gitnexus 1.4.6 → 1.4.8

package/dist/core/ingestion/pipeline.js

@@ -1,8 +1,10 @@
 import { createKnowledgeGraph } from '../graph/graph.js';
 import { processStructure } from './structure-processor.js';
+import { processMarkdown } from './markdown-processor.js';
 import { processParsing } from './parsing-processor.js';
 import { processImports, processImportsFromExtracted, buildImportResolutionContext } from './import-processor.js';
-import { processCalls, processCallsFromExtracted, processRoutesFromExtracted } from './call-processor.js';
+import { EMPTY_INDEX } from './resolvers/index.js';
+import { processCalls, processCallsFromExtracted, processAssignmentsFromExtracted, processRoutesFromExtracted, seedCrossFileReceiverTypes, buildImportedReturnTypes, buildImportedRawReturnTypes, buildExportedTypeMapFromGraph } from './call-processor.js';
 import { processHeritage, processHeritageFromExtracted } from './heritage-processor.js';
 import { computeMRO } from './mro-processor.js';
 import { processCommunities } from './community-processor.js';
@@ -12,11 +14,63 @@ import { createASTCache } from './ast-cache.js';
 import { walkRepositoryPaths, readFileContents } from './filesystem-walker.js';
 import { getLanguageFromFilename } from './utils.js';
 import { isLanguageAvailable } from '../tree-sitter/parser-loader.js';
+import { SupportedLanguages } from '../../config/supported-languages.js';
 import { createWorkerPool } from './workers/worker-pool.js';
 import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 const isDev = process.env.NODE_ENV === 'development';
+/** Kahn's algorithm: returns files grouped by topological level.
+ *  Files in the same level have no mutual dependencies — safe to process in parallel.
+ *  Files in cycles are returned as a final group (no cross-cycle propagation). */
+export function topologicalLevelSort(importMap) {
+    // Build in-degree map and reverse dependency map
+    const inDegree = new Map();
+    const reverseDeps = new Map();
+    for (const [file, deps] of importMap) {
+        if (!inDegree.has(file))
+            inDegree.set(file, 0);
+        for (const dep of deps) {
+            if (!inDegree.has(dep))
+                inDegree.set(dep, 0);
+            // file imports dep, so dep must be processed before file
+            // In Kahn's terms: dep → file (dep is a prerequisite of file)
+            inDegree.set(file, (inDegree.get(file) ?? 0) + 1);
+            let rev = reverseDeps.get(dep);
+            if (!rev) {
+                rev = [];
+                reverseDeps.set(dep, rev);
+            }
+            rev.push(file);
+        }
+    }
+    // BFS from zero-in-degree nodes, grouping by level
+    const levels = [];
+    let currentLevel = [...inDegree.entries()]
+        .filter(([, d]) => d === 0)
+        .map(([f]) => f);
+    while (currentLevel.length > 0) {
+        levels.push(currentLevel);
+        const nextLevel = [];
+        for (const file of currentLevel) {
+            for (const dependent of reverseDeps.get(file) ?? []) {
+                const newDeg = (inDegree.get(dependent) ?? 1) - 1;
+                inDegree.set(dependent, newDeg);
+                if (newDeg === 0)
+                    nextLevel.push(dependent);
+            }
+        }
+        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);
+    if (cycleFiles.length > 0) {
+        levels.push(cycleFiles);
+    }
+    return { levels, cycleCount: cycleFiles.length };
+}
 /** Max bytes of source content to load per parse chunk. Each chunk's source +
  *  parsed ASTs + extracted records + worker serialization overhead all live in
  *  memory simultaneously, so this must be conservative. 20MB source ≈ 200-400MB
@@ -24,11 +78,286 @@ const isDev = process.env.NODE_ENV === 'development';
 const CHUNK_BYTE_BUDGET = 20 * 1024 * 1024; // 20MB
 /** Max AST trees to keep in LRU cache */
 const AST_CACHE_CAP = 50;
+/** Minimum percentage of files that must benefit from cross-file seeding to justify the re-resolution pass. */
+const CROSS_FILE_SKIP_THRESHOLD = 0.03;
+/** Hard cap on files re-processed during cross-file propagation. */
+const MAX_CROSS_FILE_REPROCESS = 2000;
+/** Node labels that represent top-level importable symbols.
+ *  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',
+]);
+/** 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;
+/** Languages with whole-module import semantics (no per-symbol named imports).
+ *  For these languages, namedImportMap entries are synthesized from graph-exported
+ *  symbols after parsing, enabling Phase 14 cross-file binding propagation.
+ *
+ *  Note: Python is intentionally excluded here. `import models` is a namespace import
+ *  (not wildcard symbol expansion) — expanding all exported symbols produces ambiguous
+ *  bindings when multiple modules export the same name (e.g. models.User vs auth.User).
+ *  Python module aliases are built in synthesizeWildcardImportBindings via moduleAliasMap. */
+const WILDCARD_IMPORT_LANGUAGES = new Set([
+    SupportedLanguages.Go,
+    SupportedLanguages.Ruby,
+    SupportedLanguages.C,
+    SupportedLanguages.CPlusPlus,
+    SupportedLanguages.Swift,
+]);
+/** Languages that require synthesizeWildcardImportBindings to run before call resolution.
+ *  Superset of WILDCARD_IMPORT_LANGUAGES — includes Python for moduleAliasMap building. */
+const SYNTHESIS_LANGUAGES = new Set([...WILDCARD_IMPORT_LANGUAGES, SupportedLanguages.Python]);
+/** Synthesize namedImportMap entries for languages with whole-module imports.
+ *  These languages (Go, Ruby, C/C++, Swift, Python) import all exported symbols from a
+ *  file, not specific named symbols. After parsing, we know which symbols each file
+ *  exports (via graph isExported), so we can expand ImportMap edges into per-symbol
+ *  bindings that Phase 14 can use for cross-file type propagation. */
+function synthesizeWildcardImportBindings(graph, ctx) {
+    // Pre-compute exported symbols per file from graph (single pass)
+    const exportedSymbolsByFile = new Map();
+    graph.forEachNode(node => {
+        if (!node.properties?.isExported)
+            return;
+        if (!IMPORTABLE_SYMBOL_LABELS.has(node.label))
+            return;
+        const fp = node.properties.filePath;
+        const name = node.properties.name;
+        if (!fp || !name)
+            return;
+        let symbols = exportedSymbolsByFile.get(fp);
+        if (!symbols) {
+            symbols = [];
+            exportedSymbolsByFile.set(fp, symbols);
+        }
+        symbols.push({ name, filePath: fp });
+    });
+    if (exportedSymbolsByFile.size === 0)
+        return 0;
+    // Build a merged import map: ctx.importMap has file-based imports (Ruby, C/C++),
+    // but Go/C# package imports use graph IMPORTS edges + PackageMap instead.
+    // Collect graph-level IMPORTS edges for wildcard languages missing from ctx.importMap.
+    const FILE_PREFIX = 'File:';
+    const graphImports = new Map();
+    graph.forEachRelationship(rel => {
+        if (rel.type !== 'IMPORTS')
+            return;
+        if (!rel.sourceId.startsWith(FILE_PREFIX) || !rel.targetId.startsWith(FILE_PREFIX))
+            return;
+        const srcFile = rel.sourceId.slice(FILE_PREFIX.length);
+        const tgtFile = rel.targetId.slice(FILE_PREFIX.length);
+        const lang = getLanguageFromFilename(srcFile);
+        if (!lang || !WILDCARD_IMPORT_LANGUAGES.has(lang))
+            return;
+        // Only add if not already in ctx.importMap (avoid duplicates)
+        if (ctx.importMap.get(srcFile)?.has(tgtFile))
+            return;
+        let set = graphImports.get(srcFile);
+        if (!set) {
+            set = new Set();
+            graphImports.set(srcFile, set);
+        }
+        set.add(tgtFile);
+    });
+    let totalSynthesized = 0;
+    // Helper: synthesize bindings for a file given its imported files
+    const synthesizeForFile = (filePath, importedFiles) => {
+        let fileBindings = ctx.namedImportMap.get(filePath);
+        let fileCount = fileBindings?.size ?? 0;
+        for (const importedFile of importedFiles) {
+            const exportedSymbols = exportedSymbolsByFile.get(importedFile);
+            if (!exportedSymbols)
+                continue;
+            for (const sym of exportedSymbols) {
+                if (fileCount >= MAX_SYNTHETIC_BINDINGS_PER_FILE)
+                    return;
+                if (fileBindings?.has(sym.name))
+                    continue;
+                if (!fileBindings) {
+                    fileBindings = new Map();
+                    ctx.namedImportMap.set(filePath, fileBindings);
+                }
+                fileBindings.set(sym.name, {
+                    sourcePath: importedFile,
+                    exportedName: sym.name,
+                });
+                fileCount++;
+                totalSynthesized++;
+            }
+        }
+    };
+    // Process files from ctx.importMap (Ruby, C/C++, Swift file-based imports)
+    for (const [filePath, importedFiles] of ctx.importMap) {
+        const lang = getLanguageFromFilename(filePath);
+        if (!lang || !WILDCARD_IMPORT_LANGUAGES.has(lang))
+            continue;
+        synthesizeForFile(filePath, importedFiles);
+    }
+    // Process files from graph IMPORTS edges (Go and other wildcard-import languages)
+    for (const [filePath, importedFiles] of graphImports) {
+        synthesizeForFile(filePath, importedFiles);
+    }
+    // Build module alias map for Python namespace imports.
+    // `import models` in app.py → ctx.moduleAliasMap['app.py']['models'] = 'models.py'
+    // Enables `models.User()` to resolve to models.py:User without ambiguous symbol expansion.
+    const buildPythonModuleAliasForFile = (callerFile, importedFiles) => {
+        let aliasMap = ctx.moduleAliasMap.get(callerFile);
+        for (const importedFile of importedFiles) {
+            // Derive the module alias from the imported filename stem (e.g. "models.py" → "models")
+            const lastSlash = importedFile.lastIndexOf('/');
+            const base = lastSlash >= 0 ? importedFile.slice(lastSlash + 1) : importedFile;
+            const dot = base.lastIndexOf('.');
+            const stem = dot >= 0 ? base.slice(0, dot) : base;
+            if (!stem)
+                continue;
+            if (!aliasMap) {
+                aliasMap = new Map();
+                ctx.moduleAliasMap.set(callerFile, aliasMap);
+            }
+            aliasMap.set(stem, importedFile);
+        }
+    };
+    for (const [filePath, importedFiles] of ctx.importMap) {
+        if (getLanguageFromFilename(filePath) !== SupportedLanguages.Python)
+            continue;
+        buildPythonModuleAliasForFile(filePath, importedFiles);
+    }
+    return totalSynthesized;
+}
+/** Phase 14: Cross-file binding propagation.
+ *  Seeds downstream files with resolved type bindings from upstream exports.
+ *  Files are processed in topological import order so upstream bindings are
+ *  available when downstream files are re-resolved. */
+async function runCrossFileBindingPropagation(graph, ctx, exportedTypeMap, allPaths, totalFiles, repoPath, pipelineStart, onProgress) {
+    // For the worker path, buildTypeEnv runs inside workers without SymbolTable,
+    // so exported bindings must be collected from graph + SymbolTable in main thread.
+    if (exportedTypeMap.size === 0 && graph.nodeCount > 0) {
+        const graphExports = buildExportedTypeMapFromGraph(graph, ctx.symbols);
+        for (const [fp, exports] of graphExports)
+            exportedTypeMap.set(fp, exports);
+    }
+    if (exportedTypeMap.size === 0 || ctx.namedImportMap.size === 0)
+        return;
+    const allPathSet = new Set(allPaths);
+    const { levels, cycleCount } = topologicalLevelSort(ctx.importMap);
+    // Cycle diagnostic: only log when actual cycles detected (cycleCount from Kahn's BFS)
+    if (isDev && cycleCount > 0) {
+        console.log(`🔄 ${cycleCount} files in import cycles (skipped for cross-file propagation)`);
+    }
+    // Quick count of files with cross-file binding gaps (early exit once threshold exceeded)
+    let filesWithGaps = 0;
+    const gapThreshold = Math.max(1, Math.ceil(totalFiles * CROSS_FILE_SKIP_THRESHOLD));
+    outer: for (const level of levels) {
+        for (const filePath of level) {
+            const imports = ctx.namedImportMap.get(filePath);
+            if (!imports)
+                continue;
+            for (const [, binding] of imports) {
+                const upstream = exportedTypeMap.get(binding.sourcePath);
+                if (upstream?.has(binding.exportedName)) {
+                    filesWithGaps++;
+                    break;
+                }
+                const def = ctx.symbols.lookupExactFull(binding.sourcePath, binding.exportedName);
+                if (def?.returnType) {
+                    filesWithGaps++;
+                    break;
+                }
+            }
+            if (filesWithGaps >= gapThreshold)
+                break outer;
+        }
+    }
+    const gapRatio = totalFiles > 0 ? filesWithGaps / totalFiles : 0;
+    if (gapRatio < CROSS_FILE_SKIP_THRESHOLD && filesWithGaps < gapThreshold) {
+        if (isDev) {
+            console.log(`⏭️ Cross-file re-resolution skipped (${filesWithGaps}/${totalFiles} files, ${(gapRatio * 100).toFixed(1)}% < ${CROSS_FILE_SKIP_THRESHOLD * 100}% threshold)`);
+        }
+        return;
+    }
+    onProgress({
+        phase: 'parsing',
+        percent: 82,
+        message: `Cross-file type propagation (${filesWithGaps}+ files)...`,
+        stats: { filesProcessed: totalFiles, totalFiles, nodesCreated: graph.nodeCount },
+    });
+    let crossFileResolved = 0;
+    const crossFileStart = Date.now();
+    let astCache = createASTCache(AST_CACHE_CAP);
+    for (const level of levels) {
+        const levelCandidates = [];
+        for (const filePath of level) {
+            if (crossFileResolved + levelCandidates.length >= MAX_CROSS_FILE_REPROCESS)
+                break;
+            const imports = ctx.namedImportMap.get(filePath);
+            if (!imports)
+                continue;
+            const seeded = new Map();
+            for (const [localName, binding] of imports) {
+                const upstream = exportedTypeMap.get(binding.sourcePath);
+                if (upstream) {
+                    const type = upstream.get(binding.exportedName);
+                    if (type)
+                        seeded.set(localName, type);
+                }
+            }
+            const importedReturns = buildImportedReturnTypes(filePath, ctx.namedImportMap, ctx.symbols);
+            const importedRawReturns = buildImportedRawReturnTypes(filePath, ctx.namedImportMap, ctx.symbols);
+            if (seeded.size === 0 && importedReturns.size === 0)
+                continue;
+            if (!allPathSet.has(filePath))
+                continue;
+            const lang = getLanguageFromFilename(filePath);
+            if (!lang || !isLanguageAvailable(lang))
+                continue;
+            levelCandidates.push({ filePath, seeded, importedReturns, importedRawReturns });
+        }
+        if (levelCandidates.length === 0)
+            continue;
+        const levelPaths = levelCandidates.map(c => c.filePath);
+        const contentMap = await readFileContents(repoPath, levelPaths);
+        for (const { filePath, seeded, importedReturns, importedRawReturns } of levelCandidates) {
+            const content = contentMap.get(filePath);
+            if (!content)
+                continue;
+            const reFile = [{ path: filePath, content }];
+            const bindings = new Map();
+            if (seeded.size > 0)
+                bindings.set(filePath, seeded);
+            const importedReturnTypesMap = new Map();
+            if (importedReturns.size > 0) {
+                importedReturnTypesMap.set(filePath, importedReturns);
+            }
+            const importedRawReturnTypesMap = new Map();
+            if (importedRawReturns.size > 0) {
+                importedRawReturnTypesMap.set(filePath, importedRawReturns);
+            }
+            await processCalls(graph, reFile, astCache, ctx, undefined, exportedTypeMap, bindings.size > 0 ? bindings : undefined, importedReturnTypesMap.size > 0 ? importedReturnTypesMap : undefined, importedRawReturnTypesMap.size > 0 ? importedRawReturnTypesMap : undefined);
+            crossFileResolved++;
+        }
+        if (crossFileResolved >= MAX_CROSS_FILE_REPROCESS) {
+            if (isDev)
+                console.log(`⚠️ Cross-file re-resolution capped at ${MAX_CROSS_FILE_REPROCESS} files`);
+            break;
+        }
+    }
+    astCache.clear();
+    if (isDev) {
+        const elapsed = Date.now() - crossFileStart;
+        const totalElapsed = Date.now() - pipelineStart;
+        const reResolutionPct = totalElapsed > 0 ? ((elapsed / totalElapsed) * 100).toFixed(1) : '0';
+        console.log(`🔗 Cross-file re-resolution: ${crossFileResolved} candidates re-processed` +
+            ` in ${elapsed}ms (${reResolutionPct}% of total ingestion time so far)`);
+    }
+}
 export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
     const graph = createKnowledgeGraph();
     const ctx = createResolutionContext();
     const symbolTable = ctx.symbols;
     let astCache = createASTCache(AST_CACHE_CAP);
+    const pipelineStart = Date.now();
     const cleanup = () => {
         astCache.clear();
         ctx.clear();
@@ -72,6 +401,19 @@ export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
             message: 'Project structure analyzed',
             stats: { filesProcessed: totalFiles, totalFiles, nodesCreated: graph.nodeCount },
         });
+        // ── Phase 2.5: Markdown processing (headings + cross-links) ────────
+        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 mdFiles = mdScanned
+                .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) {
+                console.log(`  Markdown: ${mdResult.sections} sections, ${mdResult.links} cross-links from ${mdFiles.length} files`);
+            }
+        }
         // ── Phase 3+4: Chunked read + parse ────────────────────────────────
         // Group parseable files into byte-budget chunks so only ~20MB of source
         // is in memory at a time. Each chunk is: read → parse → extract → free.
@@ -163,6 +505,15 @@ export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
         // are already registered). This trades ~5% cross-chunk resolution accuracy for
         // 200-400MB less memory — critical for Linux-kernel-scale repos.
         const sequentialChunkPaths = [];
+        // Pre-compute which chunks need synthesis — O(1) lookup per chunk.
+        const chunkNeedsSynthesis = chunks.map(paths => paths.some(p => {
+            const lang = getLanguageFromFilename(p);
+            return lang != null && SYNTHESIS_LANGUAGES.has(lang);
+        }));
+        // Phase 14: Collect exported type bindings for cross-file propagation
+        const exportedTypeMap = new Map();
+        // Accumulate file-scope TypeEnv bindings from workers (closes worker/sequential quality gap)
+        const workerTypeEnvBindings = [];
         try {
             for (let chunkIdx = 0; chunkIdx < numChunks; chunkIdx++) {
                 const chunkPaths = chunks[chunkIdx];
@@ -195,6 +546,23 @@ export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
                             stats: { filesProcessed: filesParsedSoFar, totalFiles: totalParseable, nodesCreated: graph.nodeCount },
                         });
                     }, repoPath, importCtx);
+                    // ── Wildcard-import synthesis (Ruby / C/C++ / Swift / Go) + Python module aliases ─
+                    // Synthesize namedImportMap entries for wildcard-import languages and build
+                    // moduleAliasMap for Python namespace imports. Must run after imports are resolved
+                    // (importMap is populated) but BEFORE call resolution.
+                    if (chunkNeedsSynthesis[chunkIdx])
+                        synthesizeWildcardImportBindings(graph, ctx);
+                    // Phase 14 E1: Seed cross-file receiver types from ExportedTypeMap
+                    // before call resolution — eliminates re-parse for single-hop imported receivers.
+                    // NOTE: In the worker path, exportedTypeMap is empty during chunk processing
+                    // (populated later in runCrossFileBindingPropagation). This block is latent —
+                    // it activates only if incremental export collection is added per-chunk.
+                    if (exportedTypeMap.size > 0 && ctx.namedImportMap.size > 0) {
+                        const { enrichedCount } = seedCrossFileReceiverTypes(chunkWorkerData.calls, ctx.namedImportMap, exportedTypeMap);
+                        if (isDev && enrichedCount > 0) {
+                            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.
@@ -227,6 +595,14 @@ export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
                             });
                         }),
                     ]);
+                    // 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);
+                    }
                 }
                 else {
                     await processImports(graph, chunkFiles, astCache, ctx, undefined, repoPath, allPaths);
@@ -242,13 +618,17 @@ export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
             await workerPool?.terminate();
         }
         // Sequential fallback chunks: re-read source for call/heritage resolution
+        // Synthesize wildcard import bindings once after ALL imports are processed,
+        // before any call resolution — same rationale as the worker-path inline synthesis.
+        if (sequentialChunkPaths.length > 0)
+            synthesizeWildcardImportBindings(graph, ctx);
         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) }));
             astCache = createASTCache(chunkFiles.length);
-            const rubyHeritage = await processCalls(graph, chunkFiles, astCache, ctx);
+            const rubyHeritage = await processCalls(graph, chunkFiles, astCache, ctx, undefined, exportedTypeMap);
             await processHeritage(graph, chunkFiles, astCache, ctx);
             if (rubyHeritage.length > 0) {
                 await processHeritageFromExtracted(graph, rubyHeritage, ctx);
@@ -262,12 +642,53 @@ export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
             const hitRate = total > 0 ? ((rcStats.cacheHits / total) * 100).toFixed(1) : '0';
             console.log(`🔍 Resolution cache: ${rcStats.cacheHits} hits, ${rcStats.cacheMisses} misses (${hitRate}% hit rate)`);
         }
+        // ── Worker path quality enrichment: merge TypeEnv file-scope bindings into ExportedTypeMap ──
+        // Workers return file-scope bindings from their TypeEnv fixpoint (includes inferred types
+        // like `const config = getConfig()` → Config). Filter by graph isExported to match
+        // the sequential path's collectExportedBindings behavior.
+        if (workerTypeEnvBindings.length > 0) {
+            let enriched = 0;
+            for (const { filePath, bindings } of workerTypeEnvBindings) {
+                for (const [name, type] of bindings) {
+                    // Verify the symbol is exported via graph node
+                    const nodeId = `Function:${filePath}:${name}`;
+                    const varNodeId = `Variable:${filePath}:${name}`;
+                    const constNodeId = `Const:${filePath}:${name}`;
+                    const node = graph.getNode(nodeId) ?? graph.getNode(varNodeId) ?? graph.getNode(constNodeId);
+                    if (!node?.properties?.isExported)
+                        continue;
+                    let fileExports = exportedTypeMap.get(filePath);
+                    if (!fileExports) {
+                        fileExports = new Map();
+                        exportedTypeMap.set(filePath, fileExports);
+                    }
+                    // Don't overwrite existing entries (Tier 0 from SymbolTable is authoritative)
+                    if (!fileExports.has(name)) {
+                        fileExports.set(name, type);
+                        enriched++;
+                    }
+                }
+            }
+            if (isDev && enriched > 0) {
+                console.log(`🔗 Worker TypeEnv enrichment: ${enriched} fixpoint-inferred exports added to ExportedTypeMap`);
+            }
+        }
+        // ── Phase 14 pre-pass: Final synthesis pass for whole-module-import languages ──
+        // Per-chunk synthesis (above) already ran incrementally. This final pass ensures
+        // any remaining files whose imports were not covered inline are also synthesized,
+        // and that Phase 14 type propagation has complete namedImportMap data.
+        const synthesized = synthesizeWildcardImportBindings(graph, ctx);
+        if (isDev && synthesized > 0) {
+            console.log(`🔗 Synthesized ${synthesized} additional wildcard import bindings (Go/Ruby/C++/Swift/Python)`);
+        }
+        // ── Phase 14: Cross-file binding propagation ──────────────────────
+        await runCrossFileBindingPropagation(graph, ctx, exportedTypeMap, allPaths, totalFiles, repoPath, pipelineStart, onProgress);
         // Free import resolution context — suffix index + resolve cache no longer needed
         // (allPathObjects and importCtx hold ~94MB+ for large repos)
         allPathObjects.length = 0;
         importCtx.resolveCache.clear();
-        importCtx.suffixIndex = null;
-        importCtx.normalizedFileList = null;
+        importCtx.index = EMPTY_INDEX; // Release suffix index memory (~30MB for large repos)
+        importCtx.normalizedFileList = [];
         let communityResult;
         let processResult;
         if (!options?.skipGraphPhases) {

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

@@ -26,6 +26,9 @@ export declare const TIER_CONFIDENCE: Record<ResolutionTier, number>;
 export type ImportMap = Map<string, Set<string>>;
 export type PackageMap = Map<string, Set<string>>;
 export type NamedImportMap = Map<string, Map<string, NamedImportBinding>>;
+/** Maps callerFile → (moduleAlias → sourceFilePath) for Python namespace imports.
+ *  e.g. `import models` in app.py → moduleAliasMap.get('app.py')?.get('models') === 'models.py' */
+export type ModuleAliasMap = Map<string, Map<string, string>>;
 export interface ResolutionContext {
     /**
      * The only resolution API. Returns all candidates at the winning tier.
@@ -40,6 +43,8 @@ export interface ResolutionContext {
     readonly importMap: ImportMap;
     readonly packageMap: PackageMap;
     readonly namedImportMap: NamedImportMap;
+    /** Module-alias map for Python namespace imports: callerFile → (alias → sourceFile). */
+    readonly moduleAliasMap: ModuleAliasMap;
     enableCache(filePath: string): void;
     clearCache(): void;
     getStats(): {

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

@@ -26,6 +26,7 @@ export const createResolutionContext = () => {
     const importMap = new Map();
     const packageMap = new Map();
     const namedImportMap = new Map();
+    const moduleAliasMap = new Map();
     // Per-file cache state
     let cacheFile = null;
     let cache = null;
@@ -33,10 +34,10 @@ export const createResolutionContext = () => {
     let cacheMisses = 0;
     // --- Core resolution (single implementation of tier logic) ---
     const resolveUncached = (name, fromFile) => {
-        // Tier 1: Same file — authoritative match
-        const localDef = symbols.lookupExactFull(fromFile, name);
-        if (localDef) {
-            return { candidates: [localDef], tier: 'same-file' };
+        // Tier 1: Same file — authoritative match (returns all overloads)
+        const localDefs = symbols.lookupExactAll(fromFile, name);
+        if (localDefs.length > 0) {
+            return { candidates: localDefs, tier: 'same-file' };
         }
         // Get all global definitions for subsequent tiers
         const allDefs = symbols.lookupFuzzy(name);
@@ -114,6 +115,7 @@ export const createResolutionContext = () => {
         importMap.clear();
         packageMap.clear();
         namedImportMap.clear();
+        moduleAliasMap.clear();
         clearCache();
         cacheHits = 0;
         cacheMisses = 0;
@@ -124,6 +126,7 @@ export const createResolutionContext = () => {
         importMap,
         packageMap,
         namedImportMap,
+        moduleAliasMap,
         enableCache,
         clearCache,
         getStats,

package/dist/core/ingestion/resolvers/index.d.ts

@@ -2,7 +2,7 @@
  * Language-specific import resolvers.
  * Extracted from import-processor.ts for maintainability.
  */
-export { EXTENSIONS, tryResolveWithExtensions, buildSuffixIndex, suffixResolve } from './utils.js';
+export { EXTENSIONS, tryResolveWithExtensions, buildSuffixIndex, suffixResolve, EMPTY_INDEX } from './utils.js';
 export type { SuffixIndex } from './utils.js';
 export { KOTLIN_EXTENSIONS, appendKotlinWildcard, resolveJvmWildcard, resolveJvmMemberImport } from './jvm.js';
 export { resolveGoPackageDir, resolveGoPackage } from './go.js';

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

@@ -2,7 +2,7 @@
  * Language-specific import resolvers.
  * Extracted from import-processor.ts for maintainability.
  */
-export { EXTENSIONS, tryResolveWithExtensions, buildSuffixIndex, suffixResolve } from './utils.js';
+export { EXTENSIONS, tryResolveWithExtensions, buildSuffixIndex, suffixResolve, EMPTY_INDEX } from './utils.js';
 export { KOTLIN_EXTENSIONS, appendKotlinWildcard, resolveJvmWildcard, resolveJvmMemberImport } from './jvm.js';
 export { resolveGoPackageDir, resolveGoPackage } from './go.js';
 export { resolveCSharpImport, resolveCSharpNamespaceDir } from './csharp.js';

package/dist/core/ingestion/resolvers/jvm.d.ts

@@ -3,13 +3,14 @@
  * Handles wildcard imports, member/static imports, and Kotlin-specific patterns.
  */
 import type { SuffixIndex } from './utils.js';
+import type { SyntaxNode } from '../utils.js';
 /** Kotlin file extensions for JVM resolver reuse */
 export declare const KOTLIN_EXTENSIONS: readonly string[];
 /**
  * Append .* to a Kotlin import path if the AST has a wildcard_import sibling node.
  * Pure function — returns a new string without mutating the input.
  */
-export declare const appendKotlinWildcard: (importPath: string, importNode: any) => string;
+export declare const appendKotlinWildcard: (importPath: string, importNode: SyntaxNode) => string;
 /**
  * Resolve a JVM wildcard import (com.example.*) to all matching files.
  * Works for both Java (.java) and Kotlin (.kt, .kts).

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

@@ -27,26 +27,42 @@ export function resolveJvmWildcard(importPath, normalizedFileList, allFileList,
         const candidates = extensions.flatMap(ext => index.getFilesInDir(packagePath, ext));
         // Filter to only direct children (no subdirectories)
         const packageSuffix = '/' + packagePath + '/';
+        const packagePrefix = packagePath + '/';
         return candidates.filter(f => {
             const normalized = f.replace(/\\/g, '/');
-            const idx = normalized.indexOf(packageSuffix);
-            if (idx < 0)
+            // Match both nested (src/models/User.kt) and root-level (models/User.kt) packages
+            let afterPkg;
+            const idx = normalized.lastIndexOf(packageSuffix);
+            if (idx >= 0) {
+                afterPkg = normalized.substring(idx + packageSuffix.length);
+            }
+            else if (normalized.startsWith(packagePrefix)) {
+                afterPkg = normalized.substring(packagePrefix.length);
+            }
+            else {
                 return false;
-            const afterPkg = normalized.substring(idx + packageSuffix.length);
+            }
             return !afterPkg.includes('/');
         });
     }
     // Fallback: linear scan
     const packageSuffix = '/' + packagePath + '/';
+    const packagePrefix = packagePath + '/';
     const matches = [];
     for (let i = 0; i < normalizedFileList.length; i++) {
         const normalized = normalizedFileList[i];
-        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]);
-            }
+        if (!extensions.some(ext => normalized.endsWith(ext)))
+            continue;
+        // Match both nested (src/models/User.kt) and root-level (models/User.kt) packages
+        let afterPackage = null;
+        if (normalized.includes(packageSuffix)) {
+            afterPackage = normalized.substring(normalized.lastIndexOf(packageSuffix) + packageSuffix.length);
+        }
+        else if (normalized.startsWith(packagePrefix)) {
+            afterPackage = normalized.substring(packagePrefix.length);
+        }
+        if (afterPackage !== null && !afterPackage.includes('/')) {
+            matches.push(allFileList[i]);
         }
     }
     return matches;