gitnexus 1.4.1 → 1.4.5

package/dist/core/ingestion/workers/parse-worker.js

@@ -9,11 +9,12 @@ import CPP from 'tree-sitter-cpp';
 import CSharp from 'tree-sitter-c-sharp';
 import Go from 'tree-sitter-go';
 import Rust from 'tree-sitter-rust';
-import Kotlin from 'tree-sitter-kotlin';
 import PHP from 'tree-sitter-php';
+import Ruby from 'tree-sitter-ruby';
 import { createRequire } from 'node:module';
 import { SupportedLanguages } from '../../../config/supported-languages.js';
 import { LANGUAGE_QUERIES } from '../tree-sitter-queries.js';
+import { getTreeSitterBufferSize, TREE_SITTER_MAX_BUFFER } from '../constants.js';
 // tree-sitter-swift is an optionalDependency — may not be installed
 const _require = createRequire(import.meta.url);
 let Swift = null;
@@ -21,9 +22,21 @@ try {
     Swift = _require('tree-sitter-swift');
 }
 catch { }
-import { findSiblingChild, getLanguageFromFilename } from '../utils.js';
+// tree-sitter-kotlin is an optionalDependency — may not be installed
+let Kotlin = null;
+try {
+    Kotlin = _require('tree-sitter-kotlin');
+}
+catch { }
+import { getLanguageFromFilename, FUNCTION_NODE_TYPES, extractFunctionName, isBuiltInOrNoise, getDefinitionNodeFromCaptures, findEnclosingClassId, extractMethodSignature, countCallArguments, inferCallForm, extractReceiverName, extractReceiverNode, CALL_EXPRESSION_TYPES, extractCallChain, } from '../utils.js';
+import { buildTypeEnv } from '../type-env.js';
+import { isNodeExported } from '../export-detection.js';
 import { detectFrameworkFromAST } from '../framework-detection.js';
+import { typeConfigs } from '../type-extractors/index.js';
 import { generateId } from '../../../lib/utils.js';
+import { extractNamedBindings } from '../named-binding-extraction.js';
+import { appendKotlinWildcard } from '../resolvers/index.js';
+import { callRouters } from '../call-routing.js';
 // ============================================================================
 // Worker-local parser + language map
 // ============================================================================
@@ -39,10 +52,23 @@ const languageMap = {
     [SupportedLanguages.CSharp]: CSharp,
     [SupportedLanguages.Go]: Go,
     [SupportedLanguages.Rust]: Rust,
-    [SupportedLanguages.Kotlin]: Kotlin,
+    ...(Kotlin ? { [SupportedLanguages.Kotlin]: Kotlin } : {}),
     [SupportedLanguages.PHP]: PHP.php_only,
+    [SupportedLanguages.Ruby]: Ruby,
     ...(Swift ? { [SupportedLanguages.Swift]: Swift } : {}),
 };
+/**
+ * Check if a language grammar is available in this worker.
+ * Duplicated from parser-loader.ts because workers can't import from the main thread.
+ * Extra filePath parameter needed to distinguish .tsx from .ts (different grammars
+ * under the same SupportedLanguages.TypeScript key).
+ */
+const isLanguageAvailable = (language, filePath) => {
+    const key = language === SupportedLanguages.TypeScript && filePath.endsWith('.tsx')
+        ? `${language}:tsx`
+        : language;
+    return key in languageMap && languageMap[key] != null;
+};
 const setLanguage = (language, filePath) => {
     const key = language === SupportedLanguages.TypeScript && filePath.endsWith('.tsx')
         ? `${language}:tsx`
@@ -52,307 +78,24 @@ const setLanguage = (language, filePath) => {
         throw new Error(`Unsupported language: ${language}`);
     parser.setLanguage(lang);
 };
-// ============================================================================
-// Export detection (copied — needs AST parent traversal, can't cross threads)
-// ============================================================================
-const isNodeExported = (node, name, language) => {
-    let current = node;
-    switch (language) {
-        case 'javascript':
-        case 'typescript':
-            while (current) {
-                const type = current.type;
-                if (type === 'export_statement' ||
-                    type === 'export_specifier' ||
-                    type === 'lexical_declaration' && current.parent?.type === 'export_statement') {
-                    return true;
-                }
-                if (current.text?.startsWith('export ')) {
-                    return true;
-                }
-                current = current.parent;
-            }
-            return false;
-        case 'python':
-            return !name.startsWith('_');
-        case 'java':
-            while (current) {
-                if (current.parent) {
-                    const parent = current.parent;
-                    for (let i = 0; i < parent.childCount; i++) {
-                        const child = parent.child(i);
-                        if (child?.type === 'modifiers' && child.text?.includes('public')) {
-                            return true;
-                        }
-                    }
-                    if (parent.type === 'method_declaration' || parent.type === 'constructor_declaration') {
-                        if (parent.text?.trimStart().startsWith('public')) {
-                            return true;
-                        }
-                    }
-                }
-                current = current.parent;
-            }
-            return false;
-        case 'csharp':
-            while (current) {
-                if (current.type === 'modifier' || current.type === 'modifiers') {
-                    if (current.text?.includes('public'))
-                        return true;
-                }
-                current = current.parent;
-            }
-            return false;
-        case 'go':
-            if (name.length === 0)
-                return false;
-            const first = name[0];
-            return first === first.toUpperCase() && first !== first.toLowerCase();
-        case 'rust':
-            while (current) {
-                if (current.type === 'visibility_modifier') {
-                    if (current.text?.includes('pub'))
-                        return true;
-                }
-                current = current.parent;
-            }
-            return false;
-        // Kotlin: Default visibility is public (unlike Java)
-        // visibility_modifier is inside modifiers, a sibling of the name node within the declaration
-        case 'kotlin':
-            while (current) {
-                if (current.parent) {
-                    const visMod = findSiblingChild(current.parent, 'modifiers', 'visibility_modifier');
-                    if (visMod) {
-                        const text = visMod.text;
-                        if (text === 'private' || text === 'internal' || text === 'protected')
-                            return false;
-                        if (text === 'public')
-                            return true;
-                    }
-                }
-                current = current.parent;
-            }
-            // No visibility modifier = public (Kotlin default)
-            return true;
-        case 'c':
-        case 'cpp':
-            return false;
-        case 'php':
-            // Top-level classes/interfaces/traits are always accessible
-            // Methods/properties are exported only if they have 'public' modifier
-            while (current) {
-                if (current.type === 'class_declaration' ||
-                    current.type === 'interface_declaration' ||
-                    current.type === 'trait_declaration' ||
-                    current.type === 'enum_declaration') {
-                    return true;
-                }
-                if (current.type === 'visibility_modifier') {
-                    return current.text === 'public';
-                }
-                current = current.parent;
-            }
-            // Top-level functions (no parent class) are globally accessible
-            return true;
-        case 'swift':
-            while (current) {
-                if (current.type === 'modifiers' || current.type === 'visibility_modifier') {
-                    const text = current.text || '';
-                    if (text.includes('public') || text.includes('open'))
-                        return true;
-                }
-                current = current.parent;
-            }
-            return false;
-        default:
-            return false;
-    }
-};
+// isNodeExported imported from ../export-detection.js (shared module)
 // ============================================================================
 // Enclosing function detection (for call extraction)
 // ============================================================================
-const FUNCTION_NODE_TYPES = new Set([
-    'function_declaration', 'arrow_function', 'function_expression',
-    'method_definition', 'generator_function_declaration',
-    'function_definition', 'async_function_declaration', 'async_arrow_function',
-    'method_declaration', 'constructor_declaration',
-    'local_function_statement', 'function_item', 'impl_item',
-    // Kotlin
-    'lambda_literal',
-    // PHP
-    'anonymous_function',
-    // Swift initializers/deinitializers
-    'init_declaration', 'deinit_declaration',
-]);
 /** Walk up AST to find enclosing function, return its generateId or null for top-level */
 const findEnclosingFunctionId = (node, filePath) => {
     let current = node.parent;
     while (current) {
         if (FUNCTION_NODE_TYPES.has(current.type)) {
-            let funcName = null;
-            let label = 'Function';
-            if (current.type === 'init_declaration' || current.type === 'deinit_declaration') {
-                const funcName = current.type === 'init_declaration' ? 'init' : 'deinit';
-                const label = 'Constructor';
-                const startLine = current.startPosition?.row ?? 0;
-                return generateId(label, `${filePath}:${funcName}:${startLine}`);
-            }
-            if (['function_declaration', 'function_definition', 'async_function_declaration',
-                'generator_function_declaration', 'function_item'].includes(current.type)) {
-                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') {
-                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') {
-                const nameNode = current.childForFieldName?.('name') ||
-                    current.children?.find((c) => c.type === 'property_identifier');
-                funcName = nameNode?.text;
-                label = 'Method';
-            }
-            else if (current.type === 'method_declaration' || current.type === 'constructor_declaration') {
-                const nameNode = current.childForFieldName?.('name') ||
-                    current.children?.find((c) => c.type === 'identifier');
-                funcName = nameNode?.text;
-                label = 'Method';
-            }
-            else if (current.type === 'arrow_function' || current.type === 'function_expression') {
-                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) {
-                const startLine = current.startPosition?.row ?? 0;
-                return generateId(label, `${filePath}:${funcName}:${startLine}`);
+                return generateId(label, `${filePath}:${funcName}`);
             }
         }
         current = current.parent;
     }
     return null;
 };
-const BUILT_INS = new Set([
-    // JavaScript/TypeScript
-    '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',
-    'useState', 'useEffect', 'useCallback', 'useMemo', 'useRef', 'useContext',
-    'useReducer', 'useLayoutEffect', 'useImperativeHandle', 'useDebugValue',
-    'createElement', 'createContext', 'createRef', 'forwardRef', 'memo', 'lazy',
-    '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
-    '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 call-processor.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
-    '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',
-    // PHP built-ins
-    'echo', 'isset', 'empty', 'unset', 'list', 'array', 'compact', 'extract',
-    'count', 'strlen', 'strpos', 'strrpos', 'substr', 'strtolower', 'strtoupper', 'trim',
-    'ltrim', 'rtrim', 'str_replace', 'str_contains', 'str_starts_with', 'str_ends_with',
-    'sprintf', 'vsprintf', 'printf', 'number_format',
-    'array_map', 'array_filter', 'array_reduce', 'array_push', 'array_pop', 'array_shift',
-    'array_unshift', 'array_slice', 'array_splice', 'array_merge', 'array_keys', 'array_values',
-    'array_key_exists', 'in_array', 'array_search', 'array_unique', 'usort', 'rsort',
-    'json_encode', 'json_decode', 'serialize', 'unserialize',
-    'intval', 'floatval', 'strval', 'boolval', 'is_null', 'is_string', 'is_int', 'is_array',
-    'is_object', 'is_numeric', 'is_bool', 'is_float',
-    'var_dump', 'print_r', 'var_export',
-    'date', 'time', 'strtotime', 'mktime', 'microtime',
-    'file_exists', 'file_get_contents', 'file_put_contents', 'is_file', 'is_dir',
-    'preg_match', 'preg_match_all', 'preg_replace', 'preg_split',
-    'header', 'session_start', 'session_destroy', 'ob_start', 'ob_end_clean', 'ob_get_clean',
-    'dd', 'dump',
-    // 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',
-]);
 // ============================================================================
 // Label detection from capture map
 // ============================================================================
@@ -408,49 +151,7 @@ const getLabelFromCaptures = (captureMap) => {
         return 'Template';
     return 'CodeElement';
 };
-const DEFINITION_CAPTURE_KEYS = [
-    'definition.function',
-    'definition.class',
-    'definition.interface',
-    'definition.method',
-    'definition.struct',
-    'definition.enum',
-    'definition.namespace',
-    'definition.module',
-    'definition.trait',
-    'definition.impl',
-    'definition.type',
-    'definition.const',
-    'definition.static',
-    'definition.typedef',
-    'definition.macro',
-    'definition.union',
-    'definition.property',
-    'definition.record',
-    'definition.delegate',
-    'definition.annotation',
-    'definition.constructor',
-    'definition.template',
-];
-const getDefinitionNodeFromCaptures = (captureMap) => {
-    for (const key of DEFINITION_CAPTURE_KEYS) {
-        if (captureMap[key])
-            return captureMap[key];
-    }
-    return null;
-};
-/**
- * Append .* to a Kotlin import path if the AST has a wildcard_import sibling node.
- * Pure function — returns a new string without mutating the input.
- */
-const appendKotlinWildcard = (importPath, importNode) => {
-    for (let i = 0; i < importNode.childCount; i++) {
-        if (importNode.child(i)?.type === 'wildcard_import') {
-            return importPath.endsWith('.*') ? importPath : `${importPath}.*`;
-        }
-    }
-    return importPath;
-};
+// DEFINITION_CAPTURE_KEYS and getDefinitionNodeFromCaptures imported from ../utils.js
 // ============================================================================
 // Process a batch of files
 // ============================================================================
@@ -463,6 +164,8 @@ const processBatch = (files, onProgress) => {
         calls: [],
         heritage: [],
         routes: [],
+        constructorBindings: [],
+        skippedLanguages: {},
         fileCount: 0,
     };
     // Group by language to minimize setLanguage calls
@@ -510,22 +213,32 @@ const processBatch = (files, onProgress) => {
         }
         // Process regular files for this language
         if (regularFiles.length > 0) {
-            try {
-                setLanguage(language, regularFiles[0].path);
-                processFileGroup(regularFiles, language, queryString, result, onFileProcessed);
+            if (isLanguageAvailable(language, regularFiles[0].path)) {
+                try {
+                    setLanguage(language, regularFiles[0].path);
+                    processFileGroup(regularFiles, language, queryString, result, onFileProcessed);
+                }
+                catch {
+                    // parser unavailable — skip this language group
+                }
             }
-            catch {
-                // parser unavailable — skip this language group
+            else {
+                result.skippedLanguages[language] = (result.skippedLanguages[language] || 0) + regularFiles.length;
             }
         }
         // Process tsx files separately (different grammar)
         if (tsxFiles.length > 0) {
-            try {
-                setLanguage(language, tsxFiles[0].path);
-                processFileGroup(tsxFiles, language, queryString, result, onFileProcessed);
+            if (isLanguageAvailable(language, tsxFiles[0].path)) {
+                try {
+                    setLanguage(language, tsxFiles[0].path);
+                    processFileGroup(tsxFiles, language, queryString, result, onFileProcessed);
+                }
+                catch {
+                    // parser unavailable — skip this language group
+                }
             }
-            catch {
-                // parser unavailable — skip this language group
+            else {
+                result.skippedLanguages[language] = (result.skippedLanguages[language] || 0) + tsxFiles.length;
             }
         }
     }
@@ -988,27 +701,43 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
         const lang = parser.getLanguage();
         query = new Parser.Query(lang, queryString);
     }
-    catch {
+    catch (err) {
+        const message = `Query compilation failed for ${language}: ${err instanceof Error ? err.message : String(err)}`;
+        if (parentPort) {
+            parentPort.postMessage({ type: 'warning', message });
+        }
+        else {
+            console.warn(message);
+        }
         return;
     }
     for (const file of files) {
-        // Skip very large files — they can crash tree-sitter or cause OOM
-        if (file.content.length > 512 * 1024)
+        // Skip files larger than the max tree-sitter buffer (32 MB)
+        if (file.content.length > TREE_SITTER_MAX_BUFFER)
             continue;
         let tree;
         try {
-            tree = parser.parse(file.content, undefined, { bufferSize: 1024 * 256 });
+            tree = parser.parse(file.content, undefined, { bufferSize: getTreeSitterBufferSize(file.content.length) });
         }
-        catch {
+        catch (err) {
+            console.warn(`Failed to parse file ${file.path}: ${err instanceof Error ? err.message : String(err)}`);
             continue;
         }
         result.fileCount++;
         onFileProcessed?.();
+        // Build per-file type environment + constructor bindings in a single AST walk.
+        // Constructor bindings are verified against the SymbolTable in processCallsFromExtracted.
+        const typeEnv = buildTypeEnv(tree, language);
+        const callRouter = callRouters[language];
+        if (typeEnv.constructorBindings.length > 0) {
+            result.constructorBindings.push({ filePath: file.path, bindings: [...typeEnv.constructorBindings] });
+        }
         let matches;
         try {
             matches = query.matches(tree.rootNode);
         }
-        catch {
+        catch (err) {
+            console.warn(`Query execution failed for ${file.path}: ${err instanceof Error ? err.message : String(err)}`);
             continue;
         }
         for (const match of matches) {
@@ -1021,10 +750,12 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                 const rawImportPath = language === SupportedLanguages.Kotlin
                     ? appendKotlinWildcard(captureMap['import.source'].text.replace(/['"<>]/g, ''), captureMap['import'])
                     : captureMap['import.source'].text.replace(/['"<>]/g, '');
+                const namedBindings = extractNamedBindings(captureMap['import'], language);
                 result.imports.push({
                     filePath: file.path,
                     rawImportPath,
                     language: language,
+                    ...(namedBindings ? { namedBindings } : {}),
                 });
                 continue;
             }
@@ -1033,11 +764,122 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                 const callNameNode = captureMap['call.name'];
                 if (callNameNode) {
                     const calledName = callNameNode.text;
-                    if (!BUILT_INS.has(calledName)) {
+                    // Dispatch: route language-specific calls (heritage, properties, imports)
+                    const routed = callRouter(calledName, captureMap['call']);
+                    if (routed) {
+                        if (routed.kind === 'skip')
+                            continue;
+                        if (routed.kind === 'import') {
+                            result.imports.push({
+                                filePath: file.path,
+                                rawImportPath: routed.importPath,
+                                language,
+                            });
+                            continue;
+                        }
+                        if (routed.kind === 'heritage') {
+                            for (const item of routed.items) {
+                                result.heritage.push({
+                                    filePath: file.path,
+                                    className: item.enclosingClass,
+                                    parentName: item.mixinName,
+                                    kind: item.heritageKind,
+                                });
+                            }
+                            continue;
+                        }
+                        if (routed.kind === 'properties') {
+                            const propEnclosingClassId = findEnclosingClassId(captureMap['call'], file.path);
+                            for (const item of routed.items) {
+                                const nodeId = generateId('Property', `${file.path}:${item.propName}`);
+                                result.nodes.push({
+                                    id: nodeId,
+                                    label: 'Property',
+                                    properties: {
+                                        name: item.propName,
+                                        filePath: file.path,
+                                        startLine: item.startLine,
+                                        endLine: item.endLine,
+                                        language,
+                                        isExported: true,
+                                        description: item.accessorType,
+                                    },
+                                });
+                                result.symbols.push({
+                                    filePath: file.path,
+                                    name: item.propName,
+                                    nodeId,
+                                    type: 'Property',
+                                    ...(propEnclosingClassId ? { ownerId: propEnclosingClassId } : {}),
+                                });
+                                const fileId = generateId('File', file.path);
+                                const relId = generateId('DEFINES', `${fileId}->${nodeId}`);
+                                result.relationships.push({
+                                    id: relId,
+                                    sourceId: fileId,
+                                    targetId: nodeId,
+                                    type: 'DEFINES',
+                                    confidence: 1.0,
+                                    reason: '',
+                                });
+                                if (propEnclosingClassId) {
+                                    result.relationships.push({
+                                        id: generateId('HAS_METHOD', `${propEnclosingClassId}->${nodeId}`),
+                                        sourceId: propEnclosingClassId,
+                                        targetId: nodeId,
+                                        type: 'HAS_METHOD',
+                                        confidence: 1.0,
+                                        reason: '',
+                                    });
+                                }
+                            }
+                            continue;
+                        }
+                        // kind === 'call' — fall through to normal call processing below
+                    }
+                    if (!isBuiltInOrNoise(calledName)) {
                         const callNode = captureMap['call'];
                         const sourceId = findEnclosingFunctionId(callNode, file.path)
                             || generateId('File', file.path);
-                        result.calls.push({ filePath: file.path, calledName, sourceId });
+                        const callForm = inferCallForm(callNode, callNameNode);
+                        let receiverName = callForm === 'member' ? extractReceiverName(callNameNode) : undefined;
+                        let receiverTypeName = receiverName ? typeEnv.lookup(receiverName, callNode) : undefined;
+                        let receiverCallChain;
+                        // When the receiver is a call_expression (e.g. svc.getUser().save()),
+                        // extractReceiverName returns undefined because it refuses complex expressions.
+                        // Instead, walk the receiver node to build a call chain for deferred resolution.
+                        // We capture the base receiver name so processCallsFromExtracted can look it up
+                        // from constructor bindings. receiverTypeName is intentionally left unset here —
+                        // the chain resolver in processCallsFromExtracted needs the base type as input and
+                        // produces the final receiver type as output.
+                        if (callForm === 'member' && receiverName === undefined && !receiverTypeName) {
+                            const receiverNode = extractReceiverNode(callNameNode);
+                            if (receiverNode && CALL_EXPRESSION_TYPES.has(receiverNode.type)) {
+                                const extracted = extractCallChain(receiverNode);
+                                if (extracted) {
+                                    receiverCallChain = extracted.chain;
+                                    // Set receiverName to the base object so Step 1 in processCallsFromExtracted
+                                    // can resolve it via constructor bindings to a base type for the chain.
+                                    receiverName = extracted.baseReceiverName;
+                                    // Also try the type environment immediately (covers explicitly-typed locals
+                                    // and annotated parameters like `fn process(svc: &UserService)`).
+                                    // This sets a base type that chain resolution (Step 2) will use as input.
+                                    if (receiverName) {
+                                        receiverTypeName = typeEnv.lookup(receiverName, callNode);
+                                    }
+                                }
+                            }
+                        }
+                        result.calls.push({
+                            filePath: file.path,
+                            calledName,
+                            sourceId,
+                            argCount: countCallArguments(callNode),
+                            ...(callForm !== undefined ? { callForm } : {}),
+                            ...(receiverName !== undefined ? { receiverName } : {}),
+                            ...(receiverTypeName !== undefined ? { receiverTypeName } : {}),
+                            ...(receiverCallChain !== undefined ? { receiverCallChain } : {}),
+                        });
                     }
                 }
                 continue;
@@ -1045,12 +887,21 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
             // Extract heritage (extends/implements)
             if (captureMap['heritage.class']) {
                 if (captureMap['heritage.extends']) {
-                    result.heritage.push({
-                        filePath: file.path,
-                        className: captureMap['heritage.class'].text,
-                        parentName: captureMap['heritage.extends'].text,
-                        kind: 'extends',
-                    });
+                    // Go struct embedding: the query matches ALL field_declarations with
+                    // type_identifier, but only anonymous fields (no name) are embedded.
+                    // Named fields like `Breed string` also match — skip them.
+                    const extendsNode = captureMap['heritage.extends'];
+                    const fieldDecl = extendsNode.parent;
+                    const isNamedField = fieldDecl?.type === 'field_declaration'
+                        && fieldDecl.childForFieldName('name');
+                    if (!isNamedField) {
+                        result.heritage.push({
+                            filePath: file.path,
+                            className: captureMap['heritage.class'].text,
+                            parentName: captureMap['heritage.extends'].text,
+                            kind: 'extends',
+                        });
+                    }
                 }
                 if (captureMap['heritage.implements']) {
                     result.heritage.push({
@@ -1082,7 +933,7 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
             const nodeName = nameNode ? nameNode.text : 'init';
             const definitionNode = getDefinitionNodeFromCaptures(captureMap);
             const startLine = definitionNode ? definitionNode.startPosition.row : (nameNode ? nameNode.startPosition.row : 0);
-            const nodeId = generateId(nodeLabel, `${file.path}:${nodeName}:${startLine}`);
+            const nodeId = generateId(nodeLabel, `${file.path}:${nodeName}`);
             let description;
             if (language === SupportedLanguages.PHP) {
                 if (nodeLabel === 'Property' && captureMap['definition.property']) {
@@ -1095,6 +946,20 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
             const frameworkHint = definitionNode
                 ? detectFrameworkFromAST(language, (definitionNode.text || '').slice(0, 300))
                 : null;
+            let parameterCount;
+            let returnType;
+            if (nodeLabel === 'Function' || nodeLabel === 'Method' || nodeLabel === 'Constructor') {
+                const sig = extractMethodSignature(definitionNode);
+                parameterCount = sig.parameterCount;
+                returnType = sig.returnType;
+                // Language-specific return type fallback (e.g. Ruby YARD @return [Type])
+                if (!returnType && definitionNode) {
+                    const tc = typeConfigs[language];
+                    if (tc?.extractReturnType) {
+                        returnType = tc.extractReturnType(definitionNode);
+                    }
+                }
+            }
             result.nodes.push({
                 id: nodeId,
                 label: nodeLabel,
@@ -1110,13 +975,22 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                         astFrameworkReason: frameworkHint.reason,
                     } : {}),
                     ...(description !== undefined ? { description } : {}),
+                    ...(parameterCount !== undefined ? { parameterCount } : {}),
+                    ...(returnType !== undefined ? { returnType } : {}),
                 },
             });
+            // Compute enclosing class for Method/Constructor/Property/Function — used for both ownerId and HAS_METHOD
+            // Function is included because Kotlin/Rust/Python capture class methods as Function nodes
+            const needsOwner = nodeLabel === 'Method' || nodeLabel === 'Constructor' || nodeLabel === 'Property' || nodeLabel === 'Function';
+            const enclosingClassId = needsOwner ? findEnclosingClassId(nameNode || definitionNode, file.path) : null;
             result.symbols.push({
                 filePath: file.path,
                 name: nodeName,
                 nodeId,
                 type: nodeLabel,
+                ...(parameterCount !== undefined ? { parameterCount } : {}),
+                ...(returnType !== undefined ? { returnType } : {}),
+                ...(enclosingClassId ? { ownerId: enclosingClassId } : {}),
             });
             const fileId = generateId('File', file.path);
             const relId = generateId('DEFINES', `${fileId}->${nodeId}`);
@@ -1128,6 +1002,17 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                 confidence: 1.0,
                 reason: '',
             });
+            // ── HAS_METHOD: link method/constructor/property to enclosing class ──
+            if (enclosingClassId) {
+                result.relationships.push({
+                    id: generateId('HAS_METHOD', `${enclosingClassId}->${nodeId}`),
+                    sourceId: enclosingClassId,
+                    targetId: nodeId,
+                    type: 'HAS_METHOD',
+                    confidence: 1.0,
+                    reason: '',
+                });
+            }
         }
         // Extract Laravel routes from route files via procedural AST walk
         if (language === SupportedLanguages.PHP && (file.path.includes('/routes/') || file.path.startsWith('routes/')) && file.path.endsWith('.php')) {
@@ -1142,7 +1027,7 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
 /** Accumulated result across sub-batches */
 let accumulated = {
     nodes: [], relationships: [], symbols: [],
-    imports: [], calls: [], heritage: [], routes: [], fileCount: 0,
+    imports: [], calls: [], heritage: [], routes: [], constructorBindings: [], skippedLanguages: {}, fileCount: 0,
 };
 let cumulativeProcessed = 0;
 const mergeResult = (target, src) => {
@@ -1153,6 +1038,10 @@ const mergeResult = (target, src) => {
     target.calls.push(...src.calls);
     target.heritage.push(...src.heritage);
     target.routes.push(...src.routes);
+    target.constructorBindings.push(...src.constructorBindings);
+    for (const [lang, count] of Object.entries(src.skippedLanguages)) {
+        target.skippedLanguages[lang] = (target.skippedLanguages[lang] || 0) + count;
+    }
     target.fileCount += src.fileCount;
 };
 parentPort.on('message', (msg) => {
@@ -1172,7 +1061,7 @@ parentPort.on('message', (msg) => {
         if (msg && msg.type === 'flush') {
             parentPort.postMessage({ type: 'result', data: accumulated });
             // Reset for potential reuse
-            accumulated = { nodes: [], relationships: [], symbols: [], imports: [], calls: [], heritage: [], routes: [], fileCount: 0 };
+            accumulated = { nodes: [], relationships: [], symbols: [], imports: [], calls: [], heritage: [], routes: [], constructorBindings: [], skippedLanguages: {}, fileCount: 0 };
             cumulativeProcessed = 0;
             return;
         }