@herbertgao/pi-extensions 2026.10.1 → 2026.10.2

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

@@ -1,414 +0,0 @@
-/**
- * Oxlint runner for dispatch system
- *
- * Fast JavaScript/TypeScript linter written in Rust.
- * Drop-in replacement for ESLint with better performance.
- *
- * Requires: oxlint (npm install -g oxlint)
- */
-import * as path from "node:path";
-import { findLocalBinUpwards } from "../../package-manager.js";
-import { pathsEqual } from "../../path-utils.js";
-import { safeSpawnAsync } from "../../safe-spawn.js";
-import { resolveRunnerCwd } from "../../tool-cwd.js";
-import { truncatedByOutputCap } from "../../spawn-output-cap.js";
-import { getJstsLintPolicyForCwd, hasVitePlusConfig, } from "../../tool-policy.js";
-import { PRIORITY } from "../priorities.js";
-import { resolveToolCommand, resolveToolCommandWithInstallFallback, } from "./utils/runner-helpers.js";
-import { finishParsedRun, parseToolRun } from "./utils/tool-failure.js";
-// One file's JSON report. Nothing legitimate approaches 8 MiB here, so this is
-// a blast-radius bound on a runaway or wedged oxlint rather than a working
-// limit — the same value MAX_SG_OUTPUT_BYTES and MAX_REPORT_BYTES use, and what
-// makes `outputTruncated` reachable for this runner at all (#2100).
-const MAX_OXLINT_OUTPUT_BYTES = 8 * 1024 * 1024;
-const OXLINT_NO_FILES = Symbol("oxlint-no-files");
-const OXLINT_NO_FILES_UNCONFIRMED = Symbol("oxlint-no-files-unconfirmed");
-const OXLINT_NO_FILES_BANNER = "No files found to lint. Please check your paths and ignore patterns.";
-const OXLINT_NO_FILES_REPORT_KEYS = new Set([
-    "diagnostics",
-    "number_of_files",
-    "number_of_rules",
-    "threads_count",
-    "start_time",
-]);
-/**
- * Vite+'s `vp` from the project's own `node_modules/.bin`.
- *
- * Delegates to THE shared bin walker (#2544 review F1). This was a private,
- * UNCEILINGED copy of that walk, while `formatters.ts`'s `oxfmtFormatter`
- * resolved the SAME binary — `vp` — through the ceilinged `findInNodeModules`:
- * one `vp` resolver stopped at `$HOME` and the other climbed past it to the
- * filesystem root, so which policy applied depended on whether the format path
- * or the lint path asked. A `node_modules/.bin/vp` at or above `$HOME` can
- * never be this project's own Vite+ install (#2514).
- */
-function resolveLocalVp(cwd) {
-    return findLocalBinUpwards("vp", cwd) ?? null;
-}
-async function resolveVitePlusCommand(cwd) {
-    const local = resolveLocalVp(cwd);
-    if (local)
-        return local;
-    const version = await safeSpawnAsync("vp", ["--version"], {
-        timeout: 5000,
-        cwd,
-    });
-    return !version.error && version.status === 0 ? "vp" : null;
-}
-const oxlintRunner = {
-    id: "oxlint",
-    appliesTo: ["jsts"],
-    priority: PRIORITY.LINT_SECONDARY,
-    skipTestFiles: false,
-    async run(ctx) {
-        const cwd = resolveRunnerCwd(ctx, "oxlint");
-        const policy = getJstsLintPolicyForCwd(cwd);
-        if (!policy.preferredRunners.includes("oxlint")) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        let cmd = null;
-        let args;
-        if (hasVitePlusConfig(cwd)) {
-            cmd = await resolveVitePlusCommand(cwd);
-        }
-        if (cmd) {
-            args = ["lint", "--format", "json", ctx.filePath];
-        }
-        else {
-            // Use ctx.hasTool for async availability check — avoids the synchronous
-            // spawnSync probe that blocks the event loop on first call per cwd.
-            // FactStore caches the result for the session so subsequent writes are free.
-            const oxlintCmd = resolveToolCommand(cwd, "oxlint") ?? "oxlint";
-            cmd = (await ctx.hasTool(oxlintCmd))
-                ? oxlintCmd
-                : await resolveToolCommandWithInstallFallback(cwd, "oxlint");
-            args = ["--format", "json", ctx.filePath];
-        }
-        if (!cmd) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        // Run oxlint (or Vite+'s vp lint wrapper) on the file.
-        const result = await safeSpawnAsync(cmd, args, {
-            cwd,
-            timeout: 30000,
-            maxOutputBytes: MAX_OXLINT_OUTPUT_BYTES,
-        });
-        // Oxlint exits 0 whenever nothing at ERROR severity was found — that
-        // includes a run that found only warnings, its own default severity
-        // (#1947). A run that found nothing at all also exits 0, but still
-        // prints a report with an empty `diagnostics` array, so parsing
-        // unconditionally and branching on the parsed count (below) tells the
-        // two apart instead of the exit code discarding the warning case.
-        //
-        // Parse JSON output. Fall back to the unix-format parser if JSON parsing
-        // fails (older oxlint versions, malformed stderr noise, etc.) — keeps the
-        // runner producing diagnostics even when the structured-fix metadata is
-        // unavailable.
-        const stdout = result.stdout ?? "";
-        const stderr = result.stderr ?? "";
-        const parsedOutput = stdout + stderr;
-        const noFilesDecision = decideOxlintNoFiles(result, stdout, stderr);
-        // #1994's shared gate classifies invocation and parsed-output failures.
-        // The private markers preserve one legitimate nonzero/empty shape and
-        // force a status-0 lookalike away from clean. Neither escapes this runner.
-        // parseToolRun checks process failures before invoking this parser, so
-        // spawn/timeout/killed/signal precedence remains owned by #1994.
-        const parsedRun = parseToolRun("oxlint", {
-            result,
-            output: parsedOutput,
-            // EXIT TABLE (oxlint 0.8 measured fixture): 0 clean; 1 findings; 2 error; other nonzero rejected.
-            exitCodes: { ran: [1, 2] },
-        }, () => {
-            if (noFilesDecision.kind === "expected-no-files") {
-                return [OXLINT_NO_FILES];
-            }
-            if (noFilesDecision.kind === "unconfirmed-no-files" &&
-                result.status === 0) {
-                return [OXLINT_NO_FILES_UNCONFIRMED];
-            }
-            let parsed = parseOxlintJson(stdout, ctx.filePath, cwd);
-            if (parsed.length === 0 && stdout.length > 0) {
-                parsed = parseOxlintUnix(parsedOutput, ctx.filePath, cwd);
-            }
-            return parsed;
-        }, { parseOutput: parsedOutput });
-        if (parsedRun.skipped)
-            return parsedRun.skipped;
-        if (parsedRun.diagnostics.includes(OXLINT_NO_FILES)) {
-            // Real captured bytes show oxlint exits
-            // 1 with "No files found" + number_of_files: 0 when a config excludes
-            // the target, so "nonzero exit" alone cannot mean "unreadable report
-            // of problems" until the no-files shape is ruled out.
-            // Read BEFORE reporting "succeeded" — a config (root's or a nested
-            // one nearer the file, per oxlint's own discovery) that ignores this
-            // file reports the same empty diagnostics array a clean file does.
-            // "succeeded"/"none" would say "we checked, it's clean"; this file
-            // was never checked at all.
-            return {
-                status: "skipped",
-                diagnostics: [],
-                semantic: "none",
-                skipReason: "no-files-matched",
-            };
-        }
-        if (parsedRun.diagnostics.includes(OXLINT_NO_FILES_UNCONFIRMED)) {
-            const reason = noFilesDecision.kind === "unconfirmed-no-files"
-                ? noFilesDecision.reason
-                : "status-zero";
-            return {
-                status: "failed",
-                diagnostics: [
-                    {
-                        id: `oxlint:no-files-unconfirmed:${reason}`,
-                        message: `oxlint no-files report was not canonical (${reason})`,
-                        filePath: ctx.filePath,
-                        line: 1,
-                        column: 1,
-                        severity: "warning",
-                        semantic: "warning",
-                        tool: "oxlint",
-                    },
-                ],
-                semantic: "warning",
-                failureKind: "unconfirmed_output",
-                failureMessage: `no-files-${reason}`,
-            };
-        }
-        const diagnostics = parsedRun.diagnostics.filter((diagnostic) => diagnostic !== OXLINT_NO_FILES &&
-            diagnostic !== OXLINT_NO_FILES_UNCONFIRMED);
-        // A warning-only result on exit 0 is oxlint's normal outcome, not a
-        // failure: exit 0 means nothing hit ERROR severity. `status: "failed"`
-        // here would stop this arm from reporting "succeeded", which breaks two
-        // things downstream — plan.ts's ["eslint", "oxlint", "biome-check-json"]
-        // fallback group only stops at the first `status: "succeeded"` runner
-        // (dispatcher.ts's `runGroup`), so biome-check-json would run again on
-        // every warning-only save (extra spawns, a possible install, duplicate
-        // findings); and it would mismatch the sibling convention (biome-check,
-        // golangci-lint, rubocop) of keying `status` off blocking severity, not
-        // off the tool's raw exit code. The findings themselves still reach the
-        // delivery pipeline regardless of `status` — dispatcher.ts buckets by
-        // each diagnostic's own `semantic`, so a warning stays a warning.
-        return finishParsedRun({
-            tool: "oxlint",
-            ctx,
-            result,
-            diagnostics,
-            classify: (diagnostics) => {
-                const hasBlocking = diagnostics.some((d) => d.semantic === "blocking");
-                return {
-                    status: !hasBlocking && result.status === 0 ? "succeeded" : "failed",
-                    semantic: hasBlocking ? "blocking" : "warning",
-                };
-            },
-        });
-    },
-};
-function oxlintProcessState(result) {
-    const failureKind = result.spawnFailure?.kind;
-    if (truncatedByOutputCap(result))
-        return "truncated";
-    if (result.failure === "timeout" || failureKind === "timeout")
-        return "timeout";
-    if (result.failure === "aborted" || failureKind === "killed")
-        return "killed";
-    if (result.signal || result.failure === "signal")
-        return "signal";
-    if (result.failure === "spawn" || result.error)
-        return "spawn";
-    return "normal";
-}
-function isNonnegativeInteger(value) {
-    return Number.isInteger(value) && value >= 0;
-}
-function isPositiveInteger(value) {
-    return Number.isInteger(value) && value >= 1;
-}
-function isNonnegativeFinite(value) {
-    return typeof value === "number" && Number.isFinite(value) && value >= 0;
-}
-/**
- * One decision seam for every oxlint no-files axis (#1998).
- *
- * Real oxlint 1.79.0 establishes the only expected shape: a normal completed
- * process, exit 1, empty stderr, the exact no-files banner, and a JSON object
- * containing exactly the five captured summary fields with canonical types
- * and ranges. Diagnostics must be empty and `number_of_files` must be zero.
- *
- * Any process-control evidence wins before report bytes. Any no-files
- * lookalike that differs on status, stderr, banner, JSON syntax/schema,
- * diagnostics, or file count is unconfirmed rather than clean. A report with
- * no no-files evidence remains an ordinary oxlint report for the normal parser.
- */
-export function decideOxlintNoFiles(result, stdout, stderr) {
-    const processState = oxlintProcessState(result);
-    if (processState !== "normal") {
-        return {
-            kind: "unconfirmed-no-files",
-            reason: `process-${processState}`,
-        };
-    }
-    const jsonStart = stdout.indexOf("{");
-    const bannerText = (jsonStart === -1 ? stdout : stdout.slice(0, jsonStart)).trim();
-    const banner = bannerText === OXLINT_NO_FILES_BANNER
-        ? "exact"
-        : /no files found.+lint/i.test(bannerText)
-            ? "near"
-            : "missing";
-    let report;
-    let jsonMalformed = jsonStart === -1;
-    if (jsonStart !== -1) {
-        try {
-            const parsed = JSON.parse(stdout.slice(jsonStart));
-            if (typeof parsed === "object" &&
-                parsed !== null &&
-                !Array.isArray(parsed)) {
-                report = parsed;
-            }
-            else {
-                jsonMalformed = true;
-            }
-        }
-        catch {
-            jsonMalformed = true;
-        }
-    }
-    const hasFileCount = report !== undefined &&
-        Object.prototype.hasOwnProperty.call(report, "number_of_files");
-    const fileCount = report?.number_of_files;
-    const hasNoFilesEvidence = banner !== "missing" ||
-        (hasFileCount && (fileCount === 0 || !isNonnegativeInteger(fileCount)));
-    if (!hasNoFilesEvidence)
-        return { kind: "ordinary-report" };
-    if (result.status == null) {
-        return { kind: "unconfirmed-no-files", reason: "status-null" };
-    }
-    if (result.status === 0) {
-        return { kind: "unconfirmed-no-files", reason: "status-zero" };
-    }
-    if (result.status !== 1) {
-        return { kind: "unconfirmed-no-files", reason: "status-other" };
-    }
-    if (stderr.trim().length > 0) {
-        return { kind: "unconfirmed-no-files", reason: "stderr-nonempty" };
-    }
-    if (banner === "near") {
-        return { kind: "unconfirmed-no-files", reason: "banner-near" };
-    }
-    if (banner === "missing") {
-        return { kind: "unconfirmed-no-files", reason: "banner-missing" };
-    }
-    if (jsonMalformed || !report) {
-        return { kind: "unconfirmed-no-files", reason: "json-malformed" };
-    }
-    const keys = Object.keys(report);
-    if (keys.some((key) => !OXLINT_NO_FILES_REPORT_KEYS.has(key))) {
-        return { kind: "unconfirmed-no-files", reason: "json-unknown-key" };
-    }
-    if (OXLINT_NO_FILES_REPORT_KEYS.size !== keys.length ||
-        [...OXLINT_NO_FILES_REPORT_KEYS].some((key) => !Object.prototype.hasOwnProperty.call(report, key))) {
-        return { kind: "unconfirmed-no-files", reason: "json-missing-key" };
-    }
-    if (!Array.isArray(report.diagnostics) ||
-        !isNonnegativeInteger(report.number_of_files) ||
-        !isNonnegativeInteger(report.number_of_rules) ||
-        !isPositiveInteger(report.threads_count) ||
-        !isNonnegativeFinite(report.start_time)) {
-        return {
-            kind: "unconfirmed-no-files",
-            reason: "json-known-field-invalid",
-        };
-    }
-    if (report.diagnostics.length > 0) {
-        return { kind: "unconfirmed-no-files", reason: "diagnostics-nonempty" };
-    }
-    if (report.number_of_files !== 0) {
-        return { kind: "unconfirmed-no-files", reason: "files-nonzero" };
-    }
-    return { kind: "expected-no-files" };
-}
-// Oxlint codes look like "eslint(no-debugger)" or "oxc(approx-constant)".
-// Strip the plugin prefix so the rule lines up with what users expect.
-// indexOf-based extraction avoids a regex hot-spot Sonar flagged for
-// potential super-linear backtracking on adversarial inputs.
-function extractOxlintRule(code) {
-    if (!code)
-        return "unknown";
-    const open = code.indexOf("(");
-    if (open === -1)
-        return code;
-    const close = code.indexOf(")", open + 1);
-    if (close === -1 || close === open + 1)
-        return code;
-    return code.slice(open + 1, close);
-}
-function parseOxlintJson(raw, filePath, cwd) {
-    const trimmed = raw.trim();
-    if (!trimmed.startsWith("{"))
-        return [];
-    let parsed;
-    try {
-        parsed = JSON.parse(trimmed);
-    }
-    catch {
-        return [];
-    }
-    if (!Array.isArray(parsed.diagnostics))
-        return [];
-    const diagnostics = [];
-    const absTarget = path.resolve(cwd, filePath);
-    for (const d of parsed.diagnostics) {
-        if (!d.filename || !pathsEqual(path.resolve(cwd, d.filename), absTarget)) {
-            continue;
-        }
-        const rule = extractOxlintRule(d.code);
-        const label = d.labels?.[0]?.span;
-        const lineNum = label?.line ?? 1;
-        const colNum = label?.column ?? 1;
-        const severity = d.severity === "error" ? "error" : "warning";
-        const help = d.help?.trim();
-        diagnostics.push({
-            id: `oxlint-${rule}-${lineNum}`,
-            message: `${d.message ?? "oxlint issue"} (${rule})`,
-            filePath,
-            line: lineNum,
-            column: colNum,
-            severity,
-            semantic: severity === "error" ? "blocking" : "warning",
-            tool: "oxlint",
-            rule,
-            // Oxlint's help text is rule-specific guidance ("Remove the debugger
-            // statement", "Consider removing this declaration"). Surface it as a
-            // fix suggestion so the warning becomes actionable instead of falling
-            // silently into code-quality.
-            fixSuggestion: help && help.length > 0 ? help : undefined,
-        });
-    }
-    return diagnostics;
-}
-function parseOxlintUnix(raw, filePath, cwd) {
-    const diagnostics = [];
-    const absTarget = path.resolve(cwd, filePath);
-    for (const line of raw.split("\n")) {
-        // Parse: file:line:column: message (rule)
-        const match = line.match(/^(.+):(\d+):(\d+):\s*(.+?)\s*\(([^)]+)\)$/);
-        if (match) {
-            const [, reportedPath, lineStr, _col, message, rule] = match;
-            if (!reportedPath || !lineStr || !message || !rule)
-                continue;
-            if (!pathsEqual(path.resolve(cwd, reportedPath), absTarget))
-                continue;
-            diagnostics.push({
-                id: `oxlint-${rule}-${lineStr}`,
-                message: `${message} (${rule})`,
-                filePath,
-                line: parseInt(lineStr, 10),
-                severity: "warning",
-                semantic: "warning",
-                tool: "oxlint",
-                rule,
-            });
-        }
-    }
-    return diagnostics;
-}
-export default oxlintRunner;

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

@@ -1,85 +0,0 @@
-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 } from "./utils/runner-helpers.js";
-import { finishParsedRun, parseToolRun } from "./utils/tool-failure.js";
-// PHP's `-l` exit contract, declared HERE rather than in the shared classifier
-// (#3291 r3): an admission is a property of this tool. The manual documents
-// `-l` as syntax-check-only with a nonzero return on failure; the captured
-// PHP 8.3.32 wire exits 1 in the usual CLI path and 255 (the shell reading of
-// PHP's documented -1) for the parse-error wire. Both are completed analyses
-// whose output must reach the parser; any other nonzero status stays a
-// rejected invocation.
-const PHP_LINT_EXIT_CODES = { ran: [1, 255] };
-const php = createAvailabilityChecker("php", ".exe");
-function parsePhpLintOutput(raw, filePath, cwd) {
-    const output = raw.trim();
-    if (!output || !/(?:PHP )?Parse error:/i.test(output))
-        return [];
-    const lineMatch = output.match(/on line (\d+)/i);
-    const messageMatch = output.match(/PHP Parse error:\s*(.+?)(?:\s+in\s+(.+?)\s+on line \d+)?$/im) ??
-        output.match(/Parse error:\s*(.+?)(?:\s+in\s+(.+?)\s+on line \d+)?$/im);
-    // #3295: PHP names the file it could not parse in the same sentence. `php -l`
-    // follows no includes today, so this drops nothing under our argv — it pins
-    // the attribution the parser was asserting without asking.
-    const reported = messageMatch?.[2]?.trim();
-    if (reported &&
-        !pathsEqual(path.resolve(cwd, reported), path.resolve(cwd, filePath)))
-        return [];
-    return [
-        {
-            id: `php-lint:${lineMatch?.[1] ?? "1"}`,
-            message: messageMatch?.[1]?.trim() ?? output,
-            filePath,
-            line: lineMatch ? Number.parseInt(lineMatch[1], 10) : 1,
-            column: 1,
-            severity: "error",
-            semantic: "blocking",
-            tool: "php-lint",
-            rule: "syntax",
-            fixable: false,
-        },
-    ];
-}
-const phpLintRunner = {
-    id: "php-lint",
-    appliesTo: ["php"],
-    priority: PRIORITY.GENERAL_ANALYSIS,
-    skipTestFiles: false,
-    async run(ctx) {
-        const cwd = resolveRunnerCwd(ctx, "php-lint");
-        if (!(await php.isAvailableAsync(cwd))) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        const cmd = php.getCommand(cwd);
-        if (!cmd) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        const absPath = path.resolve(cwd, ctx.filePath);
-        const result = await safeSpawnAsync(cmd, ["-l", absPath], {
-            timeout: 15000,
-            cwd,
-        });
-        // `output` is what the classifier judges AND what the parser reads: the
-        // parse error arrives on stderr, so both streams are one wire here. The
-        // exit table rides in this same per-runner input, never in a shared
-        // option (#3291 r3).
-        const run = parseToolRun("php-lint", {
-            result,
-            output: `${result.stdout ?? ""}\n${result.stderr ?? ""}`,
-            exitCodes: PHP_LINT_EXIT_CODES,
-        }, (output) => parsePhpLintOutput(output, ctx.filePath, cwd));
-        if (run.skipped)
-            return run.skipped;
-        return finishParsedRun({
-            tool: "php-lint",
-            ctx,
-            result,
-            diagnostics: run.diagnostics,
-            classify: () => ({ status: "failed", semantic: "blocking" }),
-        });
-    },
-};
-export default phpLintRunner;

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

@@ -1,120 +0,0 @@
-import * as path from "node:path";
-import { safeSpawnAsync } from "../../safe-spawn.js";
-import { resolveRunnerCwd } from "../../tool-cwd.js";
-import { getLinterPolicyForCwd, hasPhpstanConfig } from "../../tool-policy.js";
-import { PRIORITY } from "../priorities.js";
-import { createAvailabilityChecker, resolveVendorToolCommand, } from "./utils/runner-helpers.js";
-import { parseToolRun } from "./utils/tool-failure.js";
-import { finishParsedRun } from "./utils/tool-failure.js";
-// EXIT TABLE (PHPStan 1.12 docs https://phpstan.org/user-guide/command-line-usage): 0 = no errors, 1 = errors found, 2 = a
-// fatal/internal error that stopped the analysis. Only 1 is a run that carries
-// findings.
-const PHPSTAN_EXIT_CODES = { ran: [1] };
-const phpstan = createAvailabilityChecker("phpstan", ".phar");
-// phpstan analyses the target file PLUS its dependency closure and keys errors
-// by the real file in `output.files`. Attribute each diagnostic to that key
-// (resolved against cwd) rather than blanket-stamping ctx.filePath — otherwise a
-// cross-file regression is mis-located onto the edited file (#265 A3). We do NOT
-// filter to the edited file: surfacing the cross-file impact is the point.
-export function parsePhpstanJson(raw, fallbackPath, cwd) {
-    try {
-        const output = JSON.parse(raw);
-        const diagnostics = [];
-        for (const [file, fileErrors] of Object.entries(output.files ?? {})) {
-            const filePath = file && file.trim()
-                ? path.isAbsolute(file)
-                    ? file
-                    : path.resolve(cwd, file)
-                : fallbackPath;
-            for (const err of fileErrors?.messages ?? []) {
-                diagnostics.push({
-                    id: `phpstan:${err.line ?? 1}:${err.message.slice(0, 40)}`,
-                    message: err.message,
-                    filePath,
-                    line: err.line ?? 1,
-                    column: 1,
-                    severity: "error",
-                    semantic: "blocking",
-                    tool: "phpstan",
-                    rule: err.identifier || "phpstan",
-                    fixable: false,
-                });
-            }
-        }
-        // #1937 round 2: the top-level `errors[]` array carries phpstan's
-        // FILE-INDEPENDENT findings — internal errors, and ignore patterns that
-        // matched nothing. A run can report `totals.errors: 1` with `files: {}`
-        // and exit 1, and reading only `files` turned that into zero
-        // diagnostics: the same defect class as the `errors`-vs-`messages` bug
-        // above, one level up. Pinned by
-        // tests/fixtures/runner-output/phpstan/top-level-errors.captured.json.
-        //
-        // These have no file or line, so they attach to the edited file at line
-        // 1. That is the honest placement: the reader needs to see them, and
-        // there is nowhere truer to put them.
-        for (const message of output.errors ?? []) {
-            if (typeof message !== "string" || !message.trim())
-                continue;
-            diagnostics.push({
-                id: `phpstan:global:${message.slice(0, 40)}`,
-                message,
-                filePath: fallbackPath,
-                line: 1,
-                column: 1,
-                severity: "error",
-                semantic: "blocking",
-                tool: "phpstan",
-                rule: "phpstan/analysis",
-                fixable: false,
-            });
-        }
-        return diagnostics;
-    }
-    catch {
-        return [];
-    }
-}
-async function resolvePhpstan(cwd) {
-    if (await phpstan.isAvailableAsync(cwd))
-        return phpstan.getCommand(cwd);
-    return resolveVendorToolCommand(cwd, "phpstan", ".bat");
-}
-const phpstanRunner = {
-    id: "phpstan",
-    appliesTo: ["php"],
-    priority: PRIORITY.GENERAL_ANALYSIS,
-    skipTestFiles: false,
-    async run(ctx) {
-        const cwd = resolveRunnerCwd(ctx, "phpstan");
-        const policy = getLinterPolicyForCwd(ctx.filePath, cwd);
-        if (policy && !policy.preferredRunners.includes("phpstan")) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        // Only run if phpstan config present — avoids noisy defaults on unconfigured projects
-        if (!hasPhpstanConfig(cwd)) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        const cmd = await resolvePhpstan(cwd);
-        if (!cmd)
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        const absPath = path.resolve(cwd, ctx.filePath);
-        const result = await safeSpawnAsync(cmd, ["analyse", "--error-format=json", "--no-progress", absPath], { timeout: 30000, cwd });
-        // phpstan exits 0 = no errors, 1 = errors found, 2 = fatal. The fatal
-        // case used to return `skipped` silently; routing it through the shared
-        // seam keeps that verdict and adds the bounded `runner-empty-result` row
-        // (#1816), and the exit-1 case now also records when the JSON report
-        // parses to nothing (#1948) — the shape the error-count-as-array bug had.
-        const run = parseToolRun("phpstan", { result, exitCodes: PHPSTAN_EXIT_CODES }, (out) => parsePhpstanJson(out, ctx.filePath, cwd), { parseOutput: result.stdout ?? "" });
-        if (run.skipped)
-            return run.skipped;
-        const diagnostics = run.diagnostics;
-        return finishParsedRun({
-            tool: "phpstan",
-            ctx,
-            result,
-            diagnostics,
-            classify: () => ({ status: "failed", semantic: "blocking" }),
-        });
-    },
-};
-export default phpstanRunner;

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

@@ -1,62 +0,0 @@
-import * as path from "node:path";
-import { safeSpawnAsync } from "../../safe-spawn.js";
-import { resolveRunnerCwd } from "../../tool-cwd.js";
-import { PRIORITY } from "../priorities.js";
-import { resolveLocalFirstAsync } from "./utils/runner-helpers.js";
-function parsePrismaValidateOutput(raw, filePath) {
-    const output = raw
-        .split("\n")
-        .map((line) => line.trim())
-        .filter(Boolean)
-        .filter((line) => !line.startsWith("Environment variables loaded"))
-        .filter((line) => !line.startsWith("Prisma schema loaded"))
-        .join(" ");
-    if (!output)
-        return [];
-    const message = output.match(/Error:\s*(.+)$/i)?.[1]?.trim() ??
-        output.match(/Validation Error Count:\s*\d+\s*(.+)$/i)?.[1]?.trim() ??
-        output;
-    const lineMatch = output.match(/:(\d+)(?::\d+)?\b/);
-    return [
-        {
-            id: `prisma-validate:${lineMatch?.[1] ?? "1"}`,
-            message,
-            filePath,
-            line: lineMatch ? Number.parseInt(lineMatch[1], 10) : 1,
-            column: 1,
-            severity: "error",
-            semantic: "blocking",
-            tool: "prisma-validate",
-            rule: "schema",
-            fixable: false,
-        },
-    ];
-}
-const prismaValidateRunner = {
-    id: "prisma-validate",
-    appliesTo: ["prisma"],
-    priority: PRIORITY.GENERAL_ANALYSIS,
-    skipTestFiles: false,
-    async run(ctx) {
-        const cwd = resolveRunnerCwd(ctx, "prisma-validate");
-        const resolved = await resolveLocalFirstAsync("prisma", cwd);
-        const absPath = path.resolve(cwd, ctx.filePath);
-        const result = await safeSpawnAsync(resolved.cmd, [...resolved.args, "validate", "--schema", absPath], { timeout: 20000, cwd });
-        if (result.error && !result.stdout && !result.stderr) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        if (result.status === 0) {
-            return { status: "succeeded", diagnostics: [], semantic: "none" };
-        }
-        const diagnostics = parsePrismaValidateOutput(`${result.stdout ?? ""}\n${result.stderr ?? ""}`, ctx.filePath);
-        if (diagnostics.length === 0) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        return {
-            status: "failed",
-            diagnostics,
-            semantic: "blocking",
-        };
-    },
-};
-export default prismaValidateRunner;