gitnexus 1.6.0 → 1.6.2-rc.1

package/dist/core/ingestion/method-extractors/generic.js

@@ -1,10 +1,53 @@
 // gitnexus/src/core/ingestion/method-extractors/generic.ts
-/** Owner node types where member functions are effectively static (JVM/Ruby semantics). */
-const STATIC_OWNER_TYPES = new Set(['companion_object', 'object_declaration', 'singleton_class']);
+/**
+ * Node types that imply static member semantics when they appear as the owner
+ * of a method (Kotlin companion objects, Kotlin top-level `object` declarations,
+ * Ruby `class << self` singleton classes). A config that lists any of these in
+ * `typeDeclarationNodes` MUST also include the same node type in
+ * `staticOwnerTypes` — otherwise methods inside these containers silently get
+ * `isStatic=false`, which is a correctness bug that previously only surfaced
+ * at analysis time on large repos.
+ *
+ * Opt-out: a config that sets `staticOwnerTypes: new Set()` (explicit empty
+ * set) signals "I handle static-ness entirely via isStatic()" and is exempt
+ * from the guard.
+ */
+const STATIC_IMPLYING_OWNER_TYPES = new Set([
+    'companion_object',
+    'object_declaration',
+    'singleton_class',
+]);
 /**
  * Create a MethodExtractor from a declarative config.
+ *
+ * @throws {Error} if `typeDeclarationNodes` contains a static-implying owner
+ *   type (companion_object / object_declaration / singleton_class) that is
+ *   not covered by `staticOwnerTypes`. The guard fires once per language at
+ *   provider construction to prevent silent `isStatic=false` regressions. See
+ *   `STATIC_IMPLYING_OWNER_TYPES` for the exact opt-out convention.
  */
 export function createMethodExtractor(config) {
+    // Runtime invariant: each static-implying container type declared in
+    // typeDeclarationNodes must be covered by staticOwnerTypes. An explicit
+    // empty Set is treated as intentional opt-out.
+    if (config.staticOwnerTypes === undefined) {
+        const missing = config.typeDeclarationNodes.filter((t) => STATIC_IMPLYING_OWNER_TYPES.has(t));
+        if (missing.length > 0) {
+            throw new Error(`[MethodExtractionConfig:${config.language}] typeDeclarationNodes includes static-implying owner type(s) ` +
+                `${JSON.stringify(missing)} but staticOwnerTypes is not set. Add ` +
+                `'staticOwnerTypes: new Set([${missing.map((t) => `'${t}'`).join(', ')}])' ` +
+                `to the config, or set 'staticOwnerTypes: new Set()' to opt out explicitly.`);
+        }
+    }
+    else {
+        const missing = config.typeDeclarationNodes.filter((t) => STATIC_IMPLYING_OWNER_TYPES.has(t) && !config.staticOwnerTypes.has(t));
+        // Explicit empty Set is the opt-out signal; don't second-guess it.
+        if (missing.length > 0 && config.staticOwnerTypes.size > 0) {
+            throw new Error(`[MethodExtractionConfig:${config.language}] typeDeclarationNodes includes static-implying owner type(s) ` +
+                `${JSON.stringify(missing)} that are missing from staticOwnerTypes. ` +
+                `Either add them to staticOwnerTypes, or set 'staticOwnerTypes: new Set()' to opt out explicitly.`);
+        }
+    }
     const typeDeclarationSet = new Set(config.typeDeclarationNodes);
     const methodNodeSet = new Set(config.methodNodeTypes);
     const bodyNodeSet = new Set(config.bodyNodeTypes);
@@ -137,8 +180,9 @@ function buildMethod(node, ownerNode, context, config) {
     // Domain invariant: abstract methods cannot be final
     if (isAbstract)
         isFinal = false;
-    // companion_object / object_declaration members are effectively static on JVM
-    const isStatic = STATIC_OWNER_TYPES.has(ownerNode.type) || config.isStatic(node);
+    // Static-owner detection is config-driven: each language declares which
+    // container node types imply static (e.g. Ruby singleton_class, Kotlin companion_object).
+    const isStatic = (config.staticOwnerTypes?.has(ownerNode.type) ?? false) || config.isStatic(node);
     return {
         name,
         receiverType: config.extractReceiverType?.(node) ?? null,

package/dist/core/ingestion/method-types.d.ts

@@ -73,6 +73,10 @@ export interface MethodExtractionConfig {
     isAsync?: (node: SyntaxNode) => boolean;
     isPartial?: (node: SyntaxNode) => boolean;
     isConst?: (node: SyntaxNode) => boolean;
+    /** Owner node types where member functions are effectively static (e.g.
+     *  Ruby singleton_class, Kotlin companion_object / object_declaration).
+     *  When the ownerNode matches one of these types, isStatic is forced true. */
+    staticOwnerTypes?: ReadonlySet<string>;
     /** Resolve the owner name from a standalone method node (e.g. Go receiver type). */
     extractOwnerName?: (node: SyntaxNode) => string | undefined;
     /** Extract a primary constructor from the owner node itself (e.g. C# 12 class Point(int x, int y)). */

package/dist/core/ingestion/model/resolve.js

@@ -47,63 +47,118 @@ function gatherAncestors(classId, parentMap) {
 export function c3Linearize(classId, parentMap, cache, inProgress) {
     if (cache.has(classId))
         return cache.get(classId);
-    // Cycle detection: if we're already computing this class, the hierarchy is cyclic
+    // Iterative C3 linearization using an explicit work stack. The recursive
+    // version overflows the call stack on deep class hierarchies (10K+
+    // levels in large Android/Java codebases).
+    //
+    // Strategy: maintain a stack of { classId, phase } frames. Each frame
+    // goes through two phases:
+    //   ENTER (0) – check cache / cycle, push parent frames to compute first
+    //   MERGE (1) – all parent linearizations are cached, merge them C3-style
     const visiting = inProgress ?? new Set();
-    if (visiting.has(classId)) {
-        cache.set(classId, null);
-        return null;
-    }
-    visiting.add(classId);
-    const directParents = parentMap.get(classId);
-    if (!directParents || directParents.length === 0) {
-        visiting.delete(classId);
-        cache.set(classId, []);
-        return [];
-    }
-    // Compute linearization for each parent first
-    const parentLinearizations = [];
-    for (const pid of directParents) {
-        const pLin = c3Linearize(pid, parentMap, cache, visiting);
-        if (pLin === null) {
-            visiting.delete(classId);
-            cache.set(classId, null);
-            return null;
-        }
-        parentLinearizations.push([pid, ...pLin]);
-    }
-    // Add the direct parents list as the final sequence
-    const sequences = [...parentLinearizations, [...directParents]];
-    const result = [];
-    while (sequences.some((s) => s.length > 0)) {
-        // Find a good head: one that doesn't appear in the tail of any other sequence
-        let head = null;
-        for (const seq of sequences) {
-            if (seq.length === 0)
+    const ENTER = 0;
+    const MERGE = 1;
+    const stack = [{ id: classId, phase: ENTER }];
+    while (stack.length > 0) {
+        const frame = stack[stack.length - 1];
+        if (frame.phase === ENTER) {
+            // ── ENTER phase ─────────────────────────────────────────────
+            if (cache.has(frame.id)) {
+                stack.pop();
+                continue;
+            }
+            if (visiting.has(frame.id)) {
+                // Cycle detected
+                cache.set(frame.id, null);
+                stack.pop();
+                continue;
+            }
+            visiting.add(frame.id);
+            const directParents = parentMap.get(frame.id);
+            if (!directParents || directParents.length === 0) {
+                visiting.delete(frame.id);
+                cache.set(frame.id, []);
+                stack.pop();
+                continue;
+            }
+            // Switch to MERGE phase and push parents that still need computing
+            frame.phase = MERGE;
+            let allParentsCached = true;
+            for (let i = directParents.length - 1; i >= 0; i--) {
+                const pid = directParents[i];
+                if (!cache.has(pid)) {
+                    stack.push({ id: pid, phase: ENTER });
+                    allParentsCached = false;
+                }
+            }
+            // If all parents are already cached, proceed directly to the MERGE
+            // phase below (frame.phase is already MERGE, frame is at stack top).
+            // Otherwise, loop back to process the newly-pushed parent frames first.
+            if (!allParentsCached) {
                 continue;
-            const candidate = seq[0];
-            const inTail = sequences.some((other) => other.length > 1 && other.indexOf(candidate, 1) !== -1);
-            if (!inTail) {
-                head = candidate;
+            }
+        }
+        // ── MERGE phase ───────────────────────────────────────────────
+        // directParents is guaranteed non-empty here — the ENTER phase already
+        // handles the empty-parents case and pops the frame before switching
+        // to MERGE.
+        stack.pop();
+        const directParents = parentMap.get(frame.id);
+        // Build parent linearizations from cache
+        const parentLinearizations = [];
+        let failed = false;
+        for (const pid of directParents) {
+            const pLin = cache.get(pid);
+            if (pLin === undefined) {
+                // Should not happen if phases are ordered correctly, but guard anyway
+                failed = true;
+                break;
+            }
+            if (pLin === null) {
+                // Parent linearization failed (cycle or inconsistent)
+                failed = true;
                 break;
             }
+            parentLinearizations.push([pid, ...pLin]);
         }
-        if (head === null) {
-            // Inconsistent hierarchy
-            visiting.delete(classId);
-            cache.set(classId, null);
-            return null;
+        if (failed) {
+            visiting.delete(frame.id);
+            cache.set(frame.id, null);
+            continue;
         }
-        result.push(head);
-        // Remove the chosen head from all sequences
-        for (const seq of sequences) {
-            if (seq.length > 0 && seq[0] === head) {
-                seq.shift();
+        // Add the direct parents list as the final sequence
+        const sequences = [...parentLinearizations, [...directParents]];
+        const result = [];
+        let inconsistent = false;
+        while (sequences.some((s) => s.length > 0)) {
+            // Find a good head: one that doesn't appear in the tail of any other sequence
+            let head = null;
+            for (const seq of sequences) {
+                if (seq.length === 0)
+                    continue;
+                const candidate = seq[0];
+                const inTail = sequences.some((other) => other.length > 1 && other.indexOf(candidate, 1) !== -1);
+                if (!inTail) {
+                    head = candidate;
+                    break;
+                }
+            }
+            if (head === null) {
+                inconsistent = true;
+                break;
+            }
+            result.push(head);
+            // Remove the chosen head from all sequences
+            for (const seq of sequences) {
+                if (seq.length > 0 && seq[0] === head) {
+                    seq.shift();
+                }
             }
         }
+        visiting.delete(frame.id);
+        cache.set(frame.id, inconsistent ? null : result);
     }
-    visiting.delete(classId);
-    cache.set(classId, result);
-    return result;
+    return cache.get(classId) ?? null;
 }
 // `gatherAncestors` is exported so mro-processor.ts can reuse the same
 // BFS traversal for graph-level MRO emission.

package/dist/core/ingestion/model/semantic-model.d.ts

@@ -7,7 +7,7 @@
  *   - A nested SymbolTable (file + callable name indexes) wrapped so
  *     that `add()` fans out into the registries via the dispatch table
  *
- * ## DAG direction
+ * ## Dependency direction
  *
  *     gitnexus-shared (NodeLabel)             — leaf
  *          ↑

package/dist/core/ingestion/model/semantic-model.js

@@ -7,7 +7,7 @@
  *   - A nested SymbolTable (file + callable name indexes) wrapped so
  *     that `add()` fans out into the registries via the dispatch table
  *
- * ## DAG direction
+ * ## Dependency direction
  *
  *     gitnexus-shared (NodeLabel)             — leaf
  *          ↑

package/dist/core/ingestion/model/symbol-table.d.ts

@@ -1,8 +1,8 @@
 /**
  * Symbol Table — file-indexed + callable-name symbol storage.
  *
- * This module is a PURE LEAF in the ingestion DAG. It owns two orthogonal
- * O(1) indexes:
+ * This module is a PURE LEAF in the ingestion dependency hierarchy. It owns
+ * two orthogonal O(1) indexes:
  *
  *   1. fileIndex      — Map<filePath, Map<name, SymbolDefinition[]>>
  *                       for same-file lookups (Tier 1 resolution)
@@ -10,12 +10,12 @@
  *                       for name-keyed callable lookups (Tier 3 widen)
  *
  * SymbolTable deliberately knows NOTHING about the owner-scoped registries
- * (types, methods, fields) that sit above it in the DAG. Those registries
- * live in `model/` and depend on SymbolTable, not the other way around.
- * {@link createSemanticModel} composes this pure SymbolTable with the
+ * (types, methods, fields) that sit above it in the dependency graph. Those
+ * registries live in `model/` and depend on SymbolTable, not the other way
+ * around. {@link createSemanticModel} composes this pure SymbolTable with the
  * registries and wraps `add()` to fan out registrations into both layers.
  *
- * DAG direction (strictly enforced):
+ * Dependency direction (strictly enforced):
  *
  *     gitnexus-shared (NodeLabel)       — leaf type
  *          ↑
@@ -31,7 +31,7 @@
  *
  * No arrow ever points downward from this file. If you are tempted to
  * import from `./model/` here, you are going the wrong way — move the
- * logic up the DAG instead.
+ * logic up the dependency chain instead.
  */
 import type { NodeLabel } from '../../../_shared/index.js';
 /**

package/dist/core/ingestion/model/symbol-table.js

@@ -1,8 +1,8 @@
 /**
  * Symbol Table — file-indexed + callable-name symbol storage.
  *
- * This module is a PURE LEAF in the ingestion DAG. It owns two orthogonal
- * O(1) indexes:
+ * This module is a PURE LEAF in the ingestion dependency hierarchy. It owns
+ * two orthogonal O(1) indexes:
  *
  *   1. fileIndex      — Map<filePath, Map<name, SymbolDefinition[]>>
  *                       for same-file lookups (Tier 1 resolution)
@@ -10,12 +10,12 @@
  *                       for name-keyed callable lookups (Tier 3 widen)
  *
  * SymbolTable deliberately knows NOTHING about the owner-scoped registries
- * (types, methods, fields) that sit above it in the DAG. Those registries
- * live in `model/` and depend on SymbolTable, not the other way around.
- * {@link createSemanticModel} composes this pure SymbolTable with the
+ * (types, methods, fields) that sit above it in the dependency graph. Those
+ * registries live in `model/` and depend on SymbolTable, not the other way
+ * around. {@link createSemanticModel} composes this pure SymbolTable with the
  * registries and wraps `add()` to fan out registrations into both layers.
  *
- * DAG direction (strictly enforced):
+ * Dependency direction (strictly enforced):
  *
  *     gitnexus-shared (NodeLabel)       — leaf type
  *          ↑
@@ -31,7 +31,7 @@
  *
  * No arrow ever points downward from this file. If you are tempted to
  * import from `./model/` here, you are going the wrong way — move the
- * logic up the DAG instead.
+ * logic up the dependency chain instead.
  */
 /**
  * Class-like NodeLabels — used for qualifiedName fallback inside

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

@@ -1,7 +1,7 @@
 /**
  * MRO (Method Resolution Order) Processor
  *
- * Walks the inheritance DAG (EXTENDS/IMPLEMENTS edges), collects methods from
+ * Walks the inheritance graph (EXTENDS/IMPLEMENTS edges), collects methods from
  * each ancestor via HAS_METHOD edges, detects method-name collisions across
  * parents, and applies language-specific resolution rules to emit METHOD_OVERRIDES edges.
  *

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

@@ -1,7 +1,7 @@
 /**
  * MRO (Method Resolution Order) Processor
  *
- * Walks the inheritance DAG (EXTENDS/IMPLEMENTS edges), collects methods from
+ * Walks the inheritance graph (EXTENDS/IMPLEMENTS edges), collects methods from
  * each ancestor via HAS_METHOD edges, detects method-name collisions across
  * parents, and applies language-specific resolution rules to emit METHOD_OVERRIDES edges.
  *

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

@@ -74,30 +74,30 @@ const processParsingWithWorkers = async (graph, files, symbolTable, astCache, wo
                 qualifiedName: sym.qualifiedName,
             });
         }
-        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);
+        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)
-            for (const _item of result.ormQueries)
-                allORMQueries.push(_item);
-        for (const _item of result.constructorBindings)
-            allConstructorBindings.push(_item);
+            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);
+            for (const item of result.fileScopeBindings)
+                fileScopeBindingsByFile.push(item);
     }
     // Merge and log skipped languages from workers
     const skippedLanguages = new Map();
@@ -135,11 +135,11 @@ const processParsingWithWorkers = async (graph, files, symbolTable, astCache, wo
 // Keyed by tree-sitter node reference — cleared at the start of each file.
 const classInfoCache = new Map();
 const exportCache = new Map();
-const cachedFindEnclosingClassInfo = (node, filePath) => {
+const cachedFindEnclosingClassInfo = (node, filePath, resolveEnclosingOwner) => {
     const cached = classInfoCache.get(node);
     if (cached !== undefined)
         return cached;
-    const result = findEnclosingClassInfo(node, filePath);
+    const result = findEnclosingClassInfo(node, filePath, resolveEnclosingOwner);
     classInfoCache.set(node, result);
     return result;
 };
@@ -158,24 +158,34 @@ const seqFieldInfoCache = new Map();
 const seqMethodExtractCache = new Map();
 // Derived method map + collision groups cache — avoids rebuilding per method.
 const seqMethodMapCache = new Map();
-function seqFindEnclosingClassNode(node) {
+/** 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)) {
-            // Return singleton_class directly so the method extractor sees it as
-            // the owner node and correctly marks methods as static. Name resolution
-            // for qualified names is handled separately by findEnclosingClassInfo.
+            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). Implements the full {@link SymbolTableReader}
- *  surface so future extractor additions don't silently fall off an
- *  `as unknown as` cast. */
+/** 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 = {
     lookupExact: () => undefined,
     lookupExactFull: () => undefined,
@@ -318,7 +328,7 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, onF
                 nodeLabel === 'Property' ||
                 nodeLabel === 'Function';
             const enclosingClassInfo = needsOwner
-                ? cachedFindEnclosingClassInfo(nameNode || definitionNodeForRange, file.path)
+                ? cachedFindEnclosingClassInfo(nameNode || definitionNodeForRange, file.path, provider.resolveEnclosingOwner)
                 : null;
             const enclosingClassId = enclosingClassInfo?.classId ?? null;
             // Qualify method/property IDs with enclosing class name to avoid collisions
@@ -339,19 +349,21 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, onF
             if (isMethodLike && definitionNode) {
                 let enriched = false;
                 if (provider.methodExtractor) {
-                    // Try class-based extraction (method inside a class/struct/trait body)
-                    const classNode = seqFindEnclosingClassNode(definitionNode);
-                    if (classNode) {
+                    // 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(classNode.id);
+                        let result = seqMethodExtractCache.get(methodOwnerNode.id);
                         if (result === undefined) {
                             result =
-                                provider.methodExtractor.extract(classNode, {
+                                provider.methodExtractor.extract(methodOwnerNode, {
                                     filePath: file.path,
                                     language,
                                 }) ?? null;
-                            seqMethodExtractCache.set(classNode.id, result);
+                            seqMethodExtractCache.set(methodOwnerNode.id, result);
                         }
                         if (result?.methods?.length) {
                             const defLine = definitionNode.startPosition.row + 1;
@@ -362,7 +374,7 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, onF
                                 methodProps = buildMethodProps(info);
                                 seqDefMethodInfo = info;
                                 seqDefMethods = result.methods;
-                                seqClassNodeId = classNode.id;
+                                seqClassNodeId = methodOwnerNode.id;
                             }
                         }
                     }
@@ -443,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,

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>;