ucn 3.8.22 → 3.8.23

package/core/analysis.js

@@ -353,13 +353,24 @@ function related(index, name, options = {}) {
     if (related.similarNames.length > similarLimit) related.similarNames = related.similarNames.slice(0, similarLimit);
 
     // 3. Shared callers - functions called by the same callers
-    const myCallers = new Set(index.findCallers(name).map(c => c.callerName).filter(Boolean));
+    // Cap findCallers to avoid O(hundreds × findCallees) on ambiguous names
+    const maxSharedCallerScan = options.all ? 50 : 20;
+    const myCallersRaw = index.findCallers(name, { maxResults: maxSharedCallerScan * 3 });
+    const myCallers = new Set(myCallersRaw.map(c => c.callerName).filter(Boolean));
     if (myCallers.size > 0) {
         const callerCounts = new Map();
+        const calleeCache = new Map();
+        let scannedCallers = 0;
         for (const callerName of myCallers) {
+            if (scannedCallers >= maxSharedCallerScan) break;
             const callerDef = index.symbols.get(callerName)?.[0];
             if (callerDef) {
-                const callees = index.findCallees(callerDef);
+                let callees = calleeCache.get(callerName);
+                if (!callees) {
+                    callees = index.findCallees(callerDef);
+                    calleeCache.set(callerName, callees);
+                }
+                scannedCallers++;
                 for (const callee of callees) {
                     if (callee.name !== name) {
                         callerCounts.set(callee.name, (callerCounts.get(callee.name) || 0) + 1);
@@ -394,9 +405,14 @@ function related(index, name, options = {}) {
         const myCalleeNames = new Set(myCallees.map(c => c.name));
         if (myCalleeNames.size > 0) {
             const calleeCounts = new Map();
+            // Cap callee scan to avoid O(callees × findCallers) explosion
+            const maxCalleeScan = options.all ? 30 : 15;
+            let scannedCallees = 0;
             for (const calleeName of myCalleeNames) {
+                if (scannedCallees >= maxCalleeScan) break;
+                scannedCallees++;
                 // Find other functions that also call this callee
-                const callers = index.findCallers(calleeName);
+                const callers = index.findCallers(calleeName, { maxResults: 50 });
                 for (const caller of callers) {
                     if (caller.callerName && caller.callerName !== name) {
                         calleeCounts.set(caller.callerName, (calleeCounts.get(caller.callerName) || 0) + 1);
@@ -789,7 +805,9 @@ function about(index, name, options = {}) {
     let aboutConfFiltered = 0;
     if (primary.type === 'function' || primary.params !== undefined) {
         // Use maxResults to limit file iteration (with buffer for exclude filtering)
-        const callerCap = maxCallers === Infinity ? undefined : maxCallers * 3;
+        // Reduce buffer for highly ambiguous names (many definitions = more noise, less value per caller)
+        const callerMultiplier = definitions.length > 5 ? 1.5 : 3;
+        const callerCap = maxCallers === Infinity ? undefined : Math.ceil(maxCallers * callerMultiplier);
         allCallers = index.findCallers(symbolName, { includeMethods, includeUncertain: options.includeUncertain, targetDefinitions: [primary], maxResults: callerCap });
         // Apply exclude filter before slicing
         if (options.exclude && options.exclude.length > 0) {
@@ -837,7 +855,8 @@ function about(index, name, options = {}) {
     }
 
     // Find tests — scope to the same file/class as the primary definition
-    const tests = index.tests(symbolName, {
+    // Skip expensive test search for highly ambiguous names (>10 other definitions)
+    const tests = (others.length > 10 && !options.all) ? [] : index.tests(symbolName, {
         file: options.file,
         className: options.className || primary.className,
         exclude: options.exclude,

package/core/cache.js

@@ -68,31 +68,22 @@ function saveCache(index, cachePath) {
         strippedFiles.push([rp, rest]);
     }
 
-    // Convert graph paths from absolute to relative
+    // Convert graph paths from absolute to relative (Sets serialized as arrays)
     const relGraph = (graph) => {
         const result = [];
         for (const [absKey, absValues] of graph) {
             const relKey = path.relative(root, absKey);
-            const relValues = absValues.map(v => path.relative(root, v));
+            const relValues = [...absValues].map(v => path.relative(root, v));
             result.push([relKey, relValues]);
         }
         return result;
     };
 
-    // Persist calleeIndex if built (paths must be absolute from this.files keys)
-    let calleeIndexData;
-    if (index.calleeIndex && index.calleeIndex.size > 0) {
-        calleeIndexData = [];
-        for (const [name, files] of index.calleeIndex) {
-            const relFiles = [...files].map(f =>
-                path.isAbsolute(f) ? path.relative(root, f) : f
-            );
-            calleeIndexData.push([name, relFiles]);
-        }
-    }
+    // calleeIndex is NOT persisted in index.json — it's rebuilt lazily from callsCache
+    // on first findCallers/buildCalleeIndex call. Removing it saves ~22MB (14%) on large projects.
 
     const cacheData = {
-        version: 7,  // v7: strip symbols/bindings from file entries (dedup ~45% cache reduction)
+        version: 8,  // v8: remove calleeIndex from index.json (rebuilt from callsCache)
         ucnVersion: UCN_VERSION,  // Invalidate cache when UCN is updated
         configHash,
         root,
@@ -108,23 +99,22 @@ function saveCache(index, cachePath) {
         failedFiles: index.failedFiles
             ? Array.from(index.failedFiles).map(f => path.relative(root, f))
             : [],
-        ...(calleeIndexData && { calleeIndex: calleeIndexData })
     };
 
     fs.writeFileSync(cacheFile, JSON.stringify(cacheData));
 
-    // Save callsCache sharded by directory for lazy loading
+    // Save callsCache sharded by directory for lazy loading.
+    // Write to a temp directory first, then atomic swap to avoid data loss on crash.
     if (callsCacheData.length > 0) {
-        const callsDir = path.join(path.dirname(cacheFile), 'calls');
-        // Clean up old shards and legacy monolithic file
-        if (fs.existsSync(callsDir)) {
-            fs.rmSync(callsDir, { recursive: true, force: true });
-        }
-        const legacyFile = path.join(path.dirname(cacheFile), 'calls-cache.json');
-        if (fs.existsSync(legacyFile)) {
-            fs.rmSync(legacyFile, { force: true });
+        const cacheDir = path.dirname(cacheFile);
+        const callsDir = path.join(cacheDir, 'calls');
+        const callsTmpDir = path.join(cacheDir, 'calls.tmp');
+
+        // Clean up any leftover temp dir from a previous crashed save
+        if (fs.existsSync(callsTmpDir)) {
+            fs.rmSync(callsTmpDir, { recursive: true, force: true });
         }
-        fs.mkdirSync(callsDir, { recursive: true });
+        fs.mkdirSync(callsTmpDir, { recursive: true });
 
         // Group by directory
         const shards = new Map();
@@ -134,17 +124,29 @@ function saveCache(index, cachePath) {
             shards.get(dir).push([relPath, entry]);
         }
 
-        // Write one shard per directory
+        // Write all shards to temp directory
         const shardManifest = [];
         for (const [dir, entries] of shards) {
             const hash = crypto.createHash('md5').update(dir).digest('hex').slice(0, 10);
-            const shardFile = path.join(callsDir, `${hash}.json`);
+            const shardFile = path.join(callsTmpDir, `${hash}.json`);
             fs.writeFileSync(shardFile, JSON.stringify(entries));
             shardManifest.push([dir, hash, entries.length]);
         }
 
-        // Write manifest for lazy loading
-        fs.writeFileSync(path.join(callsDir, 'manifest.json'), JSON.stringify(shardManifest));
+        // Write manifest to temp directory
+        fs.writeFileSync(path.join(callsTmpDir, 'manifest.json'), JSON.stringify(shardManifest));
+
+        // Atomic swap: remove old, rename temp to final
+        if (fs.existsSync(callsDir)) {
+            fs.rmSync(callsDir, { recursive: true, force: true });
+        }
+        fs.renameSync(callsTmpDir, callsDir);
+
+        // Clean up legacy monolithic file
+        const legacyFile = path.join(cacheDir, 'calls-cache.json');
+        if (fs.existsSync(legacyFile)) {
+            fs.rmSync(legacyFile, { force: true });
+        }
     }
 
     return cacheFile;
@@ -168,7 +170,8 @@ function loadCache(index, cachePath) {
 
         // Check version compatibility
         // v7: symbols/bindings stripped from file entries (dedup)
-        if (cacheData.version !== 7) {
+        // v8: calleeIndex removed from index.json (rebuilt from callsCache)
+        if (cacheData.version !== 7 && cacheData.version !== 8) {
             return false;
         }
 
@@ -186,12 +189,19 @@ function loadCache(index, cachePath) {
         }
 
         const root = cacheData.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.
+        const rootPrefix = root.endsWith(path.sep) ? root : root + path.sep;
+        const toAbs = path.sep === '/'
+            ? (relPath) => rootPrefix + relPath
+            : (relPath) => rootPrefix + relPath.replace(/\//g, path.sep);
 
         // Reconstruct files Map: relative key → absolute key, restore path and relativePath
         // Initialize symbols/bindings arrays (will be populated from top-level symbols)
         index.files = new Map();
         for (const [relPath, entry] of cacheData.files) {
-            const absPath = path.join(root, relPath);
+            const absPath = toAbs(relPath);
             entry.path = absPath;
             entry.relativePath = relPath;
             if (!entry.symbols) entry.symbols = [];
@@ -204,7 +214,7 @@ function loadCache(index, cachePath) {
         index.symbols = new Map(cacheData.symbols);
         for (const [, defs] of index.symbols) {
             for (const s of defs) {
-                if (!s.file && s.relativePath) s.file = path.join(root, s.relativePath);
+                if (!s.file && s.relativePath) s.file = toAbs(s.relativePath);
                 if (!s.bindingId && s.relativePath && s.type && s.startLine) {
                     s.bindingId = `${s.relativePath}:${s.type}:${s.startLine}`;
                 }
@@ -222,11 +232,14 @@ function loadCache(index, cachePath) {
             }
         }
 
-        // Reconstruct graphs: relative paths → absolute paths
+        // Reconstruct graphs: relative paths → absolute paths (as Sets)
+        // Uses string concat (toAbs) instead of path.join — 70x faster on 464K edges
         const absGraph = (data) => {
             const m = new Map();
             for (const [relKey, relValues] of data) {
-                m.set(path.join(root, relKey), relValues.map(v => path.join(root, v)));
+                const absValues = new Set();
+                for (const v of relValues) absValues.add(toAbs(v));
+                m.set(toAbs(relKey), absValues);
             }
             return m;
         };
@@ -243,10 +256,10 @@ function loadCache(index, cachePath) {
             index.extendedByGraph = new Map(cacheData.extendedByGraph);
         }
 
-        // Eagerly load callsCache from separate file.
-        // Prevents 10K cold tree-sitter re-parses (2GB+ peak) when findCallers runs.
+        // Prepare lazy calls cache loading — load manifest but defer shard parsing.
+        // Shards are loaded on first getCachedCalls access via ensureCallsCacheLoaded().
         if (index.callsCache.size === 0) {
-            loadCallsCache(index);
+            _prepareCallsCache(index);
         }
 
         // Build directory→files index from loaded data
@@ -257,17 +270,17 @@ function loadCache(index, cachePath) {
         // Restore failedFiles if present (convert relative paths back to absolute)
         if (Array.isArray(cacheData.failedFiles)) {
             index.failedFiles = new Set(
-                cacheData.failedFiles.map(f => path.isAbsolute(f) ? f : path.join(root, f))
+                cacheData.failedFiles.map(f => path.isAbsolute(f) ? f : toAbs(f))
             );
         }
 
-        // Restore calleeIndex if persisted
+        // Restore calleeIndex if persisted (v7 caches only; v8+ rebuilds lazily)
         if (Array.isArray(cacheData.calleeIndex)) {
             index.calleeIndex = new Map();
             for (const [name, files] of cacheData.calleeIndex) {
                 if (!Array.isArray(files)) continue;
                 index.calleeIndex.set(name, new Set(
-                    files.map(f => path.isAbsolute(f) ? f : path.join(root, f))
+                    files.map(f => path.isAbsolute(f) ? f : toAbs(f))
                 ));
             }
         }
@@ -292,6 +305,12 @@ 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;
+    }
+
     // Fast path: check cached files for modifications/deletions first (stat-only).
     // This returns early without the expensive directory walk when any file changed.
     for (const [filePath, fileEntry] of index.files) {
@@ -337,44 +356,64 @@ function isCacheStale(index) {
         }
     }
 
+    // Record when we last confirmed the cache is fresh (enables 2s skip on burst calls)
+    index._lastFreshAt = Date.now();
     return false;
 }
 
 /**
- * Load callsCache from separate file on demand.
- * Only loads if callsCache is empty (not already populated from inline or prior load).
+ * Prepare calls cache for lazy loading — reads manifest but defers shard parsing.
+ * Called during loadCache() to set up the manifest without the ~1s shard parse cost.
+ * Actual shards are loaded on first ensureCallsCacheLoaded() call.
  * @param {object} index - ProjectIndex instance
- * @returns {boolean} - True if loaded successfully
  */
-function loadCallsCache(index) {
-    if (index.callsCache.size > 0) return true; // Already populated
-    if (index._callsCacheLoaded) return false;   // Already attempted, file didn't exist
-    index._callsCacheLoaded = true;
-
+function _prepareCallsCache(index) {
+    if (index._callsCacheLoaded) return;
     const cacheDir = path.join(index.root, '.ucn-cache');
-
-    // Try sharded format first (calls/manifest.json)
     const manifestFile = path.join(cacheDir, 'calls', 'manifest.json');
     if (fs.existsSync(manifestFile)) {
         try {
             const manifest = JSON.parse(fs.readFileSync(manifestFile, 'utf-8'));
-            // Store manifest for lazy loading
             index._callsManifest = new Map();
             for (const [dir, hash, count] of manifest) {
                 index._callsManifest.set(dir, { hash, count, loaded: false });
             }
-            // Eagerly load all shards (matches previous behavior)
-            for (const [, { hash }] of index._callsManifest) {
-                _loadCallsShard(index, hash);
-            }
-            return true;
+            index._callsCachePrepared = true;
+            return;
         } catch (e) {
-            // Corrupted manifest — fall through to legacy
+            // Corrupted manifest — fall through
+        }
+    }
+    // Check legacy format
+    const legacyFile = path.join(cacheDir, 'calls-cache.json');
+    if (fs.existsSync(legacyFile)) {
+        index._callsCacheLegacyFile = legacyFile;
+        index._callsCachePrepared = true;
+    }
+}
+
+/**
+ * Load callsCache from separate file on demand.
+ * Only loads if callsCache is empty (not already populated from inline or prior load).
+ * @param {object} index - ProjectIndex instance
+ * @returns {boolean} - True if loaded successfully
+ */
+function loadCallsCache(index) {
+    if (index.callsCache.size > 0) return true; // Already populated
+    if (index._callsCacheLoaded) return false;   // Already attempted, file didn't exist
+    index._callsCacheLoaded = true;
+
+    // If manifest was prepared lazily, load all shards now
+    if (index._callsManifest) {
+        for (const [, { hash }] of index._callsManifest) {
+            _loadCallsShard(index, hash);
         }
+        return index.callsCache.size > 0;
     }
 
     // Legacy format: single calls-cache.json
-    const callsCacheFile = path.join(cacheDir, 'calls-cache.json');
+    const callsCacheFile = index._callsCacheLegacyFile ||
+        path.join(index.root, '.ucn-cache', 'calls-cache.json');
     if (!fs.existsSync(callsCacheFile)) return false;
 
     try {
@@ -393,6 +432,17 @@ function loadCallsCache(index) {
     return false;
 }
 
+/**
+ * Ensure calls cache is fully loaded (trigger lazy load if prepared but not loaded).
+ * Call this before any operation that needs callsCache (findCallers, buildCalleeIndex, etc.)
+ * @param {object} index - ProjectIndex instance
+ */
+function ensureCallsCacheLoaded(index) {
+    if (index._callsCachePrepared && !index._callsCacheLoaded) {
+        loadCallsCache(index);
+    }
+}
+
 /**
  * Load a single calls shard by hash.
  * @param {object} index - ProjectIndex instance
@@ -403,9 +453,13 @@ function _loadCallsShard(index, hash) {
     try {
         const data = JSON.parse(fs.readFileSync(shardFile, 'utf-8'));
         if (!Array.isArray(data)) return;
+        const rootPrefix = index.root.endsWith(path.sep) ? index.root : index.root + path.sep;
+        const toAbsShard = path.sep === '/'
+            ? (rp) => rootPrefix + rp
+            : (rp) => rootPrefix + rp.replace(/\//g, path.sep);
         for (const [relPath, entry] of data) {
             if (!relPath || !entry) continue;
-            const absPath = path.isAbsolute(relPath) ? relPath : path.join(index.root, relPath);
+            const absPath = path.isAbsolute(relPath) ? relPath : toAbsShard(relPath);
             index.callsCache.set(absPath, entry);
         }
     } catch (e) {
@@ -413,4 +467,4 @@ function _loadCallsShard(index, hash) {
     }
 }
 
-module.exports = { saveCache, loadCache, loadCallsCache, isCacheStale };
+module.exports = { saveCache, loadCache, loadCallsCache, isCacheStale, ensureCallsCacheLoaded };

package/core/callers.js

@@ -13,6 +13,14 @@ const { isTestFile } = require('./discovery');
 const { NON_CALLABLE_TYPES } = require('./shared');
 const { scoreEdge } = require('./confidence');
 
+/** Set.some() helper — like Array.some() but for Sets */
+function setSome(set, predicate) {
+    for (const item of set) {
+        if (predicate(item)) return true;
+    }
+    return false;
+}
+
 /**
  * Extract a single line from content without splitting the entire string.
  * @param {string} content - Full file content
@@ -40,6 +48,11 @@ function getLine(content, lineNum) {
  */
 function getCachedCalls(index, filePath, options = {}) {
     try {
+        // Trigger lazy calls cache load if prepared but not yet loaded
+        if (index._callsCachePrepared && !index._callsCacheLoaded) {
+            const { ensureCallsCacheLoaded } = require('./cache');
+            ensureCallsCacheLoaded(index);
+        }
         const cached = index.callsCache.get(filePath);
 
         // Fast path: check mtime first (stat is much faster than read+hash)
@@ -91,6 +104,8 @@ function getCachedCalls(index, filePath, options = {}) {
         }
         const calls = langModule.findCallsInCode(content, parser, callOpts);
 
+        // Remove old callee index entries before overwriting cache
+        if (cached) index._removeFromCalleeIndex(filePath, cached.calls);
         index.callsCache.set(filePath, {
             mtime,
             hash,
@@ -98,6 +113,8 @@ function getCachedCalls(index, filePath, options = {}) {
             content: options.includeContent ? content : undefined
         });
         index.callsCacheDirty = true;
+        // Incrementally update callee index with new calls
+        index._addToCalleeIndex(filePath, calls);
 
         if (options.includeContent) {
             return { calls, content };
@@ -390,14 +407,14 @@ function findCallers(index, name, options = {}) {
                     langTraits(fileEntry.language)?.typeSystem === 'structural') {
                     const targetFiles = new Set(targetDefs.map(d => d.file).filter(Boolean));
                     if (targetFiles.size > 0 && !targetFiles.has(filePath)) {
-                        const imports = index.importGraph.get(filePath) || [];
-                        const importsTarget = imports.some(imp => targetFiles.has(imp));
+                        const imports = index.importGraph.get(filePath);
+                        const importsTarget = imports && setSome(imports, imp => targetFiles.has(imp));
                         if (!importsTarget) {
                             // Check one level of re-exports (barrel files)
                             let foundViaReexport = false;
-                            for (const imp of imports) {
-                                const transImports = index.importGraph.get(imp) || [];
-                                if (transImports.some(ti => targetFiles.has(ti))) {
+                            if (imports) for (const imp of imports) {
+                                const transImports = index.importGraph.get(imp);
+                                if (transImports && setSome(transImports, ti => targetFiles.has(ti))) {
                                     foundViaReexport = true;
                                     break;
                                 }
@@ -455,10 +472,10 @@ function findCallers(index, name, options = {}) {
                             continue;
                         }
                         // Multi-segment import — verify via import graph
-                        const callerImportedFiles = index.importGraph.get(filePath) || [];
+                        const callerImportedFiles = index.importGraph.get(filePath);
                         const targetFiles = new Set(targetDefs.map(d => d.file).filter(Boolean));
                         if (!targetFiles.has(filePath)) {
-                            const hasImportEdge = callerImportedFiles.some(imp => targetFiles.has(imp));
+                            const hasImportEdge = callerImportedFiles && setSome(callerImportedFiles, imp => targetFiles.has(imp));
                             if (!hasImportEdge) {
                                 // No import edge — allow same-package (same directory) calls
                                 const callerDir = path.dirname(filePath);
@@ -583,13 +600,13 @@ function findCallers(index, name, options = {}) {
                 // Check import graph evidence: does this file import from the target definition's file?
                 const targetDefs2 = options.targetDefinitions || definitions;
                 const targetFiles2 = new Set(targetDefs2.map(d => d.file).filter(Boolean));
-                const callerImports = index.importGraph.get(filePath) || [];
-                let hasImportLink = targetFiles2.has(filePath) || callerImports.some(imp => targetFiles2.has(imp));
+                const callerImports = index.importGraph.get(filePath);
+                let hasImportLink = targetFiles2.has(filePath) || (callerImports && setSome(callerImports, imp => targetFiles2.has(imp)));
                 // Check one level of re-exports (barrel files) for import evidence
-                if (!hasImportLink) {
+                if (!hasImportLink && callerImports) {
                     for (const imp of callerImports) {
-                        const transImports = index.importGraph.get(imp) || [];
-                        if (transImports.some(ti => targetFiles2.has(ti))) {
+                        const transImports = index.importGraph.get(imp);
+                        if (transImports && setSome(transImports, ti => targetFiles2.has(ti))) {
                             hasImportLink = true;
                             break;
                         }
@@ -1175,7 +1192,7 @@ function findCallees(index, def, options = {}) {
         const defFileEntry = fileEntry;
         const callerIsTest = defFileEntry && isTestFile(defFileEntry.relativePath, defFileEntry.language);
         // Pre-compute import graph for callee confidence scoring
-        const callerImportSet = new Set(index.importGraph.get(def.file) || []);
+        const callerImportSet = index.importGraph.get(def.file) || new Set();
 
         for (const { name: calleeName, bindingId, count, isConstructor } of callees.values()) {
             const symbols = index.symbols.get(calleeName);
@@ -1366,6 +1383,7 @@ function _buildLocalTypeMap(index, def, calls) {
     }
     const lines = content.split('\n');
     const localTypes = new Map();
+    const regexCache = new Map();
 
     for (const call of calls) {
         // Only look at calls within this function's scope
@@ -1383,18 +1401,21 @@ function _buildLocalTypeMap(index, def, calls) {
         const sourceLine = lines[call.line - 1];
         if (!sourceLine) continue;
 
-        // Match: identifier = ClassName(...) or identifier: Type = ClassName(...)
-        const escapedName = call.name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-        const assignMatch = sourceLine.match(
-            new RegExp(`(\\w+)\\s*(?::\\s*\\w+)?\\s*=\\s*${escapedName}\\s*\\(`)
-        );
+        // Memoize compiled regex per call name (same name → same pattern)
+        let patterns = regexCache.get(call.name);
+        if (!patterns) {
+            const esc = call.name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+            patterns = {
+                assign: new RegExp(`(\\w+)\\s*(?::\\s*\\w+)?\\s*=\\s*${esc}\\s*\\(`),
+                with: new RegExp(`with\\s+${esc}\\s*\\([^)]*\\)\\s+as\\s+(\\w+)`)
+            };
+            regexCache.set(call.name, patterns);
+        }
+        const assignMatch = sourceLine.match(patterns.assign);
         if (assignMatch) {
             localTypes.set(assignMatch[1], call.name);
         }
-        // Match: with ClassName(...) as identifier:
-        const withMatch = sourceLine.match(
-            new RegExp(`with\\s+${escapedName}\\s*\\([^)]*\\)\\s+as\\s+(\\w+)`)
-        );
+        const withMatch = sourceLine.match(patterns.with);
         if (withMatch) {
             localTypes.set(withMatch[1], call.name);
         }
@@ -1432,10 +1453,11 @@ function _buildTypedLocalTypeMap(index, def, calls) {
         // Handles: x := NewFoo(), x, err := NewFoo(), x := pkg.NewFoo(), x, err := pkg.NewFoo()
         const newName = call.isMethod ? call.name : call.name;
         if (/^New[A-Z]/.test(newName) && !call.isPotentialCallback) {
+            if (_cachedLines === false) continue; // File unreadable, skip all
             if (!_cachedLines) {
                 try {
                     _cachedLines = index._readFile(def.file).split('\n');
-                } catch { continue; }
+                } catch { _cachedLines = false; continue; }
             }
             const sourceLine = _cachedLines[call.line - 1];
             if (!sourceLine) continue;

package/core/deadcode.js

@@ -212,6 +212,28 @@ function deadcode(index, options = {}) {
         }
     }
 
+    // Pre-filter exported symbols from the scan set when not auditing exports.
+    // Go exports ~63K capitalized names on K8s — scanning these in Phase 2 only to
+    // skip them in Phase 3 wastes O(63K × 11K files) = ~700M comparisons.
+    if (!options.includeExported) {
+        const narrowed = new Set();
+        for (const name of potentiallyDeadNames) {
+            const syms = index.symbols.get(name) || [];
+            // Keep the name only if at least one definition is NOT exported
+            const allExported = syms.every(s => {
+                const fe = index.files.get(s.file);
+                const lang = fe?.language;
+                if (!fe) return false;
+                return fe.exports.includes(name) ||
+                    (s.modifiers || []).includes('export') ||
+                    (s.modifiers || []).includes('public') ||
+                    (langTraits(lang)?.exportVisibility === 'capitalization' && /^[A-Z]/.test(name));
+            });
+            if (!allExported) narrowed.add(name);
+        }
+        potentiallyDeadNames = narrowed;
+    }
+
     // When --file is provided, pre-filter to only names of symbols in the target scope.
     // The text scan below is O(potentiallyDeadNames × files) — narrowing the name set
     // avoids scanning all files for names that will be filtered out at the result stage.
@@ -236,9 +258,16 @@ function deadcode(index, options = {}) {
         for (const [filePath, fileEntry] of index.files) {
             try {
                 const content = index._readFile(filePath);
-                const lines = content.split('\n');
+                // Fast pre-filter: extract identifiers from file, intersect with target names.
+                // One regex pass over content (O(content)) vs O(names × content) substring searches.
+                const fileIdentifiers = new Set(content.match(/\b[a-zA-Z_]\w*\b/g));
+                const namesInFile = [];
                 for (const name of potentiallyDeadNames) {
-                    if (!content.includes(name)) continue;
+                    if (fileIdentifiers.has(name)) namesInFile.push(name);
+                }
+                if (namesInFile.length === 0) continue;
+                const lines = content.split('\n');
+                for (const name of namesInFile) {
                     const nameLen = name.length;
                     for (let i = 0; i < lines.length; i++) {
                         const line = lines[i];

package/core/graph-build.js

@@ -103,7 +103,7 @@ function buildImportGraph(index) {
     }
 
     for (const [filePath, fileEntry] of index.files) {
-        const importedFiles = [];
+        const importedFiles = new Set();
         const seenModules = new Set();
 
         for (const importModule of fileEntry.imports) {
@@ -144,11 +144,11 @@ function buildImportGraph(index) {
                 }
 
                 for (const linkedFile of filesToLink) {
-                    importedFiles.push(linkedFile);
+                    importedFiles.add(linkedFile);
                     if (!index.exportGraph.has(linkedFile)) {
-                        index.exportGraph.set(linkedFile, []);
+                        index.exportGraph.set(linkedFile, new Set());
                     }
-                    index.exportGraph.get(linkedFile).push(filePath);
+                    index.exportGraph.get(linkedFile).add(filePath);
                 }
             }
         }

package/core/graph.js

@@ -119,9 +119,9 @@ function exporters(index, filePath) {
 
     const targetPath = resolved;
 
-    const importers = index.exportGraph.get(targetPath) || [];
+    const importers = index.exportGraph.get(targetPath) || new Set();
 
-    return importers.map(importerPath => {
+    return [...importers].map(importerPath => {
         const fileEntry = index.files.get(importerPath);
 
         // Find the import line
@@ -470,13 +470,10 @@ function graph(index, filePath, options = {}) {
             if (depth >= maxDepth) return;
 
             const neighbors = dir === 'imports'
-                ? (index.importGraph.get(file) || [])
-                : (index.exportGraph.get(file) || []);
+                ? (index.importGraph.get(file) || new Set())
+                : (index.exportGraph.get(file) || new Set());
 
-            // Deduplicate neighbors (same file may be imported multiple times, e.g. Java inner classes)
-            const uniqueNeighbors = [...new Set(neighbors)];
-
-            for (const neighbor of uniqueNeighbors) {
+            for (const neighbor of neighbors) {
                 edges.push({ from: file, to: neighbor });
                 traverse(neighbor, depth + 1);
             }
@@ -543,7 +540,7 @@ function circularDeps(index, options = {}) {
             color.set(file, GRAY);
             stack.push(file);
 
-            const neighbors = [...new Set(index.importGraph.get(file) || [])];
+            const neighbors = index.importGraph.get(file) || new Set();
 
             for (const neighbor of neighbors) {
                 if (neighbor === file) continue;  // Skip self-imports (not a cycle)
@@ -594,7 +591,7 @@ function circularDeps(index, options = {}) {
         // Count files that participate in import graph (have edges)
         let filesWithImports = 0;
         for (const [, targets] of index.importGraph) {
-            if (targets && targets.length > 0) filesWithImports++;
+            if (targets && targets.size > 0) filesWithImports++;
         }
 
         return {

package/core/parallel-build.js

@@ -40,12 +40,6 @@ function parallelBuild(index, files, options = {}) {
         console.error(`Parallel build: ${workerCount} workers for ${files.length} files`);
     }
 
-    // Prepare existing hash data for skip-if-unchanged checks in workers
-    const existingHashes = Object.create(null);
-    for (const [fp, entry] of index.files) {
-        existingHashes[fp] = { mtime: entry.mtime, size: entry.size, hash: entry.hash };
-    }
-
     // Partition files round-robin for balanced work distribution
     const chunks = Array.from({ length: workerCount }, () => []);
     for (let i = 0; i < files.length; i++) {
@@ -63,11 +57,20 @@ function parallelBuild(index, files, options = {}) {
         const { port1, port2 } = new MessageChannel();
         ports.push(port1);
 
+        // Build per-worker hash subset (each worker only needs hashes for its chunk)
+        const workerHashes = Object.create(null);
+        for (const fp of chunks[i]) {
+            const entry = index.files.get(fp);
+            if (entry) {
+                workerHashes[fp] = { mtime: entry.mtime, size: entry.size, hash: entry.hash };
+            }
+        }
+
         const worker = new Worker(path.join(__dirname, 'build-worker.js'), {
             workerData: {
                 files: chunks[i],
                 rootDir: index.root,
-                existingHashes,
+                existingHashes: workerHashes,
                 signal: sab,
                 workerIndex: i,
                 port: port2,

package/core/project.js

@@ -77,6 +77,7 @@ class ProjectIndex {
             this._opContentCache = new Map();
             this._opUsagesCache = new Map();
             this._opCallsCountCache = new Map();
+            this._opEnclosingFnCache = new Map();
             this._opDepth = 0;
         }
         this._opDepth++;
@@ -84,10 +85,17 @@ class ProjectIndex {
 
     /** End a per-operation content cache scope (only clears when outermost scope ends) */
     _endOp() {
+        if (!this._opContentCache) return; // Mismatched call — no active operation
         if (--this._opDepth <= 0) {
             this._opContentCache = null;
             this._opUsagesCache = null;
             this._opCallsCountCache = null;
+            this._opEnclosingFnCache = null;
+            // Free cached file content from callsCache entries (retained during
+            // operation for _readFile caching, not needed between operations)
+            for (const entry of this.callsCache.values()) {
+                if (entry.content !== undefined) entry.content = undefined;
+            }
             this._opDepth = 0;
         }
     }
@@ -474,14 +482,18 @@ class ProjectIndex {
             }
         }
 
-        // Invalidate cached call data for this file
+        // Incrementally update callee index before deleting cached calls
+        const oldCached = this.callsCache.get(filePath);
+        if (oldCached) {
+            this._removeFromCalleeIndex(filePath, oldCached.calls);
+        }
         this.callsCache.delete(filePath);
 
-        // Invalidate callee index (will be rebuilt lazily)
-        this.calleeIndex = null;
-
         // Invalidate attribute type cache for this file
         if (this._attrTypeCache) this._attrTypeCache.delete(filePath);
+
+        // Invalidate lazy Java file index (will be rebuilt on next use)
+        this._javaFileIndex = null;
     }
 
     /**
@@ -490,6 +502,61 @@ class ProjectIndex {
      */
     _buildDirIndex() { graphBuildModule.buildDirIndex(this); }
 
+    /**
+     * Add a file's calls to the callee index (name → Set<filePath>).
+     * Used by buildCalleeIndex (full build) and getCachedCalls (incremental update).
+     */
+    _addToCalleeIndex(filePath, calls) {
+        if (!this.calleeIndex || !calls) return;
+        for (const call of calls) {
+            const name = call.name;
+            if (!this.calleeIndex.has(name)) {
+                this.calleeIndex.set(name, new Set());
+            }
+            this.calleeIndex.get(name).add(filePath);
+            if (call.resolvedName && call.resolvedName !== name) {
+                if (!this.calleeIndex.has(call.resolvedName)) {
+                    this.calleeIndex.set(call.resolvedName, new Set());
+                }
+                this.calleeIndex.get(call.resolvedName).add(filePath);
+            }
+            if (call.resolvedNames) {
+                for (const rn of call.resolvedNames) {
+                    if (rn !== name) {
+                        if (!this.calleeIndex.has(rn)) {
+                            this.calleeIndex.set(rn, new Set());
+                        }
+                        this.calleeIndex.get(rn).add(filePath);
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * Remove a file's calls from the callee index.
+     * Used by removeFileSymbols for incremental updates instead of full invalidation.
+     */
+    _removeFromCalleeIndex(filePath, calls) {
+        if (!this.calleeIndex || !calls) return;
+        for (const call of calls) {
+            const removeName = (n) => {
+                const fileSet = this.calleeIndex.get(n);
+                if (fileSet) {
+                    fileSet.delete(filePath);
+                    if (fileSet.size === 0) this.calleeIndex.delete(n);
+                }
+            };
+            removeName(call.name);
+            if (call.resolvedName && call.resolvedName !== call.name) removeName(call.resolvedName);
+            if (call.resolvedNames) {
+                for (const rn of call.resolvedNames) {
+                    if (rn !== call.name) removeName(rn);
+                }
+            }
+        }
+    }
+
     /**
      * Build inverted call index: callee name -> Set<filePath>.
      * Built lazily on first findCallers call, from the calls cache.
@@ -497,37 +564,15 @@ class ProjectIndex {
      */
     buildCalleeIndex() {
         const { getCachedCalls } = require('./callers');
+        const { ensureCallsCacheLoaded } = require('./cache');
+        ensureCallsCacheLoaded(this);
         this.calleeIndex = new Map();
 
         for (const [filePath] of this.files) {
             // Fast path: use pre-populated callsCache (avoids stat per file)
             const cached = this.callsCache.get(filePath);
             const calls = cached ? cached.calls : getCachedCalls(this, filePath);
-            if (!calls) continue;
-            for (const call of calls) {
-                const name = call.name;
-                if (!this.calleeIndex.has(name)) {
-                    this.calleeIndex.set(name, new Set());
-                }
-                this.calleeIndex.get(name).add(filePath);
-                // Also index resolvedName and resolvedNames for alias resolution
-                if (call.resolvedName && call.resolvedName !== name) {
-                    if (!this.calleeIndex.has(call.resolvedName)) {
-                        this.calleeIndex.set(call.resolvedName, new Set());
-                    }
-                    this.calleeIndex.get(call.resolvedName).add(filePath);
-                }
-                if (call.resolvedNames) {
-                    for (const rn of call.resolvedNames) {
-                        if (rn !== name) {
-                            if (!this.calleeIndex.has(rn)) {
-                                this.calleeIndex.set(rn, new Set());
-                            }
-                            this.calleeIndex.get(rn).add(filePath);
-                        }
-                    }
-                }
-            }
+            this._addToCalleeIndex(filePath, calls);
         }
     }
 
@@ -548,6 +593,20 @@ class ProjectIndex {
      * Progressively strips trailing segments to find the class file.
      */
     _resolveJavaPackageImport(importModule, javaFileIndex) {
+        if (!javaFileIndex) {
+            // Lazy-build index to avoid O(N) fallback scan of all files
+            if (!this._javaFileIndex) {
+                this._javaFileIndex = new Map();
+                for (const [fp, fe] of this.files) {
+                    if (fe.language === 'java') {
+                        const name = path.basename(fp, '.java');
+                        if (!this._javaFileIndex.has(name)) this._javaFileIndex.set(name, []);
+                        this._javaFileIndex.get(name).push(fp);
+                    }
+                }
+            }
+            javaFileIndex = this._javaFileIndex;
+        }
         return graphBuildModule._resolveJavaPackageImport(this, importModule, javaFileIndex);
     }
 
@@ -582,7 +641,7 @@ class ProjectIndex {
             if (contextFile) {
                 const imports = this.importGraph.get(contextFile);
                 if (imports) {
-                    const imported = entries.find(e => imports.includes(e.file));
+                    const imported = entries.find(e => imports.has(e.file));
                     if (imported) return imported.parents;
                 }
             }
@@ -614,7 +673,7 @@ class ProjectIndex {
         if (contextFile) {
             const imports = this.importGraph.get(contextFile);
             if (imports) {
-                const imported = classSymbols.find(s => imports.includes(s.file));
+                const imported = classSymbols.find(s => imports.has(s.file));
                 if (imported) return imported.file;
             }
         }
@@ -824,7 +883,7 @@ class ProjectIndex {
             for (const candidate of tiedCandidates) {
                 let importerCount = 0;
                 for (const [, importedFiles] of this.importGraph) {
-                    if (importedFiles.includes(candidate.def.file)) {
+                    if (importedFiles.has(candidate.def.file)) {
                         importerCount++;
                     }
                 }
@@ -899,8 +958,7 @@ class ProjectIndex {
             const hasFilters = options.exclude && options.exclude.length > 0;
 
             // Pre-compute which files can reference THIS specific definition
-            const importers = this.exportGraph.get(defFile) || [];
-            const importersSet = new Set(importers);
+            const importersSet = this.exportGraph.get(defFile) || new Set();
             const defEntry = this.files.get(defFile);
             const isDirectoryScope = langTraits(defEntry?.language)?.packageScope === 'directory';
             const defDir = isDirectoryScope ? path.dirname(defFile) : null;
@@ -963,7 +1021,7 @@ class ProjectIndex {
 
             // Count imports from import graph (files that import from defFile and use this name)
             let imports = 0;
-            for (const importer of importers) {
+            for (const importer of importersSet) {
                 const fe = this.files.get(importer);
                 if (!fe) continue;
                 if (hasFilters && !this.matchesFilters(fe.relativePath, { exclude: options.exclude })) continue;
@@ -1022,7 +1080,7 @@ class ProjectIndex {
 
         while (queue.length > 0) {
             const file = queue.pop();
-            const importersArr = this.exportGraph.get(file) || [];
+            const importersArr = this.exportGraph.get(file) || new Set();
             for (const importer of importersArr) {
                 if (!relevantFiles.has(importer)) {
                     relevantFiles.add(importer);
@@ -1548,6 +1606,15 @@ class ProjectIndex {
         const fileEntry = this.files.get(filePath);
         if (!fileEntry) return null;
 
+        // Per-operation cache: avoid rescanning symbols for same (file, line)
+        const cacheKey = filePath + '\0' + lineNum;
+        if (this._opEnclosingFnCache) {
+            const cached = this._opEnclosingFnCache.get(cacheKey);
+            if (cached !== undefined) {
+                return cached === null ? null : (returnSymbol ? cached : cached.name);
+            }
+        }
+
         let best = null;
         for (const symbol of fileEntry.symbols) {
             if (!NON_CALLABLE_TYPES.has(symbol.type) &&
@@ -1558,8 +1625,11 @@ class ProjectIndex {
                 }
             }
         }
-        if (!best) return null;
-        return returnSymbol ? best : best.name;
+
+        if (this._opEnclosingFnCache) {
+            this._opEnclosingFnCache.set(cacheKey, best);
+        }
+        return best ? (returnSymbol ? best : best.name) : null;
     }
 
     /** Get instance attribute types for a class in a file */

package/core/search.js

@@ -221,11 +221,15 @@ function usages(index, name, options = {}) {
                 let _importedHasDef = null;
                 const importedFileHasDef = () => {
                     if (_importedHasDef !== null) return _importedHasDef;
-                    const importedFiles = index.importGraph.get(filePath) || [];
-                    _importedHasDef = importedFiles.some(imp => {
+                    const importedFiles = index.importGraph.get(filePath);
+                    _importedHasDef = false;
+                    if (importedFiles) for (const imp of importedFiles) {
                         const impEntry = index.files.get(imp);
-                        return impEntry?.symbols?.some(s => s.name === name);
-                    });
+                        if (impEntry?.symbols?.some(s => s.name === name)) {
+                            _importedHasDef = true;
+                            break;
+                        }
+                    }
                     return _importedHasDef;
                 };
 
@@ -1008,7 +1012,7 @@ function _buildSourceFileImporters(index, defs) {
 
     while (queue.length > 0) {
         const current = queue.shift();
-        const directImporters = index.exportGraph?.get(current) || [];
+        const directImporters = index.exportGraph?.get(current) || new Set();
         for (const imp of directImporters) {
             importers.add(imp);
             // Check if this importer re-exports the symbol (barrel pattern).

package/core/tracing.js

@@ -435,13 +435,22 @@ function reverseTrace(index, name, options = {}) {
                 if (callerEntries.length > maxChildren) {
                     node.truncatedChildren = callerEntries.length - maxChildren;
                     // Count entry points in truncated branches so summary is accurate
+                    // Use callerCache to avoid redundant findCallers calls
                     for (const { def: cDef } of callerEntries.slice(maxChildren)) {
-                        const key = `${cDef.file}:${cDef.startLine}`;
-                        if (!visited.has(key)) {
-                            const cCallers = index.findCallers(cDef.name, {
-                                includeMethods, includeUncertain,
-                                targetDefinitions: cDef.bindingId ? [cDef] : undefined,
-                            });
+                        const cKey = `${cDef.file}:${cDef.startLine}`;
+                        if (!visited.has(cKey)) {
+                            const cCacheKey = cDef.bindingId
+                                ? `${cDef.name}:${cDef.bindingId}`
+                                : `${cDef.name}:${cKey}`;
+                            let cCallers = callerCache.get(cCacheKey);
+                            if (!cCallers) {
+                                cCallers = index.findCallers(cDef.name, {
+                                    includeMethods, includeUncertain,
+                                    targetDefinitions: cDef.bindingId ? [cDef] : undefined,
+                                    maxResults: 1, // Only need to know if any exist
+                                });
+                                callerCache.set(cCacheKey, cCallers);
+                            }
                             if (cCallers.length === 0) {
                                 entryPoints.push({ name: cDef.name, file: cDef.relativePath || path.relative(index.root, cDef.file), line: cDef.startLine });
                             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ucn",
-  "version": "3.8.22",
+  "version": "3.8.23",
   "mcpName": "io.github.mleoca/ucn",
   "description": "Code intelligence toolkit for AI agents — extract functions, trace call chains, find callers, detect dead code without reading entire files. Works as MCP server, CLI, or agent skill. Supports JS/TS, Python, Go, Rust, Java.",
   "main": "index.js",
@@ -9,7 +9,7 @@
     "ucn-mcp": "mcp/server.js"
   },
   "scripts": {
-    "test": "node --test test/parser-unit.test.js test/integration.test.js test/cache.test.js test/formatter.test.js test/interactive.test.js test/feature.test.js test/regression-js.test.js test/regression-py.test.js test/regression-go.test.js test/regression-java.test.js test/regression-rust.test.js test/regression-cross.test.js test/regression-mcp.test.js test/regression-parser.test.js test/regression-commands.test.js test/regression-fixes.test.js test/regression-bugfixes.test.js test/cross-language.test.js test/accuracy.test.js test/command-coverage.test.js test/systematic-test.js test/mcp-edge-cases.js test/parity-test.js",
+    "test": "node --test test/parser-unit.test.js test/integration.test.js test/cache.test.js test/formatter.test.js test/interactive.test.js test/feature.test.js test/regression-js.test.js test/regression-py.test.js test/regression-go.test.js test/regression-java.test.js test/regression-rust.test.js test/regression-cross.test.js test/regression-mcp.test.js test/regression-parser.test.js test/regression-commands.test.js test/regression-fixes.test.js test/regression-bugfixes.test.js test/cross-language.test.js test/accuracy.test.js test/command-coverage.test.js test/perf-optimizations.test.js test/systematic-test.js test/mcp-edge-cases.js test/parity-test.js",
     "benchmark:agent": "node test/agent-understanding-benchmark.js",
     "lint": "eslint core/ cli/ mcp/ languages/"
   },