@herbertgao/pi-extensions 2026.10.1 → 2026.10.2

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

@@ -1,416 +0,0 @@
-/**
- * `cue vet` — CUE evaluation-error validation (#1522).
- *
- * `cue lsp serve` reports load and parse (syntax) errors as you type
- * (`clients/lsp/wait-policy/strategies.ts`'s `cue` entry) but deliberately
- * leaves conflicting concrete values and failed constraints to `cue vet` —
- * per the CUE wiki, that class needs a full evaluation pass the language
- * server does not run on every keystroke. This runner is the auxiliary that
- * covers the gap, in the same "LSP covers syntax, a CLI covers the rest"
- * shape as terraform's `lsp, tflint, trivy-config` group.
- *
- * `-c=false` (allow incomplete values) is deliberate, not a shortcut: CUE's
- * default `cue vet` requires every regular field to be concrete, so an
- * ordinary schema-only file — a `#Definition` library with no concrete data,
- * a very common authoring pattern — fails vet's default gate with a generic
- * "some instances are incomplete" message and nothing to point at. That is
- * noise, not a defect. `-c=false` accepts incomplete values and still
- * reports a genuine type conflict (verified: `a: int & "hello"` still fails
- * with `-c=false`, an incomplete `a: int` no longer does) — see the fixture
- * at tests/fixtures/tool-smoke/cue-vet/bad.cue.
- *
- * ## Package-scoped, not file-scoped (review round 1, F1)
- *
- * CUE packages are DIRECTORY-scoped: every `.cue` file in a directory
- * sharing a `package` clause is unified into one value. Vetting only the
- * touched file (`cue vet <file>`) was a false-positive machine on the
- * normative split-schema/values authoring style — a `#Service` defined in
- * `schema.cue` and referenced from `values.cue` vets clean as a package but
- * fails `values.cue` alone with `reference "#Service" not found`, because
- * the single-file invocation never loads the sibling that defines it.
- * Verified: a valid two-file package vets clean as `cue vet -c=false .`
- * (exit 0, empty output) but reports a blocking error for `values.cue` in
- * isolation.
- *
- * The fix runs `cue vet -c=false .` from the touched file's directory (the
- * whole package) and then filters the reported errors down to the ones
- * whose location names the touched file — `cue vet`'s locations are
- * `.\<file>:line:col` relative to the vet cwd, so the match is a plain
- * basename compare, no path resolution needed.
- *
- * This is now an honest MISSED-finding tradeoff, not an invented-finding
- * bug: an error whose ONLY location is a sibling file is filtered out here
- * (it will surface when that sibling is itself touched), rather than a
- * clean file being wrongly flagged. An error that names the touched file
- * ANYWHERE in its location list — including as a secondary location on a
- * conflict whose primary site is a sibling — is kept, using that location's
- * line/col, because the touched file is a genuine contributor to it.
- *
- * ## Directory scope can itself be unavailable (review round 2, F5/F6)
- *
- * `cue vet .` is not always a valid unit. Two real, LEGAL directory shapes
- * make it fail before it evaluates anything, with no per-file location at
- * all:
- *
- *   - a package-less standalone file (no `package` clause — the common
- *     single-file config style): `build constraints exclude all CUE files
- *     in .:\n    .\standalone.cue: no package name`;
- *   - two or more DIFFERENT package names sharing one directory (legal CUE —
- *     each is its own independent unit): `found packages "alpha"
- *     (alpha.cue) and "beta" (beta.cue) in "."`.
- *
- * Both verified against cue v0.17.1 (exit 1, no `:line:col` anywhere in the
- * output). Before F5/F6, this read as an unattributable whole-vet failure
- * and blocked every edit to an otherwise-clean file of either shape — a
- * regression the F1 fix introduced. The fix: on either signature, fall back
- * to vetting the touched file ALONE (`cue vet -c=false <file>`), which is
- * the CORRECT scope for a file that cannot be unified with anything in its
- * directory — a package-less file is its own unit by definition, and a
- * differently-packaged sibling is never part of the same value regardless of
- * scope. The single-file result needs no further filtering: every location
- * it reports already belongs to that one file.
- *
- * ## A package-less file can vet CLEAN by never being evaluated (review
- * ## round 3, F8)
- *
- * The F5/F6 fallback above only fires when the DIRECTORY vet FAILS. But a
- * directory holding both a packaged file and a package-less file is not a
- * failure at all: `cue vet .` silently BUILDS ONLY THE PACKAGE, excludes the
- * package-less file from evaluation, and exits 0. Verified against the real
- * binary: a package-less `loose.cue` with a genuine conflicting value
- * (`b: int & "x"`) sitting beside a valid packaged `packaged.cue` makes
- * `cue vet -c=false .` exit 0 with empty output — the loose file's defect is
- * never evaluated, and the F5/F6 fallback's `result.status !== 0` gate never
- * triggers because there IS no failure to react to. This is shape 10 from
- * the miss side: an empty result that does not distinguish "clean" from
- * "never evaluated".
- *
- * The fix does not wait for a failure signal at all for this shape: before
- * spawning anything, the touched file's own content is checked for a
- * `package` clause (`hasPackageClause`). A package-less touched file goes
- * straight to single-file scope — it is its own vet unit regardless of what
- * shares its directory, so directory-scoped vet has nothing to add for ITS
- * evaluation errors. Its SYNTAX errors are equally covered single-file
- * (verified: `cue vet <file>` alone reports the identical syntax error a
- * directory-wide parse would have caught for that file — parsing happens
- * before the build-constraint exclusion, but a single-file invocation
- * parses that file too), so nothing is lost by skipping the directory pass
- * for this shape. The F5/F6 `directoryScopeUnavailable` fallback stays as a
- * safety net for what the proactive check cannot see up front — the
- * touched file's content is unreadable, or the touched file DOES declare a
- * package but the directory as a whole still isn't a valid unit (F6's
- * two-different-packages shape).
- */
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { safeSpawnAsync } from "../../safe-spawn.js";
-import { pathsEqual } from "../../path-utils.js";
-import { resolveRunnerCwd } from "../../tool-cwd.js";
-import { createAvailabilityChecker, resolveAvailableOrInstall, } from "./utils/runner-helpers.js";
-import { spawnFailedWithNoOutput } from "./utils/spawn-outcome.js";
-import { PRIORITY } from "../priorities.js";
-const cue = createAvailabilityChecker("cue", ".exe", ["version"]);
-/**
- * `cue vet` reports each error as a header line (a field path or a bare
- * message, ending in `:`) followed by zero or more indented location lines
- * (`    .\path:line:col`). A syntax error has no field-path prefix; a
- * conflicting-value error carries one location per conflicting side, which
- * can span DIFFERENT files in a multi-file package.
- *
- * Verified against cue v0.17.1:
- *   a: conflicting values int and "hello" (mismatched types int and string):
- *       .\bad.cue:3:4
- *       .\bad.cue:3:10
- *   expected '}', found 'EOF':
- *       .\syntax.cue:2:6
- *   badField.name: conflicting values 5 and string (mismatched types int and string):
- *       .\bad-values.cue:3:11
- *       .\bad-values.cue:4:8
- *       .\schema.cue:4:8
- *
- * A summary-only failure (no location lines at all — e.g. the "some
- * instances are incomplete" message `-c=false` is meant to prevent, a
- * directory-scope failure like `build constraints exclude all CUE files`
- * (handled upstream of this parser — see `directoryScopeUnavailable`), or an
- * unrecognized shape from a future cue version) is intentionally NOT
- * silently dropped: `filterToTouchedFile` and the caller make sure a real
- * vet failure can never present as zero findings (recurring defect shape
- * 10) when nothing in the output could be file-attributed at all.
- */
-export function parseCueVetOutput(raw) {
-    const errors = [];
-    let current = null;
-    for (const rawLine of raw.split(/\r?\n/)) {
-        if (!rawLine.trim())
-            continue;
-        if (/^\s/.test(rawLine)) {
-            if (current) {
-                const loc = rawLine.trim().match(/^(.+):(\d+):(\d+)$/);
-                if (loc) {
-                    current.locations.push({
-                        file: loc[1],
-                        line: Number.parseInt(loc[2], 10),
-                        column: Number.parseInt(loc[3], 10),
-                    });
-                }
-            }
-            continue;
-        }
-        if (current)
-            errors.push(current);
-        current = { message: rawLine.replace(/:\s*$/, "").trim(), locations: [] };
-    }
-    if (current)
-        errors.push(current);
-    return errors;
-}
-/**
- * True when `cue vet .`'s failure means the DIRECTORY is not a valid vet
- * unit at all — not a finding about any file's content (review round 2,
- * F5/F6). Both signatures are verified against cue v0.17.1 and carry no
- * `:line:col` anywhere in their output, which is exactly why they used to
- * read as an unattributable whole-vet failure and block every edit.
- */
-export function directoryScopeUnavailable(raw) {
-    return (/build constraints exclude all CUE files/.test(raw) ||
-        // The trailing location cue reports (`in "."` vs `in "two-packages"`)
-        // depends on how it resolves the vet cwd, not on the shape of the
-        // failure — verified both forms against the real binary — so only the
-        // structural "found packages X and Y" part is matched.
-        /found packages ".+"\s*\(.+\)\s+and\s+".+"\s*\(.+\)\s+in\s+".*"/.test(raw));
-}
-/**
- * True when `content` opens with a `package` clause (review round 3, F8).
- * CUE requires the package clause, when present, to be the first
- * declaration in the file — blank lines and `//` comments above it are
- * fine, verified against the real binary — so the first non-blank,
- * non-comment line is decisive: if it isn't `package <name>`, the file has
- * none, and `cue vet .` will silently exclude it from directory-scoped
- * evaluation (F8) rather than fail outright.
- *
- * File-level attributes (`@extern(embed)` is the documented real case) are
- * ALSO legal before the package clause, and are skipped for the same reason
- * comments are (review round 4, F10) — without this, a file opening with
- * one reads as package-less, gets routed to single-file scope, and a
- * cross-file reference into a sibling then false-positives as "reference
- * not found" on an otherwise clean package (verified against the real
- * binary). Field-level attributes never collide with this: they attach to
- * a field and so always start with the field's name, never `@`.
- */
-export function hasPackageClause(content) {
-    for (const line of content.split(/\r?\n/)) {
-        const trimmed = line.trim();
-        if (!trimmed || trimmed.startsWith("//") || trimmed.startsWith("@"))
-            continue;
-        return /^package\s+[A-Za-z_]\w*\b/.test(trimmed);
-    }
-    return false;
-}
-/**
- * Is this reported location 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 and compare through `pathsEqual`.
- *
- * `cue` prints every position relative to its own cwd and prefixes a `./` when
- * the result does not already start with a dot (`cue/errors/errors.go:586-596`
- * at v0.11.0: `filepath.Rel(cfg.Cwd, s)`), which is why `.\bad.cue`,
- * `./bad.cue` and `bad.cue` all name the vetted file — `pathsEqual` folds the
- * separator and the `.` segment, so all three still match.
- *
- * What the basename compare this replaces could not do is tell those apart
- * from `./sub/bad.cue` or `../lib/bad.cue`: an imported package's file that
- * merely SHARES the touched file's basename was reported as the touched file's
- * own failure (the over-merge direction, #3278 sub-shape C).
- */
-function locationMatchesFile(location, absTarget, vetCwd) {
-    return pathsEqual(path.resolve(vetCwd, location.file), absTarget);
-}
-function toDiagnostic(id, message, fileName, line, column) {
-    return {
-        id,
-        message: message || "cue vet reported an error",
-        filePath: fileName,
-        line,
-        column,
-        severity: "error",
-        semantic: "blocking",
-        tool: "cue-vet",
-        rule: "vet",
-        fixable: false,
-    };
-}
-/**
- * Filter package-wide vet errors down to the ones that implicate the touched
- * file, and resolve each to that file's own location (the first location
- * line naming it — the field path can carry more than one, see the
- * `badField.name` example above).
- *
- * Returns `undefined` (distinct from an empty array) only when NOTHING in
- * the output could be file-attributed at all — every error lacked location
- * lines entirely — so the caller can fall back to a whole-output diagnostic
- * instead of reporting a false-clean result (shape 10).
- *
- * ## The mixed case (review round 2, F7)
- *
- * A package-wide vet run can return SEVERAL errors, some with locations and
- * some without. The original rule only fell back to `undefined` when EVERY
- * error lacked a location — so one sibling-located error alongside one
- * genuinely unattributable error made `recognized.length` nonzero, and the
- * unattributable error's diagnostic silently vanished (shape 10, from the
- * filter side this time). There is no file this parser can safely charge an
- * unattributable error to, and no file it can safely clear it from either
- * — so the honest rule is: an unattributable error ALWAYS surfaces on the
- * touched file's result, distinct from (never merged with) a real
- * touched-file location match, and independent of whatever sibling-only
- * errors get filtered out alongside it. Only the fully-uniform case (every
- * error unattributable) still returns `undefined`, so the caller's richer
- * whole-output fallback message is used instead of one row per parsed
- * header.
- */
-export function filterToTouchedFile(errors, fileName, vetCwd) {
-    if (errors.length === 0)
-        return undefined;
-    // `cue vet` always runs in the touched file's own directory, so the vet cwd
-    // joined with the bare file name IS the dispatched file.
-    const absTarget = path.resolve(vetCwd, fileName);
-    const withLocation = errors.filter((error) => error.locations.length > 0);
-    const unattributable = errors.filter((error) => error.locations.length === 0);
-    if (withLocation.length === 0)
-        return undefined;
-    const diagnostics = [];
-    for (const error of withLocation) {
-        const match = error.locations.find((location) => locationMatchesFile(location, absTarget, vetCwd));
-        if (!match)
-            continue; // sibling-only finding — surfaces when that file is touched
-        diagnostics.push(toDiagnostic(`cue-vet-${diagnostics.length + 1}-${match.line}`, error.message, fileName, match.line, match.column));
-    }
-    // F7: an error this parser could not pin to any file must never be
-    // silently dropped just because a SIBLING error happened to carry a
-    // location — surface it too, at line 1 since there is nowhere else to
-    // point.
-    for (const error of unattributable) {
-        diagnostics.push(toDiagnostic(`cue-vet-unattributed-${diagnostics.length + 1}`, error.message, fileName, 1, 1));
-    }
-    return diagnostics;
-}
-const cueVetRunner = {
-    id: "cue-vet",
-    appliesTo: ["cue"],
-    priority: PRIORITY.GENERAL_ANALYSIS,
-    skipTestFiles: false,
-    timeoutMs: 30_000,
-    async run(ctx) {
-        const cwd = resolveRunnerCwd(ctx, "cue-vet");
-        let cmd = null;
-        if (await cue.isAvailableAsync(cwd)) {
-            cmd = cue.getCommand(cwd);
-        }
-        else {
-            cmd = await resolveAvailableOrInstall(cue, "cue", cwd);
-        }
-        // An unspawnable `cue` is never a durable "clean" verdict — skip, so the
-        // dispatcher's own absence handling reports the gap rather than this
-        // runner manufacturing a false "0 findings" (recurring defect shape 10).
-        // `createAvailabilityChecker`/`resolveAvailableOrInstall` already route
-        // through the shared classify/latch policy, so a probe timeout or host
-        // stall re-arms on its own cooldown instead of latching here.
-        if (!cmd)
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        const absPath = path.resolve(cwd, ctx.filePath);
-        const fileDir = path.dirname(absPath);
-        const fileName = path.basename(absPath);
-        const singleFileArgs = ["vet", "-c=false", `./${fileName}`];
-        // F8: read the touched file's OWN content before deciding scope. A
-        // package-less file is excluded from directory-scoped evaluation
-        // entirely (silently, exit 0) rather than causing a failure, so
-        // waiting for the directory vet to fail (the F5/F6 gate below) can
-        // never catch this shape — go straight to single-file scope instead.
-        // An unreadable file falls through to the directory-scoped path below;
-        // package-less-ness that can't be verified is never assumed.
-        let touchedContent = null;
-        try {
-            touchedContent = fs.readFileSync(absPath, "utf8");
-        }
-        catch {
-            touchedContent = null;
-        }
-        const touchedIsPackageLess = touchedContent !== null && !hasPackageClause(touchedContent);
-        let result;
-        if (touchedIsPackageLess) {
-            result = await safeSpawnAsync(cmd, [...singleFileArgs], {
-                cwd: fileDir,
-                timeout: 30_000,
-            });
-        }
-        else {
-            // Package-scoped (F1): vet the whole directory the touched file lives
-            // in, not the file alone — CUE packages unify every file that shares
-            // a package clause, so a single-file invocation cannot see a
-            // definition or value declared in a sibling.
-            result = await safeSpawnAsync(cmd, ["vet", "-c=false", "."], {
-                cwd: fileDir,
-                timeout: 30_000,
-            });
-            if (!spawnFailedWithNoOutput(result, `${result.stdout}${result.stderr}`) &&
-                result.status !== 0 &&
-                directoryScopeUnavailable(`${result.stdout || ""}${result.stderr || ""}`)) {
-                // F6: the directory holds two+ DIFFERENTLY-packaged files (the
-                // touched file has its own valid package, but the directory as a
-                // whole still isn't one unit) — fall back to the touched file
-                // alone, which IS a valid unit on its own.
-                result = await safeSpawnAsync(cmd, [...singleFileArgs], {
-                    cwd: fileDir,
-                    timeout: 30_000,
-                });
-            }
-        }
-        if (spawnFailedWithNoOutput(result, `${result.stdout}${result.stderr}`)) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        // `cue vet` is silent on success (empty stdout, exit 0) — that IS the
-        // clean signal, not an unavailable/errored one, so status 0 with no
-        // output reports succeeded/no-findings rather than falling through to
-        // the skip above.
-        if (result.status === 0) {
-            return { status: "succeeded", diagnostics: [], semantic: "none" };
-        }
-        const raw = `${result.stdout || ""}\n${result.stderr || ""}`.trim();
-        const errors = parseCueVetOutput(raw);
-        // The single-file path (F5/F6/F8) needs no special-casing: every
-        // location it reports already belongs to the one file it vetted, so it
-        // trivially matches `fileName` and flows through the same filter as
-        // the directory-scoped path — one code path, and a single-file run
-        // that somehow fails with no location at all still gets the same
-        // never-silently-clean `undefined` fallback as the directory path.
-        const filtered = filterToTouchedFile(errors, fileName, fileDir);
-        if (filtered === undefined) {
-            // Nonzero exit, some output, but nothing in it could be attributed to
-            // ANY file — a real failure must not present as zero findings.
-            return {
-                status: "failed",
-                diagnostics: [
-                    {
-                        id: "cue-vet-unparsed",
-                        message: raw.slice(0, 300) || "cue vet exited non-zero",
-                        filePath: ctx.filePath,
-                        line: 1,
-                        column: 1,
-                        severity: "error",
-                        semantic: "blocking",
-                        tool: "cue-vet",
-                        rule: "vet",
-                        fixable: false,
-                    },
-                ],
-                semantic: "blocking",
-            };
-        }
-        if (filtered.length === 0) {
-            // The package has real errors, but none of them implicate the touched
-            // file — a sibling's problem, not this file's (the F1 tradeoff).
-            return { status: "succeeded", diagnostics: [], semantic: "none" };
-        }
-        return { status: "failed", diagnostics: filtered, semantic: "blocking" };
-    },
-};
-export default cueVetRunner;

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

@@ -1,183 +0,0 @@
-import * as path from "node:path";
-import { safeSpawnAsync } from "../../safe-spawn.js";
-import { pathsEqual } from "../../path-utils.js";
-import { resolveRunnerCwd } from "../../tool-cwd.js";
-import { createAvailabilityChecker } from "./utils/runner-helpers.js";
-import { finishParsedRun, parseToolRun } from "./utils/tool-failure.js";
-import { PRIORITY } from "../priorities.js";
-const dart = createAvailabilityChecker("dart", ".exe");
-const flutter = createAvailabilityChecker("flutter", ".bat");
-// Lint rules that `dart fix` rewrites deterministically. The `--format=
-// machine` output does NOT surface a per-diagnostic fix flag, so we keep
-// a curated allowlist. Sources: dart.dev/tools/dart-fix and the `linter`
-// package's documentation of which rules ship a fix. Conservative — when
-// in doubt, leave a rule off this list.
-const DART_FIXABLE_RULES = new Set([
-    // const / final canonicalization
-    "prefer_const_constructors",
-    "prefer_const_constructors_in_immutables",
-    "prefer_const_declarations",
-    "prefer_const_literals_to_create_immutables",
-    "prefer_final_fields",
-    "prefer_final_in_for_each",
-    "prefer_final_locals",
-    "prefer_final_parameters",
-    "unnecessary_const",
-    "unnecessary_final",
-    "unnecessary_new",
-    // null-aware / null safety modernization
-    "avoid_init_to_null",
-    "avoid_null_checks_in_equality_operators",
-    "avoid_returning_null_for_void",
-    "null_closures",
-    "prefer_if_null_operators",
-    "prefer_null_aware_operators",
-    "unnecessary_null_aware_assignments",
-    "unnecessary_null_in_if_null_operators",
-    // string / quoting / interpolation
-    "prefer_adjacent_string_concatenation",
-    "prefer_interpolation_to_compose_strings",
-    "prefer_single_quotes",
-    "unnecessary_brace_in_string_interps",
-    "unnecessary_string_escapes",
-    "unnecessary_string_interpolations",
-    "use_raw_strings",
-    "use_string_buffers",
-    // collection literals / spread / where
-    "prefer_collection_literals",
-    "prefer_contains",
-    "prefer_for_elements_to_map_fromiterable",
-    "prefer_inlined_adds",
-    "prefer_int_literals",
-    "prefer_iterable_whereType",
-    "prefer_is_empty",
-    "prefer_is_not_empty",
-    "prefer_is_not_operator",
-    "prefer_spread_collections",
-    "use_collection_literals_when_possible",
-    // types / generics / function syntax
-    "omit_local_variable_types",
-    "prefer_expression_function_bodies",
-    "prefer_function_declarations_over_variables",
-    "prefer_generic_function_type_aliases",
-    "prefer_typing_uninitialized_variables",
-    "prefer_void_to_null",
-    "type_init_formals",
-    "use_function_type_syntax_for_parameters",
-    // redundancy / cleanup
-    "avoid_redundant_argument_values",
-    "avoid_unused_constructor_parameters",
-    "empty_catches",
-    "empty_constructor_bodies",
-    "unnecessary_lambdas",
-    "unnecessary_overrides",
-    "unnecessary_parenthesis",
-    "unnecessary_this",
-    // imports / sorting / formatting
-    "combinators_ordering",
-    "directives_ordering",
-    "prefer_relative_imports",
-    "sort_child_properties_last",
-    "slash_for_doc_comments",
-    // flutter-specific deterministic rewrites
-    "sized_box_for_whitespace",
-    "use_decorated_box",
-    "use_full_hex_values_for_flutter_colors",
-    "use_key_in_widget_constructors",
-    "use_named_constants",
-    "use_super_parameters",
-    // misc
-    "prefer_conditional_assignment",
-    "prefer_equal_for_default_values",
-    "prefer_initializing_formals",
-    "avoid_void_async",
-    "unawaited_futures",
-    "use_rethrow_when_possible",
-]);
-// dart analyze --format=machine output:
-// severity|type|code|file|line|col|length|message
-function parseDartMachineOutput(raw, filePath, cwd) {
-    const diagnostics = [];
-    const absTarget = path.resolve(cwd, filePath);
-    for (const line of raw.split(/\r?\n/)) {
-        if (!line.trim())
-            continue;
-        const parts = line.split("|");
-        if (parts.length < 8)
-            continue;
-        const [severityStr, , code, file, lineStr, colStr, , ...messageParts] = parts;
-        const message = messageParts.join("|").trim();
-        const lineNum = parseInt(lineStr, 10);
-        const colNum = parseInt(colStr, 10);
-        // #3278: one seam for reported-path attribution — see javac.ts.
-        // The `endsWith` outer arm this replaces was inert on the target (a
-        // string ends with itself) and an over-merge risk everywhere else: any
-        // reported path whose TAIL spelled the absolute target attached to it.
-        // `file` is `parts[3]`, which `tsconfig.strict-indexed.json`
-        // (`noUncheckedIndexedAccess`) types as `string | undefined` even behind the
-        // `parts.length < 8` guard above — the strictness ratchet pins that, so the
-        // optional chain stays.
-        if (!pathsEqual(path.resolve(cwd, file?.trim() ?? ""), absTarget))
-            continue;
-        const severity = severityStr?.trim().toLowerCase() === "error" ? "error" : "warning";
-        const ruleId = code?.trim() ?? "dart";
-        const fixable = DART_FIXABLE_RULES.has(ruleId);
-        diagnostics.push({
-            id: `dart-${ruleId}-${lineNum}-${colNum}`,
-            message: `[${ruleId}] ${message}`,
-            filePath,
-            line: lineNum || 1,
-            column: colNum || 1,
-            severity,
-            semantic: severity === "error" ? "blocking" : "warning",
-            tool: "dart",
-            rule: ruleId,
-            defectClass: "style",
-            fixable,
-            fixSuggestion: fixable
-                ? "Run `dart fix --apply` to apply the deterministic auto-correction for this rule."
-                : undefined,
-        });
-    }
-    return diagnostics;
-}
-const dartAnalyzeRunner = {
-    id: "dart-analyze",
-    appliesTo: ["dart"],
-    priority: PRIORITY.GENERAL_ANALYSIS,
-    skipTestFiles: false,
-    async run(ctx) {
-        const cwd = resolveRunnerCwd(ctx, "dart-analyze");
-        const absPath = path.resolve(cwd, ctx.filePath);
-        const dartAvailable = await dart.isAvailableAsync(cwd);
-        const flutterAvailable = !dartAvailable && (await flutter.isAvailableAsync(cwd));
-        if (!dartAvailable && !flutterAvailable) {
-            return { status: "skipped", diagnostics: [], semantic: "none" };
-        }
-        const cmd = dartAvailable
-            ? dart.getCommand(cwd)
-            : flutter.getCommand(cwd);
-        const args = dartAvailable
-            ? ["analyze", "--format=machine", absPath]
-            : ["analyze", "--machine", absPath];
-        const result = await safeSpawnAsync(cmd, args, { cwd, timeout: 30000 });
-        // dart analyze writes diagnostics to stderr in machine format
-        const raw = (result.stderr || "") + (result.stdout || "");
-        const parsed = parseToolRun("dart-analyze", {
-            result,
-            output: raw,
-            // EXIT TABLE (Dart 3.5 measured fixture): 0 clean; 1 findings; 2 error; other nonzero rejected.
-            exitCodes: { ran: [1, 2] },
-        }, (out) => parseDartMachineOutput(out, ctx.filePath, cwd));
-        if (parsed.skipped)
-            return parsed.skipped;
-        return finishParsedRun({
-            tool: "dart-analyze",
-            ctx,
-            result,
-            diagnostics: parsed.diagnostics,
-        });
-    },
-};
-export default dartAnalyzeRunner;
-export { parseDartMachineOutput, DART_FIXABLE_RULES };