codeep 1.2.11 → 1.2.13

package/bin/codeep.js

@@ -1,2 +1,14 @@
 #!/usr/bin/env node
-import '../dist/renderer/main.js';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { spawn } from 'child_process';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const main = join(__dirname, '..', 'dist', 'renderer', 'main.js');
+
+const child = spawn(process.execPath, [main, ...process.argv.slice(2)], {
+  stdio: 'inherit',
+  env: process.env,
+});
+
+child.on('exit', (code) => process.exit(code ?? 0));

package/dist/config/providers.d.ts

@@ -25,6 +25,11 @@ export interface ProviderConfig {
     defaultProtocol: 'openai' | 'anthropic';
     envKey?: string;
     subscribeUrl?: string;
+    mcpEndpoints?: {
+        webSearch?: string;
+        webReader?: string;
+        zread?: string;
+    };
 }
 export declare const PROVIDERS: Record<string, ProviderConfig>;
 export type ProviderId = keyof typeof PROVIDERS;
@@ -42,4 +47,5 @@ export declare function getProviderModels(providerId: string): {
 }[];
 export declare function getProviderBaseUrl(providerId: string, protocol: 'openai' | 'anthropic'): string | null;
 export declare function getProviderAuthHeader(providerId: string, protocol: 'openai' | 'anthropic'): 'Bearer' | 'x-api-key';
+export declare function getProviderMcpEndpoints(providerId: string): ProviderConfig['mcpEndpoints'] | null;
 export declare function supportsNativeTools(providerId: string, protocol: 'openai' | 'anthropic'): boolean;

package/dist/config/providers.js

@@ -26,6 +26,41 @@ export const PROVIDERS = {
         defaultProtocol: 'openai',
         envKey: 'ZAI_API_KEY',
         subscribeUrl: 'https://z.ai/subscribe?ic=NXYNXZOV14',
+        mcpEndpoints: {
+            webSearch: 'https://api.z.ai/api/mcp/web_search_prime/mcp',
+            webReader: 'https://api.z.ai/api/mcp/web_reader/mcp',
+            zread: 'https://api.z.ai/api/mcp/zread/mcp',
+        },
+    },
+    'z.ai-cn': {
+        name: 'Z.AI China (ZhipuAI)',
+        description: 'GLM Coding Plan (China)',
+        protocols: {
+            openai: {
+                baseUrl: 'https://open.bigmodel.cn/api/coding/paas/v4',
+                authHeader: 'Bearer',
+                supportsNativeTools: true,
+            },
+            anthropic: {
+                baseUrl: 'https://open.bigmodel.cn/api/anthropic',
+                authHeader: 'x-api-key',
+                supportsNativeTools: true,
+            },
+        },
+        models: [
+            { id: 'glm-5', name: 'GLM-5', description: 'Most capable GLM model (Pro/Max subscription)' },
+            { id: 'glm-4.7', name: 'GLM-4.7', description: 'Latest GLM model' },
+            { id: 'glm-4.7-flash', name: 'GLM-4.7 Flash', description: 'Faster, lighter version' },
+        ],
+        defaultModel: 'glm-4.7',
+        defaultProtocol: 'openai',
+        envKey: 'ZAI_CN_API_KEY',
+        subscribeUrl: 'https://open.bigmodel.cn/glm-coding',
+        mcpEndpoints: {
+            webSearch: 'https://open.bigmodel.cn/api/mcp/web_search_prime/mcp',
+            webReader: 'https://open.bigmodel.cn/api/mcp/web_reader/mcp',
+            zread: 'https://open.bigmodel.cn/api/mcp/zread/mcp',
+        },
     },
     'minimax': {
         name: 'MiniMax',
@@ -43,9 +78,9 @@ export const PROVIDERS = {
             },
         },
         models: [
-            { id: 'MiniMax-M2.1', name: 'MiniMax M2.1', description: 'Latest MiniMax coding model' },
+            { id: 'MiniMax-M2.5', name: 'MiniMax M2.5', description: 'Latest MiniMax coding model' },
         ],
-        defaultModel: 'MiniMax-M2.1',
+        defaultModel: 'MiniMax-M2.5',
         defaultProtocol: 'anthropic',
         envKey: 'MINIMAX_API_KEY',
         subscribeUrl: 'https://platform.minimax.io/subscribe/coding-plan?code=2lWvoWUhrp&source=link',
@@ -116,6 +151,10 @@ export function getProviderAuthHeader(providerId, protocol) {
         return 'Bearer';
     return provider.protocols[protocol]?.authHeader || 'Bearer';
 }
+export function getProviderMcpEndpoints(providerId) {
+    const provider = PROVIDERS[providerId];
+    return provider?.mcpEndpoints || null;
+}
 export function supportsNativeTools(providerId, protocol) {
     const provider = PROVIDERS[providerId];
     if (!provider)

package/dist/config/providers.test.js

@@ -1,11 +1,15 @@
 import { describe, it, expect } from 'vitest';
-import { PROVIDERS, getProvider, getProviderList, getProviderModels, getProviderBaseUrl, getProviderAuthHeader, } from './providers.js';
+import { PROVIDERS, getProvider, getProviderList, getProviderModels, getProviderBaseUrl, getProviderAuthHeader, getProviderMcpEndpoints, } from './providers.js';
 describe('providers', () => {
     describe('PROVIDERS constant', () => {
         it('should have z.ai provider', () => {
             expect(PROVIDERS['z.ai']).toBeDefined();
             expect(PROVIDERS['z.ai'].name).toBe('Z.AI (ZhipuAI)');
         });
+        it('should have z.ai-cn provider', () => {
+            expect(PROVIDERS['z.ai-cn']).toBeDefined();
+            expect(PROVIDERS['z.ai-cn'].name).toBe('Z.AI China (ZhipuAI)');
+        });
         it('should have minimax provider', () => {
             expect(PROVIDERS['minimax']).toBeDefined();
             expect(PROVIDERS['minimax'].name).toBe('MiniMax');
@@ -68,10 +72,11 @@ describe('providers', () => {
                 expect(item.description).toBeDefined();
             }
         });
-        it('should include z.ai and minimax', () => {
+        it('should include z.ai, z.ai-cn, and minimax', () => {
             const list = getProviderList();
             const ids = list.map(p => p.id);
             expect(ids).toContain('z.ai');
+            expect(ids).toContain('z.ai-cn');
             expect(ids).toContain('minimax');
         });
     });
@@ -125,8 +130,32 @@ describe('providers', () => {
         it('should have env key for z.ai', () => {
             expect(PROVIDERS['z.ai'].envKey).toBe('ZAI_API_KEY');
         });
+        it('should have env key for z.ai-cn', () => {
+            expect(PROVIDERS['z.ai-cn'].envKey).toBe('ZAI_CN_API_KEY');
+        });
         it('should have env key for minimax', () => {
             expect(PROVIDERS['minimax'].envKey).toBe('MINIMAX_API_KEY');
         });
     });
+    describe('MCP endpoints', () => {
+        it('should have MCP endpoints for z.ai', () => {
+            const endpoints = getProviderMcpEndpoints('z.ai');
+            expect(endpoints).not.toBeNull();
+            expect(endpoints.webSearch).toContain('api.z.ai');
+            expect(endpoints.webReader).toContain('api.z.ai');
+            expect(endpoints.zread).toContain('api.z.ai');
+        });
+        it('should have MCP endpoints for z.ai-cn', () => {
+            const endpoints = getProviderMcpEndpoints('z.ai-cn');
+            expect(endpoints).not.toBeNull();
+            expect(endpoints.webSearch).toContain('open.bigmodel.cn');
+            expect(endpoints.webReader).toContain('open.bigmodel.cn');
+            expect(endpoints.zread).toContain('open.bigmodel.cn');
+        });
+        it('should return null for providers without MCP endpoints', () => {
+            expect(getProviderMcpEndpoints('minimax')).toBeNull();
+            expect(getProviderMcpEndpoints('deepseek')).toBeNull();
+            expect(getProviderMcpEndpoints('nonexistent')).toBeNull();
+        });
+    });
 });

package/dist/utils/agent.js

@@ -919,7 +919,7 @@ export async function runAgent(prompt, projectContext, options = {}) {
                 }
                 else {
                     // Actually execute the tool
-                    toolResult = executeTool(toolCall, projectContext.root || process.cwd());
+                    toolResult = await executeTool(toolCall, projectContext.root || process.cwd());
                 }
                 opts.onToolResult?.(toolResult, toolCall);
                 // Log action
@@ -1010,7 +1010,7 @@ export async function runAgent(prompt, projectContext, options = {}) {
                         const fixResults = [];
                         for (const toolCall of fixToolCalls) {
                             opts.onToolCall?.(toolCall);
-                            const toolResult = executeTool(toolCall, projectContext.root || process.cwd());
+                            const toolResult = await executeTool(toolCall, projectContext.root || process.cwd());
                             opts.onToolResult?.(toolResult, toolCall);
                             const actionLog = createActionLog(toolCall, toolResult);
                             actions.push(actionLog);

package/dist/utils/tools.d.ts

@@ -199,10 +199,70 @@ export declare const AGENT_TOOLS: {
             };
         };
     };
+    web_search: {
+        name: string;
+        description: string;
+        parameters: {
+            query: {
+                type: string;
+                description: string;
+                required: boolean;
+            };
+            domain_filter: {
+                type: string;
+                description: string;
+                required: boolean;
+            };
+            recency: {
+                type: string;
+                description: string;
+                required: boolean;
+            };
+        };
+    };
+    web_read: {
+        name: string;
+        description: string;
+        parameters: {
+            url: {
+                type: string;
+                description: string;
+                required: boolean;
+            };
+            format: {
+                type: string;
+                description: string;
+                required: boolean;
+            };
+        };
+    };
+    github_read: {
+        name: string;
+        description: string;
+        parameters: {
+            repo: {
+                type: string;
+                description: string;
+                required: boolean;
+            };
+            action: {
+                type: string;
+                description: string;
+                required: boolean;
+            };
+            query: {
+                type: string;
+                description: string;
+                required: boolean;
+            };
+            path: {
+                type: string;
+                description: string;
+                required: boolean;
+            };
+        };
+    };
 };
-/**
- * Format tool definitions for system prompt (text-based fallback)
- */
 export declare function formatToolDefinitions(): string;
 /**
  * Get tools in OpenAI Function Calling format
@@ -230,7 +290,7 @@ export declare function parseToolCalls(response: string): ToolCall[];
 /**
  * Execute a tool call
  */
-export declare function executeTool(toolCall: ToolCall, projectRoot: string): ToolResult;
+export declare function executeTool(toolCall: ToolCall, projectRoot: string): Promise<ToolResult>;
 /**
  * Create action log from tool result
  */

package/dist/utils/tools.js

@@ -12,6 +12,84 @@ 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 } 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'];
+/**
+ * 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;
+}
+/**
+ * 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);
+    }
+}
 // Tool definitions for system prompt
 export const AGENT_TOOLS = {
     read_file: {
@@ -91,13 +169,51 @@ export const AGENT_TOOLS = {
             url: { type: 'string', description: 'The URL to fetch content from', required: true },
         },
     },
+    web_search: {
+        name: 'web_search',
+        description: 'Search the web for real-time information. Returns titles, URLs, and summaries. Requires a Z.AI API key.',
+        parameters: {
+            query: { type: 'string', description: 'Search query', required: true },
+            domain_filter: { type: 'string', description: 'Limit results to specific domain (e.g. github.com)', required: false },
+            recency: { type: 'string', description: 'Time filter: oneDay, oneWeek, oneMonth, oneYear, noLimit', required: false },
+        },
+    },
+    web_read: {
+        name: 'web_read',
+        description: 'Fetch and parse a web page into clean readable text/markdown. Better than fetch_url for documentation and articles. Requires a Z.AI API key.',
+        parameters: {
+            url: { type: 'string', description: 'The URL to read', required: true },
+            format: { type: 'string', description: 'Output format: markdown or text (default: markdown)', required: false },
+        },
+    },
+    github_read: {
+        name: 'github_read',
+        description: 'Search documentation/code or read files from a public GitHub repository. Requires a Z.AI API key.',
+        parameters: {
+            repo: { type: 'string', description: 'GitHub repository in owner/repo format (e.g. facebook/react)', required: true },
+            action: { type: 'string', description: 'Action: search, tree, or read_file', required: true },
+            query: { type: 'string', description: 'Search query (for action=search)', required: false },
+            path: { type: 'string', description: 'File path (for action=read_file) or directory path (for action=tree)', required: false },
+        },
+    },
 };
 /**
  * Format tool definitions for system prompt (text-based fallback)
  */
+/**
+ * Get filtered tool entries (excludes Z.AI-only tools when not using Z.AI provider)
+ */
+function getFilteredToolEntries() {
+    const hasMcp = hasZaiMcpAccess();
+    return Object.entries(AGENT_TOOLS).filter(([name]) => {
+        if (ZAI_MCP_TOOLS.includes(name))
+            return hasMcp;
+        return true;
+    });
+}
 export function formatToolDefinitions() {
     const lines = [];
-    for (const [name, tool] of Object.entries(AGENT_TOOLS)) {
+    for (const [name, tool] of getFilteredToolEntries()) {
         lines.push(`### ${name}`);
         lines.push(tool.description);
         lines.push('Parameters:');
@@ -113,7 +229,7 @@ export function formatToolDefinitions() {
  * Get tools in OpenAI Function Calling format
  */
 export function getOpenAITools() {
-    return Object.entries(AGENT_TOOLS).map(([name, tool]) => {
+    return getFilteredToolEntries().map(([name, tool]) => {
         const properties = {};
         const required = [];
         for (const [param, info] of Object.entries(tool.parameters)) {
@@ -153,7 +269,7 @@ export function getOpenAITools() {
  * Get tools in Anthropic Tool Use format
  */
 export function getAnthropicTools() {
-    return Object.entries(AGENT_TOOLS).map(([name, tool]) => {
+    return getFilteredToolEntries().map(([name, tool]) => {
         const properties = {};
         const required = [];
         for (const [param, info] of Object.entries(tool.parameters)) {
@@ -609,7 +725,7 @@ function validatePath(path, projectRoot) {
 /**
  * Execute a tool call
  */
-export function executeTool(toolCall, projectRoot) {
+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;
@@ -899,6 +1015,90 @@ export function executeTool(toolCall, projectRoot) {
                     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 };
+            }
             default:
                 return { success: false, output: '', error: `Unknown tool: ${tool}`, tool, parameters };
         }
@@ -1014,11 +1214,16 @@ export function createActionLog(toolCall, result) {
         create_directory: 'mkdir',
         find_files: 'search',
         fetch_url: 'fetch',
+        web_search: 'fetch',
+        web_read: 'fetch',
+        github_read: '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;

package/dist/utils/tools.test.js

@@ -2,11 +2,15 @@ import { describe, it, expect } from 'vitest';
 import { getOpenAITools, getAnthropicTools, parseToolCalls, parseOpenAIToolCalls, parseAnthropicToolCalls, createActionLog, AGENT_TOOLS, } from './tools.js';
 // ─── CONSTANTS ───────────────────────────────────────────────────────────────
 const ALL_TOOL_NAMES = Object.keys(AGENT_TOOLS);
+// MCP tools are filtered out when no Z.AI API key is configured (e.g. in tests)
+const ZAI_MCP_TOOLS = ['web_search', 'web_read', 'github_read'];
+const CORE_TOOL_NAMES = ALL_TOOL_NAMES.filter(n => !ZAI_MCP_TOOLS.includes(n));
 // ─── getOpenAITools ──────────────────────────────────────────────────────────
 describe('getOpenAITools', () => {
     it('should return one entry per AGENT_TOOLS definition', () => {
         const tools = getOpenAITools();
-        expect(tools).toHaveLength(ALL_TOOL_NAMES.length);
+        // MCP tools are excluded when no Z.AI API key is configured
+        expect(tools).toHaveLength(CORE_TOOL_NAMES.length);
     });
     it('should wrap every tool in the OpenAI function-calling envelope', () => {
         const tools = getOpenAITools();
@@ -20,10 +24,10 @@ describe('getOpenAITools', () => {
             expect(Array.isArray(tool.function.parameters.required)).toBe(true);
         }
     });
-    it('should include all tool names from AGENT_TOOLS', () => {
+    it('should include all core tool names from AGENT_TOOLS', () => {
         const tools = getOpenAITools();
         const names = tools.map(t => t.function.name);
-        for (const name of ALL_TOOL_NAMES) {
+        for (const name of CORE_TOOL_NAMES) {
             expect(names).toContain(name);
         }
     });
@@ -71,7 +75,8 @@ describe('getOpenAITools', () => {
 describe('getAnthropicTools', () => {
     it('should return one entry per AGENT_TOOLS definition', () => {
         const tools = getAnthropicTools();
-        expect(tools).toHaveLength(ALL_TOOL_NAMES.length);
+        // MCP tools are excluded when no Z.AI API key is configured
+        expect(tools).toHaveLength(CORE_TOOL_NAMES.length);
     });
     it('should use Anthropic tool-use shape (name, description, input_schema)', () => {
         const tools = getAnthropicTools();
@@ -84,17 +89,17 @@ describe('getAnthropicTools', () => {
             expect(Array.isArray(tool.input_schema.required)).toBe(true);
         }
     });
-    it('should include all tool names from AGENT_TOOLS', () => {
+    it('should include all core tool names from AGENT_TOOLS', () => {
         const tools = getAnthropicTools();
         const names = tools.map(t => t.name);
-        for (const name of ALL_TOOL_NAMES) {
+        for (const name of CORE_TOOL_NAMES) {
             expect(names).toContain(name);
         }
     });
     it('should have same required params as OpenAI format', () => {
         const openai = getOpenAITools();
         const anthropic = getAnthropicTools();
-        for (const name of ALL_TOOL_NAMES) {
+        for (const name of CORE_TOOL_NAMES) {
             const oTool = openai.find(t => t.function.name === name);
             const aTool = anthropic.find(t => t.name === name);
             expect(aTool.input_schema.required).toEqual(oTool.function.parameters.required);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeep",
-  "version": "1.2.11",
+  "version": "1.2.13",
   "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",
@@ -9,6 +9,7 @@
   },
   "scripts": {
     "dev": "node --import tsx src/renderer/main.ts",
+    "prepack": "tsc; node scripts/fix-imports.js",
     "build": "tsc && node scripts/fix-imports.js",
     "start": "node dist/renderer/main.js",
     "demo:renderer": "node --import tsx src/renderer/demo.ts",

package/dist/app.d.ts

@@ -1,2 +0,0 @@
-import React from 'react';
-export declare const App: React.FC;