any-doctor 0.0.8 → 0.0.9

package/bin/engine.d.ts

@@ -1,4 +1,5 @@
 import { NamedRuleQuery, RuleQuery } from "./contract.js";
+export declare function pickNativeBinary(candidates: string[]): string | null;
 export declare function resolveAstGrepBinary(): string | null;
 export type EngineQuery = {
     op: "pattern";

package/bin/engine.js

@@ -19,6 +19,44 @@ import * as path from "path";
 //   4. the loud error — unsupported platforms only.
 const require_ = createRequire(import.meta.url);
 let cachedBinary;
+// A candidate counts only if it is a NATIVE executable, never a script.
+// Under --ignore-scripts the postinstall never runs and @ast-grep/cli's
+// bin files remain #!/usr/bin/env node shims — spawning one where env
+// cannot find node fails confusingly (the review's probe). Native
+// binaries begin with magic bytes; every script begins "#!". The
+// platform package's binary is always the postinstall-copied original,
+// so it is tried FIRST and the shim can never shadow it.
+function isNativeExecutable(p) {
+    try {
+        const fd = fs.openSync(p, "r");
+        try {
+            const buf = Buffer.alloc(2);
+            const n = fs.readSync(fd, buf, 0, 2, 0);
+            return n === 2 && !(buf[0] === 0x23 && buf[1] === 0x21);
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+    }
+    catch {
+        return false;
+    }
+}
+// The picker, pure over its candidate list (ordered by preference) so
+// the shim-shadowing law is pinnable without a real stripped install.
+export function pickNativeBinary(candidates) {
+    for (const candidate of candidates) {
+        try {
+            fs.accessSync(candidate, fs.constants.X_OK);
+            if (isNativeExecutable(candidate))
+                return candidate;
+        }
+        catch {
+            // next candidate
+        }
+    }
+    return null;
+}
 export function resolveAstGrepBinary() {
     var _a;
     if (cachedBinary !== undefined)
@@ -26,9 +64,10 @@ export function resolveAstGrepBinary() {
     const candidates = [];
     try {
         const pkgRoot = path.dirname(require_.resolve("@ast-grep/cli/package.json"));
-        candidates.push(path.join(pkgRoot, "ast-grep"), path.join(pkgRoot, "ast-grep.exe"));
         const pkg = JSON.parse(fs.readFileSync(path.join(pkgRoot, "package.json"), "utf8"));
         const platformSuffix = `-${process.platform}-${process.arch}`;
+        // 1. the platform package's own binary — native by construction,
+        //    present even under --ignore-scripts.
         for (const dep of Object.keys((_a = pkg.optionalDependencies) !== null && _a !== void 0 ? _a : {})) {
             if (dep.includes(platformSuffix)) {
                 try {
@@ -40,22 +79,15 @@ export function resolveAstGrepBinary() {
                 }
             }
         }
+        // 2. the postinstall copy inside @ast-grep/cli — same bytes after a
+        //    normal install; a shim (never native, never picked) before one.
+        candidates.push(path.join(pkgRoot, "ast-grep"), path.join(pkgRoot, "ast-grep.exe"));
     }
     catch {
         // @ast-grep/cli absent (unsupported install) — PATH is next
     }
-    for (const candidate of candidates) {
-        try {
-            fs.accessSync(candidate, fs.constants.X_OK);
-            cachedBinary = candidate;
-            return cachedBinary;
-        }
-        catch {
-            // next candidate
-        }
-    }
-    cachedBinary = null;
-    return null;
+    cachedBinary = pickNativeBinary(candidates);
+    return cachedBinary;
 }
 // One batched query over a real repo emits tens of megabytes of JSON (the
 // async-doctor pilot's ten patterns produce 24MB over a 979-file repo) —

package/bin/palette.d.ts

@@ -8,4 +8,5 @@ export declare function gradeColor(score: number): string;
 export declare function scoreHeaderTone(score: {
     score: number;
     filesTotal: number;
+    partialScan?: boolean;
 }): string;

package/bin/palette.js

@@ -20,5 +20,5 @@ export function gradeColor(score) {
 // structurally typed: palette's score imports stay value-level
 // (gradeFor, isEmptyScan) — no type dependency rides along.
 export function scoreHeaderTone(score) {
-    return isEmptyScan(score) ? YELLOW : gradeColor(score.score);
+    return isEmptyScan(score) || score.partialScan === true ? YELLOW : gradeColor(score.score);
 }

package/bin/runner.js

@@ -157,6 +157,17 @@ function spawnLoader(programPath, mode, timeoutMs, nodeFlags) {
 function lastLines(s, n = 8) {
     return s.trim().split("\n").slice(-n).join("\n");
 }
+// A crash's REASON lives at the top of stderr ("Error: <why>"), the
+// stack trails beneath it. Keeping only the tail showed frames and
+// swallowed the reason — including the engine's "ships with any-doctor"
+// explanation (review probe). Keep both ends: the leading lines that
+// state the cause, the trailing lines that locate it.
+function crashSummary(s) {
+    const lines = s.trim().split("\n");
+    if (lines.length <= 8)
+        return lines.join("\n");
+    return [...lines.slice(0, 3), "  …", ...lines.slice(-4)].join("\n");
+}
 // Loader frames are authored by our own doctor-loader — trusted construction.
 // The guards below separate "a usable frame" from "not a frame"; they are not
 // schema validation of the doctor contract.
@@ -186,7 +197,7 @@ const execLoader = (programPath, mode, timeoutMs = DEFAULT_TIMEOUT_MS) => Effect
                 findings: ["the runtime refused a forbidden capability:", ...lastLines(out.stderr, 2).split("\n")],
             });
         }
-        return yield* new DoctorCrashed({ programPath: abs, detail: lastLines(out.stderr || "exit " + out.status) });
+        return yield* new DoctorCrashed({ programPath: abs, detail: crashSummary(out.stderr || "exit " + out.status) });
     }
     const lines = out.stdout.split("\n");
     // The last sentinel line wins. A doctor writing directly to

package/bin/score.d.ts

@@ -4,6 +4,7 @@ export interface ScoreResult {
     grade: string;
     filesClean: number;
     filesTotal: number;
+    partialScan?: boolean;
 }
 export declare function findingSeverity(g: ReportGroup, f: Finding): Severity;
 export declare function gradeFor(score: number): string;
@@ -19,6 +20,7 @@ export interface ScoreHeader {
     scoreLine: string;
     cleanLine: string | null;
     emptyScan: boolean;
+    partialScan: boolean;
 }
 export declare function scoreHeaderLines(s: ScoreResult): ScoreHeader;
 export declare function categoryRollup(groups: ReportGroup[]): {

package/bin/score.js

@@ -55,15 +55,22 @@ export function isEmptyScan(s) {
 // dashboard render these strings, never re-compose them. The clean line
 // is null for an empty scan — there is nothing to be clean against —
 // and so is any score claim: "100 — Excellent" over nothing checked is
-// a false green, so the header says n/a instead.
+// a false green, so the header says n/a instead. A PARTIAL scan (doctors
+// crashed) gets the same refusal: findings stay listed and the exit
+// stays failing, but the aggregate grade is withheld — the crashed
+// doctors' silence must never read as cleanliness.
 export function scoreHeaderLines(s) {
     if (isEmptyScan(s)) {
-        return { scoreLine: "Score: n/a — no files scanned", cleanLine: null, emptyScan: true };
+        return { scoreLine: "Score: n/a — no files scanned", cleanLine: null, emptyScan: true, partialScan: false };
+    }
+    if (s.partialScan === true) {
+        return { scoreLine: "Score: n/a — partial scan (a doctor crashed; results above are incomplete)", cleanLine: null, emptyScan: false, partialScan: true };
     }
     return {
         scoreLine: `Score: ${s.score} / 100 — ${s.grade}`,
         cleanLine: `${s.filesClean}/${s.filesTotal} files clean`,
         emptyScan: false,
+        partialScan: false,
     };
 }
 export function categoryRollup(groups) {

package/bin/summary.js

@@ -54,9 +54,15 @@ function dedupeGroups(groups) {
     return { groups: out, hidden };
 }
 export function deriveSummary(outcome) {
+    var _a, _b;
     const { groups, hidden } = dedupeGroups(outcome.groups);
     const total = groups.reduce((n, g) => n + g.findings.length, 0);
     const score = computeScore(groups, outcome.fileCount);
+    // A crashed doctor contributes no findings, so the raw score reads its
+    // silence as cleanliness — the derivation is where crashes are known,
+    // and where the partial flag is set for every surface to honor.
+    if (((_b = (_a = outcome.crashed) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0) > 0)
+        score.partialScan = true;
     const header = scoreHeaderLines(score);
     const severityCounts = { error: 0, warning: 0, info: 0 };
     for (const g of groups) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "any-doctor",
-  "version": "0.0.8",
+  "version": "0.0.9",
   "description": "Your agent writes the analyzer, fixtures prove it, CI reruns it forever.",
   "license": "MIT",
   "bin": {