@zuvia-software-solutions/code-mapper 1.4.0

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

@@ -0,0 +1,405 @@
+// code-mapper/src/core/ingestion/framework-detection.ts
+/** @file framework-detection.ts @description Detects frameworks from file path patterns and AST definition text (decorators/annotations/attributes), returning entry point multipliers for process scoring. Returns null for unknown frameworks, yielding a 1.0 multiplier (no bonus, no penalty) */
+/** Detect framework from file path conventions, returning an entry point multiplier or null */
+export function detectFrameworkFromPath(filePath) {
+    // Normalize path separators and ensure leading slash for consistent matching
+    let p = filePath.toLowerCase().replace(/\\/g, '/');
+    if (!p.startsWith('/')) {
+        p = '/' + p;
+    }
+    // -- JavaScript / TypeScript --
+    // Next.js - Pages Router
+    if (p.includes('/pages/') && !p.includes('/_') && !p.includes('/api/')) {
+        if (p.endsWith('.tsx') || p.endsWith('.ts') || p.endsWith('.jsx') || p.endsWith('.js')) {
+            return { framework: 'nextjs-pages', entryPointMultiplier: 3.0, reason: 'nextjs-page' };
+        }
+    }
+    // Next.js - App Router (page.tsx files)
+    if (p.includes('/app/') && (p.endsWith('page.tsx') || p.endsWith('page.ts') ||
+        p.endsWith('page.jsx') || p.endsWith('page.js'))) {
+        return { framework: 'nextjs-app', entryPointMultiplier: 3.0, reason: 'nextjs-app-page' };
+    }
+    // Next.js - API Routes
+    if (p.includes('/pages/api/') || (p.includes('/app/') && p.includes('/api/') && p.endsWith('route.ts'))) {
+        return { framework: 'nextjs-api', entryPointMultiplier: 3.0, reason: 'nextjs-api-route' };
+    }
+    // Next.js - Layout files (moderate boost)
+    if (p.includes('/app/') && (p.endsWith('layout.tsx') || p.endsWith('layout.ts'))) {
+        return { framework: 'nextjs-app', entryPointMultiplier: 2.0, reason: 'nextjs-layout' };
+    }
+    // Express / Node.js routes
+    if (p.includes('/routes/') && (p.endsWith('.ts') || p.endsWith('.js'))) {
+        return { framework: 'express', entryPointMultiplier: 2.5, reason: 'routes-folder' };
+    }
+    // Generic controllers (MVC pattern)
+    if (p.includes('/controllers/') && (p.endsWith('.ts') || p.endsWith('.js'))) {
+        return { framework: 'mvc', entryPointMultiplier: 2.5, reason: 'controllers-folder' };
+    }
+    // Generic handlers
+    if (p.includes('/handlers/') && (p.endsWith('.ts') || p.endsWith('.js'))) {
+        return { framework: 'handlers', entryPointMultiplier: 2.5, reason: 'handlers-folder' };
+    }
+    // React components (lower priority)
+    if ((p.includes('/components/') || p.includes('/views/')) &&
+        (p.endsWith('.tsx') || p.endsWith('.jsx'))) {
+        // Only boost PascalCase filenames (likely a component, not a util)
+        const fileName = p.split('/').pop() || '';
+        if (/^[A-Z]/.test(fileName)) {
+            return { framework: 'react', entryPointMultiplier: 1.5, reason: 'react-component' };
+        }
+    }
+    // -- Python --
+    // Django views
+    if (p.endsWith('views.py')) {
+        return { framework: 'django', entryPointMultiplier: 3.0, reason: 'django-views' };
+    }
+    // Django URL configs
+    if (p.endsWith('urls.py')) {
+        return { framework: 'django', entryPointMultiplier: 2.0, reason: 'django-urls' };
+    }
+    // FastAPI / Flask routers
+    if ((p.includes('/routers/') || p.includes('/endpoints/') || p.includes('/routes/')) &&
+        p.endsWith('.py')) {
+        return { framework: 'fastapi', entryPointMultiplier: 2.5, reason: 'api-routers' };
+    }
+    // Python API folder
+    if (p.includes('/api/') && p.endsWith('.py') && !p.endsWith('__init__.py')) {
+        return { framework: 'python-api', entryPointMultiplier: 2.0, reason: 'api-folder' };
+    }
+    // -- Java --
+    // Spring Boot controllers
+    if ((p.includes('/controller/') || p.includes('/controllers/')) && p.endsWith('.java')) {
+        return { framework: 'spring', entryPointMultiplier: 3.0, reason: 'spring-controller' };
+    }
+    // Spring Boot - files ending in Controller.java
+    if (p.endsWith('controller.java')) {
+        return { framework: 'spring', entryPointMultiplier: 3.0, reason: 'spring-controller-file' };
+    }
+    // Java service layer
+    if ((p.includes('/service/') || p.includes('/services/')) && p.endsWith('.java')) {
+        return { framework: 'java-service', entryPointMultiplier: 1.8, reason: 'java-service' };
+    }
+    // -- Kotlin --
+    // 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 --
+    // ASP.NET Controllers
+    if (p.includes('/controllers/') && p.endsWith('.cs')) {
+        return { framework: 'aspnet', entryPointMultiplier: 3.0, reason: 'aspnet-controller' };
+    }
+    // ASP.NET - files ending in Controller.cs
+    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' };
+    }
+    // -- Go --
+    // Go handlers
+    if ((p.includes('/handlers/') || p.includes('/handler/')) && p.endsWith('.go')) {
+        return { framework: 'go-http', entryPointMultiplier: 2.5, reason: 'go-handlers' };
+    }
+    // Go routes
+    if (p.includes('/routes/') && p.endsWith('.go')) {
+        return { framework: 'go-http', entryPointMultiplier: 2.5, reason: 'go-routes' };
+    }
+    // Go controllers
+    if (p.includes('/controllers/') && p.endsWith('.go')) {
+        return { framework: 'go-mvc', entryPointMultiplier: 2.5, reason: 'go-controller' };
+    }
+    // Go main.go files
+    if (p.endsWith('/main.go') || p.endsWith('/cmd/') && p.endsWith('.go')) {
+        return { framework: 'go', entryPointMultiplier: 3.0, reason: 'go-main' };
+    }
+    // -- Rust --
+    // Rust handlers/routes
+    if ((p.includes('/handlers/') || p.includes('/routes/')) && p.endsWith('.rs')) {
+        return { framework: 'rust-web', entryPointMultiplier: 2.5, reason: 'rust-handlers' };
+    }
+    // Rust main.rs
+    if (p.endsWith('/main.rs')) {
+        return { framework: 'rust', entryPointMultiplier: 3.0, reason: 'rust-main' };
+    }
+    // Rust bin folder (executables)
+    if (p.includes('/bin/') && p.endsWith('.rs')) {
+        return { framework: 'rust', entryPointMultiplier: 2.5, reason: 'rust-bin' };
+    }
+    // -- C / C++ --
+    // C/C++ main files
+    if (p.endsWith('/main.c') || p.endsWith('/main.cpp') || p.endsWith('/main.cc')) {
+        return { framework: 'c-cpp', entryPointMultiplier: 3.0, reason: 'c-main' };
+    }
+    // C/C++ src folder entry points (if named specifically)
+    if ((p.includes('/src/') && (p.endsWith('/app.c') || p.endsWith('/app.cpp')))) {
+        return { framework: 'c-cpp', entryPointMultiplier: 2.5, reason: 'c-app' };
+    }
+    // -- PHP / Laravel --
+    // Laravel routes (highest priority)
+    if (p.includes('/routes/') && p.endsWith('.php')) {
+        return { framework: 'laravel', entryPointMultiplier: 3.0, reason: 'laravel-routes' };
+    }
+    // Laravel controllers
+    if ((p.includes('/http/controllers/') || p.includes('/controllers/')) && p.endsWith('.php')) {
+        return { framework: 'laravel', entryPointMultiplier: 3.0, reason: 'laravel-controller' };
+    }
+    // Laravel controller by file name convention
+    if (p.endsWith('controller.php')) {
+        return { framework: 'laravel', entryPointMultiplier: 3.0, reason: 'laravel-controller-file' };
+    }
+    // Laravel console commands
+    if ((p.includes('/console/commands/') || p.includes('/commands/')) && p.endsWith('.php')) {
+        return { framework: 'laravel', entryPointMultiplier: 2.5, reason: 'laravel-command' };
+    }
+    // Laravel jobs
+    if (p.includes('/jobs/') && p.endsWith('.php')) {
+        return { framework: 'laravel', entryPointMultiplier: 2.5, reason: 'laravel-job' };
+    }
+    // Laravel listeners
+    if (p.includes('/listeners/') && p.endsWith('.php')) {
+        return { framework: 'laravel', entryPointMultiplier: 2.5, reason: 'laravel-listener' };
+    }
+    // Laravel middleware
+    if (p.includes('/http/middleware/') && p.endsWith('.php')) {
+        return { framework: 'laravel', entryPointMultiplier: 2.5, reason: 'laravel-middleware' };
+    }
+    // Laravel service providers
+    if (p.includes('/providers/') && p.endsWith('.php')) {
+        return { framework: 'laravel', entryPointMultiplier: 1.8, reason: 'laravel-provider' };
+    }
+    // Laravel policies
+    if (p.includes('/policies/') && p.endsWith('.php')) {
+        return { framework: 'laravel', entryPointMultiplier: 2.0, reason: 'laravel-policy' };
+    }
+    // Laravel models
+    if (p.includes('/models/') && p.endsWith('.php')) {
+        return { framework: 'laravel', entryPointMultiplier: 1.5, reason: 'laravel-model' };
+    }
+    // Laravel services
+    if (p.includes('/services/') && p.endsWith('.php')) {
+        return { framework: 'laravel', entryPointMultiplier: 1.8, reason: 'laravel-service' };
+    }
+    // Laravel repositories
+    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
+    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
+    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
+    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
+    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') ||
+        p.endsWith('/__init__.py'))) {
+        return { framework: 'api', entryPointMultiplier: 1.8, reason: 'api-index' };
+    }
+    // No framework detected — null yields 1.0 multiplier
+    return null;
+}
+// Patterns matched against AST node text (class/method/function declaration text)
+export const FRAMEWORK_AST_PATTERNS = {
+    // JavaScript/TypeScript decorators
+    'nestjs': ['@Controller', '@Get', '@Post', '@Put', '@Delete', '@Patch'],
+    'express': ['app.get', 'app.post', 'app.put', 'app.delete', 'router.get', 'router.post'],
+    // Python decorators
+    'fastapi': ['@app.get', '@app.post', '@app.put', '@app.delete', '@router.get'],
+    'flask': ['@app.route', '@blueprint.route'],
+    // Java annotations
+    'spring': ['@RestController', '@Controller', '@GetMapping', '@PostMapping', '@RequestMapping'],
+    'jaxrs': ['@Path', '@GET', '@POST', '@PUT', '@DELETE'],
+    // C# attributes
+    '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
+    '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'],
+    // Swift/iOS
+    'uikit': ['viewDidLoad', 'viewWillAppear', 'viewDidAppear', 'UIViewController'],
+    'swiftui': ['@main', 'WindowGroup', 'ContentView', '@StateObject', '@ObservedObject'],
+    'combine': ['sink', 'assign', 'Publisher', 'Subscriber'],
+    // DI framework decorators/annotations (entryPointMultiplier 1.0 — not entry points, just DI metadata)
+    'nestjs-di': ['@Injectable'],
+    'angular-di': ['@Injectable', '@NgModule'],
+    'spring-di': ['@Service', '@Component', '@Repository', '@Bean', '@Configuration', '@Autowired'],
+    'dagger-di': ['@Inject', '@Provides', '@Module'],
+    'aspnet-di': ['AddScoped', 'AddTransient', 'AddSingleton'],
+    'python-di': ['@inject', '@provider'],
+};
+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 },
+        { framework: 'nestjs-di', entryPointMultiplier: 1.0, reason: 'nestjs-di-injectable', patterns: FRAMEWORK_AST_PATTERNS['nestjs-di'] },
+    ],
+    [SupportedLanguages.TypeScript]: [
+        { framework: 'nestjs', entryPointMultiplier: 3.2, reason: 'nestjs-decorator', patterns: FRAMEWORK_AST_PATTERNS.nestjs },
+        { framework: 'nestjs-di', entryPointMultiplier: 1.0, reason: 'nestjs-di-injectable', patterns: FRAMEWORK_AST_PATTERNS['nestjs-di'] },
+        { framework: 'angular-di', entryPointMultiplier: 1.0, reason: 'angular-di-injectable', patterns: FRAMEWORK_AST_PATTERNS['angular-di'] },
+    ],
+    [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 },
+        { framework: 'python-di', entryPointMultiplier: 1.0, reason: 'python-di-decorator', patterns: FRAMEWORK_AST_PATTERNS['python-di'] },
+    ],
+    [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 },
+        { framework: 'spring-di', entryPointMultiplier: 1.0, reason: 'spring-di-bean', patterns: FRAMEWORK_AST_PATTERNS['spring-di'] },
+        { framework: 'dagger-di', entryPointMultiplier: 1.0, reason: 'dagger-di-provides', patterns: FRAMEWORK_AST_PATTERNS['dagger-di'] },
+    ],
+    [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('] },
+        { framework: 'spring-di', entryPointMultiplier: 1.0, reason: 'spring-di-bean', patterns: FRAMEWORK_AST_PATTERNS['spring-di'] },
+        { framework: 'dagger-di', entryPointMultiplier: 1.0, reason: 'dagger-di-provides', patterns: FRAMEWORK_AST_PATTERNS['dagger-di'] },
+    ],
+    [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 },
+        { framework: 'aspnet-di', entryPointMultiplier: 1.0, reason: 'aspnet-di-registration', patterns: FRAMEWORK_AST_PATTERNS['aspnet-di'] },
+    ],
+    [SupportedLanguages.PHP]: [
+        { framework: 'laravel', entryPointMultiplier: 3.0, reason: 'php-route-attribute', patterns: FRAMEWORK_AST_PATTERNS.laravel },
+    ],
+};
+// Pre-lowercased patterns for O(1) 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)
+ * @param language - Source language
+ * @param definitionText - AST node text (callers should slice to ~300 chars)
+ * @returns FrameworkHint or null if no known pattern matches
+ */
+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

@@ -0,0 +1,15 @@
+/** @file heritage-processor.ts @description Extracts class inheritance relationships (EXTENDS/IMPLEMENTS) from AST matches. Resolves the correct edge type via symbol table lookup, falling back to language-gated heuristics for unresolved symbols: C#/Java use I[A-Z] convention, Swift defaults to IMPLEMENTS, all others default to EXTENDS */
+import { KnowledgeGraph } from '../graph/types.js';
+import { ASTCache } from './ast-cache.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, ctx: ResolutionContext, onProgress?: (current: number, total: number) => void) => Promise<void>;
+/**
+ * Fast path: resolve pre-extracted heritage from workers
+ *
+ * No AST parsing needed — workers already extracted className, parentName, and kind
+ */
+export declare const processHeritageFromExtracted: (graph: KnowledgeGraph, extractedHeritage: ExtractedHeritage[], ctx: ResolutionContext, onProgress?: (current: number, total: number) => void) => Promise<void>;

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

@@ -0,0 +1,237 @@
+// code-mapper/src/core/ingestion/heritage-processor.ts
+/** @file heritage-processor.ts @description Extracts class inheritance relationships (EXTENDS/IMPLEMENTS) from AST matches. Resolves the correct edge type via symbol table lookup, falling back to language-gated heuristics for unresolved symbols: C#/Java use I[A-Z] convention, Swift defaults to IMPLEMENTS, all others default to EXTENDS */
+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 { getTreeSitterBufferSize } from './constants.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 IMPLEMENTS
+ *
+ * Uses symbol table first (authoritative); falls back to language-gated heuristics
+ * for unresolved symbols (C#/Java: I[A-Z], Swift: default IMPLEMENTS, others: EXTENDS)
+ */
+const resolveExtendsType = (parentName, currentFilePath, ctx, language) => {
+    const resolved = ctx.resolve(parentName, currentFilePath);
+    if (resolved && resolved.candidates.length > 0) {
+        const isInterface = resolved.candidates[0].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 more common than class inheritance in Swift
+        return { type: 'IMPLEMENTS', idPrefix: 'Interface' };
+    }
+    return { type: 'EXTENDS', idPrefix: 'Class' };
+};
+/**
+ * Resolve a symbol ID for heritage, falling back to a generated ID
+ *
+ * Tries ctx.resolve() first, then falls back to generateId()
+ */
+const resolveHeritageId = (name, filePath, ctx, fallbackLabel, fallbackKey) => {
+    const resolved = ctx.resolve(name, filePath);
+    if (resolved && resolved.candidates.length > 0) {
+        // Refuse ambiguous global matches — a wrong edge is worse than no edge
+        if (resolved.tier === 'global' && resolved.candidates.length > 1) {
+            return generateId(fallbackLabel, fallbackKey ?? name);
+        }
+        return resolved.candidates[0].nodeId;
+    }
+    return generateId(fallbackLabel, fallbackKey ?? name);
+};
+export const processHeritage = async (graph, files, astCache, ctx, 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);
+        if (i % 20 === 0)
+            await yieldToEventLoop();
+        // Check language support
+        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;
+        // Load the language
+        await loadLanguage(language, file.path);
+        // Get AST
+        let tree = astCache.get(file.path);
+        if (!tree) {
+            try {
+                tree = parser.parse(file.content, undefined, { bufferSize: getTreeSitterBufferSize(file.content.length) });
+            }
+            catch (parseError) {
+                // Skip files that can't be parsed
+                continue;
+            }
+            // Cache re-parsed tree for future phases
+            astCache.set(file.path, tree);
+        }
+        let query;
+        let matches;
+        try {
+            const language = parser.getLanguage();
+            query = new Parser.Query(language, queryStr);
+            matches = query.matches(tree.rootNode);
+        }
+        catch (queryError) {
+            console.warn(`Heritage query error for ${file.path}:`, queryError);
+            continue;
+        }
+        // Process heritage matches
+        matches.forEach(match => {
+            const captureMap = {};
+            match.captures.forEach(c => {
+                captureMap[c.name] = c.node;
+            });
+            // EXTENDS or IMPLEMENTS: resolve via symbol table for languages
+            // where tree-sitter 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;
+                }
+                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) {
+                    graph.addRelationship({
+                        id: generateId(relType, `${childId}->${parentId}`),
+                        sourceId: childId,
+                        targetId: parentId,
+                        type: relType,
+                        confidence: 1.0,
+                        reason: '',
+                    });
+                }
+            }
+            // IMPLEMENTS: Class implements Interface (TypeScript only)
+            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) {
+                    graph.addRelationship({
+                        id: generateId('IMPLEMENTS', `${classId}->${interfaceId}`),
+                        sourceId: classId,
+                        targetId: interfaceId,
+                        type: 'IMPLEMENTS',
+                        confidence: 1.0,
+                        reason: '',
+                    });
+                }
+            }
+            // IMPLEMENTS (Rust): impl Trait for Struct
+            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) {
+                    graph.addRelationship({
+                        id: generateId('IMPLEMENTS', `${structId}->${traitId}`),
+                        sourceId: structId,
+                        targetId: traitId,
+                        type: 'IMPLEMENTS',
+                        confidence: 1.0,
+                        reason: 'trait-impl',
+                    });
+                }
+            }
+        });
+        // Tree 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 needed — workers already extracted className, parentName, and kind
+ */
+export const processHeritageFromExtracted = async (graph, extractedHeritage, ctx, onProgress) => {
+    const total = extractedHeritage.length;
+    for (let i = 0; i < extractedHeritage.length; i++) {
+        if (i % 500 === 0) {
+            onProgress?.(i, total);
+            await yieldToEventLoop();
+        }
+        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, 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) {
+                graph.addRelationship({
+                    id: generateId(relType, `${childId}->${parentId}`),
+                    sourceId: childId,
+                    targetId: parentId,
+                    type: relType,
+                    confidence: 1.0,
+                    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) {
+                graph.addRelationship({
+                    id: generateId('IMPLEMENTS', `${classId}->${interfaceId}`),
+                    sourceId: classId,
+                    targetId: interfaceId,
+                    type: 'IMPLEMENTS',
+                    confidence: 1.0,
+                    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) {
+                graph.addRelationship({
+                    id: generateId('IMPLEMENTS', `${structId}->${traitId}:${h.kind}`),
+                    sourceId: structId,
+                    targetId: traitId,
+                    type: 'IMPLEMENTS',
+                    confidence: 1.0,
+                    reason: h.kind,
+                });
+            }
+        }
+    }
+    onProgress?.(total, total);
+};