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

package/src/mcp/claude-code-wrapper.ts

@@ -1,5 +1,4 @@
 #!/usr/bin/env node
-import { getErrorMessage } from '../utils/error-handler.js';
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import {
@@ -56,14 +55,17 @@ export class ClaudeCodeMCPWrapper {
   private claudeCodeMCP: any; // Reference to Claude Code MCP client
 
   constructor() {
-    this.server = new Server({
-      name: 'claude-flow-wrapper',
-      version: '1.0.0',
-    }, {
-      capabilities: {
-        tools: {},
+    this.server = new Server(
+      {
+        name: 'claude-flow-wrapper',
+        version: '1.0.0',
       },
-    });
+      {
+        capabilities: {
+          tools: {},
+        },
+      },
+    );
 
     this.setupHandlers();
     this.loadSparcModes();
@@ -72,7 +74,7 @@ export class ClaudeCodeMCPWrapper {
   private async loadSparcModes() {
     try {
       const modes = await loadSparcModes();
-      modes.forEach(mode => {
+      modes.forEach((mode) => {
         this.sparcModes.set(mode.name, mode);
       });
     } catch (error) {
@@ -85,8 +87,8 @@ export class ClaudeCodeMCPWrapper {
       tools: await this.getTools(),
     }));
 
-    this.server.setRequestHandler(CallToolRequestSchema, async (request) => 
-      this.handleToolCall(request.params.name, request.params.arguments || {})
+    this.server.setRequestHandler(CallToolRequestSchema, async (request) =>
+      this.handleToolCall(request.params.name, request.params.arguments || {}),
     );
   }
 
@@ -152,7 +154,14 @@ export class ClaudeCodeMCPWrapper {
             },
             strategy: {
               type: 'string',
-              enum: ['research', 'development', 'analysis', 'testing', 'optimization', 'maintenance'],
+              enum: [
+                'research',
+                'development',
+                'analysis',
+                'testing',
+                'optimization',
+                'maintenance',
+              ],
               description: 'Swarm execution strategy',
             },
             mode: {
@@ -181,7 +190,7 @@ export class ClaudeCodeMCPWrapper {
             },
           },
         },
-      }
+      },
     );
 
     return tools;
@@ -192,15 +201,17 @@ export class ClaudeCodeMCPWrapper {
       if (toolName.startsWith('sparc_')) {
         return await this.handleSparcTool(toolName, args);
       }
-      
+
       // Pass through to Claude Code MCP
       return this.forwardToClaudeCode(toolName, args);
     } catch (error) {
       return {
-        content: [{
-          type: 'text',
-          text: `Error: ${error instanceof Error ? error.message : String(error)}`,
-        }],
+        content: [
+          {
+            type: 'text',
+            text: `Error: ${error instanceof Error ? error.message : String(error)}`,
+          },
+        ],
         isError: true,
       };
     }
@@ -234,26 +245,30 @@ export class ClaudeCodeMCPWrapper {
       const executeSparcMode = (mode: string, task: string, tools: any[], context: any) => {
         throw new Error('SPARC mode execution not yet implemented in wrapper');
       };
-      
+
       const result = await executeSparcMode(
         mode,
         args.task,
         sparcMode.tools || [],
-        args.context || {}
+        args.context || {},
       );
-      
+
       return {
-        content: [{
-          type: 'text',
-          text: result.output,
-        }],
+        content: [
+          {
+            type: 'text',
+            text: result.output,
+          },
+        ],
       };
     } catch (error) {
       return {
-        content: [{
-          type: 'text',
-          text: `Error executing SPARC ${mode}: ${error instanceof Error ? error.message : String(error)}`,
-        }],
+        content: [
+          {
+            type: 'text',
+            text: `Error executing SPARC ${mode}: ${error instanceof Error ? error.message : String(error)}`,
+          },
+        ],
         isError: true,
       };
     }
@@ -269,7 +284,7 @@ export class ClaudeCodeMCPWrapper {
     // Add available tools
     if (mode.tools && mode.tools.length > 0) {
       parts.push(`## Available Tools`);
-      mode.tools.forEach(tool => {
+      mode.tools.forEach((tool) => {
         parts.push(`- **${tool}**: ${this.getToolDescription(tool)}`);
       });
       parts.push('');
@@ -283,7 +298,7 @@ export class ClaudeCodeMCPWrapper {
     // Add best practices
     if (mode.bestPractices) {
       parts.push(`## Best Practices`);
-      mode.bestPractices.forEach(practice => {
+      mode.bestPractices.forEach((practice) => {
         parts.push(`- ${practice}`);
       });
       parts.push('');
@@ -292,7 +307,7 @@ export class ClaudeCodeMCPWrapper {
     // Add integration capabilities
     if (mode.integrationCapabilities) {
       parts.push(`## Integration Capabilities\nThis mode integrates with:`);
-      mode.integrationCapabilities.forEach(capability => {
+      mode.integrationCapabilities.forEach((capability) => {
         parts.push(`- ${capability}`);
       });
       parts.push('');
@@ -327,19 +342,19 @@ export class ClaudeCodeMCPWrapper {
 
   private getToolDescription(tool: string): string {
     const descriptions: Record<string, string> = {
-      'TodoWrite': 'Create and manage task coordination',
-      'TodoRead': 'Monitor task progress and status',
-      'Task': 'Spawn and manage specialized agents',
-      'Memory': 'Store and retrieve coordination data',
-      'Bash': 'Execute system commands',
-      'Read': 'Read file contents',
-      'Write': 'Write files',
-      'Edit': 'Edit existing files',
-      'MultiEdit': 'Make multiple edits to a file',
-      'Glob': 'Search for files by pattern',
-      'Grep': 'Search file contents',
-      'WebSearch': 'Search the web',
-      'WebFetch': 'Fetch web content',
+      TodoWrite: 'Create and manage task coordination',
+      TodoRead: 'Monitor task progress and status',
+      Task: 'Spawn and manage specialized agents',
+      Memory: 'Store and retrieve coordination data',
+      Bash: 'Execute system commands',
+      Read: 'Read file contents',
+      Write: 'Write files',
+      Edit: 'Edit existing files',
+      MultiEdit: 'Make multiple edits to a file',
+      Glob: 'Search for files by pattern',
+      Grep: 'Search file contents',
+      WebSearch: 'Search the web',
+      WebFetch: 'Fetch web content',
     };
     return descriptions[tool] || `${tool} tool`;
   }
@@ -443,67 +458,71 @@ Use the appropriate tools for each phase and maintain progress in TodoWrite.`;
 
   private getModeSpecificArchitecture(mode: string): string {
     const architectures: Record<string, string> = {
-      'orchestrator': 'Design for parallel agent coordination with clear task boundaries',
-      'coder': 'Focus on clean code architecture with proper abstractions',
-      'researcher': 'Structure for data collection and analysis pipelines',
-      'tdd': 'Test-first design with comprehensive test coverage',
-      'architect': 'System-wide design patterns and component interactions',
-      'reviewer': 'Code quality gates and review checkpoints',
-      'debugger': 'Diagnostic and monitoring integration points',
-      'tester': 'Test framework integration and coverage analysis',
+      orchestrator: 'Design for parallel agent coordination with clear task boundaries',
+      coder: 'Focus on clean code architecture with proper abstractions',
+      researcher: 'Structure for data collection and analysis pipelines',
+      tdd: 'Test-first design with comprehensive test coverage',
+      architect: 'System-wide design patterns and component interactions',
+      reviewer: 'Code quality gates and review checkpoints',
+      debugger: 'Diagnostic and monitoring integration points',
+      tester: 'Test framework integration and coverage analysis',
     };
     return architectures[mode] || 'Design for the specific mode requirements';
   }
 
   private getModeStrategy(mode: string): string {
     const strategies: Record<string, string> = {
-      'orchestrator': 'Parallel coordination',
-      'coder': 'Iterative development',
-      'researcher': 'Deep analysis',
-      'tdd': 'Test-driven cycles',
-      'architect': 'System design',
-      'reviewer': 'Quality assurance',
-      'debugger': 'Systematic debugging',
-      'tester': 'Comprehensive validation',
+      orchestrator: 'Parallel coordination',
+      coder: 'Iterative development',
+      researcher: 'Deep analysis',
+      tdd: 'Test-driven cycles',
+      architect: 'System design',
+      reviewer: 'Quality assurance',
+      debugger: 'Systematic debugging',
+      tester: 'Comprehensive validation',
     };
     return strategies[mode] || 'Mode-specific execution';
   }
 
   private listModes(verbose: boolean): CallToolResult {
     const modes = Array.from(this.sparcModes.values());
-    
+
     if (verbose) {
-      const content = modes.map(mode => ({
+      const content = modes.map((mode) => ({
         name: mode.name,
         description: mode.description,
         tools: mode.tools,
         bestPractices: mode.bestPractices,
       }));
-      
+
       return {
-        content: [{
-          type: 'text',
-          text: JSON.stringify(content, null, 2),
-        }],
+        content: [
+          {
+            type: 'text',
+            text: JSON.stringify(content, null, 2),
+          },
+        ],
       };
     }
 
-    const list = modes.map(m => `- **${m.name}**: ${m.description}`).join('\n');
+    const list = modes.map((m) => `- **${m.name}**: ${m.description}`).join('\n');
     return {
-      content: [{
-        type: 'text',
-        text: `Available SPARC modes:\n\n${list}`,
-      }],
+      content: [
+        {
+          type: 'text',
+          text: `Available SPARC modes:\n\n${list}`,
+        },
+      ],
     };
   }
 
   private async handleSwarm(args: any): Promise<CallToolResult> {
     const { objective, strategy, mode = 'distributed', maxAgents = 5 } = args;
     const swarmId = generateId();
-    
+
     // Plan swarm agents
     const agents = this.planSwarmAgents(objective, strategy, maxAgents);
-    
+
     // Create swarm execution record
     const execution: SwarmExecution = {
       id: swarmId,
@@ -514,98 +533,174 @@ Use the appropriate tools for each phase and maintain progress in TodoWrite.`;
       startTime: new Date(),
       status: 'active',
     };
-    
+
     this.swarmExecutions.set(swarmId, execution);
-    
+
     // Launch agents based on coordination mode
     if (mode === 'distributed' || mode === 'mesh') {
       // Parallel execution
-      await Promise.all(agents.map(agent => this.launchSwarmAgent(agent, execution)));
+      await Promise.all(agents.map((agent) => this.launchSwarmAgent(agent, execution)));
     } else {
       // Sequential execution
       for (const agent of agents) {
         await this.launchSwarmAgent(agent, execution);
       }
     }
-    
+
     execution.status = 'completed';
     execution.endTime = new Date();
-    
+
     return {
-      content: [{
-        type: 'text',
-        text: JSON.stringify({
-          swarmId,
-          objective,
-          strategy,
-          mode,
-          agentCount: agents.length,
-          status: 'launched',
-          message: 'Swarm coordination initiated',
-        }, null, 2),
-      }],
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify(
+            {
+              swarmId,
+              objective,
+              strategy,
+              mode,
+              agentCount: agents.length,
+              status: 'launched',
+              message: 'Swarm coordination initiated',
+            },
+            null,
+            2,
+          ),
+        },
+      ],
     };
   }
 
   private planSwarmAgents(objective: string, strategy: string, maxAgents: number): SwarmAgent[] {
     const agents: SwarmAgent[] = [];
-    
+
     // Strategy-based agent planning
     switch (strategy) {
       case 'research':
         agents.push(
-          { id: generateId(), mode: 'researcher', task: `Research: ${objective}`, status: 'pending' },
-          { id: generateId(), mode: 'analyst', task: `Analyze findings for: ${objective}`, status: 'pending' },
-          { id: generateId(), mode: 'documenter', task: `Document research results: ${objective}`, status: 'pending' }
+          {
+            id: generateId(),
+            mode: 'researcher',
+            task: `Research: ${objective}`,
+            status: 'pending',
+          },
+          {
+            id: generateId(),
+            mode: 'analyst',
+            task: `Analyze findings for: ${objective}`,
+            status: 'pending',
+          },
+          {
+            id: generateId(),
+            mode: 'documenter',
+            task: `Document research results: ${objective}`,
+            status: 'pending',
+          },
         );
         break;
-        
+
       case 'development':
         agents.push(
-          { id: generateId(), mode: 'architect', task: `Design architecture: ${objective}`, status: 'pending' },
+          {
+            id: generateId(),
+            mode: 'architect',
+            task: `Design architecture: ${objective}`,
+            status: 'pending',
+          },
           { id: generateId(), mode: 'coder', task: `Implement: ${objective}`, status: 'pending' },
-          { id: generateId(), mode: 'tester', task: `Test implementation: ${objective}`, status: 'pending' },
-          { id: generateId(), mode: 'reviewer', task: `Review code: ${objective}`, status: 'pending' }
+          {
+            id: generateId(),
+            mode: 'tester',
+            task: `Test implementation: ${objective}`,
+            status: 'pending',
+          },
+          {
+            id: generateId(),
+            mode: 'reviewer',
+            task: `Review code: ${objective}`,
+            status: 'pending',
+          },
         );
         break;
-        
+
       case 'analysis':
         agents.push(
           { id: generateId(), mode: 'analyst', task: `Analyze: ${objective}`, status: 'pending' },
-          { id: generateId(), mode: 'optimizer', task: `Optimize based on analysis: ${objective}`, status: 'pending' }
+          {
+            id: generateId(),
+            mode: 'optimizer',
+            task: `Optimize based on analysis: ${objective}`,
+            status: 'pending',
+          },
         );
         break;
-        
+
       case 'testing':
         agents.push(
-          { id: generateId(), mode: 'tester', task: `Create test suite: ${objective}`, status: 'pending' },
-          { id: generateId(), mode: 'debugger', task: `Debug issues: ${objective}`, status: 'pending' }
+          {
+            id: generateId(),
+            mode: 'tester',
+            task: `Create test suite: ${objective}`,
+            status: 'pending',
+          },
+          {
+            id: generateId(),
+            mode: 'debugger',
+            task: `Debug issues: ${objective}`,
+            status: 'pending',
+          },
         );
         break;
-        
+
       case 'optimization':
         agents.push(
-          { id: generateId(), mode: 'analyst', task: `Performance analysis: ${objective}`, status: 'pending' },
-          { id: generateId(), mode: 'optimizer', task: `Optimize: ${objective}`, status: 'pending' }
+          {
+            id: generateId(),
+            mode: 'analyst',
+            task: `Performance analysis: ${objective}`,
+            status: 'pending',
+          },
+          {
+            id: generateId(),
+            mode: 'optimizer',
+            task: `Optimize: ${objective}`,
+            status: 'pending',
+          },
         );
         break;
-        
+
       case 'maintenance':
         agents.push(
-          { id: generateId(), mode: 'reviewer', task: `Code review: ${objective}`, status: 'pending' },
-          { id: generateId(), mode: 'debugger', task: `Fix issues: ${objective}`, status: 'pending' },
-          { id: generateId(), mode: 'documenter', task: `Update documentation: ${objective}`, status: 'pending' }
+          {
+            id: generateId(),
+            mode: 'reviewer',
+            task: `Code review: ${objective}`,
+            status: 'pending',
+          },
+          {
+            id: generateId(),
+            mode: 'debugger',
+            task: `Fix issues: ${objective}`,
+            status: 'pending',
+          },
+          {
+            id: generateId(),
+            mode: 'documenter',
+            task: `Update documentation: ${objective}`,
+            status: 'pending',
+          },
         );
         break;
     }
-    
+
     // Limit to maxAgents
     return agents.slice(0, maxAgents);
   }
 
   private async launchSwarmAgent(agent: SwarmAgent, execution: SwarmExecution): Promise<void> {
     agent.status = 'active';
-    
+
     try {
       // Use the SPARC mode handler
       const result = await this.handleSparcTool(`sparc_${agent.mode}`, {
@@ -615,7 +710,7 @@ Use the appropriate tools for each phase and maintain progress in TodoWrite.`;
           parallel: execution.mode === 'distributed',
         },
       });
-      
+
       agent.status = 'completed';
       agent.result = result;
     } catch (error) {
@@ -629,23 +724,27 @@ Use the appropriate tools for each phase and maintain progress in TodoWrite.`;
       const execution = this.swarmExecutions.get(swarmId);
       if (!execution) {
         return {
-          content: [{
-            type: 'text',
-            text: `No swarm found with ID: ${swarmId}`,
-          }],
+          content: [
+            {
+              type: 'text',
+              text: `No swarm found with ID: ${swarmId}`,
+            },
+          ],
         };
       }
-      
+
       return {
-        content: [{
-          type: 'text',
-          text: JSON.stringify(execution, null, 2),
-        }],
+        content: [
+          {
+            type: 'text',
+            text: JSON.stringify(execution, null, 2),
+          },
+        ],
       };
     }
-    
+
     // Return all swarms
-    const swarms = Array.from(this.swarmExecutions.values()).map(e => ({
+    const swarms = Array.from(this.swarmExecutions.values()).map((e) => ({
       id: e.id,
       objective: e.objective,
       status: e.status,
@@ -653,19 +752,21 @@ Use the appropriate tools for each phase and maintain progress in TodoWrite.`;
       startTime: e.startTime,
       endTime: e.endTime,
     }));
-    
+
     return {
-      content: [{
-        type: 'text',
-        text: JSON.stringify(swarms, null, 2),
-      }],
+      content: [
+        {
+          type: 'text',
+          text: JSON.stringify(swarms, null, 2),
+        },
+      ],
     };
   }
 
   private async forwardToClaudeCode(toolName: string, args: any): Promise<CallToolResult> {
     // For SPARC tools that were already handled, this shouldn't be called
     // For other tools, we execute them using the existing logic
-    
+
     if (toolName === 'Task') {
       // This is a SPARC task that's been enhanced with prompts
       // Extract the mode from the description if possible
@@ -680,48 +781,54 @@ Use the appropriate tools for each phase and maintain progress in TodoWrite.`;
               modeName,
               args.prompt || '',
               mode.tools || [],
-              {}
+              {},
             );
-            
+
             return {
-              content: [{
-                type: 'text',
-                text: result.output,
-              }],
+              content: [
+                {
+                  type: 'text',
+                  text: result.output,
+                },
+              ],
             };
           } catch (error) {
             return {
-              content: [{
-                type: 'text',
-                text: `Error executing SPARC ${modeName}: ${error instanceof Error ? error.message : String(error)}`,
-              }],
+              content: [
+                {
+                  type: 'text',
+                  text: `Error executing SPARC ${modeName}: ${error instanceof Error ? error.message : String(error)}`,
+                },
+              ],
               isError: true,
             };
           }
         }
       }
     }
-    
+
     // For non-SPARC tools, return a message
     return {
-      content: [{
-        type: 'text',
-        text: `Tool ${toolName} is not available in this MCP server.`,
-      }],
+      content: [
+        {
+          type: 'text',
+          text: `Tool ${toolName} is not available in this MCP server.`,
+        },
+      ],
       isError: true,
     };
   }
 
   async run() {
     const transport = new StdioServerTransport();
-    
+
     // Log startup message
     console.error('🚀 Claude-Flow MCP Server (Wrapper Mode)');
     console.error('📦 Using Claude Code MCP pass-through with SPARC prompt injection');
     console.error('🔧 All SPARC tools available with enhanced AI capabilities');
     console.error('ℹ️  To use legacy mode, set CLAUDE_FLOW_LEGACY_MCP=true');
     console.error('');
-    
+
     await this.server.connect(transport);
   }
 }
@@ -730,4 +837,4 @@ Use the appropriate tools for each phase and maintain progress in TodoWrite.`;
 if (import.meta.url === `file://${process.argv[1]}`) {
   const wrapper = new ClaudeCodeMCPWrapper();
   wrapper.run().catch(console.error);
-}
+}