@veewo/gitnexus 1.3.11 → 1.4.6-rc

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

@@ -10,10 +10,33 @@ import CSharp from 'tree-sitter-c-sharp';
 import Go from 'tree-sitter-go';
 import Rust from 'tree-sitter-rust';
 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 { getLanguageFromFilename } from '../utils.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;
+try {
+    Swift = _require('tree-sitter-swift');
+}
+catch { }
+// 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
 // ============================================================================
@@ -29,7 +52,22 @@ const languageMap = {
     [SupportedLanguages.CSharp]: CSharp,
     [SupportedLanguages.Go]: Go,
     [SupportedLanguages.Rust]: Rust,
+    ...(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')
@@ -40,148 +78,16 @@ 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;
-        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;
-        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',
-    'anonymous_function_creation_expression', // PHP anonymous functions
-]);
 /** 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 (['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) {
                 return generateId(label, `${filePath}:${funcName}`);
             }
@@ -190,70 +96,6 @@ const findEnclosingFunctionId = (node, filePath) => {
     }
     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',
-    // 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',
-]);
 // ============================================================================
 // Label detection from capture map
 // ============================================================================
@@ -309,6 +151,7 @@ const getLabelFromCaptures = (captureMap) => {
         return 'Template';
     return 'CodeElement';
 };
+// DEFINITION_CAPTURE_KEYS and getDefinitionNodeFromCaptures imported from ../utils.js
 // ============================================================================
 // Process a batch of files
 // ============================================================================
@@ -320,6 +163,9 @@ const processBatch = (files, onProgress) => {
         imports: [],
         calls: [],
         heritage: [],
+        routes: [],
+        constructorBindings: [],
+        skippedLanguages: {},
         fileCount: 0,
     };
     // Group by language to minimize setLanguage calls
@@ -367,13 +213,33 @@ const processBatch = (files, onProgress) => {
         }
         // Process regular files for this language
         if (regularFiles.length > 0) {
-            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
+                }
+            }
+            else {
+                result.skippedLanguages[language] = (result.skippedLanguages[language] || 0) + regularFiles.length;
+            }
         }
         // Process tsx files separately (different grammar)
         if (tsxFiles.length > 0) {
-            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
+                }
+            }
+            else {
+                result.skippedLanguages[language] = (result.skippedLanguages[language] || 0) + tsxFiles.length;
+            }
         }
     }
     return result;
@@ -482,33 +348,396 @@ function extractEloquentRelationDescription(methodNode) {
         return relType;
     return null;
 }
+const ROUTE_HTTP_METHODS = new Set([
+    'get', 'post', 'put', 'patch', 'delete', 'options', 'any', 'match',
+]);
+const ROUTE_RESOURCE_METHODS = new Set(['resource', 'apiResource']);
+const RESOURCE_ACTIONS = ['index', 'create', 'store', 'show', 'edit', 'update', 'destroy'];
+const API_RESOURCE_ACTIONS = ['index', 'store', 'show', 'update', 'destroy'];
+/** Check if node is a scoped_call_expression with object 'Route' */
+function isRouteStaticCall(node) {
+    if (node.type !== 'scoped_call_expression')
+        return false;
+    const obj = node.childForFieldName?.('object') ?? node.children?.[0];
+    return obj?.text === 'Route';
+}
+/** Get the method name from a scoped_call_expression or member_call_expression */
+function getCallMethodName(node) {
+    const nameNode = node.childForFieldName?.('name') ??
+        node.children?.find((c) => c.type === 'name');
+    return nameNode?.text ?? null;
+}
+/** Get the arguments node from a call expression */
+function getArguments(node) {
+    return node.children?.find((c) => c.type === 'arguments') ?? null;
+}
+/** Find the closure body inside arguments */
+function findClosureBody(argsNode) {
+    if (!argsNode)
+        return null;
+    for (const child of argsNode.children ?? []) {
+        if (child.type === 'argument') {
+            for (const inner of child.children ?? []) {
+                if (inner.type === 'anonymous_function' ||
+                    inner.type === 'arrow_function') {
+                    return inner.childForFieldName?.('body') ??
+                        inner.children?.find((c) => c.type === 'compound_statement');
+                }
+            }
+        }
+        if (child.type === 'anonymous_function' ||
+            child.type === 'arrow_function') {
+            return child.childForFieldName?.('body') ??
+                child.children?.find((c) => c.type === 'compound_statement');
+        }
+    }
+    return null;
+}
+/** Extract first string argument from arguments node */
+function extractFirstStringArg(argsNode) {
+    if (!argsNode)
+        return null;
+    for (const child of argsNode.children ?? []) {
+        const target = child.type === 'argument' ? child.children?.[0] : child;
+        if (!target)
+            continue;
+        if (target.type === 'string' || target.type === 'encapsed_string') {
+            return extractStringContent(target);
+        }
+    }
+    return null;
+}
+/** Extract middleware from arguments — handles string or array */
+function extractMiddlewareArg(argsNode) {
+    if (!argsNode)
+        return [];
+    for (const child of argsNode.children ?? []) {
+        const target = child.type === 'argument' ? child.children?.[0] : child;
+        if (!target)
+            continue;
+        if (target.type === 'string' || target.type === 'encapsed_string') {
+            const val = extractStringContent(target);
+            return val ? [val] : [];
+        }
+        if (target.type === 'array_creation_expression') {
+            const items = [];
+            for (const el of target.children ?? []) {
+                if (el.type === 'array_element_initializer') {
+                    const str = el.children?.find((c) => c.type === 'string' || c.type === 'encapsed_string');
+                    const val = str ? extractStringContent(str) : null;
+                    if (val)
+                        items.push(val);
+                }
+            }
+            return items;
+        }
+    }
+    return [];
+}
+/** Extract Controller::class from arguments */
+function extractClassArg(argsNode) {
+    if (!argsNode)
+        return null;
+    for (const child of argsNode.children ?? []) {
+        const target = child.type === 'argument' ? child.children?.[0] : child;
+        if (target?.type === 'class_constant_access_expression') {
+            return target.children?.find((c) => c.type === 'name')?.text ?? null;
+        }
+    }
+    return null;
+}
+/** Extract controller class name from arguments: [Controller::class, 'method'] or 'Controller@method' */
+function extractControllerTarget(argsNode) {
+    if (!argsNode)
+        return { controller: null, method: null };
+    const args = [];
+    for (const child of argsNode.children ?? []) {
+        if (child.type === 'argument')
+            args.push(child.children?.[0]);
+        else if (child.type !== '(' && child.type !== ')' && child.type !== ',')
+            args.push(child);
+    }
+    // Second arg is the handler
+    const handlerNode = args[1];
+    if (!handlerNode)
+        return { controller: null, method: null };
+    // Array syntax: [UserController::class, 'index']
+    if (handlerNode.type === 'array_creation_expression') {
+        let controller = null;
+        let method = null;
+        const elements = [];
+        for (const el of handlerNode.children ?? []) {
+            if (el.type === 'array_element_initializer')
+                elements.push(el);
+        }
+        if (elements[0]) {
+            const classAccess = findDescendant(elements[0], 'class_constant_access_expression');
+            if (classAccess) {
+                controller = classAccess.children?.find((c) => c.type === 'name')?.text ?? null;
+            }
+        }
+        if (elements[1]) {
+            const str = findDescendant(elements[1], 'string');
+            method = str ? extractStringContent(str) : null;
+        }
+        return { controller, method };
+    }
+    // String syntax: 'UserController@index'
+    if (handlerNode.type === 'string' || handlerNode.type === 'encapsed_string') {
+        const text = extractStringContent(handlerNode);
+        if (text?.includes('@')) {
+            const [controller, method] = text.split('@');
+            return { controller, method };
+        }
+    }
+    // Class reference: UserController::class (invokable controller)
+    if (handlerNode.type === 'class_constant_access_expression') {
+        const controller = handlerNode.children?.find((c) => c.type === 'name')?.text ?? null;
+        return { controller, method: '__invoke' };
+    }
+    return { controller: null, method: null };
+}
+/**
+ * Unwrap a chained call like Route::middleware('auth')->prefix('api')->group(fn)
+ */
+function unwrapRouteChain(node) {
+    if (node.type !== 'member_call_expression')
+        return null;
+    const terminalMethod = getCallMethodName(node);
+    if (!terminalMethod)
+        return null;
+    const terminalArgs = getArguments(node);
+    const attributes = [];
+    let current = node.children?.[0];
+    while (current) {
+        if (current.type === 'member_call_expression') {
+            const method = getCallMethodName(current);
+            const args = getArguments(current);
+            if (method)
+                attributes.unshift({ method, argsNode: args });
+            current = current.children?.[0];
+        }
+        else if (current.type === 'scoped_call_expression') {
+            const obj = current.childForFieldName?.('object') ?? current.children?.[0];
+            if (obj?.text !== 'Route')
+                return null;
+            const method = getCallMethodName(current);
+            const args = getArguments(current);
+            if (method)
+                attributes.unshift({ method, argsNode: args });
+            return { isRouteFacade: true, terminalMethod, attributes, terminalArgs, node };
+        }
+        else {
+            break;
+        }
+    }
+    return null;
+}
+/** Parse Route::group(['middleware' => ..., 'prefix' => ...], fn) array syntax */
+function parseArrayGroupArgs(argsNode) {
+    const ctx = { middleware: [], prefix: null, controller: null };
+    if (!argsNode)
+        return ctx;
+    for (const child of argsNode.children ?? []) {
+        const target = child.type === 'argument' ? child.children?.[0] : child;
+        if (target?.type === 'array_creation_expression') {
+            for (const el of target.children ?? []) {
+                if (el.type !== 'array_element_initializer')
+                    continue;
+                const children = el.children ?? [];
+                const arrowIdx = children.findIndex((c) => c.type === '=>');
+                if (arrowIdx === -1)
+                    continue;
+                const key = extractStringContent(children[arrowIdx - 1]);
+                const val = children[arrowIdx + 1];
+                if (key === 'middleware') {
+                    if (val?.type === 'string') {
+                        const s = extractStringContent(val);
+                        if (s)
+                            ctx.middleware.push(s);
+                    }
+                    else if (val?.type === 'array_creation_expression') {
+                        for (const item of val.children ?? []) {
+                            if (item.type === 'array_element_initializer') {
+                                const str = item.children?.find((c) => c.type === 'string');
+                                const s = str ? extractStringContent(str) : null;
+                                if (s)
+                                    ctx.middleware.push(s);
+                            }
+                        }
+                    }
+                }
+                else if (key === 'prefix') {
+                    ctx.prefix = extractStringContent(val) ?? null;
+                }
+                else if (key === 'controller') {
+                    if (val?.type === 'class_constant_access_expression') {
+                        ctx.controller = val.children?.find((c) => c.type === 'name')?.text ?? null;
+                    }
+                }
+            }
+        }
+    }
+    return ctx;
+}
+function extractLaravelRoutes(tree, filePath) {
+    const routes = [];
+    function resolveStack(stack) {
+        const middleware = [];
+        let prefix = null;
+        let controller = null;
+        for (const ctx of stack) {
+            middleware.push(...ctx.middleware);
+            if (ctx.prefix)
+                prefix = prefix ? `${prefix}/${ctx.prefix}`.replace(/\/+/g, '/') : ctx.prefix;
+            if (ctx.controller)
+                controller = ctx.controller;
+        }
+        return { middleware, prefix, controller };
+    }
+    function emitRoute(httpMethod, argsNode, lineNumber, groupStack, chainAttrs) {
+        const effective = resolveStack(groupStack);
+        for (const attr of chainAttrs) {
+            if (attr.method === 'middleware')
+                effective.middleware.push(...extractMiddlewareArg(attr.argsNode));
+            if (attr.method === 'prefix') {
+                const p = extractFirstStringArg(attr.argsNode);
+                if (p)
+                    effective.prefix = effective.prefix ? `${effective.prefix}/${p}` : p;
+            }
+            if (attr.method === 'controller') {
+                const cls = extractClassArg(attr.argsNode);
+                if (cls)
+                    effective.controller = cls;
+            }
+        }
+        const routePath = extractFirstStringArg(argsNode);
+        if (ROUTE_RESOURCE_METHODS.has(httpMethod)) {
+            const target = extractControllerTarget(argsNode);
+            const actions = httpMethod === 'apiResource' ? API_RESOURCE_ACTIONS : RESOURCE_ACTIONS;
+            for (const action of actions) {
+                routes.push({
+                    filePath, httpMethod, routePath,
+                    controllerName: target.controller ?? effective.controller,
+                    methodName: action,
+                    middleware: [...effective.middleware],
+                    prefix: effective.prefix,
+                    lineNumber,
+                });
+            }
+        }
+        else {
+            const target = extractControllerTarget(argsNode);
+            routes.push({
+                filePath, httpMethod, routePath,
+                controllerName: target.controller ?? effective.controller,
+                methodName: target.method,
+                middleware: [...effective.middleware],
+                prefix: effective.prefix,
+                lineNumber,
+            });
+        }
+    }
+    function walk(node, groupStack) {
+        // Case 1: Simple Route::get(...), Route::post(...), etc.
+        if (isRouteStaticCall(node)) {
+            const method = getCallMethodName(node);
+            if (method && (ROUTE_HTTP_METHODS.has(method) || ROUTE_RESOURCE_METHODS.has(method))) {
+                emitRoute(method, getArguments(node), node.startPosition.row, groupStack, []);
+                return;
+            }
+            if (method === 'group') {
+                const argsNode = getArguments(node);
+                const groupCtx = parseArrayGroupArgs(argsNode);
+                const body = findClosureBody(argsNode);
+                if (body) {
+                    groupStack.push(groupCtx);
+                    walkChildren(body, groupStack);
+                    groupStack.pop();
+                }
+                return;
+            }
+        }
+        // Case 2: Fluent chain — Route::middleware(...)->group(...) or Route::middleware(...)->get(...)
+        const chain = unwrapRouteChain(node);
+        if (chain) {
+            if (chain.terminalMethod === 'group') {
+                const groupCtx = { middleware: [], prefix: null, controller: null };
+                for (const attr of chain.attributes) {
+                    if (attr.method === 'middleware')
+                        groupCtx.middleware.push(...extractMiddlewareArg(attr.argsNode));
+                    if (attr.method === 'prefix')
+                        groupCtx.prefix = extractFirstStringArg(attr.argsNode);
+                    if (attr.method === 'controller')
+                        groupCtx.controller = extractClassArg(attr.argsNode);
+                }
+                const body = findClosureBody(chain.terminalArgs);
+                if (body) {
+                    groupStack.push(groupCtx);
+                    walkChildren(body, groupStack);
+                    groupStack.pop();
+                }
+                return;
+            }
+            if (ROUTE_HTTP_METHODS.has(chain.terminalMethod) || ROUTE_RESOURCE_METHODS.has(chain.terminalMethod)) {
+                emitRoute(chain.terminalMethod, chain.terminalArgs, node.startPosition.row, groupStack, chain.attributes);
+                return;
+            }
+        }
+        // Default: recurse into children
+        walkChildren(node, groupStack);
+    }
+    function walkChildren(node, groupStack) {
+        for (const child of node.children ?? []) {
+            walk(child, groupStack);
+        }
+    }
+    walk(tree.rootNode, []);
+    return routes;
+}
 const processFileGroup = (files, language, queryString, result, onFileProcessed) => {
     let query;
     try {
         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) {
@@ -518,11 +747,15 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
             }
             // Extract import paths before skipping
             if (captureMap['import'] && captureMap['import.source']) {
-                const rawImportPath = captureMap['import.source'].text.replace(/['"<>]/g, '');
+                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;
             }
@@ -531,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;
@@ -543,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({
@@ -574,7 +927,12 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
             if (!nodeLabel)
                 continue;
             const nameNode = captureMap['name'];
-            const nodeName = nameNode.text;
+            // Synthesize name for constructors without explicit @name capture (e.g. Swift init)
+            if (!nameNode && nodeLabel !== 'Constructor')
+                continue;
+            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}`);
             let description;
             if (language === SupportedLanguages.PHP) {
@@ -585,6 +943,26 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                     description = extractEloquentRelationDescription(captureMap['definition.method']) ?? undefined;
                 }
             }
+            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])
+                // Also upgrades uninformative AST types like PHP `array` with PHPDoc `@return User[]`
+                if ((!returnType || returnType === 'array' || returnType === 'iterable') && definitionNode) {
+                    const tc = typeConfigs[language];
+                    if (tc?.extractReturnType) {
+                        const docReturn = tc.extractReturnType(definitionNode);
+                        if (docReturn)
+                            returnType = docReturn;
+                    }
+                }
+            }
             result.nodes.push({
                 id: nodeId,
                 label: nodeLabel,
@@ -594,15 +972,28 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
                     startLine: nameNode.startPosition.row + 1,
                     endLine: nameNode.endPosition.row + 1,
                     language: language,
-                    isExported: isNodeExported(nameNode, nodeName, language),
+                    isExported: isNodeExported(nameNode || definitionNode, nodeName, language),
+                    ...(frameworkHint ? {
+                        astFrameworkMultiplier: frameworkHint.entryPointMultiplier,
+                        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}`);
@@ -614,6 +1005,22 @@ 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')) {
+            const extractedRoutes = extractLaravelRoutes(tree, file.path);
+            result.routes.push(...extractedRoutes);
         }
     }
 };
@@ -623,7 +1030,7 @@ const processFileGroup = (files, language, queryString, result, onFileProcessed)
 /** Accumulated result across sub-batches */
 let accumulated = {
     nodes: [], relationships: [], symbols: [],
-    imports: [], calls: [], heritage: [], fileCount: 0,
+    imports: [], calls: [], heritage: [], routes: [], constructorBindings: [], skippedLanguages: {}, fileCount: 0,
 };
 let cumulativeProcessed = 0;
 const mergeResult = (target, src) => {
@@ -633,6 +1040,11 @@ const mergeResult = (target, src) => {
     target.imports.push(...src.imports);
     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) => {
@@ -652,7 +1064,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: [], fileCount: 0 };
+            accumulated = { nodes: [], relationships: [], symbols: [], imports: [], calls: [], heritage: [], routes: [], constructorBindings: [], skippedLanguages: {}, fileCount: 0 };
             cumulativeProcessed = 0;
             return;
         }