ucn 5.2.0 → 5.2.2

package/core/cache.js

@@ -26,8 +26,9 @@ const CACHE_PRUNE_INTERVAL_MS = 60 * 60 * 1000;
 const CACHE_MAX_PROJECTS = 128;
 const CACHE_MAX_BYTES = 1024 * 1024 * 1024;
 
-function discoveryRulesHash(root) {
-    return crypto.createHash('md5').update(parseGitignore(root).join('\0')).digest('hex');
+function discoveryRulesHash(root, patterns = null) {
+    const rules = patterns || parseGitignore(root);
+    return crypto.createHash('md5').update(rules.join('\0')).digest('hex');
 }
 
 /**
@@ -644,7 +645,131 @@ function clearAllCaches() {
 // symbols retain AST-derived parameter qualification/forwarding effects, so
 // replacement-list requalification cannot masquerade as lexical calls
 // (fix #306).
-const CACHE_FORMAT_VERSION = 188;
+// v189: Python import records retain function-local/deferred scope so cycle
+// reporting can classify import-time vs lazy edges from fresh and cached
+// indexes; C# properties retain property identity instead of masquerading as
+// ordinary fields for accessor impact/refactoring.
+// v190: members of Rust generic impl owners retain ownerGenerics so blanket
+// impl parameters (`impl<I> Trait for I`) cannot be mistaken for concrete
+// receiver types after a cache round-trip (fix #302).
+// v191: Python call records retain untyped loop-element provenance so a
+// same-spelled project method cannot gain confirmed identity after reload.
+// v192: JS/TS callback records carry moduleLocalBinding so dynamically
+// produced module values cannot borrow target identity from file imports.
+// v193: overload-heavy JS/TS class-member aliases materialize when every
+// declared return has one concrete runtime head, changing indexed symbols.
+// v194: JS/TS static fields preserve direct same-file callable forwarding for
+// immutable module/export aliases (fix #313).
+// v195: JS/TS call records retain safe ordered namespace-spread receiver
+// compositions for exact module export ownership (fix #314).
+// v196: TS parameter type references no longer mark namespace receiver roots
+// as locally shadowed, changing receiverLocalBinding evidence (fix #315).
+// v197 (fix #317): JS/TS expression-bodied arrow symbols persist the exact
+// returned call span so query-time flow can resolve compiler-inferred factory
+// results without treating block bodies or arbitrary expressions as returns.
+// v198 (fix #318): JS/TS one-return methods persist exact this-field paths for
+// generic declared-field result flow.
+// v199 (fix #321): Python call records persist receiver types derived from
+// exact, scope-local class-value aliases such as `_Segment = Segment`.
+// v200 (fix #323): Python dotted module calls persist their exact import
+// specifier (`import rich.repr` → `rich.repr.auto()`).
+// v201 (fix #324): Python method-call records persist simple subscript roots
+// and their local type provenance for `items[key].method()` dispatch; local
+// callable aliases/non-callable bindings no longer leak across functions.
+// v202 (fix #325): Python call records preserve exact typed subscript sources
+// across one local assignment (`item = items[key]; item.method()`).
+// v203 (fix #326): Python call records type stable, direct module constructor
+// globals even when their functions are declared before the assignment.
+// v204 (fix #328): Python union-alias symbols retain their concrete members
+// so imported annotations can participate in exact conditional narrowing.
+// v205 (fix #332): Go method-call records retain capture-aware lexical scope
+// chains so return-type flow reaches nested closures without crossing shadows.
+// v206 (fix #333): Go calls assigned in `var` declarations retain their
+// declaration targets for compiler-return-type receiver flow.
+// v207 (fix #334): Go method-call records retain compiler-exact receiver
+// types for values bound from declared map, slice, and array indexes.
+// v208 (fix #335): Go indexed-value calls preserve receiver-root/field
+// provenance so sibling-file container declarations resolve query-time.
+const CACHE_FORMAT_VERSION = 208;
+const USAGE_CACHE_FILE = 'usage-results.json';
+
+/**
+ * Persist the small hot-name usage cache independently of index/call shards.
+ * This keeps one-shot CLI repeats fast without rewriting the whole project
+ * cache after every read-only account query.
+ */
+function saveUsageCache(index, cachePath) {
+    if (!index.usageCacheDirty) return null;
+    const cacheDir = cachePath
+        ? path.dirname(cachePath)
+        : getProjectCacheDir(index.root);
+    fs.mkdirSync(cacheDir, { recursive: true });
+    const entries = [];
+    for (const [key, cached] of index._usageResultCache || []) {
+        const parts = key.split('\0');
+        if (parts.length < 3 || !Array.isArray(cached?.value)) continue;
+        const [filePath, fileHash, name, mode = ''] = parts;
+        const fileEntry = index.files.get(filePath);
+        // Drop removed/changed-file generations rather than carrying dead LRU
+        // weight across incremental builds.
+        if (!fileEntry || fileEntry.hash !== fileHash) continue;
+        entries.push([
+            path.relative(index.root, filePath), fileHash, name, mode,
+            cached.value,
+        ]);
+    }
+    const usageFile = path.join(cacheDir, USAGE_CACHE_FILE);
+    const tmpFile = usageFile + '.tmp';
+    fs.writeFileSync(tmpFile, JSON.stringify({
+        version: CACHE_FORMAT_VERSION,
+        ucnVersion: UCN_VERSION,
+        entries,
+    }));
+    fs.renameSync(tmpFile, usageFile);
+    index.usageCacheDirty = false;
+    return usageFile;
+}
+
+function loadUsageCache(index, cacheFile) {
+    const usageFile = path.join(path.dirname(cacheFile), USAGE_CACHE_FILE);
+    if (!fs.existsSync(usageFile)) return false;
+    try {
+        const payload = JSON.parse(fs.readFileSync(usageFile, 'utf-8'));
+        if (payload.version !== CACHE_FORMAT_VERSION ||
+            payload.ucnVersion !== UCN_VERSION ||
+            !Array.isArray(payload.entries)) return false;
+        const restored = new Map();
+        let weightTotal = 0;
+        for (const entry of payload.entries) {
+            if (!Array.isArray(entry) || entry.length < 5) continue;
+            const [relativePath, fileHash, name, mode, value] = entry;
+            if (typeof relativePath !== 'string' ||
+                typeof fileHash !== 'string' ||
+                typeof name !== 'string' || typeof mode !== 'string' ||
+                !Array.isArray(value)) continue;
+            const filePath = path.resolve(index.root, relativePath);
+            const fileEntry = index.files.get(filePath);
+            if (!fileEntry || fileEntry.hash !== fileHash) continue;
+            const suffix = mode ? `\0${mode}` : '';
+            const key = `${filePath}\0${fileHash}\0${name}${suffix}`;
+            const weight = 64 + value.length * 40;
+            restored.set(key, { value, weight });
+            weightTotal += weight;
+            while (restored.size > 4096 || weightTotal > 16 * 1024 * 1024) {
+                const oldest = restored.entries().next().value;
+                if (!oldest) break;
+                restored.delete(oldest[0]);
+                weightTotal -= oldest[1].weight;
+            }
+        }
+        index._usageResultCache = restored;
+        index._usageResultCacheWeight = weightTotal;
+        index.usageCacheDirty = false;
+        return true;
+    } catch (_) {
+        return false;
+    }
+}
 
 /**
  * Save index to cache file
@@ -922,8 +1047,14 @@ function loadCache(index, cachePath) {
             : (relPath) => rootPrefix + relPath.replace(/\//g, path.sep);
 
         // Loading into a previously-used ProjectIndex replaces its indexed
-        // contents, so no parsed tree from the old state may survive.
+        // contents, so no parsed tree or cross-file derived query answer from
+        // the old state may survive. Usage results are content-hash keyed and
+        // remain safe; these caches are graph/text-universe keyed instead.
         index._clearParsedTreeCache?.();
+        index._groundSetCache = new Map();
+        index._groundSetCacheLines = 0;
+        index._nameBindingReachCache = new Map();
+        index._returnTypeFlowCache = new Map();
 
         // Reconstruct files Map: relative key → absolute key, restore path and relativePath
         // Initialize symbols/bindings arrays (will be populated from top-level symbols)
@@ -1071,6 +1202,8 @@ function loadCache(index, cachePath) {
             index.buildInheritanceGraph();
         }
 
+        loadUsageCache(index, cacheFile);
+
         return true;
     } catch (e) {
         return false;
@@ -1088,9 +1221,17 @@ function isCacheStale(index) {
     if (index._loadedConfigHash && currentConfigHash !== index._loadedConfigHash) {
         return true;
     }
-    if (index._loadedDiscoveryHash &&
-        discoveryRulesHash(index.root) !== index._loadedDiscoveryHash) {
-        return true;
+    // Parse gitignore rules once for both the discovery fingerprint and the
+    // new-file walk below. On a fresh cache these used to run two identical
+    // `git ls-files` subprocesses per one-shot CLI invocation, accounting for
+    // roughly a third of warm-start staleness time on measured repositories.
+    let gitignorePatterns = null;
+    if (index._loadedDiscoveryHash) {
+        gitignorePatterns = parseGitignore(index.root);
+        if (discoveryRulesHash(index.root, gitignorePatterns) !==
+            index._loadedDiscoveryHash) {
+            return true;
+        }
     }
     // Modified/deleted detection (stat sweep) runs UNCONDITIONALLY — agents
     // edit a file and re-query through MCP within seconds, and a stale answer
@@ -1149,7 +1290,7 @@ function isCacheStale(index) {
             });
         },
     };
-    const gitignorePatterns = parseGitignore(index.root);
+    if (!gitignorePatterns) gitignorePatterns = parseGitignore(index.root);
     globOpts.gitignorePatterns = gitignorePatterns;
     globOpts.trackedPaths = gitTrackedPaths(index.root);
     const configExclude = index.config.exclude || [];
@@ -1343,7 +1484,7 @@ function _computeReachabilityFingerprint(index) {
 }
 
 module.exports = {
-    saveCache, loadCache, loadCallsCache, isCacheStale, ensureCallsCacheLoaded,
+    saveCache, saveUsageCache, loadCache, loadCallsCache, isCacheStale, ensureCallsCacheLoaded,
     getUserCacheRoot, getProjectCacheDir, getProjectCachePath,
     getLegacyProjectCacheDir, migrateLegacyProjectCache, clearProjectCache,
     clearAllCaches, pruneUserCache,