kynjal-cli 4.0.0 → 4.0.1

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

@@ -9,68 +9,22 @@
  *
  * 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) {
-    if (dimensions === void 0) { dimensions = 384; }
+function formatEmbedding(embedding, dimensions = 384) {
     // Ensure correct dimensions by padding or truncating
-    var padded = __spreadArray([], embedding, true);
+    const padded = [...embedding];
     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
@@ -82,22 +36,36 @@ function escapeString(str) {
  * Generate SQL INSERT statement for a memory entry
  */
 function generateInsertSQL(entry) {
-    var key = escapeString(entry.key);
-    var value = typeof entry.value === 'string'
+    const key = escapeString(entry.key);
+    const value = typeof entry.value === 'string'
         ? escapeString(entry.value)
         : escapeString(JSON.stringify(entry.value));
-    var namespace = entry.namespace || 'default';
-    var metadata = entry.metadata ? escapeString(JSON.stringify(entry.metadata)) : '{}';
-    var embeddingClause = 'NULL';
+    const namespace = entry.namespace || 'default';
+    const metadata = entry.metadata ? escapeString(JSON.stringify(entry.metadata)) : '{}';
+    let 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)\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();";
+    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();`;
 }
 /**
  * RuVector Import command - import from sql.js/JSON to PostgreSQL
  */
-export var importCommand = {
+export const importCommand = {
     name: 'import',
     description: 'Import data from sql.js/JSON memory to RuVector PostgreSQL',
     aliases: ['load', 'migrate-data'],
@@ -106,73 +74,73 @@ export var importCommand = {
             name: 'input',
             short: 'i',
             description: 'Input JSON file path',
-            type: 'string'
+            type: 'string',
         },
         {
             name: 'from-memory',
             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: [
@@ -181,211 +149,201 @@ export var 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: 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 }];
+    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 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 { 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));
                     }
-                    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.printSuccess('Import completed successfully!');
+                }
+                catch (execError) {
+                    const execErrorMessage = execError instanceof Error ? execError.message : String(execError);
+                    output.printError(`Import failed: ${execErrorMessage}`);
                     output.writeln();
-                    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;
+                    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
                     try {
-                        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 (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 }];
+                        fs.unlinkSync(tempFile);
                     }
-                    finally {
-                        // Clean up temp file
-                        try {
-                            fs.unlinkSync(tempFile);
-                        }
-                        catch (_b) {
-                            // Ignore cleanup errors
-                        }
+                    catch {
+                        // 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 }];
+                }
             }
-        });
-    }); }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                output.printError(`Failed to create temp file: ${errorMessage}`);
+                return { success: false, message: errorMessage };
+            }
+        }
+        // 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