claude-flow-novice 1.0.0

package/dist/src/mcp/ruv-swarm-tools.js

@@ -0,0 +1,671 @@
+/**
+ * ruv-swarm MCP tools wrapper for Claude Code integration
+ *
+ * This module provides MCP tools that integrate with the external ruv-swarm
+ * package to enable advanced swarm coordination and neural capabilities.
+ */ import { execAsync } from '../utils/helpers.js';
+// Import error fixes for agent_metrics, swarm_monitor, neural_train
+let errorFixes;
+try {
+    errorFixes = require('./fixes/mcp-error-fixes.js');
+} catch (e) {
+    // Fallback if module not found
+    errorFixes = {
+        fixAgentMetrics: (d)=>d,
+        fixSwarmMonitor: (d)=>d,
+        fixNeuralTrain: (d)=>d,
+        wrapRuvSwarmResponse: (n, d)=>d
+    };
+}
+/**
+ * Execute ruv-swarm command with proper error handling
+ */ async function executeRuvSwarmCommand(command, args = [], context, logger) {
+    try {
+        const workDir = context?.workingDirectory || process.cwd();
+        const fullCommand = `npx ruv-swarm ${command} ${args.join(' ')}`;
+        logger?.debug('Executing ruv-swarm command', {
+            command: fullCommand,
+            workDir
+        });
+        const result = await execAsync(fullCommand, {
+            cwd: workDir
+        });
+        // Parse JSON response if possible
+        let data;
+        try {
+            data = JSON.parse(result.stdout);
+        } catch  {
+            data = {
+                output: result.stdout,
+                stderr: result.stderr
+            };
+        }
+        logger?.debug('ruv-swarm command completed', {
+            command,
+            success: true
+        });
+        return {
+            success: true,
+            data,
+            metadata: {
+                timestamp: Date.now(),
+                swarmId: context?.swarmId,
+                sessionId: context?.sessionId
+            }
+        };
+    } catch (error) {
+        logger?.error('ruv-swarm command failed', {
+            command,
+            error: error instanceof Error ? error.message : String(error)
+        });
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : String(error),
+            metadata: {
+                timestamp: Date.now(),
+                swarmId: context?.swarmId,
+                sessionId: context?.sessionId
+            }
+        };
+    }
+}
+/**
+ * Create ruv-swarm MCP tools for Claude Code integration
+ *
+ * These tools provide access to the full ruv-swarm functionality including:
+ * - Swarm initialization and management
+ * - Neural agent coordination
+ * - Memory and persistence
+ * - Performance monitoring
+ * - Task orchestration
+ */ export function createRuvSwarmTools(logger) {
+    return [
+        // === SWARM LIFECYCLE TOOLS ===
+        {
+            name: 'mcp__ruv-swarm__swarm_init',
+            description: 'Initialize a new ruv-swarm with specified topology and configuration',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    topology: {
+                        type: 'string',
+                        enum: [
+                            'mesh',
+                            'hierarchical',
+                            'ring',
+                            'star'
+                        ],
+                        description: 'Swarm topology type'
+                    },
+                    maxAgents: {
+                        type: 'number',
+                        minimum: 1,
+                        maximum: 100,
+                        default: 5,
+                        description: 'Maximum number of agents'
+                    },
+                    strategy: {
+                        type: 'string',
+                        enum: [
+                            'balanced',
+                            'specialized',
+                            'adaptive'
+                        ],
+                        default: 'balanced',
+                        description: 'Distribution strategy'
+                    }
+                },
+                required: [
+                    'topology'
+                ]
+            },
+            handler: async (input, context)=>{
+                const args = [
+                    '--topology',
+                    input.topology,
+                    '--max-agents',
+                    String(input.maxAgents || 5),
+                    '--strategy',
+                    input.strategy || 'balanced'
+                ];
+                return await executeRuvSwarmCommand('swarm init', args, context, logger);
+            }
+        },
+        {
+            name: 'mcp__ruv-swarm__swarm_status',
+            description: 'Get current swarm status and agent information',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    verbose: {
+                        type: 'boolean',
+                        default: false,
+                        description: 'Include detailed agent information'
+                    }
+                }
+            },
+            handler: async (input, context)=>{
+                const args = input.verbose ? [
+                    '--verbose'
+                ] : [];
+                return await executeRuvSwarmCommand('swarm status', args, context, logger);
+            }
+        },
+        {
+            name: 'mcp__ruv-swarm__swarm_monitor',
+            description: 'Monitor swarm activity in real-time',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    duration: {
+                        type: 'number',
+                        default: 10,
+                        description: 'Monitoring duration in seconds'
+                    },
+                    interval: {
+                        type: 'number',
+                        default: 1,
+                        description: 'Update interval in seconds'
+                    }
+                }
+            },
+            handler: async (input, context)=>{
+                const args = [
+                    '--duration',
+                    String(input.duration || 10),
+                    '--interval',
+                    String(input.interval || 1)
+                ];
+                const result = await executeRuvSwarmCommand('swarm monitor', args, context, logger);
+                // Apply fix to ensure recentEvents is an array
+                return errorFixes.fixSwarmMonitor(result);
+            }
+        },
+        // === AGENT MANAGEMENT TOOLS ===
+        {
+            name: 'mcp__ruv-swarm__agent_spawn',
+            description: 'Spawn a new agent in the swarm',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    type: {
+                        type: 'string',
+                        enum: [
+                            'coordinator',
+                            'researcher',
+                            'coder',
+                            'analyst',
+                            'architect',
+                            'tester',
+                            'reviewer',
+                            'optimizer',
+                            'documenter',
+                            'monitor',
+                            'specialist'
+                        ],
+                        description: 'Agent type'
+                    },
+                    name: {
+                        type: 'string',
+                        description: 'Custom agent name'
+                    },
+                    capabilities: {
+                        type: 'array',
+                        items: {
+                            type: 'string'
+                        },
+                        description: 'Agent capabilities'
+                    }
+                },
+                required: [
+                    'type'
+                ]
+            },
+            handler: async (input, context)=>{
+                const args = [
+                    '--type',
+                    input.type
+                ];
+                if (input.name) {
+                    args.push('--name', input.name);
+                }
+                if (input.capabilities && input.capabilities.length > 0) {
+                    args.push('--capabilities', input.capabilities.join(','));
+                }
+                return await executeRuvSwarmCommand('agent spawn', args, context, logger);
+            }
+        },
+        {
+            name: 'mcp__ruv-swarm__agent_list',
+            description: 'List all active agents in the swarm',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    filter: {
+                        type: 'string',
+                        enum: [
+                            'all',
+                            'active',
+                            'idle',
+                            'busy'
+                        ],
+                        default: 'all',
+                        description: 'Filter agents by status'
+                    }
+                }
+            },
+            handler: async (input, context)=>{
+                const args = [
+                    '--filter',
+                    input.filter || 'all'
+                ];
+                return await executeRuvSwarmCommand('agent list', args, context, logger);
+            }
+        },
+        {
+            name: 'mcp__ruv-swarm__agent_metrics',
+            description: 'Get performance metrics for agents',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    agentId: {
+                        type: 'string',
+                        description: 'Specific agent ID (optional)'
+                    },
+                    metric: {
+                        type: 'string',
+                        enum: [
+                            'all',
+                            'cpu',
+                            'memory',
+                            'tasks',
+                            'performance'
+                        ],
+                        default: 'all'
+                    }
+                }
+            },
+            handler: async (input, context)=>{
+                const args = [
+                    '--metric',
+                    input.metric || 'all'
+                ];
+                if (input.agentId) {
+                    args.push('--agent-id', input.agentId);
+                }
+                const result = await executeRuvSwarmCommand('agent metrics', args, context, logger);
+                // Apply fix to ensure neuralNetworks is an array
+                return errorFixes.fixAgentMetrics(result);
+            }
+        },
+        // === TASK ORCHESTRATION TOOLS ===
+        {
+            name: 'mcp__ruv-swarm__task_orchestrate',
+            description: 'Orchestrate a task across the swarm',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    task: {
+                        type: 'string',
+                        description: 'Task description or instructions'
+                    },
+                    strategy: {
+                        type: 'string',
+                        enum: [
+                            'parallel',
+                            'sequential',
+                            'adaptive'
+                        ],
+                        default: 'adaptive',
+                        description: 'Execution strategy'
+                    },
+                    priority: {
+                        type: 'string',
+                        enum: [
+                            'low',
+                            'medium',
+                            'high',
+                            'critical'
+                        ],
+                        default: 'medium',
+                        description: 'Task priority'
+                    },
+                    maxAgents: {
+                        type: 'number',
+                        minimum: 1,
+                        maximum: 10,
+                        description: 'Maximum agents to use'
+                    }
+                },
+                required: [
+                    'task'
+                ]
+            },
+            handler: async (input, context)=>{
+                const args = [
+                    '--task',
+                    JSON.stringify(input.task),
+                    '--strategy',
+                    input.strategy || 'adaptive',
+                    '--priority',
+                    input.priority || 'medium'
+                ];
+                if (input.maxAgents) {
+                    args.push('--max-agents', String(input.maxAgents));
+                }
+                return await executeRuvSwarmCommand('task orchestrate', args, context, logger);
+            }
+        },
+        {
+            name: 'mcp__ruv-swarm__task_status',
+            description: 'Check progress of running tasks',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    taskId: {
+                        type: 'string',
+                        description: 'Specific task ID (optional)'
+                    },
+                    detailed: {
+                        type: 'boolean',
+                        default: false,
+                        description: 'Include detailed progress'
+                    }
+                }
+            },
+            handler: async (input, context)=>{
+                const args = [];
+                if (input.taskId) {
+                    args.push('--task-id', input.taskId);
+                }
+                if (input.detailed) {
+                    args.push('--detailed');
+                }
+                return await executeRuvSwarmCommand('task status', args, context, logger);
+            }
+        },
+        {
+            name: 'mcp__ruv-swarm__task_results',
+            description: 'Retrieve results from completed tasks',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    taskId: {
+                        type: 'string',
+                        description: 'Task ID to retrieve results for'
+                    },
+                    format: {
+                        type: 'string',
+                        enum: [
+                            'summary',
+                            'detailed',
+                            'raw'
+                        ],
+                        default: 'summary',
+                        description: 'Result format'
+                    }
+                },
+                required: [
+                    'taskId'
+                ]
+            },
+            handler: async (input, context)=>{
+                const args = [
+                    '--task-id',
+                    input.taskId,
+                    '--format',
+                    input.format || 'summary'
+                ];
+                return await executeRuvSwarmCommand('task results', args, context, logger);
+            }
+        },
+        // === MEMORY AND PERSISTENCE TOOLS ===
+        {
+            name: 'mcp__ruv-swarm__memory_usage',
+            description: 'Get current memory usage statistics',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    detail: {
+                        type: 'string',
+                        enum: [
+                            'summary',
+                            'detailed',
+                            'by-agent'
+                        ],
+                        default: 'summary',
+                        description: 'Detail level'
+                    }
+                }
+            },
+            handler: async (input, context)=>{
+                const args = [
+                    '--detail',
+                    input.detail || 'summary'
+                ];
+                return await executeRuvSwarmCommand('memory usage', args, context, logger);
+            }
+        },
+        // === NEURAL CAPABILITIES TOOLS ===
+        {
+            name: 'mcp__ruv-swarm__neural_status',
+            description: 'Get neural agent status and performance metrics',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    agentId: {
+                        type: 'string',
+                        description: 'Specific agent ID (optional)'
+                    }
+                }
+            },
+            handler: async (input, context)=>{
+                const args = [];
+                if (input.agentId) {
+                    args.push('--agent-id', input.agentId);
+                }
+                return await executeRuvSwarmCommand('neural status', args, context, logger);
+            }
+        },
+        {
+            name: 'mcp__ruv-swarm__neural_train',
+            description: 'Train neural agents with sample tasks',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    agentId: {
+                        type: 'string',
+                        description: 'Specific agent ID to train (optional)'
+                    },
+                    iterations: {
+                        type: 'number',
+                        minimum: 1,
+                        maximum: 100,
+                        default: 10,
+                        description: 'Number of training iterations'
+                    }
+                }
+            },
+            handler: async (input, context)=>{
+                // Apply fix to ensure agentId is valid
+                const fixedInput = errorFixes.fixNeuralTrain(input);
+                const args = [
+                    '--iterations',
+                    String(fixedInput.iterations || 10)
+                ];
+                if (fixedInput.agentId) {
+                    args.push('--agent-id', fixedInput.agentId);
+                }
+                return await executeRuvSwarmCommand('neural train', args, context, logger);
+            }
+        },
+        {
+            name: 'mcp__ruv-swarm__neural_patterns',
+            description: 'Get cognitive pattern information',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    pattern: {
+                        type: 'string',
+                        enum: [
+                            'all',
+                            'convergent',
+                            'divergent',
+                            'lateral',
+                            'systems',
+                            'critical',
+                            'abstract'
+                        ],
+                        default: 'all',
+                        description: 'Cognitive pattern type'
+                    }
+                }
+            },
+            handler: async (input, context)=>{
+                const args = [
+                    '--pattern',
+                    input.pattern || 'all'
+                ];
+                return await executeRuvSwarmCommand('neural patterns', args, context, logger);
+            }
+        },
+        // === PERFORMANCE AND BENCHMARKING TOOLS ===
+        {
+            name: 'mcp__ruv-swarm__benchmark_run',
+            description: 'Execute performance benchmarks',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    type: {
+                        type: 'string',
+                        enum: [
+                            'all',
+                            'wasm',
+                            'swarm',
+                            'agent',
+                            'task'
+                        ],
+                        default: 'all',
+                        description: 'Benchmark type'
+                    },
+                    iterations: {
+                        type: 'number',
+                        minimum: 1,
+                        maximum: 100,
+                        default: 10,
+                        description: 'Number of iterations'
+                    }
+                }
+            },
+            handler: async (input, context)=>{
+                const args = [
+                    '--type',
+                    input.type || 'all',
+                    '--iterations',
+                    String(input.iterations || 10)
+                ];
+                return await executeRuvSwarmCommand('benchmark run', args, context, logger);
+            }
+        },
+        {
+            name: 'mcp__ruv-swarm__features_detect',
+            description: 'Detect runtime features and capabilities',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    category: {
+                        type: 'string',
+                        enum: [
+                            'all',
+                            'wasm',
+                            'simd',
+                            'memory',
+                            'platform'
+                        ],
+                        default: 'all',
+                        description: 'Feature category'
+                    }
+                }
+            },
+            handler: async (input, context)=>{
+                const args = [
+                    '--category',
+                    input.category || 'all'
+                ];
+                return await executeRuvSwarmCommand('features detect', args, context, logger);
+            }
+        }
+    ];
+}
+/**
+ * Check if ruv-swarm is available in the current environment
+ */ export async function isRuvSwarmAvailable(logger) {
+    try {
+        const result = await executeRuvSwarmCommand('--version', [], undefined, logger);
+        return result.success;
+    } catch (error) {
+        logger?.warn('ruv-swarm not available', {
+            error: error instanceof Error ? error instanceof Error ? error.message : String(error) : error
+        });
+        return false;
+    }
+}
+/**
+ * Get ruv-swarm configuration and capabilities
+ */ export async function getRuvSwarmCapabilities(logger) {
+    try {
+        const result = await executeRuvSwarmCommand('features detect', [
+            '--category',
+            'all'
+        ], undefined, logger);
+        return result.data;
+    } catch (error) {
+        logger?.error('Failed to get ruv-swarm capabilities', error);
+        return null;
+    }
+}
+/**
+ * Initialize ruv-swarm with claude-code-flow integration
+ */ export async function initializeRuvSwarmIntegration(workingDirectory, logger) {
+    const context = {
+        workingDirectory,
+        sessionId: `claude-flow-${Date.now()}`
+    };
+    logger?.info('Initializing ruv-swarm integration', {
+        workingDirectory
+    });
+    // Check if ruv-swarm is available
+    const available = await isRuvSwarmAvailable(logger);
+    if (!available) {
+        return {
+            success: false,
+            error: 'ruv-swarm is not available. Please install it with: npm install -g ruv-swarm'
+        };
+    }
+    // Get capabilities
+    const capabilities = await getRuvSwarmCapabilities(logger);
+    logger?.info('ruv-swarm integration initialized', {
+        capabilities
+    });
+    return {
+        success: true,
+        data: {
+            available: true,
+            capabilities,
+            integration: 'claude-code-flow',
+            sessionId: context.sessionId
+        },
+        metadata: {
+            timestamp: Date.now(),
+            sessionId: context.sessionId
+        }
+    };
+}
+export default {
+    createRuvSwarmTools,
+    isRuvSwarmAvailable,
+    getRuvSwarmCapabilities,
+    initializeRuvSwarmIntegration
+};
+
+//# sourceMappingURL=ruv-swarm-tools.js.map

package/dist/src/mcp/ruv-swarm-tools.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/mcp/ruv-swarm-tools.ts"],"names":["execAsync","errorFixes","require","e","fixAgentMetrics","d","fixSwarmMonitor","fixNeuralTrain","wrapRuvSwarmResponse","n","executeRuvSwarmCommand","command","args","context","logger","workDir","workingDirectory","process","cwd","fullCommand","join","debug","result","data","JSON","parse","stdout","output","stderr","success","metadata","timestamp","Date","now","swarmId","sessionId","error","Error","message","String","createRuvSwarmTools","name","description","inputSchema","type","properties","topology","enum","maxAgents","minimum","maximum","default","strategy","required","handler","input","verbose","duration","interval","capabilities","items","push","length","filter","agentId","metric","task","priority","stringify","taskId","detailed","format","detail","iterations","fixedInput","pattern","category","isRuvSwarmAvailable","undefined","warn","getRuvSwarmCapabilities","initializeRuvSwarmIntegration","info","available","integration"],"mappings":"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"}