pi-lens 3.8.70 → 3.8.71

package/dist/clients/git-tracked-ignore.js

@@ -0,0 +1,208 @@
+/**
+ * Shared "untracked AND ignored" file-id computation (#679's `/lens-map`,
+ * reused by #694's review-graph ignore-gated node creation) — and, since
+ * #703, the sibling "tracked files" set that lets `getProjectIgnoreMatcher`
+ * (`file-utils.ts`) honor the OTHER half of the same git semantic.
+ *
+ * THE critical git semantic this exists to respect: a TRACKED file is never
+ * ignored, even when a `.gitignore` pattern matches it (pi-lens's own
+ * committed `clients/deps/*.js` vendored sources match the repo's `*.js`
+ * ignore pattern and MUST stay graph/map nodes) — which is why this asks git
+ * itself (`ls-files --others --ignored --exclude-standard` for the untracked
+ * side, `ls-files` alone for the tracked side) instead of running a pattern
+ * matcher over `.gitignore` (a matcher-only approach would wrongly drop
+ * tracked vendored files, e.g. #703's `clients/test-runner-client.ts`
+ * matching `.gitignore`'s `test-*.ts`).
+ *
+ * Degradation: when git is absent/fails/times out (not a git repo, bare
+ * checkout, etc.) both `collectUntrackedIgnoredIds` and `collectTrackedFiles`
+ * return `undefined` and every caller SKIPS/degrades — the graph/map shows
+ * what's known rather than guessing via a matcher that can't see tracked
+ * status, and `getProjectIgnoreMatcher` falls back to pattern-only behavior.
+ *
+ * Keying asymmetry (deliberate, not an oversight): `collectUntrackedIgnoredIds`
+ * keys its ids with `normalizeMapKey` (realpath-backed) because those ids are
+ * compared against review-graph/map NODE ids — externally-produced state that
+ * genuinely needs canonical on-disk casing/symlink resolution to match up.
+ * `collectTrackedFiles`'s ids, by contrast, are only ever compared against a
+ * `ProjectIgnoreMatcher`'s own `path.resolve`'d paths, produced by THIS
+ * process in the SAME walk — an ephemeral, self-consistent comparison per
+ * `normalizeEphemeralMapKey`'s contract (`path-utils.ts`), so it uses the
+ * cheap syntactic-only fold instead. Do not "fix" this asymmetry by unifying
+ * the two — they solve different problems (#703 review).
+ */
+import * as path from "node:path";
+import { isExcludedDirName } from "./file-utils.js";
+import { normalizeEphemeralMapKey, normalizeMapKey } from "./path-utils.js";
+import { safeSpawnAsync } from "./safe-spawn.js";
+/**
+ * Parses `git ls-files --others --ignored --exclude-standard` output
+ * (repo-relative paths, one per line) into normalized map-key file ids.
+ * Exported as a pure function so the parse/normalize step is unit-testable
+ * without mocking the spawn.
+ */
+export function parseUntrackedIgnoredOutput(stdout, cwd) {
+    const ids = new Set();
+    for (const line of stdout.split(/\r?\n/)) {
+        const rel = line.trim();
+        if (!rel)
+            continue;
+        // Paths inside shared-excluded dirs (node_modules, dist, .git, …) can
+        // never be review-graph/map nodes — the graph walk itself routes
+        // exclusion through `isExcludedDirName` — so skip them BEFORE paying for
+        // `normalizeMapKey` (realpath-backed, per-call filesystem cost): on
+        // pi-lens itself this prunes a 66k-line ignored list (node_modules) down
+        // to ~1.6k paths that actually need normalizing.
+        const dirSegments = rel.split("/").slice(0, -1);
+        if (dirSegments.some((segment) => isExcludedDirName(segment)))
+            continue;
+        ids.add(normalizeMapKey(path.join(cwd, rel)));
+    }
+    return ids;
+}
+async function fetchUntrackedIgnoredIds(cwd) {
+    try {
+        const result = await safeSpawnAsync("git", ["ls-files", "--others", "--ignored", "--exclude-standard"], { cwd, timeout: 10_000, resourceLabel: "git-tracked-ignore" });
+        if (result.error || result.status !== 0)
+            return undefined;
+        return parseUntrackedIgnoredOutput(result.stdout, cwd);
+    }
+    catch {
+        return undefined;
+    }
+}
+// #694: the review-graph build calls this on EVERY incremental/cascade
+// rebuild (a hot, per-edit path), not just `/lens-map`'s one-shot generation —
+// spawning `git ls-files` per edit would be a real per-keystroke cost. Memoize
+// per cwd with a short time bound: cheap enough that a `.gitignore` edit or a
+// newly-untracked file takes effect within a few seconds, but a burst of
+// per-edit rebuilds within that window shares one spawn.
+const CACHE_TTL_MS = 30_000;
+const _cache = new Map();
+/**
+ * The untracked-AND-ignored id set for `cwd`, memoized per-process with a
+ * {@link CACHE_TTL_MS} time bound so a hot rebuild loop (review-graph
+ * incremental/cascade builds) never spawns `git` per file/per edit — see the
+ * module doc for the tracked-file semantic and the degrade-to-undefined
+ * contract.
+ */
+export function collectUntrackedIgnoredIds(cwd) {
+    const key = normalizeMapKey(cwd);
+    const now = Date.now();
+    const cached = _cache.get(key);
+    if (cached && now - cached.fetchedAtMs < CACHE_TTL_MS)
+        return cached.promise;
+    const promise = fetchUntrackedIgnoredIds(cwd);
+    _cache.set(key, { promise, fetchedAtMs: now });
+    return promise;
+}
+/** Test hook: drop the memoized cache so a test's fake git state is re-read. */
+export function _resetUntrackedIgnoredCacheForTests() {
+    _cache.clear();
+}
+/**
+ * Parses `git ls-files` output (repo-relative paths, one per line, tracked
+ * files only — no `--others`) into normalized ids, keyed for comparison
+ * against a `ProjectIgnoreMatcher`'s own (non-realpath'd) `path.resolve`'d
+ * paths — NOT against {@link parseUntrackedIgnoredOutput}'s ids, which are
+ * realpath-keyed for a different consumer (review-graph/map node ids). The
+ * two sets are NOT directly comparable/mergeable despite the shared
+ * dir-exclusion-prune shape — see this file's module doc for the asymmetry.
+ *
+ * `cwd` is realpath'd exactly ONCE here (not per file) to reconcile the one
+ * divergence that matters in practice: on Windows, the matcher's
+ * `resolvedRoot` comes from `path.resolve` while this fetch's `cwd` may carry
+ * different on-disk casing (e.g. `c:\users` vs `C:\Users`) — a single
+ * realpath on the shared root, followed by a cheap syntactic fold
+ * (`normalizeEphemeralMapKey`) on every per-file join, reconciles that without
+ * paying `realpathSync` per tracked file (#703 perf follow-up — a ~2k-file
+ * repo was doing ~2k realpath calls in one synchronous burst per fetch).
+ * Accepted edge case: a symlinked or 8.3-short-name project root can still
+ * make the cheap per-file fold miss even after this one realpath — degrades
+ * to today's pattern-only behavior for that root, consistent with the
+ * fail-open contract elsewhere in this module.
+ */
+export function parseTrackedFilesOutput(stdout, cwd) {
+    const ids = new Set();
+    const base = normalizeMapKey(cwd);
+    for (const line of stdout.split(/\r?\n/)) {
+        const rel = line.trim();
+        if (!rel)
+            continue;
+        const dirSegments = rel.split("/").slice(0, -1);
+        if (dirSegments.some((segment) => isExcludedDirName(segment)))
+            continue;
+        ids.add(normalizeEphemeralMapKey(path.join(base, rel)));
+    }
+    return ids;
+}
+async function fetchTrackedFiles(cwd) {
+    try {
+        const result = await safeSpawnAsync("git", ["ls-files"], {
+            cwd,
+            timeout: 10_000,
+            resourceLabel: "git-tracked-ignore",
+        });
+        if (result.error || result.status !== 0)
+            return undefined;
+        return parseTrackedFilesOutput(result.stdout, cwd);
+    }
+    catch {
+        return undefined;
+    }
+}
+const _trackedCache = new Map();
+// Sync snapshot of the most recently RESOLVED tracked-files fetch per root,
+// keyed the same way as `_trackedCache`. `getProjectIgnoreMatcher`'s
+// `isIgnored` is sync-and-hot (#703 constraint) and can't await a promise, so
+// this is the seam it reads from: `ensureTrackedIndex` (file-utils.ts) awaits
+// `collectTrackedFiles` ONCE per walk, which populates this snapshot as a
+// side effect; `isIgnored` then reads the snapshot synchronously for every
+// file in that same walk. A caller that never primes sees an absent snapshot
+// entry and degrades to pattern-only behavior (fail-open, by design).
+const _trackedSnapshot = new Map();
+/**
+ * The tracked-files id set for `cwd` (i.e. `git ls-files`, no `--others`),
+ * memoized per-process with the same {@link CACHE_TTL_MS} time bound as
+ * {@link collectUntrackedIgnoredIds} — see that function's doc for the hot
+ * per-edit-rebuild-loop rationale. Also updates the synchronous snapshot
+ * `getTrackedFilesSnapshot` reads, so sync hot-path callers can consult a
+ * cheap in-memory Set instead of awaiting this promise per file.
+ */
+export function collectTrackedFiles(cwd) {
+    // #703 perf follow-up: `normalizeEphemeralMapKey`, not `normalizeMapKey` —
+    // this map's only readers/writers are `ensureTrackedIndex`/`isIgnored`
+    // (file-utils.ts), both of which derive `cwd` from the SAME matcher's
+    // `resolvedRoot` (`path.resolve`, not realpath) within one process, so the
+    // cheap syntactic fold is sufficient and avoids a realpath per call — see
+    // this file's module doc for why this diverges from `collectUntrackedIgnoredIds`.
+    const key = normalizeEphemeralMapKey(cwd);
+    const now = Date.now();
+    const cached = _trackedCache.get(key);
+    if (cached && now - cached.fetchedAtMs < CACHE_TTL_MS)
+        return cached.promise;
+    const promise = fetchTrackedFiles(cwd).then((result) => {
+        _trackedSnapshot.set(key, result);
+        return result;
+    });
+    _trackedCache.set(key, { promise, fetchedAtMs: now });
+    return promise;
+}
+/**
+ * Synchronous read of the most recent {@link collectTrackedFiles} result for
+ * `cwd`. Returns `undefined` when nothing has primed this root yet (never
+ * called `collectTrackedFiles`), when git degraded (no repo/spawn failure),
+ * OR when a fetch is still in flight — all three collapse to the same
+ * fail-open "tracked status unknown, use pattern-only behavior" contract.
+ * Called on every `isIgnored` check that reaches the tracked-rescue branch
+ * (file-utils.ts's `isTrackedAndRescued`), so this key MUST stay the cheap
+ * `normalizeEphemeralMapKey` fold, not a realpath.
+ */
+export function getTrackedFilesSnapshot(cwd) {
+    return _trackedSnapshot.get(normalizeEphemeralMapKey(cwd));
+}
+/** Test hook: drop the memoized tracked-files cache/snapshot. */
+export function _resetTrackedFilesCacheForTests() {
+    _trackedCache.clear();
+    _trackedSnapshot.clear();
+}

package/dist/clients/instance-registry.js

@@ -23,6 +23,16 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { getGlobalPiLensDir } from "./file-utils.js";
+// #735: reuse the #449/#525 reaper's exact conservative liveness check
+// (`process.kill(pid, 0)`, ESRCH-only-means-dead) rather than inventing a
+// second one — see realIsPidAlive's own docstring, which already calls out
+// clients/lsp-budget.ts as a precedent consumer. This creates a live-binding
+// import cycle with instance-reaper.ts (which imports readInstanceRegistry/
+// isInstanceRegistryEnabled from here); safe under Node ESM because every
+// use on both sides happens inside function bodies, never at module-
+// evaluation time, so both modules are fully initialized before either
+// import is actually invoked.
+import { realIsPidAlive } from "./instance-reaper.js";
 import { normalizeFilePath } from "./path-utils.js";
 function registryPath() {
     return path.join(getGlobalPiLensDir(), "instances.json");
@@ -264,9 +274,32 @@ export function deregisterInstance() {
  * short-lived and sampled separately per-invocation via
  * clients/resource-sampler.ts into clients/latency-logger.ts, not carried in
  * the registry (see the module docstring's scope note).
+ *
+ * #735: `isPidAlive`, when supplied, drops any instance whose owning pid is
+ * confirmed dead BEFORE aggregation — a hard-killed pi process otherwise
+ * leaves a registry entry with heartbeat-cached RSS that reads as a live,
+ * resource-consuming instance until it eventually ages out (up to
+ * `STALE_HEARTBEAT_MS`, see clients/instance-reaper.ts). Dropped rather than
+ * flagged `stale: true`: a dead pid is unambiguous (unlike heartbeat
+ * staleness, which the reaper deliberately treats as "maybe idle-but-alive"
+ * and never uses to justify removing/hiding anything) — the wire shape and
+ * every existing caller (chiefly `pilens_health`'s headline instance
+ * count/RSS/CPU numbers) simply expects a footprint of currently-live
+ * instances. Left `undefined` for pure/synchronous callers (incl. every
+ * pre-#735 unit test) that pass a plain snapshot with no intent to check OS
+ * process state — no filtering happens, preserving prior behavior exactly.
+ * No pid-reuse identity check is applied here (unlike the reaper's child-pid
+ * `matchProcess`): `InstanceEntry` never recorded the host's own command
+ * line to verify against (same gap #525 called out for the reaper's PARENT
+ * pid, deliberately left unfixed there too), and a health-report false
+ * positive is a much smaller blast radius than the reaper's mistaken kill —
+ * so plain liveness is judged sufficient here.
  */
-export function computeResourceFootprint(instances) {
-    const perInstance = instances.map((instance) => {
+export function computeResourceFootprint(instances, isPidAlive) {
+    const liveInstances = isPidAlive
+        ? instances.filter((instance) => isPidAlive(instance.pid))
+        : instances;
+    const perInstance = liveInstances.map((instance) => {
         const lspChildRssBytes = instance.lspChildren.reduce((sum, child) => sum + (child.rssBytes ?? 0), 0);
         const lspChildCpuPercent = instance.lspChildren.reduce((sum, child) => sum + (child.cpuPercent ?? 0), 0);
         return {
@@ -300,8 +333,45 @@ export function computeResourceFootprint(instances) {
  * side of "how much CPU/RAM is pi-lens using right now" (#620). Best-effort
  * (readInstanceRegistry never throws); the answer only reflects whatever
  * heartbeats have landed so far.
+ *
+ * #735: defaults to the reaper's `realIsPidAlive` so dead-pid registry
+ * entries (a hard-killed pi process) are excluded from both the returned
+ * footprint AND — opportunistically, fire-and-forget, best-effort — pruned
+ * from the on-disk registry, the same "entry removal only, never blocks the
+ * caller" convention `sweepOrphans`/`pruneDeadInstances` already use.
+ * Pruning here is a bonus cleanup, not a substitute for the reaper sweep:
+ * this path only prunes pids this particular read happened to find dead,
+ * while the reaper sweep is the authoritative, scheduled cleanup. Injectable
+ * so tests can pass a fake predicate (or omit filtering entirely by passing
+ * a function that always returns true) without touching real OS process
+ * state.
  */
-export async function getResourceFootprint() {
+export async function getResourceFootprint(isPidAlive = realIsPidAlive) {
     const instances = await readInstanceRegistry();
-    return computeResourceFootprint(instances);
+    const deadPids = new Set(instances.filter((instance) => !isPidAlive(instance.pid)).map((instance) => instance.pid));
+    if (deadPids.size > 0) {
+        // Fire-and-forget: a health-report read must never block on, or fail
+        // because of, a registry write.
+        prunePids(deadPids).catch(() => {
+            // best-effort — a dead-pid entry that fails to prune here is simply
+            // re-evaluated (and re-dropped from the report) on the next read, and
+            // remains catchable by the scheduled reaper sweep regardless.
+        });
+    }
+    return computeResourceFootprint(instances, isPidAlive);
+}
+/** Best-effort removal of specific dead pids' entries from the on-disk
+ *  registry (#735). Re-reads immediately before writing (rather than reusing
+ *  an earlier snapshot) to narrow — not eliminate — the last-writer-wins race
+ *  already accepted for this module's read-modify-write model (see the
+ *  module docstring). Mirrors clients/instance-reaper.ts's
+ *  `pruneDeadInstances`, kept local here rather than imported to avoid
+ *  reaching back across the same import edge `realIsPidAlive` already
+ *  crosses in the other direction. */
+async function prunePids(deadPids) {
+    const file = await readRegistryAsync();
+    const remaining = file.instances.filter((entry) => !deadPids.has(entry.pid));
+    if (remaining.length === file.instances.length)
+        return;
+    await writeRegistryAsync({ instances: remaining });
 }

package/dist/clients/json-cache-read.js

@@ -0,0 +1,65 @@
+/**
+ * Shared "read a JSON cache file off disk" boilerplate (#676).
+ *
+ * At least 7 sites across the codebase hand-duplicated the same shape:
+ * `JSON.parse(fs.readFileSync(path, "utf-8"))` → structural/version guard →
+ * return the parsed value, or `undefined`/`null` on ANY throw (missing file,
+ * unreadable, corrupt JSON, or a `validate` callback itself throwing). This
+ * module extracts only that read/parse/try-catch mechanics; every call
+ * site's own "is this actually a valid, current-version cache?" logic stays
+ * put, as the `validate` callback — consolidation is only meant to remove
+ * the duplicated plumbing, not to unify subtly different validation rules
+ * that call sites had for good reason (e.g. a second `ruleHash` field check
+ * alongside the version check).
+ *
+ * `validate` returning `undefined` means "treat this like a parse failure" —
+ * the same fail-open posture every existing site already had for a
+ * wrong-version/wrong-shape cache.
+ */
+import * as fs from "node:fs";
+import { promises as fsPromises } from "node:fs";
+/**
+ * Synchronous read: `JSON.parse(fs.readFileSync(path, "utf-8"))`, run through
+ * `validate`, with any failure (missing file, unreadable, corrupt JSON,
+ * `validate` throwing) swallowed to `undefined`.
+ *
+ * `onError`, when provided, is invoked with the caught error BEFORE
+ * `undefined` is returned — for sites that log a read failure today (e.g.
+ * `CacheManager`'s verbose `this.log(...)`) rather than silently swallowing
+ * it. `onError` itself is never allowed to throw the failure back out.
+ */
+export function readJsonCache(path, validate, onError) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(path, "utf-8"));
+        return validate(parsed);
+    }
+    catch (err) {
+        try {
+            onError?.(err);
+        }
+        catch {
+            /* onError must never mask the original fail-open behavior */
+        }
+        return undefined;
+    }
+}
+/**
+ * Async sibling of {@link readJsonCache}, for call sites already on the
+ * `fs.promises` API (e.g. `session-state-store.ts`). Same fail-open contract.
+ */
+export async function readJsonCacheAsync(path, validate, onError) {
+    try {
+        const raw = await fsPromises.readFile(path, "utf-8");
+        const parsed = JSON.parse(raw);
+        return validate(parsed);
+    }
+    catch (err) {
+        try {
+            onError?.(err);
+        }
+        catch {
+            /* onError must never mask the original fail-open behavior */
+        }
+        return undefined;
+    }
+}

package/dist/clients/language-profile.js

@@ -282,6 +282,10 @@ const MAX_WARMUP_SOURCE_FILES = 2000;
 export async function collectSourceFilesForWarmup(rootDir, maxFiles = MAX_WARMUP_SOURCE_FILES, yieldEvery = 100) {
     const root = path.resolve(rootDir);
     const ignoreMatcher = getProjectIgnoreMatcher(root);
+    // #703: prime the tracked-files set once before the walk so a tracked file
+    // matching a `.gitignore`/global pattern still counts toward language
+    // detection. Fail-open on no-git/spawn failure.
+    await ignoreMatcher.ensureTrackedIndex();
     const stack = [root];
     const out = [];
     let processedSinceYield = 0;