pi-lens 4.1.0 → 4.1.2

package/dist/clients/dispatch/runners/utils/tool-failure.js

@@ -29,7 +29,9 @@ export function formatToolFailure(input) {
             ? "did not run (spawn failure)"
             : `exited ${input.status}`;
     const missing = input.reportMissing ? "no report file" : "no output";
-    const detail = firstOutputLine(input.stderr) || firstOutputLine(input.stdout) || "no stderr";
+    const detail = firstOutputLine(input.stderr) ||
+        firstOutputLine(input.stdout) ||
+        "no stderr";
     return truncateForLedger(`${identity} ${what} with ${missing}: ${detail}`);
 }
 /**
@@ -70,3 +72,152 @@ export function skipUnlessToolRan(tool, input, fields) {
     });
     return { status: "skipped", diagnostics: [], semantic: "none" };
 }
+/**
+ * The record a runner leaves when its parser read NOTHING out of output the
+ * tool did produce (#1948).
+ *
+ * `skipUnlessToolRan` covers the adjacent case: the tool produced no output at
+ * all. The hole it leaves is the one that hid five parser bugs for months —
+ * vale (#1933), taplo, stylelint, phpstan (#1946), sqlfluff. Each received a
+ * real report, extracted zero diagnostics from it, and reported "succeeded, 0
+ * diagnostics", which is byte-for-byte what a genuinely clean file records.
+ * A reader could not answer "is this file clean, or did the parser fail?".
+ *
+ * THE RULE: record only when the exit status is NONZERO, the output handed to
+ * the parser is non-empty, and the parse yielded zero diagnostics. A nonzero
+ * exit is the tool asserting something is wrong; extracting nothing from that
+ * assertion means our reader disagrees with the tool, and one of the two is
+ * broken.
+ *
+ * Exit 0 with zero parsed is deliberately NOT recorded, even with non-empty
+ * output: that is the overwhelmingly common clean save. Linters print summary
+ * banners, empty JSON arrays, and progress noise on a clean run, so a row per
+ * clean save would drown the ledger and bury the real signal.
+ *
+ * FALSE NEGATIVES this rule accepts, stated plainly:
+ *   - A tool that reports findings under exit 0. `swiftlint` is the live
+ *     example among the adopters: a warning-only run exits 0 and still writes
+ *     a full JSON array, so a swiftlint parser break that never trips a
+ *     nonzero exit stays invisible here. (`vale` also exits 0 on findings by
+ *     default, but its actual #1933 break exited 1, so it is not the example.)
+ *     This gap is deliberate and is NOT closed by adding an output-length
+ *     threshold for exit 0. That class belongs to the captured-fixture lane —
+ *     `tests/clients/dispatch/runners/captured-real-output.test.ts` pins each
+ *     parser against real recorded binary output, which catches a broken
+ *     parser directly instead of guessing from output size. A length
+ *     threshold here would fire on every clean run of every tool that prints
+ *     a summary banner.
+ *   - A tool whose parser breaks only for a SUBSET of findings still reports
+ *     the ones it can read, so `parsedCount` is nonzero and nothing records.
+ *
+ * FALSE POSITIVES it accepts: a runner that legitimately parses zero
+ * diagnostics out of a failing run — `go-vet` exits nonzero for a SIBLING
+ * file's problem and then filters to the edited file, and `terragrunt` does
+ * the same across a unit directory. Such runners stay off this helper rather
+ * than being special-cased inside it; see the runner-family registries in
+ * `tests/clients/dispatch/runners/parsed-nothing-sweep.test.ts`.
+ *
+ * Bounded by `incrementDegradationCount`: one latest-reason entry per
+ * (kind, subject) with an exact tally, so a permanently broken parser costs
+ * ONE ledger row and not one per dispatched file. `subject` is the tool id
+ * because a parser break is a property of the tool and our reader of it, not
+ * of the project it ran in; aggregating on the tool keeps exactly the identity
+ * a reader needs ("which tool is stuck") while staying bounded across every
+ * workspace in the session.
+ *
+ * @returns true when a row was recorded.
+ */
+export function recordParsedNothing(input) {
+    const { tool, status, output, parsedCount } = input;
+    // Three conjuncts, one per clause of the rule above. Each is separately
+    // load-bearing and separately tested: `parsedCount` keeps a run that DID
+    // yield findings silent, `status` keeps the clean-save case silent (0 and a
+    // never-arrived null alike — neither is a tool asserting a problem), and
+    // `output` keeps "the tool said nothing at all" with `runner-empty-result`
+    // rather than double-recording it here.
+    if (parsedCount > 0)
+        return false;
+    if (!status)
+        return false;
+    const text = output ?? "";
+    if (!text.trim())
+        return false;
+    const entries = Object.entries(input.fields ?? {}).filter(([, value]) => value !== undefined && value !== "");
+    const identity = entries.length
+        ? `${tool} (${entries.map(([key, value]) => `${key}=${value}`).join(", ")})`
+        : tool;
+    incrementDegradationCount({
+        kind: "runner-parsed-nothing",
+        subject: tool,
+        reason: truncateForLedger(`${identity} exited ${status} with ${text.length} chars of output but the parser read 0 diagnostics: ${firstOutputLine(text) || "no first line"}`),
+    });
+    return true;
+}
+/**
+ * The one seam a runner uses to go from a spawn result to diagnostics (#1948).
+ *
+ * It composes the two gates that must BOTH hold before a runner may claim a
+ * clean file: `skipUnlessToolRan` (the tool produced nothing — #1816) and
+ * `recordParsedNothing` (the tool produced something the parser could not
+ * read). Runners call this instead of calling `skipUnlessToolRan` and then
+ * parsing on their own, so the second gate cannot be forgotten by whoever
+ * writes runner 53. `tests/clients/dispatch/runners/parsed-nothing-sweep.test.ts`
+ * enforces that.
+ */
+export function parseToolRun(tool, input, parse, options = {}) {
+    const skipped = skipUnlessToolRan(tool, input, options.fields);
+    if (skipped)
+        return { skipped, diagnostics: [], parsedNothing: false };
+    const output = options.parseOutput ?? input.output ?? input.result.stdout ?? "";
+    const diagnostics = [...parse(output)];
+    const parsedNothing = recordParsedNothing({
+        tool,
+        status: input.result.status ?? null,
+        output,
+        parsedCount: diagnostics.length,
+        fields: options.fields,
+    });
+    if (parsedNothing && options.skipWhenParsedNothing) {
+        return {
+            skipped: { status: "skipped", diagnostics: [], semantic: "none" },
+            diagnostics: [],
+            parsedNothing,
+        };
+    }
+    return { skipped: null, diagnostics, parsedNothing };
+}
+export function finishParsedRun(input) {
+    const raw = `${input.result.stdout ?? ""}${input.result.stderr ?? ""}`;
+    const status = input.result.status ?? null;
+    if (input.diagnostics.length === 0) {
+        if (status !== 0 && raw.trim().length > 0) {
+            return {
+                status: "failed",
+                diagnostics: [
+                    {
+                        id: `${input.tool}:parse-error:1`,
+                        message: `${input.tool} exited ${status} but its output could not be parsed`,
+                        filePath: input.ctx.filePath,
+                        line: 1,
+                        column: 1,
+                        severity: "warning",
+                        semantic: "warning",
+                        tool: input.tool,
+                    },
+                ],
+                semantic: "warning",
+            };
+        }
+        return { status: "succeeded", diagnostics: [], semantic: "none" };
+    }
+    const mapped = input.classify?.(input.diagnostics);
+    if (mapped) {
+        return { ...mapped, diagnostics: input.diagnostics };
+    }
+    const hasBlocking = input.diagnostics.some((d) => d.semantic === "blocking");
+    return {
+        status: hasBlocking ? "failed" : "succeeded",
+        diagnostics: input.diagnostics,
+        semantic: hasBlocking ? "blocking" : "warning",
+    };
+}

package/dist/clients/dispatch/runners/vale.js

@@ -3,7 +3,7 @@ import * as path from "node:path";
 import { safeSpawnAsync } from "../../safe-spawn.js";
 import { PRIORITY } from "../priorities.js";
 import { createAvailabilityChecker, resolveToolCommandWithInstallFallback, } from "./utils/runner-helpers.js";
-import { skipUnlessToolRan } from "./utils/tool-failure.js";
+import { parseToolRun } from "./utils/tool-failure.js";
 const vale = createAvailabilityChecker("vale", ".exe");
 /**
  * Check for a .vale.ini config file in cwd or parent dirs.
@@ -24,19 +24,18 @@ function findValeConfig(cwd) {
     }
     return undefined;
 }
-function parseValeOutput(raw, filePath) {
+export function parseValeOutput(raw, filePath) {
     const diagnostics = [];
     if (!raw.trim())
         return diagnostics;
     try {
         const parsed = JSON.parse(raw);
-        const files = parsed?.Data?.Files;
-        if (!files)
+        if (!parsed || typeof parsed !== "object")
             return diagnostics;
-        for (const file of files) {
-            if (!file.Alerts)
+        for (const alerts of Object.values(parsed)) {
+            if (!Array.isArray(alerts))
                 continue;
-            for (const alert of file.Alerts) {
+            for (const alert of alerts) {
                 if (!alert.Message)
                     continue;
                 const severityMap = {
@@ -51,7 +50,7 @@ function parseValeOutput(raw, filePath) {
                     message: `[${alert.Check ?? "vale"}] ${alert.Message}`,
                     filePath,
                     line: alert.Line ?? 1,
-                    column: alert.Column ?? 1,
+                    column: alert.Span?.[0] ?? 1,
                     severity,
                     semantic: severity === "error" ? "blocking" : "warning",
                     tool: "vale",
@@ -80,7 +79,7 @@ const valeRunner = {
             return { status: "skipped", diagnostics: [], semantic: "none" };
         }
         let cmd = null;
-        if (await (vale.isAvailableAsync(cwd))) {
+        if (await vale.isAvailableAsync(cwd)) {
             cmd = vale.getCommand(cwd);
         }
         else {
@@ -95,11 +94,14 @@ const valeRunner = {
         // zero alerts, and reported clean prose. No exit-code table: Vale's
         // nonzero codes vary with --minAlertLevel, so the conservative
         // nothing-to-parse rule is the only safe discriminator here.
-        const skipped = skipUnlessToolRan("vale", { result });
-        if (skipped)
-            return skipped;
-        const raw = result.stdout || "";
-        const diagnostics = parseValeOutput(raw, ctx.filePath);
+        //
+        // #1948: `parseToolRun` adds the second gate. Vale's `Data.Files`
+        // envelope bug produced exactly this shape — exit 1, a full JSON
+        // report on stdout, zero alerts parsed — and left no record.
+        const run = parseToolRun("vale", { result }, (raw) => parseValeOutput(raw, ctx.filePath));
+        if (run.skipped)
+            return run.skipped;
+        const diagnostics = run.diagnostics;
         if (diagnostics.length === 0) {
             return { status: "succeeded", diagnostics: [], semantic: "none" };
         }

package/dist/clients/dispatch/runners/yaml-rule-parser.js

@@ -106,9 +106,7 @@ export function loadYamlRulesFresh(ruleDir, severityFilter) {
         hash.update("\0");
     }
     const signature = hash.digest("hex");
-    const cache = severityFilter === "error"
-        ? contentBlockingRulesCache
-        : contentRulesCache;
+    const cache = severityFilter === "error" ? contentBlockingRulesCache : contentRulesCache;
     const cached = cache.get(ruleDir);
     if (cached?.signature === signature)
         return cached.rules;

package/dist/clients/dispatch/runners/yamllint.js

@@ -2,7 +2,8 @@ import { safeSpawnAsync } from "../../safe-spawn.js";
 import { getLinterPolicyForCwd, hasYamllintConfig } from "../../tool-policy.js";
 import { PRIORITY } from "../priorities.js";
 import { createAvailabilityChecker, resolveToolCommandWithInstallFallback, } from "./utils/runner-helpers.js";
-import { skipUnlessToolRan } from "./utils/tool-failure.js";
+import { parseToolRun } from "./utils/tool-failure.js";
+import { finishParsedRun } from "./utils/tool-failure.js";
 const yamllint = createAvailabilityChecker("yamllint", ".exe");
 export { hasYamllintConfig };
 function parseYamllintParsable(raw, filePath) {
@@ -45,7 +46,7 @@ const yamllintRunner = {
             ctx.log("yamllint: no config detected, running with default rules");
         }
         let cmd = null;
-        if (await (yamllint.isAvailableAsync(cwd))) {
+        if (await yamllint.isAvailableAsync(cwd)) {
             cmd = yamllint.getCommand(cwd);
         }
         else {
@@ -66,22 +67,18 @@ const yamllintRunner = {
         // and tracebacks. So the gate judges "nothing to parse" on stdout alone,
         // while the parser still reads both streams.
         const raw = `${result.stdout ?? ""}${result.stderr ?? ""}`;
-        const skipped = skipUnlessToolRan("yamllint", {
+        // #1948: classify on stdout as before, parse both streams as before, and
+        // record when a failing run yields nothing.
+        const run = parseToolRun("yamllint", { result, output: result.stdout }, (out) => parseYamllintParsable(out, ctx.filePath), { parseOutput: raw });
+        if (run.skipped)
+            return run.skipped;
+        const diagnostics = run.diagnostics;
+        return finishParsedRun({
+            tool: "yamllint",
+            ctx,
             result,
-            output: result.stdout,
-        });
-        if (skipped)
-            return skipped;
-        const diagnostics = parseYamllintParsable(raw, ctx.filePath);
-        if (diagnostics.length === 0) {
-            return { status: "succeeded", diagnostics: [], semantic: "none" };
-        }
-        const hasBlocking = diagnostics.some((d) => d.semantic === "blocking");
-        return {
-            status: hasBlocking ? "failed" : "succeeded",
             diagnostics,
-            semantic: hasBlocking ? "blocking" : "warning",
-        };
+        });
     },
 };
 export default yamllintRunner;

package/dist/clients/dispatch/runners/zig-check.js

@@ -48,7 +48,7 @@ const zigCheckRunner = {
     skipTestFiles: false,
     async run(ctx) {
         const cwd = ctx.cwd || process.cwd();
-        if (!(await (zig.isAvailableAsync(cwd)))) {
+        if (!(await zig.isAvailableAsync(cwd))) {
             return { status: "skipped", diagnostics: [], semantic: "none" };
         }
         const cmd = zig.getCommand(cwd);

package/dist/clients/dispatch/suppress-writer.js

@@ -56,7 +56,8 @@ export function insertSuppressComment(content, filePath, line, rule) {
             .filter(Boolean);
         if (!rules.includes(rule))
             rules.push(rule);
-        lines[aboveIdx] = existingAbove.slice(0, match.index) + match[1] + rules.join(", ");
+        lines[aboveIdx] =
+            existingAbove.slice(0, match.index) + match[1] + rules.join(", ");
         return lines.join("\n");
     }
     // Match the indentation of the flagged line so the inserted comment lines

package/dist/clients/dispatch/types.js

@@ -10,4 +10,9 @@
  *
  * The dispatcher must handle these semantics consistently.
  */
-export {};
+/** Closed telemetry taxonomy for expected runner skips. */
+export const RUNNER_SKIP_REASONS = ["no-files-matched"];
+/** Runtime guard for untyped/plugin-provided runner results. */
+export function isRunnerSkipReason(value) {
+    return RUNNER_SKIP_REASONS.some((reason) => reason === value);
+}

package/dist/clients/dispatch/utils/lsp-diagnostics.js

@@ -3,9 +3,13 @@ export function convertLspDiagnostics(diags, filePath, options = {}) {
     return diags
         .filter((d) => d.range?.start?.line !== undefined)
         .map((d, idx) => {
-        const severityMap = { 1: "error", 2: "warning", 4: "hint" };
+        const severityMap = {
+            1: "error",
+            2: "warning",
+            4: "hint",
+        };
         const severity = severityMap[d.severity] ?? "info";
-        const semantic = d.severity === 1 ? "blocking" : (d.severity === 2 ? "warning" : "none");
+        const semantic = d.severity === 1 ? "blocking" : d.severity === 2 ? "warning" : "none";
         const code = String(d.code ?? "unknown");
         // #692: identity ALWAYS derives from the diagnostic's own source — never
         // from a caller-supplied scan label (see `scanOrigin`'s doc comment above).

package/dist/clients/extension-log.js

@@ -137,7 +137,7 @@ let moduleLoadWindowOpen = false;
  * the same as an empty store, so it reads as "no window" rather than throwing.
  */
 export function isConsoleCaptureActive() {
-    return (moduleLoadWindowOpen || consoleCaptureStorage?.getStore() === true);
+    return moduleLoadWindowOpen || consoleCaptureStorage?.getStore() === true;
 }
 /**
  * Open the module-evaluation window. Called by `clients/console-guard-install.ts`
@@ -207,7 +207,7 @@ function inCaptureWindow(fn) {
  * the terminal.
  */
 function isCaptureSeam(prop) {
-    return prop === "on" || (typeof prop === "string" && prop.startsWith("register"));
+    return (prop === "on" || (typeof prop === "string" && prop.startsWith("register")));
 }
 /**
  * Wrap every function value found in `value`, in place. Handles the two
@@ -312,7 +312,9 @@ export function withConsoleCaptureWindows(api) {
             // value instead of tripping that invariant (S2a) — a frozen host API
             // loses the capture window for that member, but keeps working.
             const descriptor = Reflect.getOwnPropertyDescriptor(target, prop);
-            if (descriptor && descriptor.writable === false && descriptor.configurable === false) {
+            if (descriptor &&
+                descriptor.writable === false &&
+                descriptor.configurable === false) {
                 return descriptor.value;
             }
             const cached = wrapperCache.get(prop);

package/dist/clients/feature-hints.js

@@ -81,7 +81,14 @@ export function inferTrustBoundaries(nameOrPath) {
         boundaries.add("user-input");
         boundaries.add("process-exec");
     }
-    if (hasHintToken(normalized, ["auth", "login", "token", "session", "oauth", "jwt"])) {
+    if (hasHintToken(normalized, [
+        "auth",
+        "login",
+        "token",
+        "session",
+        "oauth",
+        "jwt",
+    ])) {
         boundaries.add("auth");
         boundaries.add("user-input");
     }

package/dist/clients/file-kinds.js

@@ -7,24 +7,10 @@
 import { basename, extname } from "node:path";
 // --- Extension Maps ---
 export const KIND_EXTENSIONS = {
-    clojure: [
-        ".clj",
-        ".cljc",
-        ".cljs",
-        ".edn",
-    ],
-    cmake: [
-        ".cmake",
-    ],
-    csharp: [
-        ".cs",
-    ],
-    css: [
-        ".css",
-        ".less",
-        ".sass",
-        ".scss",
-    ],
+    clojure: [".clj", ".cljc", ".cljs", ".edn"],
+    cmake: [".cmake"],
+    csharp: [".cs"],
+    css: [".css", ".less", ".sass", ".scss"],
     cue: [".cue"],
     // From llvm-project/clang/lib/Driver/Types.cpp clang::driver::types::lookupTypeForExtension:
     cxx: [
@@ -61,49 +47,18 @@ export const KIND_EXTENSIONS = {
         ".cl",
         ".clcpp",
     ],
-    dart: [
-        ".dart",
-    ],
-    docker: [
-        ".dockerfile",
-    ],
-    elixir: [
-        ".ex",
-        ".exs",
-    ],
-    fish: [
-        ".fish",
-    ],
-    fsharp: [
-        ".fs",
-        ".fsi",
-        ".fsx",
-    ],
-    gleam: [
-        ".gleam",
-    ],
-    go: [
-        ".go",
-    ],
-    haskell: [
-        ".hs",
-        ".lhs",
-    ],
-    "helm-template": [
-        ".tpl",
-    ],
-    html: [
-        ".htm",
-        ".html",
-    ],
-    java: [
-        ".java",
-    ],
-    json: [
-        ".json",
-        ".json5",
-        ".jsonc",
-    ],
+    dart: [".dart"],
+    docker: [".dockerfile"],
+    elixir: [".ex", ".exs"],
+    fish: [".fish"],
+    fsharp: [".fs", ".fsi", ".fsx"],
+    gleam: [".gleam"],
+    go: [".go"],
+    haskell: [".hs", ".lhs"],
+    "helm-template": [".tpl"],
+    html: [".htm", ".html"],
+    java: [".java"],
+    json: [".json", ".json5", ".jsonc"],
     jsts: [
         ".cjs",
         ".cts",
@@ -116,75 +71,25 @@ export const KIND_EXTENSIONS = {
         ".tsx",
         ".vue",
     ],
-    kotlin: [
-        ".kt",
-        ".kts",
-    ],
-    lua: [
-        ".lua",
-    ],
-    markdown: [
-        ".md",
-        ".mdx",
-    ],
-    nix: [
-        ".nix",
-    ],
-    ocaml: [
-        ".ml",
-        ".mli",
-    ],
-    php: [
-        ".php",
-    ],
-    powershell: [
-        ".ps1",
-        ".psm1",
-        ".psd1",
-    ],
-    prisma: [
-        ".prisma",
-    ],
-    python: [
-        ".py",
-        ".pyi",
-    ],
-    ruby: [
-        ".gemspec",
-        ".rake",
-        ".rb",
-        ".ru",
-    ],
-    rust: [
-        ".rs",
-    ],
-    shell: [
-        ".bash",
-        ".sh",
-        ".zsh",
-    ],
-    sql: [
-        ".sql",
-    ],
-    swift: [
-        ".swift",
-    ],
-    terraform: [
-        ".tf",
-        ".tfvars",
-    ],
+    kotlin: [".kt", ".kts"],
+    lua: [".lua"],
+    markdown: [".md", ".mdx"],
+    nix: [".nix"],
+    ocaml: [".ml", ".mli"],
+    php: [".php"],
+    powershell: [".ps1", ".psm1", ".psd1"],
+    prisma: [".prisma"],
+    python: [".py", ".pyi"],
+    ruby: [".gemspec", ".rake", ".rb", ".ru"],
+    rust: [".rs"],
+    shell: [".bash", ".sh", ".zsh"],
+    sql: [".sql"],
+    swift: [".swift"],
+    terraform: [".tf", ".tfvars"],
     terragrunt: [],
-    toml: [
-        ".toml",
-    ],
-    yaml: [
-        ".yaml",
-        ".yml",
-    ],
-    zig: [
-        ".zig",
-        ".zon",
-    ],
+    toml: [".toml"],
+    yaml: [".yaml", ".yml"],
+    zig: [".zig", ".zon"],
 };
 /** Return whether a path has an extension registered for the given file kind. */
 export function hasKindExtension(filePath, kind) {

package/dist/clients/file-utils.js

@@ -5,7 +5,8 @@ import * as fs from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 import { minimatch } from "./deps/minimatch.js";
-import { collectTrackedFiles, getTrackedFilesSnapshot } from "./git-tracked-ignore.js";
+import { isInSpawnTimeoutCooldown, noteSpawnTimeout, } from "./spawn-timeout-cooldown.js";
+import { collectTrackedFiles, getTrackedFilesSnapshot, } from "./git-tracked-ignore.js";
 import { getGlobalIgnorePatterns, getPiLensGlobalConfigPath, } from "./lens-config.js";
 import { normalizeEphemeralMapKey, normalizeFilePath } from "./path-utils.js";
 import { findPiLensConfigInDir, findPiLensProjectConfig, loadPiLensConfigInDir, loadPiLensProjectConfig, } from "./project-lens-config.js";
@@ -577,12 +578,27 @@ export async function detectFileChangedAfterCommand(filePath, command, args, cwd
     catch {
         return 0;
     }
+    // #1995: a command cooling down after a spawn timeout must not be handed
+    // a second budget - autofix is one of the lanes that paid twice for a
+    // wedged .cmd shim. Return "no fix applied" (an honest not-checked).
+    if (isInSpawnTimeoutCooldown(command))
+        return 0;
     const result = await safeSpawnAsync(command, args, {
         timeout: 30000,
         cwd,
     });
     if (result.error)
         return 0;
+    if (result.failure === "timeout") {
+        noteSpawnTimeout({
+            tool: path.basename(command).replace(/\.[^.]+$/, ""),
+            command,
+            phase: "autofix",
+            durationMs: 30000,
+            teardown: result.timeoutTeardown,
+        });
+        return 0;
+    }
     if (result.status !== 0 && !ignoreStatuses.includes(result.status ?? -1)) {
         return 0;
     }