@zuvia-software-solutions/code-mapper 1.4.0

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

@@ -0,0 +1,31 @@
+/** @file import-processor.ts @description Resolves import statements across all supported languages, builds the ImportMap/PackageMap/NamedImportMap, and emits IMPORTS graph edges. Supports language-specific resolution for TS, Go, C#, PHP, Swift, Ruby, Rust, and JVM languages */
+import { KnowledgeGraph } from '../graph/types.js';
+import { ASTCache } from './ast-cache.js';
+import type { ExtractedImport } from './workers/parse-worker.js';
+import type { ResolutionContext } from './resolution-context.js';
+import type { SuffixIndex } from './resolvers/index.js';
+export type { SuffixIndex, TsconfigPaths, GoModuleConfig, CSharpProjectConfig, ComposerConfig } from './resolvers/index.js';
+export type ImportMap = Map<string, Set<string>>;
+export type PackageMap = Map<string, Set<string>>;
+export interface NamedImportBinding {
+    sourcePath: string;
+    exportedName: string;
+}
+export type NamedImportMap = Map<string, Map<string, NamedImportBinding>>;
+/** Check if a file path is directly inside a package directory identified by its suffix */
+export declare function isFileInPackageDir(filePath: string, dirSuffix: string): boolean;
+export interface ImportResolutionContext {
+    allFilePaths: Set<string>;
+    allFileList: string[];
+    normalizedFileList: string[];
+    suffixIndex: SuffixIndex;
+    resolveCache: Map<string, string | null>;
+}
+export declare function buildImportResolutionContext(allPaths: string[]): ImportResolutionContext;
+export declare const processImports: (graph: KnowledgeGraph, files: {
+    path: string;
+    content: string;
+}[], astCache: ASTCache, ctx: ResolutionContext, onProgress?: (current: number, total: number) => void, repoRoot?: string, allPaths?: string[]) => Promise<void>;
+export declare const processImportsFromExtracted: (graph: KnowledgeGraph, files: {
+    path: string;
+}[], extractedImports: ExtractedImport[], ctx: ResolutionContext, onProgress?: (current: number, total: number) => void, repoRoot?: string, prebuiltCtx?: ImportResolutionContext) => Promise<void>;

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

@@ -0,0 +1,416 @@
+// code-mapper/src/core/ingestion/import-processor.ts
+/** @file import-processor.ts @description Resolves import statements across all supported languages, builds the ImportMap/PackageMap/NamedImportMap, and emits IMPORTS graph edges. Supports language-specific resolution for TS, Go, C#, PHP, Swift, Ruby, Rust, and JVM languages */
+import Parser from 'tree-sitter';
+import { isLanguageAvailable, loadParser, loadLanguage } from '../tree-sitter/parser-loader.js';
+import { LANGUAGE_QUERIES } from './tree-sitter-queries.js';
+import { generateId } from '../../lib/utils.js';
+import { getLanguageFromFilename, isVerboseIngestionEnabled, yieldToEventLoop } from './utils.js';
+import { SupportedLanguages } from '../../config/supported-languages.js';
+import { extractNamedBindings } from './named-binding-extraction.js';
+import { getTreeSitterBufferSize } from './constants.js';
+import { loadTsconfigPaths, loadGoModulePath, loadComposerConfig, loadCSharpProjectConfig, loadSwiftPackageConfig, } from './language-config.js';
+import { buildSuffixIndex, resolveImportPath, appendKotlinWildcard, KOTLIN_EXTENSIONS, resolveJvmWildcard, resolveJvmMemberImport, resolveGoPackageDir, resolveGoPackage, resolveCSharpImport, resolveCSharpNamespaceDir, resolvePhpImport, resolveRustImport, resolveRubyImport, } from './resolvers/index.js';
+import { callRouters } from './call-routing.js';
+const isDev = process.env.NODE_ENV === 'development';
+/** Check if a file path is directly inside a package directory identified by its suffix */
+export function isFileInPackageDir(filePath, dirSuffix) {
+    // Prepend '/' so paths like "internal/auth/service.go" match suffix "/internal/auth/"
+    const normalized = '/' + filePath.replace(/\\/g, '/');
+    if (!normalized.includes(dirSuffix))
+        return false;
+    const afterDir = normalized.substring(normalized.indexOf(dirSuffix) + dirSuffix.length);
+    return !afterDir.includes('/');
+}
+export function buildImportResolutionContext(allPaths) {
+    const allFileList = allPaths;
+    const normalizedFileList = allFileList.map(p => p.replace(/\\/g, '/'));
+    const allFilePaths = new Set(allFileList);
+    const suffixIndex = buildSuffixIndex(normalizedFileList, allFileList);
+    return { allFilePaths, allFileList, normalizedFileList, suffixIndex, resolveCache: new Map() };
+}
+/** Shared language dispatch for import resolution, used by both AST and fast paths */
+function resolveLanguageImport(filePath, rawImportPath, language, configs, ctx) {
+    const { allFilePaths, allFileList, normalizedFileList, index, resolveCache } = ctx;
+    const { tsconfigPaths, goModule, composerConfig, swiftPackageConfig, csharpConfigs } = configs;
+    // JVM languages (Java + Kotlin): handle wildcards and member imports
+    if (language === SupportedLanguages.Java || language === SupportedLanguages.Kotlin) {
+        const exts = language === SupportedLanguages.Java ? ['.java'] : KOTLIN_EXTENSIONS;
+        if (rawImportPath.endsWith('.*')) {
+            const matchedFiles = resolveJvmWildcard(rawImportPath, normalizedFileList, allFileList, exts, index);
+            if (matchedFiles.length === 0 && language === SupportedLanguages.Kotlin) {
+                const javaMatches = resolveJvmWildcard(rawImportPath, normalizedFileList, allFileList, ['.java'], index);
+                if (javaMatches.length > 0)
+                    return { kind: 'files', files: javaMatches };
+            }
+            if (matchedFiles.length > 0)
+                return { kind: 'files', files: matchedFiles };
+            // Fall through to standard resolution
+        }
+        else {
+            let memberResolved = resolveJvmMemberImport(rawImportPath, normalizedFileList, allFileList, exts, index);
+            if (!memberResolved && language === SupportedLanguages.Kotlin) {
+                memberResolved = resolveJvmMemberImport(rawImportPath, normalizedFileList, allFileList, ['.java'], index);
+            }
+            if (memberResolved)
+                return { kind: 'files', files: [memberResolved] };
+            // Fall through to standard resolution
+        }
+    }
+    // Go: handle package-level imports
+    if (language === SupportedLanguages.Go && goModule && rawImportPath.startsWith(goModule.modulePath)) {
+        const pkgSuffix = resolveGoPackageDir(rawImportPath, goModule);
+        if (pkgSuffix) {
+            const pkgFiles = resolveGoPackage(rawImportPath, goModule, normalizedFileList, allFileList);
+            if (pkgFiles.length > 0) {
+                return { kind: 'package', files: pkgFiles, dirSuffix: pkgSuffix };
+            }
+        }
+        // Fall through if no files found (package might be external)
+    }
+    // C#: handle namespace-based imports (using directives)
+    if (language === SupportedLanguages.CSharp && csharpConfigs.length > 0) {
+        const resolvedFiles = resolveCSharpImport(rawImportPath, csharpConfigs, normalizedFileList, allFileList, index);
+        if (resolvedFiles.length > 1) {
+            const dirSuffix = resolveCSharpNamespaceDir(rawImportPath, csharpConfigs);
+            if (dirSuffix) {
+                return { kind: 'package', files: resolvedFiles, dirSuffix };
+            }
+        }
+        if (resolvedFiles.length > 0)
+            return { kind: 'files', files: resolvedFiles };
+        return null;
+    }
+    // PHP: namespace-based imports (use statements)
+    if (language === SupportedLanguages.PHP) {
+        const resolved = resolvePhpImport(rawImportPath, composerConfig, allFilePaths, normalizedFileList, allFileList, index);
+        return resolved ? { kind: 'files', files: [resolved] } : null;
+    }
+    // Swift: handle module imports
+    if (language === SupportedLanguages.Swift && swiftPackageConfig) {
+        const targetDir = swiftPackageConfig.targets.get(rawImportPath);
+        if (targetDir) {
+            const dirPrefix = targetDir + '/';
+            const files = [];
+            for (let i = 0; i < normalizedFileList.length; i++) {
+                if (normalizedFileList[i].startsWith(dirPrefix) && normalizedFileList[i].endsWith('.swift')) {
+                    files.push(allFileList[i]);
+                }
+            }
+            if (files.length > 0)
+                return { kind: 'files', files };
+        }
+        return null; // External framework (Foundation, UIKit, etc)
+    }
+    // Ruby: require / require_relative
+    if (language === SupportedLanguages.Ruby) {
+        const resolved = resolveRubyImport(rawImportPath, normalizedFileList, allFileList, index);
+        return resolved ? { kind: 'files', files: [resolved] } : null;
+    }
+    // Rust: expand top-level grouped imports — use {crate::a, crate::b}
+    if (language === SupportedLanguages.Rust && rawImportPath.startsWith('{') && rawImportPath.endsWith('}')) {
+        const inner = rawImportPath.slice(1, -1);
+        const parts = inner.split(',').map(p => p.trim()).filter(Boolean);
+        const resolved = [];
+        for (const part of parts) {
+            const r = resolveRustImport(filePath, part, allFilePaths);
+            if (r)
+                resolved.push(r);
+        }
+        return resolved.length > 0 ? { kind: 'files', files: resolved } : null;
+    }
+    // Standard single-file resolution
+    const resolvedPath = resolveImportPath(filePath, rawImportPath, allFilePaths, allFileList, normalizedFileList, resolveCache, language, tsconfigPaths, index);
+    return resolvedPath ? { kind: 'files', files: [resolvedPath] } : null;
+}
+/** Apply an ImportResult — emit graph edges, update ImportMap/PackageMap and NamedImportMap */
+function applyImportResult(result, filePath, importMap, packageMap, addImportEdge, addImportGraphEdge, namedBindings, namedImportMap) {
+    if (!result)
+        return;
+    if (result.kind === 'package' && packageMap) {
+        // Store directory suffix in PackageMap (skip ImportMap expansion)
+        for (const resolvedFile of result.files) {
+            addImportGraphEdge(filePath, resolvedFile);
+        }
+        if (!packageMap.has(filePath))
+            packageMap.set(filePath, new Set());
+        packageMap.get(filePath).add(result.dirSuffix);
+    }
+    else {
+        // 'files' kind or 'package' without PackageMap — use ImportMap directly
+        const files = result.files;
+        for (const resolvedFile of files) {
+            addImportEdge(filePath, resolvedFile);
+        }
+        // Record named bindings for precise Tier 2a resolution
+        if (namedBindings && namedImportMap && files.length === 1) {
+            const resolvedFile = files[0];
+            if (!namedImportMap.has(filePath))
+                namedImportMap.set(filePath, new Map());
+            const fileBindings = namedImportMap.get(filePath);
+            for (const binding of namedBindings) {
+                fileBindings.set(binding.local, { sourcePath: resolvedFile, exportedName: binding.exported });
+            }
+        }
+    }
+}
+/**
+ * Create transitive IMPORTS edges by walking re-export chains in the NamedImportMap
+ *
+ * When A imports {User} from B and B re-exports {User} from C, adds edge A→C
+ * Must be called AFTER all imports are processed
+ */
+function addTransitiveImportEdges(namedImportMap, importMap, addImportEdge) {
+    for (const [filePath, bindings] of namedImportMap) {
+        const existingImports = importMap.get(filePath);
+        for (const [localName, binding] of bindings) {
+            // Walk the re-export chain to find the ultimate source file
+            let sourcePath = binding.sourcePath;
+            const visited = new Set([`${filePath}:${localName}`]);
+            let depth = 0;
+            while (depth < 5) {
+                const sourceBindings = namedImportMap.get(sourcePath);
+                if (!sourceBindings)
+                    break;
+                const nextBinding = sourceBindings.get(binding.exportedName);
+                if (!nextBinding)
+                    break;
+                const key = `${nextBinding.sourcePath}:${nextBinding.exportedName}`;
+                if (visited.has(key))
+                    break;
+                visited.add(key);
+                sourcePath = nextBinding.sourcePath;
+                depth++;
+            }
+            // If the chain resolved to a different file, create a transitive edge
+            if (depth > 0 && (!existingImports || !existingImports.has(sourcePath))) {
+                addImportEdge(filePath, sourcePath);
+            }
+        }
+    }
+}
+export const processImports = async (graph, files, astCache, ctx, onProgress, repoRoot, allPaths) => {
+    const importMap = ctx.importMap;
+    const packageMap = ctx.packageMap;
+    const namedImportMap = ctx.namedImportMap;
+    // Use allPaths (full repo) when available for cross-chunk resolution
+    const allFileList = allPaths ?? files.map(f => f.path);
+    const allFilePaths = new Set(allFileList);
+    const parser = await loadParser();
+    const logSkipped = isVerboseIngestionEnabled();
+    const skippedByLang = logSkipped ? new Map() : null;
+    const resolveCache = new Map();
+    // Pre-compute normalized file list once
+    const normalizedFileList = allFileList.map(p => p.replace(/\\/g, '/'));
+    // Build suffix index for O(1) lookups
+    const index = buildSuffixIndex(normalizedFileList, allFileList);
+    // Track import statistics
+    let totalImportsFound = 0;
+    let totalImportsResolved = 0;
+    // Load language-specific configs once before the file loop
+    const effectiveRoot = repoRoot || '';
+    const configs = {
+        tsconfigPaths: await loadTsconfigPaths(effectiveRoot),
+        goModule: await loadGoModulePath(effectiveRoot),
+        composerConfig: await loadComposerConfig(effectiveRoot),
+        swiftPackageConfig: await loadSwiftPackageConfig(effectiveRoot),
+        csharpConfigs: await loadCSharpProjectConfig(effectiveRoot),
+    };
+    const resolveCtx = { allFilePaths, allFileList, normalizedFileList, index, resolveCache };
+    // Add IMPORTS edge to graph only (no ImportMap update)
+    const addImportGraphEdge = (filePath, resolvedPath) => {
+        const sourceId = generateId('File', filePath);
+        const targetId = generateId('File', resolvedPath);
+        const relId = generateId('IMPORTS', `${filePath}->${resolvedPath}`);
+        totalImportsResolved++;
+        graph.addRelationship({
+            id: relId,
+            sourceId,
+            targetId,
+            type: 'IMPORTS',
+            confidence: 1.0,
+            reason: '',
+        });
+    };
+    // Add IMPORTS edge + update ImportMap
+    const addImportEdge = (filePath, resolvedPath) => {
+        addImportGraphEdge(filePath, resolvedPath);
+        if (!importMap.has(filePath)) {
+            importMap.set(filePath, new Set());
+        }
+        importMap.get(filePath).add(resolvedPath);
+    };
+    for (let i = 0; i < files.length; i++) {
+        const file = files[i];
+        onProgress?.(i + 1, files.length);
+        if (i % 20 === 0)
+            await yieldToEventLoop();
+        // Check language support
+        const language = getLanguageFromFilename(file.path);
+        if (!language)
+            continue;
+        if (!isLanguageAvailable(language)) {
+            if (skippedByLang) {
+                skippedByLang.set(language, (skippedByLang.get(language) ?? 0) + 1);
+            }
+            continue;
+        }
+        const queryStr = LANGUAGE_QUERIES[language];
+        if (!queryStr)
+            continue;
+        // Load the language before querying (parser is stateful)
+        await loadLanguage(language, file.path);
+        // Get AST (try cache first)
+        let tree = astCache.get(file.path);
+        let wasReparsed = false;
+        if (!tree) {
+            try {
+                tree = parser.parse(file.content, undefined, { bufferSize: getTreeSitterBufferSize(file.content.length) });
+            }
+            catch (parseError) {
+                continue;
+            }
+            wasReparsed = true;
+            // Cache re-parsed tree for call/heritage phases
+            astCache.set(file.path, tree);
+        }
+        let query;
+        let matches;
+        try {
+            const lang = parser.getLanguage();
+            query = new Parser.Query(lang, queryStr);
+            matches = query.matches(tree.rootNode);
+        }
+        catch (queryError) {
+            if (isDev) {
+                console.group(`🔴 Query Error: ${file.path}`);
+                console.log('Language:', language);
+                console.log('Query (first 200 chars):', queryStr.substring(0, 200) + '...');
+                console.log('Error:', queryError?.message || queryError);
+                console.log('File content (first 300 chars):', file.content.substring(0, 300));
+                console.log('AST root type:', tree.rootNode?.type);
+                console.log('AST has errors:', tree.rootNode?.hasError);
+                console.groupEnd();
+            }
+            if (wasReparsed)
+                tree.delete?.();
+            continue;
+        }
+        matches.forEach(match => {
+            const captureMap = {};
+            match.captures.forEach(c => captureMap[c.name] = c.node);
+            if (captureMap['import']) {
+                const sourceNode = captureMap['import.source'];
+                if (!sourceNode) {
+                    if (isDev) {
+                        console.log(`⚠️ Import captured but no source node in ${file.path}`);
+                    }
+                    return;
+                }
+                // Clean path — remove quotes and angle brackets for C/C++ includes
+                const rawImportPath = language === SupportedLanguages.Kotlin
+                    ? appendKotlinWildcard(sourceNode.text.replace(/['"<>]/g, ''), captureMap['import'])
+                    : sourceNode.text.replace(/['"<>]/g, '');
+                totalImportsFound++;
+                const result = resolveLanguageImport(file.path, rawImportPath, language, configs, resolveCtx);
+                const bindings = namedImportMap ? extractNamedBindings(captureMap['import'], language) : undefined;
+                applyImportResult(result, file.path, importMap, packageMap, addImportEdge, addImportGraphEdge, bindings, namedImportMap);
+            }
+            // Language-specific call-as-import routing (Ruby require, etc)
+            if (captureMap['call']) {
+                const callNameNode = captureMap['call.name'];
+                if (callNameNode) {
+                    const callRouter = callRouters[language];
+                    const routed = callRouter(callNameNode.text, captureMap['call']);
+                    if (routed && routed.kind === 'import') {
+                        totalImportsFound++;
+                        const result = resolveLanguageImport(file.path, routed.importPath, language, configs, resolveCtx);
+                        applyImportResult(result, file.path, importMap, packageMap, addImportEdge, addImportGraphEdge);
+                    }
+                }
+            }
+        });
+        // Tree owned by the LRU cache — no manual delete needed
+    }
+    if (skippedByLang && skippedByLang.size > 0) {
+        for (const [lang, count] of skippedByLang.entries()) {
+            console.warn(`[ingestion] Skipped ${count} ${lang} file(s) in import processing — ${lang} parser not available.`);
+        }
+    }
+    // Create transitive IMPORTS edges for re-export chains (barrel files)
+    addTransitiveImportEdges(namedImportMap, importMap, addImportEdge);
+    if (isDev) {
+        console.log(`Import processing complete: ${totalImportsResolved}/${totalImportsFound} imports resolved to graph edges`);
+    }
+};
+// Fast path: resolve pre-extracted imports (no AST parsing needed)
+export const processImportsFromExtracted = async (graph, files, extractedImports, ctx, onProgress, repoRoot, prebuiltCtx) => {
+    const importMap = ctx.importMap;
+    const packageMap = ctx.packageMap;
+    const namedImportMap = ctx.namedImportMap;
+    const importCtx = prebuiltCtx ?? buildImportResolutionContext(files.map(f => f.path));
+    const { allFilePaths, allFileList, normalizedFileList, suffixIndex: index, resolveCache } = importCtx;
+    let totalImportsFound = 0;
+    let totalImportsResolved = 0;
+    const effectiveRoot = repoRoot || '';
+    const configs = {
+        tsconfigPaths: await loadTsconfigPaths(effectiveRoot),
+        goModule: await loadGoModulePath(effectiveRoot),
+        composerConfig: await loadComposerConfig(effectiveRoot),
+        swiftPackageConfig: await loadSwiftPackageConfig(effectiveRoot),
+        csharpConfigs: await loadCSharpProjectConfig(effectiveRoot),
+    };
+    const resolveCtx = { allFilePaths, allFileList, normalizedFileList, index, resolveCache };
+    // Add IMPORTS edge to graph only (no ImportMap update)
+    const addImportGraphEdge = (filePath, resolvedPath) => {
+        const sourceId = generateId('File', filePath);
+        const targetId = generateId('File', resolvedPath);
+        const relId = generateId('IMPORTS', `${filePath}->${resolvedPath}`);
+        totalImportsResolved++;
+        graph.addRelationship({
+            id: relId,
+            sourceId,
+            targetId,
+            type: 'IMPORTS',
+            confidence: 1.0,
+            reason: '',
+        });
+    };
+    // Add IMPORTS edge + update ImportMap
+    const addImportEdge = (filePath, resolvedPath) => {
+        addImportGraphEdge(filePath, resolvedPath);
+        if (!importMap.has(filePath)) {
+            importMap.set(filePath, new Set());
+        }
+        importMap.get(filePath).add(resolvedPath);
+    };
+    // Group by file for progress reporting
+    const importsByFile = new Map();
+    for (const imp of extractedImports) {
+        let list = importsByFile.get(imp.filePath);
+        if (!list) {
+            list = [];
+            importsByFile.set(imp.filePath, list);
+        }
+        list.push(imp);
+    }
+    const totalFiles = importsByFile.size;
+    let filesProcessed = 0;
+    for (const [filePath, fileImports] of importsByFile) {
+        filesProcessed++;
+        if (filesProcessed % 100 === 0) {
+            onProgress?.(filesProcessed, totalFiles);
+            await yieldToEventLoop();
+        }
+        for (const imp of fileImports) {
+            totalImportsFound++;
+            const result = resolveLanguageImport(filePath, imp.rawImportPath, imp.language, configs, resolveCtx);
+            applyImportResult(result, filePath, importMap, packageMap, addImportEdge, addImportGraphEdge, imp.namedBindings, namedImportMap);
+        }
+    }
+    onProgress?.(totalFiles, totalFiles);
+    // Create transitive IMPORTS edges for re-export chains (barrel files)
+    addTransitiveImportEdges(namedImportMap, importMap, addImportEdge);
+    if (isDev) {
+        console.log(`Import processing (fast path): ${totalImportsResolved}/${totalImportsFound} imports resolved to graph edges`);
+    }
+};

package/dist/core/ingestion/language-config.d.ts

@@ -0,0 +1,32 @@
+/** @file language-config.ts @description Loads language-specific project configuration (tsconfig.json, go.mod, composer.json, .csproj, Package.swift) for import path resolution */
+export interface TsconfigPaths {
+    aliases: Map<string, string>;
+    baseUrl: string;
+}
+export interface GoModuleConfig {
+    modulePath: string;
+}
+export interface ComposerConfig {
+    psr4: Map<string, string>;
+}
+export interface CSharpProjectConfig {
+    rootNamespace: string;
+    projectDir: string;
+}
+export interface SwiftPackageConfig {
+    targets: Map<string, string>;
+}
+/**
+ * Parse tsconfig.json to extract path aliases
+ *
+ * Tries tsconfig.json, tsconfig.app.json, tsconfig.base.json in order
+ */
+export declare function loadTsconfigPaths(repoRoot: string): Promise<TsconfigPaths | null>;
+/** Parse go.mod to extract module path */
+export declare function loadGoModulePath(repoRoot: string): Promise<GoModuleConfig | null>;
+/** Parse composer.json to extract PSR-4 autoload mappings (including autoload-dev) */
+export declare function loadComposerConfig(repoRoot: string): Promise<ComposerConfig | null>;
+/** Parse .csproj files to extract RootNamespace via BFS scan up to 5 levels deep */
+export declare function loadCSharpProjectConfig(repoRoot: string): Promise<CSharpProjectConfig[]>;
+/** Load Swift Package Manager target map from Sources/ directories */
+export declare function loadSwiftPackageConfig(repoRoot: string): Promise<SwiftPackageConfig | null>;

package/dist/core/ingestion/language-config.js

@@ -0,0 +1,161 @@
+// code-mapper/src/core/ingestion/language-config.ts
+/** @file language-config.ts @description Loads language-specific project configuration (tsconfig.json, go.mod, composer.json, .csproj, Package.swift) for import path resolution */
+import fs from 'fs/promises';
+import path from 'path';
+const isDev = process.env.NODE_ENV === 'development';
+/**
+ * Parse tsconfig.json to extract path aliases
+ *
+ * Tries tsconfig.json, tsconfig.app.json, tsconfig.base.json in order
+ */
+export async function loadTsconfigPaths(repoRoot) {
+    const candidates = ['tsconfig.json', 'tsconfig.app.json', 'tsconfig.base.json'];
+    for (const filename of candidates) {
+        try {
+            const tsconfigPath = path.join(repoRoot, filename);
+            const raw = await fs.readFile(tsconfigPath, 'utf-8');
+            // Strip JSON comments (// and /* */ style)
+            const stripped = raw.replace(/\/\/.*$/gm, '').replace(/\/\*[\s\S]*?\*\//g, '');
+            const tsconfig = JSON.parse(stripped);
+            const compilerOptions = tsconfig.compilerOptions;
+            if (!compilerOptions?.paths)
+                continue;
+            const baseUrl = compilerOptions.baseUrl || '.';
+            const aliases = new Map();
+            for (const [pattern, targets] of Object.entries(compilerOptions.paths)) {
+                if (!Array.isArray(targets) || targets.length === 0)
+                    continue;
+                const target = targets[0];
+                // Convert glob patterns: "@/*" -> "@/", "src/*" -> "src/"
+                const aliasPrefix = pattern.endsWith('/*') ? pattern.slice(0, -1) : pattern;
+                const targetPrefix = target.endsWith('/*') ? target.slice(0, -1) : target;
+                aliases.set(aliasPrefix, targetPrefix);
+            }
+            if (aliases.size > 0) {
+                if (isDev) {
+                    console.log(`📦 Loaded ${aliases.size} path aliases from ${filename}`);
+                }
+                return { aliases, baseUrl };
+            }
+        }
+        catch {
+            // File doesn't exist or isn't valid JSON — try next
+        }
+    }
+    return null;
+}
+/** Parse go.mod to extract module path */
+export async function loadGoModulePath(repoRoot) {
+    try {
+        const goModPath = path.join(repoRoot, 'go.mod');
+        const content = await fs.readFile(goModPath, 'utf-8');
+        const match = content.match(/^module\s+(\S+)/m);
+        if (match) {
+            if (isDev) {
+                console.log(`📦 Loaded Go module path: ${match[1]}`);
+            }
+            return { modulePath: match[1] };
+        }
+    }
+    catch {
+        // No go.mod
+    }
+    return null;
+}
+/** Parse composer.json to extract PSR-4 autoload mappings (including autoload-dev) */
+export async function loadComposerConfig(repoRoot) {
+    try {
+        const composerPath = path.join(repoRoot, 'composer.json');
+        const raw = await fs.readFile(composerPath, 'utf-8');
+        const composer = JSON.parse(raw);
+        const psr4Raw = composer.autoload?.['psr-4'] ?? {};
+        const psr4Dev = composer['autoload-dev']?.['psr-4'] ?? {};
+        const merged = { ...psr4Raw, ...psr4Dev };
+        const psr4 = new Map();
+        for (const [ns, dir] of Object.entries(merged)) {
+            const nsNorm = ns.replace(/\\+$/, '');
+            const dirNorm = dir.replace(/\\/g, '/').replace(/\/+$/, '');
+            psr4.set(nsNorm, dirNorm);
+        }
+        if (isDev) {
+            console.log(`📦 Loaded ${psr4.size} PSR-4 mappings from composer.json`);
+        }
+        return { psr4 };
+    }
+    catch {
+        return null;
+    }
+}
+/** Parse .csproj files to extract RootNamespace via BFS scan up to 5 levels deep */
+export async function loadCSharpProjectConfig(repoRoot) {
+    const configs = [];
+    // BFS scan for .csproj files, capped at 100 dirs
+    const scanQueue = [{ dir: repoRoot, depth: 0 }];
+    const maxDepth = 5;
+    const maxDirs = 100;
+    let dirsScanned = 0;
+    while (scanQueue.length > 0 && dirsScanned < maxDirs) {
+        const { dir, depth } = scanQueue.shift();
+        dirsScanned++;
+        try {
+            const entries = await fs.readdir(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.isDirectory() && depth < maxDepth) {
+                    // Skip common non-project directories
+                    if (entry.name === 'node_modules' || entry.name === '.git' || entry.name === 'bin' || entry.name === 'obj')
+                        continue;
+                    scanQueue.push({ dir: path.join(dir, entry.name), depth: depth + 1 });
+                }
+                if (entry.isFile() && entry.name.endsWith('.csproj')) {
+                    try {
+                        const csprojPath = path.join(dir, entry.name);
+                        const content = await fs.readFile(csprojPath, 'utf-8');
+                        const nsMatch = content.match(/<RootNamespace>\s*([^<]+)\s*<\/RootNamespace>/);
+                        const rootNamespace = nsMatch
+                            ? nsMatch[1].trim()
+                            : entry.name.replace(/\.csproj$/, '');
+                        const projectDir = path.relative(repoRoot, dir).replace(/\\/g, '/');
+                        configs.push({ rootNamespace, projectDir });
+                        if (isDev) {
+                            console.log(`📦 Loaded C# project: ${entry.name} (namespace: ${rootNamespace}, dir: ${projectDir})`);
+                        }
+                    }
+                    catch {
+                        // Can't read .csproj
+                    }
+                }
+            }
+        }
+        catch {
+            // Can't read directory
+        }
+    }
+    return configs;
+}
+/** Load Swift Package Manager target map from Sources/ directories */
+export async function loadSwiftPackageConfig(repoRoot) {
+    // SPM convention: Sources/<TargetName>/ or Package/Sources/<TargetName>/
+    const targets = new Map();
+    const sourceDirs = ['Sources', 'Package/Sources', 'src'];
+    for (const sourceDir of sourceDirs) {
+        try {
+            const fullPath = path.join(repoRoot, sourceDir);
+            const entries = await fs.readdir(fullPath, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.isDirectory()) {
+                    targets.set(entry.name, sourceDir + '/' + entry.name);
+                }
+            }
+        }
+        catch {
+            // Directory doesn't exist
+        }
+    }
+    if (targets.size > 0) {
+        if (isDev) {
+            console.log(`📦 Loaded ${targets.size} Swift package targets`);
+        }
+        return { targets };
+    }
+    return null;
+}

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

@@ -0,0 +1,32 @@
+/**
+ * @file mro-processor.ts
+ * @description Walks the inheritance DAG, collects methods from ancestors via HAS_METHOD
+ * edges, detects method-name collisions, and emits OVERRIDES edges using language-specific
+ * resolution rules (C++ leftmost base, C#/Java class-over-interface, Python C3 linearization,
+ * Rust requires qualified syntax). OVERRIDES edge direction: Class -> winning ancestor Method
+ */
+import { KnowledgeGraph } from '../graph/types.js';
+import { SupportedLanguages } from '../../config/supported-languages.js';
+export interface MROEntry {
+    classId: string;
+    className: string;
+    language: SupportedLanguages;
+    mro: string[];
+    ambiguities: MethodAmbiguity[];
+}
+export interface MethodAmbiguity {
+    methodName: string;
+    definedIn: Array<{
+        classId: string;
+        className: string;
+        methodId: string;
+    }>;
+    resolvedTo: string | null;
+    reason: string;
+}
+export interface MROResult {
+    entries: MROEntry[];
+    overrideEdges: number;
+    ambiguityCount: number;
+}
+export declare function computeMRO(graph: KnowledgeGraph): MROResult;