gitnexus 1.4.0 → 1.4.1

package/dist/core/ingestion/entry-point-scoring.js

@@ -10,7 +10,6 @@
  * This module is language-agnostic - language-specific patterns are defined per language.
  */
 import { detectFrameworkFromPath } from './framework-detection.js';
-import { SupportedLanguages } from '../../config/supported-languages.js';
 // ============================================================================
 // NAME PATTERNS - All 9 supported languages
 // ============================================================================
@@ -35,112 +34,65 @@ const ENTRY_POINT_PATTERNS = {
         /^emit[A-Z]/, // emitEvent
     ],
     // JavaScript/TypeScript
-    [SupportedLanguages.JavaScript]: [
+    'javascript': [
         /^use[A-Z]/, // React hooks (useEffect, etc.)
     ],
-    [SupportedLanguages.TypeScript]: [
+    'typescript': [
         /^use[A-Z]/, // React hooks
     ],
     // Python
-    [SupportedLanguages.Python]: [
+    'python': [
         /^app$/, // Flask/FastAPI app
         /^(get|post|put|delete|patch)_/i, // REST conventions
         /^api_/, // API functions
         /^view_/, // Django views
     ],
     // Java
-    [SupportedLanguages.Java]: [
+    'java': [
         /^do[A-Z]/, // doGet, doPost (Servlets)
         /^create[A-Z]/, // Factory patterns
         /^build[A-Z]/, // Builder patterns
         /Service$/, // UserService
     ],
     // C#
-    [SupportedLanguages.CSharp]: [
-        /^(Get|Post|Put|Delete|Patch)/, // ASP.NET action methods
+    'csharp': [
+        /^(Get|Post|Put|Delete)/, // ASP.NET conventions
         /Action$/, // MVC actions
-        /^On[A-Z]/, // Event handlers / Blazor lifecycle
+        /^On[A-Z]/, // Event handlers
         /Async$/, // Async entry points
-        /^Configure$/, // Startup.Configure
-        /^ConfigureServices$/, // Startup.ConfigureServices
-        /^Handle$/, // MediatR / generic handler
-        /^Execute$/, // Command pattern
-        /^Invoke$/, // Middleware Invoke
-        /^Map[A-Z]/, // Minimal API MapGet, MapPost
-        /Service$/, // Service classes
-        /^Seed/, // Database seeding
     ],
     // Go
-    [SupportedLanguages.Go]: [
+    'go': [
         /Handler$/, // http.Handler pattern
         /^Serve/, // ServeHTTP
         /^New[A-Z]/, // Constructor pattern (returns new instance)
         /^Make[A-Z]/, // Make functions
     ],
     // Rust
-    [SupportedLanguages.Rust]: [
+    'rust': [
         /^(get|post|put|delete)_handler$/i,
         /^handle_/, // handle_request
         /^new$/, // Constructor pattern
         /^run$/, // run entry point
         /^spawn/, // Async spawn
     ],
-    // C - explicit main() boost plus common C entry point conventions
-    [SupportedLanguages.C]: [
+    // C - explicit main() boost (critical for C programs)
+    'c': [
         /^main$/, // THE entry point
-        /^init_/, // init_server, init_client
-        /_init$/, // module_init, server_init
-        /^start_/, // start_server
-        /_start$/, // thread_start
-        /^run_/, // run_loop
-        /_run$/, // event_run
-        /^stop_/, // stop_server
-        /_stop$/, // service_stop
-        /^open_/, // open_connection
-        /_open$/, // file_open
-        /^close_/, // close_connection
-        /_close$/, // socket_close
-        /^create_/, // create_session
-        /_create$/, // object_create
-        /^destroy_/, // destroy_session
-        /_destroy$/, // object_destroy
-        /^handle_/, // handle_request
-        /_handler$/, // signal_handler
-        /_callback$/, // event_callback
-        /^cmd_/, // tmux: cmd_new_window, cmd_attach_session
-        /^server_/, // server_start, server_loop
-        /^client_/, // client_connect
-        /^session_/, // session_create
-        /^window_/, // window_resize (tmux)
-        /^key_/, // key_press
-        /^input_/, // input_parse
-        /^output_/, // output_write
-        /^notify_/, // notify_client
-        /^control_/, // control_start
+        /^init_/, // Initialization functions
+        /^start_/, // Start functions
+        /^run_/, // Run functions
     ],
-    // C++ - same as C plus OOP/template patterns
-    [SupportedLanguages.CPlusPlus]: [
+    // C++ - same as C plus class patterns
+    'cpp': [
         /^main$/, // THE entry point
         /^init_/,
-        /_init$/,
         /^Create[A-Z]/, // Factory patterns
-        /^create_/,
         /^Run$/, // Run methods
-        /^run$/,
         /^Start$/, // Start methods
-        /^start$/,
-        /^handle_/,
-        /_handler$/,
-        /_callback$/,
-        /^OnEvent/, // Event callbacks
-        /^on_/,
-        /::Run$/, // Class::Run
-        /::Start$/, // Class::Start
-        /::Init$/, // Class::Init
-        /::Execute$/, // Class::Execute
     ],
     // Swift / iOS
-    [SupportedLanguages.Swift]: [
+    'swift': [
         /^viewDidLoad$/, // UIKit lifecycle
         /^viewWillAppear$/, // UIKit lifecycle
         /^viewDidAppear$/, // UIKit lifecycle
@@ -159,7 +111,7 @@ const ENTRY_POINT_PATTERNS = {
         /^makeBody$/, // SwiftUI ViewModifier
     ],
     // PHP / Laravel
-    [SupportedLanguages.PHP]: [
+    'php': [
         /Controller$/, // UserController (class name convention)
         /^handle$/, // Job::handle(), Listener::handle()
         /^execute$/, // Command::execute()
@@ -179,14 +131,6 @@ const ENTRY_POINT_PATTERNS = {
         /^delete$/, // Repository::delete()
     ],
 };
-/** Pre-computed merged patterns (universal + language-specific) to avoid per-call array allocation. */
-const MERGED_ENTRY_POINT_PATTERNS = {};
-const UNIVERSAL_PATTERNS = ENTRY_POINT_PATTERNS['*'] || [];
-for (const [lang, patterns] of Object.entries(ENTRY_POINT_PATTERNS)) {
-    if (lang === '*')
-        continue;
-    MERGED_ENTRY_POINT_PATTERNS[lang] = [...UNIVERSAL_PATTERNS, ...patterns];
-}
 // ============================================================================
 // UTILITY PATTERNS - Functions that should be penalized
 // ============================================================================
@@ -252,7 +196,9 @@ export function calculateEntryPointScore(name, language, isExported, callerCount
     }
     else {
         // Check positive patterns
-        const allPatterns = MERGED_ENTRY_POINT_PATTERNS[language] || UNIVERSAL_PATTERNS;
+        const universalPatterns = ENTRY_POINT_PATTERNS['*'] || [];
+        const langPatterns = ENTRY_POINT_PATTERNS[language] || [];
+        const allPatterns = [...universalPatterns, ...langPatterns];
         if (allPatterns.some(p => p.test(name))) {
             nameMultiplier = 1.5; // Bonus for matching entry point pattern
             reasons.push('entry-pattern');
@@ -307,13 +253,8 @@ export function isTestFile(filePath) {
         p.endsWith('test.swift') ||
         p.includes('uitests/') ||
         // C# test patterns
-        p.endsWith('tests.cs') ||
-        p.endsWith('test.cs') ||
         p.includes('.tests/') ||
-        p.includes('.test/') ||
-        p.includes('.integrationtests/') ||
-        p.includes('.unittests/') ||
-        p.includes('/testproject/') ||
+        p.includes('tests.cs') ||
         // PHP/Laravel test patterns
         p.endsWith('test.php') ||
         p.endsWith('spec.php') ||

package/dist/core/ingestion/framework-detection.d.ts

@@ -33,9 +33,6 @@ export declare const FRAMEWORK_AST_PATTERNS: {
     spring: string[];
     jaxrs: string[];
     aspnet: string[];
-    signalr: string[];
-    blazor: string[];
-    efcore: string[];
     'go-http': string[];
     laravel: string[];
     actix: string[];
@@ -45,10 +42,9 @@ export declare const FRAMEWORK_AST_PATTERNS: {
     swiftui: string[];
     combine: string[];
 };
-import { SupportedLanguages } from '../../config/supported-languages.js';
 /**
  * Detect framework entry points from AST definition text (decorators/annotations/attributes).
  * Returns null if no known pattern is found.
  * Note: callers should slice definitionText to ~300 chars since annotations appear at the start.
  */
-export declare function detectFrameworkFromAST(language: SupportedLanguages, definitionText: string): FrameworkHint | null;
+export declare function detectFrameworkFromAST(language: string, definitionText: string): FrameworkHint | null;

package/dist/core/ingestion/framework-detection.js

@@ -140,29 +140,6 @@ export function detectFrameworkFromPath(filePath) {
     if (p.endsWith('controller.cs')) {
         return { framework: 'aspnet', entryPointMultiplier: 3.0, reason: 'aspnet-controller-file' };
     }
-    // ASP.NET Services
-    if ((p.includes('/services/') || p.includes('/service/')) && p.endsWith('.cs')) {
-        return { framework: 'aspnet', entryPointMultiplier: 1.8, reason: 'aspnet-service' };
-    }
-    // ASP.NET Middleware
-    if (p.includes('/middleware/') && p.endsWith('.cs')) {
-        return { framework: 'aspnet', entryPointMultiplier: 2.5, reason: 'aspnet-middleware' };
-    }
-    // SignalR Hubs
-    if (p.includes('/hubs/') && p.endsWith('.cs')) {
-        return { framework: 'signalr', entryPointMultiplier: 2.5, reason: 'signalr-hub' };
-    }
-    if (p.endsWith('hub.cs')) {
-        return { framework: 'signalr', entryPointMultiplier: 2.5, reason: 'signalr-hub-file' };
-    }
-    // Minimal API / Program.cs / Startup.cs
-    if (p.endsWith('/program.cs') || p.endsWith('/startup.cs')) {
-        return { framework: 'aspnet', entryPointMultiplier: 3.0, reason: 'aspnet-entry' };
-    }
-    // Background services / Hosted services
-    if ((p.includes('/backgroundservices/') || p.includes('/hostedservices/')) && p.endsWith('.cs')) {
-        return { framework: 'aspnet', entryPointMultiplier: 2.0, reason: 'aspnet-background-service' };
-    }
     // Blazor pages
     if (p.includes('/pages/') && p.endsWith('.razor')) {
         return { framework: 'blazor', entryPointMultiplier: 2.5, reason: 'blazor-page' };
@@ -319,11 +296,7 @@ export const FRAMEWORK_AST_PATTERNS = {
     'spring': ['@RestController', '@Controller', '@GetMapping', '@PostMapping', '@RequestMapping'],
     'jaxrs': ['@Path', '@GET', '@POST', '@PUT', '@DELETE'],
     // C# attributes
-    'aspnet': ['[ApiController]', '[HttpGet]', '[HttpPost]', '[HttpPut]', '[HttpDelete]',
-        '[Route]', '[Authorize]', '[AllowAnonymous]'],
-    'signalr': ['[HubMethodName]', ': Hub', ': Hub<'],
-    'blazor': ['@page', '[Parameter]', '@inject'],
-    'efcore': ['DbContext', 'DbSet<', 'OnModelCreating'],
+    'aspnet': ['[ApiController]', '[HttpGet]', '[HttpPost]', '[Route]'],
     // Go patterns (function signatures)
     'go-http': ['http.Handler', 'http.HandlerFunc', 'ServeHTTP'],
     // PHP/Laravel
@@ -338,35 +311,31 @@ export const FRAMEWORK_AST_PATTERNS = {
     'swiftui': ['@main', 'WindowGroup', 'ContentView', '@StateObject', '@ObservedObject'],
     'combine': ['sink', 'assign', 'Publisher', 'Subscriber'],
 };
-import { SupportedLanguages } from '../../config/supported-languages.js';
 const AST_FRAMEWORK_PATTERNS_BY_LANGUAGE = {
-    [SupportedLanguages.JavaScript]: [
+    javascript: [
         { framework: 'nestjs', entryPointMultiplier: 3.2, reason: 'nestjs-decorator', patterns: FRAMEWORK_AST_PATTERNS.nestjs },
     ],
-    [SupportedLanguages.TypeScript]: [
+    typescript: [
         { framework: 'nestjs', entryPointMultiplier: 3.2, reason: 'nestjs-decorator', patterns: FRAMEWORK_AST_PATTERNS.nestjs },
     ],
-    [SupportedLanguages.Python]: [
+    python: [
         { framework: 'fastapi', entryPointMultiplier: 3.0, reason: 'fastapi-decorator', patterns: FRAMEWORK_AST_PATTERNS.fastapi },
         { framework: 'flask', entryPointMultiplier: 2.8, reason: 'flask-decorator', patterns: FRAMEWORK_AST_PATTERNS.flask },
     ],
-    [SupportedLanguages.Java]: [
+    java: [
         { framework: 'spring', entryPointMultiplier: 3.2, reason: 'spring-annotation', patterns: FRAMEWORK_AST_PATTERNS.spring },
         { framework: 'jaxrs', entryPointMultiplier: 3.0, reason: 'jaxrs-annotation', patterns: FRAMEWORK_AST_PATTERNS.jaxrs },
     ],
-    [SupportedLanguages.Kotlin]: [
+    kotlin: [
         { framework: 'spring-kotlin', entryPointMultiplier: 3.2, reason: 'spring-kotlin-annotation', patterns: FRAMEWORK_AST_PATTERNS.spring },
         { framework: 'jaxrs', entryPointMultiplier: 3.0, reason: 'jaxrs-annotation', patterns: FRAMEWORK_AST_PATTERNS.jaxrs },
         { framework: 'ktor', entryPointMultiplier: 2.8, reason: 'ktor-routing', patterns: ['routing', 'embeddedServer', 'Application.module'] },
         { framework: 'android-kotlin', entryPointMultiplier: 2.5, reason: 'android-annotation', patterns: ['@AndroidEntryPoint', 'AppCompatActivity', 'Fragment('] },
     ],
-    [SupportedLanguages.CSharp]: [
+    csharp: [
         { framework: 'aspnet', entryPointMultiplier: 3.2, reason: 'aspnet-attribute', patterns: FRAMEWORK_AST_PATTERNS.aspnet },
-        { framework: 'signalr', entryPointMultiplier: 2.8, reason: 'signalr-attribute', patterns: FRAMEWORK_AST_PATTERNS.signalr },
-        { framework: 'blazor', entryPointMultiplier: 2.5, reason: 'blazor-attribute', patterns: FRAMEWORK_AST_PATTERNS.blazor },
-        { framework: 'efcore', entryPointMultiplier: 2.0, reason: 'efcore-pattern', patterns: FRAMEWORK_AST_PATTERNS.efcore },
     ],
-    [SupportedLanguages.PHP]: [
+    php: [
         { framework: 'laravel', entryPointMultiplier: 3.0, reason: 'php-route-attribute', patterns: FRAMEWORK_AST_PATTERNS.laravel },
     ],
 };

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

@@ -2,28 +2,19 @@
  * Heritage Processor
  *
  * Extracts class inheritance relationships:
- * - EXTENDS: Class extends another Class (TS, JS, Python, C#, C++)
- * - IMPLEMENTS: Class implements an Interface (TS, C#, Java, Kotlin, PHP)
- *
- * Languages like C# use a single `base_list` for both class and interface parents.
- * We resolve the correct edge type by checking the symbol table: if the parent is
- * registered as an Interface, we emit IMPLEMENTS; otherwise EXTENDS. For unresolved
- * external symbols, the fallback heuristic is language-gated:
- *   - C# / Java: apply the `I[A-Z]` naming convention (e.g. IDisposable → IMPLEMENTS)
- *   - Swift: default to IMPLEMENTS (protocol conformance is more common than class inheritance)
- *   - All other languages: default to EXTENDS
+ * - EXTENDS: Class extends another Class (TS, JS, Python)
+ * - IMPLEMENTS: Class implements an Interface (TS only)
  */
 import { KnowledgeGraph } from '../graph/types.js';
 import { ASTCache } from './ast-cache.js';
 import { SymbolTable } from './symbol-table.js';
 import type { ExtractedHeritage } from './workers/parse-worker.js';
-import type { ImportMap, PackageMap } from './import-processor.js';
 export declare const processHeritage: (graph: KnowledgeGraph, files: {
     path: string;
     content: string;
-}[], astCache: ASTCache, symbolTable: SymbolTable, importMap: ImportMap, packageMap?: PackageMap, onProgress?: (current: number, total: number) => void) => Promise<void>;
+}[], astCache: ASTCache, symbolTable: SymbolTable, onProgress?: (current: number, total: number) => void) => Promise<void>;
 /**
  * Fast path: resolve pre-extracted heritage from workers.
  * No AST parsing — workers already extracted className + parentName + kind.
  */
-export declare const processHeritageFromExtracted: (graph: KnowledgeGraph, extractedHeritage: ExtractedHeritage[], symbolTable: SymbolTable, importMap: ImportMap, packageMap?: PackageMap, onProgress?: (current: number, total: number) => void) => Promise<void>;
+export declare const processHeritageFromExtracted: (graph: KnowledgeGraph, extractedHeritage: ExtractedHeritage[], symbolTable: SymbolTable, onProgress?: (current: number, total: number) => void) => Promise<void>;

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

@@ -2,59 +2,16 @@
  * Heritage Processor
  *
  * Extracts class inheritance relationships:
- * - EXTENDS: Class extends another Class (TS, JS, Python, C#, C++)
- * - IMPLEMENTS: Class implements an Interface (TS, C#, Java, Kotlin, PHP)
- *
- * Languages like C# use a single `base_list` for both class and interface parents.
- * We resolve the correct edge type by checking the symbol table: if the parent is
- * registered as an Interface, we emit IMPLEMENTS; otherwise EXTENDS. For unresolved
- * external symbols, the fallback heuristic is language-gated:
- *   - C# / Java: apply the `I[A-Z]` naming convention (e.g. IDisposable → IMPLEMENTS)
- *   - Swift: default to IMPLEMENTS (protocol conformance is more common than class inheritance)
- *   - All other languages: default to EXTENDS
+ * - EXTENDS: Class extends another Class (TS, JS, Python)
+ * - IMPLEMENTS: Class implements an Interface (TS only)
  */
 import Parser from 'tree-sitter';
-import { isLanguageAvailable, loadParser, loadLanguage } from '../tree-sitter/parser-loader.js';
+import { 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 { getTreeSitterBufferSize } from './constants.js';
-import { resolveSymbol } from './symbol-resolver.js';
-/** C#/Java convention: interfaces start with I followed by an uppercase letter */
-const INTERFACE_NAME_RE = /^I[A-Z]/;
-/**
- * Determine whether a heritage.extends capture is actually an IMPLEMENTS relationship.
- * Uses the symbol table first (authoritative — Tier 1); falls back to a language-gated
- * heuristic for external symbols not present in the graph:
- *   - C# / Java: `I[A-Z]` naming convention
- *   - Swift: default IMPLEMENTS (protocol conformance is the norm)
- *   - All others: default EXTENDS
- */
-const resolveExtendsType = (parentName, currentFilePath, symbolTable, importMap, language, packageMap) => {
-    const resolved = resolveSymbol(parentName, currentFilePath, symbolTable, importMap, packageMap);
-    if (resolved) {
-        const isInterface = resolved.type === 'Interface';
-        return isInterface
-            ? { type: 'IMPLEMENTS', idPrefix: 'Interface' }
-            : { type: 'EXTENDS', idPrefix: 'Class' };
-    }
-    // Unresolved symbol — fall back to language-specific heuristic
-    if (language === SupportedLanguages.CSharp || language === SupportedLanguages.Java) {
-        if (INTERFACE_NAME_RE.test(parentName)) {
-            return { type: 'IMPLEMENTS', idPrefix: 'Interface' };
-        }
-    }
-    else if (language === SupportedLanguages.Swift) {
-        // Protocol conformance is far more common than class inheritance in Swift
-        return { type: 'IMPLEMENTS', idPrefix: 'Interface' };
-    }
-    return { type: 'EXTENDS', idPrefix: 'Class' };
-};
-export const processHeritage = async (graph, files, astCache, symbolTable, importMap, packageMap, onProgress) => {
+import { getLanguageFromFilename, yieldToEventLoop } from './utils.js';
+export const processHeritage = async (graph, files, astCache, symbolTable, onProgress) => {
     const parser = await loadParser();
-    const logSkipped = isVerboseIngestionEnabled();
-    const skippedByLang = logSkipped ? new Map() : null;
     for (let i = 0; i < files.length; i++) {
         const file = files[i];
         onProgress?.(i + 1, files.length);
@@ -64,12 +21,6 @@ export const processHeritage = async (graph, files, astCache, symbolTable, impor
         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;
@@ -81,7 +32,7 @@ export const processHeritage = async (graph, files, astCache, symbolTable, impor
         if (!tree) {
             // Use larger bufferSize for files > 32KB
             try {
-                tree = parser.parse(file.content, undefined, { bufferSize: getTreeSitterBufferSize(file.content.length) });
+                tree = parser.parse(file.content, undefined, { bufferSize: 1024 * 256 });
             }
             catch (parseError) {
                 // Skip files that can't be parsed
@@ -108,29 +59,23 @@ export const processHeritage = async (graph, files, astCache, symbolTable, impor
             match.captures.forEach(c => {
                 captureMap[c.name] = c.node;
             });
-            // EXTENDS or IMPLEMENTS: resolve via symbol table for languages where
-            // the tree-sitter query can't distinguish classes from interfaces (C#, Java)
+            // EXTENDS: Class extends another Class
             if (captureMap['heritage.class'] && captureMap['heritage.extends']) {
-                // Go struct embedding: skip named fields (only anonymous fields are embedded)
-                const extendsNode = captureMap['heritage.extends'];
-                const fieldDecl = extendsNode.parent;
-                if (fieldDecl?.type === 'field_declaration' && fieldDecl.childForFieldName('name')) {
-                    return; // Named field, not struct embedding
-                }
                 const className = captureMap['heritage.class'].text;
                 const parentClassName = captureMap['heritage.extends'].text;
-                const { type: relType, idPrefix } = resolveExtendsType(parentClassName, file.path, symbolTable, importMap, language, packageMap);
+                // Resolve both class IDs
                 const childId = symbolTable.lookupExact(file.path, className) ||
-                    resolveSymbol(className, file.path, symbolTable, importMap, packageMap)?.nodeId ||
+                    symbolTable.lookupFuzzy(className)[0]?.nodeId ||
                     generateId('Class', `${file.path}:${className}`);
-                const parentId = resolveSymbol(parentClassName, file.path, symbolTable, importMap, packageMap)?.nodeId ||
-                    generateId(idPrefix, `${parentClassName}`);
+                const parentId = symbolTable.lookupFuzzy(parentClassName)[0]?.nodeId ||
+                    generateId('Class', `${parentClassName}`);
                 if (childId && parentId && childId !== parentId) {
+                    const relId = generateId('EXTENDS', `${childId}->${parentId}`);
                     graph.addRelationship({
-                        id: generateId(relType, `${childId}->${parentId}`),
+                        id: relId,
                         sourceId: childId,
                         targetId: parentId,
-                        type: relType,
+                        type: 'EXTENDS',
                         confidence: 1.0,
                         reason: '',
                     });
@@ -142,9 +87,9 @@ export const processHeritage = async (graph, files, astCache, symbolTable, impor
                 const interfaceName = captureMap['heritage.implements'].text;
                 // Resolve class and interface IDs
                 const classId = symbolTable.lookupExact(file.path, className) ||
-                    resolveSymbol(className, file.path, symbolTable, importMap, packageMap)?.nodeId ||
+                    symbolTable.lookupFuzzy(className)[0]?.nodeId ||
                     generateId('Class', `${file.path}:${className}`);
-                const interfaceId = resolveSymbol(interfaceName, file.path, symbolTable, importMap, packageMap)?.nodeId ||
+                const interfaceId = symbolTable.lookupFuzzy(interfaceName)[0]?.nodeId ||
                     generateId('Interface', `${interfaceName}`);
                 if (classId && interfaceId) {
                     const relId = generateId('IMPLEMENTS', `${classId}->${interfaceId}`);
@@ -164,9 +109,9 @@ export const processHeritage = async (graph, files, astCache, symbolTable, impor
                 const traitName = captureMap['heritage.trait'].text;
                 // Resolve struct and trait IDs
                 const structId = symbolTable.lookupExact(file.path, structName) ||
-                    resolveSymbol(structName, file.path, symbolTable, importMap, packageMap)?.nodeId ||
+                    symbolTable.lookupFuzzy(structName)[0]?.nodeId ||
                     generateId('Struct', `${file.path}:${structName}`);
-                const traitId = resolveSymbol(traitName, file.path, symbolTable, importMap, packageMap)?.nodeId ||
+                const traitId = symbolTable.lookupFuzzy(traitName)[0]?.nodeId ||
                     generateId('Trait', `${traitName}`);
                 if (structId && traitId) {
                     const relId = generateId('IMPLEMENTS', `${structId}->${traitId}`);
@@ -183,17 +128,12 @@ export const processHeritage = async (graph, files, astCache, symbolTable, impor
         });
         // Tree is now 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 heritage processing — ${lang} parser not available.`);
-        }
-    }
 };
 /**
  * Fast path: resolve pre-extracted heritage from workers.
  * No AST parsing — workers already extracted className + parentName + kind.
  */
-export const processHeritageFromExtracted = async (graph, extractedHeritage, symbolTable, importMap, packageMap, onProgress) => {
+export const processHeritageFromExtracted = async (graph, extractedHeritage, symbolTable, onProgress) => {
     const total = extractedHeritage.length;
     for (let i = 0; i < extractedHeritage.length; i++) {
         if (i % 500 === 0) {
@@ -202,21 +142,17 @@ export const processHeritageFromExtracted = async (graph, extractedHeritage, sym
         }
         const h = extractedHeritage[i];
         if (h.kind === 'extends') {
-            const fileLanguage = getLanguageFromFilename(h.filePath);
-            if (!fileLanguage)
-                continue;
-            const { type: relType, idPrefix } = resolveExtendsType(h.parentName, h.filePath, symbolTable, importMap, fileLanguage, packageMap);
             const childId = symbolTable.lookupExact(h.filePath, h.className) ||
-                resolveSymbol(h.className, h.filePath, symbolTable, importMap, packageMap)?.nodeId ||
+                symbolTable.lookupFuzzy(h.className)[0]?.nodeId ||
                 generateId('Class', `${h.filePath}:${h.className}`);
-            const parentId = resolveSymbol(h.parentName, h.filePath, symbolTable, importMap, packageMap)?.nodeId ||
-                generateId(idPrefix, `${h.parentName}`);
+            const parentId = symbolTable.lookupFuzzy(h.parentName)[0]?.nodeId ||
+                generateId('Class', `${h.parentName}`);
             if (childId && parentId && childId !== parentId) {
                 graph.addRelationship({
-                    id: generateId(relType, `${childId}->${parentId}`),
+                    id: generateId('EXTENDS', `${childId}->${parentId}`),
                     sourceId: childId,
                     targetId: parentId,
-                    type: relType,
+                    type: 'EXTENDS',
                     confidence: 1.0,
                     reason: '',
                 });
@@ -224,9 +160,9 @@ export const processHeritageFromExtracted = async (graph, extractedHeritage, sym
         }
         else if (h.kind === 'implements') {
             const classId = symbolTable.lookupExact(h.filePath, h.className) ||
-                resolveSymbol(h.className, h.filePath, symbolTable, importMap, packageMap)?.nodeId ||
+                symbolTable.lookupFuzzy(h.className)[0]?.nodeId ||
                 generateId('Class', `${h.filePath}:${h.className}`);
-            const interfaceId = resolveSymbol(h.parentName, h.filePath, symbolTable, importMap, packageMap)?.nodeId ||
+            const interfaceId = symbolTable.lookupFuzzy(h.parentName)[0]?.nodeId ||
                 generateId('Interface', `${h.parentName}`);
             if (classId && interfaceId) {
                 graph.addRelationship({
@@ -241,9 +177,9 @@ export const processHeritageFromExtracted = async (graph, extractedHeritage, sym
         }
         else if (h.kind === 'trait-impl') {
             const structId = symbolTable.lookupExact(h.filePath, h.className) ||
-                resolveSymbol(h.className, h.filePath, symbolTable, importMap, packageMap)?.nodeId ||
+                symbolTable.lookupFuzzy(h.className)[0]?.nodeId ||
                 generateId('Struct', `${h.filePath}:${h.className}`);
-            const traitId = resolveSymbol(h.parentName, h.filePath, symbolTable, importMap, packageMap)?.nodeId ||
+            const traitId = symbolTable.lookupFuzzy(h.parentName)[0]?.nodeId ||
                 generateId('Trait', `${h.parentName}`);
             if (structId && traitId) {
                 graph.addRelationship({

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

@@ -1,23 +1,8 @@
 import { KnowledgeGraph } from '../graph/types.js';
 import { ASTCache } from './ast-cache.js';
 import type { ExtractedImport } from './workers/parse-worker.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 declare const createImportMap: () => ImportMap;
-export type PackageMap = Map<string, Set<string>>;
-export declare const createPackageMap: () => PackageMap;
-export interface NamedImportBinding {
-    sourcePath: string;
-    exportedName: string;
-}
-export type NamedImportMap = Map<string, Map<string, NamedImportBinding>>;
-export declare const createNamedImportMap: () => NamedImportMap;
-/**
- * Check if a file path is directly inside a package directory identified by its suffix.
- * Used by the symbol resolver for Go and C# directory-level import matching.
- */
-export declare function isFileInPackageDir(filePath: string, dirSuffix: string): boolean;
 /** Pre-built lookup structures for import resolution. Build once, reuse across chunks. */
 export interface ImportResolutionContext {
     allFilePaths: Set<string>;
@@ -27,10 +12,27 @@ export interface ImportResolutionContext {
     resolveCache: Map<string, string | null>;
 }
 export declare function buildImportResolutionContext(allPaths: string[]): ImportResolutionContext;
+/**
+ * Build a suffix index for O(1) endsWith lookups.
+ * Maps every possible path suffix to its original file path.
+ * e.g. for "src/com/example/Foo.java":
+ *   "Foo.java" -> "src/com/example/Foo.java"
+ *   "example/Foo.java" -> "src/com/example/Foo.java"
+ *   "com/example/Foo.java" -> "src/com/example/Foo.java"
+ *   etc.
+ */
+export interface SuffixIndex {
+    /** Exact suffix lookup (case-sensitive) */
+    get(suffix: string): string | undefined;
+    /** Case-insensitive suffix lookup */
+    getInsensitive(suffix: string): string | undefined;
+    /** Get all files in a directory suffix */
+    getFilesInDir(dirSuffix: string, extension: string): string[];
+}
 export declare const processImports: (graph: KnowledgeGraph, files: {
     path: string;
     content: string;
-}[], astCache: ASTCache, importMap: ImportMap, onProgress?: (current: number, total: number) => void, repoRoot?: string, allPaths?: string[], packageMap?: PackageMap, namedImportMap?: NamedImportMap) => Promise<void>;
+}[], astCache: ASTCache, importMap: ImportMap, onProgress?: (current: number, total: number) => void, repoRoot?: string, allPaths?: string[]) => Promise<void>;
 export declare const processImportsFromExtracted: (graph: KnowledgeGraph, files: {
     path: string;
-}[], extractedImports: ExtractedImport[], importMap: ImportMap, onProgress?: (current: number, total: number) => void, repoRoot?: string, prebuiltCtx?: ImportResolutionContext, packageMap?: PackageMap, namedImportMap?: NamedImportMap) => Promise<void>;
+}[], extractedImports: ExtractedImport[], importMap: ImportMap, onProgress?: (current: number, total: number) => void, repoRoot?: string, prebuiltCtx?: ImportResolutionContext) => Promise<void>;