gitnexus 1.5.3 → 1.6.1

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

@@ -0,0 +1,156 @@
+/**
+ * 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 { processCalls, buildImportedReturnTypes, buildImportedRawReturnTypes, } from '../call-processor.js';
+import { createASTCache } from '../ast-cache.js';
+import { getLanguageFromFilename } from '../../../_shared/index.js';
+import { readFileContents } from '../filesystem-walker.js';
+import { isLanguageAvailable } from '../../tree-sitter/parser-loader.js';
+import { topologicalLevelSort } from '../utils/graph-sort.js';
+import { isDev } from '../utils/env.js';
+/** Max AST trees to keep in LRU cache for cross-file binding propagation. */
+const AST_CACHE_CAP = 50;
+/** Minimum percentage of files that must benefit from cross-file seeding. */
+const CROSS_FILE_SKIP_THRESHOLD = 0.03;
+/** Hard cap on files re-processed during cross-file propagation. */
+const MAX_CROSS_FILE_REPROCESS = 2000;
+/**
+ * Cross-file binding propagation.
+ * Returns the number of files re-processed.
+ */
+export async function runCrossFileBindingPropagation(graph, ctx, parseExportedTypeMap, allPathSet, totalFiles, repoPath, pipelineStart, onProgress) {
+    if (parseExportedTypeMap.size === 0 || ctx.namedImportMap.size === 0)
+        return 0;
+    // Build a local mutable working copy. Per-file re-resolution below mutates
+    // this map (each `processCalls` writes that file's exports back into it so
+    // later iterations in the same level/loop can resolve transitive bindings).
+    // Owning a local copy here keeps `ParseOutput.exportedTypeMap` truly
+    // read-only at the phase boundary — no cast, no shared-mutable handoff.
+    const exportedTypeMap = new Map();
+    for (const [fp, exports] of parseExportedTypeMap) {
+        exportedTypeMap.set(fp, new Map(exports));
+    }
+    const { levels, cycleCount } = topologicalLevelSort(ctx.importMap);
+    if (isDev && cycleCount > 0) {
+        console.log(`🔄 ${cycleCount} files in import cycles (processed last in undefined order)`);
+    }
+    let filesWithGaps = 0;
+    const gapThreshold = Math.max(1, Math.ceil(totalFiles * CROSS_FILE_SKIP_THRESHOLD));
+    outer: for (const level of levels) {
+        for (const filePath of level) {
+            const imports = ctx.namedImportMap.get(filePath);
+            if (!imports)
+                continue;
+            for (const [, binding] of imports) {
+                const upstream = exportedTypeMap.get(binding.sourcePath);
+                if (upstream?.has(binding.exportedName)) {
+                    filesWithGaps++;
+                    break;
+                }
+                const def = ctx.model.symbols.lookupExactFull(binding.sourcePath, binding.exportedName);
+                if (def?.returnType) {
+                    filesWithGaps++;
+                    break;
+                }
+            }
+            if (filesWithGaps >= gapThreshold)
+                break outer;
+        }
+    }
+    const gapRatio = totalFiles > 0 ? filesWithGaps / totalFiles : 0;
+    if (gapRatio < CROSS_FILE_SKIP_THRESHOLD && filesWithGaps < gapThreshold) {
+        if (isDev) {
+            console.log(`⏭️ Cross-file re-resolution skipped (${filesWithGaps}/${totalFiles} files, ${(gapRatio * 100).toFixed(1)}% < ${CROSS_FILE_SKIP_THRESHOLD * 100}% threshold)`);
+        }
+        return 0;
+    }
+    // Intentionally reports `phase: 'parsing'` rather than a separate
+    // 'crossFile' phase: cross-file re-resolution is logically a continuation of
+    // the parsing/resolution work and is bucketed under "parsing" in any
+    // telemetry that groups events by phase name. Kept consistent with the
+    // upstream `parse` phase's progress events so the UI shows one continuous
+    // progress segment instead of a phase flicker. If a future change splits
+    // this out into its own phase, also rename `parse-impl.ts` per-chunk
+    // progress events accordingly.
+    onProgress({
+        phase: 'parsing',
+        percent: 82,
+        message: `Cross-file type propagation (${filesWithGaps}+ files)...`,
+        stats: { filesProcessed: totalFiles, totalFiles, nodesCreated: graph.nodeCount },
+    });
+    let crossFileResolved = 0;
+    const crossFileStart = Date.now();
+    const astCache = createASTCache(AST_CACHE_CAP);
+    for (const level of levels) {
+        const levelCandidates = [];
+        for (const filePath of level) {
+            if (crossFileResolved + levelCandidates.length >= MAX_CROSS_FILE_REPROCESS)
+                break;
+            const imports = ctx.namedImportMap.get(filePath);
+            if (!imports)
+                continue;
+            const seeded = new Map();
+            for (const [localName, binding] of imports) {
+                const upstream = exportedTypeMap.get(binding.sourcePath);
+                if (upstream) {
+                    const type = upstream.get(binding.exportedName);
+                    if (type)
+                        seeded.set(localName, type);
+                }
+            }
+            const importedReturns = buildImportedReturnTypes(filePath, ctx.namedImportMap, ctx.model.symbols);
+            const importedRawReturns = buildImportedRawReturnTypes(filePath, ctx.namedImportMap, ctx.model.symbols);
+            if (seeded.size === 0 && importedReturns.size === 0)
+                continue;
+            if (!allPathSet.has(filePath))
+                continue;
+            const lang = getLanguageFromFilename(filePath);
+            if (!lang || !isLanguageAvailable(lang))
+                continue;
+            levelCandidates.push({ filePath, seeded, importedReturns, importedRawReturns });
+        }
+        if (levelCandidates.length === 0)
+            continue;
+        const levelPaths = levelCandidates.map((c) => c.filePath);
+        const contentMap = await readFileContents(repoPath, levelPaths);
+        for (const { filePath, seeded, importedReturns, importedRawReturns } of levelCandidates) {
+            const content = contentMap.get(filePath);
+            if (!content)
+                continue;
+            const reFile = [{ path: filePath, content }];
+            const bindings = new Map();
+            if (seeded.size > 0)
+                bindings.set(filePath, seeded);
+            const importedReturnTypesMap = new Map();
+            if (importedReturns.size > 0) {
+                importedReturnTypesMap.set(filePath, importedReturns);
+            }
+            const importedRawReturnTypesMap = new Map();
+            if (importedRawReturns.size > 0) {
+                importedRawReturnTypesMap.set(filePath, importedRawReturns);
+            }
+            await processCalls(graph, reFile, astCache, ctx, undefined, exportedTypeMap, bindings.size > 0 ? bindings : undefined, importedReturnTypesMap.size > 0 ? importedReturnTypesMap : undefined, importedRawReturnTypesMap.size > 0 ? importedRawReturnTypesMap : undefined);
+            crossFileResolved++;
+        }
+        if (crossFileResolved >= MAX_CROSS_FILE_REPROCESS) {
+            if (isDev)
+                console.log(`⚠️ Cross-file re-resolution capped at ${MAX_CROSS_FILE_REPROCESS} files`);
+            break;
+        }
+    }
+    astCache.clear();
+    if (isDev) {
+        const elapsed = Date.now() - crossFileStart;
+        const totalElapsed = Date.now() - pipelineStart;
+        const reResolutionPct = totalElapsed > 0 ? ((elapsed / totalElapsed) * 100).toFixed(1) : '0';
+        console.log(`🔗 Cross-file re-resolution: ${crossFileResolved} candidates re-processed` +
+            ` in ${elapsed}ms (${reResolutionPct}% of total ingestion time so far)`);
+    }
+    return crossFileResolved;
+}

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

@@ -0,0 +1,37 @@
+/**
+ * Phase: crossFile
+ *
+ * Cross-file binding propagation: 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.
+ *
+ * @deps    parse, routes, tools, orm (waits for all post-parse phases)
+ * @reads   exportedTypeMap, allPaths, totalFiles
+ * @writes  graph (refined CALLS edges via re-resolution)
+ *
+ * **Accumulator ownership / residual risk.** This phase is the sole
+ * disposer of the `BindingAccumulator` produced by `parse`. The dispose
+ * call lives inside a `finally` block in `execute()` so that a throw
+ * inside `runCrossFileBindingPropagation` (or anywhere else in the body)
+ * still releases the accumulator's heap. The dependency declaration
+ * (`deps: ['parse', 'routes', 'tools', 'orm']`) plus the runner's
+ * topological scheduling guarantee that every other consumer of the
+ * accumulator has finished before this phase starts, so disposing here
+ * is correct.
+ *
+ * The residual risk is intentional and accepted: if a future phase is
+ * inserted between `parse` and `crossFile` that reads the accumulator
+ * and throws, `crossFile.execute()` never runs and the accumulator
+ * leaks. Any author inserting a new phase between `parse` and
+ * `crossFile` MUST either route the new phase's output through
+ * `crossFile` (so disposal still happens here) or take ownership of
+ * the accumulator's lifetime explicitly (its own try/finally that
+ * disposes on the failure path). Do not silently rely on the GC.
+ */
+import type { PipelinePhase } from './types.js';
+export interface CrossFileOutput {
+    /** Number of files re-processed during cross-file propagation. */
+    filesReprocessed: number;
+}
+export declare const crossFilePhase: PipelinePhase<CrossFileOutput>;

package/dist/core/ingestion/pipeline-phases/cross-file.js

@@ -0,0 +1,63 @@
+/**
+ * Phase: crossFile
+ *
+ * Cross-file binding propagation: 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.
+ *
+ * @deps    parse, routes, tools, orm (waits for all post-parse phases)
+ * @reads   exportedTypeMap, allPaths, totalFiles
+ * @writes  graph (refined CALLS edges via re-resolution)
+ *
+ * **Accumulator ownership / residual risk.** This phase is the sole
+ * disposer of the `BindingAccumulator` produced by `parse`. The dispose
+ * call lives inside a `finally` block in `execute()` so that a throw
+ * inside `runCrossFileBindingPropagation` (or anywhere else in the body)
+ * still releases the accumulator's heap. The dependency declaration
+ * (`deps: ['parse', 'routes', 'tools', 'orm']`) plus the runner's
+ * topological scheduling guarantee that every other consumer of the
+ * accumulator has finished before this phase starts, so disposing here
+ * is correct.
+ *
+ * The residual risk is intentional and accepted: if a future phase is
+ * inserted between `parse` and `crossFile` that reads the accumulator
+ * and throws, `crossFile.execute()` never runs and the accumulator
+ * leaks. Any author inserting a new phase between `parse` and
+ * `crossFile` MUST either route the new phase's output through
+ * `crossFile` (so disposal still happens here) or take ownership of
+ * the accumulator's lifetime explicitly (its own try/finally that
+ * disposes on the failure path). Do not silently rely on the GC.
+ */
+import { getPhaseOutput } from './types.js';
+import { runCrossFileBindingPropagation } from './cross-file-impl.js';
+import { isDev } from '../utils/env.js';
+export const crossFilePhase = {
+    name: 'crossFile',
+    deps: ['parse', 'routes', 'tools', 'orm'],
+    async execute(ctx, deps) {
+        const { exportedTypeMap, allPathSet, totalFiles, bindingAccumulator, resolutionContext } = getPhaseOutput(deps, 'parse');
+        try {
+            // Telemetry must run BEFORE dispose: totalBindings, fileCount, and
+            // estimateMemoryBytes() all return 0 once dispose() clears the
+            // internal maps.
+            if (isDev) {
+                if (bindingAccumulator.totalBindings > 0) {
+                    const memKB = Math.round(bindingAccumulator.estimateMemoryBytes() / 1024);
+                    console.log(`📦 BindingAccumulator: ${bindingAccumulator.totalBindings} bindings across ${bindingAccumulator.fileCount} files (~${memKB} KB)`);
+                }
+                else if (totalFiles > 0) {
+                    console.log(`📦 BindingAccumulator: EMPTY — 0 bindings across 0 files despite ${totalFiles} parsed files. If the codebase has typed bindings, this indicates an upstream regression.`);
+                }
+            }
+            const filesReprocessed = await runCrossFileBindingPropagation(ctx.graph, resolutionContext, exportedTypeMap, allPathSet, totalFiles, ctx.repoPath, ctx.pipelineStart, ctx.onProgress);
+            return { filesReprocessed };
+        }
+        finally {
+            // Single dispose call site for the accumulator — runs on both the
+            // happy path and the throw path so the heap is always released
+            // before the runner moves on (or surfaces the error).
+            bindingAccumulator.dispose();
+        }
+    },
+};

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

@@ -0,0 +1,21 @@
+/**
+ * Pipeline Phases — barrel export.
+ *
+ * Exports all phases, the runner, types, and shared utilities
+ * for the ingestion pipeline.
+ */
+export { scanPhase, type ScanOutput } from './scan.js';
+export { structurePhase, type StructureOutput } from './structure.js';
+export { markdownPhase, type MarkdownOutput } from './markdown.js';
+export { cobolPhase, type CobolOutput } from './cobol.js';
+export { parsePhase, type ParseOutput } from './parse.js';
+export { routesPhase, type RoutesOutput, type RouteEntry } from './routes.js';
+export { toolsPhase, type ToolsOutput, type ToolDef } from './tools.js';
+export { ormPhase, type ORMOutput } from './orm.js';
+export { crossFilePhase, type CrossFileOutput } from './cross-file.js';
+export { mroPhase, type MROOutput } from './mro.js';
+export { communitiesPhase, type CommunitiesOutput } from './communities.js';
+export { processesPhase, type ProcessesOutput } from './processes.js';
+export { runPipeline } from './runner.js';
+export type { PipelinePhase, PipelineContext, PhaseResult } from './types.js';
+export { getPhaseOutput } from './types.js';

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

@@ -0,0 +1,22 @@
+/**
+ * Pipeline Phases — barrel export.
+ *
+ * Exports all phases, the runner, types, and shared utilities
+ * for the ingestion pipeline.
+ */
+// ── Phase exports (in dependency order) ────────────────────────────────────
+export { scanPhase } from './scan.js';
+export { structurePhase } from './structure.js';
+export { markdownPhase } from './markdown.js';
+export { cobolPhase } from './cobol.js';
+export { parsePhase } from './parse.js';
+export { routesPhase } from './routes.js';
+export { toolsPhase } from './tools.js';
+export { ormPhase } from './orm.js';
+export { crossFilePhase } from './cross-file.js';
+export { mroPhase } from './mro.js';
+export { communitiesPhase } from './communities.js';
+export { processesPhase } from './processes.js';
+// ── Infrastructure ─────────────────────────────────────────────────────────
+export { runPipeline } from './runner.js';
+export { getPhaseOutput } from './types.js';

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

@@ -0,0 +1,17 @@
+/**
+ * Phase: markdown
+ *
+ * Processes Markdown/MDX files to extract headings and cross-links.
+ *
+ * @deps    structure
+ * @reads   scannedFiles, allPaths (from structure phase)
+ * @writes  graph (Markdown section nodes + cross-link edges)
+ */
+import type { PipelinePhase } from './types.js';
+export interface MarkdownOutput {
+    /** Number of markdown sections extracted. */
+    sections: number;
+    /** Number of cross-links created. */
+    links: number;
+}
+export declare const markdownPhase: PipelinePhase<MarkdownOutput>;

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

@@ -0,0 +1,33 @@
+/**
+ * Phase: markdown
+ *
+ * Processes Markdown/MDX files to extract headings and cross-links.
+ *
+ * @deps    structure
+ * @reads   scannedFiles, allPaths (from structure phase)
+ * @writes  graph (Markdown section nodes + cross-link edges)
+ */
+import { getPhaseOutput } from './types.js';
+import { processMarkdown } from '../markdown-processor.js';
+import { readFileContents } from '../filesystem-walker.js';
+import { isDev } from '../utils/env.js';
+export const markdownPhase = {
+    name: 'markdown',
+    deps: ['structure'],
+    async execute(ctx, deps) {
+        const { scannedFiles, allPathSet } = getPhaseOutput(deps, 'structure');
+        const mdScanned = scannedFiles.filter((f) => f.path.endsWith('.md') || f.path.endsWith('.mdx'));
+        if (mdScanned.length === 0) {
+            return { sections: 0, links: 0 };
+        }
+        const mdContents = await readFileContents(ctx.repoPath, mdScanned.map((f) => f.path));
+        const mdFiles = mdScanned
+            .filter((f) => mdContents.has(f.path))
+            .map((f) => ({ path: f.path, content: mdContents.get(f.path) }));
+        const mdResult = processMarkdown(ctx.graph, mdFiles, allPathSet);
+        if (isDev) {
+            console.log(`  Markdown: ${mdResult.sections} sections, ${mdResult.links} cross-links from ${mdFiles.length} files`);
+        }
+        return { sections: mdResult.sections, links: mdResult.links };
+    },
+};

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

@@ -0,0 +1,18 @@
+/**
+ * Phase: mro
+ *
+ * Computes Method Resolution Order (MRO) and creates METHOD_OVERRIDES
+ * and METHOD_IMPLEMENTS edges.
+ *
+ * @deps    crossFile
+ * @reads   graph (all nodes and relationships)
+ * @writes  graph (METHOD_OVERRIDES, METHOD_IMPLEMENTS edges)
+ */
+import type { PipelinePhase } from './types.js';
+export interface MROOutput {
+    entries: number;
+    ambiguityCount: number;
+    overrideEdges: number;
+    methodImplementsEdges: number;
+}
+export declare const mroPhase: PipelinePhase<MROOutput>;

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

@@ -0,0 +1,36 @@
+/**
+ * Phase: mro
+ *
+ * Computes Method Resolution Order (MRO) and creates METHOD_OVERRIDES
+ * and METHOD_IMPLEMENTS edges.
+ *
+ * @deps    crossFile
+ * @reads   graph (all nodes and relationships)
+ * @writes  graph (METHOD_OVERRIDES, METHOD_IMPLEMENTS edges)
+ */
+import { getPhaseOutput } from './types.js';
+import { computeMRO } from '../mro-processor.js';
+import { isDev } from '../utils/env.js';
+export const mroPhase = {
+    name: 'mro',
+    deps: ['crossFile', 'structure'],
+    async execute(ctx, deps) {
+        const { totalFiles } = getPhaseOutput(deps, 'structure');
+        ctx.onProgress({
+            phase: 'enriching',
+            percent: 83,
+            message: 'Computing method resolution order...',
+            stats: { filesProcessed: totalFiles, totalFiles, nodesCreated: ctx.graph.nodeCount },
+        });
+        const mroResult = computeMRO(ctx.graph);
+        if (isDev && mroResult.entries.length > 0) {
+            console.log(`🔀 MRO: ${mroResult.entries.length} classes analyzed, ${mroResult.ambiguityCount} ambiguities, ${mroResult.overrideEdges} METHOD_OVERRIDES, ${mroResult.methodImplementsEdges} METHOD_IMPLEMENTS`);
+        }
+        return {
+            entries: mroResult.entries.length,
+            ambiguityCount: mroResult.ambiguityCount,
+            overrideEdges: mroResult.overrideEdges,
+            methodImplementsEdges: mroResult.methodImplementsEdges,
+        };
+    },
+};

package/dist/core/ingestion/pipeline-phases/orm-extraction.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Inline ORM query extraction (sequential fallback path).
+ *
+ * Extracts Prisma and Supabase query calls from source content using
+ * regex patterns. Used by the sequential parse path when workers are
+ * not available — the worker path extracts ORM queries via tree-sitter
+ * queries instead.
+ *
+ * @module
+ */
+import type { ExtractedORMQuery } from '../workers/parse-worker.js';
+/**
+ * Extract ORM query calls from file content using regex.
+ *
+ * Fast-path: skips files that don't contain `prisma.` or `supabase.from`.
+ * Results are appended to the `out` array (push pattern avoids allocation).
+ *
+ * @param filePath  Relative path of the source file
+ * @param content   File content string
+ * @param out       Output array to append extracted queries to
+ */
+export declare function extractORMQueriesInline(filePath: string, content: string, out: ExtractedORMQuery[]): void;

package/dist/core/ingestion/pipeline-phases/orm-extraction.js

@@ -0,0 +1,92 @@
+/**
+ * Inline ORM query extraction (sequential fallback path).
+ *
+ * Extracts Prisma and Supabase query calls from source content using
+ * regex patterns. Used by the sequential parse path when workers are
+ * not available — the worker path extracts ORM queries via tree-sitter
+ * queries instead.
+ *
+ * @module
+ */
+// ── Regex patterns ─────────────────────────────────────────────────────────
+/** Matches Prisma client method calls: `prisma.user.findMany(...)` */
+const PRISMA_QUERY_RE = /\bprisma\.(\w+)\.(findMany|findFirst|findUnique|findUniqueOrThrow|findFirstOrThrow|create|createMany|update|updateMany|delete|deleteMany|upsert|count|aggregate|groupBy)\s*\(/g;
+/** Matches Supabase client method calls: `supabase.from('users').select(...)` */
+const SUPABASE_QUERY_RE = /\bsupabase\.from\s*\(\s*['"](\w+)['"]\s*\)\s*\.(select|insert|update|delete|upsert)\s*\(/g;
+// ── Extraction function ───────────────────────────────────────────────────
+/**
+ * Extract ORM query calls from file content using regex.
+ *
+ * Fast-path: skips files that don't contain `prisma.` or `supabase.from`.
+ * Results are appended to the `out` array (push pattern avoids allocation).
+ *
+ * @param filePath  Relative path of the source file
+ * @param content   File content string
+ * @param out       Output array to append extracted queries to
+ */
+export function extractORMQueriesInline(filePath, content, out) {
+    const hasPrisma = content.includes('prisma.');
+    const hasSupabase = content.includes('supabase.from');
+    if (!hasPrisma && !hasSupabase)
+        return;
+    // Pre-compute line number offsets to avoid O(n²) substring+split per match
+    const lineOffsets = buildLineOffsets(content);
+    if (hasPrisma) {
+        PRISMA_QUERY_RE.lastIndex = 0;
+        let m;
+        while ((m = PRISMA_QUERY_RE.exec(content)) !== null) {
+            const model = m[1];
+            if (model.startsWith('$'))
+                continue;
+            out.push({
+                filePath,
+                orm: 'prisma',
+                model,
+                method: m[2],
+                lineNumber: lineNumberAtOffset(lineOffsets, m.index),
+            });
+        }
+    }
+    if (hasSupabase) {
+        SUPABASE_QUERY_RE.lastIndex = 0;
+        let m;
+        while ((m = SUPABASE_QUERY_RE.exec(content)) !== null) {
+            out.push({
+                filePath,
+                orm: 'supabase',
+                model: m[1],
+                method: m[2],
+                lineNumber: lineNumberAtOffset(lineOffsets, m.index),
+            });
+        }
+    }
+}
+// ── Line offset helpers ───────────────────────────────────────────────────
+/** Build an array of byte offsets where each newline occurs (O(n) once). */
+function buildLineOffsets(content) {
+    const offsets = [];
+    for (let i = 0; i < content.length; i++) {
+        if (content[i] === '\n')
+            offsets.push(i);
+    }
+    return offsets;
+}
+/**
+ * Binary search for 0-based line number at a given character offset.
+ *
+ * Returns the number of newlines that occur before `offset` in the content,
+ * which is the 0-based line number. When `offset` is beyond the last newline,
+ * returns `lineOffsets.length` (i.e., the last line index).
+ */
+function lineNumberAtOffset(lineOffsets, offset) {
+    let lo = 0;
+    let hi = lineOffsets.length;
+    while (lo < hi) {
+        const mid = (lo + hi) >>> 1;
+        if (lineOffsets[mid] < offset)
+            lo = mid + 1;
+        else
+            hi = mid;
+    }
+    return lo;
+}

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

@@ -0,0 +1,15 @@
+/**
+ * Phase: orm
+ *
+ * Processes ORM queries (Prisma + Supabase) and creates QUERIES edges.
+ *
+ * @deps    parse
+ * @reads   allORMQueries (from parse)
+ * @writes  graph (CodeElement nodes, QUERIES edges)
+ */
+import type { PipelinePhase } from './types.js';
+export interface ORMOutput {
+    edgesCreated: number;
+    modelCount: number;
+}
+export declare const ormPhase: PipelinePhase<ORMOutput>;

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

@@ -0,0 +1,74 @@
+/**
+ * Phase: orm
+ *
+ * Processes ORM queries (Prisma + Supabase) and creates QUERIES edges.
+ *
+ * @deps    parse
+ * @reads   allORMQueries (from parse)
+ * @writes  graph (CodeElement nodes, QUERIES edges)
+ */
+import { getPhaseOutput } from './types.js';
+import { generateId } from '../../../lib/utils.js';
+import { isDev } from '../utils/env.js';
+export const ormPhase = {
+    name: 'orm',
+    deps: ['parse'],
+    async execute(ctx, deps) {
+        const { allORMQueries } = getPhaseOutput(deps, 'parse');
+        if (allORMQueries.length === 0) {
+            return { edgesCreated: 0, modelCount: 0 };
+        }
+        return processORMQueries(ctx.graph, allORMQueries);
+    },
+};
+function processORMQueries(graph, queries) {
+    const modelNodes = new Map();
+    const seenEdges = new Set();
+    let edgesCreated = 0;
+    for (const q of queries) {
+        const modelKey = `${q.orm}:${q.model}`;
+        let modelNodeId = modelNodes.get(modelKey);
+        if (!modelNodeId) {
+            const candidateIds = [
+                generateId('Class', `${q.model}`),
+                generateId('Interface', `${q.model}`),
+                generateId('CodeElement', `${q.model}`),
+            ];
+            const existing = candidateIds.find((id) => graph.getNode(id));
+            if (existing) {
+                modelNodeId = existing;
+            }
+            else {
+                modelNodeId = generateId('CodeElement', `${q.orm}:${q.model}`);
+                graph.addNode({
+                    id: modelNodeId,
+                    label: 'CodeElement',
+                    properties: {
+                        name: q.model,
+                        filePath: '',
+                        description: `${q.orm} model/table: ${q.model}`,
+                    },
+                });
+            }
+            modelNodes.set(modelKey, modelNodeId);
+        }
+        const fileId = generateId('File', q.filePath);
+        const edgeKey = `${fileId}->${modelNodeId}:${q.method}`;
+        if (seenEdges.has(edgeKey))
+            continue;
+        seenEdges.add(edgeKey);
+        graph.addRelationship({
+            id: generateId('QUERIES', edgeKey),
+            sourceId: fileId,
+            targetId: modelNodeId,
+            type: 'QUERIES',
+            confidence: 0.9,
+            reason: `${q.orm}-${q.method}`,
+        });
+        edgesCreated++;
+    }
+    if (isDev) {
+        console.log(`ORM dataflow: ${edgesCreated} QUERIES edges, ${modelNodes.size} models (${queries.length} total calls)`);
+    }
+    return { edgesCreated, modelCount: modelNodes.size };
+}

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

@@ -0,0 +1,47 @@
+/**
+ * Parse implementation — chunked parse + resolve loop.
+ *
+ * This is the core parsing engine of the ingestion pipeline. It reads
+ * source files in byte-budget chunks (~20MB each), parses via worker
+ * pool (or sequential fallback), resolves imports/calls/heritage per
+ * chunk, and synthesizes wildcard import bindings.
+ *
+ * Consumed by the parse phase (`parse.ts`) — the phase file handles
+ * dependency wiring while the heavy implementation lives here.
+ *
+ * @module
+ */
+import { BindingAccumulator } from '../binding-accumulator.js';
+import { type ExportedTypeMap } from '../call-processor.js';
+import { createResolutionContext } from '../model/resolution-context.js';
+import { type PipelineProgress } from '../../../_shared/index.js';
+import type { ExtractedDecoratorRoute, ExtractedFetchCall, ExtractedORMQuery, ExtractedRoute, ExtractedToolDef } from '../workers/parse-worker.js';
+import type { KnowledgeGraph } from '../../graph/types.js';
+import type { PipelineOptions } from '../pipeline.js';
+type ScannedFile = {
+    path: string;
+    size: number;
+};
+type ProgressFn = (progress: PipelineProgress) => void;
+/**
+ * Chunked parse + resolve loop.
+ *
+ * Reads source in byte-budget chunks (~20MB each). For each chunk:
+ * 1. Parse via worker pool (or sequential fallback)
+ * 2. Resolve imports from extracted data
+ * 3. Synthesize wildcard import bindings (Go/Ruby/C++/Swift/Python)
+ * 4. Resolve heritage + routes per chunk; defer worker CALLS until all chunks
+ *    have contributed heritage so interface-dispatch implementor map is complete
+ * 5. Collect TypeEnv bindings for cross-file propagation
+ */
+export declare function runChunkedParseAndResolve(graph: KnowledgeGraph, scannedFiles: ScannedFile[], allPaths: string[], totalFiles: number, repoPath: string, pipelineStart: number, onProgress: ProgressFn, options?: PipelineOptions): Promise<{
+    exportedTypeMap: ExportedTypeMap;
+    allFetchCalls: ExtractedFetchCall[];
+    allExtractedRoutes: ExtractedRoute[];
+    allDecoratorRoutes: ExtractedDecoratorRoute[];
+    allToolDefs: ExtractedToolDef[];
+    allORMQueries: ExtractedORMQuery[];
+    bindingAccumulator: BindingAccumulator;
+    resolutionContext: ReturnType<typeof createResolutionContext>;
+}>;
+export {};