@zuvia-software-solutions/code-mapper 1.4.0

package/dist/core/ingestion/named-binding-extraction.js

@@ -0,0 +1,343 @@
+// code-mapper/src/core/ingestion/named-binding-extraction.ts
+/** @file named-binding-extraction.ts @description Extracts named import bindings from AST import nodes and walks re-export chains through NamedImportMap to resolve barrel file indirection */
+import { SupportedLanguages } from '../../config/supported-languages.js';
+/**
+ * Walk a named-binding re-export chain through NamedImportMap
+ *
+ * Follows A->B->C chains until a definition is found (max depth 5)
+ * Returns null if the chain breaks (missing binding, circular reference, or depth exceeded)
+ *
+ * @param allDefs - Complete unfiltered lookupFuzzy(name) result; file-filtered subsets cause silent misses
+ */
+export function walkBindingChain(name, currentFilePath, symbolTable, namedImportMap, allDefs) {
+    let lookupFile = currentFilePath;
+    let lookupName = name;
+    const visited = new Set();
+    for (let depth = 0; depth < 5; depth++) {
+        const bindings = namedImportMap.get(lookupFile);
+        if (!bindings)
+            return null;
+        const binding = bindings.get(lookupName);
+        if (!binding)
+            return null;
+        const key = `${binding.sourcePath}:${binding.exportedName}`;
+        if (visited.has(key))
+            return null;
+        visited.add(key);
+        const targetName = binding.exportedName;
+        const resolvedDefs = targetName !== lookupName || depth > 0
+            ? symbolTable.lookupFuzzy(targetName).filter(def => def.filePath === binding.sourcePath)
+            : allDefs.filter(def => def.filePath === binding.sourcePath);
+        if (resolvedDefs.length > 0)
+            return resolvedDefs;
+        // No definition in source file → follow re-export chain
+        lookupFile = binding.sourcePath;
+        lookupName = targetName;
+    }
+    return null;
+}
+/**
+ * Extract named bindings from an import AST node
+ *
+ * Returns undefined for non-named imports (import *, default, side-effect)
+ * Example: `import { User, Repo as R }` -> [{local:'User', exported:'User'}, {local:'R', exported:'Repo'}]
+ */
+export function extractNamedBindings(importNode, language) {
+    if (language === SupportedLanguages.TypeScript || language === SupportedLanguages.JavaScript) {
+        return extractTsNamedBindings(importNode);
+    }
+    if (language === SupportedLanguages.Python) {
+        return extractPythonNamedBindings(importNode);
+    }
+    if (language === SupportedLanguages.Kotlin) {
+        return extractKotlinNamedBindings(importNode);
+    }
+    if (language === SupportedLanguages.Rust) {
+        return extractRustNamedBindings(importNode);
+    }
+    if (language === SupportedLanguages.PHP) {
+        return extractPhpNamedBindings(importNode);
+    }
+    if (language === SupportedLanguages.CSharp) {
+        return extractCsharpNamedBindings(importNode);
+    }
+    if (language === SupportedLanguages.Java) {
+        return extractJavaNamedBindings(importNode);
+    }
+    return undefined;
+}
+// TS/JS: import_statement > import_clause > named_imports > import_specifier*
+export function extractTsNamedBindings(importNode) {
+    const importClause = findChild(importNode, 'import_clause');
+    if (importClause) {
+        const namedImports = findChild(importClause, 'named_imports');
+        if (!namedImports)
+            return undefined;
+        const bindings = [];
+        for (let i = 0; i < namedImports.namedChildCount; i++) {
+            const specifier = namedImports.namedChild(i);
+            if (specifier?.type !== 'import_specifier')
+                continue;
+            const identifiers = [];
+            for (let j = 0; j < specifier.namedChildCount; j++) {
+                const child = specifier.namedChild(j);
+                if (child?.type === 'identifier')
+                    identifiers.push(child.text);
+            }
+            if (identifiers.length === 1) {
+                bindings.push({ local: identifiers[0], exported: identifiers[0] });
+            }
+            else if (identifiers.length === 2) {
+                // import { Foo as Bar } -> exported='Foo', local='Bar'
+                bindings.push({ local: identifiers[1], exported: identifiers[0] });
+            }
+        }
+        return bindings.length > 0 ? bindings : undefined;
+    }
+    // Re-export: export { X } from './y'
+    const exportClause = findChild(importNode, 'export_clause');
+    if (exportClause) {
+        const bindings = [];
+        for (let i = 0; i < exportClause.namedChildCount; i++) {
+            const specifier = exportClause.namedChild(i);
+            if (specifier?.type !== 'export_specifier')
+                continue;
+            const identifiers = [];
+            for (let j = 0; j < specifier.namedChildCount; j++) {
+                const child = specifier.namedChild(j);
+                if (child?.type === 'identifier')
+                    identifiers.push(child.text);
+            }
+            if (identifiers.length === 1) {
+                bindings.push({ local: identifiers[0], exported: identifiers[0] });
+            }
+            else if (identifiers.length === 2) {
+                // export { Repo as Repository } -> first is source name, second is exported alias
+                bindings.push({ local: identifiers[1], exported: identifiers[0] });
+            }
+        }
+        return bindings.length > 0 ? bindings : undefined;
+    }
+    return undefined;
+}
+// Python: from_import_statement only (not plain import_statement)
+export function extractPythonNamedBindings(importNode) {
+    if (importNode.type !== 'import_from_statement')
+        return undefined;
+    const bindings = [];
+    for (let i = 0; i < importNode.namedChildCount; i++) {
+        const child = importNode.namedChild(i);
+        if (!child)
+            continue;
+        if (child.type === 'dotted_name') {
+            // Skip the module_name (first dotted_name)
+            const fieldName = importNode.childForFieldName?.('module_name');
+            if (fieldName && child.startIndex === fieldName.startIndex)
+                continue;
+            // This is an imported name: from x import User
+            const name = child.text;
+            if (name)
+                bindings.push({ local: name, exported: name });
+        }
+        if (child.type === 'aliased_import') {
+            // from x import Repo as R
+            const dottedName = findChild(child, 'dotted_name');
+            const aliasIdent = findChild(child, 'identifier');
+            if (dottedName && aliasIdent) {
+                bindings.push({ local: aliasIdent.text, exported: dottedName.text });
+            }
+        }
+    }
+    return bindings.length > 0 ? bindings : undefined;
+}
+// Kotlin: import_header > identifier + import_alias > simple_identifier
+export function extractKotlinNamedBindings(importNode) {
+    if (importNode.type !== 'import_header')
+        return undefined;
+    const fullIdent = findChild(importNode, 'identifier');
+    if (!fullIdent)
+        return undefined;
+    const fullText = fullIdent.text;
+    const exportedName = fullText.includes('.') ? fullText.split('.').pop() : fullText;
+    const importAlias = findChild(importNode, 'import_alias');
+    if (importAlias) {
+        // Aliased: import com.example.User as U
+        const aliasIdent = findChild(importAlias, 'simple_identifier');
+        if (!aliasIdent)
+            return undefined;
+        return [{ local: aliasIdent.text, exported: exportedName }];
+    }
+    // Non-aliased: import com.example.User -> local="User", exported="User"
+    if (fullText.endsWith('.*') || fullText.endsWith('*'))
+        return undefined;
+    // Skip lowercase last segments — member/function imports would collide in NamedImportMap
+    if (exportedName[0] && exportedName[0] === exportedName[0].toLowerCase())
+        return undefined;
+    return [{ local: exportedName, exported: exportedName }];
+}
+// Rust: use_declaration may contain use_as_clause at any depth
+export function extractRustNamedBindings(importNode) {
+    if (importNode.type !== 'use_declaration')
+        return undefined;
+    const bindings = [];
+    collectRustBindings(importNode, bindings);
+    return bindings.length > 0 ? bindings : undefined;
+}
+function collectRustBindings(node, bindings) {
+    if (node.type === 'use_as_clause') {
+        // First identifier = exported name, second identifier = local alias
+        const idents = [];
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (child?.type === 'identifier')
+                idents.push(child.text);
+            // For scoped_identifier, extract the last segment
+            if (child?.type === 'scoped_identifier') {
+                const nameNode = child.childForFieldName?.('name');
+                if (nameNode)
+                    idents.push(nameNode.text);
+            }
+        }
+        if (idents.length === 2) {
+            bindings.push({ local: idents[1], exported: idents[0] });
+        }
+        return;
+    }
+    // Terminal identifier in a use_list: use crate::models::{User, Repo}
+    if (node.type === 'identifier' && node.parent?.type === 'use_list') {
+        bindings.push({ local: node.text, exported: node.text });
+        return;
+    }
+    // Skip path prefix in scoped_use_list (e.g. "crate::models" in use crate::models::{User, Repo})
+    if (node.type === 'scoped_identifier' && node.parent?.type === 'scoped_use_list') {
+        return;
+    }
+    // Terminal scoped_identifier (leaf with no deeper use_list/use_as_clause)
+    if (node.type === 'scoped_identifier') {
+        let hasDeeper = false;
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (child?.type === 'use_list' || child?.type === 'use_as_clause' || child?.type === 'scoped_use_list') {
+                hasDeeper = true;
+                break;
+            }
+        }
+        if (!hasDeeper) {
+            const nameNode = node.childForFieldName?.('name');
+            if (nameNode) {
+                bindings.push({ local: nameNode.text, exported: nameNode.text });
+            }
+            return;
+        }
+    }
+    // Recurse into children
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child)
+            collectRustBindings(child, bindings);
+    }
+}
+// PHP: namespace_use_declaration > namespace_use_clause* (flat or grouped)
+export function extractPhpNamedBindings(importNode) {
+    if (importNode.type !== 'namespace_use_declaration')
+        return undefined;
+    const bindings = [];
+    // Collect all clauses — from direct children AND from namespace_use_group
+    const clauses = [];
+    for (let i = 0; i < importNode.namedChildCount; i++) {
+        const child = importNode.namedChild(i);
+        if (child?.type === 'namespace_use_clause') {
+            clauses.push(child);
+        }
+        else if (child?.type === 'namespace_use_group') {
+            for (let j = 0; j < child.namedChildCount; j++) {
+                const groupChild = child.namedChild(j);
+                if (groupChild?.type === 'namespace_use_clause')
+                    clauses.push(groupChild);
+            }
+        }
+    }
+    for (const clause of clauses) {
+        // Flat imports: qualified_name + name (alias)
+        let qualifiedName = null;
+        const names = [];
+        for (let j = 0; j < clause.namedChildCount; j++) {
+            const child = clause.namedChild(j);
+            if (child?.type === 'qualified_name')
+                qualifiedName = child;
+            else if (child?.type === 'name')
+                names.push(child);
+        }
+        if (qualifiedName && names.length > 0) {
+            // Flat aliased import: use App\Models\Repo as R;
+            const fullText = qualifiedName.text;
+            const exportedName = fullText.includes('\\') ? fullText.split('\\').pop() : fullText;
+            bindings.push({ local: names[0].text, exported: exportedName });
+        }
+        else if (qualifiedName && names.length === 0) {
+            // Flat non-aliased import: use App\Models\User;
+            const fullText = qualifiedName.text;
+            const lastSegment = fullText.includes('\\') ? fullText.split('\\').pop() : fullText;
+            bindings.push({ local: lastSegment, exported: lastSegment });
+        }
+        else if (!qualifiedName && names.length >= 2) {
+            // Grouped aliased import: {Repo as R} — first name = exported, second = alias
+            bindings.push({ local: names[1].text, exported: names[0].text });
+        }
+        else if (!qualifiedName && names.length === 1) {
+            // Grouped non-aliased import: {User} in use App\Models\{User, Repo as R}
+            bindings.push({ local: names[0].text, exported: names[0].text });
+        }
+    }
+    return bindings.length > 0 ? bindings : undefined;
+}
+// C#: using_directive with identifier (alias) + qualified_name (target)
+export function extractCsharpNamedBindings(importNode) {
+    if (importNode.type !== 'using_directive')
+        return undefined;
+    let aliasIdent = null;
+    let qualifiedName = null;
+    for (let i = 0; i < importNode.namedChildCount; i++) {
+        const child = importNode.namedChild(i);
+        if (child?.type === 'identifier' && !aliasIdent)
+            aliasIdent = child;
+        else if (child?.type === 'qualified_name')
+            qualifiedName = child;
+    }
+    if (!aliasIdent || !qualifiedName)
+        return undefined;
+    const fullText = qualifiedName.text;
+    const exportedName = fullText.includes('.') ? fullText.split('.').pop() : fullText;
+    return [{ local: aliasIdent.text, exported: exportedName }];
+}
+// Java: import_declaration > scoped_identifier (wildcards produce no bindings)
+export function extractJavaNamedBindings(importNode) {
+    if (importNode.type !== 'import_declaration')
+        return undefined;
+    // Skip wildcard imports
+    for (let i = 0; i < importNode.childCount; i++) {
+        const child = importNode.child(i);
+        if (child?.type === 'asterisk')
+            return undefined;
+    }
+    const scopedId = findChild(importNode, 'scoped_identifier');
+    if (!scopedId)
+        return undefined;
+    const fullText = scopedId.text;
+    const lastDot = fullText.lastIndexOf('.');
+    if (lastDot === -1)
+        return undefined;
+    const className = fullText.slice(lastDot + 1);
+    // Skip lowercase names (package imports, not class imports)
+    if (className[0] && className[0] === className[0].toLowerCase())
+        return undefined;
+    return [{ local: className, exported: className }];
+}
+function findChild(node, type) {
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child?.type === type)
+            return child;
+    }
+    return null;
+}

package/dist/core/ingestion/parsing-processor.d.ts

@@ -0,0 +1,20 @@
+/** @file parsing-processor.ts @description Parses source files via tree-sitter, extracts code structure nodes (classes, functions, methods, etc), populates the symbol table, and emits DEFINES/HAS_METHOD graph relationships. Supports parallel worker pools with sequential fallback */
+import { KnowledgeGraph } from '../graph/types.js';
+import { SymbolTable } from './symbol-table.js';
+import { ASTCache } from './ast-cache.js';
+import { WorkerPool } from './workers/worker-pool.js';
+import type { ExtractedImport, ExtractedCall, ExtractedHeritage, ExtractedRoute, FileConstructorBindings } from './workers/parse-worker.js';
+export type FileProgressCallback = (current: number, total: number, filePath: string) => void;
+export interface WorkerExtractedData {
+    imports: ExtractedImport[];
+    calls: ExtractedCall[];
+    heritage: ExtractedHeritage[];
+    routes: ExtractedRoute[];
+    constructorBindings: FileConstructorBindings[];
+}
+export { isNodeExported } from './export-detection.js';
+/** Parse files using worker pool with sequential fallback */
+export declare const processParsing: (graph: KnowledgeGraph, files: {
+    path: string;
+    content: string;
+}[], symbolTable: SymbolTable, astCache: ASTCache, onFileProgress?: FileProgressCallback, workerPool?: WorkerPool) => Promise<WorkerExtractedData | null>;

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

@@ -0,0 +1,282 @@
+// code-mapper/src/core/ingestion/parsing-processor.ts
+/** @file parsing-processor.ts @description Parses source files via tree-sitter, extracts code structure nodes (classes, functions, methods, etc), populates the symbol table, and emits DEFINES/HAS_METHOD graph relationships. Supports parallel worker pools with sequential fallback */
+import Parser from 'tree-sitter';
+import { loadParser, loadLanguage, isLanguageAvailable } from '../tree-sitter/parser-loader.js';
+import { LANGUAGE_QUERIES } from './tree-sitter-queries.js';
+import { generateId } from '../../lib/utils.js';
+import { getLanguageFromFilename, yieldToEventLoop, getDefinitionNodeFromCaptures, findEnclosingClassId, extractMethodSignature } from './utils.js';
+import { isNodeExported } from './export-detection.js';
+import { detectFrameworkFromAST } from './framework-detection.js';
+import { typeConfigs } from './type-extractors/index.js';
+import { getTreeSitterBufferSize, TREE_SITTER_MAX_BUFFER } from './constants.js';
+export { isNodeExported } from './export-detection.js';
+// Worker-based parallel parsing
+const processParsingWithWorkers = async (graph, files, symbolTable, astCache, workerPool, onFileProgress) => {
+    // Filter to parseable files only
+    const parseableFiles = [];
+    for (const file of files) {
+        const lang = getLanguageFromFilename(file.path);
+        if (lang)
+            parseableFiles.push({ path: file.path, content: file.content });
+    }
+    if (parseableFiles.length === 0)
+        return { imports: [], calls: [], heritage: [], routes: [], constructorBindings: [] };
+    const total = files.length;
+    // Dispatch to worker pool
+    const chunkResults = await workerPool.dispatch(parseableFiles, (filesProcessed) => {
+        onFileProgress?.(Math.min(filesProcessed, total), total, 'Parsing...');
+    });
+    // Merge worker results into graph and symbol table
+    const allImports = [];
+    const allCalls = [];
+    const allHeritage = [];
+    const allRoutes = [];
+    const allConstructorBindings = [];
+    for (const result of chunkResults) {
+        for (const node of result.nodes) {
+            graph.addNode({
+                id: node.id,
+                label: node.label,
+                properties: node.properties,
+            });
+        }
+        for (const rel of result.relationships) {
+            graph.addRelationship(rel);
+        }
+        for (const sym of result.symbols) {
+            symbolTable.add(sym.filePath, sym.name, sym.nodeId, sym.type, {
+                parameterCount: sym.parameterCount,
+                returnType: sym.returnType,
+                ownerId: sym.ownerId,
+                parameterTypes: sym.parameterTypes,
+            });
+        }
+        allImports.push(...result.imports);
+        allCalls.push(...result.calls);
+        allHeritage.push(...result.heritage);
+        allRoutes.push(...result.routes);
+        allConstructorBindings.push(...result.constructorBindings);
+    }
+    // Merge and log skipped languages
+    const skippedLanguages = new Map();
+    for (const result of chunkResults) {
+        for (const [lang, count] of Object.entries(result.skippedLanguages)) {
+            skippedLanguages.set(lang, (skippedLanguages.get(lang) || 0) + count);
+        }
+    }
+    if (skippedLanguages.size > 0) {
+        const summary = Array.from(skippedLanguages.entries())
+            .map(([lang, count]) => `${lang}: ${count}`)
+            .join(', ');
+        console.warn(`  Skipped unsupported languages: ${summary}`);
+    }
+    // Final progress report
+    onFileProgress?.(total, total, 'done');
+    return { imports: allImports, calls: allCalls, heritage: allHeritage, routes: allRoutes, constructorBindings: allConstructorBindings };
+};
+// Sequential fallback (single-threaded)
+const processParsingSequential = async (graph, files, symbolTable, astCache, onFileProgress) => {
+    const parser = await loadParser();
+    const total = files.length;
+    const skippedLanguages = new Map();
+    for (let i = 0; i < files.length; i++) {
+        const file = files[i];
+        onFileProgress?.(i + 1, total, file.path);
+        if (i % 20 === 0)
+            await yieldToEventLoop();
+        const language = getLanguageFromFilename(file.path);
+        if (!language)
+            continue;
+        // Skip unsupported languages
+        if (!isLanguageAvailable(language)) {
+            skippedLanguages.set(language, (skippedLanguages.get(language) || 0) + 1);
+            continue;
+        }
+        // Skip files larger than the max tree-sitter buffer
+        if (file.content.length > TREE_SITTER_MAX_BUFFER)
+            continue;
+        try {
+            await loadLanguage(language, file.path);
+        }
+        catch {
+            continue;
+        }
+        let tree;
+        try {
+            tree = parser.parse(file.content, undefined, { bufferSize: getTreeSitterBufferSize(file.content.length) });
+        }
+        catch (parseError) {
+            console.warn(`Skipping unparseable file: ${file.path}`);
+            continue;
+        }
+        astCache.set(file.path, tree);
+        const queryString = LANGUAGE_QUERIES[language];
+        if (!queryString) {
+            continue;
+        }
+        let query;
+        let matches;
+        try {
+            const language = parser.getLanguage();
+            query = new Parser.Query(language, queryString);
+            matches = query.matches(tree.rootNode);
+        }
+        catch (queryError) {
+            console.warn(`Query error for ${file.path}:`, queryError);
+            continue;
+        }
+        matches.forEach(match => {
+            const captureMap = {};
+            match.captures.forEach(c => {
+                captureMap[c.name] = c.node;
+            });
+            if (captureMap['import']) {
+                return;
+            }
+            if (captureMap['call']) {
+                return;
+            }
+            const nameNode = captureMap['name'];
+            // Synthesize name for constructors without explicit @name capture (e.g. Swift init)
+            if (!nameNode && !captureMap['definition.constructor'])
+                return;
+            const nodeName = nameNode ? nameNode.text : 'init';
+            let nodeLabel = 'CodeElement';
+            if (captureMap['definition.function'])
+                nodeLabel = 'Function';
+            else if (captureMap['definition.class'])
+                nodeLabel = 'Class';
+            else if (captureMap['definition.interface'])
+                nodeLabel = 'Interface';
+            else if (captureMap['definition.method'])
+                nodeLabel = 'Method';
+            else if (captureMap['definition.struct'])
+                nodeLabel = 'Struct';
+            else if (captureMap['definition.enum'])
+                nodeLabel = 'Enum';
+            else if (captureMap['definition.namespace'])
+                nodeLabel = 'Namespace';
+            else if (captureMap['definition.module'])
+                nodeLabel = 'Module';
+            else if (captureMap['definition.trait'])
+                nodeLabel = 'Trait';
+            else if (captureMap['definition.impl'])
+                nodeLabel = 'Impl';
+            else if (captureMap['definition.type'])
+                nodeLabel = 'TypeAlias';
+            else if (captureMap['definition.const'])
+                nodeLabel = 'Const';
+            else if (captureMap['definition.static'])
+                nodeLabel = 'Static';
+            else if (captureMap['definition.typedef'])
+                nodeLabel = 'Typedef';
+            else if (captureMap['definition.macro'])
+                nodeLabel = 'Macro';
+            else if (captureMap['definition.union'])
+                nodeLabel = 'Union';
+            else if (captureMap['definition.property'])
+                nodeLabel = 'Property';
+            else if (captureMap['definition.record'])
+                nodeLabel = 'Record';
+            else if (captureMap['definition.delegate'])
+                nodeLabel = 'Delegate';
+            else if (captureMap['definition.annotation'])
+                nodeLabel = 'Annotation';
+            else if (captureMap['definition.constructor'])
+                nodeLabel = 'Constructor';
+            else if (captureMap['definition.template'])
+                nodeLabel = 'Template';
+            const definitionNodeForRange = getDefinitionNodeFromCaptures(captureMap);
+            const startLine = definitionNodeForRange ? definitionNodeForRange.startPosition.row : (nameNode ? nameNode.startPosition.row : 0);
+            const nodeId = generateId(nodeLabel, `${file.path}:${nodeName}`);
+            const definitionNode = getDefinitionNodeFromCaptures(captureMap);
+            const frameworkHint = definitionNode
+                ? detectFrameworkFromAST(language, (definitionNode.text || '').slice(0, 300))
+                : null;
+            // Extract method signature for Method/Constructor nodes
+            const methodSig = (nodeLabel === 'Function' || nodeLabel === 'Method' || nodeLabel === 'Constructor')
+                ? extractMethodSignature(definitionNode)
+                : undefined;
+            // Language-specific return type fallback (e.g. Ruby YARD @return)
+            if (methodSig && !methodSig.returnType && definitionNode) {
+                const tc = typeConfigs[language];
+                if (tc?.extractReturnType) {
+                    methodSig.returnType = tc.extractReturnType(definitionNode);
+                }
+            }
+            const node = {
+                id: nodeId,
+                label: nodeLabel,
+                properties: {
+                    name: nodeName,
+                    filePath: file.path,
+                    startLine: definitionNodeForRange ? definitionNodeForRange.startPosition.row : startLine,
+                    endLine: definitionNodeForRange ? definitionNodeForRange.endPosition.row : startLine,
+                    language: language,
+                    isExported: isNodeExported(nameNode || definitionNodeForRange, nodeName, language),
+                    ...(frameworkHint ? {
+                        astFrameworkMultiplier: frameworkHint.entryPointMultiplier,
+                        astFrameworkReason: frameworkHint.reason,
+                    } : {}),
+                    ...(methodSig ? {
+                        parameterCount: methodSig.parameterCount,
+                        returnType: methodSig.returnType,
+                    } : {}),
+                },
+            };
+            graph.addNode(node);
+            // Compute enclosing class for Method/Constructor/Property/Function
+            // Function 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 || definitionNodeForRange, file.path) : null;
+            symbolTable.add(file.path, nodeName, nodeId, nodeLabel, {
+                parameterCount: methodSig?.parameterCount,
+                returnType: methodSig?.returnType,
+                parameterTypes: methodSig?.parameterTypes,
+                ownerId: enclosingClassId ?? undefined,
+            });
+            const fileId = generateId('File', file.path);
+            const relId = generateId('DEFINES', `${fileId}->${nodeId}`);
+            const relationship = {
+                id: relId,
+                sourceId: fileId,
+                targetId: nodeId,
+                type: 'DEFINES',
+                confidence: 1.0,
+                reason: '',
+            };
+            graph.addRelationship(relationship);
+            // HAS_METHOD: link method/constructor/property to enclosing class
+            if (enclosingClassId) {
+                graph.addRelationship({
+                    id: generateId('HAS_METHOD', `${enclosingClassId}->${nodeId}`),
+                    sourceId: enclosingClassId,
+                    targetId: nodeId,
+                    type: 'HAS_METHOD',
+                    confidence: 1.0,
+                    reason: '',
+                });
+            }
+        });
+    }
+    if (skippedLanguages.size > 0) {
+        const summary = Array.from(skippedLanguages.entries())
+            .map(([lang, count]) => `${lang}: ${count}`)
+            .join(', ');
+        console.warn(`  Skipped unsupported languages: ${summary}`);
+    }
+};
+/** Parse files using worker pool with sequential fallback */
+export const processParsing = async (graph, files, symbolTable, astCache, onFileProgress, workerPool) => {
+    if (workerPool) {
+        try {
+            return await processParsingWithWorkers(graph, files, symbolTable, astCache, workerPool, onFileProgress);
+        }
+        catch (err) {
+            console.warn('Worker pool parsing failed, falling back to sequential:', err instanceof Error ? err.message : err);
+        }
+    }
+    // Fallback: sequential parsing
+    await processParsingSequential(graph, files, symbolTable, astCache, onFileProgress);
+    return null;
+};

package/dist/core/ingestion/pipeline.d.ts

@@ -0,0 +1,3 @@
+/** @file pipeline.ts @description Main ingestion pipeline that orchestrates scanning, parsing, resolution, community detection, and process detection across chunked file batches */
+import { PipelineProgress, PipelineResult } from '../../types/pipeline.js';
+export declare const runPipelineFromRepo: (repoPath: string, onProgress: (progress: PipelineProgress) => void) => Promise<PipelineResult>;