@claude-flow/cli 3.0.0-alpha.62 → 3.0.0-alpha.64

package/dist/src/commands/memory.js

@@ -76,7 +76,7 @@ const storeCommand = {
             });
         }
         if (!value) {
-            output.printError('Value is required. Use --value or -v');
+            output.printError('Value is required. Use --value');
             return { success: false, exitCode: 1 };
         }
         const storeData = {
@@ -90,17 +90,24 @@ const storeCommand = {
             size: Buffer.byteLength(value, 'utf8')
         };
         output.printInfo(`Storing in ${namespace}/${key}...`);
-        if (asVector) {
-            output.writeln(output.dim('  Generating embedding vector...'));
-            output.writeln(output.dim('  Indexing with HNSW (M=16, ef=200)...'));
-        }
-        // Call MCP memory/store tool for real persistence
+        // Use direct sql.js storage with automatic embedding generation
         try {
-            const result = await callMCPTool('memory/store', {
+            const { storeEntry } = await import('../memory/memory-initializer.js');
+            if (asVector) {
+                output.writeln(output.dim('  Generating embedding vector...'));
+            }
+            const result = await storeEntry({
                 key,
                 value,
-                metadata: { namespace, tags, ttl, asVector, size: storeData.size }
+                namespace,
+                generateEmbeddingFlag: true, // Always generate embeddings for semantic search
+                tags,
+                ttl
             });
+            if (!result.success) {
+                output.printError(result.error || 'Failed to store');
+                return { success: false, exitCode: 1 };
+            }
             output.writeln();
             output.printTable({
                 columns: [
@@ -113,13 +120,13 @@ const storeCommand = {
                     { property: 'Size', val: `${storeData.size} bytes` },
                     { property: 'TTL', val: ttl ? `${ttl}s` : 'None' },
                     { property: 'Tags', val: tags.length > 0 ? tags.join(', ') : 'None' },
-                    { property: 'Vector', val: asVector ? 'Yes' : 'No' },
-                    { property: 'Total Entries', val: String(result.totalEntries || 1) }
+                    { property: 'Vector', val: result.embedding ? `Yes (${result.embedding.dimensions}-dim)` : 'No' },
+                    { property: 'ID', val: result.id.substring(0, 20) }
                 ]
             });
             output.writeln();
             output.printSuccess('Data stored successfully');
-            return { success: true, data: { ...storeData, ...result } };
+            return { success: true, data: { ...storeData, id: result.id, embedding: result.embedding } };
         }
         catch (error) {
             output.printError(`Failed to store: ${error instanceof Error ? error.message : 'Unknown error'}`);
@@ -154,42 +161,36 @@ const retrieveCommand = {
             output.printError('Key is required');
             return { success: false, exitCode: 1 };
         }
-        // Call MCP memory/retrieve tool for real data
+        // Use sql.js directly for consistent data access
         try {
-            const result = await callMCPTool('memory/retrieve', { key });
-            if (!result.found) {
+            const { getEntry } = await import('../memory/memory-initializer.js');
+            const result = await getEntry({ key, namespace });
+            if (!result.success) {
+                output.printError(`Failed to retrieve: ${result.error}`);
+                return { success: false, exitCode: 1 };
+            }
+            if (!result.found || !result.entry) {
                 output.printWarning(`Key not found: ${key}`);
                 return { success: false, exitCode: 1, data: { key, found: false } };
             }
-            const data = {
-                key: result.key,
-                namespace,
-                value: result.value,
-                metadata: {
-                    storedAt: result.storedAt || 'Unknown',
-                    accessCount: result.accessCount || 0,
-                    lastAccessed: new Date().toISOString(),
-                    ...(result.metadata || {})
-                }
-            };
+            const entry = result.entry;
             if (ctx.flags.format === 'json') {
-                output.printJson(data);
-                return { success: true, data };
+                output.printJson(entry);
+                return { success: true, data: entry };
             }
-            const metaTags = result.metadata?.tags || [];
-            const metaSize = result.metadata?.size || String(data.value).length;
             output.writeln();
             output.printBox([
-                `Namespace: ${namespace}`,
-                `Key: ${data.key}`,
-                `Size: ${metaSize} bytes`,
-                `Access Count: ${data.metadata.accessCount}`,
-                `Tags: ${metaTags.length > 0 ? metaTags.join(', ') : 'None'}`,
+                `Namespace: ${entry.namespace}`,
+                `Key: ${entry.key}`,
+                `Size: ${entry.content.length} bytes`,
+                `Access Count: ${entry.accessCount}`,
+                `Tags: ${entry.tags.length > 0 ? entry.tags.join(', ') : 'None'}`,
+                `Vector: ${entry.hasEmbedding ? 'Yes' : 'No'}`,
                 '',
                 output.bold('Value:'),
-                typeof data.value === 'string' ? data.value : JSON.stringify(data.value, null, 2)
+                entry.content
             ].join('\n'), 'Memory Entry');
-            return { success: true, data };
+            return { success: true, data: entry };
         }
         catch (error) {
             output.printError(`Failed to retrieve: ${error instanceof Error ? error.message : 'Unknown error'}`);
@@ -243,36 +244,45 @@ const searchCommand = {
     ],
     action: async (ctx) => {
         const query = ctx.flags.query || ctx.args[0];
-        const namespace = ctx.flags.namespace;
-        const limit = ctx.flags.limit;
-        const threshold = ctx.flags.threshold;
-        const searchType = ctx.flags.type;
+        const namespace = ctx.flags.namespace || 'all';
+        const limit = ctx.flags.limit || 10;
+        const threshold = ctx.flags.threshold || 0.3;
+        const searchType = ctx.flags.type || 'semantic';
         if (!query) {
             output.printError('Query is required. Use --query or -q');
             return { success: false, exitCode: 1 };
         }
         output.printInfo(`Searching: "${query}" (${searchType})`);
         output.writeln();
-        // Call MCP memory/search tool for real results
+        // Use direct sql.js search with vector similarity
         try {
-            const searchResult = await callMCPTool('memory/search', { query, limit });
+            const { searchEntries } = await import('../memory/memory-initializer.js');
+            const searchResult = await searchEntries({
+                query,
+                namespace,
+                limit,
+                threshold
+            });
+            if (!searchResult.success) {
+                output.printError(searchResult.error || 'Search failed');
+                return { success: false, exitCode: 1 };
+            }
             const results = searchResult.results.map(r => ({
                 key: r.key,
                 score: r.score,
-                namespace: namespace || 'default',
-                preview: typeof r.value === 'string'
-                    ? r.value.substring(0, 40) + (r.value.length > 40 ? '...' : '')
-                    : JSON.stringify(r.value).substring(0, 40)
+                namespace: r.namespace,
+                preview: r.content
             }));
             if (ctx.flags.format === 'json') {
-                output.printJson({ query, searchType, results, searchTime: searchResult.searchTime });
+                output.printJson({ query, searchType, results, searchTime: `${searchResult.searchTime}ms` });
                 return { success: true, data: results };
             }
             // Performance stats
-            output.writeln(output.dim(`  Search time: ${searchResult.searchTime}`));
+            output.writeln(output.dim(`  Search time: ${searchResult.searchTime}ms`));
             output.writeln();
             if (results.length === 0) {
                 output.printWarning('No results found');
+                output.writeln(output.dim('Try: claude-flow memory store -k "key" --value "data"'));
                 return { success: true, data: [] };
             }
             output.printTable({
@@ -323,26 +333,33 @@ const listCommand = {
     action: async (ctx) => {
         const namespace = ctx.flags.namespace;
         const limit = ctx.flags.limit;
-        // Call MCP memory/list tool for real entries
+        // Use sql.js directly for consistent data access
         try {
-            const listResult = await callMCPTool('memory/list', { limit, offset: 0 });
+            const { listEntries } = await import('../memory/memory-initializer.js');
+            const listResult = await listEntries({ namespace, limit, offset: 0 });
+            if (!listResult.success) {
+                output.printError(`Failed to list: ${listResult.error}`);
+                return { success: false, exitCode: 1 };
+            }
             // Format entries for display
             const entries = listResult.entries.map(e => ({
                 key: e.key,
-                namespace: namespace || 'default',
-                size: e.preview.length + ' B',
+                namespace: e.namespace,
+                size: e.size + ' B',
+                vector: e.hasEmbedding ? '✓' : '-',
                 accessCount: e.accessCount,
-                updated: formatRelativeTime(e.storedAt)
+                updated: formatRelativeTime(e.updatedAt)
             }));
             if (ctx.flags.format === 'json') {
-                output.printJson(entries);
-                return { success: true, data: entries };
+                output.printJson(listResult.entries);
+                return { success: true, data: listResult.entries };
             }
             output.writeln();
             output.writeln(output.bold('Memory Entries'));
             output.writeln();
             if (entries.length === 0) {
                 output.printWarning('No entries found');
+                output.printInfo('Store data: claude-flow memory store -k "key" --value "data"');
                 return { success: true, data: [] };
             }
             output.printTable({
@@ -350,6 +367,7 @@ const listCommand = {
                     { key: 'key', header: 'Key', width: 25 },
                     { key: 'namespace', header: 'Namespace', width: 12 },
                     { key: 'size', header: 'Size', width: 10, align: 'right' },
+                    { key: 'vector', header: 'Vector', width: 8, align: 'center' },
                     { key: 'accessCount', header: 'Accessed', width: 10, align: 'right' },
                     { key: 'updated', header: 'Updated', width: 12 }
                 ],
@@ -357,7 +375,7 @@ const listCommand = {
             });
             output.writeln();
             output.printInfo(`Showing ${entries.length} of ${listResult.total} entries`);
-            return { success: true, data: entries };
+            return { success: true, data: listResult.entries };
         }
         catch (error) {
             output.printError(`Failed to list: ${error instanceof Error ? error.message : 'Unknown error'}`);
@@ -946,14 +964,14 @@ const importCommand = {
 // Init subcommand - initialize memory database using sql.js
 const initMemoryCommand = {
     name: 'init',
-    description: 'Initialize memory database with sql.js (WASM SQLite)',
+    description: 'Initialize memory database with sql.js (WASM SQLite) - includes vector embeddings, pattern learning, temporal decay',
     options: [
         {
             name: 'backend',
             short: 'b',
-            description: 'Backend type: sqlite (default), hybrid, or agentdb',
+            description: 'Backend type: hybrid (default), sqlite, or agentdb',
             type: 'string',
-            default: 'sqlite'
+            default: 'hybrid'
         },
         {
             name: 'path',
@@ -967,191 +985,177 @@ const initMemoryCommand = {
             description: 'Overwrite existing database',
             type: 'boolean',
             default: false
+        },
+        {
+            name: 'verbose',
+            description: 'Show detailed initialization output',
+            type: 'boolean',
+            default: false
+        },
+        {
+            name: 'verify',
+            description: 'Run verification tests after initialization',
+            type: 'boolean',
+            default: true
+        },
+        {
+            name: 'load-embeddings',
+            description: 'Pre-load ONNX embedding model (lazy by default)',
+            type: 'boolean',
+            default: false
         }
     ],
     examples: [
-        { command: 'claude-flow memory init', description: 'Initialize default SQLite database' },
-        { command: 'claude-flow memory init -b hybrid', description: 'Initialize hybrid backend' },
-        { command: 'claude-flow memory init -p ./data/memory.db', description: 'Custom path' }
+        { command: 'claude-flow memory init', description: 'Initialize hybrid backend with all features' },
+        { command: 'claude-flow memory init -b agentdb', description: 'Initialize AgentDB backend' },
+        { command: 'claude-flow memory init -p ./data/memory.db --force', description: 'Reinitialize at custom path' },
+        { command: 'claude-flow memory init --verbose --verify', description: 'Initialize with full verification' }
     ],
     action: async (ctx) => {
-        const backend = ctx.flags.backend || 'sqlite';
+        const backend = ctx.flags.backend || 'hybrid';
         const customPath = ctx.flags.path;
         const force = ctx.flags.force;
-        const fs = await import('fs');
-        const path = await import('path');
-        // Determine database paths
-        const swarmDir = path.join(process.cwd(), '.swarm');
-        const claudeDir = path.join(process.cwd(), '.claude');
-        const dbPath = customPath || path.join(swarmDir, 'memory.db');
-        const dbDir = path.dirname(dbPath);
-        // Check if already exists
-        if (fs.existsSync(dbPath) && !force) {
-            output.printWarning(`Memory database already exists at ${dbPath}`);
-            output.printInfo('Use --force to reinitialize');
-            return { success: false, exitCode: 1 };
-        }
-        output.printInfo(`Initializing ${backend} memory backend...`);
+        const verbose = ctx.flags.verbose;
+        const verify = ctx.flags.verify !== false; // Default true
+        const loadEmbeddings = ctx.flags.loadEmbeddings;
+        output.writeln();
+        output.writeln(output.bold('Initializing Memory Database'));
+        output.writeln(output.dim('─'.repeat(50)));
+        const spinner = output.createSpinner({ text: 'Initializing schema...', spinner: 'dots' });
+        spinner.start();
         try {
-            // Create directories
-            if (!fs.existsSync(dbDir)) {
-                fs.mkdirSync(dbDir, { recursive: true });
-                output.writeln(output.dim(`  Created directory: ${dbDir}`));
+            // Import the memory initializer
+            const { initializeMemoryDatabase, loadEmbeddingModel, verifyMemoryInit } = await import('../memory/memory-initializer.js');
+            const result = await initializeMemoryDatabase({
+                backend,
+                dbPath: customPath,
+                force,
+                verbose
+            });
+            if (!result.success) {
+                spinner.fail('Initialization failed');
+                output.printError(result.error || 'Unknown error');
+                return { success: false, exitCode: 1 };
+            }
+            spinner.succeed('Schema initialized');
+            // Lazy load or pre-load embedding model
+            if (loadEmbeddings) {
+                const embeddingSpinner = output.createSpinner({ text: 'Loading embedding model...', spinner: 'dots' });
+                embeddingSpinner.start();
+                const embeddingResult = await loadEmbeddingModel({ verbose });
+                if (embeddingResult.success) {
+                    embeddingSpinner.succeed(`Embedding model loaded: ${embeddingResult.modelName} (${embeddingResult.dimensions}-dim, ${embeddingResult.loadTime}ms)`);
+                }
+                else {
+                    embeddingSpinner.stop(output.warning(`Embedding model: ${embeddingResult.error || 'Using fallback'}`));
+                }
             }
-            // Initialize database using sql.js (WASM SQLite)
-            output.writeln(output.dim('  Using sql.js (WASM SQLite - cross-platform, no native compilation)'));
-            // Create basic schema
-            const schema = `
--- Claude Flow V3 Memory Database
--- Backend: ${backend}
--- Created: ${new Date().toISOString()}
-
--- Core memory entries
-CREATE TABLE IF NOT EXISTS memory_entries (
-  id INTEGER PRIMARY KEY AUTOINCREMENT,
-  key TEXT NOT NULL UNIQUE,
-  value TEXT NOT NULL,
-  namespace TEXT DEFAULT 'default',
-  type TEXT DEFAULT 'text',
-  created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-  updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-  expires_at DATETIME,
-  metadata TEXT
-);
-
--- Vector embeddings for semantic search
-CREATE TABLE IF NOT EXISTS vectors (
-  id INTEGER PRIMARY KEY AUTOINCREMENT,
-  entry_id INTEGER REFERENCES memory_entries(id),
-  embedding BLOB NOT NULL,
-  dimension INTEGER NOT NULL,
-  model TEXT DEFAULT 'local',
-  created_at DATETIME DEFAULT CURRENT_TIMESTAMP
-);
-
--- Patterns for learning
-CREATE TABLE IF NOT EXISTS patterns (
-  id INTEGER PRIMARY KEY AUTOINCREMENT,
-  pattern_type TEXT NOT NULL,
-  pattern_data TEXT NOT NULL,
-  confidence REAL DEFAULT 0.5,
-  usage_count INTEGER DEFAULT 0,
-  created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-  last_used_at DATETIME
-);
-
--- Sessions for context persistence
-CREATE TABLE IF NOT EXISTS sessions (
-  id TEXT PRIMARY KEY,
-  state TEXT NOT NULL,
-  created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
-  updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
-);
-
--- Learning trajectories
-CREATE TABLE IF NOT EXISTS trajectories (
-  id INTEGER PRIMARY KEY AUTOINCREMENT,
-  session_id TEXT,
-  action TEXT NOT NULL,
-  outcome TEXT,
-  reward REAL DEFAULT 0,
-  created_at DATETIME DEFAULT CURRENT_TIMESTAMP
-);
-
--- Indexes for performance
-CREATE INDEX IF NOT EXISTS idx_memory_namespace ON memory_entries(namespace);
-CREATE INDEX IF NOT EXISTS idx_memory_key ON memory_entries(key);
-CREATE INDEX IF NOT EXISTS idx_patterns_type ON patterns(pattern_type);
-CREATE INDEX IF NOT EXISTS idx_trajectories_session ON trajectories(session_id);
-
--- Metadata table
-CREATE TABLE IF NOT EXISTS metadata (
-  key TEXT PRIMARY KEY,
-  value TEXT NOT NULL
-);
-
-INSERT OR REPLACE INTO metadata (key, value) VALUES
-  ('version', '3.0.0'),
-  ('backend', '${backend}'),
-  ('created_at', '${new Date().toISOString()}'),
-  ('sql_js', 'true');
-`;
-            // Write schema to temp file for initialization
-            const schemaPath = path.join(dbDir, 'schema.sql');
-            fs.writeFileSync(schemaPath, schema);
-            // Create empty database file (sql.js will initialize it on first use)
-            if (force && fs.existsSync(dbPath)) {
-                fs.unlinkSync(dbPath);
+            output.writeln();
+            // Show features enabled with detailed capabilities
+            const featureLines = [
+                `Backend:           ${result.backend}`,
+                `Schema Version:    ${result.schemaVersion}`,
+                `Database Path:     ${result.dbPath}`,
+                '',
+                output.bold('Features:'),
+                `  Vector Embeddings: ${result.features.vectorEmbeddings ? output.success('✓ Enabled') : output.dim('✗ Disabled')}`,
+                `  Pattern Learning:  ${result.features.patternLearning ? output.success('✓ Enabled') : output.dim('✗ Disabled')}`,
+                `  Temporal Decay:    ${result.features.temporalDecay ? output.success('✓ Enabled') : output.dim('✗ Disabled')}`,
+                `  HNSW Indexing:     ${result.features.hnswIndexing ? output.success('✓ Enabled') : output.dim('✗ Disabled')}`,
+                `  Migration Tracking: ${result.features.migrationTracking ? output.success('✓ Enabled') : output.dim('✗ Disabled')}`
+            ];
+            if (verbose) {
+                featureLines.push('', output.bold('HNSW Configuration:'), `  M (connections):     16`, `  ef (construction):   200`, `  ef (search):         100`, `  Metric:              cosine`, '', output.bold('Pattern Learning:'), `  Confidence scoring:  0.0 - 1.0`, `  Temporal decay:      Half-life 30 days`, `  Pattern versioning:  Enabled`, `  Types: task-routing, error-recovery, optimization, coordination, prediction`);
+            }
+            output.printBox(featureLines.join('\n'), 'Configuration');
+            output.writeln();
+            // Show tables created
+            if (verbose && result.tablesCreated.length > 0) {
+                output.writeln(output.bold('Tables Created:'));
+                output.printTable({
+                    columns: [
+                        { key: 'table', header: 'Table', width: 22 },
+                        { key: 'purpose', header: 'Purpose', width: 38 }
+                    ],
+                    data: [
+                        { table: 'memory_entries', purpose: 'Core memory storage with embeddings' },
+                        { table: 'patterns', purpose: 'Learned patterns with confidence scores' },
+                        { table: 'pattern_history', purpose: 'Pattern versioning and evolution' },
+                        { table: 'trajectories', purpose: 'SONA learning trajectories' },
+                        { table: 'trajectory_steps', purpose: 'Individual trajectory steps' },
+                        { table: 'migration_state', purpose: 'Migration progress tracking' },
+                        { table: 'sessions', purpose: 'Context persistence' },
+                        { table: 'vector_indexes', purpose: 'HNSW index configuration' },
+                        { table: 'metadata', purpose: 'System metadata' }
+                    ]
+                });
+                output.writeln();
+                output.writeln(output.bold('Indexes Created:'));
+                output.printList(result.indexesCreated.slice(0, 8).map(idx => output.dim(idx)));
+                if (result.indexesCreated.length > 8) {
+                    output.writeln(output.dim(`  ... and ${result.indexesCreated.length - 8} more`));
+                }
+                output.writeln();
+            }
+            // Run verification if enabled
+            if (verify) {
+                const verifySpinner = output.createSpinner({ text: 'Verifying initialization...', spinner: 'dots' });
+                verifySpinner.start();
+                const verification = await verifyMemoryInit(result.dbPath, { verbose });
+                if (verification.success) {
+                    verifySpinner.succeed(`Verification passed (${verification.summary.passed}/${verification.summary.total} tests)`);
+                }
+                else {
+                    verifySpinner.fail(`Verification failed (${verification.summary.failed}/${verification.summary.total} tests failed)`);
+                }
+                if (verbose || !verification.success) {
+                    output.writeln();
+                    output.writeln(output.bold('Verification Results:'));
+                    output.printTable({
+                        columns: [
+                            { key: 'status', header: '', width: 3 },
+                            { key: 'name', header: 'Test', width: 22 },
+                            { key: 'details', header: 'Details', width: 30 },
+                            { key: 'duration', header: 'Time', width: 8, align: 'right' }
+                        ],
+                        data: verification.tests.map(t => ({
+                            status: t.passed ? output.success('✓') : output.error('✗'),
+                            name: t.name,
+                            details: t.details || '',
+                            duration: t.duration ? `${t.duration}ms` : '-'
+                        }))
+                    });
+                }
+                output.writeln();
             }
-            // Write minimal SQLite header to create valid empty database
-            // sql.js will properly initialize the schema on first connection
-            const sqliteHeader = Buffer.from([
-                0x53, 0x51, 0x4C, 0x69, 0x74, 0x65, 0x20, 0x66, 0x6F, 0x72, 0x6D, 0x61, 0x74, 0x20, 0x33, 0x00, // "SQLite format 3\0"
-                0x10, 0x00, // page size: 4096 bytes
-                0x01, // file format write version
-                0x01, // file format read version
-                0x00, // reserved space
-                0x40, // max embedded payload fraction
-                0x20, // min embedded payload fraction
-                0x20, // leaf payload fraction
-                0x00, 0x00, 0x00, 0x01, // file change counter
-                0x00, 0x00, 0x00, 0x01, // database size in pages
-                0x00, 0x00, 0x00, 0x00, // first freelist trunk page
-                0x00, 0x00, 0x00, 0x00, // total freelist pages
-                0x00, 0x00, 0x00, 0x01, // schema cookie
-                0x00, 0x00, 0x00, 0x04, // schema format number
-                0x00, 0x00, 0x00, 0x00, // default page cache size
-                0x00, 0x00, 0x00, 0x00, // largest root btree page
-                0x00, 0x00, 0x00, 0x01, // text encoding (1=UTF-8)
-                0x00, 0x00, 0x00, 0x00, // user version
-                0x00, 0x00, 0x00, 0x00, // incremental vacuum mode
-                0x00, 0x00, 0x00, 0x00, // application id
-                ...Array(20).fill(0x00), // reserved for expansion
-                0x00, 0x00, 0x00, 0x01, // version-valid-for number
-                0x00, 0x2E, 0x32, 0x8F, // SQLite version number (3.46.1)
+            // Show next steps
+            output.writeln(output.bold('Next Steps:'));
+            output.printList([
+                `Store data: ${output.highlight('claude-flow memory store -k "key" --value "data"')}`,
+                `Search: ${output.highlight('claude-flow memory search -q "query"')}`,
+                `Train patterns: ${output.highlight('claude-flow neural train -p coordination')}`,
+                `View stats: ${output.highlight('claude-flow memory stats')}`
             ]);
-            // Pad to 4096 bytes (one page)
-            const page = Buffer.alloc(4096, 0);
-            sqliteHeader.copy(page);
-            fs.writeFileSync(dbPath, page);
-            // Also create in .claude directory for compatibility
+            // Also sync to .claude directory
+            const fs = await import('fs');
+            const path = await import('path');
+            const claudeDir = path.join(process.cwd(), '.claude');
             const claudeDbPath = path.join(claudeDir, 'memory.db');
             if (!fs.existsSync(claudeDir)) {
                 fs.mkdirSync(claudeDir, { recursive: true });
             }
-            if (!fs.existsSync(claudeDbPath)) {
-                fs.copyFileSync(dbPath, claudeDbPath);
-                output.writeln(output.dim(`  Synced to: ${claudeDbPath}`));
+            if (fs.existsSync(result.dbPath) && (!fs.existsSync(claudeDbPath) || force)) {
+                fs.copyFileSync(result.dbPath, claudeDbPath);
+                output.writeln();
+                output.writeln(output.dim(`Synced to: ${claudeDbPath}`));
             }
-            output.writeln();
-            output.printSuccess('Memory database initialized');
-            output.writeln();
-            output.printTable({
-                columns: [
-                    { key: 'property', header: 'Property', width: 15 },
-                    { key: 'value', header: 'Value', width: 40 }
-                ],
-                data: [
-                    { property: 'Backend', value: backend },
-                    { property: 'Path', value: dbPath },
-                    { property: 'Engine', value: 'sql.js (WASM SQLite)' },
-                    { property: 'Schema', value: schemaPath },
-                    { property: 'Tables', value: '6 (memory_entries, vectors, patterns, sessions, trajectories, metadata)' }
-                ]
-            });
-            output.writeln();
-            output.printInfo('Ready for use. Store data with: claude-flow memory store -k "key" --value "data"');
             return {
                 success: true,
-                data: {
-                    backend,
-                    path: dbPath,
-                    schemaPath,
-                    engine: 'sql.js'
-                }
+                data: result
             };
         }
         catch (error) {
+            spinner.fail('Initialization failed');
             output.printError(`Failed to initialize memory: ${error instanceof Error ? error.message : String(error)}`);
             return { success: false, exitCode: 1 };
         }