pi-lens 3.8.69 → 3.8.71

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/knip-client.js

@@ -9,9 +9,9 @@
  * Docs: https://knip.dev/
  */
 import * as fs from "node:fs";
-import * as os from "node:os";
 import * as path from "node:path";
-import { isAtOrAboveHomeDir } from "./path-utils.js";
+import { getProjectDataDir } from "./file-utils.js";
+import { findNearestMarkerRoot } from "./path-utils.js";
 import { safeSpawnAsync } from "./safe-spawn.js";
 const EMPTY_RESULT = {
     success: false,
@@ -54,44 +54,15 @@ export class KnipClient {
      * previously this fell back to `startDir`, which on a bare cwd like
      * `/home/v` caused knip to recurse through every project and balloon
      * memory/CPU.
+     *
+     * Delegates to the shared path-utils helper (refs #625) — never treats a
+     * package/knip config at or above $HOME as the project (escapes the
+     * workspace, #296/#250), and never walks past a `.git`/`.hg`/`.svn`
+     * boundary to pick up an unrelated parent's package.json (Unity/non-JS
+     * repos often have no package.json at their own root).
      */
     resolveProjectRoot(startDir, homeDirOverride) {
-        const markers = [
-            "package.json",
-            "knip.json",
-            "knip.ts",
-            "knip.config.js",
-            "knip.config.ts",
-        ];
-        const boundaries = [".git", ".hg", ".svn"];
-        const homeDir = path.resolve(homeDirOverride ?? os.homedir());
-        let current = path.resolve(startDir);
-        // Safety bound: in practice depths are ~10. This cap just prevents a
-        // pathological symlink loop from hanging the search.
-        for (let depth = 0; depth < 64; depth++) {
-            // Never treat a package/knip config at $HOME — or above it, such as
-            // /home/package.json from a shared parent — as the project for startup
-            // analysis. That escapes the workspace and can make knip scan the whole
-            // home tree from an empty folder (#296/#250).
-            if (isAtOrAboveHomeDir(current, homeDir)) {
-                return null;
-            }
-            if (markers.some((m) => fs.existsSync(path.join(current, m)))) {
-                return current;
-            }
-            // Do not escape the current repository just to find an unrelated parent
-            // package.json. Unity/non-JS repos often have no package.json at their
-            // root; walking past their .git boundary can accidentally pick up
-            // ~/package.json and make knip scan the entire home directory.
-            if (boundaries.some((m) => fs.existsSync(path.join(current, m)))) {
-                return null;
-            }
-            const parent = path.dirname(current);
-            if (parent === current)
-                return null;
-            current = parent;
-        }
-        return null;
+        return findNearestMarkerRoot(startDir, ["package.json", "knip.json", "knip.ts", "knip.config.js", "knip.config.ts"], { boundaries: [".git", ".hg", ".svn"], homeDir: homeDirOverride });
     }
     /**
      * Check if knip CLI is available, auto-install if not
@@ -175,6 +146,29 @@ export class KnipClient {
         return promise;
     }
     async runAnalyze(targetDir) {
+        // Cache dir is routed through pi-lens's project-data-dir convention (NOT
+        // knip's own default `./node_modules/.cache/knip`) so it lives alongside
+        // every other project cache (see cache-manager.ts, call-graph.ts) and is
+        // covered by the existing `.pi-lens/` gitignore entry.
+        //
+        // Caveat (per knip's docs): a cached run does NOT pick up newly-added
+        // `.gitignore` files automatically — the cache must be deleted to detect
+        // them. Not auto-handled here; this is a documented tradeoff, not a bug.
+        const cacheLocation = path.join(getProjectDataDir(targetDir), "cache", "knip");
+        // knip (verified against 6.26.0) silently fails to persist the cache when
+        // `--cache-location` points at a directory that doesn't exist yet: its
+        // internal auto-mkdir throws ENOENT (swallowed internally, debug-logged
+        // only) on Windows, so the very first run — and every run after, since the
+        // dir never gets created — degrades to an uncached scan with no error
+        // surfaced. Pre-creating the dir avoids that path entirely; matches the
+        // mkdirSync-before-spawn convention call-graph.ts already uses for its
+        // cache file's parent dir.
+        try {
+            fs.mkdirSync(cacheLocation, { recursive: true });
+        }
+        catch (err) {
+            this.log(`Failed to pre-create knip cache dir ${cacheLocation}: ${err}`);
+        }
         const args = [
             "--reporter=json",
             "--include",
@@ -183,6 +177,9 @@ export class KnipClient {
             // it makes knip exit 2 with zero output, silently disabling the scan —
             // verified against knip 6.20. Valid member-level type here is enumMembers.)
             "files,exports,types,dependencies,unlisted,enumMembers",
+            "--cache",
+            "--cache-location",
+            cacheLocation,
         ];
         const result = await safeSpawnAsync("knip", args, {
             timeout: ANALYSIS_TIMEOUT_MS,

package/dist/clients/language-profile.js

@@ -1,9 +1,10 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { detectFileKind } from "./file-kinds.js";
-import { getProjectIgnoreMatcher, isExcludedDirName, } from "./file-utils.js";
+import { getProjectIgnoreMatcher } from "./file-utils.js";
 import { LANGUAGE_POLICY, } from "./language-policy.js";
 import { getSourceFiles } from "./scan-utils.js";
+import { readDirEntriesSafe, shouldRecurseIntoDir } from "./source-walker.js";
 export const SUPPORTED_FILE_KINDS = [
     "jsts",
     "python",
@@ -281,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;
@@ -288,20 +293,15 @@ export async function collectSourceFilesForWarmup(rootDir, maxFiles = MAX_WARMUP
         const current = stack.pop();
         if (!current)
             continue;
-        let entries = [];
-        try {
-            entries = fs.readdirSync(current, { withFileTypes: true });
-        }
-        catch {
-            continue;
-        }
+        const entries = readDirEntriesSafe(current);
         for (const entry of entries) {
             const fullPath = path.join(current, entry.name);
             if (entry.isDirectory()) {
-                if (isExcludedDirName(entry.name))
-                    continue;
-                if (ignoreMatcher.isIgnored(fullPath, true))
+                // Never checked symlinks — always follows them (unlike
+                // source-filter.ts's collectSourceFiles*, refs #191).
+                if (!shouldRecurseIntoDir(entry, fullPath, { ignoreMatcher, followSymlinks: true })) {
                     continue;
+                }
                 stack.push(fullPath);
             }
             else if (entry.isFile()) {

package/dist/clients/lens-engine.js

@@ -15,6 +15,7 @@
  */
 import { getDiagnosticTracker } from "./diagnostic-tracker.js";
 import { getLatencyReports, } from "./dispatch/integration.js";
+import { getResourceFootprint as getResourceFootprintSnapshot, } from "./instance-registry.js";
 import { initLSPConfig } from "./lsp/config.js";
 import { getLSPService } from "./lsp/index.js";
 import { getOrLoadWarmWordIndex } from "./mcp/analyze.js";
@@ -57,6 +58,17 @@ export function diagnosticStats() {
 export function ensureLspConfig(cwd) {
     return initLSPConfig(cwd);
 }
+/**
+ * #620: total CPU/RAM footprint attributable to pi-lens across every process
+ * it owns — every registered instance's host, plus that instance's live LSP
+ * children. Reads the machine-global `~/.pi-lens/instances.json` registry, so
+ * this answers across ALL concurrent pi-lens sessions/worktrees on the box,
+ * not just this one. Best-effort: reflects whatever heartbeats have landed so
+ * far — a stale-heartbeat instance simply reports its last-sampled numbers.
+ */
+export function resourceFootprint() {
+    return getResourceFootprintSnapshot();
+}
 function toSymbolSearchHit(result) {
     const line = result.lines[0] ?? 1;
     return {