gitnexus 1.4.8 → 1.4.10

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

@@ -28,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[];
@@ -42,6 +43,8 @@ export declare const FRAMEWORK_AST_PATTERNS: {
     echo: string[];
     fiber: string[];
     'go-grpc': string[];
+    prisma: string[];
+    supabase: string[];
     laravel: string[];
     actix: string[];
     axum: string[];
@@ -53,6 +56,90 @@ export declare const FRAMEWORK_AST_PATTERNS: {
     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[];
 };
 /**
  * Detect framework entry points from AST definition text (decorators/annotations/attributes).

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

@@ -42,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' };
@@ -302,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') ||
@@ -321,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'],
@@ -340,6 +389,9 @@ export const FRAMEWORK_AST_PATTERNS = {
     '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('],
@@ -358,13 +410,19 @@ export const FRAMEWORK_AST_PATTERNS = {
     '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'],
 };
-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 },
@@ -415,6 +473,11 @@ const AST_FRAMEWORK_PATTERNS_BY_LANGUAGE = {
         { 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]) => [

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

@@ -15,20 +15,19 @@
  */
 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 { getLanguageFromFilename } from './utils/language-detection.js';
+import { isVerboseIngestionEnabled } from './utils/verbose.js';
+import { yieldToEventLoop } from './utils/event-loop.js';
+import { getProvider } from './languages/index.js';
 import { getTreeSitterBufferSize } from './constants.js';
 import { TIER_CONFIDENCE } from './resolution-context.js';
-/** C#/Java convention: interfaces start with I followed by an uppercase letter */
-const INTERFACE_NAME_RE = /^I[A-Z]/;
 /**
  * Determine whether a heritage.extends capture is actually an IMPLEMENTS relationship.
- * Uses the symbol table first (authoritative — Tier 1); falls back to a language-gated
- * heuristic for external symbols not present in the graph:
- *   - C# / Java: `I[A-Z]` naming convention
- *   - Swift: default IMPLEMENTS (protocol conformance is the norm)
+ * Uses the symbol table first (authoritative — Tier 1); falls back to provider-defined
+ * heuristics for external symbols not present in the graph:
+ *   - interfaceNamePattern: matched against parent name (e.g., /^I[A-Z]/ for C#/Java)
+ *   - heritageDefaultEdge: 'IMPLEMENTS' causes all unresolved parents to map to IMPLEMENTS
  *   - All others: default EXTENDS
  */
 const resolveExtendsType = (parentName, currentFilePath, ctx, language) => {
@@ -39,14 +38,12 @@ const resolveExtendsType = (parentName, currentFilePath, ctx, language) => {
             ? { 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' };
-        }
+    // Unresolved symbol — fall back to provider-defined heuristics
+    const provider = getProvider(language);
+    if (provider.interfaceNamePattern?.test(parentName)) {
+        return { type: 'IMPLEMENTS', idPrefix: 'Interface' };
     }
-    else if (language === SupportedLanguages.Swift) {
-        // Protocol conformance is far more common than class inheritance in Swift
+    if (provider.heritageDefaultEdge === 'IMPLEMENTS') {
         return { type: 'IMPLEMENTS', idPrefix: 'Interface' };
     }
     return { type: 'EXTENDS', idPrefix: 'Class' };
@@ -82,7 +79,8 @@ export const processHeritage = async (graph, files, astCache, ctx, onProgress) =
             }
             continue;
         }
-        const queryStr = LANGUAGE_QUERIES[language];
+        const provider = getProvider(language);
+        const queryStr = provider.treeSitterQueries;
         if (!queryStr)
             continue;
         // 2. Load the language

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

@@ -1,9 +1,10 @@
 import { KnowledgeGraph } from '../graph/types.js';
 import { ASTCache } from './ast-cache.js';
+import type { LanguageProvider } from './language-provider.js';
 import type { ExtractedImport } from './workers/parse-worker.js';
 import type { ResolutionContext } from './resolution-context.js';
-import type { SuffixIndex } from './resolvers/index.js';
-export type { SuffixIndex, TsconfigPaths, GoModuleConfig, CSharpProjectConfig, ComposerConfig } from './resolvers/index.js';
+import type { ImportResolutionContext } from './import-resolvers/types.js';
+import type { SyntaxNode } from './utils/ast-helpers.js';
 export type ImportMap = Map<string, Set<string>>;
 export type PackageMap = Map<string, Set<string>>;
 export interface NamedImportBinding {
@@ -16,15 +17,13 @@ export type NamedImportMap = Map<string, Map<string, NamedImportBinding>>;
  * Used by the symbol resolver for Go and C# directory-level import matching.
  */
 export declare function isFileInPackageDir(filePath: string, dirSuffix: string): boolean;
-/** Pre-built lookup structures for import resolution. Build once, reuse across chunks. */
-export interface ImportResolutionContext {
-    allFilePaths: Set<string>;
-    allFileList: string[];
-    normalizedFileList: string[];
-    index: SuffixIndex;
-    resolveCache: Map<string, string | null>;
-}
 export declare function buildImportResolutionContext(allPaths: string[]): ImportResolutionContext;
+/**
+ * Clean and preprocess a raw import source text into a resolved import path.
+ * Strips quotes/angle brackets (universal) and applies provider-specific
+ * transformations (currently only Kotlin wildcard import detection).
+ */
+export declare function preprocessImportPath(sourceText: string, importNode: SyntaxNode, provider: LanguageProvider): string | null;
 export declare const processImports: (graph: KnowledgeGraph, files: {
     path: string;
     content: string;