codeep 1.2.66 → 1.2.67

package/dist/renderer/App.js

@@ -1892,7 +1892,8 @@ 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)
+        // Current action line (clear first to avoid stale text from longer previous paths)
+        this.screen.writeLine(y, '');
         if (this.agentActions.length > 0) {
             const lastAction = this.agentActions[this.agentActions.length - 1];
             const actionLabel = this.getActionLabel(lastAction.type);
@@ -1906,7 +1907,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/utils/agent.js

@@ -468,7 +468,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.67",
   "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",