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

package/dist/cli/simple-commands/hive-mind/mcp-wrapper.js

@@ -8,47 +8,107 @@ import { spawn } from 'child_process';
  */
 const MCP_TOOLS = {
     swarm: [
-        'swarm_init', 'agent_spawn', 'task_orchestrate', 'swarm_status',
-        'agent_list', 'agent_metrics', 'swarm_monitor', 'topology_optimize',
-        'load_balance', 'coordination_sync', 'swarm_scale', 'swarm_destroy'
+        'swarm_init',
+        'agent_spawn',
+        'task_orchestrate',
+        'swarm_status',
+        'agent_list',
+        'agent_metrics',
+        'swarm_monitor',
+        'topology_optimize',
+        'load_balance',
+        'coordination_sync',
+        'swarm_scale',
+        'swarm_destroy',
     ],
     neural: [
-        'neural_status', 'neural_train', 'neural_patterns', 'neural_predict',
-        'model_load', 'model_save', 'wasm_optimize', 'inference_run',
-        'pattern_recognize', 'cognitive_analyze', 'learning_adapt',
-        'neural_compress', 'ensemble_create', 'transfer_learn', 'neural_explain'
+        'neural_status',
+        'neural_train',
+        'neural_patterns',
+        'neural_predict',
+        'model_load',
+        'model_save',
+        'wasm_optimize',
+        'inference_run',
+        'pattern_recognize',
+        'cognitive_analyze',
+        'learning_adapt',
+        'neural_compress',
+        'ensemble_create',
+        'transfer_learn',
+        'neural_explain',
     ],
     memory: [
-        'memory_usage', 'memory_search', 'memory_persist', 'memory_namespace',
-        'memory_backup', 'memory_restore', 'memory_compress', 'memory_sync',
-        'cache_manage', 'state_snapshot', 'context_restore', 'memory_analytics'
+        'memory_usage',
+        'memory_search',
+        'memory_persist',
+        'memory_namespace',
+        'memory_backup',
+        'memory_restore',
+        'memory_compress',
+        'memory_sync',
+        'cache_manage',
+        'state_snapshot',
+        'context_restore',
+        'memory_analytics',
     ],
     performance: [
-        'performance_report', 'bottleneck_analyze', 'token_usage', 'benchmark_run',
-        'metrics_collect', 'trend_analysis', 'cost_analysis', 'quality_assess',
-        'error_analysis', 'usage_stats', 'health_check'
+        'performance_report',
+        'bottleneck_analyze',
+        'token_usage',
+        'benchmark_run',
+        'metrics_collect',
+        'trend_analysis',
+        'cost_analysis',
+        'quality_assess',
+        'error_analysis',
+        'usage_stats',
+        'health_check',
     ],
     github: [
-        'github_repo_analyze', 'github_pr_manage', 'github_issue_track',
-        'github_release_coord', 'github_workflow_auto', 'github_code_review',
-        'github_sync_coord', 'github_metrics'
+        'github_repo_analyze',
+        'github_pr_manage',
+        'github_issue_track',
+        'github_release_coord',
+        'github_workflow_auto',
+        'github_code_review',
+        'github_sync_coord',
+        'github_metrics',
     ],
     workflow: [
-        'workflow_create', 'workflow_execute', 'workflow_export', 'automation_setup',
-        'pipeline_create', 'scheduler_manage', 'trigger_setup', 'workflow_template',
-        'batch_process', 'parallel_execute'
+        'workflow_create',
+        'workflow_execute',
+        'workflow_export',
+        'automation_setup',
+        'pipeline_create',
+        'scheduler_manage',
+        'trigger_setup',
+        'workflow_template',
+        'batch_process',
+        'parallel_execute',
     ],
     daa: [
-        'daa_agent_create', 'daa_capability_match', 'daa_resource_alloc',
-        'daa_lifecycle_manage', 'daa_communication', 'daa_consensus',
-        'daa_fault_tolerance', 'daa_optimization'
+        'daa_agent_create',
+        'daa_capability_match',
+        'daa_resource_alloc',
+        'daa_lifecycle_manage',
+        'daa_communication',
+        'daa_consensus',
+        'daa_fault_tolerance',
+        'daa_optimization',
     ],
     system: [
-        'terminal_execute', 'config_manage', 'features_detect', 'security_scan',
-        'backup_create', 'restore_system', 'log_analysis', 'diagnostic_run'
+        'terminal_execute',
+        'config_manage',
+        'features_detect',
+        'security_scan',
+        'backup_create',
+        'restore_system',
+        'log_analysis',
+        'diagnostic_run',
     ],
     sparc: ['sparc_mode'],
-    task: ['task_status', 'task_results']
+    task: ['task_status', 'task_results'],
 };
 /**
  * MCPToolWrapper class for unified MCP tool access
@@ -59,7 +119,7 @@ export class MCPToolWrapper {
             parallel: true,
             timeout: 60000,
             retryCount: 3,
-            ...config
+            ...config,
         };
         this.toolStats = new Map();
         this.parallelQueue = [];
@@ -124,7 +184,7 @@ export class MCPToolWrapper {
                 console.error(`Attempt ${attempt} failed for ${toolName}:`, error.message);
                 if (attempt < this.config.retryCount) {
                     // Exponential backoff
-                    await new Promise(resolve => setTimeout(resolve, Math.pow(2, attempt) * 1000));
+                    await new Promise((resolve) => setTimeout(resolve, Math.pow(2, attempt) * 1000));
                 }
             }
         }
@@ -160,7 +220,7 @@ export class MCPToolWrapper {
                 for (let i = 0; i < group.length; i += concurrencyLimit) {
                     const batch = group.slice(i, i + concurrencyLimit);
                     // Execute batch with timeout and retry logic
-                    const batchPromises = batch.map(call => this._executeWithTimeout(call, this.config.timeout));
+                    const batchPromises = batch.map((call) => this._executeWithTimeout(call, this.config.timeout));
                     const batchResults = await Promise.allSettled(batchPromises);
                     // Process results and handle failures
                     for (let j = 0; j < batchResults.length; j++) {
@@ -190,11 +250,11 @@ export class MCPToolWrapper {
      * Calculate optimal concurrency based on tool types
      */
     _calculateOptimalConcurrency(toolCalls) {
-        const toolTypes = toolCalls.map(call => this._getToolCategory(call.tool));
+        const toolTypes = toolCalls.map((call) => this._getToolCategory(call.tool));
         const uniqueTypes = new Set(toolTypes);
         // Heavy operations (neural, github) need lower concurrency
         const heavyTypes = ['neural', 'github', 'workflow'];
-        const hasHeavyOps = toolTypes.some(type => heavyTypes.includes(type));
+        const hasHeavyOps = toolTypes.some((type) => heavyTypes.includes(type));
         if (hasHeavyOps) {
             return Math.min(3, Math.max(1, Math.floor(toolCalls.length / 2)));
         }
@@ -209,9 +269,9 @@ export class MCPToolWrapper {
             critical: [], // swarm_init, swarm_destroy
             high: [], // agent_spawn, memory operations
             medium: [], // task operations, monitoring
-            low: [] // analytics, reporting
+            low: [], // analytics, reporting
         };
-        toolCalls.forEach(call => {
+        toolCalls.forEach((call) => {
             const category = this._getToolCategory(call.tool);
             const tool = call.tool;
             if (['swarm_init', 'swarm_destroy', 'memory_backup'].includes(tool)) {
@@ -228,8 +288,7 @@ export class MCPToolWrapper {
             }
         });
         // Return groups in priority order, filtering empty groups
-        return [priorities.critical, priorities.high, priorities.medium, priorities.low]
-            .filter(group => group.length > 0);
+        return [priorities.critical, priorities.high, priorities.medium, priorities.low].filter((group) => group.length > 0);
     }
     /**
      * Execute tool with timeout wrapper
@@ -240,11 +299,11 @@ export class MCPToolWrapper {
                 reject(new Error(`Tool ${call.tool} timed out after ${timeout}ms`));
             }, timeout);
             this.executeTool(call.tool, call.params)
-                .then(result => {
+                .then((result) => {
                 clearTimeout(timer);
                 resolve(result);
             })
-                .catch(error => {
+                .catch((error) => {
                 clearTimeout(timer);
                 reject(error);
             });
@@ -261,7 +320,7 @@ export class MCPToolWrapper {
                 totalTime: 0,
                 avgConcurrency: 0,
                 avgToolsPerBatch: 0,
-                avgTimePerTool: 0
+                avgTimePerTool: 0,
             };
         }
         this.batchStats.totalBatches++;
@@ -296,7 +355,7 @@ export class MCPToolWrapper {
         // For other tools, use mock responses
         console.log(`Executing MCP tool: mcp__claude-flow__${toolName} with params:`, params);
         // Simulate async execution for non-memory tools
-        await new Promise(resolve => setTimeout(resolve, Math.random() * 500));
+        await new Promise((resolve) => setTimeout(resolve, Math.random() * 500));
         // Mock response based on tool type
         const mockResponse = this._getMockResponse(toolName, params);
         return mockResponse;
@@ -321,28 +380,28 @@ export class MCPToolWrapper {
             swarm_init: {
                 swarmId: `swarm-${Date.now()}`,
                 topology: params.topology || 'hierarchical',
-                status: 'initialized'
+                status: 'initialized',
             },
             agent_spawn: {
                 agentId: `agent-${Date.now()}-${Math.random().toString(36).substring(2, 11)}`,
                 type: params.type,
-                status: 'active'
+                status: 'active',
             },
             task_orchestrate: {
                 taskId: `task-${Date.now()}`,
                 status: 'orchestrated',
-                strategy: params.strategy || 'parallel'
+                strategy: params.strategy || 'parallel',
             },
             memory_usage: {
                 action: params.action,
                 result: params.action === 'store' ? 'stored' : 'retrieved',
-                data: params.value || null
+                data: params.value || null,
             },
             neural_status: {
                 status: 'ready',
                 models: 27,
-                accuracy: 0.848
-            }
+                accuracy: 0.848,
+            },
         };
         return mockResponses[toolName] || { status: 'success', toolName };
     }
@@ -356,7 +415,7 @@ export class MCPToolWrapper {
                 successes: 0,
                 failures: 0,
                 totalDuration: 0,
-                avgDuration: 0
+                avgDuration: 0,
             });
         }
         const stats = this.toolStats.get(toolName);
@@ -386,7 +445,7 @@ export class MCPToolWrapper {
                 totalTime: 0,
                 avgConcurrency: 0,
                 avgToolsPerBatch: 0,
-                avgTimePerTool: 0
+                avgTimePerTool: 0,
             },
             spawn: this.spawnStats || {
                 totalSpawns: 0,
@@ -394,31 +453,29 @@ export class MCPToolWrapper {
                 totalTime: 0,
                 avgTimePerAgent: 0,
                 bestTime: 0,
-                worstTime: 0
+                worstTime: 0,
             },
             performance: {
                 totalCalls: Array.from(this.toolStats.values()).reduce((sum, stat) => sum + stat.calls, 0),
                 successRate: this._calculateOverallSuccessRate(),
                 avgLatency: this._calculateAvgLatency(),
-                throughput: this._calculateThroughput()
-            }
+                throughput: this._calculateThroughput(),
+            },
         };
     }
     /**
      * Calculate overall success rate
      */
     _calculateOverallSuccessRate() {
-        const total = Array.from(this.toolStats.values())
-            .reduce((sum, stat) => sum + stat.calls, 0);
-        const successes = Array.from(this.toolStats.values())
-            .reduce((sum, stat) => sum + stat.successes, 0);
-        return total > 0 ? (successes / total * 100).toFixed(2) : 100;
+        const total = Array.from(this.toolStats.values()).reduce((sum, stat) => sum + stat.calls, 0);
+        const successes = Array.from(this.toolStats.values()).reduce((sum, stat) => sum + stat.successes, 0);
+        return total > 0 ? ((successes / total) * 100).toFixed(2) : 100;
     }
     /**
      * Calculate average latency
      */
     _calculateAvgLatency() {
-        const stats = Array.from(this.toolStats.values()).filter(stat => stat.calls > 0);
+        const stats = Array.from(this.toolStats.values()).filter((stat) => stat.calls > 0);
         if (stats.length === 0)
             return 0;
         const totalLatency = stats.reduce((sum, stat) => sum + stat.avgDuration, 0);
@@ -437,9 +494,9 @@ export class MCPToolWrapper {
      * Create batch of tool calls for parallel execution
      */
     createBatch(calls) {
-        return calls.map(call => ({
+        return calls.map((call) => ({
             tool: call.tool,
-            params: call.params || {}
+            params: call.params || {},
         }));
     }
     /**
@@ -451,24 +508,30 @@ export class MCPToolWrapper {
         try {
             // Phase 1: Critical initialization (sequential)
             const criticalOps = [
-                { tool: 'swarm_init', params: {
+                {
+                    tool: 'swarm_init',
+                    params: {
                         topology: config.topology || 'hierarchical',
                         maxAgents: config.maxAgents || 8,
                         strategy: 'auto',
-                        swarmId
-                    } }
+                        swarmId,
+                    },
+                },
             ];
             const [swarmInitResult] = await this.executeParallel(criticalOps);
             // Phase 2: Supporting services (parallel)
             const supportingOps = [
-                { tool: 'memory_namespace', params: {
+                {
+                    tool: 'memory_namespace',
+                    params: {
                         action: 'create',
                         namespace: swarmId,
-                        maxSize: config.memorySize || 100
-                    } },
+                        maxSize: config.memorySize || 100,
+                    },
+                },
                 { tool: 'neural_status', params: {} },
                 { tool: 'performance_report', params: { format: 'summary' } },
-                { tool: 'features_detect', params: { component: 'swarm' } }
+                { tool: 'features_detect', params: { component: 'swarm' } },
             ];
             const supportingResults = await this.executeParallel(supportingOps);
             // Store initialization metadata
@@ -477,7 +540,7 @@ export class MCPToolWrapper {
                 initTime,
                 topology: config.topology,
                 maxAgents: config.maxAgents,
-                timestamp: Date.now()
+                timestamp: Date.now(),
             }, 'metrics');
             return [swarmInitResult, ...supportingResults];
         }
@@ -500,14 +563,14 @@ export class MCPToolWrapper {
         try {
             // Spawn each group in parallel
             for (const group of groupedTypes) {
-                const batch = group.map(type => ({
+                const batch = group.map((type) => ({
                     tool: 'agent_spawn',
                     params: {
                         type,
                         swarmId,
                         timestamp: Date.now(),
-                        batchId: `batch-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`
-                    }
+                        batchId: `batch-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
+                    },
                 }));
                 const groupResults = await this.executeParallel(batch);
                 allResults.push(...groupResults);
@@ -531,16 +594,16 @@ export class MCPToolWrapper {
             development: ['coder', 'architect', 'reviewer'],
             analysis: ['researcher', 'analyst', 'optimizer'],
             quality: ['tester', 'documenter'],
-            coordination: ['coordinator']
+            coordination: ['coordinator'],
         };
         const result = [];
         const remaining = [...types];
         // Create groups of complementary agents
-        Object.values(groups).forEach(groupTypes => {
-            const groupAgents = remaining.filter(type => groupTypes.includes(type));
+        Object.values(groups).forEach((groupTypes) => {
+            const groupAgents = remaining.filter((type) => groupTypes.includes(type));
             if (groupAgents.length > 0) {
                 result.push(groupAgents);
-                groupAgents.forEach(type => {
+                groupAgents.forEach((type) => {
                     const index = remaining.indexOf(type);
                     if (index > -1)
                         remaining.splice(index, 1);
@@ -548,7 +611,7 @@ export class MCPToolWrapper {
             }
         });
         // Add remaining agents as individual groups
-        remaining.forEach(type => result.push([type]));
+        remaining.forEach((type) => result.push([type]));
         return result;
     }
     /**
@@ -562,7 +625,7 @@ export class MCPToolWrapper {
                 totalTime: 0,
                 avgTimePerAgent: 0,
                 bestTime: Infinity,
-                worstTime: 0
+                worstTime: 0,
             };
         }
         this.spawnStats.totalSpawns++;
@@ -596,7 +659,7 @@ export class MCPToolWrapper {
                     key,
                     type,
                     timestamp,
-                    id: result.lastInsertRowid
+                    id: result.lastInsertRowid,
                 };
             }
             else {
@@ -607,7 +670,7 @@ export class MCPToolWrapper {
                     key,
                     value: valueStr,
                     type,
-                    timestamp
+                    timestamp,
                 });
                 return {
                     success: true,
@@ -615,7 +678,7 @@ export class MCPToolWrapper {
                     namespace: swarmId,
                     key,
                     type,
-                    timestamp
+                    timestamp,
                 };
             }
         }
@@ -642,7 +705,7 @@ export class MCPToolWrapper {
                     try {
                         return {
                             ...row,
-                            value: JSON.parse(row.value)
+                            value: JSON.parse(row.value),
                         };
                     }
                     catch {
@@ -658,7 +721,7 @@ export class MCPToolWrapper {
                     try {
                         return {
                             ...memory,
-                            value: JSON.parse(memory.value)
+                            value: JSON.parse(memory.value),
                         };
                     }
                     catch {
@@ -709,11 +772,11 @@ export class MCPToolWrapper {
                 const stmt = this.memoryDb.prepare(query);
                 results = stmt.all(...params);
                 // Parse JSON values where possible
-                results = results.map(row => {
+                results = results.map((row) => {
                     try {
                         return {
                             ...row,
-                            value: JSON.parse(row.value)
+                            value: JSON.parse(row.value),
                         };
                     }
                     catch {
@@ -732,7 +795,7 @@ export class MCPToolWrapper {
                             try {
                                 results.push({
                                     ...memory,
-                                    value: JSON.parse(memory.value)
+                                    value: JSON.parse(memory.value),
                                 });
                             }
                             catch {
@@ -750,7 +813,7 @@ export class MCPToolWrapper {
                 namespace: swarmId,
                 pattern: pattern || '',
                 total: results.length,
-                results: results
+                results: results,
             };
         }
         catch (error) {
@@ -768,26 +831,36 @@ export class MCPToolWrapper {
         const monitoringInterval = {
             low: 10000,
             medium: 5000,
-            high: 2000
+            high: 2000,
         }[complexity] || 5000;
         const batch = [
-            { tool: 'task_orchestrate', params: {
+            {
+                tool: 'task_orchestrate',
+                params: {
                     task,
                     strategy,
                     taskId,
                     priority: metadata.priority || 5,
-                    estimatedDuration: metadata.estimatedDuration || 30000
-                } },
-            { tool: 'swarm_monitor', params: {
+                    estimatedDuration: metadata.estimatedDuration || 30000,
+                },
+            },
+            {
+                tool: 'swarm_monitor',
+                params: {
                     interval: monitoringInterval,
                     taskId,
-                    metrics: ['performance', 'progress', 'bottlenecks']
-                } },
+                    metrics: ['performance', 'progress', 'bottlenecks'],
+                },
+            },
             // Add performance tracking for high-priority tasks
-            ...(metadata.priority > 7 ? [{
-                    tool: 'performance_report',
-                    params: { format: 'detailed', taskId }
-                }] : [])
+            ...(metadata.priority > 7
+                ? [
+                    {
+                        tool: 'performance_report',
+                        params: { format: 'detailed', taskId },
+                    },
+                ]
+                : []),
         ];
         return await this.executeParallel(batch);
     }
@@ -798,7 +871,7 @@ export class MCPToolWrapper {
         const batch = [
             { tool: 'bottleneck_analyze', params: { component: swarmId } },
             { tool: 'performance_report', params: { format: 'detailed' } },
-            { tool: 'token_usage', params: { operation: swarmId } }
+            { tool: 'token_usage', params: { operation: swarmId } },
         ];
         return await this.executeParallel(batch);
     }
@@ -810,7 +883,7 @@ export class MCPToolWrapper {
             analyze: 'github_repo_analyze',
             pr: 'github_pr_manage',
             issue: 'github_issue_track',
-            review: 'github_code_review'
+            review: 'github_code_review',
         };
         const tool = githubTools[operation];
         if (!tool) {
@@ -826,7 +899,7 @@ export class MCPToolWrapper {
             train: 'neural_train',
             predict: 'neural_predict',
             analyze: 'neural_patterns',
-            optimize: 'wasm_optimize'
+            optimize: 'wasm_optimize',
         };
         const tool = neuralTools[operation];
         if (!tool) {
@@ -840,14 +913,20 @@ export class MCPToolWrapper {
     async destroySwarm(swarmId) {
         const batch = [
             { tool: 'swarm_destroy', params: { swarmId } },
-            { tool: 'memory_namespace', params: {
+            {
+                tool: 'memory_namespace',
+                params: {
                     action: 'delete',
-                    namespace: swarmId
-                } },
-            { tool: 'cache_manage', params: {
+                    namespace: swarmId,
+                },
+            },
+            {
+                tool: 'cache_manage',
+                params: {
                     action: 'clear',
-                    key: `swarm-${swarmId}`
-                } }
+                    key: `swarm-${swarmId}`,
+                },
+            },
         ];
         return await this.executeParallel(batch);
     }