@herbertgao/pi-extensions 2026.10.1 → 2026.10.2

package/node_modules/pi-lens/dist/clients/dispatch/runners/biome-check.js

@@ -1,296 +0,0 @@
-/**
- * Biome check 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.
- */
-import * as path from "node:path";
-import { incrementDegradationCount } from "../../degradation-ledger.js";
-import { pathsEqual } from "../../path-utils.js";
-import { mapWithConcurrency } from "../../dependency-checker.js";
-import { safeSpawnAsync } from "../../safe-spawn.js";
-import { biomeConfigArgs, getAutofixCapability, getJstsLintPolicyForCwd, } from "../../tool-policy.js";
-import { PRIORITY } from "../priorities.js";
-import { resolveRunnerCwd, resolveToolCommandWithInstallFallback, } from "./utils/runner-helpers.js";
-import { finishParsedRun } from "./utils/tool-failure.js";
-/**
- * Map biome's own severity vocabulary onto the four-tier `Diagnostic.severity`
- * (clients/dispatch/types.ts), the same way `normalizeRuleSeverity` does for
- * ast-grep-napi post-#1787. Biome's real `lint --reporter=json` output
- * (re-probed live for #1810's review round) spells its info tier `"info"`,
- * not `"information"` — the value this switch matched before, which meant a
- * real info-tier diagnostic fell through the `default` and was silently
- * promoted to `"warning"`, one tier too loud. Every other tier is a direct
- * pass-through; an unrecognized value still falls back to `"warning"` — the
- * tier every biome diagnostic reported at before this fix, so reviving
- * hint/info never silently demotes an existing finding.
- */
-export function normalizeBiomeSeverity(raw) {
-    switch (raw) {
-        case "error":
-            return "error";
-        case "info":
-            return "info";
-        case "hint":
-            return "hint";
-        case "warning":
-            return "warning";
-        default:
-            return "warning";
-    }
-}
-/**
- * A diagnostic's `category` is `"lint/<group>/<ruleName>"` — extracts the
- * bare rule name `biome explain` expects. Returns `undefined` for anything
- * that isn't a `lint/` category (e.g. a parse-error pseudo-category), so
- * callers never look up fixability for a rule that was never a real rule.
- */
-export function biomeRuleNameFromCategory(category) {
-    if (!category?.startsWith("lint/"))
-        return undefined;
-    const parts = category.split("/");
-    return parts[parts.length - 1] || undefined;
-}
-export function parseBiomeJson(raw, filePath, cwd, fixKindByRule) {
-    try {
-        const result = JSON.parse(raw);
-        const diagnostics = result.diagnostics || [];
-        const autofix = getAutofixCapability("biome");
-        const absTarget = path.resolve(cwd, filePath);
-        return {
-            diagnostics: diagnostics.flatMap((d) => {
-                // #3295: `location.path` is biome's own name for the file each
-                // diagnostic is about; `biome.json` `files.includes` can widen the
-                // run past the argv.
-                if (d.location?.path &&
-                    !pathsEqual(path.resolve(cwd, d.location.path), absTarget))
-                    return [];
-                {
-                    const ruleName = biomeRuleNameFromCategory(d.category);
-                    const fixKind = ruleName ? fixKindByRule?.get(ruleName) : undefined;
-                    const isFixable = fixKind === "safe" || fixKind === "unsafe";
-                    return [
-                        {
-                            id: `biome:${d.category}:${d.location.start.line}`,
-                            message: d.message,
-                            filePath,
-                            line: d.location.start.line,
-                            column: d.location.start.column,
-                            severity: normalizeBiomeSeverity(d.severity),
-                            semantic: d.severity === "error" ? "blocking" : "warning",
-                            tool: "biome",
-                            rule: d.category,
-                            fixable: isFixable,
-                            // Mirrors `biomeClient.fixFileAsync`'s own `lint --write` call
-                            // (no `--unsafe`, clients/biome-client.ts): the pipeline only
-                            // ever applies SAFE fixes, so only "safe" earns autoFixAvailable.
-                            autoFixAvailable: fixKind === "safe" && (autofix?.safePipelineAutofix ?? false),
-                            fixKind: isFixable && autofix?.fixKind !== "none"
-                                ? autofix?.fixKind
-                                : undefined,
-                        },
-                    ];
-                }
-            }),
-        };
-    }
-    catch (err) {
-        return {
-            diagnostics: [],
-            parseError: err instanceof Error ? err.message : String(err),
-        };
-    }
-}
-// Process-lifetime cache: a rule's fix kind is a static property of the
-// (biome binary, rule name) pair, not of any one diagnostic occurrence, so
-// it's resolved once and reused. Keyed on the resolved `cmd` so a different
-// biome binary (e.g. a different project's pinned version) never reuses
-// another binary's answer. Registered in
-// tests/support/session-state-registry.ts as `process_lifetime` — the
-// answer cannot change without a different biome binary, which is a
-// different cache key, so there is nothing for a session boundary to
-// invalidate.
-const biomeFixKindCache = new Map();
-/** Test-only: drop every cached verdict so a test starts from a clean cache. */
-export function _resetBiomeFixKindCacheForTests() {
-    biomeFixKindCache.clear();
-}
-const BIOME_FIX_KIND_PATTERN = /^-\s*Fix:\s*(safe|unsafe)\s*$/m;
-// The explicit "no fix" statement `biome explain` prints for a rule with no
-// autofix at all (e.g. `noConstantCondition`). Matching this SEPARATELY from
-// "the safe/unsafe pattern didn't match" is the point (#1810 review F1/F2):
-// only a POSITIVE read — either a stated fix tier or this explicit negative
-// — is trustworthy enough to cache. Anything else (a differently-shaped
-// `explain` output, e.g. a biome 1.x install) is a parse failure, not a
-// verdict, and must never be cached as one.
-const BIOME_NO_FIX_PATTERN = /^-\s*No fix available\.\s*$/m;
-/** At most this many `biome explain` spawns run concurrently (#1810 review F6). */
-const EXPLAIN_CONCURRENCY = 4;
-/**
- * Resolves each rule referenced by `categories` to its fix kind via
- * `biome explain <rule>` — the one place biome's shipped CLI states
- * fixability as structured text (`- Fix: safe|unsafe`, or `- No fix
- * available.` when absent), sourced live from the running binary's own rule
- * registry rather than a hand-maintained table (#1810; real diagnostics
- * carry no per-occurrence fixability field — see `BiomeDiagnostic`).
- *
- * Only a POSITIVE read is cached: either `- Fix: safe|unsafe` or the
- * explicit `- No fix available.` statement. A spawn failure, a nonzero
- * exit, or output that matches NEITHER pattern (e.g. a biome 1.x install —
- * its `explain` text differs and would otherwise poison every rule as
- * permanently unfixable, #1810 review F1) resolves to `"none"` for THIS
- * call only and is never written to the cache — caching an unparsed result
- * would permanently under-report a genuinely fixable rule for the rest of
- * the process's life (the never-cache-a-transient-failure screen).
- */
-export async function resolveBiomeFixKinds(cmd, cwd, categories) {
-    const resolved = new Map();
-    const ruleNames = new Set();
-    for (const category of categories) {
-        const ruleName = biomeRuleNameFromCategory(category);
-        if (ruleName)
-            ruleNames.add(ruleName);
-    }
-    const toResolve = [];
-    for (const ruleName of ruleNames) {
-        const cacheKey = `${cmd}::${ruleName}`;
-        const cached = biomeFixKindCache.get(cacheKey);
-        if (cached === undefined) {
-            toResolve.push(ruleName);
-        }
-        else {
-            resolved.set(ruleName, cached);
-        }
-    }
-    await mapWithConcurrency(toResolve, EXPLAIN_CONCURRENCY, async (ruleName) => {
-        const cacheKey = `${cmd}::${ruleName}`;
-        const spawned = await safeSpawnAsync(cmd, ["explain", ruleName], {
-            timeout: 10000,
-            cwd,
-        });
-        if (spawned.error || spawned.status !== 0) {
-            incrementDegradationCount({
-                kind: "biome-explain-unavailable",
-                subject: ruleName,
-                reason: spawned.error
-                    ? `spawn failed: ${spawned.error}`
-                    : `explain exited ${spawned.status}`,
-            });
-            resolved.set(ruleName, "none");
-            return;
-        }
-        const stdout = spawned.stdout || "";
-        const fixMatch = stdout.match(BIOME_FIX_KIND_PATTERN);
-        if (fixMatch) {
-            const kind = fixMatch[1] === "safe" ? "safe" : "unsafe";
-            biomeFixKindCache.set(cacheKey, kind);
-            resolved.set(ruleName, kind);
-            return;
-        }
-        if (BIOME_NO_FIX_PATTERN.test(stdout)) {
-            biomeFixKindCache.set(cacheKey, "none");
-            resolved.set(ruleName, "none");
-            return;
-        }
-        // Neither pattern matched — an unrecognized `explain` output shape, not
-        // a confirmed negative. Resolve to "none" for this call, but leave the
-        // cache untouched so the next batch retries against real output.
-        incrementDegradationCount({
-            kind: "biome-explain-unavailable",
-            subject: ruleName,
-            reason: "explain output matched neither the Fix nor No-fix pattern",
-        });
-        resolved.set(ruleName, "none");
-    });
-    return resolved;
-}
-const biomeCheckJsonRunner = {
-    id: "biome-check-json",
-    appliesTo: ["jsts"],
-    priority: PRIORITY.FORMAT_AND_LINT_PRIMARY,
-    async run(ctx) {
-        const cwd = resolveRunnerCwd(ctx, "biome");
-        const policy = getJstsLintPolicyForCwd(cwd);
-        // Defer to ESLint/oxlint if the project has explicitly configured one —
-        // biome runs as the default linter only when no alternative is present.
-        if (!policy.hasBiomeConfig && policy.hasExplicitNonBiomeLinter) {
-            return {
-                status: "skipped",
-                diagnostics: [],
-                semantic: "none",
-                skipReason: "configured-non-biome-linter",
-            };
-        }
-        const cmd = await resolveToolCommandWithInstallFallback(cwd, "biome");
-        if (!cmd) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        // Shared config-args seam (#1247): `biomeClient.fixFileAsync` consumes
-        // the same builder, so the user's config / package fallback applies on
-        // `lint --write` too.
-        const configArg = biomeConfigArgs(cwd);
-        // Run biome lint (diagnostics only - format is handled separately)
-        const checkResult = await safeSpawnAsync(cmd, [
-            "lint",
-            "--reporter=json",
-            "--no-errors-on-unmatched",
-            ...configArg,
-            ctx.filePath,
-        ], { timeout: 30000, cwd });
-        // Handle spawn errors (e.g., binary not found)
-        if (checkResult.error) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        let fixKindByRule;
-        if (checkResult.status === 0 || checkResult.status === 1) {
-            // Cheap pre-parse just to collect rule categories — the real parse
-            // (with parseError handling) happens below via parseBiomeJson. A
-            // malformed-JSON pre-parse simply yields no categories, and
-            // `resolveBiomeFixKinds` no-ops on an empty list (no spawn, an
-            // immediately-resolved empty map) — the real parse still surfaces
-            // the parseError diagnostic as before.
-            let categories = [];
-            try {
-                const preParsed = JSON.parse(checkResult.stdout || "{}");
-                categories = (preParsed.diagnostics || []).map((d) => d.category);
-            }
-            catch {
-                categories = [];
-            }
-            fixKindByRule = await resolveBiomeFixKinds(cmd, cwd, categories);
-        }
-        const parsed = checkResult.status === 0 || checkResult.status === 1
-            ? parseBiomeJson(checkResult.stdout || "", ctx.filePath, cwd, fixKindByRule)
-            : { diagnostics: [] };
-        if (parsed.parseError) {
-            const raw = checkResult.stdout || checkResult.stderr || "";
-            const preview = raw.replace(/\s+/g, " ").slice(0, 160);
-            return {
-                status: "failed",
-                diagnostics: [
-                    {
-                        id: "biome:parse-error:1",
-                        message: "Biome JSON parse failed: " +
-                            parsed.parseError +
-                            (preview ? " (output preview: " + preview + ")" : ""),
-                        filePath: ctx.filePath,
-                        line: 1,
-                        column: 1,
-                        severity: "warning",
-                        semantic: "warning",
-                        tool: "biome",
-                    },
-                ],
-                semantic: "warning",
-            };
-        }
-        return finishParsedRun({
-            tool: "biome",
-            ctx,
-            result: checkResult,
-            diagnostics: parsed.diagnostics,
-        });
-    },
-};
-export default biomeCheckJsonRunner;

package/node_modules/pi-lens/dist/clients/dispatch/runners/cpp-check.js

@@ -1,219 +0,0 @@
-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 { probeToolAsync } from "../../tool-probe.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-compiler availability checkers — each one caches per-cwd and
-// dedupes concurrent --version probes, the same protections every other
-// runner gets via createAvailabilityChecker. cpp-check previously
-// re-spawned its full candidate sweep on every edit.
-const compilerCheckers = {
-    clang: createAvailabilityChecker("clang", ".exe"),
-    gcc: createAvailabilityChecker("gcc", ".exe"),
-    cc: createAvailabilityChecker("cc", ".exe"),
-    "clang++": createAvailabilityChecker("clang++", ".exe"),
-    "g++": createAvailabilityChecker("g++", ".exe"),
-    "c++": createAvailabilityChecker("c++", ".exe"),
-    cl: createAvailabilityChecker("cl", ".exe"),
-};
-const C_SOURCE_EXTENSIONS = new Set([".c"]);
-const C_HEADER_EXTENSIONS = new Set([".h"]);
-const CPP_SOURCE_EXTENSIONS = new Set([
-    ".c++",
-    ".cc",
-    ".cp",
-    ".cpp",
-    ".cxx",
-    ".c++m",
-    ".cppm",
-    ".cxxm",
-    ".ixx",
-    ".cu",
-    ".hip",
-    ".mm",
-    ".clcpp",
-]);
-const CPP_HEADER_EXTENSIONS = new Set([
-    ".hh",
-    ".hpp",
-    ".hxx",
-    ".inl",
-    ".ipp",
-    ".tpp",
-    ".txx",
-]);
-function headerLooksLikeCpp(absPath) {
-    try {
-        const content = fs.readFileSync(absPath, "utf-8");
-        return /\b(namespace|template|class|constexpr|concept|using)\b|std::|\b(public|private|protected)\s*:/.test(content);
-    }
-    catch {
-        return false;
-    }
-}
-function getGccLikeCandidates(absPath) {
-    const ext = path.extname(absPath).toLowerCase();
-    const cMode = C_SOURCE_EXTENSIONS.has(ext) ||
-        (C_HEADER_EXTENSIONS.has(ext) && !headerLooksLikeCpp(absPath));
-    const cppMode = CPP_SOURCE_EXTENSIONS.has(ext) || CPP_HEADER_EXTENSIONS.has(ext);
-    if (cMode) {
-        const cArgs = C_HEADER_EXTENSIONS.has(ext)
-            ? ["-x", "c-header", "-fsyntax-only", absPath]
-            : ["-x", "c", "-fsyntax-only", absPath];
-        return [
-            { key: "clang", args: cArgs },
-            { key: "gcc", args: cArgs },
-            { key: "cc", args: cArgs },
-        ];
-    }
-    if (cppMode || ext) {
-        return [
-            { key: "clang++", args: ["-fsyntax-only", absPath] },
-            { key: "g++", args: ["-fsyntax-only", absPath] },
-            { key: "c++", args: ["-fsyntax-only", absPath] },
-        ];
-    }
-    return [];
-}
-async function resolveCompiler(absPath, cwd) {
-    for (const candidate of getGccLikeCandidates(absPath)) {
-        const checker = compilerCheckers[candidate.key];
-        if (await checker.isAvailableAsync(cwd)) {
-            const command = checker.getCommand(cwd) ?? candidate.key;
-            return { command, args: candidate.args, flavor: "gcc" };
-        }
-    }
-    // MSVC `cl.exe` doesn't accept `--version`; the createAvailabilityChecker
-    // probe used by every other compiler returns false even when cl is on
-    // PATH. Keep the ad-hoc no-arg probe but cache the resolution via the
-    // shared checker so subsequent edits don't re-spawn.
-    const clChecker = compilerCheckers.cl;
-    const clCmd = clChecker.getCommand(cwd);
-    if (clCmd) {
-        // Already probed in a previous turn and resolved.
-        return {
-            command: clCmd,
-            args: ["/nologo", "/Zs", absPath],
-            flavor: "msvc",
-        };
-    }
-    // Mirrors the deliberate global-PATH probes in utils/runner-helpers.ts:
-    // this never resolves a config file or a target path, so there is no cwd
-    // for it to get wrong.
-    const clProbe = await probeToolAsync("cl", [], { timeout: 5000 });
-    if (!clProbe.error && clProbe.status !== null) {
-        return {
-            command: "cl",
-            args: ["/nologo", "/Zs", absPath],
-            flavor: "msvc",
-        };
-    }
-    return undefined;
-}
-function parseGccLikeOutput(raw, filePath, cwd) {
-    const diagnostics = [];
-    const absTarget = path.resolve(cwd, filePath);
-    for (const line of raw.split(/\r?\n/)) {
-        const match = line.match(/^(.*?):(\d+):(?:(\d+):)?\s*(fatal error|error|warning|note):\s+(.+)$/i);
-        if (!match)
-            continue;
-        const [, sourcePath, lineStr, colStr, severityLabel, message] = match;
-        // #3278: one seam for reported-path attribution — see javac.ts.
-        if (!pathsEqual(path.resolve(cwd, sourcePath.trim()), absTarget))
-            continue;
-        const severity = severityLabel.toLowerCase().includes("error")
-            ? "error"
-            : "warning";
-        diagnostics.push({
-            id: `cpp-check-${severityLabel}-${lineStr}-${colStr || "1"}`,
-            message: message.trim(),
-            filePath,
-            line: Number.parseInt(lineStr, 10) || 1,
-            column: Number.parseInt(colStr || "1", 10) || 1,
-            severity,
-            // This single-file syntax check has no compile database, include path,
-            // or build flags. It can inform, but cannot prove a project blocker.
-            semantic: "warning",
-            tool: "cpp-check",
-            rule: severityLabel.toLowerCase(),
-            fixable: false,
-        });
-    }
-    return diagnostics;
-}
-function parseMsvcOutput(raw, filePath, cwd) {
-    const diagnostics = [];
-    const absTarget = path.resolve(cwd, filePath);
-    for (const line of raw.split(/\r?\n/)) {
-        const match = line.match(/^(.*)\((\d+)(?:,(\d+))?\):\s*(fatal error|error|warning)\s+([A-Z]+\d+):\s+(.+)$/i);
-        if (!match)
-            continue;
-        const [, sourcePath, lineStr, colStr, severityLabel, rule, message] = match;
-        // #3278: one seam for reported-path attribution — see javac.ts.
-        if (!pathsEqual(path.resolve(cwd, sourcePath.trim()), absTarget))
-            continue;
-        const severity = severityLabel.toLowerCase().includes("error")
-            ? "error"
-            : "warning";
-        diagnostics.push({
-            id: `cpp-check-${rule}-${lineStr}-${colStr || "1"}`,
-            message: `[${rule}] ${message.trim()}`,
-            filePath,
-            line: Number.parseInt(lineStr, 10) || 1,
-            column: Number.parseInt(colStr || "1", 10) || 1,
-            severity,
-            // MSVC is invoked with the same context-free single-file contract.
-            semantic: "warning",
-            tool: "cpp-check",
-            rule,
-            fixable: false,
-        });
-    }
-    return diagnostics;
-}
-const cppCheckRunner = {
-    id: "cpp-check",
-    appliesTo: ["cxx"],
-    priority: PRIORITY.GENERAL_ANALYSIS,
-    skipTestFiles: false,
-    async run(ctx) {
-        const cwd = resolveRunnerCwd(ctx, "cpp-check");
-        const absPath = path.resolve(cwd, ctx.filePath);
-        const compiler = await resolveCompiler(absPath, cwd);
-        if (!compiler) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        const result = await safeSpawnAsync(compiler.command, compiler.args, {
-            cwd,
-            timeout: 30000,
-        });
-        const raw = `${result.stdout ?? ""}\n${result.stderr ?? ""}`.trim();
-        const parsed = parseToolRun("cpp-check", {
-            result,
-            output: raw,
-            // EXIT TABLE (gcc/clang 13 measured fixture): 0 clean; 1 findings; 2 error; other nonzero rejected.
-            exitCodes: { ran: [1, 2] },
-        }, (output) => compiler.flavor === "msvc"
-            ? parseMsvcOutput(output, ctx.filePath, cwd)
-            : parseGccLikeOutput(output, ctx.filePath, cwd));
-        if (parsed.skipped)
-            return parsed.skipped;
-        return finishParsedRun({
-            tool: "cpp-check",
-            ctx,
-            result,
-            diagnostics: parsed.diagnostics,
-            classify: (diagnostics) => ({
-                status: diagnostics.some((d) => d.severity === "error")
-                    ? "failed"
-                    : "succeeded",
-                semantic: "warning",
-            }),
-        });
-    },
-};
-export default cppCheckRunner;

package/node_modules/pi-lens/dist/clients/dispatch/runners/credo.js

@@ -1,82 +0,0 @@
-import * as path from "node:path";
-import * as fs from "node:fs";
-import { safeSpawnAsync } from "../../safe-spawn.js";
-import { resolveRunnerCwd } from "../../tool-cwd.js";
-import { PRIORITY } from "../priorities.js";
-import { finishParsedRun, parseToolRun } from "./utils/tool-failure.js";
-import { createCwdCachedProbe } from "./utils/runner-helpers.js";
-const CREDO_PROBE_BUDGET_MS = 10_000;
-// Per-cwd cached `mix credo --version` probe (#120), governed by the shared
-// availability policy (#1494). The probe returns the spawn result so the policy
-// can tell a cold-BEAM timeout from a genuinely absent credo: the 10 s budget
-// here is the widest in the repo and the most likely to expire on a slow first
-// compile, and latching that as "not installed" used to disable credo for the
-// rest of the session.
-const probeCredo = createCwdCachedProbe((cwd) => safeSpawnAsync("mix", ["credo", "--version"], {
-    timeout: CREDO_PROBE_BUDGET_MS,
-    cwd,
-}), { tool: "credo", budgetMs: CREDO_PROBE_BUDGET_MS });
-// `mix credo <file>` is single-file-scoped today, so blanket attribution would
-// be correct — but map issue.filename (resolved against cwd) for robustness so
-// this stays correct if the invocation ever widens to a directory (#265 A4).
-export function parseCredoJson(raw, fallbackPath, cwd) {
-    try {
-        const output = JSON.parse(raw);
-        return (output.issues ?? []).map((issue) => ({
-            id: `credo:${issue.check}:${issue.line_no}`,
-            message: `[${issue.check}] ${issue.message}`,
-            filePath: issue.filename && issue.filename.trim()
-                ? path.isAbsolute(issue.filename)
-                    ? issue.filename
-                    : path.resolve(cwd, issue.filename)
-                : fallbackPath,
-            line: issue.line_no,
-            column: issue.column ?? 1,
-            severity: issue.priority <= 10 ? "error" : "warning",
-            semantic: issue.priority <= 10 ? "blocking" : "warning",
-            tool: "credo",
-            rule: issue.check,
-            fixable: false,
-        }));
-    }
-    catch {
-        return [];
-    }
-}
-function hasMixExs(cwd) {
-    return fs.existsSync(path.join(cwd, "mix.exs"));
-}
-const credoRunner = {
-    id: "credo",
-    appliesTo: ["elixir"],
-    priority: PRIORITY.GENERAL_ANALYSIS,
-    skipTestFiles: false,
-    async run(ctx) {
-        const cwd = resolveRunnerCwd(ctx, "credo");
-        if (!hasMixExs(cwd)) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        // Credo ships as a mix dependency — cached per-cwd probe (see probeCredo).
-        if (!(await probeCredo(cwd))) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        const absPath = path.resolve(cwd, ctx.filePath);
-        const result = await safeSpawnAsync("mix", ["credo", "--format", "json", "--strict", absPath], { timeout: 30000, cwd });
-        const output = `${result.stdout ?? ""}${result.stderr ?? ""}`;
-        const parsed = parseToolRun("credo", {
-            result,
-            output,
-            // EXIT TABLE (Credo 1.7 measured fixture): 0 clean; 1 findings; 2 error; other nonzero rejected.
-            exitCodes: { ran: [1, 2] },
-        }, (raw) => parseCredoJson(raw, ctx.filePath, cwd));
-        if (parsed.skipped)
-            return parsed.skipped;
-        return finishParsedRun({
-            tool: "credo",
-            ctx,
-            result,
-            diagnostics: parsed.diagnostics,
-        });
-    },
-};
-export default credoRunner;