claude-flow 2.7.0 → 2.7.2

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

@@ -1,1398 +0,0 @@
-/**
- * Claude-Flow specific MCP tools
- */
-import { getAvailableAgentTypes } from '../constants/agent-types.js';
-/**
- * Enhance tool schema with dynamic agent types
- */
-async function enhanceToolWithAgentTypes(tool) {
-    const availableTypes = await getAvailableAgentTypes();
-    // Clone the tool to avoid modifying the original
-    const enhancedTool = JSON.parse(JSON.stringify(tool));
-    // Find and populate enum fields for agent types
-    function addEnumToAgentTypeFields(obj) {
-        if (typeof obj !== 'object' || obj === null)
-            return;
-        for (const [key, value] of Object.entries(obj)) {
-            if (typeof value === 'object' && value !== null) {
-                // Check if this is an agent type field
-                if (key === 'type' || key === 'filterByType' || key === 'assignToAgentType') {
-                    const field = value;
-                    if (field.type === 'string' && field.description?.includes('loaded dynamically from .claude/agents/')) {
-                        field.enum = availableTypes;
-                    }
-                }
-                addEnumToAgentTypeFields(value);
-            }
-        }
-    }
-    addEnumToAgentTypeFields(enhancedTool.inputSchema);
-    return enhancedTool;
-}
-/**
- * Create all Claude-Flow specific MCP tools
- */
-export async function createClaudeFlowTools(logger) {
-    const tools = [
-        // Agent management tools
-        createSpawnAgentTool(logger),
-        createSpawnParallelAgentsTool(logger), // NEW: Phase 4 - Parallel spawning
-        createListAgentsTool(logger),
-        createTerminateAgentTool(logger),
-        createGetAgentInfoTool(logger),
-        // Query control tools (NEW: Phase 4 - Real-time control)
-        createQueryControlTool(logger),
-        createListQueriesTool(logger),
-        // Task management tools
-        createCreateTaskTool(logger),
-        createListTasksTool(logger),
-        createGetTaskStatusTool(logger),
-        createCancelTaskTool(logger),
-        createAssignTaskTool(logger),
-        // Memory management tools
-        createQueryMemoryTool(logger),
-        createStoreMemoryTool(logger),
-        createDeleteMemoryTool(logger),
-        createExportMemoryTool(logger),
-        createImportMemoryTool(logger),
-        // System monitoring tools
-        createGetSystemStatusTool(logger),
-        createGetMetricsTool(logger),
-        createHealthCheckTool(logger),
-        // Configuration tools
-        createGetConfigTool(logger),
-        createUpdateConfigTool(logger),
-        createValidateConfigTool(logger),
-        // Workflow tools
-        createExecuteWorkflowTool(logger),
-        createCreateWorkflowTool(logger),
-        createListWorkflowsTool(logger),
-        // Terminal management tools
-        createExecuteCommandTool(logger),
-        createListTerminalsTool(logger),
-        createCreateTerminalTool(logger),
-    ];
-    // Enhance tools with dynamic agent types
-    const enhancedTools = await Promise.all(tools.map(tool => enhanceToolWithAgentTypes(tool)));
-    return enhancedTools;
-}
-function createSpawnAgentTool(logger) {
-    return {
-        name: 'agents/spawn',
-        description: 'Spawn a new Claude agent with specified configuration',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                type: {
-                    type: 'string',
-                    // Note: enum will be populated dynamically at runtime
-                    description: 'Type of specialized agent to spawn (loaded dynamically from .claude/agents/)',
-                },
-                name: {
-                    type: 'string',
-                    description: 'Display name for the agent',
-                },
-                capabilities: {
-                    type: 'array',
-                    items: { type: 'string' },
-                    description: 'List of capabilities for the agent',
-                },
-                systemPrompt: {
-                    type: 'string',
-                    description: 'Custom system prompt for the agent',
-                },
-                maxConcurrentTasks: {
-                    type: 'number',
-                    default: 3,
-                    description: 'Maximum number of concurrent tasks',
-                },
-                priority: {
-                    type: 'number',
-                    default: 5,
-                    description: 'Agent priority level (1-10)',
-                },
-                environment: {
-                    type: 'object',
-                    description: 'Environment variables for the agent',
-                },
-                workingDirectory: {
-                    type: 'string',
-                    description: 'Working directory for the agent',
-                },
-            },
-            required: ['type', 'name'],
-        },
-        handler: async (input, context) => {
-            logger.info('Spawning agent', { input, sessionId: context?.sessionId });
-            if (!context?.orchestrator) {
-                throw new Error('Orchestrator not available');
-            }
-            const profile = {
-                id: `agent_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
-                name: input.name,
-                type: input.type,
-                capabilities: input.capabilities || [],
-                systemPrompt: input.systemPrompt || getDefaultSystemPrompt(input.type),
-                maxConcurrentTasks: input.maxConcurrentTasks || 3,
-                priority: input.priority || 5,
-                environment: input.environment,
-                workingDirectory: input.workingDirectory,
-            };
-            const sessionId = await context.orchestrator.spawnAgent(profile);
-            return {
-                agentId: profile.id,
-                sessionId,
-                profile,
-                status: 'spawned',
-                timestamp: new Date().toISOString(),
-            };
-        },
-    };
-}
-function createListAgentsTool(logger) {
-    return {
-        name: 'agents/list',
-        description: 'List all active agents in the system',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                includeTerminated: {
-                    type: 'boolean',
-                    default: false,
-                    description: 'Include terminated agents in the list',
-                },
-                filterByType: {
-                    type: 'string',
-                    // Note: enum will be populated dynamically at runtime
-                    description: 'Filter agents by type (loaded dynamically from .claude/agents/)',
-                },
-            },
-        },
-        handler: async (input, context) => {
-            logger.info('Listing agents', { input, sessionId: context?.sessionId });
-            if (!context?.orchestrator) {
-                throw new Error('Orchestrator not available');
-            }
-            const agents = await context.orchestrator.listAgents();
-            let filteredAgents = agents;
-            if (!input.includeTerminated) {
-                filteredAgents = filteredAgents.filter((agent) => agent.status !== 'terminated');
-            }
-            if (input.filterByType) {
-                filteredAgents = filteredAgents.filter((agent) => agent.type === input.filterByType);
-            }
-            return {
-                agents: filteredAgents,
-                count: filteredAgents.length,
-                timestamp: new Date().toISOString(),
-            };
-        },
-    };
-}
-function createTerminateAgentTool(logger) {
-    return {
-        name: 'agents/terminate',
-        description: 'Terminate a specific agent',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                agentId: {
-                    type: 'string',
-                    description: 'ID of the agent to terminate',
-                },
-                reason: {
-                    type: 'string',
-                    description: 'Reason for termination',
-                },
-                graceful: {
-                    type: 'boolean',
-                    default: true,
-                    description: 'Whether to perform graceful shutdown',
-                },
-            },
-            required: ['agentId'],
-        },
-        handler: async (input, context) => {
-            logger.info('Terminating agent', { input, sessionId: context?.sessionId });
-            if (!context?.orchestrator) {
-                throw new Error('Orchestrator not available');
-            }
-            await context.orchestrator.terminateAgent(input.agentId, {
-                reason: input.reason || 'Manual termination',
-                graceful: input.graceful !== false,
-            });
-            return {
-                agentId: input.agentId,
-                status: 'terminated',
-                reason: input.reason || 'Manual termination',
-                timestamp: new Date().toISOString(),
-            };
-        },
-    };
-}
-function createGetAgentInfoTool(logger) {
-    return {
-        name: 'agents/info',
-        description: 'Get detailed information about a specific agent',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                agentId: {
-                    type: 'string',
-                    description: 'ID of the agent',
-                },
-            },
-            required: ['agentId'],
-        },
-        handler: async (input, context) => {
-            logger.info('Getting agent info', { input, sessionId: context?.sessionId });
-            if (!context?.orchestrator) {
-                throw new Error('Orchestrator not available');
-            }
-            const agentInfo = await context.orchestrator.getAgentInfo(input.agentId);
-            if (!agentInfo) {
-                throw new Error(`Agent not found: ${input.agentId}`);
-            }
-            return {
-                agent: agentInfo,
-                timestamp: new Date().toISOString(),
-            };
-        },
-    };
-}
-function createCreateTaskTool(logger) {
-    return {
-        name: 'tasks/create',
-        description: 'Create a new task for execution',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                type: {
-                    type: 'string',
-                    description: 'Type of task to create',
-                },
-                description: {
-                    type: 'string',
-                    description: 'Description of the task',
-                },
-                priority: {
-                    type: 'number',
-                    default: 5,
-                    description: 'Task priority (1-10)',
-                },
-                dependencies: {
-                    type: 'array',
-                    items: { type: 'string' },
-                    description: 'List of task IDs this task depends on',
-                },
-                assignToAgent: {
-                    type: 'string',
-                    description: 'Specific agent ID to assign the task to',
-                },
-                assignToAgentType: {
-                    type: 'string',
-                    // Note: enum will be populated dynamically at runtime
-                    description: 'Type of specialized agent to assign the task to (loaded dynamically from .claude/agents/)',
-                },
-                input: {
-                    type: 'object',
-                    description: 'Input data for the task',
-                },
-                timeout: {
-                    type: 'number',
-                    description: 'Task timeout in milliseconds',
-                },
-            },
-            required: ['type', 'description'],
-        },
-        handler: async (input, context) => {
-            logger.info('Creating task', { input, sessionId: context?.sessionId });
-            if (!context?.orchestrator) {
-                throw new Error('Orchestrator not available');
-            }
-            const task = {
-                type: input.type,
-                description: input.description,
-                priority: input.priority || 5,
-                dependencies: input.dependencies || [],
-                input: input.input || {},
-                status: 'pending',
-                createdAt: new Date(),
-            };
-            const taskId = await context.orchestrator.createTask(task);
-            // Handle assignment
-            if (input.assignToAgent) {
-                await context.orchestrator.assignTask(taskId, input.assignToAgent);
-            }
-            else if (input.assignToAgentType) {
-                await context.orchestrator.assignTaskToType(taskId, input.assignToAgentType);
-            }
-            return {
-                taskId,
-                task: { ...task, id: taskId },
-                timestamp: new Date().toISOString(),
-            };
-        },
-    };
-}
-function createListTasksTool(logger) {
-    return {
-        name: 'tasks/list',
-        description: 'List tasks with optional filtering',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                status: {
-                    type: 'string',
-                    enum: ['pending', 'queued', 'assigned', 'running', 'completed', 'failed', 'cancelled'],
-                    description: 'Filter by task status',
-                },
-                agentId: {
-                    type: 'string',
-                    description: 'Filter by assigned agent ID',
-                },
-                type: {
-                    type: 'string',
-                    description: 'Filter by task type',
-                },
-                limit: {
-                    type: 'number',
-                    default: 50,
-                    description: 'Maximum number of tasks to return',
-                },
-                offset: {
-                    type: 'number',
-                    default: 0,
-                    description: 'Number of tasks to skip',
-                },
-            },
-        },
-        handler: async (input, context) => {
-            logger.info('Listing tasks', { input, sessionId: context?.sessionId });
-            if (!context?.orchestrator) {
-                throw new Error('Orchestrator not available');
-            }
-            const tasks = await context.orchestrator.listTasks({
-                status: input.status,
-                agentId: input.agentId,
-                type: input.type,
-                limit: input.limit || 50,
-                offset: input.offset || 0,
-            });
-            return {
-                tasks,
-                count: tasks.length,
-                timestamp: new Date().toISOString(),
-            };
-        },
-    };
-}
-function createGetTaskStatusTool(logger) {
-    return {
-        name: 'tasks/status',
-        description: 'Get detailed status of a specific task',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                taskId: {
-                    type: 'string',
-                    description: 'ID of the task',
-                },
-            },
-            required: ['taskId'],
-        },
-        handler: async (input, context) => {
-            logger.info('Getting task status', { input, sessionId: context?.sessionId });
-            if (!context?.orchestrator) {
-                throw new Error('Orchestrator not available');
-            }
-            const task = await context.orchestrator.getTask(input.taskId);
-            if (!task) {
-                throw new Error(`Task not found: ${input.taskId}`);
-            }
-            return {
-                task,
-                timestamp: new Date().toISOString(),
-            };
-        },
-    };
-}
-function createCancelTaskTool(logger) {
-    return {
-        name: 'tasks/cancel',
-        description: 'Cancel a pending or running task',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                taskId: {
-                    type: 'string',
-                    description: 'ID of the task to cancel',
-                },
-                reason: {
-                    type: 'string',
-                    description: 'Reason for cancellation',
-                },
-            },
-            required: ['taskId'],
-        },
-        handler: async (input, context) => {
-            logger.info('Cancelling task', { input, sessionId: context?.sessionId });
-            if (!context?.orchestrator) {
-                throw new Error('Orchestrator not available');
-            }
-            await context.orchestrator.cancelTask(input.taskId, input.reason || 'Manual cancellation');
-            return {
-                taskId: input.taskId,
-                status: 'cancelled',
-                reason: input.reason || 'Manual cancellation',
-                timestamp: new Date().toISOString(),
-            };
-        },
-    };
-}
-function createAssignTaskTool(logger) {
-    return {
-        name: 'tasks/assign',
-        description: 'Assign a task to a specific agent',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                taskId: {
-                    type: 'string',
-                    description: 'ID of the task to assign',
-                },
-                agentId: {
-                    type: 'string',
-                    description: 'ID of the agent to assign the task to',
-                },
-            },
-            required: ['taskId', 'agentId'],
-        },
-        handler: async (input, context) => {
-            logger.info('Assigning task', { input, sessionId: context?.sessionId });
-            if (!context?.orchestrator) {
-                throw new Error('Orchestrator not available');
-            }
-            await context.orchestrator.assignTask(input.taskId, input.agentId);
-            return {
-                taskId: input.taskId,
-                agentId: input.agentId,
-                status: 'assigned',
-                timestamp: new Date().toISOString(),
-            };
-        },
-    };
-}
-function createQueryMemoryTool(logger) {
-    return {
-        name: 'memory/query',
-        description: 'Query agent memory with filters and search',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                agentId: {
-                    type: 'string',
-                    description: 'Filter by agent ID',
-                },
-                sessionId: {
-                    type: 'string',
-                    description: 'Filter by session ID',
-                },
-                type: {
-                    type: 'string',
-                    enum: ['observation', 'insight', 'decision', 'artifact', 'error'],
-                    description: 'Filter by entry type',
-                },
-                tags: {
-                    type: 'array',
-                    items: { type: 'string' },
-                    description: 'Filter by tags',
-                },
-                search: {
-                    type: 'string',
-                    description: 'Full-text search query',
-                },
-                startTime: {
-                    type: 'string',
-                    format: 'date-time',
-                    description: 'Filter entries after this time',
-                },
-                endTime: {
-                    type: 'string',
-                    format: 'date-time',
-                    description: 'Filter entries before this time',
-                },
-                limit: {
-                    type: 'number',
-                    default: 50,
-                    description: 'Maximum number of entries to return',
-                },
-                offset: {
-                    type: 'number',
-                    default: 0,
-                    description: 'Number of entries to skip',
-                },
-            },
-        },
-        handler: async (input, context) => {
-            logger.info('Querying memory', { input, sessionId: context?.sessionId });
-            if (!context?.orchestrator) {
-                throw new Error('Orchestrator not available');
-            }
-            const query = {
-                agentId: input.agentId,
-                sessionId: input.sessionId,
-                type: input.type,
-                tags: input.tags,
-                search: input.search,
-                startTime: input.startTime ? new Date(input.startTime) : undefined,
-                endTime: input.endTime ? new Date(input.endTime) : undefined,
-                limit: input.limit || 50,
-                offset: input.offset || 0,
-            };
-            const entries = await context.orchestrator.queryMemory(query);
-            return {
-                entries,
-                count: entries.length,
-                query,
-                timestamp: new Date().toISOString(),
-            };
-        },
-    };
-}
-function createStoreMemoryTool(logger) {
-    return {
-        name: 'memory/store',
-        description: 'Store a new memory entry',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                agentId: {
-                    type: 'string',
-                    description: 'Agent ID for the memory entry',
-                },
-                sessionId: {
-                    type: 'string',
-                    description: 'Session ID for the memory entry',
-                },
-                type: {
-                    type: 'string',
-                    enum: ['observation', 'insight', 'decision', 'artifact', 'error'],
-                    description: 'Type of memory entry',
-                },
-                content: {
-                    type: 'string',
-                    description: 'Content of the memory entry',
-                },
-                context: {
-                    type: 'object',
-                    description: 'Context data for the memory entry',
-                },
-                tags: {
-                    type: 'array',
-                    items: { type: 'string' },
-                    description: 'Tags for the memory entry',
-                },
-                parentId: {
-                    type: 'string',
-                    description: 'Parent memory entry ID',
-                },
-            },
-            required: ['agentId', 'sessionId', 'type', 'content'],
-        },
-        handler: async (input, context) => {
-            logger.info('Storing memory', { input, sessionId: context?.sessionId });
-            if (!context?.orchestrator) {
-                throw new Error('Orchestrator not available');
-            }
-            const entry = {
-                agentId: input.agentId,
-                sessionId: input.sessionId,
-                type: input.type,
-                content: input.content,
-                context: input.context || {},
-                tags: input.tags || [],
-                parentId: input.parentId,
-                timestamp: new Date(),
-                version: 1,
-            };
-            const entryId = await context.orchestrator.storeMemory(entry);
-            return {
-                entryId,
-                entry: { ...entry, id: entryId },
-                timestamp: new Date().toISOString(),
-            };
-        },
-    };
-}
-function createDeleteMemoryTool(logger) {
-    return {
-        name: 'memory/delete',
-        description: 'Delete a memory entry',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                entryId: {
-                    type: 'string',
-                    description: 'ID of the memory entry to delete',
-                },
-            },
-            required: ['entryId'],
-        },
-        handler: async (input, context) => {
-            logger.info('Deleting memory', { input, sessionId: context?.sessionId });
-            if (!context?.orchestrator) {
-                throw new Error('Orchestrator not available');
-            }
-            await context.orchestrator.deleteMemory(input.entryId);
-            return {
-                entryId: input.entryId,
-                status: 'deleted',
-                timestamp: new Date().toISOString(),
-            };
-        },
-    };
-}
-function createExportMemoryTool(logger) {
-    return {
-        name: 'memory/export',
-        description: 'Export memory entries to a file',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                format: {
-                    type: 'string',
-                    enum: ['json', 'csv', 'markdown'],
-                    default: 'json',
-                    description: 'Export format',
-                },
-                agentId: {
-                    type: 'string',
-                    description: 'Filter by agent ID',
-                },
-                sessionId: {
-                    type: 'string',
-                    description: 'Filter by session ID',
-                },
-                startTime: {
-                    type: 'string',
-                    format: 'date-time',
-                    description: 'Export entries after this time',
-                },
-                endTime: {
-                    type: 'string',
-                    format: 'date-time',
-                    description: 'Export entries before this time',
-                },
-            },
-        },
-        handler: async (input, context) => {
-            logger.info('Exporting memory', { input, sessionId: context?.sessionId });
-            if (!context?.orchestrator) {
-                throw new Error('Orchestrator not available');
-            }
-            const exportResult = await context.orchestrator.exportMemory({
-                format: input.format || 'json',
-                agentId: input.agentId,
-                sessionId: input.sessionId,
-                startTime: input.startTime ? new Date(input.startTime) : undefined,
-                endTime: input.endTime ? new Date(input.endTime) : undefined,
-            });
-            return {
-                ...exportResult,
-                timestamp: new Date().toISOString(),
-            };
-        },
-    };
-}
-function createImportMemoryTool(logger) {
-    return {
-        name: 'memory/import',
-        description: 'Import memory entries from a file',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                filePath: {
-                    type: 'string',
-                    description: 'Path to the file to import',
-                },
-                format: {
-                    type: 'string',
-                    enum: ['json', 'csv'],
-                    default: 'json',
-                    description: 'Import format',
-                },
-                mergeStrategy: {
-                    type: 'string',
-                    enum: ['skip', 'overwrite', 'version'],
-                    default: 'skip',
-                    description: 'Strategy for handling duplicate entries',
-                },
-            },
-            required: ['filePath'],
-        },
-        handler: async (input, context) => {
-            logger.info('Importing memory', { input, sessionId: context?.sessionId });
-            if (!context?.orchestrator) {
-                throw new Error('Orchestrator not available');
-            }
-            const importResult = await context.orchestrator.importMemory({
-                filePath: input.filePath,
-                format: input.format || 'json',
-                mergeStrategy: input.mergeStrategy || 'skip',
-            });
-            return {
-                ...importResult,
-                timestamp: new Date().toISOString(),
-            };
-        },
-    };
-}
-function createGetSystemStatusTool(logger) {
-    return {
-        name: 'system/status',
-        description: 'Get comprehensive system status information',
-        inputSchema: {
-            type: 'object',
-            properties: {},
-        },
-        handler: async (input, context) => {
-            logger.info('Getting system status', { sessionId: context?.sessionId });
-            if (!context?.orchestrator) {
-                throw new Error('Orchestrator not available');
-            }
-            const status = await context.orchestrator.getSystemStatus();
-            return {
-                ...status,
-                timestamp: new Date().toISOString(),
-            };
-        },
-    };
-}
-function createGetMetricsTool(logger) {
-    return {
-        name: 'system/metrics',
-        description: 'Get system performance metrics',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                timeRange: {
-                    type: 'string',
-                    enum: ['1h', '6h', '24h', '7d'],
-                    default: '1h',
-                    description: 'Time range for metrics',
-                },
-            },
-        },
-        handler: async (input, context) => {
-            logger.info('Getting system metrics', { input, sessionId: context?.sessionId });
-            if (!context?.orchestrator) {
-                throw new Error('Orchestrator not available');
-            }
-            const metrics = await context.orchestrator.getMetrics(input.timeRange || '1h');
-            return {
-                metrics,
-                timeRange: input.timeRange || '1h',
-                timestamp: new Date().toISOString(),
-            };
-        },
-    };
-}
-function createHealthCheckTool(logger) {
-    return {
-        name: 'system/health',
-        description: 'Perform a comprehensive health check',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                deep: {
-                    type: 'boolean',
-                    default: false,
-                    description: 'Perform deep health check including component tests',
-                },
-            },
-        },
-        handler: async (input, context) => {
-            logger.info('Performing health check', { input, sessionId: context?.sessionId });
-            if (!context?.orchestrator) {
-                throw new Error('Orchestrator not available');
-            }
-            const healthCheck = await context.orchestrator.performHealthCheck(input.deep || false);
-            return {
-                ...healthCheck,
-                timestamp: new Date().toISOString(),
-            };
-        },
-    };
-}
-function createGetConfigTool(logger) {
-    return {
-        name: 'config/get',
-        description: 'Get current system configuration',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                section: {
-                    type: 'string',
-                    enum: ['orchestrator', 'terminal', 'memory', 'coordination', 'mcp', 'logging'],
-                    description: 'Specific configuration section to retrieve',
-                },
-            },
-        },
-        handler: async (input, context) => {
-            logger.info('Getting configuration', { input, sessionId: context?.sessionId });
-            if (!context?.orchestrator) {
-                throw new Error('Orchestrator not available');
-            }
-            const config = await context.orchestrator.getConfig(input.section);
-            return {
-                config,
-                section: input.section,
-                timestamp: new Date().toISOString(),
-            };
-        },
-    };
-}
-function createUpdateConfigTool(logger) {
-    return {
-        name: 'config/update',
-        description: 'Update system configuration',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                section: {
-                    type: 'string',
-                    enum: ['orchestrator', 'terminal', 'memory', 'coordination', 'mcp', 'logging'],
-                    description: 'Configuration section to update',
-                },
-                config: {
-                    type: 'object',
-                    description: 'Configuration values to update',
-                },
-                restart: {
-                    type: 'boolean',
-                    default: false,
-                    description: 'Restart affected components after update',
-                },
-            },
-            required: ['section', 'config'],
-        },
-        handler: async (input, context) => {
-            logger.info('Updating configuration', { input, sessionId: context?.sessionId });
-            if (!context?.orchestrator) {
-                throw new Error('Orchestrator not available');
-            }
-            const result = await context.orchestrator.updateConfig(input.section, input.config, input.restart || false);
-            return {
-                ...result,
-                timestamp: new Date().toISOString(),
-            };
-        },
-    };
-}
-function createValidateConfigTool(logger) {
-    return {
-        name: 'config/validate',
-        description: 'Validate a configuration object',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                config: {
-                    type: 'object',
-                    description: 'Configuration object to validate',
-                },
-            },
-            required: ['config'],
-        },
-        handler: async (input, context) => {
-            logger.info('Validating configuration', { input, sessionId: context?.sessionId });
-            if (!context?.orchestrator) {
-                throw new Error('Orchestrator not available');
-            }
-            const validation = await context.orchestrator.validateConfig(input.config);
-            return {
-                ...validation,
-                timestamp: new Date().toISOString(),
-            };
-        },
-    };
-}
-function createExecuteWorkflowTool(logger) {
-    return {
-        name: 'workflow/execute',
-        description: 'Execute a workflow from a file or definition',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                filePath: {
-                    type: 'string',
-                    description: 'Path to workflow file',
-                },
-                workflow: {
-                    type: 'object',
-                    description: 'Inline workflow definition',
-                },
-                parameters: {
-                    type: 'object',
-                    description: 'Parameters to pass to the workflow',
-                },
-            },
-        },
-        handler: async (input, context) => {
-            logger.info('Executing workflow', { input, sessionId: context?.sessionId });
-            if (!context?.orchestrator) {
-                throw new Error('Orchestrator not available');
-            }
-            if (!input.filePath && !input.workflow) {
-                throw new Error('Either filePath or workflow must be provided');
-            }
-            const result = await context.orchestrator.executeWorkflow({
-                filePath: input.filePath,
-                workflow: input.workflow,
-                parameters: input.parameters || {},
-            });
-            return {
-                ...result,
-                timestamp: new Date().toISOString(),
-            };
-        },
-    };
-}
-function createCreateWorkflowTool(logger) {
-    return {
-        name: 'workflow/create',
-        description: 'Create a new workflow definition',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                name: {
-                    type: 'string',
-                    description: 'Name of the workflow',
-                },
-                description: {
-                    type: 'string',
-                    description: 'Description of the workflow',
-                },
-                tasks: {
-                    type: 'array',
-                    items: {
-                        type: 'object',
-                        properties: {
-                            id: { type: 'string' },
-                            type: { type: 'string' },
-                            description: { type: 'string' },
-                            dependencies: {
-                                type: 'array',
-                                items: { type: 'string' },
-                            },
-                            assignTo: { type: 'string' },
-                        },
-                        required: ['id', 'type', 'description'],
-                    },
-                    description: 'List of tasks in the workflow',
-                },
-                savePath: {
-                    type: 'string',
-                    description: 'Path to save the workflow file',
-                },
-            },
-            required: ['name', 'tasks'],
-        },
-        handler: async (input, context) => {
-            logger.info('Creating workflow', { input, sessionId: context?.sessionId });
-            if (!context?.orchestrator) {
-                throw new Error('Orchestrator not available');
-            }
-            const workflow = {
-                name: input.name,
-                description: input.description,
-                tasks: input.tasks,
-                created: new Date().toISOString(),
-            };
-            const result = await context.orchestrator.createWorkflow(workflow, input.savePath);
-            return {
-                ...result,
-                workflow,
-                timestamp: new Date().toISOString(),
-            };
-        },
-    };
-}
-function createListWorkflowsTool(logger) {
-    return {
-        name: 'workflow/list',
-        description: 'List available workflows',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                directory: {
-                    type: 'string',
-                    description: 'Directory to search for workflows',
-                },
-            },
-        },
-        handler: async (input, context) => {
-            logger.info('Listing workflows', { input, sessionId: context?.sessionId });
-            if (!context?.orchestrator) {
-                throw new Error('Orchestrator not available');
-            }
-            const workflows = await context.orchestrator.listWorkflows(input.directory);
-            return {
-                workflows,
-                count: workflows.length,
-                timestamp: new Date().toISOString(),
-            };
-        },
-    };
-}
-function createExecuteCommandTool(logger) {
-    return {
-        name: 'terminal/execute',
-        description: 'Execute a command in a terminal session',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                command: {
-                    type: 'string',
-                    description: 'Command to execute',
-                },
-                args: {
-                    type: 'array',
-                    items: { type: 'string' },
-                    description: 'Command arguments',
-                },
-                cwd: {
-                    type: 'string',
-                    description: 'Working directory for the command',
-                },
-                env: {
-                    type: 'object',
-                    description: 'Environment variables',
-                },
-                timeout: {
-                    type: 'number',
-                    default: 30000,
-                    description: 'Command timeout in milliseconds',
-                },
-                terminalId: {
-                    type: 'string',
-                    description: 'Specific terminal ID to use',
-                },
-            },
-            required: ['command'],
-        },
-        handler: async (input, context) => {
-            logger.info('Executing command', { input, sessionId: context?.sessionId });
-            if (!context?.orchestrator) {
-                throw new Error('Orchestrator not available');
-            }
-            const result = await context.orchestrator.executeCommand({
-                command: input.command,
-                args: input.args,
-                cwd: input.cwd,
-                env: input.env,
-                timeout: input.timeout || 30000,
-                terminalId: input.terminalId,
-            });
-            return {
-                ...result,
-                timestamp: new Date().toISOString(),
-            };
-        },
-    };
-}
-function createListTerminalsTool(logger) {
-    return {
-        name: 'terminal/list',
-        description: 'List all terminal sessions',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                includeIdle: {
-                    type: 'boolean',
-                    default: true,
-                    description: 'Include idle terminals',
-                },
-            },
-        },
-        handler: async (input, context) => {
-            logger.info('Listing terminals', { input, sessionId: context?.sessionId });
-            if (!context?.orchestrator) {
-                throw new Error('Orchestrator not available');
-            }
-            const terminals = await context.orchestrator.listTerminals(input.includeIdle !== false);
-            return {
-                terminals,
-                count: terminals.length,
-                timestamp: new Date().toISOString(),
-            };
-        },
-    };
-}
-function createCreateTerminalTool(logger) {
-    return {
-        name: 'terminal/create',
-        description: 'Create a new terminal session',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                cwd: {
-                    type: 'string',
-                    description: 'Working directory for the terminal',
-                },
-                env: {
-                    type: 'object',
-                    description: 'Environment variables',
-                },
-                shell: {
-                    type: 'string',
-                    description: 'Shell to use (bash, zsh, etc.)',
-                },
-            },
-        },
-        handler: async (input, context) => {
-            logger.info('Creating terminal', { input, sessionId: context?.sessionId });
-            if (!context?.orchestrator) {
-                throw new Error('Orchestrator not available');
-            }
-            const terminal = await context.orchestrator.createTerminal({
-                cwd: input.cwd,
-                env: input.env,
-                shell: input.shell,
-            });
-            return {
-                terminal,
-                timestamp: new Date().toISOString(),
-            };
-        },
-    };
-}
-/**
- * NEW: Phase 4 - Parallel Agent Spawning (10-20x faster)
- * Spawn multiple agents in parallel using ParallelSwarmExecutor
- */
-function createSpawnParallelAgentsTool(logger) {
-    return {
-        name: 'agents/spawn_parallel',
-        description: 'Spawn multiple agents in parallel (10-20x faster than sequential spawning)',
-        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',
-                },
-                batchSize: {
-                    type: 'number',
-                    default: 3,
-                    description: 'Number of agents per batch',
-                },
-            },
-            required: ['agents'],
-        },
-        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');
-            }
-            // Convert input agents to ParallelAgentConfig format
-            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,
-                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(),
-            };
-        },
-    };
-}
-/**
- * NEW: Phase 4 - Real-Time Query Control
- * Control running queries: pause, resume, terminate, change model
- */
-function createQueryControlTool(logger) {
-    return {
-        name: 'query/control',
-        description: 'Control running queries (pause, resume, terminate, change model)',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                action: {
-                    type: 'string',
-                    enum: ['pause', 'resume', 'terminate', 'change_model', 'change_permissions', 'execute_command'],
-                    description: 'Control action to perform',
-                },
-                queryId: {
-                    type: 'string',
-                    description: 'ID of the query to control',
-                },
-                model: {
-                    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: {
-                    type: 'string',
-                    enum: ['default', 'acceptEdits', 'bypassPermissions', 'plan'],
-                    description: 'Permission mode to switch to (for change_permissions action)',
-                },
-                command: {
-                    type: 'string',
-                    description: 'Command to execute (for execute_command action)',
-                },
-            },
-            required: ['action', 'queryId'],
-        },
-        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,
-                action: input.action,
-                queryId: input.queryId,
-                result,
-                timestamp: new Date().toISOString(),
-            };
-        },
-    };
-}
-/**
- * NEW: Phase 4 - List Active Queries
- * Get status of all active queries being controlled
- */
-function createListQueriesTool(logger) {
-    return {
-        name: 'query/list',
-        description: 'List all active queries and their status',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                includeHistory: {
-                    type: 'boolean',
-                    default: false,
-                    description: 'Include completed queries in the list',
-                },
-            },
-        },
-        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,
-                queries: Array.from(queries.entries()).map(([id, status]) => ({
-                    queryId: id,
-                    ...status,
-                })),
-                count: queries.size,
-                timestamp: new Date().toISOString(),
-            };
-        },
-    };
-}
-function getDefaultSystemPrompt(type) {
-    const prompts = {
-        coordinator: 'You are a coordinator agent responsible for planning, delegating, and orchestrating tasks across multiple agents.',
-        researcher: 'You are a research agent specialized in gathering, analyzing, and synthesizing information from various sources.',
-        implementer: 'You are an implementation agent focused on writing code, creating solutions, and executing technical tasks.',
-        analyst: 'You are an analysis agent that identifies patterns, generates insights, and provides data-driven recommendations.',
-        custom: 'You are a specialized agent with custom capabilities defined by your configuration.',
-    };
-    return prompts[type] || prompts.custom;
-}
-//# sourceMappingURL=claude-flow-tools.js.map