@herbertgao/pi-extensions 2026.10.1 → 2026.10.2

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

@@ -1,117 +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 { getLinterPolicyForCwd } 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 htmlhint = createAvailabilityChecker("htmlhint");
-const HTMLHINT_RULES = {
-    "tag-pair": true,
-    "attr-no-duplication": true,
-    "tagname-lowercase": true,
-    "doctype-first": false,
-    "spec-char-escape": true,
-    "id-unique": true,
-};
-function parseHtmlhintOutput(raw, filePath, cwd) {
-    const diagnostics = [];
-    const absTarget = path.resolve(cwd, filePath);
-    // unix format: "file:line:col: message [severity/rule]"
-    const lineRe = /^(.+?):(\d+):(\d+): (.+?) \[(error|warning)\/([^\]]+)\]/;
-    for (const line of raw.split("\n")) {
-        const match = line.match(lineRe);
-        if (!match)
-            continue;
-        if (!pathsEqual(path.resolve(cwd, match[1]), absTarget))
-            continue;
-        const lineNum = parseInt(match[2], 10);
-        const col = parseInt(match[3], 10);
-        const message = match[4].trim();
-        const level = match[5];
-        const rule = match[6].trim();
-        const severity = level === "error" ? "error" : "warning";
-        diagnostics.push({
-            id: `htmlhint-${rule}-${lineNum}`,
-            message,
-            filePath,
-            line: lineNum,
-            column: col,
-            severity,
-            semantic: severity === "error" ? "blocking" : "warning",
-            tool: "htmlhint",
-            rule,
-            fixable: false,
-        });
-    }
-    return diagnostics;
-}
-const htmlhintRunner = {
-    id: "htmlhint",
-    appliesTo: ["html"],
-    priority: PRIORITY.GENERAL_ANALYSIS,
-    skipTestFiles: false,
-    async run(ctx) {
-        const cwd = resolveRunnerCwd(ctx, "htmlhint");
-        const policy = getLinterPolicyForCwd(ctx.filePath, cwd);
-        if (policy && !policy.preferredRunners.includes("htmlhint")) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        let cmd = null;
-        if (await htmlhint.isAvailableAsync(cwd)) {
-            cmd = htmlhint.getCommand(cwd);
-        }
-        else {
-            cmd = await resolveToolCommandWithInstallFallback(cwd, "htmlhint");
-        }
-        if (!cmd) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        // htmlhint's --rules flag takes a comma-separated ruleid list
-        // ("tag-pair,id-class-value=underline"), NOT a JSON object. The old JSON
-        // blob parsed as one bogus rule id, leaving ZERO rules enabled — every
-        // file read CLEAN (exit 0, no output) no matter what it contained.
-        // Root-caused live against htmlhint 1.x after the tier-1 parser smoke
-        // caught htmlhint reporting 0 findings on the planted tag-pair defect.
-        // Entries set to false are omitted: under --rules semantics an unlisted
-        // rule is off, which is exactly what `false` means here.
-        const rulesArg = Object.entries(HTMLHINT_RULES)
-            .flatMap(([rule, enabled]) => (enabled === true ? [rule] : []))
-            .join(",");
-        const result = await safeSpawnAsync(cmd, [
-            "--rules",
-            rulesArg,
-            "--format",
-            "unix",
-            path.resolve(cwd, ctx.filePath),
-        ], { cwd });
-        // #1948: htmlhint exits 1 when it finds errors and prints them in `unix`
-        // format on stdout. Zero parsed out of a nonzero exit is a parser break.
-        const output = result.stdout || result.stderr || "";
-        const run = parseToolRun("htmlhint", {
-            result,
-            output,
-            // EXIT TABLE (HTMLHint 1.1 measured fixture): 0 clean; 1 findings; 2 error; other nonzero rejected.
-            exitCodes: { ran: [1, 2] },
-        }, (out) => parseHtmlhintOutput(out, ctx.filePath, cwd));
-        if (run.skipped)
-            return run.skipped;
-        const diagnostics = run.diagnostics;
-        return finishParsedRun({
-            tool: "htmlhint",
-            ctx,
-            result,
-            diagnostics,
-            classify: (diagnostics) => {
-                const hasErrors = diagnostics.some((d) => d.severity === "error");
-                return {
-                    status: "failed",
-                    semantic: hasErrors ? "blocking" : "warning",
-                };
-            },
-        });
-    },
-};
-export default htmlhintRunner;

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

@@ -1,108 +0,0 @@
-/**
- * Runner definitions for pi-lens dispatch system
- */
-import actionlintRunner from "./actionlint.js";
-import astGrepNapiRunner from "./ast-grep-napi.js";
-import biomeCheckJsonRunner from "./biome-check.js";
-import cppCheckRunner from "./cpp-check.js";
-import credoRunner from "./credo.js";
-import cueVetRunner from "./cue-vet.js";
-import dartAnalyzeRunner from "./dart-analyze.js";
-import detektRunner from "./detekt.js";
-import dotnetBuildRunner from "./dotnet-build.js";
-import elixirCheckRunner from "./elixir-check.js";
-import eslintRunner from "./eslint.js";
-import factRulesRunner from "./fact-rules.js";
-import gleamCheckRunner from "./gleam-check.js";
-import goVetRunner from "./go-vet.js";
-import golangciRunner from "./golangci-lint.js";
-import hadolintRunner from "./hadolint.js";
-import helmLintRunner from "./helm-lint.js";
-import helmRenderRunner from "./helm-render.js";
-import htmlhintRunner from "./htmlhint.js";
-import javacRunner from "./javac.js";
-import ktlintRunner from "./ktlint.js";
-import lspRunner from "./lsp.js";
-import markdownlintRunner from "./markdownlint.js";
-import mypyRunner from "./mypy.js";
-import oxlintRunner from "./oxlint.js";
-import phpLintRunner from "./php-lint.js";
-import phpstanRunner from "./phpstan.js";
-import prismaValidateRunner from "./prisma-validate.js";
-import psScriptAnalyzerRunner from "./psscriptanalyzer.js";
-import pyrightRunner from "./pyright.js";
-import rubocopRunner from "./rubocop.js";
-import ruffRunner from "./ruff.js";
-import rustClippyRunner from "./rust-clippy.js";
-import spotbugsRunner from "./spotbugs.js";
-import shellcheckRunner from "./shellcheck.js";
-import fishIndentRunner from "./fish-indent.js";
-import shfmtRunner from "./shfmt.js";
-import spellcheckRunner from "./spellcheck.js";
-import sqlfluffRunner from "./sqlfluff.js";
-import stylelintRunner from "./stylelint.js";
-import swiftlintRunner from "./swiftlint.js";
-import taploRunner from "./taplo.js";
-import terragruntRunner from "./terragrunt.js";
-import tflintRunner from "./tflint.js";
-import trivyConfigRunner from "./trivy-config.js";
-import valeRunner from "./vale.js";
-// Import tree-sitter runner
-import treeSitterRunner from "./tree-sitter.js";
-import yamllintRunner from "./yamllint.js";
-import zigCheckRunner from "./zig-check.js";
-export function registerDefaultRunners(registry) {
-    // Register all runners (ordered by priority)
-    // Unified LSP runner for all languages (TypeScript, Python, Go, Rust, etc.) - priority 4
-    registry.register(lspRunner); // Unified LSP type-checking for all languages (priority 4)
-    registry.register(pyrightRunner); // Python type-checking (priority 5) - fallback when --lens-lsp disabled
-    registry.register(biomeCheckJsonRunner); // Biome check with JSON output for diagnostic capture (priority 9)
-    registry.register(astGrepNapiRunner); // JS/TS, CSS, and HTML structural analysis via NAPI (priority 15)
-    registry.register(treeSitterRunner); // Tree-sitter structural analysis (priority 14)
-    registry.register(ruffRunner); // Python linting (priority 10)
-    registry.register(shellcheckRunner); // Shell script linting (priority 20)
-    registry.register(spotbugsRunner); // SpotBugs bytecode bug-patterns for Java/Kotlin (flag-gated via withSpotbugsGroup, priority 50)
-    // DISABLED: registerRunner(astGrepRunner); // Replaced by ast-grep-napi for dispatch
-    // CLI ast-grep kept for ast_grep_search/ast_grep_replace tools only
-    registry.register(eslintRunner); // ESLint (priority 12, jsts, config-gated)
-    registry.register(oxlintRunner); // Oxlint (priority 12, jsts, config-aware default fallback)
-    registry.register(golangciRunner); // golangci-lint (priority 20, go, config-gated)
-    registry.register(rubocopRunner); // RuboCop lint (priority 10, ruby)
-    registry.register(spellcheckRunner); // Spellcheck for markdown/docs (priority 30)
-    registry.register(yamllintRunner); // YAML lint (priority 22)
-    registry.register(actionlintRunner); // GitHub Actions workflow linting (priority 23)
-    registry.register(sqlfluffRunner); // SQL lint (priority 24)
-    registry.register(goVetRunner); // Go analysis (priority 50)
-    registry.register(rustClippyRunner); // Rust analysis (priority 50)
-    registry.register(markdownlintRunner); // Markdown lint (priority 30)
-    registry.register(mypyRunner); // Python type checking — mypy (priority 20, config-gated)
-    registry.register(stylelintRunner); // CSS/SCSS/Less lint (priority 10, config-gated)
-    registry.register(swiftlintRunner); // Swift lint — out-of-the-box defaults (priority 20)
-    registry.register(shfmtRunner); // Shell formatting check (priority 10)
-    registry.register(fishIndentRunner); // Fish script formatting check (priority 10)
-    registry.register(factRulesRunner); // FactRule pipeline — all registered rules (priority 21)
-    registry.register(htmlhintRunner); // HTML linting — tag pairs, attribute rules (priority 20)
-    registry.register(hadolintRunner); // Dockerfile linting — syntax, best practices (priority 20)
-    registry.register(helmLintRunner); // Helm chart linting (priority 20)
-    registry.register(helmRenderRunner); // Rendered-manifest validation (priority 20, helm.renderValidation.enabled-gated, off by default)
-    registry.register(valeRunner); // Prose/style linting for Markdown — config-gated (.vale.ini) (priority 30)
-    registry.register(phpLintRunner); // PHP syntax validation via php -l (priority 20)
-    registry.register(psScriptAnalyzerRunner); // PowerShell linting via PSScriptAnalyzer module (priority 20)
-    registry.register(prismaValidateRunner); // Prisma schema validation via CLI (priority 20)
-    registry.register(ktlintRunner); // Kotlin linting via ktlint (priority 10)
-    registry.register(detektRunner); // Kotlin static analysis via detekt (priority 20, config-gated)
-    registry.register(tflintRunner); // Terraform linting via tflint (priority 20)
-    registry.register(terragruntRunner); // Terragrunt linting via terragrunt hcl validate (priority 20)
-    registry.register(trivyConfigRunner); // IaC misconfig (Dockerfile/k8s/Terraform) via trivy config (priority 20, trivy.enabled-gated)
-    registry.register(taploRunner); // TOML linting/validation via taplo (priority 10)
-    registry.register(dartAnalyzeRunner); // Dart analysis via dart analyze (priority 20)
-    registry.register(javacRunner); // Java compile diagnostics via javac (priority 20)
-    registry.register(dotnetBuildRunner); // C# compile diagnostics via dotnet build (priority 20)
-    registry.register(cppCheckRunner); // C/C++ compile diagnostics via compiler syntax checks (priority 20)
-    registry.register(zigCheckRunner); // Zig compile diagnostics via zig build-exe (priority 20)
-    registry.register(gleamCheckRunner); // Gleam project diagnostics via gleam check (priority 20)
-    registry.register(credoRunner); // Elixir static analysis via credo (priority 20, mix.exs-gated)
-    registry.register(elixirCheckRunner); // Elixir compile/syntax diagnostics via mix/elixirc (priority 20)
-    registry.register(phpstanRunner); // PHP static analysis via phpstan (priority 20, config-gated)
-    registry.register(cueVetRunner); // CUE evaluation-error validation via cue vet (priority 20) — covers the class cuelsp doesn't publish
-}

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

@@ -1,99 +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 { hasJavaBuildDescriptor } from "../../tool-policy.js";
-import { PRIORITY } from "../priorities.js";
-import { createAvailabilityChecker } from "./utils/runner-helpers.js";
-import { finishParsedRun, parseToolRun } from "./utils/tool-failure.js";
-const javac = createAvailabilityChecker("javac", ".exe");
-function parseJavacOutput(raw, filePath, cwd) {
-    const diagnostics = [];
-    const lines = raw.split(/\r?\n/);
-    const absTarget = path.resolve(cwd, filePath);
-    for (const line of lines) {
-        const match = line.match(/^(.*?\.java):(\d+):\s+(error|warning):\s+(.+)$/i);
-        if (!match)
-            continue;
-        const [, reportedFile, lineStr, severityLabel, message] = match;
-        // Is this reported diagnostic about the file we dispatched for? ONE seam
-        // answers that for every runner (#3278): resolve the tool's spelling against
-        // the cwd the tool RAN in — never `process.cwd()`, which is the extension's,
-        // not the runner's — and compare through `pathsEqual`, the repo's on-disk
-        // identity predicate. A bare `===` treats a spelling that differs only in
-        // case (the same file on Windows and on a case-folding POSIX mount) as a
-        // different file and drops every finding for the edited file (#209, #3277).
-        if (!pathsEqual(path.resolve(cwd, reportedFile.trim()), absTarget))
-            continue;
-        const severity = severityLabel.toLowerCase() === "error" ? "error" : "warning";
-        const lineNum = Number.parseInt(lineStr, 10) || 1;
-        diagnostics.push({
-            id: `javac-${severity}-${lineNum}-${message}`,
-            message: message.trim(),
-            filePath,
-            line: lineNum,
-            column: 1,
-            severity,
-            // A standalone single-file javac run has no project classpath. It can
-            // report useful syntax/type evidence, but it cannot prove a blocker.
-            semantic: "warning",
-            tool: "javac",
-            rule: "compile",
-            fixable: false,
-        });
-    }
-    return diagnostics;
-}
-const javacRunner = {
-    id: "javac",
-    appliesTo: ["java"],
-    priority: PRIORITY.GENERAL_ANALYSIS,
-    skipTestFiles: false,
-    async run(ctx) {
-        const cwd = resolveRunnerCwd(ctx, "javac");
-        const absPath = path.resolve(cwd, ctx.filePath);
-        // Inside a Maven/Gradle project a classpath-less single-file compile
-        // cannot produce a valid verdict: every non-JDK import becomes a
-        // "package does not exist" error, and the fallback turns those into
-        // false blocking diagnostics (#1877). jdtls owns those projects; this
-        // runner keeps its value for standalone files with no build descriptor.
-        // Same shared descriptor walk the SpotBugs gate uses.
-        if (hasJavaBuildDescriptor(path.dirname(absPath), ctx.projectRoot ?? ctx.cwd)) {
-            ctx.log?.("javac: skipped — file is inside a Maven/Gradle project; a classpath-less compile would emit false positives");
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        if (!(await javac.isAvailableAsync(cwd))) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        const cmd = javac.getCommand(cwd);
-        if (!cmd) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        const result = await safeSpawnAsync(cmd, ["-Xlint:none", "-proc:none", absPath], {
-            cwd,
-            timeout: 30000,
-        });
-        const raw = `${result.stdout ?? ""}\n${result.stderr ?? ""}`.trim();
-        const parsed = parseToolRun("javac", {
-            result,
-            output: raw,
-            // EXIT TABLE (javac 21 docs https://docs.oracle.com/en/java/javase/21/docs/specs/man/javac.html): 0 clean; 1 findings; 2 error; other nonzero rejected.
-            exitCodes: { ran: [1, 2] },
-        }, (output) => parseJavacOutput(output, ctx.filePath, cwd));
-        if (parsed.skipped)
-            return parsed.skipped;
-        return finishParsedRun({
-            tool: "javac",
-            ctx,
-            result,
-            diagnostics: parsed.diagnostics,
-            classify: (diagnostics) => ({
-                status: diagnostics.some((d) => d.severity === "error")
-                    ? "failed"
-                    : "succeeded",
-                semantic: "warning",
-            }),
-        });
-    },
-};
-export default javacRunner;

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

@@ -1,110 +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 { getAutofixCapability, getLinterPolicyForCwd, } from "../../tool-policy.js";
-import { PRIORITY } from "../priorities.js";
-import { createAvailabilityChecker, resolveToolCommandWithInstallFallback, } from "./utils/runner-helpers.js";
-import { finishParsedRun, parseToolRun } from "./utils/tool-failure.js";
-const ktlint = createAvailabilityChecker("ktlint", ".exe");
-// KtLint's exit contract, declared HERE rather than in the shared classifier:
-// an admission is a property of this tool, and #3291 round 2 shipped it through
-// a shared `parseToolRun` option that silently erased every OTHER runner's
-// table. KtLint 1.8.0's CLI page documents the JSON reporter and a nonzero exit
-// on violations, but does not enumerate numeric classes; 1, 2 and 3 are the
-// statuses this runner observes carrying a valid reporter payload, and a valid
-// payload is the evidence that analysis was reached. Any other nonzero status
-// stays a rejected invocation.
-const KTLINT_EXIT_CODES = { ran: [1, 2, 3] };
-function normalizeKtlintResults(parsed) {
-    if (Array.isArray(parsed)) {
-        return parsed;
-    }
-    if (parsed &&
-        typeof parsed === "object" &&
-        Array.isArray(parsed.errors)) {
-        return [parsed];
-    }
-    return null;
-}
-function parseKtlintOutput(raw, filePath, cwd) {
-    try {
-        const parsed = normalizeKtlintResults(JSON.parse(raw));
-        if (!parsed)
-            return null;
-        const autofix = getAutofixCapability("ktlint");
-        const diagnostics = [];
-        const absTarget = path.resolve(cwd, filePath);
-        for (const result of parsed) {
-            // #3295: ktlint's JSON reporter is an array of FILES; `.editorconfig`
-            // globs put more than the argv in it.
-            if (result.file && !pathsEqual(path.resolve(cwd, result.file), absTarget))
-                continue;
-            for (const err of result.errors ?? []) {
-                diagnostics.push({
-                    id: `ktlint-${err.ruleId}-${err.line}-${err.col}`,
-                    message: `[${err.ruleId}] ${err.detail}`,
-                    filePath,
-                    line: err.line,
-                    column: err.col,
-                    severity: "warning",
-                    semantic: "warning",
-                    tool: "ktlint",
-                    rule: err.ruleId,
-                    fixable: true,
-                    autoFixAvailable: autofix?.safePipelineAutofix ?? false,
-                    fixKind: autofix?.fixKind === "none" ? undefined : autofix?.fixKind,
-                });
-            }
-        }
-        return diagnostics;
-    }
-    catch {
-        return null;
-    }
-}
-const ktlintRunner = {
-    id: "ktlint",
-    appliesTo: ["kotlin"],
-    priority: PRIORITY.FORMAT_AND_LINT_PRIMARY,
-    skipTestFiles: false,
-    async run(ctx) {
-        const cwd = resolveRunnerCwd(ctx, "ktlint");
-        const policy = getLinterPolicyForCwd(ctx.filePath, cwd);
-        if (policy && !policy.preferredRunners.includes("ktlint")) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        let cmd = null;
-        if (await ktlint.isAvailableAsync(cwd)) {
-            cmd = ktlint.getCommand(cwd);
-        }
-        else {
-            cmd = await resolveToolCommandWithInstallFallback(cwd, "ktlint");
-        }
-        if (!cmd)
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        const absPath = path.resolve(cwd, ctx.filePath);
-        const result = await safeSpawnAsync(cmd, ["--reporter=json", absPath], {
-            cwd,
-            timeout: 30000,
-        });
-        // `output` is what the classifier judges AND what the parser reads: ktlint
-        // writes its reporter payload to stdout and its errors to stderr, so both
-        // are one wire here. The exit table rides in this same per-runner input,
-        // never in a shared option (#3291 r3).
-        const run = parseToolRun("ktlint", {
-            result,
-            output: `${result.stdout ?? ""}\n${result.stderr ?? ""}`,
-            exitCodes: KTLINT_EXIT_CODES,
-        }, (output) => parseKtlintOutput(output, ctx.filePath, cwd) ?? []);
-        if (run.skipped)
-            return run.skipped;
-        return finishParsedRun({
-            tool: "ktlint",
-            ctx,
-            result,
-            diagnostics: run.diagnostics,
-        });
-    },
-};
-export default ktlintRunner;