pi-lens 4.3.0 → 4.4.0

package/dist/clients/dispatch/runners/stylelint.js

@@ -1,166 +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, hasStylelintConfig, } 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 stylelint = createAvailabilityChecker("stylelint", ".cmd");
-// stylelint exit codes (its "Exit codes" docs page): 0 = no problems, 1 = a
-// fatal error, 2 = lint problems found, 78 = a configuration error.
-//
-// 1 is listed as a run here rather than a rejection. The evidence for that is
-// NOT a live stylelint: it is this repo's own hand-written fixture
-// (tests/clients/dispatch/runners/stylelint-fixable.test.ts), which reports
-// findings under exit 1. Rather than rewrite a fixture whose provenance is
-// unknown, the table keeps 1 permissive. 78 is the rejection this table
-// exists to name.
-//
-// #1937 corrected the safety argument that used to sit here: it claimed a
-// EXIT TABLE (Stylelint 16 docs https://stylelint.io/user-guide/cli): 0 clean; 1 findings; 2 fatal/error; other nonzero rejected.
-// fatal stylelint "writes nothing to stdout", which is true but useless,
-// because a stylelint that DID find problems writes nothing to stdout either.
-// `stylelintReport` below is what now separates the two.
-const STYLELINT_EXIT_CODES = { ran: [1, 2] };
-/**
- * The JSON report out of a stylelint run, whichever stream carried it (#1937).
- *
- * stylelint 16+ writes the formatted report to STDERR whenever the run
- * "errored" — which is every run that found an error-severity warning, i.e.
- * every run with something to say. Reading stdout alone parsed nothing and
- * called the stylesheet clean, the #1933 vale shape. Verified against
- * stylelint 17.8.0 in tests/fixtures/runner-output/stylelint/.
- *
- * Only a stream that actually starts a JSON array counts. A crash's stack
- * trace on stderr must stay "nothing to parse" so #1816's empty-result skip
- * still fires instead of reporting a clean file.
- */
-export function stylelintReport(stdout, stderr) {
-    for (const stream of [stdout, stderr]) {
-        if (stream?.trimStart().startsWith("["))
-            return stream;
-    }
-    return "";
-}
-// Stylelint's standard JSON output reports only aggregate fixableErrorCount /
-// fixableWarningCount per file — there is no per-warning fix flag in the CLI
-// surface. To route the actionable warnings here without a tool rewrite, we
-// keep a curated set of rule IDs whose `--fix` behavior is deterministic and
-// safe. Sourced from rule pages in stylelint's docs that explicitly state
-// "stylelint can automatically fix all of the problems reported by this rule".
-// Update when stylelint adds or removes fixable rules.
-const STYLELINT_FIXABLE_RULES = new Set([
-    // whitespace / spacing — formatter-style, always safe
-    "block-no-empty",
-    "color-hex-length",
-    "declaration-block-no-duplicate-properties",
-    "declaration-block-no-redundant-longhand-properties",
-    "declaration-block-no-shorthand-property-overrides",
-    "declaration-block-single-line-max-declarations",
-    "font-family-name-quotes",
-    "function-url-quotes",
-    "length-zero-no-unit",
-    "media-feature-name-no-vendor-prefix",
-    "no-descending-specificity",
-    "no-duplicate-at-import-rules",
-    "no-duplicate-selectors",
-    "no-empty-source",
-    "no-eol-whitespace",
-    "no-extra-semicolons",
-    "no-invalid-double-slash-comments",
-    "no-missing-end-of-source-newline",
-    "number-leading-zero",
-    "number-no-trailing-zeros",
-    "property-no-vendor-prefix",
-    "selector-attribute-quotes",
-    "selector-no-vendor-prefix",
-    "selector-pseudo-element-colon-notation",
-    "selector-type-case",
-    "shorthand-property-no-redundant-values",
-    "string-quotes",
-    "value-no-vendor-prefix",
-]);
-function parseStylelintJson(raw, filePath, cwd) {
-    try {
-        const results = JSON.parse(raw);
-        const diagnostics = [];
-        const absTarget = path.resolve(cwd, filePath);
-        for (const result of results) {
-            // #3295: stylelint keys each result by its own `source`; a config
-            // `files`/`overrides` entry or an `@import` makes that a DIFFERENT file.
-            if (result.source &&
-                !pathsEqual(path.resolve(cwd, result.source), absTarget))
-                continue;
-            for (const w of result.warnings) {
-                const severity = w.severity === "error" ? "error" : "warning";
-                const fixable = STYLELINT_FIXABLE_RULES.has(w.rule);
-                diagnostics.push({
-                    id: `stylelint-${w.line}-${w.rule}`,
-                    message: `[${w.rule}] ${w.text.replace(/\s*\(stylelint.*?\)$/, "")}`,
-                    filePath,
-                    line: w.line,
-                    column: w.column,
-                    severity,
-                    semantic: severity === "error" ? "blocking" : "warning",
-                    tool: "stylelint",
-                    rule: w.rule,
-                    fixable,
-                    fixSuggestion: fixable
-                        ? "Run `stylelint --fix` to apply the deterministic auto-correction for this rule."
-                        : undefined,
-                });
-            }
-        }
-        return diagnostics;
-    }
-    catch {
-        return [];
-    }
-}
-const stylelintRunner = {
-    id: "stylelint",
-    appliesTo: ["css"],
-    priority: PRIORITY.FORMAT_AND_LINT_PRIMARY,
-    skipTestFiles: false,
-    async run(ctx) {
-        const cwd = resolveRunnerCwd(ctx, "stylelint");
-        const policy = getLinterPolicyForCwd(ctx.filePath, cwd);
-        if (policy && !policy.preferredRunners.includes("stylelint")) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        const fileDir = path.dirname(path.resolve(cwd, ctx.filePath));
-        const hasConfig = hasStylelintConfig(fileDir) || hasStylelintConfig(cwd);
-        if (!hasConfig) {
-            logRunnerAdvisoryOnce(ctx, "stylelint", cwd, "stylelint: no config detected, running with default rules");
-        }
-        let cmd = null;
-        if (await stylelint.isAvailableAsync(cwd)) {
-            cmd = stylelint.getCommand(cwd);
-        }
-        else {
-            cmd = await resolveToolCommandWithInstallFallback(cwd, "stylelint");
-        }
-        if (!cmd)
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        const result = await safeSpawnAsync(cmd, ["--formatter", "json", ctx.filePath], { timeout: 20000, cwd });
-        // #1816: this runner read `result.status` zero times, so an exit-78
-        // config error (or an exit-1 crash) fell through parseStylelintJson's
-        // catch to zero diagnostics and reported a clean stylesheet.
-        const raw = stylelintReport(result.stdout, result.stderr);
-        // #1948: the stdout-vs-stderr report bug landed here as exit 2 plus a
-        // full JSON report and zero parsed warnings. That now leaves a record.
-        const run = parseToolRun("stylelint", { result, output: raw, exitCodes: STYLELINT_EXIT_CODES }, (out) => parseStylelintJson(out, ctx.filePath, cwd));
-        if (run.skipped)
-            return run.skipped;
-        const diagnostics = run.diagnostics;
-        return finishParsedRun({
-            tool: "stylelint",
-            ctx,
-            result,
-            diagnostics,
-        });
-    },
-};
-export default stylelintRunner;

package/dist/clients/dispatch/runners/swiftlint.js

@@ -1,163 +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, resolveToolCommandWithInstallFallback, } from "./utils/runner-helpers.js";
-import { parseToolRun } from "./utils/tool-failure.js";
-const swiftlint = createAvailabilityChecker("swiftlint", ".exe");
-// SwiftLint rules whose rule class declares a `corrector` — i.e. rules that
-// `swiftlint --fix` rewrites deterministically. The JSON reporter does not
-// surface a per-violation `is_corrected` flag, so we keep a curated allowlist.
-// Source: https://realm.github.io/SwiftLint/rule-directory.html (each rule
-// page indicates whether a corrector exists). Conservative — when in doubt,
-// leave a rule off this list.
-const SWIFTLINT_FIXABLE_RULES = new Set([
-    "closing_brace",
-    "colon",
-    "comma",
-    "comma_inheritance",
-    "control_statement",
-    "duplicate_imports",
-    "empty_collection_literal",
-    "empty_enum_arguments",
-    "empty_parameters",
-    "empty_parentheses_with_trailing_closure",
-    "empty_string",
-    "explicit_init",
-    "file_header",
-    "joined_default_parameter",
-    "legacy_constant",
-    "legacy_constructor",
-    "legacy_hashing",
-    "legacy_nsgeometry_functions",
-    "mark",
-    "modifier_order",
-    "no_extension_access_modifier",
-    "no_space_in_method_call",
-    "number_separator",
-    "opening_brace",
-    "operator_usage_whitespace",
-    "prefer_zero_over_explicit_init",
-    "private_over_fileprivate",
-    "protocol_property_accessors_order",
-    "redundant_discardable_let",
-    "redundant_nil_coalescing",
-    "redundant_objc_attribute",
-    "redundant_optional_initialization",
-    "redundant_string_enum_value",
-    "redundant_type_annotation",
-    "redundant_void_return",
-    "return_arrow_whitespace",
-    "self_in_property_initialization",
-    "shorthand_operator",
-    "sorted_imports",
-    "statement_position",
-    "trailing_comma",
-    "trailing_newline",
-    "trailing_semicolon",
-    "trailing_whitespace",
-    "unneeded_break_in_switch",
-    "unneeded_parentheses_in_closure_argument",
-    "unused_capture_list",
-    "vertical_parameter_alignment",
-    "vertical_whitespace",
-    "vertical_whitespace_between_cases",
-    "vertical_whitespace_closing_braces",
-    "vertical_whitespace_opening_braces",
-    "void_function_in_ternary",
-    "void_return",
-    "yoda_condition",
-]);
-function parseSwiftLintOutput(raw, filePath, cwd) {
-    const diagnostics = [];
-    if (!raw.trim())
-        return diagnostics;
-    const absTarget = path.resolve(cwd, filePath);
-    try {
-        const parsed = JSON.parse(raw);
-        if (!Array.isArray(parsed))
-            return diagnostics;
-        for (const item of parsed) {
-            if (!item.reason)
-                continue;
-            // #3295: `.swiftlint.yml` `included:` widens the run past the argv.
-            if (item.file && !pathsEqual(path.resolve(cwd, item.file), absTarget))
-                continue;
-            const severityMap = {
-                error: "error",
-                warning: "warning",
-                info: "info",
-            };
-            const severity = severityMap[item.severity?.toLowerCase() ?? ""] ?? "warning";
-            const ruleId = item.rule_id ?? "swiftlint";
-            const fixable = SWIFTLINT_FIXABLE_RULES.has(ruleId);
-            diagnostics.push({
-                id: `swiftlint-${item.line}-${ruleId}`,
-                message: `[${ruleId}] ${item.reason}`,
-                filePath,
-                line: item.line ?? 1,
-                column: item.character ?? 1,
-                severity,
-                semantic: severity === "error" ? "blocking" : "warning",
-                tool: "swiftlint",
-                rule: ruleId,
-                defectClass: "style",
-                fixable,
-                fixSuggestion: fixable
-                    ? "Run `swiftlint --fix` to apply the deterministic auto-correction for this rule."
-                    : undefined,
-            });
-        }
-    }
-    catch {
-        return diagnostics;
-    }
-    return diagnostics;
-}
-const swiftlintRunner = {
-    id: "swiftlint",
-    appliesTo: ["swift"],
-    priority: PRIORITY.GENERAL_ANALYSIS,
-    skipTestFiles: false,
-    async run(ctx) {
-        const cwd = resolveRunnerCwd(ctx, "swiftlint");
-        let cmd = null;
-        if (await swiftlint.isAvailableAsync(cwd)) {
-            cmd = swiftlint.getCommand(cwd);
-        }
-        else {
-            cmd = await resolveToolCommandWithInstallFallback(cwd, "swiftlint");
-        }
-        if (!cmd)
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        const result = await safeSpawnAsync(cmd, ["--reporter", "json", path.resolve(cwd, ctx.filePath)], { cwd, timeout: 15000 });
-        // #1816: this runner read `result.status` zero times, so a SwiftLint
-        // that refused the invocation reported a clean Swift file. No exit-code
-        // table is declared: SwiftLint's nonzero codes are not documented
-        // stably enough to call any of them a rejection, so classification
-        // rests on the conservative rule — a nonzero exit with nothing to parse
-        // never ran.
-        // SwiftLint exits non-zero on violations — stdout still has the JSON, so
-        // a nonzero exit whose JSON yields nothing is a parser break (#1948).
-        const run = parseToolRun("swiftlint", {
-            result,
-            // EXIT TABLE (SwiftLint 0.56 measured fixture): 0 clean; 1 findings; 2 error; other nonzero rejected.
-            exitCodes: { ran: [1, 2] },
-        }, (out) => parseSwiftLintOutput(out, ctx.filePath, cwd));
-        if (run.skipped)
-            return run.skipped;
-        const diagnostics = run.diagnostics;
-        if (diagnostics.length === 0) {
-            return { status: "succeeded", diagnostics: [], semantic: "none" };
-        }
-        const hasBlocking = diagnostics.some((d) => d.semantic === "blocking");
-        return {
-            status: hasBlocking ? "failed" : "succeeded",
-            diagnostics,
-            semantic: hasBlocking ? "blocking" : "warning",
-        };
-    },
-};
-export default swiftlintRunner;
-export { parseSwiftLintOutput, SWIFTLINT_FIXABLE_RULES };

package/dist/clients/dispatch/runners/taplo.js

@@ -1,174 +0,0 @@
-import * as path from "node:path";
-import { pathsEqual } from "../../path-utils.js";
-import { findLocalBinUpwards } from "../../package-manager.js";
-import { stripAnsi } from "../../sanitize.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, lspPrimaryCoversFile, resolveToolCommandWithInstallFallback, } from "./utils/runner-helpers.js";
-import { parseToolRun } from "./utils/tool-failure.js";
-const taplo = createAvailabilityChecker("taplo", ".exe");
-// Verified against taplo 0.10.0: 0 = clean, 1 = the file is invalid (lint
-// findings, or a schema it could not load), 2 = clap rejected the invocation.
-//
-// #1937 round 2: the parser fix alone turned the old silent-clean into a false
-// BLOCKING diagnostic. clap prints `error: unexpected argument '--output'
-// EXIT TABLE (taplo 0.9 measured fixture): 0 clean; 1 findings; other nonzero rejected/error.
-// found`, which starts with the same lowercase `error:` a real taplo
-// diagnostic does, so a mistyped flag would have reddened every valid TOML
-// file. Both readings are wrong; the exit code is what separates them.
-const TAPLO_EXIT_CODES = { ran: [1] };
-/** `error: <summary>` or `warning: <summary>` at the head of a codespan block. */
-const HEADER_PATTERN = /^\s*(error|warning):(.*)$/;
-/** The box-drawing lead taplo puts on a codespan location line. */
-const LOCATION_LEAD = "┌─";
-/** The `:line:column` tail of a codespan location line. */
-const LOCATION_PATTERN = /^\s*┌─\s+(.+?):(\d+):(\d+)$/;
-/**
- * Parse `taplo lint` output (#1937).
- *
- * This parser used to `JSON.parse` a `{ errors: [{ range, message, kind }] }`
- * envelope that taplo has never emitted, fed by a `--output=json` flag taplo
- * has never accepted. Real taplo rejected the flag with exit 2 and a usage
- * error, the JSON parse threw, the catch returned [], and malformed TOML was
- * reported clean. Same shape as the vale parser in #1933.
- *
- * Real taplo 0.10.0 writes codespan diagnostics to STDERR, interleaved with
- * uppercase tracing lines:
- *
- *     error: invalid TOML
- *       ┌─ /path/to/bad.toml:2:9
- *       │
- *     2 │   [package
- *
- * Verified against tests/fixtures/runner-output/taplo/real.captured.json.
- *
- * A header alone is NOT enough to emit a diagnostic. The codespan location
- * line must follow it. clap's own failures start with the same lowercase
- * `error:` and carry no location, so without that requirement a rejected
- * invocation becomes a blocking finding on line 1 of a perfectly valid file
- * (#1937 round 2). The exit-code table in the runner is the primary guard;
- * this is the structural one, and each covers a case the other does not.
- */
-export function parseTaploOutput(raw, filePath, cwd) {
-    const diagnostics = [];
-    const absTarget = path.resolve(cwd, filePath);
-    const lines = stripAnsi(raw ?? "").split(/\r?\n/);
-    for (let i = 0; i < lines.length; i++) {
-        // Lowercase `error:`/`warning:` starts a diagnostic. taplo's tracing
-        // lines are uppercase (`ERROR taplo:lint_files: ...`), so a
-        // case-sensitive match keeps them out.
-        //
-        // Both patterns below trim in code rather than with a trailing `\s*`,
-        // and the location one tests for its box-drawing lead separately
-        // instead of skipping to it with `.*`. Either shape backtracks
-        // super-linearly on a long line, and this parser reads bytes a third
-        // party wrote.
-        const header = HEADER_PATTERN.exec(lines[i].trimEnd());
-        if (!header)
-            continue;
-        const severityWord = header[1];
-        const summary = header[2].trim();
-        if (!summary)
-            continue;
-        // The location arrives on a following `┌─ file:line:col` line. Scan a
-        // short window rather than assuming adjacency: taplo puts a gutter line
-        // between them in some layouts.
-        let line = null;
-        let column = 1;
-        for (let j = i + 1; j < Math.min(i + 4, lines.length); j++) {
-            if (!lines[j].includes(LOCATION_LEAD))
-                continue;
-            const location = LOCATION_PATTERN.exec(lines[j].trimEnd());
-            if (!location)
-                continue;
-            if (!pathsEqual(path.resolve(cwd, location[1].trim()), absTarget))
-                continue;
-            line = Number.parseInt(location[2], 10) || 1;
-            column = Number.parseInt(location[3], 10) || 1;
-            break;
-        }
-        if (line === null)
-            continue;
-        const severity = severityWord === "warning" ? "warning" : "error";
-        diagnostics.push({
-            id: `taplo-${severity}-${line}-${column}`,
-            message: summary,
-            filePath,
-            line,
-            column,
-            severity,
-            semantic: severity === "error" ? "blocking" : "warning",
-            tool: "taplo",
-            rule: `taplo/${severity}`,
-            fixable: false,
-        });
-    }
-    return diagnostics;
-}
-const taploRunner = {
-    id: "taplo",
-    appliesTo: ["toml"],
-    priority: PRIORITY.FORMAT_AND_LINT_PRIMARY,
-    skipTestFiles: false,
-    async run(ctx) {
-        const cwd = resolveRunnerCwd(ctx, "taplo");
-        const policy = getLinterPolicyForCwd(ctx.filePath, cwd);
-        if (policy && !policy.preferredRunners.includes("taplo")) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        // #233: the `toml` LSP server IS `taplo lsp` (same binary). When that LSP
-        // covers this file, the warm server already produces these diagnostics —
-        // skip the redundant CLI scan to avoid double-reporting. Stays active when
-        // the LSP is disabled/unavailable so TOML coverage never regresses.
-        if (lspPrimaryCoversFile(ctx, "toml") && (await ctx.hasTool("taplo"))) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        // Project binary first (#1731, discipline B): `taplo.isAvailableAsync`
-        // resolves through `findManagedNodeToolBinary`, pi-lens's own managed
-        // shim — checked BEFORE any project-local candidate, so a project's own
-        // `node_modules/.bin/taplo` (npm `@taplo/cli`) never won once the managed
-        // copy answered. `findLocalBinUpwards` defaults to `.cmd` on Windows,
-        // matching that npm shim; the availability checker's `.exe` extension is
-        // correct for pi-lens's OWN managed install (a GitHub-release binary,
-        // `clients/installer/index.ts` taplo entry), a different artifact with a
-        // different extension, so it stays as the checker's fallback only.
-        let cmd = findLocalBinUpwards("taplo", cwd) ?? null;
-        if (!cmd) {
-            if (await taplo.isAvailableAsync(cwd)) {
-                cmd = taplo.getCommand(cwd);
-            }
-            else {
-                cmd = await resolveToolCommandWithInstallFallback(cwd, "taplo");
-            }
-        }
-        if (!cmd)
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        const absPath = path.resolve(cwd, ctx.filePath);
-        // #1937: `--output=json` is not a taplo flag. taplo rejected it with a
-        // usage error, so this runner never linted anything. `--colors never`
-        // keeps ANSI escapes out of the bytes the parser reads.
-        const result = await safeSpawnAsync(cmd, ["check", "--colors", "never", absPath], { cwd, timeout: 15000 });
-        // taplo reports on stderr and leaves stdout empty, so the
-        // "nothing to parse" test must read the same string the parser gets —
-        // otherwise every real run looks like a failed spawn.
-        const raw = result.stderr?.trim() ? result.stderr : (result.stdout ?? "");
-        //
-        // taplo exits 1 only when a file is INVALID, and it does not always draw
-        // a codespan block when it does: a schema it could not load is reported
-        // through its tracing output alone. Claiming that file clean would be an
-        // outright lie, so taplo opts into `skipWhenParsedNothing` (#1948). This
-        // replaces a hand-rolled per-runner copy of the same rule, which wrote
-        // its own `runner-empty-result` row with its own wording.
-        const run = parseToolRun("taplo", { result, output: raw, exitCodes: TAPLO_EXIT_CODES }, (out) => parseTaploOutput(out, ctx.filePath, cwd), { skipWhenParsedNothing: true });
-        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: "blocking" };
-    },
-};
-export default taploRunner;

package/dist/clients/dispatch/runners/terragrunt.js

@@ -1,168 +0,0 @@
-import * as path from "node:path";
-import { safeSpawnAsync } from "../../safe-spawn.js";
-import { resolveRunnerCwd } from "../../tool-cwd.js";
-import { pathsEqual } from "../../path-utils.js";
-import { getLinterPolicyForCwd } from "../../tool-policy.js";
-import { PRIORITY } from "../priorities.js";
-import { createAvailabilityChecker, resolveAvailableOrInstall, } from "./utils/runner-helpers.js";
-import { spawnFailedWithNoOutput } from "./utils/spawn-outcome.js";
-import { finishParsedRun } from "./utils/tool-failure.js";
-const terragrunt = createAvailabilityChecker("terragrunt", ".exe");
-function normalizeSeverity(raw) {
-    if (typeof raw === "number")
-        return raw === 1 ? "error" : "warning";
-    if (typeof raw === "string" && raw.toLowerCase() === "error")
-        return "error";
-    return "warning";
-}
-function toRawDiagnostics(parsed) {
-    if (Array.isArray(parsed))
-        return parsed;
-    if (!parsed || typeof parsed !== "object")
-        return [];
-    const invalidFiles = parsed.invalid_files;
-    if (!Array.isArray(invalidFiles))
-        return [];
-    return invalidFiles.flatMap((f) => Array.isArray(f?.diagnostics) ? f.diagnostics : []);
-}
-/**
- * Parse `terragrunt hcl validate --json` output.
- *
- * OBSERVED CONTRACT (captured empirically from terragrunt v1.1.2, win-x64):
- * the payload is a FLAT JSON array of diagnostic objects on stdout, e.g.
- *
- *   [{"range":{"filename":"<ABSOLUTE path>","start":{"line":1,"column":8,...},
- *     "end":{...}},"snippet":{...},"summary":"Unclosed configuration block",
- *     "detail":"...","severity":"error"}]
- *
- * Key facts: `severity` is a STRING ("error"), `range.filename` is an ABSOLUTE
- * path (host separator), and a CLEAN unit prints NOTHING (empty stdout, exit 0)
- * — not `[]`. The nested `{invalid_files:[{diagnostics:[...]}]}` wrapper and the
- * numeric (1=error/2=warning) severity encoding were NOT observed on v1.1.2 and
- * are retained only as a tolerant fallback for other/older shapes.
- * Malformed/unparseable input returns [].
- */
-export function parseTerragruntOutput(raw, filePath, absPath = path.resolve(filePath)) {
-    if (!raw.trim())
-        return [];
-    let parsed;
-    try {
-        parsed = JSON.parse(raw);
-    }
-    catch {
-        return [];
-    }
-    // Resolved against the unit dir, not compared by basename: a unit that
-    // includes its parent via find_in_parent_folders() gets diagnostics from a
-    // parent terragrunt.hcl, whose basename matches but whose lines do not.
-    const unitDir = path.dirname(absPath);
-    const diagnostics = [];
-    for (const d of toRawDiagnostics(parsed)) {
-        if (!d || typeof d !== "object")
-            continue;
-        const diagFile = d.range?.filename;
-        if (diagFile && !pathsEqual(path.resolve(unitDir, diagFile), absPath))
-            continue;
-        const line = d.range?.start?.line ?? 1;
-        const column = d.range?.start?.column ?? 1;
-        const severity = normalizeSeverity(d.severity);
-        const message = d.summary ?? d.detail ?? "terragrunt hcl validate error";
-        // No rule code in hcl validate output, so the message carries the identity.
-        const idMessage = message
-            .toLowerCase()
-            .replace(/[^a-z0-9]+/g, "-")
-            .slice(0, 80);
-        diagnostics.push({
-            id: `terragrunt-hclvalidate-${line}-${column}-${idMessage}`,
-            message,
-            filePath,
-            line,
-            column,
-            severity,
-            semantic: severity === "error" ? "blocking" : "warning",
-            tool: "terragrunt",
-            fixable: false,
-        });
-    }
-    return diagnostics;
-}
-const SKIPPED = {
-    status: "skipped",
-    diagnostics: [],
-    semantic: "none",
-};
-/**
- * Runner for `terragrunt hcl validate --json`, the linter for terragrunt units.
- *
- * REQUIRES the redesigned terragrunt CLI: the `terragrunt hcl validate` /
- * `terragrunt hcl fmt` command group replaced the old `hclvalidate`/`hclfmt`
- * top-level commands in the CLI redesign (~terragrunt v0.75; the legacy names
- * were removed in v1.0). Contract verified empirically on terragrunt v1.1.2.
- *
- * Observed exit-code / output table (terragrunt v1.1.2, win-x64):
- *   - clean unit ............ exit 0, EMPTY stdout (no `[]`)
- *   - validation findings ... exit 1, flat JSON array on stdout (+ a log line
- *                             "N HCL validation error(s) found" on stderr)
- *   - unknown command ....... an older binary that predates `hcl validate`
- *                             exits non-zero with the error on STDERR and EMPTY
- *                             stdout; `spawnFailedWithNoOutput` classifies that
- *                             as SKIPPED (never a false blocker, and never a
- *                             false CLEAN — a nonzero exit carries no
- *                             `SpawnResult.error`, so the status has to be part
- *                             of the test).
- *
- * `hcl validate` recursively validates the unit(s) at its working dir; it has no
- * per-file flag (`--filter` takes component filter-syntax, NOT a filename — a
- * bare basename silently matches zero components and suppresses ALL findings,
- * verified on v1.1.2). So we validate the edited file's unit directory and
- * attribute findings back to the edited file by absolute path in
- * parseTerragruntOutput.
- *
- * Misdetection edge: `root.hcl` is filename-detected as terragrunt, so a
- * `root.hcl` that is NOT a terragrunt file still gets validated here — `hcl
- * validate` just checks generic HCL, so a non-terragrunt file fails soft
- * (either clean or a plain HCL diagnostic, never a spurious hard blocker).
- */
-const terragruntRunner = {
-    id: "terragrunt",
-    appliesTo: ["terragrunt"],
-    priority: PRIORITY.GENERAL_ANALYSIS,
-    skipTestFiles: false,
-    async run(ctx) {
-        const cwd = resolveRunnerCwd(ctx, "terragrunt");
-        const policy = getLinterPolicyForCwd(ctx.filePath, cwd);
-        if (policy && !policy.preferredRunners.includes("terragrunt"))
-            return SKIPPED;
-        let cmd = null;
-        if (await terragrunt.isAvailableAsync(cwd)) {
-            cmd = terragrunt.getCommand(cwd);
-        }
-        else {
-            const managed = await resolveAvailableOrInstall(terragrunt, "terragrunt", cwd);
-            if (managed)
-                cmd = managed;
-        }
-        if (!cmd)
-            return SKIPPED;
-        const absPath = path.resolve(cwd, ctx.filePath);
-        const fileDir = path.dirname(absPath);
-        const result = await safeSpawnAsync(cmd, ["hcl", "validate", "--json", "--non-interactive"], { cwd: fileDir, timeout: 30000 });
-        if (spawnFailedWithNoOutput(result))
-            return SKIPPED;
-        const diagnostics = parseTerragruntOutput(result.stdout || "", ctx.filePath, absPath);
-        return finishParsedRun({
-            tool: "terragrunt",
-            ctx,
-            result,
-            diagnostics,
-            classify: (diagnostics) => {
-                const hasErrors = diagnostics.some((d) => d.severity === "error");
-                return {
-                    status: hasErrors ? "failed" : "succeeded",
-                    semantic: hasErrors ? "blocking" : "warning",
-                };
-            },
-        });
-    },
-};
-export default terragruntRunner;