claude-flow/src/hive-mind/integration/MCPToolWrapper.ts

Enterprise-grade AI agent orchestration with ruv-swarm integration (Alpha Release)

/**
 * MCPToolWrapper Class
 *
 * Wraps all MCP tools for use within the Hive Mind system,
 * providing a unified interface for swarm coordination, neural processing,
 * and memory management.
 */

import { EventEmitter } from 'events';
import { exec } from 'child_process';
import { promisify } from 'util';
import { getErrorMessage } from '../../utils/type-guards.js';

const execAsync = promisify(exec);

interface MCPToolResponse {
  success: boolean;
  data?: any;
  error?: string;
}

export class MCPToolWrapper extends EventEmitter {
  private toolPrefix = 'mcp__ruv-swarm__';
  private isInitialized = false;

  constructor() {
    super();
  }

  /**
   * Initialize MCP tools
   */
  async initialize(): Promise<void> {
    try {
      // Check if MCP tools are available
      await this.checkToolAvailability();
      this.isInitialized = true;
      this.emit('initialized');
    } catch (error) {
      this.emit('error', error);
      throw error;
    }
  }

  /**
   * Check if MCP tools are available
   */
  private async checkToolAvailability(): Promise<void> {
    try {
      const { stdout } = await execAsync('npx ruv-swarm --version');
      if (!stdout) {
        throw new Error('ruv-swarm MCP tools not found');
      }
    } catch (error) {
      throw new Error('MCP tools not available. Please ensure ruv-swarm is installed.');
    }
  }

  /**
   * Execute MCP tool via CLI
   */
  private async executeTool(toolName: string, params: any): Promise<MCPToolResponse> {
    try {
      const command = `npx ruv-swarm mcp-execute ${toolName} '${JSON.stringify(params)}'`;
      const { stdout, stderr } = await execAsync(command);

      if (stderr) {
        return { success: false, error: stderr };
      }

      const result = JSON.parse(stdout);
      return { success: true, data: result };
    } catch (error) {
      return { success: false, error: getErrorMessage(error) };
    }
  }

  // Swarm coordination tools

  async initSwarm(params: {
    topology: string;
    maxAgents?: number;
    strategy?: string;
  }): Promise<any> {
    return this.executeTool('swarm_init', params);
  }

  async spawnAgent(params: {
    type: string;
    name?: string;
    swarmId?: string;
    capabilities?: string[];
  }): Promise<any> {
    return this.executeTool('agent_spawn', params);
  }

  async orchestrateTask(params: {
    task: string;
    priority?: string;
    strategy?: string;
    dependencies?: string[];
  }): Promise<any> {
    return this.executeTool('task_orchestrate', params);
  }

  async getSwarmStatus(swarmId?: string): Promise<any> {
    return this.executeTool('swarm_status', { swarmId });
  }

  async monitorSwarm(params: { swarmId?: string; interval?: number }): Promise<any> {
    return this.executeTool('swarm_monitor', params);
  }

  // Neural and pattern tools

  async analyzePattern(params: {
    action: string;
    operation?: string;
    metadata?: any;
  }): Promise<any> {
    return this.executeTool('neural_patterns', params);
  }

  async trainNeural(params: {
    pattern_type: string;
    training_data: string;
    epochs?: number;
  }): Promise<any> {
    return this.executeTool('neural_train', params);
  }

  async predict(params: { modelId: string; input: string }): Promise<any> {
    return this.executeTool('neural_predict', params);
  }

  async getNeuralStatus(modelId?: string): Promise<any> {
    return this.executeTool('neural_status', { modelId });
  }

  // Memory management tools

  async storeMemory(params: {
    action: 'store';
    key: string;
    value: string;
    namespace?: string;
    ttl?: number;
  }): Promise<any> {
    return this.executeTool('memory_usage', params);
  }

  async retrieveMemory(params: {
    action: 'retrieve';
    key: string;
    namespace?: string;
  }): Promise<any> {
    const result = await this.executeTool('memory_usage', params);
    return result.success ? result.data : null;
  }

  async searchMemory(params: {
    pattern: string;
    namespace?: string;
    limit?: number;
  }): Promise<any> {
    return this.executeTool('memory_search', params);
  }

  async deleteMemory(params: { action: 'delete'; key: string; namespace?: string }): Promise<any> {
    return this.executeTool('memory_usage', params);
  }

  async listMemory(params: { action: 'list'; namespace?: string }): Promise<any> {
    return this.executeTool('memory_usage', params);
  }

  // Performance and monitoring tools

  async getPerformanceReport(params?: { format?: string; timeframe?: string }): Promise<any> {
    return this.executeTool('performance_report', params || {});
  }

  async analyzeBottlenecks(params?: { component?: string; metrics?: string[] }): Promise<any> {
    return this.executeTool('bottleneck_analyze', params || {});
  }

  async getTokenUsage(params?: { operation?: string; timeframe?: string }): Promise<any> {
    return this.executeTool('token_usage', params || {});
  }

  // Agent management tools

  async listAgents(swarmId?: string): Promise<any> {
    return this.executeTool('agent_list', { swarmId });
  }

  async getAgentMetrics(agentId: string): Promise<any> {
    return this.executeTool('agent_metrics', { agentId });
  }

  // Task management tools

  async getTaskStatus(taskId: string): Promise<any> {
    return this.executeTool('task_status', { taskId });
  }

  async getTaskResults(taskId: string): Promise<any> {
    return this.executeTool('task_results', { taskId });
  }

  // Advanced coordination tools

  async optimizeTopology(swarmId?: string): Promise<any> {
    return this.executeTool('topology_optimize', { swarmId });
  }

  async loadBalance(params: { swarmId?: string; tasks: any[] }): Promise<any> {
    return this.executeTool('load_balance', params);
  }

  async syncCoordination(swarmId?: string): Promise<any> {
    return this.executeTool('coordination_sync', { swarmId });
  }

  async scaleSwarm(params: { swarmId?: string; targetSize: number }): Promise<any> {
    return this.executeTool('swarm_scale', params);
  }

  // SPARC mode integration

  async runSparcMode(params: {
    mode: string;
    task_description: string;
    options?: any;
  }): Promise<any> {
    return this.executeTool('sparc_mode', params);
  }

  // Workflow tools

  async createWorkflow(params: { name: string; steps: any[]; triggers?: any[] }): Promise<any> {
    return this.executeTool('workflow_create', params);
  }

  async executeWorkflow(params: { workflowId: string; params?: any }): Promise<any> {
    return this.executeTool('workflow_execute', params);
  }

  // GitHub integration tools

  async analyzeRepository(params: { repo: string; analysis_type?: string }): Promise<any> {
    return this.executeTool('github_repo_analyze', params);
  }

  async manageGitHubPR(params: { repo: string; action: string; pr_number?: number }): Promise<any> {
    return this.executeTool('github_pr_manage', params);
  }

  // Dynamic Agent Architecture tools

  async createDynamicAgent(params: {
    agent_type: string;
    capabilities?: string[];
    resources?: any;
  }): Promise<any> {
    return this.executeTool('daa_agent_create', params);
  }

  async matchCapabilities(params: {
    task_requirements: string[];
    available_agents?: any[];
  }): Promise<any> {
    return this.executeTool('daa_capability_match', params);
  }

  // System tools

  async runBenchmark(suite?: string): Promise<any> {
    return this.executeTool('benchmark_run', { suite });
  }

  async collectMetrics(components?: string[]): Promise<any> {
    return this.executeTool('metrics_collect', { components });
  }

  async analyzeTrends(params: { metric: string; period?: string }): Promise<any> {
    return this.executeTool('trend_analysis', params);
  }

  async analyzeCost(timeframe?: string): Promise<any> {
    return this.executeTool('cost_analysis', { timeframe });
  }

  async assessQuality(params: { target: string; criteria?: string[] }): Promise<any> {
    return this.executeTool('quality_assess', params);
  }

  async healthCheck(components?: string[]): Promise<any> {
    return this.executeTool('health_check', { components });
  }

  // Batch operations

  async batchProcess(params: { items: any[]; operation: string }): Promise<any> {
    return this.executeTool('batch_process', params);
  }

  async parallelExecute(tasks: any[]): Promise<any> {
    return this.executeTool('parallel_execute', { tasks });
  }

  /**
   * Generic tool execution for custom tools
   */
  async executeMCPTool(toolName: string, params: any): Promise<any> {
    return this.executeTool(toolName, params);
  }

  /**
   * Helper to format tool responses
   */
  private formatResponse(response: MCPToolResponse): any {
    if (response.success) {
      return response.data;
    } else {
      throw new Error(`MCP Tool Error: ${response.error}`);
    }
  }
}