ucn 4.0.1 → 4.1.0

package/core/bridge.js

@@ -23,6 +23,7 @@
 'use strict';
 
 const fs = require('fs');
+const { codeUnitCompare } = require('./shared');
 const path = require('path');
 const { getCachedCalls } = require('./callers');
 const { langTraits } = require('../languages');
@@ -353,10 +354,10 @@ function extractServerRoutes(index) {
 
     // Sort deterministically (file, line, method, path)
     routes.sort((a, b) => {
-        if (a.file !== b.file) return a.file.localeCompare(b.file);
+        if (a.file !== b.file) return codeUnitCompare(a.file, b.file);
         if (a.line !== b.line) return a.line - b.line;
-        if (a.method !== b.method) return a.method.localeCompare(b.method);
-        return a.path.localeCompare(b.path);
+        if (a.method !== b.method) return codeUnitCompare(a.method, b.method);
+        return codeUnitCompare(a.path, b.path);
     });
 
     // Cache it
@@ -726,10 +727,10 @@ function extractClientRequests(index) {
 
     // Stable sort
     requests.sort((a, b) => {
-        if (a.file !== b.file) return a.file.localeCompare(b.file);
+        if (a.file !== b.file) return codeUnitCompare(a.file, b.file);
         if (a.line !== b.line) return a.line - b.line;
-        if (a.method !== b.method) return a.method.localeCompare(b.method);
-        return a.path.localeCompare(b.path);
+        if (a.method !== b.method) return codeUnitCompare(a.method, b.method);
+        return codeUnitCompare(a.path, b.path);
     });
 
     if (!index._endpointsCache) index._endpointsCache = {};
@@ -887,13 +888,13 @@ function bridgeEndpoints(index) {
     // For each (request) keep all matches but sort with best first
     bridges.sort((a, b) => {
         // Group by request first
-        const reqCmpFile = a.request.file.localeCompare(b.request.file);
+        const reqCmpFile = codeUnitCompare(a.request.file, b.request.file);
         if (reqCmpFile !== 0) return reqCmpFile;
         if (a.request.line !== b.request.line) return a.request.line - b.request.line;
         // Then by confidence desc
         if (a.confidence !== b.confidence) return b.confidence - a.confidence;
         // Then by route file/line
-        if (a.route.file !== b.route.file) return a.route.file.localeCompare(b.route.file);
+        if (a.route.file !== b.route.file) return codeUnitCompare(a.route.file, b.route.file);
         return a.route.line - b.route.line;
     });
 
@@ -1067,6 +1068,10 @@ function endpoints(index, options = {}) {
     }
 
     return {
+        // Advisory when bridging (v4 two-tier surface): route↔request
+        // matching is heuristic (per-match tiers EXACT/PARTIAL/UNCERTAIN),
+        // not a verified claim. Route/request EXTRACTION is AST-based.
+        ...(opts.bridge && { advisory: 'heuristic-route-matching' }),
         routes,
         requests,
         bridges,

package/core/cache.js

@@ -51,7 +51,65 @@ const UCN_VERSION = require('../package.json').version;
 // node's line (the #201/RUST-2 name-node convention — multi-line receivers
 // like `(&pkg.Name{...}).String()` reported the chain-start line; Go was the
 // only parser still keying calls off the call node's start).
-const CACHE_FORMAT_VERSION = 26;
+// v27 (fix #224): Python from-import submodules — `from . import jobs` binds
+// jobs.py as a plain NAME; graph-build resolves the composed submodule
+// specifier ('.jobs') into fileEntry.moduleResolved and adds the import edge,
+// so submodule receivers behave like `import jobs` module receivers
+// (persisted moduleResolved/importGraph shapes gain entries).
+// v28 (fix #227): canonical index order — everything persisted is written from
+// a canonicalized state (_canonicalizeOrder: files/callsCache by path, defs
+// arrays by (relativePath, startLine, type, className), calleeIndex sorted),
+// so fresh-build, cache-load, and incremental-rebuild states are
+// byte-equivalent and command output no longer depends on cache history.
+// v29 (fix #229): Rust impl members and Java class methods carry method-level
+// `generics` — generic-param receiver types (t.wipe() on TStore: Wipe) resolve
+// against the enclosing declaration instead of excluding as type mismatches.
+// v30 (fix #230): TS parameter-property modifiers (protected/readonly/...)
+// and parameter decorators are no longer recorded as parameter DEFAULTS in
+// paramsStructured.
+// v31 (fix #231): Java try-with-resources declarations type receivers —
+// `try (Res r = new Res())` records receiverType on r.use() like a plain
+// declared-type local (#220(7) typing-sources family).
+// v32 (fix #238): super(...)/this(...) constructor-delegation call records
+// (JS/TS 'constructor' with receiver 'super'; Java under the target class
+// name), Java enum-constant constructor invocations (RED(1)), and Go/Rust
+// zero-param signatures record '' instead of the '...' unknown sentinel.
+// v33 (fix #240): persisted importGraph/exportGraph/moduleResolved content
+// changed — Java wildcard imports link EVERY file directly in the package
+// (non-recursively; subpackage false links dropped), Rust flat-layout crates
+// (no src/) resolve crate:: paths, and super::/crate:: item imports fall back
+// to the parent module FILE (mod.rs / <dir>.rs / lib.rs / main.rs).
+// v34 (fix #241): Java/Python zero-param signatures record '' instead of the
+// '...' unknown sentinel (completes #238's Go/Rust fix), and Rust struct field
+// member symbols carry their own visibility in `modifiers` (pub/pub(crate)/...)
+// so export listings judge fields per-symbol.
+// v35 (fix #245): persisted exports/exportDetails/imports content changed —
+// the JS/TS export scanner records `export abstract class`, `export declare`
+// wrappers, and `export namespace` (the namespace is the importable name),
+// and TS import-equals (`import x = require('./y')`) produces an import
+// record (the dependency edge was invisible to all filedeps commands).
+// v36 (fix #246): persisted importGraph/moduleResolved content changed —
+// Rust own-package-name imports (`use my_crate::helper` in tests/, benches/,
+// examples/) resolve into the package's source tree via the Cargo [package]
+// name, so integration-test dependency edges exist.
+// v37 (fix #247): JS/TS class members carry `private`/`protected`
+// accessibility keywords in `modifiers` (deadcode's exported-member check
+// treated every TS member as implicitly public).
+// v38 (fix #248): Go generic receivers normalize to the type name
+// (`Pair[K, V]` → `Pair` in receiver/className); Rust trait members carry
+// the trait's own visibility instead of the non-Rust 'public', and Rust
+// impl methods record async/unsafe/const/extern qualifiers in modifiers.
+// v39 (fix #249): JS/TS modifiers come from AST tokens, not first-line
+// text — cached symbols may carry export/async/default fabricated from
+// string literals and comments.
+// v40 (fix #251): Java field members carry visibility modifiers, enum
+// constants carry their implicit public/static/final, and Python type
+// aliases (PEP 695 + TypeAlias annotations) are indexed as 'type' symbols.
+// v41 (fix #252): CJS export object maps index their shorthand/pair
+// function properties (module.exports = { doThing(x){} }) and list them in
+// exports; member-expression assignments record RHS identifier function
+// references (window.onload = handler).
+const CACHE_FORMAT_VERSION = 41;
 
 /**
  * Save index to cache file
@@ -281,7 +339,16 @@ function loadCache(index, cachePath) {
             return false;
         }
 
-        const root = cacheData.root || index.root;
+        // Rehydrate against the CURRENT root, never cacheData.root — the
+        // cache stores relative paths precisely so a moved/copied project
+        // keeps its cache. Using the recorded root re-attached every path to
+        // the ORIGINAL directory: the staleness check then forced a rebuild
+        // of files/symbols, but _reachableSymbols survived with old-root
+        // keys (the fingerprint is path-blind), poisoning reachability notes
+        // and --unreachable-only permanently (fix #249, G9-parity P1 —
+        // repro: cp -r projA projB). The calls-shard loader already used
+        // index.root.
+        const root = index.root;
         // Fast path conversion: string concat is ~70x faster than path.join for
         // cache-stored relative paths (no '..' segments). On Windows, path.relative
         // produces backslash paths, so rootPrefix uses the native separator.
@@ -325,6 +392,12 @@ function loadCache(index, cachePath) {
             }
         }
 
+        // Canonical order (see ProjectIndex._canonicalizeOrder): the loop above
+        // rebuilds fileEntry.symbols/bindings in NAME-MAP order, which differs
+        // from build's parse order — canonicalize so a loaded index is
+        // byte-equivalent to a freshly built one before anything derives from it.
+        index._canonicalizeOrder();
+
         // Reconstruct graphs: relative paths → absolute paths (as Sets)
         // Uses string concat (toAbs) instead of path.join — 70x faster on 464K edges
         const absGraph = (data) => {
@@ -421,11 +494,13 @@ function loadCache(index, cachePath) {
  * @returns {boolean} - True if cache needs rebuilding
  */
 function isCacheStale(index) {
-    // Ultra-fast path: skip full check if last confirmed-fresh < 2s ago (covers MCP burst calls).
-    // Only uses _lastFreshAt (set at the end of a successful full check), not cache save timestamp.
-    if (index._lastFreshAt && Date.now() - index._lastFreshAt < 2000) {
-        return false;
-    }
+    // Modified/deleted detection (stat sweep) runs UNCONDITIONALLY — agents
+    // edit a file and re-query through MCP within seconds, and a stale answer
+    // presented as fresh is the worst trust failure the tool can produce.
+    // The 2s freshness window below shields only the expensive directory
+    // walk (new-file detection): a brand-new file queried within 2s of the
+    // last full check is a far rarer race than an edit, and the walk is the
+    // part that costs real time on large repos.
 
     // Fast path: check cached files for modifications/deletions first (stat-only).
     // This returns early without the expensive directory walk when any file changed.
@@ -454,6 +529,13 @@ function isCacheStale(index) {
         }
     }
 
+    // Ultra-fast skip for the SLOW path only: last confirmed-fresh < 2s ago
+    // (covers MCP burst calls). Uses _lastFreshAt (set at the end of a
+    // successful full check), never the cache save timestamp.
+    if (index._lastFreshAt && Date.now() - index._lastFreshAt < 2000) {
+        return false;
+    }
+
     // Slow path: glob the project to detect new files added since last build.
     // Only reached when all cached files are unchanged.
     const pattern = detectProjectPattern(index.root);
@@ -510,13 +592,14 @@ function _prepareCallsCache(index) {
 
 /**
  * Load callsCache from separate file on demand.
- * Only loads if callsCache is empty (not already populated from inline or prior load).
+ * Merges under existing entries (first writer wins) — anything already in
+ * memory came from a fresh parse of current disk content, so persisted data
+ * must never replace it (fix #227).
  * @param {object} index - ProjectIndex instance
- * @returns {boolean} - True if loaded successfully
+ * @returns {boolean} - True if entries are available after the load
  */
 function loadCallsCache(index) {
-    if (index.callsCache.size > 0) return true; // Already populated
-    if (index._callsCacheLoaded) return false;   // Already attempted, file didn't exist
+    if (index._callsCacheLoaded) return index.callsCache.size > 0;
     index._callsCacheLoaded = true;
 
     // If manifest was prepared lazily, load all shards now
@@ -530,22 +613,24 @@ function loadCallsCache(index) {
     // Legacy format: single calls-cache.json
     const callsCacheFile = index._callsCacheLegacyFile ||
         path.join(index.root, '.ucn-cache', 'calls-cache.json');
-    if (!fs.existsSync(callsCacheFile)) return false;
+    if (!fs.existsSync(callsCacheFile)) return index.callsCache.size > 0;
 
     try {
         const data = JSON.parse(fs.readFileSync(callsCacheFile, 'utf-8'));
         if (Array.isArray(data)) {
-            const absData = data.map(([relPath, entry]) => {
+            for (const [relPath, entry] of data) {
+                if (!relPath || !entry) continue;
                 const absPath = path.isAbsolute(relPath) ? relPath : path.join(index.root, relPath);
-                return [absPath, entry];
-            });
-            index.callsCache = new Map(absData);
-            return true;
+                if (!index.callsCache.has(absPath)) {
+                    index.callsCache.set(absPath, entry);
+                }
+            }
+            return index.callsCache.size > 0;
         }
     } catch (e) {
         // Corrupted file — ignore
     }
-    return false;
+    return index.callsCache.size > 0;
 }
 
 /**
@@ -576,7 +661,12 @@ function _loadCallsShard(index, hash) {
         for (const [relPath, entry] of data) {
             if (!relPath || !entry) continue;
             const absPath = path.isAbsolute(relPath) ? relPath : toAbsShard(relPath);
-            index.callsCache.set(absPath, entry);
+            // First writer wins: an entry already in memory came from a fresh
+            // parse of current disk content (or an earlier load) — never
+            // clobber it with persisted shard data (fix #227).
+            if (!index.callsCache.has(absPath)) {
+                index.callsCache.set(absPath, entry);
+            }
         }
     } catch (e) {
         // Corrupted shard — skip