codeep 1.0.0

package/dist/components/Settings.js

@@ -0,0 +1,162 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+import { config } from '../config/index';
+import { updateRateLimits } from '../utils/ratelimit';
+const SETTINGS = [
+    {
+        key: 'temperature',
+        label: 'Temperature',
+        value: () => config.get('temperature'),
+        type: 'number',
+        min: 0,
+        max: 2,
+        step: 0.1,
+    },
+    {
+        key: 'maxTokens',
+        label: 'Max Tokens',
+        value: () => config.get('maxTokens'),
+        type: 'number',
+        min: 256,
+        max: 32768,
+        step: 256,
+    },
+    {
+        key: 'apiTimeout',
+        label: 'API Timeout (ms)',
+        value: () => config.get('apiTimeout'),
+        type: 'number',
+        min: 5000,
+        max: 120000,
+        step: 5000,
+    },
+    {
+        key: 'rateLimitApi',
+        label: 'API Rate Limit (/min)',
+        value: () => config.get('rateLimitApi'),
+        type: 'number',
+        min: 1,
+        max: 300,
+        step: 5,
+    },
+    {
+        key: 'rateLimitCommands',
+        label: 'Command Rate Limit (/min)',
+        value: () => config.get('rateLimitCommands'),
+        type: 'number',
+        min: 10,
+        max: 1000,
+        step: 10,
+    },
+    {
+        key: 'autoSave',
+        label: 'Auto Save Sessions',
+        value: () => config.get('autoSave') ? 'On' : 'Off',
+        type: 'select',
+        options: [
+            { value: true, label: 'On' },
+            { value: false, label: 'Off' },
+        ],
+    },
+    {
+        key: 'agentMode',
+        label: 'Agent Mode',
+        value: () => config.get('agentMode') === 'auto' ? 'Auto' : 'Manual',
+        type: 'select',
+        options: [
+            { value: 'auto', label: 'Auto' },
+            { value: 'manual', label: 'Manual' },
+        ],
+    },
+];
+export const Settings = ({ onClose, notify }) => {
+    const [selected, setSelected] = useState(0);
+    const [editing, setEditing] = useState(false);
+    const [editValue, setEditValue] = useState('');
+    useInput((input, key) => {
+        if (key.escape) {
+            if (editing) {
+                setEditing(false);
+                setEditValue('');
+            }
+            else {
+                onClose();
+            }
+            return;
+        }
+        if (editing) {
+            // Handle editing mode
+            if (key.return) {
+                const setting = SETTINGS[selected];
+                if (setting.type === 'number') {
+                    const num = parseFloat(editValue);
+                    if (!isNaN(num)) {
+                        const clamped = Math.max(setting.min || 0, Math.min(setting.max || Infinity, num));
+                        config.set(setting.key, clamped);
+                        // Update rate limiters if changed
+                        if (setting.key === 'rateLimitApi' || setting.key === 'rateLimitCommands') {
+                            updateRateLimits();
+                        }
+                        notify(`${setting.label}: ${clamped}`);
+                    }
+                }
+                setEditing(false);
+                setEditValue('');
+            }
+            else if (key.backspace || key.delete) {
+                setEditValue(v => v.slice(0, -1));
+            }
+            else if (/^[0-9.]$/.test(input)) {
+                setEditValue(v => v + input);
+            }
+            return;
+        }
+        // Navigation mode
+        if (key.upArrow) {
+            setSelected(s => Math.max(0, s - 1));
+        }
+        else if (key.downArrow) {
+            setSelected(s => Math.min(SETTINGS.length - 1, s + 1));
+        }
+        else if (key.leftArrow || key.rightArrow) {
+            // Adjust value with arrows
+            const setting = SETTINGS[selected];
+            if (setting.type === 'number') {
+                const current = setting.value();
+                const step = setting.step || 1;
+                const delta = key.leftArrow ? -step : step;
+                const newValue = Math.max(setting.min || 0, Math.min(setting.max || Infinity, current + delta));
+                config.set(setting.key, newValue);
+                // Update rate limiters if changed
+                if (setting.key === 'rateLimitApi' || setting.key === 'rateLimitCommands') {
+                    updateRateLimits();
+                }
+            }
+            else if (setting.type === 'select' && setting.options) {
+                const current = config.get(setting.key);
+                const currentIdx = setting.options.findIndex(o => o.value === current);
+                const newIdx = key.leftArrow
+                    ? Math.max(0, currentIdx - 1)
+                    : Math.min(setting.options.length - 1, currentIdx + 1);
+                config.set(setting.key, setting.options[newIdx].value);
+            }
+        }
+        else if (key.return) {
+            const setting = SETTINGS[selected];
+            if (setting.type === 'number') {
+                setEditing(true);
+                setEditValue(String(setting.value()));
+            }
+            else if (setting.type === 'select' && setting.options) {
+                // Toggle select options
+                const current = config.get(setting.key);
+                const currentIdx = setting.options.findIndex(o => o.value === current);
+                const newIdx = (currentIdx + 1) % setting.options.length;
+                config.set(setting.key, setting.options[newIdx].value);
+                notify(`${setting.label}: ${setting.options[newIdx].label}`);
+            }
+        }
+    });
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "#f02a30", padding: 1, children: [_jsx(Text, { color: "#f02a30", bold: true, children: "Settings" }), _jsx(Text, { children: " " }), SETTINGS.map((setting, i) => (_jsx(Box, { children: _jsxs(Text, { children: [i === selected ? _jsx(Text, { color: "#f02a30", children: "\u25B8 " }) : '  ', _jsxs(Text, { color: i === selected ? '#f02a30' : undefined, children: [setting.label, ":"] }), _jsx(Text, { children: " " }), editing && i === selected ? (_jsx(Text, { color: "cyan", inverse: true, children: editValue || ' ' })) : (_jsx(Text, { color: "green", children: setting.value() })), i === selected && setting.type === 'number' && !editing && (_jsx(Text, { children: " (\u2190/\u2192 adjust, Enter to type)" })), i === selected && setting.type === 'select' && (_jsx(Text, { children: " (\u2190/\u2192 or Enter to toggle)" }))] }) }, setting.key))), _jsx(Text, { children: " " }), _jsx(Text, { children: "\u2191/\u2193 Navigate  |  \u2190/\u2192 Adjust  |  Enter Edit  |  Esc Close" })] }));
+};

package/dist/components/Status.d.ts

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

package/dist/components/Status.js

@@ -0,0 +1,12 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Text, Box } from 'ink';
+import { config, getMaskedApiKey, getModelsForCurrentProvider, getCurrentProvider, PROTOCOLS, LANGUAGES } from '../config/index';
+export const Status = () => {
+    const model = config.get('model');
+    const protocol = config.get('protocol');
+    const plan = config.get('plan');
+    const language = config.get('language');
+    const provider = getCurrentProvider();
+    const models = getModelsForCurrentProvider();
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "#f02a30", padding: 1, children: [_jsx(Text, { color: "#f02a30", bold: true, children: "Status" }), _jsx(Text, { children: " " }), _jsxs(Text, { children: [_jsx(Text, { color: "#f02a30", children: "Provider:" }), " ", provider.name] }), _jsxs(Text, { children: [_jsx(Text, { color: "#f02a30", children: "Model:" }), "    ", models[model] || model] }), _jsxs(Text, { children: [_jsx(Text, { color: "#f02a30", children: "Protocol:" }), " ", PROTOCOLS[protocol] || protocol] }), _jsxs(Text, { children: [_jsx(Text, { color: "#f02a30", children: "Language:" }), " ", LANGUAGES[language] || language] }), _jsxs(Text, { children: [_jsx(Text, { color: "#f02a30", children: "Plan:" }), "     ", plan.toUpperCase()] }), _jsxs(Text, { children: [_jsx(Text, { color: "#f02a30", children: "API Key:" }), "  ", getMaskedApiKey()] })] }));
+};

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

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

package/dist/config/config.test.js

@@ -0,0 +1,157 @@
+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/index.d.ts

@@ -0,0 +1,121 @@
+import Conf from 'conf';
+export interface Message {
+    role: 'user' | 'assistant' | 'system';
+    content: string;
+}
+type LanguageCode = 'auto' | 'en' | 'zh' | 'es' | 'hi' | 'ar' | 'pt' | 'fr' | 'de' | 'ja' | 'ru' | 'hr';
+interface ProjectPermission {
+    path: string;
+    readPermission: boolean;
+    writePermission: boolean;
+    grantedAt: string;
+}
+interface ProviderApiKey {
+    providerId: string;
+    apiKey: string;
+}
+type AgentMode = 'auto' | 'manual';
+interface ConfigSchema {
+    apiKey: string;
+    provider: string;
+    model: string;
+    protocol: 'openai' | 'anthropic';
+    plan: 'lite' | 'pro' | 'max';
+    language: LanguageCode;
+    autoSave: boolean;
+    currentSessionId: string;
+    temperature: number;
+    maxTokens: number;
+    apiTimeout: number;
+    rateLimitApi: number;
+    rateLimitCommands: number;
+    agentMode: AgentMode;
+    agentConfirmation: 'always' | 'dangerous' | 'never';
+    agentAutoCommit: boolean;
+    agentAutoCommitBranch: boolean;
+    agentAutoVerify: boolean;
+    agentMaxFixAttempts: number;
+    projectPermissions: ProjectPermission[];
+    providerApiKeys: ProviderApiKey[];
+}
+export type { AgentMode };
+export type { LanguageCode };
+export declare const config: Conf<ConfigSchema>;
+export declare const LANGUAGES: Record<string, string>;
+export declare const PROTOCOLS: Record<string, string>;
+/**
+ * Load API key from config into cache
+ */
+export declare function loadApiKey(providerId?: string): Promise<string>;
+/**
+ * Load API keys for ALL providers into cache
+ * Should be called at app startup
+ */
+export declare function loadAllApiKeys(): Promise<void>;
+/**
+ * Get API key synchronously from cache (must call loadAllApiKeys first)
+ */
+export declare function getApiKey(providerId?: string): string;
+/**
+ * Set API key - stores in config file
+ */
+export declare function setApiKey(key: string, providerId?: string): void;
+export declare function getMaskedApiKey(providerId?: string): string;
+/**
+ * Get list of providers that have API keys configured
+ */
+export declare function getConfiguredProviders(): {
+    id: string;
+    name: string;
+}[];
+/**
+ * Clear API key for a specific provider
+ */
+export declare function clearApiKey(providerId: string): void;
+export declare function isConfiguredAsync(providerId?: string): Promise<boolean>;
+export declare function isConfigured(providerId?: string): boolean;
+export declare function getCurrentProvider(): {
+    id: string;
+    name: string;
+};
+export declare function setProvider(providerId: string): boolean;
+export declare function getModelsForCurrentProvider(): Record<string, string>;
+export { PROVIDERS } from './providers';
+export declare function getCurrentSessionId(): string;
+export declare function startNewSession(): string;
+export declare function autoSaveSession(history: Message[], projectPath?: string): boolean;
+export declare function flushAutoSave(): boolean;
+export declare function saveSession(name: string, history: Message[], projectPath?: string): boolean;
+export declare function loadSession(name: string, projectPath?: string): Message[] | null;
+export declare function listSessions(projectPath?: string): string[];
+export declare function deleteSession(name: string, projectPath?: string): boolean;
+export declare function renameSession(oldName: string, newName: string, projectPath?: string): boolean;
+export declare function getSessionInfo(name: string, projectPath?: string): {
+    name: string;
+    createdAt: string;
+    messageCount: number;
+} | null;
+export interface SessionInfo {
+    name: string;
+    createdAt: string;
+    messageCount: number;
+    fileSize: number;
+}
+/**
+ * List all sessions with metadata, sorted by date (newest first)
+ */
+export declare function listSessionsWithInfo(projectPath?: string): SessionInfo[];
+/**
+ * Get project permission from local .codeep/config.json
+ */
+export declare function getProjectPermission(projectPath: string): ProjectPermission | null;
+/**
+ * Set project permission in local .codeep/config.json
+ */
+export declare function setProjectPermission(projectPath: string, read: boolean, write: boolean): void;
+/**
+ * Remove project permission from local .codeep/config.json
+ */
+export declare function removeProjectPermission(projectPath: string): boolean;
+export declare function hasReadPermission(projectPath: string): boolean;
+export declare function hasWritePermission(projectPath: string): boolean;