gitnexus 1.3.10 → 1.4.0

package/dist/core/ingestion/workers/parse-worker.d.ts

@@ -1,3 +1,4 @@
+import { SupportedLanguages } from '../../../config/supported-languages.js';
 interface ParsedNode {
     id: string;
     label: string;
@@ -6,18 +7,20 @@ interface ParsedNode {
         filePath: string;
         startLine: number;
         endLine: number;
-        language: string;
+        language: SupportedLanguages;
         isExported: boolean;
         astFrameworkMultiplier?: number;
         astFrameworkReason?: string;
         description?: string;
+        parameterCount?: number;
+        returnType?: string;
     };
 }
 interface ParsedRelationship {
     id: string;
     sourceId: string;
     targetId: string;
-    type: 'DEFINES';
+    type: 'DEFINES' | 'HAS_METHOD';
     confidence: number;
     reason: string;
 }
@@ -26,17 +29,31 @@ interface ParsedSymbol {
     name: string;
     nodeId: string;
     type: string;
+    parameterCount?: number;
+    ownerId?: string;
 }
 export interface ExtractedImport {
     filePath: string;
     rawImportPath: string;
-    language: string;
+    language: SupportedLanguages;
+    /** Named bindings from the import (e.g., import {User as U} → [{local:'U', exported:'User'}]) */
+    namedBindings?: {
+        local: string;
+        exported: string;
+    }[];
 }
 export interface ExtractedCall {
     filePath: string;
     calledName: string;
     /** generateId of enclosing function, or generateId('File', filePath) for top-level */
     sourceId: string;
+    argCount?: number;
+    /** Discriminates free function calls from member/constructor calls */
+    callForm?: 'free' | 'member' | 'constructor';
+    /** Simple identifier of the receiver for member calls (e.g., 'user' in user.save()) */
+    receiverName?: string;
+    /** Resolved type name of the receiver (e.g., 'User' for user.save() when user: User) */
+    receiverTypeName?: string;
 }
 export interface ExtractedHeritage {
     filePath: string;

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

@@ -14,6 +14,7 @@ import PHP from 'tree-sitter-php';
 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,13 @@ try {
     Swift = _require('tree-sitter-swift');
 }
 catch { }
-import { findSiblingChild, getLanguageFromFilename } from '../utils.js';
+import { getLanguageFromFilename, FUNCTION_NODE_TYPES, extractFunctionName, isBuiltInOrNoise, getDefinitionNodeFromCaptures, findEnclosingClassId, extractMethodSignature, countCallArguments, inferCallForm, extractReceiverName } from '../utils.js';
+import { buildTypeEnv, lookupTypeEnv } from '../type-env.js';
+import { isNodeExported } from '../export-detection.js';
 import { detectFrameworkFromAST } from '../framework-detection.js';
 import { generateId } from '../../../lib/utils.js';
+import { extractNamedBindings } from '../named-binding-extraction.js';
+import { appendKotlinWildcard } from '../resolvers/index.js';
 // ============================================================================
 // Worker-local parser + language map
 // ============================================================================
@@ -52,307 +57,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 +130,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
 // ============================================================================
@@ -988,27 +668,38 @@ 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 TypeEnv from explicit type annotations (for receiver resolution)
+        const typeEnv = buildTypeEnv(tree, language);
         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 +712,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 +726,22 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                 const callNameNode = captureMap['call.name'];
                 if (callNameNode) {
                     const calledName = callNameNode.text;
-                    if (!BUILT_INS.has(calledName)) {
+                    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);
+                        const receiverName = callForm === 'member' ? extractReceiverName(callNameNode) : undefined;
+                        const receiverTypeName = receiverName ? lookupTypeEnv(typeEnv, receiverName, callNode) : undefined;
+                        result.calls.push({
+                            filePath: file.path,
+                            calledName,
+                            sourceId,
+                            argCount: countCallArguments(callNode),
+                            ...(callForm !== undefined ? { callForm } : {}),
+                            ...(receiverName !== undefined ? { receiverName } : {}),
+                            ...(receiverTypeName !== undefined ? { receiverTypeName } : {}),
+                        });
                     }
                 }
                 continue;
@@ -1045,12 +749,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 +795,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 +808,13 @@ 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;
+            }
             result.nodes.push({
                 id: nodeId,
                 label: nodeLabel,
@@ -1110,13 +830,21 @@ 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 } : {}),
+                ...(enclosingClassId ? { ownerId: enclosingClassId } : {}),
             });
             const fileId = generateId('File', file.path);
             const relId = generateId('DEFINES', `${fileId}->${nodeId}`);
@@ -1128,6 +856,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')) {

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

@@ -1,5 +1,7 @@
 import { Worker } from 'node:worker_threads';
 import os from 'node:os';
+import fs from 'node:fs';
+import { fileURLToPath } from 'node:url';
 /**
  * Max files to send to a worker in a single postMessage.
  * Keeps structured-clone memory bounded per sub-batch.
@@ -12,6 +14,12 @@ const SUB_BATCH_TIMEOUT_MS = 30_000;
  * Create a pool of worker threads.
  */
 export const createWorkerPool = (workerUrl, poolSize) => {
+    // Validate worker script exists before spawning to prevent uncaught
+    // MODULE_NOT_FOUND crashes in worker threads (e.g. when running from src/ via vitest)
+    const workerPath = fileURLToPath(workerUrl);
+    if (!fs.existsSync(workerPath)) {
+        throw new Error(`Worker script not found: ${workerPath}`);
+    }
     const size = poolSize ?? Math.min(8, Math.max(1, os.cpus().length - 1));
     const workers = [];
     for (let i = 0; i < size; i++) {