gitnexus 1.4.7 → 1.4.9

package/dist/core/ingestion/field-extractors/typescript.js

@@ -0,0 +1,291 @@
+// gitnexus/src/core/ingestion/field-extractors/typescript.ts
+import { SupportedLanguages } from '../../../config/supported-languages.js';
+import { BaseFieldExtractor } from '../field-extractor.js';
+/**
+ * Hand-written TypeScript field extractor.
+ *
+ * This exists alongside the config-based extractor in configs/typescript-javascript.ts
+ * (used for JavaScript) because TypeScript has unique requirements:
+ * 1. type_alias_declaration with object type literals (e.g., type Config = { key: string })
+ * 2. Optional property detection appending '| undefined' to types
+ * 3. Nested type discovery within class/interface bodies
+ *
+ * The config-based extractor cannot express these TS-specific capabilities.
+ * JavaScript uses the config-based version since it lacks type syntax.
+ */
+export class TypeScriptFieldExtractor extends BaseFieldExtractor {
+    language = SupportedLanguages.TypeScript;
+    /**
+     * Node types that represent type declarations with fields in TypeScript
+     */
+    static TYPE_DECLARATION_NODES = new Set([
+        'class_declaration',
+        'interface_declaration',
+        'abstract_class_declaration',
+        'type_alias_declaration', // for object type literals
+    ]);
+    /**
+     * Node types that contain field definitions within class bodies
+     */
+    static FIELD_NODE_TYPES = new Set([
+        'public_field_definition', // class field: private users: User[]
+        'property_signature', // interface property: name: string
+        'field_definition', // fallback field type
+    ]);
+    /**
+     * Visibility modifiers in TypeScript
+     */
+    static VISIBILITY_MODIFIERS = new Set([
+        'public',
+        'private',
+        'protected',
+    ]);
+    /**
+     * Check if this node represents a type declaration with fields
+     */
+    isTypeDeclaration(node) {
+        return TypeScriptFieldExtractor.TYPE_DECLARATION_NODES.has(node.type);
+    }
+    /**
+     * Extract visibility modifier from a field node
+     */
+    extractVisibility(node) {
+        // Check for accessibility_modifier named child (tree-sitter typescript)
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (child && child.type === 'accessibility_modifier') {
+                const text = child.text.trim();
+                if (TypeScriptFieldExtractor.VISIBILITY_MODIFIERS.has(text)) {
+                    return text;
+                }
+            }
+        }
+        // Check for modifiers in the field's unnamed children (fallback)
+        for (let i = 0; i < node.childCount; i++) {
+            const child = node.child(i);
+            if (child && !child.isNamed) {
+                const text = child.text.trim();
+                if (TypeScriptFieldExtractor.VISIBILITY_MODIFIERS.has(text)) {
+                    return text;
+                }
+            }
+        }
+        // Check for modifier node (tree-sitter typescript may group these)
+        const modifiers = node.childForFieldName('modifiers');
+        if (modifiers) {
+            for (let i = 0; i < modifiers.childCount; i++) {
+                const modifier = modifiers.child(i);
+                const modText = modifier?.text.trim();
+                if (modText && TypeScriptFieldExtractor.VISIBILITY_MODIFIERS.has(modText)) {
+                    return modText;
+                }
+            }
+        }
+        // TypeScript class members are public by default
+        return 'public';
+    }
+    /**
+     * Check if a field has the static modifier
+     */
+    isStatic(node) {
+        for (let i = 0; i < node.childCount; i++) {
+            const child = node.child(i);
+            if (child && !child.isNamed && child.text.trim() === 'static') {
+                return true;
+            }
+        }
+        const modifiers = node.childForFieldName('modifiers');
+        if (modifiers) {
+            for (let i = 0; i < modifiers.childCount; i++) {
+                const modifier = modifiers.child(i);
+                if (modifier && modifier.text === 'static') {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    /**
+     * Check if a field has the readonly modifier
+     */
+    isReadonly(node) {
+        for (let i = 0; i < node.childCount; i++) {
+            const child = node.child(i);
+            if (child && !child.isNamed && child.text.trim() === 'readonly') {
+                return true;
+            }
+        }
+        const modifiers = node.childForFieldName('modifiers');
+        if (modifiers) {
+            for (let i = 0; i < modifiers.childCount; i++) {
+                const modifier = modifiers.child(i);
+                if (modifier && modifier.text === 'readonly') {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    /**
+     * Check if a property is optional (has ?: syntax)
+     */
+    isOptional(node) {
+        // Look for the optional marker '?' in unnamed children
+        for (let i = 0; i < node.childCount; i++) {
+            const child = node.child(i);
+            if (child && !child.isNamed && child.text === '?') {
+                return true;
+            }
+        }
+        // Also check for optional_property_signature or marker in type
+        const kind = node.childForFieldName('kind');
+        if (kind && kind.text === '?') {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Extract the full type text, handling complex generic types.
+     *
+     * type_annotation nodes wrap the literal ': SomeType' — only that branch
+     * needs special handling to unwrap the inner child and skip the colon.
+     * All other node kinds are already the type text itself, so normalizeType
+     * is applied directly.
+     */
+    extractFullType(typeNode) {
+        if (!typeNode)
+            return null;
+        if (typeNode.type === 'type_annotation') {
+            const innerType = typeNode.firstNamedChild;
+            return innerType ? this.normalizeType(innerType.text) : null;
+        }
+        return this.normalizeType(typeNode.text);
+    }
+    /**
+     * Extract a single field from a field definition node
+     */
+    extractField(node, context) {
+        // Get the field name
+        const nameNode = node.childForFieldName('name') ?? node.childForFieldName('property');
+        if (!nameNode)
+            return null;
+        const name = nameNode.text;
+        if (!name)
+            return null;
+        // Get the type annotation
+        const typeNode = node.childForFieldName('type');
+        let type = this.extractFullType(typeNode);
+        // Try to resolve the type using the context
+        if (type) {
+            const resolvedType = this.resolveType(type, context);
+            type = resolvedType ?? type;
+        }
+        return {
+            name,
+            type,
+            visibility: this.extractVisibility(node),
+            isStatic: this.isStatic(node),
+            isReadonly: this.isReadonly(node),
+            sourceFile: context.filePath,
+            line: node.startPosition.row + 1,
+        };
+    }
+    /**
+     * Extract fields from a class body or interface body
+     */
+    extractFieldsFromBody(bodyNode, context) {
+        const fields = [];
+        // Find all field definition nodes within the body
+        for (let i = 0; i < bodyNode.namedChildCount; i++) {
+            const child = bodyNode.namedChild(i);
+            if (!child)
+                continue;
+            if (TypeScriptFieldExtractor.FIELD_NODE_TYPES.has(child.type)) {
+                const field = this.extractField(child, context);
+                if (field) {
+                    fields.push(field);
+                }
+            }
+        }
+        return fields;
+    }
+    /**
+     * Extract fields from an object type (used in type aliases)
+     */
+    extractFieldsFromObjectType(objectTypeNode, context) {
+        const fields = [];
+        // Find all property_signature nodes within the object type
+        const propertySignatures = objectTypeNode.descendantsOfType('property_signature');
+        for (const propNode of propertySignatures) {
+            const field = this.extractField(propNode, context);
+            if (field) {
+                // Mark optional properties
+                if (this.isOptional(propNode) && field.type) {
+                    field.type = field.type + ' | undefined';
+                }
+                fields.push(field);
+            }
+        }
+        return fields;
+    }
+    /**
+     * Extract fields from a class or interface declaration
+     */
+    extract(node, context) {
+        if (!this.isTypeDeclaration(node))
+            return null;
+        // Get the type name
+        const nameNode = node.childForFieldName('name');
+        if (!nameNode)
+            return null;
+        const typeName = nameNode.text;
+        const ownerFqn = typeName;
+        const fields = [];
+        const nestedTypes = [];
+        // Handle different declaration types
+        if (node.type === 'class_declaration' || node.type === 'abstract_class_declaration') {
+            // Find the class body
+            const bodyNode = node.childForFieldName('body');
+            if (bodyNode) {
+                const extractedFields = this.extractFieldsFromBody(bodyNode, context);
+                fields.push(...extractedFields);
+            }
+        }
+        else if (node.type === 'interface_declaration') {
+            // Find the interface body
+            const bodyNode = node.childForFieldName('body');
+            if (bodyNode) {
+                const extractedFields = this.extractFieldsFromBody(bodyNode, context);
+                fields.push(...extractedFields);
+            }
+        }
+        else if (node.type === 'type_alias_declaration') {
+            // Handle type aliases with object types
+            const valueNode = node.childForFieldName('value');
+            if (valueNode && valueNode.type === 'object_type') {
+                const extractedFields = this.extractFieldsFromObjectType(valueNode, context);
+                fields.push(...extractedFields);
+            }
+        }
+        // Find nested type declarations
+        const nestedClasses = node.descendantsOfType('class_declaration');
+        const nestedInterfaces = node.descendantsOfType('interface_declaration');
+        const nestedDeclarations = [...nestedClasses, ...nestedInterfaces];
+        for (const nested of nestedDeclarations) {
+            // Skip the current node itself
+            if (nested === node)
+                continue;
+            const nestedName = nested.childForFieldName('name');
+            if (nestedName) {
+                nestedTypes.push(nestedName.text);
+            }
+        }
+        return {
+            ownerFqn,
+            fields,
+            nestedTypes,
+        };
+    }
+}
+// Export a singleton instance for registration
+export const typescriptFieldExtractor = new TypeScriptFieldExtractor();

package/dist/core/ingestion/field-types.d.ts

@@ -0,0 +1,59 @@
+import type { TypeEnvironment } from './type-env.js';
+import type { SymbolTable } from './symbol-table.js';
+import { SupportedLanguages } from '../../config/supported-languages.js';
+/**
+ * Visibility levels used across all supported languages.
+ * - public / private / protected: universal modifiers
+ * - internal: C#, Kotlin (assembly/module scope)
+ * - package: Java (package-private, no keyword)
+ * - fileprivate: Swift (file scope)
+ * - open: Swift (subclassable across modules)
+ */
+export type FieldVisibility = 'public' | 'private' | 'protected' | 'internal' | 'package' | 'fileprivate' | 'open';
+/**
+ * Represents a field or property within a class/struct/interface
+ */
+export interface FieldInfo {
+    /** Field name */
+    name: string;
+    /** Resolved type (may be primitive, FQN, or generic) */
+    type: string | null;
+    /** Visibility modifier */
+    visibility: FieldVisibility;
+    /** Is this a static member? */
+    isStatic: boolean;
+    /** Is this readonly/const? */
+    isReadonly: boolean;
+    /** Source file path */
+    sourceFile: string;
+    /** Line number */
+    line: number;
+}
+/**
+ * Maps owner type FQN to its fields
+ */
+export type FieldTypeMap = Map<string, FieldInfo[]>;
+/**
+ * Context for field extraction
+ */
+export interface FieldExtractorContext {
+    /** Type environment for resolution */
+    typeEnv: TypeEnvironment;
+    /** Symbol table for FQN lookups */
+    symbolTable: SymbolTable;
+    /** Current file path */
+    filePath: string;
+    /** Language ID */
+    language: SupportedLanguages;
+}
+/**
+ * Result of field extraction from a type declaration
+ */
+export interface ExtractedFields {
+    /** Owner type FQN */
+    ownerFqn: string;
+    /** Extracted fields */
+    fields: FieldInfo[];
+    /** Nested types found during extraction */
+    nestedTypes: string[];
+}

package/dist/core/ingestion/field-types.js

@@ -0,0 +1,2 @@
+// gitnexus/src/core/ingestion/field-types.ts
+export {};

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;
@@ -27,6 +28,7 @@ export declare function detectFrameworkFromPath(filePath: string): FrameworkHint
  */
 export declare const FRAMEWORK_AST_PATTERNS: {
     nestjs: string[];
+    'expo-router': string[];
     express: string[];
     fastapi: string[];
     flask: string[];
@@ -37,15 +39,108 @@ export declare const FRAMEWORK_AST_PATTERNS: {
     blazor: string[];
     efcore: string[];
     'go-http': string[];
+    gin: string[];
+    echo: string[];
+    fiber: string[];
+    'go-grpc': string[];
+    prisma: string[];
+    supabase: 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[];
+    flutter: string[];
+    riverpod: string[];
+};
+export declare const AST_FRAMEWORK_PATTERNS_BY_LANGUAGE: {
+    javascript: {
+        framework: string;
+        entryPointMultiplier: number;
+        reason: string;
+        patterns: string[];
+    }[];
+    typescript: {
+        framework: string;
+        entryPointMultiplier: number;
+        reason: string;
+        patterns: string[];
+    }[];
+    python: {
+        framework: string;
+        entryPointMultiplier: number;
+        reason: string;
+        patterns: string[];
+    }[];
+    java: {
+        framework: string;
+        entryPointMultiplier: number;
+        reason: string;
+        patterns: string[];
+    }[];
+    kotlin: {
+        framework: string;
+        entryPointMultiplier: number;
+        reason: string;
+        patterns: string[];
+    }[];
+    csharp: {
+        framework: string;
+        entryPointMultiplier: number;
+        reason: string;
+        patterns: string[];
+    }[];
+    php: {
+        framework: string;
+        entryPointMultiplier: number;
+        reason: string;
+        patterns: string[];
+    }[];
+    go: {
+        framework: string;
+        entryPointMultiplier: number;
+        reason: string;
+        patterns: string[];
+    }[];
+    rust: {
+        framework: string;
+        entryPointMultiplier: number;
+        reason: string;
+        patterns: string[];
+    }[];
+    c: any[];
+    cpp: {
+        framework: string;
+        entryPointMultiplier: number;
+        reason: string;
+        patterns: string[];
+    }[];
+    swift: {
+        framework: string;
+        entryPointMultiplier: number;
+        reason: string;
+        patterns: string[];
+    }[];
+    ruby: {
+        framework: string;
+        entryPointMultiplier: number;
+        reason: string;
+        patterns: string[];
+    }[];
+    dart: {
+        framework: string;
+        entryPointMultiplier: number;
+        reason: string;
+        patterns: string[];
+    }[];
+    cobol: any[];
 };
-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
 // ============================================================================
@@ -41,9 +42,32 @@ export function detectFrameworkFromPath(filePath) {
         return { framework: 'nextjs-api', entryPointMultiplier: 3.0, reason: 'nextjs-api-route' };
     }
     // Next.js - Layout files (moderate - they're entry-ish but not the main entry)
-    if (p.includes('/app/') && (p.endsWith('layout.tsx') || p.endsWith('layout.ts'))) {
+    if (p.includes('/app/') && !p.includes('_layout') && (p.endsWith('layout.tsx') || p.endsWith('layout.ts'))) {
         return { framework: 'nextjs-app', entryPointMultiplier: 2.0, reason: 'nextjs-layout' };
     }
+    // Expo Router - screen/layout/api files in app/ directory
+    if (p.includes('/app/') && (p.endsWith('.tsx') || p.endsWith('.ts') || p.endsWith('.jsx') || p.endsWith('.js'))) {
+        const fn = p.split('/').pop() || '';
+        if (fn.startsWith('_layout')) {
+            return { framework: 'expo-router', entryPointMultiplier: 2.0, reason: 'expo-layout' };
+        }
+        if (fn.startsWith('+') && !fn.startsWith('+api')) {
+            return { framework: 'expo-router', entryPointMultiplier: 1.5, reason: 'expo-special-route' };
+        }
+        if (fn.endsWith('+api.ts') || fn.endsWith('+api.tsx')) {
+            return { framework: 'expo-router', entryPointMultiplier: 3.0, reason: 'expo-api-route' };
+        }
+        return { framework: 'expo-router', entryPointMultiplier: 2.5, reason: 'expo-screen' };
+    }
+    // Prisma schema (ORM data model definition)
+    if (p.includes('/prisma/') && p.endsWith('schema.prisma')) {
+        return { framework: 'prisma', entryPointMultiplier: 1.5, reason: 'prisma-schema' };
+    }
+    // Supabase client files
+    if ((p.includes('/lib/supabase') || p.includes('/utils/supabase') || p.includes('/supabase/')) &&
+        (p.endsWith('.ts') || p.endsWith('.js'))) {
+        return { framework: 'supabase', entryPointMultiplier: 1.5, reason: 'supabase-client' };
+    }
     // Express / Node.js routes
     if (p.includes('/routes/') && (p.endsWith('.ts') || p.endsWith('.js'))) {
         return { framework: 'express', entryPointMultiplier: 2.5, reason: 'routes-folder' };
@@ -180,8 +204,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 ==========
@@ -301,6 +325,31 @@ export function detectFrameworkFromPath(filePath) {
     if (p.includes('/router/') && p.endsWith('.swift')) {
         return { framework: 'ios-router', entryPointMultiplier: 2.0, reason: 'ios-router' };
     }
+    // ========== DART / FLUTTER ==========
+    // Flutter main/app entry points
+    if (p.endsWith('/main.dart') || p.endsWith('/app.dart')) {
+        return { framework: 'flutter', entryPointMultiplier: 3.0, reason: 'flutter-main' };
+    }
+    // Flutter screens/pages/views (high priority - route entry points)
+    if ((p.includes('/screens/') || p.includes('/pages/') || p.includes('/views/')) && p.endsWith('.dart')) {
+        return { framework: 'flutter', entryPointMultiplier: 2.5, reason: 'flutter-screen' };
+    }
+    // Flutter routes
+    if (p.includes('/routes/') && p.endsWith('.dart')) {
+        return { framework: 'flutter', entryPointMultiplier: 2.5, reason: 'flutter-routes' };
+    }
+    // Flutter BLoC / controllers / presentation (state management entry points)
+    if ((p.includes('/bloc/') || p.includes('/controllers/') || p.includes('/cubit/') || p.includes('/presentation/')) && p.endsWith('.dart')) {
+        return { framework: 'flutter', entryPointMultiplier: 2.0, reason: 'flutter-state-management' };
+    }
+    // Flutter services / domain
+    if ((p.includes('/services/') || p.includes('/domain/')) && p.endsWith('.dart')) {
+        return { framework: 'flutter', entryPointMultiplier: 1.8, reason: 'flutter-service' };
+    }
+    // Flutter widgets (reusable components)
+    if (p.includes('/widgets/') && p.endsWith('.dart')) {
+        return { framework: 'flutter', entryPointMultiplier: 1.5, reason: 'flutter-widget' };
+    }
     // ========== GENERIC PATTERNS ==========
     // Any language: index files in API folders
     if (p.includes('/api/') && (p.endsWith('/index.ts') || p.endsWith('/index.js') ||
@@ -320,6 +369,7 @@ export function detectFrameworkFromPath(filePath) {
 export const FRAMEWORK_AST_PATTERNS = {
     // JavaScript/TypeScript decorators
     'nestjs': ['@Controller', '@Get', '@Post', '@Put', '@Delete', '@Patch'],
+    'expo-router': ['router.push', 'router.replace', 'router.navigate', 'useRouter', 'useLocalSearchParams', 'useSegments', 'expo-router'],
     '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'],
@@ -333,27 +383,46 @@ 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'],
+    // ORM patterns
+    'prisma': ['prisma.', 'PrismaClient', '@prisma/client'],
+    'supabase': ['supabase.from', 'createClient', '@supabase/supabase-js'],
     // 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'],
+    // Dart/Flutter
+    'flutter': ['StatelessWidget', 'StatefulWidget', 'BuildContext', 'Widget build',
+        'ChangeNotifier', 'GetxController', 'Cubit<', 'Bloc<', 'ConsumerWidget'],
+    'riverpod': ['@riverpod', 'ref.watch', 'ref.read', 'AsyncNotifier', 'Notifier'],
 };
-import { SupportedLanguages } from '../../config/supported-languages.js';
-const AST_FRAMEWORK_PATTERNS_BY_LANGUAGE = {
+export const AST_FRAMEWORK_PATTERNS_BY_LANGUAGE = {
     [SupportedLanguages.JavaScript]: [
         { framework: 'nestjs', entryPointMultiplier: 3.2, reason: 'nestjs-decorator', patterns: FRAMEWORK_AST_PATTERNS.nestjs },
+        { framework: 'expo-router', entryPointMultiplier: 2.5, reason: 'expo-router-navigation', patterns: FRAMEWORK_AST_PATTERNS['expo-router'] },
     ],
     [SupportedLanguages.TypeScript]: [
         { framework: 'nestjs', entryPointMultiplier: 3.2, reason: 'nestjs-decorator', patterns: FRAMEWORK_AST_PATTERNS.nestjs },
+        { framework: 'expo-router', entryPointMultiplier: 2.5, reason: 'expo-router-navigation', patterns: FRAMEWORK_AST_PATTERNS['expo-router'] },
     ],
     [SupportedLanguages.Python]: [
         { framework: 'fastapi', entryPointMultiplier: 3.0, reason: 'fastapi-decorator', patterns: FRAMEWORK_AST_PATTERNS.fastapi },
@@ -378,6 +447,37 @@ 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 },
+    ],
+    [SupportedLanguages.Dart]: [
+        { framework: 'flutter', entryPointMultiplier: 2.5, reason: 'flutter-widget', patterns: FRAMEWORK_AST_PATTERNS.flutter },
+        { framework: 'riverpod', entryPointMultiplier: 2.8, reason: 'riverpod-pattern', patterns: FRAMEWORK_AST_PATTERNS.riverpod },
+    ],
+    [SupportedLanguages.Cobol]: [], // Standalone regex processor — no AST framework patterns
 };
 /** 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]) => [