gitnexus 1.4.7 → 1.4.9

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

@@ -15,19 +15,19 @@
  */
 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 { getLanguageFromFilename } from './utils/language-detection.js';
+import { isVerboseIngestionEnabled } from './utils/verbose.js';
+import { yieldToEventLoop } from './utils/event-loop.js';
+import { getProvider } from './languages/index.js';
 import { getTreeSitterBufferSize } from './constants.js';
-/** C#/Java convention: interfaces start with I followed by an uppercase letter */
-const INTERFACE_NAME_RE = /^I[A-Z]/;
+import { TIER_CONFIDENCE } from './resolution-context.js';
 /**
  * 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)
+ * Uses the symbol table first (authoritative — Tier 1); falls back to provider-defined
+ * heuristics for external symbols not present in the graph:
+ *   - interfaceNamePattern: matched against parent name (e.g., /^I[A-Z]/ for C#/Java)
+ *   - heritageDefaultEdge: 'IMPLEMENTS' causes all unresolved parents to map to IMPLEMENTS
  *   - All others: default EXTENDS
  */
 const resolveExtendsType = (parentName, currentFilePath, ctx, language) => {
@@ -38,32 +38,27 @@ const resolveExtendsType = (parentName, currentFilePath, ctx, language) => {
             ? { 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' };
-        }
+    // Unresolved symbol — fall back to provider-defined heuristics
+    const provider = getProvider(language);
+    if (provider.interfaceNamePattern?.test(parentName)) {
+        return { type: 'IMPLEMENTS', idPrefix: 'Interface' };
     }
-    else if (language === SupportedLanguages.Swift) {
-        // Protocol conformance is far more common than class inheritance in Swift
+    if (provider.heritageDefaultEdge === 'IMPLEMENTS') {
         return { type: 'IMPLEMENTS', idPrefix: 'Interface' };
     }
     return { type: 'EXTENDS', idPrefix: 'Class' };
 };
-/**
- * Resolve a symbol ID for heritage, with fallback to generated ID.
- * Uses ctx.resolve() → pick first candidate's nodeId → generate synthetic ID.
- */
 const resolveHeritageId = (name, filePath, ctx, fallbackLabel, fallbackKey) => {
     const resolved = ctx.resolve(name, filePath);
     if (resolved && resolved.candidates.length > 0) {
         // For global with multiple candidates, refuse (a wrong edge is worse than no edge)
         if (resolved.tier === 'global' && resolved.candidates.length > 1) {
-            return generateId(fallbackLabel, fallbackKey ?? name);
+            return { id: generateId(fallbackLabel, fallbackKey ?? name), confidence: TIER_CONFIDENCE['global'] };
         }
-        return resolved.candidates[0].nodeId;
+        return { id: resolved.candidates[0].nodeId, confidence: TIER_CONFIDENCE[resolved.tier] };
     }
-    return generateId(fallbackLabel, fallbackKey ?? name);
+    // Unresolved: use global-tier confidence as fallback
+    return { id: generateId(fallbackLabel, fallbackKey ?? name), confidence: TIER_CONFIDENCE['global'] };
 };
 export const processHeritage = async (graph, files, astCache, ctx, onProgress) => {
     const parser = await loadParser();
@@ -84,7 +79,8 @@ export const processHeritage = async (graph, files, astCache, ctx, onProgress) =
             }
             continue;
         }
-        const queryStr = LANGUAGE_QUERIES[language];
+        const provider = getProvider(language);
+        const queryStr = provider.treeSitterQueries;
         if (!queryStr)
             continue;
         // 2. Load the language
@@ -132,15 +128,15 @@ export const processHeritage = async (graph, files, astCache, ctx, onProgress) =
                 const className = captureMap['heritage.class'].text;
                 const parentClassName = captureMap['heritage.extends'].text;
                 const { type: relType, idPrefix } = resolveExtendsType(parentClassName, file.path, ctx, language);
-                const childId = resolveHeritageId(className, file.path, ctx, 'Class', `${file.path}:${className}`);
-                const parentId = resolveHeritageId(parentClassName, file.path, ctx, idPrefix);
-                if (childId && parentId && childId !== parentId) {
+                const child = resolveHeritageId(className, file.path, ctx, 'Class', `${file.path}:${className}`);
+                const parent = resolveHeritageId(parentClassName, file.path, ctx, idPrefix);
+                if (child.id && parent.id && child.id !== parent.id) {
                     graph.addRelationship({
-                        id: generateId(relType, `${childId}->${parentId}`),
-                        sourceId: childId,
-                        targetId: parentId,
+                        id: generateId(relType, `${child.id}->${parent.id}`),
+                        sourceId: child.id,
+                        targetId: parent.id,
                         type: relType,
-                        confidence: 1.0,
+                        confidence: Math.sqrt(child.confidence * parent.confidence),
                         reason: '',
                     });
                 }
@@ -149,15 +145,15 @@ export const processHeritage = async (graph, files, astCache, ctx, onProgress) =
             if (captureMap['heritage.class'] && captureMap['heritage.implements']) {
                 const className = captureMap['heritage.class'].text;
                 const interfaceName = captureMap['heritage.implements'].text;
-                const classId = resolveHeritageId(className, file.path, ctx, 'Class', `${file.path}:${className}`);
-                const interfaceId = resolveHeritageId(interfaceName, file.path, ctx, 'Interface');
-                if (classId && interfaceId) {
+                const cls = resolveHeritageId(className, file.path, ctx, 'Class', `${file.path}:${className}`);
+                const iface = resolveHeritageId(interfaceName, file.path, ctx, 'Interface');
+                if (cls.id && iface.id) {
                     graph.addRelationship({
-                        id: generateId('IMPLEMENTS', `${classId}->${interfaceId}`),
-                        sourceId: classId,
-                        targetId: interfaceId,
+                        id: generateId('IMPLEMENTS', `${cls.id}->${iface.id}`),
+                        sourceId: cls.id,
+                        targetId: iface.id,
                         type: 'IMPLEMENTS',
-                        confidence: 1.0,
+                        confidence: Math.sqrt(cls.confidence * iface.confidence),
                         reason: '',
                     });
                 }
@@ -166,15 +162,15 @@ export const processHeritage = async (graph, files, astCache, ctx, onProgress) =
             if (captureMap['heritage.trait'] && captureMap['heritage.class']) {
                 const structName = captureMap['heritage.class'].text;
                 const traitName = captureMap['heritage.trait'].text;
-                const structId = resolveHeritageId(structName, file.path, ctx, 'Struct', `${file.path}:${structName}`);
-                const traitId = resolveHeritageId(traitName, file.path, ctx, 'Trait');
-                if (structId && traitId) {
+                const strct = resolveHeritageId(structName, file.path, ctx, 'Struct', `${file.path}:${structName}`);
+                const trait = resolveHeritageId(traitName, file.path, ctx, 'Trait');
+                if (strct.id && trait.id) {
                     graph.addRelationship({
-                        id: generateId('IMPLEMENTS', `${structId}->${traitId}`),
-                        sourceId: structId,
-                        targetId: traitId,
+                        id: generateId('IMPLEMENTS', `${strct.id}->${trait.id}`),
+                        sourceId: strct.id,
+                        targetId: trait.id,
                         type: 'IMPLEMENTS',
-                        confidence: 1.0,
+                        confidence: Math.sqrt(strct.confidence * trait.confidence),
                         reason: 'trait-impl',
                     });
                 }
@@ -205,43 +201,43 @@ export const processHeritageFromExtracted = async (graph, extractedHeritage, ctx
             if (!fileLanguage)
                 continue;
             const { type: relType, idPrefix } = resolveExtendsType(h.parentName, h.filePath, ctx, fileLanguage);
-            const childId = resolveHeritageId(h.className, h.filePath, ctx, 'Class', `${h.filePath}:${h.className}`);
-            const parentId = resolveHeritageId(h.parentName, h.filePath, ctx, idPrefix);
-            if (childId && parentId && childId !== parentId) {
+            const child = resolveHeritageId(h.className, h.filePath, ctx, 'Class', `${h.filePath}:${h.className}`);
+            const parent = resolveHeritageId(h.parentName, h.filePath, ctx, idPrefix);
+            if (child.id && parent.id && child.id !== parent.id) {
                 graph.addRelationship({
-                    id: generateId(relType, `${childId}->${parentId}`),
-                    sourceId: childId,
-                    targetId: parentId,
+                    id: generateId(relType, `${child.id}->${parent.id}`),
+                    sourceId: child.id,
+                    targetId: parent.id,
                     type: relType,
-                    confidence: 1.0,
+                    confidence: Math.sqrt(child.confidence * parent.confidence),
                     reason: '',
                 });
             }
         }
         else if (h.kind === 'implements') {
-            const classId = resolveHeritageId(h.className, h.filePath, ctx, 'Class', `${h.filePath}:${h.className}`);
-            const interfaceId = resolveHeritageId(h.parentName, h.filePath, ctx, 'Interface');
-            if (classId && interfaceId) {
+            const cls = resolveHeritageId(h.className, h.filePath, ctx, 'Class', `${h.filePath}:${h.className}`);
+            const iface = resolveHeritageId(h.parentName, h.filePath, ctx, 'Interface');
+            if (cls.id && iface.id) {
                 graph.addRelationship({
-                    id: generateId('IMPLEMENTS', `${classId}->${interfaceId}`),
-                    sourceId: classId,
-                    targetId: interfaceId,
+                    id: generateId('IMPLEMENTS', `${cls.id}->${iface.id}`),
+                    sourceId: cls.id,
+                    targetId: iface.id,
                     type: 'IMPLEMENTS',
-                    confidence: 1.0,
+                    confidence: Math.sqrt(cls.confidence * iface.confidence),
                     reason: '',
                 });
             }
         }
         else if (h.kind === 'trait-impl' || h.kind === 'include' || h.kind === 'extend' || h.kind === 'prepend') {
-            const structId = resolveHeritageId(h.className, h.filePath, ctx, 'Struct', `${h.filePath}:${h.className}`);
-            const traitId = resolveHeritageId(h.parentName, h.filePath, ctx, 'Trait');
-            if (structId && traitId) {
+            const strct = resolveHeritageId(h.className, h.filePath, ctx, 'Struct', `${h.filePath}:${h.className}`);
+            const trait = resolveHeritageId(h.parentName, h.filePath, ctx, 'Trait');
+            if (strct.id && trait.id) {
                 graph.addRelationship({
-                    id: generateId('IMPLEMENTS', `${structId}->${traitId}:${h.kind}`),
-                    sourceId: structId,
-                    targetId: traitId,
+                    id: generateId('IMPLEMENTS', `${strct.id}->${trait.id}:${h.kind}`),
+                    sourceId: strct.id,
+                    targetId: trait.id,
                     type: 'IMPLEMENTS',
-                    confidence: 1.0,
+                    confidence: Math.sqrt(strct.confidence * trait.confidence),
                     reason: h.kind,
                 });
             }

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

@@ -1,9 +1,10 @@
 import { KnowledgeGraph } from '../graph/types.js';
 import { ASTCache } from './ast-cache.js';
+import type { LanguageProvider } from './language-provider.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';
+import type { ImportResolutionContext } from './import-resolvers/types.js';
+import type { SyntaxNode } from './utils/ast-helpers.js';
 export type ImportMap = Map<string, Set<string>>;
 export type PackageMap = Map<string, Set<string>>;
 export interface NamedImportBinding {
@@ -16,15 +17,13 @@ export type NamedImportMap = Map<string, Map<string, NamedImportBinding>>;
  * 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>;
-    allFileList: string[];
-    normalizedFileList: string[];
-    suffixIndex: SuffixIndex;
-    resolveCache: Map<string, string | null>;
-}
 export declare function buildImportResolutionContext(allPaths: string[]): ImportResolutionContext;
+/**
+ * Clean and preprocess a raw import source text into a resolved import path.
+ * Strips quotes/angle brackets (universal) and applies provider-specific
+ * transformations (currently only Kotlin wildcard import detection).
+ */
+export declare function preprocessImportPath(sourceText: string, importNode: SyntaxNode, provider: LanguageProvider): string | null;
 export declare const processImports: (graph: KnowledgeGraph, files: {
     path: string;
     content: string;