gitnexus 1.5.3 → 1.6.1

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

@@ -2,11 +2,13 @@ import Parser from 'tree-sitter';
 import { loadParser, loadLanguage, isLanguageAvailable } from '../tree-sitter/parser-loader.js';
 import { getProvider } from './languages/index.js';
 import { generateId } from '../../lib/utils.js';
-import { getLanguageFromFilename } from '../../_shared/index.js';
+import { getLanguageFromFilename, SupportedLanguages } from '../../_shared/index.js';
+import { extractVueScript, isVueSetupTopLevel } from './vue-sfc-extractor.js';
 import { yieldToEventLoop } from './utils/event-loop.js';
-import { getDefinitionNodeFromCaptures, findEnclosingClassId, extractMethodSignature, getLabelFromCaptures, CLASS_CONTAINER_TYPES, } from './utils/ast-helpers.js';
+import { getDefinitionNodeFromCaptures, findEnclosingClassInfo, getLabelFromCaptures, CLASS_CONTAINER_TYPES, } from './utils/ast-helpers.js';
 import { detectFrameworkFromAST } from './framework-detection.js';
 import { buildTypeEnv } from './type-env.js';
+import { buildMethodProps, arityForIdFromInfo, typeTagForId, constTagForId, buildCollisionGroups, } from './utils/method-props.js';
 import { getTreeSitterBufferSize, TREE_SITTER_MAX_BUFFER } from './constants.js';
 // ============================================================================
 // Worker-based parallel parsing
@@ -31,7 +33,7 @@ const processParsingWithWorkers = async (graph, files, symbolTable, astCache, wo
             toolDefs: [],
             ormQueries: [],
             constructorBindings: [],
-            typeEnvBindings: [],
+            fileScopeBindings: [],
         };
     const total = files.length;
     // Dispatch to worker pool — pool handles splitting into chunks and sub-batching
@@ -49,7 +51,7 @@ const processParsingWithWorkers = async (graph, files, symbolTable, astCache, wo
     const allToolDefs = [];
     const allORMQueries = [];
     const allConstructorBindings = [];
-    const allTypeEnvBindings = [];
+    const fileScopeBindingsByFile = [];
     for (const result of chunkResults) {
         for (const node of result.nodes) {
             graph.addNode({
@@ -69,20 +71,33 @@ const processParsingWithWorkers = async (graph, files, symbolTable, astCache, wo
                 returnType: sym.returnType,
                 declaredType: sym.declaredType,
                 ownerId: sym.ownerId,
+                qualifiedName: sym.qualifiedName,
             });
         }
-        allImports.push(...result.imports);
-        allCalls.push(...result.calls);
-        allAssignments.push(...result.assignments);
-        allHeritage.push(...result.heritage);
-        allRoutes.push(...result.routes);
-        allFetchCalls.push(...result.fetchCalls);
-        allDecoratorRoutes.push(...result.decoratorRoutes);
-        allToolDefs.push(...result.toolDefs);
+        for (const item of result.imports)
+            allImports.push(item);
+        for (const item of result.calls)
+            allCalls.push(item);
+        for (const item of result.assignments)
+            allAssignments.push(item);
+        for (const item of result.heritage)
+            allHeritage.push(item);
+        for (const item of result.routes)
+            allRoutes.push(item);
+        for (const item of result.fetchCalls)
+            allFetchCalls.push(item);
+        for (const item of result.decoratorRoutes)
+            allDecoratorRoutes.push(item);
+        for (const item of result.toolDefs)
+            allToolDefs.push(item);
         if (result.ormQueries)
-            allORMQueries.push(...result.ormQueries);
-        allConstructorBindings.push(...result.constructorBindings);
-        allTypeEnvBindings.push(...result.typeEnvBindings);
+            for (const item of result.ormQueries)
+                allORMQueries.push(item);
+        for (const item of result.constructorBindings)
+            allConstructorBindings.push(item);
+        if (result.fileScopeBindings)
+            for (const item of result.fileScopeBindings)
+                fileScopeBindingsByFile.push(item);
     }
     // Merge and log skipped languages from workers
     const skippedLanguages = new Map();
@@ -110,7 +125,7 @@ const processParsingWithWorkers = async (graph, files, symbolTable, astCache, wo
         toolDefs: allToolDefs,
         ormQueries: allORMQueries,
         constructorBindings: allConstructorBindings,
-        typeEnvBindings: allTypeEnvBindings,
+        fileScopeBindings: fileScopeBindingsByFile,
     };
 };
 // ============================================================================
@@ -118,14 +133,14 @@ const processParsingWithWorkers = async (graph, files, symbolTable, astCache, wo
 // ============================================================================
 // Inline caches to avoid repeated parent-walks per node (same pattern as parse-worker.ts).
 // Keyed by tree-sitter node reference — cleared at the start of each file.
-const classIdCache = new Map();
+const classInfoCache = new Map();
 const exportCache = new Map();
-const cachedFindEnclosingClassId = (node, filePath) => {
-    const cached = classIdCache.get(node);
+const cachedFindEnclosingClassInfo = (node, filePath, resolveEnclosingOwner) => {
+    const cached = classInfoCache.get(node);
     if (cached !== undefined)
         return cached;
-    const result = findEnclosingClassId(node, filePath);
-    classIdCache.set(node, result);
+    const result = findEnclosingClassInfo(node, filePath, resolveEnclosingOwner);
+    classInfoCache.set(node, result);
     return result;
 };
 const cachedExportCheck = (checker, node, name) => {
@@ -138,21 +153,46 @@ const cachedExportCheck = (checker, node, name) => {
 };
 // FieldExtractor cache for sequential path — same pattern as parse-worker.ts
 const seqFieldInfoCache = new Map();
-function seqFindEnclosingClassNode(node) {
+// MethodExtractor cache for sequential path — avoids re-traversing the same class
+// body once per method. Keyed on classNode.id (tree-sitter node identity number).
+const seqMethodExtractCache = new Map();
+// Derived method map + collision groups cache — avoids rebuilding per method.
+const seqMethodMapCache = new Map();
+/** Provider-aware enclosing container lookup.
+ *  Walks up from `node` until a CLASS_CONTAINER_TYPES node is found.
+ *  When `resolveEnclosingOwner` is provided, delegates language-specific
+ *  container remapping (e.g., Ruby singleton_class → enclosing class).
+ *  Without the hook, returns the first matching container directly (raw lookup). */
+function seqFindEnclosingOwnerNode(node, resolveEnclosingOwner) {
     let current = node.parent;
     while (current) {
-        if (CLASS_CONTAINER_TYPES.has(current.type))
+        if (CLASS_CONTAINER_TYPES.has(current.type)) {
+            if (resolveEnclosingOwner) {
+                const resolved = resolveEnclosingOwner(current);
+                if (resolved === null) {
+                    // Provider says skip this container — keep walking up.
+                    current = current.parent;
+                    continue;
+                }
+                return resolved;
+            }
             return current;
+        }
         current = current.parent;
     }
     return null;
 }
-/** Minimal no-op SymbolTable stub for FieldExtractorContext (sequential path has a real
- *  SymbolTable, but it's incomplete at this stage — use the stub for safety). */
+/** Minimal no-op SymbolTable stub for sequential extractor contexts. The real
+ *  SymbolTable is not fully populated yet at this stage, so use the stub for safety.
+ *  Implements the full {@link SymbolTableReader} surface so future extractor additions
+ *  don't silently fall off an `as unknown as` cast. */
 const NOOP_SYMBOL_TABLE_SEQ = {
-    lookupExactAll: () => [],
     lookupExact: () => undefined,
     lookupExactFull: () => undefined,
+    lookupExactAll: () => [],
+    lookupCallableByName: () => [],
+    getFiles: () => [][Symbol.iterator](),
+    getStats: () => ({ fileCount: 0 }),
 };
 function seqGetFieldInfo(classNode, provider, context) {
     if (!provider.fieldExtractor)
@@ -177,9 +217,11 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, onF
     for (let i = 0; i < files.length; i++) {
         const file = files[i];
         // Reset memoization before each new file (node refs are per-tree)
-        classIdCache.clear();
+        classInfoCache.clear();
         exportCache.clear();
         seqFieldInfoCache.clear();
+        seqMethodExtractCache.clear();
+        seqMethodMapCache.clear();
         onFileProgress?.(i + 1, total, file.path);
         if (i % 20 === 0)
             await yieldToEventLoop();
@@ -194,6 +236,18 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, onF
         // Skip files larger than the max tree-sitter buffer (32 MB)
         if (file.content.length > TREE_SITTER_MAX_BUFFER)
             continue;
+        // Vue SFC preprocessing: extract <script> block content
+        let parseContent = file.content;
+        let lineOffset = 0;
+        let isVueSetup = false;
+        if (language === SupportedLanguages.Vue) {
+            const extracted = extractVueScript(file.content);
+            if (!extracted)
+                continue; // skip .vue files with no script block
+            parseContent = extracted.scriptContent;
+            lineOffset = extracted.lineOffset;
+            isVueSetup = extracted.isSetup;
+        }
         try {
             await loadLanguage(language, file.path);
         }
@@ -202,8 +256,8 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, onF
         }
         let tree;
         try {
-            tree = parser.parse(file.content, undefined, {
-                bufferSize: getTreeSitterBufferSize(file.content.length),
+            tree = parser.parse(parseContent, undefined, {
+                bufferSize: getTreeSitterBufferSize(parseContent.length),
             });
         }
         catch (parseError) {
@@ -227,90 +281,172 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, onF
             console.warn(`Query error for ${file.path}:`, queryError);
             continue;
         }
-        // Build per-file type environment for FieldExtractor context (lightweight — skipped if no fieldExtractor)
+        // Build per-file type environment for FieldExtractor context (lightweight — skipped if no fieldExtractor).
+        //
+        // Note: this TypeEnv is intentionally NOT flushed into the BindingAccumulator.
+        // The accumulator feed happens later in `call-processor.ts` via its own
+        // `typeEnv.flush(accumulator)` call. Flushing here would double-count
+        // file-scope bindings and break the single-use invariant of `flush()`.
+        // See the BindingAccumulator class JSDoc for the full accumulator
+        // lifecycle and flush-site ownership rules.
         const typeEnv = provider.fieldExtractor
-            ? buildTypeEnv(tree, language, { enclosingFunctionFinder: provider.enclosingFunctionFinder })
+            ? buildTypeEnv(tree, language, {
+                enclosingFunctionFinder: provider.enclosingFunctionFinder,
+                extractFunctionName: provider.methodExtractor?.extractFunctionName,
+            })
             : null;
         matches.forEach((match) => {
             const captureMap = {};
             match.captures.forEach((c) => {
                 captureMap[c.name] = c.node;
             });
-            const nodeLabel = getLabelFromCaptures(captureMap, provider);
-            if (!nodeLabel)
+            const definitionNodeForRange = getDefinitionNodeFromCaptures(captureMap);
+            const definitionNode = getDefinitionNodeFromCaptures(captureMap);
+            const defaultNodeLabel = getLabelFromCaptures(captureMap, provider);
+            if (!defaultNodeLabel)
                 return;
             const nameNode = captureMap['name'];
+            const extractedClassSymbol = definitionNode && provider.classExtractor?.isTypeDeclaration(definitionNode)
+                ? provider.classExtractor.extract(definitionNode, {
+                    name: nameNode?.text,
+                    type: defaultNodeLabel,
+                })
+                : null;
+            const nodeLabel = extractedClassSymbol?.type ?? defaultNodeLabel;
             // Synthesize name for constructors without explicit @name capture (e.g. Swift init)
-            if (!nameNode && nodeLabel !== 'Constructor')
+            if (!nameNode && nodeLabel !== 'Constructor' && !extractedClassSymbol)
                 return;
-            const nodeName = nameNode ? nameNode.text : 'init';
-            const definitionNodeForRange = getDefinitionNodeFromCaptures(captureMap);
+            const nodeName = extractedClassSymbol?.name ?? (nameNode ? nameNode.text : 'init');
             const startLine = definitionNodeForRange
-                ? definitionNodeForRange.startPosition.row
+                ? definitionNodeForRange.startPosition.row + lineOffset
                 : 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))
+                    ? nameNode.startPosition.row + lineOffset
+                    : lineOffset;
+            // Compute enclosing class BEFORE node ID — needed to qualify method IDs
+            const needsOwner = nodeLabel === 'Method' ||
+                nodeLabel === 'Constructor' ||
+                nodeLabel === 'Property' ||
+                nodeLabel === 'Function';
+            const enclosingClassInfo = needsOwner
+                ? cachedFindEnclosingClassInfo(nameNode || definitionNodeForRange, file.path, provider.resolveEnclosingOwner)
                 : 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 [Type])
-            // Also upgrades uninformative AST types like PHP `array` with PHPDoc `@return User[]`
-            if (methodSig &&
-                (!methodSig.returnType ||
-                    methodSig.returnType === 'array' ||
-                    methodSig.returnType === 'iterable') &&
-                definitionNode) {
-                const tc = provider.typeConfig;
-                if (tc?.extractReturnType) {
-                    const docReturn = tc.extractReturnType(definitionNode);
-                    if (docReturn)
-                        methodSig.returnType = docReturn;
+            const enclosingClassId = enclosingClassInfo?.classId ?? null;
+            // Qualify method/property IDs with enclosing class name to avoid collisions
+            // e.g. "Method:animal.dart:Animal.speak" vs "Method:animal.dart:Dog.speak"
+            const qualifiedName = enclosingClassInfo
+                ? `${enclosingClassInfo.className}.${nodeName}`
+                : nodeName;
+            // Extract method metadata for Function/Method/Constructor nodes BEFORE generating
+            // the node ID — parameterCount is needed to disambiguate overloaded methods.
+            // Use the per-language MethodExtractor for method metadata (isAbstract, isStatic,
+            // visibility, annotations, parameterCount, parameterTypes, returnType, etc.).
+            const isMethodLike = nodeLabel === 'Function' || nodeLabel === 'Method' || nodeLabel === 'Constructor';
+            let methodProps = {};
+            let arityForId; // raw param count for ID, even for variadic
+            let seqDefMethodInfo;
+            let seqDefMethods;
+            let seqClassNodeId;
+            if (isMethodLike && definitionNode) {
+                let enriched = false;
+                if (provider.methodExtractor) {
+                    // Try class-based extraction (method inside a class/struct/trait body).
+                    // Raw lookup (no resolveEnclosingOwner) so the method extractor sees
+                    // the actual container node (e.g. singleton_class) for static detection.
+                    const methodOwnerNode = seqFindEnclosingOwnerNode(definitionNode);
+                    if (methodOwnerNode) {
+                        // Cache extract() results per class node to avoid re-traversing the
+                        // same class body for every method it contains (O(N) -> O(1) per hit).
+                        let result = seqMethodExtractCache.get(methodOwnerNode.id);
+                        if (result === undefined) {
+                            result =
+                                provider.methodExtractor.extract(methodOwnerNode, {
+                                    filePath: file.path,
+                                    language,
+                                }) ?? null;
+                            seqMethodExtractCache.set(methodOwnerNode.id, result);
+                        }
+                        if (result?.methods?.length) {
+                            const defLine = definitionNode.startPosition.row + 1;
+                            const info = result.methods.find((m) => m.name === nodeName && m.line === defLine);
+                            if (info) {
+                                enriched = true;
+                                arityForId = arityForIdFromInfo(info);
+                                methodProps = buildMethodProps(info);
+                                seqDefMethodInfo = info;
+                                seqDefMethods = result.methods;
+                                seqClassNodeId = methodOwnerNode.id;
+                            }
+                        }
+                    }
+                    // For top-level methods (e.g. Go method_declaration), try extractFromNode
+                    if (!enriched && provider.methodExtractor.extractFromNode) {
+                        const info = provider.methodExtractor.extractFromNode(definitionNode, {
+                            filePath: file.path,
+                            language,
+                        });
+                        if (info) {
+                            enriched = true;
+                            arityForId = arityForIdFromInfo(info);
+                            methodProps = buildMethodProps(info);
+                        }
+                    }
+                }
+            }
+            // Append #<paramCount> to Method/Constructor IDs to disambiguate overloads.
+            // Functions are not suffixed — they don't overload by name in the same scope.
+            // When same-arity collisions exist, append ~type1,type2 for further disambiguation.
+            const needsAritySuffix = nodeLabel === 'Method' || nodeLabel === 'Constructor';
+            let arityTag = needsAritySuffix && arityForId !== undefined ? `#${arityForId}` : '';
+            if (arityTag && seqDefMethods && seqDefMethodInfo && seqClassNodeId !== undefined) {
+                // Use cached method map + collision groups (built once per class, not per method)
+                let cached = seqMethodMapCache.get(seqClassNodeId);
+                if (!cached) {
+                    const tempMap = new Map();
+                    for (const m of seqDefMethods)
+                        tempMap.set(`${m.name}:${m.line}`, m);
+                    cached = { map: tempMap, groups: buildCollisionGroups(tempMap) };
+                    seqMethodMapCache.set(seqClassNodeId, cached);
                 }
+                arityTag += typeTagForId(cached.map, nodeName, arityForId, seqDefMethodInfo, language, cached.groups);
+                arityTag += constTagForId(cached.map, nodeName, arityForId, seqDefMethodInfo, cached.groups);
             }
+            const nodeId = generateId(nodeLabel, `${file.path}:${qualifiedName}${arityTag}`);
+            const classNodeForSymbol = definitionNodeForRange || definitionNode || nameNode;
+            const qualifiedTypeName = extractedClassSymbol?.qualifiedName ??
+                (classNodeForSymbol && provider.classExtractor?.isTypeDeclaration(classNodeForSymbol)
+                    ? (provider.classExtractor.extractQualifiedName(classNodeForSymbol, nodeName) ?? nodeName)
+                    : undefined);
+            const frameworkHint = definitionNode
+                ? detectFrameworkFromAST(language, (definitionNode.text || '').slice(0, 300))
+                : null;
             const node = {
                 id: nodeId,
                 label: nodeLabel,
                 properties: {
                     name: nodeName,
                     filePath: file.path,
-                    startLine: definitionNodeForRange ? definitionNodeForRange.startPosition.row : startLine,
-                    endLine: definitionNodeForRange ? definitionNodeForRange.endPosition.row : startLine,
+                    startLine: definitionNodeForRange
+                        ? definitionNodeForRange.startPosition.row + lineOffset
+                        : startLine,
+                    endLine: definitionNodeForRange
+                        ? definitionNodeForRange.endPosition.row + lineOffset
+                        : startLine,
                     language: language,
-                    isExported: cachedExportCheck(provider.exportChecker, nameNode || definitionNodeForRange, nodeName),
+                    isExported: language === SupportedLanguages.Vue && isVueSetup
+                        ? isVueSetupTopLevel(nameNode || definitionNodeForRange)
+                        : cachedExportCheck(provider.exportChecker, nameNode || definitionNodeForRange, nodeName),
+                    ...(qualifiedTypeName !== undefined ? { qualifiedName: qualifiedTypeName } : {}),
                     ...(frameworkHint
                         ? {
                             astFrameworkMultiplier: frameworkHint.entryPointMultiplier,
                             astFrameworkReason: frameworkHint.reason,
                         }
                         : {}),
-                    ...(methodSig
-                        ? {
-                            parameterCount: methodSig.parameterCount,
-                            ...(methodSig.requiredParameterCount !== undefined
-                                ? { requiredParameterCount: methodSig.requiredParameterCount }
-                                : {}),
-                            ...(methodSig.parameterTypes ? { parameterTypes: methodSig.parameterTypes } : {}),
-                            returnType: methodSig.returnType,
-                        }
-                        : {}),
+                    ...methodProps,
                 },
             };
             graph.addNode(node);
-            // 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
-                ? cachedFindEnclosingClassId(nameNode || definitionNodeForRange, file.path)
-                : null;
+            // enclosingClassId already computed above (before nodeId generation)
             // Extract declared type and field metadata for Property nodes
             let declaredType;
             let seqVisibility;
@@ -319,7 +455,7 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, onF
             if (nodeLabel === 'Property' && definitionNode) {
                 // FieldExtractor is the single source of truth when available
                 if (provider.fieldExtractor && typeEnv) {
-                    const classNode = seqFindEnclosingClassNode(definitionNode);
+                    const classNode = seqFindEnclosingOwnerNode(definitionNode, provider.resolveEnclosingOwner);
                     if (classNode) {
                         const fieldMap = seqGetFieldInfo(classNode, provider, {
                             typeEnv,
@@ -336,7 +472,7 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, onF
                         }
                     }
                 }
-                // All 14 languages register a FieldExtractor — no fallback needed.
+                // All 15 tree-sitter languages register a FieldExtractor — no fallback needed.
             }
             // Apply field metadata to the graph node retroactively
             if (seqVisibility !== undefined)
@@ -348,12 +484,13 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, onF
             if (declaredType !== undefined)
                 node.properties.declaredType = declaredType;
             symbolTable.add(file.path, nodeName, nodeId, nodeLabel, {
-                parameterCount: methodSig?.parameterCount,
-                requiredParameterCount: methodSig?.requiredParameterCount,
-                parameterTypes: methodSig?.parameterTypes,
-                returnType: methodSig?.returnType,
+                parameterCount: methodProps.parameterCount,
+                requiredParameterCount: methodProps.requiredParameterCount,
+                parameterTypes: methodProps.parameterTypes,
+                returnType: methodProps.returnType,
                 declaredType,
                 ownerId: enclosingClassId ?? undefined,
+                qualifiedName: qualifiedTypeName,
             });
             const fileId = generateId('File', file.path);
             const relId = generateId('DEFINES', `${fileId}->${nodeId}`);

package/dist/core/ingestion/pipeline-phases/cobol.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Phase: cobol
+ *
+ * Processes COBOL and JCL files via regex extraction (no tree-sitter).
+ *
+ * @deps    structure
+ * @reads   scannedFiles, allPaths (from structure phase)
+ * @writes  graph (COBOL program/paragraph/section nodes, JCL job/step nodes)
+ */
+import type { PipelinePhase } from './types.js';
+export interface CobolOutput {
+    programs: number;
+    paragraphs: number;
+    sections: number;
+}
+export declare const cobolPhase: PipelinePhase<CobolOutput>;

package/dist/core/ingestion/pipeline-phases/cobol.js

@@ -0,0 +1,45 @@
+/**
+ * Phase: cobol
+ *
+ * Processes COBOL and JCL files via regex extraction (no tree-sitter).
+ *
+ * @deps    structure
+ * @reads   scannedFiles, allPaths (from structure phase)
+ * @writes  graph (COBOL program/paragraph/section nodes, JCL job/step nodes)
+ */
+import { getPhaseOutput } from './types.js';
+import { processCobol, isCobolFile, isJclFile } from '../cobol-processor.js';
+import { readFileContents } from '../filesystem-walker.js';
+import { isDev } from '../utils/env.js';
+export const cobolPhase = {
+    name: 'cobol',
+    deps: ['structure'],
+    async execute(ctx, deps) {
+        const { scannedFiles, allPathSet } = getPhaseOutput(deps, 'structure');
+        const cobolScanned = scannedFiles.filter((f) => isCobolFile(f.path) || isJclFile(f.path));
+        if (cobolScanned.length === 0) {
+            return { programs: 0, paragraphs: 0, sections: 0 };
+        }
+        const cobolContents = await readFileContents(ctx.repoPath, cobolScanned.map((f) => f.path));
+        const cobolFiles = cobolScanned
+            .filter((f) => cobolContents.has(f.path))
+            .map((f) => ({ path: f.path, content: cobolContents.get(f.path) }));
+        const cobolResult = processCobol(ctx.graph, cobolFiles, allPathSet);
+        if (isDev) {
+            console.log(`  COBOL: ${cobolResult.programs} programs, ${cobolResult.paragraphs} paragraphs, ${cobolResult.sections} sections from ${cobolFiles.length} files`);
+            if (cobolResult.execSqlBlocks > 0 ||
+                cobolResult.execCicsBlocks > 0 ||
+                cobolResult.entryPoints > 0) {
+                console.log(`  COBOL enriched: ${cobolResult.execSqlBlocks} SQL blocks, ${cobolResult.execCicsBlocks} CICS blocks, ${cobolResult.entryPoints} entry points, ${cobolResult.moves} moves, ${cobolResult.fileDeclarations} file declarations`);
+            }
+            if (cobolResult.jclJobs > 0) {
+                console.log(`  JCL: ${cobolResult.jclJobs} jobs, ${cobolResult.jclSteps} steps`);
+            }
+        }
+        return {
+            programs: cobolResult.programs,
+            paragraphs: cobolResult.paragraphs,
+            sections: cobolResult.sections,
+        };
+    },
+};

package/dist/core/ingestion/pipeline-phases/communities.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Phase: communities
+ *
+ * Detects code communities via Leiden algorithm and creates
+ * Community nodes + MEMBER_OF edges.
+ *
+ * @deps    mro
+ * @reads   graph (all nodes and relationships)
+ * @writes  graph (Community nodes, MEMBER_OF edges)
+ */
+import type { PipelinePhase } from './types.js';
+import { type CommunityDetectionResult } from '../community-processor.js';
+export interface CommunitiesOutput {
+    communityResult: CommunityDetectionResult;
+}
+export declare const communitiesPhase: PipelinePhase<CommunitiesOutput>;

package/dist/core/ingestion/pipeline-phases/communities.js

@@ -0,0 +1,62 @@
+/**
+ * Phase: communities
+ *
+ * Detects code communities via Leiden algorithm and creates
+ * Community nodes + MEMBER_OF edges.
+ *
+ * @deps    mro
+ * @reads   graph (all nodes and relationships)
+ * @writes  graph (Community nodes, MEMBER_OF edges)
+ */
+import { getPhaseOutput } from './types.js';
+import { processCommunities } from '../community-processor.js';
+import { isDev } from '../utils/env.js';
+export const communitiesPhase = {
+    name: 'communities',
+    deps: ['mro', 'structure'],
+    async execute(ctx, deps) {
+        const { totalFiles } = getPhaseOutput(deps, 'structure');
+        ctx.onProgress({
+            phase: 'communities',
+            percent: 84,
+            message: 'Detecting code communities...',
+            stats: { filesProcessed: totalFiles, totalFiles, nodesCreated: ctx.graph.nodeCount },
+        });
+        const communityResult = await processCommunities(ctx.graph, (message, progress) => {
+            const communityProgress = 84 + progress * 0.09;
+            ctx.onProgress({
+                phase: 'communities',
+                percent: Math.round(communityProgress),
+                message,
+                stats: { filesProcessed: totalFiles, totalFiles, nodesCreated: ctx.graph.nodeCount },
+            });
+        });
+        if (isDev) {
+            console.log(`🏘️ Community detection: ${communityResult.stats.totalCommunities} communities found (modularity: ${communityResult.stats.modularity.toFixed(3)})`);
+        }
+        communityResult.communities.forEach((comm) => {
+            ctx.graph.addNode({
+                id: comm.id,
+                label: 'Community',
+                properties: {
+                    name: comm.label,
+                    filePath: '',
+                    heuristicLabel: comm.heuristicLabel,
+                    cohesion: comm.cohesion,
+                    symbolCount: comm.symbolCount,
+                },
+            });
+        });
+        communityResult.memberships.forEach((membership) => {
+            ctx.graph.addRelationship({
+                id: `${membership.nodeId}_member_of_${membership.communityId}`,
+                type: 'MEMBER_OF',
+                sourceId: membership.nodeId,
+                targetId: membership.communityId,
+                confidence: 1.0,
+                reason: 'leiden-algorithm',
+            });
+        });
+        return { communityResult };
+    },
+};

package/dist/core/ingestion/pipeline-phases/cross-file-impl.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Cross-file binding propagation — extracted from pipeline.ts.
+ *
+ * Seeds downstream files with resolved type bindings from upstream exports.
+ * Files are processed in topological import order so upstream bindings
+ * are available when downstream files are re-resolved.
+ *
+ * @module
+ */
+import type { createResolutionContext } from '../model/resolution-context.js';
+import { type PipelineProgress } from '../../../_shared/index.js';
+import type { KnowledgeGraph } from '../../graph/types.js';
+/**
+ * Cross-file binding propagation.
+ * Returns the number of files re-processed.
+ */
+export declare function runCrossFileBindingPropagation(graph: KnowledgeGraph, ctx: ReturnType<typeof createResolutionContext>, parseExportedTypeMap: ReadonlyMap<string, ReadonlyMap<string, string>>, allPathSet: ReadonlySet<string>, totalFiles: number, repoPath: string, pipelineStart: number, onProgress: (progress: PipelineProgress) => void): Promise<number>;