mira-consciousness
Version:
Memory & Intelligence Retention Archive - Preserving The Spark
181 lines • 8.21 kB
JavaScript
import chalk from 'chalk';
import ora from 'ora';
import { getDirectPythonInterface } from '../core/DirectPythonInterface.js';
import fs from 'fs-extra';
import * as path from 'path';
export async function importCommand(filePath, options) {
const spinner = ora('Importing MIRA memory data...').start();
try {
// Check if file exists
if (!(await fs.pathExists(filePath))) {
throw new Error(`Import file not found: ${filePath}`);
}
// Read and parse the import file
spinner.text = 'Reading import file...';
let importData;
if (filePath.endsWith('.json')) {
importData = await fs.readJson(filePath);
}
else if (filePath.endsWith('.csv')) {
const csvContent = await fs.readFile(filePath, 'utf-8');
importData = parseCSV(csvContent);
}
else {
throw new Error('Unsupported file format. Use .json or .csv files.');
}
// Validate import data structure
if (!importData.export_info) {
throw new Error('Invalid import file format. Missing export_info.');
}
const pythonInterface = getDirectPythonInterface();
const memoryDir = process.env.MIRA_RESOLVED_MEMORY_DIR || process.cwd() + '/.mira';
let importedMemories = 0;
let importedFiles = 0;
// Import memories
if (importData.memories && Array.isArray(importData.memories)) {
spinner.text = 'Importing memories...';
for (const memory of importData.memories) {
try {
const content = typeof memory === 'string' ? memory :
memory.content || JSON.stringify(memory);
await pythonInterface.storeMemory(content);
importedMemories++;
}
catch (error) {
// Continue with other memories if one fails
}
}
}
// Import file data
if (importData.files && typeof importData.files === 'object') {
spinner.text = 'Importing file data...';
for (const [dirName, files] of Object.entries(importData.files)) {
if (Array.isArray(files)) {
const targetDir = path.join(memoryDir, dirName);
await fs.ensureDir(targetDir);
for (const fileData of files) {
try {
if (fileData.type === 'jsonl' && fileData.entries) {
const fileName = fileData.file || `imported_${Date.now()}.jsonl`;
const filePath = path.join(targetDir, fileName);
if (options.merge && await fs.pathExists(filePath)) {
// Append to existing file
for (const entry of fileData.entries) {
await fs.appendFile(filePath, JSON.stringify(entry) + '\n');
}
}
else {
// Create new file
const content = fileData.entries.map((entry) => JSON.stringify(entry)).join('\n');
await fs.writeFile(filePath, content + '\n');
}
importedFiles++;
}
else if (fileData.type === 'json' && fileData.content) {
const fileName = fileData.file || `imported_${Date.now()}.json`;
const filePath = path.join(targetDir, fileName);
if (options.merge && await fs.pathExists(filePath)) {
// For JSON files, merge with existing content if possible
try {
const existing = await fs.readJson(filePath);
const merged = Array.isArray(existing) && Array.isArray(fileData.content)
? [...existing, ...fileData.content]
: { ...existing, ...fileData.content };
await fs.writeJson(filePath, merged, { spaces: 2 });
}
catch {
// If merge fails, overwrite
await fs.writeJson(filePath, fileData.content, { spaces: 2 });
}
}
else {
await fs.writeJson(filePath, fileData.content, { spaces: 2 });
}
importedFiles++;
}
}
catch (error) {
// Continue with other files if one fails
}
}
}
}
}
// Log the import
const reportsDir = path.join(memoryDir, 'reports');
await fs.ensureDir(reportsDir);
const importLogEntry = {
timestamp: new Date().toISOString(),
type: 'import',
source_file: filePath,
merge_mode: options.merge || false,
imported_memories: importedMemories,
imported_files: importedFiles
};
const importLogFile = path.join(reportsDir, 'generated_reports.jsonl');
await fs.appendFile(importLogFile, JSON.stringify(importLogEntry) + '\n');
spinner.succeed(chalk.green('Import completed successfully'));
console.log(chalk.cyan('\n📥 Import Summary:'));
console.log(chalk.white(` Source: ${filePath}`));
console.log(chalk.white(` Mode: ${options.merge ? 'Merge' : 'Replace'}`));
console.log(chalk.white(` Memories imported: ${importedMemories}`));
console.log(chalk.white(` Files imported: ${importedFiles}`));
if (importedMemories > 0 || importedFiles > 0) {
console.log(chalk.green('\n✅ Data has been successfully imported into MIRA'));
}
else {
console.log(chalk.yellow('\n⚠️ No data was imported. Check the file format.'));
}
}
catch (error) {
spinner.fail('Import failed');
console.error(chalk.red('Error:'), error instanceof Error ? error.message : String(error));
process.exit(1);
}
}
function parseCSV(csvContent) {
const lines = csvContent.trim().split('\n');
const headers = lines[0].split(',');
const memories = [];
const files = {};
for (let i = 1; i < lines.length; i++) {
const values = lines[i].split(',');
if (values.length >= headers.length) {
const type = values[0];
const timestamp = values[1];
const content = values[2];
const extra = values[3];
if (type === 'memory') {
memories.push({
content: content.replace(/""/g, '"'),
timestamp: timestamp,
score: extra || undefined
});
}
else {
// File data
if (!files[type]) {
files[type] = [];
}
files[type].push({
file: extra || 'imported.jsonl',
type: 'jsonl',
entries: [{
timestamp: timestamp,
content: content.replace(/""/g, '"')
}]
});
}
}
}
return {
export_info: {
timestamp: new Date().toISOString(),
version: '1.0',
format: 'csv'
},
memories: memories,
files: files
};
}
//# sourceMappingURL=import.js.map