gitnexus 1.4.10 → 1.5.0

package/dist/core/ingestion/pipeline.js

@@ -3,23 +3,23 @@ import { processStructure } from './structure-processor.js';
 import { processMarkdown } from './markdown-processor.js';
 import { processCobol, isCobolFile, isJclFile } from './cobol-processor.js';
 import { processParsing } from './parsing-processor.js';
-import { processImports, processImportsFromExtracted, buildImportResolutionContext } from './import-processor.js';
+import { processImports, processImportsFromExtracted, buildImportResolutionContext, } from './import-processor.js';
 import { EMPTY_INDEX } from './import-resolvers/utils.js';
-import { processCalls, processCallsFromExtracted, processAssignmentsFromExtracted, processRoutesFromExtracted, processNextjsFetchRoutes, extractFetchCallsFromFiles, seedCrossFileReceiverTypes, buildImportedReturnTypes, buildImportedRawReturnTypes, buildExportedTypeMapFromGraph } from './call-processor.js';
+import { processCalls, processCallsFromExtracted, processAssignmentsFromExtracted, processRoutesFromExtracted, processNextjsFetchRoutes, extractFetchCallsFromFiles, seedCrossFileReceiverTypes, buildImportedReturnTypes, buildImportedRawReturnTypes, buildExportedTypeMapFromGraph, buildImplementorMap, mergeImplementorMaps, } from './call-processor.js';
 import { nextjsFileToRouteURL, normalizeFetchURL } from './route-extractors/nextjs.js';
 import { expoFileToRouteURL } from './route-extractors/expo.js';
 import { phpFileToRouteURL } from './route-extractors/php.js';
-import { extractResponseShapes, extractPHPResponseShapes } from './route-extractors/response-shapes.js';
-import { extractMiddlewareChain, extractNextjsMiddlewareConfig, compileMatcher, compiledMatcherMatchesRoute } from './route-extractors/middleware.js';
+import { extractResponseShapes, extractPHPResponseShapes, } from './route-extractors/response-shapes.js';
+import { extractMiddlewareChain, extractNextjsMiddlewareConfig, compileMatcher, compiledMatcherMatchesRoute, } from './route-extractors/middleware.js';
 import { generateId } from '../../lib/utils.js';
-import { processHeritage, processHeritageFromExtracted } from './heritage-processor.js';
+import { processHeritage, processHeritageFromExtracted, extractExtractedHeritageFromFiles, } from './heritage-processor.js';
 import { computeMRO } from './mro-processor.js';
 import { processCommunities } from './community-processor.js';
 import { processProcesses } from './process-processor.js';
 import { createResolutionContext } from './resolution-context.js';
 import { createASTCache } from './ast-cache.js';
+import { getLanguageFromFilename } from 'gitnexus-shared';
 import { walkRepositoryPaths, readFileContents } from './filesystem-walker.js';
-import { getLanguageFromFilename } from './utils/language-detection.js';
 import { isLanguageAvailable } from '../tree-sitter/parser-loader.js';
 import { providers, getProviderForFile } from './languages/index.js';
 import { createWorkerPool } from './workers/worker-pool.js';
@@ -57,9 +57,7 @@ export function topologicalLevelSort(importMap) {
     }
     // BFS from zero-in-degree nodes, grouping by level
     const levels = [];
-    let currentLevel = [...inDegree.entries()]
-        .filter(([, d]) => d === 0)
-        .map(([f]) => f);
+    let currentLevel = [...inDegree.entries()].filter(([, d]) => d === 0).map(([f]) => f);
     while (currentLevel.length > 0) {
         levels.push(currentLevel);
         const nextLevel = [];
@@ -74,9 +72,7 @@ export function topologicalLevelSort(importMap) {
         currentLevel = nextLevel;
     }
     // Files still with positive in-degree are in cycles — add as final group
-    const cycleFiles = [...inDegree.entries()]
-        .filter(([, d]) => d > 0)
-        .map(([f]) => f);
+    const cycleFiles = [...inDegree.entries()].filter(([, d]) => d > 0).map(([f]) => f);
     if (cycleFiles.length > 0) {
         levels.push(cycleFiles);
     }
@@ -97,15 +93,30 @@ const MAX_CROSS_FILE_REPROCESS = 2000;
  *  Excludes Method, Property, Constructor (accessed via receiver, not directly imported),
  *  and structural labels (File, Folder, Package, Module, Project, etc.). */
 const IMPORTABLE_SYMBOL_LABELS = new Set([
-    'Function', 'Class', 'Interface', 'Struct', 'Enum', 'Trait',
-    'TypeAlias', 'Const', 'Static', 'Record', 'Union', 'Typedef', 'Macro',
+    'Function',
+    'Class',
+    'Interface',
+    'Struct',
+    'Enum',
+    'Trait',
+    'TypeAlias',
+    'Const',
+    'Static',
+    'Record',
+    'Union',
+    'Typedef',
+    'Macro',
 ]);
 /** Max synthetic bindings per importing file — prevents memory bloat for
  *  C/C++ files that include many large headers. */
 const MAX_SYNTHETIC_BINDINGS_PER_FILE = 1000;
 /** Pre-computed language sets derived from providers at module load. */
-const WILDCARD_LANGUAGES = new Set(Object.values(providers).filter(p => p.importSemantics === 'wildcard').map(p => p.id));
-const SYNTHESIS_LANGUAGES = new Set(Object.values(providers).filter(p => p.importSemantics !== 'named').map(p => p.id));
+const WILDCARD_LANGUAGES = new Set(Object.values(providers)
+    .filter((p) => p.importSemantics === 'wildcard')
+    .map((p) => p.id));
+const SYNTHESIS_LANGUAGES = new Set(Object.values(providers)
+    .filter((p) => p.importSemantics !== 'named')
+    .map((p) => p.id));
 /** Check if a language uses wildcard (whole-module) import semantics.
  *  Derived from LanguageProvider.importSemantics — no hardcoded set needed. */
 function isWildcardImportLanguage(lang) {
@@ -124,7 +135,7 @@ function needsSynthesis(lang) {
 function synthesizeWildcardImportBindings(graph, ctx) {
     // Pre-compute exported symbols per file from graph (single pass)
     const exportedSymbolsByFile = new Map();
-    graph.forEachNode(node => {
+    graph.forEachNode((node) => {
         if (!node.properties?.isExported)
             return;
         if (!IMPORTABLE_SYMBOL_LABELS.has(node.label))
@@ -147,7 +158,7 @@ function synthesizeWildcardImportBindings(graph, ctx) {
     // Collect graph-level IMPORTS edges for wildcard languages missing from ctx.importMap.
     const FILE_PREFIX = 'File:';
     const graphImports = new Map();
-    graph.forEachRelationship(rel => {
+    graph.forEachRelationship((rel) => {
         if (rel.type !== 'IMPORTS')
             return;
         if (!rel.sourceId.startsWith(FILE_PREFIX) || !rel.targetId.startsWith(FILE_PREFIX))
@@ -292,7 +303,7 @@ async function runCrossFileBindingPropagation(graph, ctx, exportedTypeMap, allPa
     });
     let crossFileResolved = 0;
     const crossFileStart = Date.now();
-    let astCache = createASTCache(AST_CACHE_CAP);
+    const astCache = createASTCache(AST_CACHE_CAP);
     for (const level of levels) {
         const levelCandidates = [];
         for (const filePath of level) {
@@ -323,7 +334,7 @@ async function runCrossFileBindingPropagation(graph, ctx, exportedTypeMap, allPa
         }
         if (levelCandidates.length === 0)
             continue;
-        const levelPaths = levelCandidates.map(c => c.filePath);
+        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);
@@ -396,7 +407,7 @@ async function runScanAndStructure(repoPath, graph, onProgress) {
         message: 'Analyzing project structure...',
         stats: { filesProcessed: 0, totalFiles, nodesCreated: graph.nodeCount },
     });
-    const allPaths = scannedFiles.map(f => f.path);
+    const allPaths = scannedFiles.map((f) => f.path);
     processStructure(graph, allPaths);
     onProgress({
         phase: 'structure',
@@ -412,12 +423,12 @@ async function runScanAndStructure(repoPath, graph, onProgress) {
     // To add a new language: create a new processor file, import it here,
     // and add a filter-read-call-log block following the pattern below.
     // ── Phase 2.5: Markdown processing (headings + cross-links) ────────
-    const mdScanned = scannedFiles.filter(f => f.path.endsWith('.md') || f.path.endsWith('.mdx'));
+    const mdScanned = scannedFiles.filter((f) => f.path.endsWith('.md') || f.path.endsWith('.mdx'));
     if (mdScanned.length > 0) {
-        const mdContents = await readFileContents(repoPath, mdScanned.map(f => f.path));
+        const mdContents = await readFileContents(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) }));
+            .filter((f) => mdContents.has(f.path))
+            .map((f) => ({ path: f.path, content: mdContents.get(f.path) }));
         const allPathSet = new Set(allPaths);
         const mdResult = processMarkdown(graph, mdFiles, allPathSet);
         if (isDev) {
@@ -425,17 +436,19 @@ async function runScanAndStructure(repoPath, graph, onProgress) {
         }
     }
     // ── Phase 2.6: COBOL processing (regex extraction, no tree-sitter) ──
-    const cobolScanned = scannedFiles.filter(f => isCobolFile(f.path) || isJclFile(f.path));
+    const cobolScanned = scannedFiles.filter((f) => isCobolFile(f.path) || isJclFile(f.path));
     if (cobolScanned.length > 0) {
-        const cobolContents = await readFileContents(repoPath, cobolScanned.map(f => f.path));
+        const cobolContents = await readFileContents(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) }));
+            .filter((f) => cobolContents.has(f.path))
+            .map((f) => ({ path: f.path, content: cobolContents.get(f.path) }));
         const allPathSet = new Set(allPaths);
         const cobolResult = processCobol(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) {
+            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) {
@@ -452,7 +465,8 @@ async function runScanAndStructure(repoPath, graph, onProgress) {
  * 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 calls, heritage, routes concurrently (Promise.all)
+ * 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
  *
  * State accumulated across chunks: symbolTable, importMap, namedImportMap,
@@ -462,10 +476,13 @@ async function runScanAndStructure(repoPath, graph, onProgress) {
  * @reads  allPaths (from scan phase)
  * @writes graph (Symbol nodes, IMPORTS/CALLS/EXTENDS/IMPLEMENTS/ACCESSES edges)
  * @writes ctx.symbolTable, ctx.importMap, ctx.namedImportMap, ctx.moduleAliasMap
+ *
+ * Follow-up from PR review: MethodExtractor (FieldExtractor parity) and optional
+ * METHOD_IMPLEMENTS graph edges to make dispatch queryable without an in-memory map.
  */
 async function runChunkedParseAndResolve(graph, ctx, scannedFiles, allPaths, totalFiles, repoPath, pipelineStart, onProgress) {
     const symbolTable = ctx.symbols;
-    const parseableScanned = scannedFiles.filter(f => {
+    const parseableScanned = scannedFiles.filter((f) => {
         const lang = getLanguageFromFilename(f.path);
         return lang && isLanguageAvailable(lang);
     });
@@ -547,14 +564,14 @@ async function runChunkedParseAndResolve(graph, ctx, scannedFiles, allPaths, tot
     // Build import resolution context once — suffix index, file lists, resolve cache.
     // Reused across all chunks to avoid rebuilding O(files × path_depth) structures.
     const importCtx = buildImportResolutionContext(allPaths);
-    const allPathObjects = allPaths.map(p => ({ path: p }));
-    // Single-pass: parse + resolve imports/calls/heritage per chunk.
-    // Calls/heritage use the symbol table built so far (symbols from earlier chunks
-    // are already registered). This trades ~5% cross-chunk resolution accuracy for
-    // 200-400MB less memory — critical for Linux-kernel-scale repos.
+    const allPathObjects = allPaths.map((p) => ({ path: p }));
+    // Worker path: parse + imports + heritage per chunk; buffer extracted calls and
+    // run processCallsFromExtracted once after all chunks so interface-dispatch uses a
+    // complete implementor map (heritage from every chunk). Costs peak RAM for buffered
+    // call rows vs streaming resolution per chunk.
     const sequentialChunkPaths = [];
     // Pre-compute which chunks need synthesis — O(1) lookup per chunk.
-    const chunkNeedsSynthesis = chunks.map(paths => paths.some(p => {
+    const chunkNeedsSynthesis = chunks.map((paths) => paths.some((p) => {
         const lang = getLanguageFromFilename(p);
         return lang != null && needsSynthesis(lang);
     }));
@@ -571,27 +588,35 @@ async function runChunkedParseAndResolve(graph, ctx, scannedFiles, allPaths, tot
     // Accumulate MCP/RPC tool definitions (@mcp.tool(), @app.tool(), etc.)
     const allToolDefs = [];
     const allORMQueries = [];
+    const deferredWorkerCalls = [];
+    const deferredWorkerHeritage = [];
+    const deferredConstructorBindings = [];
+    const deferredAssignments = [];
     try {
         for (let chunkIdx = 0; chunkIdx < numChunks; chunkIdx++) {
             const chunkPaths = chunks[chunkIdx];
             // Read content for this chunk only
             const chunkContents = await readFileContents(repoPath, chunkPaths);
             const chunkFiles = chunkPaths
-                .filter(p => chunkContents.has(p))
-                .map(p => ({ path: p, content: chunkContents.get(p) }));
+                .filter((p) => chunkContents.has(p))
+                .map((p) => ({ path: p, content: chunkContents.get(p) }));
             // Parse this chunk (workers or sequential fallback)
             const chunkWorkerData = await processParsing(graph, chunkFiles, symbolTable, astCache, (current, _total, filePath) => {
                 const globalCurrent = filesParsedSoFar + current;
-                const parsingProgress = 20 + ((globalCurrent / totalParseable) * 62);
+                const parsingProgress = 20 + (globalCurrent / totalParseable) * 62;
                 onProgress({
                     phase: 'parsing',
                     percent: Math.round(parsingProgress),
                     message: `Parsing chunk ${chunkIdx + 1}/${numChunks}...`,
                     detail: filePath,
-                    stats: { filesProcessed: globalCurrent, totalFiles: totalParseable, nodesCreated: graph.nodeCount },
+                    stats: {
+                        filesProcessed: globalCurrent,
+                        totalFiles: totalParseable,
+                        nodesCreated: graph.nodeCount,
+                    },
                 });
             }, workerPool);
-            const chunkBasePercent = 20 + ((filesParsedSoFar / totalParseable) * 62);
+            const chunkBasePercent = 20 + (filesParsedSoFar / totalParseable) * 62;
             if (chunkWorkerData) {
                 // Imports
                 await processImportsFromExtracted(graph, allPathObjects, chunkWorkerData.imports, ctx, (current, total) => {
@@ -600,7 +625,11 @@ async function runChunkedParseAndResolve(graph, ctx, scannedFiles, allPaths, tot
                         percent: Math.round(chunkBasePercent),
                         message: `Resolving imports (chunk ${chunkIdx + 1}/${numChunks})...`,
                         detail: `${current}/${total} files`,
-                        stats: { filesProcessed: filesParsedSoFar, totalFiles: totalParseable, nodesCreated: graph.nodeCount },
+                        stats: {
+                            filesProcessed: filesParsedSoFar,
+                            totalFiles: totalParseable,
+                            nodesCreated: graph.nodeCount,
+                        },
                     });
                 }, repoPath, importCtx);
                 // ── Wildcard-import synthesis (Ruby / C/C++ / Swift / Go) + Python module aliases ─
@@ -620,26 +649,26 @@ async function runChunkedParseAndResolve(graph, ctx, scannedFiles, allPaths, tot
                         console.log(`🔗 E1: Seeded ${enrichedCount} cross-file receiver types (chunk ${chunkIdx + 1})`);
                     }
                 }
-                // Calls + Heritage + Routes — resolve in parallel (no shared mutable state between them)
-                // This is safe because each writes disjoint relationship types into idempotent id-keyed Maps,
-                // and the single-threaded event loop prevents races between synchronous addRelationship calls.
+                deferredWorkerCalls.push(...chunkWorkerData.calls);
+                deferredWorkerHeritage.push(...chunkWorkerData.heritage);
+                deferredConstructorBindings.push(...chunkWorkerData.constructorBindings);
+                if (chunkWorkerData.assignments?.length) {
+                    deferredAssignments.push(...chunkWorkerData.assignments);
+                }
+                // Heritage + Routes — calls deferred until all chunks have contributed heritage
+                // (complete implementor map for interface dispatch).
                 await Promise.all([
-                    processCallsFromExtracted(graph, chunkWorkerData.calls, ctx, (current, total) => {
-                        onProgress({
-                            phase: 'parsing',
-                            percent: Math.round(chunkBasePercent),
-                            message: `Resolving calls (chunk ${chunkIdx + 1}/${numChunks})...`,
-                            detail: `${current}/${total} files`,
-                            stats: { filesProcessed: filesParsedSoFar, totalFiles: totalParseable, nodesCreated: graph.nodeCount },
-                        });
-                    }, chunkWorkerData.constructorBindings),
                     processHeritageFromExtracted(graph, chunkWorkerData.heritage, ctx, (current, total) => {
                         onProgress({
                             phase: 'parsing',
                             percent: Math.round(chunkBasePercent),
                             message: `Resolving heritage (chunk ${chunkIdx + 1}/${numChunks})...`,
                             detail: `${current}/${total} records`,
-                            stats: { filesProcessed: filesParsedSoFar, totalFiles: totalParseable, nodesCreated: graph.nodeCount },
+                            stats: {
+                                filesProcessed: filesParsedSoFar,
+                                totalFiles: totalParseable,
+                                nodesCreated: graph.nodeCount,
+                            },
                         });
                     }),
                     processRoutesFromExtracted(graph, chunkWorkerData.routes ?? [], ctx, (current, total) => {
@@ -648,14 +677,14 @@ async function runChunkedParseAndResolve(graph, ctx, scannedFiles, allPaths, tot
                             percent: Math.round(chunkBasePercent),
                             message: `Resolving routes (chunk ${chunkIdx + 1}/${numChunks})...`,
                             detail: `${current}/${total} routes`,
-                            stats: { filesProcessed: filesParsedSoFar, totalFiles: totalParseable, nodesCreated: graph.nodeCount },
+                            stats: {
+                                filesProcessed: filesParsedSoFar,
+                                totalFiles: totalParseable,
+                                nodesCreated: graph.nodeCount,
+                            },
                         });
                     }),
                 ]);
-                // Process field write assignments (synchronous, runs after calls resolve)
-                if (chunkWorkerData.assignments?.length) {
-                    processAssignmentsFromExtracted(graph, chunkWorkerData.assignments, ctx, chunkWorkerData.constructorBindings);
-                }
                 // Collect TypeEnv file-scope bindings for exported type enrichment
                 if (chunkWorkerData.typeEnvBindings?.length) {
                     workerTypeEnvBindings.push(...chunkWorkerData.typeEnvBindings);
@@ -686,6 +715,28 @@ async function runChunkedParseAndResolve(graph, ctx, scannedFiles, allPaths, tot
             astCache.clear();
             // chunkContents + chunkFiles + chunkWorkerData go out of scope → GC reclaims
         }
+        // Complete implementor map from all worker heritage, then resolve CALLS once (interface dispatch).
+        const fullWorkerImplementorMap = deferredWorkerHeritage.length > 0
+            ? buildImplementorMap(deferredWorkerHeritage, ctx)
+            : new Map();
+        if (deferredWorkerCalls.length > 0) {
+            await processCallsFromExtracted(graph, deferredWorkerCalls, ctx, (current, total) => {
+                onProgress({
+                    phase: 'parsing',
+                    percent: 82,
+                    message: 'Resolving calls (all chunks)...',
+                    detail: `${current}/${total} files`,
+                    stats: {
+                        filesProcessed: filesParsedSoFar,
+                        totalFiles: totalParseable,
+                        nodesCreated: graph.nodeCount,
+                    },
+                });
+            }, deferredConstructorBindings.length > 0 ? deferredConstructorBindings : undefined, fullWorkerImplementorMap);
+        }
+        if (deferredAssignments.length > 0) {
+            processAssignmentsFromExtracted(graph, deferredAssignments, ctx, deferredConstructorBindings.length > 0 ? deferredConstructorBindings : undefined);
+        }
     }
     finally {
         await workerPool?.terminate();
@@ -695,13 +746,18 @@ async function runChunkedParseAndResolve(graph, ctx, scannedFiles, allPaths, tot
     // before any call resolution — same rationale as the worker-path inline synthesis.
     if (sequentialChunkPaths.length > 0)
         synthesizeWildcardImportBindings(graph, ctx);
+    // Merge implementor-map deltas per chunk (O(heritage per chunk)), not O(|edges|) graph scans
+    // per chunk — mirrors worker-path deferred heritage without re-iterating all relationships.
+    const sequentialImplementorMap = new Map();
     for (const chunkPaths of sequentialChunkPaths) {
         const chunkContents = await readFileContents(repoPath, chunkPaths);
         const chunkFiles = chunkPaths
-            .filter(p => chunkContents.has(p))
-            .map(p => ({ path: p, content: chunkContents.get(p) }));
+            .filter((p) => chunkContents.has(p))
+            .map((p) => ({ path: p, content: chunkContents.get(p) }));
         astCache = createASTCache(chunkFiles.length);
-        const rubyHeritage = await processCalls(graph, chunkFiles, astCache, ctx, undefined, exportedTypeMap);
+        const sequentialHeritage = await extractExtractedHeritageFromFiles(chunkFiles, astCache);
+        mergeImplementorMaps(sequentialImplementorMap, buildImplementorMap(sequentialHeritage, ctx));
+        const rubyHeritage = await processCalls(graph, chunkFiles, astCache, ctx, undefined, exportedTypeMap, undefined, undefined, undefined, sequentialImplementorMap);
         await processHeritage(graph, chunkFiles, astCache, ctx);
         if (rubyHeritage.length > 0) {
             await processHeritageFromExtracted(graph, rubyHeritage, ctx);
@@ -769,7 +825,14 @@ async function runChunkedParseAndResolve(graph, ctx, scannedFiles, allPaths, tot
     importCtx.resolveCache.clear();
     importCtx.index = EMPTY_INDEX; // Release suffix index memory (~30MB for large repos)
     importCtx.normalizedFileList = [];
-    return { exportedTypeMap, allFetchCalls, allExtractedRoutes, allDecoratorRoutes, allToolDefs, allORMQueries };
+    return {
+        exportedTypeMap,
+        allFetchCalls,
+        allExtractedRoutes,
+        allDecoratorRoutes,
+        allToolDefs,
+        allORMQueries,
+    };
 }
 /**
  * Post-parse graph analysis: MRO, community detection, process extraction.
@@ -797,7 +860,7 @@ async function runGraphAnalysisPhases(graph, totalFiles, onProgress, routeRegist
         stats: { filesProcessed: totalFiles, totalFiles, nodesCreated: graph.nodeCount },
     });
     const communityResult = await processCommunities(graph, (message, progress) => {
-        const communityProgress = 82 + (progress * 0.10);
+        const communityProgress = 82 + progress * 0.1;
         onProgress({
             phase: 'communities',
             percent: Math.round(communityProgress),
@@ -808,7 +871,7 @@ async function runGraphAnalysisPhases(graph, totalFiles, onProgress, routeRegist
     if (isDev) {
         console.log(`🏘️ Community detection: ${communityResult.stats.totalCommunities} communities found (modularity: ${communityResult.stats.modularity.toFixed(3)})`);
     }
-    communityResult.communities.forEach(comm => {
+    communityResult.communities.forEach((comm) => {
         graph.addNode({
             id: comm.id,
             label: 'Community',
@@ -818,10 +881,10 @@ async function runGraphAnalysisPhases(graph, totalFiles, onProgress, routeRegist
                 heuristicLabel: comm.heuristicLabel,
                 cohesion: comm.cohesion,
                 symbolCount: comm.symbolCount,
-            }
+            },
         });
     });
-    communityResult.memberships.forEach(membership => {
+    communityResult.memberships.forEach((membership) => {
         graph.addRelationship({
             id: `${membership.nodeId}_member_of_${membership.communityId}`,
             type: 'MEMBER_OF',
@@ -839,11 +902,13 @@ async function runGraphAnalysisPhases(graph, totalFiles, onProgress, routeRegist
         stats: { filesProcessed: totalFiles, totalFiles, nodesCreated: graph.nodeCount },
     });
     let symbolCount = 0;
-    graph.forEachNode(n => { if (n.label !== 'File')
-        symbolCount++; });
+    graph.forEachNode((n) => {
+        if (n.label !== 'File')
+            symbolCount++;
+    });
     const dynamicMaxProcesses = Math.max(20, Math.min(300, Math.round(symbolCount / 10)));
     const processResult = await processProcesses(graph, communityResult.memberships, (message, progress) => {
-        const processProgress = 94 + (progress * 0.05);
+        const processProgress = 94 + progress * 0.05;
         onProgress({
             phase: 'processes',
             percent: Math.round(processProgress),
@@ -854,7 +919,7 @@ async function runGraphAnalysisPhases(graph, totalFiles, onProgress, routeRegist
     if (isDev) {
         console.log(`🔄 Process detection: ${processResult.stats.totalProcesses} processes found (${processResult.stats.crossCommunityCount} cross-community)`);
     }
-    processResult.processes.forEach(proc => {
+    processResult.processes.forEach((proc) => {
         graph.addNode({
             id: proc.id,
             label: 'Process',
@@ -867,10 +932,10 @@ async function runGraphAnalysisPhases(graph, totalFiles, onProgress, routeRegist
                 communities: proc.communities,
                 entryPointId: proc.entryPointId,
                 terminalId: proc.terminalId,
-            }
+            },
         });
     });
-    processResult.steps.forEach(step => {
+    processResult.steps.forEach((step) => {
         graph.addRelationship({
             id: `${step.nodeId}_step_${step.step}_${step.processId}`,
             type: 'STEP_IN_PROCESS',
@@ -962,7 +1027,7 @@ export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
         // Phase 1+2: Scan paths, build structure, process markdown
         const { scannedFiles, allPaths, totalFiles } = await runScanAndStructure(repoPath, graph, onProgress);
         // Phase 3+4: Chunked parse + resolve (imports, calls, heritage, routes)
-        const { exportedTypeMap, allFetchCalls, allExtractedRoutes, allDecoratorRoutes, allToolDefs, allORMQueries } = await runChunkedParseAndResolve(graph, ctx, scannedFiles, allPaths, totalFiles, repoPath, pipelineStart, onProgress);
+        const { exportedTypeMap, allFetchCalls, allExtractedRoutes, allDecoratorRoutes, allToolDefs, allORMQueries, } = await runChunkedParseAndResolve(graph, ctx, scannedFiles, allPaths, totalFiles, repoPath, pipelineStart, onProgress);
         const routeRegistry = new Map();
         // Detect Expo Router app/ roots vs Next.js app/ roots (monorepo-safe).
         const expoAppRoots = new Set();
@@ -1009,7 +1074,7 @@ export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
                 }
             }
         }
-        const ensureSlash = (path) => path.startsWith('/') ? path : '/' + path;
+        const ensureSlash = (path) => (path.startsWith('/') ? path : '/' + path);
         let duplicateRoutes = 0;
         const addRoute = (url, entry) => {
             if (routeRegistry.has(url)) {
@@ -1021,20 +1086,28 @@ export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
         for (const route of allExtractedRoutes) {
             if (!route.routePath)
                 continue;
-            addRoute(ensureSlash(route.routePath), { filePath: route.filePath, source: 'framework-route' });
+            addRoute(ensureSlash(route.routePath), {
+                filePath: route.filePath,
+                source: 'framework-route',
+            });
         }
         for (const dr of allDecoratorRoutes) {
-            addRoute(ensureSlash(dr.routePath), { filePath: dr.filePath, source: `decorator-${dr.decoratorName}` });
+            addRoute(ensureSlash(dr.routePath), {
+                filePath: dr.filePath,
+                source: `decorator-${dr.decoratorName}`,
+            });
         }
         let handlerContents;
         if (routeRegistry.size > 0) {
-            const handlerPaths = [...routeRegistry.values()].map(e => e.filePath);
+            const handlerPaths = [...routeRegistry.values()].map((e) => e.filePath);
             handlerContents = await readFileContents(repoPath, handlerPaths);
             for (const [routeURL, entry] of routeRegistry) {
                 const { filePath: handlerPath, source: routeSource } = entry;
                 const content = handlerContents.get(handlerPath);
                 const { responseKeys, errorKeys } = content
-                    ? (handlerPath.endsWith(".php") ? extractPHPResponseShapes(content) : extractResponseShapes(content))
+                    ? handlerPath.endsWith('.php')
+                        ? extractPHPResponseShapes(content)
+                        : extractResponseShapes(content)
                     : { responseKeys: undefined, errorKeys: undefined };
                 const mwResult = content ? extractMiddlewareChain(content) : undefined;
                 const middleware = mwResult?.chain;
@@ -1066,23 +1139,29 @@ export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
         }
         // ── Phase 3.5b: Link Next.js project-level middleware.ts to routes ──
         if (routeRegistry.size > 0) {
-            const middlewareCandidates = allPaths.filter(p => p === 'middleware.ts' || p === 'middleware.js' || p === 'middleware.tsx' || p === 'middleware.jsx' ||
-                p === 'src/middleware.ts' || p === 'src/middleware.js' || p === 'src/middleware.tsx' || p === 'src/middleware.jsx');
+            const middlewareCandidates = allPaths.filter((p) => p === 'middleware.ts' ||
+                p === 'middleware.js' ||
+                p === 'middleware.tsx' ||
+                p === 'middleware.jsx' ||
+                p === 'src/middleware.ts' ||
+                p === 'src/middleware.js' ||
+                p === 'src/middleware.tsx' ||
+                p === 'src/middleware.jsx');
             if (middlewareCandidates.length > 0) {
                 const mwContents = await readFileContents(repoPath, middlewareCandidates);
                 for (const [mwPath, mwContent] of mwContents) {
                     const config = extractNextjsMiddlewareConfig(mwContent);
                     if (!config)
                         continue;
-                    const mwLabel = config.wrappedFunctions.length > 0
-                        ? config.wrappedFunctions
-                        : [config.exportedName];
+                    const mwLabel = config.wrappedFunctions.length > 0 ? config.wrappedFunctions : [config.exportedName];
                     // Pre-compile matchers once per middleware file
-                    const compiled = config.matchers.map(compileMatcher).filter((m) => m !== null);
+                    const compiled = config.matchers
+                        .map(compileMatcher)
+                        .filter((m) => m !== null);
                     let linkedCount = 0;
                     for (const [routeURL] of routeRegistry) {
                         const matches = compiled.length === 0 ||
-                            compiled.some(cm => compiledMatcherMatchesRoute(cm, routeURL));
+                            compiled.some((cm) => compiledMatcherMatchesRoute(cm, routeURL));
                         if (!matches)
                             continue;
                         const routeNodeId = generateId('Route', routeURL);
@@ -1091,7 +1170,10 @@ export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
                             continue;
                         const currentMw = existing.properties.middleware ?? [];
                         // Prepend project-level middleware (runs before handler-level wrappers)
-                        existing.properties.middleware = [...mwLabel, ...currentMw.filter(m => !mwLabel.includes(m))];
+                        existing.properties.middleware = [
+                            ...mwLabel,
+                            ...currentMw.filter((m) => !mwLabel.includes(m)),
+                        ];
                         linkedCount++;
                     }
                     if (isDev && linkedCount > 0) {
@@ -1103,8 +1185,11 @@ export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
         // Scan HTML/PHP/template files for <form action="/path"> and AJAX url patterns
         // Scan HTML/template files for <form action="/path"> and AJAX url patterns
         // Skip .php — already parsed by tree-sitter with http_client/fetch queries
-        const htmlCandidates = allPaths.filter(p => p.endsWith('.html') || p.endsWith('.htm') ||
-            p.endsWith('.ejs') || p.endsWith('.hbs') || p.endsWith('.blade.php'));
+        const htmlCandidates = allPaths.filter((p) => p.endsWith('.html') ||
+            p.endsWith('.htm') ||
+            p.endsWith('.ejs') ||
+            p.endsWith('.hbs') ||
+            p.endsWith('.blade.php'));
         if (htmlCandidates.length > 0 && routeRegistry.size > 0) {
             const htmlContents = await readFileContents(repoPath, htmlCandidates);
             const htmlPatterns = [/action=["']([^"']+)["']/g, /url:\s*["']([^"']+)["']/g];
@@ -1123,8 +1208,10 @@ export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
         }
         // ── Phase 3.5c: Extract Expo Router navigation patterns ──
         if (expoAppPaths.size > 0 && routeRegistry.size > 0) {
-            const unreadExpoPaths = [...expoAppPaths].filter(p => !handlerContents?.has(p));
-            const extraContents = unreadExpoPaths.length > 0 ? await readFileContents(repoPath, unreadExpoPaths) : new Map();
+            const unreadExpoPaths = [...expoAppPaths].filter((p) => !handlerContents?.has(p));
+            const extraContents = unreadExpoPaths.length > 0
+                ? await readFileContents(repoPath, unreadExpoPaths)
+                : new Map();
             const allExpoContents = new Map([...(handlerContents ?? new Map()), ...extraContents]);
             for (const [filePath, content] of allExpoContents) {
                 if (!expoAppPaths.has(filePath))
@@ -1146,7 +1233,7 @@ export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
             for (const [url, entry] of routeRegistry)
                 routeURLToFile.set(url, entry.filePath);
             // Read consumer file contents so we can extract property access patterns
-            const consumerPaths = [...new Set(allFetchCalls.map(c => c.filePath))];
+            const consumerPaths = [...new Set(allFetchCalls.map((c) => c.filePath))];
             const consumerContents = await readFileContents(repoPath, consumerPaths);
             processNextjsFetchRoutes(graph, allFetchCalls, routeURLToFile, consumerContents);
             if (isDev) {
@@ -1163,8 +1250,11 @@ export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
             toolDefs.push({ name: td.toolName, filePath: td.filePath, description: td.description });
         }
         // TS tool definition arrays — require inputSchema nearby to distinguish from config objects
-        const toolCandidatePaths = allPaths.filter(p => (p.endsWith('.ts') || p.endsWith('.js')) && p.toLowerCase().includes('tool')
-            && !p.includes('node_modules') && !p.includes('test') && !p.includes('__'));
+        const toolCandidatePaths = allPaths.filter((p) => (p.endsWith('.ts') || p.endsWith('.js')) &&
+            p.toLowerCase().includes('tool') &&
+            !p.includes('node_modules') &&
+            !p.includes('test') &&
+            !p.includes('__'));
         if (toolCandidatePaths.length > 0) {
             const toolContents = await readFileContents(repoPath, toolCandidatePaths);
             for (const [filePath, content] of toolContents) {
@@ -1178,7 +1268,11 @@ export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
                     if (seenToolNames.has(name))
                         continue;
                     seenToolNames.add(name);
-                    toolDefs.push({ name, filePath, description: match[2].slice(0, 200).replace(/\n/g, ' ').trim() });
+                    toolDefs.push({
+                        name,
+                        filePath,
+                        description: match[2].slice(0, 200).replace(/\n/g, ' ').trim(),
+                    });
                 }
             }
         }
@@ -1228,7 +1322,7 @@ export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
             stats: {
                 filesProcessed: totalFiles,
                 totalFiles,
-                nodesCreated: graph.nodeCount
+                nodesCreated: graph.nodeCount,
             },
         });
         return { graph, repoPath, totalFileCount: totalFiles, communityResult, processResult };
@@ -1253,14 +1347,26 @@ function extractORMQueriesInline(filePath, content, out) {
             const model = m[1];
             if (model.startsWith('$'))
                 continue;
-            out.push({ filePath, orm: 'prisma', model, method: m[2], lineNumber: content.substring(0, m.index).split('\n').length - 1 });
+            out.push({
+                filePath,
+                orm: 'prisma',
+                model,
+                method: m[2],
+                lineNumber: content.substring(0, m.index).split('\n').length - 1,
+            });
         }
     }
     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: content.substring(0, m.index).split('\n').length - 1 });
+            out.push({
+                filePath,
+                orm: 'supabase',
+                model: m[1],
+                method: m[2],
+                lineNumber: content.substring(0, m.index).split('\n').length - 1,
+            });
         }
     }
 }
@@ -1280,7 +1386,7 @@ function processORMQueries(graph, queries, isDev) {
                 generateId('Interface', `${q.model}`),
                 generateId('CodeElement', `${q.model}`),
             ];
-            const existing = candidateIds.find(id => graph.getNode(id));
+            const existing = candidateIds.find((id) => graph.getNode(id));
             if (existing) {
                 modelNodeId = existing;
             }