codeep 1.2.67 → 1.2.69

package/dist/renderer/App.d.ts

@@ -44,6 +44,7 @@ export declare class App {
     private agentMaxIterations;
     private agentActions;
     private agentThinking;
+    private agentWaitingForAI;
     private pasteInfo;
     private pasteInfoOpen;
     private codeBlockCounter;
@@ -179,6 +180,7 @@ export declare class App {
      * Set agent thinking text
      */
     setAgentThinking(text: string): void;
+    setAgentWaitingForAI(waiting: boolean): void;
     /**
      * Paste from system clipboard (Ctrl+V)
      */

package/dist/renderer/App.js

@@ -102,6 +102,7 @@ export class App {
     agentMaxIterations = 0;
     agentActions = [];
     agentThinking = '';
+    agentWaitingForAI = false;
     // Paste detection state
     pasteInfo = null;
     pasteInfoOpen = false;
@@ -365,6 +366,7 @@ export class App {
             this.agentMaxIterations = 0;
             this.agentActions = [];
             this.agentThinking = '';
+            this.agentWaitingForAI = true;
             this.isLoading = false; // Clear loading state when agent takes over
             this.startSpinner();
         }
@@ -394,6 +396,10 @@ export class App {
         this.agentThinking = text;
         this.render();
     }
+    setAgentWaitingForAI(waiting) {
+        this.agentWaitingForAI = waiting;
+        this.render();
+    }
     /**
      * Paste from system clipboard (Ctrl+V)
      */
@@ -1894,7 +1900,10 @@ export class App {
         y++;
         // Current action line (clear first to avoid stale text from longer previous paths)
         this.screen.writeLine(y, '');
-        if (this.agentActions.length > 0) {
+        if (this.agentWaitingForAI) {
+            this.screen.write(1, y, 'Thinking...', fg.gray);
+        }
+        else if (this.agentActions.length > 0) {
             const lastAction = this.agentActions[this.agentActions.length - 1];
             const actionLabel = this.getActionLabel(lastAction.type);
             const actionColor = this.getActionColor(lastAction.type);

package/dist/renderer/Screen.js

@@ -119,6 +119,7 @@ export class Screen {
             this.buffer[y][x] = { char: ' ', style: '' };
         }
         // Parse text character by character, tracking ANSI escape sequences
+        // Use index-based loop to handle ANSI sequences, but read full Unicode code points
         let col = 0;
         let i = 0;
         let currentStyle = prefixStyle;
@@ -132,8 +133,8 @@ export class Screen {
                 }
                 if (escEnd < text.length) {
                     const escSeq = text.slice(i, escEnd + 1);
-                    // Reset code clears style, otherwise accumulate
-                    if (escSeq === '\x1b[0m') {
+                    // Reset code clears accumulated style back to prefix
+                    if (escSeq === '\x1b[0m' || escSeq === '\x1b[m') {
                         currentStyle = prefixStyle;
                     }
                     else {
@@ -146,17 +147,20 @@ export class Screen {
                 }
             }
             else {
-                // Regular character
-                const w = charWidth(text[i]);
+                // Read full Unicode code point (handles surrogate pairs for emoji)
+                const codePoint = text.codePointAt(i) ?? text.charCodeAt(i);
+                const char = String.fromCodePoint(codePoint);
+                const charLen = char.length; // surrogate pair = 2, BMP char = 1
+                const w = charWidth(char);
                 if (col < this.width) {
-                    this.buffer[y][col] = { char: text[i], style: currentStyle };
+                    this.buffer[y][col] = { char, style: currentStyle };
                     // Wide char: fill next cell with empty placeholder
                     if (w === 2 && col + 1 < this.width) {
                         this.buffer[y][col + 1] = { char: '', style: currentStyle };
                     }
                 }
                 col += w;
-                i++;
+                i += charLen;
             }
         }
     }
@@ -192,8 +196,14 @@ export class Screen {
                 lineLength = wordLength;
             }
             else {
-                line += (line ? ' ' : '') + word;
-                lineLength += wordLength + (line.length > wordLength ? 1 : 0);
+                if (line) {
+                    line += ' ' + word;
+                    lineLength += 1 + wordLength;
+                }
+                else {
+                    line = word;
+                    lineLength = wordLength;
+                }
             }
         }
         if (line && currentY < this.height) {
@@ -236,8 +246,17 @@ export class Screen {
                 if (cell.char === renderedCell.char && cell.style === renderedCell.style) {
                     continue;
                 }
-                // Skip wide-char placeholder cells
+                // Wide-char placeholder cell (right half of emoji/CJK):
+                // If previously rendered something here, clear it with a space so there's no ghost.
+                // The wide char itself (left cell) already moved the terminal cursor past this cell.
                 if (cell.char === '') {
+                    if (renderedCell.char !== '') {
+                        // Previous char here was something visible — overwrite with space to clear ghost
+                        output += cursor.to(y + 1, x + 1);
+                        output += style.reset;
+                        lastStyle = '';
+                        output += ' ';
+                    }
                     this.rendered[y][x] = { ...cell };
                     continue;
                 }

package/dist/renderer/agentExecution.js

@@ -142,12 +142,14 @@ export async function executeAgentTask(task, dryRun, ctx) {
             chatHistory: app.getChatHistory(),
             onIteration: (iteration, message) => {
                 app.updateAgentProgress(iteration);
+                app.setAgentWaitingForAI(true); // Waiting for AI response between tool calls
                 // Show special status messages (timeout retries, verification) but not generic iteration messages
                 if (message && !message.startsWith('Iteration ')) {
                     app.addMessage({ role: 'system', content: `_${message}_` });
                 }
             },
             onToolCall: (tool) => {
+                app.setAgentWaitingForAI(false); // AI responded, executing tool
                 const toolName = tool.tool.toLowerCase();
                 const target = tool.parameters.path ||
                     tool.parameters.command ||

package/dist/utils/agent.js

@@ -283,12 +283,16 @@ export async function runAgent(prompt, projectContext, options = {}) {
                         await new Promise(resolve => setTimeout(resolve, 1000 * retryCount));
                         continue;
                     }
-                    // Handle 429 rate-limit / server overload with retry + backoff
-                    if (err.message.includes('429')) {
+                    // Retry on transient errors: rate-limit, server errors, network failures
+                    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
-                        debug(`429 rate limit (retry ${retryCount}/${maxTimeoutRetries}), waiting ${waitSec}s`);
-                        opts.onIteration?.(iteration, `Server busy (429), retrying in ${waitSec}s... (${retryCount}/${maxTimeoutRetries})`);
+                        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
                         }

package/package.json

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