gitnexus 1.3.11 → 1.4.0

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

@@ -2,16 +2,59 @@
  * Heritage Processor
  *
  * Extracts class inheritance relationships:
- * - EXTENDS: Class extends another Class (TS, JS, Python)
- * - IMPLEMENTS: Class implements an Interface (TS only)
+ * - 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
  */
 import Parser from 'tree-sitter';
-import { loadParser, loadLanguage } from '../tree-sitter/parser-loader.js';
+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, yieldToEventLoop } from './utils.js';
-export const processHeritage = async (graph, files, astCache, symbolTable, onProgress) => {
+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) => {
     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);
@@ -21,6 +64,12 @@ export const processHeritage = async (graph, files, astCache, symbolTable, onPro
         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;
@@ -32,7 +81,7 @@ export const processHeritage = async (graph, files, astCache, symbolTable, onPro
         if (!tree) {
             // Use larger bufferSize for files > 32KB
             try {
-                tree = parser.parse(file.content, undefined, { bufferSize: 1024 * 256 });
+                tree = parser.parse(file.content, undefined, { bufferSize: getTreeSitterBufferSize(file.content.length) });
             }
             catch (parseError) {
                 // Skip files that can't be parsed
@@ -59,23 +108,29 @@ export const processHeritage = async (graph, files, astCache, symbolTable, onPro
             match.captures.forEach(c => {
                 captureMap[c.name] = c.node;
             });
-            // EXTENDS: Class extends another Class
+            // EXTENDS or IMPLEMENTS: resolve via symbol table for languages where
+            // the tree-sitter query can't distinguish classes from interfaces (C#, Java)
             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;
-                // Resolve both class IDs
+                const { type: relType, idPrefix } = resolveExtendsType(parentClassName, file.path, symbolTable, importMap, language, packageMap);
                 const childId = symbolTable.lookupExact(file.path, className) ||
-                    symbolTable.lookupFuzzy(className)[0]?.nodeId ||
+                    resolveSymbol(className, file.path, symbolTable, importMap, packageMap)?.nodeId ||
                     generateId('Class', `${file.path}:${className}`);
-                const parentId = symbolTable.lookupFuzzy(parentClassName)[0]?.nodeId ||
-                    generateId('Class', `${parentClassName}`);
+                const parentId = resolveSymbol(parentClassName, file.path, symbolTable, importMap, packageMap)?.nodeId ||
+                    generateId(idPrefix, `${parentClassName}`);
                 if (childId && parentId && childId !== parentId) {
-                    const relId = generateId('EXTENDS', `${childId}->${parentId}`);
                     graph.addRelationship({
-                        id: relId,
+                        id: generateId(relType, `${childId}->${parentId}`),
                         sourceId: childId,
                         targetId: parentId,
-                        type: 'EXTENDS',
+                        type: relType,
                         confidence: 1.0,
                         reason: '',
                     });
@@ -87,9 +142,9 @@ export const processHeritage = async (graph, files, astCache, symbolTable, onPro
                 const interfaceName = captureMap['heritage.implements'].text;
                 // Resolve class and interface IDs
                 const classId = symbolTable.lookupExact(file.path, className) ||
-                    symbolTable.lookupFuzzy(className)[0]?.nodeId ||
+                    resolveSymbol(className, file.path, symbolTable, importMap, packageMap)?.nodeId ||
                     generateId('Class', `${file.path}:${className}`);
-                const interfaceId = symbolTable.lookupFuzzy(interfaceName)[0]?.nodeId ||
+                const interfaceId = resolveSymbol(interfaceName, file.path, symbolTable, importMap, packageMap)?.nodeId ||
                     generateId('Interface', `${interfaceName}`);
                 if (classId && interfaceId) {
                     const relId = generateId('IMPLEMENTS', `${classId}->${interfaceId}`);
@@ -109,9 +164,9 @@ export const processHeritage = async (graph, files, astCache, symbolTable, onPro
                 const traitName = captureMap['heritage.trait'].text;
                 // Resolve struct and trait IDs
                 const structId = symbolTable.lookupExact(file.path, structName) ||
-                    symbolTable.lookupFuzzy(structName)[0]?.nodeId ||
+                    resolveSymbol(structName, file.path, symbolTable, importMap, packageMap)?.nodeId ||
                     generateId('Struct', `${file.path}:${structName}`);
-                const traitId = symbolTable.lookupFuzzy(traitName)[0]?.nodeId ||
+                const traitId = resolveSymbol(traitName, file.path, symbolTable, importMap, packageMap)?.nodeId ||
                     generateId('Trait', `${traitName}`);
                 if (structId && traitId) {
                     const relId = generateId('IMPLEMENTS', `${structId}->${traitId}`);
@@ -128,12 +183,17 @@ export const processHeritage = async (graph, files, astCache, symbolTable, onPro
         });
         // 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, onProgress) => {
+export const processHeritageFromExtracted = async (graph, extractedHeritage, symbolTable, importMap, packageMap, onProgress) => {
     const total = extractedHeritage.length;
     for (let i = 0; i < extractedHeritage.length; i++) {
         if (i % 500 === 0) {
@@ -142,17 +202,21 @@ 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) ||
-                symbolTable.lookupFuzzy(h.className)[0]?.nodeId ||
+                resolveSymbol(h.className, h.filePath, symbolTable, importMap, packageMap)?.nodeId ||
                 generateId('Class', `${h.filePath}:${h.className}`);
-            const parentId = symbolTable.lookupFuzzy(h.parentName)[0]?.nodeId ||
-                generateId('Class', `${h.parentName}`);
+            const parentId = resolveSymbol(h.parentName, h.filePath, symbolTable, importMap, packageMap)?.nodeId ||
+                generateId(idPrefix, `${h.parentName}`);
             if (childId && parentId && childId !== parentId) {
                 graph.addRelationship({
-                    id: generateId('EXTENDS', `${childId}->${parentId}`),
+                    id: generateId(relType, `${childId}->${parentId}`),
                     sourceId: childId,
                     targetId: parentId,
-                    type: 'EXTENDS',
+                    type: relType,
                     confidence: 1.0,
                     reason: '',
                 });
@@ -160,9 +224,9 @@ export const processHeritageFromExtracted = async (graph, extractedHeritage, sym
         }
         else if (h.kind === 'implements') {
             const classId = symbolTable.lookupExact(h.filePath, h.className) ||
-                symbolTable.lookupFuzzy(h.className)[0]?.nodeId ||
+                resolveSymbol(h.className, h.filePath, symbolTable, importMap, packageMap)?.nodeId ||
                 generateId('Class', `${h.filePath}:${h.className}`);
-            const interfaceId = symbolTable.lookupFuzzy(h.parentName)[0]?.nodeId ||
+            const interfaceId = resolveSymbol(h.parentName, h.filePath, symbolTable, importMap, packageMap)?.nodeId ||
                 generateId('Interface', `${h.parentName}`);
             if (classId && interfaceId) {
                 graph.addRelationship({
@@ -177,9 +241,9 @@ export const processHeritageFromExtracted = async (graph, extractedHeritage, sym
         }
         else if (h.kind === 'trait-impl') {
             const structId = symbolTable.lookupExact(h.filePath, h.className) ||
-                symbolTable.lookupFuzzy(h.className)[0]?.nodeId ||
+                resolveSymbol(h.className, h.filePath, symbolTable, importMap, packageMap)?.nodeId ||
                 generateId('Struct', `${h.filePath}:${h.className}`);
-            const traitId = symbolTable.lookupFuzzy(h.parentName)[0]?.nodeId ||
+            const traitId = resolveSymbol(h.parentName, h.filePath, symbolTable, importMap, packageMap)?.nodeId ||
                 generateId('Trait', `${h.parentName}`);
             if (structId && traitId) {
                 graph.addRelationship({

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

@@ -1,8 +1,23 @@
 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>;
@@ -12,27 +27,10 @@ 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[]) => Promise<void>;
+}[], astCache: ASTCache, importMap: ImportMap, onProgress?: (current: number, total: number) => void, repoRoot?: string, allPaths?: string[], packageMap?: PackageMap, namedImportMap?: NamedImportMap) => 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) => Promise<void>;
+}[], extractedImports: ExtractedImport[], importMap: ImportMap, onProgress?: (current: number, total: number) => void, repoRoot?: string, prebuiltCtx?: ImportResolutionContext, packageMap?: PackageMap, namedImportMap?: NamedImportMap) => Promise<void>;