claude-flow 2.5.0-alpha.139 → 2.7.0-alpha

package/dist/src/mcp/claude-flow-tools.js

@@ -22,9 +22,12 @@ async function enhanceToolWithAgentTypes(tool) {
 export async function createClaudeFlowTools(logger) {
     const tools = [
         createSpawnAgentTool(logger),
+        createSpawnParallelAgentsTool(logger),
         createListAgentsTool(logger),
         createTerminateAgentTool(logger),
         createGetAgentInfoTool(logger),
+        createQueryControlTool(logger),
+        createListQueriesTool(logger),
         createCreateTaskTool(logger),
         createListTasksTool(logger),
         createGetTaskStatusTool(logger),
@@ -514,7 +517,7 @@ function createAssignTaskTool(logger) {
 }
 function createQueryMemoryTool(logger) {
     return {
-        name: 'memory_query',
+        name: 'memory/query',
         description: 'Query agent memory with filters and search',
         inputSchema: {
             type: 'object',
@@ -602,7 +605,7 @@ function createQueryMemoryTool(logger) {
 }
 function createStoreMemoryTool(logger) {
     return {
-        name: 'memory_store',
+        name: 'memory/store',
         description: 'Store a new memory entry',
         inputSchema: {
             type: 'object',
@@ -686,7 +689,7 @@ function createStoreMemoryTool(logger) {
 }
 function createDeleteMemoryTool(logger) {
     return {
-        name: 'memory_delete',
+        name: 'memory/delete',
         description: 'Delete a memory entry',
         inputSchema: {
             type: 'object',
@@ -719,7 +722,7 @@ function createDeleteMemoryTool(logger) {
 }
 function createExportMemoryTool(logger) {
     return {
-        name: 'memory_export',
+        name: 'memory/export',
         description: 'Export memory entries to a file',
         inputSchema: {
             type: 'object',
@@ -778,7 +781,7 @@ function createExportMemoryTool(logger) {
 }
 function createImportMemoryTool(logger) {
     return {
-        name: 'memory_import',
+        name: 'memory/import',
         description: 'Import memory entries from a file',
         inputSchema: {
             type: 'object',
@@ -1330,197 +1333,249 @@ function createCreateTerminalTool(logger) {
         }
     };
 }
-function createCheckpointCreateTool(logger) {
+function createSpawnParallelAgentsTool(logger) {
     return {
-        name: 'checkpoint_create',
-        description: 'Create a checkpoint for a session (Git-like time travel)',
+        name: 'agents/spawn_parallel',
+        description: 'Spawn multiple agents in parallel (10-20x faster than sequential spawning)',
         inputSchema: {
             type: 'object',
             properties: {
-                sessionId: {
-                    type: 'string',
-                    description: 'Session ID to checkpoint'
+                agents: {
+                    type: 'array',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            type: {
+                                type: 'string',
+                                description: 'Agent type'
+                            },
+                            name: {
+                                type: 'string',
+                                description: 'Agent name'
+                            },
+                            capabilities: {
+                                type: 'array',
+                                items: {
+                                    type: 'string'
+                                }
+                            },
+                            priority: {
+                                type: 'string',
+                                enum: [
+                                    'low',
+                                    'medium',
+                                    'high',
+                                    'critical'
+                                ],
+                                default: 'medium'
+                            }
+                        },
+                        required: [
+                            'type',
+                            'name'
+                        ]
+                    },
+                    description: 'Array of agent configurations to spawn in parallel'
                 },
-                description: {
-                    type: 'string',
-                    description: "Checkpoint description"
-                }
-            },
-            required: [
-                'sessionId'
-            ]
-        },
-        handler: async (input)=>{
-            const checkpointId = await checkpointManager.createCheckpoint(input.sessionId, input.description || `Checkpoint at ${new Date().toLocaleString()}`);
-            return {
-                success: true,
-                checkpointId,
-                sessionId: input.sessionId
-            };
-        }
-    };
-}
-function createCheckpointListTool(logger) {
-    return {
-        name: 'checkpoint_list',
-        description: 'List all checkpoints for a session',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                sessionId: {
-                    type: 'string',
-                    description: 'Session ID'
+                maxConcurrency: {
+                    type: 'number',
+                    default: 5,
+                    description: 'Maximum number of agents to spawn concurrently'
+                },
+                batchSize: {
+                    type: 'number',
+                    default: 3,
+                    description: 'Number of agents per batch'
                 }
             },
             required: [
-                'sessionId'
+                'agents'
             ]
         },
-        handler: async (input)=>{
-            const checkpoints = checkpointManager.listCheckpoints(input.sessionId);
+        handler: async (input, context)=>{
+            logger.info('Spawning parallel agents', {
+                count: input.agents?.length,
+                sessionId: context?.sessionId
+            });
+            if (!context?.orchestrator) {
+                throw new Error('Orchestrator not available');
+            }
+            const executor = context.orchestrator.getParallelExecutor();
+            if (!executor) {
+                throw new Error('ParallelSwarmExecutor not initialized');
+            }
+            const agentConfigs = input.agents.map((agent)=>({
+                    agentId: `agent_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+                    agentType: agent.type,
+                    task: `Spawn ${agent.name} agent`,
+                    capabilities: agent.capabilities || [],
+                    priority: agent.priority || 'medium'
+                }));
+            const startTime = Date.now();
+            const sessions = await executor.spawnParallelAgents(agentConfigs, {
+                maxConcurrency: input.maxConcurrency || 5,
+                batchSize: input.batchSize || 3
+            });
+            const elapsedTime = Date.now() - startTime;
             return {
                 success: true,
-                checkpoints,
-                count: checkpoints.length
+                agentsSpawned: sessions.size,
+                sessions: Array.from(sessions.entries()).map(([id, session])=>({
+                        agentId: id,
+                        sessionId: session.sessionId,
+                        status: session.status
+                    })),
+                performance: {
+                    totalTime: elapsedTime,
+                    averageTimePerAgent: elapsedTime / sessions.size,
+                    speedupVsSequential: `~${Math.round(sessions.size * 750 / elapsedTime)}x`
+                },
+                timestamp: new Date().toISOString()
             };
         }
     };
 }
-function createCheckpointRollbackTool(logger) {
+function createQueryControlTool(logger) {
     return {
-        name: 'checkpoint_rollback',
-        description: 'Rollback session to a checkpoint',
+        name: 'query/control',
+        description: 'Control running queries (pause, resume, terminate, change model)',
         inputSchema: {
             type: 'object',
             properties: {
-                checkpointId: {
+                action: {
                     type: 'string',
-                    description: 'Checkpoint ID to restore'
+                    enum: [
+                        'pause',
+                        'resume',
+                        'terminate',
+                        'change_model',
+                        'change_permissions',
+                        'execute_command'
+                    ],
+                    description: 'Control action to perform'
                 },
-                prompt: {
+                queryId: {
                     type: 'string',
-                    description: 'Continue prompt after rollback'
-                }
-            },
-            required: [
-                'checkpointId'
-            ]
-        },
-        handler: async (input)=>{
-            await checkpointManager.rollbackToCheckpoint(input.checkpointId, input.prompt || 'Continue from checkpoint');
-            return {
-                success: true,
-                checkpointId: input.checkpointId
-            };
-        }
-    };
-}
-function createSessionForkTool(logger) {
-    return {
-        name: 'session_fork',
-        description: 'Fork a session for parallel exploration (real SDK forking)',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                sessionId: {
+                    description: 'ID of the query to control'
+                },
+                model: {
                     type: 'string',
-                    description: 'Base session ID to fork from'
+                    enum: [
+                        'claude-3-5-sonnet-20241022',
+                        'claude-3-5-haiku-20241022',
+                        'claude-3-opus-20240229'
+                    ],
+                    description: 'Model to switch to (for change_model action)'
                 },
-                forkOptions: {
-                    type: 'object',
-                    description: 'Fork configuration options',
-                    properties: {}
-                }
-            },
-            required: [
-                'sessionId'
-            ]
-        },
-        handler: async (input)=>{
-            const fork = await sessionForking.fork(input.sessionId, input.forkOptions || {});
-            return {
-                success: true,
-                fork
-            };
-        }
-    };
-}
-function createSessionInfoTool(logger) {
-    return {
-        name: 'session_info',
-        description: 'Get session and fork information',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                sessionId: {
+                permissionMode: {
                     type: 'string',
-                    description: 'Session ID'
-                }
-            },
-            required: [
-                'sessionId'
-            ]
-        },
-        handler: async (input)=>{
-            const info = sessionForking.getSessionInfo(input.sessionId);
-            return {
-                success: true,
-                session: info
-            };
-        }
-    };
-}
-function createPauseQueryTool(logger) {
-    return {
-        name: 'query_pause',
-        description: 'Pause a query with SDK (real pause with resumeSessionAt)',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                sessionId: {
+                    enum: [
+                        'default',
+                        'acceptEdits',
+                        'bypassPermissions',
+                        'plan'
+                    ],
+                    description: 'Permission mode to switch to (for change_permissions action)'
+                },
+                command: {
                     type: 'string',
-                    description: 'Session ID to pause'
+                    description: 'Command to execute (for execute_command action)'
                 }
             },
             required: [
-                'sessionId'
+                'action',
+                'queryId'
             ]
         },
-        handler: async (input)=>{
-            const { queryController } = await import('../sdk/query-control.js');
-            queryController.requestPause(input.sessionId);
+        handler: async (input, context)=>{
+            logger.info('Query control action', {
+                action: input.action,
+                queryId: input.queryId,
+                sessionId: context?.sessionId
+            });
+            if (!context?.orchestrator) {
+                throw new Error('Orchestrator not available');
+            }
+            const controller = context.orchestrator.getQueryController();
+            if (!controller) {
+                throw new Error('RealTimeQueryController not initialized');
+            }
+            let result;
+            switch(input.action){
+                case 'pause':
+                    result = await controller.pauseQuery(input.queryId);
+                    break;
+                case 'resume':
+                    result = await controller.resumeQuery(input.queryId);
+                    break;
+                case 'terminate':
+                    result = await controller.terminateQuery(input.queryId);
+                    break;
+                case 'change_model':
+                    if (!input.model) {
+                        throw new Error('model parameter required for change_model action');
+                    }
+                    result = await controller.changeModel(input.queryId, input.model);
+                    break;
+                case 'change_permissions':
+                    if (!input.permissionMode) {
+                        throw new Error('permissionMode parameter required for change_permissions action');
+                    }
+                    result = await controller.changePermissionMode(input.queryId, input.permissionMode);
+                    break;
+                case 'execute_command':
+                    if (!input.command) {
+                        throw new Error('command parameter required for execute_command action');
+                    }
+                    result = await controller.executeCommand(input.queryId, input.command);
+                    break;
+                default:
+                    throw new Error(`Unknown action: ${input.action}`);
+            }
             return {
                 success: true,
-                sessionId: input.sessionId,
-                paused: true
+                action: input.action,
+                queryId: input.queryId,
+                result,
+                timestamp: new Date().toISOString()
             };
         }
     };
 }
-function createResumeQueryTool(logger) {
+function createListQueriesTool(logger) {
     return {
-        name: 'query_resume',
-        description: 'Resume a paused query',
+        name: 'query/list',
+        description: 'List all active queries and their status',
         inputSchema: {
             type: 'object',
             properties: {
-                sessionId: {
-                    type: 'string',
-                    description: 'Session ID to resume'
+                includeHistory: {
+                    type: 'boolean',
+                    default: false,
+                    description: 'Include completed queries in the list'
                 }
-            },
-            required: [
-                'sessionId'
-            ]
+            }
         },
-        handler: async (input)=>{
-            const { queryController } = await import('../sdk/query-control.js');
-            const result = await queryController.resumeQuery(input.sessionId);
+        handler: async (input, context)=>{
+            logger.info('Listing queries', {
+                sessionId: context?.sessionId
+            });
+            if (!context?.orchestrator) {
+                throw new Error('Orchestrator not available');
+            }
+            const controller = context.orchestrator.getQueryController();
+            if (!controller) {
+                throw new Error('RealTimeQueryController not initialized');
+            }
+            const queries = controller.getAllQueries();
             return {
                 success: true,
-                sessionId: input.sessionId,
-                resumed: true,
-                result
+                queries: Array.from(queries.entries()).map(([id, status])=>({
+                        queryId: id,
+                        ...status
+                    })),
+                count: queries.size,
+                timestamp: new Date().toISOString()
             };
         }
     };