codeep 1.0.0

package/dist/config/index.js

@@ -0,0 +1,555 @@
+import Conf from 'conf';
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync, unlinkSync, statSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { PROVIDERS, getProvider } from './providers';
+import { logSession } from '../utils/logger';
+// Global sessions directory (fallback when not in a project)
+const GLOBAL_SESSIONS_DIR = join(homedir(), '.codeep', 'sessions');
+// Ensure global sessions directory exists
+if (!existsSync(GLOBAL_SESSIONS_DIR)) {
+    mkdirSync(GLOBAL_SESSIONS_DIR, { recursive: true });
+}
+/**
+ * Get sessions directory - local .codeep/sessions/ if in project, otherwise global
+ */
+function getSessionsDir(projectPath) {
+    if (projectPath && isProjectDirectory(projectPath)) {
+        const localDir = join(projectPath, '.codeep', 'sessions');
+        if (!existsSync(localDir)) {
+            mkdirSync(localDir, { recursive: true });
+        }
+        return localDir;
+    }
+    return GLOBAL_SESSIONS_DIR;
+}
+/**
+ * Get local project config path
+ */
+function getLocalConfigPath(projectPath) {
+    if (!isProjectDirectory(projectPath))
+        return null;
+    const configDir = join(projectPath, '.codeep');
+    if (!existsSync(configDir)) {
+        mkdirSync(configDir, { recursive: true });
+    }
+    return join(configDir, 'config.json');
+}
+/**
+ * Check if directory is a project (has package.json)
+ */
+function isProjectDirectory(path) {
+    return existsSync(join(path, 'package.json'));
+}
+export const config = new Conf({
+    projectName: 'codeep',
+    defaults: {
+        apiKey: '',
+        provider: 'z.ai',
+        model: 'glm-4.7',
+        agentMode: 'auto',
+        agentConfirmation: 'dangerous', // Confirm only dangerous actions by default
+        agentAutoCommit: false,
+        agentAutoCommitBranch: false,
+        agentAutoVerify: true, // Auto-verify by default
+        agentMaxFixAttempts: 3,
+        protocol: 'openai',
+        plan: 'lite',
+        language: 'en',
+        autoSave: true,
+        currentSessionId: '',
+        temperature: 0.7,
+        maxTokens: 4096,
+        apiTimeout: 30000,
+        rateLimitApi: 30, // 30 requests per minute
+        rateLimitCommands: 100, // 100 commands per minute
+        projectPermissions: [],
+        providerApiKeys: [],
+    },
+});
+// In-memory cache for API keys (populated on first access)
+const apiKeyCache = new Map();
+export 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)',
+};
+export const PROTOCOLS = {
+    'openai': 'OpenAI Compatible',
+    'anthropic': 'Anthropic Protocol',
+};
+// Get API key for current or specified provider
+/**
+ * Load API key from config into cache
+ */
+export async function loadApiKey(providerId) {
+    const provider = providerId || config.get('provider');
+    const providerConfig = getProvider(provider);
+    // Check environment variable first
+    if (providerConfig?.envKey) {
+        const envKey = process.env[providerConfig.envKey];
+        if (envKey) {
+            apiKeyCache.set(provider, envKey);
+            return envKey;
+        }
+    }
+    // Legacy env vars for z.ai
+    if (provider === 'z.ai') {
+        if (process.env.ZAI_API_KEY) {
+            apiKeyCache.set(provider, process.env.ZAI_API_KEY);
+            return process.env.ZAI_API_KEY;
+        }
+        if (process.env.ZHIPUAI_API_KEY) {
+            apiKeyCache.set(provider, process.env.ZHIPUAI_API_KEY);
+            return process.env.ZHIPUAI_API_KEY;
+        }
+    }
+    // Check config file
+    const providerKeys = config.get('providerApiKeys') || [];
+    const stored = providerKeys.find(k => k.providerId === provider);
+    if (stored?.apiKey) {
+        apiKeyCache.set(provider, stored.apiKey);
+        return stored.apiKey;
+    }
+    // Fallback to legacy apiKey field (for z.ai)
+    if (provider === 'z.ai') {
+        const legacyKey = config.get('apiKey') || '';
+        if (legacyKey) {
+            apiKeyCache.set(provider, legacyKey);
+            return legacyKey;
+        }
+    }
+    return '';
+}
+/**
+ * Load API keys for ALL providers into cache
+ * Should be called at app startup
+ */
+export async function loadAllApiKeys() {
+    // Load keys for all configured providers from providerApiKeys
+    const providerKeys = config.get('providerApiKeys') || [];
+    for (const { providerId, apiKey } of providerKeys) {
+        if (apiKey) {
+            apiKeyCache.set(providerId, apiKey);
+        }
+    }
+    // Also check environment variables for each provider
+    for (const [providerId, providerConfig] of Object.entries(PROVIDERS)) {
+        if (providerConfig.envKey) {
+            const envKey = process.env[providerConfig.envKey];
+            if (envKey) {
+                apiKeyCache.set(providerId, envKey);
+            }
+        }
+    }
+    // Legacy env vars for z.ai
+    if (!apiKeyCache.get('z.ai')) {
+        if (process.env.ZAI_API_KEY) {
+            apiKeyCache.set('z.ai', process.env.ZAI_API_KEY);
+        }
+        else if (process.env.ZHIPUAI_API_KEY) {
+            apiKeyCache.set('z.ai', process.env.ZHIPUAI_API_KEY);
+        }
+        else {
+            // Fallback to legacy apiKey field
+            const legacyKey = config.get('apiKey') || '';
+            if (legacyKey) {
+                apiKeyCache.set('z.ai', legacyKey);
+            }
+        }
+    }
+}
+/**
+ * Get API key synchronously from cache (must call loadAllApiKeys first)
+ */
+export function getApiKey(providerId) {
+    const provider = providerId || config.get('provider');
+    return apiKeyCache.get(provider) || '';
+}
+/**
+ * Set API key - stores in config file
+ */
+export function setApiKey(key, providerId) {
+    const provider = providerId || config.get('provider');
+    // Update cache immediately
+    apiKeyCache.set(provider, key);
+    // Store in config
+    const providerKeys = config.get('providerApiKeys') || [];
+    const existing = providerKeys.findIndex(k => k.providerId === provider);
+    if (existing >= 0) {
+        providerKeys[existing].apiKey = key;
+    }
+    else {
+        providerKeys.push({ providerId: provider, apiKey: key });
+    }
+    config.set('providerApiKeys', providerKeys);
+    // Also set legacy field for backwards compatibility (z.ai only)
+    if (provider === 'z.ai') {
+        config.set('apiKey', key);
+    }
+}
+export function getMaskedApiKey(providerId) {
+    const key = getApiKey(providerId);
+    if (key.length > 4) {
+        return '*'.repeat(key.length - 4) + key.slice(-4);
+    }
+    return key;
+}
+/**
+ * Get list of providers that have API keys configured
+ */
+export function getConfiguredProviders() {
+    const providerKeys = config.get('providerApiKeys') || [];
+    const configured = [];
+    for (const pk of providerKeys) {
+        if (pk.apiKey && pk.apiKey.length > 0) {
+            const provider = getProvider(pk.providerId);
+            configured.push({
+                id: pk.providerId,
+                name: provider?.name || pk.providerId,
+            });
+        }
+    }
+    return configured;
+}
+/**
+ * Clear API key for a specific provider
+ */
+export function clearApiKey(providerId) {
+    // Clear from cache
+    apiKeyCache.delete(providerId);
+    // Clear from config
+    const providerKeys = config.get('providerApiKeys') || [];
+    const filtered = providerKeys.filter(k => k.providerId !== providerId);
+    config.set('providerApiKeys', filtered);
+    // Clear legacy field if z.ai
+    if (providerId === 'z.ai') {
+        config.set('apiKey', '');
+    }
+}
+export async function isConfiguredAsync(providerId) {
+    const key = await loadApiKey(providerId);
+    return Boolean(key);
+}
+export function isConfigured(providerId) {
+    return Boolean(getApiKey(providerId));
+}
+// Get current provider info
+export function getCurrentProvider() {
+    const providerId = config.get('provider');
+    const provider = getProvider(providerId);
+    return {
+        id: providerId,
+        name: provider?.name || providerId,
+    };
+}
+// Set provider and update model/protocol to defaults
+export function setProvider(providerId) {
+    const provider = getProvider(providerId);
+    if (!provider)
+        return false;
+    config.set('provider', providerId);
+    config.set('model', provider.defaultModel);
+    config.set('protocol', provider.defaultProtocol);
+    // Load API key for the new provider into cache
+    // This is async but we fire-and-forget since the key will be loaded before next API call
+    loadApiKey(providerId);
+    return true;
+}
+// Get models for current provider
+export function getModelsForCurrentProvider() {
+    const providerId = config.get('provider');
+    const provider = getProvider(providerId);
+    if (!provider)
+        return {};
+    const models = {};
+    for (const model of provider.models) {
+        models[model.id] = `${model.name} - ${model.description}`;
+    }
+    return models;
+}
+// Re-export PROVIDERS for convenience
+export { PROVIDERS } from './providers';
+// Generate unique session ID
+function generateSessionId() {
+    const now = new Date();
+    const date = now.toISOString().split('T')[0];
+    const time = now.toTimeString().split(' ')[0].replace(/:/g, '-');
+    return `session-${date}-${time}`;
+}
+// Get or create current session ID
+export function getCurrentSessionId() {
+    let sessionId = config.get('currentSessionId');
+    if (!sessionId) {
+        sessionId = generateSessionId();
+        config.set('currentSessionId', sessionId);
+    }
+    return sessionId;
+}
+// Start new session
+export function startNewSession() {
+    const sessionId = generateSessionId();
+    config.set('currentSessionId', sessionId);
+    return sessionId;
+}
+// Auto-save debounce state
+let autoSaveTimeout = null;
+let pendingAutoSave = null;
+// Auto-save current session (debounced - saves max every 5 seconds)
+export function autoSaveSession(history, projectPath) {
+    if (!config.get('autoSave') || history.length === 0) {
+        return false;
+    }
+    // Store pending save data
+    pendingAutoSave = { history, projectPath };
+    // If already scheduled, don't reschedule
+    if (autoSaveTimeout) {
+        return true;
+    }
+    // Schedule save after 5 seconds
+    autoSaveTimeout = setTimeout(() => {
+        if (pendingAutoSave) {
+            const sessionId = getCurrentSessionId();
+            saveSession(sessionId, pendingAutoSave.history, pendingAutoSave.projectPath);
+            pendingAutoSave = null;
+        }
+        autoSaveTimeout = null;
+    }, 5000);
+    return true;
+}
+// Force immediate save (for explicit save commands)
+export function flushAutoSave() {
+    if (autoSaveTimeout) {
+        clearTimeout(autoSaveTimeout);
+        autoSaveTimeout = null;
+    }
+    if (pendingAutoSave) {
+        const sessionId = getCurrentSessionId();
+        const result = saveSession(sessionId, pendingAutoSave.history, pendingAutoSave.projectPath);
+        pendingAutoSave = null;
+        return result;
+    }
+    return false;
+}
+// Session management
+export function saveSession(name, history, projectPath) {
+    try {
+        const session = {
+            name,
+            history,
+            createdAt: new Date().toISOString(),
+        };
+        const sessionsDir = getSessionsDir(projectPath);
+        const filePath = join(sessionsDir, `${name}.json`);
+        writeFileSync(filePath, JSON.stringify(session, null, 2));
+        logSession('save', name, true);
+        return true;
+    }
+    catch (error) {
+        logSession('save', name, false);
+        return false;
+    }
+}
+export function loadSession(name, projectPath) {
+    try {
+        const sessionsDir = getSessionsDir(projectPath);
+        const filePath = join(sessionsDir, `${name}.json`);
+        if (existsSync(filePath)) {
+            const data = JSON.parse(readFileSync(filePath, 'utf-8'));
+            logSession('load', name, true);
+            return data.history;
+        }
+        logSession('load', name, false);
+        return null;
+    }
+    catch (error) {
+        logSession('load', name, false);
+        return null;
+    }
+}
+export function listSessions(projectPath) {
+    try {
+        const sessionsDir = getSessionsDir(projectPath);
+        return readdirSync(sessionsDir)
+            .filter(f => f.endsWith('.json'))
+            .map(f => f.replace('.json', ''))
+            .sort();
+    }
+    catch {
+        return [];
+    }
+}
+export function deleteSession(name, projectPath) {
+    try {
+        const sessionsDir = getSessionsDir(projectPath);
+        const filePath = join(sessionsDir, `${name}.json`);
+        if (existsSync(filePath)) {
+            unlinkSync(filePath);
+            logSession('delete', name, true);
+            return true;
+        }
+        logSession('delete', name, false);
+        return false;
+    }
+    catch (error) {
+        logSession('delete', name, false);
+        return false;
+    }
+}
+export function renameSession(oldName, newName, projectPath) {
+    try {
+        const sessionsDir = getSessionsDir(projectPath);
+        const oldPath = join(sessionsDir, `${oldName}.json`);
+        const newPath = join(sessionsDir, `${newName}.json`);
+        if (!existsSync(oldPath)) {
+            logSession('rename', `${oldName} -> ${newName}`, false);
+            return false;
+        }
+        // Read existing session
+        const data = JSON.parse(readFileSync(oldPath, 'utf-8'));
+        // Update name and save to new path
+        data.name = newName;
+        writeFileSync(newPath, JSON.stringify(data, null, 2));
+        // Delete old file
+        unlinkSync(oldPath);
+        // Update current session ID if it was the renamed one
+        if (config.get('currentSessionId') === oldName) {
+            config.set('currentSessionId', newName);
+        }
+        logSession('rename', `${oldName} -> ${newName}`, true);
+        return true;
+    }
+    catch (error) {
+        logSession('rename', `${oldName} -> ${newName}`, false);
+        return false;
+    }
+}
+export function getSessionInfo(name, projectPath) {
+    try {
+        const sessionsDir = getSessionsDir(projectPath);
+        const filePath = join(sessionsDir, `${name}.json`);
+        if (existsSync(filePath)) {
+            const data = JSON.parse(readFileSync(filePath, 'utf-8'));
+            return {
+                name: data.name,
+                createdAt: data.createdAt,
+                messageCount: data.history.length,
+            };
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * List all sessions with metadata, sorted by date (newest first)
+ */
+export function listSessionsWithInfo(projectPath) {
+    try {
+        const sessionsDir = getSessionsDir(projectPath);
+        const files = readdirSync(sessionsDir).filter(f => f.endsWith('.json'));
+        const sessions = [];
+        for (const file of files) {
+            const filePath = join(sessionsDir, file);
+            try {
+                const stat = statSync(filePath);
+                const data = JSON.parse(readFileSync(filePath, 'utf-8'));
+                sessions.push({
+                    name: data.name || file.replace('.json', ''),
+                    createdAt: data.createdAt || stat.mtime.toISOString(),
+                    messageCount: data.history?.length || 0,
+                    fileSize: stat.size,
+                });
+            }
+            catch {
+                // Skip invalid session files
+            }
+        }
+        // Sort by date, newest first
+        return sessions.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+    }
+    catch {
+        return [];
+    }
+}
+// Project permission management
+/**
+ * Get project permission from local .codeep/config.json
+ */
+export function getProjectPermission(projectPath) {
+    const configPath = getLocalConfigPath(projectPath);
+    if (!configPath || !existsSync(configPath)) {
+        return null;
+    }
+    try {
+        const data = JSON.parse(readFileSync(configPath, 'utf-8'));
+        return data.permission || null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Set project permission in local .codeep/config.json
+ */
+export function setProjectPermission(projectPath, read, write) {
+    const configPath = getLocalConfigPath(projectPath);
+    if (!configPath)
+        return;
+    const permission = {
+        path: projectPath,
+        readPermission: read,
+        writePermission: write,
+        grantedAt: new Date().toISOString(),
+    };
+    let data = {};
+    if (existsSync(configPath)) {
+        try {
+            data = JSON.parse(readFileSync(configPath, 'utf-8'));
+        }
+        catch {
+            // Invalid JSON, start fresh
+        }
+    }
+    data.permission = permission;
+    writeFileSync(configPath, JSON.stringify(data, null, 2));
+}
+/**
+ * Remove project permission from local .codeep/config.json
+ */
+export function removeProjectPermission(projectPath) {
+    const configPath = getLocalConfigPath(projectPath);
+    if (!configPath || !existsSync(configPath)) {
+        return false;
+    }
+    try {
+        const data = JSON.parse(readFileSync(configPath, 'utf-8'));
+        if (data.permission) {
+            delete data.permission;
+            writeFileSync(configPath, JSON.stringify(data, null, 2));
+            return true;
+        }
+    }
+    catch {
+        // Ignore errors
+    }
+    return false;
+}
+export function hasReadPermission(projectPath) {
+    const perm = getProjectPermission(projectPath);
+    return perm?.readPermission === true;
+}
+export function hasWritePermission(projectPath) {
+    const perm = getProjectPermission(projectPath);
+    return perm?.writePermission === true;
+}

package/dist/config/providers.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Provider configurations for different AI services
+ */
+export interface ProviderConfig {
+    name: string;
+    description: string;
+    protocols: {
+        openai?: {
+            baseUrl: string;
+            authHeader: 'Bearer' | 'x-api-key';
+            supportsNativeTools?: boolean;
+        };
+        anthropic?: {
+            baseUrl: string;
+            authHeader: 'Bearer' | 'x-api-key';
+            supportsNativeTools?: boolean;
+        };
+    };
+    models: {
+        id: string;
+        name: string;
+        description: string;
+    }[];
+    defaultModel: string;
+    defaultProtocol: 'openai' | 'anthropic';
+    envKey?: string;
+}
+export declare const PROVIDERS: Record<string, ProviderConfig>;
+export type ProviderId = keyof typeof PROVIDERS;
+export declare function getProvider(id: string): ProviderConfig | null;
+export declare function getProviderList(): {
+    id: string;
+    name: string;
+    description: string;
+}[];
+export declare function getProviderModels(providerId: string): {
+    id: string;
+    name: string;
+    description: 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 supportsNativeTools(providerId: string, protocol: 'openai' | 'anthropic'): boolean;

package/dist/config/providers.js

@@ -0,0 +1,82 @@
+/**
+ * Provider configurations for different AI services
+ */
+export const PROVIDERS = {
+    'z.ai': {
+        name: 'Z.AI (ZhipuAI)',
+        description: 'GLM Coding Plan',
+        protocols: {
+            openai: {
+                baseUrl: 'https://api.z.ai/api/coding/paas/v4',
+                authHeader: 'Bearer',
+                supportsNativeTools: true,
+            },
+            anthropic: {
+                baseUrl: 'https://api.z.ai/api/anthropic',
+                authHeader: 'x-api-key',
+                supportsNativeTools: true,
+            },
+        },
+        models: [
+            { 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_API_KEY',
+    },
+    'minimax': {
+        name: 'MiniMax',
+        description: 'MiniMax Coding Plan',
+        protocols: {
+            openai: {
+                baseUrl: 'https://api.minimax.io/v1',
+                authHeader: 'Bearer',
+                supportsNativeTools: true,
+            },
+            anthropic: {
+                baseUrl: 'https://api.minimax.io/anthropic',
+                authHeader: 'x-api-key',
+                supportsNativeTools: false, // MiniMax Anthropic doesn't support native tools properly
+            },
+        },
+        models: [
+            { id: 'MiniMax-M2.1', name: 'MiniMax M2.1', description: 'Latest MiniMax coding model' },
+        ],
+        defaultModel: 'MiniMax-M2.1',
+        defaultProtocol: 'anthropic',
+        envKey: 'MINIMAX_API_KEY',
+    },
+};
+export function getProvider(id) {
+    return PROVIDERS[id] || null;
+}
+export function getProviderList() {
+    return Object.entries(PROVIDERS).map(([id, config]) => ({
+        id,
+        name: config.name,
+        description: config.description,
+    }));
+}
+export function getProviderModels(providerId) {
+    const provider = PROVIDERS[providerId];
+    return provider ? provider.models : [];
+}
+export function getProviderBaseUrl(providerId, protocol) {
+    const provider = PROVIDERS[providerId];
+    if (!provider)
+        return null;
+    return provider.protocols[protocol]?.baseUrl || null;
+}
+export function getProviderAuthHeader(providerId, protocol) {
+    const provider = PROVIDERS[providerId];
+    if (!provider)
+        return 'Bearer';
+    return provider.protocols[protocol]?.authHeader || 'Bearer';
+}
+export function supportsNativeTools(providerId, protocol) {
+    const provider = PROVIDERS[providerId];
+    if (!provider)
+        return false;
+    return provider.protocols[protocol]?.supportsNativeTools ?? true; // Default to true
+}

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

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