@zuvia-software-solutions/code-mapper 1.4.0 → 2.0.1

package/dist/core/ingestion/pipeline.js

@@ -4,7 +4,7 @@ import { createKnowledgeGraph } from '../graph/graph.js';
 import { processStructure } from './structure-processor.js';
 import { processParsing } from './parsing-processor.js';
 import { processImports, processImportsFromExtracted, buildImportResolutionContext } from './import-processor.js';
-import { processCalls, processCallsFromExtracted, processRoutesFromExtracted, createDependsOnEdges, createProvidesEdges } from './call-processor.js';
+import { processCalls, processCallsFromExtracted, processRoutesFromExtracted, createDependsOnEdges, createProvidesEdges, resolveInterfaceDispatches } from './call-processor.js';
 import { processHeritage, processHeritageFromExtracted } from './heritage-processor.js';
 import { computeMRO } from './mro-processor.js';
 import { processCommunities } from './community-processor.js';
@@ -19,7 +19,9 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { memoryGuard } from '../../lib/memory-guard.js';
-const isDev = process.env.NODE_ENV === 'development';
+import { toNodeId, toEdgeId } from '../db/schema.js';
+import { getTsgoService } from '../semantic/tsgo-service.js';
+const isDev = process.env['NODE_ENV'] === 'development';
 // Default chunk budget — used when memory is plentiful.
 // Under memory pressure, adaptiveBatchSize() shrinks this automatically.
 const DEFAULT_CHUNK_BYTE_BUDGET = 50 * 1024 * 1024;
@@ -28,7 +30,7 @@ const DEFAULT_CHUNK_BYTE_BUDGET = 50 * 1024 * 1024;
 const WORKING_MEMORY_MULTIPLIER = 20;
 // Max AST trees to keep in LRU cache
 const AST_CACHE_CAP = 50;
-export const runPipelineFromRepo = async (repoPath, onProgress) => {
+export const runPipelineFromRepo = async (repoPath, onProgress, opts) => {
     const graph = createKnowledgeGraph();
     const ctx = createResolutionContext();
     const symbolTable = ctx.symbols;
@@ -167,6 +169,8 @@ export const runPipelineFromRepo = async (repoPath, onProgress) => {
         try {
             for (let chunkIdx = 0; chunkIdx < numChunks; chunkIdx++) {
                 const chunkPaths = chunks[chunkIdx];
+                if (!chunkPaths)
+                    continue;
                 // Read content for this chunk
                 const chunkContents = await readFileContents(repoPath, chunkPaths);
                 const chunkFiles = chunkPaths
@@ -256,6 +260,7 @@ export const runPipelineFromRepo = async (repoPath, onProgress) => {
             }
             astCache.clear();
         }
+        let tsgoWasUsed = false;
         // Phase B: Resolve ALL deferred calls now that every symbol is registered
         if (allExtractedCalls.length > 0) {
             onProgress({
@@ -264,14 +269,34 @@ export const runPipelineFromRepo = async (repoPath, onProgress) => {
                 message: `Resolving ${allExtractedCalls.length} calls across all files...`,
                 stats: { filesProcessed: totalFiles, totalFiles, nodesCreated: graph.nodeCount },
             });
-            await processCallsFromExtracted(graph, allExtractedCalls, ctx, (current, total) => {
-                onProgress({
-                    phase: 'parsing',
-                    percent: 82,
-                    message: `Resolving calls: ${current}/${total} files...`,
-                    stats: { filesProcessed: totalFiles, totalFiles, nodesCreated: graph.nodeCount },
-                });
-            }, allConstructorBindings.length > 0 ? allConstructorBindings : undefined);
+            // Start tsgo for high-confidence TS/JS resolution (optional — graceful fallback)
+            let tsgoService = null;
+            if (opts?.tsgo !== false) {
+                try {
+                    const service = getTsgoService(repoPath);
+                    if (await service.start()) {
+                        tsgoService = service;
+                        tsgoWasUsed = true;
+                    }
+                }
+                catch {
+                    // tsgo is optional — if @typescript/native-preview isn't installed, skip silently
+                }
+            }
+            try {
+                await processCallsFromExtracted(graph, allExtractedCalls, ctx, (current, total) => {
+                    onProgress({
+                        phase: 'parsing',
+                        percent: 82,
+                        message: `Resolving calls: ${current}/${total} files...`,
+                        stats: { filesProcessed: totalFiles, totalFiles, nodesCreated: graph.nodeCount },
+                    });
+                }, allConstructorBindings.length > 0 ? allConstructorBindings : undefined, tsgoService, repoPath);
+            }
+            finally {
+                // Stop tsgo after call resolution completes
+                tsgoService?.stop();
+            }
         }
         // Log resolution cache stats in dev mode
         if (isDev) {
@@ -293,6 +318,11 @@ export const runPipelineFromRepo = async (repoPath, onProgress) => {
         if (isDev && (diEdgeCount > 0 || providesEdgeCount > 0)) {
             console.log(`💉 DI: ${diEdgeCount} DEPENDS_ON edges, ${providesEdgeCount} PROVIDES edges`);
         }
+        // Phase 4.5a2: Interface dispatch — connect callers of interfaces to implementations
+        const ifaceEdges = await resolveInterfaceDispatches(graph, ctx);
+        if (isDev && ifaceEdges > 0) {
+            console.log(`🔌 Interface dispatch: ${ifaceEdges} implementation edges`);
+        }
         // Phase 4.5b: Method Resolution Order
         onProgress({
             phase: 'parsing',
@@ -325,7 +355,7 @@ export const runPipelineFromRepo = async (repoPath, onProgress) => {
         }
         communityResult.communities.forEach(comm => {
             graph.addNode({
-                id: comm.id,
+                id: toNodeId(comm.id),
                 label: 'Community',
                 properties: {
                     name: comm.label,
@@ -338,10 +368,10 @@ export const runPipelineFromRepo = async (repoPath, onProgress) => {
         });
         communityResult.memberships.forEach(membership => {
             graph.addRelationship({
-                id: `${membership.nodeId}_member_of_${membership.communityId}`,
+                id: toEdgeId(`${membership.nodeId}_member_of_${membership.communityId}`),
                 type: 'MEMBER_OF',
-                sourceId: membership.nodeId,
-                targetId: membership.communityId,
+                sourceId: toNodeId(membership.nodeId),
+                targetId: toNodeId(membership.communityId),
                 confidence: 1.0,
                 reason: 'leiden-algorithm',
             });
@@ -371,7 +401,7 @@ export const runPipelineFromRepo = async (repoPath, onProgress) => {
         }
         processResult.processes.forEach(proc => {
             graph.addNode({
-                id: proc.id,
+                id: toNodeId(proc.id),
                 label: 'Process',
                 properties: {
                     name: proc.label,
@@ -387,10 +417,10 @@ export const runPipelineFromRepo = async (repoPath, onProgress) => {
         });
         processResult.steps.forEach(step => {
             graph.addRelationship({
-                id: `${step.nodeId}_step_${step.step}_${step.processId}`,
+                id: toEdgeId(`${step.nodeId}_step_${step.step}_${step.processId}`),
                 type: 'STEP_IN_PROCESS',
-                sourceId: step.nodeId,
-                targetId: step.processId,
+                sourceId: toNodeId(step.nodeId),
+                targetId: toNodeId(step.processId),
                 confidence: 1.0,
                 reason: 'trace-detection',
                 step: step.step,
@@ -407,7 +437,7 @@ export const runPipelineFromRepo = async (repoPath, onProgress) => {
             },
         });
         astCache.clear();
-        return { graph, repoPath, totalFileCount: totalFiles, communityResult, processResult };
+        return { graph, repoPath, totalFileCount: totalFiles, communityResult, processResult, tsgoEnabled: tsgoWasUsed };
     }
     catch (error) {
         cleanup();

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

@@ -1,6 +1,6 @@
 /** @file process-processor.ts @description Detects execution flows (Processes) by finding entry points, tracing forward via confidence-gated beam search, deduplicating similar paths, and labeling with heuristic names */
-import { KnowledgeGraph } from '../graph/types.js';
-import { CommunityMembership } from './community-processor.js';
+import type { KnowledgeGraph } from '../graph/types.js';
+import type { CommunityMembership } from './community-processor.js';
 export interface ProcessDetectionConfig {
     maxTraceDepth: number;
     maxProcesses: number;

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

@@ -1,8 +1,8 @@
 // code-mapper/src/core/ingestion/process-processor.ts
 /** @file process-processor.ts @description Detects execution flows (Processes) by finding entry points, tracing forward via confidence-gated beam search, deduplicating similar paths, and labeling with heuristic names */
-import { calculateEntryPointScore, isTestFile } from './entry-point-scoring.js';
+import { calculateEntryPointScore } from './entry-point-scoring.js';
 import { SupportedLanguages } from '../../config/supported-languages.js';
-const isDev = process.env.NODE_ENV === 'development';
+const isDev = process.env['NODE_ENV'] === 'development';
 const DEFAULT_CONFIG = {
     maxTraceDepth: 20,
     maxProcesses: 120,
@@ -30,6 +30,8 @@ export const processProcesses = async (knowledgeGraph, memberships, onProgress,
     const allTraces = [];
     for (let i = 0; i < entryPoints.length && allTraces.length < cfg.maxProcesses * 2; i++) {
         const entryId = entryPoints[i];
+        if (entryId === undefined)
+            continue;
         const traces = traceFromEntryPoint(entryId, callsEdges, cfg);
         // Filter out traces that are too short
         traces.filter(t => t.length >= cfg.minSteps).forEach(t => allTraces.push(t));
@@ -64,6 +66,8 @@ export const processProcesses = async (knowledgeGraph, memberships, onProgress,
     limitedTraces.forEach((trace, idx) => {
         const entryPointId = trace[0];
         const terminalId = trace[trace.length - 1];
+        if (entryPointId === undefined || terminalId === undefined)
+            return;
         // Get communities touched
         const communitiesSet = new Set();
         trace.forEach(nodeId => {
@@ -126,10 +130,12 @@ const buildCallsGraph = (graph, minEdgeConfidence) => {
     const adj = new Map();
     for (const rel of graph.iterRelationships()) {
         if (rel.type === 'CALLS' && rel.confidence >= minEdgeConfidence) {
-            if (!adj.has(rel.sourceId)) {
-                adj.set(rel.sourceId, []);
+            let edges = adj.get(rel.sourceId);
+            if (edges === undefined) {
+                edges = [];
+                adj.set(rel.sourceId, edges);
             }
-            adj.get(rel.sourceId).push({ targetId: rel.targetId, confidence: rel.confidence });
+            edges.push({ targetId: rel.targetId, confidence: rel.confidence });
         }
     }
     // Sort each caller's callees by confidence descending — beam search explores
@@ -143,10 +149,12 @@ const buildReverseCallsGraph = (graph, minEdgeConfidence) => {
     const adj = new Map();
     for (const rel of graph.iterRelationships()) {
         if (rel.type === 'CALLS' && rel.confidence >= minEdgeConfidence) {
-            if (!adj.has(rel.targetId)) {
-                adj.set(rel.targetId, []);
+            let callers = adj.get(rel.targetId);
+            if (callers === undefined) {
+                callers = [];
+                adj.set(rel.targetId, callers);
             }
-            adj.get(rel.targetId).push(rel.sourceId);
+            callers.push(rel.sourceId);
         }
     }
     return adj;
@@ -163,9 +171,6 @@ const findEntryPoints = (graph, reverseCallsEdges, callsEdges) => {
         if (!symbolTypes.has(node.label))
             continue;
         const filePath = node.properties.filePath || '';
-        // Skip test files entirely
-        if (isTestFile(filePath))
-            continue;
         const callers = reverseCallsEdges.get(node.id) || [];
         const calleeEdges = callsEdges.get(node.id) || [];
         // Must have at least 1 outgoing call to trace forward
@@ -221,6 +226,8 @@ const traceFromEntryPoint = (entryId, callsEdges, config) => {
     while (beam.length > 0) {
         // Pop highest cumulative confidence
         const entry = beam.shift();
+        if (entry === undefined)
+            break;
         const edges = callsEdges.get(entry.currentId) || [];
         // Filter edges by per-edge confidence gate
         const viable = edges.filter(e => e.confidence >= config.minEdgeConfidence);
@@ -254,7 +261,10 @@ const traceFromEntryPoint = (entryId, callsEdges, config) => {
             let hi = beam.length;
             while (lo < hi) {
                 const mid = (lo + hi) >>> 1;
-                if (beam[mid].cumulativeConf > childConf)
+                const midEntry = beam[mid];
+                if (midEntry === undefined)
+                    break;
+                if (midEntry.cumulativeConf > childConf)
                     lo = mid + 1;
                 else
                     hi = mid;
@@ -325,13 +335,17 @@ const mergeSimilarTraces = (traces) => {
     for (let i = 0; i < sorted.length; i++) {
         if (removed.has(i))
             continue;
-        kept.push(sorted[i]);
+        const longer = sorted[i];
+        if (longer === undefined)
+            continue;
+        kept.push(longer);
         // Check remaining traces for high overlap with this one
         for (let j = i + 1; j < sorted.length; j++) {
             if (removed.has(j))
                 continue;
             const shorter = sorted[j];
-            const longer = sorted[i];
+            if (shorter === undefined)
+                continue;
             // Count shared steps
             const longerSet = new Set(longer);
             let shared = 0;

package/dist/core/ingestion/resolution-context.d.ts

@@ -11,7 +11,7 @@
  */
 import type { SymbolTable, SymbolDefinition } from './symbol-table.js';
 import type { NamedImportBinding } from './import-processor.js';
-export type ResolutionTier = 'same-file' | 'import-scoped' | 'global';
+export type ResolutionTier = 'tsgo-resolved' | 'same-file' | 'import-scoped' | 'global';
 export interface TieredCandidates {
     readonly candidates: readonly SymbolDefinition[];
     readonly tier: ResolutionTier;

package/dist/core/ingestion/resolution-context.js

@@ -15,6 +15,7 @@ import { isFileInPackageDir } from './import-processor.js';
 import { walkBindingChain } from './named-binding-extraction.js';
 // Confidence scores per resolution tier
 export const TIER_CONFIDENCE = {
+    'tsgo-resolved': 0.99,
     'same-file': 0.95,
     'import-scoped': 0.9,
     'global': 0.5,
@@ -70,10 +71,19 @@ export const createResolutionContext = () => {
                         return { candidates: importedDefs, tier: 'import-scoped' };
                     }
                 }
-                // Last resort: if there's exactly one global definition and it's a Function, use it
-                // This handles cross-file calls where the import map fails but the symbol is unique
-                if (fuzzyDefs.length === 1 && (fuzzyDefs[0].type === 'Function' || fuzzyDefs[0].type === 'Method')) {
-                    return { candidates: fuzzyDefs, tier: 'global' };
+                // Last resort: if there are few global definitions that are callable, use them
+                // This handles cross-file calls where the import map fails but the symbol is resolvable
+                const callableDefs = fuzzyDefs.filter(d => d.type === 'Function' || d.type === 'Method' || d.type === 'Class' ||
+                    d.type === 'Constructor' || d.type === 'Interface');
+                if (callableDefs.length === 1) {
+                    return { candidates: callableDefs, tier: 'global' };
+                }
+                // If all callable defs point to the same nodeId (duplicates from re-exports), deduplicate
+                if (callableDefs.length > 1) {
+                    const uniqueIds = new Set(callableDefs.map(d => d.nodeId));
+                    if (uniqueIds.size === 1) {
+                        return { candidates: [callableDefs[0]], tier: 'global' };
+                    }
                 }
             }
             return null;

package/dist/core/ingestion/resolvers/csharp.js

@@ -56,14 +56,15 @@ export function resolveCSharpImport(importPath, csharpConfigs, normalizedFileLis
             const dirTrail = dirPrefix + '/';
             for (let i = 0; i < normalizedFileList.length; i++) {
                 const normalized = normalizedFileList[i];
-                if (!normalized.endsWith('.cs'))
+                if (!normalized || !normalized.endsWith('.cs'))
                     continue;
                 const prefixIdx = normalized.indexOf(dirTrail);
                 if (prefixIdx < 0)
                     continue;
                 const afterDir = normalized.substring(prefixIdx + dirTrail.length);
-                if (!afterDir.includes('/')) {
-                    results.push(allFileList[i]);
+                const original = allFileList[i];
+                if (!afterDir.includes('/') && original) {
+                    results.push(original);
                 }
             }
             if (results.length > 0)

package/dist/core/ingestion/resolvers/go.js

@@ -25,7 +25,9 @@ export function resolveGoPackage(importPath, goModule, normalizedFileList, allFi
         if (normalized.includes(pkgSuffix) && normalized.endsWith('.go') && !normalized.endsWith('_test.go')) {
             const afterPkg = normalized.substring(normalized.indexOf(pkgSuffix) + pkgSuffix.length);
             if (!afterPkg.includes('/')) {
-                matches.push(allFileList[i]);
+                const original = allFileList[i];
+                if (original !== undefined)
+                    matches.push(original);
             }
         }
     }

package/dist/core/ingestion/resolvers/jvm.js

@@ -33,11 +33,15 @@ export function resolveJvmWildcard(importPath, normalizedFileList, allFileList,
     const matches = [];
     for (let i = 0; i < normalizedFileList.length; i++) {
         const normalized = normalizedFileList[i];
+        if (normalized === undefined)
+            continue;
         if (normalized.includes(packageSuffix) &&
             extensions.some(ext => normalized.endsWith(ext))) {
             const afterPackage = normalized.substring(normalized.indexOf(packageSuffix) + packageSuffix.length);
             if (!afterPackage.includes('/')) {
-                matches.push(allFileList[i]);
+                const original = allFileList[i];
+                if (original !== undefined)
+                    matches.push(original);
             }
         }
     }
@@ -50,6 +54,8 @@ export function resolveJvmMemberImport(importPath, normalizedFileList, allFileLi
     if (segments.length < 3)
         return null;
     const lastSeg = segments[segments.length - 1];
+    if (lastSeg === undefined)
+        return null;
     if (lastSeg === '*' || /^[a-z]/.test(lastSeg) || /^[A-Z_]+$/.test(lastSeg)) {
         const classPath = segments.slice(0, -1).join('/');
         for (const ext of extensions) {
@@ -62,9 +68,12 @@ export function resolveJvmMemberImport(importPath, normalizedFileList, allFileLi
             else {
                 const fullSuffix = '/' + classSuffix;
                 for (let i = 0; i < normalizedFileList.length; i++) {
-                    if (normalizedFileList[i].endsWith(fullSuffix) ||
-                        normalizedFileList[i].toLowerCase().endsWith(fullSuffix.toLowerCase())) {
-                        return allFileList[i];
+                    const normalized = normalizedFileList[i];
+                    if (normalized === undefined)
+                        continue;
+                    if (normalized.endsWith(fullSuffix) ||
+                        normalized.toLowerCase().endsWith(fullSuffix.toLowerCase())) {
+                        return allFileList[i] ?? null;
                     }
                 }
             }

package/dist/core/ingestion/resolvers/standard.js

@@ -82,8 +82,8 @@ export const resolveImportPath = (currentFile, importPath, allFiles, allFileList
     if (language === SupportedLanguages.Python && importPath.startsWith('.')) {
         const dotMatch = importPath.match(/^(\.+)(.*)/);
         if (dotMatch) {
-            const dotCount = dotMatch[1].length;
-            const modulePart = dotMatch[2]; // e.g., "models" from ".models"
+            const dotCount = dotMatch[1]?.length ?? 0;
+            const modulePart = dotMatch[2] ?? ''; // e.g., "models" from ".models"
             const dirParts = currentFile.split('/').slice(0, -1);
             // 1 dot = same package, each additional dot goes up one level
             for (let i = 1; i < dotCount; i++) {

package/dist/core/ingestion/resolvers/utils.js

@@ -43,6 +43,8 @@ export function buildSuffixIndex(normalizedFileList, allFileList) {
     for (let i = 0; i < normalizedFileList.length; i++) {
         const normalized = normalizedFileList[i];
         const original = allFileList[i];
+        if (normalized === undefined || original === undefined)
+            continue;
         const parts = normalized.split('/');
         // Index all suffixes: "a/b/c.java" -> "c.java", "b/c.java", "a/b/c.java"
         for (let j = parts.length - 1; j >= 0; j--) {
@@ -61,7 +63,9 @@ export function buildSuffixIndex(normalizedFileList, allFileList) {
         if (lastSlash >= 0) {
             // Build all directory suffix variants
             const dirParts = parts.slice(0, -1);
-            const fileName = parts[parts.length - 1];
+            const fileName = parts.at(-1);
+            if (fileName === undefined)
+                continue;
             const ext = fileName.substring(fileName.lastIndexOf('.'));
             for (let j = dirParts.length - 1; j >= 0; j--) {
                 const dirSuffix = dirParts.slice(j).join('/');
@@ -105,7 +109,7 @@ export function suffixResolve(pathParts, normalizedFileList, allFileList, index)
             const suffixPattern = '/' + suffixWithExt;
             const matchIdx = normalizedFileList.findIndex(filePath => filePath.endsWith(suffixPattern) || filePath.toLowerCase().endsWith(suffixPattern.toLowerCase()));
             if (matchIdx !== -1) {
-                return allFileList[matchIdx];
+                return allFileList[matchIdx] ?? null;
             }
         }
     }

package/dist/core/ingestion/route-stitcher.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @file HTTP route stitching — connects client-side URL builders to server-side route handlers
+ *
+ * Runs AFTER DB loading (needs content field populated by graph-loader).
+ * Queries the DB directly for node content with route patterns.
+ *
+ * Strategy: "meet in the middle" via canonical URL patterns.
+ * Works for Express, Fastify, Koa, Hono, or any framework using router.method(path, handler)
+ */
+import type Database from 'better-sqlite3';
+/**
+ * Stitch client-side API path functions to server-side route handlers.
+ * Runs after loadGraphToDb — queries SQLite content field directly.
+ */
+export declare function stitchRoutes(db: Database.Database): number;

package/dist/core/ingestion/route-stitcher.js

@@ -0,0 +1,92 @@
+// code-mapper/src/core/ingestion/route-stitcher.ts
+/**
+ * @file HTTP route stitching — connects client-side URL builders to server-side route handlers
+ *
+ * Runs AFTER DB loading (needs content field populated by graph-loader).
+ * Queries the DB directly for node content with route patterns.
+ *
+ * Strategy: "meet in the middle" via canonical URL patterns.
+ * Works for Express, Fastify, Koa, Hono, or any framework using router.method(path, handler)
+ */
+import { toEdgeId } from '../db/schema.js';
+import { insertEdgesBatch } from '../db/adapter.js';
+/** Normalize a URL pattern to canonical form for matching */
+function canonicalizeRoute(pattern) {
+    return pattern
+        .replace(/['"``]/g, '')
+        .replace(/:[a-zA-Z_]\w*/g, ':p') // Express params :paramName → :p
+        .replace(/\$\{[^}]+\}/g, ':p') // Template literals ${var} → :p
+        .replace(/\/+$/, '') // Strip trailing slashes
+        .replace(/\/+/g, '/') // Collapse double slashes
+        .toLowerCase();
+}
+/**
+ * Stitch client-side API path functions to server-side route handlers.
+ * Runs after loadGraphToDb — queries SQLite content field directly.
+ */
+export function stitchRoutes(db) {
+    const serverRoutes = [];
+    const clientRoutes = [];
+    // Regex for route registrations in server File nodes
+    const ROUTE_REG = /\.(get|post|put|patch|delete|options)\s*\(\s*['"`](\/[^'"`\n]+)['"`]/gi;
+    // Regex for template literal URLs in client Function nodes
+    const TEMPLATE_URL = /`(\/(?:api|v\d+)\/[^`\n]+)`/g;
+    // String literal URLs (fetch('/api/...'))
+    const STRING_URL = /['"](\/(api|v\d+)\/[^'"]+)['"]/g;
+    // Server: scan File nodes for route registrations
+    const serverNodes = db.prepare(`SELECT id, name, filePath, content FROM nodes WHERE label = 'File' AND content LIKE '%/api/%'`).all();
+    for (const node of serverNodes) {
+        let m;
+        ROUTE_REG.lastIndex = 0;
+        while ((m = ROUTE_REG.exec(node.content)) !== null) {
+            const routePattern = canonicalizeRoute(m[2]);
+            if (routePattern.includes('/api/') || routePattern.includes('/v1/') || routePattern.includes('/v2/')) {
+                serverRoutes.push({ pattern: routePattern, nodeId: node.id, filePath: node.filePath, name: node.name, side: 'server' });
+            }
+        }
+    }
+    // Client: scan Function nodes for template URLs
+    const clientNodes = db.prepare(`SELECT id, name, filePath, content FROM nodes WHERE label = 'Function' AND content LIKE '%/api/%'`).all();
+    for (const node of clientNodes) {
+        let m;
+        TEMPLATE_URL.lastIndex = 0;
+        while ((m = TEMPLATE_URL.exec(node.content)) !== null) {
+            const routePattern = canonicalizeRoute(m[1]);
+            if (routePattern.length > 3) {
+                clientRoutes.push({ pattern: routePattern, nodeId: node.id, filePath: node.filePath, name: node.name, side: 'client' });
+            }
+        }
+        STRING_URL.lastIndex = 0;
+        while ((m = STRING_URL.exec(node.content)) !== null) {
+            const routePattern = canonicalizeRoute(m[1]);
+            if (routePattern.length > 3) {
+                clientRoutes.push({ pattern: routePattern, nodeId: node.id, filePath: node.filePath, name: node.name, side: 'client' });
+            }
+        }
+    }
+    // Match client patterns to server patterns
+    const edges = [];
+    const seen = new Set();
+    for (const client of clientRoutes) {
+        for (const server of serverRoutes) {
+            if (client.pattern === server.pattern && client.filePath !== server.filePath) {
+                const edgeKey = `${client.nodeId}->${server.nodeId}`;
+                if (seen.has(edgeKey))
+                    continue;
+                seen.add(edgeKey);
+                edges.push({
+                    id: toEdgeId(`CALLS:route-stitch:${edgeKey}`),
+                    sourceId: client.nodeId,
+                    targetId: server.nodeId,
+                    type: 'CALLS',
+                    confidence: 0.85,
+                    reason: 'http-route-match',
+                });
+            }
+        }
+    }
+    if (edges.length > 0) {
+        insertEdgesBatch(db, edges);
+    }
+    return edges.length;
+}

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

@@ -1,4 +1,4 @@
 /** @file structure-processor.ts @description Builds the file/folder tree structure in the knowledge graph by creating File and Folder nodes with CONTAINS relationships */
-import { KnowledgeGraph } from "../graph/types.js";
+import type { KnowledgeGraph } from "../graph/types.js";
 /** Build File/Folder nodes and CONTAINS edges from a list of file paths */
 export declare const processStructure: (graph: KnowledgeGraph, paths: string[]) => void;

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

@@ -1,12 +1,13 @@
 // code-mapper/src/core/ingestion/structure-processor.ts
 /** @file structure-processor.ts @description Builds the file/folder tree structure in the knowledge graph by creating File and Folder nodes with CONTAINS relationships */
 import { generateId } from "../../lib/utils.js";
+import { toEdgeId } from "../db/schema.js";
 /** Build File/Folder nodes and CONTAINS edges from a list of file paths */
 export const processStructure = (graph, paths) => {
     paths.forEach(path => {
         const parts = path.split('/');
         let currentPath = '';
-        let parentId = '';
+        let parentId = null;
         parts.forEach((part, index) => {
             const isFile = index === parts.length - 1;
             const label = isFile ? 'File' : 'Folder';
@@ -22,7 +23,7 @@ export const processStructure = (graph, paths) => {
             };
             graph.addNode(node);
             if (parentId) {
-                const relId = generateId('CONTAINS', `${parentId}->${nodeId}`);
+                const relId = toEdgeId(`CONTAINS:${parentId}->${nodeId}`);
                 const relationship = {
                     id: relId,
                     type: 'CONTAINS',

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

@@ -22,6 +22,8 @@ export interface SymbolTable {
     lookupExactFull: (filePath: string, name: string) => SymbolDefinition | undefined;
     /** Look up a symbol anywhere in the project (low confidence, used for missing imports) */
     lookupFuzzy: (name: string) => SymbolDefinition[];
+    /** Return all symbol definitions registered for a given file */
+    lookupAllInFile: (filePath: string) => SymbolDefinition[];
     /** Return file count and global symbol count for debugging */
     getStats: () => {
         fileCount: number;

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

@@ -36,6 +36,10 @@ export const createSymbolTable = () => {
     const lookupFuzzy = (name) => {
         return globalIndex.get(name) || [];
     };
+    const lookupAllInFile = (filePath) => {
+        const fileMap = fileIndex.get(filePath);
+        return fileMap ? Array.from(fileMap.values()) : [];
+    };
     const getStats = () => ({
         fileCount: fileIndex.size,
         globalSymbolCount: globalIndex.size
@@ -44,5 +48,5 @@ export const createSymbolTable = () => {
         fileIndex.clear();
         globalIndex.clear();
     };
-    return { add, lookupExact, lookupExactFull, lookupFuzzy, getStats, clear };
+    return { add, lookupExact, lookupExactFull, lookupFuzzy, lookupAllInFile, getStats, clear };
 };