codeep 1.2.69 → 1.2.70

package/dist/api/index.js

@@ -293,7 +293,7 @@ async function chatOpenAI(message, history, model, apiKey, onChunk, abortSignal)
     const timeoutId = setTimeout(() => { timedOut = true; controller.abort(); }, timeout);
     // Listen to external abort signal if provided (user cancel)
     if (abortSignal) {
-        abortSignal.addEventListener('abort', () => controller.abort());
+        abortSignal.addEventListener('abort', () => controller.abort(), { once: true });
     }
     // Build headers based on auth type
     const headers = {
@@ -413,7 +413,7 @@ async function chatAnthropic(message, history, model, apiKey, onChunk, abortSign
     const timeoutId = setTimeout(() => { timedOut = true; controller.abort(); }, timeout);
     // Listen to external abort signal if provided (user cancel)
     if (abortSignal) {
-        abortSignal.addEventListener('abort', () => controller.abort());
+        abortSignal.addEventListener('abort', () => controller.abort(), { once: true });
     }
     // Build headers based on auth type
     const headers = {

package/dist/renderer/agentExecution.js

@@ -9,6 +9,16 @@ import { chat } from '../api/index.js';
 import { runAgent } from '../utils/agent.js';
 import { config, autoSaveSession } from '../config/index.js';
 import { getGitStatus } from '../utils/git.js';
+function getActionType(toolName) {
+    return toolName.includes('write') ? 'write' :
+        toolName.includes('edit') ? 'edit' :
+            toolName.includes('read') ? 'read' :
+                toolName.includes('delete') ? 'delete' :
+                    toolName.includes('list') ? 'list' :
+                        toolName.includes('search') || toolName.includes('grep') ? 'search' :
+                            toolName.includes('mkdir') ? 'mkdir' :
+                                toolName.includes('fetch') ? 'fetch' : 'command';
+}
 // ─── Dangerous tool detection ────────────────────────────────────────────────
 const DANGEROUS_TOOLS = ['write', 'edit', 'delete', 'command', 'execute', 'shell', 'rm', 'mv'];
 export function isDangerousTool(toolName, parameters) {
@@ -154,14 +164,7 @@ export async function executeAgentTask(task, dryRun, ctx) {
                 const target = tool.parameters.path ||
                     tool.parameters.command ||
                     tool.parameters.pattern || '';
-                const actionType = toolName.includes('write') ? 'write' :
-                    toolName.includes('edit') ? 'edit' :
-                        toolName.includes('read') ? 'read' :
-                            toolName.includes('delete') ? 'delete' :
-                                toolName.includes('list') ? 'list' :
-                                    toolName.includes('search') || toolName.includes('grep') ? 'search' :
-                                        toolName.includes('mkdir') ? 'mkdir' :
-                                            toolName.includes('fetch') ? 'fetch' : 'command';
+                const actionType = getActionType(toolName);
                 const shortTarget = target.length > 50 ? '...' + target.slice(-47) : target;
                 app.setAgentThinking(`${actionType}: ${shortTarget}`);
                 if (actionType === 'write' && tool.parameters.content) {
@@ -247,14 +250,7 @@ export async function executeAgentTask(task, dryRun, ctx) {
             onToolResult: (result, toolCall) => {
                 const toolName = toolCall.tool.toLowerCase();
                 const target = toolCall.parameters.path || toolCall.parameters.command || '';
-                const actionType = toolName.includes('write') ? 'write' :
-                    toolName.includes('edit') ? 'edit' :
-                        toolName.includes('read') ? 'read' :
-                            toolName.includes('delete') ? 'delete' :
-                                toolName.includes('list') ? 'list' :
-                                    toolName.includes('search') || toolName.includes('grep') ? 'search' :
-                                        toolName.includes('mkdir') ? 'mkdir' :
-                                            toolName.includes('fetch') ? 'fetch' : 'command';
+                const actionType = getActionType(toolName);
                 app.updateAgentProgress(0, {
                     type: actionType,
                     target,
@@ -324,11 +320,13 @@ export async function executeAgentTask(task, dryRun, ctx) {
             app.addMessage({ role: 'assistant', content: 'Agent stopped by user.' });
         }
         else {
-            const failLines = [];
-            if (result.finalResponse)
-                failLines.push(result.finalResponse);
-            failLines.push(`**Agent stopped**: ${result.error || 'Unknown error'}`);
-            app.addMessage({ role: 'assistant', content: failLines.join('\n\n') });
+            // Show the agent's summary if available, with error details below
+            if (result.finalResponse) {
+                app.addMessage({ role: 'assistant', content: result.finalResponse });
+            }
+            else {
+                app.addMessage({ role: 'assistant', content: `Agent could not complete the task: ${result.error || 'Unknown error'}` });
+            }
         }
         autoSaveSession(app.getMessages(), ctx.projectPath);
     }

package/dist/utils/agent.js

@@ -16,7 +16,7 @@ export { loadProjectRules, formatChatHistoryForAgent };
  * Calculate dynamic timeout based on task complexity
  * Complex tasks (creating pages, multiple files) need more time
  */
-function calculateDynamicTimeout(prompt, iteration, baseTimeout) {
+function calculateDynamicTimeout(iteration, baseTimeout) {
     // Simple approach: just use base timeout with small multiplier for later iterations
     // Complex calculations were causing more problems than they solved
     let multiplier = 1.0;
@@ -224,11 +224,11 @@ export async function runAgent(prompt, projectContext, options = {}) {
             if (compressed !== messages) {
                 messages.length = 0;
                 messages.push(...compressed);
-                opts.onIteration?.(iteration, `Context compressed (${compressed.length} messages kept)`);
+                opts.onIteration?.(iteration, `Context compressed to save memory — continuing with last ${compressed.length} messages`);
             }
             debug(`Starting iteration ${iteration}/${opts.maxIterations}, actions: ${actions.length}`);
             // Calculate dynamic timeout based on task complexity
-            const dynamicTimeout = calculateDynamicTimeout(prompt, iteration, baseTimeout);
+            const dynamicTimeout = calculateDynamicTimeout(iteration, baseTimeout);
             debug(`Using timeout: ${dynamicTimeout}ms (base: ${baseTimeout}ms)`);
             // Get AI response with retry logic for timeouts
             let chatResponse = null;
@@ -283,23 +283,37 @@ export async function runAgent(prompt, projectContext, options = {}) {
                         await new Promise(resolve => setTimeout(resolve, 1000 * retryCount));
                         continue;
                     }
-                    // Retry on transient errors: rate-limit, server errors, network failures
+                    // All non-abort errors are retryable — retry with backoff
+                    retryCount++;
                     const isRateLimit = err.message.includes('429');
                     const isServerError = err.message.includes('500') || err.message.includes('502') || err.message.includes('503') || err.message.includes('529');
-                    const isNetworkError = ['ECONNRESET', 'ECONNREFUSED', 'ETIMEDOUT', 'ENOTFOUND', 'EPIPE', 'EAI_AGAIN'].some(code => err.message.includes(code));
-                    if (isRateLimit || isServerError || isNetworkError) {
-                        retryCount++;
-                        const waitSec = Math.min(5 * retryCount, 30); // 5s, 10s, 15s … max 30s
-                        const code = isRateLimit ? '429' : isServerError ? '5xx' : 'network';
-                        debug(`${code} error (retry ${retryCount}/${maxTimeoutRetries}), waiting ${waitSec}s`);
-                        opts.onIteration?.(iteration, `Server error (${code}), retrying in ${waitSec}s... (${retryCount}/${maxTimeoutRetries})`);
-                        if (retryCount >= maxTimeoutRetries) {
-                            throw error; // Give up after max retries
+                    const code = isRateLimit ? '429' : isServerError ? '5xx' : 'error';
+                    const waitSec = Math.min(5 * retryCount, 30);
+                    debug(`${code} (retry ${retryCount}/${maxTimeoutRetries}): ${err.message}`);
+                    opts.onIteration?.(iteration, `API ${code}, retrying in ${waitSec}s... (${retryCount}/${maxTimeoutRetries})`);
+                    if (retryCount >= maxTimeoutRetries) {
+                        // Don't throw — skip this iteration like timeouts do
+                        consecutiveTimeouts++;
+                        if (consecutiveTimeouts >= maxConsecutiveTimeouts) {
+                            result = {
+                                success: false,
+                                iterations: iteration,
+                                actions,
+                                finalResponse: actions.length > 0
+                                    ? `Agent made progress (${actions.length} actions) but API errors prevented completion. You can continue by running the agent again.`
+                                    : 'Agent could not complete the task due to repeated API errors. Check your API key and network connection.',
+                                error: `API failed after ${maxTimeoutRetries} retries: ${err.message}`,
+                            };
+                            return result;
                         }
-                        await new Promise(resolve => setTimeout(resolve, waitSec * 1000));
-                        continue;
+                        messages.push({
+                            role: 'user',
+                            content: 'The previous request failed. Please continue with the task.'
+                        });
+                        break; // Break retry loop, continue main loop
                     }
-                    throw error;
+                    await new Promise(resolve => setTimeout(resolve, waitSec * 1000));
+                    continue;
                 }
             }
             // If we broke out due to max retries without a response, continue to next iteration
@@ -326,7 +340,7 @@ export async function runAgent(prompt, projectContext, options = {}) {
                     .replace(/<arg_key>[\s\S]*?<\/arg_value>/gi, '')
                     .replace(/Tool parameters:[\s\S]*?(?=\n\n|$)/gi, '')
                     .replace(/\{'path'[\s\S]*?\}/g, '')
-                    .replace(/```[\s\S]*?```/g, '')
+                    .replace(/```(?:json|tool_call)?\s*\{[\s\S]*?\}\s*```/g, '') // Only strip tool-call-like code blocks
                     .trim();
                 // Check if model indicates it wants to continue (incomplete response)
                 const continueIndicators = [
@@ -426,11 +440,14 @@ export async function runAgent(prompt, projectContext, options = {}) {
                 else {
                     toolResults.push(`Tool ${toolCall.tool} failed:\n${toolResult.error || 'Unknown error'}`);
                 }
-                // Invalidate read cache when a file is written/edited
+                // Invalidate read cache when files may have changed
                 if ((toolCall.tool === 'write_file' || toolCall.tool === 'edit_file') && toolResult.success) {
                     const filePath = toolCall.parameters.path || '';
                     readCache.delete(filePath);
                 }
+                else if (toolCall.tool === 'execute_command' && toolResult.success) {
+                    readCache.clear(); // Commands can modify arbitrary files
+                }
             }
             // Add tool results to messages
             messages.push({
@@ -543,7 +560,8 @@ export async function runAgent(prompt, projectContext, options = {}) {
                             const actionLog = createActionLog(toolCall, toolResult);
                             actions.push(actionLog);
                             if (toolResult.success) {
-                                fixResults.push(`Tool ${toolCall.tool} succeeded:\n${toolResult.output}`);
+                                const truncated = truncateToolResult(toolResult.output, toolCall.tool);
+                                fixResults.push(`Tool ${toolCall.tool} succeeded:\n${truncated}`);
                             }
                             else {
                                 fixResults.push(`Tool ${toolCall.tool} failed:\n${toolResult.error || 'Unknown error'}`);

package/dist/utils/agentChat.js

@@ -154,7 +154,7 @@ export async function agentChat(messages, systemPrompt, onChunk, abortSignal, dy
     let isTimeout = false;
     const timeout = setTimeout(() => { isTimeout = true; controller.abort(); }, timeoutMs);
     if (abortSignal) {
-        abortSignal.addEventListener('abort', () => { isTimeout = false; controller.abort(); });
+        abortSignal.addEventListener('abort', () => { isTimeout = false; controller.abort(); }, { once: true });
     }
     const headers = { 'Content-Type': 'application/json' };
     if (authHeader === 'Bearer') {
@@ -268,7 +268,7 @@ export async function agentChatFallback(messages, systemPrompt, onChunk, abortSi
     let isTimeout = false;
     const timeout = setTimeout(() => { isTimeout = true; controller.abort(); }, timeoutMs);
     if (abortSignal) {
-        abortSignal.addEventListener('abort', () => { isTimeout = false; controller.abort(); });
+        abortSignal.addEventListener('abort', () => { isTimeout = false; controller.abort(); }, { once: true });
     }
     const headers = { 'Content-Type': 'application/json' };
     if (authHeader === 'Bearer') {

package/dist/utils/shell.js

@@ -112,8 +112,8 @@ export function validateCommand(command, args, options) {
     }
     // Special validation for rm command
     if (command === 'rm') {
-        const hasRecursive = args.some(a => a.includes('r'));
-        const hasForce = args.some(a => a.includes('f'));
+        const hasRecursive = args.some(a => a.startsWith('-') && a.includes('r'));
+        const hasForce = args.some(a => a.startsWith('-') && a.includes('f'));
         if (hasRecursive && hasForce) {
             // rm -rf requires extra validation
             const paths = args.filter(a => !a.startsWith('-'));

package/dist/utils/toolExecution.js

@@ -176,8 +176,8 @@ export async function executeTool(toolCall, projectRoot) {
                     return { success: false, output: '', error: 'Missing required parameter: path', tool, parameters };
                 }
                 if (content === undefined || content === null) {
-                    debug('write_file: content was undefined, using placeholder');
-                    content = '<!-- Content was not provided -->\n';
+                    debug('write_file failed: content was undefined');
+                    return { success: false, output: '', error: 'File content was empty or truncated by the API. Try writing a smaller file or splitting into multiple writes.', tool, parameters };
                 }
                 const validation = validatePath(path, projectRoot);
                 if (!validation.valid)

package/dist/utils/verify.js

@@ -390,25 +390,26 @@ export async function runLintVerification(projectRoot, timeout = 60000) {
 export async function runAllVerifications(projectRoot, options = {}) {
     const opts = { ...DEFAULT_OPTIONS, ...options };
     const results = [];
-    // Run typecheck first (fastest feedback)
-    if (opts.runTypecheck) {
-        const result = await runTypecheckVerification(projectRoot, opts.timeout);
-        if (result)
-            results.push(result);
+    // Run typecheck and lint in parallel (independent checks)
+    const parallel = [];
+    if (opts.runTypecheck)
+        parallel.push(runTypecheckVerification(projectRoot, opts.timeout));
+    if (opts.runLint)
+        parallel.push(runLintVerification(projectRoot, opts.timeout));
+    if (parallel.length > 0) {
+        const parallelResults = await Promise.all(parallel);
+        for (const r of parallelResults) {
+            if (r)
+                results.push(r);
+        }
     }
-    // Run build
+    // Run build after typecheck/lint (may depend on them)
     if (opts.runBuild) {
         const result = await runBuildVerification(projectRoot, opts.timeout);
         if (result)
             results.push(result);
     }
-    // Run lint
-    if (opts.runLint) {
-        const result = await runLintVerification(projectRoot, opts.timeout);
-        if (result)
-            results.push(result);
-    }
-    // Run tests last (slowest)
+    // Run tests last (slowest, depends on build)
     if (opts.runTest) {
         const result = await runTestVerification(projectRoot, opts.timeout);
         if (result)

package/package.json

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