claude-flow 2.0.0-alpha.61 → 2.0.0-alpha.63

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

@@ -3,32 +3,32 @@ import { printSuccess, printError, printWarning } from '../utils.js';
 
 export async function mcpCommand(subArgs, flags) {
   const mcpCmd = subArgs[0];
-  
+
   switch (mcpCmd) {
     case 'status':
       await showMcpStatus(subArgs, flags);
       break;
-      
+
     case 'start':
       await startMcpServer(subArgs, flags);
       break;
-      
+
     case 'stop':
       await stopMcpServer(subArgs, flags);
       break;
-      
+
     case 'tools':
       await listMcpTools(subArgs, flags);
       break;
-      
+
     case 'auth':
       await manageMcpAuth(subArgs, flags);
       break;
-      
+
     case 'config':
       await showMcpConfig(subArgs, flags);
       break;
-      
+
     default:
       showMcpHelp();
   }
@@ -47,11 +47,11 @@ async function startMcpServer(subArgs, flags) {
   const autoOrchestrator = subArgs.includes('--auto-orchestrator') || flags.autoOrchestrator;
   const daemon = subArgs.includes('--daemon') || flags.daemon;
   const stdio = subArgs.includes('--stdio') || flags.stdio || true; // Default to stdio mode
-  
+
   if (stdio) {
     // Start MCP server in stdio mode (like ruv-swarm)
     printSuccess('Starting Claude Flow MCP server in stdio mode...');
-    
+
     if (autoOrchestrator) {
       console.log('🚀 Auto-starting orchestrator...');
       console.log('🧠 Neural network capabilities: ENABLED');
@@ -59,17 +59,17 @@ async function startMcpServer(subArgs, flags) {
       console.log('📊 Performance monitoring: ENABLED');
       console.log('🐝 Swarm coordination: READY');
     }
-    
+
     // Import and start the MCP server
     try {
       const { fileURLToPath } = await import('url');
       const path = await import('path');
       const { spawn } = await import('child_process');
-      
+
       const __filename = fileURLToPath(import.meta.url);
       const __dirname = path.dirname(__filename);
       const mcpServerPath = path.join(__dirname, '../../mcp/mcp-server.js');
-      
+
       // Check if the file exists, and log the path for debugging
       const fs = await import('fs');
       if (!fs.existsSync(mcpServerPath)) {
@@ -78,7 +78,7 @@ async function startMcpServer(subArgs, flags) {
         console.error(`Script directory: ${__dirname}`);
         throw new Error(`MCP server file not found: ${mcpServerPath}`);
       }
-      
+
       // Start the MCP server process
       const serverProcess = spawn('node', [mcpServerPath], {
         stdio: 'inherit',
@@ -86,22 +86,21 @@ async function startMcpServer(subArgs, flags) {
           ...process.env,
           CLAUDE_FLOW_AUTO_ORCHESTRATOR: autoOrchestrator ? 'true' : 'false',
           CLAUDE_FLOW_NEURAL_ENABLED: 'true',
-          CLAUDE_FLOW_WASM_ENABLED: 'true'
-        }
+          CLAUDE_FLOW_WASM_ENABLED: 'true',
+        },
       });
-      
+
       serverProcess.on('exit', (code) => {
         if (code !== 0) {
           console.error(`MCP server exited with code ${code}`);
         }
       });
-      
+
       // Keep the process alive
       await new Promise(() => {}); // Never resolves, keeps server running
-      
     } catch (error) {
       console.error('Failed to start MCP server:', error.message);
-      
+
       // Fallback to status display
       console.log('🚀 MCP server would start with:');
       console.log('   Protocol: stdio');
@@ -113,7 +112,7 @@ async function startMcpServer(subArgs, flags) {
     // HTTP mode (for future implementation)
     const port = getFlag(subArgs, '--port') || flags.port || 3000;
     const host = getFlag(subArgs, '--host') || flags.host || 'localhost';
-    
+
     printSuccess(`Starting Claude Flow MCP server on ${host}:${port}...`);
     console.log('🚀 HTTP mode not yet implemented, use --stdio for full functionality');
   }
@@ -129,9 +128,9 @@ async function stopMcpServer(subArgs, flags) {
 async function listMcpTools(subArgs, flags) {
   const verbose = subArgs.includes('--verbose') || subArgs.includes('-v') || flags.verbose;
   const category = getFlag(subArgs, '--category') || flags.category;
-  
+
   printSuccess('Claude-Flow MCP Tools & Resources (87 total):');
-  
+
   if (!category || category === 'swarm') {
     console.log('\n🐝 SWARM COORDINATION (12 tools):');
     console.log('  • swarm_init            Initialize swarm with topology');
@@ -147,7 +146,7 @@ async function listMcpTools(subArgs, flags) {
     console.log('  • swarm_scale           Auto-scale agent count');
     console.log('  • swarm_destroy         Gracefully shutdown swarm');
   }
-  
+
   if (!category || category === 'neural') {
     console.log('\n🧠 NEURAL NETWORKS & AI (15 tools):');
     console.log('  • neural_status         Check neural network status');
@@ -166,7 +165,7 @@ async function listMcpTools(subArgs, flags) {
     console.log('  • transfer_learn        Transfer learning');
     console.log('  • neural_explain        AI explainability');
   }
-  
+
   if (!category || category === 'memory') {
     console.log('\n💾 MEMORY & PERSISTENCE (12 tools):');
     console.log('  • memory_usage          Store/retrieve persistent data');
@@ -182,7 +181,7 @@ async function listMcpTools(subArgs, flags) {
     console.log('  • context_restore       Restore execution context');
     console.log('  • memory_analytics      Analyze memory usage');
   }
-  
+
   if (!category || category === 'analysis') {
     console.log('\n📊 ANALYSIS & MONITORING (13 tools):');
     console.log('  • task_status           Check task execution status');
@@ -199,7 +198,7 @@ async function listMcpTools(subArgs, flags) {
     console.log('  • usage_stats           Usage statistics');
     console.log('  • health_check          System health monitoring');
   }
-  
+
   if (!category || category === 'workflow') {
     console.log('\n🔧 WORKFLOW & AUTOMATION (11 tools):');
     console.log('  • workflow_create       Create custom workflows');
@@ -214,7 +213,7 @@ async function listMcpTools(subArgs, flags) {
     console.log('  • batch_process         Batch processing');
     console.log('  • parallel_execute      Execute tasks in parallel');
   }
-  
+
   if (!category || category === 'github') {
     console.log('\n🐙 GITHUB INTEGRATION (8 tools):');
     console.log('  • github_repo_analyze   Repository analysis');
@@ -226,7 +225,7 @@ async function listMcpTools(subArgs, flags) {
     console.log('  • github_sync_coord     Multi-repo sync coordination');
     console.log('  • github_metrics        Repository metrics');
   }
-  
+
   if (!category || category === 'daa') {
     console.log('\n🤖 DAA (Dynamic Agent Architecture) (8 tools):');
     console.log('  • daa_agent_create      Create dynamic agents');
@@ -238,7 +237,7 @@ async function listMcpTools(subArgs, flags) {
     console.log('  • daa_fault_tolerance   Fault tolerance & recovery');
     console.log('  • daa_optimization      Performance optimization');
   }
-  
+
   if (!category || category === 'system') {
     console.log('\n⚙️ SYSTEM & UTILITIES (8 tools):');
     console.log('  • terminal_execute      Execute terminal commands');
@@ -250,23 +249,29 @@ async function listMcpTools(subArgs, flags) {
     console.log('  • log_analysis          Log analysis & insights');
     console.log('  • diagnostic_run        System diagnostics');
   }
-  
+
   if (verbose) {
     console.log('\n📋 DETAILED TOOL INFORMATION:');
     console.log('  🔥 HIGH-PRIORITY TOOLS:');
-    console.log('    swarm_init: Initialize coordination with 4 topologies (hierarchical, mesh, ring, star)');
-    console.log('    agent_spawn: 8 agent types (researcher, coder, analyst, architect, tester, coordinator, reviewer, optimizer)');
+    console.log(
+      '    swarm_init: Initialize coordination with 4 topologies (hierarchical, mesh, ring, star)',
+    );
+    console.log(
+      '    agent_spawn: 8 agent types (researcher, coder, analyst, architect, tester, coordinator, reviewer, optimizer)',
+    );
     console.log('    neural_train: Train 27 neural models with WASM SIMD acceleration');
-    console.log('    memory_usage: 5 operations (store, retrieve, list, delete, search) with TTL & namespacing');
+    console.log(
+      '    memory_usage: 5 operations (store, retrieve, list, delete, search) with TTL & namespacing',
+    );
     console.log('    performance_report: Real-time metrics with 24h/7d/30d timeframes');
-    
+
     console.log('\n  ⚡ PERFORMANCE FEATURES:');
     console.log('    • 2.8-4.4x speed improvement with parallel execution');
     console.log('    • 32.3% token reduction through optimization');
     console.log('    • 84.8% SWE-Bench solve rate with swarm coordination');
     console.log('    • WASM neural processing with SIMD optimization');
     console.log('    • Cross-session memory persistence');
-    
+
     console.log('\n  🔗 INTEGRATION CAPABILITIES:');
     console.log('    • Full ruv-swarm feature parity (rebranded)');
     console.log('    • Claude Code native tool integration');
@@ -274,7 +279,7 @@ async function listMcpTools(subArgs, flags) {
     console.log('    • SPARC methodology with 17 modes');
     console.log('    • MCP protocol compatibility');
   }
-  
+
   console.log('\n📡 Status: 87 tools & resources available when server is running');
   console.log('🎯 Categories: swarm, neural, memory, analysis, workflow, github, daa, system');
   console.log('🔗 Compatibility: ruv-swarm + DAA + Claude-Flow unified platform');
@@ -283,7 +288,7 @@ async function listMcpTools(subArgs, flags) {
 
 async function manageMcpAuth(subArgs, flags) {
   const authCmd = subArgs[1];
-  
+
   switch (authCmd) {
     case 'setup':
       printSuccess('Setting up MCP authentication...');
@@ -292,20 +297,20 @@ async function manageMcpAuth(subArgs, flags) {
       console.log('   Scope: Claude-Flow tools');
       console.log('   Security: TLS encrypted');
       break;
-      
+
     case 'status':
       printSuccess('MCP Authentication Status:');
       console.log('🔐 Status: Not configured');
       console.log('🔑 API Keys: 0 active');
       console.log('🛡️  Security: Default settings');
       break;
-      
+
     case 'rotate':
       printSuccess('Rotating MCP authentication keys...');
       console.log('🔄 New API keys would be generated');
       console.log('♻️  Old keys would be deprecated gracefully');
       break;
-      
+
     default:
       console.log('Auth commands: setup, status, rotate');
       console.log('Examples:');
@@ -322,38 +327,38 @@ async function showMcpConfig(subArgs, flags) {
   console.log('   Protocol: HTTP/STDIO');
   console.log('   Timeout: 30000ms');
   console.log('   Auto-Orchestrator: Enabled');
-  
+
   console.log('\n🔧 Tool Configuration:');
   console.log('   Available Tools: 87 total');
   console.log('   Categories: 8 (swarm, neural, memory, analysis, workflow, github, daa, system)');
   console.log('   Authentication: API Key + OAuth');
   console.log('   Rate Limiting: 1000 req/min');
   console.log('   WASM Support: Enabled with SIMD');
-  
+
   console.log('\n🧠 Neural Network Settings:');
   console.log('   Models: 27 pre-trained models available');
   console.log('   Training: Real-time adaptive learning');
   console.log('   Inference: WASM optimized');
   console.log('   Pattern Recognition: Enabled');
-  
+
   console.log('\n🐝 Swarm Configuration:');
   console.log('   Max Agents: 10 per swarm');
   console.log('   Topologies: hierarchical, mesh, ring, star');
   console.log('   Coordination: Real-time with hooks');
   console.log('   Memory: Cross-session persistence');
-  
+
   console.log('\n🔐 Security Settings:');
   console.log('   TLS: Enabled in production');
   console.log('   CORS: Configured for Claude Code');
   console.log('   API Key Rotation: 30 days');
   console.log('   Audit Logging: Enabled');
-  
+
   console.log('\n🔗 Integration Settings:');
   console.log('   ruv-swarm Compatibility: 100%');
   console.log('   DAA Integration: Enabled');
   console.log('   GitHub Actions: Connected');
   console.log('   SPARC Modes: 17 available');
-  
+
   console.log('\n📁 Configuration Files:');
   console.log('   Main Config: ./mcp_config/claude-flow.json');
   console.log('   Neural Models: ./models/');
@@ -386,7 +391,9 @@ function showMcpHelp() {
   console.log('  --enable-wasm                    Enable WASM SIMD optimization');
   console.log();
   console.log('TOOLS OPTIONS:');
-  console.log('  --category <cat>                 Filter by category (swarm, neural, memory, etc.)');
+  console.log(
+    '  --category <cat>                 Filter by category (swarm, neural, memory, etc.)',
+  );
   console.log('  --verbose, -v                    Show detailed tool information');
   console.log('  --examples                       Show usage examples');
   console.log();
@@ -410,4 +417,4 @@ function showMcpHelp() {
   console.log();
   console.log('🎯 Total: 87 tools & resources available');
   console.log('🔗 Full ruv-swarm + DAA + Claude-Flow integration');
-}
+}

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

@@ -5,7 +5,7 @@ import { Deno, cwd, exit, existsSync } from '../node-compat.js';
 export async function memoryCommand(subArgs, flags) {
   const memorySubcommand = subArgs[0];
   const memoryStore = './memory/memory-store.json';
-  
+
   // Helper to load memory data
   async function loadMemory() {
     try {
@@ -15,42 +15,42 @@ export async function memoryCommand(subArgs, flags) {
       return {};
     }
   }
-  
+
   // Helper to save memory data
   async function saveMemory(data) {
     await Deno.mkdir('./memory', { recursive: true });
     await Deno.writeTextFile(memoryStore, JSON.stringify(data, null, 2));
   }
-  
+
   switch (memorySubcommand) {
     case 'store':
       await storeMemory(subArgs, loadMemory, saveMemory);
       break;
-      
+
     case 'query':
       await queryMemory(subArgs, loadMemory);
       break;
-      
+
     case 'stats':
       await showMemoryStats(loadMemory);
       break;
-      
+
     case 'export':
       await exportMemory(subArgs, loadMemory);
       break;
-      
+
     case 'import':
       await importMemory(subArgs, saveMemory);
       break;
-      
+
     case 'clear':
       await clearMemory(subArgs, saveMemory);
       break;
-      
+
     case 'list':
       await listNamespaces(loadMemory);
       break;
-      
+
     default:
       showMemoryHelp();
   }
@@ -59,31 +59,31 @@ export async function memoryCommand(subArgs, flags) {
 async function storeMemory(subArgs, loadMemory, saveMemory) {
   const key = subArgs[1];
   const value = subArgs.slice(2).join(' ');
-  
+
   if (!key || !value) {
     printError('Usage: memory store <key> <value>');
     return;
   }
-  
+
   try {
     const data = await loadMemory();
     const namespace = getNamespaceFromArgs(subArgs) || 'default';
-    
+
     if (!data[namespace]) {
       data[namespace] = [];
     }
-    
+
     // Remove existing entry with same key
-    data[namespace] = data[namespace].filter(e => e.key !== key);
-    
+    data[namespace] = data[namespace].filter((e) => e.key !== key);
+
     // Add new entry
     data[namespace].push({
       key,
       value,
       namespace,
-      timestamp: Date.now()
+      timestamp: Date.now(),
     });
-    
+
     await saveMemory(data);
     printSuccess('Stored successfully');
     console.log(`📝 Key: ${key}`);
@@ -96,44 +96,46 @@ async function storeMemory(subArgs, loadMemory, saveMemory) {
 
 async function queryMemory(subArgs, loadMemory) {
   const search = subArgs.slice(1).join(' ');
-  
+
   if (!search) {
     printError('Usage: memory query <search>');
     return;
   }
-  
+
   try {
     const data = await loadMemory();
     const namespace = getNamespaceFromArgs(subArgs);
     const results = [];
-    
+
     for (const [ns, entries] of Object.entries(data)) {
       if (namespace && ns !== namespace) continue;
-      
+
       for (const entry of entries) {
         if (entry.key.includes(search) || entry.value.includes(search)) {
           results.push(entry);
         }
       }
     }
-    
+
     if (results.length === 0) {
       printWarning('No results found');
       return;
     }
-    
+
     printSuccess(`Found ${results.length} results:`);
-    
+
     // Sort by timestamp (newest first)
     results.sort((a, b) => b.timestamp - a.timestamp);
-    
+
     for (const entry of results.slice(0, 10)) {
       console.log(`\n📌 ${entry.key}`);
       console.log(`   Namespace: ${entry.namespace}`);
-      console.log(`   Value: ${entry.value.substring(0, 100)}${entry.value.length > 100 ? '...' : ''}`);
+      console.log(
+        `   Value: ${entry.value.substring(0, 100)}${entry.value.length > 100 ? '...' : ''}`,
+      );
       console.log(`   Stored: ${new Date(entry.timestamp).toLocaleString()}`);
     }
-    
+
     if (results.length > 10) {
       console.log(`\n... and ${results.length - 10} more results`);
     }
@@ -147,17 +149,19 @@ async function showMemoryStats(loadMemory) {
     const data = await loadMemory();
     let totalEntries = 0;
     const namespaceStats = {};
-    
+
     for (const [namespace, entries] of Object.entries(data)) {
       namespaceStats[namespace] = entries.length;
       totalEntries += entries.length;
     }
-    
+
     printSuccess('Memory Bank Statistics:');
     console.log(`   Total Entries: ${totalEntries}`);
     console.log(`   Namespaces: ${Object.keys(data).length}`);
-    console.log(`   Size: ${(new TextEncoder().encode(JSON.stringify(data)).length / 1024).toFixed(2)} KB`);
-    
+    console.log(
+      `   Size: ${(new TextEncoder().encode(JSON.stringify(data)).length / 1024).toFixed(2)} KB`,
+    );
+
     if (Object.keys(data).length > 0) {
       console.log('\n📁 Namespace Breakdown:');
       for (const [namespace, count] of Object.entries(namespaceStats)) {
@@ -171,24 +175,26 @@ async function showMemoryStats(loadMemory) {
 
 async function exportMemory(subArgs, loadMemory) {
   const filename = subArgs[1] || `memory-export-${Date.now()}.json`;
-  
+
   try {
     const data = await loadMemory();
     const namespace = getNamespaceFromArgs(subArgs);
-    
+
     let exportData = data;
     if (namespace) {
       exportData = { [namespace]: data[namespace] || [] };
     }
-    
+
     await Deno.writeTextFile(filename, JSON.stringify(exportData, null, 2));
     printSuccess(`Memory exported to ${filename}`);
-    
+
     let totalEntries = 0;
     for (const entries of Object.values(exportData)) {
       totalEntries += entries.length;
     }
-    console.log(`📦 Exported ${totalEntries} entries from ${Object.keys(exportData).length} namespace(s)`);
+    console.log(
+      `📦 Exported ${totalEntries} entries from ${Object.keys(exportData).length} namespace(s)`,
+    );
   } catch (err) {
     printError(`Failed to export memory: ${err.message}`);
   }
@@ -196,34 +202,34 @@ async function exportMemory(subArgs, loadMemory) {
 
 async function importMemory(subArgs, saveMemory) {
   const filename = subArgs[1];
-  
+
   if (!filename) {
     printError('Usage: memory import <filename>');
     return;
   }
-  
+
   try {
     const importContent = await Deno.readTextFile(filename);
     const importData = JSON.parse(importContent);
-    
+
     // Load existing memory
     const existingData = await loadMemory();
-    
+
     // Merge imported data
     let totalImported = 0;
     for (const [namespace, entries] of Object.entries(importData)) {
       if (!existingData[namespace]) {
         existingData[namespace] = [];
       }
-      
+
       // Add entries that don't already exist (by key)
-      const existingKeys = new Set(existingData[namespace].map(e => e.key));
-      const newEntries = entries.filter(e => !existingKeys.has(e.key));
-      
+      const existingKeys = new Set(existingData[namespace].map((e) => e.key));
+      const newEntries = entries.filter((e) => !existingKeys.has(e.key));
+
       existingData[namespace].push(...newEntries);
       totalImported += newEntries.length;
     }
-    
+
     await saveMemory(existingData);
     printSuccess(`Imported ${totalImported} new entries from ${filename}`);
   } catch (err) {
@@ -233,24 +239,24 @@ async function importMemory(subArgs, saveMemory) {
 
 async function clearMemory(subArgs, saveMemory) {
   const namespace = getNamespaceFromArgs(subArgs);
-  
+
   if (!namespace) {
     printError('Usage: memory clear --namespace <namespace>');
     printWarning('This will clear all entries in the specified namespace');
     return;
   }
-  
+
   try {
     const data = await loadMemory();
-    
+
     if (!data[namespace]) {
       printWarning(`Namespace '${namespace}' does not exist`);
       return;
     }
-    
+
     const entryCount = data[namespace].length;
     delete data[namespace];
-    
+
     await saveMemory(data);
     printSuccess(`Cleared ${entryCount} entries from namespace '${namespace}'`);
   } catch (err) {
@@ -262,12 +268,12 @@ async function listNamespaces(loadMemory) {
   try {
     const data = await loadMemory();
     const namespaces = Object.keys(data);
-    
+
     if (namespaces.length === 0) {
       printWarning('No namespaces found');
       return;
     }
-    
+
     printSuccess('Available namespaces:');
     for (const namespace of namespaces) {
       const count = data[namespace].length;
@@ -283,12 +289,12 @@ function getNamespaceFromArgs(subArgs) {
   if (namespaceIndex !== -1 && namespaceIndex + 1 < subArgs.length) {
     return subArgs[namespaceIndex + 1];
   }
-  
+
   const nsIndex = subArgs.indexOf('--ns');
   if (nsIndex !== -1 && nsIndex + 1 < subArgs.length) {
     return subArgs[nsIndex + 1];
   }
-  
+
   return null;
 }
 
@@ -322,4 +328,4 @@ function showMemoryHelp() {
   console.log('  memory export backup.json --namespace default');
   console.log('  memory import project-memory.json');
   console.log('  memory stats');
-}
+}