@veewo/gitnexus 1.3.11 → 1.4.6-rc

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

@@ -0,0 +1,231 @@
+/**
+ * Export Detection
+ *
+ * Determines whether a symbol (function, class, etc.) is exported/public
+ * in its language. This is a pure function — safe for use in worker threads.
+ *
+ * Shared between parse-worker.ts (worker pool) and parsing-processor.ts (sequential fallback).
+ */
+import { findSiblingChild } from './utils.js';
+import { SupportedLanguages } from '../../config/supported-languages.js';
+// ============================================================================
+// Per-language export checkers
+// ============================================================================
+/** JS/TS: walk ancestors looking for export_statement or export_specifier. */
+const tsExportChecker = (node, _name) => {
+    let current = node;
+    while (current) {
+        const type = current.type;
+        if (type === 'export_statement' ||
+            type === 'export_specifier' ||
+            (type === 'lexical_declaration' && current.parent?.type === 'export_statement')) {
+            return true;
+        }
+        // Fallback: check if node text starts with 'export ' for edge cases
+        if (current.text?.startsWith('export ')) {
+            return true;
+        }
+        current = current.parent;
+    }
+    return false;
+};
+/** Python: public if no leading underscore (convention). */
+const pythonExportChecker = (_node, name) => !name.startsWith('_');
+/** Java: check for 'public' modifier — modifiers are siblings of the name node, not parents. */
+const javaExportChecker = (node, _name) => {
+    let current = node;
+    while (current) {
+        if (current.parent) {
+            const parent = current.parent;
+            for (let i = 0; i < parent.childCount; i++) {
+                const child = parent.child(i);
+                if (child?.type === 'modifiers' && child.text?.includes('public')) {
+                    return true;
+                }
+            }
+            if (parent.type === 'method_declaration' || parent.type === 'constructor_declaration') {
+                if (parent.text?.trimStart().startsWith('public')) {
+                    return true;
+                }
+            }
+        }
+        current = current.parent;
+    }
+    return false;
+};
+/** C# declaration node types for sibling modifier scanning. */
+const CSHARP_DECL_TYPES = new Set([
+    'method_declaration', 'local_function_statement', 'constructor_declaration',
+    'class_declaration', 'interface_declaration', 'struct_declaration',
+    'enum_declaration', 'record_declaration', 'record_struct_declaration',
+    'record_class_declaration', 'delegate_declaration',
+    'property_declaration', 'field_declaration', 'event_declaration',
+    'namespace_declaration', 'file_scoped_namespace_declaration',
+]);
+/**
+ * C#: modifier nodes are SIBLINGS of the name node inside the declaration.
+ * Walk up to the declaration node, then scan its direct children.
+ */
+const csharpExportChecker = (node, _name) => {
+    let current = node;
+    while (current) {
+        if (CSHARP_DECL_TYPES.has(current.type)) {
+            for (let i = 0; i < current.childCount; i++) {
+                const child = current.child(i);
+                if (child?.type === 'modifier' && child.text === 'public')
+                    return true;
+            }
+            return false;
+        }
+        current = current.parent;
+    }
+    return false;
+};
+/** Go: uppercase first letter = exported. */
+const goExportChecker = (_node, name) => {
+    if (name.length === 0)
+        return false;
+    const first = name[0];
+    return first === first.toUpperCase() && first !== first.toLowerCase();
+};
+/** Rust declaration node types for sibling visibility_modifier scanning. */
+const RUST_DECL_TYPES = new Set([
+    'function_item', 'struct_item', 'enum_item', 'trait_item', 'impl_item',
+    'union_item', 'type_item', 'const_item', 'static_item', 'mod_item',
+    'use_declaration', 'associated_type', 'function_signature_item',
+]);
+/**
+ * Rust: visibility_modifier is a SIBLING of the name node within the declaration node
+ * (function_item, struct_item, etc.), not a parent. Walk up to the declaration node,
+ * then scan its direct children.
+ */
+const rustExportChecker = (node, _name) => {
+    let current = node;
+    while (current) {
+        if (RUST_DECL_TYPES.has(current.type)) {
+            for (let i = 0; i < current.childCount; i++) {
+                const child = current.child(i);
+                if (child?.type === 'visibility_modifier' && child.text?.startsWith('pub'))
+                    return true;
+            }
+            return false;
+        }
+        current = current.parent;
+    }
+    return false;
+};
+/**
+ * Kotlin: default visibility is public (unlike Java).
+ * visibility_modifier is inside modifiers, a sibling of the name node within the declaration.
+ */
+const kotlinExportChecker = (node, _name) => {
+    let current = node;
+    while (current) {
+        if (current.parent) {
+            const visMod = findSiblingChild(current.parent, 'modifiers', 'visibility_modifier');
+            if (visMod) {
+                const text = visMod.text;
+                if (text === 'private' || text === 'internal' || text === 'protected')
+                    return false;
+                if (text === 'public')
+                    return true;
+            }
+        }
+        current = current.parent;
+    }
+    // No visibility modifier = public (Kotlin default)
+    return true;
+};
+/**
+ * C/C++: functions without 'static' storage class have external linkage by default,
+ * making them globally accessible (equivalent to exported). Only functions explicitly
+ * marked 'static' are file-scoped (not exported). C++ anonymous namespaces
+ * (namespace { ... }) also give internal linkage.
+ */
+const cCppExportChecker = (node, _name) => {
+    let cur = node;
+    while (cur) {
+        if (cur.type === 'function_definition' || cur.type === 'declaration') {
+            // Check for 'static' storage class specifier as a direct child node.
+            // This avoids reading the full function text (which can be very large).
+            for (let i = 0; i < cur.childCount; i++) {
+                const child = cur.child(i);
+                if (child?.type === 'storage_class_specifier' && child.text === 'static')
+                    return false;
+            }
+        }
+        // C++ anonymous namespace: namespace_definition with no name child = internal linkage
+        if (cur.type === 'namespace_definition') {
+            const hasName = cur.childForFieldName?.('name');
+            if (!hasName)
+                return false;
+        }
+        cur = cur.parent;
+    }
+    return true; // Top-level C/C++ functions default to external linkage
+};
+/** PHP: check for visibility modifier or top-level scope. */
+const phpExportChecker = (node, _name) => {
+    let current = node;
+    while (current) {
+        if (current.type === 'class_declaration' ||
+            current.type === 'interface_declaration' ||
+            current.type === 'trait_declaration' ||
+            current.type === 'enum_declaration') {
+            return true;
+        }
+        if (current.type === 'visibility_modifier') {
+            return current.text === 'public';
+        }
+        current = current.parent;
+    }
+    // Top-level functions are globally accessible
+    return true;
+};
+/** Swift: check for 'public' or 'open' access modifiers. */
+const swiftExportChecker = (node, _name) => {
+    let current = node;
+    while (current) {
+        if (current.type === 'modifiers' || current.type === 'visibility_modifier') {
+            const text = current.text || '';
+            if (text.includes('public') || text.includes('open'))
+                return true;
+        }
+        current = current.parent;
+    }
+    return false;
+};
+// ============================================================================
+// Exhaustive dispatch table — satisfies enforces all SupportedLanguages are covered
+// ============================================================================
+const exportCheckers = {
+    [SupportedLanguages.JavaScript]: tsExportChecker,
+    [SupportedLanguages.TypeScript]: tsExportChecker,
+    [SupportedLanguages.Python]: pythonExportChecker,
+    [SupportedLanguages.Java]: javaExportChecker,
+    [SupportedLanguages.CSharp]: csharpExportChecker,
+    [SupportedLanguages.Go]: goExportChecker,
+    [SupportedLanguages.Rust]: rustExportChecker,
+    [SupportedLanguages.Kotlin]: kotlinExportChecker,
+    [SupportedLanguages.C]: cCppExportChecker,
+    [SupportedLanguages.CPlusPlus]: cCppExportChecker,
+    [SupportedLanguages.PHP]: phpExportChecker,
+    [SupportedLanguages.Swift]: swiftExportChecker,
+    [SupportedLanguages.Ruby]: (_node, _name) => true,
+};
+// ============================================================================
+// Public API
+// ============================================================================
+/**
+ * Check if a tree-sitter node is exported/public in its language.
+ * @param node - The tree-sitter AST node
+ * @param name - The symbol name
+ * @param language - The programming language
+ * @returns true if the symbol is exported/public
+ */
+export const isNodeExported = (node, name, language) => {
+    const checker = exportCheckers[language];
+    if (!checker)
+        return false;
+    return checker(node, name);
+};

package/dist/core/ingestion/filesystem-walker.js

@@ -1,7 +1,7 @@
 import fs from 'fs/promises';
 import path from 'path';
 import { glob } from 'glob';
-import { shouldIgnorePath } from '../../config/ignore-service.js';
+import { createIgnoreFilter, shouldIgnorePath } from '../../config/ignore-service.js';
 const READ_CONCURRENCY = 32;
 /** Skip files larger than 512KB — they're usually generated/vendored and crash tree-sitter */
 const MAX_FILE_SIZE = 512 * 1024;
@@ -11,12 +11,13 @@ const UNITY_RESOURCE_GLOBS = ['**/*.prefab', '**/*.unity', '**/*.asset'];
  * Memory: ~10MB for 100K files vs ~1GB+ with content.
  */
 export const walkRepositoryPaths = async (repoPath, onProgress) => {
-    const files = await glob('**/*', {
+    const ignoreFilter = await createIgnoreFilter(repoPath);
+    const filtered = await glob('**/*', {
         cwd: repoPath,
         nodir: true,
         dot: false,
+        ignore: ignoreFilter,
     });
-    const filtered = files.filter(file => !shouldIgnorePath(file));
     const entries = [];
     let processed = 0;
     let skippedLarge = 0;

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

@@ -1,8 +1,10 @@
 /**
  * Framework Detection
  *
- * Detects frameworks from file path patterns and provides entry point multipliers.
- * This enables framework-aware entry point scoring.
+ * Detects frameworks from:
+ * 1) file path patterns
+ * 2) AST definition text (decorators/annotations/attributes)
+ * and provides entry point multipliers for process scoring.
  *
  * DESIGN: Returns null for unknown frameworks, which causes a 1.0 multiplier
  * (no bonus, no penalty) - same behavior as before this feature.
@@ -20,8 +22,8 @@ export interface FrameworkHint {
  */
 export declare function detectFrameworkFromPath(filePath: string): FrameworkHint | null;
 /**
- * Patterns that indicate entry points within code (for future AST-based detection)
- * These would require parsing decorators/annotations in the code itself.
+ * Patterns that indicate framework entry points within code definitions.
+ * These are matched against AST node text (class/method/function declaration text).
  */
 export declare const FRAMEWORK_AST_PATTERNS: {
     nestjs: string[];
@@ -31,9 +33,22 @@ 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[];
     axum: string[];
     rocket: string[];
+    uikit: string[];
+    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;

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

@@ -1,8 +1,10 @@
 /**
  * Framework Detection
  *
- * Detects frameworks from file path patterns and provides entry point multipliers.
- * This enables framework-aware entry point scoring.
+ * Detects frameworks from:
+ * 1) file path patterns
+ * 2) AST definition text (decorators/annotations/attributes)
+ * and provides entry point multipliers for process scoring.
  *
  * DESIGN: Returns null for unknown frameworks, which causes a 1.0 multiplier
  * (no bonus, no penalty) - same behavior as before this feature.
@@ -94,6 +96,41 @@ export function detectFrameworkFromPath(filePath) {
     if ((p.includes('/service/') || p.includes('/services/')) && p.endsWith('.java')) {
         return { framework: 'java-service', entryPointMultiplier: 1.8, reason: 'java-service' };
     }
+    // ========== KOTLIN FRAMEWORKS ==========
+    // Spring Boot Kotlin controllers
+    if ((p.includes('/controller/') || p.includes('/controllers/')) && p.endsWith('.kt')) {
+        return { framework: 'spring-kotlin', entryPointMultiplier: 3.0, reason: 'spring-kotlin-controller' };
+    }
+    // Spring Boot - files ending in Controller.kt
+    if (p.endsWith('controller.kt')) {
+        return { framework: 'spring-kotlin', entryPointMultiplier: 3.0, reason: 'spring-kotlin-controller-file' };
+    }
+    // Ktor routes
+    if (p.includes('/routes/') && p.endsWith('.kt')) {
+        return { framework: 'ktor', entryPointMultiplier: 2.5, reason: 'ktor-routes' };
+    }
+    // Ktor plugins folder or Routing.kt files
+    if (p.includes('/plugins/') && p.endsWith('.kt')) {
+        return { framework: 'ktor', entryPointMultiplier: 2.0, reason: 'ktor-plugin' };
+    }
+    if (p.endsWith('routing.kt') || p.endsWith('routes.kt')) {
+        return { framework: 'ktor', entryPointMultiplier: 2.5, reason: 'ktor-routing-file' };
+    }
+    // Android Activities, Fragments
+    if ((p.includes('/activity/') || p.includes('/ui/')) && p.endsWith('.kt')) {
+        return { framework: 'android-kotlin', entryPointMultiplier: 2.5, reason: 'android-ui' };
+    }
+    if (p.endsWith('activity.kt') || p.endsWith('fragment.kt')) {
+        return { framework: 'android-kotlin', entryPointMultiplier: 2.5, reason: 'android-component' };
+    }
+    // Kotlin main entry point
+    if (p.endsWith('/main.kt')) {
+        return { framework: 'kotlin', entryPointMultiplier: 3.0, reason: 'kotlin-main' };
+    }
+    // Kotlin Application entry point (common naming)
+    if (p.endsWith('/application.kt')) {
+        return { framework: 'kotlin', entryPointMultiplier: 2.5, reason: 'kotlin-application' };
+    }
     // ========== C# / .NET FRAMEWORKS ==========
     // ASP.NET Controllers
     if (p.includes('/controllers/') && p.endsWith('.cs')) {
@@ -103,6 +140,29 @@ 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' };
@@ -195,6 +255,52 @@ export function detectFrameworkFromPath(filePath) {
     if (p.includes('/repositories/') && p.endsWith('.php')) {
         return { framework: 'laravel', entryPointMultiplier: 1.5, reason: 'laravel-repository' };
     }
+    // ========== RUBY ==========
+    // Ruby: bin/ or exe/ (CLI entry points)
+    if ((p.includes('/bin/') || p.includes('/exe/')) && p.endsWith('.rb')) {
+        return { framework: 'ruby', entryPointMultiplier: 2.5, reason: 'ruby-executable' };
+    }
+    // Ruby: Rakefile or *.rake (task definitions)
+    if (p.endsWith('/rakefile') || p.endsWith('.rake')) {
+        return { framework: 'ruby', entryPointMultiplier: 1.5, reason: 'ruby-rake' };
+    }
+    // ========== SWIFT / iOS ==========
+    // iOS App entry points (highest priority)
+    if (p.endsWith('/appdelegate.swift') || p.endsWith('/scenedelegate.swift') || p.endsWith('/app.swift')) {
+        return { framework: 'ios', entryPointMultiplier: 3.0, reason: 'ios-app-entry' };
+    }
+    // SwiftUI App entry (@main)
+    if (p.endsWith('app.swift') && p.includes('/sources/')) {
+        return { framework: 'swiftui', entryPointMultiplier: 3.0, reason: 'swiftui-app' };
+    }
+    // UIKit ViewControllers (high priority - screen entry points)
+    if ((p.includes('/viewcontrollers/') || p.includes('/controllers/') || p.includes('/screens/')) && p.endsWith('.swift')) {
+        return { framework: 'uikit', entryPointMultiplier: 2.5, reason: 'uikit-viewcontroller' };
+    }
+    // ViewController by filename convention
+    if (p.endsWith('viewcontroller.swift') || p.endsWith('vc.swift')) {
+        return { framework: 'uikit', entryPointMultiplier: 2.5, reason: 'uikit-viewcontroller-file' };
+    }
+    // Coordinator pattern (navigation entry points)
+    if (p.includes('/coordinators/') && p.endsWith('.swift')) {
+        return { framework: 'ios-coordinator', entryPointMultiplier: 2.5, reason: 'ios-coordinator' };
+    }
+    // Coordinator by filename
+    if (p.endsWith('coordinator.swift')) {
+        return { framework: 'ios-coordinator', entryPointMultiplier: 2.5, reason: 'ios-coordinator-file' };
+    }
+    // SwiftUI Views (moderate - reusable components)
+    if ((p.includes('/views/') || p.includes('/scenes/')) && p.endsWith('.swift')) {
+        return { framework: 'swiftui', entryPointMultiplier: 1.8, reason: 'swiftui-view' };
+    }
+    // Service layer
+    if (p.includes('/services/') && p.endsWith('.swift')) {
+        return { framework: 'ios-service', entryPointMultiplier: 1.8, reason: 'ios-service' };
+    }
+    // Router / navigation
+    if (p.includes('/router/') && p.endsWith('.swift')) {
+        return { framework: 'ios-router', entryPointMultiplier: 2.0, reason: 'ios-router' };
+    }
     // ========== GENERIC PATTERNS ==========
     // Any language: index files in API folders
     if (p.includes('/api/') && (p.endsWith('/index.ts') || p.endsWith('/index.js') ||
@@ -205,11 +311,11 @@ export function detectFrameworkFromPath(filePath) {
     return null;
 }
 // ============================================================================
-// FUTURE: AST-BASED PATTERNS (for Phase 3)
+// AST-BASED FRAMEWORK DETECTION
 // ============================================================================
 /**
- * Patterns that indicate entry points within code (for future AST-based detection)
- * These would require parsing decorators/annotations in the code itself.
+ * Patterns that indicate framework entry points within code definitions.
+ * These are matched against AST node text (class/method/function declaration text).
  */
 export const FRAMEWORK_AST_PATTERNS = {
     // JavaScript/TypeScript decorators
@@ -222,7 +328,11 @@ export const FRAMEWORK_AST_PATTERNS = {
     'spring': ['@RestController', '@Controller', '@GetMapping', '@PostMapping', '@RequestMapping'],
     'jaxrs': ['@Path', '@GET', '@POST', '@PUT', '@DELETE'],
     // C# attributes
-    'aspnet': ['[ApiController]', '[HttpGet]', '[HttpPost]', '[Route]'],
+    'aspnet': ['[ApiController]', '[HttpGet]', '[HttpPost]', '[HttpPut]', '[HttpDelete]',
+        '[Route]', '[Authorize]', '[AllowAnonymous]'],
+    'signalr': ['[HubMethodName]', ': Hub', ': Hub<'],
+    'blazor': ['@page', '[Parameter]', '@inject'],
+    'efcore': ['DbContext', 'DbSet<', 'OnModelCreating'],
     // Go patterns (function signatures)
     'go-http': ['http.Handler', 'http.HandlerFunc', 'ServeHTTP'],
     // PHP/Laravel
@@ -232,4 +342,70 @@ export const FRAMEWORK_AST_PATTERNS = {
     'actix': ['#[get', '#[post', '#[put', '#[delete'],
     'axum': ['Router::new'],
     'rocket': ['#[get', '#[post'],
+    // Swift/iOS
+    'uikit': ['viewDidLoad', 'viewWillAppear', 'viewDidAppear', 'UIViewController'],
+    '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]: [
+        { framework: 'nestjs', entryPointMultiplier: 3.2, reason: 'nestjs-decorator', patterns: FRAMEWORK_AST_PATTERNS.nestjs },
+    ],
+    [SupportedLanguages.TypeScript]: [
+        { framework: 'nestjs', entryPointMultiplier: 3.2, reason: 'nestjs-decorator', patterns: FRAMEWORK_AST_PATTERNS.nestjs },
+    ],
+    [SupportedLanguages.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]: [
+        { 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]: [
+        { 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]: [
+        { 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]: [
+        { framework: 'laravel', entryPointMultiplier: 3.0, reason: 'php-route-attribute', patterns: FRAMEWORK_AST_PATTERNS.laravel },
+    ],
 };
+/** 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]) => [
+    lang,
+    cfgs.map(cfg => ({ ...cfg, patterns: cfg.patterns.map(p => p.toLowerCase()) })),
+]));
+/**
+ * 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 function detectFrameworkFromAST(language, definitionText) {
+    if (!language || !definitionText)
+        return null;
+    const configs = AST_PATTERNS_LOWERED[language.toLowerCase()];
+    if (!configs || configs.length === 0)
+        return null;
+    const normalized = definitionText.toLowerCase();
+    for (const cfg of configs) {
+        for (const pattern of cfg.patterns) {
+            if (normalized.includes(pattern)) {
+                return {
+                    framework: cfg.framework,
+                    entryPointMultiplier: cfg.entryPointMultiplier,
+                    reason: cfg.reason,
+                };
+            }
+        }
+    }
+    return null;
+}

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

@@ -2,19 +2,27 @@
  * 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 { 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 { ResolutionContext } from './resolution-context.js';
 export declare const processHeritage: (graph: KnowledgeGraph, files: {
     path: string;
     content: string;
-}[], astCache: ASTCache, symbolTable: SymbolTable, onProgress?: (current: number, total: number) => void) => Promise<void>;
+}[], astCache: ASTCache, ctx: ResolutionContext, 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, onProgress?: (current: number, total: number) => void) => Promise<void>;
+export declare const processHeritageFromExtracted: (graph: KnowledgeGraph, extractedHeritage: ExtractedHeritage[], ctx: ResolutionContext, onProgress?: (current: number, total: number) => void) => Promise<void>;