kynjal-cli 3.1.3 → 4.0.0

package/dist/src/commands/ruvector/import.js

@@ -9,22 +9,68 @@
  *
  * Created with care by ruv.io
  */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
 import { output } from '../../output.js';
 import * as fs from 'fs';
 import * as path from 'path';
 /**
  * Format a ruvector embedding array for PostgreSQL
  */
-function formatEmbedding(embedding, dimensions = 384) {
+function formatEmbedding(embedding, dimensions) {
+    if (dimensions === void 0) { dimensions = 384; }
     // Ensure correct dimensions by padding or truncating
-    const padded = [...embedding];
+    var padded = __spreadArray([], embedding, true);
     while (padded.length < dimensions) {
         padded.push(0);
     }
     if (padded.length > dimensions) {
         padded.length = dimensions;
     }
-    return `'[${padded.join(',')}]'::ruvector(${dimensions})`;
+    return "'[" + padded.join(',') + "]'::ruvector(" + dimensions + ")";
 }
 /**
  * Escape string for PostgreSQL
@@ -36,36 +82,22 @@ function escapeString(str) {
  * Generate SQL INSERT statement for a memory entry
  */
 function generateInsertSQL(entry) {
-    const key = escapeString(entry.key);
-    const value = typeof entry.value === 'string'
+    var key = escapeString(entry.key);
+    var value = typeof entry.value === 'string'
         ? escapeString(entry.value)
         : escapeString(JSON.stringify(entry.value));
-    const namespace = entry.namespace || 'default';
-    const metadata = entry.metadata ? escapeString(JSON.stringify(entry.metadata)) : '{}';
-    let embeddingClause = 'NULL';
+    var namespace = entry.namespace || 'default';
+    var metadata = entry.metadata ? escapeString(JSON.stringify(entry.metadata)) : '{}';
+    var embeddingClause = 'NULL';
     if (entry.embedding && Array.isArray(entry.embedding) && entry.embedding.length > 0) {
         embeddingClause = formatEmbedding(entry.embedding);
     }
-    return `INSERT INTO claude_flow.memory_entries (key, value, embedding, namespace, metadata, created_at, updated_at)
-VALUES (
-  '${key}',
-  '${value}',
-  ${embeddingClause},
-  '${namespace}',
-  '${metadata}'::jsonb,
-  ${entry.created_at ? `'${entry.created_at}'::timestamptz` : 'NOW()'},
-  ${entry.updated_at ? `'${entry.updated_at}'::timestamptz` : 'NOW()'}
-)
-ON CONFLICT (key, namespace) DO UPDATE SET
-  value = EXCLUDED.value,
-  embedding = COALESCE(EXCLUDED.embedding, claude_flow.memory_entries.embedding),
-  metadata = EXCLUDED.metadata,
-  updated_at = NOW();`;
+    return "INSERT INTO claude_flow.memory_entries (key, value, embedding, namespace, metadata, created_at, updated_at)\nVALUES (\n  '" + key + "',\n  '" + value + "',\n  " + embeddingClause + ",\n  '" + namespace + "',\n  '" + metadata + "'::jsonb,\n  " + (entry.created_at ? "'" + entry.created_at + "'::timestamptz" : 'NOW()') + ",\n  " + (entry.updated_at ? "'" + entry.updated_at + "'::timestamptz" : 'NOW()') + "\n)\nON CONFLICT (key, namespace) DO UPDATE SET\n  value = EXCLUDED.value,\n  embedding = COALESCE(EXCLUDED.embedding, claude_flow.memory_entries.embedding),\n  metadata = EXCLUDED.metadata,\n  updated_at = NOW();";
 }
 /**
  * RuVector Import command - import from sql.js/JSON to PostgreSQL
  */
-export const importCommand = {
+export var importCommand = {
     name: 'import',
     description: 'Import data from sql.js/JSON memory to RuVector PostgreSQL',
     aliases: ['load', 'migrate-data'],
@@ -74,73 +106,73 @@ export const importCommand = {
             name: 'input',
             short: 'i',
             description: 'Input JSON file path',
-            type: 'string',
+            type: 'string'
         },
         {
             name: 'from-memory',
-            description: 'Export from current KynjalFlow memory and import',
+            description: 'Export from current Claude-Flow memory and import',
             type: 'boolean',
-            default: false,
+            "default": false
         },
         {
             name: 'output',
             short: 'o',
             description: 'Output SQL file instead of executing (dry-run)',
-            type: 'string',
+            type: 'string'
         },
         {
             name: 'batch-size',
             short: 'b',
             description: 'Batch size for imports',
             type: 'number',
-            default: 100,
+            "default": 100
         },
         {
             name: 'host',
             short: 'h',
             description: 'PostgreSQL host',
             type: 'string',
-            default: 'localhost',
+            "default": 'localhost'
         },
         {
             name: 'port',
             short: 'p',
             description: 'PostgreSQL port',
             type: 'number',
-            default: 5432,
+            "default": 5432
         },
         {
             name: 'database',
             short: 'd',
             description: 'Database name',
             type: 'string',
-            default: 'claude_flow',
+            "default": 'claude_flow'
         },
         {
             name: 'user',
             short: 'u',
             description: 'Database user',
             type: 'string',
-            default: 'claude',
+            "default": 'claude'
         },
         {
             name: 'password',
             description: 'Database password (or use PGPASSWORD env var)',
-            type: 'string',
+            type: 'string'
         },
         {
             name: 'container',
             short: 'c',
             description: 'Docker container name to exec into',
             type: 'string',
-            default: 'ruvector-postgres',
+            "default": 'ruvector-postgres'
         },
         {
             name: 'verbose',
             short: 'v',
             description: 'Verbose output',
             type: 'boolean',
-            default: false,
+            "default": false
         },
     ],
     examples: [
@@ -149,201 +181,211 @@ export const importCommand = {
         { command: 'claude-flow ruvector import --from-memory', description: 'Export current memory and import' },
         { command: 'claude-flow ruvector import --input data.json --container my-postgres', description: 'Import using custom container' },
     ],
-    action: async (ctx) => {
-        const inputFile = ctx.flags.input;
-        const fromMemory = ctx.flags['from-memory'];
-        const outputFile = ctx.flags.output;
-        const batchSize = ctx.flags['batch-size'] || 100;
-        const containerName = ctx.flags.container || 'ruvector-postgres';
-        const verbose = ctx.flags.verbose;
-        output.writeln();
-        output.writeln(output.bold('RuVector PostgreSQL Import'));
-        output.writeln(output.dim('='.repeat(50)));
-        output.writeln();
-        // Validate input
-        if (!inputFile && !fromMemory) {
-            output.printError('Either --input <file> or --from-memory is required');
-            output.writeln();
-            output.printInfo('Examples:');
-            output.writeln('  claude-flow ruvector import --input memory-export.json');
-            output.writeln('  claude-flow ruvector import --from-memory');
-            return { success: false, message: 'Missing input source' };
-        }
-        let entries = [];
-        // Load entries from JSON file
-        if (inputFile) {
-            if (!fs.existsSync(inputFile)) {
-                output.printError(`Input file not found: ${inputFile}`);
-                return { success: false, message: 'File not found' };
-            }
-            try {
-                output.printInfo(`Reading: ${inputFile}`);
-                const content = fs.readFileSync(inputFile, 'utf-8');
-                const data = JSON.parse(content);
-                // Handle different JSON formats
-                if (Array.isArray(data)) {
-                    entries = data;
-                }
-                else if (data.entries && Array.isArray(data.entries)) {
-                    entries = data.entries;
-                }
-                else if (data.results && Array.isArray(data.results)) {
-                    entries = data.results;
-                }
-                else if (typeof data === 'object') {
-                    // Convert object format { key: value } to entries
-                    entries = Object.entries(data).map(([key, value]) => ({
-                        key,
-                        value: typeof value === 'object' ? JSON.stringify(value) : String(value),
-                    }));
-                }
-                output.printSuccess(`Loaded ${entries.length} entries from file`);
-            }
-            catch (error) {
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                output.printError(`Failed to parse JSON: ${errorMessage}`);
-                return { success: false, message: errorMessage };
-            }
-        }
-        // Export from current memory
-        if (fromMemory) {
-            output.printInfo('Exporting from current KynjalFlow memory...');
-            output.printWarning('Note: Run "npx claude-flow memory list --format json > memory-export.json" first');
-            output.printInfo('Then use: npx claude-flow ruvector import --input memory-export.json');
-            return { success: false, message: 'Use explicit JSON export first' };
-        }
-        if (entries.length === 0) {
-            output.printWarning('No entries to import');
-            return { success: true };
-        }
-        // Calculate statistics
-        const stats = {
-            total: entries.length,
-            imported: 0,
-            skipped: 0,
-            errors: 0,
-            withEmbeddings: 0,
-            byNamespace: {},
-        };
-        // Generate SQL statements
-        const sqlStatements = [];
-        sqlStatements.push('-- RuVector PostgreSQL Import');
-        sqlStatements.push(`-- Generated: ${new Date().toISOString()}`);
-        sqlStatements.push(`-- Total entries: ${entries.length}`);
-        sqlStatements.push('');
-        sqlStatements.push('BEGIN;');
-        sqlStatements.push('');
-        for (const entry of entries) {
-            try {
-                // Track statistics
-                const ns = entry.namespace || 'default';
-                stats.byNamespace[ns] = (stats.byNamespace[ns] || 0) + 1;
-                if (entry.embedding && entry.embedding.length > 0) {
-                    stats.withEmbeddings++;
-                }
-                const sql = generateInsertSQL(entry);
-                sqlStatements.push(sql);
-                sqlStatements.push('');
-                stats.imported++;
-                if (verbose) {
-                    output.writeln(output.dim(`  Processed: ${entry.key} (${ns})`));
-                }
-            }
-            catch (error) {
-                stats.errors++;
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                output.printWarning(`Skipped entry "${entry.key}": ${errorMessage}`);
-            }
-        }
-        sqlStatements.push('COMMIT;');
-        sqlStatements.push('');
-        sqlStatements.push(`-- Import complete: ${stats.imported} entries`);
-        const fullSQL = sqlStatements.join('\n');
-        // Output SQL file (dry-run)
-        if (outputFile) {
-            try {
-                output.printInfo(`Writing SQL to: ${outputFile}`);
-                fs.writeFileSync(outputFile, fullSQL);
-                output.printSuccess(`SQL file created: ${outputFile}`);
-                output.writeln();
-                output.printInfo('To execute the import:');
-                output.writeln(`  docker exec -i ${containerName} psql -U claude -d claude_flow < ${outputFile}`);
-            }
-            catch (error) {
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                output.printError(`Failed to write SQL file: ${errorMessage}`);
-                return { success: false, message: errorMessage };
-            }
-        }
-        else {
-            // Execute directly via docker exec
-            output.printInfo(`Importing to PostgreSQL via container: ${containerName}`);
-            output.writeln();
-            // Write to temp file for execution
-            const tempFile = path.join(process.cwd(), '.ruvector-import-temp.sql');
-            try {
-                fs.writeFileSync(tempFile, fullSQL);
-                output.printInfo('Executing import...');
-                output.writeln();
-                output.writeln(output.dim('Command:'));
-                output.writeln(output.dim(`  docker exec -i ${containerName} psql -U claude -d claude_flow < ${tempFile}`));
-                output.writeln();
-                // Execute via child_process
-                const { execSync } = await import('child_process');
-                try {
-                    const result = execSync(`docker exec -i ${containerName} psql -U claude -d claude_flow < ${tempFile}`, {
-                        encoding: 'utf-8',
-                        timeout: 60000,
-                    });
-                    if (verbose) {
-                        output.writeln(output.dim(result));
+    action: function (ctx) { return __awaiter(void 0, void 0, Promise, function () {
+        var inputFile, fromMemory, outputFile, batchSize, containerName, verbose, entries, content, data, errorMessage, stats, sqlStatements, _i, entries_1, entry, ns, sql, errorMessage, fullSQL, errorMessage, tempFile, execSync, result, execErrorMessage, error_1, errorMessage;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    inputFile = ctx.flags.input;
+                    fromMemory = ctx.flags['from-memory'];
+                    outputFile = ctx.flags.output;
+                    batchSize = ctx.flags['batch-size'] || 100;
+                    containerName = ctx.flags.container || 'ruvector-postgres';
+                    verbose = ctx.flags.verbose;
+                    output.writeln();
+                    output.writeln(output.bold('RuVector PostgreSQL Import'));
+                    output.writeln(output.dim('='.repeat(50)));
+                    output.writeln();
+                    // Validate input
+                    if (!inputFile && !fromMemory) {
+                        output.printError('Either --input <file> or --from-memory is required');
+                        output.writeln();
+                        output.printInfo('Examples:');
+                        output.writeln('  claude-flow ruvector import --input memory-export.json');
+                        output.writeln('  claude-flow ruvector import --from-memory');
+                        return [2 /*return*/, { success: false, message: 'Missing input source' }];
+                    }
+                    entries = [];
+                    // Load entries from JSON file
+                    if (inputFile) {
+                        if (!fs.existsSync(inputFile)) {
+                            output.printError("Input file not found: " + inputFile);
+                            return [2 /*return*/, { success: false, message: 'File not found' }];
+                        }
+                        try {
+                            output.printInfo("Reading: " + inputFile);
+                            content = fs.readFileSync(inputFile, 'utf-8');
+                            data = JSON.parse(content);
+                            // Handle different JSON formats
+                            if (Array.isArray(data)) {
+                                entries = data;
+                            }
+                            else if (data.entries && Array.isArray(data.entries)) {
+                                entries = data.entries;
+                            }
+                            else if (data.results && Array.isArray(data.results)) {
+                                entries = data.results;
+                            }
+                            else if (typeof data === 'object') {
+                                // Convert object format { key: value } to entries
+                                entries = Object.entries(data).map(function (_a) {
+                                    var key = _a[0], value = _a[1];
+                                    return ({
+                                        key: key,
+                                        value: typeof value === 'object' ? JSON.stringify(value) : String(value)
+                                    });
+                                });
+                            }
+                            output.printSuccess("Loaded " + entries.length + " entries from file");
+                        }
+                        catch (error) {
+                            errorMessage = error instanceof Error ? error.message : String(error);
+                            output.printError("Failed to parse JSON: " + errorMessage);
+                            return [2 /*return*/, { success: false, message: errorMessage }];
+                        }
+                    }
+                    // Export from current memory
+                    if (fromMemory) {
+                        output.printInfo('Exporting from current Claude-Flow memory...');
+                        output.printWarning('Note: Run "npx claude-flow memory list --format json > memory-export.json" first');
+                        output.printInfo('Then use: npx claude-flow ruvector import --input memory-export.json');
+                        return [2 /*return*/, { success: false, message: 'Use explicit JSON export first' }];
+                    }
+                    if (entries.length === 0) {
+                        output.printWarning('No entries to import');
+                        return [2 /*return*/, { success: true }];
+                    }
+                    stats = {
+                        total: entries.length,
+                        imported: 0,
+                        skipped: 0,
+                        errors: 0,
+                        withEmbeddings: 0,
+                        byNamespace: {}
+                    };
+                    sqlStatements = [];
+                    sqlStatements.push('-- RuVector PostgreSQL Import');
+                    sqlStatements.push("-- Generated: " + new Date().toISOString());
+                    sqlStatements.push("-- Total entries: " + entries.length);
+                    sqlStatements.push('');
+                    sqlStatements.push('BEGIN;');
+                    sqlStatements.push('');
+                    for (_i = 0, entries_1 = entries; _i < entries_1.length; _i++) {
+                        entry = entries_1[_i];
+                        try {
+                            ns = entry.namespace || 'default';
+                            stats.byNamespace[ns] = (stats.byNamespace[ns] || 0) + 1;
+                            if (entry.embedding && entry.embedding.length > 0) {
+                                stats.withEmbeddings++;
+                            }
+                            sql = generateInsertSQL(entry);
+                            sqlStatements.push(sql);
+                            sqlStatements.push('');
+                            stats.imported++;
+                            if (verbose) {
+                                output.writeln(output.dim("  Processed: " + entry.key + " (" + ns + ")"));
+                            }
+                        }
+                        catch (error) {
+                            stats.errors++;
+                            errorMessage = error instanceof Error ? error.message : String(error);
+                            output.printWarning("Skipped entry \"" + entry.key + "\": " + errorMessage);
+                        }
+                    }
+                    sqlStatements.push('COMMIT;');
+                    sqlStatements.push('');
+                    sqlStatements.push("-- Import complete: " + stats.imported + " entries");
+                    fullSQL = sqlStatements.join('\n');
+                    if (!outputFile) return [3 /*break*/, 1];
+                    try {
+                        output.printInfo("Writing SQL to: " + outputFile);
+                        fs.writeFileSync(outputFile, fullSQL);
+                        output.printSuccess("SQL file created: " + outputFile);
+                        output.writeln();
+                        output.printInfo('To execute the import:');
+                        output.writeln("  docker exec -i " + containerName + " psql -U claude -d claude_flow < " + outputFile);
+                    }
+                    catch (error) {
+                        errorMessage = error instanceof Error ? error.message : String(error);
+                        output.printError("Failed to write SQL file: " + errorMessage);
+                        return [2 /*return*/, { success: false, message: errorMessage }];
                     }
-                    output.printSuccess('Import completed successfully!');
-                }
-                catch (execError) {
-                    const execErrorMessage = execError instanceof Error ? execError.message : String(execError);
-                    output.printError(`Import failed: ${execErrorMessage}`);
+                    return [3 /*break*/, 5];
+                case 1:
+                    // Execute directly via docker exec
+                    output.printInfo("Importing to PostgreSQL via container: " + containerName);
+                    output.writeln();
+                    tempFile = path.join(process.cwd(), '.ruvector-import-temp.sql');
+                    _a.label = 2;
+                case 2:
+                    _a.trys.push([2, 4, , 5]);
+                    fs.writeFileSync(tempFile, fullSQL);
+                    output.printInfo('Executing import...');
                     output.writeln();
-                    output.printInfo('You can manually run the import with:');
-                    output.writeln(`  docker exec -i ${containerName} psql -U claude -d claude_flow < ${tempFile}`);
-                    return { success: false, message: execErrorMessage };
-                }
-                finally {
-                    // Clean up temp file
+                    output.writeln(output.dim('Command:'));
+                    output.writeln(output.dim("  docker exec -i " + containerName + " psql -U claude -d claude_flow < " + tempFile));
+                    output.writeln();
+                    return [4 /*yield*/, import('child_process')];
+                case 3:
+                    execSync = (_a.sent()).execSync;
                     try {
-                        fs.unlinkSync(tempFile);
+                        result = execSync("docker exec -i " + containerName + " psql -U claude -d claude_flow < " + tempFile, {
+                            encoding: 'utf-8',
+                            timeout: 60000
+                        });
+                        if (verbose) {
+                            output.writeln(output.dim(result));
+                        }
+                        output.printSuccess('Import completed successfully!');
                     }
-                    catch {
-                        // Ignore cleanup errors
+                    catch (execError) {
+                        execErrorMessage = execError instanceof Error ? execError.message : String(execError);
+                        output.printError("Import failed: " + execErrorMessage);
+                        output.writeln();
+                        output.printInfo('You can manually run the import with:');
+                        output.writeln("  docker exec -i " + containerName + " psql -U claude -d claude_flow < " + tempFile);
+                        return [2 /*return*/, { success: false, message: execErrorMessage }];
                     }
-                }
-            }
-            catch (error) {
-                const errorMessage = error instanceof Error ? error.message : String(error);
-                output.printError(`Failed to create temp file: ${errorMessage}`);
-                return { success: false, message: errorMessage };
+                    finally {
+                        // Clean up temp file
+                        try {
+                            fs.unlinkSync(tempFile);
+                        }
+                        catch (_b) {
+                            // Ignore cleanup errors
+                        }
+                    }
+                    return [3 /*break*/, 5];
+                case 4:
+                    error_1 = _a.sent();
+                    errorMessage = error_1 instanceof Error ? error_1.message : String(error_1);
+                    output.printError("Failed to create temp file: " + errorMessage);
+                    return [2 /*return*/, { success: false, message: errorMessage }];
+                case 5:
+                    // Print statistics
+                    output.writeln();
+                    output.printBox(__spreadArray([
+                        'Import Statistics',
+                        '',
+                        "  Total entries:     " + stats.total,
+                        "  Imported:          " + stats.imported,
+                        "  With embeddings:   " + stats.withEmbeddings,
+                        "  Errors:            " + stats.errors,
+                        '',
+                        'By Namespace:'
+                    ], Object.entries(stats.byNamespace).map(function (_a) {
+                        var ns = _a[0], count = _a[1];
+                        return "  " + ns + ": " + count;
+                    }), true).join('\n'), 'Import Complete');
+                    output.writeln();
+                    // Show verification command
+                    output.printInfo('To verify the import:');
+                    output.writeln("  docker exec " + containerName + " psql -U claude -d claude_flow -c \"SELECT COUNT(*) FROM claude_flow.memory_entries;\"");
+                    output.writeln();
+                    return [2 /*return*/, { success: true }];
             }
-        }
-        // Print statistics
-        output.writeln();
-        output.printBox([
-            'Import Statistics',
-            '',
-            `  Total entries:     ${stats.total}`,
-            `  Imported:          ${stats.imported}`,
-            `  With embeddings:   ${stats.withEmbeddings}`,
-            `  Errors:            ${stats.errors}`,
-            '',
-            'By Namespace:',
-            ...Object.entries(stats.byNamespace).map(([ns, count]) => `  ${ns}: ${count}`),
-        ].join('\n'), 'Import Complete');
-        output.writeln();
-        // Show verification command
-        output.printInfo('To verify the import:');
-        output.writeln(`  docker exec ${containerName} psql -U claude -d claude_flow -c "SELECT COUNT(*) FROM claude_flow.memory_entries;"`);
-        output.writeln();
-        return { success: true };
-    },
+        });
+    }); }
 };
 export default importCommand;
 //# sourceMappingURL=import.js.map