gitnexus 1.4.7 → 1.4.8

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;