pi-lens 3.8.73 → 4.0.0

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

@@ -9,11 +9,56 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import { getProjectDataDir } from "../file-utils.js";
 import { readJsonCache } from "../json-cache-read.js";
-const CACHE_VERSION = "v3";
+import { resolvePackagePath } from "../package-root.js";
+import { writeFileAtomic } from "../atomic-write.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.
+ */
+const BUNDLED_RULES_ROOT = resolvePackagePath(import.meta.url, "rules", "tree-sitter-queries");
+function isBundledRuleFile(resolvedFile) {
+    return (resolvedFile === BUNDLED_RULES_ROOT ||
+        resolvedFile.startsWith(BUNDLED_RULES_ROOT + path.sep));
+}
 export class RuleCache {
     cacheFile;
     cacheDir;
+    language;
     constructor(language, rootDir = process.cwd()) {
+        this.language = language;
         this.cacheDir = path.join(getProjectDataDir(rootDir), "cache");
         this.cacheFile = path.join(this.cacheDir, `${language}-rules-${CACHE_VERSION}.json`);
     }
@@ -25,9 +70,19 @@ export class RuleCache {
     computeRuleHash(ruleFiles) {
         const hash = crypto.createHash("sha256");
         for (const file of ruleFiles.sort((a, b) => a.localeCompare(b))) {
-            if (fs.existsSync(file)) {
-                const stat = fs.statSync(file);
-                hash.update(`${file}:${stat.mtimeMs}:${stat.size}`);
+            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);
@@ -40,7 +95,8 @@ export class RuleCache {
             const currentHash = this.computeRuleHash(ruleFiles);
             const cached = readJsonCache(this.cacheFile, (parsed) => {
                 const entry = parsed;
-                if (entry.version !== CACHE_VERSION || entry.ruleHash !== currentHash) {
+                if (entry.version !== CACHE_VERSION ||
+                    entry.ruleHash !== currentHash) {
                     return undefined; // Cache invalid
                 }
                 return entry;
@@ -60,12 +116,39 @@ export class RuleCache {
                 ruleHash: this.computeRuleHash(ruleFiles),
                 queries,
             };
-            fs.writeFileSync(this.cacheFile, JSON.stringify(entry, null, 2));
+            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)) {

package/dist/clients/cache-manager.js

@@ -8,9 +8,11 @@
  *
  * All paths are relative to project root (process.cwd()).
  */
+import { createSubsystemLogger } from "./extension-log.js";
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { getProjectDataDir } from "./file-utils.js";
+import { writeFileAtomic } from "./atomic-write.js";
 import { readJsonCache } from "./json-cache-read.js";
 import { normalizeMapKey } from "./path-utils.js";
 // --- Defaults ---
@@ -21,6 +23,8 @@ const DEFAULT_TURN_STATE = {
     maxCycles: 3,
     lastUpdated: "",
 };
+export const MCP_TURN_STATE_OWNER_ID = `mcp-${process.pid}`;
+const TURN_OWNER_STALE_MS = 30 * 60 * 1000;
 // --- Helpers ---
 function getLensDir(cwd) {
     return getProjectDataDir(cwd);
@@ -36,7 +40,7 @@ export class CacheManager {
     log;
     constructor(verbose = false) {
         this.log = verbose
-            ? (msg) => console.error(`[cache] ${msg}`)
+            ? createSubsystemLogger("cache")
             : () => { };
     }
     /**
@@ -107,10 +111,45 @@ export class CacheManager {
             timestamp: new Date().toISOString(),
             ...extraMeta,
         };
-        fs.writeFileSync(cachePath, JSON.stringify(data, null, 2));
-        fs.writeFileSync(metaPath, JSON.stringify(meta, null, 2));
+        writeFileAtomic(cachePath, JSON.stringify(data, null, 2), {
+            bestEffort: false,
+        });
+        writeFileAtomic(metaPath, JSON.stringify(meta, null, 2), {
+            bestEffort: false,
+        });
         this.log(`Cache written: ${scanner}`);
     }
+    /** Inspect a cache without changing the behavior of readCache consumers. */
+    inspectCache(scanner, cwd, maxAgeMs = DEFAULT_MAX_AGE_MS) {
+        const cachePath = path.join(getCacheDir(cwd), `${scanner}.json`);
+        const metaPath = path.join(getCacheDir(cwd), `${scanner}.meta.json`);
+        for (const cachePathname of [cachePath, metaPath]) {
+            try {
+                fs.statSync(cachePathname);
+            }
+            catch (err) {
+                if (err.code === "ENOENT")
+                    return "missing";
+                return "unreadable";
+            }
+        }
+        try {
+            const meta = readJsonCache(metaPath, (parsed) => parsed);
+            if (!meta || typeof meta.timestamp !== "string")
+                return "malformed";
+            const timestamp = new Date(meta.timestamp).getTime();
+            if (!Number.isFinite(timestamp))
+                return "malformed";
+            const age = Date.now() - timestamp;
+            if (age < 0 || age > maxAgeMs)
+                return age < 0 ? "malformed" : "stale";
+            const data = readJsonCache(cachePath, (parsed) => parsed);
+            return data === undefined ? "malformed" : "fresh";
+        }
+        catch {
+            return "unreadable";
+        }
+    }
     /**
      * Check if a cache entry is fresh (exists and not expired).
      */
@@ -175,16 +214,57 @@ export class CacheManager {
         fs.mkdirSync(lensDir, { recursive: true });
         const statePath = getTurnStatePath(cwd);
         state.lastUpdated = new Date().toISOString();
-        fs.writeFileSync(statePath, JSON.stringify(state, null, 2));
+        writeFileAtomic(statePath, JSON.stringify(state, null, 2));
+    }
+    /** Return whether a writer may read/write this workspace worklist. */
+    getTurnStateAccess(cwd, owner) {
+        const state = this.readTurnState(cwd);
+        if (!state.owner) {
+            if (!state.sessionId || state.sessionId === owner.id)
+                return "owned";
+            // Pre-owner files have no liveness information. Preserve the existing
+            // stale-session eviction behavior for this legacy shape.
+            return "available";
+        }
+        if (state.owner.kind === owner.kind &&
+            state.owner.id === owner.id) {
+            return "owned";
+        }
+        return this.isTurnStateOwnerStale(state.owner) ? "available" : "foreign-live";
+    }
+    isTurnStateOwnerStale(owner) {
+        if (owner.pid > 0 && owner.pid !== process.pid) {
+            try {
+                process.kill(owner.pid, 0);
+                return false;
+            }
+            catch {
+                return true;
+            }
+        }
+        const lastSeen = Date.parse(owner.lastSeen);
+        return !Number.isFinite(lastSeen) || Date.now() - lastSeen > TURN_OWNER_STALE_MS;
     }
     /**
      * Add or update a file's modified ranges in turn state.
-     * Merges overlapping ranges.
+     * Merges overlapping ranges. `sessionId:null` deliberately preserves the
+     * current owner; callers must provide an explicit owner id to claim a stale
+     * worklist.
      */
-    addModifiedRange(filePath, range, importsChanged, cwd, sessionId) {
+    addModifiedRange(filePath, range, importsChanged, cwd, sessionId, ownerKind = "pi") {
         const state = this.readTurnState(cwd);
-        if (sessionId)
+        if (sessionId) {
+            const owner = {
+                kind: ownerKind,
+                id: sessionId,
+                pid: process.pid,
+                lastSeen: new Date().toISOString(),
+            };
+            if (this.getTurnStateAccess(cwd, owner) === "foreign-live")
+                return state;
             state.sessionId = sessionId;
+            state.owner = owner;
+        }
         const normalizedPath = this.toTurnStateKey(filePath, cwd);
         const existing = state.files[normalizedPath];
         if (existing) {
@@ -209,19 +289,27 @@ export class CacheManager {
     /**
      * Clear turn state (after turn_end processes it).
      */
-    clearTurnState(cwd) {
+    clearTurnState(cwd, owner) {
+        const currentState = this.readTurnState(cwd);
+        const isCurrentOwner = this.getTurnStateAccess(cwd, owner) !== "foreign-live";
+        if (!isCurrentOwner && process.pid !== currentState.owner?.pid)
+            return false;
         const state = {
             ...DEFAULT_TURN_STATE,
             files: {}, // fresh object — DEFAULT_TURN_STATE.files can be polluted by addModifiedRange
             lastUpdated: new Date().toISOString(),
         };
         this.writeTurnState(state, cwd);
+        return true;
     }
     /**
      * Increment turn cycle counter.
      */
-    incrementTurnCycle(cwd) {
+    incrementTurnCycle(cwd, owner) {
         const state = this.readTurnState(cwd);
+        const isCurrentOwner = this.getTurnStateAccess(cwd, owner) !== "foreign-live";
+        if (!isCurrentOwner && process.pid !== state.owner?.pid)
+            return state;
         state.turnCycles++;
         this.writeTurnState(state, cwd);
         return state;