pi-lens 4.1.0 → 4.1.2

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

@@ -91,7 +91,11 @@ async function resolveCompiler(absPath, cwd) {
     const clCmd = clChecker.getCommand(cwd);
     if (clCmd) {
         // Already probed in a previous turn and resolved.
-        return { command: clCmd, args: ["/nologo", "/Zs", absPath], flavor: "msvc" };
+        return {
+            command: clCmd,
+            args: ["/nologo", "/Zs", absPath],
+            flavor: "msvc",
+        };
     }
     const clProbe = await safeSpawnAsync("cl", [], { timeout: 5000 });
     if (!clProbe.error && clProbe.status !== null) {

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

@@ -4,7 +4,7 @@ import { safeSpawnAsync } from "../../safe-spawn.js";
 import { getLinterPolicyForCwd } from "../../tool-policy.js";
 import { PRIORITY } from "../priorities.js";
 import { createAvailabilityChecker } from "./utils/runner-helpers.js";
-import { spawnFailedWithNoOutput } from "./utils/spawn-outcome.js";
+import { parseToolRun } from "./utils/tool-failure.js";
 const detekt = createAvailabilityChecker("detekt", ".bat");
 const DETEKT_CONFIG_CANDIDATES = [
     "detekt.yml",
@@ -146,11 +146,14 @@ const detektRunner = {
             return { status: "skipped", diagnostics: [], semantic: "none" };
         const absPath = path.resolve(cwd, ctx.filePath);
         const result = await safeSpawnAsync(cmd, ["--input", absPath, "--config", configPath], { cwd, timeout: 60000 });
+        // #1948: detekt reports across both streams, so the gate and the parser
+        // read the same concatenated string. A nonzero exit that yields zero
+        // findings out of real output is a parser break, not clean Kotlin.
         const raw = `${result.stdout ?? ""}${result.stderr ?? ""}`;
-        if (spawnFailedWithNoOutput(result, raw)) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        const diagnostics = parseDetektOutput(raw, ctx.filePath);
+        const run = parseToolRun("detekt", { result, output: raw }, (out) => parseDetektOutput(out, ctx.filePath));
+        if (run.skipped)
+            return run.skipped;
+        const diagnostics = run.diagnostics;
         if (diagnostics.length === 0) {
             return { status: "succeeded", diagnostics: [], semantic: "none" };
         }
@@ -163,4 +166,4 @@ const detektRunner = {
     },
 };
 export default detektRunner;
-export { parseDetektOutput, DETEKT_FIXABLE_RULES };
+export { DETEKT_FIXABLE_RULES, parseDetektOutput };

package/dist/clients/dispatch/runners/dotnet-build.js

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

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

@@ -88,7 +88,9 @@ function parseElixirOutput(raw, filePath, cwd = process.cwd()) {
                 if (matchesTarget(sourcePath)) {
                     diagnostics.push({
                         id: `elixir-check-${severity}-${lineStr}-${colStr || "1"}`,
-                        message: severity === "error" ? `[error] ${message.trim()}` : message.trim(),
+                        message: severity === "error"
+                            ? `[error] ${message.trim()}`
+                            : message.trim(),
                         filePath,
                         line: Number.parseInt(lineStr, 10) || 1,
                         column: Number.parseInt(colStr || "1", 10) || 1,

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

@@ -88,13 +88,22 @@ const eslintRunner = {
             return { status: "skipped", diagnostics: [], semantic: "none" };
         }
         const result = await safeSpawnAsync(cmd, ["--format", "json", "--no-error-on-unmatched-pattern", ctx.filePath], { timeout: 30000, cwd });
-        // ESLint exits 1 when there are lint errors, 2 on fatal/config error
+        // ESLint exits 2 on fatal/config errors — nothing was linted, so this
+        // is an unavailable run, not a clean or failed one.
         if (result.status === 2) {
             return { status: "skipped", diagnostics: [], semantic: "none" };
         }
-        const raw = result.stdout || result.stderr || "";
-        if (result.status === 0) {
-            return { status: "succeeded", diagnostics: [], semantic: "none" };
+        // ESLint exits 0 whenever nothing reached ERROR severity — that
+        // includes a run that found only warnings (#1954), which also prints a
+        // full JSON report. So parse stdout unconditionally and branch on the
+        // parsed diagnostic count instead of letting the exit code discard the
+        // warning case. Stderr is only a fallback for a failing run whose
+        // stdout went missing; parsing stderr noise on a healthy exit-0 run
+        // would turn deprecation chatter into spurious parse-error findings.
+        const stdout = result.stdout ?? "";
+        let raw = stdout;
+        if (raw.length === 0 && result.status !== 0) {
+            raw = result.stderr || "";
         }
         const parsed = parseEslintJson(raw, ctx.filePath);
         if (parsed.parseError && raw.trim().length > 0) {
@@ -104,7 +113,9 @@ const eslintRunner = {
                 diagnostics: [
                     {
                         id: "eslint:parse-error:1",
-                        message: "ESLint JSON parse failed: " + parsed.parseError + (preview ? " (output preview: " + preview + ")" : ""),
+                        message: "ESLint JSON parse failed: " +
+                            parsed.parseError +
+                            (preview ? " (output preview: " + preview + ")" : ""),
                         filePath: ctx.filePath,
                         line: 1,
                         column: 1,
@@ -121,8 +132,16 @@ const eslintRunner = {
             return { status: "succeeded", diagnostics: [], semantic: "none" };
         }
         const hasErrors = diagnostics.some((d) => d.semantic === "blocking");
+        // A warning-only result on exit 0 is ESLint's normal outcome, not a
+        // failure: exit 0 means nothing hit ERROR severity. Keying status off
+        // blocking severity plus exit code (the sibling convention from oxlint,
+        // biome-check, golangci-lint, rubocop) keeps plan.ts's fallback group
+        // ["eslint", "oxlint", "biome-check-json"] stopping at eslint instead
+        // of re-running oxlint and biome-check-json on every warning-only save.
+        // The findings reach delivery regardless of status — dispatcher.ts
+        // buckets by each diagnostic's own `semantic`.
         return {
-            status: "failed",
+            status: !hasErrors && result.status === 0 ? "succeeded" : "failed",
             diagnostics,
             semantic: hasErrors ? "blocking" : "warning",
         };

package/dist/clients/dispatch/runners/fish-indent.js

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

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

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

package/dist/clients/dispatch/runners/golangci-lint.js

@@ -31,7 +31,9 @@ function describeReplacement(replacement) {
         return "Delete this code";
     if (replacement.NewLines && replacement.NewLines.length > 0) {
         const preview = replacement.NewLines[0].trim();
-        const hint = replacement.NewLines.length > 1 ? ` (+${replacement.NewLines.length - 1} more lines)` : "";
+        const hint = replacement.NewLines.length > 1
+            ? ` (+${replacement.NewLines.length - 1} more lines)`
+            : "";
         return `Replace with: ${preview}${hint}`;
     }
     return "Apply golangci-lint suggested fix";

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

@@ -3,7 +3,8 @@ import { safeSpawnAsync } from "../../safe-spawn.js";
 import { getLinterPolicyForCwd } from "../../tool-policy.js";
 import { PRIORITY } from "../priorities.js";
 import { createAvailabilityChecker, resolveToolCommandWithInstallFallback, } from "./utils/runner-helpers.js";
-import { spawnFailedWithNoOutput } from "./utils/spawn-outcome.js";
+import { parseToolRun } from "./utils/tool-failure.js";
+import { finishParsedRun } from "./utils/tool-failure.js";
 const hadolint = createAvailabilityChecker("hadolint", ".exe");
 function parseHadolintOutput(raw, filePath) {
     try {
@@ -43,7 +44,7 @@ const hadolintRunner = {
             return { status: "skipped", diagnostics: [], semantic: "none" };
         }
         let cmd = null;
-        if (await (hadolint.isAvailableAsync(cwd))) {
+        if (await hadolint.isAvailableAsync(cwd)) {
             cmd = hadolint.getCommand(cwd);
         }
         else {
@@ -53,20 +54,26 @@ const hadolintRunner = {
             return { status: "skipped", diagnostics: [], semantic: "none" };
         }
         const result = await safeSpawnAsync(cmd, ["--format", "json", "--no-fail", path.resolve(cwd, ctx.filePath)], { cwd });
-        if (spawnFailedWithNoOutput(result)) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        const output = result.stdout || "";
-        const diagnostics = parseHadolintOutput(output, ctx.filePath);
-        if (diagnostics.length === 0) {
-            return { status: "succeeded", diagnostics: [], semantic: "none" };
-        }
-        const hasErrors = diagnostics.some((d) => d.severity === "error");
-        return {
-            status: "failed",
+        // #1948: hadolint runs with `--no-fail`, so it exits 0 even when it finds
+        // something. A nonzero exit therefore means hadolint itself failed, and
+        // zero parsed diagnostics out of whatever it printed is a parser break.
+        const run = parseToolRun("hadolint", { result }, (out) => parseHadolintOutput(out, ctx.filePath));
+        if (run.skipped)
+            return run.skipped;
+        const diagnostics = run.diagnostics;
+        return finishParsedRun({
+            tool: "hadolint",
+            ctx,
+            result,
             diagnostics,
-            semantic: hasErrors ? "blocking" : "warning",
-        };
+            classify: (diagnostics) => {
+                const hasErrors = diagnostics.some((d) => d.severity === "error");
+                return {
+                    status: "failed",
+                    semantic: hasErrors ? "blocking" : "warning",
+                };
+            },
+        });
     },
 };
 export default hadolintRunner;

package/dist/clients/dispatch/runners/helm-lint.js

@@ -15,7 +15,10 @@ const SKIPPED = {
 };
 function isWithin(root, candidate) {
     const relative = path.relative(normalizeMapKey(root), normalizeMapKey(candidate));
-    return relative === "" || (!relative.startsWith(`..${path.sep}`) && relative !== ".." && !path.isAbsolute(relative));
+    return (relative === "" ||
+        (!relative.startsWith(`..${path.sep}`) &&
+            relative !== ".." &&
+            !path.isAbsolute(relative)));
 }
 function diagnosticLocation(message, chartRoot) {
     const location = message.match(/(?:^|\s)([^:\r\n]+\.(?:ya?ml|tpl|json))(?::(\d+))?(?::\d+)?(?::|\s)/i);

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

@@ -3,7 +3,8 @@ import { safeSpawnAsync } from "../../safe-spawn.js";
 import { getLinterPolicyForCwd } from "../../tool-policy.js";
 import { PRIORITY } from "../priorities.js";
 import { createAvailabilityChecker, resolveToolCommandWithInstallFallback, } from "./utils/runner-helpers.js";
-import { spawnFailedWithNoOutput } from "./utils/spawn-outcome.js";
+import { parseToolRun } from "./utils/tool-failure.js";
+import { finishParsedRun } from "./utils/tool-failure.js";
 const htmlhint = createAvailabilityChecker("htmlhint");
 const HTMLHINT_RULES = {
     "tag-pair": true,
@@ -55,7 +56,7 @@ const htmlhintRunner = {
             return { status: "skipped", diagnostics: [], semantic: "none" };
         }
         let cmd = null;
-        if (await (htmlhint.isAvailableAsync(cwd))) {
+        if (await htmlhint.isAvailableAsync(cwd)) {
             cmd = htmlhint.getCommand(cwd);
         }
         else {
@@ -64,28 +65,44 @@ const htmlhintRunner = {
         if (!cmd) {
             return { status: "skipped", diagnostics: [], semantic: "none" };
         }
-        const rulesJson = JSON.stringify(HTMLHINT_RULES);
+        // htmlhint's --rules flag takes a comma-separated ruleid list
+        // ("tag-pair,id-class-value=underline"), NOT a JSON object. The old JSON
+        // blob parsed as one bogus rule id, leaving ZERO rules enabled — every
+        // file read CLEAN (exit 0, no output) no matter what it contained.
+        // Root-caused live against htmlhint 1.x after the tier-1 parser smoke
+        // caught htmlhint reporting 0 findings on the planted tag-pair defect.
+        // Entries set to false are omitted: under --rules semantics an unlisted
+        // rule is off, which is exactly what `false` means here.
+        const rulesArg = Object.entries(HTMLHINT_RULES)
+            .flatMap(([rule, enabled]) => (enabled === true ? [rule] : []))
+            .join(",");
         const result = await safeSpawnAsync(cmd, [
             "--rules",
-            rulesJson,
+            rulesArg,
             "--format",
             "unix",
             path.resolve(cwd, ctx.filePath),
         ], { cwd });
+        // #1948: htmlhint exits 1 when it finds errors and prints them in `unix`
+        // format on stdout. Zero parsed out of a nonzero exit is a parser break.
         const output = result.stdout || result.stderr || "";
-        if (spawnFailedWithNoOutput(result, output)) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        const diagnostics = parseHtmlhintOutput(output, ctx.filePath);
-        if (diagnostics.length === 0) {
-            return { status: "succeeded", diagnostics: [], semantic: "none" };
-        }
-        const hasErrors = diagnostics.some((d) => d.severity === "error");
-        return {
-            status: "failed",
+        const run = parseToolRun("htmlhint", { result, output }, (out) => parseHtmlhintOutput(out, ctx.filePath));
+        if (run.skipped)
+            return run.skipped;
+        const diagnostics = run.diagnostics;
+        return finishParsedRun({
+            tool: "htmlhint",
+            ctx,
+            result,
             diagnostics,
-            semantic: hasErrors ? "blocking" : "warning",
-        };
+            classify: (diagnostics) => {
+                const hasErrors = diagnostics.some((d) => d.severity === "error");
+                return {
+                    status: "failed",
+                    semantic: hasErrors ? "blocking" : "warning",
+                };
+            },
+        });
     },
 };
 export default htmlhintRunner;

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

@@ -54,7 +54,7 @@ const javacRunner = {
             ctx.log?.("javac: skipped — file is inside a Maven/Gradle project; a classpath-less compile would emit false positives");
             return { status: "skipped", diagnostics: [], semantic: "none" };
         }
-        if (!(await (javac.isAvailableAsync(cwd)))) {
+        if (!(await javac.isAvailableAsync(cwd))) {
             return { status: "skipped", diagnostics: [], semantic: "none" };
         }
         const cmd = javac.getCommand(cwd);

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

@@ -65,7 +65,7 @@ const ktlintRunner = {
             return { status: "skipped", diagnostics: [], semantic: "none" };
         }
         let cmd = null;
-        if (await (ktlint.isAvailableAsync(cwd))) {
+        if (await ktlint.isAvailableAsync(cwd)) {
             cmd = ktlint.getCommand(cwd);
         }
         else {

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

@@ -23,7 +23,7 @@ import { demoteInferredProjectDiagnostics } from "../../lsp/inferred-project.js"
 import { enabledAuxiliaryLspServerIds, retagAuxiliaryDiagnostics, } from "../auxiliary-lsp.js";
 import { readFileContent } from "./utils.js";
 import { tryWarmAttachedCodeActions, tryWarmAttachedDiagnostics, } from "../../warm-attach.js";
-import { contentHash, WARM_CODE_ACTION_LOOKUP_LIMIT, } from "../../mcp/ipc.js";
+import { contentHash, WARM_CODE_ACTION_LOOKUP_LIMIT } from "../../mcp/ipc.js";
 const LSP_MAX_FILE_BYTES = RUNTIME_CONFIG.pipeline.lspMaxFileBytes;
 const LSP_MAX_FILE_LINES = RUNTIME_CONFIG.pipeline.lspMaxFileLines;
 const LSP_SPAWN_BUDGET_MS = RUNTIME_CONFIG.pipeline.lspSpawnBudgetMs;

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

@@ -2,7 +2,9 @@ import { safeSpawnAsync } from "../../safe-spawn.js";
 import { getLinterPolicyForCwd, markdownlintConfigArgs, } 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 { isInSpawnTimeoutCooldown, noteSpawnTimeout, } from "../../spawn-timeout-cooldown.js";
+import { finishParsedRun } from "./utils/tool-failure.js";
 const markdownlint = createAvailabilityChecker("markdownlint-cli2", ".cmd");
 // markdownlint-cli2 exit codes (its README's "Exit Codes" section): 0 = no
 // findings, 1 = lint findings, 2 = unexpected error (unreadable config, bad
@@ -98,7 +100,7 @@ const markdownlintRunner = {
             return { status: "skipped", diagnostics: [], semantic: "none" };
         }
         let cmd = null;
-        if (await (markdownlint.isAvailableAsync(cwd))) {
+        if (await markdownlint.isAvailableAsync(cwd)) {
             cmd = markdownlint.getCommand(cwd);
         }
         else {
@@ -106,6 +108,13 @@ const markdownlintRunner = {
         }
         if (!cmd)
             return { status: "skipped", diagnostics: [], semantic: "none" };
+        // #1995: a command cooling down after a spawn timeout already consumed
+        // its budget in another lane (availability verify, autofix --fix). Skip
+        // without spawning — "not checked", never re-reported as clean.
+        if (isInSpawnTimeoutCooldown(cmd)) {
+            ctx.log(`markdownlint: ${cmd} is cooling down after a spawn timeout — skipping (one bounded failure budget per edit)`);
+            return { status: "skipped", diagnostics: [], semantic: "none" };
+        }
         // Shared config-args seam (#1247): the autofix path consumes the same
         // builder, so the package-owned fallback config can never drift.
         const configArgs = markdownlintConfigArgs(cwd);
@@ -113,23 +122,36 @@ const markdownlintRunner = {
             timeout: 15000,
             cwd,
         });
+        // #1995: a timeout is negative runtime evidence. Arm the cooldown so
+        // the autofix and availability lanes cannot hand this command a second
+        // budget within the same session.
+        if (result.failure === "timeout") {
+            noteSpawnTimeout({
+                tool: "markdownlint",
+                command: cmd,
+                phase: "lint",
+                durationMs: 15000,
+                teardown: result.timeoutTeardown,
+            });
+        }
         // #1816: this runner read `result.status` zero times, so an exit-2
         // config error with an empty stdout parsed to zero diagnostics and was
         // reported as a clean Markdown file. An empty result must distinguish
         // clean from errored.
         const raw = `${result.stdout ?? ""}${result.stderr ?? ""}`;
-        const skipped = skipUnlessToolRan("markdownlint", {
+        // #1948: one seam for both gates — the tool produced nothing, and the
+        // tool produced something the parser could not read.
+        const run = parseToolRun("markdownlint", { result, output: raw, exitCodes: MARKDOWNLINT_EXIT_CODES }, (out) => parseMarkdownlintOutput(out, ctx.filePath));
+        if (run.skipped)
+            return run.skipped;
+        const diagnostics = run.diagnostics;
+        return finishParsedRun({
+            tool: "markdownlint",
+            ctx,
             result,
-            output: raw,
-            exitCodes: MARKDOWNLINT_EXIT_CODES,
+            diagnostics,
+            classify: () => ({ status: "succeeded", semantic: "warning" }),
         });
-        if (skipped)
-            return skipped;
-        const diagnostics = parseMarkdownlintOutput(raw, ctx.filePath);
-        if (diagnostics.length === 0) {
-            return { status: "succeeded", diagnostics: [], semantic: "none" };
-        }
-        return { status: "succeeded", diagnostics, semantic: "warning" };
     },
 };
 export default markdownlintRunner;

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

@@ -3,7 +3,8 @@ import { safeSpawnAsync } from "../../safe-spawn.js";
 import { hasMypyConfig } 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 mypy = createAvailabilityChecker("mypy", "");
 // mypy exit codes: 0 = no type errors, 1 = type errors found, 2 = a blocking
 // error. 2 is NOT a rejected invocation on its own — mypy reports a source
@@ -67,7 +68,7 @@ const mypyRunner = {
             return { status: "skipped", diagnostics: [], semantic: "none" };
         }
         let cmd = null;
-        if (await (mypy.isAvailableAsync(cwd))) {
+        if (await mypy.isAvailableAsync(cwd)) {
             cmd = mypy.getCommand(cwd);
         }
         else {
@@ -81,23 +82,20 @@ const mypyRunner = {
         // stdout only (see MYPY_EXIT_CODES) so an exit-2 SYNTAX error, which
         // does write a diagnostic there, still reaches the parser.
         const raw = `${result.stdout ?? ""}${result.stderr ?? ""}`;
-        const skipped = skipUnlessToolRan("mypy", {
+        // #1948: `parseOutput` keeps the split this runner already had — the gate
+        // judges "did it run" on stdout alone, the parser still reads both
+        // streams — so adding the parsed-nothing record does not widen the
+        // did-it-run verdict.
+        const run = parseToolRun("mypy", { result, output: result.stdout, exitCodes: MYPY_EXIT_CODES }, (out) => parseMypyOutput(out, ctx.filePath, cwd), { parseOutput: raw });
+        if (run.skipped)
+            return run.skipped;
+        const diagnostics = run.diagnostics;
+        return finishParsedRun({
+            tool: "mypy",
+            ctx,
             result,
-            output: result.stdout,
-            exitCodes: MYPY_EXIT_CODES,
-        });
-        if (skipped)
-            return skipped;
-        const diagnostics = parseMypyOutput(raw, ctx.filePath, cwd);
-        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 mypyRunner;