gitnexus 1.4.0 → 1.4.1

package/dist/core/ingestion/call-processor.js

@@ -1,13 +1,44 @@
-import { isFileInPackageDir } from './import-processor.js';
-import { resolveSymbolInternal } from './symbol-resolver.js';
-import { walkBindingChain } from './named-binding-extraction.js';
 import Parser from 'tree-sitter';
-import { isLanguageAvailable, loadParser, loadLanguage } from '../tree-sitter/parser-loader.js';
+import { loadParser, loadLanguage } from '../tree-sitter/parser-loader.js';
 import { LANGUAGE_QUERIES } from './tree-sitter-queries.js';
 import { generateId } from '../../lib/utils.js';
-import { getLanguageFromFilename, isVerboseIngestionEnabled, yieldToEventLoop, FUNCTION_NODE_TYPES, extractFunctionName, isBuiltInOrNoise, countCallArguments, inferCallForm, extractReceiverName, } from './utils.js';
-import { buildTypeEnv, lookupTypeEnv } from './type-env.js';
-import { getTreeSitterBufferSize } from './constants.js';
+import { getLanguageFromFilename, yieldToEventLoop } from './utils.js';
+/**
+ * Node types that represent function/method definitions across languages.
+ * Used to find the enclosing function for a call site.
+ */
+const FUNCTION_NODE_TYPES = new Set([
+    // TypeScript/JavaScript
+    'function_declaration',
+    'arrow_function',
+    'function_expression',
+    'method_definition',
+    'generator_function_declaration',
+    // Python
+    'function_definition',
+    // Common async variants
+    'async_function_declaration',
+    'async_arrow_function',
+    // Java
+    'method_declaration',
+    'constructor_declaration',
+    // C/C++
+    // 'function_definition' already included above
+    // Go
+    // 'method_declaration' already included from Java
+    // C#
+    'local_function_statement',
+    // Rust
+    'function_item',
+    'impl_item', // Methods inside impl blocks
+    // Kotlin (function_declaration already included above via JS/TS)
+    'anonymous_function',
+    'lambda_literal',
+    // PHP — no additional node types needed
+    // Swift
+    'init_declaration',
+    'deinit_declaration',
+]);
 /**
  * Walk up the AST from a node to find the enclosing function/method.
  * Returns null if the call is at module/file level (top-level code).
@@ -16,22 +47,86 @@ const findEnclosingFunction = (node, filePath, symbolTable) => {
     let current = node.parent;
     while (current) {
         if (FUNCTION_NODE_TYPES.has(current.type)) {
-            const { funcName, label } = extractFunctionName(current);
+            // Found enclosing function - try to get its name
+            let funcName = null;
+            let label = 'Function';
+            // Different node types have different name locations
+            // Swift init/deinit — handle before generic cases (more specific)
+            if (current.type === 'init_declaration' || current.type === 'deinit_declaration') {
+                const funcName = current.type === 'init_declaration' ? 'init' : 'deinit';
+                const startLine = current.startPosition?.row ?? 0;
+                return generateId('Constructor', `${filePath}:${funcName}:${startLine}`);
+            }
+            if (current.type === 'function_declaration' ||
+                current.type === 'function_definition' ||
+                current.type === 'async_function_declaration' ||
+                current.type === 'generator_function_declaration' ||
+                current.type === 'function_item') { // Rust function
+                // Named function: function foo() {}
+                const nameNode = current.childForFieldName?.('name') ||
+                    current.children?.find((c) => c.type === 'identifier' || c.type === 'property_identifier');
+                funcName = nameNode?.text;
+            }
+            else if (current.type === 'impl_item') {
+                // Rust method inside impl block: wrapper around function_item or const_item
+                // We need to look inside for the function_item
+                const funcItem = current.children?.find((c) => c.type === 'function_item');
+                if (funcItem) {
+                    const nameNode = funcItem.childForFieldName?.('name') ||
+                        funcItem.children?.find((c) => c.type === 'identifier');
+                    funcName = nameNode?.text;
+                    label = 'Method';
+                }
+            }
+            else if (current.type === 'method_definition') {
+                // Method: foo() {} inside class (JS/TS)
+                const nameNode = current.childForFieldName?.('name') ||
+                    current.children?.find((c) => c.type === 'property_identifier');
+                funcName = nameNode?.text;
+                label = 'Method';
+            }
+            else if (current.type === 'method_declaration') {
+                // Java method: public void foo() {}
+                const nameNode = current.childForFieldName?.('name') ||
+                    current.children?.find((c) => c.type === 'identifier');
+                funcName = nameNode?.text;
+                label = 'Method';
+            }
+            else if (current.type === 'constructor_declaration') {
+                // Java constructor: public ClassName() {}
+                const nameNode = current.childForFieldName?.('name') ||
+                    current.children?.find((c) => c.type === 'identifier');
+                funcName = nameNode?.text;
+                label = 'Method'; // Treat constructors as methods for process detection
+            }
+            else if (current.type === 'arrow_function' || current.type === 'function_expression') {
+                // Arrow/expression: const foo = () => {} - check parent variable declarator
+                const parent = current.parent;
+                if (parent?.type === 'variable_declarator') {
+                    const nameNode = parent.childForFieldName?.('name') ||
+                        parent.children?.find((c) => c.type === 'identifier');
+                    funcName = nameNode?.text;
+                }
+            }
             if (funcName) {
+                // Look up the function in symbol table to get its node ID
+                // Try exact match first
                 const nodeId = symbolTable.lookupExact(filePath, funcName);
                 if (nodeId)
                     return nodeId;
-                return generateId(label, `${filePath}:${funcName}`);
+                // Try construct ID manually if lookup fails (common for non-exported internal functions)
+                // Format must match parsing-processor: "Label:path/to/file:funcName:startLine"
+                const startLine = current.startPosition?.row ?? 0;
+                return generateId(label, `${filePath}:${funcName}:${startLine}`);
             }
+            // Couldn't determine function name - try parent (might be nested)
         }
         current = current.parent;
     }
-    return null;
+    return null; // Top-level call (not inside any function)
 };
-export const processCalls = async (graph, files, astCache, symbolTable, importMap, packageMap, onProgress, namedImportMap) => {
+export const processCalls = async (graph, files, astCache, symbolTable, importMap, onProgress) => {
     const parser = await loadParser();
-    const logSkipped = isVerboseIngestionEnabled();
-    const skippedByLang = logSkipped ? new Map() : null;
     for (let i = 0; i < files.length; i++) {
         const file = files[i];
         onProgress?.(i + 1, files.length);
@@ -41,12 +136,6 @@ export const processCalls = async (graph, files, astCache, symbolTable, importMa
         const language = getLanguageFromFilename(file.path);
         if (!language)
             continue;
-        if (!isLanguageAvailable(language)) {
-            if (skippedByLang) {
-                skippedByLang.set(language, (skippedByLang.get(language) ?? 0) + 1);
-            }
-            continue;
-        }
         const queryStr = LANGUAGE_QUERIES[language];
         if (!queryStr)
             continue;
@@ -59,7 +148,7 @@ export const processCalls = async (graph, files, astCache, symbolTable, importMa
             // Cache Miss: Re-parse
             // Use larger bufferSize for files > 32KB
             try {
-                tree = parser.parse(file.content, undefined, { bufferSize: getTreeSitterBufferSize(file.content.length) });
+                tree = parser.parse(file.content, undefined, { bufferSize: 1024 * 256 });
             }
             catch (parseError) {
                 // Skip files that can't be parsed
@@ -80,9 +169,6 @@ export const processCalls = async (graph, files, astCache, symbolTable, importMa
             console.warn(`Query error for ${file.path}:`, queryError);
             continue;
         }
-        // Build per-file TypeEnv for receiver resolution
-        const lang = getLanguageFromFilename(file.path);
-        const typeEnv = lang ? buildTypeEnv(tree, lang) : new Map();
         // 3. Process each call match
         matches.forEach(match => {
             const captureMap = {};
@@ -97,20 +183,12 @@ export const processCalls = async (graph, files, astCache, symbolTable, importMa
             // Skip common built-ins and noise
             if (isBuiltInOrNoise(calledName))
                 return;
-            const callNode = captureMap['call'];
-            const callForm = inferCallForm(callNode, nameNode);
-            const receiverName = callForm === 'member' ? extractReceiverName(nameNode) : undefined;
-            const receiverTypeName = receiverName ? lookupTypeEnv(typeEnv, receiverName, callNode) : undefined;
             // 4. Resolve the target using priority strategy (returns confidence)
-            const resolved = resolveCallTarget({
-                calledName,
-                argCount: countCallArguments(callNode),
-                callForm,
-                receiverTypeName,
-            }, file.path, symbolTable, importMap, packageMap, namedImportMap);
+            const resolved = resolveCallTarget(calledName, file.path, symbolTable, importMap);
             if (!resolved)
                 return;
             // 5. Find the enclosing function (caller)
+            const callNode = captureMap['call'];
             const enclosingFuncId = findEnclosingFunction(callNode, file.path, symbolTable);
             // Use enclosing function as source, fallback to file for top-level calls
             const sourceId = enclosingFuncId || generateId('File', file.path);
@@ -126,137 +204,149 @@ export const processCalls = async (graph, files, astCache, symbolTable, importMa
         });
         // Tree is now owned by the LRU cache — no manual delete needed
     }
-    if (skippedByLang && skippedByLang.size > 0) {
-        for (const [lang, count] of skippedByLang.entries()) {
-            console.warn(`[ingestion] Skipped ${count} ${lang} file(s) in call processing — ${lang} parser not available.`);
-        }
-    }
-};
-const CALLABLE_SYMBOL_TYPES = new Set([
-    'Function',
-    'Method',
-    'Constructor',
-    'Macro',
-    'Delegate',
-]);
-const collectTieredCandidates = (calledName, currentFile, symbolTable, importMap, packageMap, namedImportMap) => {
-    const allDefs = symbolTable.lookupFuzzy(calledName);
-    // Tier 1: Same-file — highest priority, prevents imports from shadowing local defs
-    // (matches resolveSymbolInternal which checks lookupExactFull before named bindings)
-    const localDefs = allDefs.filter(def => def.filePath === currentFile);
-    if (localDefs.length > 0) {
-        return { candidates: localDefs, tier: 'same-file' };
-    }
-    // Tier 2a-named: Check named bindings with re-export chain following.
-    // Aliased imports (import { User as U }) mean lookupFuzzy('U') returns
-    // empty but we can resolve via the exported name.
-    // Re-exports (export { User } from './base') are followed up to 5 hops.
-    if (namedImportMap) {
-        const chainResult = resolveNamedBindingChainForCandidates(calledName, currentFile, symbolTable, namedImportMap, allDefs);
-        if (chainResult)
-            return chainResult;
-    }
-    if (allDefs.length === 0)
-        return null;
-    const importedFiles = importMap.get(currentFile);
-    if (importedFiles) {
-        const importedDefs = allDefs.filter(def => importedFiles.has(def.filePath));
-        if (importedDefs.length > 0) {
-            return { candidates: importedDefs, tier: 'import-scoped' };
-        }
-    }
-    const importedPackages = packageMap?.get(currentFile);
-    if (importedPackages) {
-        const packageDefs = allDefs.filter(def => {
-            for (const dirSuffix of importedPackages) {
-                if (isFileInPackageDir(def.filePath, dirSuffix))
-                    return true;
-            }
-            return false;
-        });
-        if (packageDefs.length > 0) {
-            return { candidates: packageDefs, tier: 'import-scoped' };
-        }
-    }
-    // Tier 3: Global — pass all candidates through; filterCallableCandidates
-    // will narrow by kind/arity and resolveCallTarget only emits when exactly 1 remains.
-    return { candidates: allDefs, tier: 'unique-global' };
-};
-const CONSTRUCTOR_TARGET_TYPES = new Set(['Constructor', 'Class', 'Struct', 'Record']);
-const filterCallableCandidates = (candidates, argCount, callForm) => {
-    let kindFiltered;
-    if (callForm === 'constructor') {
-        // For constructor calls, prefer Constructor > Class/Struct/Record > callable fallback
-        const constructors = candidates.filter(c => c.type === 'Constructor');
-        if (constructors.length > 0) {
-            kindFiltered = constructors;
-        }
-        else {
-            const types = candidates.filter(c => CONSTRUCTOR_TARGET_TYPES.has(c.type));
-            kindFiltered = types.length > 0 ? types : candidates.filter(c => CALLABLE_SYMBOL_TYPES.has(c.type));
-        }
-    }
-    else {
-        kindFiltered = candidates.filter(c => CALLABLE_SYMBOL_TYPES.has(c.type));
-    }
-    if (kindFiltered.length === 0)
-        return [];
-    if (argCount === undefined)
-        return kindFiltered;
-    const hasParameterMetadata = kindFiltered.some(candidate => candidate.parameterCount !== undefined);
-    if (!hasParameterMetadata)
-        return kindFiltered;
-    return kindFiltered.filter(candidate => candidate.parameterCount === undefined || candidate.parameterCount === argCount);
-};
-const toResolveResult = (definition, tier) => {
-    if (tier === 'same-file') {
-        return { nodeId: definition.nodeId, confidence: 0.95, reason: 'same-file' };
-    }
-    if (tier === 'import-scoped') {
-        return { nodeId: definition.nodeId, confidence: 0.9, reason: 'import-resolved' };
-    }
-    return { nodeId: definition.nodeId, confidence: 0.5, reason: 'unique-global' };
 };
 /**
  * Resolve a function call to its target node ID using priority strategy:
- * A. Narrow candidates by scope tier (same-file, import-scoped, unique-global)
- * B. Filter to callable symbol kinds (constructor-aware when callForm is set)
- * C. Apply arity filtering when parameter metadata is available
- * D. Apply receiver-type filtering for member calls with typed receivers
+ * A. Check imported files first (highest confidence)
+ * B. Check local file definitions
+ * C. Fuzzy global search (lowest confidence)
  *
- * If filtering still leaves multiple candidates, refuse to emit a CALLS edge.
+ * Returns confidence score so agents know what to trust.
  */
-const resolveCallTarget = (call, currentFile, symbolTable, importMap, packageMap, namedImportMap) => {
-    const tiered = collectTieredCandidates(call.calledName, currentFile, symbolTable, importMap, packageMap, namedImportMap);
-    if (!tiered)
-        return null;
-    const filteredCandidates = filterCallableCandidates(tiered.candidates, call.argCount, call.callForm);
-    // D. Receiver-type filtering: for member calls with a known receiver type,
-    // filter candidates by ownerId matching the resolved type's nodeId
-    if (call.callForm === 'member' && call.receiverTypeName && filteredCandidates.length > 1) {
-        const typeDefs = symbolTable.lookupFuzzy(call.receiverTypeName);
-        if (typeDefs.length > 0) {
-            const typeNodeIds = new Set(typeDefs.map(d => d.nodeId));
-            const ownerFiltered = filteredCandidates.filter(c => c.ownerId && typeNodeIds.has(c.ownerId));
-            if (ownerFiltered.length === 1) {
-                return toResolveResult(ownerFiltered[0], tiered.tier);
+const resolveCallTarget = (calledName, currentFile, symbolTable, importMap) => {
+    // Strategy B first (cheapest — single map lookup): Check local file
+    const localNodeId = symbolTable.lookupExact(currentFile, calledName);
+    if (localNodeId) {
+        return { nodeId: localNodeId, confidence: 0.85, reason: 'same-file' };
+    }
+    // Strategy A: Check if any definition of calledName is in an imported file
+    // Reversed: instead of iterating all imports and checking each, get all definitions
+    // and check if any is imported. O(definitions) instead of O(imports).
+    const allDefs = symbolTable.lookupFuzzy(calledName);
+    if (allDefs.length > 0) {
+        const importedFiles = importMap.get(currentFile);
+        if (importedFiles) {
+            for (const def of allDefs) {
+                if (importedFiles.has(def.filePath)) {
+                    return { nodeId: def.nodeId, confidence: 0.9, reason: 'import-resolved' };
+                }
             }
-            // If receiver filtering narrows to 0, fall through to name-only resolution
-            // If still 2+, refuse (don't guess)
-            if (ownerFiltered.length > 1)
-                return null;
         }
+        // Strategy C: Fuzzy global (no import match found)
+        const confidence = allDefs.length === 1 ? 0.5 : 0.3;
+        return { nodeId: allDefs[0].nodeId, confidence, reason: 'fuzzy-global' };
     }
-    if (filteredCandidates.length !== 1)
-        return null;
-    return toResolveResult(filteredCandidates[0], tiered.tier);
+    return null;
 };
+/**
+ * Filter out common built-in functions and noise
+ * that shouldn't be tracked as calls
+ */
+/** Pre-built set (module-level singleton) to avoid re-creating per call */
+const BUILT_IN_NAMES = new Set([
+    // JavaScript/TypeScript built-ins
+    'console', 'log', 'warn', 'error', 'info', 'debug',
+    'setTimeout', 'setInterval', 'clearTimeout', 'clearInterval',
+    'parseInt', 'parseFloat', 'isNaN', 'isFinite',
+    'encodeURI', 'decodeURI', 'encodeURIComponent', 'decodeURIComponent',
+    'JSON', 'parse', 'stringify',
+    'Object', 'Array', 'String', 'Number', 'Boolean', 'Symbol', 'BigInt',
+    'Map', 'Set', 'WeakMap', 'WeakSet',
+    'Promise', 'resolve', 'reject', 'then', 'catch', 'finally',
+    'Math', 'Date', 'RegExp', 'Error',
+    'require', 'import', 'export',
+    'fetch', 'Response', 'Request',
+    // React hooks and common functions
+    'useState', 'useEffect', 'useCallback', 'useMemo', 'useRef', 'useContext',
+    'useReducer', 'useLayoutEffect', 'useImperativeHandle', 'useDebugValue',
+    'createElement', 'createContext', 'createRef', 'forwardRef', 'memo', 'lazy',
+    // Common array/object methods
+    'map', 'filter', 'reduce', 'forEach', 'find', 'findIndex', 'some', 'every',
+    'includes', 'indexOf', 'slice', 'splice', 'concat', 'join', 'split',
+    'push', 'pop', 'shift', 'unshift', 'sort', 'reverse',
+    'keys', 'values', 'entries', 'assign', 'freeze', 'seal',
+    'hasOwnProperty', 'toString', 'valueOf',
+    // Python built-ins
+    'print', 'len', 'range', 'str', 'int', 'float', 'list', 'dict', 'set', 'tuple',
+    'open', 'read', 'write', 'close', 'append', 'extend', 'update',
+    'super', 'type', 'isinstance', 'issubclass', 'getattr', 'setattr', 'hasattr',
+    'enumerate', 'zip', 'sorted', 'reversed', 'min', 'max', 'sum', 'abs',
+    // Kotlin stdlib (IMPORTANT: keep in sync with parse-worker.ts BUILT_IN_NAMES)
+    'println', 'print', 'readLine', 'require', 'requireNotNull', 'check', 'assert', 'lazy', 'error',
+    'listOf', 'mapOf', 'setOf', 'mutableListOf', 'mutableMapOf', 'mutableSetOf',
+    'arrayOf', 'sequenceOf', 'also', 'apply', 'run', 'with', 'takeIf', 'takeUnless',
+    'TODO', 'buildString', 'buildList', 'buildMap', 'buildSet',
+    'repeat', 'synchronized',
+    // Kotlin coroutine builders & scope functions
+    'launch', 'async', 'runBlocking', 'withContext', 'coroutineScope',
+    'supervisorScope', 'delay',
+    // Kotlin Flow operators
+    'flow', 'flowOf', 'collect', 'emit', 'onEach', 'catch',
+    'buffer', 'conflate', 'distinctUntilChanged',
+    'flatMapLatest', 'flatMapMerge', 'combine',
+    'stateIn', 'shareIn', 'launchIn',
+    // Kotlin infix stdlib functions
+    'to', 'until', 'downTo', 'step',
+    // C/C++ standard library and common kernel helpers
+    'printf', 'fprintf', 'sprintf', 'snprintf', 'vprintf', 'vfprintf', 'vsprintf', 'vsnprintf',
+    'scanf', 'fscanf', 'sscanf',
+    'malloc', 'calloc', 'realloc', 'free', 'memcpy', 'memmove', 'memset', 'memcmp',
+    'strlen', 'strcpy', 'strncpy', 'strcat', 'strncat', 'strcmp', 'strncmp', 'strstr', 'strchr', 'strrchr',
+    'atoi', 'atol', 'atof', 'strtol', 'strtoul', 'strtoll', 'strtoull', 'strtod',
+    'sizeof', 'offsetof', 'typeof',
+    'assert', 'abort', 'exit', '_exit',
+    'fopen', 'fclose', 'fread', 'fwrite', 'fseek', 'ftell', 'rewind', 'fflush', 'fgets', 'fputs',
+    // Linux kernel common macros/helpers (not real call targets)
+    'likely', 'unlikely', 'BUG', 'BUG_ON', 'WARN', 'WARN_ON', 'WARN_ONCE',
+    'IS_ERR', 'PTR_ERR', 'ERR_PTR', 'IS_ERR_OR_NULL',
+    'ARRAY_SIZE', 'container_of', 'list_for_each_entry', 'list_for_each_entry_safe',
+    'min', 'max', 'clamp', 'abs', 'swap',
+    'pr_info', 'pr_warn', 'pr_err', 'pr_debug', 'pr_notice', 'pr_crit', 'pr_emerg',
+    'printk', 'dev_info', 'dev_warn', 'dev_err', 'dev_dbg',
+    'GFP_KERNEL', 'GFP_ATOMIC',
+    'spin_lock', 'spin_unlock', 'spin_lock_irqsave', 'spin_unlock_irqrestore',
+    'mutex_lock', 'mutex_unlock', 'mutex_init',
+    'kfree', 'kmalloc', 'kzalloc', 'kcalloc', 'krealloc', 'kvmalloc', 'kvfree',
+    'get', 'put',
+    // Swift/iOS built-ins and standard library
+    'print', 'debugPrint', 'dump', 'fatalError', 'precondition', 'preconditionFailure',
+    'assert', 'assertionFailure', 'NSLog',
+    'abs', 'min', 'max', 'zip', 'stride', 'sequence', 'repeatElement',
+    'swap', 'withUnsafePointer', 'withUnsafeMutablePointer', 'withUnsafeBytes',
+    'autoreleasepool', 'unsafeBitCast', 'unsafeDowncast', 'numericCast',
+    'type', 'MemoryLayout',
+    // Swift collection/string methods (common noise)
+    'map', 'flatMap', 'compactMap', 'filter', 'reduce', 'forEach', 'contains',
+    'first', 'last', 'prefix', 'suffix', 'dropFirst', 'dropLast',
+    'sorted', 'reversed', 'enumerated', 'joined', 'split',
+    'append', 'insert', 'remove', 'removeAll', 'removeFirst', 'removeLast',
+    'isEmpty', 'count', 'index', 'startIndex', 'endIndex',
+    // UIKit/Foundation common methods (noise in call graph)
+    'addSubview', 'removeFromSuperview', 'layoutSubviews', 'setNeedsLayout',
+    'layoutIfNeeded', 'setNeedsDisplay', 'invalidateIntrinsicContentSize',
+    'addTarget', 'removeTarget', 'addGestureRecognizer',
+    'addConstraint', 'addConstraints', 'removeConstraint', 'removeConstraints',
+    'NSLocalizedString', 'Bundle',
+    'reloadData', 'reloadSections', 'reloadRows', 'performBatchUpdates',
+    'register', 'dequeueReusableCell', 'dequeueReusableSupplementaryView',
+    'beginUpdates', 'endUpdates', 'insertRows', 'deleteRows', 'insertSections', 'deleteSections',
+    'present', 'dismiss', 'pushViewController', 'popViewController', 'popToRootViewController',
+    'performSegue', 'prepare',
+    // GCD / async
+    'DispatchQueue', 'async', 'sync', 'asyncAfter',
+    'Task', 'withCheckedContinuation', 'withCheckedThrowingContinuation',
+    // Combine
+    'sink', 'store', 'assign', 'receive', 'subscribe',
+    // Notification / KVO
+    'addObserver', 'removeObserver', 'post', 'NotificationCenter',
+]);
+const isBuiltInOrNoise = (name) => BUILT_IN_NAMES.has(name);
 /**
  * Fast path: resolve pre-extracted call sites from workers.
  * No AST parsing — workers already extracted calledName + sourceId.
  * This function only does symbol table lookups + graph mutations.
  */
-export const processCallsFromExtracted = async (graph, extractedCalls, symbolTable, importMap, packageMap, onProgress, namedImportMap) => {
+export const processCallsFromExtracted = async (graph, extractedCalls, symbolTable, importMap, onProgress) => {
     // Group by file for progress reporting
     const byFile = new Map();
     for (const call of extractedCalls) {
@@ -276,7 +366,7 @@ export const processCallsFromExtracted = async (graph, extractedCalls, symbolTab
             await yieldToEventLoop();
         }
         for (const call of calls) {
-            const resolved = resolveCallTarget(call, call.filePath, symbolTable, importMap, packageMap, namedImportMap);
+            const resolved = resolveCallTarget(call.calledName, call.filePath, symbolTable, importMap);
             if (!resolved)
                 continue;
             const relId = generateId('CALLS', `${call.sourceId}:${call.calledName}->${resolved.nodeId}`);
@@ -295,7 +385,7 @@ export const processCallsFromExtracted = async (graph, extractedCalls, symbolTab
 /**
  * Resolve pre-extracted Laravel routes to CALLS edges from route files to controller methods.
  */
-export const processRoutesFromExtracted = async (graph, extractedRoutes, symbolTable, importMap, packageMap, onProgress) => {
+export const processRoutesFromExtracted = async (graph, extractedRoutes, symbolTable, importMap, onProgress) => {
     for (let i = 0; i < extractedRoutes.length; i++) {
         const route = extractedRoutes[i];
         if (i % 50 === 0) {
@@ -304,16 +394,23 @@ export const processRoutesFromExtracted = async (graph, extractedRoutes, symbolT
         }
         if (!route.controllerName || !route.methodName)
             continue;
-        // Resolve controller class using shared resolver (Tier 1: same file,
-        // Tier 2: import-scoped, Tier 3: unique global).
-        const resolution = resolveSymbolInternal(route.controllerName, route.filePath, symbolTable, importMap, packageMap);
-        if (!resolution)
+        // Resolve controller class in symbol table
+        const controllerDefs = symbolTable.lookupFuzzy(route.controllerName);
+        if (controllerDefs.length === 0)
             continue;
-        const controllerDef = resolution.definition;
-        // Derive confidence from the resolution tier
-        const confidence = resolution.tier === 'same-file' ? 0.95
-            : resolution.tier === 'import-scoped' ? 0.9
-                : 0.7;
+        // Prefer import-resolved match
+        const importedFiles = importMap.get(route.filePath);
+        let controllerDef = controllerDefs[0];
+        let confidence = controllerDefs.length === 1 ? 0.7 : 0.5;
+        if (importedFiles) {
+            for (const def of controllerDefs) {
+                if (importedFiles.has(def.filePath)) {
+                    controllerDef = def;
+                    confidence = 0.9;
+                    break;
+                }
+            }
+        }
         // Find the method on the controller
         const methodId = symbolTable.lookupExact(controllerDef.filePath, route.methodName);
         const sourceId = generateId('File', route.filePath);
@@ -343,15 +440,3 @@ export const processRoutesFromExtracted = async (graph, extractedRoutes, symbolT
     }
     onProgress?.(extractedRoutes.length, extractedRoutes.length);
 };
-/**
- * Follow re-export chains through NamedImportMap for call candidate collection.
- * Delegates chain-walking to the shared walkBindingChain utility, then
- * applies call-processor semantics: any number of matches accepted.
- */
-const resolveNamedBindingChainForCandidates = (calledName, currentFile, symbolTable, namedImportMap, allDefs) => {
-    const defs = walkBindingChain(calledName, currentFile, symbolTable, namedImportMap, allDefs);
-    if (defs && defs.length > 0) {
-        return { candidates: defs, tier: 'import-scoped' };
-    }
-    return null;
-};

package/dist/core/ingestion/cluster-enricher.js

@@ -13,12 +13,12 @@ const buildEnrichmentPrompt = (members, heuristicLabel) => {
     const memberList = limitedMembers
         .map(m => `${m.name} (${m.type})`)
         .join(', ');
-    return `Analyze this code cluster and provide a semantic name and short description.
-
-Heuristic: "${heuristicLabel}"
-Members: ${memberList}${members.length > 20 ? ` (+${members.length - 20} more)` : ''}
-
-Reply with JSON only:
+    return `Analyze this code cluster and provide a semantic name and short description.
+
+Heuristic: "${heuristicLabel}"
+Members: ${memberList}${members.length > 20 ? ` (+${members.length - 20} more)` : ''}
+
+Reply with JSON only:
 {"name": "2-4 word semantic name", "description": "One sentence describing purpose"}`;
 };
 // ============================================================================
@@ -115,18 +115,18 @@ export const enrichClustersBatch = async (communities, memberMap, llmClient, bat
             const memberList = limitedMembers
                 .map(m => `${m.name} (${m.type})`)
                 .join(', ');
-            return `Cluster ${idx + 1} (id: ${community.id}):
-Heuristic: "${community.heuristicLabel}"
+            return `Cluster ${idx + 1} (id: ${community.id}):
+Heuristic: "${community.heuristicLabel}"
 Members: ${memberList}`;
         }).join('\n\n');
-        const prompt = `Analyze these code clusters and generate semantic names, keywords, and descriptions.
-
-${batchPrompt}
-
-Output JSON array:
-[
-  {"id": "comm_X", "name": "...", "keywords": [...], "description": "..."},
-  ...
+        const prompt = `Analyze these code clusters and generate semantic names, keywords, and descriptions.
+
+${batchPrompt}
+
+Output JSON array:
+[
+  {"id": "comm_X", "name": "...", "keywords": [...], "description": "..."},
+  ...
 ]`;
         try {
             const response = await llmClient.generate(prompt);

package/dist/core/ingestion/entry-point-scoring.d.ts

@@ -9,7 +9,6 @@
  *
  * This module is language-agnostic - language-specific patterns are defined per language.
  */
-import { SupportedLanguages } from '../../config/supported-languages.js';
 export interface EntryPointScoreResult {
     score: number;
     reasons: string[];
@@ -27,7 +26,7 @@ export interface EntryPointScoreResult {
  * @param calleeCount - Number of functions this function calls
  * @returns Score and array of reasons explaining the score
  */
-export declare function calculateEntryPointScore(name: string, language: SupportedLanguages, isExported: boolean, callerCount: number, calleeCount: number, filePath?: string): EntryPointScoreResult;
+export declare function calculateEntryPointScore(name: string, language: string, isExported: boolean, callerCount: number, calleeCount: number, filePath?: string): EntryPointScoreResult;
 /**
  * Check if a file path is a test file (should be excluded from entry points)
  * Covers common test file patterns across all supported languages