gitnexus 1.3.11 → 1.4.0

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

@@ -1,44 +1,13 @@
+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 { loadParser, loadLanguage } from '../tree-sitter/parser-loader.js';
+import { isLanguageAvailable, loadParser, loadLanguage } from '../tree-sitter/parser-loader.js';
 import { LANGUAGE_QUERIES } from './tree-sitter-queries.js';
 import { generateId } from '../../lib/utils.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',
-]);
+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';
 /**
  * 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).
@@ -47,88 +16,22 @@ const findEnclosingFunction = (node, filePath, symbolTable) => {
     let current = node.parent;
     while (current) {
         if (FUNCTION_NODE_TYPES.has(current.type)) {
-            // 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';
-                return generateId('Constructor', `${filePath}:${funcName}`);
-            }
-            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;
-                }
-            }
+            const { funcName, label } = extractFunctionName(current);
             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;
-                // Try construct ID manually if lookup fails (common for non-exported internal functions)
-                // Format should match what parsing-processor generates: "Function:path/to/file:funcName"
-                // Check if we already have a node with this ID in the symbol table to be safe
-                const generatedId = generateId(label, `${filePath}:${funcName}`);
-                // Ideally we should verify this ID exists, but strictly speaking if we are inside it,
-                // it SHOULD exist. Returning it is better than falling back to File.
-                return generatedId;
+                return generateId(label, `${filePath}:${funcName}`);
             }
-            // Couldn't determine function name - try parent (might be nested)
         }
         current = current.parent;
     }
-    return null; // Top-level call (not inside any function)
+    return null;
 };
-export const processCalls = async (graph, files, astCache, symbolTable, importMap, onProgress) => {
+export const processCalls = async (graph, files, astCache, symbolTable, importMap, packageMap, onProgress, namedImportMap) => {
     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);
@@ -138,6 +41,12 @@ 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;
@@ -150,7 +59,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: 1024 * 256 });
+                tree = parser.parse(file.content, undefined, { bufferSize: getTreeSitterBufferSize(file.content.length) });
             }
             catch (parseError) {
                 // Skip files that can't be parsed
@@ -171,6 +80,9 @@ 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 = {};
@@ -185,12 +97,20 @@ 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, file.path, symbolTable, importMap);
+            const resolved = resolveCallTarget({
+                calledName,
+                argCount: countCallArguments(callNode),
+                callForm,
+                receiverTypeName,
+            }, file.path, symbolTable, importMap, packageMap, namedImportMap);
             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);
@@ -206,149 +126,137 @@ 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. Check imported files first (highest confidence)
- * B. Check local file definitions
- * C. Fuzzy global search (lowest confidence)
+ * 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
  *
- * Returns confidence score so agents know what to trust.
+ * If filtering still leaves multiple candidates, refuse to emit a CALLS edge.
  */
-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' };
-                }
+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);
             }
+            // 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' };
     }
-    return null;
+    if (filteredCandidates.length !== 1)
+        return null;
+    return toResolveResult(filteredCandidates[0], tiered.tier);
 };
-/**
- * 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, onProgress) => {
+export const processCallsFromExtracted = async (graph, extractedCalls, symbolTable, importMap, packageMap, onProgress, namedImportMap) => {
     // Group by file for progress reporting
     const byFile = new Map();
     for (const call of extractedCalls) {
@@ -368,7 +276,7 @@ export const processCallsFromExtracted = async (graph, extractedCalls, symbolTab
             await yieldToEventLoop();
         }
         for (const call of calls) {
-            const resolved = resolveCallTarget(call.calledName, call.filePath, symbolTable, importMap);
+            const resolved = resolveCallTarget(call, call.filePath, symbolTable, importMap, packageMap, namedImportMap);
             if (!resolved)
                 continue;
             const relId = generateId('CALLS', `${call.sourceId}:${call.calledName}->${resolved.nodeId}`);
@@ -387,7 +295,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, onProgress) => {
+export const processRoutesFromExtracted = async (graph, extractedRoutes, symbolTable, importMap, packageMap, onProgress) => {
     for (let i = 0; i < extractedRoutes.length; i++) {
         const route = extractedRoutes[i];
         if (i % 50 === 0) {
@@ -396,23 +304,16 @@ export const processRoutesFromExtracted = async (graph, extractedRoutes, symbolT
         }
         if (!route.controllerName || !route.methodName)
             continue;
-        // Resolve controller class in symbol table
-        const controllerDefs = symbolTable.lookupFuzzy(route.controllerName);
-        if (controllerDefs.length === 0)
+        // 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)
             continue;
-        // 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;
-                }
-            }
-        }
+        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;
         // Find the method on the controller
         const methodId = symbolTable.lookupExact(controllerDef.filePath, route.methodName);
         const sourceId = generateId('File', route.filePath);
@@ -442,3 +343,15 @@ 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/constants.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Default minimum buffer size for tree-sitter parsing (512 KB).
+ * tree-sitter requires bufferSize >= file size in bytes.
+ */
+export declare const TREE_SITTER_BUFFER_SIZE: number;
+/**
+ * Maximum buffer size cap (32 MB) to prevent OOM on huge files.
+ * Also used as the file-size skip threshold — files larger than this are not parsed.
+ */
+export declare const TREE_SITTER_MAX_BUFFER: number;
+/**
+ * Compute adaptive buffer size for tree-sitter parsing.
+ * Uses 2× file size, clamped between 512 KB and 32 MB.
+ * Previous 256 KB fixed limit silently skipped files > ~200 KB (e.g., imgui.h at 411 KB).
+ */
+export declare const getTreeSitterBufferSize: (contentLength: number) => number;

package/dist/core/ingestion/constants.js

@@ -0,0 +1,16 @@
+/**
+ * Default minimum buffer size for tree-sitter parsing (512 KB).
+ * tree-sitter requires bufferSize >= file size in bytes.
+ */
+export const TREE_SITTER_BUFFER_SIZE = 512 * 1024;
+/**
+ * Maximum buffer size cap (32 MB) to prevent OOM on huge files.
+ * Also used as the file-size skip threshold — files larger than this are not parsed.
+ */
+export const TREE_SITTER_MAX_BUFFER = 32 * 1024 * 1024;
+/**
+ * Compute adaptive buffer size for tree-sitter parsing.
+ * Uses 2× file size, clamped between 512 KB and 32 MB.
+ * Previous 256 KB fixed limit silently skipped files > ~200 KB (e.g., imgui.h at 411 KB).
+ */
+export const getTreeSitterBufferSize = (contentLength) => Math.min(Math.max(contentLength * 2, TREE_SITTER_BUFFER_SIZE), TREE_SITTER_MAX_BUFFER);

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

@@ -9,6 +9,7 @@
  *
  * 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[];
@@ -26,7 +27,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: string, isExported: boolean, callerCount: number, calleeCount: number, filePath?: string): EntryPointScoreResult;
+export declare function calculateEntryPointScore(name: string, language: SupportedLanguages, 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