codeep 1.2.16 → 1.2.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeep",
-  "version": "1.2.16",
+  "version": "1.2.18",
   "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",
@@ -58,6 +58,8 @@
   "files": [
     "bin/**/*",
     "dist/**/*",
+    "!dist/**/*.test.js",
+    "!dist/**/*.test.d.ts",
     "README.md",
     "LICENSE"
   ],

package/dist/config/config.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/config/config.test.js

@@ -1,157 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { mkdirSync, rmSync, writeFileSync, existsSync } from 'fs';
-import { join } from 'path';
-import { tmpdir } from 'os';
-// We need to test the config functions
-// Since config uses Conf which has side effects, we'll test the utility functions
-describe('config utilities', () => {
-    const TEST_DIR = join(tmpdir(), 'codeep-config-test-' + Date.now());
-    const SESSIONS_DIR = join(TEST_DIR, '.codeep', 'sessions');
-    beforeEach(() => {
-        mkdirSync(SESSIONS_DIR, { recursive: true });
-    });
-    afterEach(() => {
-        try {
-            rmSync(TEST_DIR, { recursive: true, force: true });
-        }
-        catch { }
-    });
-    describe('session file operations', () => {
-        it('should create sessions directory structure', () => {
-            expect(existsSync(SESSIONS_DIR)).toBe(true);
-        });
-        it('should handle session JSON files', () => {
-            const sessionId = 'test-session';
-            const sessionFile = join(SESSIONS_DIR, `${sessionId}.json`);
-            const sessionData = {
-                name: sessionId,
-                history: [
-                    { role: 'user', content: 'Hello' },
-                    { role: 'assistant', content: 'Hi there!' },
-                ],
-                createdAt: new Date().toISOString(),
-            };
-            writeFileSync(sessionFile, JSON.stringify(sessionData, null, 2));
-            expect(existsSync(sessionFile)).toBe(true);
-        });
-    });
-    describe('language codes', () => {
-        const LANGUAGES = {
-            'auto': 'Auto-detect',
-            'en': 'English',
-            'zh': 'Chinese (中文)',
-            'es': 'Spanish (Español)',
-            'hi': 'Hindi (हिन्दी)',
-            'ar': 'Arabic (العربية)',
-            'pt': 'Portuguese (Português)',
-            'fr': 'French (Français)',
-            'de': 'German (Deutsch)',
-            'ja': 'Japanese (日本語)',
-            'ru': 'Russian (Русский)',
-            'hr': 'Croatian (Hrvatski)',
-        };
-        it('should have all supported languages', () => {
-            expect(Object.keys(LANGUAGES)).toContain('auto');
-            expect(Object.keys(LANGUAGES)).toContain('en');
-            expect(Object.keys(LANGUAGES)).toContain('hr');
-        });
-        it('should have display names for all languages', () => {
-            for (const [code, name] of Object.entries(LANGUAGES)) {
-                expect(typeof name).toBe('string');
-                expect(name.length).toBeGreaterThan(0);
-            }
-        });
-    });
-    describe('protocols', () => {
-        const PROTOCOLS = {
-            'openai': 'OpenAI Compatible',
-            'anthropic': 'Anthropic Protocol',
-        };
-        it('should support openai protocol', () => {
-            expect(PROTOCOLS['openai']).toBe('OpenAI Compatible');
-        });
-        it('should support anthropic protocol', () => {
-            expect(PROTOCOLS['anthropic']).toBe('Anthropic Protocol');
-        });
-    });
-    describe('config schema validation', () => {
-        it('should have valid default values', () => {
-            const defaults = {
-                apiKey: '',
-                provider: 'z.ai',
-                model: 'glm-4.7',
-                protocol: 'openai',
-                plan: 'lite',
-                language: 'en',
-                autoSave: true,
-                currentSessionId: '',
-                temperature: 0.7,
-                maxTokens: 4096,
-                apiTimeout: 30000,
-                rateLimitApi: 30,
-                rateLimitCommands: 100,
-                projectPermissions: [],
-                providerApiKeys: [],
-            };
-            // Validate types
-            expect(typeof defaults.apiKey).toBe('string');
-            expect(typeof defaults.provider).toBe('string');
-            expect(typeof defaults.model).toBe('string');
-            expect(['openai', 'anthropic']).toContain(defaults.protocol);
-            expect(['lite', 'pro', 'max']).toContain(defaults.plan);
-            expect(typeof defaults.autoSave).toBe('boolean');
-            expect(typeof defaults.temperature).toBe('number');
-            expect(defaults.temperature).toBeGreaterThanOrEqual(0);
-            expect(defaults.temperature).toBeLessThanOrEqual(2);
-            expect(typeof defaults.maxTokens).toBe('number');
-            expect(defaults.maxTokens).toBeGreaterThan(0);
-            expect(typeof defaults.apiTimeout).toBe('number');
-            expect(defaults.apiTimeout).toBeGreaterThan(0);
-            expect(typeof defaults.rateLimitApi).toBe('number');
-            expect(typeof defaults.rateLimitCommands).toBe('number');
-            expect(Array.isArray(defaults.projectPermissions)).toBe(true);
-            expect(Array.isArray(defaults.providerApiKeys)).toBe(true);
-        });
-    });
-    describe('project permissions structure', () => {
-        it('should validate permission structure', () => {
-            const permission = {
-                path: '/Users/test/project',
-                readPermission: true,
-                writePermission: false,
-                grantedAt: new Date().toISOString(),
-            };
-            expect(typeof permission.path).toBe('string');
-            expect(typeof permission.readPermission).toBe('boolean');
-            expect(typeof permission.writePermission).toBe('boolean');
-            expect(typeof permission.grantedAt).toBe('string');
-            // Validate ISO date string
-            expect(() => new Date(permission.grantedAt)).not.toThrow();
-        });
-    });
-    describe('provider API keys structure', () => {
-        it('should validate API key structure', () => {
-            const apiKey = {
-                providerId: 'z.ai',
-                apiKey: 'test-api-key-123',
-            };
-            expect(typeof apiKey.providerId).toBe('string');
-            expect(typeof apiKey.apiKey).toBe('string');
-            expect(apiKey.providerId.length).toBeGreaterThan(0);
-            expect(apiKey.apiKey.length).toBeGreaterThan(0);
-        });
-    });
-    describe('message structure', () => {
-        it('should validate message structure', () => {
-            const userMessage = { role: 'user', content: 'Hello' };
-            const assistantMessage = { role: 'assistant', content: 'Hi!' };
-            const systemMessage = { role: 'system', content: 'You are a helpful assistant' };
-            expect(['user', 'assistant', 'system']).toContain(userMessage.role);
-            expect(['user', 'assistant', 'system']).toContain(assistantMessage.role);
-            expect(['user', 'assistant', 'system']).toContain(systemMessage.role);
-            expect(typeof userMessage.content).toBe('string');
-            expect(typeof assistantMessage.content).toBe('string');
-            expect(typeof systemMessage.content).toBe('string');
-        });
-    });
-});

package/dist/config/providers.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/config/providers.test.js

@@ -1,187 +0,0 @@
-import { describe, it, expect } from 'vitest';
-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');
-        });
-        it('should have valid structure for all providers', () => {
-            for (const [id, provider] of Object.entries(PROVIDERS)) {
-                expect(provider.name).toBeDefined();
-                expect(typeof provider.name).toBe('string');
-                expect(provider.description).toBeDefined();
-                expect(provider.protocols).toBeDefined();
-                expect(provider.models).toBeDefined();
-                expect(Array.isArray(provider.models)).toBe(true);
-                expect(provider.models.length).toBeGreaterThan(0);
-                expect(provider.defaultModel).toBeDefined();
-                expect(provider.defaultProtocol).toBeDefined();
-                expect(['openai', 'anthropic']).toContain(provider.defaultProtocol);
-            }
-        });
-        it('should have valid model structure', () => {
-            for (const provider of Object.values(PROVIDERS)) {
-                for (const model of provider.models) {
-                    expect(model.id).toBeDefined();
-                    expect(typeof model.id).toBe('string');
-                    expect(model.name).toBeDefined();
-                    expect(typeof model.name).toBe('string');
-                    expect(model.description).toBeDefined();
-                    expect(typeof model.description).toBe('string');
-                }
-            }
-        });
-        it('should have default model in models list', () => {
-            for (const provider of Object.values(PROVIDERS)) {
-                const modelIds = provider.models.map(m => m.id);
-                expect(modelIds).toContain(provider.defaultModel);
-            }
-        });
-    });
-    describe('getProvider', () => {
-        it('should return provider config for valid id', () => {
-            const provider = getProvider('z.ai');
-            expect(provider).not.toBeNull();
-            expect(provider.name).toBe('Z.AI (ZhipuAI)');
-        });
-        it('should return null for invalid id', () => {
-            expect(getProvider('nonexistent')).toBeNull();
-            expect(getProvider('')).toBeNull();
-        });
-    });
-    describe('getProviderList', () => {
-        it('should return list of providers', () => {
-            const list = getProviderList();
-            expect(Array.isArray(list)).toBe(true);
-            expect(list.length).toBeGreaterThan(0);
-        });
-        it('should include id, name, and description', () => {
-            const list = getProviderList();
-            for (const item of list) {
-                expect(item.id).toBeDefined();
-                expect(item.name).toBeDefined();
-                expect(item.description).toBeDefined();
-            }
-        });
-        it('should include z.ai, z.ai-cn, minimax, minimax-cn, and anthropic', () => {
-            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');
-            expect(ids).toContain('minimax-cn');
-            expect(ids).toContain('anthropic');
-        });
-    });
-    describe('getProviderModels', () => {
-        it('should return models for valid provider', () => {
-            const models = getProviderModels('z.ai');
-            expect(Array.isArray(models)).toBe(true);
-            expect(models.length).toBeGreaterThan(0);
-        });
-        it('should return empty array for invalid provider', () => {
-            const models = getProviderModels('nonexistent');
-            expect(Array.isArray(models)).toBe(true);
-            expect(models.length).toBe(0);
-        });
-        it('should include glm-4.7 for z.ai', () => {
-            const models = getProviderModels('z.ai');
-            const ids = models.map(m => m.id);
-            expect(ids).toContain('glm-4.7');
-        });
-    });
-    describe('getProviderBaseUrl', () => {
-        it('should return base URL for valid provider and protocol', () => {
-            const url = getProviderBaseUrl('z.ai', 'openai');
-            expect(url).not.toBeNull();
-            expect(url).toContain('api.z.ai');
-        });
-        it('should return different URLs for different protocols', () => {
-            const openaiUrl = getProviderBaseUrl('z.ai', 'openai');
-            const anthropicUrl = getProviderBaseUrl('z.ai', 'anthropic');
-            expect(openaiUrl).not.toBe(anthropicUrl);
-        });
-        it('should return null for invalid provider', () => {
-            expect(getProviderBaseUrl('nonexistent', 'openai')).toBeNull();
-        });
-    });
-    describe('getProviderAuthHeader', () => {
-        it('should return auth header for valid provider', () => {
-            const header = getProviderAuthHeader('z.ai', 'openai');
-            expect(['Bearer', 'x-api-key']).toContain(header);
-        });
-        it('should return Bearer as default for invalid provider', () => {
-            expect(getProviderAuthHeader('nonexistent', 'openai')).toBe('Bearer');
-        });
-        it('should return correct header for each protocol', () => {
-            // z.ai uses Bearer for openai and x-api-key for anthropic
-            expect(getProviderAuthHeader('z.ai', 'openai')).toBe('Bearer');
-            expect(getProviderAuthHeader('z.ai', 'anthropic')).toBe('x-api-key');
-        });
-    });
-    describe('environment variable keys', () => {
-        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');
-        });
-        it('should have env key for minimax-cn', () => {
-            expect(PROVIDERS['minimax-cn'].envKey).toBe('MINIMAX_CN_API_KEY');
-        });
-        it('should have env key for anthropic', () => {
-            expect(PROVIDERS['anthropic'].envKey).toBe('ANTHROPIC_API_KEY');
-        });
-    });
-    describe('minimax-cn provider', () => {
-        it('should have correct name and endpoints', () => {
-            expect(PROVIDERS['minimax-cn']).toBeDefined();
-            expect(PROVIDERS['minimax-cn'].name).toBe('MiniMax China');
-            expect(getProviderBaseUrl('minimax-cn', 'openai')).toContain('api.minimaxi.com');
-            expect(getProviderBaseUrl('minimax-cn', 'anthropic')).toContain('api.minimaxi.com');
-        });
-    });
-    describe('anthropic provider', () => {
-        it('should include Claude Sonnet 4.6 as default model', () => {
-            expect(PROVIDERS['anthropic'].defaultModel).toBe('claude-sonnet-4-6');
-            const modelIds = PROVIDERS['anthropic'].models.map(m => m.id);
-            expect(modelIds).toContain('claude-sonnet-4-6');
-            expect(modelIds).toContain('claude-opus-4-6');
-            expect(modelIds).toContain('claude-sonnet-4-5-20250929');
-            expect(modelIds).toContain('claude-haiku-4-5-20251001');
-        });
-    });
-    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/hooks/index.d.ts

@@ -1,4 +0,0 @@
-/**
- * Custom hooks for Codeep
- */
-export { useAgent } from './useAgent';

package/dist/hooks/index.js

@@ -1,4 +0,0 @@
-/**
- * Custom hooks for Codeep
- */
-export { useAgent } from './useAgent.js';

package/dist/hooks/useAgent.d.ts

@@ -1,29 +0,0 @@
-/**
- * useAgent hook - isolates agent state management from main App
- * Reduces re-renders in App component when agent state changes
- */
-import { AgentResult } from '../utils/agent';
-import { ActionLog } from '../utils/tools';
-import { ProjectContext } from '../utils/project';
-import { Message } from '../config/index';
-interface UseAgentOptions {
-    projectContext: ProjectContext | null;
-    hasWriteAccess: boolean;
-    messages: Message[];
-    projectPath: string;
-    onMessageAdd: (message: Message) => void;
-    notify: (msg: string, duration?: number) => void;
-}
-interface UseAgentReturn {
-    isAgentRunning: boolean;
-    agentIteration: number;
-    agentActions: ActionLog[];
-    agentThinking: string;
-    agentResult: AgentResult | null;
-    agentDryRun: boolean;
-    startAgent: (prompt: string, dryRun?: boolean) => Promise<void>;
-    stopAgent: () => void;
-    clearAgentState: () => void;
-}
-export declare function useAgent({ projectContext, hasWriteAccess, messages, projectPath, onMessageAdd, notify, }: UseAgentOptions): UseAgentReturn;
-export default useAgent;

package/dist/hooks/useAgent.js

@@ -1,148 +0,0 @@
-/**
- * useAgent hook - isolates agent state management from main App
- * Reduces re-renders in App component when agent state changes
- */
-import { useState, useCallback, useRef } from 'react';
-import { runAgent, formatAgentResult } from '../utils/agent.js';
-import { createActionLog } from '../utils/tools.js';
-import { autoSaveSession } from '../config/index.js';
-export function useAgent({ projectContext, hasWriteAccess, messages, projectPath, onMessageAdd, notify, }) {
-    const [isAgentRunning, setIsAgentRunning] = useState(false);
-    const [agentIteration, setAgentIteration] = useState(0);
-    const [agentActions, setAgentActions] = useState([]);
-    const [agentThinking, setAgentThinking] = useState('');
-    const [agentResult, setAgentResult] = useState(null);
-    const [agentDryRun, setAgentDryRun] = useState(false);
-    const abortControllerRef = useRef(null);
-    const clearAgentState = useCallback(() => {
-        setAgentResult(null);
-        setAgentActions([]);
-        setAgentThinking('');
-        setAgentIteration(0);
-    }, []);
-    const stopAgent = useCallback(() => {
-        abortControllerRef.current?.abort();
-    }, []);
-    const startAgent = useCallback(async (prompt, dryRun = false) => {
-        if (!projectContext) {
-            notify('Agent mode requires project context. Run in a project directory.');
-            return;
-        }
-        if (!hasWriteAccess && !dryRun) {
-            notify('Agent mode requires write access. Grant permission first or use /agent-dry');
-            return;
-        }
-        // Reset agent state
-        setIsAgentRunning(true);
-        setAgentIteration(0);
-        setAgentActions([]);
-        setAgentThinking('');
-        setAgentResult(null);
-        setAgentDryRun(dryRun);
-        // Add user message
-        const userMessage = {
-            role: 'user',
-            content: dryRun ? `[DRY RUN] ${prompt}` : `[AGENT] ${prompt}`
-        };
-        onMessageAdd(userMessage);
-        const controller = new AbortController();
-        abortControllerRef.current = controller;
-        try {
-            const result = await runAgent(prompt, projectContext, {
-                dryRun,
-                onIteration: (iteration) => {
-                    setAgentIteration(iteration);
-                },
-                onToolCall: (tool) => {
-                    const toolName = tool.tool.toLowerCase().replace(/-/g, '_');
-                    let details;
-                    if (toolName === 'write_file' && tool.parameters.content) {
-                        details = tool.parameters.content;
-                    }
-                    else if (toolName === 'edit_file' && tool.parameters.new_text) {
-                        details = tool.parameters.new_text;
-                    }
-                    const actionLog = {
-                        type: toolName === 'write_file' ? 'write' :
-                            toolName === 'edit_file' ? 'edit' :
-                                toolName === 'read_file' ? 'read' :
-                                    toolName === 'delete_file' ? 'delete' :
-                                        toolName === 'execute_command' ? 'command' :
-                                            toolName === 'search_code' ? 'search' :
-                                                toolName === 'list_files' ? 'list' :
-                                                    toolName === 'create_directory' ? 'mkdir' :
-                                                        toolName === 'fetch_url' ? 'fetch' : 'command',
-                        target: tool.parameters.path ||
-                            tool.parameters.command ||
-                            tool.parameters.pattern ||
-                            tool.parameters.url || 'unknown',
-                        result: 'success',
-                        details,
-                        timestamp: Date.now(),
-                    };
-                    setAgentActions(prev => [...prev, actionLog]);
-                },
-                onToolResult: (result, toolCall) => {
-                    const actionLog = createActionLog(toolCall, result);
-                    setAgentActions(prev => {
-                        const updated = [...prev];
-                        if (updated.length > 0) {
-                            updated[updated.length - 1] = actionLog;
-                        }
-                        return updated;
-                    });
-                },
-                onThinking: (text) => {
-                    const cleanText = text
-                        .replace(/<think>[\s\S]*?<\/think>/gi, '')
-                        .replace(/<tool_call>[\s\S]*?<\/tool_call>/gi, '')
-                        .replace(/<toolcall>[\s\S]*?<\/toolcall>/gi, '')
-                        .trim();
-                    if (cleanText) {
-                        setAgentThinking(prev => prev + cleanText);
-                    }
-                },
-                abortSignal: controller.signal,
-            });
-            setAgentResult(result);
-            // Add agent summary as assistant message
-            const summaryMessage = {
-                role: 'assistant',
-                content: result.finalResponse || formatAgentResult(result),
-            };
-            onMessageAdd(summaryMessage);
-            // Auto-save session
-            autoSaveSession([...messages, userMessage, summaryMessage], projectPath);
-            if (result.success) {
-                notify(`Agent completed: ${result.actions.length} action(s)`);
-            }
-            else if (result.aborted) {
-                notify('Agent stopped by user');
-            }
-            else {
-                notify(`Agent failed: ${result.error}`);
-            }
-        }
-        catch (error) {
-            const err = error;
-            notify(`Agent error: ${err.message}`);
-        }
-        finally {
-            setIsAgentRunning(false);
-            abortControllerRef.current = null;
-            setAgentThinking('');
-        }
-    }, [projectContext, hasWriteAccess, messages, projectPath, onMessageAdd, notify]);
-    return {
-        isAgentRunning,
-        agentIteration,
-        agentActions,
-        agentThinking,
-        agentResult,
-        agentDryRun,
-        startAgent,
-        stopAgent,
-        clearAgentState,
-    };
-}
-export default useAgent;

package/dist/utils/agent.test.d.ts

@@ -1 +0,0 @@
-export {};