@herbertgao/pi-extensions 2026.10.1 → 2026.10.2

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

@@ -1,445 +0,0 @@
-import * as fs from "node:fs/promises";
-import * as os from "node:os";
-import * as path from "node:path";
-import { incrementDegradationCount } from "../../degradation-ledger.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 { classifyProbeFailure, createAvailabilityLatch, isLatchingOutcome, logAvailabilityDecision, startHostStallSampler, } from "./utils/availability-policy.js";
-// The PS script written to a temp file each run. `-File` with a temp script
-// keeps the analysis argv free of embedded script text; safe-spawn itself never
-// uses a shell (#817), so nothing here is quoting-sensitive.
-const PS_SCRIPT = `
-param([string]$FilePath)
-Import-Module PSScriptAnalyzer -ErrorAction Stop
-$results = @(Invoke-ScriptAnalyzer -Path $FilePath | Select-Object RuleName,@{N='Severity';E={$_.Severity.ToString()}},Line,Column,Message)
-if ($results.Count -eq 0) { Write-Output '[]'; exit 0 }
-$results | ConvertTo-Json -Depth 3 -Compress
-`.trim();
-const PS_TIMEOUT_MS = 30000;
-/**
- * PowerShell spawns go through `safeSpawnAsync` (#1490).
- *
- * The hand-rolled version returned `status: null` for a timeout, a synchronous
- * `spawn UNKNOWN` and a missing binary alike, so the call site had nothing to
- * classify and remembered every one of them as "PowerShell analysis is not
- * available". `safeSpawnAsync` carries the standard taxonomy — `failure`,
- * `spawnFailure.kind` and the errno on `error` — which is what lets the
- * availability policy tell a stall from an absence.
- *
- * The two presence probes that used to share this wrapper now go through
- * `probeToolAsync` (#2894), so the only spawn left here is the ANALYSIS pass
- * — which always has a project to resolve `PSScriptAnalyzerSettings.psd1`
- * against. `cwd` is required to keep it that way.
- */
-function spawnPs(cmd, args, options) {
-    const { timeoutMs = PS_TIMEOUT_MS, cwd } = options;
-    return safeSpawnAsync(cmd, args, {
-        cwd,
-        timeout: timeoutMs,
-        resourceLabel: "psscriptanalyzer",
-    });
-}
-/**
- * The two verdicts this runner memoizes, both owned by the shared policy.
- *
- * The availability-policy coverage gate never flagged either of them, and the
- * reason is not a bug in the gate: it recognises a probe by a quoted VERSION
- * FLAG, and neither probe below asks for a version. One runs `exit 0` to see if
- * an interpreter answers; the other asks `Get-Module -ListAvailable`. A
- * capability probe with no version flag is invisible to that pre-filter, so this
- * file was skipped before any unit was analysed. The residual gate blindness is
- * tracked with #1489's gate work; the migration here does not depend on it.
- */
-const psCmdLatch = createAvailabilityLatch();
-const psAnalyzerLatchByCmd = new Map();
-/**
- * Whether `-File` actually executes, keyed by interpreter (#1540).
- *
- * Neither probe above asks `-File` a question -- both use `-Command`, which
- * PowerShell's execution policy does not gate. Under `Restricted`/`AllSigned`
- * that lets both probes report "available" while the real analysis spawn
- * (which DOES go through `-File`) gets a policy `SecurityError` on stderr and
- * exits nonzero with empty stdout. This latch is deliberately populated by
- * the real analysis run rather than a third `-Command`-shaped probe, so the
- * verdict it records is direct evidence about `-File`, not an inference from
- * a proxy that has already been shown to disagree with it.
- */
-const psExecLatchByCmd = new Map();
-let psCmd = null;
-/** Record one decision, and report whether the caller may retry later. */
-function notePsDecision(latch, tool, verdict) {
-    let retryAfterMs;
-    if (verdict.available) {
-        latch.noteAvailable();
-    }
-    else {
-        const delay = latch.noteUnavailable(verdict.outcome, verdict.cause);
-        if (delay > 0)
-            retryAfterMs = delay;
-    }
-    logAvailabilityDecision({
-        tool,
-        verdict: verdict.available ? "available" : "unavailable",
-        outcome: verdict.available ? "success" : verdict.outcome,
-        cause: verdict.available ? "ok" : verdict.cause,
-        elapsedMs: verdict.elapsedMs,
-        latched: verdict.available || isLatchingOutcome(verdict.outcome),
-        classifiedBy: "probe",
-        hostStallMs: verdict.hostStallMs,
-        ...(retryAfterMs !== undefined && { retryAfterMs }),
-        budgetMs: PS_TIMEOUT_MS,
-    });
-}
-/**
- * Drop both verdicts at the session boundary (#1490 review).
- *
- * Every other runner gets this for free through
- * `resetDispatchAvailabilityState`'s generation counter; these latches are local
- * to the module, so `session_start` clears them explicitly. Without it, a
- * PowerShell or module install performed mid-process is invisible until the host
- * restarts — the same "suppression outliving its session" defect #1222 fixed for
- * install attempts.
- */
-export function resetPsScriptAnalyzerAvailability() {
-    psCmdLatch.reset();
-    psAnalyzerLatchByCmd.clear();
-    psExecLatchByCmd.clear();
-    psCmd = null;
-}
-/**
- * Resolve the PowerShell binary, once per session per verdict.
- *
- * A candidate that times out is NOT evidence that PowerShell is absent, so the
- * loop only concludes "missing" when every candidate answered with a durable
- * failure. One transient candidate makes the whole verdict transient, and the
- * next turn after the cooldown probes again.
- */
-async function resolvePowerShellCmd() {
-    const memo = psCmdLatch.read();
-    if (memo !== null)
-        return memo ? psCmd : null;
-    // Rank what the candidates said, rather than collapsing every failure to
-    // "not-found" (#1490 review). A stall outranks everything: it means we never
-    // got an answer. A present-but-rejecting interpreter (nonzero exit, EACCES)
-    // is durable but is NOT a missing install, and reporting it as one both sends
-    // the user to install PowerShell they already have and fabricates the cause in
-    // `availability_decision`. Only an all-candidates ENOENT sweep is `missing`.
-    let transient = null;
-    let rejected = null;
-    let elapsedTotalMs = 0;
-    let stallTotalMs = 0;
-    for (const candidate of ["pwsh", "powershell"]) {
-        const sampler = startHostStallSampler();
-        const startedAt = Date.now();
-        const result = await probeToolAsync(candidate, ["-NoProfile", "-NonInteractive", "-Command", "exit 0"], { timeout: PS_TIMEOUT_MS, resourceLabel: "psscriptanalyzer" });
-        const hostStallMs = sampler.stop();
-        const elapsedMs = Date.now() - startedAt;
-        elapsedTotalMs += elapsedMs;
-        stallTotalMs += hostStallMs;
-        if (!result.error && result.status === 0) {
-            psCmd = candidate;
-            notePsDecision(psCmdLatch, "powershell", {
-                available: true,
-                elapsedMs,
-                hostStallMs,
-            });
-            return candidate;
-        }
-        const classified = classifyProbeFailure(result, { hostStallMs });
-        if (classified.outcome === "transient")
-            transient ??= classified;
-        else if (classified.outcome !== "missing")
-            rejected ??= classified;
-    }
-    psCmd = null;
-    const verdict = transient ??
-        rejected ?? {
-        outcome: "missing",
-        cause: "not-found",
-    };
-    notePsDecision(psCmdLatch, "powershell", {
-        available: false,
-        outcome: verdict.outcome,
-        cause: verdict.cause,
-        elapsedMs: elapsedTotalMs,
-        hostStallMs: stallTotalMs,
-    });
-    return null;
-}
-async function checkModuleAvailable(cmd) {
-    let latch = psAnalyzerLatchByCmd.get(cmd);
-    if (!latch) {
-        latch = createAvailabilityLatch();
-        psAnalyzerLatchByCmd.set(cmd, latch);
-    }
-    const memo = latch.read();
-    if (memo !== null)
-        return memo;
-    const sampler = startHostStallSampler();
-    const startedAt = Date.now();
-    const result = await probeToolAsync(cmd, [
-        "-NoProfile",
-        "-NonInteractive",
-        "-Command",
-        "if (Get-Module -ListAvailable PSScriptAnalyzer) { exit 0 } else { exit 1 }",
-    ], { timeout: PS_TIMEOUT_MS, resourceLabel: "psscriptanalyzer" });
-    const hostStallMs = sampler.stop();
-    const elapsedMs = Date.now() - startedAt;
-    if (!result.error && result.status === 0) {
-        notePsDecision(latch, "psscriptanalyzer", {
-            available: true,
-            elapsedMs,
-            hostStallMs,
-        });
-        return true;
-    }
-    // A CLEAN `exit 1` is the module genuinely not being installed — the one
-    // outcome an install fixes, so that alone earns the `missing` override.
-    //
-    // Everything else did not answer the question (#1490 review). A `spawn
-    // UNKNOWN`, an EMFILE, an EACCES, or a PowerShell that vanished between the
-    // two probes all arrive with an error and no status, and calling those
-    // "PSScriptAnalyzer is not installed" latched PowerShell analysis off for the
-    // session on hosts where the module was present the whole time.
-    const moduleAbsent = result.status === 1 && !result.failure && !result.error;
-    const classified = classifyProbeFailure(result, {
-        hostStallMs,
-        ...(moduleAbsent && { unclassifiedFailureOutcome: "missing" }),
-    });
-    let { outcome, cause } = classified;
-    if (!moduleAbsent && outcome !== "transient") {
-        // Nothing here is evidence about the module, so the verdict must expire.
-        outcome = "transient";
-        cause = "probe-rejected";
-    }
-    notePsDecision(latch, "psscriptanalyzer", {
-        available: false,
-        outcome,
-        cause,
-        elapsedMs,
-        hostStallMs,
-    });
-    return false;
-}
-/**
- * `null` means "unreadable" (#1598): empty stdout, or stdout that fails to
- * parse as JSON. `PS_SCRIPT` always writes either the literal `[]` marker or
- * a `ConvertTo-Json` array/object on a genuine run, so anything else on an
- * exit-0 run is not a clean-file answer -- it is a lost or truncated write
- * between the child and us. The caller must not read `null` the same way it
- * reads a real `[]`.
- */
-function parsePSAnalyzerOutput(raw, filePath) {
-    const trimmed = raw.trim();
-    if (!trimmed)
-        return null;
-    if (trimmed === "[]")
-        return [];
-    let parsed;
-    try {
-        parsed = JSON.parse(trimmed);
-    }
-    catch {
-        return null;
-    }
-    const items = Array.isArray(parsed) ? parsed : [parsed];
-    return items
-        .filter((item) => item.Message && item.Line)
-        .map((item) => {
-        const sev = (item.Severity ?? "Warning").toLowerCase();
-        const severity = sev === "error" || sev === "parseerror"
-            ? "error"
-            : sev === "information"
-                ? "info"
-                : "warning";
-        const rule = item.RuleName ?? "PSScriptAnalyzer";
-        return {
-            id: `psscriptanalyzer-${rule}-${item.Line}`,
-            message: `[${rule}] ${item.Message}`,
-            filePath,
-            line: item.Line,
-            column: item.Column ?? 1,
-            severity,
-            semantic: severity === "error" ? "blocking" : "warning",
-            tool: "psscriptanalyzer",
-            rule,
-            fixable: false,
-        };
-    });
-}
-const psScriptAnalyzerRunner = {
-    id: "psscriptanalyzer",
-    appliesTo: ["powershell"],
-    priority: PRIORITY.GENERAL_ANALYSIS,
-    skipTestFiles: false,
-    async run(ctx) {
-        const cmd = await resolvePowerShellCmd();
-        if (!cmd)
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        if (!(await checkModuleAvailable(cmd))) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        let execLatch = psExecLatchByCmd.get(cmd);
-        if (!execLatch) {
-            execLatch = createAvailabilityLatch();
-            psExecLatchByCmd.set(cmd, execLatch);
-        }
-        // A durably blocked `-File` execution (an execution policy, typically) is
-        // a fact about the interpreter, not about any one file -- re-spawning on
-        // every save would just re-confirm the same policy every time (#1540).
-        if (execLatch.read() === false) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        const cwd = resolveRunnerCwd(ctx, "psscriptanalyzer");
-        const absPath = path.resolve(cwd, ctx.filePath);
-        // Write script to temp file so we avoid cmd.exe quoting entirely
-        const tmpScript = path.join(os.tmpdir(), `pi-lens-psa-${process.pid}.ps1`);
-        await fs.writeFile(tmpScript, PS_SCRIPT, "utf-8");
-        try {
-            const sampler = startHostStallSampler();
-            const startedAt = Date.now();
-            const result = await spawnPs(cmd, [
-                "-NoProfile",
-                "-NonInteractive",
-                "-File",
-                tmpScript,
-                "-FilePath",
-                absPath,
-            ], { timeoutMs: PS_TIMEOUT_MS, cwd });
-            const hostStallMs = sampler.stop();
-            const elapsedMs = Date.now() - startedAt;
-            // The two probes above use `-Command`, which PowerShell's execution
-            // policy does not gate; this run uses `-File`, which it does. A
-            // crashed/signal-killed process (#1540 second gap) or a blocked/
-            // erroring run (#1540 primary gap) must both produce a recorded,
-            // legible availability_decision -- never a silent "clean" read of
-            // empty stdout, and never a silent skip.
-            if (result.status === null) {
-                const classified = classifyProbeFailure(result, { hostStallMs });
-                let { outcome, cause } = classified;
-                // A `spawn UNKNOWN`/EMFILE/crash never ran the script, so it is not
-                // evidence that `-File` is broken (mirrors the nonzero-exit guard
-                // below, and checkModuleAvailable's own guard against over-latching
-                // an unclassified failure). Latching an unspawnable prober's
-                // verdict would durably disable analysis for the whole session on
-                // a host where `-File` works fine.
-                if (outcome !== "transient") {
-                    outcome = "transient";
-                    cause = "probe-rejected";
-                }
-                notePsDecision(execLatch, "psscriptanalyzer-exec", {
-                    available: false,
-                    outcome,
-                    cause,
-                    elapsedMs,
-                    hostStallMs,
-                });
-                incrementDegradationCount({
-                    kind: "grammar-blocked",
-                    subject: "psscriptanalyzer",
-                    reason: `PowerShell (${cmd}) -File analysis exited with no status -- crash or signal-killed process`,
-                });
-                return { status: "skipped", diagnostics: [], semantic: "none" };
-            }
-            if (result.status !== 0) {
-                const stderrText = result.stderr ?? "";
-                // Require the SecurityError/UnauthorizedAccess pairing that a real
-                // script-load block produces, not a bare "unauthorizedaccess"
-                // match (#1556 review F4) -- that word alone also appears in
-                // unrelated file-permission and access-denied stderr that has
-                // nothing to do with the execution policy, and misclassifying it
-                // as `policy-denied` would latch analysis off durably for a
-                // transient, per-file permission error.
-                const policyDenied = /securityerror/i.test(stderrText) &&
-                    (/execution polic(y|ies)/i.test(stderrText) ||
-                        /running scripts is disabled/i.test(stderrText) ||
-                        /unauthorizedaccess/i.test(stderrText));
-                const classified = classifyProbeFailure(result, { hostStallMs });
-                let { outcome, cause } = classified;
-                if (policyDenied) {
-                    // Direct, unambiguous evidence: PowerShell's own execution
-                    // policy refused to load the script. Durable until the policy
-                    // changes, so this is the one case allowed to latch.
-                    outcome = "non-installable";
-                    cause = "policy-denied";
-                }
-                else if (outcome !== "transient") {
-                    // A single nonzero exit is not durable evidence that `-File`
-                    // is broken for every file (mirrors checkModuleAvailable's own
-                    // guard against over-latching an unclassified failure).
-                    outcome = "transient";
-                    cause = "probe-rejected";
-                }
-                notePsDecision(execLatch, "psscriptanalyzer-exec", {
-                    available: false,
-                    outcome,
-                    cause,
-                    elapsedMs,
-                    hostStallMs,
-                });
-                incrementDegradationCount({
-                    kind: "grammar-blocked",
-                    subject: "psscriptanalyzer",
-                    reason: policyDenied
-                        ? `PowerShell execution policy blocked -File analysis for ${cmd}: ${stderrText.trim().split("\n")[0] || "SecurityError"}`
-                        : `PowerShell -File analysis for ${cmd} exited ${result.status}: ${stderrText.trim().slice(0, 200) || "no stderr"}`,
-                });
-                return { status: "skipped", diagnostics: [], semantic: "none" };
-            }
-            // `-File` ran and exited 0: direct proof it works. Log the decision
-            // once (memoized by the latch) rather than on every save.
-            if (execLatch.read() === null) {
-                notePsDecision(execLatch, "psscriptanalyzer-exec", {
-                    available: true,
-                    elapsedMs,
-                    hostStallMs,
-                });
-            }
-            const diagnostics = parsePSAnalyzerOutput(result.stdout, ctx.filePath);
-            if (diagnostics === null) {
-                // Exit 0 proves `-File` itself ran, so this does NOT reuse the
-                // exec latch above -- one bad read says nothing durable about the
-                // interpreter (mirrors the nonzero-exit branch's own guard against
-                // over-latching an unclassified failure), and it is logged rather
-                // than latched. It must still never be read as a clean file
-                // (#1598): empty/malformed stdout on a successful exit is a lost
-                // or truncated write, not evidence of zero diagnostics.
-                const unreadableReason = result.stdout.trim() ? "unparseable" : "empty";
-                logAvailabilityDecision({
-                    tool: "psscriptanalyzer-stdout",
-                    verdict: "unavailable",
-                    outcome: "transient",
-                    cause: "empty-result",
-                    elapsedMs,
-                    latched: false,
-                    hostStallMs,
-                    budgetMs: PS_TIMEOUT_MS,
-                    // A read of the process's own stdout, not classifyProbeFailure, is
-                    // what decided this (#2209).
-                    classifiedBy: "caller",
-                });
-                incrementDegradationCount({
-                    kind: "grammar-blocked",
-                    subject: "psscriptanalyzer",
-                    reason: `PowerShell -File analysis for ${cmd} exited 0 but stdout was ${unreadableReason}`,
-                });
-                return { status: "skipped", diagnostics: [], semantic: "none" };
-            }
-            if (diagnostics.length === 0) {
-                return { status: "succeeded", diagnostics: [], semantic: "none" };
-            }
-            const hasErrors = diagnostics.some((d) => d.severity === "error");
-            return {
-                status: hasErrors ? "failed" : "succeeded",
-                diagnostics,
-                semantic: hasErrors ? "blocking" : "warning",
-            };
-        }
-        finally {
-            await fs.unlink(tmpScript).catch(() => { });
-        }
-    },
-};
-export default psScriptAnalyzerRunner;

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

@@ -1,169 +0,0 @@
-/**
- * Pyright runner for dispatch system
- *
- * Provides real Python type-checking (not just linting).
- * Catches type errors like: result: str = add(1, 2)  # Type "int" not assignable to "str"
- *
- * Requires: pyright (pip install pyright or npm install -g pyright)
- */
-import { logExtension } from "../../extension-log.js";
-import { getLSPService } from "../../lsp/index.js";
-import { augmentPythonEnvironment, detectPythonEnvironment, } from "../../python-environment.js";
-import { safeSpawnAsync } from "../../safe-spawn.js";
-import { resolveRunnerCwd } from "../../tool-cwd.js";
-import { PRIORITY } from "../priorities.js";
-import { createAvailabilityChecker, resolveAvailableOrInstall, } from "./utils/runner-helpers.js";
-import { finishParsedRun } from "./utils/tool-failure.js";
-const pyright = createAvailabilityChecker("pyright", ".exe");
-const pyrightRunner = {
-    id: "pyright",
-    appliesTo: ["python"],
-    priority: PRIORITY.LSP_FALLBACK,
-    timeoutMs: 75_000,
-    async run(ctx) {
-        // Always allow pyright CLI fallback even when LSP is enabled.
-        // LSP can be present but still fail transiently for a file; in that case,
-        // pyright provides a resilient second signal path.
-        // When LSP is enabled (not disabled via --no-lsp), connect to the LSP service for this file
-        if (!ctx.pi.getFlag("no-lsp")) {
-            const lspService = getLSPService();
-            await lspService.getClientForFile(ctx.filePath);
-        }
-        const cwd = resolveRunnerCwd(ctx, "pyright");
-        // Get pyright command - try multiple strategies
-        let cmd = null;
-        // Strategy 1: Check cached availability (fast path)
-        if (await pyright.isAvailableAsync(cwd)) {
-            cmd = pyright.getCommand(cwd);
-        }
-        // Strategy 2: use the shared availability taxonomy and install suppression.
-        if (!cmd) {
-            const installedPath = await resolveAvailableOrInstall(pyright, "pyright", cwd);
-            if (installedPath)
-                cmd = installedPath;
-        }
-        // Strategy 3: Direct PATH check (handles module cache staleness)
-        if (!cmd) {
-            const { findCommandAsync } = await import("../../safe-spawn.js");
-            const foundCmd = await findCommandAsync("pyright");
-            if (foundCmd)
-                cmd = foundCmd;
-        }
-        // If still no pyright, skip this runner
-        if (!cmd) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        // Pyright's Node CLI falls back to `python` on PATH when the project has no
-        // explicit Pyright config. Apply the same environment the Python LSP uses so
-        // a conventional project .venv resolves without shell activation.
-        const pythonEnvironment = await detectPythonEnvironment(cwd);
-        const env = augmentPythonEnvironment(process.env, pythonEnvironment);
-        const result = await safeSpawnAsync(cmd, ["--outputjson", ctx.filePath], {
-            timeout: 60000,
-            cwd,
-            env,
-        });
-        // Pyright returns non-zero when errors found, that's OK
-        if (result.error) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        const output = (result.stdout || "").trim();
-        if (!output) {
-            // Empty stdout with a nonzero exit and stderr chatter is an unreadable
-            // report of problems, never clean (#1839). The helper turns that into
-            // failed + parse-error; exit 0 stays clean.
-            return finishParsedRun({
-                tool: "pyright",
-                ctx,
-                result,
-                diagnostics: [],
-            });
-        }
-        try {
-            const data = JSON.parse(output);
-            const diagnostics = parsePyrightOutput(data, ctx.filePath);
-            return finishParsedRun({
-                tool: "pyright",
-                ctx,
-                result,
-                diagnostics,
-                classify: (diagnostics) => {
-                    const hasErrors = diagnostics.some((d) => d.severity === "error");
-                    return {
-                        status: hasErrors ? "failed" : "succeeded",
-                        semantic: hasErrors ? "blocking" : "warning",
-                    };
-                },
-            });
-            // pi-lens-ignore: missing-error-propagation
-        }
-        catch {
-            logExtension({
-                subsystem: "runner:pyright",
-                message: `JSON parse failed for ${ctx.filePath} — raw output: ${output.slice(0, 200)}`,
-                metadata: { filePath: ctx.filePath },
-            });
-            return {
-                status: "failed",
-                diagnostics: [],
-                semantic: "none",
-                rawOutput: output.slice(0, 500),
-            };
-        }
-    },
-};
-/**
- * Map pyright's own severity vocabulary onto the four-tier `Diagnostic.severity`
- * (clients/dispatch/types.ts), the same way `normalizeBiomeSeverity` does for
- * biome-check (#1791) and `normalizeRuleSeverity` does for ast-grep-napi
- * (#1787). Pyright names its info tier `"information"`; `"error"`/`"warning"`
- * pass through as-is. An unrecognized value falls back to `"warning"` — the
- * tier every pyright diagnostic reported at before this fix, so reviving the
- * info tier never silently demotes an existing finding. Pyright has no
- * `"hint"` tier in its own vocabulary, so that tier is unreachable here.
- */
-export function normalizePyrightSeverity(raw) {
-    switch (raw) {
-        case "error":
-            return "error";
-        case "information":
-            return "info";
-        // "warning" and any unrecognized value fall back below — the tier
-        // every pyright diagnostic reported at before this fix, so reviving
-        // the info tier never silently demotes an existing finding. There is
-        // no separate `case "warning"` branch: it would be redundant with
-        // this default and unprovable as its own branch.
-        default:
-            return "warning";
-    }
-}
-export function parsePyrightOutput(data, _filePath) {
-    const diagnostics = [];
-    // Pyright JSON output has generalDiagnostics array
-    const generalDiags = data.generalDiagnostics || [];
-    for (const diag of generalDiags) {
-        // Skip if not for this file (pyright may output diagnostics for imports)
-        // For now, include all - caller will filter if needed
-        // pyright's `range.start.line`/`character` are zero-based (see the
-        // `PyrightDiagnostic` note above); `Diagnostic.line`/`column` are
-        // one-based, the same convention ast-grep-napi and taplo already
-        // convert to (`range.start.line + 1`). `range` itself is omitted when
-        // pyright has nothing to point at, so both fall back to line 1.
-        const start = diag.range?.start;
-        diagnostics.push({
-            id: `pyright-${diag.rule || start?.line || "unknown"}`,
-            message: diag.message || "Type error",
-            filePath: diag.file || _filePath,
-            line: (start?.line ?? 0) + 1,
-            column: (start?.character ?? 0) + 1,
-            severity: normalizePyrightSeverity(diag.severity),
-            // Blocking classification stays error-only — reviving the info tier
-            // must never widen what fails a turn.
-            semantic: diag.severity === "error" ? "blocking" : "warning",
-            tool: "pyright",
-            rule: diag.rule,
-        });
-    }
-    return diagnostics;
-}
-export default pyrightRunner;