pi-lens 4.3.0 → 4.4.1

package/dist/clients/build-identity.js

@@ -1,95 +0,0 @@
-/**
- * #1775: `sessionstart.log` recorded no build identity — no commit hash, no
- * build timestamp. Dogfood forensics ("does this session include PR #1727?")
- * had to reconstruct that by hand: run `git merge-base --is-ancestor` in the
- * serving checkout and compare `dist/` mtimes against the session-start time.
- *
- * The running extension can be a different checkout than the repo an
- * investigator is looking at, so identity is derived from the RUNNING
- * build's own files — `getPackageRoot` (already used by grammar-source.ts to
- * find pi-lens's own assets under both the unbundled dev layout and a
- * packaged install) plus the mtime of the very entry file that is executing
- * right now — never from `process.cwd()` and never assumed to be a git
- * checkout.
- *
- * Commit resolution reuses `review-graph/git-identity.ts`'s
- * `resolveGitIdentity` — a PURE filesystem read, no `git` subprocess. This
- * runs inside the `session_start` handler, ahead of the #473
- * concurrent-secondary classification, so every in-process subagent pays
- * whatever this costs; a synchronous `git rev-parse`/`git status` spawn pair
- * (fix round 1's approach, reverted here) measured 150-300ms typical and up
- * to ~10s worst case on two 5s timeouts. `resolveGitIdentity` is a handful of
- * `fs.readFileSync` calls, LRU-cached per process, so this path never spawns.
- *
- * The dirty working-tree flag genuinely needs `git status`, which has no
- * spawn-free equivalent — so it is dropped from this record rather than
- * reintroducing a spawn on the session-start hot path (refs #1775 followup
- * comment: dirty flag deferred, commit + entryMtime + version shipped).
- */
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { fileURLToPath } from "node:url";
-import { isTestMode } from "./env-utils.js";
-import { getPackageRoot } from "./package-root.js";
-import { normalizeFilePath } from "./path-utils.js";
-import { resolveGitIdentity } from "./review-graph/git-identity.js";
-/**
- * A `.git` found by walking up from `root` only counts as owning `root` when
- * its resolved worktree top-level IS `root` — not merely an ancestor of it.
- * Without this check, a packaged install nested anywhere under an unrelated
- * repo (a dotfiles checkout in $HOME is the common case) would confidently
- * report that repo's HEAD as the running build's identity.
- */
-function resolveOwnedCommit(root) {
-    const identity = resolveGitIdentity(root);
-    if (!identity)
-        return "unknown";
-    const normalizedRoot = normalizeFilePath(path.resolve(root));
-    if (identity.worktreeRoot !== normalizedRoot)
-        return "unknown";
-    return identity.headCommit.slice(0, 8);
-}
-function readPackageVersion(root) {
-    try {
-        const raw = fs.readFileSync(path.join(root, "package.json"), "utf-8");
-        const pkg = JSON.parse(raw);
-        return pkg.version ?? "unknown";
-    }
-    catch {
-        return "unknown";
-    }
-}
-function statEntryMtime(entryImportMetaUrl) {
-    try {
-        return fs.statSync(fileURLToPath(entryImportMetaUrl)).mtime.toISOString();
-    }
-    catch {
-        // Entry path unresolvable (e.g. a non-file:// URL) — "unknown" rather
-        // than throw out of a session-start observability line.
-        return "unknown";
-    }
-}
-/**
- * Resolve the identity of the build currently running — pure filesystem
- * reads, no subprocess. `entryImportMetaUrl` must be the ENTRY module's own
- * `import.meta.url` (index.ts) — passing a different module's URL would
- * report that module's mtime instead of the running build's.
- *
- * Returns `undefined` inside the test runner: nothing computed, nothing
- * logged (`sessionstart-logger`'s writer is a no-op there too), so a caller
- * on the session-start hot path never pays this cost during tests.
- */
-export function getBuildIdentity(entryImportMetaUrl) {
-    if (isTestMode())
-        return undefined;
-    const root = getPackageRoot(entryImportMetaUrl);
-    return {
-        commit: resolveOwnedCommit(root),
-        entryMtime: statEntryMtime(entryImportMetaUrl),
-        version: readPackageVersion(root),
-    };
-}
-/** One bounded, human-readable line for sessionstart.log's free-text writer. */
-export function formatBuildIdentity(identity) {
-    return `session_start: build identity — commit=${identity.commit} entryMtime=${identity.entryMtime} version=${identity.version}`;
-}

package/dist/clients/bundled-resource-health.js

@@ -1,113 +0,0 @@
-/**
- * Shared health classification + degradation reporting for a bundled
- * resource directory read DIRECTLY by pi-lens (never handed to an external
- * spawned tool as a `--config`/`--rule-dir` argument — that class already
- * fails loudly through the tool's own spawn-failure path).
- *
- * #2626 fixed this shape for `clients/skills-resolver.ts`'s `skills/`
- * directory: `resolvePackagePath(import.meta.url, …)` walks up from the
- * loaded entry file to the nearest `package.json`, which is correct for both
- * the source and compiled `dist/` layouts, but goes wrong SILENTLY, not
- * loudly, when that walk lands somewhere with no resource dir beside it —
- * the bundled dir missing from an installed package, or the entry file
- * copied out of the package tree by a managed extension cache so the
- * nearest `package.json` is the cache's own. #2636 is the class sweep:
- * `clients/ast-grep-client.ts`'s `rules` fallback and the bundled
- * tree-sitter-queries root (read identically by `clients/cache/rule-cache.ts`
- * and `clients/tree-sitter-query-loader.ts`) have the exact same gap.
- *
- * Both callers reuse this ONE classify+report pair rather than each
- * hand-rolling the ENOENT/EACCES distinction (#2626 review F4) a second and
- * third time.
- */
-import * as fs from "node:fs";
-import { incrementDegradationCount, } from "./degradation-ledger.js";
-import { notifyUserDegradation } from "./user-notify.js";
-/**
- * Classify `dir`: does it exist, is it readable, and does it hold anything?
- * Fail-closed and never throws. Distinguishes `ENOENT` (the common
- * managed-cache-relocation case) from any OTHER `readdirSync` error
- * (`EACCES` and friends) — an unreadable directory might genuinely hold a
- * real resource pi-lens simply cannot read, so the honest report is "cannot
- * read it", never "nothing is there" (#2626 review F4).
- *
- * `countEntries` lets a caller supply its OWN notion of "found" — e.g.
- * `skills-resolver.ts` counts pi-loadable skill entry points via
- * `scanEntriesForSkills`, not a bare directory listing — while still sharing
- * this function's ENOENT/EACCES/empty classification shell (#2636 review F4:
- * that shell was duplicated character-for-character between the two modules
- * before this parameter existed). The default counts plain directory
- * entries, which is what every OTHER caller (ast-grep's rules dir, the
- * bundled tree-sitter-queries root) actually wants.
- */
-export function classifyBundledResourceDir(dir, countEntries = (d) => fs.readdirSync(d).length) {
-    let entryCount;
-    try {
-        entryCount = countEntries(dir);
-    }
-    catch (error) {
-        const fsErrorCode = error?.code ?? "UNKNOWN";
-        if (fsErrorCode === "ENOENT")
-            return { status: "absent" };
-        return { status: "unreadable", fsErrorCode };
-    }
-    return entryCount > 0
-        ? { status: "healthy", entryCount }
-        : { status: "empty" };
-}
-/**
- * Render `health` as a reason string. `emptyDescription` lets a caller name
- * what "nothing found" actually means for its own resource (skills' loader
- * cares about `SKILL.md`, not bare directory entries); every other status's
- * prose is shared verbatim, since ENOENT/EACCES mean the exact same thing
- * regardless of which resource directory hit them.
- */
-export function describeBundledResourceHealth(health, dir, emptyDescription = `${dir} exists but holds nothing`) {
-    switch (health.status) {
-        case "absent":
-            return `no such directory: ${dir}`;
-        case "unreadable":
-            return `cannot read ${dir} (${health.fsErrorCode})`;
-        case "empty":
-            return emptyDescription;
-        default:
-            // unreachable for the "healthy" case — callers only report unhealthy ones.
-            return `${dir}: unexpected health status`;
-    }
-}
-/**
- * Record ONE bounded `kind` degradation plus one `notifyUserDegradation`
- * warning per (kind, dir) per session, when `health` is not healthy.
- * Pure no-op when healthy. `incrementDegradationCount`'s own return value
- * (not a hand-rolled Set) gates the notify to the rising edge, so a caller
- * invoked on every dispatch (e.g. `RuleCache`'s constructor) can call this
- * unconditionally without spamming the notify surface.
- *
- * `reasonOverride` lets a caller build a richer reason (skills-resolver.ts
- * appends the entry file's directory) while still sharing the
- * increment/notify mechanics below; the default is this module's own
- * `describeBundledResourceHealth`.
- *
- * `notifyMessage` lets a caller replace the DEFAULT `pi-lens: <label>
- * unavailable — <reason>.` sentence with its own finished wording (#2636
- * review round 2, F1): `skills-resolver.ts`'s shipped notify text ("registers
- * zero skills") is user-visible product text #2626 chose deliberately — the
- * SYMPTOM the notification exists to surface — and folding onto this shared
- * helper must never silently reword a string a maintainer already tuned.
- */
-export function reportBundledResourceDirHealth(kind, dir, health, label, reasonOverride, notifyMessage) {
-    if (health.status === "healthy")
-        return;
-    const reason = reasonOverride ?? describeBundledResourceHealth(health, dir);
-    const isFirstOccurrence = incrementDegradationCount({
-        kind,
-        subject: dir,
-        reason,
-        metadata: health.status === "unreadable"
-            ? { fsErrorCode: health.fsErrorCode }
-            : undefined,
-    });
-    if (isFirstOccurrence) {
-        notifyUserDegradation(notifyMessage ?? `pi-lens: ${label} unavailable — ${reason}.`, "warning");
-    }
-}

package/dist/clients/bus-events-logger.js

@@ -1,105 +0,0 @@
-/**
- * Persistent NDJSON trace of `pi.events` bus publish attempts
- * (`pilens:files:touched` #482 / `pilens:diagnostics` #502 /
- * `pilens:diagnostic:disposition` / `pilens:format:queued` +
- * `pilens:format:start` + `pilens:autofix:start` #673/#684 /
- * `pi-lens/analysis-complete` + `pi-lens/findings` + `pi-lens/turn-findings`
- * #1415) — nine event names across five producers.
- *
- * All five producers (clients/bus-publish.ts, clients/diagnostics-publish.ts,
- * clients/disposition-publish.ts, clients/format-events-publish.ts,
- * clients/lens-events.ts) are fire-and-forget: on failure or on a structural
- * no-op (never wired, kill switch off) the four #482/#502/#673/#684
- * producers only invoke an optional `dbg` callback, which varies by host and
- * is a documented no-op in the MCP host (clients/mcp/session.ts's
- * `dbg: noop`); `lens-events.ts` (#1415) has no `dbg` param at all — its
- * events are purely observational inter-extension telemetry, so this NDJSON
- * trace is its ONLY failure-visible surface. Either way, that leaves
- * bus-publish outcomes invisible in exactly the context where they matter
- * most — same failure shape as the #544 MCP session_start incident this repo
- * already fixed once.
- *
- * This module gives bus events the same durable trace every other pi-lens
- * subsystem already has (latency.log, cascade.log, read-guard.log, ...) —
- * see clients/latency-logger.ts for the house pattern this mirrors exactly:
- * one shared `createNdjsonLogger` writer, `isTestMode()` no-op guard.
- *
- * Logging volume: `emitted` and `emit_failed` are logged on every call —
- * they're the two outcomes an operator actually needs a per-event trace for.
- * `skipped_unwired` and `skipped_disabled` are process-lifetime-static facts
- * (wiring happens once at extension factory time; the kill switch is an env
- * var read once at startup) — logging them on every publish attempt would
- * spam one identical line per write batch for an entire session with zero
- * new information after the first. Both are gated log-once-per-process, the
- * same `hasLoggedFailure` shape the producers already use for emit_failed.
- * `skipped_stale_session` is an info-level per-occurrence outcome: the emit
- * seam intentionally declined a target whose associated ctx was confirmed
- * stale, so it is neither a bus failure nor input for the smells rollup.
- * The empty-batch branch (`paths.length === 0` / `files.length === 0`) is
- * NOT logged at all: every call site already guards against invoking these
- * functions with nothing to report (see clients/pipeline.ts,
- * clients/runtime-agent-end.ts), so it's a normal, frequent no-op rather
- * than a real event worth a log line.
- */
-import * as path from "node:path";
-import { isTestMode } from "./env-utils.js";
-import { getGlobalPiLensLogDir } from "./probe-home-state.js";
-import { createNdjsonLogger } from "./ndjson-logger.js";
-import { getMaxLogSizeMB } from "./log-cleanup.js";
-import { logLatency } from "./latency-logger.js";
-const BUS_EVENTS_LOG_FILE = path.join(getGlobalPiLensLogDir(), "bus-events.log");
-const writer = createNdjsonLogger({
-    filePath: BUS_EVENTS_LOG_FILE,
-    maxBytes: getMaxLogSizeMB() * 1024 * 1024,
-});
-const eventRollupCounts = new Map();
-function bumpRollupCount(event, outcome) {
-    const existing = eventRollupCounts.get(event) ?? {
-        emitted: 0,
-        skipped_stale_session: 0,
-        emit_failed: 0,
-    };
-    existing[outcome] += 1;
-    eventRollupCounts.set(event, existing);
-}
-export function logBusEvent(entry) {
-    if (entry.outcome === "emitted" ||
-        entry.outcome === "skipped_stale_session" ||
-        entry.outcome === "emit_failed") {
-        bumpRollupCount(entry.event, entry.outcome);
-    }
-    if (isTestMode()) {
-        return;
-    }
-    writer.log({ ts: new Date().toISOString(), ...entry });
-}
-/** Snapshot the current session's rollup, keyed by event name. Non-mutating —
- *  pair with {@link resetBusEventRollupCounts} at session end. */
-export function getBusEventRollupCounts() {
-    return Object.fromEntries(eventRollupCounts);
-}
-/** Clear the rollup — call once the session-end snapshot has been logged
- *  (or from tests) so a new session starts from zero. */
-export function resetBusEventRollupCounts() {
-    eventRollupCounts.clear();
-}
-/**
- * Log one `session_end_bus_rollup` latency row per event NAME that had any
- * activity this session, then clear the rollup. Called from index.ts's
- * `session_shutdown` handler (the session-end hook this repo's other
- * teardown work — LSP fleet shutdown, cache-prefix eviction — already runs
- * from). A no-op (logs nothing) when nothing was ever published, matching
- * `formatSmellsSessionStartLine`'s "no noise on an ordinary session" shape.
- */
-export function emitBusEventRollupAtSessionEnd(cwd) {
-    for (const [event, counts] of eventRollupCounts) {
-        logLatency({
-            type: "phase",
-            phase: "session_end_bus_rollup",
-            filePath: cwd,
-            durationMs: 0,
-            metadata: { event, ...counts },
-        });
-    }
-    resetBusEventRollupCounts();
-}

package/dist/clients/bus-publish.js

@@ -1,171 +0,0 @@
-/**
- * Publishes `pilens:files:touched` on pi's shared `pi.events` bus (#482).
- *
- * This is pi-lens's FIRST `pi.events` broadcast surface: it exists so other
- * extensions in the same session can observe files pi-lens writes
- * autonomously (autofix/format runners) without reverse-engineering us —
- * writes the agent makes itself via its own tool calls are NOT ours to
- * broadcast; the host already knows about those (see the seam audit in
- * AGENTS.md / issue #482).
- *
- * Versioning policy: the payload is frozen-additive. New optional fields may
- * be added under the same `v: 1`; a breaking/incompatible change to an
- * existing field's meaning must bump `v`.
- *
- * Fire-and-forget: publishing must never affect the write path's success or
- * latency. Any failure (bus unavailable, emit throws) is swallowed; a `dbg`
- * callback is invoked at most once on first failure so a wired caller can log
- * it without spamming.
- */
-import { logBusEvent } from "./bus-events-logger.js";
-import { normalizeFilePath } from "./path-utils.js";
-import { appendRecentTouches } from "./recent-touches.js";
-import { createLiveBusEmitter, recordStaleBusFailure, resolveLiveBusEmitter, } from "./live-bus-emitter.js";
-export const BUS_FILES_TOUCHED_EVENT = "pilens:files:touched";
-export const BUS_FILES_TOUCHED_VERSION = 1;
-const BUS_LOG_PATH_CAP = 64;
-const liveEmitter = createLiveBusEmitter();
-let hasLoggedFailure = false;
-// Log-once-per-process guards for the two structural-no-op outcomes below
-// (see bus-events-logger.ts's module doc for why these aren't logged on
-// every call — both are static, session-lifetime facts, not transient
-// per-event failures).
-let hasLoggedUnwired = false;
-let hasLoggedDisabled = false;
-/**
- * Wire the emit function from pi's `pi.events` bus. Called once at extension
- * factory time from index.ts (module-level singleton, same pattern as
- * `initLensEvents`). Never called ⇒ `publishFilesTouched` no-ops, which is
- * exactly the state unit tests and the MCP server path run in (no pi host,
- * no `pi.events`).
- */
-export function wireBusEmitter(emitFn) {
-    liveEmitter.wire(emitFn);
-}
-export function wireBusEmitterGetter(getter) {
-    liveEmitter.wireGetter(getter);
-}
-/** Test-only: reset module state between test files. */
-export function _resetForTests() {
-    liveEmitter.reset();
-    hasLoggedFailure = false;
-    hasLoggedUnwired = false;
-    hasLoggedDisabled = false;
-    _envCache = undefined;
-}
-let _envCache;
-/**
- * Lazy env read (house style) so tests can flip `PI_LENS_BUS_PUBLISH` at
- * runtime via `_resetForTests` + re-set the env var. Kill switch: set to `0`
- * to disable publishing outright.
- */
-export function isBusPublishEnabled() {
-    if (_envCache === undefined) {
-        _envCache = process.env.PI_LENS_BUS_PUBLISH !== "0";
-    }
-    return _envCache;
-}
-/**
- * Publish one `pilens:files:touched` event for a logical write batch (one
- * event per call site invocation, not per file). Fire-and-forget: never
- * throws, never awaited by the caller's write path.
- *
- * #492: this is also the producer seam for the cross-process
- * `recent-touches.json` record (clients/recent-touches.ts) — parent and
- * child pi processes run this exact function, so appending here (rather
- * than at each of the several `publishFilesTouched` call sites) guarantees
- * every future call site gets cross-process propagation for free. The
- * append is independent of `busEmit` being wired (a bare/MCP/test host with
- * no `pi.events` still gets a cross-process record — the in-process bus and
- * the on-disk record are two separate deliveries of the same payload, and
- * the record is the ONLY one of the two that survives a process boundary).
- * Fire-and-forget, same as the bus emit: never awaited, failures swallowed
- * and dbg-logged (never break the publish path).
- */
-export function publishFilesTouched(args) {
-    if (args.origin === "bus")
-        return;
-    if (args.paths.length === 0)
-        return;
-    if (!isBusPublishEnabled()) {
-        if (!hasLoggedDisabled) {
-            hasLoggedDisabled = true;
-            logBusEvent({
-                event: BUS_FILES_TOUCHED_EVENT,
-                outcome: "skipped_disabled",
-                cwd: normalizeFilePath(args.cwd),
-                reason: args.reason,
-            });
-        }
-        return;
-    }
-    void appendRecentTouches({
-        cwd: args.cwd,
-        reason: args.reason,
-        paths: args.paths,
-        sessionId: args.sessionId,
-    }).catch((err) => {
-        args.dbg?.(`bus-publish: recent-touches append failed: ${err}`);
-    });
-    const resolution = resolveLiveBusEmitter(liveEmitter, () => ({
-        event: BUS_FILES_TOUCHED_EVENT,
-        cwd: normalizeFilePath(args.cwd),
-        reason: args.reason,
-    }));
-    if (resolution.outcome === "stale-session")
-        return;
-    if (resolution.outcome === "unwired") {
-        if (!hasLoggedUnwired) {
-            hasLoggedUnwired = true;
-            logBusEvent({
-                event: BUS_FILES_TOUCHED_EVENT,
-                outcome: "skipped_unwired",
-                cwd: normalizeFilePath(args.cwd),
-                reason: args.reason,
-            });
-        }
-        return;
-    }
-    const busEmit = resolution.emit;
-    try {
-        const payload = {
-            v: BUS_FILES_TOUCHED_VERSION,
-            source: "pi-lens",
-            reason: args.reason,
-            paths: args.paths.map((p) => normalizeFilePath(p)),
-            cwd: normalizeFilePath(args.cwd),
-        };
-        if (args.fixes && args.fixes.length > 0) {
-            payload.fixes = args.fixes.map((f) => ({
-                ...f,
-                path: normalizeFilePath(f.path),
-            }));
-        }
-        busEmit(BUS_FILES_TOUCHED_EVENT, payload);
-        hasLoggedFailure = false;
-        logBusEvent({
-            event: BUS_FILES_TOUCHED_EVENT,
-            outcome: "emitted",
-            cwd: payload.cwd,
-            reason: args.reason,
-            fileCount: payload.paths.length,
-            writer: "pi-lens",
-            paths: payload.paths.slice(0, BUS_LOG_PATH_CAP),
-        });
-    }
-    catch (err) {
-        logBusEvent({
-            event: BUS_FILES_TOUCHED_EVENT,
-            outcome: "emit_failed",
-            cwd: normalizeFilePath(args.cwd),
-            reason: args.reason,
-            error: String(err),
-            ctxSource: resolution.ctxSource,
-        });
-        if (!hasLoggedFailure) {
-            hasLoggedFailure = true;
-            recordStaleBusFailure(BUS_FILES_TOUCHED_EVENT, err);
-            args.dbg?.(`bus-publish: pilens:files:touched emit failed (further failures suppressed): ${err}`);
-        }
-    }
-}

package/dist/clients/cache/rule-cache.js

@@ -1,190 +0,0 @@
-/**
- * Rule Cache for pi-lens
- *
- * Provides disk-based caching for parsed tree-sitter rules with
- * automatic invalidation based on rule file modification times.
- */
-import * as crypto from "node:crypto";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import { reportBundledResourceDirHealth } from "../bundled-resource-health.js";
-import { getProjectDataDir } from "../file-utils.js";
-import { readJsonCache } from "../json-cache-read.js";
-import { BUNDLED_QUERIES_ROOT, getBundledQueriesRootHealth, } from "../tree-sitter-query-loader.js";
-import { writeFileAtomic } from "../atomic-write.js";
-import { compareOrdinal } from "../string-utils.js";
-// v4: cache skip_test_files + fix_action — v3 entries silently dropped them,
-// and ruleHash (rule-file mtimes) never invalidates on a code-only fix.
-// v5 (#675): rule SELECTION changed in code — javascript no longer inherits the
-// typescript rule set and tsx now does. A v4 entry holds the old merge, and
-// queries now compile against the file's parse language, so replaying it would
-// fire typescript rules on javascript trees for real this time.
-// v6 (#878): the ruleHash FINGERPRINT now covers the full effective rule set —
-// inherited rule-source directories (tsx also runs typescript rules), not just
-// the language's own. A v5 tsx entry was hashed over tsx files only, so a
-// typescript-rule edit never invalidated it; v5 entries self-miss anyway (the
-// hash input set changed), the bump just makes the semantics break explicit.
-// v7 (#1118): computeRuleHash now CONTENT-hashes project-local rule files
-// instead of trusting mtime+size alone. mtime+size is the review-graph
-// first-filter, not the full gold standard (size:mtimeMs + confirmContentChanged)
-// — a rule-file edit that preserves both (git checkout timestamp restoration, a
-// same-length tweak, a formatter that preserves mtime) replayed a stale
-// compiled set from disk and re-persisted it under the still-matching
-// fingerprint, poisoning every future process. The bump forces every v6 entry
-// (hashed under the old metadata-only formula) to miss once on upgrade, so a
-// silently-poisoned v6 entry can't be trusted by the new code.
-export const CACHE_VERSION = "v7";
-/**
- * Bundled rule files ship with the extension and are immutable within a
- * process — they can't change mid-session, so the cheap mtime+size
- * fingerprint (v6's whole-set formula) is sufficient for them, and there are
- * ~705 of them across all languages, so unconditionally reading+hashing their
- * bytes on every edit would be the unconditional hot-path hashing the
- * event-loop discipline forbids (RuleCache.get runs on the per-edit
- * tree-sitter runner hot path).
- *
- * Project-local rule files (under `<project>/rules/tree-sitter-queries/`,
- * see `ruleFilesForLanguage`) are the opposite: mutable, and a SMALL set (the
- * handful a developer actually maintains) — cheap to content-hash. Splitting
- * on this prefix mirrors the split `yaml-rule-parser.ts`/`ast-grep-napi.ts`
- * already use for the ast-grep side of the same class (#1105): project-origin
- * trees get a content-hash CONFIRM, bundled trees stay mtime-cheap.
- *
- * #2636 review F4: re-exported from `tree-sitter-query-loader.ts`'s
- * `BUNDLED_QUERIES_ROOT` rather than computed a second time here — the two
- * modules read the IDENTICAL physical directory, and the "one ledger row"
- * claim below rests on that being reference equality, not two independently
- * `resolvePackagePath`-resolved strings that happen to match.
- */
-export { BUNDLED_QUERIES_ROOT as BUNDLED_RULES_ROOT } from "../tree-sitter-query-loader.js";
-function isBundledRuleFile(resolvedFile) {
-    return (resolvedFile === BUNDLED_QUERIES_ROOT ||
-        resolvedFile.startsWith(BUNDLED_QUERIES_ROOT + path.sep));
-}
-/**
- * #2636 (the #2626 class sweep's tree-sitter leg): the bundled
- * tree-sitter-queries root above was used unconditionally with no existence
- * check — same managed-cache-relocation gap #2626 fixed for `skills/`.
- * Purely observational (never gates `isBundledRuleFile`'s classification):
- * records a bounded `tree-sitter-queries-dir-missing` degradation only when
- * the bundled root is absent, unreadable, or (uncommonly) present but empty.
- * Shares the exact kind + subject `clients/tree-sitter-query-loader.ts`'s
- * `ruleFilesForLanguage` reports under — both read the SAME physical
- * directory (`getBundledQueriesRootHealth`'s process-lifetime memo, #2636
- * review F6 — this constructor runs per dispatched file, so an unmemoized
- * `readdirSync` here would be the same unconditional hot-path cost the
- * class doc comment above forbids for rule-file hashing), so the ledger's
- * own (kind, subject) dedup collapses whichever call site observes it first
- * into ONE row rather than two duplicates.
- */
-function reportBundledRulesRootHealth() {
-    reportBundledResourceDirHealth("tree-sitter-queries-dir-missing", BUNDLED_QUERIES_ROOT, getBundledQueriesRootHealth(), "bundled tree-sitter query rules");
-}
-export class RuleCache {
-    cacheFile;
-    cacheDir;
-    language;
-    constructor(language, rootDir = process.cwd()) {
-        this.language = language;
-        reportBundledRulesRootHealth();
-        this.cacheDir = path.join(getProjectDataDir(rootDir), "cache");
-        this.cacheFile = path.join(this.cacheDir, `${language}-rules-${CACHE_VERSION}.json`);
-    }
-    ensureCacheDir() {
-        if (!fs.existsSync(this.cacheDir)) {
-            fs.mkdirSync(this.cacheDir, { recursive: true });
-        }
-    }
-    computeRuleHash(ruleFiles) {
-        const hash = crypto.createHash("sha256");
-        for (const file of ruleFiles.sort(compareOrdinal)) {
-            const resolved = path.resolve(file);
-            if (!fs.existsSync(resolved))
-                continue;
-            const stat = fs.statSync(resolved);
-            hash.update(`${file}:${stat.mtimeMs}:${stat.size}`);
-            // Content-CONFIRM only the project-local, mutable subset (a handful of
-            // files) — mtime+size alone is a first filter, not proof of freshness,
-            // and a preserved-mtime+size edit here would otherwise replay (and
-            // re-persist) a stale compiled set. Bundled files (~705, immutable
-            // within a process) skip this: the metadata fingerprint stays their
-            // whole story, keeping the common no-project-rules case as cheap as v6.
-            if (!isBundledRuleFile(resolved)) {
-                hash.update(fs.readFileSync(resolved));
-            }
-        }
-        return hash.digest("hex").slice(0, 16);
-    }
-    get(ruleFiles) {
-        try {
-            this.ensureCacheDir();
-            if (!fs.existsSync(this.cacheFile))
-                return null;
-            const currentHash = this.computeRuleHash(ruleFiles);
-            const cached = readJsonCache(this.cacheFile, (parsed) => {
-                const entry = parsed;
-                if (entry.version !== CACHE_VERSION ||
-                    entry.ruleHash !== currentHash) {
-                    return undefined; // Cache invalid
-                }
-                return entry;
-            });
-            return cached ?? null;
-        }
-        catch {
-            return null;
-        }
-    }
-    set(ruleFiles, queries) {
-        try {
-            this.ensureCacheDir();
-            const entry = {
-                version: CACHE_VERSION,
-                timestamp: Date.now(),
-                ruleHash: this.computeRuleHash(ruleFiles),
-                queries,
-            };
-            writeFileAtomic(this.cacheFile, JSON.stringify(entry, null, 2));
-            this.pruneStaleVersions();
-        }
-        catch {
-            // Cache write failure is non-fatal
-        }
-    }
-    // Orphaned `<language>-rules-v<N>.json` files from a prior CACHE_VERSION
-    // (e.g. v3 entries left behind by the #448 v3→v4 bump) never got cleaned up
-    // on their own — nothing ever read or removed them again once the version
-    // bumped. Delete every sibling for this language that isn't the current file.
-    pruneStaleVersions() {
-        const currentName = path.basename(this.cacheFile);
-        const pattern = new RegExp(`^${this.language}-rules-v\\d+\\.json$`);
-        let dirents;
-        try {
-            dirents = fs.readdirSync(this.cacheDir);
-        }
-        catch {
-            return;
-        }
-        for (const name of dirents) {
-            if (name === currentName || !pattern.test(name))
-                continue;
-            try {
-                fs.unlinkSync(path.join(this.cacheDir, name));
-            }
-            catch {
-                // Best-effort; ENOENT (already gone) or any other removal failure
-                // shouldn't undo the write that already succeeded above.
-            }
-        }
-    }
-    clear() {
-        try {
-            if (fs.existsSync(this.cacheFile)) {
-                fs.unlinkSync(this.cacheFile);
-            }
-        }
-        catch {
-            // Ignore
-        }
-    }
-}