genesis-ai-cli 7.4.5

package/dist/src/cli/dispatcher.js

@@ -0,0 +1,718 @@
+"use strict";
+/**
+ * Genesis 6.0 - Tool Dispatcher
+ *
+ * Intelligent router that:
+ * 1. Parses tool calls from LLM responses
+ * 2. Routes to appropriate tools (local or MCP)
+ * 3. Supports parallel execution
+ * 4. Tracks execution status with progress
+ * 5. Feeds results back for continued conversation
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ToolDispatcher = void 0;
+exports.getDispatcher = getDispatcher;
+exports.resetDispatcher = resetDispatcher;
+exports.dispatchTools = dispatchTools;
+exports.executeTool = executeTool;
+exports.listAllTools = listAllTools;
+const index_js_1 = require("../tools/index.js");
+const index_js_2 = require("../mcp/index.js");
+// ============================================================================
+// Tool Categories for Routing
+// ============================================================================
+const LOCAL_TOOLS = [
+    // File tools
+    'bash', 'edit', 'write', 'read', 'glob', 'grep',
+    // Git tools
+    'git_status', 'git_diff', 'git_log', 'git_add', 'git_commit', 'git_push',
+    'git_branch', 'git_checkout',
+];
+const MCP_TOOL_MAP = {
+    // Knowledge
+    'search_arxiv': 'arxiv',
+    'parse_paper_content': 'arxiv',
+    'get_recent_ai_papers': 'arxiv',
+    'search_semantic_scholar': 'semantic-scholar',
+    'get_semantic_scholar_paper': 'semantic-scholar',
+    'resolve-library-id': 'context7',
+    'query-docs': 'context7',
+    'wolfram_query': 'wolfram',
+    // Research
+    'web_search': 'gemini',
+    'brave_web_search': 'brave-search',
+    'web_search_exa': 'exa',
+    'firecrawl_scrape': 'firecrawl',
+    'firecrawl_search': 'firecrawl',
+    // Creation
+    'openai_chat': 'openai',
+    'create_repository': 'github',
+    'create_issue': 'github',
+    'create_pull_request': 'github',
+    // Storage - Memory (knowledge graph)
+    'create_entities': 'memory',
+    'create_relations': 'memory',
+    'add_observations': 'memory',
+    'search_nodes': 'memory',
+    'read_graph': 'memory',
+    'read_file': 'filesystem',
+    'write_file': 'filesystem',
+    'list_directory': 'filesystem',
+    // Visual
+    'stability-ai-generate-image': 'stability-ai',
+    'stability-ai-generate-image-sd35': 'stability-ai',
+};
+// ============================================================================
+// v7.3: Static Tool Schemas (fallback when MCP discovery fails)
+// ============================================================================
+const STATIC_TOOL_SCHEMAS = {
+    // Gemini - note: parameter is 'q' not 'query'
+    'web_search': {
+        description: 'Web search via Gemini AI',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                q: { type: 'string', description: 'Search query (required)' },
+                mode: { type: 'string', description: 'Search mode: normal or research' },
+            },
+            required: ['q'],
+        },
+    },
+    // Brave Search
+    'brave_web_search': {
+        description: 'Web search via Brave',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: { type: 'string', description: 'Search query (required)' },
+                count: { type: 'number', description: 'Number of results (1-20)' },
+            },
+            required: ['query'],
+        },
+    },
+    // arXiv
+    'search_arxiv': {
+        description: 'Search academic papers on arXiv',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: { type: 'string', description: 'Search query' },
+                maxResults: { type: 'number', description: 'Max results (default 5)' },
+            },
+            required: ['query'],
+        },
+    },
+    // OpenAI
+    'openai_chat': {
+        description: 'Chat completion via GPT-4',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                messages: { type: 'array', description: 'Array of {role, content} messages' },
+                model: { type: 'string', description: 'Model: gpt-4o, gpt-4o-mini, o1-preview' },
+            },
+            required: ['messages'],
+        },
+    },
+    // Filesystem
+    'read_file': {
+        description: 'Read file contents',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'Absolute file path' },
+            },
+            required: ['path'],
+        },
+    },
+    'write_file': {
+        description: 'Write content to file',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'Absolute file path' },
+                content: { type: 'string', description: 'File content' },
+            },
+            required: ['path', 'content'],
+        },
+    },
+    'list_directory': {
+        description: 'List directory contents',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                path: { type: 'string', description: 'Directory path' },
+            },
+            required: ['path'],
+        },
+    },
+    // Memory
+    'read_graph': {
+        description: 'Read the entire knowledge graph',
+        inputSchema: { type: 'object', properties: {} },
+    },
+    'search_nodes': {
+        description: 'Search nodes in knowledge graph',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: { type: 'string', description: 'Search query' },
+            },
+            required: ['query'],
+        },
+    },
+    'create_entities': {
+        description: 'Create entities in knowledge graph',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                entities: { type: 'array', description: 'Array of {name, entityType, observations}' },
+            },
+            required: ['entities'],
+        },
+    },
+    'create_relations': {
+        description: 'Create relations between entities in knowledge graph',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                relations: { type: 'array', description: 'Array of {from, to, relationType}' },
+            },
+            required: ['relations'],
+        },
+    },
+    'add_observations': {
+        description: 'Add observations to existing entities',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                observations: { type: 'array', description: 'Array of {entityName, contents[]}' },
+            },
+            required: ['observations'],
+        },
+    },
+    // GitHub
+    'create_repository': {
+        description: 'Create GitHub repository',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: { type: 'string', description: 'Repository name' },
+                description: { type: 'string', description: 'Repository description' },
+                private: { type: 'boolean', description: 'Private repository' },
+            },
+            required: ['name'],
+        },
+    },
+    // Wolfram
+    'wolfram_query': {
+        description: 'Query Wolfram Alpha for math/science',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: { type: 'string', description: 'Query in natural language' },
+                mode: { type: 'string', description: 'Mode: llm, full, short, simple' },
+            },
+            required: ['query'],
+        },
+    },
+    // Firecrawl
+    'firecrawl_scrape': {
+        description: 'Scrape content from URL',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                url: { type: 'string', description: 'URL to scrape' },
+                formats: { type: 'array', description: 'Output formats: markdown, html' },
+            },
+            required: ['url'],
+        },
+    },
+    'firecrawl_search': {
+        description: 'Search the web via Firecrawl',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                query: { type: 'string', description: 'Search query' },
+                limit: { type: 'number', description: 'Max results' },
+            },
+            required: ['query'],
+        },
+    },
+};
+// ============================================================================
+// Default Config
+// ============================================================================
+const DEFAULT_CONFIG = {
+    maxParallel: 5,
+    timeout: 60000,
+    retries: 2,
+    verbose: false,
+};
+// ============================================================================
+// Dispatcher Class
+// ============================================================================
+class ToolDispatcher {
+    config;
+    executionHistory = [];
+    constructor(config) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+    }
+    /**
+     * Parse tool calls from LLM response
+     */
+    parseToolCalls(response) {
+        // If already parsed (from OpenAI-style API)
+        if (Array.isArray(response)) {
+            return response.map(call => this.parseLLMToolCall(call));
+        }
+        // Parse from text (XML-style)
+        return this.parseXMLToolCalls(response);
+    }
+    /**
+     * Parse OpenAI-style tool call
+     */
+    parseLLMToolCall(call) {
+        const name = call.function.name;
+        let params = {};
+        try {
+            params = JSON.parse(call.function.arguments);
+        }
+        catch {
+            // Invalid JSON, use empty params
+        }
+        return {
+            id: call.id,
+            name,
+            params,
+            ...this.routeTool(name),
+        };
+    }
+    /**
+     * Parse XML-style tool calls from text
+     * Example: <tool_use name="bash"><param name="command">ls -la</param></tool_use>
+     */
+    parseXMLToolCalls(text) {
+        const calls = [];
+        // Match <tool_use> or <function_call> or similar patterns
+        const patterns = [
+            // <tool_use name="...">...</tool_use>
+            /<tool_use\s+name="([^"]+)"[^>]*>([\s\S]*?)<\/tool_use>/gi,
+            // <invoke name="...">...</invoke>
+            /<invoke\s+name="([^"]+)"[^>]*>([\s\S]*?)<\/invoke>/gi,
+            // ```tool\n{name: ..., params: {...}}```
+            /```tool\s*\n?\{[\s\S]*?"name"\s*:\s*"([^"]+)"[\s\S]*?\}```/gi,
+        ];
+        for (const pattern of patterns) {
+            let match;
+            while ((match = pattern.exec(text)) !== null) {
+                const name = match[1];
+                const content = match[2] || '';
+                const params = this.parseToolParams(content);
+                calls.push({
+                    id: `call_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+                    name,
+                    params,
+                    ...this.routeTool(name),
+                });
+            }
+        }
+        // Also check for JSON-style tool calls
+        const jsonPattern = /\{\s*"tool"\s*:\s*"([^"]+)"\s*,\s*"params"\s*:\s*(\{[^}]+\})\s*\}/gi;
+        let jsonMatch;
+        while ((jsonMatch = jsonPattern.exec(text)) !== null) {
+            try {
+                const name = jsonMatch[1];
+                const params = JSON.parse(jsonMatch[2]);
+                calls.push({
+                    id: `call_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+                    name,
+                    params,
+                    ...this.routeTool(name),
+                });
+            }
+            catch {
+                // Invalid JSON, skip
+            }
+        }
+        return calls;
+    }
+    /**
+     * Parse params from tool content
+     */
+    parseToolParams(content) {
+        const params = {};
+        // Try JSON first
+        try {
+            const trimmed = content.trim();
+            if (trimmed.startsWith('{')) {
+                return JSON.parse(trimmed);
+            }
+        }
+        catch {
+            // Not JSON, continue with XML parsing
+        }
+        // Parse <param name="...">value</param> OR <parameter name="...">value</parameter>
+        // v7.3.2: Support both tag formats (system prompt uses <parameter>, some parsers expect <param>)
+        const paramPattern = /<param(?:eter)?\s+name="([^"]+)"[^>]*>([\s\S]*?)<\/param(?:eter)?>/gi;
+        let match;
+        while ((match = paramPattern.exec(content)) !== null) {
+            const name = match[1];
+            let value = match[2].trim();
+            // Try to parse as JSON if it looks like an object/array
+            if (value.startsWith('{') || value.startsWith('[')) {
+                try {
+                    value = JSON.parse(value);
+                }
+                catch {
+                    // Keep as string
+                }
+            }
+            // Try to parse as number
+            else if (!isNaN(Number(value))) {
+                value = Number(value);
+            }
+            // Try to parse as boolean
+            else if (value === 'true' || value === 'false') {
+                value = value === 'true';
+            }
+            params[name] = value;
+        }
+        // If no params found, treat whole content as 'input'
+        if (Object.keys(params).length === 0 && content.trim()) {
+            params.input = content.trim();
+        }
+        return params;
+    }
+    /**
+     * Route tool to local or MCP
+     */
+    routeTool(name) {
+        // Check local tools first
+        if (LOCAL_TOOLS.includes(name) || index_js_1.toolRegistry.has(name)) {
+            return { source: 'local' };
+        }
+        // Check MCP tools
+        const mcpServer = MCP_TOOL_MAP[name];
+        if (mcpServer) {
+            return { source: 'mcp', mcpServer };
+        }
+        // Default to local (will fail gracefully if not found)
+        return { source: 'local' };
+    }
+    /**
+     * Execute tool calls
+     */
+    async dispatch(calls) {
+        const startTime = Date.now();
+        const results = [];
+        let parallelCount = 0;
+        let sequentialCount = 0;
+        this.progress({ phase: 'validating', current: 0, total: calls.length });
+        // Validate all calls first
+        const validCalls = [];
+        for (const call of calls) {
+            const validation = this.validateCall(call);
+            if (!validation.valid) {
+                results.push({
+                    callId: call.id,
+                    name: call.name,
+                    success: false,
+                    error: validation.reason,
+                    duration: 0,
+                    source: call.source,
+                });
+            }
+            else {
+                validCalls.push(call);
+            }
+        }
+        // Group by dependencies (for now, all parallel)
+        const groups = this.groupByDependencies(validCalls);
+        // Execute each group
+        for (let i = 0; i < groups.length; i++) {
+            const group = groups[i];
+            if (group.length > 1) {
+                parallelCount++;
+            }
+            else {
+                sequentialCount++;
+            }
+            this.progress({
+                phase: 'executing',
+                current: i + 1,
+                total: groups.length,
+                message: `Executing group ${i + 1}/${groups.length} (${group.length} tools)`,
+            });
+            // Execute group in parallel
+            const groupResults = await Promise.all(group.map(call => this.executeCall(call)));
+            results.push(...groupResults);
+        }
+        const totalDuration = Date.now() - startTime;
+        this.executionHistory.push(...results);
+        this.progress({ phase: 'complete', current: calls.length, total: calls.length });
+        return {
+            success: results.every(r => r.success),
+            results,
+            totalDuration,
+            parallelExecutions: parallelCount,
+            sequentialExecutions: sequentialCount,
+        };
+    }
+    /**
+     * Validate a tool call
+     */
+    validateCall(call) {
+        // Check if tool exists
+        if (call.source === 'local') {
+            const tool = index_js_1.toolRegistry.get(call.name);
+            if (!tool) {
+                return { valid: false, reason: `Unknown tool: ${call.name}` };
+            }
+            // Run tool-specific validation
+            if (tool.validate) {
+                return tool.validate(call.params);
+            }
+        }
+        else if (call.source === 'mcp') {
+            if (!call.mcpServer) {
+                return { valid: false, reason: `No MCP server for tool: ${call.name}` };
+            }
+        }
+        return { valid: true };
+    }
+    /**
+     * Group calls by dependencies
+     * For now, all calls are independent and can run in parallel
+     */
+    groupByDependencies(calls) {
+        // Simple grouping: max N parallel
+        const groups = [];
+        for (let i = 0; i < calls.length; i += this.config.maxParallel) {
+            groups.push(calls.slice(i, i + this.config.maxParallel));
+        }
+        return groups;
+    }
+    /**
+     * Execute a single tool call
+     */
+    async executeCall(call) {
+        const startTime = Date.now();
+        try {
+            if (this.config.verbose) {
+                console.log(`  Executing: ${call.name}`);
+            }
+            let data;
+            if (call.source === 'local') {
+                data = await this.executeLocalTool(call);
+            }
+            else {
+                data = await this.executeMCPTool(call);
+            }
+            return {
+                callId: call.id,
+                name: call.name,
+                success: true,
+                data,
+                duration: Date.now() - startTime,
+                source: call.source,
+            };
+        }
+        catch (error) {
+            return {
+                callId: call.id,
+                name: call.name,
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+                duration: Date.now() - startTime,
+                source: call.source,
+            };
+        }
+    }
+    /**
+     * Execute local tool
+     */
+    async executeLocalTool(call) {
+        const tool = index_js_1.toolRegistry.get(call.name);
+        if (!tool) {
+            throw new Error(`Tool not found: ${call.name}`);
+        }
+        return tool.execute(call.params);
+    }
+    /**
+     * Execute MCP tool
+     */
+    async executeMCPTool(call) {
+        if (!call.mcpServer) {
+            throw new Error(`No MCP server for tool: ${call.name}`);
+        }
+        const client = (0, index_js_2.getMCPClient)();
+        const result = await client.call(call.mcpServer, call.name, call.params);
+        if (!result.success) {
+            throw new Error(result.error || 'MCP call failed');
+        }
+        return result.data;
+    }
+    /**
+     * Report progress
+     */
+    progress(status) {
+        if (this.config.onProgress) {
+            this.config.onProgress(status);
+        }
+    }
+    /**
+     * Get execution history
+     */
+    getHistory() {
+        return [...this.executionHistory];
+    }
+    /**
+     * Clear history
+     */
+    clearHistory() {
+        this.executionHistory = [];
+    }
+    /**
+     * Update config
+     */
+    updateConfig(updates) {
+        this.config = { ...this.config, ...updates };
+    }
+    /**
+     * Get available tools (names only, for backward compatibility)
+     */
+    listTools() {
+        const local = Array.from(index_js_1.toolRegistry.keys());
+        const mcp = {};
+        for (const [tool, server] of Object.entries(MCP_TOOL_MAP)) {
+            if (!mcp[server]) {
+                mcp[server] = [];
+            }
+            mcp[server].push(tool);
+        }
+        return { local, mcp };
+    }
+    /**
+     * Get available tools with schemas (for dynamic prompt building)
+     * Returns tool definitions with name, description, and inputSchema
+     * Note: This is the sync version with static fallbacks - use discoverToolsWithSchemas() for real schemas
+     */
+    listToolsWithSchemas() {
+        // Local tools with basic info from registry
+        const local = Array.from(index_js_1.toolRegistry.entries()).map(([name, tool]) => ({
+            name,
+            description: tool.description,
+        }));
+        // MCP tools - use static fallback schemas
+        const mcp = {};
+        for (const [tool, server] of Object.entries(MCP_TOOL_MAP)) {
+            if (!mcp[server]) {
+                mcp[server] = [];
+            }
+            mcp[server].push({ name: tool, ...STATIC_TOOL_SCHEMAS[tool] });
+        }
+        return { local, mcp };
+    }
+    /**
+     * v7.3: Discover tools with REAL schemas from MCP servers
+     * Falls back to static schemas for servers that fail to connect
+     */
+    async discoverToolsWithSchemas() {
+        const local = Array.from(index_js_1.toolRegistry.entries()).map(([name, tool]) => ({
+            name,
+            description: tool.description,
+        }));
+        // Try to get real schemas from MCP client
+        const client = (0, index_js_2.getMCPClient)();
+        let realSchemas = {};
+        try {
+            realSchemas = await client.discoverAllTools();
+        }
+        catch {
+            // Fall back to static schemas
+            console.log('[Dispatcher] Failed to discover MCP tools, using static schemas');
+        }
+        // Merge real schemas with static fallbacks
+        const mcp = {};
+        for (const [tool, server] of Object.entries(MCP_TOOL_MAP)) {
+            if (!mcp[server]) {
+                mcp[server] = realSchemas[server] || [];
+            }
+            // If tool not in real schemas, add static fallback
+            if (!mcp[server].find(t => t.name === tool)) {
+                mcp[server].push({ name: tool, ...STATIC_TOOL_SCHEMAS[tool] });
+            }
+        }
+        return { local, mcp };
+    }
+    /**
+     * Format results for LLM context
+     */
+    formatResultsForLLM(results) {
+        const lines = ['<tool_results>'];
+        for (const result of results) {
+            lines.push(`<result name="${result.name}" success="${result.success}">`);
+            if (result.success) {
+                const data = typeof result.data === 'string'
+                    ? result.data
+                    : JSON.stringify(result.data, null, 2);
+                lines.push(data);
+            }
+            else {
+                lines.push(`Error: ${result.error}`);
+            }
+            lines.push('</result>');
+        }
+        lines.push('</tool_results>');
+        return lines.join('\n');
+    }
+}
+exports.ToolDispatcher = ToolDispatcher;
+// ============================================================================
+// Singleton
+// ============================================================================
+let dispatcherInstance = null;
+function getDispatcher(config) {
+    if (!dispatcherInstance) {
+        dispatcherInstance = new ToolDispatcher(config);
+    }
+    else if (config) {
+        dispatcherInstance.updateConfig(config);
+    }
+    return dispatcherInstance;
+}
+function resetDispatcher() {
+    dispatcherInstance = null;
+}
+// ============================================================================
+// Convenience Functions
+// ============================================================================
+/**
+ * Parse and dispatch tool calls from LLM response
+ */
+async function dispatchTools(response, config) {
+    const dispatcher = getDispatcher(config);
+    const calls = dispatcher.parseToolCalls(response);
+    return dispatcher.dispatch(calls);
+}
+/**
+ * Execute a single tool by name
+ */
+async function executeTool(name, params) {
+    const dispatcher = getDispatcher();
+    const call = {
+        id: `call_${Date.now()}`,
+        name,
+        params,
+        ...dispatcher['routeTool'](name),
+    };
+    const result = await dispatcher.dispatch([call]);
+    return result.results[0];
+}
+/**
+ * List all available tools
+ */
+function listAllTools() {
+    return getDispatcher().listTools();
+}