pi-lens 4.3.0 → 4.4.1

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

@@ -1,99 +0,0 @@
-/**
- * RuboCop runner for dispatch system
- *
- * Runs rubocop in lint-only mode (no auto-correct) on Ruby files.
- * Auto-correct is handled by the formatter pipeline — this runner
- * only reports remaining offenses after formatting.
- *
- * Supports bundle exec (preferred in Bundler projects).
- */
-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, getLinterPolicyForCwd, getRubocopCommand, } from "../../tool-policy.js";
-import { PRIORITY } from "../priorities.js";
-import { resolveCommandArgsWithInstallFallback } from "./utils/runner-helpers.js";
-import { finishParsedRun, parseToolRun } from "./utils/tool-failure.js";
-const SEVERITY_MAP = {
-    fatal: "error",
-    error: "error",
-    warning: "warning",
-    convention: "warning",
-    refactor: "info",
-};
-function parseRubocopJson(raw, filePath, cwd) {
-    try {
-        const output = JSON.parse(raw);
-        const autofix = getAutofixCapability("rubocop");
-        const diagnostics = [];
-        const absTarget = path.resolve(cwd, filePath);
-        for (const file of output.files) {
-            // #3295: `.rubocop.yml` `Include:`/`inherit_from` can widen the run past
-            // the argv, and each result carries its own `path`.
-            if (file.path && !pathsEqual(path.resolve(cwd, file.path), absTarget))
-                continue;
-            for (const offense of file.offenses) {
-                const severity = SEVERITY_MAP[offense.severity] ?? "warning";
-                diagnostics.push({
-                    id: `rubocop:${offense.cop_name}:${offense.location.line}`,
-                    message: `${offense.cop_name}: ${offense.message}`,
-                    filePath,
-                    line: offense.location.line,
-                    column: offense.location.column,
-                    severity,
-                    semantic: severity === "error" ? "blocking" : "warning",
-                    tool: "rubocop",
-                    rule: offense.cop_name,
-                    fixable: offense.correctable,
-                    autoFixAvailable: offense.correctable && (autofix?.safePipelineAutofix ?? false),
-                    fixKind: offense.correctable && autofix?.fixKind !== "none"
-                        ? autofix?.fixKind
-                        : undefined,
-                });
-            }
-        }
-        return diagnostics;
-    }
-    catch {
-        return [];
-    }
-}
-const rubocopRunner = {
-    id: "rubocop",
-    appliesTo: ["ruby"],
-    priority: PRIORITY.FORMAT_AND_LINT_PRIMARY,
-    async run(ctx) {
-        const cwd = resolveRunnerCwd(ctx, "rubocop");
-        const policy = getLinterPolicyForCwd(ctx.filePath, cwd);
-        if (policy && !policy.preferredRunners.includes("rubocop")) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        const resolved = await resolveCommandArgsWithInstallFallback(getRubocopCommand(cwd), "rubocop", cwd, ["--version"], 10000);
-        if (!resolved) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        const { cmd, args } = resolved;
-        // Lint only — no auto-correct (formatter handles that)
-        const result = await safeSpawnAsync(cmd, [...args, "--format", "json", "--no-color", ctx.filePath], { timeout: 30000, cwd });
-        // EXIT TABLE (RuboCop 1.66 docs https://docs.rubocop.org/rubocop/usage/basic_usage.html): 0 = clean, 1 = offenses/findings, 2 = fatal/error or rejected
-        // invocation. A nonzero exit with valid JSON remains findings; a nonzero
-        // exit with empty or unparsable JSON is never clean (#1816).
-        const run = parseToolRun("rubocop", {
-            result,
-            // Classify both streams so stderr-only failures reach the parse-error
-            // path, while parseOutput keeps RuboCop's native JSON parser on stdout.
-            output: `${result.stdout}${result.stderr}`,
-            exitCodes: { ran: [1, 2] },
-        }, (output) => parseRubocopJson(output, ctx.filePath, cwd), { parseOutput: result.stdout });
-        if (run.skipped)
-            return run.skipped;
-        return finishParsedRun({
-            tool: "rubocop",
-            ctx,
-            result,
-            diagnostics: run.diagnostics,
-        });
-    },
-};
-export default rubocopRunner;

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

@@ -1,88 +0,0 @@
-/**
- * Ruff runner for dispatch system
- *
- * Dispatch mode is diagnostics-only.
- * Autofix is handled earlier by the post-write pipeline to avoid
- * mutating files mid-dispatch after LSP sync has already happened.
- * Supports venv-local installations.
- */
-import { safeSpawnAsync } from "../../safe-spawn.js";
-import { stripAnsi } from "../../sanitize.js";
-import { getAutofixCapability, getLinterPolicyForCwd, ruffConfigArgs, } from "../../tool-policy.js";
-import { PRIORITY } from "../priorities.js";
-import { finishParsedRun, parseToolRun } from "./utils/tool-failure.js";
-import { parseRuffOutput } from "./utils/diagnostic-parsers.js";
-import { createAvailabilityChecker, resolveAvailableOrInstall, resolveRunnerCwd, } from "./utils/runner-helpers.js";
-const ruff = createAvailabilityChecker("ruff", ".exe");
-function parseRuffJson(raw, filePath) {
-    try {
-        const parsed = JSON.parse(raw);
-        if (!Array.isArray(parsed))
-            return [];
-        const autofix = getAutofixCapability("ruff");
-        return parsed.map((item, index) => {
-            const severity = item.severity === "error" ? "error" : "warning";
-            const code = item.code || "ruff";
-            const toolFixable = Boolean(item.fix);
-            return {
-                id: `ruff-${code}-${item.location?.row ?? index + 1}`,
-                message: item.message || code,
-                filePath: item.filename || filePath,
-                line: item.location?.row ?? 1,
-                column: item.location?.column ?? 1,
-                severity,
-                semantic: severity === "error" ? "blocking" : "warning",
-                tool: "ruff",
-                rule: code,
-                fixable: toolFixable,
-                autoFixAvailable: toolFixable && (autofix?.safePipelineAutofix ?? false),
-                fixKind: toolFixable && autofix?.fixKind !== "none"
-                    ? autofix?.fixKind
-                    : undefined,
-            };
-        });
-    }
-    catch {
-        return [];
-    }
-}
-const ruffRunner = {
-    id: "ruff-lint",
-    appliesTo: ["python"],
-    priority: PRIORITY.FORMAT_AND_LINT_PRIMARY,
-    async run(ctx) {
-        const cwd = resolveRunnerCwd(ctx, "ruff");
-        const policy = getLinterPolicyForCwd(ctx.filePath, cwd);
-        if (policy && !policy.preferredRunners.includes("ruff-lint")) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        const cmd = await resolveAvailableOrInstall(ruff, "ruff", cwd);
-        if (!cmd) {
-            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 = ruffConfigArgs(cwd);
-        // Step 1: Capture diagnostics (before fixing) — teaching signal for the agent
-        const checkResult = await safeSpawnAsync(cmd, ["check", "--output-format", "json", ...configArgs, ctx.filePath], { cwd, timeout: 30000 });
-        const raw = stripAnsi(checkResult.stdout + checkResult.stderr);
-        // EXIT TABLE (Ruff 0.6 docs https://docs.astral.sh/ruff/linter/): 0 = clean, 1 = findings, 2 = findings/error or
-        // tool error. A nonzero exit with valid findings stays findings; empty or
-        // unparsable output must never become clean (#1816).
-        const run = parseToolRun("ruff", { result: checkResult, output: raw, exitCodes: { ran: [1, 2] } }, (output) => {
-            const diagnostics = parseRuffJson(output, ctx.filePath);
-            return diagnostics.length > 0
-                ? diagnostics
-                : parseRuffOutput(output, ctx.filePath, cwd);
-        });
-        if (run.skipped)
-            return run.skipped;
-        return finishParsedRun({
-            tool: "ruff",
-            ctx,
-            result: checkResult,
-            diagnostics: run.diagnostics,
-        });
-    },
-};
-export default ruffRunner;

package/dist/clients/dispatch/runners/rust-clippy.js

@@ -1,256 +0,0 @@
-/**
- * Rust clippy runner for dispatch system
- *
- * Runs `cargo clippy` for Rust files to catch common mistakes.
- */
-import { isAbsolute, resolve } from "node:path";
-import { pathsEqual } from "../../path-utils.js";
-import { rustClient } from "../../rust-client.js";
-import { safeSpawnAsync } from "../../safe-spawn.js";
-import { stripAnsi } from "../../sanitize.js";
-import { getLazyInstallAttempt, tryLazyInstall, } from "./utils/lazy-installer.js";
-import { describeInstallAttempt, logAvailabilityDecision, } from "./utils/availability-policy.js";
-import { PRIORITY } from "../priorities.js";
-import { resolveRunnerCwdWithReason } from "../../tool-cwd.js";
-import { createCwdCachedProbe } from "./utils/runner-helpers.js";
-// Cached per-cwd `cargo clippy --version` probe (#120). Before this, the
-// probe fired on every Rust file save in a project where clippy was already
-// installed.
-//
-// `tryLazyInstall("rust-clippy", cwd)` mutates installed state, so on a
-// false initial result the runner needs a way to bust the cache and re-probe
-// after install. We can't `delete` a Promise mid-flight, so the safe path
-// is: if the cached probe resolves false AND the install just succeeded,
-// fall back to a one-shot fresh probe rather than reusing the cached false.
-//
-// The verdict is governed by the shared availability policy (#1494): a probe
-// timeout expires on a cooldown, so only a genuinely absent clippy latches.
-const CLIPPY_PROBE_BUDGET_MS = 8000;
-let clippyProbeRevision = 0;
-const makeClippyProbe = (cargoExe, flightKeyComponent = cargoExe) => createCwdCachedProbe((cwd) => safeSpawnAsync(cargoExe, ["clippy", "--version"], {
-    timeout: CLIPPY_PROBE_BUDGET_MS,
-    cwd,
-}), {
-    tool: "clippy",
-    budgetMs: CLIPPY_PROBE_BUDGET_MS,
-    flightKeyComponent,
-});
-const clippyAvailabilityByCargo = new Map();
-function getClippyProbe(cargoExe) {
-    return (clippyAvailabilityByCargo.get(cargoExe) ?? refreshClippyProbe(cargoExe));
-}
-/** Replace the cached probe so a post-install state is observed. */
-function refreshClippyProbe(cargoExe) {
-    const created = makeClippyProbe(cargoExe, `${cargoExe}#refresh-${++clippyProbeRevision}`);
-    clippyAvailabilityByCargo.set(cargoExe, created);
-    return created;
-}
-const rustClippyRunner = {
-    id: "rust-clippy",
-    appliesTo: ["rust"],
-    priority: PRIORITY.SPECIALIZED_ANALYSIS,
-    timeoutMs: 90_000,
-    async run(ctx) {
-        // Resolve cargo path using platform-aware lookup (handles ~/.cargo/bin on Windows)
-        const cargoExe = await rustClient.findCargoPathAsync();
-        if (!cargoExe) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        const clippyProbe = getClippyProbe(cargoExe);
-        if (!(await clippyProbe(ctx.cwd))) {
-            // A timed-out probe is not evidence that clippy is missing, so it must
-            // not drive an install. Skip this turn and let the policy re-probe once
-            // its cooldown expires (#1494).
-            if (clippyProbe.getVerdict(ctx.cwd).outcome === "transient") {
-                return { status: "skipped", diagnostics: [], semantic: "none" };
-            }
-            await tryLazyInstall("rust-clippy", ctx.cwd);
-            // Bust the cwd-keyed cache so the post-install state is observed. Held in
-            // a local: `refreshClippyProbe` REPLACES the cached probe, so calling it
-            // again to read the verdict would spend a second probe.
-            const refreshedProbe = refreshClippyProbe(cargoExe);
-            if (!(await refreshedProbe(ctx.cwd))) {
-                // #1537: clippy is still absent, and the interesting question is WHY —
-                // "we tried `rustup component add` and the network failed" is a
-                // different fact from "this machine has no rustup", and until now the
-                // lazy installers recorded neither. Put the attempt beside the verdict
-                // it produced (#1500), so a reader does not have to infer the install
-                // from a runner that silently skipped.
-                const verdict = refreshedProbe.getVerdict(ctx.cwd);
-                logAvailabilityDecision({
-                    tool: "rust-clippy",
-                    verdict: "unavailable",
-                    outcome: verdict.outcome ?? "missing",
-                    cause: verdict.cause ?? "not-found",
-                    classifiedBy: "caller",
-                    evidence: describeInstallAttempt(getLazyInstallAttempt("rust-clippy", ctx.cwd)),
-                    elapsedMs: 0,
-                    latched: false,
-                });
-                return { status: "skipped", diagnostics: [], semantic: "none" };
-            }
-        }
-        // The package root (where Cargo.toml is), through the shared cwd seam
-        // (#2894): the shared language marker vocabulary includes `Cargo.toml`, so
-        // this IS the walk this runner used to do with `findNearestContaining` — plus
-        // the seam's dispatch-root and `$HOME` ceilings, which the hand-rolled
-        // walk had neither of. The gate then asks about exactly the directory
-        // cargo will run in, rather than about a separately-derived one.
-        const cargoResolution = resolveRunnerCwdWithReason(ctx, "rust-clippy");
-        const cargoDir = cargoResolution.cwd;
-        if (cargoResolution.marker !== "Cargo.toml") {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        // Run cargo clippy on the package
-        const result = await safeSpawnAsync(cargoExe, ["clippy", "--message-format=json", "-q"], {
-            timeout: 60000,
-            cwd: cargoDir,
-        });
-        const raw = stripAnsi(result.stdout + result.stderr);
-        if (result.status === 0 && !raw.trim()) {
-            return { status: "succeeded", diagnostics: [], semantic: "none" };
-        }
-        // Parse JSON output. span.file is relative to the package root, so pass
-        // the cargo dir to resolve diagnostics to absolute paths for filtering.
-        const allDiagnostics = parseClippyOutput(raw, ctx.filePath, cargoDir);
-        if (allDiagnostics.length === 0) {
-            // Non-parseable output
-            return {
-                status: "failed",
-                diagnostics: [],
-                semantic: "warning",
-                rawOutput: raw.substring(0, 500),
-            };
-        }
-        // Lint-style policy (#265 B1): `cargo clippy` compiles the whole crate, so
-        // a crate-mate's pre-existing diagnostic must NOT fail the edited file's
-        // turn. Filter to the edited file like golangci-lint — if the edited file
-        // is clean, this turn succeeds even when siblings carry warnings/errors.
-        // #3278: one seam for reported-path attribution — see javac.ts. This
-        // member already had the right BASE (`parseClippyOutput` resolves
-        // `span.file` against `cargoDir`); what it lacked was the on-disk
-        // identity predicate.
-        const absEdited = resolve(ctx.filePath);
-        const diagnostics = allDiagnostics.filter((d) => pathsEqual(resolve(cargoDir, d.filePath), absEdited));
-        const hasErrors = diagnostics.some((d) => d.semantic === "blocking");
-        return {
-            status: hasErrors ? "failed" : "succeeded",
-            diagnostics,
-            semantic: hasErrors
-                ? "blocking"
-                : diagnostics.length > 0
-                    ? "warning"
-                    : "none",
-        };
-    },
-};
-/**
- * #1802 fix round: the original review claimed rustc/clippy's top-level
- * `compiler-message.level` is genuinely two-valued (error/warning). A live
- * `cargo clippy --message-format=json` repro falsified that: rustc_errors's
- * `Level` serializes SIX values, and top-level messages with a real primary
- * span are NOT limited to error/warning —
- *
- *   - `"error"` — a hard compiler/lint error.
- *   - `"warning"` — the common clippy-lint case.
- *   - `"note"` — DOES appear as a top-level message with a non-empty primary
- *     span (repro: an erroneous-constant note pointing at the offending
- *     expression), not only as a `message.children[].level` annotation.
- *   - `"help"` — a top-level suggestion-carrying message.
- *   - `"failure-note"` — observed with an empty `spans` array, so it is
- *     already filtered out by the `if (!span) continue` guard below; no
- *     diagnostic is ever built from it. Verified, not assumed.
- *   - `"error: internal compiler error"` — an ICE. The old `level === "error"`
- *     exact-match ternary silently mapped this to `"warning"`, because the
- *     string doesn't equal `"error"` — an ICE must never be under-reported,
- *     so it is normalized to `"error"` here explicitly.
- *
- * `note`/`help` don't have a `"blocking"`-worthy tier of their own in the
- * four-valued `Diagnostic.severity`, so they land on the two quiet tiers:
- * `note` → `hint`, `help` → `info`. Blocking stays derived from the
- * *normalized* severity (not the raw string), which is what makes the ICE
- * case blocking too instead of silently passing.
- */
-export function normalizeClippyLevel(raw) {
-    if (raw === "error")
-        return "error";
-    if (typeof raw === "string" &&
-        raw.startsWith("error: internal compiler error")) {
-        return "error";
-    }
-    if (raw === "note")
-        return "hint";
-    if (raw === "help")
-        return "info";
-    // "warning", "failure-note" (unreachable here, see above), and anything
-    // unrecognized fall back to "warning" — the tier every clippy diagnostic
-    // reported at before this fix.
-    return "warning";
-}
-/**
- * Find a machine-applicable suggested replacement across the message's spans.
- * Clippy emits one diagnostic per warning but can attach the auto-fix to a
- * span other than the primary one (e.g. a fix that rewrites a use-site AND
- * removes the now-unused import). We treat the diagnostic as fixable if any
- * span carries a MachineApplicable suggestion — that's the applicability
- * level clippy promises is safe for `cargo clippy --fix` to apply without
- * human review.
- */
-function findMachineApplicableSpan(spans) {
-    return spans.find((s) => typeof s.suggested_replacement === "string" &&
-        s.suggestion_applicability === "MachineApplicable");
-}
-export function parseClippyOutput(raw, fallbackPath, cargoDir) {
-    const diagnostics = [];
-    const lines = raw.split("\n").filter((l) => l.trim());
-    for (const line of lines) {
-        try {
-            const msg = JSON.parse(line);
-            if (msg.reason !== "compiler-message")
-                continue;
-            const message = msg.message;
-            if (!message)
-                continue;
-            // Only include messages for this file or project-wide
-            const spans = message.spans ?? [];
-            const span = spans[0];
-            if (!span)
-                continue;
-            const fixableSpan = findMachineApplicableSpan(spans);
-            // span.file is relative to the package root; resolve to absolute when
-            // the cargo dir is known so callers can filter by edited file (#265 B1).
-            const rawFile = span.file || span.file_name;
-            const filePath = rawFile
-                ? cargoDir && !isAbsolute(rawFile)
-                    ? resolve(cargoDir, rawFile)
-                    : rawFile
-                : fallbackPath;
-            // #1802: preserve clippy's real six-level vocabulary instead of
-            // collapsing it. See `normalizeClippyLevel` above for the verified
-            // mapping and the repro that falsified the original "two-valued"
-            // claim. Blocking is derived from the NORMALIZED severity so an ICE
-            // (`"error: internal compiler error"`) is blocking too, not just an
-            // exact-match `"error"` string.
-            const normalizedSeverity = normalizeClippyLevel(message.level);
-            diagnostics.push({
-                id: `clippy-${message.code?.code || "unknown"}`,
-                message: message.message || "Clippy warning",
-                filePath,
-                line: span.line_start || 0,
-                column: span.column_start || 0,
-                severity: normalizedSeverity,
-                semantic: normalizedSeverity === "error" ? "blocking" : "warning",
-                tool: "rust-clippy",
-                rule: message.code?.code,
-                defectClass: "correctness",
-                fixable: fixableSpan !== undefined,
-                fixSuggestion: fixableSpan?.suggested_replacement,
-            });
-        }
-        catch {
-            // Not a JSON line, skip
-        }
-    }
-    return diagnostics;
-}
-export default rustClippyRunner;

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

@@ -1,173 +0,0 @@
-/**
- * Shellcheck runner for dispatch system
- *
- * Industry-standard linter for shell scripts (bash, sh, zsh).
- * Detects syntax errors, undefined variables, quoting issues, and best practices.
- *
- * Why shellcheck?
- * - Industry standard (used in CI/CD everywhere)
- * - Comprehensive checks (syntax, variables, quotes, best practices)
- * - JSON output for easy parsing
- * - Available on all platforms (apt, brew, cargo, etc.)
- *
- * Alternative considered: bash-language-server
- * - LSP approach like OpenCode uses
- * - Richer features but heavier
- * - shellcheck is simpler and faster for basic linting
- *
- * Install: apt install shellcheck, brew install shellcheck, or cargo install shellcheck
- *
- * Config: .shellcheckrc (optional, zero-config works)
- */
-import * as fs from "node:fs";
-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 { PRIORITY } from "../priorities.js";
-import { createAvailabilityChecker, lspPrimaryCoversFile, resolveAvailableOrInstall, } from "./utils/runner-helpers.js";
-import { finishParsedRun } from "./utils/tool-failure.js";
-const shellcheck = createAvailabilityChecker("shellcheck", ".exe");
-function findShellcheckConfig(cwd) {
-    const local = path.join(cwd, ".shellcheckrc");
-    if (fs.existsSync(local))
-        return local;
-    let current = path.resolve(cwd);
-    while (true) {
-        const candidate = path.join(current, ".shellcheckrc");
-        if (fs.existsSync(candidate))
-            return candidate;
-        const parent = path.dirname(current);
-        if (parent === current)
-            break;
-        current = parent;
-    }
-    return undefined;
-}
-/**
- * Parse shellcheck JSON output
- *
- * Format: Array of check objects
- * [{
- *   "file": "script.sh",
- *   "line": 10,
- *   "endLine": 10,
- *   "column": 5,
- *   "endColumn": 10,
- *   "level": "warning",
- *   "code": 2154,
- *   "message": "var is referenced but not assigned.",
- *   "fix": null
- * }]
- *
- * Levels: "error", "warning", "info", "style"
- */
-function parseShellcheckOutput(raw, filePath, cwd) {
-    const diagnostics = [];
-    const absTarget = path.resolve(cwd, filePath);
-    if (!raw.trim()) {
-        return diagnostics;
-    }
-    try {
-        const parsed = JSON.parse(raw);
-        if (!Array.isArray(parsed)) {
-            return diagnostics;
-        }
-        for (const item of parsed) {
-            if (!item.message || !item.line)
-                continue;
-            if (!item.file || !pathsEqual(path.resolve(cwd, item.file), absTarget))
-                continue;
-            // Map shellcheck levels to our severity
-            const severityMap = {
-                error: "error",
-                warning: "warning",
-                info: "info",
-                style: "info",
-            };
-            const severity = severityMap[item.level || "warning"] || "warning";
-            const ruleCode = item.code ? `SC${item.code}` : "unknown";
-            diagnostics.push({
-                id: `shellcheck-${item.line}-${ruleCode}`,
-                message: `[${ruleCode}] ${item.message}`,
-                filePath,
-                line: item.line,
-                column: item.column || 1,
-                severity,
-                semantic: severity === "error" ? "blocking" : "warning",
-                tool: "shellcheck",
-                rule: ruleCode,
-                fixable: !!item.fix,
-                autoFixAvailable: false,
-                fixKind: item.fix ? "suggestion" : undefined,
-            });
-        }
-    }
-    catch {
-        // JSON parse failed, return empty
-        return diagnostics;
-    }
-    return diagnostics;
-}
-const shellcheckRunner = {
-    id: "shellcheck",
-    appliesTo: ["shell"],
-    priority: PRIORITY.GENERAL_ANALYSIS,
-    skipTestFiles: false, // Shell scripts in test directories should still be checked
-    async run(ctx) {
-        const cwd = resolveRunnerCwd(ctx, "shellcheck");
-        // #233: bash-language-server runs shellcheck internally. When the `bash` LSP
-        // covers this file AND shellcheck is on PATH (so the LSP actually emits its
-        // findings), the warm server already produces these diagnostics — skip the
-        // redundant CLI scan. Stays active when the LSP or shellcheck is absent so
-        // shell coverage never regresses.
-        if (lspPrimaryCoversFile(ctx, "bash") &&
-            (await ctx.hasTool("bash-language-server")) &&
-            (await ctx.hasTool("shellcheck"))) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        let cmd = null;
-        if (await shellcheck.isAvailableAsync(cwd)) {
-            cmd = shellcheck.getCommand(cwd);
-        }
-        else {
-            const managed = await resolveAvailableOrInstall(shellcheck, "shellcheck", cwd);
-            if (managed)
-                cmd = managed;
-        }
-        if (!cmd)
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        // Determine shell dialect from file extension (all map to bash for shellcheck)
-        const shellDialect = "bash";
-        // Build args
-        // --format json: JSON output
-        // --shell: Specify shell dialect (bash, sh, zsh, ksh, busybox)
-        // --severity: Minimum severity (we'll filter ourselves)
-        const args = ["--format", "json", "--shell", shellDialect];
-        // Check for config file
-        const configPath = findShellcheckConfig(ctx.cwd);
-        if (!configPath) {
-            // No config file: surface `info`-level findings (e.g. SC2086
-            // double-quote-to-prevent-globbing — a high-value, commonly-relevant
-            // check that was previously dropped, #213) while still excluding pure
-            // `style` rules to limit noise. Projects opt into style via .shellcheckrc.
-            args.push("--severity", "info");
-        }
-        args.push(ctx.filePath);
-        const result = await safeSpawnAsync(cmd, args, { cwd, timeout: 15000 });
-        // shellcheck exits with code 1 if issues found, 0 if clean
-        if (result.status === 0 && !result.stdout?.trim()) {
-            return { status: "succeeded", diagnostics: [], semantic: "none" };
-        }
-        // Parse diagnostics
-        const raw = result.stdout + result.stderr;
-        const diagnostics = parseShellcheckOutput(raw, ctx.filePath, cwd);
-        return finishParsedRun({
-            tool: "shellcheck",
-            ctx,
-            result,
-            diagnostics,
-        });
-    },
-};
-export default shellcheckRunner;