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

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

@@ -22,12 +22,9 @@ 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),
@@ -517,7 +514,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',
@@ -605,7 +602,7 @@ function createQueryMemoryTool(logger) {
 }
 function createStoreMemoryTool(logger) {
     return {
-        name: 'memory/store',
+        name: 'memory_store',
         description: 'Store a new memory entry',
         inputSchema: {
             type: 'object',
@@ -689,7 +686,7 @@ function createStoreMemoryTool(logger) {
 }
 function createDeleteMemoryTool(logger) {
     return {
-        name: 'memory/delete',
+        name: 'memory_delete',
         description: 'Delete a memory entry',
         inputSchema: {
             type: 'object',
@@ -722,7 +719,7 @@ function createDeleteMemoryTool(logger) {
 }
 function createExportMemoryTool(logger) {
     return {
-        name: 'memory/export',
+        name: 'memory_export',
         description: 'Export memory entries to a file',
         inputSchema: {
             type: 'object',
@@ -781,7 +778,7 @@ function createExportMemoryTool(logger) {
 }
 function createImportMemoryTool(logger) {
     return {
-        name: 'memory/import',
+        name: 'memory_import',
         description: 'Import memory entries from a file',
         inputSchema: {
             type: 'object',
@@ -1333,249 +1330,197 @@ function createCreateTerminalTool(logger) {
         }
     };
 }
-function createSpawnParallelAgentsTool(logger) {
+function createCheckpointCreateTool(logger) {
     return {
-        name: 'agents/spawn_parallel',
-        description: 'Spawn multiple agents in parallel (10-20x faster than sequential spawning)',
+        name: 'checkpoint_create',
+        description: 'Create a checkpoint for a session (Git-like time travel)',
         inputSchema: {
             type: 'object',
             properties: {
-                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'
-                },
-                maxConcurrency: {
-                    type: 'number',
-                    default: 5,
-                    description: 'Maximum number of agents to spawn concurrently'
+                sessionId: {
+                    type: 'string',
+                    description: 'Session ID to checkpoint'
                 },
-                batchSize: {
-                    type: 'number',
-                    default: 3,
-                    description: 'Number of agents per batch'
+                description: {
+                    type: 'string',
+                    description: "Checkpoint description"
                 }
             },
             required: [
-                'agents'
+                '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;
+        handler: async (input)=>{
+            const checkpointId = await checkpointManager.createCheckpoint(input.sessionId, input.description || `Checkpoint at ${new Date().toLocaleString()}`);
             return {
                 success: true,
-                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()
+                checkpointId,
+                sessionId: input.sessionId
             };
         }
     };
 }
-function createQueryControlTool(logger) {
+function createCheckpointListTool(logger) {
     return {
-        name: 'query/control',
-        description: 'Control running queries (pause, resume, terminate, change model)',
+        name: 'checkpoint_list',
+        description: 'List all checkpoints for a session',
         inputSchema: {
             type: 'object',
             properties: {
-                action: {
+                sessionId: {
                     type: 'string',
-                    enum: [
-                        'pause',
-                        'resume',
-                        'terminate',
-                        'change_model',
-                        'change_permissions',
-                        'execute_command'
-                    ],
-                    description: 'Control action to perform'
-                },
-                queryId: {
+                    description: 'Session ID'
+                }
+            },
+            required: [
+                'sessionId'
+            ]
+        },
+        handler: async (input)=>{
+            const checkpoints = checkpointManager.listCheckpoints(input.sessionId);
+            return {
+                success: true,
+                checkpoints,
+                count: checkpoints.length
+            };
+        }
+    };
+}
+function createCheckpointRollbackTool(logger) {
+    return {
+        name: 'checkpoint_rollback',
+        description: 'Rollback session to a checkpoint',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                checkpointId: {
                     type: 'string',
-                    description: 'ID of the query to control'
+                    description: 'Checkpoint ID to restore'
                 },
-                model: {
+                prompt: {
                     type: 'string',
-                    enum: [
-                        'claude-3-5-sonnet-20241022',
-                        'claude-3-5-haiku-20241022',
-                        'claude-3-opus-20240229'
-                    ],
-                    description: 'Model to switch to (for change_model action)'
-                },
-                permissionMode: {
+                    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: {
                     type: 'string',
-                    enum: [
-                        'default',
-                        'acceptEdits',
-                        'bypassPermissions',
-                        'plan'
-                    ],
-                    description: 'Permission mode to switch to (for change_permissions action)'
+                    description: 'Base session ID to fork from'
                 },
-                command: {
+                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: {
                     type: 'string',
-                    description: 'Command to execute (for execute_command action)'
+                    description: 'Session ID'
                 }
             },
             required: [
-                'action',
-                'queryId'
+                '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}`);
-            }
+        handler: async (input)=>{
+            const info = sessionForking.getSessionInfo(input.sessionId);
             return {
                 success: true,
-                action: input.action,
-                queryId: input.queryId,
-                result,
-                timestamp: new Date().toISOString()
+                session: info
             };
         }
     };
 }
-function createListQueriesTool(logger) {
+function createPauseQueryTool(logger) {
     return {
-        name: 'query/list',
-        description: 'List all active queries and their status',
+        name: 'query_pause',
+        description: 'Pause a query with SDK (real pause with resumeSessionAt)',
         inputSchema: {
             type: 'object',
             properties: {
-                includeHistory: {
-                    type: 'boolean',
-                    default: false,
-                    description: 'Include completed queries in the list'
+                sessionId: {
+                    type: 'string',
+                    description: 'Session ID to pause'
                 }
-            }
+            },
+            required: [
+                '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();
+        handler: async (input)=>{
+            const { queryController } = await import('../sdk/query-control.js');
+            queryController.requestPause(input.sessionId);
             return {
                 success: true,
-                queries: Array.from(queries.entries()).map(([id, status])=>({
-                        queryId: id,
-                        ...status
-                    })),
-                count: queries.size,
-                timestamp: new Date().toISOString()
+                sessionId: input.sessionId,
+                paused: true
+            };
+        }
+    };
+}
+function createResumeQueryTool(logger) {
+    return {
+        name: 'query_resume',
+        description: 'Resume a paused query',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                sessionId: {
+                    type: 'string',
+                    description: 'Session ID to resume'
+                }
+            },
+            required: [
+                'sessionId'
+            ]
+        },
+        handler: async (input)=>{
+            const { queryController } = await import('../sdk/query-control.js');
+            const result = await queryController.resumeQuery(input.sessionId);
+            return {
+                success: true,
+                sessionId: input.sessionId,
+                resumed: true,
+                result
             };
         }
     };