claude-flow 2.7.0-alpha → 2.7.0-alpha.2

package/src/cli/simple-commands/init/index.js

@@ -1568,6 +1568,57 @@ ${commands.map((cmd) => `- [${cmd}](./${cmd}.md)`).join('\n')}
 
       // Initialize memory database with fallback support
       try {
+        // Check if database exists BEFORE creating it
+        const dbPath = '.swarm/memory.db';
+        const { existsSync } = await import('fs');
+        const dbExistedBefore = existsSync(dbPath);
+
+        // Handle ReasoningBank migration BEFORE FallbackMemoryStore initialization
+        // This prevents schema conflicts with old databases
+        if (dbExistedBefore) {
+          console.log('  🔍 Checking existing database for ReasoningBank schema...');
+
+          try {
+            const {
+              initializeReasoningBank,
+              checkReasoningBankTables,
+              migrateReasoningBank
+            } = await import('../../../reasoningbank/reasoningbank-adapter.js');
+
+            // Set the database path for ReasoningBank
+            process.env.CLAUDE_FLOW_DB_PATH = dbPath;
+
+            const tableCheck = await checkReasoningBankTables();
+
+            if (tableCheck.exists) {
+              console.log('  ✅ ReasoningBank schema already complete');
+            } else if (force) {
+              // User used --force flag, migrate the database
+              console.log(`  🔄 Migrating database: ${tableCheck.missingTables.length} tables missing`);
+              console.log(`     Missing: ${tableCheck.missingTables.join(', ')}`);
+
+              const migrationResult = await migrateReasoningBank();
+
+              if (migrationResult.success) {
+                printSuccess(`  ✓ Migration complete: added ${migrationResult.addedTables?.length || 0} tables`);
+                console.log('     Use --reasoningbank flag to enable AI-powered memory features');
+              } else {
+                console.log(`  ⚠️  Migration failed: ${migrationResult.message}`);
+                console.log('     Basic memory will work, use: memory init --reasoningbank to retry');
+              }
+            } else {
+              // Database exists with missing tables but no --force flag
+              console.log(`  ℹ️  Database has ${tableCheck.missingTables.length} missing ReasoningBank tables`);
+              console.log(`     Missing: ${tableCheck.missingTables.join(', ')}`);
+              console.log('     Use --force to migrate existing database');
+              console.log('     Or use: memory init --reasoningbank');
+            }
+          } catch (rbErr) {
+            console.log(`  ⚠️  ReasoningBank check failed: ${rbErr.message}`);
+            console.log('     Will attempt normal initialization...');
+          }
+        }
+
         // Import and initialize FallbackMemoryStore to create the database
         const { FallbackMemoryStore } = await import('../../../memory/fallback-store.js');
         const memoryStore = new FallbackMemoryStore();
@@ -1580,6 +1631,25 @@ ${commands.map((cmd) => `- [${cmd}](./${cmd}.md)`).join('\n')}
           );
         } else {
           printSuccess('✓ Initialized memory database (.swarm/memory.db)');
+
+          // Initialize ReasoningBank schema for fresh databases
+          if (!dbExistedBefore) {
+            try {
+              const {
+                initializeReasoningBank
+              } = await import('../../../reasoningbank/reasoningbank-adapter.js');
+
+              // Set the database path for ReasoningBank
+              process.env.CLAUDE_FLOW_DB_PATH = dbPath;
+
+              console.log('  🧠 Initializing ReasoningBank schema...');
+              await initializeReasoningBank();
+              printSuccess('  ✓ ReasoningBank schema initialized (use --reasoningbank flag for AI-powered memory)');
+            } catch (rbErr) {
+              console.log(`  ⚠️  ReasoningBank initialization failed: ${rbErr.message}`);
+              console.log('     Basic memory will work, use: memory init --reasoningbank to retry');
+            }
+          }
         }
 
         memoryStore.close();

package/src/cli/simple-commands/memory.js

@@ -422,24 +422,61 @@ async function isReasoningBankInitialized() {
 async function handleReasoningBankCommand(command, subArgs, flags) {
   const initialized = await isReasoningBankInitialized();
 
+  // Lazy load the adapter (ES modules)
+  const { initializeReasoningBank, storeMemory, queryMemories, listMemories, getStatus, checkReasoningBankTables, migrateReasoningBank } = await import('../../reasoningbank/reasoningbank-adapter.js');
+
   // Special handling for 'init' command
   if (command === 'init') {
+    const dbPath = '.swarm/memory.db';
+
     if (initialized) {
-      printWarning('⚠️  ReasoningBank already initialized');
-      console.log('Database: .swarm/memory.db');
-      console.log('\nTo reinitialize, delete .swarm/memory.db first');
+      // Database exists - check if migration is needed
+      printInfo('🔍 Checking existing database for ReasoningBank schema...\n');
+
+      try {
+        // Set the database path for ReasoningBank
+        process.env.CLAUDE_FLOW_DB_PATH = dbPath;
+
+        const tableCheck = await checkReasoningBankTables();
+
+        if (tableCheck.exists) {
+          printSuccess('✅ ReasoningBank already complete');
+          console.log('Database: .swarm/memory.db');
+          console.log('All ReasoningBank tables present\n');
+          console.log('Use --reasoningbank flag with memory commands to enable AI features');
+          return;
+        }
+
+        // Missing tables found - run migration
+        console.log(`🔄 Migrating database: ${tableCheck.missingTables.length} tables missing`);
+        console.log(`   Missing: ${tableCheck.missingTables.join(', ')}\n`);
+
+        const migrationResult = await migrateReasoningBank();
+
+        if (migrationResult.success) {
+          printSuccess(`✓ Migration complete: added ${migrationResult.addedTables?.length || 0} tables`);
+          console.log('\nNext steps:');
+          console.log('  1. Store memories: memory store key "value" --reasoningbank');
+          console.log('  2. Query memories: memory query "search" --reasoningbank');
+          console.log('  3. Check status: memory status --reasoningbank');
+        } else {
+          printError(`❌ Migration failed: ${migrationResult.message}`);
+          console.log('Try running: init --force to reinitialize');
+        }
+      } catch (error) {
+        printError('❌ Migration check failed');
+        console.error(error.message);
+        console.log('\nTry running: init --force to reinitialize');
+      }
       return;
     }
 
+    // Fresh initialization
     printInfo('🧠 Initializing ReasoningBank...');
     console.log('This will create: .swarm/memory.db\n');
 
     try {
-      const { stdout, stderr } = await execAsync('npx agentic-flow reasoningbank init', {
-        timeout: 30000,
-      });
-
-      if (stdout) console.log(stdout);
+      await initializeReasoningBank();
       printSuccess('✅ ReasoningBank initialized successfully!');
       console.log('\nNext steps:');
       console.log('  1. Store memories: memory store key "value" --reasoningbank');
@@ -448,9 +485,6 @@ async function handleReasoningBankCommand(command, subArgs, flags) {
     } catch (error) {
       printError('❌ Failed to initialize ReasoningBank');
       console.error(error.message);
-      if (error.stderr) {
-        console.error('Details:', error.stderr);
-      }
     }
     return;
   }
@@ -463,21 +497,156 @@ async function handleReasoningBankCommand(command, subArgs, flags) {
     return;
   }
 
-  // Delegate to agentic-flow reasoningbank commands
   printInfo(`🧠 Using ReasoningBank mode...`);
 
   try {
-    const cmd = buildReasoningBankCommand(command, subArgs, flags);
-    const { stdout, stderr } = await execAsync(cmd, { timeout: 30000 });
-
-    if (stdout) console.log(stdout);
-    if (stderr && !stderr.includes('Warning')) console.error(stderr);
+    // Handle different commands
+    switch (command) {
+      case 'store':
+        await handleReasoningBankStore(subArgs, flags, storeMemory);
+        break;
+
+      case 'query':
+        await handleReasoningBankQuery(subArgs, flags, queryMemories);
+        break;
+
+      case 'list':
+        await handleReasoningBankList(subArgs, flags, listMemories);
+        break;
+
+      case 'status':
+        await handleReasoningBankStatus(getStatus);
+        break;
+
+      case 'consolidate':
+      case 'demo':
+      case 'test':
+      case 'benchmark':
+        // These still use CLI commands
+        const cmd = `npx agentic-flow reasoningbank ${command}`;
+        const { stdout } = await execAsync(cmd, { timeout: 60000 });
+        if (stdout) console.log(stdout);
+        break;
+
+      default:
+        printError(`Unknown ReasoningBank command: ${command}`);
+    }
   } catch (error) {
     printError(`❌ ReasoningBank command failed`);
     console.error(error.message);
   }
 }
 
+// NEW: Handle ReasoningBank store
+async function handleReasoningBankStore(subArgs, flags, storeMemory) {
+  const key = subArgs[1];
+  const value = subArgs.slice(2).join(' ');
+
+  if (!key || !value) {
+    printError('Usage: memory store <key> <value> --reasoningbank');
+    return;
+  }
+
+  try {
+    const namespace = flags?.namespace || flags?.ns || getArgValue(subArgs, '--namespace') || 'default';
+
+    const memoryId = await storeMemory(key, value, {
+      namespace,
+      agent: 'memory-agent',
+      domain: namespace,
+    });
+
+    printSuccess('✅ Stored successfully in ReasoningBank');
+    console.log(`📝 Key: ${key}`);
+    console.log(`🧠 Memory ID: ${memoryId}`);
+    console.log(`📦 Namespace: ${namespace}`);
+    console.log(`💾 Size: ${new TextEncoder().encode(value).length} bytes`);
+    console.log(`🔍 Semantic search: enabled`);
+  } catch (error) {
+    printError(`Failed to store: ${error.message}`);
+  }
+}
+
+// NEW: Handle ReasoningBank query
+async function handleReasoningBankQuery(subArgs, flags, queryMemories) {
+  const search = subArgs.slice(1).join(' ');
+
+  if (!search) {
+    printError('Usage: memory query <search> --reasoningbank');
+    return;
+  }
+
+  try {
+    const namespace = flags?.namespace || flags?.ns || getArgValue(subArgs, '--namespace');
+    const results = await queryMemories(search, {
+      domain: namespace || 'general',
+      limit: 10,
+    });
+
+    if (results.length === 0) {
+      printWarning('No results found');
+      return;
+    }
+
+    printSuccess(`Found ${results.length} results (semantic search):`);
+
+    for (const entry of results) {
+      console.log(`\n📌 ${entry.key}`);
+      console.log(`   Namespace: ${entry.namespace}`);
+      console.log(`   Value: ${entry.value.substring(0, 100)}${entry.value.length > 100 ? '...' : ''}`);
+      console.log(`   Confidence: ${(entry.confidence * 100).toFixed(1)}%`);
+      console.log(`   Usage: ${entry.usage_count} times`);
+      if (entry.score) {
+        console.log(`   Match Score: ${(entry.score * 100).toFixed(1)}%`);
+      }
+      console.log(`   Stored: ${new Date(entry.created_at).toLocaleString()}`);
+    }
+  } catch (error) {
+    printError(`Failed to query: ${error.message}`);
+  }
+}
+
+// NEW: Handle ReasoningBank list
+async function handleReasoningBankList(subArgs, flags, listMemories) {
+  try {
+    const sort = flags?.sort || getArgValue(subArgs, '--sort') || 'created_at';
+    const limit = parseInt(flags?.limit || getArgValue(subArgs, '--limit') || '10');
+
+    const results = await listMemories({ sort, limit });
+
+    if (results.length === 0) {
+      printWarning('No memories found');
+      return;
+    }
+
+    printSuccess(`ReasoningBank memories (${results.length} shown):`);
+
+    for (const entry of results) {
+      console.log(`\n📌 ${entry.key}`);
+      console.log(`   Value: ${entry.value.substring(0, 80)}${entry.value.length > 80 ? '...' : ''}`);
+      console.log(`   Confidence: ${(entry.confidence * 100).toFixed(1)}% | Usage: ${entry.usage_count}`);
+    }
+  } catch (error) {
+    printError(`Failed to list: ${error.message}`);
+  }
+}
+
+// NEW: Handle ReasoningBank status
+async function handleReasoningBankStatus(getStatus) {
+  try {
+    const stats = await getStatus();
+
+    printSuccess('📊 ReasoningBank Status:');
+    console.log(`   Total memories: ${stats.total_memories}`);
+    console.log(`   Average confidence: ${(stats.avg_confidence * 100).toFixed(1)}%`);
+    console.log(`   Total usage: ${stats.total_usage}`);
+    console.log(`   Embeddings: ${stats.total_embeddings}`);
+    console.log(`   Trajectories: ${stats.total_trajectories}`);
+  } catch (error) {
+    printError(`Failed to get status: ${error.message}`);
+  }
+}
+
 // NEW: Build agentic-flow reasoningbank command
 function buildReasoningBankCommand(command, subArgs, flags) {
   const parts = ['npx', 'agentic-flow', 'reasoningbank'];
@@ -504,6 +673,9 @@ function buildReasoningBankCommand(command, subArgs, flags) {
     }
   });
 
+  // Add required --agent parameter
+  parts.push('--agent', 'memory-agent');
+
   return parts.join(' ');
 }
 

package/src/reasoningbank/reasoningbank-adapter.js

@@ -0,0 +1,273 @@
+/**
+ * ReasoningBank Adapter for Claude-Flow
+ *
+ * Wraps agentic-flow's ReasoningBank SDK for use in claude-flow memory commands
+ */
+
+import {  db, initialize, retrieveMemories, computeEmbedding, loadConfig } from 'agentic-flow/dist/reasoningbank/index.js';
+import { v4 as uuidv4 } from 'uuid';
+
+/**
+ * Initialize ReasoningBank database
+ */
+export async function initializeReasoningBank() {
+  // Set database path
+  process.env.CLAUDE_FLOW_DB_PATH = '.swarm/memory.db';
+
+  await initialize();
+  return true;
+}
+
+/**
+ * Store a memory in ReasoningBank
+ */
+export async function storeMemory(key, value, options = {}) {
+  const memoryId = `mem_${uuidv4()}`;
+
+  const memory = {
+    id: memoryId,
+    type: options.type || 'fact',
+    pattern_data: JSON.stringify({
+      key,
+      value,
+      namespace: options.namespace || 'default',
+      agent: options.agent || 'memory-agent',
+      domain: options.domain || 'general',
+    }),
+    confidence: options.confidence || 0.8,
+    usage_count: 0,
+    created_at: new Date().toISOString(),
+  };
+
+  // Store memory
+  db.upsertMemory(memory);
+
+  // Compute and store embedding for semantic search
+  try {
+    const config = loadConfig();
+    const embeddingModel = config.embeddings.provider || 'claude';
+
+    const embedding = await computeEmbedding(`${key}: ${value}`);
+    const vectorArray = new Float32Array(embedding);
+
+    db.upsertEmbedding({
+      memory_id: memoryId,
+      vector: vectorArray,
+      model: embeddingModel,  // Dynamic model from config
+      dims: vectorArray.length,  // Required: embedding dimensions
+      created_at: new Date().toISOString(),
+    });
+  } catch (error) {
+    console.warn('[ReasoningBank] Warning: Could not compute embedding:', error.message);
+    // Continue without embedding - memory is still stored
+  }
+
+  return memoryId;
+}
+
+/**
+ * Query memories from ReasoningBank
+ */
+export async function queryMemories(searchQuery, options = {}) {
+  try {
+    // Use ReasoningBank's semantic retrieval
+    const memories = await retrieveMemories(searchQuery, {
+      domain: options.domain || 'general',
+      agent: options.agent || 'memory-agent',
+      k: options.limit || 10,
+    });
+
+    return memories.map(mem => {
+      try {
+        const data = JSON.parse(mem.pattern_data);
+        return {
+          id: mem.id,
+          key: data.key,
+          value: data.value,
+          namespace: data.namespace,
+          confidence: mem.confidence,
+          usage_count: mem.usage_count,
+          created_at: mem.created_at,
+          score: mem.score || 0,
+        };
+      } catch {
+        return null;
+      }
+    }).filter(Boolean);
+  } catch (error) {
+    // Fallback to simple query if semantic search fails
+    console.warn('[ReasoningBank] Semantic search failed, using simple query:', error.message);
+
+    const dbInstance = db.getDb();
+    const rows = dbInstance.prepare(`
+      SELECT * FROM patterns
+      WHERE pattern_data LIKE ?
+      ORDER BY confidence DESC, usage_count DESC
+      LIMIT ?
+    `).all(`%${searchQuery}%`, options.limit || 10);
+
+    return rows.map(row => {
+      try {
+        const data = JSON.parse(row.pattern_data);
+        return {
+          id: row.id,
+          key: data.key,
+          value: data.value,
+          namespace: data.namespace,
+          confidence: row.confidence,
+          usage_count: row.usage_count,
+          created_at: row.created_at,
+        };
+      } catch {
+        return null;
+      }
+    }).filter(Boolean);
+  }
+}
+
+/**
+ * List all memories
+ */
+export async function listMemories(options = {}) {
+  const dbInstance = db.getDb();
+
+  const limit = options.limit || 10;
+  const sortBy = options.sort || 'created_at';
+  const sortOrder = options.order || 'DESC';
+
+  const rows = dbInstance.prepare(`
+    SELECT * FROM patterns
+    ORDER BY ${sortBy} ${sortOrder}
+    LIMIT ?
+  `).all(limit);
+
+  return rows.map(row => {
+    try {
+      const data = JSON.parse(row.pattern_data);
+      return {
+        id: row.id,
+        key: data.key,
+        value: data.value,
+        namespace: data.namespace,
+        confidence: row.confidence,
+        usage_count: row.usage_count,
+        created_at: row.created_at,
+      };
+    } catch {
+      return null;
+    }
+  }).filter(Boolean);
+}
+
+/**
+ * Get ReasoningBank statistics
+ */
+export async function getStatus() {
+  const dbInstance = db.getDb();
+
+  const stats = dbInstance.prepare(`
+    SELECT
+      COUNT(*) as total_memories,
+      AVG(confidence) as avg_confidence,
+      SUM(usage_count) as total_usage
+    FROM patterns
+  `).get();
+
+  const embeddingCount = dbInstance.prepare(`
+    SELECT COUNT(*) as count FROM pattern_embeddings
+  `).get();
+
+  const trajectoryCount = dbInstance.prepare(`
+    SELECT COUNT(*) as count FROM task_trajectories
+  `).get();
+
+  return {
+    total_memories: stats.total_memories || 0,
+    avg_confidence: stats.avg_confidence || 0,
+    total_usage: stats.total_usage || 0,
+    total_embeddings: embeddingCount.count || 0,
+    total_trajectories: trajectoryCount.count || 0,
+  };
+}
+
+/**
+ * Check which ReasoningBank tables are present in the database
+ * Returns object with table names and their existence status
+ */
+export async function checkReasoningBankTables() {
+  try {
+    const dbInstance = db.getDb();
+
+    // Required ReasoningBank tables
+    const requiredTables = [
+      'patterns',
+      'pattern_embeddings',
+      'pattern_links',
+      'task_trajectories',
+      'matts_runs',
+      'consolidation_runs',
+      'metrics_log'
+    ];
+
+    // Query existing tables
+    const existingTables = dbInstance.prepare(`
+      SELECT name FROM sqlite_master
+      WHERE type='table'
+    `).all().map(row => row.name);
+
+    // Check which required tables are missing
+    const missingTables = requiredTables.filter(table => !existingTables.includes(table));
+
+    return {
+      exists: missingTables.length === 0,
+      existingTables,
+      missingTables,
+      requiredTables
+    };
+  } catch (error) {
+    return {
+      exists: false,
+      existingTables: [],
+      missingTables: [],
+      requiredTables: [],
+      error: error.message
+    };
+  }
+}
+
+/**
+ * Migrate existing database to add missing ReasoningBank tables
+ */
+export async function migrateReasoningBank() {
+  try {
+    // Check current state
+    const tableCheck = await checkReasoningBankTables();
+
+    if (tableCheck.exists) {
+      return {
+        success: true,
+        message: 'All ReasoningBank tables already exist',
+        migrated: false
+      };
+    }
+
+    // Run full initialization which will create missing tables
+    await initializeReasoningBank();
+
+    // Verify migration
+    const afterCheck = await checkReasoningBankTables();
+
+    return {
+      success: afterCheck.exists,
+      message: `Migration completed: ${tableCheck.missingTables.length} tables added`,
+      migrated: true,
+      addedTables: tableCheck.missingTables
+    };
+  } catch (error) {
+    return {
+      success: false,
+      message: `Migration failed: ${error.message}`,
+      error: error.message
+    };
+  }
+}