codeep 1.2.17 → 1.2.18

package/dist/utils/tools.js

@@ -1,170 +1,12 @@
 /**
- * Agent tools - definitions and execution
- */
-import { existsSync, readdirSync, statSync, readFileSync, writeFileSync, unlinkSync, mkdirSync, rmSync } from 'fs';
-// Debug logging helper - only logs when CODEEP_DEBUG=1
-const debug = (...args) => {
-    if (process.env.CODEEP_DEBUG === '1') {
-        console.error('[DEBUG]', ...args);
-    }
-};
-import { join, dirname, relative, resolve, isAbsolute } from 'path';
-import { executeCommand } from './shell.js';
-import { recordWrite, recordEdit, recordDelete, recordMkdir, recordCommand } from './history.js';
-import { loadIgnoreRules, isIgnored } from './gitignore.js';
-import { config, getApiKey } from '../config/index.js';
-import { getProviderMcpEndpoints, PROVIDERS } from '../config/providers.js';
-// Z.AI MCP tool names (available when user has any Z.AI API key)
-const ZAI_MCP_TOOLS = ['web_search', 'web_read', 'github_read'];
-// Z.AI provider IDs that have MCP endpoints
-const ZAI_PROVIDER_IDS = ['z.ai', 'z.ai-cn'];
-// MiniMax MCP tool names (available when user has any MiniMax API key)
-const MINIMAX_MCP_TOOLS = ['minimax_web_search', 'minimax_understand_image'];
-// MiniMax provider IDs
-const MINIMAX_PROVIDER_IDS = ['minimax', 'minimax-cn'];
-/**
- * Find a Z.AI provider that has an API key configured.
- * Returns the provider ID and API key, or null if none found.
- * Prefers the active provider if it's Z.AI, otherwise checks all Z.AI providers.
- */
-function getZaiMcpConfig() {
-    // First check if active provider is Z.AI
-    const activeProvider = config.get('provider');
-    if (ZAI_PROVIDER_IDS.includes(activeProvider)) {
-        const key = getApiKey(activeProvider);
-        const endpoints = getProviderMcpEndpoints(activeProvider);
-        if (key && endpoints?.webSearch && endpoints?.webReader && endpoints?.zread) {
-            return { providerId: activeProvider, apiKey: key, endpoints: endpoints };
-        }
-    }
-    // Otherwise check all Z.AI providers for a configured key
-    for (const pid of ZAI_PROVIDER_IDS) {
-        const key = getApiKey(pid);
-        const endpoints = getProviderMcpEndpoints(pid);
-        if (key && endpoints?.webSearch && endpoints?.webReader && endpoints?.zread) {
-            return { providerId: pid, apiKey: key, endpoints: endpoints };
-        }
-    }
-    return null;
-}
-/**
- * Check if Z.AI MCP tools are available (user has any Z.AI API key)
- */
-function hasZaiMcpAccess() {
-    return getZaiMcpConfig() !== null;
-}
-/**
- * Find a MiniMax provider that has an API key configured.
- * Returns the base host URL and API key, or null if none found.
- */
-function getMinimaxMcpConfig() {
-    // First check if active provider is MiniMax
-    const activeProvider = config.get('provider');
-    if (MINIMAX_PROVIDER_IDS.includes(activeProvider)) {
-        const key = getApiKey(activeProvider);
-        if (key) {
-            const provider = PROVIDERS[activeProvider];
-            const baseUrl = provider?.protocols?.openai?.baseUrl;
-            if (baseUrl) {
-                // Extract host from baseUrl (e.g. https://api.minimax.io/v1 -> https://api.minimax.io)
-                const host = baseUrl.replace(/\/v1\/?$/, '');
-                return { host, apiKey: key };
-            }
-        }
-    }
-    // Otherwise check all MiniMax providers
-    for (const pid of MINIMAX_PROVIDER_IDS) {
-        const key = getApiKey(pid);
-        if (key) {
-            const provider = PROVIDERS[pid];
-            const baseUrl = provider?.protocols?.openai?.baseUrl;
-            if (baseUrl) {
-                const host = baseUrl.replace(/\/v1\/?$/, '');
-                return { host, apiKey: key };
-            }
-        }
-    }
-    return null;
-}
-/**
- * Check if MiniMax MCP tools are available
- */
-function hasMinimaxMcpAccess() {
-    return getMinimaxMcpConfig() !== null;
-}
-/**
- * Call a MiniMax MCP REST API endpoint
- */
-async function callMinimaxApi(host, path, body, apiKey) {
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), 60000);
-    try {
-        const response = await fetch(`${host}${path}`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                'Authorization': `Bearer ${apiKey}`,
-            },
-            body: JSON.stringify(body),
-            signal: controller.signal,
-        });
-        if (!response.ok) {
-            const errorText = await response.text().catch(() => '');
-            throw new Error(`MiniMax API error ${response.status}: ${errorText || response.statusText}`);
-        }
-        const data = await response.json();
-        // MiniMax returns content array like MCP
-        if (data.content && Array.isArray(data.content)) {
-            return data.content.map((c) => c.text || '').join('\n');
-        }
-        // Fallback: return raw result
-        return typeof data === 'string' ? data : JSON.stringify(data);
-    }
-    finally {
-        clearTimeout(timeout);
-    }
-}
-/**
- * Call a Z.AI MCP endpoint via JSON-RPC 2.0
- */
-async function callZaiMcp(endpoint, toolName, args, apiKey) {
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), 60000);
-    try {
-        const response = await fetch(endpoint, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                'Accept': 'application/json',
-                'Authorization': `Bearer ${apiKey}`,
-            },
-            body: JSON.stringify({
-                jsonrpc: '2.0',
-                id: Date.now().toString(),
-                method: 'tools/call',
-                params: { name: toolName, arguments: args },
-            }),
-            signal: controller.signal,
-        });
-        if (!response.ok) {
-            const errorText = await response.text().catch(() => '');
-            throw new Error(`MCP error ${response.status}: ${errorText || response.statusText}`);
-        }
-        const data = await response.json();
-        if (data.error) {
-            throw new Error(data.error.message || JSON.stringify(data.error));
-        }
-        // MCP returns result.content as array of {type, text} blocks
-        const content = data.result?.content;
-        if (Array.isArray(content)) {
-            return content.map((c) => c.text || '').join('\n');
-        }
-        return typeof data.result === 'string' ? data.result : JSON.stringify(data.result);
-    }
-    finally {
-        clearTimeout(timeout);
-    }
-}
+ * Agent tools - definitions, interfaces, and re-exports.
+ *
+ * Heavy implementation is split into:
+ *   mcpIntegration.ts  — Z.AI and MiniMax MCP API helpers
+ *   toolParsing.ts     — parseToolCalls, parseOpenAIToolCalls, parseAnthropicToolCalls
+ *   toolExecution.ts   — executeTool, validatePath, createActionLog
+ */
+import { hasZaiMcpAccess, hasMinimaxMcpAccess, ZAI_MCP_TOOLS, MINIMAX_MCP_TOOLS } from './mcpIntegration.js';
 // Tool definitions for system prompt
 export const AGENT_TOOLS = {
     read_file: {
@@ -287,9 +129,6 @@ export const AGENT_TOOLS = {
         },
     },
 };
-/**
- * Format tool definitions for system prompt (text-based fallback)
- */
 /**
  * Get filtered tool entries (excludes provider-specific tools when API key not available)
  */
@@ -304,6 +143,9 @@ function getFilteredToolEntries() {
         return true;
     });
 }
+/**
+ * Format tool definitions for system prompt (text-based fallback)
+ */
 export function formatToolDefinitions() {
     const lines = [];
     for (const [name, tool] of getFilteredToolEntries()) {
@@ -328,32 +170,20 @@ export function getOpenAITools() {
         for (const [param, info] of Object.entries(tool.parameters)) {
             const paramInfo = info;
             if (paramInfo.type === 'array') {
-                properties[param] = {
-                    type: 'array',
-                    description: paramInfo.description,
-                    items: { type: 'string' },
-                };
+                properties[param] = { type: 'array', description: paramInfo.description, items: { type: 'string' } };
             }
             else {
-                properties[param] = {
-                    type: paramInfo.type,
-                    description: paramInfo.description,
-                };
+                properties[param] = { type: paramInfo.type, description: paramInfo.description };
             }
-            if (paramInfo.required) {
+            if (paramInfo.required)
                 required.push(param);
-            }
         }
         return {
             type: 'function',
             function: {
                 name,
                 description: tool.description,
-                parameters: {
-                    type: 'object',
-                    properties,
-                    required,
-                },
+                parameters: { type: 'object', properties, required },
             },
         };
     });
@@ -368,1016 +198,21 @@ export function getAnthropicTools() {
         for (const [param, info] of Object.entries(tool.parameters)) {
             const paramInfo = info;
             if (paramInfo.type === 'array') {
-                properties[param] = {
-                    type: 'array',
-                    description: paramInfo.description,
-                    items: { type: 'string' },
-                };
+                properties[param] = { type: 'array', description: paramInfo.description, items: { type: 'string' } };
             }
             else {
-                properties[param] = {
-                    type: paramInfo.type,
-                    description: paramInfo.description,
-                };
+                properties[param] = { type: paramInfo.type, description: paramInfo.description };
             }
-            if (paramInfo.required) {
+            if (paramInfo.required)
                 required.push(param);
-            }
         }
         return {
             name,
             description: tool.description,
-            input_schema: {
-                type: 'object',
-                properties,
-                required,
-            },
+            input_schema: { type: 'object', properties, required },
         };
     });
 }
-/**
- * Parse tool calls from OpenAI response
- */
-/**
- * Normalize tool name to lowercase with underscores
- */
-function normalizeToolName(name) {
-    const toolNameMap = {
-        'executecommand': 'execute_command',
-        'execute_command': 'execute_command',
-        'readfile': 'read_file',
-        'read_file': 'read_file',
-        'writefile': 'write_file',
-        'write_file': 'write_file',
-        'editfile': 'edit_file',
-        'edit_file': 'edit_file',
-        'deletefile': 'delete_file',
-        'delete_file': 'delete_file',
-        'listfiles': 'list_files',
-        'list_files': 'list_files',
-        'searchcode': 'search_code',
-        'search_code': 'search_code',
-        'createdirectory': 'create_directory',
-        'create_directory': 'create_directory',
-        'findfiles': 'find_files',
-        'find_files': 'find_files',
-        'fetchurl': 'fetch_url',
-        'fetch_url': 'fetch_url',
-    };
-    const lower = name.toLowerCase().replace(/-/g, '_');
-    return toolNameMap[lower] || lower;
-}
-export function parseOpenAIToolCalls(toolCalls) {
-    if (!toolCalls || !Array.isArray(toolCalls))
-        return [];
-    const parsed = [];
-    for (const tc of toolCalls) {
-        const toolName = normalizeToolName(tc.function?.name || '');
-        if (!toolName)
-            continue;
-        let parameters = {};
-        const rawArgs = tc.function?.arguments || '{}';
-        try {
-            parameters = JSON.parse(rawArgs);
-        }
-        catch (e) {
-            // JSON parsing failed - likely truncated response
-            // Try to extract what we can from partial JSON
-            debug(`Failed to parse tool arguments for ${toolName}, attempting partial extraction...`);
-            debug('Raw args preview:', rawArgs.substring(0, 200));
-            const partialParams = extractPartialToolParams(toolName, rawArgs);
-            if (partialParams) {
-                debug(`Successfully extracted partial params for ${toolName}:`, Object.keys(partialParams));
-                parameters = partialParams;
-            }
-            else {
-                debug(`Could not extract params, skipping ${toolName}`);
-                continue;
-            }
-        }
-        // Validate required parameters for specific tools
-        // For write_file, we need at least a path (content can be empty string or placeholder)
-        if (toolName === 'write_file' && !parameters.path) {
-            debug(`Skipping write_file - missing path. Raw args:`, rawArgs.substring(0, 200));
-            continue;
-        }
-        if (toolName === 'read_file' && !parameters.path) {
-            debug(`Skipping read_file - missing path`);
-            continue;
-        }
-        if (toolName === 'edit_file' && (!parameters.path || parameters.old_text === undefined || parameters.new_text === undefined)) {
-            debug(`Skipping edit_file - missing required params`);
-            continue;
-        }
-        parsed.push({
-            tool: toolName,
-            parameters,
-            id: tc.id,
-        });
-    }
-    return parsed;
-}
-/**
- * Extract parameters from truncated/partial JSON for tool calls
- * This is a fallback when JSON.parse fails due to API truncation
- */
-function extractPartialToolParams(toolName, rawArgs) {
-    try {
-        // For write_file, try to extract path and content
-        if (toolName === 'write_file') {
-            const pathMatch = rawArgs.match(/"path"\s*:\s*"([^"]+)"/);
-            if (pathMatch) {
-                // Try to extract content - it may be truncated
-                const contentMatch = rawArgs.match(/"content"\s*:\s*"([\s\S]*?)(?:"|$)/);
-                if (contentMatch) {
-                    // Unescape the content
-                    let content = contentMatch[1];
-                    content = content
-                        .replace(/\\n/g, '\n')
-                        .replace(/\\t/g, '\t')
-                        .replace(/\\r/g, '\r')
-                        .replace(/\\"/g, '"')
-                        .replace(/\\\\/g, '\\');
-                    // If content appears truncated (doesn't end properly), add a comment
-                    if (!content.endsWith('\n') && !content.endsWith('}') && !content.endsWith(';') && !content.endsWith('>')) {
-                        content += '\n<!-- Content may be truncated -->\n';
-                    }
-                    return { path: pathMatch[1], content };
-                }
-                else {
-                    // Path found but content completely missing or malformed
-                    // Return with empty content placeholder so the file is at least created
-                    return { path: pathMatch[1], content: '<!-- Content was truncated by API -->\n' };
-                }
-            }
-        }
-        // For read_file, just need path
-        if (toolName === 'read_file') {
-            const pathMatch = rawArgs.match(/"path"\s*:\s*"([^"]+)"/);
-            if (pathMatch) {
-                return { path: pathMatch[1] };
-            }
-        }
-        // For list_files, just need path
-        if (toolName === 'list_files') {
-            const pathMatch = rawArgs.match(/"path"\s*:\s*"([^"]+)"/);
-            if (pathMatch) {
-                return { path: pathMatch[1] };
-            }
-        }
-        // For create_directory, just need path
-        if (toolName === 'create_directory') {
-            const pathMatch = rawArgs.match(/"path"\s*:\s*"([^"]+)"/);
-            if (pathMatch) {
-                return { path: pathMatch[1] };
-            }
-        }
-        // For edit_file, need path, old_text, new_text
-        if (toolName === 'edit_file') {
-            const pathMatch = rawArgs.match(/"path"\s*:\s*"([^"]+)"/);
-            const oldTextMatch = rawArgs.match(/"old_text"\s*:\s*"([\s\S]*?)(?:"|$)/);
-            const newTextMatch = rawArgs.match(/"new_text"\s*:\s*"([\s\S]*?)(?:"|$)/);
-            if (pathMatch && oldTextMatch && newTextMatch) {
-                return {
-                    path: pathMatch[1],
-                    old_text: oldTextMatch[1].replace(/\\n/g, '\n').replace(/\\"/g, '"'),
-                    new_text: newTextMatch[1].replace(/\\n/g, '\n').replace(/\\"/g, '"'),
-                };
-            }
-        }
-        // For execute_command
-        if (toolName === 'execute_command') {
-            const commandMatch = rawArgs.match(/"command"\s*:\s*"([^"]+)"/);
-            if (commandMatch) {
-                const argsMatch = rawArgs.match(/"args"\s*:\s*\[([\s\S]*?)\]/);
-                let args = [];
-                if (argsMatch) {
-                    const argStrings = argsMatch[1].match(/"([^"]+)"/g);
-                    if (argStrings) {
-                        args = argStrings.map(s => s.replace(/"/g, ''));
-                    }
-                }
-                return { command: commandMatch[1], args };
-            }
-        }
-        return null;
-    }
-    catch (e) {
-        debug('Error in extractPartialToolParams:', e);
-        return null;
-    }
-}
-/**
- * Parse tool calls from Anthropic response
- */
-export function parseAnthropicToolCalls(content) {
-    if (!content || !Array.isArray(content))
-        return [];
-    return content
-        .filter(block => block.type === 'tool_use')
-        .map(block => ({
-        tool: normalizeToolName(block.name || ''),
-        parameters: block.input || {},
-        id: block.id,
-    }))
-        .filter(tc => tc.tool);
-}
-/**
- * Parse tool calls from LLM response
- * Supports multiple formats:
- * - <tool_call>{"tool": "name", "parameters": {...}}</tool_call>
- * - <toolcall>{"tool": "name", "parameters": {...}}</toolcall>
- * - <toolcall>toolname{"parameters": {...}}</toolcall>
- * - ```tool\n{"tool": "name", "parameters": {...}}\n```
- * - Direct JSON blocks with tool property
- */
-export function parseToolCalls(response) {
-    const toolCalls = [];
-    // Format 1: <tool_call>...</tool_call> or <toolcall>...</toolcall> with JSON inside
-    const toolCallRegex = /<tool_?call>\s*([\s\S]*?)\s*<\/tool_?call>/gi;
-    let match;
-    while ((match = toolCallRegex.exec(response)) !== null) {
-        const parsed = tryParseToolCall(match[1].trim());
-        if (parsed)
-            toolCalls.push(parsed);
-    }
-    // Format 2: <toolcall>toolname{...} or <toolcall>toolname, "parameters": {...}
-    const malformedRegex = /<toolcall>(\w+)[\s,]*(?:"parameters"\s*:\s*)?(\{[\s\S]*?\})/gi;
-    while ((match = malformedRegex.exec(response)) !== null) {
-        const toolName = match[1].toLowerCase();
-        let jsonPart = match[2];
-        // Map common variations to actual tool names
-        const toolNameMap = {
-            'executecommand': 'execute_command',
-            'execute_command': 'execute_command',
-            'readfile': 'read_file',
-            'read_file': 'read_file',
-            'writefile': 'write_file',
-            'write_file': 'write_file',
-            'editfile': 'edit_file',
-            'edit_file': 'edit_file',
-            'deletefile': 'delete_file',
-            'delete_file': 'delete_file',
-            'listfiles': 'list_files',
-            'list_files': 'list_files',
-            'searchcode': 'search_code',
-            'search_code': 'search_code',
-            'findfiles': 'find_files',
-            'find_files': 'find_files',
-        };
-        const actualToolName = toolNameMap[toolName] || toolName;
-        try {
-            const parsed = JSON.parse(jsonPart);
-            const params = parsed.parameters || parsed;
-            toolCalls.push({
-                tool: actualToolName,
-                parameters: params,
-            });
-        }
-        catch {
-            // Try to extract parameters manually
-            const params = tryExtractParams(jsonPart);
-            if (params) {
-                toolCalls.push({
-                    tool: actualToolName,
-                    parameters: params,
-                });
-            }
-        }
-    }
-    // Format 2b: Even more malformed - toolname followed by loose JSON-like content
-    const looseRegex = /<toolcall>(\w+)[,\s]+["']?parameters["']?\s*:\s*(\{[\s\S]*?\})(?:<\/toolcall>|<|$)/gi;
-    while ((match = looseRegex.exec(response)) !== null) {
-        // Skip if already parsed
-        const toolName = match[1].toLowerCase();
-        const toolNameMap = {
-            'executecommand': 'execute_command',
-            'readfile': 'read_file',
-            'writefile': 'write_file',
-            'editfile': 'edit_file',
-            'deletefile': 'delete_file',
-            'listfiles': 'list_files',
-            'searchcode': 'search_code',
-            'findfiles': 'find_files',
-        };
-        const actualToolName = toolNameMap[toolName] || toolName;
-        // Check if we already have this tool call
-        if (toolCalls.some(t => t.tool === actualToolName))
-            continue;
-        const params = tryExtractParams(match[2]);
-        if (params) {
-            toolCalls.push({
-                tool: actualToolName,
-                parameters: params,
-            });
-        }
-    }
-    // Format 3: ```tool or ```json with tool calls
-    const codeBlockRegex = /```(?:tool|json)?\s*\n?([\s\S]*?)\n?```/g;
-    while ((match = codeBlockRegex.exec(response)) !== null) {
-        const content = match[1].trim();
-        // Only parse if it looks like a tool call JSON
-        if (content.includes('"tool"') || content.includes('"parameters"')) {
-            const parsed = tryParseToolCall(content);
-            if (parsed && !toolCalls.some(t => t.tool === parsed.tool && JSON.stringify(t.parameters) === JSON.stringify(parsed.parameters))) {
-                toolCalls.push(parsed);
-            }
-        }
-    }
-    // Format 4: Inline JSON objects with tool property (fallback)
-    if (toolCalls.length === 0) {
-        const jsonRegex = /\{[^{}]*"tool"\s*:\s*"[^"]+"\s*,\s*"parameters"\s*:\s*\{[^{}]*\}[^{}]*\}/g;
-        while ((match = jsonRegex.exec(response)) !== null) {
-            const parsed = tryParseToolCall(match[0]);
-            if (parsed)
-                toolCalls.push(parsed);
-        }
-    }
-    return toolCalls;
-}
-/**
- * Try to extract parameters from a malformed JSON string
- */
-function tryExtractParams(str) {
-    const params = {};
-    // Extract "args": [...] 
-    const argsMatch = str.match(/"args"\s*:\s*\[([\s\S]*?)\]/);
-    if (argsMatch) {
-        try {
-            params.args = JSON.parse(`[${argsMatch[1]}]`);
-        }
-        catch {
-            // Try to extract string array manually
-            const items = argsMatch[1].match(/"([^"]*)"/g);
-            if (items) {
-                params.args = items.map(i => i.replace(/"/g, ''));
-            }
-        }
-    }
-    // Extract "command": "..."
-    const cmdMatch = str.match(/"command"\s*:\s*"([^"]*)"/);
-    if (cmdMatch) {
-        params.command = cmdMatch[1];
-    }
-    // Extract "path": "..."
-    const pathMatch = str.match(/"path"\s*:\s*"([^"]*)"/);
-    if (pathMatch) {
-        params.path = pathMatch[1];
-    }
-    // Extract "content": "..."
-    const contentMatch = str.match(/"content"\s*:\s*"([\s\S]*?)(?<!\\)"/);
-    if (contentMatch) {
-        params.content = contentMatch[1].replace(/\\n/g, '\n').replace(/\\"/g, '"');
-    }
-    // Extract "old_text" and "new_text"
-    const oldTextMatch = str.match(/"old_text"\s*:\s*"([\s\S]*?)(?<!\\)"/);
-    if (oldTextMatch) {
-        params.old_text = oldTextMatch[1];
-    }
-    const newTextMatch = str.match(/"new_text"\s*:\s*"([\s\S]*?)(?<!\\)"/);
-    if (newTextMatch) {
-        params.new_text = newTextMatch[1];
-    }
-    // Extract "pattern": "..."
-    const patternMatch = str.match(/"pattern"\s*:\s*"([^"]*)"/);
-    if (patternMatch) {
-        params.pattern = patternMatch[1];
-    }
-    // Extract "recursive": true/false
-    const recursiveMatch = str.match(/"recursive"\s*:\s*(true|false)/i);
-    if (recursiveMatch) {
-        params.recursive = recursiveMatch[1].toLowerCase() === 'true';
-    }
-    return Object.keys(params).length > 0 ? params : null;
-}
-/**
- * Try to parse a string as a tool call
- */
-function tryParseToolCall(str) {
-    try {
-        // Clean up common issues
-        let cleaned = str
-            .replace(/[\r\n]+/g, ' ') // Remove newlines
-            .replace(/,\s*}/g, '}') // Remove trailing commas
-            .replace(/,\s*]/g, ']') // Remove trailing commas in arrays
-            .trim();
-        const parsed = JSON.parse(cleaned);
-        if (parsed.tool && typeof parsed.tool === 'string') {
-            return {
-                tool: normalizeToolName(parsed.tool),
-                parameters: parsed.parameters || {},
-                id: parsed.id,
-            };
-        }
-    }
-    catch {
-        // Try to extract tool name and parameters manually for malformed JSON
-        const toolMatch = str.match(/"tool"\s*:\s*"([^"]+)"/i);
-        if (toolMatch) {
-            const tool = normalizeToolName(toolMatch[1]);
-            const params = {};
-            // Extract simple string parameters
-            const paramMatches = str.matchAll(/"(\w+)"\s*:\s*"([^"]*)"/g);
-            for (const m of paramMatches) {
-                if (m[1] !== 'tool') {
-                    params[m[1]] = m[2];
-                }
-            }
-            // Extract boolean parameters
-            const boolMatches = str.matchAll(/"(\w+)"\s*:\s*(true|false)/gi);
-            for (const m of boolMatches) {
-                params[m[1]] = m[2].toLowerCase() === 'true';
-            }
-            if (Object.keys(params).length > 0 || AGENT_TOOLS[tool]) {
-                return { tool, parameters: params };
-            }
-        }
-    }
-    return null;
-}
-/**
- * Validate path is within project
- */
-function validatePath(path, projectRoot) {
-    // If path is absolute but starts with projectRoot, convert to relative
-    let normalizedPath = path;
-    if (isAbsolute(path) && path.startsWith(projectRoot)) {
-        normalizedPath = relative(projectRoot, path);
-    }
-    // If still absolute and doesn't match projectRoot, reject it
-    if (isAbsolute(normalizedPath)) {
-        return { valid: false, absolutePath: normalizedPath, error: `Absolute path '${path}' not allowed. Use relative paths.` };
-    }
-    const absolutePath = resolve(projectRoot, normalizedPath);
-    const relativePath = relative(projectRoot, absolutePath);
-    if (relativePath.startsWith('..')) {
-        return { valid: false, absolutePath, error: `Path '${path}' is outside project directory` };
-    }
-    return { valid: true, absolutePath };
-}
-/**
- * Execute a tool call
- */
-export async function executeTool(toolCall, projectRoot) {
-    // Normalize tool name to handle case variations (WRITE_FILE -> write_file)
-    const tool = normalizeToolName(toolCall.tool);
-    const parameters = toolCall.parameters;
-    debug(`Executing tool: ${tool}`, parameters.path || parameters.command || '');
-    try {
-        switch (tool) {
-            case 'read_file': {
-                const path = parameters.path;
-                if (!path) {
-                    return { success: false, output: '', error: 'Missing required parameter: path', tool, parameters };
-                }
-                const validation = validatePath(path, projectRoot);
-                if (!validation.valid) {
-                    return { success: false, output: '', error: validation.error, tool, parameters };
-                }
-                if (!existsSync(validation.absolutePath)) {
-                    return { success: false, output: '', error: `File not found: ${path}`, tool, parameters };
-                }
-                const stat = statSync(validation.absolutePath);
-                if (stat.isDirectory()) {
-                    return { success: false, output: '', error: `Path is a directory, not a file: ${path}`, tool, parameters };
-                }
-                // Limit file size
-                if (stat.size > 100 * 1024) { // 100KB
-                    return { success: false, output: '', error: `File too large (${stat.size} bytes). Max: 100KB`, tool, parameters };
-                }
-                const content = readFileSync(validation.absolutePath, 'utf-8');
-                return { success: true, output: content, tool, parameters };
-            }
-            case 'write_file': {
-                const path = parameters.path;
-                let content = parameters.content;
-                if (!path) {
-                    debug('write_file failed: missing path');
-                    return { success: false, output: '', error: 'Missing required parameter: path', tool, parameters };
-                }
-                // Allow empty content or provide placeholder for truncated responses
-                if (content === undefined || content === null) {
-                    debug('write_file: content was undefined, using placeholder');
-                    content = '<!-- Content was not provided -->\n';
-                }
-                const validation = validatePath(path, projectRoot);
-                if (!validation.valid) {
-                    return { success: false, output: '', error: validation.error, tool, parameters };
-                }
-                // Create directory if needed
-                const dir = dirname(validation.absolutePath);
-                if (!existsSync(dir)) {
-                    mkdirSync(dir, { recursive: true });
-                }
-                // Record for undo
-                recordWrite(validation.absolutePath);
-                const existed = existsSync(validation.absolutePath);
-                writeFileSync(validation.absolutePath, content, 'utf-8');
-                const action = existed ? 'Updated' : 'Created';
-                return { success: true, output: `${action} file: ${path}`, tool, parameters };
-            }
-            case 'edit_file': {
-                const path = parameters.path;
-                const oldText = parameters.old_text;
-                const newText = parameters.new_text;
-                if (!path || oldText === undefined || newText === undefined) {
-                    return { success: false, output: '', error: 'Missing required parameters', tool, parameters };
-                }
-                const validation = validatePath(path, projectRoot);
-                if (!validation.valid) {
-                    return { success: false, output: '', error: validation.error, tool, parameters };
-                }
-                if (!existsSync(validation.absolutePath)) {
-                    return { success: false, output: '', error: `File not found: ${path}`, tool, parameters };
-                }
-                const content = readFileSync(validation.absolutePath, 'utf-8');
-                if (!content.includes(oldText)) {
-                    return { success: false, output: '', error: `Text not found in file. Make sure old_text matches exactly.`, tool, parameters };
-                }
-                // Count occurrences to prevent ambiguous replacements
-                let matchCount = 0;
-                let searchPos = 0;
-                while ((searchPos = content.indexOf(oldText, searchPos)) !== -1) {
-                    matchCount++;
-                    searchPos += oldText.length;
-                }
-                if (matchCount > 1) {
-                    return { success: false, output: '', error: `old_text matches ${matchCount} locations in the file. Provide more surrounding context to make it unique (only 1 match allowed).`, tool, parameters };
-                }
-                // Record for undo
-                recordEdit(validation.absolutePath);
-                const newContent = content.replace(oldText, newText);
-                writeFileSync(validation.absolutePath, newContent, 'utf-8');
-                return { success: true, output: `Edited file: ${path}`, tool, parameters };
-            }
-            case 'delete_file': {
-                const path = parameters.path;
-                if (!path) {
-                    return { success: false, output: '', error: 'Missing required parameter: path', tool, parameters };
-                }
-                const validation = validatePath(path, projectRoot);
-                if (!validation.valid) {
-                    return { success: false, output: '', error: validation.error, tool, parameters };
-                }
-                if (!existsSync(validation.absolutePath)) {
-                    return { success: false, output: '', error: `Path not found: ${path}`, tool, parameters };
-                }
-                // Record for undo (before delete)
-                recordDelete(validation.absolutePath);
-                const stat = statSync(validation.absolutePath);
-                if (stat.isDirectory()) {
-                    // Delete directory recursively
-                    rmSync(validation.absolutePath, { recursive: true, force: true });
-                    return { success: true, output: `Deleted directory: ${path}`, tool, parameters };
-                }
-                else {
-                    unlinkSync(validation.absolutePath);
-                    return { success: true, output: `Deleted file: ${path}`, tool, parameters };
-                }
-            }
-            case 'list_files': {
-                const path = parameters.path || '.';
-                const recursive = parameters.recursive || false;
-                const validation = validatePath(path, projectRoot);
-                if (!validation.valid) {
-                    return { success: false, output: '', error: validation.error, tool, parameters };
-                }
-                if (!existsSync(validation.absolutePath)) {
-                    return { success: false, output: '', error: `Directory not found: ${path}`, tool, parameters };
-                }
-                const stat = statSync(validation.absolutePath);
-                if (!stat.isDirectory()) {
-                    return { success: false, output: '', error: `Path is not a directory: ${path}`, tool, parameters };
-                }
-                const files = listDirectory(validation.absolutePath, projectRoot, recursive);
-                return { success: true, output: files.join('\n'), tool, parameters };
-            }
-            case 'create_directory': {
-                const path = parameters.path;
-                if (!path) {
-                    return { success: false, output: '', error: 'Missing required parameter: path', tool, parameters };
-                }
-                const validation = validatePath(path, projectRoot);
-                if (!validation.valid) {
-                    return { success: false, output: '', error: validation.error, tool, parameters };
-                }
-                if (existsSync(validation.absolutePath)) {
-                    const stat = statSync(validation.absolutePath);
-                    if (stat.isDirectory()) {
-                        return { success: true, output: `Directory already exists: ${path}`, tool, parameters };
-                    }
-                    else {
-                        return { success: false, output: '', error: `Path exists but is a file: ${path}`, tool, parameters };
-                    }
-                }
-                // Record for undo
-                recordMkdir(validation.absolutePath);
-                mkdirSync(validation.absolutePath, { recursive: true });
-                return { success: true, output: `Created directory: ${path}`, tool, parameters };
-            }
-            case 'execute_command': {
-                const command = parameters.command;
-                const args = parameters.args || [];
-                if (!command) {
-                    return { success: false, output: '', error: 'Missing required parameter: command', tool, parameters };
-                }
-                // Record command (can't undo but tracked)
-                recordCommand(command, args);
-                const result = executeCommand(command, args, {
-                    cwd: projectRoot,
-                    projectRoot,
-                    timeout: 120000, // 2 minutes for commands
-                });
-                if (result.success) {
-                    return { success: true, output: result.stdout || '(no output)', tool, parameters };
-                }
-                else {
-                    return { success: false, output: result.stdout, error: result.stderr, tool, parameters };
-                }
-            }
-            case 'search_code': {
-                const pattern = parameters.pattern;
-                const searchPath = parameters.path || '.';
-                if (!pattern) {
-                    return { success: false, output: '', error: 'Missing required parameter: pattern', tool, parameters };
-                }
-                const validation = validatePath(searchPath, projectRoot);
-                if (!validation.valid) {
-                    return { success: false, output: '', error: validation.error, tool, parameters };
-                }
-                // Use grep for search
-                const result = executeCommand('grep', ['-rn', '--include=*.{ts,tsx,js,jsx,json,md,css,html,py,go,rs,rb,kt,kts,swift,php,java,cs,c,cpp,h,hpp,vue,svelte,yaml,yml,toml,sh,sql,xml,scss,less}', pattern, validation.absolutePath], {
-                    cwd: projectRoot,
-                    projectRoot,
-                    timeout: 30000,
-                });
-                if (result.exitCode === 0) {
-                    // Limit output
-                    const lines = result.stdout.split('\n').slice(0, 50);
-                    return { success: true, output: lines.join('\n') || 'No matches found', tool, parameters };
-                }
-                else if (result.exitCode === 1) {
-                    return { success: true, output: 'No matches found', tool, parameters };
-                }
-                else {
-                    return { success: false, output: '', error: result.stderr || 'Search failed', tool, parameters };
-                }
-            }
-            case 'find_files': {
-                const pattern = parameters.pattern;
-                const searchPath = parameters.path || '.';
-                if (!pattern) {
-                    return { success: false, output: '', error: 'Missing required parameter: pattern', tool, parameters };
-                }
-                const validation = validatePath(searchPath, projectRoot);
-                if (!validation.valid) {
-                    return { success: false, output: '', error: validation.error, tool, parameters };
-                }
-                // Use find with -name or -path for glob matching
-                // Convert glob pattern to find-compatible format
-                const findArgs = [validation.absolutePath];
-                // Ignore common directories
-                findArgs.push('(', '-name', 'node_modules', '-o', '-name', '.git', '-o', '-name', '.codeep', '-o', '-name', 'dist', '-o', '-name', 'build', '-o', '-name', '.next', ')', '-prune', '-o');
-                if (pattern.includes('/')) {
-                    // Path-based pattern: use -path
-                    findArgs.push('-path', `*/${pattern}`, '-print');
-                }
-                else {
-                    // Name-based pattern: use -name
-                    findArgs.push('-name', pattern, '-print');
-                }
-                const result = executeCommand('find', findArgs, {
-                    cwd: projectRoot,
-                    projectRoot,
-                    timeout: 15000,
-                });
-                if (result.exitCode === 0 || result.stdout) {
-                    const files = result.stdout.split('\n').filter(Boolean);
-                    // Make paths relative to project root
-                    const relativePaths = files.map(f => {
-                        const rel = relative(projectRoot, f);
-                        return rel || f;
-                    }).slice(0, 100); // Limit to 100 results
-                    if (relativePaths.length === 0) {
-                        return { success: true, output: `No files matching "${pattern}"`, tool, parameters };
-                    }
-                    return { success: true, output: `Found ${relativePaths.length} file(s):\n${relativePaths.join('\n')}`, tool, parameters };
-                }
-                else {
-                    return { success: false, output: '', error: result.stderr || 'Find failed', tool, parameters };
-                }
-            }
-            case 'fetch_url': {
-                const url = parameters.url;
-                if (!url) {
-                    return { success: false, output: '', error: 'Missing required parameter: url', tool, parameters };
-                }
-                // Validate URL
-                try {
-                    new URL(url);
-                }
-                catch {
-                    return { success: false, output: '', error: 'Invalid URL format', tool, parameters };
-                }
-                // Use curl to fetch URL
-                const result = executeCommand('curl', [
-                    '-s', '-L',
-                    '-m', '30', // 30 second timeout
-                    '-A', 'Codeep/1.0',
-                    '--max-filesize', '1000000', // 1MB max
-                    url
-                ], {
-                    cwd: projectRoot,
-                    projectRoot,
-                    timeout: 35000,
-                });
-                if (result.success) {
-                    // Try to extract text content (strip HTML tags for basic display)
-                    let content = result.stdout;
-                    // If it looks like HTML, convert to readable text
-                    if (content.includes('<html') || content.includes('<!DOCTYPE')) {
-                        content = htmlToText(content);
-                    }
-                    // Limit output
-                    if (content.length > 10000) {
-                        content = content.substring(0, 10000) + '\n\n... (truncated)';
-                    }
-                    return { success: true, output: content, tool, parameters };
-                }
-                else {
-                    return { success: false, output: '', error: result.stderr || 'Failed to fetch URL', tool, parameters };
-                }
-            }
-            // === Z.AI MCP Tools ===
-            case 'web_search': {
-                const mcpConfig = getZaiMcpConfig();
-                if (!mcpConfig) {
-                    return { success: false, output: '', error: 'web_search requires a Z.AI API key. Configure one via /provider z.ai', tool, parameters };
-                }
-                const query = parameters.query;
-                if (!query) {
-                    return { success: false, output: '', error: 'Missing required parameter: query', tool, parameters };
-                }
-                const args = { search_query: query };
-                if (parameters.domain_filter)
-                    args.search_domain_filter = parameters.domain_filter;
-                if (parameters.recency)
-                    args.search_recency_filter = parameters.recency;
-                const result = await callZaiMcp(mcpConfig.endpoints.webSearch, 'webSearchPrime', args, mcpConfig.apiKey);
-                const output = result.length > 15000 ? result.substring(0, 15000) + '\n\n... (truncated)' : result;
-                return { success: true, output, tool, parameters };
-            }
-            case 'web_read': {
-                const mcpConfig = getZaiMcpConfig();
-                if (!mcpConfig) {
-                    return { success: false, output: '', error: 'web_read requires a Z.AI API key. Configure one via /provider z.ai', tool, parameters };
-                }
-                const url = parameters.url;
-                if (!url) {
-                    return { success: false, output: '', error: 'Missing required parameter: url', tool, parameters };
-                }
-                try {
-                    new URL(url);
-                }
-                catch {
-                    return { success: false, output: '', error: 'Invalid URL format', tool, parameters };
-                }
-                const args = { url };
-                if (parameters.format)
-                    args.return_format = parameters.format;
-                const result = await callZaiMcp(mcpConfig.endpoints.webReader, 'webReader', args, mcpConfig.apiKey);
-                const output = result.length > 15000 ? result.substring(0, 15000) + '\n\n... (truncated)' : result;
-                return { success: true, output, tool, parameters };
-            }
-            case 'github_read': {
-                const mcpConfig = getZaiMcpConfig();
-                if (!mcpConfig) {
-                    return { success: false, output: '', error: 'github_read requires a Z.AI API key. Configure one via /provider z.ai', tool, parameters };
-                }
-                const repo = parameters.repo;
-                const action = parameters.action;
-                if (!repo) {
-                    return { success: false, output: '', error: 'Missing required parameter: repo', tool, parameters };
-                }
-                if (!repo.includes('/')) {
-                    return { success: false, output: '', error: 'Invalid repo format. Use owner/repo (e.g. facebook/react)', tool, parameters };
-                }
-                if (!action || !['search', 'tree', 'read_file'].includes(action)) {
-                    return { success: false, output: '', error: 'Invalid action. Must be: search, tree, or read_file', tool, parameters };
-                }
-                let mcpToolName;
-                const args = { repo_name: repo };
-                if (action === 'search') {
-                    mcpToolName = 'search_doc';
-                    const query = parameters.query;
-                    if (!query) {
-                        return { success: false, output: '', error: 'Missing required parameter: query (for action=search)', tool, parameters };
-                    }
-                    args.query = query;
-                }
-                else if (action === 'tree') {
-                    mcpToolName = 'get_repo_structure';
-                    if (parameters.path)
-                        args.dir_path = parameters.path;
-                }
-                else {
-                    mcpToolName = 'read_file';
-                    const filePath = parameters.path;
-                    if (!filePath) {
-                        return { success: false, output: '', error: 'Missing required parameter: path (for action=read_file)', tool, parameters };
-                    }
-                    args.file_path = filePath;
-                }
-                const result = await callZaiMcp(mcpConfig.endpoints.zread, mcpToolName, args, mcpConfig.apiKey);
-                const output = result.length > 15000 ? result.substring(0, 15000) + '\n\n... (truncated)' : result;
-                return { success: true, output, tool, parameters };
-            }
-            // === MiniMax MCP Tools ===
-            case 'minimax_web_search': {
-                const mmConfig = getMinimaxMcpConfig();
-                if (!mmConfig) {
-                    return { success: false, output: '', error: 'minimax_web_search requires a MiniMax API key. Configure one via /provider minimax', tool, parameters };
-                }
-                const query = parameters.query;
-                if (!query) {
-                    return { success: false, output: '', error: 'Missing required parameter: query', tool, parameters };
-                }
-                const result = await callMinimaxApi(mmConfig.host, '/v1/coding_plan/search', { q: query }, mmConfig.apiKey);
-                const output = result.length > 15000 ? result.substring(0, 15000) + '\n\n... (truncated)' : result;
-                return { success: true, output, tool, parameters };
-            }
-            case 'minimax_understand_image': {
-                const mmConfig = getMinimaxMcpConfig();
-                if (!mmConfig) {
-                    return { success: false, output: '', error: 'minimax_understand_image requires a MiniMax API key. Configure one via /provider minimax', tool, parameters };
-                }
-                const prompt = parameters.prompt;
-                const imageUrl = parameters.image_url;
-                if (!prompt) {
-                    return { success: false, output: '', error: 'Missing required parameter: prompt', tool, parameters };
-                }
-                if (!imageUrl) {
-                    return { success: false, output: '', error: 'Missing required parameter: image_url', tool, parameters };
-                }
-                const result = await callMinimaxApi(mmConfig.host, '/v1/coding_plan/vlm', { prompt, image_url: imageUrl }, mmConfig.apiKey);
-                const output = result.length > 15000 ? result.substring(0, 15000) + '\n\n... (truncated)' : result;
-                return { success: true, output, tool, parameters };
-            }
-            default:
-                return { success: false, output: '', error: `Unknown tool: ${tool}`, tool, parameters };
-        }
-    }
-    catch (error) {
-        const err = error;
-        return { success: false, output: '', error: err.message, tool, parameters };
-    }
-}
-/**
- * List directory contents
- */
-function listDirectory(dir, projectRoot, recursive, prefix = '', ignoreRules) {
-    const entries = readdirSync(dir, { withFileTypes: true });
-    const files = [];
-    const rules = ignoreRules || loadIgnoreRules(projectRoot);
-    for (const entry of entries) {
-        const fullPath = join(dir, entry.name);
-        // Skip ignored paths
-        if (isIgnored(fullPath, rules))
-            continue;
-        if (entry.isDirectory()) {
-            files.push(`${prefix}${entry.name}/`);
-            if (recursive) {
-                const subFiles = listDirectory(fullPath, projectRoot, true, prefix + '  ', rules);
-                files.push(...subFiles);
-            }
-        }
-        else {
-            files.push(`${prefix}${entry.name}`);
-        }
-    }
-    return files;
-}
-/**
- * Convert HTML to readable plain text, preserving structure.
- */
-function htmlToText(html) {
-    // Remove invisible elements
-    let text = html
-        .replace(/<script[^>]*>[\s\S]*?<\/script>/gi, '')
-        .replace(/<style[^>]*>[\s\S]*?<\/style>/gi, '')
-        .replace(/<noscript[^>]*>[\s\S]*?<\/noscript>/gi, '')
-        .replace(/<svg[^>]*>[\s\S]*?<\/svg>/gi, '')
-        .replace(/<!--[\s\S]*?-->/g, '');
-    // Try to extract <main>, <article>, or <body> content for less noise
-    const mainMatch = text.match(/<main[^>]*>([\s\S]*?)<\/main>/i);
-    const articleMatch = text.match(/<article[^>]*>([\s\S]*?)<\/article>/i);
-    const bodyMatch = text.match(/<body[^>]*>([\s\S]*?)<\/body>/i);
-    text = mainMatch?.[1] || articleMatch?.[1] || bodyMatch?.[1] || text;
-    // Headings → prefix with # markers + newlines
-    text = text.replace(/<h1[^>]*>([\s\S]*?)<\/h1>/gi, '\n\n# $1\n\n');
-    text = text.replace(/<h2[^>]*>([\s\S]*?)<\/h2>/gi, '\n\n## $1\n\n');
-    text = text.replace(/<h3[^>]*>([\s\S]*?)<\/h3>/gi, '\n\n### $1\n\n');
-    text = text.replace(/<h[4-6][^>]*>([\s\S]*?)<\/h[4-6]>/gi, '\n\n#### $1\n\n');
-    // Links → [text](href)
-    text = text.replace(/<a[^>]+href="([^"]*)"[^>]*>([\s\S]*?)<\/a>/gi, '[$2]($1)');
-    // Code blocks
-    text = text.replace(/<pre[^>]*><code[^>]*>([\s\S]*?)<\/code><\/pre>/gi, '\n```\n$1\n```\n');
-    text = text.replace(/<pre[^>]*>([\s\S]*?)<\/pre>/gi, '\n```\n$1\n```\n');
-    text = text.replace(/<code[^>]*>([\s\S]*?)<\/code>/gi, '`$1`');
-    // Lists
-    text = text.replace(/<li[^>]*>([\s\S]*?)<\/li>/gi, '\n- $1');
-    text = text.replace(/<\/[uo]l>/gi, '\n');
-    text = text.replace(/<[uo]l[^>]*>/gi, '\n');
-    // Block elements → newlines
-    text = text.replace(/<\/p>/gi, '\n\n');
-    text = text.replace(/<br\s*\/?>/gi, '\n');
-    text = text.replace(/<\/div>/gi, '\n');
-    text = text.replace(/<\/tr>/gi, '\n');
-    text = text.replace(/<\/th>/gi, '\t');
-    text = text.replace(/<\/td>/gi, '\t');
-    text = text.replace(/<hr[^>]*>/gi, '\n---\n');
-    text = text.replace(/<\/blockquote>/gi, '\n');
-    text = text.replace(/<blockquote[^>]*>/gi, '\n> ');
-    // Bold/italic
-    text = text.replace(/<(strong|b)[^>]*>([\s\S]*?)<\/\1>/gi, '**$2**');
-    text = text.replace(/<(em|i)[^>]*>([\s\S]*?)<\/\1>/gi, '*$2*');
-    // Strip remaining tags
-    text = text.replace(/<[^>]+>/g, '');
-    // Decode common HTML entities
-    text = text
-        .replace(/&amp;/g, '&')
-        .replace(/&lt;/g, '<')
-        .replace(/&gt;/g, '>')
-        .replace(/&quot;/g, '"')
-        .replace(/&#39;/g, "'")
-        .replace(/&nbsp;/g, ' ')
-        .replace(/&#(\d+);/g, (_, code) => String.fromCharCode(parseInt(code)))
-        .replace(/&#x([0-9a-f]+);/gi, (_, code) => String.fromCharCode(parseInt(code, 16)));
-    // Clean up whitespace
-    text = text
-        .replace(/[ \t]+/g, ' ') // Collapse horizontal whitespace
-        .replace(/ *\n/g, '\n') // Trim trailing spaces on lines
-        .replace(/\n{3,}/g, '\n\n') // Max 2 consecutive newlines
-        .trim();
-    return text;
-}
-/**
- * Create action log from tool result
- */
-export function createActionLog(toolCall, result) {
-    // Normalize tool name to handle case variations
-    const normalizedTool = normalizeToolName(toolCall.tool);
-    const typeMap = {
-        read_file: 'read',
-        write_file: 'write',
-        edit_file: 'edit',
-        delete_file: 'delete',
-        execute_command: 'command',
-        search_code: 'search',
-        list_files: 'list',
-        create_directory: 'mkdir',
-        find_files: 'search',
-        fetch_url: 'fetch',
-        web_search: 'fetch',
-        web_read: 'fetch',
-        github_read: 'fetch',
-        minimax_web_search: 'fetch',
-        minimax_understand_image: 'fetch',
-    };
-    const target = toolCall.parameters.path ||
-        toolCall.parameters.command ||
-        toolCall.parameters.pattern ||
-        toolCall.parameters.url ||
-        toolCall.parameters.query ||
-        toolCall.parameters.repo ||
-        'unknown';
-    // For write/edit actions, include FULL content in details for live code view
-    let details;
-    if (result.success) {
-        if (normalizedTool === 'write_file' && toolCall.parameters.content) {
-            // Show FULL content being written - for live code tracking
-            details = toolCall.parameters.content;
-        }
-        else if (normalizedTool === 'edit_file' && toolCall.parameters.new_text) {
-            // Show FULL new text being inserted - for live code tracking
-            details = toolCall.parameters.new_text;
-        }
-        else if (normalizedTool === 'execute_command') {
-            // Show command output (limited)
-            details = result.output.slice(0, 1000);
-        }
-        else {
-            details = result.output.slice(0, 500);
-        }
-    }
-    else {
-        details = result.error;
-    }
-    return {
-        type: typeMap[normalizedTool] || 'command',
-        target,
-        result: result.success ? 'success' : 'error',
-        details,
-        timestamp: Date.now(),
-    };
-}
+// Re-export from sub-modules so existing imports don't break
+export { normalizeToolName, parseOpenAIToolCalls, parseAnthropicToolCalls, parseToolCalls } from './toolParsing.js';
+export { executeTool, validatePath, createActionLog } from './toolExecution.js';