pi-lens 4.2.1 → 4.4.0

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

@@ -1,154 +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 { 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";
-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) {
-    try {
-        const results = JSON.parse(raw);
-        const autofix = getAutofixCapability("eslint");
-        const diagnostics = [];
-        for (const fileResult of results) {
-            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 });
-        // 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" };
-        }
-        // 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) {
-            const preview = raw.replace(/\s+/g, " ").slice(0, 160);
-            return {
-                status: "failed",
-                diagnostics: [
-                    {
-                        id: "eslint:parse-error:1",
-                        message: "ESLint JSON parse failed: " +
-                            parsed.parseError +
-                            (preview ? " (output preview: " + preview + ")" : ""),
-                        filePath: ctx.filePath,
-                        line: 1,
-                        column: 1,
-                        severity: "warning",
-                        semantic: "warning",
-                        tool: "eslint",
-                    },
-                ],
-                semantic: "warning",
-            };
-        }
-        const diagnostics = parsed.diagnostics;
-        if (diagnostics.length === 0) {
-            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: !hasErrors && result.status === 0 ? "succeeded" : "failed",
-            diagnostics,
-            semantic: hasErrors ? "blocking" : "warning",
-        };
-    },
-};
-export default eslintRunner;

package/dist/clients/dispatch/runners/fact-rules.js

@@ -1,29 +0,0 @@
-/**
- * Fact-rules runner — executes all registered FactRule instances against
- * the populated fact store. Each FactRule has its own appliesTo() guard
- * so this runner can be registered broadly; rules self-select.
- *
- * Severity semantics follow each rule's own diagnostic output.
- * Blocking rules surface on every write; warning-tier rules surface
- * only during full scans (blockingOnly === false).
- */
-import { PRIORITY } from "../priorities.js";
-import { evaluateRules } from "../fact-rule-runner.js";
-const factRulesRunner = {
-    id: "fact-rules",
-    appliesTo: ["jsts", "python", "go", "rust", "ruby", "shell", "cmake"],
-    priority: PRIORITY.GENERAL_ANALYSIS + 1,
-    async run(ctx) {
-        const diagnostics = evaluateRules(ctx);
-        if (diagnostics.length === 0) {
-            return { status: "succeeded", diagnostics: [], semantic: "none" };
-        }
-        const hasBlocking = diagnostics.some((d) => d.semantic === "blocking" || d.severity === "error");
-        return {
-            status: hasBlocking ? "failed" : "succeeded",
-            diagnostics,
-            semantic: hasBlocking ? "blocking" : "warning",
-        };
-    },
-};
-export default factRulesRunner;

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

@@ -1,69 +0,0 @@
-import { safeSpawnAsync } from "../../safe-spawn.js";
-import { resolveRunnerCwd } from "../../tool-cwd.js";
-import { PRIORITY } from "../priorities.js";
-import { createAvailabilityChecker } from "./utils/runner-helpers.js";
-// fish_indent ships with fish — not separately installable, no managed fallback
-const fishIndent = createAvailabilityChecker("fish_indent");
-const fishIndentRunner = {
-    id: "fish-indent",
-    appliesTo: ["fish"],
-    priority: PRIORITY.FORMAT_AND_LINT_PRIMARY,
-    skipTestFiles: false,
-    async run(ctx) {
-        const cwd = resolveRunnerCwd(ctx, "fish-indent");
-        const available = await fishIndent.isAvailableAsync(cwd);
-        if (!available)
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        const cmd = fishIndent.getCommand(cwd);
-        if (!cmd)
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        // --check: exits 0 if already formatted, 1 if reformatting would change the file
-        const result = await safeSpawnAsync(cmd, ["--check", ctx.filePath], {
-            timeout: 10000,
-            cwd,
-        });
-        if (result.status === 0) {
-            return { status: "succeeded", diagnostics: [], semantic: "none" };
-        }
-        // Non-zero exit: either needs formatting or a parse error was reported on stderr
-        const stderrLine = (result.stderr ?? "").split("\n").find((l) => l.trim());
-        if (stderrLine) {
-            // Parse/syntax error — extract line number from "filename (line N): message" if present
-            const lineMatch = stderrLine.match(/\(line\s+(\d+)\)/);
-            const line = lineMatch ? Number(lineMatch[1]) : 1;
-            const diagnostics = [
-                {
-                    id: `fish-indent-parse-${ctx.filePath}`,
-                    message: `fish_indent: ${stderrLine.trim()}`,
-                    filePath: ctx.filePath,
-                    line,
-                    column: 1,
-                    severity: "error",
-                    semantic: "blocking",
-                    tool: "fish-indent",
-                    rule: "fish-indent-parse-error",
-                },
-            ];
-            return { status: "failed", diagnostics, semantic: "blocking" };
-        }
-        // Clean stderr — file just needs formatting
-        const diagnostics = [
-            {
-                id: `fish-indent-format-${ctx.filePath}`,
-                message: "Fish script is not formatted — run `fish_indent -w` to fix",
-                filePath: ctx.filePath,
-                line: 1,
-                column: 1,
-                severity: "warning",
-                semantic: "warning",
-                tool: "fish-indent",
-                rule: "fish-indent-unformatted",
-                fixable: true,
-                autoFixAvailable: false,
-                fixKind: "manual",
-            },
-        ];
-        return { status: "succeeded", diagnostics, semantic: "warning" };
-    },
-};
-export default fishIndentRunner;

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

@@ -1,87 +0,0 @@
-import { safeSpawnAsync } from "../../safe-spawn.js";
-import { resolveRunnerCwd } from "../../tool-cwd.js";
-import { createAvailabilityChecker } from "./utils/runner-helpers.js";
-import { PRIORITY } from "../priorities.js";
-const gleam = createAvailabilityChecker("gleam", ".exe");
-function parseGleamOutput(raw, filePath) {
-    const diagnostics = [];
-    const lines = raw.split(/\r?\n/);
-    for (let i = 0; i < lines.length; i++) {
-        const location = lines[i].match(/^(.+?):(\d+):(\d+)$/);
-        if (!location)
-            continue;
-        const [, sourcePath, lineStr, colStr] = location;
-        if (!sourcePath.replace(/\\/g, "/").endsWith(filePath.replace(/\\/g, "/"))) {
-            continue;
-        }
-        const message = lines.slice(i + 1).find((line) => line.trim().length > 0);
-        diagnostics.push({
-            id: `gleam-check-${lineStr}-${colStr}`,
-            message: message?.trim() || "gleam check reported an error",
-            filePath,
-            line: Number.parseInt(lineStr, 10) || 1,
-            column: Number.parseInt(colStr, 10) || 1,
-            severity: "error",
-            semantic: "blocking",
-            tool: "gleam",
-            rule: "gleam-check",
-            fixable: false,
-        });
-    }
-    return diagnostics;
-}
-function firstOutputLine(result) {
-    return `${result.stderr || ""}\n${result.stdout || ""}`
-        .trim()
-        .split(/\r?\n/, 1)[0]
-        .slice(0, 200);
-}
-const gleamCheckRunner = {
-    id: "gleam-check",
-    appliesTo: ["gleam"],
-    priority: PRIORITY.GENERAL_ANALYSIS,
-    skipTestFiles: false,
-    async run(ctx) {
-        const cwd = resolveRunnerCwd(ctx, "gleam-check");
-        if (!(await gleam.isAvailableAsync(cwd))) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        const cmd = gleam.getCommand(cwd);
-        const result = await safeSpawnAsync(cmd, ["check"], {
-            cwd,
-            timeout: 30000,
-        });
-        if (result.error && !result.stdout && !result.stderr) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        const diagnostics = parseGleamOutput(`${result.stderr || ""}\n${result.stdout || ""}`, ctx.filePath);
-        if (diagnostics.length === 0) {
-            if (result.status && result.status !== 0) {
-                return {
-                    status: "failed",
-                    diagnostics: [
-                        {
-                            id: "gleam-check-nonzero-no-diagnostics",
-                            message: firstOutputLine(result) ||
-                                "gleam check exited non-zero without structured diagnostics",
-                            filePath: ctx.filePath,
-                            severity: "error",
-                            semantic: "blocking",
-                            tool: "gleam",
-                            rule: "gleam-check",
-                            fixable: false,
-                        },
-                    ],
-                    semantic: "blocking",
-                };
-            }
-            return { status: "succeeded", diagnostics: [], semantic: "none" };
-        }
-        return {
-            status: "failed",
-            diagnostics,
-            semantic: "blocking",
-        };
-    },
-};
-export default gleamCheckRunner;

package/dist/clients/dispatch/runners/go-vet.js

@@ -1,90 +0,0 @@
-/**
- * Go vet runner for dispatch system
- *
- * Runs `go vet` for Go files to catch common mistakes.
- */
-import { relative, resolve, sep, posix } from "node:path";
-import { goClient } from "../../go-client.js";
-import { safeSpawnAsync } from "../../safe-spawn.js";
-import { resolveRunnerCwd } from "../../tool-cwd.js";
-import { stripAnsi } from "../../sanitize.js";
-import { skipUnlessToolRan } from "./utils/tool-failure.js";
-import { parseGoVetOutput } from "./utils/diagnostic-parsers.js";
-import { PRIORITY } from "../priorities.js";
-const goVetRunner = {
-    id: "go-vet",
-    appliesTo: ["go"],
-    priority: PRIORITY.SPECIALIZED_ANALYSIS,
-    timeoutMs: 40_000,
-    async run(ctx) {
-        // Resolve go path using platform-aware lookup (handles system install paths on Windows)
-        const goExe = await goClient.findGoPathAsync();
-        if (!goExe) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        // Vet the package containing the file from the module root.
-        //
-        // `go vet <one-file.go>` compiles that file in isolation, so same-package
-        // symbols defined in sibling files read as false `undefined: X`, and when
-        // the spawn cwd is outside the module the run also reports
-        // `go.mod file not found` (#263). ctx.cwd is the go.mod module root
-        // (resolveLanguageRootForFile, markers ["go.mod"]), so vet the file's
-        // package from there.
-        const cwd = resolveRunnerCwd(ctx, "go-vet");
-        const fileRel = relative(cwd, ctx.filePath).split(sep).join(posix.sep);
-        const pkgPath = fileRel.startsWith("../")
-            ? // File isn't under ctx.cwd (unexpected — ctx.cwd is the go.mod root).
-                // Vet the root package as a safe fallback rather than emit `./../x`;
-                // the filename filter below still prevents mis-attribution.
-                "."
-            : fileRel.includes("/")
-                ? "./" + fileRel.slice(0, fileRel.lastIndexOf("/"))
-                : ".";
-        const result = await safeSpawnAsync(goExe, ["vet", pkgPath], {
-            timeout: 30000,
-            cwd,
-        });
-        const raw = stripAnsi(result.stdout + result.stderr);
-        // #1816: `go vet` exits nonzero both for "found problems" and for a
-        // toolchain failure it never got past — `go.mod file not found in
-        // current directory or any parent directory` is the one that bit us
-        // (#263). That prose carries no `file:line:col:` prefix, so it parsed to
-        // zero diagnostics and the file was reported CLEAN by a vet that never
-        // ran. The exit code cannot separate the two cases; the presence of a
-        // parsable diagnostic line can, so that is what the gate is handed.
-        const parsableLines = raw
-            .split("\n")
-            .filter((line) => /^.+?:\d+:\d+:/.test(line))
-            .join("\n");
-        const skipped = skipUnlessToolRan("go-vet", {
-            result,
-            output: parsableLines,
-        });
-        if (skipped)
-            return skipped;
-        if (result.status === 0 && !raw.trim()) {
-            return { status: "succeeded", diagnostics: [], semantic: "none" };
-        }
-        // createLineParser ignores the output filename and attributes every
-        // diagnostic to ctx.filePath, so keep only this file's lines — package
-        // vetting reports siblings too. Resolve each output path against the vet
-        // cwd before comparing, so go's path FORM (a leading `./` for the
-        // module-root package, an absolute path, `.` segments) can't cause the
-        // edited file's OWN diagnostics to be silently dropped.
-        const absTarget = resolve(ctx.filePath);
-        const relevant = raw
-            .split("\n")
-            .filter((line) => {
-            const m = line.match(/^(.+?):(\d+):(\d+):\s*(.+)/);
-            return m != null && resolve(cwd, m[1].trim()) === absTarget;
-        })
-            .join("\n");
-        const diagnostics = parseGoVetOutput(relevant, ctx.filePath);
-        // Edited file clean → succeeded: a sibling-file error no longer flags
-        // the edited file's turn (it surfaces when that file is itself edited).
-        return diagnostics.length > 0
-            ? { status: "failed", diagnostics, semantic: "warning" }
-            : { status: "succeeded", diagnostics: [], semantic: "none" };
-    },
-};
-export default goVetRunner;

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

@@ -1,120 +0,0 @@
-/**
- * golangci-lint runner for dispatch system
- *
- * Runs golangci-lint when a .golangci.yml config is present.
- * golangci-lint is the standard meta-linter for Go projects — it runs
- * staticcheck, errcheck, gosimple, and many others in one pass.
- *
- * Gate: skips when no .golangci.yml/.golangci.yaml config is found (project
- * relies on go-vet only). This avoids noisy default-rule runs on projects
- * that haven't opted in.
- */
-import * as path from "node:path";
-import { safeSpawnAsync } from "../../safe-spawn.js";
-import { resolveRunnerCwd } from "../../tool-cwd.js";
-import { getLinterPolicyForCwd, hasGolangciConfig } from "../../tool-policy.js";
-import { PRIORITY } from "../priorities.js";
-import { createAvailabilityChecker, resolveAvailableOrInstall, } from "./utils/runner-helpers.js";
-const golangci = createAvailabilityChecker("golangci-lint", ".exe");
-/**
- * Summarize a golangci-lint Replacement into a single-line fixSuggestion.
- * Prefers the Inline rewrite (precise + short) over multi-line block
- * replacements, and reports a delete-only fix when there's no new content.
- * Returns undefined when there is no Replacement attached.
- */
-function describeReplacement(replacement) {
-    if (!replacement)
-        return undefined;
-    if (replacement.Inline?.NewString !== undefined) {
-        return `Replace with: ${replacement.Inline.NewString}`;
-    }
-    if (replacement.NeedOnlyDelete)
-        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)`
-            : "";
-        return `Replace with: ${preview}${hint}`;
-    }
-    return "Apply golangci-lint suggested fix";
-}
-function parseGolangciJson(raw, filePath) {
-    try {
-        const output = JSON.parse(raw);
-        if (!output.Issues)
-            return [];
-        const absFile = path.resolve(filePath);
-        return output.Issues.filter((issue) => path.resolve(issue.Pos.Filename) === absFile).map((issue) => {
-            const severity = issue.Severity === "error" ? "error" : "warning";
-            // golangci-lint's --out-format=json emits a Replacement object per
-            // issue when `golangci-lint run --fix` would deterministically
-            // rewrite the code. Mirror the rust-clippy structured-output path
-            // (commit 221b34d): propagate the field to fixable / fixSuggestion
-            // so the diagnostic routes through actionable-warnings.
-            const fixSuggestion = describeReplacement(issue.Replacement);
-            return {
-                id: `golangci:${issue.FromLinter}:${issue.Pos.Line}`,
-                message: `${issue.FromLinter}: ${issue.Text}`,
-                filePath,
-                line: issue.Pos.Line,
-                column: issue.Pos.Column,
-                severity,
-                semantic: severity === "error" ? "blocking" : "warning",
-                tool: "golangci-lint",
-                rule: issue.FromLinter,
-                defectClass: "correctness",
-                fixable: Boolean(issue.Replacement),
-                fixSuggestion,
-            };
-        });
-    }
-    catch {
-        return [];
-    }
-}
-// Exported for the parser unit tests (#112 golangci-lint slice).
-export { parseGolangciJson };
-const golangciRunner = {
-    id: "golangci-lint",
-    appliesTo: ["go"],
-    priority: PRIORITY.GENERAL_ANALYSIS,
-    timeoutMs: 90_000,
-    async run(ctx) {
-        const cwd = resolveRunnerCwd(ctx, "golangci-lint");
-        const policy = getLinterPolicyForCwd(ctx.filePath, cwd);
-        if (policy && !policy.preferredRunners.includes("golangci-lint")) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        // Only run if project has opted in via config file
-        if (!hasGolangciConfig(cwd)) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        const cmd = await resolveAvailableOrInstall(golangci, "golangci-lint", cwd);
-        if (!cmd)
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        // Run on the specific file. golangci-lint accepts file paths directly.
-        const result = await safeSpawnAsync(cmd, ["run", "--out-format=json", ctx.filePath], { timeout: 60000, cwd });
-        if (result.status === 0) {
-            return { status: "succeeded", diagnostics: [], semantic: "none" };
-        }
-        const diagnostics = parseGolangciJson(result.stdout, ctx.filePath);
-        let semantic = "none";
-        if (diagnostics.some((d) => d.semantic === "blocking")) {
-            semantic = "blocking";
-        }
-        else if (diagnostics.length > 0) {
-            semantic = "warning";
-        }
-        if (semantic === "none") {
-            // Non-zero exit but no parseable issues — likely a config/tool error
-            return { status: "skipped", diagnostics: [], semantic };
-        }
-        return {
-            status: semantic === "blocking" ? "failed" : "succeeded",
-            diagnostics,
-            semantic,
-        };
-    },
-};
-export default golangciRunner;

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

@@ -1,79 +0,0 @@
-import * as path from "node:path";
-import { safeSpawnAsync } from "../../safe-spawn.js";
-import { resolveRunnerCwd } from "../../tool-cwd.js";
-import { getLinterPolicyForCwd } from "../../tool-policy.js";
-import { PRIORITY } from "../priorities.js";
-import { createAvailabilityChecker, resolveToolCommandWithInstallFallback, } from "./utils/runner-helpers.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 {
-        const parsed = JSON.parse(raw);
-        if (!Array.isArray(parsed))
-            return [];
-        return parsed.map((item) => {
-            const severity = item.level === "error" ? "error" : "warning";
-            return {
-                id: `hadolint-${item.code}-${item.line}`,
-                message: `[${item.code}] ${item.message}`,
-                filePath,
-                line: item.line,
-                column: item.column ?? 1,
-                severity,
-                semantic: severity === "error" ? "blocking" : "warning",
-                tool: "hadolint",
-                rule: item.code,
-                fixable: false,
-            };
-        });
-    }
-    catch {
-        return [];
-    }
-}
-const hadolintRunner = {
-    id: "hadolint",
-    appliesTo: ["docker"],
-    priority: PRIORITY.GENERAL_ANALYSIS,
-    skipTestFiles: false,
-    async run(ctx) {
-        const cwd = resolveRunnerCwd(ctx, "hadolint");
-        const policy = getLinterPolicyForCwd(ctx.filePath, cwd);
-        if (policy && !policy.preferredRunners.includes("hadolint")) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        let cmd = null;
-        if (await hadolint.isAvailableAsync(cwd)) {
-            cmd = hadolint.getCommand(cwd);
-        }
-        else {
-            cmd = await resolveToolCommandWithInstallFallback(cwd, "hadolint");
-        }
-        if (!cmd) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        const result = await safeSpawnAsync(cmd, ["--format", "json", "--no-fail", path.resolve(cwd, ctx.filePath)], { cwd });
-        // #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,
-            classify: (diagnostics) => {
-                const hasErrors = diagnostics.some((d) => d.severity === "error");
-                return {
-                    status: "failed",
-                    semantic: hasErrors ? "blocking" : "warning",
-                };
-            },
-        });
-    },
-};
-export default hadolintRunner;