codeep 1.2.87 → 1.2.89

package/dist/acp/commands.js

@@ -190,12 +190,17 @@ export async function handleCommand(input, session, onChunk, abortSignal) {
             return { handled: true, response: `Write access granted for \`${ctx?.name || session.workspaceRoot}\`` };
         }
         case 'lang': {
+            const validLangs = ['auto', 'en', 'zh', 'es', 'hi', 'ar', 'pt', 'fr', 'de', 'ja', 'ru', 'hr'];
             if (!args.length) {
                 const current = config.get('language') || 'auto';
-                return { handled: true, response: `Current language: \`${current}\`. Usage: \`/lang <code>\` (e.g. \`en\`, \`hr\`, \`auto\`)` };
+                return { handled: true, response: `Current language: \`${current}\`. Usage: \`/lang <code>\` (${validLangs.join(', ')})` };
             }
-            config.set('language', args[0]);
-            return { handled: true, response: `Language set to \`${args[0]}\`` };
+            const lang = args[0].toLowerCase();
+            if (!validLangs.includes(lang)) {
+                return { handled: true, response: `Invalid language \`${args[0]}\`. Valid: ${validLangs.join(', ')}` };
+            }
+            config.set('language', lang);
+            return { handled: true, response: `Language set to \`${lang}\`` };
         }
         // ─── File context ──────────────────────────────────────────────────────────
         case 'add': {
@@ -211,7 +216,11 @@ export async function handleCommand(input, session, onChunk, abortSignal) {
             const added = [];
             const errors = [];
             for (const filePath of args) {
-                const fullPath = pathMod.isAbsolute(filePath) ? filePath : pathMod.join(root, filePath);
+                const fullPath = pathMod.resolve(root, filePath);
+                if (!fullPath.startsWith(root + pathMod.sep) && fullPath !== root) {
+                    errors.push(`\`${filePath}\`: path outside workspace`);
+                    continue;
+                }
                 const relativePath = pathMod.relative(root, fullPath);
                 try {
                     const stat = await fs.stat(fullPath);
@@ -248,7 +257,9 @@ export async function handleCommand(input, session, onChunk, abortSignal) {
             const root = session.workspaceRoot;
             let dropped = 0;
             for (const filePath of args) {
-                const fullPath = pathMod.isAbsolute(filePath) ? filePath : pathMod.join(root, filePath);
+                const fullPath = pathMod.resolve(root, filePath);
+                if (!fullPath.startsWith(root + pathMod.sep) && fullPath !== root)
+                    continue;
                 if (session.addedFiles.delete(fullPath))
                     dropped++;
             }

package/dist/acp/transport.js

@@ -1,5 +1,7 @@
 // acp/transport.ts
 // Newline-delimited JSON-RPC over stdio
+const MAX_BUFFER_SIZE = 10 * 1024 * 1024; // 10MB
+const REQUEST_TIMEOUT_MS = 30_000; // 30s
 export class StdioTransport {
     buffer = '';
     handler = null;
@@ -13,6 +15,10 @@ export class StdioTransport {
     }
     onData(chunk) {
         this.buffer += chunk;
+        if (this.buffer.length > MAX_BUFFER_SIZE) {
+            this.buffer = '';
+            return;
+        }
         const lines = this.buffer.split('\n');
         this.buffer = lines.pop() ?? '';
         for (const line of lines) {
@@ -59,6 +65,11 @@ export class StdioTransport {
         return new Promise((resolve) => {
             this.pendingRequests.set(id, resolve);
             process.stdout.write(JSON.stringify({ jsonrpc: '2.0', id, method, params }) + '\n');
+            setTimeout(() => {
+                if (this.pendingRequests.delete(id)) {
+                    resolve(null);
+                }
+            }, REQUEST_TIMEOUT_MS);
         });
     }
 }

package/dist/config/index.d.ts

@@ -38,6 +38,7 @@ interface ConfigSchema {
     agentMaxIterations: number;
     agentMaxDuration: number;
     agentApiTimeout: number;
+    agentInteractive: boolean;
     projectPermissions: ProjectPermission[];
     providerApiKeys: ProviderApiKey[];
 }

package/dist/config/index.js

@@ -148,9 +148,10 @@ function createConfig() {
         agentAutoCommitBranch: false,
         agentAutoVerify: 'off',
         agentMaxFixAttempts: 3,
-        agentMaxIterations: 200,
-        agentMaxDuration: 20,
-        agentApiTimeout: 180000,
+        agentMaxIterations: 10000,
+        agentMaxDuration: 480,
+        agentApiTimeout: 600000,
+        agentInteractive: true,
         protocol: 'openai',
         plan: 'lite',
         language: 'en',
@@ -159,8 +160,8 @@ function createConfig() {
         temperature: 0.7,
         maxTokens: 8192,
         apiTimeout: 60000,
-        rateLimitApi: 30,
-        rateLimitCommands: 100,
+        rateLimitApi: 10000,
+        rateLimitCommands: 10000,
         projectPermissions: [],
         providerApiKeys: [],
     };

package/dist/renderer/components/Settings.js

@@ -41,8 +41,8 @@ export const SETTINGS = [
         getValue: () => config.get('rateLimitApi'),
         type: 'number',
         min: 1,
-        max: 300,
-        step: 5,
+        max: 10000,
+        step: 50,
     },
     {
         key: 'rateLimitCommands',
@@ -50,8 +50,8 @@ export const SETTINGS = [
         getValue: () => config.get('rateLimitCommands'),
         type: 'number',
         min: 10,
-        max: 1000,
-        step: 10,
+        max: 10000,
+        step: 100,
     },
     {
         key: 'autoSave',
@@ -91,8 +91,8 @@ export const SETTINGS = [
         getValue: () => config.get('agentApiTimeout'),
         type: 'number',
         min: 30000,
-        max: 300000,
-        step: 10000,
+        max: 3600000,
+        step: 30000,
     },
     {
         key: 'agentMaxDuration',
@@ -100,8 +100,8 @@ export const SETTINGS = [
         getValue: () => config.get('agentMaxDuration'),
         type: 'number',
         min: 5,
-        max: 60,
-        step: 5,
+        max: 1440,
+        step: 30,
     },
     {
         key: 'agentMaxIterations',
@@ -109,8 +109,8 @@ export const SETTINGS = [
         getValue: () => config.get('agentMaxIterations'),
         type: 'number',
         min: 10,
-        max: 500,
-        step: 10,
+        max: 100000,
+        step: 100,
     },
     {
         key: 'agentAutoVerify',

package/dist/utils/agent.d.ts

@@ -4,9 +4,9 @@
  * Private chat/stream logic lives in agentChat.ts and agentStream.ts.
  */
 import { ProjectContext } from './project';
-import { loadProjectRules, formatChatHistoryForAgent } from './agentChat';
+import { loadProjectRules, loadProgressLog, writeProgressLog, formatChatHistoryForAgent } from './agentChat';
 import type { AgentChatResponse } from './agentChat';
-export { loadProjectRules, formatChatHistoryForAgent };
+export { loadProjectRules, loadProgressLog, writeProgressLog, formatChatHistoryForAgent };
 export type { AgentChatResponse };
 import { ToolCall, ToolResult, ActionLog } from './tools';
 import { undoLastAction, undoAllActions, getCurrentSession, getRecentSessions, formatSession, ActionSession } from './history';

package/dist/utils/agent.js

@@ -10,9 +10,9 @@ const debug = (...args) => {
     }
 };
 // Import chat layer (prompt building + API calls)
-import { agentChat, getAgentSystemPrompt, getFallbackSystemPrompt, loadProjectRules, formatChatHistoryForAgent, } from './agentChat.js';
+import { agentChat, getAgentSystemPrompt, getFallbackSystemPrompt, loadProjectRules, loadProgressLog, writeProgressLog, formatChatHistoryForAgent, } from './agentChat.js';
 import { ApiError } from '../api/index.js';
-export { loadProjectRules, formatChatHistoryForAgent };
+export { loadProjectRules, loadProgressLog, writeProgressLog, formatChatHistoryForAgent };
 /**
  * Calculate dynamic timeout based on task complexity
  * Complex tasks (creating pages, multiple files) need more time
@@ -28,9 +28,9 @@ function calculateDynamicTimeout(iteration, baseTimeout) {
     if (iteration > 8) {
         multiplier = 1.5;
     }
-    // Minimum 120 seconds, maximum 5 minutes for a single API call
+    // Minimum 120 seconds, no hard upper cap — let agentApiTimeout setting be the real ceiling
     const calculatedTimeout = baseTimeout * multiplier;
-    return Math.min(Math.max(calculatedTimeout, 120000), 300000);
+    return Math.max(calculatedTimeout, 120000);
 }
 import { parseToolCalls, executeTool, createActionLog } from './tools.js';
 import { config } from '../config/index.js';
@@ -157,6 +157,11 @@ export async function runAgent(prompt, projectContext, options = {}) {
     if (projectRules) {
         systemPrompt += projectRules;
     }
+    // Inject previous session progress (from .codeep/progress.md)
+    const progressLog = loadProgressLog(projectContext.root);
+    if (progressLog) {
+        systemPrompt += progressLog;
+    }
     if (smartContextStr) {
         systemPrompt += '\n\n' + smartContextStr;
     }
@@ -176,13 +181,13 @@ export async function runAgent(prompt, projectContext, options = {}) {
     let result;
     let consecutiveTimeouts = 0;
     let incompleteWorkRetries = 0;
-    const maxIncompleteWorkRetries = 2;
+    const maxIncompleteWorkRetries = 5;
     // Track tools permanently allowed this session via allow_always
     const alwaysAllowedTools = new Set();
     // Tools that require permission when onRequestPermission is set
     const dangerousTools = new Set(['delete_file', 'execute_command']);
     const maxTimeoutRetries = 3;
-    const maxConsecutiveTimeouts = 9; // Allow more consecutive timeouts before giving up
+    const maxConsecutiveTimeouts = 30; // Allow more consecutive timeouts before giving up
     const baseTimeout = config.get('agentApiTimeout');
     // Infinite loop detection: track last write hash per file path
     const lastWriteHashByPath = new Map();
@@ -208,6 +213,7 @@ export async function runAgent(prompt, projectContext, options = {}) {
                     finalResponse: partialLines.join('\n'),
                     error: `Exceeded maximum duration of ${durationMin} min`,
                 };
+                writeProgressLog(projectContext.root || '', prompt, result);
                 return result;
             }
             // Check abort signal
@@ -519,7 +525,7 @@ export async function runAgent(prompt, projectContext, options = {}) {
             // Add tool results to messages
             messages.push({
                 role: 'user',
-                content: `Tool results:\n\n${toolResults.join('\n\n')}\n\nContinue with the task. If this subtask is complete, provide a summary without tool calls.`,
+                content: `Tool results:\n\n${toolResults.join('\n\n')}\n\nContinue with the task. Keep working until everything is fully done.`,
             });
         }
         // Check if we hit max iterations — build partial summary from actions log
@@ -538,6 +544,7 @@ export async function runAgent(prompt, projectContext, options = {}) {
                 finalResponse: partialLines.join('\n'),
                 error: `Exceeded maximum of ${opts.maxIterations} iterations`,
             };
+            writeProgressLog(projectContext.root || '', prompt, result);
             return result;
         }
         // Self-verification: Run build/test and fix errors if needed
@@ -669,6 +676,7 @@ export async function runAgent(prompt, projectContext, options = {}) {
             actions,
             finalResponse,
         };
+        writeProgressLog(projectContext.root || '', prompt, result);
         return result;
     }
     catch (error) {

package/dist/utils/agentChat.d.ts

@@ -25,6 +25,24 @@ export declare class TimeoutError extends Error {
  * Load project rules from .codeep/rules.md or CODEEP.md
  */
 export declare function loadProjectRules(projectRoot: string): string;
+/**
+ * Load agent progress log from .codeep/progress.md
+ * Injected into system prompt so agent knows what was previously done.
+ */
+export declare function loadProgressLog(projectRoot: string): string;
+/**
+ * Write agent progress log to .codeep/progress.md
+ * Called after each agent run so the next session has context.
+ */
+export declare function writeProgressLog(projectRoot: string, prompt: string, result: {
+    success: boolean;
+    iterations: number;
+    actions: Array<{
+        type: string;
+        target: string;
+    }>;
+    finalResponse: string;
+}): void;
 /**
  * Format chat session history for inclusion in agent system prompt.
  * Keeps the most recent messages within a character budget.

package/dist/utils/agentChat.js

@@ -11,7 +11,7 @@
  *   AgentChatResponse        — response type (re-export from agentStream)
  *   TimeoutError             — distinguishes timeout from user abort
  */
-import { existsSync, readFileSync } from 'fs';
+import { existsSync, readFileSync, writeFileSync } from 'fs';
 import { join } from 'path';
 import { config, getApiKey } from '../config/index.js';
 import { getProviderBaseUrl, getProviderAuthHeader, supportsNativeTools, getEffectiveMaxTokens } from '../config/providers.js';
@@ -57,6 +57,85 @@ export function loadProjectRules(projectRoot) {
     }
     return '';
 }
+/**
+ * Load agent progress log from .codeep/progress.md
+ * Injected into system prompt so agent knows what was previously done.
+ */
+export function loadProgressLog(projectRoot) {
+    if (!projectRoot)
+        return '';
+    const progressFile = join(projectRoot, '.codeep', 'progress.md');
+    if (!existsSync(progressFile))
+        return '';
+    try {
+        const content = readFileSync(progressFile, 'utf-8').trim();
+        if (content) {
+            return `\n\n## Previous Session Progress\nThe agent has previously worked on this project. Read this to understand what was already done and what still needs to be done:\n\n${content}`;
+        }
+    }
+    catch (err) {
+        debug('Failed to read progress log from', progressFile, err);
+    }
+    return '';
+}
+/**
+ * Write agent progress log to .codeep/progress.md
+ * Called after each agent run so the next session has context.
+ */
+export function writeProgressLog(projectRoot, prompt, result) {
+    if (!projectRoot)
+        return;
+    const codeepDir = join(projectRoot, '.codeep');
+    if (!existsSync(codeepDir))
+        return; // Only write if .codeep already exists (initialized project)
+    try {
+        const now = new Date().toISOString();
+        const fileWrites = result.actions.filter(a => a.type === 'write' || a.type === 'edit');
+        const fileDeletes = result.actions.filter(a => a.type === 'delete');
+        const commands = result.actions.filter(a => a.type === 'command');
+        const lines = [
+            `# Agent Progress Log`,
+            ``,
+            `## Last Session: ${now}`,
+            ``,
+            `### Task`,
+            `${prompt}`,
+            ``,
+            `### Status`,
+            result.success ? `✓ Completed (${result.iterations} iterations)` : `⚠ Incomplete — task may need to be continued`,
+            ``,
+        ];
+        if (fileWrites.length > 0) {
+            lines.push(`### Files Written/Edited`);
+            [...new Set(fileWrites.map(a => a.target))].forEach(f => lines.push(`- ${f}`));
+            lines.push('');
+        }
+        if (fileDeletes.length > 0) {
+            lines.push(`### Files Deleted`);
+            [...new Set(fileDeletes.map(a => a.target))].forEach(f => lines.push(`- ${f}`));
+            lines.push('');
+        }
+        if (commands.length > 0) {
+            lines.push(`### Commands Run`);
+            commands.forEach(a => lines.push(`- ${a.target}`));
+            lines.push('');
+        }
+        if (result.finalResponse) {
+            lines.push(`### Summary`);
+            lines.push(result.finalResponse.slice(0, 3000));
+            lines.push('');
+        }
+        if (!result.success) {
+            lines.push(`### What Still Needs to Be Done`);
+            lines.push(`The task was not fully completed in the last session. Run the agent again on the same project to continue from where it left off.`);
+            lines.push('');
+        }
+        writeFileSync(join(codeepDir, 'progress.md'), lines.join('\n'), 'utf-8');
+    }
+    catch (err) {
+        debug('Failed to write progress log:', err);
+    }
+}
 /**
  * Format chat session history for inclusion in agent system prompt.
  * Keeps the most recent messages within a character budget.

package/dist/utils/ratelimit.js

@@ -76,11 +76,11 @@ class RateLimiter {
 }
 // Default rate limiters - configs are loaded from user settings
 let apiRateLimiter = new RateLimiter({
-    maxRequests: config.get('rateLimitApi') || 30,
+    maxRequests: config.get('rateLimitApi') || 1000000,
     windowMs: 60 * 1000, // per minute
 });
 let commandRateLimiter = new RateLimiter({
-    maxRequests: config.get('rateLimitCommands') || 100,
+    maxRequests: config.get('rateLimitCommands') || 10000,
     windowMs: 60 * 1000, // per minute
 });
 /**
@@ -88,11 +88,11 @@ let commandRateLimiter = new RateLimiter({
  */
 export function updateRateLimits() {
     apiRateLimiter = new RateLimiter({
-        maxRequests: config.get('rateLimitApi') || 30,
+        maxRequests: config.get('rateLimitApi') || 1000000,
         windowMs: 60 * 1000,
     });
     commandRateLimiter = new RateLimiter({
-        maxRequests: config.get('rateLimitCommands') || 100,
+        maxRequests: config.get('rateLimitCommands') || 10000,
         windowMs: 60 * 1000,
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeep",
-  "version": "1.2.87",
+  "version": "1.2.89",
   "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",