pi-lens 4.3.0 → 4.4.1

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

@@ -1,176 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { safeSpawnAsync } from "../../safe-spawn.js";
-import { pathsEqual } from "../../path-utils.js";
-import { resolveRunnerCwd } from "../../tool-cwd.js";
-import { getLinterPolicyForCwd } from "../../tool-policy.js";
-import { PRIORITY } from "../priorities.js";
-import { createAvailabilityChecker } from "./utils/runner-helpers.js";
-import { parseToolRun } from "./utils/tool-failure.js";
-const detekt = createAvailabilityChecker("detekt", ".bat");
-const DETEKT_CONFIG_CANDIDATES = [
-    "detekt.yml",
-    ".detekt.yml",
-    path.join("config", "detekt", "detekt.yml"),
-    path.join("detekt", "detekt.yml"),
-];
-// Rules that `detekt --auto-correct` rewrites deterministically. Detekt's
-// formatting ruleset wraps ktlint, whose rules are all autocorrectable; a
-// small handful of style rules also support autocorrect. Detekt's text
-// output does not surface a per-finding `canAutoCorrect` flag, so we keep a
-// curated allowlist here. Source: https://detekt.dev/docs/rules/formatting/
-// plus the autoCorrect-capable rules under style/comments. Conservative —
-// when in doubt, leave a rule off this list.
-const DETEKT_FIXABLE_RULES = new Set([
-    // formatting (ktlint wrapper) — every rule supports autocorrect
-    "AnnotationOnSeparateLine",
-    "AnnotationSpacing",
-    "ArgumentListWrapping",
-    "BlockCommentInitialStarAlignment",
-    "ChainWrapping",
-    "CommentSpacing",
-    "CommentWrapping",
-    "EnumEntryNameCase",
-    "Filename",
-    "FinalNewline",
-    "ImportOrdering",
-    "Indentation",
-    "MaximumLineLength",
-    "ModifierListSpacing",
-    "ModifierOrdering",
-    "MultiLineIfElse",
-    "NoBlankLineBeforeRbrace",
-    "NoBlankLinesInChainedMethodCalls",
-    "NoConsecutiveBlankLines",
-    "NoEmptyClassBody",
-    "NoEmptyFirstLineInMethodBlock",
-    "NoLineBreakAfterElse",
-    "NoLineBreakBeforeAssignment",
-    "NoMultipleSpaces",
-    "NoSemicolons",
-    "NoTrailingSpaces",
-    "NoUnitReturn",
-    "NoUnusedImports",
-    "NoWildcardImports",
-    "PackageName",
-    "ParameterListWrapping",
-    "SpacingAroundAngleBrackets",
-    "SpacingAroundColon",
-    "SpacingAroundComma",
-    "SpacingAroundCurly",
-    "SpacingAroundDot",
-    "SpacingAroundDoubleColon",
-    "SpacingAroundKeyword",
-    "SpacingAroundOperators",
-    "SpacingAroundParens",
-    "SpacingAroundRangeOperator",
-    "SpacingAroundUnaryOperator",
-    "SpacingBetweenDeclarationsWithAnnotations",
-    "SpacingBetweenDeclarationsWithComments",
-    "StringTemplate",
-    "TrailingCommaOnCallSite",
-    "TrailingCommaOnDeclarationSite",
-    "TypeArgumentListSpacing",
-    "TypeParameterListSpacing",
-    "UnnecessaryParenthesesBeforeTrailingLambda",
-    "Wrapping",
-    // style / comments — these implement autoCorrect in their detekt rule classes
-    "OptionalUnit",
-    "OptionalAbstractKeyword",
-    "ProtectedMemberInFinalClass",
-    "UnnecessaryParentheses",
-    "UnusedImports",
-    "UnusedPrivateClass",
-    "RedundantVisibilityModifierRule",
-]);
-export function findDetektConfig(cwd) {
-    for (const candidate of DETEKT_CONFIG_CANDIDATES) {
-        const full = path.join(cwd, candidate);
-        if (fs.existsSync(full))
-            return full;
-    }
-    return undefined;
-}
-// detekt text output: /path/file.kt:10:5: error: Message [RuleId]
-function parseDetektOutput(raw, filePath, cwd) {
-    const diagnostics = [];
-    const pattern = /^(.+?):(\d+):(\d+): (error|warning): (.+?)(?:\s+\[([^\]]+)\])?$/gm;
-    const absTarget = path.resolve(cwd, filePath);
-    for (const match of raw.matchAll(pattern)) {
-        const [, file, lineStr, colStr, level, message, rule] = match;
-        // #3278: one seam for reported-path attribution — see javac.ts.
-        if (!pathsEqual(path.resolve(cwd, file.trim()), absTarget))
-            continue;
-        const severity = level === "error" ? "error" : "warning";
-        const lineNum = Number.parseInt(lineStr, 10);
-        const colNum = Number.parseInt(colStr, 10);
-        const ruleId = rule ?? "detekt";
-        const fixable = rule ? DETEKT_FIXABLE_RULES.has(rule) : false;
-        diagnostics.push({
-            id: `detekt-${ruleId}-${lineNum}-${colNum}`,
-            message: rule ? `[${rule}] ${message}` : message,
-            filePath,
-            line: lineNum,
-            column: colNum,
-            severity,
-            semantic: severity === "error" ? "blocking" : "warning",
-            tool: "detekt",
-            rule: ruleId,
-            defectClass: "style",
-            fixable,
-            fixSuggestion: fixable
-                ? "Run `detekt --auto-correct` to apply the deterministic auto-correction for this rule."
-                : undefined,
-        });
-    }
-    return diagnostics;
-}
-const detektRunner = {
-    id: "detekt",
-    appliesTo: ["kotlin"],
-    priority: PRIORITY.GENERAL_ANALYSIS,
-    timeoutMs: 90_000,
-    skipTestFiles: false,
-    async run(ctx) {
-        const cwd = resolveRunnerCwd(ctx, "detekt");
-        const policy = getLinterPolicyForCwd(ctx.filePath, cwd);
-        if (policy && !policy.preferredRunners.includes("detekt")) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        const configPath = findDetektConfig(cwd);
-        if (!configPath) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        const cmd = (await detekt.isAvailableAsync(cwd))
-            ? detekt.getCommand(cwd)
-            : null;
-        if (!cmd)
-            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 ?? ""}`;
-        const run = parseToolRun("detekt", {
-            result,
-            output: raw,
-            // EXIT TABLE (detekt 1.23 measured fixture): 0 clean; 1 findings; 2 error; other nonzero rejected.
-            exitCodes: { ran: [1, 2] },
-        }, (out) => parseDetektOutput(out, ctx.filePath, cwd));
-        if (run.skipped)
-            return run.skipped;
-        const diagnostics = run.diagnostics;
-        if (diagnostics.length === 0) {
-            return { status: "succeeded", diagnostics: [], semantic: "none" };
-        }
-        const hasErrors = diagnostics.some((d) => d.severity === "error");
-        return {
-            status: hasErrors ? "failed" : "succeeded",
-            diagnostics,
-            semantic: hasErrors ? "blocking" : "warning",
-        };
-    },
-};
-export default detektRunner;
-export { DETEKT_FIXABLE_RULES, parseDetektOutput };

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

@@ -1,164 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { safeSpawnAsync } from "../../safe-spawn.js";
-import { pathsEqual } from "../../path-utils.js";
-import { resolveRunnerCwd } from "../../tool-cwd.js";
-import { PRIORITY } from "../priorities.js";
-import { createAvailabilityChecker } from "./utils/runner-helpers.js";
-import { finishParsedRun, parseToolRun } from "./utils/tool-failure.js";
-const dotnet = createAvailabilityChecker("dotnet", ".exe");
-function findProjectTarget(cwd) {
-    const entries = fs.readdirSync(cwd);
-    const solution = entries.find((entry) => /\.(sln|slnx)$/i.test(entry));
-    if (solution)
-        return solution;
-    return entries.find((entry) => /\.(csproj)$/i.test(entry));
-}
-function isDotnetRuleId(value) {
-    if (value.length < 2)
-        return false;
-    let sawDigit = false;
-    for (const char of value) {
-        const code = char.charCodeAt(0);
-        const isLetter = (code >= 65 && code <= 90) || (code >= 97 && code <= 122);
-        const isDigit = code >= 48 && code <= 57;
-        if (isDigit) {
-            sawDigit = true;
-            continue;
-        }
-        if (!isLetter || sawDigit)
-            return false;
-    }
-    return sawDigit;
-}
-function parseDotnetDiagnosticLine(line) {
-    const lower = line.toLowerCase();
-    const fileEnd = lower.lastIndexOf(".cs(");
-    if (fileEnd < 0)
-        return null;
-    const reportedFile = line.slice(0, fileEnd + 3).trim();
-    let cursor = fileEnd + 4;
-    const lineStart = cursor;
-    while (cursor < line.length &&
-        line.charCodeAt(cursor) >= 48 &&
-        line.charCodeAt(cursor) <= 57) {
-        cursor += 1;
-    }
-    if (cursor === lineStart || line[cursor] !== ",")
-        return null;
-    const lineStr = line.slice(lineStart, cursor);
-    cursor += 1;
-    const colStart = cursor;
-    while (cursor < line.length &&
-        line.charCodeAt(cursor) >= 48 &&
-        line.charCodeAt(cursor) <= 57) {
-        cursor += 1;
-    }
-    if (cursor === colStart || line.slice(cursor, cursor + 3) !== "): ")
-        return null;
-    const colStr = line.slice(colStart, cursor);
-    cursor += 3;
-    const tailLower = line.slice(cursor).toLowerCase();
-    let severityLabel;
-    if (tailLower.startsWith("error ")) {
-        severityLabel = "error";
-        cursor += "error ".length;
-    }
-    else if (tailLower.startsWith("warning ")) {
-        severityLabel = "warning";
-        cursor += "warning ".length;
-    }
-    else {
-        return null;
-    }
-    const colon = line.indexOf(":", cursor);
-    if (colon < 0)
-        return null;
-    const rule = line.slice(cursor, colon).trim();
-    if (!isDotnetRuleId(rule))
-        return null;
-    let message = line.slice(colon + 1).trim();
-    if (message.endsWith("]")) {
-        const projectSuffix = message.lastIndexOf(" [");
-        if (projectSuffix >= 0)
-            message = message.slice(0, projectSuffix).trimEnd();
-    }
-    return { reportedFile, lineStr, colStr, severityLabel, rule, message };
-}
-function parseDotnetBuildOutput(raw, filePath, cwd) {
-    const diagnostics = [];
-    const absTarget = path.resolve(cwd, filePath);
-    for (const line of raw.split(/\r?\n/)) {
-        const parsed = parseDotnetDiagnosticLine(line);
-        if (!parsed)
-            continue;
-        const { reportedFile, lineStr, colStr, severityLabel, rule, message } = parsed;
-        // #3278: one seam for reported-path attribution — see javac.ts.
-        if (!pathsEqual(path.resolve(cwd, reportedFile), absTarget))
-            continue;
-        const severity = severityLabel.toLowerCase() === "error" ? "error" : "warning";
-        const lineNum = Number.parseInt(lineStr, 10) || 1;
-        const colNum = Number.parseInt(colStr, 10) || 1;
-        diagnostics.push({
-            id: `dotnet-build-${rule}-${lineNum}-${colNum}`,
-            message: `[${rule}] ${message.trim()}`,
-            filePath,
-            line: lineNum,
-            column: colNum,
-            severity,
-            semantic: severity === "error" ? "blocking" : "warning",
-            tool: "dotnet-build",
-            rule,
-            fixable: false,
-        });
-    }
-    return diagnostics;
-}
-const dotnetBuildRunner = {
-    id: "dotnet-build",
-    appliesTo: ["csharp"],
-    priority: PRIORITY.GENERAL_ANALYSIS,
-    timeoutMs: 90_000,
-    skipTestFiles: false,
-    async run(ctx) {
-        const cwd = resolveRunnerCwd(ctx, "dotnet-build");
-        if (!(await dotnet.isAvailableAsync(cwd))) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        const cmd = dotnet.getCommand(cwd);
-        if (!cmd) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        const target = findProjectTarget(cwd);
-        if (!target) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        const result = await safeSpawnAsync(cmd, ["build", target, "--nologo", "--verbosity", "minimal"], {
-            cwd,
-            timeout: 60000,
-        });
-        const raw = `${result.stdout ?? ""}\n${result.stderr ?? ""}`.trim();
-        const parsed = parseToolRun("dotnet-build", {
-            result,
-            output: raw,
-            // EXIT TABLE (.NET SDK 8 measured fixture): 0 clean; 1 findings; 2 error; other nonzero rejected.
-            exitCodes: { ran: [1, 2] },
-        }, (output) => parseDotnetBuildOutput(output, ctx.filePath, cwd));
-        if (parsed.skipped)
-            return parsed.skipped;
-        return finishParsedRun({
-            tool: "dotnet-build",
-            ctx,
-            result,
-            diagnostics: parsed.diagnostics,
-            classify: (diagnostics) => {
-                const hasErrors = diagnostics.some((d) => d.severity === "error");
-                return {
-                    status: hasErrors ? "failed" : "succeeded",
-                    semantic: hasErrors ? "blocking" : "warning",
-                };
-            },
-        });
-    },
-};
-export default dotnetBuildRunner;

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

@@ -1,195 +0,0 @@
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { getProjectDataDir } from "../../file-utils.js";
-import { pathsEqual } from "../../path-utils.js";
-import { safeSpawnAsync } from "../../safe-spawn.js";
-import { resolveRunnerCwd } from "../../tool-cwd.js";
-import { PRIORITY } from "../priorities.js";
-import { createAvailabilityChecker } from "./utils/runner-helpers.js";
-import { finishParsedRun, parseToolRun } from "./utils/tool-failure.js";
-// Per-cwd cached `--version` probes (#120). Before this, each dispatch
-// invocation fired a fresh `safeSpawnAsync` per command — once per Elixir
-// file save.
-const mix = createAvailabilityChecker("mix", ".bat");
-const elixirc = createAvailabilityChecker("elixirc", ".bat");
-function hasMixExs(cwd) {
-    return fs.existsSync(path.join(cwd, "mix.exs"));
-}
-// Elixir 1.16+ emits diagnostics in a multi-line "code snippet" format where
-// the file:line:col lives on a trailing `└─ path:line:col` line, several lines
-// after the `error:`/`warning:` header:
-//
-//     warning: variable "x" is unused
-//     │
-//   3 │     x = 1
-//     │     ~
-//     │
-//     └─ lib/foo.ex:3:5: Foo.bar/0
-//
-// Older Elixir put the location on the line immediately after `warning:` and
-// reported compile errors as a single `** (Kind) path:line:col: message` line.
-// We support both so the runner works across toolchain versions.
-const ELIXIR_SNIPPET_LOCATION = /└─\s+(.+?):(\d+)(?::(\d+))?(?::|$)/;
-function parseElixirOutput(raw, filePath, cwd = process.cwd()) {
-    const diagnostics = [];
-    const resolvedTarget = path.resolve(cwd, filePath);
-    const lines = raw.split(/\r?\n/);
-    // elixirc reports paths RELATIVE to its cwd (e.g. `bad.ex`, not the absolute
-    // path we passed), so resolve the reported path against the runner cwd — not
-    // process.cwd(). Two resolved spellings of ONE file still differ in ways
-    // only the filesystem can settle — Elixir 1.16+ normalizes to a lowercase
-    // drive letter and forward slashes (`c:/...`), which never string-equals
-    // `C:\...` on Windows — so ask `pathsEqual`, the repo's on-disk identity
-    // seam, instead of hand-rolling a win32 case fold here. It folds case
-    // exactly where the filesystem does and nowhere else, which a
-    // `process.platform` test cannot express; `terragrunt.ts:90` asks the same
-    // question the same way (#1193).
-    const matchesTarget = (sourcePath) => pathsEqual(path.resolve(cwd, sourcePath.trim()), resolvedTarget);
-    for (let index = 0; index < lines.length; index++) {
-        const line = lines[index];
-        // Defense-in-depth: cap line length before regex matching. The input is
-        // trusted, bounded compiler output and the patterns have no exponential
-        // backtracking, but this bounds worst-case work regardless (ReDoS guard).
-        if (line.length > 2000)
-            continue;
-        // Legacy one-line compile error: ** (CompileError) path:line:col: message
-        const syntax = line.match(/^\*\* \(([^)]+)\)\s+(.+?):(\d+):(?:(\d+):)?\s*(.+)$/);
-        if (syntax) {
-            const [, kind, sourcePath, lineStr, colStr, message] = syntax;
-            if (!matchesTarget(sourcePath))
-                continue;
-            diagnostics.push({
-                id: `elixir-check-${kind}-${lineStr}-${colStr || "1"}`,
-                message: `[${kind}] ${message.trim()}`,
-                filePath,
-                line: Number.parseInt(lineStr, 10) || 1,
-                column: Number.parseInt(colStr || "1", 10) || 1,
-                severity: "error",
-                semantic: "blocking",
-                tool: "elixir-check",
-                rule: kind,
-                fixable: false,
-            });
-            continue;
-        }
-        // error:/warning: header — may be bare (legacy) or indented (1.16+).
-        const header = line.match(/^\s*(error|warning):\s+(.+)$/);
-        if (!header)
-            continue;
-        const [, severityLabel, message] = header;
-        const severity = severityLabel === "error" ? "error" : "warning";
-        // New format: scan forward for the `└─ path:line:col` snippet footer.
-        let located = false;
-        for (let lookahead = index + 1; lookahead < lines.length && lookahead <= index + 12; lookahead++) {
-            const next = lines[lookahead];
-            // A blank gap or another header ends this diagnostic block.
-            if (/^\s*(error|warning):\s+/.test(next))
-                break;
-            const snippet = next.match(ELIXIR_SNIPPET_LOCATION);
-            if (snippet) {
-                const [, sourcePath, lineStr, colStr] = snippet;
-                if (matchesTarget(sourcePath)) {
-                    diagnostics.push({
-                        id: `elixir-check-${severity}-${lineStr}-${colStr || "1"}`,
-                        message: severity === "error"
-                            ? `[error] ${message.trim()}`
-                            : message.trim(),
-                        filePath,
-                        line: Number.parseInt(lineStr, 10) || 1,
-                        column: Number.parseInt(colStr || "1", 10) || 1,
-                        severity,
-                        semantic: severity === "error" ? "blocking" : "warning",
-                        tool: "elixir-check",
-                        rule: severity === "error" ? "error" : "warning",
-                        fixable: false,
-                    });
-                }
-                located = true;
-                break;
-            }
-        }
-        if (located)
-            continue;
-        // Legacy format: location on the immediately following line.
-        const location = lines[index + 1]?.match(/^\s+(.+?):(\d+):(?:(\d+):)?$/);
-        if (!location)
-            continue;
-        const [, sourcePath, lineStr, colStr] = location;
-        if (!matchesTarget(sourcePath))
-            continue;
-        diagnostics.push({
-            id: `elixir-check-${severity}-${lineStr}-${colStr || "1"}`,
-            message: severity === "error" ? `[error] ${message.trim()}` : message.trim(),
-            filePath,
-            line: Number.parseInt(lineStr, 10) || 1,
-            column: Number.parseInt(colStr || "1", 10) || 1,
-            severity,
-            semantic: severity === "error" ? "blocking" : "warning",
-            tool: "elixir-check",
-            rule: severity === "error" ? "error" : "warning",
-            fixable: false,
-        });
-    }
-    return diagnostics;
-}
-const elixirCheckRunner = {
-    id: "elixir-check",
-    appliesTo: ["elixir"],
-    priority: PRIORITY.GENERAL_ANALYSIS,
-    skipTestFiles: false,
-    async run(ctx) {
-        const cwd = resolveRunnerCwd(ctx, "elixir-check");
-        const absPath = path.resolve(cwd, ctx.filePath);
-        let command;
-        let args = [];
-        if (hasMixExs(cwd) && (await mix.isAvailableAsync(cwd))) {
-            command = "mix";
-            args = ["compile", "--warnings-as-errors"];
-        }
-        else if (await elixirc.isAvailableAsync(cwd)) {
-            const outDir = path.join(getProjectDataDir(cwd), "elixir-check");
-            fs.mkdirSync(outDir, { recursive: true });
-            command = "elixirc";
-            args = ["-o", outDir, absPath];
-        }
-        if (!command) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        const result = await safeSpawnAsync(command, args, {
-            cwd,
-            timeout: 30000,
-        });
-        const raw = `${result.stderr || ""}\n${result.stdout || ""}`;
-        const hasProjectContext = command === "mix";
-        const parsed = parseToolRun("elixir-check", {
-            result,
-            output: raw,
-            // EXIT TABLE (Elixir 1.16 measured fixture): 0 clean; 1 findings; 2 error; other nonzero rejected.
-            exitCodes: { ran: [1, 2] },
-        }, (out) => parseElixirOutput(out, ctx.filePath, cwd).map((d) => hasProjectContext
-            ? d
-            : {
-                ...d,
-                // A direct elixirc invocation cannot resolve Mix dependencies.
-                // Standalone findings inform the agent, but cannot block it.
-                semantic: "warning",
-            }));
-        if (parsed.skipped)
-            return parsed.skipped;
-        return finishParsedRun({
-            tool: "elixir-check",
-            ctx,
-            result,
-            diagnostics: parsed.diagnostics,
-            classify: (diagnostics) => {
-                const hasBlocking = diagnostics.some((d) => d.semantic === "blocking");
-                return {
-                    status: hasBlocking ? "failed" : "succeeded",
-                    semantic: hasBlocking ? "blocking" : "warning",
-                };
-            },
-        });
-    },
-};
-export default elixirCheckRunner;
-export { parseElixirOutput };

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

@@ -1,137 +0,0 @@
-/**
- * ESLint runner for dispatch system
- *
- * Runs ESLint on JS/TS files when an ESLint config is present in the project.
- * Prefers the local node_modules installation over global.
- *
- * Gate: skips when no ESLint config is detected (project uses Biome/OxLint instead).
- */
-import * as path from "node:path";
-import { pathsEqual } from "../../path-utils.js";
-import { safeSpawnAsync } from "../../safe-spawn.js";
-import { resolveRunnerCwd } from "../../tool-cwd.js";
-import { getAutofixCapability, hasEslintConfig } from "../../tool-policy.js";
-import { PRIORITY } from "../priorities.js";
-import { createCwdCachedProbe, resolveToolCommand, } from "./utils/runner-helpers.js";
-import { finishParsedRun, parseToolRun } from "./utils/tool-failure.js";
-const ESLINT_PROBE_BUDGET_MS = 5000;
-// Per-cwd cached eslint `--version` verification (#120). Before this, every
-// dispatch invocation ran a fresh `safeSpawnAsync(cmd, ["--version"])` after
-// the local cmd resolution. The probe is cached per cwd because
-// `resolveToolCommand("eslint")` is deterministic from cwd; the underlying
-// cmd identity is captured inside the probe closure.
-//
-// The verdict is governed by the shared availability policy (#1494): the probe
-// hands back the spawn result, so one stalled probe on the first JS/TS save
-// expires on a cooldown instead of disabling eslint for the whole session.
-function makeEslintProbe(cmd) {
-    return createCwdCachedProbe((cwd) => safeSpawnAsync(cmd, ["--version"], {
-        timeout: ESLINT_PROBE_BUDGET_MS,
-        cwd,
-    }), {
-        tool: "eslint",
-        budgetMs: ESLINT_PROBE_BUDGET_MS,
-        flightKeyComponent: cmd,
-    });
-}
-const eslintAvailabilityByCmd = new Map();
-function getEslintProbe(cmd) {
-    const existing = eslintAvailabilityByCmd.get(cmd);
-    if (existing)
-        return existing;
-    const created = makeEslintProbe(cmd);
-    eslintAvailabilityByCmd.set(cmd, created);
-    return created;
-}
-function parseEslintJson(raw, filePath, cwd) {
-    try {
-        const results = JSON.parse(raw);
-        const autofix = getAutofixCapability("eslint");
-        const diagnostics = [];
-        const absTarget = path.resolve(cwd, filePath);
-        for (const fileResult of results) {
-            // #3295: flat config `files`/`ignores` and a directory argv both put a
-            // SECOND result in this array; each names its own `filePath`.
-            if (fileResult.filePath &&
-                !pathsEqual(path.resolve(cwd, fileResult.filePath), absTarget))
-                continue;
-            for (const msg of fileResult.messages) {
-                const severity = msg.severity === 2 ? "error" : "warning";
-                diagnostics.push({
-                    id: `eslint:${msg.ruleId ?? "unknown"}:${msg.line}`,
-                    message: msg.ruleId ? `${msg.ruleId}: ${msg.message}` : msg.message,
-                    filePath,
-                    line: msg.line ?? 1,
-                    column: msg.column ?? 1,
-                    severity,
-                    semantic: severity === "error" ? "blocking" : "warning",
-                    tool: "eslint",
-                    rule: msg.ruleId ?? undefined,
-                    fixable: !!msg.fix,
-                    autoFixAvailable: !!msg.fix && (autofix?.safePipelineAutofix ?? false),
-                    fixKind: !!msg.fix && autofix?.fixKind !== "none"
-                        ? autofix?.fixKind
-                        : undefined,
-                });
-            }
-        }
-        return { diagnostics };
-    }
-    catch (err) {
-        return {
-            diagnostics: [],
-            parseError: err instanceof Error ? err.message : String(err),
-        };
-    }
-}
-const eslintRunner = {
-    id: "eslint",
-    appliesTo: ["jsts"],
-    priority: PRIORITY.LINT_SECONDARY,
-    async run(ctx) {
-        const cwd = resolveRunnerCwd(ctx, "eslint");
-        const userHasConfig = hasEslintConfig(cwd);
-        // Only run if project has an ESLint config.
-        if (!userHasConfig) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        const cmd = resolveToolCommand(cwd, "eslint") ?? "eslint";
-        // Verify ESLint is actually executable (cached per cwd, see getEslintProbe).
-        if (!(await getEslintProbe(cmd)(cwd))) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        const result = await safeSpawnAsync(cmd, ["--format", "json", "--no-error-on-unmatched-pattern", ctx.filePath], { timeout: 30000, cwd });
-        // Exit table: 0 is clean-or-findings, and 1/2 are ran outcomes whose
-        // JSON parser decides whether findings or a parse/config error reached the
-        // user. In particular, status 2 carries file-local fatal parse messages
-        // as JSON and must not be discarded before parsing.
-        //
-        // 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 = parseToolRun("eslint", {
-            result,
-            output: raw,
-            // EXIT TABLE (ESLint 9.10 docs https://eslint.org/docs/latest/use/command-line-interface): 0 clean; 1 findings; 2 fatal findings/error; other nonzero rejected.
-            exitCodes: { ran: [1, 2] },
-        }, (rawOutput) => parseEslintJson(rawOutput, ctx.filePath, cwd).diagnostics);
-        if (parsed.skipped)
-            return parsed.skipped;
-        return finishParsedRun({
-            tool: "eslint",
-            ctx,
-            result,
-            diagnostics: parsed.diagnostics,
-        });
-    },
-};
-export default eslintRunner;