codeep 3.3.3 → 3.4.1

package/dist/utils/verify.js

@@ -2,9 +2,9 @@
  * Self-verification module for agent
  * Runs build/test and analyzes errors for auto-fixing
  */
-import { existsSync, readFileSync } from 'fs';
-import { join } from 'path';
-import { executeCommandAsync } from './shell.js';
+import { existsSync, readFileSync, readdirSync } from 'fs';
+import { delimiter, dirname, join, resolve } from 'path';
+import { executeCommandAsync, validateCommandAsync } from './shell.js';
 const DEFAULT_OPTIONS = {
     runBuild: true,
     runTest: true,
@@ -120,45 +120,203 @@ export function detectProjectScripts(projectRoot) {
     }
     return result;
 }
+/** A check that could not be carried out, with the reason. */
+function notRunResult(type, command, reason, output = '', duration = 0) {
+    return { success: false, notRun: reason, type, command, output: output || reason, errors: [], duration };
+}
+const STOPPED_REASON = 'Stopped by the user.';
+function timedOutReason(ms) {
+    return `Timed out after ${Math.round(ms / 1000)}s. This tool may be too slow for verification.`;
+}
+/** Whether executeCommandAsync stopped the command at its timeout. */
+function commandTimedOut(result) {
+    return result.timedOut === true && !result.cancelled;
+}
 /**
- * Run a verification command
+ * Why a command that was started produced no exit status of its own, or null
+ * when it did. executeCommandAsync reports these cases with exit code -1 and a
+ * message of its own in place of the command's stderr.
+ */
+function whyCommandDidNotFinish(result, command, duration) {
+    if (result.cancelled)
+        return STOPPED_REASON;
+    if (result.exitCode !== -1)
+        return null;
+    const stderr = (result.stderr ?? '').trim();
+    if (commandTimedOut(result))
+        return timedOutReason(duration);
+    // Node's own spawn failure, e.g. "spawn php ENOENT" when php is not installed.
+    if (/^spawn \S+ E[A-Z]+$/.test(stderr))
+        return `Could not start ${command} (${stderr}).`;
+    if (stderr.startsWith('Working directory does not exist'))
+        return stderr;
+    return null;
+}
+/**
+ * Run one command for a check. `notRun` is set when the command never ran to
+ * completion, in which case its output says nothing about the code.
  */
-async function runVerifyCommand(type, command, args, projectRoot, timeout) {
+async function runCheckCommand(command, args, projectRoot, timeout, signal) {
+    // Checks run under the same shell guard as the agent's own commands. A
+    // command the guard refuses fails every time, whatever the code looks like,
+    // so it is reported as not run instead of as a failing check.
+    const validation = await validateCommandAsync(command, args, { cwd: projectRoot, projectRoot });
+    if (!validation.valid) {
+        return { notRun: `The shell guard refused \`${command}\`: ${validation.reason ?? 'not allowed'}`, duration: 0 };
+    }
     const startTime = Date.now();
     const result = await executeCommandAsync(command, args, {
         cwd: projectRoot,
         projectRoot,
         timeout,
+        signal,
     });
     const duration = Date.now() - startTime;
-    const output = result.stdout + '\n' + result.stderr;
-    // Parse errors from output
+    const notRun = whyCommandDidNotFinish(result, command, duration) ?? undefined;
+    return { result, notRun, duration };
+}
+/**
+ * Build the result of a check that ran, from its combined output. `reason` is
+ * the part of the output that best explains a failure nothing could be parsed
+ * from.
+ */
+function checkResult(type, command, success, output, duration, reason = output, note) {
     const errors = parseErrors(output, type);
-    // If command failed but no errors were parsed, surface the failure reason as warning
-    // (not error — could be pre-existing build issue unrelated to agent's changes)
-    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.`
-            : 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: 'warning', message: reason });
+    // A failed check whose output could not be parsed still failed. Its output
+    // is the only account of why, so it goes along as a warning (the failure may
+    // predate the agent's change).
+    if (!success && errors.length === 0) {
+        errors.push({ severity: 'warning', message: reason.trim() || 'Command failed with no output' });
+    }
+    if (note)
+        errors.push({ severity: 'warning', message: note });
+    return { success, type, command, output: output.trim(), errors, duration };
+}
+/** The warning on a failed check whose command did not finish. */
+function incompleteNote(notRun) {
+    return `Output incomplete: ${notRun.replace(/ This tool may be too slow for verification\.$/, '')} Other errors may be missing.`;
+}
+/**
+ * Run a verification command
+ */
+async function runVerifyCommand(type, command, args, projectRoot, timeout, signal) {
+    const display = `${command} ${args.join(' ')}`;
+    const { result, notRun, duration } = await runCheckCommand(command, args, projectRoot, timeout, signal);
+    const output = result ? `${result.stdout ?? ''}\n${result.stderr ?? ''}` : '';
+    // A check that timed out after printing failures did fail: those failures
+    // are real even though the run never finished (a suite that hangs after a
+    // FAIL, `jest --watch`).
+    if (notRun && result && commandTimedOut(result) && parseErrors(output, type).some(e => e.severity === 'error')) {
+        return checkResult(type, display, false, output, duration, output, incompleteNote(notRun));
+    }
+    if (notRun || !result)
+        return notRunResult(type, display, notRun ?? 'The command did not run.', output.trim(), duration);
+    return checkResult(type, display, result.success, output, duration, result.stderr?.trim() || result.stdout?.trim() || '');
+}
+/**
+ * Whether `name` is installed in a node_modules/.bin directory at or above
+ * the project, which is where npx looks for it (a workspace package usually
+ * finds its tools hoisted to the repository root).
+ */
+function hasLocalBin(projectRoot, name) {
+    let dir = resolve(projectRoot);
+    for (;;) {
+        if (existsSync(join(dir, 'node_modules', '.bin', name)))
+            return true;
+        const parent = dirname(dir);
+        if (parent === dir)
+            return false;
+        dir = parent;
     }
-    return {
-        success: result.success,
-        type,
-        command: `${command} ${args.join(' ')}`,
-        output: output.trim(),
-        errors,
-        duration,
+}
+/** Whether `name` is an executable found on PATH. */
+function isOnPath(name) {
+    return (process.env.PATH ?? '').split(delimiter).some(dir => dir !== '' && existsSync(join(dir, name)));
+}
+const PHP_LINT_SKIPPED_DIRS = new Set(['vendor', 'node_modules']);
+const PHP_LINT_CONCURRENCY = 8;
+/** Project PHP files, relative to the root, outside dependency and dot directories. */
+function listPhpFiles(projectRoot) {
+    const files = [];
+    const walk = (rel) => {
+        let entries;
+        try {
+            entries = readdirSync(rel ? join(projectRoot, rel) : projectRoot, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const entry of entries) {
+            const path = rel ? `${rel}/${entry.name}` : entry.name;
+            if (entry.isDirectory()) {
+                if (!entry.name.startsWith('.') && !PHP_LINT_SKIPPED_DIRS.has(entry.name))
+                    walk(path);
+            }
+            else if (entry.isFile() && entry.name.endsWith('.php')) {
+                files.push(path);
+            }
+        }
     };
+    walk('');
+    return files.sort();
+}
+/**
+ * PHP syntax check, one `php -l` per file. `find -exec` would hand the file
+ * list to php in one command, but the shell guard refuses exec flags, and
+ * before PHP 8.3 `php -l` reads only its first file.
+ */
+async function runPhpLint(projectRoot, timeout, signal) {
+    const files = listPhpFiles(projectRoot);
+    if (files.length === 0)
+        return null;
+    const display = `php -l (${files.length} file${files.length === 1 ? '' : 's'})`;
+    const startTime = Date.now();
+    const deadline = startTime + timeout;
+    const failures = [];
+    let notRun;
+    let next = 0;
+    const worker = async () => {
+        while (notRun === undefined && next < files.length) {
+            const file = files[next++];
+            const remaining = deadline - Date.now();
+            if (remaining <= 0) {
+                notRun = timedOutReason(timeout);
+                return;
+            }
+            // "./" keeps a file named like an option from being read as one.
+            const run = await runCheckCommand('php', ['-l', `./${file}`], projectRoot, remaining, signal);
+            if (run.notRun || !run.result) {
+                // A call cut short by the deadline stands for the whole lint, which
+                // ran for the full timeout, not just this call's share of it.
+                notRun ??= run.result && commandTimedOut(run.result)
+                    ? timedOutReason(timeout)
+                    : run.notRun ?? 'The command did not run.';
+                return;
+            }
+            if (!run.result.success)
+                failures.push(`${run.result.stdout ?? ''}\n${run.result.stderr ?? ''}`);
+        }
+    };
+    await Promise.all(Array.from({ length: Math.min(PHP_LINT_CONCURRENCY, files.length) }, worker));
+    const duration = Date.now() - startTime;
+    // A file that failed to parse is a failure even if the lint ran out of
+    // time before every file was checked. A lint the user stopped is not run,
+    // as any other stopped check.
+    if (failures.length > 0 && notRun !== STOPPED_REASON) {
+        return checkResult('typecheck', display, false, failures.join('\n'), duration, failures.join('\n'), notRun && incompleteNote(notRun));
+    }
+    if (notRun)
+        return notRunResult('typecheck', display, notRun, '', duration);
+    return checkResult('typecheck', display, true, '', duration);
 }
 /**
  * Parse errors from command output
  */
 function parseErrors(output, type) {
     const errors = [];
-    const lines = output.split('\n');
+    // Tools that are told to keep their colours (FORCE_COLOR) wrap words in
+    // escape codes, which no pattern below would match.
+    const lines = output.replace(/\x1b\[[0-9;]*m/g, '').split('\n');
     for (const line of lines) {
         // TypeScript/TSC errors: src/file.ts(10,5): error TS2345: ...
         const tsMatch = line.match(/^(.+?)\((\d+),(\d+)\):\s*(error|warning)\s+(TS\d+):\s*(.+)$/);
@@ -185,13 +343,22 @@ function parseErrors(output, type) {
             });
             continue;
         }
-        // Jest/Vitest: FAIL src/file.test.ts
+        // Jest/Vitest: "FAIL src/file.test.ts", with Jest's "(5.1 s)", Vitest's
+        // "|project|" label or "[ src/file.test.ts ]" suffix, or Vitest's
+        // "FAIL src/file.test.ts > suite > test name" for a single test.
         const jestFailMatch = line.match(/^\s*FAIL\s+(.+)$/);
         if (jestFailMatch) {
+            const rest = jestFailMatch[1].trim().replace(/^\|[^|]*\|\s+/, '');
+            const nameAt = rest.search(/\s+[>›]\s+/);
+            const file = (nameAt < 0 ? rest : rest.slice(0, nameAt))
+                .replace(/\s+\[.*\]$/, '')
+                .replace(/\s+\([\d.]+\s*m?s\)$/, '')
+                .trim();
+            const testName = nameAt < 0 ? '' : rest.slice(nameAt).replace(/^\s+[>›]\s+/, '').trim();
             errors.push({
-                file: jestFailMatch[1],
+                file,
                 severity: 'error',
-                message: 'Test file failed',
+                message: testName ? `Test failed: ${testName}` : 'Test file failed',
             });
             continue;
         }
@@ -230,15 +397,20 @@ function parseErrors(output, type) {
             });
             continue;
         }
-        // PHP errors: PHP Parse error: ... in /path/file.php on line 10
-        const phpMatch = line.match(/PHP\s+(Parse error|Fatal error|Warning):\s*(.+?)\s+in\s+(.+?)\s+on line\s+(\d+)/i);
+        // PHP errors: "PHP Parse error: ... in /path/file.php on line 10" in the
+        // error log, "Parse error: ... in ... on line 10" on stdout. php -l often
+        // prints both for the same error, so a repeat is dropped.
+        const phpMatch = line.match(/^\s*(?:PHP\s+)?(Parse error|Fatal error|Warning):\s*(.+?)\s+in\s+(.+?)\s+on line\s+(\d+)/i);
         if (phpMatch) {
-            errors.push({
-                file: phpMatch[3],
+            const error = {
+                file: phpMatch[3].replace(/^\.\//, ''),
                 line: parseInt(phpMatch[4]),
                 severity: phpMatch[1].toLowerCase().includes('warning') ? 'warning' : 'error',
                 message: phpMatch[2],
-            });
+            };
+            const seen = errors.some(e => e.file === error.file && e.line === error.line && e.message === error.message);
+            if (!seen)
+                errors.push(error);
             continue;
         }
         // PHPUnit errors: 1) TestClass::testMethod
@@ -256,7 +428,7 @@ function parseErrors(output, type) {
 /**
  * Run build verification
  */
-export async function runBuildVerification(projectRoot, timeout = 120000) {
+export async function runBuildVerification(projectRoot, timeout = 120000, signal) {
     const scripts = detectProjectScripts(projectRoot);
     if (!scripts.build) {
         return null;
@@ -277,24 +449,17 @@ export async function runBuildVerification(projectRoot, timeout = 120000) {
     }
     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,
-            };
+            return notRunResult('build', `${scripts.packageManager} run ${scripts.build}`, 'node_modules not found. Run npm install first.');
         }
         command = scripts.packageManager;
         args = ['run', scripts.build];
     }
-    return runVerifyCommand('build', command, args, projectRoot, timeout);
+    return runVerifyCommand('build', command, args, projectRoot, timeout, signal);
 }
 /**
  * Run test verification
  */
-export async function runTestVerification(projectRoot, timeout = 120000) {
+export async function runTestVerification(projectRoot, timeout = 120000, signal) {
     const scripts = detectProjectScripts(projectRoot);
     if (!scripts.test) {
         return null;
@@ -314,8 +479,13 @@ export async function runTestVerification(projectRoot, timeout = 120000) {
         args = ['test'];
     }
     else if (scripts.test === '__phpunit__') {
-        command = './vendor/bin/phpunit';
-        args = [];
+        // Through php: the shell guard runs named commands only, not a path.
+        // Composer's vendor/bin/phpunit is a PHP script either way.
+        command = 'php';
+        args = ['vendor/bin/phpunit'];
+        if (!existsSync(join(projectRoot, 'vendor', 'bin', 'phpunit'))) {
+            return notRunResult('test', `${command} ${args.join(' ')}`, 'vendor/bin/phpunit not found. Run composer install first.');
+        }
     }
     else if (scripts.test === '__composer_test__') {
         command = 'composer';
@@ -327,24 +497,17 @@ export async function runTestVerification(projectRoot, timeout = 120000) {
     }
     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,
-            };
+            return notRunResult('test', `${scripts.packageManager} run ${scripts.test}`, 'node_modules not found. Run npm install first.');
         }
         command = scripts.packageManager;
         args = ['run', scripts.test];
     }
-    return runVerifyCommand('test', command, args, projectRoot, timeout);
+    return runVerifyCommand('test', command, args, projectRoot, timeout, signal);
 }
 /**
  * Run TypeScript type checking
  */
-export async function runTypecheckVerification(projectRoot, timeout = 60000) {
+export async function runTypecheckVerification(projectRoot, timeout = 60000, signal) {
     const scripts = detectProjectScripts(projectRoot);
     if (!scripts.typecheck) {
         return null;
@@ -352,38 +515,41 @@ export async function runTypecheckVerification(projectRoot, timeout = 60000) {
     let command;
     let args;
     if (scripts.typecheck === '__tsc_direct__') {
-        const localTsc = join(projectRoot, 'node_modules', '.bin', 'tsc');
-        if (existsSync(localTsc)) {
-            command = localTsc;
+        // The shell guard runs named commands only, so a project's own tsc goes
+        // through npx, which finds it in node_modules/.bin. --no-install keeps npx
+        // from fetching the unrelated "tsc" package from the registry instead.
+        if (hasLocalBin(projectRoot, 'tsc')) {
+            command = 'npx';
+            args = ['--no-install', 'tsc', '--noEmit'];
+        }
+        else if (isOnPath('tsc')) {
+            command = 'tsc';
             args = ['--noEmit'];
         }
         else {
-            command = 'npx';
-            args = ['tsc', '--noEmit'];
+            return notRunResult('typecheck', 'tsc --noEmit', 'TypeScript is not installed (no tsc in node_modules/.bin or on PATH). Run npm install first.');
         }
     }
     else if (scripts.typecheck === '__php_lint__') {
-        // PHP syntax check on all PHP files
-        command = 'find';
-        args = ['.', '-name', '*.php', '-not', '-path', './vendor/*', '-exec', 'php', '-l', '{}', ';'];
+        return runPhpLint(projectRoot, timeout, signal);
     }
     else {
         command = scripts.packageManager;
         args = ['run', scripts.typecheck];
     }
-    return runVerifyCommand('typecheck', command, args, projectRoot, timeout);
+    return runVerifyCommand('typecheck', command, args, projectRoot, timeout, signal);
 }
 /**
  * Run lint verification
  */
-export async function runLintVerification(projectRoot, timeout = 60000) {
+export async function runLintVerification(projectRoot, timeout = 60000, signal) {
     const scripts = detectProjectScripts(projectRoot);
     if (!scripts.lint) {
         return null;
     }
     const command = scripts.packageManager;
     const args = ['run', scripts.lint];
-    return runVerifyCommand('lint', command, args, projectRoot, timeout);
+    return runVerifyCommand('lint', command, args, projectRoot, timeout, signal);
 }
 /**
  * Run all verifications
@@ -394,9 +560,9 @@ export async function runAllVerifications(projectRoot, options = {}) {
     // Run typecheck and lint in parallel (independent checks)
     const parallel = [];
     if (opts.runTypecheck)
-        parallel.push(runTypecheckVerification(projectRoot, opts.timeout));
+        parallel.push(runTypecheckVerification(projectRoot, opts.timeout, opts.signal));
     if (opts.runLint)
-        parallel.push(runLintVerification(projectRoot, opts.timeout));
+        parallel.push(runLintVerification(projectRoot, opts.timeout, opts.signal));
     if (parallel.length > 0) {
         const parallelResults = await Promise.all(parallel);
         for (const r of parallelResults) {
@@ -406,13 +572,13 @@ export async function runAllVerifications(projectRoot, options = {}) {
     }
     // Run build after typecheck/lint (may depend on them)
     if (opts.runBuild) {
-        const result = await runBuildVerification(projectRoot, opts.timeout);
+        const result = await runBuildVerification(projectRoot, opts.timeout, opts.signal);
         if (result)
             results.push(result);
     }
     // Run tests last (slowest, depends on build)
     if (opts.runTest) {
-        const result = await runTestVerification(projectRoot, opts.timeout);
+        const result = await runTestVerification(projectRoot, opts.timeout, opts.signal);
         if (result)
             results.push(result);
     }
@@ -424,9 +590,13 @@ export async function runAllVerifications(projectRoot, options = {}) {
 export function formatVerifyResults(results) {
     const lines = [];
     for (const result of results) {
-        const status = result.success ? '✓' : '✗';
+        const status = result.success ? '✓' : result.notRun ? '⚠' : '✗';
         const duration = `${(result.duration / 1000).toFixed(1)}s`;
         lines.push(`${status} ${result.type}: ${result.command} (${duration})`);
+        if (result.notRun) {
+            lines.push(`  not run: ${result.notRun}`);
+            continue;
+        }
         if (!result.success && result.errors.length > 0) {
             const errorCount = result.errors.filter(e => e.severity === 'error').length;
             const warnCount = result.errors.filter(e => e.severity === 'warning').length;
@@ -447,7 +617,8 @@ export function formatVerifyResults(results) {
  * Format errors for agent to fix
  */
 export function formatErrorsForAgent(results) {
-    const failedResults = results.filter(r => !r.success);
+    // A check that did not run has nothing in it to fix.
+    const failedResults = failedChecks(results);
     if (failedResults.length === 0) {
         return '';
     }
@@ -480,22 +651,36 @@ export function formatErrorsForAgent(results) {
     lines.push('Please fix these errors and try again.');
     return lines.join('\n');
 }
+/**
+ * Checks that ran and failed. A check that could not run is not among them.
+ */
+export function failedChecks(results) {
+    return results.filter(r => !r.success && !r.notRun);
+}
+/**
+ * Checks that could not be carried out (see VerifyResult.notRun).
+ */
+export function checksNotRun(results) {
+    return results.filter(r => !r.success && r.notRun);
+}
 /**
  * Check if any verification failed
  */
 export function hasVerificationErrors(results) {
-    return results.some(r => !r.success);
+    return failedChecks(results).length > 0;
 }
 /**
  * Get summary of verification
  */
 export function getVerificationSummary(results) {
     const passed = results.filter(r => r.success).length;
-    const failed = results.filter(r => !r.success).length;
+    const failed = failedChecks(results).length;
+    const notRun = checksNotRun(results).length;
     const errors = results.reduce((sum, r) => sum + r.errors.filter(e => e.severity === 'error').length, 0);
     return {
         passed,
         failed,
+        notRun,
         total: results.length,
         errors,
     };

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "3.3.3";
+export declare const VERSION = "3.4.1";

package/dist/version.js

@@ -1,4 +1,4 @@
 // AUTO-GENERATED by scripts/gen-version.js — do not edit by hand.
 // Baked from package.json at build time so the bun-compiled binary reports
 // the right version (it has no package.json on disk to read at runtime).
-export const VERSION = '3.3.3';
+export const VERSION = '3.4.1';

package/package.json

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