gitnexus 1.6.0 → 1.6.1

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