codeep 1.2.62 → 1.2.64

package/dist/renderer/App.d.ts

@@ -41,6 +41,7 @@ export declare class App {
     private spinnerInterval;
     private isAgentRunning;
     private agentIteration;
+    private agentMaxIterations;
     private agentActions;
     private agentThinking;
     private pasteInfo;
@@ -173,6 +174,7 @@ export declare class App {
         target: string;
         result: string;
     }): void;
+    setAgentMaxIterations(max: number): void;
     /**
      * Set agent thinking text
      */

package/dist/renderer/App.js

@@ -99,6 +99,7 @@ export class App {
     // Agent progress state
     isAgentRunning = false;
     agentIteration = 0;
+    agentMaxIterations = 0;
     agentActions = [];
     agentThinking = '';
     // Paste detection state
@@ -361,6 +362,7 @@ export class App {
         this.isAgentRunning = running;
         if (running) {
             this.agentIteration = 0;
+            this.agentMaxIterations = 0;
             this.agentActions = [];
             this.agentThinking = '';
             this.isLoading = false; // Clear loading state when agent takes over
@@ -382,6 +384,9 @@ export class App {
         }
         this.render();
     }
+    setAgentMaxIterations(max) {
+        this.agentMaxIterations = max;
+    }
     /**
      * Set agent thinking text
      */
@@ -1445,7 +1450,10 @@ export class App {
         // Agent running state - show special prompt
         if (this.isAgentRunning) {
             const spinner = SPINNER_FRAMES[this.spinnerFrame];
-            const agentText = `${spinner} Agent working... step ${this.agentIteration} | ${this.agentActions.length} actions (Esc to stop)`;
+            const stepLabel = this.agentMaxIterations > 0
+                ? `step ${this.agentIteration}/${this.agentMaxIterations}`
+                : `step ${this.agentIteration}`;
+            const agentText = `${spinner} Agent working... ${stepLabel} | ${this.agentActions.length} actions (Esc to stop)`;
             this.screen.writeLine(y, agentText, PRIMARY_COLOR);
             this.screen.showCursor(false);
             return;
@@ -1932,7 +1940,9 @@ export class App {
             x += txt.length + 1;
         }
         // Step info on the right
-        const stepText = `step ${this.agentIteration}`;
+        const stepText = this.agentMaxIterations > 0
+            ? `step ${this.agentIteration}/${this.agentMaxIterations}`
+            : `step ${this.agentIteration}`;
         this.screen.write(width - stepText.length - 1, y, stepText, fg.gray);
         y++;
         // Bottom border with help

package/dist/renderer/agentExecution.js

@@ -135,6 +135,8 @@ export async function executeAgentTask(task, dryRun, ctx) {
     try {
         const fileContext = ctx.formatAddedFilesContext();
         const enrichedTask = fileContext ? fileContext + task : task;
+        // Show N/M progress in status bar
+        app.setAgentMaxIterations(config.get('agentMaxIterations'));
         const result = await runAgent(enrichedTask, context, {
             dryRun,
             chatHistory: app.getChatHistory(),
@@ -320,7 +322,11 @@ export async function executeAgentTask(task, dryRun, ctx) {
             app.addMessage({ role: 'assistant', content: 'Agent stopped by user.' });
         }
         else {
-            app.addMessage({ role: 'assistant', content: `Agent failed: ${result.error || 'Unknown error'}` });
+            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') });
         }
         autoSaveSession(app.getMessages(), ctx.projectPath);
     }

package/dist/utils/agent.js

@@ -38,6 +38,56 @@ import { startSession, endSession, undoLastAction, undoAllActions, getCurrentSes
 import { runAllVerifications, formatErrorsForAgent, hasVerificationErrors, getVerificationSummary } from './verify.js';
 import { gatherSmartContext, formatSmartContext, extractTargetFile } from './smartContext.js';
 import { planTasks, formatTaskPlan } from './taskPlanner.js';
+// ─── Tool result truncation ───────────────────────────────────────────────────
+const TOOL_RESULT_MAX_CHARS = 8_000; // ~2K tokens per tool result
+function truncateToolResult(output, toolName) {
+    if (output.length <= TOOL_RESULT_MAX_CHARS)
+        return output;
+    const kept = output.slice(0, TOOL_RESULT_MAX_CHARS);
+    const truncated = output.length - TOOL_RESULT_MAX_CHARS;
+    return `${kept}\n[... ${truncated} chars truncated — use search_code or read specific sections if you need more]`;
+}
+// ─── Context window compression ───────────────────────────────────────────────
+const CONTEXT_COMPRESS_THRESHOLD = 80_000; // ~20K tokens, safe for all providers
+const RECENT_MESSAGES_TO_KEEP = 6; // Always preserve the last N messages verbatim
+/**
+ * Compress old messages when the conversation grows too large.
+ * Keeps the first message (original task) and the last RECENT_MESSAGES_TO_KEEP
+ * messages intact. Everything in between is replaced with a compact summary
+ * built from the actions log — no extra API call needed.
+ */
+function compressMessages(messages, actions) {
+    const totalChars = messages.reduce((sum, m) => sum + m.content.length, 0);
+    if (totalChars < CONTEXT_COMPRESS_THRESHOLD)
+        return messages;
+    // Need at least first + recent block to be worth compressing
+    if (messages.length <= RECENT_MESSAGES_TO_KEEP + 1)
+        return messages;
+    const firstMessage = messages[0];
+    const recentMessages = messages.slice(-RECENT_MESSAGES_TO_KEEP);
+    // Build summary from action log
+    const fileWrites = actions.filter(a => a.type === 'write' || a.type === 'edit');
+    const fileDeletes = actions.filter(a => a.type === 'delete');
+    const commands = actions.filter(a => a.type === 'command');
+    const reads = actions.filter(a => a.type === 'read');
+    const summaryLines = ['[Context compressed — summary of work so far]'];
+    if (fileWrites.length > 0) {
+        summaryLines.push(`Files written/edited (${fileWrites.length}): ${fileWrites.map(a => a.target).join(', ')}`);
+    }
+    if (fileDeletes.length > 0) {
+        summaryLines.push(`Files deleted: ${fileDeletes.map(a => a.target).join(', ')}`);
+    }
+    if (commands.length > 0) {
+        summaryLines.push(`Commands run: ${commands.map(a => a.target).join(', ')}`);
+    }
+    if (reads.length > 0) {
+        summaryLines.push(`Files read (${reads.length}): ${reads.slice(-10).map(a => a.target).join(', ')}`);
+    }
+    summaryLines.push('[End of summary — continuing from current state]');
+    const summaryMessage = { role: 'user', content: summaryLines.join('\n') };
+    debug(`Context compressed: ${totalChars} chars → keeping first + summary + last ${RECENT_MESSAGES_TO_KEEP} messages`);
+    return [firstMessage, summaryMessage, ...recentMessages];
+}
 const DEFAULT_OPTIONS = {
     maxIterations: 100, // Increased for large tasks
     maxDuration: 20 * 60 * 1000, // 20 minutes
@@ -129,16 +179,29 @@ export async function runAgent(prompt, projectContext, options = {}) {
     const maxTimeoutRetries = 3;
     const maxConsecutiveTimeouts = 9; // 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();
+    let duplicateWriteCount = 0;
+    // Duplicate read cache: path → truncated output (avoid re-sending large file content)
+    const readCache = new Map();
     try {
         while (iteration < opts.maxIterations) {
             // Check timeout
             if (Date.now() - startTime > opts.maxDuration) {
+                const filesDone = actions.filter(a => a.type === 'write' || a.type === 'edit').map(a => a.target);
+                const durationMin = Math.round(opts.maxDuration / 60000);
+                const partialLines = [`Agent reached the time limit (${durationMin} min).`];
+                if (filesDone.length > 0) {
+                    partialLines.push(`\n**Partial progress — files written/edited:**`);
+                    [...new Set(filesDone)].forEach(f => partialLines.push(`  ✓ \`${f}\``));
+                    partialLines.push(`\nYou can continue by running the agent again.`);
+                }
                 result = {
                     success: false,
                     iterations: iteration,
                     actions,
-                    finalResponse: 'Agent timed out',
-                    error: `Exceeded maximum duration of ${opts.maxDuration / 1000} seconds`,
+                    finalResponse: partialLines.join('\n'),
+                    error: `Exceeded maximum duration of ${durationMin} min`,
                 };
                 return result;
             }
@@ -156,6 +219,13 @@ export async function runAgent(prompt, projectContext, options = {}) {
             }
             iteration++;
             opts.onIteration?.(iteration, `Iteration ${iteration}/${opts.maxIterations}`);
+            // Compress messages if context window is getting full
+            const compressed = compressMessages(messages, actions);
+            if (compressed !== messages) {
+                messages.length = 0;
+                messages.push(...compressed);
+                opts.onIteration?.(iteration, `Context compressed (${compressed.length} messages kept)`);
+            }
             debug(`Starting iteration ${iteration}/${opts.maxIterations}, actions: ${actions.length}`);
             // Calculate dynamic timeout based on task complexity
             const dynamicTimeout = calculateDynamicTimeout(prompt, iteration, baseTimeout);
@@ -294,13 +364,57 @@ export async function runAgent(prompt, projectContext, options = {}) {
                 // Log action
                 const actionLog = createActionLog(toolCall, toolResult);
                 actions.push(actionLog);
-                // Format result for AI
-                if (toolResult.success) {
-                    toolResults.push(`Tool ${toolCall.tool} succeeded:\n${toolResult.output}`);
+                // ── Infinite loop detection for write/edit ──────────────────────────
+                if (toolCall.tool === 'write_file' || toolCall.tool === 'edit_file') {
+                    const filePath = toolCall.parameters.path || '';
+                    const contentKey = JSON.stringify(toolCall.parameters).slice(0, 500);
+                    const prevHash = lastWriteHashByPath.get(filePath);
+                    if (prevHash === contentKey) {
+                        duplicateWriteCount++;
+                        if (duplicateWriteCount >= 2) {
+                            toolResults.push(`[WARNING] You have written the same content to \`${filePath}\` ${duplicateWriteCount + 1} times in a row. You are stuck in a loop. Stop and think differently — read the file to check its current state, then try a completely different approach.`);
+                            duplicateWriteCount = 0;
+                        }
+                        else {
+                            toolResults.push(`Tool ${toolCall.tool} succeeded (note: same content as previous write to this file):\n${toolResult.output}`);
+                        }
+                    }
+                    else {
+                        duplicateWriteCount = 0;
+                        lastWriteHashByPath.set(filePath, contentKey);
+                        if (toolResult.success) {
+                            toolResults.push(`Tool ${toolCall.tool} succeeded:\n${toolResult.output}`);
+                        }
+                        else {
+                            toolResults.push(`Tool ${toolCall.tool} failed:\n${toolResult.error || 'Unknown error'}`);
+                        }
+                    }
+                    // ── Duplicate read cache ────────────────────────────────────────────
+                }
+                else if (toolCall.tool === 'read_file' && toolResult.success) {
+                    const filePath = toolCall.parameters.path || '';
+                    if (readCache.has(filePath)) {
+                        toolResults.push(`Tool read_file succeeded (cached — file unchanged since last read):\n${readCache.get(filePath)}`);
+                    }
+                    else {
+                        const truncated = truncateToolResult(toolResult.output, toolCall.tool);
+                        readCache.set(filePath, truncated);
+                        toolResults.push(`Tool read_file succeeded:\n${truncated}`);
+                    }
+                    // ── General truncation for other tools ─────────────────────────────
+                }
+                else if (toolResult.success) {
+                    const truncated = truncateToolResult(toolResult.output, toolCall.tool);
+                    toolResults.push(`Tool ${toolCall.tool} succeeded:\n${truncated}`);
                 }
                 else {
                     toolResults.push(`Tool ${toolCall.tool} failed:\n${toolResult.error || 'Unknown error'}`);
                 }
+                // Invalidate read cache when a file is written/edited
+                if ((toolCall.tool === 'write_file' || toolCall.tool === 'edit_file') && toolResult.success) {
+                    const filePath = toolCall.parameters.path || '';
+                    readCache.delete(filePath);
+                }
             }
             // Add tool results to messages
             messages.push({
@@ -308,13 +422,20 @@ export async function runAgent(prompt, projectContext, options = {}) {
                 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.`,
             });
         }
-        // Check if we hit max iterations
+        // Check if we hit max iterations — build partial summary from actions log
         if (iteration >= opts.maxIterations && !finalResponse) {
+            const filesDone = actions.filter(a => a.type === 'write' || a.type === 'edit').map(a => a.target);
+            const partialLines = [`Agent reached the iteration limit (${opts.maxIterations} steps).`];
+            if (filesDone.length > 0) {
+                partialLines.push(`\n**Partial progress — files written/edited:**`);
+                [...new Set(filesDone)].forEach(f => partialLines.push(`  ✓ \`${f}\``));
+                partialLines.push(`\nThe task may be incomplete. You can continue by running the agent again.`);
+            }
             result = {
                 success: false,
                 iterations: iteration,
                 actions,
-                finalResponse: 'Agent reached maximum iterations',
+                finalResponse: partialLines.join('\n'),
                 error: `Exceeded maximum of ${opts.maxIterations} iterations`,
             };
             return result;

package/package.json

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