claude-flow 2.5.0-alpha.141 → 2.7.0-alpha

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

@@ -3,14 +3,25 @@ import { printSuccess, printError, printWarning, printInfo } from '../utils.js';
 import { promises as fs } from 'fs';
 import { cwd, exit, existsSync } from '../node-compat.js';
 import { getUnifiedMemory } from '../../memory/unified-memory-manager.js';
+import { KeyRedactor } from '../../utils/key-redactor.js';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+
+const execAsync = promisify(exec);
 
 export async function memoryCommand(subArgs, flags) {
   const memorySubcommand = subArgs[0];
   const memoryStore = './memory/memory-store.json';
-  
+
   // Extract namespace from flags or subArgs
   const namespace = flags?.namespace || flags?.ns || getNamespaceFromArgs(subArgs) || 'default';
 
+  // Check for redaction flag
+  const enableRedaction = flags?.redact || subArgs.includes('--redact') || subArgs.includes('--secure');
+
+  // NEW: Detect memory mode (basic, reasoningbank, auto)
+  const mode = await detectMemoryMode(flags, subArgs);
+
   // Helper to load memory data
   async function loadMemory() {
     try {
@@ -27,13 +38,28 @@ export async function memoryCommand(subArgs, flags) {
     await fs.writeFile(memoryStore, JSON.stringify(data, null, 2, 'utf8'));
   }
 
+  // NEW: Handle ReasoningBank-specific commands
+  if (mode === 'reasoningbank' && ['init', 'status', 'consolidate', 'demo', 'test', 'benchmark'].includes(memorySubcommand)) {
+    return await handleReasoningBankCommand(memorySubcommand, subArgs, flags);
+  }
+
+  // NEW: Handle new mode management commands
+  if (['detect', 'mode', 'migrate'].includes(memorySubcommand)) {
+    return await handleModeCommand(memorySubcommand, subArgs, flags);
+  }
+
+  // NEW: Delegate to ReasoningBank for regular commands if mode is set
+  if (mode === 'reasoningbank' && ['store', 'query', 'list'].includes(memorySubcommand)) {
+    return await handleReasoningBankCommand(memorySubcommand, subArgs, flags);
+  }
+
   switch (memorySubcommand) {
     case 'store':
-      await storeMemory(subArgs, loadMemory, saveMemory, namespace);
+      await storeMemory(subArgs, loadMemory, saveMemory, namespace, enableRedaction);
       break;
 
     case 'query':
-      await queryMemory(subArgs, loadMemory, namespace);
+      await queryMemory(subArgs, loadMemory, namespace, enableRedaction);
       break;
 
     case 'stats':
@@ -61,16 +87,39 @@ export async function memoryCommand(subArgs, flags) {
   }
 }
 
-async function storeMemory(subArgs, loadMemory, saveMemory, namespace) {
+async function storeMemory(subArgs, loadMemory, saveMemory, namespace, enableRedaction = false) {
   const key = subArgs[1];
-  const value = subArgs.slice(2).join(' ');
+  let value = subArgs.slice(2).join(' ');
 
   if (!key || !value) {
-    printError('Usage: memory store <key> <value> [--namespace <ns>]');
+    printError('Usage: memory store <key> <value> [--namespace <ns>] [--redact]');
     return;
   }
 
   try {
+    // Apply redaction if enabled
+    let redactedValue = value;
+    let securityWarnings = [];
+
+    if (enableRedaction) {
+      redactedValue = KeyRedactor.redact(value, true);
+      const validation = KeyRedactor.validate(value);
+
+      if (!validation.safe) {
+        securityWarnings = validation.warnings;
+        printWarning('🔒 Redaction enabled: Sensitive data detected and redacted');
+        securityWarnings.forEach(warning => console.log(`   ⚠️  ${warning}`));
+      }
+    } else {
+      // Even if redaction is not explicitly enabled, validate and warn
+      const validation = KeyRedactor.validate(value);
+      if (!validation.safe) {
+        printWarning('⚠️  Potential sensitive data detected! Use --redact flag for automatic redaction');
+        validation.warnings.forEach(warning => console.log(`   ⚠️  ${warning}`));
+        console.log('   💡 Tip: Add --redact flag to automatically redact API keys');
+      }
+    }
+
     const data = await loadMemory();
 
     if (!data[namespace]) {
@@ -80,29 +129,33 @@ async function storeMemory(subArgs, loadMemory, saveMemory, namespace) {
     // Remove existing entry with same key
     data[namespace] = data[namespace].filter((e) => e.key !== key);
 
-    // Add new entry
+    // Add new entry with redacted value
     data[namespace].push({
       key,
-      value,
+      value: redactedValue,
       namespace,
       timestamp: Date.now(),
+      redacted: enableRedaction && securityWarnings.length > 0,
     });
 
     await saveMemory(data);
-    printSuccess('Stored successfully');
+    printSuccess(enableRedaction && securityWarnings.length > 0 ? '🔒 Stored successfully (with redaction)' : '✅ Stored successfully');
     console.log(`📝 Key: ${key}`);
     console.log(`📦 Namespace: ${namespace}`);
-    console.log(`💾 Size: ${new TextEncoder().encode(value).length} bytes`);
+    console.log(`💾 Size: ${new TextEncoder().encode(redactedValue).length} bytes`);
+    if (enableRedaction && securityWarnings.length > 0) {
+      console.log(`🔒 Security: ${securityWarnings.length} sensitive pattern(s) redacted`);
+    }
   } catch (err) {
     printError(`Failed to store: ${err.message}`);
   }
 }
 
-async function queryMemory(subArgs, loadMemory, namespace) {
+async function queryMemory(subArgs, loadMemory, namespace, enableRedaction = false) {
   const search = subArgs.slice(1).join(' ');
 
   if (!search) {
-    printError('Usage: memory query <search> [--namespace <ns>]');
+    printError('Usage: memory query <search> [--namespace <ns>] [--redact]');
     return;
   }
 
@@ -133,10 +186,24 @@ async function queryMemory(subArgs, loadMemory, namespace) {
     for (const entry of results.slice(0, 10)) {
       console.log(`\n📌 ${entry.key}`);
       console.log(`   Namespace: ${entry.namespace}`);
+
+      // Apply redaction to displayed value if requested
+      let displayValue = entry.value;
+      if (enableRedaction) {
+        displayValue = KeyRedactor.redact(displayValue, true);
+      }
+
       console.log(
-        `   Value: ${entry.value.substring(0, 100)}${entry.value.length > 100 ? '...' : ''}`,
+        `   Value: ${displayValue.substring(0, 100)}${displayValue.length > 100 ? '...' : ''}`,
       );
       console.log(`   Stored: ${new Date(entry.timestamp).toLocaleString()}`);
+
+      // Show redaction status
+      if (entry.redacted) {
+        console.log(`   🔒 Status: Redacted on storage`);
+      } else if (enableRedaction) {
+        console.log(`   🔒 Status: Redacted for display`);
+      }
     }
 
     if (results.length > 10) {
@@ -322,6 +389,248 @@ async function loadMemory() {
   }
 }
 
+// NEW: Mode detection function
+async function detectMemoryMode(flags, subArgs) {
+  // Explicit ReasoningBank flag takes precedence
+  if (flags?.reasoningbank || flags?.rb || subArgs.includes('--reasoningbank') || subArgs.includes('--rb')) {
+    return 'reasoningbank';
+  }
+
+  // Auto mode: detect if ReasoningBank is initialized
+  if (flags?.auto || subArgs.includes('--auto')) {
+    const initialized = await isReasoningBankInitialized();
+    return initialized ? 'reasoningbank' : 'basic';
+  }
+
+  // Default: basic mode (backward compatible)
+  return 'basic';
+}
+
+// NEW: Check if ReasoningBank is initialized
+async function isReasoningBankInitialized() {
+  try {
+    // Check if .swarm/memory.db exists
+    const dbPath = '.swarm/memory.db';
+    await fs.access(dbPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// NEW: Handle ReasoningBank commands
+async function handleReasoningBankCommand(command, subArgs, flags) {
+  const initialized = await isReasoningBankInitialized();
+
+  // Special handling for 'init' command
+  if (command === 'init') {
+    if (initialized) {
+      printWarning('⚠️  ReasoningBank already initialized');
+      console.log('Database: .swarm/memory.db');
+      console.log('\nTo reinitialize, delete .swarm/memory.db first');
+      return;
+    }
+
+    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);
+      printSuccess('✅ ReasoningBank initialized successfully!');
+      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');
+    } catch (error) {
+      printError('❌ Failed to initialize ReasoningBank');
+      console.error(error.message);
+      if (error.stderr) {
+        console.error('Details:', error.stderr);
+      }
+    }
+    return;
+  }
+
+  // All other commands require initialization
+  if (!initialized) {
+    printError('❌ ReasoningBank not initialized');
+    console.log('\nTo use ReasoningBank mode, first run:');
+    console.log('  memory init --reasoningbank\n');
+    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);
+  } catch (error) {
+    printError(`❌ ReasoningBank command failed`);
+    console.error(error.message);
+  }
+}
+
+// NEW: Build agentic-flow reasoningbank command
+function buildReasoningBankCommand(command, subArgs, flags) {
+  const parts = ['npx', 'agentic-flow', 'reasoningbank'];
+
+  // Map memory commands to reasoningbank commands
+  const commandMap = {
+    store: 'store',
+    query: 'query',
+    list: 'list',
+    status: 'status',
+    consolidate: 'consolidate',
+    demo: 'demo',
+    test: 'test',
+    benchmark: 'benchmark',
+  };
+
+  parts.push(commandMap[command] || command);
+
+  // Add arguments (skip the command itself)
+  const args = subArgs.slice(1);
+  args.forEach((arg) => {
+    if (!arg.startsWith('--reasoningbank') && !arg.startsWith('--rb') && !arg.startsWith('--auto')) {
+      parts.push(`"${arg}"`);
+    }
+  });
+
+  return parts.join(' ');
+}
+
+// NEW: Handle mode management commands
+async function handleModeCommand(command, subArgs, flags) {
+  switch (command) {
+    case 'detect':
+      await detectModes();
+      break;
+
+    case 'mode':
+      await showCurrentMode();
+      break;
+
+    case 'migrate':
+      await migrateMemory(subArgs, flags);
+      break;
+
+    default:
+      printError(`Unknown mode command: ${command}`);
+  }
+}
+
+// NEW: Detect and show available memory modes
+async function detectModes() {
+  printInfo('🔍 Detecting memory modes...\n');
+
+  // Check basic mode
+  const basicAvailable = await checkBasicMode();
+  console.log(basicAvailable ? '✅ Basic Mode (active)' : '❌ Basic Mode (unavailable)');
+  if (basicAvailable) {
+    console.log('   Location: ./memory/memory-store.json');
+    console.log('   Features: Simple key-value storage, fast');
+  }
+
+  console.log('');
+
+  // Check ReasoningBank mode
+  const rbAvailable = await isReasoningBankInitialized();
+  console.log(rbAvailable ? '✅ ReasoningBank Mode (available)' : '⚠️  ReasoningBank Mode (not initialized)');
+  if (rbAvailable) {
+    console.log('   Location: .swarm/memory.db');
+    console.log('   Features: AI-powered semantic search, learning');
+  } else {
+    console.log('   To enable: memory init --reasoningbank');
+  }
+
+  console.log('\n💡 Usage:');
+  console.log('   Basic: memory store key "value"');
+  console.log('   ReasoningBank: memory store key "value" --reasoningbank');
+  console.log('   Auto-detect: memory query search --auto');
+}
+
+// NEW: Check if basic mode is available
+async function checkBasicMode() {
+  try {
+    const memoryDir = './memory';
+    await fs.access(memoryDir);
+    return true;
+  } catch {
+    // Create directory if it doesn't exist
+    try {
+      await fs.mkdir(memoryDir, { recursive: true });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+}
+
+// NEW: Show current default mode
+async function showCurrentMode() {
+  const rbInitialized = await isReasoningBankInitialized();
+
+  printInfo('📊 Current Memory Configuration:\n');
+  console.log('Default Mode: Basic (backward compatible)');
+  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');
+}
+
+// NEW: Migrate memory between modes
+async function migrateMemory(subArgs, flags) {
+  const targetMode = flags?.to || getArgValue(subArgs, '--to');
+
+  if (!targetMode || !['basic', 'reasoningbank'].includes(targetMode)) {
+    printError('Usage: memory migrate --to <basic|reasoningbank>');
+    return;
+  }
+
+  printInfo(`🔄 Migrating to ${targetMode} mode...\n`);
+
+  if (targetMode === 'reasoningbank') {
+    // Migrate basic → ReasoningBank
+    const rbInitialized = await isReasoningBankInitialized();
+    if (!rbInitialized) {
+      printError('❌ ReasoningBank not initialized');
+      console.log('First run: memory init --reasoningbank\n');
+      return;
+    }
+
+    printWarning('⚠️  Migration from basic to ReasoningBank is not yet implemented');
+    console.log('This feature is coming in v2.7.1\n');
+    console.log('For now, you can:');
+    console.log('  1. Export basic memory: memory export backup.json');
+    console.log('  2. Manually import to ReasoningBank');
+  } else {
+    // Migrate ReasoningBank → basic
+    printWarning('⚠️  Migration from ReasoningBank to basic is not yet implemented');
+    console.log('This feature is coming in v2.7.1\n');
+  }
+}
+
+// Helper to get argument value
+function getArgValue(args, flag) {
+  const index = args.indexOf(flag);
+  if (index !== -1 && index + 1 < args.length) {
+    return args[index + 1];
+  }
+  return null;
+}
+
 function showMemoryHelp() {
   console.log('Memory commands:');
   console.log('  store <key> <value>    Store a key-value pair');
@@ -332,14 +641,52 @@ function showMemoryHelp() {
   console.log('  clear --namespace <ns> Clear a namespace');
   console.log('  list                   List all namespaces');
   console.log();
+  console.log('🧠 ReasoningBank Commands (NEW in v2.7.0):');
+  console.log('  init --reasoningbank   Initialize ReasoningBank (AI-powered memory)');
+  console.log('  status --reasoningbank Show ReasoningBank statistics');
+  console.log('  detect                 Show available memory modes');
+  console.log('  mode                   Show current memory configuration');
+  console.log('  migrate --to <mode>    Migrate between basic/reasoningbank');
+  console.log();
   console.log('Options:');
   console.log('  --namespace <ns>       Specify namespace for operations');
   console.log('  --ns <ns>              Short form of --namespace');
+  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();
+  console.log('🔒 Security Features (v2.6.0):');
+  console.log('  API Key Protection:    Automatically detects and redacts sensitive data');
+  console.log('  Patterns Detected:     Anthropic, OpenRouter, Gemini, Bearer tokens, etc.');
+  console.log('  Auto-Validation:       Warns when storing unredacted sensitive data');
+  console.log('  Display Redaction:     Redact sensitive data when querying with --redact');
   console.log();
   console.log('Examples:');
+  console.log('  # Basic mode (default - backward compatible)');
   console.log('  memory store previous_work "Research findings from yesterday"');
+  console.log('  memory store api_config "key=sk-ant-..." --redact  # 🔒 Redacts API key');
   console.log('  memory query research --namespace sparc');
-  console.log('  memory export backup.json --namespace default');
-  console.log('  memory import project-memory.json');
-  console.log('  memory stats');
+  console.log();
+  console.log('  # ReasoningBank mode (AI-powered, opt-in)');
+  console.log('  memory init --reasoningbank  # One-time setup');
+  console.log('  memory store api_pattern "Always use env vars" --reasoningbank');
+  console.log('  memory query "API configuration" --reasoningbank  # Semantic search!');
+  console.log('  memory status --reasoningbank  # Show AI metrics');
+  console.log();
+  console.log('  # Auto-detect mode (smart selection)');
+  console.log('  memory query config --auto  # Uses ReasoningBank if available');
+  console.log();
+  console.log('  # Mode management');
+  console.log('  memory detect  # Show available modes');
+  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('  • Always use --redact when storing API keys or secrets!');
 }