arceus-s 1.6.4

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,75 @@
+/**
+ * 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';
+import { logger } from '../../logger.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) {
+        logger.info(`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,63 @@
+/**
+ * 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 { ASTCache } from '../ast-cache.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>;
+    usedWorkerPool: boolean;
+    /** Cross-phase tree-sitter Tree cache populated by the sequential
+     *  parse path. Distinct from the chunk-local `astCache` used inside
+     *  the parse loop (that one is cleared between chunks). Empty when
+     *  every chunk ran via the worker pool (workers can't return native
+     *  tree-sitter Trees across the MessageChannel). Downstream phases
+     *  (scope-resolution) read from this to skip re-parsing the same
+     *  source. See plan
+     *  docs/plans/2026-04-20-002-perf-parse-heritage-mro-plan.md (Unit 4). */
+    scopeTreeCache: ASTCache;
+    /** Worker-produced ParsedFile artifacts aggregated across chunks.
+     *  Threaded into scope-resolution as a re-extract cache so the warm-
+     *  cache analyze run can skip the dominant `extractParsedFile` cost
+     *  (otherwise ~58s on a 1000-file repo). */
+    parsedFiles: import('../../../_shared/index.js').ParsedFile[];
+}>;
+export {};