@veewo/gitnexus 1.3.4

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

@@ -0,0 +1,672 @@
+import { parentPort } from 'node:worker_threads';
+import Parser from 'tree-sitter';
+import JavaScript from 'tree-sitter-javascript';
+import TypeScript from 'tree-sitter-typescript';
+import Python from 'tree-sitter-python';
+import Java from 'tree-sitter-java';
+import C from 'tree-sitter-c';
+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 PHP from 'tree-sitter-php';
+import { SupportedLanguages } from '../../../config/supported-languages.js';
+import { LANGUAGE_QUERIES } from '../tree-sitter-queries.js';
+import { getLanguageFromFilename } from '../utils.js';
+import { generateId } from '../../../lib/utils.js';
+// ============================================================================
+// Worker-local parser + language map
+// ============================================================================
+const parser = new Parser();
+const languageMap = {
+    [SupportedLanguages.JavaScript]: JavaScript,
+    [SupportedLanguages.TypeScript]: TypeScript.typescript,
+    [`${SupportedLanguages.TypeScript}:tsx`]: TypeScript.tsx,
+    [SupportedLanguages.Python]: Python,
+    [SupportedLanguages.Java]: Java,
+    [SupportedLanguages.C]: C,
+    [SupportedLanguages.CPlusPlus]: CPP,
+    [SupportedLanguages.CSharp]: CSharp,
+    [SupportedLanguages.Go]: Go,
+    [SupportedLanguages.Rust]: Rust,
+    [SupportedLanguages.PHP]: PHP.php_only,
+};
+const setLanguage = (language, filePath) => {
+    const key = language === SupportedLanguages.TypeScript && filePath.endsWith('.tsx')
+        ? `${language}:tsx`
+        : language;
+    const lang = languageMap[key];
+    if (!lang)
+        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;
+    }
+};
+// ============================================================================
+// 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;
+                }
+            }
+            if (funcName) {
+                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',
+    // 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
+// ============================================================================
+const getLabelFromCaptures = (captureMap) => {
+    // Skip imports (handled separately) and calls
+    if (captureMap['import'] || captureMap['call'])
+        return null;
+    if (!captureMap['name'])
+        return null;
+    if (captureMap['definition.function'])
+        return 'Function';
+    if (captureMap['definition.class'])
+        return 'Class';
+    if (captureMap['definition.interface'])
+        return 'Interface';
+    if (captureMap['definition.method'])
+        return 'Method';
+    if (captureMap['definition.struct'])
+        return 'Struct';
+    if (captureMap['definition.enum'])
+        return 'Enum';
+    if (captureMap['definition.namespace'])
+        return 'Namespace';
+    if (captureMap['definition.module'])
+        return 'Module';
+    if (captureMap['definition.trait'])
+        return 'Trait';
+    if (captureMap['definition.impl'])
+        return 'Impl';
+    if (captureMap['definition.type'])
+        return 'TypeAlias';
+    if (captureMap['definition.const'])
+        return 'Const';
+    if (captureMap['definition.static'])
+        return 'Static';
+    if (captureMap['definition.typedef'])
+        return 'Typedef';
+    if (captureMap['definition.macro'])
+        return 'Macro';
+    if (captureMap['definition.union'])
+        return 'Union';
+    if (captureMap['definition.property'])
+        return 'Property';
+    if (captureMap['definition.record'])
+        return 'Record';
+    if (captureMap['definition.delegate'])
+        return 'Delegate';
+    if (captureMap['definition.annotation'])
+        return 'Annotation';
+    if (captureMap['definition.constructor'])
+        return 'Constructor';
+    if (captureMap['definition.template'])
+        return 'Template';
+    return 'CodeElement';
+};
+// ============================================================================
+// Process a batch of files
+// ============================================================================
+const processBatch = (files, onProgress) => {
+    const result = {
+        nodes: [],
+        relationships: [],
+        symbols: [],
+        imports: [],
+        calls: [],
+        heritage: [],
+        fileCount: 0,
+    };
+    // Group by language to minimize setLanguage calls
+    const byLanguage = new Map();
+    for (const file of files) {
+        const lang = getLanguageFromFilename(file.path);
+        if (!lang)
+            continue;
+        let list = byLanguage.get(lang);
+        if (!list) {
+            list = [];
+            byLanguage.set(lang, list);
+        }
+        list.push(file);
+    }
+    let totalProcessed = 0;
+    let lastReported = 0;
+    const PROGRESS_INTERVAL = 100; // report every 100 files
+    const onFileProcessed = onProgress ? () => {
+        totalProcessed++;
+        if (totalProcessed - lastReported >= PROGRESS_INTERVAL) {
+            lastReported = totalProcessed;
+            onProgress(totalProcessed);
+        }
+    } : undefined;
+    for (const [language, langFiles] of byLanguage) {
+        const queryString = LANGUAGE_QUERIES[language];
+        if (!queryString)
+            continue;
+        // Track if we need to handle tsx separately
+        const tsxFiles = [];
+        const regularFiles = [];
+        if (language === SupportedLanguages.TypeScript) {
+            for (const f of langFiles) {
+                if (f.path.endsWith('.tsx')) {
+                    tsxFiles.push(f);
+                }
+                else {
+                    regularFiles.push(f);
+                }
+            }
+        }
+        else {
+            regularFiles.push(...langFiles);
+        }
+        // Process regular files for this language
+        if (regularFiles.length > 0) {
+            setLanguage(language, regularFiles[0].path);
+            processFileGroup(regularFiles, language, queryString, result, onFileProcessed);
+        }
+        // Process tsx files separately (different grammar)
+        if (tsxFiles.length > 0) {
+            setLanguage(language, tsxFiles[0].path);
+            processFileGroup(tsxFiles, language, queryString, result, onFileProcessed);
+        }
+    }
+    return result;
+};
+// ============================================================================
+// PHP Eloquent metadata extraction
+// ============================================================================
+/** Eloquent model properties whose array values are worth indexing */
+const ELOQUENT_ARRAY_PROPS = new Set(['fillable', 'casts', 'hidden', 'guarded', 'with', 'appends']);
+/** Eloquent relationship method names */
+const ELOQUENT_RELATIONS = new Set([
+    'hasMany', 'hasOne', 'belongsTo', 'belongsToMany',
+    'morphTo', 'morphMany', 'morphOne', 'morphToMany', 'morphedByMany',
+    'hasManyThrough', 'hasOneThrough',
+]);
+function findDescendant(node, type) {
+    if (node.type === type)
+        return node;
+    for (const child of (node.children ?? [])) {
+        const found = findDescendant(child, type);
+        if (found)
+            return found;
+    }
+    return null;
+}
+function extractStringContent(node) {
+    if (!node)
+        return null;
+    const content = node.children?.find((c) => c.type === 'string_content');
+    if (content)
+        return content.text;
+    if (node.type === 'string_content')
+        return node.text;
+    return null;
+}
+/**
+ * For a PHP property_declaration node, extract array values as a description string.
+ * Returns null if not an Eloquent model property or no array values found.
+ */
+function extractPhpPropertyDescription(propName, propDeclNode) {
+    if (!ELOQUENT_ARRAY_PROPS.has(propName))
+        return null;
+    const arrayNode = findDescendant(propDeclNode, 'array_creation_expression');
+    if (!arrayNode)
+        return null;
+    const items = [];
+    for (const child of (arrayNode.children ?? [])) {
+        if (child.type !== 'array_element_initializer')
+            continue;
+        const children = child.children ?? [];
+        const arrowIdx = children.findIndex((c) => c.type === '=>');
+        if (arrowIdx !== -1) {
+            // key => value pair (used in $casts)
+            const key = extractStringContent(children[arrowIdx - 1]);
+            const val = extractStringContent(children[arrowIdx + 1]);
+            if (key && val)
+                items.push(`${key}:${val}`);
+        }
+        else {
+            // Simple value (used in $fillable, $hidden, etc.)
+            const val = extractStringContent(children[0]);
+            if (val)
+                items.push(val);
+        }
+    }
+    return items.length > 0 ? items.join(', ') : null;
+}
+/**
+ * For a PHP method_declaration node, detect if it defines an Eloquent relationship.
+ * Returns description like "hasMany(Post)" or null.
+ */
+function extractEloquentRelationDescription(methodNode) {
+    function findRelationCall(node) {
+        if (node.type === 'member_call_expression') {
+            const children = node.children ?? [];
+            const objectNode = children.find((c) => c.type === 'variable_name' && c.text === '$this');
+            const nameNode = children.find((c) => c.type === 'name');
+            if (objectNode && nameNode && ELOQUENT_RELATIONS.has(nameNode.text))
+                return node;
+        }
+        for (const child of (node.children ?? [])) {
+            const found = findRelationCall(child);
+            if (found)
+                return found;
+        }
+        return null;
+    }
+    const callNode = findRelationCall(methodNode);
+    if (!callNode)
+        return null;
+    const relType = callNode.children?.find((c) => c.type === 'name')?.text;
+    const argsNode = callNode.children?.find((c) => c.type === 'arguments');
+    let targetModel = null;
+    if (argsNode) {
+        const firstArg = argsNode.children?.find((c) => c.type === 'argument');
+        if (firstArg) {
+            const classConstant = firstArg.children?.find((c) => c.type === 'class_constant_access_expression');
+            if (classConstant) {
+                targetModel = classConstant.children?.find((c) => c.type === 'name')?.text ?? null;
+            }
+        }
+    }
+    if (relType && targetModel)
+        return `${relType}(${targetModel})`;
+    if (relType)
+        return relType;
+    return null;
+}
+const processFileGroup = (files, language, queryString, result, onFileProcessed) => {
+    let query;
+    try {
+        const lang = parser.getLanguage();
+        query = new Parser.Query(lang, queryString);
+    }
+    catch {
+        return;
+    }
+    for (const file of files) {
+        // Skip very large files — they can crash tree-sitter or cause OOM
+        if (file.content.length > 512 * 1024)
+            continue;
+        let tree;
+        try {
+            tree = parser.parse(file.content, undefined, { bufferSize: 1024 * 256 });
+        }
+        catch {
+            continue;
+        }
+        result.fileCount++;
+        onFileProcessed?.();
+        let matches;
+        try {
+            matches = query.matches(tree.rootNode);
+        }
+        catch {
+            continue;
+        }
+        for (const match of matches) {
+            const captureMap = {};
+            for (const c of match.captures) {
+                captureMap[c.name] = c.node;
+            }
+            // Extract import paths before skipping
+            if (captureMap['import'] && captureMap['import.source']) {
+                const rawImportPath = captureMap['import.source'].text.replace(/['"<>]/g, '');
+                result.imports.push({
+                    filePath: file.path,
+                    rawImportPath,
+                    language: language,
+                });
+                continue;
+            }
+            // Extract call sites
+            if (captureMap['call']) {
+                const callNameNode = captureMap['call.name'];
+                if (callNameNode) {
+                    const calledName = callNameNode.text;
+                    if (!BUILT_INS.has(calledName)) {
+                        const callNode = captureMap['call'];
+                        const sourceId = findEnclosingFunctionId(callNode, file.path)
+                            || generateId('File', file.path);
+                        result.calls.push({ filePath: file.path, calledName, sourceId });
+                    }
+                }
+                continue;
+            }
+            // 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',
+                    });
+                }
+                if (captureMap['heritage.implements']) {
+                    result.heritage.push({
+                        filePath: file.path,
+                        className: captureMap['heritage.class'].text,
+                        parentName: captureMap['heritage.implements'].text,
+                        kind: 'implements',
+                    });
+                }
+                if (captureMap['heritage.trait']) {
+                    result.heritage.push({
+                        filePath: file.path,
+                        className: captureMap['heritage.class'].text,
+                        parentName: captureMap['heritage.trait'].text,
+                        kind: 'trait-impl',
+                    });
+                }
+                if (captureMap['heritage.extends'] || captureMap['heritage.implements'] || captureMap['heritage.trait']) {
+                    continue;
+                }
+            }
+            const nodeLabel = getLabelFromCaptures(captureMap);
+            if (!nodeLabel)
+                continue;
+            const nameNode = captureMap['name'];
+            const nodeName = nameNode.text;
+            const nodeId = generateId(nodeLabel, `${file.path}:${nodeName}`);
+            let description;
+            if (language === SupportedLanguages.PHP) {
+                if (nodeLabel === 'Property' && captureMap['definition.property']) {
+                    description = extractPhpPropertyDescription(nodeName, captureMap['definition.property']) ?? undefined;
+                }
+                else if (nodeLabel === 'Method' && captureMap['definition.method']) {
+                    description = extractEloquentRelationDescription(captureMap['definition.method']) ?? undefined;
+                }
+            }
+            result.nodes.push({
+                id: nodeId,
+                label: nodeLabel,
+                properties: {
+                    name: nodeName,
+                    filePath: file.path,
+                    startLine: nameNode.startPosition.row + 1,
+                    endLine: nameNode.endPosition.row + 1,
+                    language: language,
+                    isExported: isNodeExported(nameNode, nodeName, language),
+                    ...(description !== undefined ? { description } : {}),
+                },
+            });
+            result.symbols.push({
+                filePath: file.path,
+                name: nodeName,
+                nodeId,
+                type: nodeLabel,
+            });
+            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: '',
+            });
+        }
+    }
+};
+// ============================================================================
+// Worker message handler — supports sub-batch streaming
+// ============================================================================
+/** Accumulated result across sub-batches */
+let accumulated = {
+    nodes: [], relationships: [], symbols: [],
+    imports: [], calls: [], heritage: [], fileCount: 0,
+};
+let cumulativeProcessed = 0;
+const mergeResult = (target, src) => {
+    target.nodes.push(...src.nodes);
+    target.relationships.push(...src.relationships);
+    target.symbols.push(...src.symbols);
+    target.imports.push(...src.imports);
+    target.calls.push(...src.calls);
+    target.heritage.push(...src.heritage);
+    target.fileCount += src.fileCount;
+};
+parentPort.on('message', (msg) => {
+    try {
+        // Sub-batch mode: { type: 'sub-batch', files: [...] }
+        if (msg && msg.type === 'sub-batch') {
+            const result = processBatch(msg.files, (filesProcessed) => {
+                parentPort.postMessage({ type: 'progress', filesProcessed: cumulativeProcessed + filesProcessed });
+            });
+            cumulativeProcessed += result.fileCount;
+            mergeResult(accumulated, result);
+            // Signal ready for next sub-batch
+            parentPort.postMessage({ type: 'sub-batch-done' });
+            return;
+        }
+        // Flush: send accumulated results
+        if (msg && msg.type === 'flush') {
+            parentPort.postMessage({ type: 'result', data: accumulated });
+            // Reset for potential reuse
+            accumulated = { nodes: [], relationships: [], symbols: [], imports: [], calls: [], heritage: [], fileCount: 0 };
+            cumulativeProcessed = 0;
+            return;
+        }
+        // Legacy single-message mode (backward compat): array of files
+        if (Array.isArray(msg)) {
+            const result = processBatch(msg, (filesProcessed) => {
+                parentPort.postMessage({ type: 'progress', filesProcessed });
+            });
+            parentPort.postMessage({ type: 'result', data: result });
+            return;
+        }
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        parentPort.postMessage({ type: 'error', error: message });
+    }
+});