codeep 1.2.66 → 1.2.68

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)
      */
@@ -1892,8 +1898,12 @@ export class App {
         this.screen.write(titlePadLeft, y, title, PRIMARY_COLOR + style.bold);
         this.screen.write(titlePadLeft + title.length, y, '─'.repeat(Math.max(0, titlePadRight)), PRIMARY_COLOR);
         y++;
-        // Current action line (no side borders)
-        if (this.agentActions.length > 0) {
+        // Current action line (clear first to avoid stale text from longer previous paths)
+        this.screen.writeLine(y, '');
+        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);
@@ -1906,7 +1916,8 @@ export class App {
             this.screen.write(1, y, 'Starting...', fg.gray);
         }
         y++;
-        // Stats line: Files and step info
+        // Stats line: Files and step info (clear line first to avoid stale text)
+        this.screen.writeLine(y, '');
         let x = 1;
         // File changes
         if (stats.writes > 0) {

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
                         }
@@ -468,7 +472,7 @@ export async function runAgent(prompt, projectContext, options = {}) {
                     }
                     opts.onIteration?.(iteration, `Verification attempt ${fixAttempt + 1}/${maxFixAttempts}`);
                     // Run verifications
-                    const verifyResults = runAllVerifications(projectContext.root || process.cwd(), {
+                    const verifyResults = await runAllVerifications(projectContext.root || process.cwd(), {
                         runBuild: true,
                         runTest: true,
                         runTypecheck: true,

package/dist/utils/shell.d.ts

@@ -27,10 +27,18 @@ export declare function validateCommand(command: string, args: string[], options
  * Execute a shell command with safety checks
  */
 export declare function executeCommand(command: string, args?: string[], options?: CommandOptions): CommandResult;
+/**
+ * Execute a shell command asynchronously (non-blocking)
+ */
+export declare function executeCommandAsync(command: string, args?: string[], options?: CommandOptions): Promise<CommandResult>;
 /**
  * Execute a command and return only stdout if successful
  */
 export declare function execSimple(command: string, args?: string[], options?: CommandOptions): string | null;
+/**
+ * Execute a command asynchronously and return only stdout if successful
+ */
+export declare function execSimpleAsync(command: string, args?: string[], options?: CommandOptions): Promise<string | null>;
 /**
  * Check if a command exists in PATH
  */

package/dist/utils/shell.js

@@ -1,7 +1,7 @@
 /**
  * Shell command execution utilities with safety checks
  */
-import { spawnSync } from 'child_process';
+import { spawnSync, spawn } from 'child_process';
 import { resolve, relative, isAbsolute } from 'path';
 import { existsSync } from 'fs';
 // Dangerous command patterns that should never be executed
@@ -68,7 +68,7 @@ const ALLOWED_COMMANDS = new Set([
     // Linting/Formatting
     'eslint', 'prettier', 'black', 'rustfmt',
     // Other common tools
-    'echo', 'pwd', 'which', 'env', 'date',
+    'echo', 'pwd', 'which', 'env', 'date', 'sleep',
     'curl', 'wget', // allowed but patterns checked
     'tar', 'unzip', 'zip',
     // HTTP tools
@@ -205,6 +205,100 @@ export function executeCommand(command, args = [], options) {
         };
     }
 }
+/**
+ * Execute a shell command asynchronously (non-blocking)
+ */
+export function executeCommandAsync(command, args = [], options) {
+    return new Promise((resolve) => {
+        const startTime = Date.now();
+        const cwd = options?.cwd || process.cwd();
+        const timeout = options?.timeout || 60000;
+        // Validate command first (synchronous, fast)
+        const validation = validateCommand(command, args, options);
+        if (!validation.valid) {
+            resolve({
+                success: false,
+                stdout: '',
+                stderr: validation.reason || 'Command validation failed',
+                exitCode: -1,
+                duration: 0,
+                command,
+                args,
+            });
+            return;
+        }
+        // Ensure cwd exists
+        if (!existsSync(cwd)) {
+            resolve({
+                success: false,
+                stdout: '',
+                stderr: `Working directory does not exist: ${cwd}`,
+                exitCode: -1,
+                duration: 0,
+                command,
+                args,
+            });
+            return;
+        }
+        const child = spawn(command, args, {
+            cwd,
+            env: { ...process.env, ...options?.env },
+        });
+        let stdout = '';
+        let stderr = '';
+        child.stdout.on('data', (data) => { stdout += data.toString(); });
+        child.stderr.on('data', (data) => { stderr += data.toString(); });
+        let settled = false;
+        const timer = setTimeout(() => {
+            if (settled)
+                return;
+            settled = true;
+            child.kill('SIGTERM');
+            const duration = Date.now() - startTime;
+            resolve({
+                success: false,
+                stdout,
+                stderr: `Command timed out after ${timeout}ms`,
+                exitCode: -1,
+                duration,
+                command,
+                args,
+            });
+        }, timeout);
+        child.on('close', (code) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            const duration = Date.now() - startTime;
+            resolve({
+                success: code === 0,
+                stdout,
+                stderr,
+                exitCode: code ?? -1,
+                duration,
+                command,
+                args,
+            });
+        });
+        child.on('error', (err) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            const duration = Date.now() - startTime;
+            resolve({
+                success: false,
+                stdout: '',
+                stderr: err.message,
+                exitCode: -1,
+                duration,
+                command,
+                args,
+            });
+        });
+    });
+}
 /**
  * Execute a command and return only stdout if successful
  */
@@ -212,6 +306,13 @@ export function execSimple(command, args = [], options) {
     const result = executeCommand(command, args, options);
     return result.success ? result.stdout.trim() : null;
 }
+/**
+ * Execute a command asynchronously and return only stdout if successful
+ */
+export async function execSimpleAsync(command, args = [], options) {
+    const result = await executeCommandAsync(command, args, options);
+    return result.success ? result.stdout.trim() : null;
+}
 /**
  * Check if a command exists in PATH
  */

package/dist/utils/toolExecution.js

@@ -8,7 +8,7 @@
  */
 import { existsSync, readdirSync, statSync, readFileSync, writeFileSync, unlinkSync, mkdirSync, rmSync, realpathSync } from 'fs';
 import { join, dirname, relative, resolve, isAbsolute } from 'path';
-import { executeCommand } from './shell.js';
+import { executeCommandAsync } from './shell.js';
 import { recordWrite, recordEdit, recordDelete, recordMkdir, recordCommand } from './history.js';
 import { loadIgnoreRules, isIgnored } from './gitignore.js';
 import { normalizeToolName } from './toolParsing.js';
@@ -276,7 +276,7 @@ export async function executeTool(toolCall, projectRoot) {
                 if (!command)
                     return { success: false, output: '', error: 'Missing required parameter: command', tool, parameters };
                 recordCommand(command, args);
-                const result = executeCommand(command, args, {
+                const result = await executeCommandAsync(command, args, {
                     cwd: projectRoot,
                     projectRoot,
                     timeout: 120000,
@@ -293,7 +293,7 @@ export async function executeTool(toolCall, projectRoot) {
                 const validation = validatePath(searchPath, projectRoot);
                 if (!validation.valid)
                     return { success: false, output: '', error: validation.error, tool, parameters };
-                const result = executeCommand('grep', ['-rn', '--include=*.{ts,tsx,js,jsx,json,md,css,html,py,go,rs,rb,kt,kts,swift,php,java,cs,c,cpp,h,hpp,vue,svelte,yaml,yml,toml,sh,sql,xml,scss,less}', pattern, validation.absolutePath], {
+                const result = await executeCommandAsync('grep', ['-rn', '--include=*.{ts,tsx,js,jsx,json,md,css,html,py,go,rs,rb,kt,kts,swift,php,java,cs,c,cpp,h,hpp,vue,svelte,yaml,yml,toml,sh,sql,xml,scss,less}', pattern, validation.absolutePath], {
                     cwd: projectRoot,
                     projectRoot,
                     timeout: 30000,
@@ -322,7 +322,7 @@ export async function executeTool(toolCall, projectRoot) {
                 else {
                     findArgs.push('-name', pattern, '-print');
                 }
-                const result = executeCommand('find', findArgs, { cwd: projectRoot, projectRoot, timeout: 15000 });
+                const result = await executeCommandAsync('find', findArgs, { cwd: projectRoot, projectRoot, timeout: 15000 });
                 if (result.exitCode === 0 || result.stdout) {
                     const files = result.stdout.split('\n').filter(Boolean);
                     const relativePaths = files.map(f => relative(projectRoot, f) || f).slice(0, 100);
@@ -342,7 +342,7 @@ export async function executeTool(toolCall, projectRoot) {
                 catch {
                     return { success: false, output: '', error: 'Invalid URL format', tool, parameters };
                 }
-                const result = executeCommand('curl', ['-s', '-L', '-m', '30', '-A', 'Codeep/1.0', '--max-filesize', '1000000', url], {
+                const result = await executeCommandAsync('curl', ['-s', '-L', '-m', '30', '-A', 'Codeep/1.0', '--max-filesize', '1000000', url], {
                     cwd: projectRoot,
                     projectRoot,
                     timeout: 35000,

package/dist/utils/verify.d.ts

@@ -38,23 +38,23 @@ export declare function detectProjectScripts(projectRoot: string): {
 /**
  * Run build verification
  */
-export declare function runBuildVerification(projectRoot: string, timeout?: number): VerifyResult | null;
+export declare function runBuildVerification(projectRoot: string, timeout?: number): Promise<VerifyResult | null>;
 /**
  * Run test verification
  */
-export declare function runTestVerification(projectRoot: string, timeout?: number): VerifyResult | null;
+export declare function runTestVerification(projectRoot: string, timeout?: number): Promise<VerifyResult | null>;
 /**
  * Run TypeScript type checking
  */
-export declare function runTypecheckVerification(projectRoot: string, timeout?: number): VerifyResult | null;
+export declare function runTypecheckVerification(projectRoot: string, timeout?: number): Promise<VerifyResult | null>;
 /**
  * Run lint verification
  */
-export declare function runLintVerification(projectRoot: string, timeout?: number): VerifyResult | null;
+export declare function runLintVerification(projectRoot: string, timeout?: number): Promise<VerifyResult | null>;
 /**
  * Run all verifications
  */
-export declare function runAllVerifications(projectRoot: string, options?: Partial<VerifyOptions>): VerifyResult[];
+export declare function runAllVerifications(projectRoot: string, options?: Partial<VerifyOptions>): Promise<VerifyResult[]>;
 /**
  * Format verification results for display
  */

package/dist/utils/verify.js

@@ -4,7 +4,7 @@
  */
 import { existsSync, readFileSync } from 'fs';
 import { join } from 'path';
-import { executeCommand } from './shell.js';
+import { executeCommandAsync } from './shell.js';
 const DEFAULT_OPTIONS = {
     runBuild: true,
     runTest: true,
@@ -123,9 +123,9 @@ export function detectProjectScripts(projectRoot) {
 /**
  * Run a verification command
  */
-function runVerifyCommand(type, command, args, projectRoot, timeout) {
+async function runVerifyCommand(type, command, args, projectRoot, timeout) {
     const startTime = Date.now();
-    const result = executeCommand(command, args, {
+    const result = await executeCommandAsync(command, args, {
         cwd: projectRoot,
         projectRoot,
         timeout,
@@ -134,6 +134,15 @@ function runVerifyCommand(type, command, args, projectRoot, timeout) {
     const output = result.stdout + '\n' + result.stderr;
     // Parse errors from output
     const errors = parseErrors(output, type);
+    // If command failed but no errors were parsed, surface the failure reason explicitly
+    if (!result.success && errors.length === 0) {
+        const reason = result.stderr?.includes('timed out')
+            ? `Command timed out after ${Math.round(duration / 1000)}s. This build tool may be too slow for verification. Consider adding a faster typecheck script to package.json.`
+            : result.stderr?.includes('not in the allowed list') || result.stderr?.includes('not allowed')
+                ? `Command '${command}' is not allowed. Check shell.ts ALLOWED_COMMANDS.`
+                : result.stderr?.trim() || result.stdout?.trim() || 'Command failed with no output';
+        errors.push({ severity: 'error', message: reason });
+    }
     return {
         success: result.success,
         type,
@@ -246,7 +255,7 @@ function parseErrors(output, type) {
 /**
  * Run build verification
  */
-export function runBuildVerification(projectRoot, timeout = 120000) {
+export async function runBuildVerification(projectRoot, timeout = 120000) {
     const scripts = detectProjectScripts(projectRoot);
     if (!scripts.build) {
         return null;
@@ -266,6 +275,16 @@ export function runBuildVerification(projectRoot, timeout = 120000) {
         args = ['run', 'build'];
     }
     else {
+        if (!existsSync(join(projectRoot, 'node_modules'))) {
+            return {
+                success: false,
+                type: 'build',
+                command: `${scripts.packageManager} run ${scripts.build}`,
+                output: 'node_modules not found. Run npm install first.',
+                errors: [{ severity: 'error', message: 'node_modules not found. Run npm install first.' }],
+                duration: 0,
+            };
+        }
         command = scripts.packageManager;
         args = ['run', scripts.build];
     }
@@ -274,7 +293,7 @@ export function runBuildVerification(projectRoot, timeout = 120000) {
 /**
  * Run test verification
  */
-export function runTestVerification(projectRoot, timeout = 120000) {
+export async function runTestVerification(projectRoot, timeout = 120000) {
     const scripts = detectProjectScripts(projectRoot);
     if (!scripts.test) {
         return null;
@@ -306,6 +325,16 @@ export function runTestVerification(projectRoot, timeout = 120000) {
         args = ['artisan', 'test'];
     }
     else {
+        if (!existsSync(join(projectRoot, 'node_modules'))) {
+            return {
+                success: false,
+                type: 'test',
+                command: `${scripts.packageManager} run ${scripts.test}`,
+                output: 'node_modules not found. Run npm install first.',
+                errors: [{ severity: 'error', message: 'node_modules not found. Run npm install first.' }],
+                duration: 0,
+            };
+        }
         command = scripts.packageManager;
         args = ['run', scripts.test];
     }
@@ -314,7 +343,7 @@ export function runTestVerification(projectRoot, timeout = 120000) {
 /**
  * Run TypeScript type checking
  */
-export function runTypecheckVerification(projectRoot, timeout = 60000) {
+export async function runTypecheckVerification(projectRoot, timeout = 60000) {
     const scripts = detectProjectScripts(projectRoot);
     if (!scripts.typecheck) {
         return null;
@@ -322,8 +351,15 @@ export function runTypecheckVerification(projectRoot, timeout = 60000) {
     let command;
     let args;
     if (scripts.typecheck === '__tsc_direct__') {
-        command = 'npx';
-        args = ['tsc', '--noEmit'];
+        const localTsc = join(projectRoot, 'node_modules', '.bin', 'tsc');
+        if (existsSync(localTsc)) {
+            command = localTsc;
+            args = ['--noEmit'];
+        }
+        else {
+            command = 'npx';
+            args = ['tsc', '--noEmit'];
+        }
     }
     else if (scripts.typecheck === '__php_lint__') {
         // PHP syntax check on all PHP files
@@ -339,7 +375,7 @@ export function runTypecheckVerification(projectRoot, timeout = 60000) {
 /**
  * Run lint verification
  */
-export function runLintVerification(projectRoot, timeout = 60000) {
+export async function runLintVerification(projectRoot, timeout = 60000) {
     const scripts = detectProjectScripts(projectRoot);
     if (!scripts.lint) {
         return null;
@@ -351,30 +387,30 @@ export function runLintVerification(projectRoot, timeout = 60000) {
 /**
  * Run all verifications
  */
-export function runAllVerifications(projectRoot, options = {}) {
+export async function runAllVerifications(projectRoot, options = {}) {
     const opts = { ...DEFAULT_OPTIONS, ...options };
     const results = [];
     // Run typecheck first (fastest feedback)
     if (opts.runTypecheck) {
-        const result = runTypecheckVerification(projectRoot, opts.timeout);
+        const result = await runTypecheckVerification(projectRoot, opts.timeout);
         if (result)
             results.push(result);
     }
     // Run build
     if (opts.runBuild) {
-        const result = runBuildVerification(projectRoot, opts.timeout);
+        const result = await runBuildVerification(projectRoot, opts.timeout);
         if (result)
             results.push(result);
     }
     // Run lint
     if (opts.runLint) {
-        const result = runLintVerification(projectRoot, opts.timeout);
+        const result = await runLintVerification(projectRoot, opts.timeout);
         if (result)
             results.push(result);
     }
     // Run tests last (slowest)
     if (opts.runTest) {
-        const result = runTestVerification(projectRoot, opts.timeout);
+        const result = await runTestVerification(projectRoot, opts.timeout);
         if (result)
             results.push(result);
     }

package/package.json

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