codeep 1.0.0

package/dist/config/providers.test.js

@@ -0,0 +1,132 @@
+import { describe, it, expect } from 'vitest';
+import { PROVIDERS, getProvider, getProviderList, getProviderModels, getProviderBaseUrl, getProviderAuthHeader, } from './providers';
+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 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 and minimax', () => {
+            const list = getProviderList();
+            const ids = list.map(p => p.id);
+            expect(ids).toContain('z.ai');
+            expect(ids).toContain('minimax');
+        });
+    });
+    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 minimax', () => {
+            expect(PROVIDERS['minimax'].envKey).toBe('MINIMAX_API_KEY');
+        });
+    });
+});

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from 'ink';
+import { App } from './app';
+import { getCurrentVersion } from './utils/update';
+// Handle CLI flags
+const args = process.argv.slice(2);
+if (args.includes('--version') || args.includes('-v')) {
+    console.log(`Codeep v${getCurrentVersion()}`);
+    process.exit(0);
+}
+if (args.includes('--help') || args.includes('-h')) {
+    console.log(`
+Codeep - AI-powered coding assistant TUI
+
+Usage:
+  codeep              Start interactive chat
+  codeep --version    Show version
+  codeep --help       Show this help
+
+Commands (in chat):
+  /help      Show all available commands
+  /status    Show current status
+  /version   Show version and current model
+  /update    Check for updates
+  /exit      Quit application
+
+Documentation: https://codeep.dev
+GitHub: https://github.com/VladoIvankovic/Codeep
+X/Twitter: https://x.com/CodeepDev
+Contact: info@codeep.dev
+  `);
+    process.exit(0);
+}
+// Clear screen
+console.clear();
+// Render app
+render(_jsx(App, {}));

package/dist/utils/agent.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Agent loop - autonomous task execution
+ */
+import { ProjectContext } from './project';
+import { ToolCall, ToolResult, ActionLog } from './tools';
+import { undoLastAction, undoAllActions, getCurrentSession, getRecentSessions, formatSession, ActionSession } from './history';
+import { VerifyResult } from './verify';
+export interface AgentOptions {
+    maxIterations: number;
+    maxDuration: number;
+    onToolCall?: (tool: ToolCall) => void;
+    onToolResult?: (result: ToolResult) => void;
+    onIteration?: (iteration: number, message: string) => void;
+    onThinking?: (text: string) => void;
+    onVerification?: (results: VerifyResult[]) => void;
+    abortSignal?: AbortSignal;
+    dryRun?: boolean;
+    autoVerify?: boolean;
+    maxFixAttempts?: number;
+}
+export interface AgentResult {
+    success: boolean;
+    iterations: number;
+    actions: ActionLog[];
+    finalResponse: string;
+    error?: string;
+    aborted?: boolean;
+}
+/**
+ * Run the agent loop
+ */
+export declare function runAgent(prompt: string, projectContext: ProjectContext, options?: Partial<AgentOptions>): Promise<AgentResult>;
+/**
+ * Format agent result for display
+ */
+export declare function formatAgentResult(result: AgentResult): string;
+export { undoLastAction, undoAllActions, getCurrentSession, getRecentSessions, formatSession, type ActionSession };