ucn 5.2.1 → 5.2.2

package/cli/index.js

@@ -760,6 +760,9 @@ function runProjectCommand(rootDir, command, arg) {
         if (flags.cache && (needsCacheSave || index.callsCacheDirty || index.reachabilityDirty || index.computedDispatchDirty)) {
             try { index.saveCache(); } catch (e) { /* best-effort */ }
         }
+        if (flags.cache && index.usageCacheDirty) {
+            try { index.saveUsageCache(); } catch (e) { /* best-effort */ }
+        }
     }
 }
 

package/core/account.js

@@ -36,14 +36,16 @@
  * Ground-set semantics are grep `-n -w`: unit is the (file, line) pair, each
  * line with >= 1 word-boundary match counts once, case-sensitive.
  *
- * Performance: the ground scan is one `includes()`-gated read per project file
- * per caller-command — the same I/O profile as the existing `search`/`usages`
- * commands. Deriving counts from callsCache (zero reads) was rejected because
+ * Performance: the first ground scan is one `includes()`-gated read per project
+ * file — the same I/O profile as the existing `search`/`usages` commands.
+ * Exact results are retained in a small LRU for the lifetime of one built index
+ * so context/about/impact projections of the same symbol do not rescan the
+ * project. Deriving counts from callsCache (zero reads) was rejected because
  * comments/strings/references are not in the calls cache and the contract's
  * ground set is text-defined. AST parsing (the expensive part) is restricted
- * to files containing UNCLAIMED ground lines, via the op-cached
- * `index._getCachedUsages`. No file is read twice in one command because
- * context/about/impact run inside `index._beginOp()`.
+ * to files containing UNCLAIMED ground lines, via the content-hash-keyed
+ * `index._getCachedUsages`. Build invalidation and cache bounds preserve the
+ * same answer without retaining an unbounded repository mirror.
  */
 
 'use strict';
@@ -75,6 +77,12 @@ const UNSUPPORTED_SITE_TEXT_MAX = 160;
  * }}
  */
 function computeGroundSet(index, name) {
+    if (index._groundSetCache?.has(name)) {
+        const cached = index._groundSetCache.get(name);
+        index._groundSetCache.delete(name);
+        index._groundSetCache.set(name, cached);
+        return cached.result;
+    }
     const wordRe = new RegExp('\\b' + escapeRegExp(name) + '\\b');
     const perFile = new Map();
     let total = 0;
@@ -117,7 +125,7 @@ function computeGroundSet(index, name) {
         ? index.discoveryIssues.map(issue => ({ ...issue })) : [];
     unreadableFiles.sort();
 
-    return {
+    const result = {
         total: total + unparsed.lines + unsupported.lines,
         fileCount: fileCount + unparsed.fileCount + unsupported.fileCount,
         perFile,
@@ -126,6 +134,21 @@ function computeGroundSet(index, name) {
         unreadableFiles,
         skippedSources,
     };
+    if (index._groundSetCache) {
+        const weight = result.total + result.fileCount;
+        index._groundSetCache.set(name, { result, weight });
+        index._groundSetCacheLines = (index._groundSetCacheLines || 0) + weight;
+        const maxNames = 64;
+        const maxLines = 100000;
+        while (index._groundSetCache.size > maxNames ||
+            index._groundSetCacheLines > maxLines) {
+            const oldest = index._groundSetCache.entries().next().value;
+            if (!oldest) break;
+            index._groundSetCache.delete(oldest[0]);
+            index._groundSetCacheLines -= oldest[1].weight;
+        }
+    }
+    return result;
 }
 
 /** Scan only files the parser/index could not ingest. */
@@ -300,7 +323,12 @@ function classifyGroundLines(index, name, groundSet, claimedKeys) {
 
         // Remainder: AST usage scan distinguishes import/definition/reference
         // from comment/string/skipped-token lines.
-        const usages = index._getCachedUsages(filePath, name);
+        // Call lines were classified from the complete calls cache above.
+        // Language adapters may skip usage-only call recovery here; notably,
+        // C/C++ avoids reparsing every matching macro replacement list.
+        const usages = index._getCachedUsages(filePath, name, {
+            skipCallRecovery: true,
+        });
         const byLine = new Map();
         if (Array.isArray(usages)) {
             for (const u of usages) {

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');
 }
 
 /**
@@ -648,7 +649,127 @@ function clearAllCaches() {
 // 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.
-const CACHE_FORMAT_VERSION = 189;
+// 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
@@ -926,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)
@@ -1075,6 +1202,8 @@ function loadCache(index, cachePath) {
             index.buildInheritanceGraph();
         }
 
+        loadUsageCache(index, cacheFile);
+
         return true;
     } catch (e) {
         return false;
@@ -1092,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
@@ -1153,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 || [];
@@ -1347,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,