gitnexus 1.4.6 → 1.4.8

package/dist/core/ingestion/call-routing.d.ts

@@ -10,12 +10,31 @@
  * two packages have separate build targets (Node native vs WASM/browser).
  * Keep both copies in sync until a shared package is introduced.
  */
-import { SupportedLanguages } from '../../config/supported-languages.js';
 /** null = this call was not routed; fall through to default call handling */
 export type CallRoutingResult = RubyCallRouting | null;
+/**
+ * Per-language call router.
+ * IMPORTANT: Call-routed imports bypass preprocessImportPath(), so any router that
+ * returns an importPath MUST validate it independently (length cap, control-char
+ * rejection). See routeRubyCall for the reference implementation.
+ */
 export type CallRouter = (calledName: string, callNode: any) => CallRoutingResult;
 /** Per-language call routing. noRouting = no special routing (normal call processing) */
-export declare const callRouters: Record<SupportedLanguages, CallRouter>;
+export declare const callRouters: {
+    javascript: CallRouter;
+    typescript: CallRouter;
+    python: CallRouter;
+    java: CallRouter;
+    kotlin: CallRouter;
+    go: CallRouter;
+    rust: CallRouter;
+    csharp: CallRouter;
+    php: CallRouter;
+    swift: CallRouter;
+    cpp: CallRouter;
+    c: CallRouter;
+    ruby: typeof routeRubyCall;
+};
 export type RubyCallRouting = {
     kind: 'import';
     importPath: string;
@@ -42,6 +61,8 @@ export interface RubyPropertyItem {
     accessorType: RubyAccessorType;
     startLine: number;
     endLine: number;
+    /** YARD @return [Type] annotation preceding the attr_accessor call */
+    declaredType?: string;
 }
 /**
  * Classify a Ruby call node and extract its semantic payload.

package/dist/core/ingestion/call-routing.js

@@ -89,6 +89,26 @@ export function routeRubyCall(calledName, callNode) {
     }
     // ── attr_accessor / attr_reader / attr_writer → property definitions ───
     if (calledName === 'attr_accessor' || calledName === 'attr_reader' || calledName === 'attr_writer') {
+        // Extract YARD @return [Type] from preceding comment (e.g. `# @return [Address]`)
+        let yardType;
+        let sibling = callNode.previousSibling;
+        while (sibling) {
+            if (sibling.type === 'comment') {
+                const match = /@return\s+\[([^\]]+)\]/.exec(sibling.text);
+                if (match) {
+                    const raw = match[1].trim();
+                    // Extract simple type name: "User", "Array<User>" → "User"
+                    const simple = raw.match(/^([A-Z]\w*)/);
+                    if (simple)
+                        yardType = simple[1];
+                    break;
+                }
+            }
+            else if (sibling.isNamed) {
+                break; // stop at non-comment named sibling
+            }
+            sibling = sibling.previousSibling;
+        }
         const items = [];
         const argList = callNode.childForFieldName?.('arguments');
         for (const arg of (argList?.children ?? [])) {
@@ -98,6 +118,7 @@ export function routeRubyCall(calledName, callNode) {
                     accessorType: calledName,
                     startLine: arg.startPosition.row,
                     endLine: arg.endPosition.row,
+                    ...(yardType ? { declaredType: yardType } : {}),
                 });
             }
         }

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

@@ -12,28 +12,31 @@
 import { detectFrameworkFromPath } from './framework-detection.js';
 import { SupportedLanguages } from '../../config/supported-languages.js';
 // ============================================================================
-// NAME PATTERNS - All 11 supported languages
+// NAME PATTERNS - All 13 supported languages
 // ============================================================================
 /**
- * Common entry point naming patterns by language
- * These patterns indicate functions that are likely feature entry points
+ * Common entry point naming patterns by language.
+ * These patterns indicate functions that are likely feature entry points.
+ *
+ * Universal patterns are separated from per-language patterns so the per-language
+ * table can use `satisfies Record<SupportedLanguages, RegExp[]>` for compile-time
+ * exhaustiveness — the compiler catches any missing language entry.
  */
+const UNIVERSAL_ENTRY_POINT_PATTERNS = [
+    /^(main|init|bootstrap|start|run|setup|configure)$/i,
+    /^handle[A-Z]/, // handleLogin, handleSubmit
+    /^on[A-Z]/, // onClick, onSubmit
+    /Handler$/, // RequestHandler
+    /Controller$/, // UserController
+    /^process[A-Z]/, // processPayment
+    /^execute[A-Z]/, // executeQuery
+    /^perform[A-Z]/, // performAction
+    /^dispatch[A-Z]/, // dispatchEvent
+    /^trigger[A-Z]/, // triggerAction
+    /^fire[A-Z]/, // fireEvent
+    /^emit[A-Z]/, // emitEvent
+];
 const ENTRY_POINT_PATTERNS = {
-    // Universal patterns (apply to all languages)
-    '*': [
-        /^(main|init|bootstrap|start|run|setup|configure)$/i,
-        /^handle[A-Z]/, // handleLogin, handleSubmit
-        /^on[A-Z]/, // onClick, onSubmit
-        /Handler$/, // RequestHandler
-        /Controller$/, // UserController
-        /^process[A-Z]/, // processPayment
-        /^execute[A-Z]/, // executeQuery
-        /^perform[A-Z]/, // performAction
-        /^dispatch[A-Z]/, // dispatchEvent
-        /^trigger[A-Z]/, // triggerAction
-        /^fire[A-Z]/, // fireEvent
-        /^emit[A-Z]/, // emitEvent
-    ],
     // JavaScript/TypeScript
     [SupportedLanguages.JavaScript]: [
         /^use[A-Z]/, // React hooks (useEffect, etc.)
@@ -55,6 +58,16 @@ const ENTRY_POINT_PATTERNS = {
         /^build[A-Z]/, // Builder patterns
         /Service$/, // UserService
     ],
+    // Kotlin
+    [SupportedLanguages.Kotlin]: [
+        /^on(Create|Start|Resume|Pause|Stop|Destroy)$/, // Android lifecycle
+        /^do[A-Z]/, // doGet, doPost (shared JVM Servlet pattern)
+        /^create[A-Z]/, // Factory patterns
+        /^build[A-Z]/, // Builder patterns
+        /ViewModel$/, // MVVM pattern (Android)
+        /^module$/, // Ktor module entry point
+        /Service$/, // Service classes
+    ],
     // C#
     [SupportedLanguages.CSharp]: [
         /^(Get|Post|Put|Delete|Patch)/, // ASP.NET action methods
@@ -186,13 +199,10 @@ const ENTRY_POINT_PATTERNS = {
     ],
 };
 /** 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];
-}
+const MERGED_ENTRY_POINT_PATTERNS = Object.fromEntries(Object.keys(ENTRY_POINT_PATTERNS).map(lang => [
+    lang,
+    [...UNIVERSAL_ENTRY_POINT_PATTERNS, ...ENTRY_POINT_PATTERNS[lang]],
+]));
 // ============================================================================
 // UTILITY PATTERNS - Functions that should be penalized
 // ============================================================================
@@ -258,7 +268,7 @@ export function calculateEntryPointScore(name, language, isExported, callerCount
     }
     else {
         // Check positive patterns
-        const allPatterns = MERGED_ENTRY_POINT_PATTERNS[language] || UNIVERSAL_PATTERNS;
+        const allPatterns = MERGED_ENTRY_POINT_PATTERNS[language];
         if (allPatterns.some(p => p.test(name))) {
             nameMultiplier = 1.5; // Bonus for matching entry point pattern
             reasons.push('entry-pattern');

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

@@ -9,6 +9,7 @@
  * DESIGN: Returns null for unknown frameworks, which causes a 1.0 multiplier
  * (no bonus, no penalty) - same behavior as before this feature.
  */
+import { SupportedLanguages } from '../../config/supported-languages.js';
 export interface FrameworkHint {
     framework: string;
     entryPointMultiplier: number;
@@ -37,15 +38,22 @@ export declare const FRAMEWORK_AST_PATTERNS: {
     blazor: string[];
     efcore: string[];
     'go-http': string[];
+    gin: string[];
+    echo: string[];
+    fiber: string[];
+    'go-grpc': string[];
     laravel: string[];
     actix: string[];
     axum: string[];
     rocket: string[];
+    tokio: string[];
+    qt: string[];
     uikit: string[];
     swiftui: string[];
-    combine: string[];
+    vapor: string[];
+    rails: string[];
+    sinatra: 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.

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

@@ -9,6 +9,7 @@
  * DESIGN: Returns null for unknown frameworks, which causes a 1.0 multiplier
  * (no bonus, no penalty) - same behavior as before this feature.
  */
+import { SupportedLanguages } from '../../config/supported-languages.js';
 // ============================================================================
 // PATH-BASED FRAMEWORK DETECTION
 // ============================================================================
@@ -180,8 +181,8 @@ export function detectFrameworkFromPath(filePath) {
     if (p.includes('/controllers/') && p.endsWith('.go')) {
         return { framework: 'go-mvc', entryPointMultiplier: 2.5, reason: 'go-controller' };
     }
-    // Go main.go files (THE entry point)
-    if (p.endsWith('/main.go') || p.endsWith('/cmd/') && p.endsWith('.go')) {
+    // Go main.go files (THE entry point) — only match main.go, not arbitrary .go files under cmd/
+    if (p.endsWith('/main.go')) {
         return { framework: 'go', entryPointMultiplier: 3.0, reason: 'go-main' };
     }
     // ========== RUST FRAMEWORKS ==========
@@ -333,21 +334,31 @@ export const FRAMEWORK_AST_PATTERNS = {
     'signalr': ['[HubMethodName]', ': Hub', ': Hub<'],
     'blazor': ['@page', '[Parameter]', '@inject'],
     'efcore': ['DbContext', 'DbSet<', 'OnModelCreating'],
-    // Go patterns (function signatures)
-    'go-http': ['http.Handler', 'http.HandlerFunc', 'ServeHTTP'],
+    // Go patterns (function signatures include framework types)
+    'go-http': ['http.Handler', 'http.HandlerFunc', 'ServeHTTP', 'http.ResponseWriter', 'http.Request'],
+    'gin': ['gin.Context', 'gin.Default', 'gin.New'],
+    'echo': ['echo.Context', 'echo.New'],
+    'fiber': ['fiber.Ctx', 'fiber.New', 'fiber.App'],
+    'go-grpc': ['grpc.Server', 'RegisterServer', 'pb.Unimplemented'],
     // PHP/Laravel
     'laravel': ['Route::get', 'Route::post', 'Route::put', 'Route::delete',
         'Route::resource', 'Route::apiResource', '#[Route('],
-    // Rust macros
-    'actix': ['#[get', '#[post', '#[put', '#[delete'],
-    'axum': ['Router::new'],
-    'rocket': ['#[get', '#[post'],
+    // Rust macros (proc-macro attributes in definition text)
+    'actix': ['#[get', '#[post', '#[put', '#[delete', '#[actix_web', 'HttpRequest', 'HttpResponse'],
+    'axum': ['Router::new', 'axum::extract', 'axum::routing'],
+    'rocket': ['#[get', '#[post', '#[launch', 'rocket::'],
+    'tokio': ['#[tokio::main]', '#[tokio::test]'],
+    // C++ patterns (Qt, Boost)
+    'qt': ['Q_OBJECT', 'Q_INVOKABLE', 'Q_PROPERTY', 'Q_SIGNALS', 'Q_SLOTS', 'Q_SIGNAL', 'Q_SLOT', 'QWidget', 'QApplication'],
     // Swift/iOS
-    'uikit': ['viewDidLoad', 'viewWillAppear', 'viewDidAppear', 'UIViewController'],
-    'swiftui': ['@main', 'WindowGroup', 'ContentView', '@StateObject', '@ObservedObject'],
-    'combine': ['sink', 'assign', 'Publisher', 'Subscriber'],
+    'uikit': ['viewDidLoad', 'viewWillAppear', 'viewDidAppear', 'UIViewController', '@IBOutlet', '@IBAction', '@objc'],
+    'swiftui': ['@main', 'WindowGroup', 'ContentView', '@StateObject', '@ObservedObject', '@EnvironmentObject', '@Published'],
+    'vapor': ['app.get', 'app.post', 'req.content.decode', 'Vapor'],
+    // Ruby patterns (class-level macros in definition text)
+    'rails': ['ApplicationController', 'ApplicationRecord', 'ActiveRecord::Base',
+        'before_action', 'after_action', 'has_many', 'belongs_to', 'has_one', 'validates'],
+    'sinatra': ['Sinatra::Base', 'Sinatra::Application'],
 };
-import { SupportedLanguages } from '../../config/supported-languages.js';
 const AST_FRAMEWORK_PATTERNS_BY_LANGUAGE = {
     [SupportedLanguages.JavaScript]: [
         { framework: 'nestjs', entryPointMultiplier: 3.2, reason: 'nestjs-decorator', patterns: FRAMEWORK_AST_PATTERNS.nestjs },
@@ -378,6 +389,32 @@ const AST_FRAMEWORK_PATTERNS_BY_LANGUAGE = {
     [SupportedLanguages.PHP]: [
         { framework: 'laravel', entryPointMultiplier: 3.0, reason: 'php-route-attribute', patterns: FRAMEWORK_AST_PATTERNS.laravel },
     ],
+    [SupportedLanguages.Go]: [
+        { framework: 'go-http', entryPointMultiplier: 2.5, reason: 'go-http-handler', patterns: FRAMEWORK_AST_PATTERNS['go-http'] },
+        { framework: 'gin', entryPointMultiplier: 3.0, reason: 'gin-handler', patterns: FRAMEWORK_AST_PATTERNS.gin },
+        { framework: 'echo', entryPointMultiplier: 3.0, reason: 'echo-handler', patterns: FRAMEWORK_AST_PATTERNS.echo },
+        { framework: 'fiber', entryPointMultiplier: 3.0, reason: 'fiber-handler', patterns: FRAMEWORK_AST_PATTERNS.fiber },
+        { framework: 'go-grpc', entryPointMultiplier: 2.8, reason: 'grpc-service', patterns: FRAMEWORK_AST_PATTERNS['go-grpc'] },
+    ],
+    [SupportedLanguages.Rust]: [
+        { framework: 'actix-web', entryPointMultiplier: 3.0, reason: 'actix-attribute', patterns: FRAMEWORK_AST_PATTERNS.actix },
+        { framework: 'axum', entryPointMultiplier: 3.0, reason: 'axum-routing', patterns: FRAMEWORK_AST_PATTERNS.axum },
+        { framework: 'rocket', entryPointMultiplier: 3.0, reason: 'rocket-attribute', patterns: FRAMEWORK_AST_PATTERNS.rocket },
+        { framework: 'tokio', entryPointMultiplier: 2.5, reason: 'tokio-runtime', patterns: FRAMEWORK_AST_PATTERNS.tokio },
+    ],
+    [SupportedLanguages.C]: [], // C has no framework-specific AST patterns (POSIX/socket patterns are in entry-point-scoring)
+    [SupportedLanguages.CPlusPlus]: [
+        { framework: 'qt', entryPointMultiplier: 2.8, reason: 'qt-macro', patterns: FRAMEWORK_AST_PATTERNS.qt },
+    ],
+    [SupportedLanguages.Swift]: [
+        { framework: 'uikit', entryPointMultiplier: 2.5, reason: 'uikit-lifecycle', patterns: FRAMEWORK_AST_PATTERNS.uikit },
+        { framework: 'swiftui', entryPointMultiplier: 2.8, reason: 'swiftui-pattern', patterns: FRAMEWORK_AST_PATTERNS.swiftui },
+        { framework: 'vapor', entryPointMultiplier: 3.0, reason: 'vapor-routing', patterns: FRAMEWORK_AST_PATTERNS.vapor },
+    ],
+    [SupportedLanguages.Ruby]: [
+        { framework: 'rails', entryPointMultiplier: 3.0, reason: 'rails-pattern', patterns: FRAMEWORK_AST_PATTERNS.rails },
+        { framework: 'sinatra', entryPointMultiplier: 2.8, reason: 'sinatra-pattern', patterns: FRAMEWORK_AST_PATTERNS.sinatra },
+    ],
 };
 /** Pre-lowercased patterns for O(1) pattern matching at runtime */
 const AST_PATTERNS_LOWERED = Object.fromEntries(Object.entries(AST_FRAMEWORK_PATTERNS_BY_LANGUAGE).map(([lang, cfgs]) => [

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

@@ -20,6 +20,7 @@ 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 { TIER_CONFIDENCE } from './resolution-context.js';
 /** C#/Java convention: interfaces start with I followed by an uppercase letter */
 const INTERFACE_NAME_RE = /^I[A-Z]/;
 /**
@@ -50,20 +51,17 @@ const resolveExtendsType = (parentName, currentFilePath, ctx, language) => {
     }
     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();
@@ -132,15 +130,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 +147,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 +164,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 +203,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

@@ -21,7 +21,7 @@ export interface ImportResolutionContext {
     allFilePaths: Set<string>;
     allFileList: string[];
     normalizedFileList: string[];
-    suffixIndex: SuffixIndex;
+    index: SuffixIndex;
     resolveCache: Map<string, string | null>;
 }
 export declare function buildImportResolutionContext(allPaths: string[]): ImportResolutionContext;