codehere 1.0.1 → 1.0.3

package/dist/application/use-cases/rerun-tests.js

@@ -24,7 +24,46 @@ import { spawn } from 'node:child_process';
 import { existsSync, readFileSync, readdirSync } from 'node:fs';
 import { join } from 'node:path';
 import { parseTestSummary } from '../../infrastructure/orchestration/artifacts-extractor.js';
-const DEFAULT_TIMEOUT_MS = Number(process.env.CODEHERE_RERUN_TIMEOUT_MS ?? 120_000);
+const TIMEOUT_SETTING = Number(process.env.CODEHERE_RERUN_TIMEOUT_MS);
+/**
+ * Whole milliseconds that a timer can hold; anything else falls back to two minutes. Node fires a NaN, fractional
+ * or over-2^31 timer after 1 ms, which would time out every run.
+ */
+const DEFAULT_TIMEOUT_MS = Number.isInteger(TIMEOUT_SETTING) && TIMEOUT_SETTING > 0 && TIMEOUT_SETTING <= 2 ** 31 - 1
+    ? TIMEOUT_SETTING
+    : 120_000;
+/** 500 → "0.5s", 120000 → "120s". */
+const seconds = (ms) => `${Number.isInteger(ms / 1000) ? ms / 1000 : (ms / 1000).toFixed(1)}s`;
+/** True when node's test runner printed a summary and every summary says 0 tests, or when go test found no test files. `node --test`
+ *  exits 0 for a misnamed file (`calc.tests.js`), so the exit code alone reads as a pass.
+ *  pytest already exits 5 in that case. */
+export function reportedZeroTests(out) {
+    const counts = [...out.matchAll(/^[ \t]*(?:ℹ|#)[ \t]+tests[ \t]+(\d+)[ \t]*$/gm)].map((m) => Number(m[1]));
+    if (counts.length > 0)
+        return counts.every((n) => n === 0);
+    // `go test ./...` exits 0 and prints `[no test files]` for every package when the module has no _test.go files.
+    return /^\?[ \t]+.*\[no test files\]/m.test(out) && !/^(ok|FAIL|---)[ \t]/m.test(out);
+}
+/** True when the runner's own summary says tests were skipped and none passed or failed: node:test (`pass 0`,
+ *  `skipped N`), pytest's final line, and the jest or vitest `Tests` line. A run like that tested nothing. */
+export function reportedOnlySkipped(out) {
+    const last = (re) => [...out.matchAll(re)].pop();
+    const node = (k) => {
+        const m = last(new RegExp(`^[ \\t]*(?:ℹ|#)[ \\t]+${k}[ \\t]+(\\d+)[ \\t]*$`, 'gm'));
+        return m ? Number(m[1]) : null;
+    };
+    const pass = node('pass');
+    const skipped = node('skipped');
+    if (pass !== null && skipped !== null)
+        return pass === 0 && (node('fail') ?? 0) === 0 && skipped > 0;
+    const py = last(/^=+ (.*) in [\d.]+s(?: \([^)]*\))? =+$/gm);
+    if (py)
+        return /\b\d+ skipped\b/.test(py[1]) && !/\b\d+ (passed|failed|errors?|xpassed)\b/.test(py[1]);
+    const js = last(/^[ \t]*Tests:?[ \t]+(.*)$/gm);
+    if (js)
+        return /\b\d+ skipped\b/.test(js[1]) && !/\b\d+ (passed|failed)\b/.test(js[1]);
+    return false;
+}
 /** True if `file` exists in `cwd` and its text contains `needle` (case-insensitive). */
 function fileMentions(cwd, file, needle) {
     try {
@@ -139,6 +178,41 @@ export function detectTestCommand(cwd) {
     }
     return null;
 }
+/**
+ * The one command that would make the suite runnable — returned as a STRING to
+ * SHOW the user, NEVER executed. The owner's call (2026-08-17): guide, never execute —
+ * auto-installing runs arbitrary postinstall code, which is exactly the posture
+ * a trust tool must not take (the same reason detectTestCommand keeps
+ * `--no-install`). Mirrors detectTestCommand's marker-probing: pick the
+ * ecosystem, name its install. Returns undefined when there's nothing to suggest.
+ */
+export function detectRemedy(cwd) {
+    const has = (f) => existsSync(join(cwd, f));
+    // Node — deps missing / runner not installed → install from the lockfile.
+    if (has('package.json')) {
+        if (has('pnpm-lock.yaml'))
+            return 'pnpm install';
+        if (has('yarn.lock'))
+            return 'yarn install';
+        if (has('package-lock.json'))
+            return 'npm ci';
+        return 'npm install';
+    }
+    // Python — set up a venv and install, then re-check.
+    if (has('requirements.txt')) {
+        return 'python -m venv .venv && . .venv/bin/activate && pip install -r requirements.txt';
+    }
+    if (has('pyproject.toml') || has('setup.py') || has('setup.cfg')) {
+        return 'python -m venv .venv && . .venv/bin/activate && pip install -e .';
+    }
+    if (has('pytest.ini') || has('conftest.py'))
+        return 'pip install pytest';
+    if (has('go.mod'))
+        return 'go mod download';
+    if (has('Cargo.toml'))
+        return 'cargo fetch';
+    return undefined;
+}
 /**
  * Re-run the project's tests on the real on-disk state. Async + timeout-bounded.
  * Resolves with `ran:false` + a reason when there's nothing to run or it's
@@ -146,11 +220,11 @@ export function detectTestCommand(cwd) {
  */
 export function rerunTests(cwd) {
     if (process.env.CODEHERE_RERUN_TESTS === '0') {
-        return Promise.resolve({ ran: false, skippedReason: 'disabled (CODEHERE_RERUN_TESTS=0)' });
+        return Promise.resolve({ ran: false, kind: 'disabled', skippedReason: 'disabled (CODEHERE_RERUN_TESTS=0)' });
     }
     const detected = detectTestCommand(cwd);
     if (!detected) {
-        return Promise.resolve({ ran: false, skippedReason: 'no known test command in this project' });
+        return Promise.resolve({ ran: false, kind: 'no-command', skippedReason: 'no known test command in this project' });
     }
     return new Promise((resolve) => {
         const start = Date.now();
@@ -175,7 +249,13 @@ export function rerunTests(cwd) {
             });
         }
         catch (e) {
-            done({ ran: false, skippedReason: `could not spawn test command: ${String(e).slice(0, 80)}` });
+            done({
+                ran: false,
+                kind: 'command-not-found',
+                command: detected.display,
+                skippedReason: `could not spawn test command: ${String(e).slice(0, 80)}`,
+                remedy: detectRemedy(cwd),
+            });
             return;
         }
         const timer = setTimeout(() => {
@@ -195,7 +275,12 @@ export function rerunTests(cwd) {
                     /* best-effort */
                 }
             }
-            done({ ran: false, skippedReason: `test re-run timed out after ${Math.round(DEFAULT_TIMEOUT_MS / 1000)}s` });
+            done({
+                ran: false,
+                kind: 'timed-out',
+                command: detected.display,
+                skippedReason: `test re-run timed out after ${seconds(DEFAULT_TIMEOUT_MS)}`,
+            });
         }, DEFAULT_TIMEOUT_MS);
         const cap = (chunk) => {
             out += String(chunk);
@@ -207,18 +292,36 @@ export function rerunTests(cwd) {
         child.stderr?.on('data', cap);
         child.on('error', (e) => {
             clearTimeout(timer);
-            done({ ran: false, skippedReason: `test command errored: ${String(e.message).slice(0, 80)}` });
+            done({
+                ran: false,
+                kind: 'command-not-found',
+                command: detected.display,
+                skippedReason: `test command errored: ${String(e.message).slice(0, 80)}`,
+                remedy: detectRemedy(cwd),
+            });
         });
         child.on('close', (code) => {
             clearTimeout(timer);
+            const ec = code ?? -1;
             const parsed = parseTestSummary(out);
+            // 126/127 = the wrapper launched but the runner/deps aren't installed —
+            // nothing was tested, so this is NOT a failing suite. Classify it as
+            // runner-missing (with the one-command remedy) so no surface renders a
+            // red measured-fail for an unrunnable suite.
+            const allSkipped = ec === 0 && reportedOnlySkipped(out);
+            const noTests = ec === 0 && (reportedZeroTests(out) || allSkipped);
+            const kind = ec === 126 || ec === 127 ? 'runner-missing' : ec === 0 && !noTests ? 'passed' : 'failed';
             done({
                 ran: true,
+                kind,
                 command: detected.display,
-                exitCode: code ?? -1,
+                exitCode: ec,
                 passed: parsed?.passed,
                 failed: parsed?.failed,
+                ...(noTests ? { noTests: true } : {}),
+                ...(allSkipped ? { allSkipped: true } : {}),
                 durationMs: Date.now() - start,
+                ...(kind === 'runner-missing' ? { remedy: detectRemedy(cwd) } : {}),
             });
         });
     });