claude-flow 2.7.0-alpha.1 → 2.7.0-alpha.10

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

@@ -402,8 +402,15 @@ async function detectMemoryMode(flags, subArgs) {
     return initialized ? 'reasoningbank' : 'basic';
   }
 
-  // Default: basic mode (backward compatible)
-  return 'basic';
+  // Explicit basic mode flag
+  if (flags?.basic || subArgs.includes('--basic')) {
+    return 'basic';
+  }
+
+  // Default: AUTO MODE (smart selection with JSON fallback)
+  // Automatically use ReasoningBank if initialized, otherwise fall back to basic mode
+  const initialized = await isReasoningBankInitialized();
+  return initialized ? 'reasoningbank' : 'basic';
 }
 
 // NEW: Check if ReasoningBank is initialized
@@ -423,17 +430,60 @@ async function handleReasoningBankCommand(command, subArgs, flags) {
   const initialized = await isReasoningBankInitialized();
 
   // Lazy load the adapter (ES modules)
-  const { initializeReasoningBank, storeMemory, queryMemories, listMemories, getStatus } = await import('../../reasoningbank/reasoningbank-adapter.js');
+  const { initializeReasoningBank, storeMemory, queryMemories, listMemories, getStatus, checkReasoningBankTables, migrateReasoningBank, cleanup } = 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');
+      } finally {
+        // Cleanup after migration check
+        cleanup();
+        // Force exit to prevent hanging from embedding cache timers
+        setTimeout(() => process.exit(0), 100);
+      }
       return;
     }
 
+    // Fresh initialization
     printInfo('🧠 Initializing ReasoningBank...');
     console.log('This will create: .swarm/memory.db\n');
 
@@ -447,6 +497,11 @@ async function handleReasoningBankCommand(command, subArgs, flags) {
     } catch (error) {
       printError('❌ Failed to initialize ReasoningBank');
       console.error(error.message);
+    } finally {
+      // Cleanup after init
+      cleanup();
+      // Force exit to prevent hanging from embedding cache timers
+      setTimeout(() => process.exit(0), 100);
     }
     return;
   }
@@ -496,6 +551,16 @@ async function handleReasoningBankCommand(command, subArgs, flags) {
   } catch (error) {
     printError(`❌ ReasoningBank command failed`);
     console.error(error.message);
+  } finally {
+    // Always cleanup database connection
+    cleanup();
+
+    // Force process exit after cleanup (embedding cache timers prevent natural exit)
+    // This is necessary because agentic-flow's embedding cache uses setTimeout
+    // which keeps the event loop alive
+    setTimeout(() => {
+      process.exit(0);
+    }, 100);
   }
 }
 
@@ -713,15 +778,16 @@ async function showCurrentMode() {
   const rbInitialized = await isReasoningBankInitialized();
 
   printInfo('📊 Current Memory Configuration:\n');
-  console.log('Default Mode: Basic (backward compatible)');
+  console.log('Default Mode: AUTO (smart selection with JSON fallback)');
   console.log('Available Modes:');
-  console.log('  • Basic Mode: Always available');
-  console.log(`  • ReasoningBank Mode: ${rbInitialized ? 'Initialized ✅' : 'Not initialized ⚠️'}`);
-
-  console.log('\n💡 To use a specific mode:');
-  console.log('   --reasoningbank or --rb  → Use ReasoningBank');
-  console.log('   --auto                   → Auto-detect best mode');
-  console.log('   (no flag)                → Use Basic mode');
+  console.log('  • Basic Mode: Always available (JSON storage)');
+  console.log(`  • ReasoningBank Mode: ${rbInitialized ? 'Initialized ✅ (will be used by default)' : 'Not initialized ⚠️ (JSON fallback active)'}`);
+
+  console.log('\n💡 Mode Behavior:');
+  console.log('   (no flag)                → AUTO: Use ReasoningBank if initialized, else JSON');
+  console.log('   --reasoningbank or --rb  → Force ReasoningBank mode');
+  console.log('   --basic                  → Force JSON mode');
+  console.log('   --auto                   → Same as default (explicit)');
 }
 
 // NEW: Migrate memory between modes
@@ -788,10 +854,11 @@ function showMemoryHelp() {
   console.log('  --redact               🔒 Enable API key redaction (security feature)');
   console.log('  --secure               Alias for --redact');
   console.log();
-  console.log('🎯 Mode Selection (NEW):');
-  console.log('  --reasoningbank, --rb  Use ReasoningBank mode (AI-powered)');
-  console.log('  --auto                 Auto-detect best available mode');
-  console.log('  (no flag)              Use Basic mode (default, backward compatible)');
+  console.log('🎯 Mode Selection:');
+  console.log('  (no flag)              AUTO MODE (default) - Uses ReasoningBank if initialized, else JSON fallback');
+  console.log('  --reasoningbank, --rb  Force ReasoningBank mode (AI-powered)');
+  console.log('  --basic                Force Basic mode (JSON storage)');
+  console.log('  --auto                 Explicit auto-detect (same as default)');
   console.log();
   console.log('🔒 Security Features (v2.6.0):');
   console.log('  API Key Protection:    Automatically detects and redacts sensitive data');
@@ -819,8 +886,9 @@ function showMemoryHelp() {
   console.log('  memory mode    # Show current configuration');
   console.log();
   console.log('💡 Tips:');
-  console.log('  • Use Basic mode for simple key-value storage (fast, always available)');
-  console.log('  • Use ReasoningBank for AI-powered semantic search (learns from patterns)');
-  console.log('  • Use --auto to let claude-flow choose the best mode for you');
+  console.log('  • AUTO MODE (default): Automatically uses best available storage');
+  console.log('  • ReasoningBank: AI-powered semantic search (learns from patterns)');
+  console.log('  • JSON fallback: Always available, fast, simple key-value storage');
+  console.log('  • Initialize ReasoningBank once: "memory init --reasoningbank"');
   console.log('  • Always use --redact when storing API keys or secrets!');
 }

package/src/cli/simple-commands/performance-metrics.js

@@ -21,13 +21,78 @@ let metricsCache = {
   agents: {},
   system: [],
   performance: {
+    // Session information
     startTime: Date.now(),
+    sessionId: `session-${Date.now()}`,
+    lastActivity: Date.now(),
+    sessionDuration: 0,
+
+    // General task metrics
     totalTasks: 0,
     successfulTasks: 0,
     failedTasks: 0,
     totalAgents: 0,
     activeAgents: 0,
-    neuralEvents: 0
+    neuralEvents: 0,
+
+    // Memory mode tracking
+    memoryMode: {
+      reasoningbankOperations: 0,
+      basicOperations: 0,
+      autoModeSelections: 0,
+      modeOverrides: 0,
+      currentMode: 'auto'
+    },
+
+    // Operation type breakdown
+    operations: {
+      store: { count: 0, totalDuration: 0, errors: 0 },
+      retrieve: { count: 0, totalDuration: 0, errors: 0 },
+      query: { count: 0, totalDuration: 0, errors: 0 },
+      list: { count: 0, totalDuration: 0, errors: 0 },
+      delete: { count: 0, totalDuration: 0, errors: 0 },
+      search: { count: 0, totalDuration: 0, errors: 0 },
+      init: { count: 0, totalDuration: 0, errors: 0 }
+    },
+
+    // Performance statistics
+    performance: {
+      avgOperationDuration: 0,
+      minOperationDuration: null,
+      maxOperationDuration: null,
+      slowOperations: 0, // Count of operations > 5s
+      fastOperations: 0, // Count of operations < 100ms
+      totalOperationTime: 0
+    },
+
+    // Memory storage statistics
+    storage: {
+      totalEntries: 0,
+      reasoningbankEntries: 0,
+      basicEntries: 0,
+      databaseSize: 0,
+      lastBackup: null,
+      growthRate: 0
+    },
+
+    // Error tracking
+    errors: {
+      total: 0,
+      byType: {},
+      byOperation: {},
+      recent: []
+    },
+
+    // ReasoningBank specific metrics
+    reasoningbank: {
+      semanticSearches: 0,
+      sqlFallbacks: 0,
+      embeddingGenerated: 0,
+      consolidations: 0,
+      avgQueryTime: 0,
+      cacheHits: 0,
+      cacheMisses: 0
+    }
   }
 };
 
@@ -162,10 +227,211 @@ export async function trackAgentActivity(agentId, agentType, action, duration, s
 // Track neural events
 export async function trackNeuralEvent(eventType, metadata = {}) {
   metricsCache.performance.neuralEvents++;
-  
+
   await saveMetricsToDisk();
 }
 
+// Track memory operations
+export async function trackMemoryOperation(operationType, mode, duration, success = true, errorType = null) {
+  // Update session activity
+  metricsCache.performance.lastActivity = Date.now();
+  metricsCache.performance.sessionDuration = Date.now() - metricsCache.performance.startTime;
+
+  // Track mode usage
+  if (mode === 'reasoningbank') {
+    metricsCache.performance.memoryMode.reasoningbankOperations++;
+  } else if (mode === 'basic') {
+    metricsCache.performance.memoryMode.basicOperations++;
+  }
+
+  // Track operation type
+  if (metricsCache.performance.operations[operationType]) {
+    const op = metricsCache.performance.operations[operationType];
+    op.count++;
+    op.totalDuration += duration;
+
+    if (!success) {
+      op.errors++;
+    }
+  }
+
+  // Update performance statistics
+  const perf = metricsCache.performance.performance;
+  perf.totalOperationTime += duration;
+
+  const totalOps = Object.values(metricsCache.performance.operations)
+    .reduce((sum, op) => sum + op.count, 0);
+
+  if (totalOps > 0) {
+    perf.avgOperationDuration = perf.totalOperationTime / totalOps;
+  }
+
+  if (perf.minOperationDuration === null || duration < perf.minOperationDuration) {
+    perf.minOperationDuration = duration;
+  }
+
+  if (perf.maxOperationDuration === null || duration > perf.maxOperationDuration) {
+    perf.maxOperationDuration = duration;
+  }
+
+  if (duration > 5000) {
+    perf.slowOperations++;
+  } else if (duration < 100) {
+    perf.fastOperations++;
+  }
+
+  // Track errors
+  if (!success && errorType) {
+    metricsCache.performance.errors.total++;
+
+    // Track by type
+    if (!metricsCache.performance.errors.byType[errorType]) {
+      metricsCache.performance.errors.byType[errorType] = 0;
+    }
+    metricsCache.performance.errors.byType[errorType]++;
+
+    // Track by operation
+    if (!metricsCache.performance.errors.byOperation[operationType]) {
+      metricsCache.performance.errors.byOperation[operationType] = 0;
+    }
+    metricsCache.performance.errors.byOperation[operationType]++;
+
+    // Add to recent errors (keep last 20)
+    metricsCache.performance.errors.recent.push({
+      operation: operationType,
+      type: errorType,
+      timestamp: Date.now(),
+      mode
+    });
+
+    if (metricsCache.performance.errors.recent.length > 20) {
+      metricsCache.performance.errors.recent = metricsCache.performance.errors.recent.slice(-20);
+    }
+  }
+
+  await saveMetricsToDisk();
+}
+
+// Track mode selection (auto, override)
+export async function trackModeSelection(selectedMode, wasAutomatic = true) {
+  metricsCache.performance.memoryMode.currentMode = selectedMode;
+
+  if (wasAutomatic) {
+    metricsCache.performance.memoryMode.autoModeSelections++;
+  } else {
+    metricsCache.performance.memoryMode.modeOverrides++;
+  }
+
+  await saveMetricsToDisk();
+}
+
+// Track ReasoningBank specific operations
+export async function trackReasoningBankOperation(operationType, duration, metadata = {}) {
+  const rb = metricsCache.performance.reasoningbank;
+
+  switch (operationType) {
+    case 'semantic_search':
+      rb.semanticSearches++;
+      break;
+    case 'sql_fallback':
+      rb.sqlFallbacks++;
+      break;
+    case 'embedding_generated':
+      rb.embeddingGenerated++;
+      break;
+    case 'consolidation':
+      rb.consolidations++;
+      break;
+    case 'cache_hit':
+      rb.cacheHits++;
+      break;
+    case 'cache_miss':
+      rb.cacheMisses++;
+      break;
+  }
+
+  // Update average query time
+  const totalQueries = rb.semanticSearches + rb.sqlFallbacks;
+  if (totalQueries > 0) {
+    rb.avgQueryTime = ((rb.avgQueryTime * (totalQueries - 1)) + duration) / totalQueries;
+  }
+
+  await saveMetricsToDisk();
+}
+
+// Update storage statistics
+export async function updateStorageStats(totalEntries, reasoningbankEntries, basicEntries, databaseSize = 0) {
+  const storage = metricsCache.performance.storage;
+
+  const previousTotal = storage.totalEntries;
+  storage.totalEntries = totalEntries;
+  storage.reasoningbankEntries = reasoningbankEntries;
+  storage.basicEntries = basicEntries;
+  storage.databaseSize = databaseSize;
+
+  // Calculate growth rate (entries per hour)
+  if (previousTotal > 0) {
+    const sessionHours = metricsCache.performance.sessionDuration / (1000 * 60 * 60);
+    if (sessionHours > 0) {
+      storage.growthRate = (totalEntries - previousTotal) / sessionHours;
+    }
+  }
+
+  await saveMetricsToDisk();
+}
+
+// Get memory performance summary
+export async function getMemoryPerformanceSummary() {
+  const perf = metricsCache.performance;
+  const totalOps = Object.values(perf.operations).reduce((sum, op) => sum + op.count, 0);
+  const totalErrors = Object.values(perf.operations).reduce((sum, op) => sum + op.errors, 0);
+
+  return {
+    session: {
+      sessionId: perf.sessionId,
+      duration: perf.sessionDuration,
+      startTime: new Date(perf.startTime).toISOString(),
+      lastActivity: new Date(perf.lastActivity).toISOString()
+    },
+    mode: {
+      current: perf.memoryMode.currentMode,
+      reasoningbankUsage: perf.memoryMode.reasoningbankOperations,
+      basicUsage: perf.memoryMode.basicOperations,
+      autoSelections: perf.memoryMode.autoModeSelections,
+      manualOverrides: perf.memoryMode.modeOverrides
+    },
+    operations: {
+      total: totalOps,
+      breakdown: perf.operations,
+      errors: totalErrors,
+      errorRate: totalOps > 0 ? (totalErrors / totalOps) * 100 : 0
+    },
+    performance: {
+      avgDuration: perf.performance.avgOperationDuration,
+      minDuration: perf.performance.minOperationDuration,
+      maxDuration: perf.performance.maxOperationDuration,
+      slowOps: perf.performance.slowOperations,
+      fastOps: perf.performance.fastOperations
+    },
+    storage: perf.storage,
+    reasoningbank: {
+      ...perf.reasoningbank,
+      fallbackRate: perf.reasoningbank.semanticSearches > 0
+        ? (perf.reasoningbank.sqlFallbacks / perf.reasoningbank.semanticSearches) * 100
+        : 0,
+      cacheHitRate: (perf.reasoningbank.cacheHits + perf.reasoningbank.cacheMisses) > 0
+        ? (perf.reasoningbank.cacheHits / (perf.reasoningbank.cacheHits + perf.reasoningbank.cacheMisses)) * 100
+        : 0
+    },
+    errors: {
+      total: perf.errors.total,
+      byType: perf.errors.byType,
+      byOperation: perf.errors.byOperation,
+      recent: perf.errors.recent.slice(-5)
+    }
+  };
+}
+
 // Get performance report data
 export async function getPerformanceReport(timeframe = '24h') {
   const now = Date.now();