codeep 1.3.42 → 2.0.0

package/dist/utils/toolExecution.js

@@ -14,6 +14,8 @@ import { loadIgnoreRules, isIgnored } from './gitignore.js';
 import { normalizeToolName } from './toolParsing.js';
 import { getZaiMcpConfig, getZaiVisionConfig, getMinimaxMcpConfig, callZaiMcp, callZaiVisionApi, callMinimaxApi } from './mcpIntegration.js';
 import { logger } from './logger.js';
+import { runHook } from './hooks.js';
+import { isMcpToolName, callSessionTool, isVirtualMcpToolName, callSessionVirtualTool } from './mcpRegistry.js';
 const debug = (...args) => {
     if (process.env.CODEEP_DEBUG === '1') {
         logger.debug(args.map(String).join(' '));
@@ -146,11 +148,114 @@ function htmlToText(html) {
 }
 /**
  * Execute a tool call and return the result.
+ *
+ * `fs` is optional — if provided and the relevant method is defined, file
+ * read/write is delegated to the client. Otherwise we fall back to direct
+ * disk I/O. A delegated call that throws also falls back to disk so a
+ * single client hiccup doesn't kill the agent loop.
  */
-export async function executeTool(toolCall, projectRoot) {
+export async function executeTool(toolCall, projectRoot, fs, mcpSessionId) {
     const tool = normalizeToolName(toolCall.tool);
     const parameters = toolCall.parameters;
     debug(`Executing tool: ${tool}`, parameters.path || parameters.command || '');
+    // pre_tool_call hook runs first, even for MCP tools. A `pre_tool_call`
+    // script is the policy gate (block writes to certain dirs, refuse risky
+    // commands, deny outbound calls to specific MCP servers, etc.), so
+    // letting MCP traffic bypass it would defeat the gate's purpose.
+    // Failing closed is the safe default.
+    const preHook = runHook({ event: 'pre_tool_call', workspaceRoot: projectRoot, toolName: tool, toolParams: parameters });
+    if (preHook.blocked) {
+        const msg = preHook.stderr?.trim() || preHook.stdout?.trim() || `pre_tool_call hook exited ${preHook.exitCode}`;
+        return {
+            success: false,
+            output: '',
+            error: `Blocked by pre_tool_call hook: ${msg}`,
+            tool,
+            parameters,
+        };
+    }
+    // MCP-prefixed tool names (`<server>__<tool>`) route through the
+    // per-session MCP registry. We still fire on_error so logging hooks
+    // see MCP failures the same way they see built-in failures, but skip
+    // post_edit — MCP tools aren't file-edit operations in the local sense
+    // (they may do anything; we don't have enough info to call it an edit).
+    //
+    // IMPORTANT: lookup uses the RAW tool name from the model, not the
+    // normalized one. `normalizeToolName` lowercases and converts hyphens
+    // to underscores — fine for built-in tools, but it mangles MCP server
+    // names that legitimately contain hyphens (e.g. `my-fs__read_file`
+    // would become `my_fs__read_file` and miss the registry lookup).
+    const rawTool = toolCall.tool;
+    // invoke_skill — agent-driven skill bundle invocation. Returns the
+    // bundle's SKILL.md body so the agent can read its instructions in
+    // the next iteration. Project-scoped bundles win over global.
+    if (rawTool === 'invoke_skill') {
+        const name = String(parameters.name ?? '').trim();
+        if (!name) {
+            return { success: false, output: '', error: 'invoke_skill requires a `name` argument', tool: rawTool, parameters };
+        }
+        try {
+            const { findSkillBundle } = await import('./skillBundles.js');
+            const bundle = findSkillBundle(name, projectRoot);
+            if (!bundle) {
+                return { success: false, output: '', error: `Skill "${name}" not found. Use the catalog in your system prompt or ask the user to /skills bundles.`, tool: rawTool, parameters };
+            }
+            // Prefix the body with a header so the model sees clear framing.
+            const output = `# Skill: ${bundle.name}\n_${bundle.description}_\n\n${bundle.body}`;
+            return { success: true, output, tool: rawTool, parameters };
+        }
+        catch (err) {
+            return { success: false, output: '', error: err.message, tool: rawTool, parameters };
+        }
+    }
+    if (isMcpToolName(rawTool) && mcpSessionId) {
+        let result;
+        try {
+            // Virtual wrappers (resource_list / resource_read / prompt_list /
+            // prompt_get) live in mcpRegistry alongside the real tools. We
+            // dispatch them through their own helper so the registry stays the
+            // single source of truth for what's namespaced under each server.
+            const output = isVirtualMcpToolName(rawTool)
+                ? await callSessionVirtualTool(mcpSessionId, rawTool, parameters)
+                : await callSessionTool(mcpSessionId, rawTool, parameters);
+            result = { success: true, output, tool: rawTool, parameters };
+        }
+        catch (err) {
+            result = { success: false, output: '', error: err.message, tool: rawTool, parameters };
+        }
+        if (!result.success) {
+            runHook({ event: 'on_error', workspaceRoot: projectRoot, toolName: rawTool, toolParams: parameters });
+        }
+        return result;
+    }
+    // Wrap the original dispatch so we can run on_error / post_edit hooks
+    // around it without indenting every case.
+    const result = await dispatchTool(tool, parameters, projectRoot, fs, toolCall);
+    if (!result.success) {
+        runHook({
+            event: 'on_error',
+            workspaceRoot: projectRoot,
+            toolName: tool,
+            toolParams: parameters,
+        });
+    }
+    else if (tool === 'write_file' || tool === 'edit_file') {
+        const filePath = parameters.path;
+        if (filePath) {
+            const abs = isAbsolute(filePath) ? filePath : join(projectRoot, filePath);
+            // post_edit is advisory — non-zero exit doesn't roll back the write.
+            // Typical use is `prettier --write "$CODEEP_HOOK_FILE"`.
+            runHook({
+                event: 'post_edit',
+                workspaceRoot: projectRoot,
+                toolName: tool,
+                filePath: abs,
+            });
+        }
+    }
+    return result;
+}
+async function dispatchTool(tool, parameters, projectRoot, fs, toolCall) {
     try {
         switch (tool) {
             case 'read_file': {
@@ -160,6 +265,28 @@ export async function executeTool(toolCall, projectRoot) {
                 const validation = validatePath(path, projectRoot);
                 if (!validation.valid)
                     return { success: false, output: '', error: validation.error, tool, parameters };
+                // Try client delegation first. The client owns the source of truth
+                // for unsaved buffers, so we prefer it even if the file also exists
+                // on disk. The 100 KB cap below is enforced on the delegated result
+                // too — a malicious or misconfigured client could otherwise return
+                // an arbitrarily large blob that blows up the agent's context.
+                if (fs?.readTextFile) {
+                    try {
+                        const content = await fs.readTextFile(validation.absolutePath);
+                        // Cap is on character count, not raw bytes — JS strings are
+                        // UTF-16 in memory, so 100K chars ≈ 200K bytes of process
+                        // memory plus whatever the model context costs. Either way,
+                        // a 1GB blob from a misbehaving client gets rejected here.
+                        if (content.length > 100 * 1024) {
+                            return { success: false, output: '', error: `File too large (${content.length} chars via client). Max: 100K chars`, tool, parameters };
+                        }
+                        return { success: true, output: content, tool, parameters };
+                    }
+                    catch (err) {
+                        debug('fs/read_text_file delegation failed, falling back to disk:', err);
+                        // fall through to disk read
+                    }
+                }
                 if (!existsSync(validation.absolutePath))
                     return { success: false, output: '', error: `File not found: ${path}`, tool, parameters };
                 const stat = statSync(validation.absolutePath);
@@ -183,12 +310,30 @@ export async function executeTool(toolCall, projectRoot) {
                 const validation = validatePath(path, projectRoot);
                 if (!validation.valid)
                     return { success: false, output: '', error: validation.error, tool, parameters };
+                // Client delegation: lets editors keep dirty buffers, undo history,
+                // and lint-on-save reactions consistent. The client is responsible
+                // for creating parent directories — VS Code's WorkspaceEdit does;
+                // for the disk fallback below we do it ourselves.
+                if (fs?.writeTextFile) {
+                    try {
+                        const existed = existsSync(validation.absolutePath);
+                        await fs.writeTextFile(validation.absolutePath, content);
+                        // Only record after the write actually succeeded — otherwise a
+                        // failed delegation that falls through to disk would double-log.
+                        recordWrite(validation.absolutePath);
+                        return { success: true, output: `${existed ? 'Updated' : 'Created'} file: ${path}`, tool, parameters };
+                    }
+                    catch (err) {
+                        debug('fs/write_text_file delegation failed, falling back to disk:', err);
+                        // fall through to disk write
+                    }
+                }
                 const dir = dirname(validation.absolutePath);
                 if (!existsSync(dir))
                     mkdirSync(dir, { recursive: true });
-                recordWrite(validation.absolutePath);
                 const existed = existsSync(validation.absolutePath);
                 writeFileSync(validation.absolutePath, content, 'utf-8');
+                recordWrite(validation.absolutePath);
                 return { success: true, output: `${existed ? 'Updated' : 'Created'} file: ${path}`, tool, parameters };
             }
             case 'edit_file': {
@@ -201,9 +346,27 @@ export async function executeTool(toolCall, projectRoot) {
                 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');
+                // Read through the client when delegation is available — the dirty
+                // buffer in the editor is the authoritative version for an edit.
+                let content;
+                let readDelegated = false;
+                if (fs?.readTextFile) {
+                    try {
+                        content = await fs.readTextFile(validation.absolutePath);
+                        readDelegated = true;
+                    }
+                    catch (err) {
+                        debug('fs/read_text_file (in edit_file) failed, falling back to disk:', err);
+                        if (!existsSync(validation.absolutePath))
+                            return { success: false, output: '', error: `File not found: ${path}`, tool, parameters };
+                        content = readFileSync(validation.absolutePath, 'utf-8');
+                    }
+                }
+                else {
+                    if (!existsSync(validation.absolutePath))
+                        return { success: false, output: '', error: `File not found: ${path}`, tool, parameters };
+                    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 };
                 }
@@ -217,7 +380,22 @@ export async function executeTool(toolCall, projectRoot) {
                     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 };
                 }
                 recordEdit(validation.absolutePath);
-                writeFileSync(validation.absolutePath, content.replace(oldText, newText), 'utf-8');
+                const updated = content.replace(oldText, newText);
+                if (fs?.writeTextFile) {
+                    try {
+                        await fs.writeTextFile(validation.absolutePath, updated);
+                        return { success: true, output: `Edited file: ${path}`, tool, parameters };
+                    }
+                    catch (err) {
+                        debug('fs/write_text_file (in edit_file) failed, falling back to disk:', err);
+                        // If we read through the client but write back to disk, the
+                        // editor's dirty buffer could be discarded next save. Log and
+                        // continue — better than silently dropping the edit.
+                        if (readDelegated)
+                            debug('warning: edit_file read via client but writing to disk');
+                    }
+                }
+                writeFileSync(validation.absolutePath, updated, 'utf-8');
                 return { success: true, output: `Edited file: ${path}`, tool, parameters };
             }
             case 'delete_file': {

package/dist/utils/tools.d.ts

@@ -312,16 +312,32 @@ export declare const AGENT_TOOLS: {
     };
 };
 /**
- * Format tool definitions for system prompt (text-based fallback)
+ * Shape of additional (non-built-in) tools merged into the agent's catalog.
+ * Used by MCP integration — the registered tool's prefixed name and the raw
+ * MCP `tools/list` schema are both passed through.
  */
-export declare function formatToolDefinitions(): string;
+export interface AdditionalToolDef {
+    /** Name the agent must use to invoke this tool (e.g. `fs__read_file`). */
+    name: string;
+    description?: string;
+    /** JSON-schema-like `input_schema` from the MCP server's tools/list reply. */
+    inputSchema?: Record<string, unknown>;
+}
+/**
+ * Format tool definitions for system prompt (text-based fallback).
+ * Optionally appends an "Additional tools" section listing tools from
+ * sources outside the built-in catalog (currently MCP servers).
+ */
+export declare function formatToolDefinitions(additionalTools?: AdditionalToolDef[]): string;
 /**
- * Get tools in OpenAI Function Calling format
+ * Get tools in OpenAI Function Calling format.
+ * Additional tools (e.g. MCP) are appended with their JSON-schema as-is.
  */
-export declare function getOpenAITools(): OpenAITool[];
+export declare function getOpenAITools(additionalTools?: AdditionalToolDef[]): OpenAITool[];
 /**
- * Get tools in Anthropic Tool Use format
+ * Get tools in Anthropic Tool Use format.
+ * Additional tools (e.g. MCP) are appended with their JSON-schema as-is.
  */
-export declare function getAnthropicTools(): AnthropicTool[];
+export declare function getAnthropicTools(additionalTools?: AdditionalToolDef[]): AnthropicTool[];
 export { normalizeToolName, parseOpenAIToolCalls, parseAnthropicToolCalls, parseToolCalls } from './toolParsing';
 export { executeTool, validatePath, createActionLog } from './toolExecution';

package/dist/utils/tools.js

@@ -155,9 +155,11 @@ function getFilteredToolEntries() {
     });
 }
 /**
- * Format tool definitions for system prompt (text-based fallback)
+ * Format tool definitions for system prompt (text-based fallback).
+ * Optionally appends an "Additional tools" section listing tools from
+ * sources outside the built-in catalog (currently MCP servers).
  */
-export function formatToolDefinitions() {
+export function formatToolDefinitions(additionalTools) {
     const lines = [];
     for (const [name, tool] of getFilteredToolEntries()) {
         lines.push(`### ${name}`);
@@ -169,13 +171,64 @@ export function formatToolDefinitions() {
         }
         lines.push('');
     }
+    if (additionalTools?.length) {
+        // Token budget caps. MCP servers can return tools with absurdly verbose
+        // JSON Schema definitions (multi-KB per tool). Without caps a 30-tool
+        // server eats ~10K tokens of every prompt. Per-tool 2KB + total 16KB
+        // is enough for the model to learn parameter shapes without breaking
+        // the bank.
+        const PER_TOOL_CAP = 2048;
+        const TOTAL_CAP = 16_384;
+        let budget = TOTAL_CAP;
+        let skipped = 0;
+        lines.push('## Additional tools (from MCP servers)');
+        lines.push('');
+        for (const tool of additionalTools) {
+            if (budget <= 0) {
+                skipped++;
+                continue;
+            }
+            const headerLines = [`### ${tool.name}`];
+            if (tool.description)
+                headerLines.push(tool.description);
+            let schemaBlock = '';
+            if (tool.inputSchema) {
+                let schemaJson = JSON.stringify(tool.inputSchema, null, 2);
+                if (schemaJson.length > PER_TOOL_CAP) {
+                    schemaJson = schemaJson.slice(0, PER_TOOL_CAP) + `\n… (truncated, ${schemaJson.length - PER_TOOL_CAP} more chars)`;
+                }
+                schemaBlock = `Parameters (JSON Schema):\n\`\`\`json\n${schemaJson}\n\`\`\``;
+            }
+            const entry = [...headerLines, schemaBlock, ''].filter(Boolean).join('\n');
+            if (entry.length > budget) {
+                skipped++;
+                continue;
+            }
+            lines.push(entry);
+            budget -= entry.length;
+        }
+        if (skipped > 0) {
+            lines.push(`_(${skipped} more MCP tool${skipped === 1 ? '' : 's'} omitted — total catalog exceeded ${TOTAL_CAP}-char budget.)_`);
+        }
+    }
     return lines.join('\n');
 }
+/** Build a generic JSON-schema parameters object from an additional-tool spec.
+ * Falls back to a permissive `additionalProperties: true` schema if the MCP
+ * server didn't supply one — that lets the model still attempt the call. */
+function additionalToolSchema(tool) {
+    if (tool.inputSchema && typeof tool.inputSchema === 'object') {
+        // Most MCP servers already return a JSON-schema-shaped object.
+        return tool.inputSchema;
+    }
+    return { type: 'object', properties: {}, additionalProperties: true };
+}
 /**
- * Get tools in OpenAI Function Calling format
+ * Get tools in OpenAI Function Calling format.
+ * Additional tools (e.g. MCP) are appended with their JSON-schema as-is.
  */
-export function getOpenAITools() {
-    return getFilteredToolEntries().map(([name, tool]) => {
+export function getOpenAITools(additionalTools) {
+    const builtin = getFilteredToolEntries().map(([name, tool]) => {
         const properties = {};
         const required = [];
         for (const [param, info] of Object.entries(tool.parameters)) {
@@ -198,12 +251,26 @@ export function getOpenAITools() {
             },
         };
     });
+    if (!additionalTools?.length)
+        return builtin;
+    const extra = additionalTools.map(t => ({
+        type: 'function',
+        function: {
+            name: t.name,
+            description: t.description ?? `External tool: ${t.name}`,
+            // Cast — OpenAITool.function.parameters is statically typed for
+            // built-ins, but MCP schemas vary. The runtime API doesn't care.
+            parameters: additionalToolSchema(t),
+        },
+    }));
+    return [...builtin, ...extra];
 }
 /**
- * Get tools in Anthropic Tool Use format
+ * Get tools in Anthropic Tool Use format.
+ * Additional tools (e.g. MCP) are appended with their JSON-schema as-is.
  */
-export function getAnthropicTools() {
-    return getFilteredToolEntries().map(([name, tool]) => {
+export function getAnthropicTools(additionalTools) {
+    const builtin = getFilteredToolEntries().map(([name, tool]) => {
         const properties = {};
         const required = [];
         for (const [param, info] of Object.entries(tool.parameters)) {
@@ -223,6 +290,14 @@ export function getAnthropicTools() {
             input_schema: { type: 'object', properties, required },
         };
     });
+    if (!additionalTools?.length)
+        return builtin;
+    const extra = additionalTools.map(t => ({
+        name: t.name,
+        description: t.description ?? `External tool: ${t.name}`,
+        input_schema: additionalToolSchema(t),
+    }));
+    return [...builtin, ...extra];
 }
 // Re-export from sub-modules so existing imports don't break
 export { normalizeToolName, parseOpenAIToolCalls, parseAnthropicToolCalls, parseToolCalls } from './toolParsing.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeep",
-  "version": "1.3.42",
+  "version": "2.0.0",
   "description": "AI-powered coding assistant built for the terminal. Multiple LLM providers, project-aware context, and a seamless development workflow.",
   "type": "module",
   "main": "dist/index.js",
@@ -57,10 +57,11 @@
     "node": ">=20.0.0"
   },
   "files": [
-    "bin/**/*",
+    "bin/codeep.js",
     "dist/**/*",
     "!dist/**/*.test.js",
     "!dist/**/*.test.d.ts",
+    "!dist/zed/**",
     "README.md",
     "LICENSE"
   ],