@herbertgao/pi-extensions 2026.10.0 → 2026.10.2

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

@@ -1,102 +0,0 @@
-import { safeSpawnAsync } from "../../safe-spawn.js";
-import { findNearestContaining } from "../../path-utils.js";
-import { resolveRunnerCwd } from "../../tool-cwd.js";
-import { PRIORITY } from "../priorities.js";
-import { createAvailabilityChecker, resolveAvailableOrInstall, } from "./utils/runner-helpers.js";
-const shfmt = createAvailabilityChecker("shfmt", ".exe");
-// shfmt's only config source is .editorconfig. We treat its presence as the
-// opt-in for the (non-error) format-diff warning, so out of the box shfmt only
-// reports genuine parse errors instead of nagging every unformatted shell file
-// against shfmt's built-in defaults (#211).
-function hasEditorConfig(cwd) {
-    return findNearestContaining(cwd, [".editorconfig"]) !== undefined;
-}
-/**
- * shfmt runner — checks shell script formatting.
- * Reports files that differ from shfmt's canonical output as a single warning.
- * Does NOT auto-apply formatting (that's the formatter's job).
- */
-const shfmtRunner = {
-    id: "shfmt",
-    appliesTo: ["shell"],
-    priority: PRIORITY.FORMAT_AND_LINT_PRIMARY,
-    skipTestFiles: false,
-    async run(ctx) {
-        const cwd = resolveRunnerCwd(ctx, "shfmt");
-        let cmd = null;
-        if (await shfmt.isAvailableAsync(cwd)) {
-            cmd = shfmt.getCommand(cwd);
-        }
-        else {
-            const installed = await resolveAvailableOrInstall(shfmt, "shfmt", cwd);
-            if (!installed) {
-                return { status: "skipped", diagnostics: [], semantic: "none" };
-            }
-            cmd = installed;
-        }
-        if (!cmd)
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        // --diff exits 1 and prints a unified diff if the file needs formatting
-        const result = await safeSpawnAsync(cmd, ["--diff", ctx.filePath], {
-            timeout: 10000,
-            cwd,
-        });
-        // exit 0 = already formatted, exit 1 = needs formatting, exit >1 = parse error
-        if (result.status === 0) {
-            return { status: "succeeded", diagnostics: [], semantic: "none" };
-        }
-        if ((result.status ?? 2) > 1) {
-            // Parse error — report on line 1
-            const errMsg = (result.stderr ?? "").split("\n")[0].trim();
-            const diagnostics = [
-                {
-                    id: `shfmt-parse-${ctx.filePath}`,
-                    message: errMsg
-                        ? `shfmt parse error: ${errMsg}`
-                        : "shfmt: failed to parse shell script",
-                    filePath: ctx.filePath,
-                    line: 1,
-                    column: 1,
-                    severity: "error",
-                    semantic: "blocking",
-                    tool: "shfmt",
-                    rule: "shfmt-parse-error",
-                },
-            ];
-            return { status: "failed", diagnostics, semantic: "blocking" };
-        }
-        // Needs formatting (exit 1). Only warn if the project opted into shfmt via
-        // .editorconfig — otherwise this nags on every shell write against shfmt's
-        // defaults (#211). Parse errors (above) are always reported.
-        if (!hasEditorConfig(cwd)) {
-            // #211: without project opt-in, do not nag about formatting. But
-            // shfmt DID exit 1 — differences exist — so this is "chose not to
-            // check", reported as skipped, never as a clean result (#1839).
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        // Extract first changed line from diff if possible
-        const diffOutput = result.stdout ?? result.stderr ?? "";
-        let line = 1;
-        const lineMatch = diffOutput.match(/^@@\s+-(\d+)/m);
-        if (lineMatch)
-            line = Number(lineMatch[1]);
-        const diagnostics = [
-            {
-                id: `shfmt-format-${ctx.filePath}`,
-                message: "Shell script is not formatted — run `shfmt -w` to fix",
-                filePath: ctx.filePath,
-                line,
-                column: 1,
-                severity: "warning",
-                semantic: "warning",
-                tool: "shfmt",
-                rule: "shfmt-unformatted",
-                fixable: true,
-                autoFixAvailable: false,
-                fixKind: "manual",
-            },
-        ];
-        return { status: "succeeded", diagnostics, semantic: "warning" };
-    },
-};
-export default shfmtRunner;

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

@@ -1,128 +0,0 @@
-/**
- * Spellcheck runner for dispatch system
- *
- * Uses typos-cli (Rust-based, fast, zero-config) to check spelling in:
- * - Markdown files (.md, .mdx)
- * - Code comments (optional, if typos is configured)
- *
- * Key features:
- * - Fast (Rust-based, ~10x faster than cspell)
- * - Low false positives (only checks known typos)
- * - Zero-config by default
- * - JSON output for easy parsing
- *
- * Alternative considered: cspell
- * - cspell: More comprehensive, but higher false positives, needs config
- * - typos-cli: Faster, less noise, works out of the box
- *
- * Install: cargo install typos-cli
- * Or: npm install -g typos-cli (if wrapped)
- */
-import * as path from "node:path";
-import { pathsEqual } from "../../path-utils.js";
-import { safeSpawnAsync } from "../../safe-spawn.js";
-import { PRIORITY } from "../priorities.js";
-import { createAvailabilityChecker, resolveRunnerCwd, } from "./utils/runner-helpers.js";
-import { parseToolRun } from "./utils/tool-failure.js";
-const typos = createAvailabilityChecker("typos", ".exe");
-// EXIT TABLE (typos-cli 1.29 docs https://github.com/crate-ci/typos): 0 = no typos, 2 = typos found, 1 = an error that
-// stopped the scan. Anything nonzero outside {2} is a rejected invocation.
-const TYPOS_EXIT_CODES = { ran: [2] };
-/**
- * Parse typos-cli JSON output (JSON Lines format)
- *
- * Each line is a JSON object:
- * {
- *   "path": "file.md",
- *   "line_num": 42,
- *   "byte_offset": 1234,
- *   "typo": "recieve",
- *   "corrections": ["receive"]
- * }
- */
-function parseTyposOutput(raw, filePath, cwd) {
-    const diagnostics = [];
-    const absTarget = path.resolve(cwd, filePath);
-    if (!raw.trim()) {
-        return diagnostics;
-    }
-    const lines = raw
-        .trim()
-        .split("\n")
-        .filter((l) => l.trim());
-    for (const line of lines) {
-        try {
-            const parsed = JSON.parse(line);
-            if (!parsed.typo || !parsed.line_num)
-                continue;
-            // #3295: every typos JSONL record names its own `path`; a `typos.toml`
-            // `files.extend-exclude` or a directory argv makes that a second file.
-            if (parsed.path && !pathsEqual(path.resolve(cwd, parsed.path), absTarget))
-                continue;
-            const corrections = parsed.corrections?.join(", ") || "no suggestions";
-            const message = `Typo: "${parsed.typo}" → ${corrections}`;
-            diagnostics.push({
-                id: `typos-${parsed.line_num}-${parsed.typo}`,
-                message,
-                filePath,
-                line: parsed.line_num,
-                column: 1, // typos-cli doesn't provide column, just byte offset
-                severity: "warning",
-                semantic: "warning",
-                tool: "typos",
-                rule: "typo",
-                fixable: !!parsed.corrections?.length,
-                autoFixAvailable: false,
-                fixKind: parsed.corrections?.length ? "suggestion" : undefined,
-                fixSuggestion: parsed.corrections?.[0],
-            });
-        }
-        catch (err) {
-            void err;
-        }
-    }
-    return diagnostics;
-}
-const spellcheckRunner = {
-    id: "spellcheck",
-    appliesTo: ["markdown"],
-    priority: PRIORITY.DOC_QUALITY,
-    skipTestFiles: false, // Check docs in test files too
-    async run(ctx) {
-        const cwd = resolveRunnerCwd(ctx, "spellcheck/typos");
-        // Skip if typos-cli is not installed
-        if (!(await typos.isAvailableAsync(cwd))) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        // Run typos-cli with JSON output
-        // --format json: Output JSON Lines
-        // --exclude <pattern>: Could be used to exclude code blocks if needed
-        const args = ["--format", "json", ctx.filePath];
-        const result = await safeSpawnAsync(typos.getCommand(cwd), args, {
-            cwd,
-            timeout: 15000,
-        });
-        // #1816: typos-cli exits 0 clean, 2 with typos found, and 1 on an ERROR
-        // (unreadable config, bad argument). The `status === 2 || stdout` test
-        // below is false for exit 1 with an empty stdout, so a failed run was
-        // reported as a clean file. Only 0 and 2 are runs.
-        //
-        // #1948: parse through the shared seam so an exit-2 run whose JSON lines
-        // yield nothing leaves a record. `parseOutput` keeps the historical
-        // split: the gate judges "did it run" on stdout, the parser reads both
-        // streams.
-        const run = parseToolRun("spellcheck", { result, exitCodes: TYPOS_EXIT_CODES }, (out) => parseTyposOutput(out, ctx.filePath, cwd), { parseOutput: `${result.stdout ?? ""}${result.stderr ?? ""}` });
-        if (run.skipped)
-            return run.skipped;
-        const diagnostics = run.diagnostics;
-        if (diagnostics.length === 0) {
-            return { status: "succeeded", diagnostics: [], semantic: "none" };
-        }
-        return {
-            status: "failed",
-            diagnostics,
-            semantic: "warning",
-        };
-    },
-};
-export default spellcheckRunner;

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

@@ -1,259 +0,0 @@
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { BoundedLruCache } from "../../bounded-cache.js";
-import { safeSpawnAsync } from "../../safe-spawn.js";
-import { resolveRunnerCwd } from "../../tool-cwd.js";
-import { findCompiledClassesDir } from "../../tool-policy.js";
-import { PRIORITY } from "../priorities.js";
-import { createAvailabilityChecker, resolveAvailableOrInstall, } from "./utils/runner-helpers.js";
-// SpotBugs is a JVM tool installed via the archive strategy (#133); java gates
-// it (no JRE → skip). It analyzes the *bytecode tree*, not the edited source.
-const java = createAvailabilityChecker("java", ".exe", ["-version"]);
-const spotbugs = createAvailabilityChecker("spotbugs", ".bat", ["-version"]);
-const MAX_DIAGNOSTICS = 50;
-const MAX_XML_BYTES = 4 * 1024 * 1024;
-const scanCache = new BoundedLruCache(32);
-/** Reset the SpotBugs scan cache (tests). */
-export function _resetSpotbugsCacheForTests() {
-    scanCache.clear();
-}
-/**
- * Cheap signature of the compiled-classes tree: count + newest mtime of all
- * `.class` files. Changes iff the user rebuilt, which is exactly when SpotBugs
- * should re-run.
- */
-function classesSignature(classesDir) {
-    let count = 0;
-    let newest = 0;
-    const stack = [classesDir];
-    // Bounded walk — large class trees are fine (count is cheap), but cap depth
-    // of the stack defensively.
-    while (stack.length > 0) {
-        const dir = stack.pop();
-        if (!dir)
-            break;
-        let entries;
-        try {
-            entries = fs.readdirSync(dir, { withFileTypes: true });
-        }
-        catch {
-            continue;
-        }
-        for (const entry of entries) {
-            const full = path.join(dir, entry.name);
-            if (entry.isDirectory()) {
-                stack.push(full);
-            }
-            else if (entry.isFile() && entry.name.endsWith(".class")) {
-                count++;
-                try {
-                    const m = fs.statSync(full).mtimeMs;
-                    if (m > newest)
-                        newest = m;
-                }
-                catch { }
-            }
-        }
-    }
-    return `${count}:${newest}`;
-}
-// SpotBugs bug categories → pi-lens defect taxonomy (per #133).
-function mapCategory(category) {
-    switch (category.toUpperCase()) {
-        case "CORRECTNESS":
-        case "MT_CORRECTNESS":
-            return "correctness";
-        case "SECURITY":
-            return "safety";
-        case "PERFORMANCE":
-        case "BAD_PRACTICE":
-        case "STYLE":
-        case "I18N":
-        case "EXPERIMENTAL":
-            return "style";
-        default:
-            // Unmapped SpotBugs categories are still bug patterns — treat as correctness.
-            return "correctness";
-    }
-}
-function mapSeverity(priority) {
-    switch (priority) {
-        case "1":
-            return "error";
-        case "3":
-            return "info";
-        default:
-            return "warning";
-    }
-}
-function attr(attrs, name) {
-    // Bounded, non-backtracking: a single negated-char class, no nesting (S5852-safe).
-    const m = new RegExp(`\\b${name}="([^"]*)"`).exec(attrs);
-    return m ? m[1] : undefined;
-}
-function firstSentence(text) {
-    const trimmed = text.replace(/\s+/g, " ").trim();
-    const dot = trimmed.indexOf(". ");
-    return (dot > 0 ? trimmed.slice(0, dot + 1) : trimmed).slice(0, 300);
-}
-/**
- * Parse SpotBugs `-xml:withMessages` output. Hand-rolled (no XML dep, zero-dep
- * ethos) but bounded: input capped, lazy `<BugInstance>…</BugInstance>` blocks
- * (no nested quantifiers), diagnostics capped.
- */
-export function parseSpotbugsXml(raw) {
-    const xml = raw.length > MAX_XML_BYTES ? raw.slice(0, MAX_XML_BYTES) : raw;
-    const diagnostics = [];
-    const blockRe = /<BugInstance\b([^>]*)>([\s\S]*?)<\/BugInstance>/g;
-    let block;
-    let index = 0;
-    // biome-ignore lint/suspicious/noAssignInExpressions: standard regex-exec loop
-    while ((block = blockRe.exec(xml)) !== null) {
-        if (diagnostics.length >= MAX_DIAGNOSTICS)
-            break;
-        const headAttrs = block[1];
-        const body = block[2];
-        const type = attr(headAttrs, "type") || "SPOTBUGS";
-        const priority = attr(headAttrs, "priority") || "2";
-        const category = attr(headAttrs, "category") || "CORRECTNESS";
-        // A BugInstance has several SourceLines: class span, method span, and the
-        // primary (the actual defect location, marked primary="true"). Prefer the
-        // primary; otherwise the last one (most specific), else the first.
-        let filePath;
-        let line = 1;
-        const slRe = /<SourceLine\b([^>]*?)\/?>/g;
-        let sl;
-        // biome-ignore lint/suspicious/noAssignInExpressions: standard regex-exec loop
-        while ((sl = slRe.exec(body)) !== null) {
-            const slAttrs = sl[1];
-            const start = attr(slAttrs, "start");
-            const sourcepath = attr(slAttrs, "sourcepath");
-            const sourcefile = attr(slAttrs, "sourcefile");
-            if (!start || !(sourcepath || sourcefile))
-                continue;
-            filePath = sourcepath || sourcefile;
-            line = Number(start) || 1;
-            if (attr(slAttrs, "primary") === "true")
-                break; // the defect location
-        }
-        if (!filePath)
-            continue; // no source mapping — skip (can't surface usefully)
-        const longMsgMatch = /<LongMessage>([\s\S]*?)<\/LongMessage>/.exec(body);
-        const shortMsgMatch = /<ShortMessage>([\s\S]*?)<\/ShortMessage>/.exec(body);
-        const longMsg = longMsgMatch
-            ? decodeXmlEntities(longMsgMatch[1].trim())
-            : "";
-        const shortMsg = shortMsgMatch
-            ? decodeXmlEntities(shortMsgMatch[1].trim())
-            : "";
-        const message = shortMsg || longMsg || type;
-        const fixSuggestion = longMsg ? firstSentence(longMsg) : undefined;
-        diagnostics.push({
-            id: `spotbugs:${type}:${path.basename(filePath)}:${line}:${index}`,
-            message: `[${type}] ${message}`,
-            filePath,
-            line,
-            column: 1,
-            severity: mapSeverity(priority),
-            // Bug patterns are advisory by default (not always exploitable); a user
-            // can promote to blocking via config. So semantic stays "warning".
-            semantic: "warning",
-            tool: "spotbugs",
-            rule: type,
-            defectClass: mapCategory(category),
-            fixable: false,
-            autoFixAvailable: false,
-            fixKind: fixSuggestion ? "suggestion" : undefined,
-            fixSuggestion,
-        });
-        index++;
-    }
-    return diagnostics;
-}
-function decodeXmlEntities(s) {
-    return s
-        .replace(/&lt;/g, "<")
-        .replace(/&gt;/g, ">")
-        .replace(/&quot;/g, '"')
-        .replace(/&apos;/g, "'")
-        .replace(/&amp;/g, "&");
-}
-/**
- * SpotBugs bytecode bug-pattern analyzer for Java + Kotlin (#133).
- *
- * Opt-in (lens-spotbugs flag) and gated via the withSpotbugsGroup dispatch
- * group, which only adds it when a Java build descriptor + compiled .class dir
- * exist. Operates on the compiled tree, NOT the edited source, and only
- * re-invokes after a rebuild (mtime-cached).
- */
-const spotbugsRunner = {
-    id: "spotbugs",
-    appliesTo: ["java", "kotlin"],
-    priority: PRIORITY.DEEP_LANGUAGE_ANALYSIS,
-    async run(ctx) {
-        const cwd = resolveRunnerCwd(ctx, "spotbugs");
-        const classesDir = findCompiledClassesDir(cwd);
-        if (!classesDir) {
-            ctx.log?.("spotbugs: Java project detected but no compiled .class files found — run `mvn compile` / `gradle build` first");
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        // JRE required — skip silently if absent (SpotBugs needs JDK 11+).
-        if (!(await java.isAvailableAsync(cwd))) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        // Cache gate: re-run only when the .class tree changed since last scan.
-        const signature = classesSignature(classesDir);
-        const cached = scanCache.get(classesDir);
-        if (cached && cached.signature === signature) {
-            return {
-                status: "succeeded",
-                diagnostics: cached.diagnostics,
-                semantic: cached.diagnostics.length > 0 ? "warning" : "none",
-            };
-        }
-        const cmd = await resolveAvailableOrInstall(spotbugs, "spotbugs", cwd);
-        if (!cmd)
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        const tmpXml = path.join(os.tmpdir(), `pi-lens-spotbugs-${process.pid}-${Date.now()}.xml`);
-        const result = await safeSpawnAsync(cmd, [
-            "-textui",
-            "-xml:withMessages",
-            "-low",
-            "-longBugCodes",
-            "-output",
-            tmpXml,
-            classesDir,
-        ], { cwd, timeout: 120000 });
-        let xml = "";
-        try {
-            xml = fs.readFileSync(tmpXml, "utf8");
-        }
-        catch {
-            // No output file — if the run errored, surface a soft failure.
-            if (result.error || (result.status ?? 0) > 1) {
-                return {
-                    status: "failed",
-                    diagnostics: [],
-                    semantic: "none",
-                    rawOutput: (result.stderr || "").slice(0, 500),
-                };
-            }
-            return { status: "succeeded", diagnostics: [], semantic: "none" };
-        }
-        finally {
-            try {
-                fs.rmSync(tmpXml, { force: true });
-            }
-            catch { }
-        }
-        const diagnostics = parseSpotbugsXml(xml);
-        scanCache.set(classesDir, { signature, diagnostics });
-        return {
-            status: "succeeded",
-            diagnostics,
-            semantic: diagnostics.length > 0 ? "warning" : "none",
-        };
-    },
-};
-export default spotbugsRunner;

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

@@ -1,183 +0,0 @@
-import * as path from "node:path";
-import { pathsEqual } from "../../path-utils.js";
-import { safeSpawnAsync } from "../../safe-spawn.js";
-import { logRunnerAdvisoryOnce, resolveRunnerCwd } from "../../tool-cwd.js";
-import { getLinterPolicyForCwd, hasSqlfluffConfig } 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 sqlfluff = createAvailabilityChecker("sqlfluff", ".exe");
-// sqlfluff exit codes (its CLI docs): 0 = clean, 1 = violations found, 2 = a
-// user error that stopped the lint (unknown dialect, unreadable config).
-// Only 2 is a rejected invocation.
-//
-// The exit TABLE is what protects this runner, not the nothing-to-parse rule:
-// EXIT TABLE (SQLFluff 3.1 docs https://docs.sqlfluff.com/en/stable/production.html): 0 clean; 1 findings/error; other nonzero rejected.
-// sqlfluff writes its user errors to STDOUT, not stderr (live: an unknown
-// dialect prints the error there), so stdout is non-empty and the fallback
-// rule would read the failed run as a run that found nothing.
-const SQLFLUFF_EXIT_CODES = { ran: [1] };
-export { hasSqlfluffConfig };
-// sqlfluff's JSON lint output does not carry a per-violation fixable flag —
-// `sqlfluff fix` is a separate command and the lint surface doesn't tell us
-// which violations its `--fix` would resolve. Mirror the stylelint /
-// markdownlint pattern from commit 9c8db1b: maintain a curated set of rule
-// codes whose `fix` is deterministic and safe, sourced from sqlfluff's docs
-// pages that document each rule as "Auto-fix: yes" with a deterministic
-// rewrite. Update when sqlfluff adds or removes fixable rules.
-//
-// Scope: layout / capitalisation / safe-convention / alias-formatting /
-// reference-formatting rules whose fixes don't change query semantics.
-// Excluded: ambiguity rules (AM01..), structural rules whose fix may
-// change query plan (ST05, ST07..), and CV05 (which can flip null
-// comparisons in ways that change result sets).
-const SQLFLUFF_FIXABLE_RULES = new Set([
-    // Layout — pure formatting
-    "LT01",
-    "LT02",
-    "LT03",
-    "LT04",
-    "LT05",
-    "LT06",
-    "LT07",
-    "LT08",
-    "LT09",
-    "LT10",
-    "LT11",
-    "LT12",
-    "LT13",
-    // Capitalisation — pure formatting
-    "CP01",
-    "CP02",
-    "CP03",
-    "CP04",
-    "CP05",
-    // Aliasing — safe formatting / unused-alias removal
-    "AL01",
-    "AL05",
-    "AL06",
-    "AL07",
-    "AL08",
-    "AL09",
-    // Convention — safe formatting / equivalent rewrites
-    "CV01",
-    "CV02",
-    "CV06",
-    "CV07",
-    "CV10",
-    "CV11",
-    // References — quoting / qualifier formatting
-    "RF02",
-    "RF04",
-    "RF05",
-    "RF06",
-    // Structure — only deterministic-safe simplifications
-    "ST01",
-    "ST02",
-]);
-function parseSqlfluffOutput(raw, filePath, cwd) {
-    if (!raw.trim())
-        return [];
-    try {
-        const parsed = JSON.parse(raw);
-        if (!Array.isArray(parsed))
-            return [];
-        const diagnostics = [];
-        const absTarget = path.resolve(cwd, filePath);
-        for (const item of parsed) {
-            // #3295: sqlfluff's JSON is an array of FILES; a jinja `{% include %}`
-            // or a directory argv puts a second one in it.
-            if (item.filepath &&
-                !pathsEqual(path.resolve(cwd, item.filepath), absTarget))
-                continue;
-            for (const v of item.violations ?? []) {
-                if (!v.description)
-                    continue;
-                const code = v.code ?? "SQL";
-                const fixable = SQLFLUFF_FIXABLE_RULES.has(code);
-                diagnostics.push({
-                    id: `sqlfluff-${v.line_no ?? 1}-${v.line_pos ?? 1}-${code}`,
-                    message: `[${code}] ${v.description}`,
-                    filePath,
-                    line: v.line_no ?? 1,
-                    column: v.line_pos ?? 1,
-                    severity: "warning",
-                    semantic: "warning",
-                    tool: "sqlfluff",
-                    rule: code,
-                    fixable,
-                    fixSuggestion: fixable
-                        ? "Run `sqlfluff fix` to apply the deterministic auto-correction for this rule."
-                        : undefined,
-                });
-            }
-        }
-        return diagnostics;
-    }
-    catch {
-        return [];
-    }
-}
-// Exported for the parser unit tests (#112 sqlfluff slice).
-export { parseSqlfluffOutput };
-const sqlfluffRunner = {
-    id: "sqlfluff",
-    appliesTo: ["sql"],
-    priority: PRIORITY.SQL_LINT,
-    skipTestFiles: false,
-    async run(ctx) {
-        const cwd = resolveRunnerCwd(ctx, "sqlfluff");
-        const policy = getLinterPolicyForCwd(ctx.filePath, cwd);
-        if (policy && !policy.preferredRunners.includes("sqlfluff")) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        const hasConfig = hasSqlfluffConfig(cwd);
-        if (!hasConfig) {
-            logRunnerAdvisoryOnce(ctx, "sqlfluff", cwd, "sqlfluff: no config detected, using ANSI dialect defaults");
-        }
-        let cmd = null;
-        if (await sqlfluff.isAvailableAsync(cwd)) {
-            cmd = sqlfluff.getCommand(cwd);
-        }
-        else {
-            cmd = await resolveToolCommandWithInstallFallback(cwd, "sqlfluff");
-        }
-        if (!cmd)
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        // #1937: this used to be `args.splice(2, 0, "--dialect", "ansi")` on
-        // `["lint", "--format", "json", file]`, which inserts BETWEEN the flag
-        // and its value and yields `lint --format --dialect ansi json file`.
-        // sqlfluff rejects `--dialect` as the value of `--format` and exits 2,
-        // so every SQL project WITHOUT a .sqlfluff — exactly the case this
-        // dialect default exists to serve — was never linted. Built in order
-        // rather than patched by index, and pinned by the argv-tie assertion
-        // in runners/captured-real-output.test.ts.
-        const args = ["lint", "--format", "json"];
-        if (!hasConfig) {
-            args.push("--dialect", "ansi");
-        }
-        args.push(ctx.filePath);
-        const result = await safeSpawnAsync(cmd, args, {
-            timeout: 20000,
-            cwd,
-        });
-        // #1816: this runner read `result.status` zero times, so a user error
-        // fell through `parseSqlfluffOutput`'s JSON catch to zero violations and
-        // reported the SQL file as clean.
-        // #1948: sqlfluff exit 1 with a JSON report we read nothing out of is a
-        // parser break, not a clean file.
-        const run = parseToolRun("sqlfluff", { result, exitCodes: SQLFLUFF_EXIT_CODES }, (out) => parseSqlfluffOutput(out, ctx.filePath, cwd), { parseOutput: result.stdout ?? "" });
-        if (run.skipped)
-            return run.skipped;
-        const diagnostics = run.diagnostics;
-        return finishParsedRun({
-            tool: "sqlfluff",
-            ctx,
-            result,
-            diagnostics,
-            classify: () => ({ status: "failed", semantic: "warning" }),
-        });
-    },
-};
-export default sqlfluffRunner;