claude-flow 2.0.0-alpha.78 → 2.0.0-alpha.79

package/dist/mcp/swarm-tools.js

@@ -0,0 +1,731 @@
+/**
+ * Comprehensive MCP tools for swarm system functionality
+ */
+export function createSwarmTools(logger) {
+    return [
+        // === LEGACY SWARM TOOLS ===
+        {
+            name: 'dispatch_agent',
+            description: 'Spawn a new agent in the swarm to handle a specific task',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    type: {
+                        type: 'string',
+                        enum: [
+                            'coordinator',
+                            'researcher',
+                            'coder',
+                            'analyst',
+                            'architect',
+                            'tester',
+                            'reviewer',
+                            'optimizer',
+                            'documenter',
+                            'monitor',
+                            'specialist',
+                        ],
+                        description: 'The type of agent to spawn',
+                    },
+                    task: {
+                        type: 'string',
+                        description: 'The specific task for the agent to complete',
+                    },
+                    name: {
+                        type: 'string',
+                        description: 'Optional name for the agent',
+                    },
+                },
+                required: ['type', 'task'],
+            },
+            handler: async (input, context) => {
+                const { type, task, name } = input;
+                // Get swarm ID from environment
+                const swarmId = process.env['CLAUDE_SWARM_ID'];
+                if (!swarmId) {
+                    throw new Error('Not running in swarm context');
+                }
+                // Get parent agent ID if available
+                const parentId = process.env['CLAUDE_SWARM_AGENT_ID'];
+                try {
+                    // Legacy functionality - would integrate with swarm spawn system
+                    const agentId = `agent-${Date.now()}`;
+                    logger.info('Agent spawned via legacy dispatch tool', { agentId });
+                    return {
+                        success: true,
+                        agentId,
+                        agentName: name || type,
+                        terminalId: 'N/A',
+                        message: `Successfully spawned ${name || type} to work on: ${task}`,
+                    };
+                }
+                catch (error) {
+                    logger.error('Failed to spawn agent via legacy dispatch tool', error);
+                    return {
+                        success: false,
+                        error: error instanceof Error ? error.message : 'Unknown error',
+                    };
+                }
+            },
+        },
+        {
+            name: 'swarm_status',
+            description: 'Get the current status of the swarm and all agents',
+            inputSchema: {
+                type: 'object',
+                properties: {},
+            },
+            handler: async (input, context) => {
+                const swarmId = process.env['CLAUDE_SWARM_ID'] || 'default-swarm';
+                // Legacy functionality - would integrate with swarm state system
+                const mockState = {
+                    swarmId,
+                    objective: 'Legacy swarm status',
+                    startTime: Date.now() - 60000, // Started 1 minute ago
+                    agents: [],
+                };
+                const runtime = Math.floor((Date.now() - mockState.startTime) / 1000);
+                return {
+                    swarmId: mockState.swarmId,
+                    objective: mockState.objective,
+                    runtime: `${runtime}s`,
+                    totalAgents: mockState.agents.length,
+                    activeAgents: 0,
+                    completedAgents: 0,
+                    failedAgents: 0,
+                    agents: mockState.agents,
+                };
+            },
+        },
+        // === SWARM COORDINATION TOOLS ===
+        {
+            name: 'swarm/create-objective',
+            description: 'Create a new swarm objective with tasks and coordination',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    title: { type: 'string', description: 'Objective title' },
+                    description: { type: 'string', description: 'Detailed description' },
+                    tasks: {
+                        type: 'array',
+                        items: {
+                            type: 'object',
+                            properties: {
+                                type: { type: 'string' },
+                                description: { type: 'string' },
+                                requirements: { type: 'object' },
+                                priority: { type: 'string', enum: ['low', 'normal', 'high', 'critical'] },
+                            },
+                            required: ['type', 'description'],
+                        },
+                    },
+                    strategy: { type: 'string', enum: ['parallel', 'sequential', 'adaptive'] },
+                    timeout: { type: 'number', description: 'Timeout in milliseconds' },
+                },
+                required: ['title', 'description', 'tasks'],
+            },
+            handler: async (input, context) => {
+                if (!context?.swarmCoordinator) {
+                    throw new Error('Swarm coordinator not available');
+                }
+                try {
+                    const objectiveId = await context.swarmCoordinator.createObjective({
+                        title: input.title,
+                        description: input.description,
+                        tasks: input.tasks || [],
+                        strategy: input.strategy || 'adaptive',
+                        timeout: input.timeout,
+                    });
+                    logger.info('Swarm objective created via MCP', { objectiveId });
+                    return {
+                        success: true,
+                        objectiveId,
+                        message: `Created swarm objective: ${input.title}`,
+                    };
+                }
+                catch (error) {
+                    logger.error('Failed to create swarm objective via MCP', error);
+                    throw error;
+                }
+            },
+        },
+        {
+            name: 'swarm/execute-objective',
+            description: 'Execute a swarm objective',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    objectiveId: { type: 'string', description: 'Objective ID to execute' },
+                },
+                required: ['objectiveId'],
+            },
+            handler: async (input, context) => {
+                if (!context?.swarmCoordinator) {
+                    throw new Error('Swarm coordinator not available');
+                }
+                try {
+                    const result = await context.swarmCoordinator.executeObjective(input.objectiveId);
+                    logger.info('Swarm objective executed via MCP', { objectiveId: input.objectiveId });
+                    return {
+                        success: true,
+                        objectiveId: input.objectiveId,
+                        result,
+                        message: 'Objective execution started',
+                    };
+                }
+                catch (error) {
+                    logger.error('Failed to execute swarm objective via MCP', error);
+                    throw error;
+                }
+            },
+        },
+        {
+            name: 'swarm/get-status',
+            description: 'Get comprehensive swarm status',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    includeDetails: { type: 'boolean', default: false },
+                },
+            },
+            handler: async (input, context) => {
+                if (!context?.swarmCoordinator) {
+                    throw new Error('Swarm coordinator not available');
+                }
+                try {
+                    const status = await context.swarmCoordinator.getSwarmStatus();
+                    if (input.includeDetails) {
+                        const detailedStatus = {
+                            ...status,
+                            objectives: await context.swarmCoordinator.getActiveObjectives(),
+                            agents: context.agentManager ? await context.agentManager.getAllAgents() : [],
+                            resources: context.resourceManager
+                                ? context.resourceManager.getManagerStatistics()
+                                : null,
+                            messaging: context.messageBus ? context.messageBus.getMetrics() : null,
+                            monitoring: context.monitor ? context.monitor.getMonitoringStatistics() : null,
+                        };
+                        return detailedStatus;
+                    }
+                    return status;
+                }
+                catch (error) {
+                    logger.error('Failed to get swarm status via MCP', error);
+                    throw error;
+                }
+            },
+        },
+        // === AGENT MANAGEMENT TOOLS ===
+        {
+            name: 'agent/create',
+            description: 'Create a new agent in the swarm',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    type: { type: 'string', description: 'Agent type (developer, researcher, etc.)' },
+                    capabilities: {
+                        type: 'object',
+                        properties: {
+                            domains: { type: 'array', items: { type: 'string' } },
+                            tools: { type: 'array', items: { type: 'string' } },
+                            languages: { type: 'array', items: { type: 'string' } },
+                            frameworks: { type: 'array', items: { type: 'string' } },
+                        },
+                    },
+                    config: { type: 'object', description: 'Agent configuration' },
+                },
+                required: ['type'],
+            },
+            handler: async (input, context) => {
+                if (!context?.agentManager) {
+                    throw new Error('Agent manager not available');
+                }
+                try {
+                    const agentId = await context.agentManager.createAgent(input.type, input.capabilities || {}, input.config || {});
+                    logger.info('Agent created via MCP', { agentId, type: input.type });
+                    return {
+                        success: true,
+                        agentId,
+                        message: `Created ${input.type} agent`,
+                    };
+                }
+                catch (error) {
+                    logger.error('Failed to create agent via MCP', error);
+                    throw error;
+                }
+            },
+        },
+        {
+            name: 'agent/list',
+            description: 'List all agents with their status',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    status: {
+                        type: 'string',
+                        enum: ['active', 'idle', 'busy', 'failed', 'all'],
+                        default: 'all',
+                    },
+                },
+            },
+            handler: async (input, context) => {
+                if (!context?.agentManager) {
+                    throw new Error('Agent manager not available');
+                }
+                try {
+                    const agents = await context.agentManager.getAllAgents();
+                    const filteredAgents = input.status === 'all'
+                        ? agents
+                        : agents.filter((agent) => agent.status === input.status);
+                    return {
+                        success: true,
+                        agents: filteredAgents,
+                        count: filteredAgents.length,
+                        filter: input.status,
+                    };
+                }
+                catch (error) {
+                    logger.error('Failed to list agents via MCP', error);
+                    throw error;
+                }
+            },
+        },
+        // === RESOURCE MANAGEMENT TOOLS ===
+        {
+            name: 'resource/register',
+            description: 'Register a new resource',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    type: {
+                        type: 'string',
+                        enum: ['compute', 'storage', 'network', 'memory', 'gpu', 'custom'],
+                    },
+                    name: { type: 'string', description: 'Resource name' },
+                    capacity: {
+                        type: 'object',
+                        properties: {
+                            cpu: { type: 'number' },
+                            memory: { type: 'number' },
+                            disk: { type: 'number' },
+                            network: { type: 'number' },
+                        },
+                    },
+                    metadata: { type: 'object', description: 'Additional metadata' },
+                },
+                required: ['type', 'name', 'capacity'],
+            },
+            handler: async (input, context) => {
+                if (!context?.resourceManager) {
+                    throw new Error('Resource manager not available');
+                }
+                try {
+                    const resourceId = await context.resourceManager.registerResource(input.type, input.name, input.capacity, input.metadata || {});
+                    logger.info('Resource registered via MCP', { resourceId, type: input.type });
+                    return {
+                        success: true,
+                        resourceId,
+                        message: `Registered ${input.type} resource: ${input.name}`,
+                    };
+                }
+                catch (error) {
+                    logger.error('Failed to register resource via MCP', error);
+                    throw error;
+                }
+            },
+        },
+        {
+            name: 'resource/get-statistics',
+            description: 'Get resource manager statistics',
+            inputSchema: {
+                type: 'object',
+                properties: {},
+            },
+            handler: async (input, context) => {
+                if (!context?.resourceManager) {
+                    throw new Error('Resource manager not available');
+                }
+                try {
+                    const stats = context.resourceManager.getManagerStatistics();
+                    return {
+                        success: true,
+                        statistics: stats,
+                    };
+                }
+                catch (error) {
+                    logger.error('Failed to get resource statistics via MCP', error);
+                    throw error;
+                }
+            },
+        },
+        // === MESSAGING TOOLS ===
+        {
+            name: 'message/send',
+            description: 'Send a message through the message bus',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    type: { type: 'string', description: 'Message type' },
+                    content: { type: 'object', description: 'Message content' },
+                    sender: { type: 'string', description: 'Sender agent ID' },
+                    receivers: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        description: 'Receiver agent IDs',
+                    },
+                    priority: { type: 'string', enum: ['low', 'normal', 'high', 'critical'] },
+                    channel: { type: 'string', description: 'Optional channel to use' },
+                },
+                required: ['type', 'content', 'sender', 'receivers'],
+            },
+            handler: async (input, context) => {
+                if (!context?.messageBus) {
+                    throw new Error('Message bus not available');
+                }
+                try {
+                    const senderAgent = {
+                        id: input.sender,
+                        swarmId: 'default',
+                        type: 'coordinator',
+                        instance: 1,
+                    };
+                    const receiverAgents = input.receivers.map((id) => ({
+                        id,
+                        swarmId: 'default',
+                        type: 'coordinator',
+                        instance: 1,
+                    }));
+                    const messageId = await context.messageBus.sendMessage(input.type, input.content, senderAgent, receiverAgents, {
+                        priority: input.priority || 'normal',
+                        channel: input.channel,
+                    });
+                    logger.info('Message sent via MCP', { messageId, type: input.type });
+                    return {
+                        success: true,
+                        messageId,
+                        message: 'Message sent successfully',
+                    };
+                }
+                catch (error) {
+                    logger.error('Failed to send message via MCP', error);
+                    throw error;
+                }
+            },
+        },
+        {
+            name: 'message/get-metrics',
+            description: 'Get message bus metrics',
+            inputSchema: {
+                type: 'object',
+                properties: {},
+            },
+            handler: async (input, context) => {
+                if (!context?.messageBus) {
+                    throw new Error('Message bus not available');
+                }
+                try {
+                    const metrics = context.messageBus.getMetrics();
+                    return {
+                        success: true,
+                        metrics,
+                    };
+                }
+                catch (error) {
+                    logger.error('Failed to get message metrics via MCP', error);
+                    throw error;
+                }
+            },
+        },
+        // === MONITORING TOOLS ===
+        {
+            name: 'monitor/get-metrics',
+            description: 'Get system monitoring metrics',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    type: {
+                        type: 'string',
+                        enum: ['system', 'swarm', 'agents', 'all'],
+                        default: 'all',
+                    },
+                },
+            },
+            handler: async (input, context) => {
+                if (!context?.monitor) {
+                    throw new Error('Monitor not available');
+                }
+                try {
+                    const metrics = {};
+                    if (input.type === 'system' || input.type === 'all') {
+                        metrics.system = context.monitor.getSystemMetrics();
+                    }
+                    if (input.type === 'swarm' || input.type === 'all') {
+                        metrics.swarm = context.monitor.getSwarmMetrics();
+                    }
+                    if (input.type === 'agents' || input.type === 'all') {
+                        metrics.statistics = context.monitor.getMonitoringStatistics();
+                    }
+                    return {
+                        success: true,
+                        metrics,
+                    };
+                }
+                catch (error) {
+                    logger.error('Failed to get monitoring metrics via MCP', error);
+                    throw error;
+                }
+            },
+        },
+        {
+            name: 'monitor/get-alerts',
+            description: 'Get active alerts',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    level: {
+                        type: 'string',
+                        enum: ['info', 'warning', 'critical', 'all'],
+                        default: 'all',
+                    },
+                    limit: { type: 'number', default: 50 },
+                },
+            },
+            handler: async (input, context) => {
+                if (!context?.monitor) {
+                    throw new Error('Monitor not available');
+                }
+                try {
+                    let alerts = context.monitor.getActiveAlerts();
+                    if (input.level !== 'all') {
+                        alerts = alerts.filter((alert) => alert.level === input.level);
+                    }
+                    alerts = alerts.slice(0, input.limit);
+                    return {
+                        success: true,
+                        alerts,
+                        count: alerts.length,
+                    };
+                }
+                catch (error) {
+                    logger.error('Failed to get alerts via MCP', error);
+                    throw error;
+                }
+            },
+        },
+        // === UTILITY TOOLS ===
+        {
+            name: 'swarm/get-comprehensive-status',
+            description: 'Get comprehensive status of the entire swarm system',
+            inputSchema: {
+                type: 'object',
+                properties: {},
+            },
+            handler: async (input, context) => {
+                try {
+                    const status = {
+                        timestamp: new Date(),
+                        system: 'operational',
+                    };
+                    if (context?.swarmCoordinator) {
+                        status.swarm = await context.swarmCoordinator.getSwarmStatus();
+                    }
+                    if (context?.agentManager) {
+                        const agents = await context.agentManager.getAllAgents();
+                        status.agents = {
+                            total: agents.length,
+                            active: agents.filter((a) => a.status === 'active').length,
+                            idle: agents.filter((a) => a.status === 'idle').length,
+                            busy: agents.filter((a) => a.status === 'busy').length,
+                            failed: agents.filter((a) => a.status === 'failed').length,
+                        };
+                    }
+                    if (context?.resourceManager) {
+                        status.resources = context.resourceManager.getManagerStatistics();
+                    }
+                    if (context?.messageBus) {
+                        status.messaging = context.messageBus.getMetrics();
+                    }
+                    if (context?.monitor) {
+                        status.monitoring = context.monitor.getMonitoringStatistics();
+                        status.systemMetrics = context.monitor.getSystemMetrics();
+                        status.swarmMetrics = context.monitor.getSwarmMetrics();
+                        status.activeAlerts = context.monitor.getActiveAlerts().length;
+                    }
+                    return {
+                        success: true,
+                        status,
+                    };
+                }
+                catch (error) {
+                    logger.error('Failed to get comprehensive status via MCP', error);
+                    throw error;
+                }
+            },
+        },
+        {
+            name: 'swarm/emergency-stop',
+            description: 'Emergency stop of all swarm operations',
+            inputSchema: {
+                type: 'object',
+                properties: {
+                    reason: { type: 'string', description: 'Reason for emergency stop' },
+                    force: { type: 'boolean', default: false },
+                },
+                required: ['reason'],
+            },
+            handler: async (input, context) => {
+                logger.warn('Emergency stop initiated via MCP', { reason: input.reason });
+                const results = {
+                    reason: input.reason,
+                    timestamp: new Date(),
+                    components: {},
+                };
+                try {
+                    // Stop swarm coordinator
+                    if (context?.swarmCoordinator) {
+                        await context.swarmCoordinator.emergencyStop(input.reason);
+                        results.components.swarmCoordinator = 'stopped';
+                    }
+                    // Stop all agents
+                    if (context?.agentManager) {
+                        await context.agentManager.stopAllAgents();
+                        results.components.agentManager = 'stopped';
+                    }
+                    // Release all resources (if method exists)
+                    if (context?.resourceManager?.releaseAllAllocations) {
+                        await context.resourceManager.releaseAllAllocations();
+                        results.components.resourceManager = 'resources_released';
+                    }
+                    // Stop message bus
+                    if (context?.messageBus?.shutdown) {
+                        await context.messageBus.shutdown();
+                        results.components.messageBus = 'stopped';
+                    }
+                    results.success = true;
+                    results.message = 'Emergency stop completed successfully';
+                    logger.info('Emergency stop completed via MCP', results);
+                    return results;
+                }
+                catch (error) {
+                    logger.error('Emergency stop failed via MCP', error);
+                    results.success = false;
+                    results.error = error instanceof Error ? error.message : 'Unknown error';
+                    throw error;
+                }
+            },
+        },
+    ];
+}
+// Legacy exports for backward compatibility
+export const dispatchAgentTool = {
+    name: 'dispatch_agent',
+    description: 'Spawn a new agent in the swarm to handle a specific task',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            type: {
+                type: 'string',
+                enum: ['researcher', 'coder', 'analyst', 'reviewer', 'coordinator'],
+                description: 'The type of agent to spawn',
+            },
+            task: {
+                type: 'string',
+                description: 'The specific task for the agent to complete',
+            },
+            name: {
+                type: 'string',
+                description: 'Optional name for the agent',
+            },
+        },
+        required: ['type', 'task'],
+    },
+};
+export const memoryStoreTool = {
+    name: 'memory_store',
+    description: 'Store data in the shared swarm memory for coordination',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            key: {
+                type: 'string',
+                description: 'The key to store data under',
+            },
+            value: {
+                type: 'object',
+                description: 'The data to store (JSON object)',
+            },
+        },
+        required: ['key', 'value'],
+    },
+};
+export const memoryRetrieveTool = {
+    name: 'memory_retrieve',
+    description: 'Retrieve data from the shared swarm memory',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            key: {
+                type: 'string',
+                description: 'The key to retrieve data from',
+            },
+        },
+        required: ['key'],
+    },
+};
+export const swarmStatusTool = {
+    name: 'swarm_status',
+    description: 'Get the current status of the swarm and all agents',
+    inputSchema: {
+        type: 'object',
+        properties: {},
+    },
+};
+// Legacy handler functions
+export async function handleDispatchAgent(args) {
+    const { type, task, name } = args;
+    const swarmId = process.env['CLAUDE_SWARM_ID'];
+    if (!swarmId) {
+        throw new Error('Not running in swarm context');
+    }
+    const parentId = process.env['CLAUDE_SWARM_AGENT_ID'];
+    try {
+        // Legacy functionality - would integrate with swarm spawn system
+        const agentId = `agent-${Date.now()}`;
+        return {
+            success: true,
+            agentId,
+            agentName: name || type,
+            terminalId: 'N/A',
+            message: `Successfully spawned ${name || type} to work on: ${task}`,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Unknown error',
+        };
+    }
+}
+export async function handleSwarmStatus(args) {
+    const swarmId = process.env['CLAUDE_SWARM_ID'] || 'default-swarm';
+    // Legacy functionality - would integrate with swarm state system
+    const mockState = {
+        swarmId,
+        objective: 'Legacy swarm status',
+        startTime: Date.now() - 60000, // Started 1 minute ago
+        agents: [],
+    };
+    const runtime = Math.floor((Date.now() - mockState.startTime) / 1000);
+    return {
+        swarmId: mockState.swarmId,
+        objective: mockState.objective,
+        runtime: `${runtime}s`,
+        totalAgents: mockState.agents.length,
+        activeAgents: 0,
+        completedAgents: 0,
+        failedAgents: 0,
+        agents: mockState.agents,
+    };
+}
+export const swarmTools = [dispatchAgentTool, memoryStoreTool, memoryRetrieveTool, swarmStatusTool];
+//# sourceMappingURL=swarm-tools.js.map