gitnexus 1.0.0

package/dist/core/ingestion/entry-point-scoring.js

@@ -0,0 +1,235 @@
+/**
+ * Entry Point Scoring
+ *
+ * Calculates entry point scores for process detection based on:
+ * 1. Call ratio (existing algorithm - callees / (callers + 1))
+ * 2. Export status (exported functions get higher priority)
+ * 3. Name patterns (functions matching entry point patterns like handle*, on*, *Controller)
+ * 4. Framework detection (path-based detection for Next.js, Express, Django, etc.)
+ *
+ * This module is language-agnostic - language-specific patterns are defined per language.
+ */
+import { detectFrameworkFromPath } from './framework-detection.js';
+// ============================================================================
+// NAME PATTERNS - All 9 supported languages
+// ============================================================================
+/**
+ * Common entry point naming patterns by language
+ * These patterns indicate functions that are likely feature entry points
+ */
+const ENTRY_POINT_PATTERNS = {
+    // Universal patterns (apply to all languages)
+    '*': [
+        /^(main|init|bootstrap|start|run|setup|configure)$/i,
+        /^handle[A-Z]/, // handleLogin, handleSubmit
+        /^on[A-Z]/, // onClick, onSubmit
+        /Handler$/, // RequestHandler
+        /Controller$/, // UserController
+        /^process[A-Z]/, // processPayment
+        /^execute[A-Z]/, // executeQuery
+        /^perform[A-Z]/, // performAction
+        /^dispatch[A-Z]/, // dispatchEvent
+        /^trigger[A-Z]/, // triggerAction
+        /^fire[A-Z]/, // fireEvent
+        /^emit[A-Z]/, // emitEvent
+    ],
+    // JavaScript/TypeScript
+    'javascript': [
+        /^use[A-Z]/, // React hooks (useEffect, etc.)
+    ],
+    'typescript': [
+        /^use[A-Z]/, // React hooks
+    ],
+    // Python
+    'python': [
+        /^app$/, // Flask/FastAPI app
+        /^(get|post|put|delete|patch)_/i, // REST conventions
+        /^api_/, // API functions
+        /^view_/, // Django views
+    ],
+    // Java
+    'java': [
+        /^do[A-Z]/, // doGet, doPost (Servlets)
+        /^create[A-Z]/, // Factory patterns
+        /^build[A-Z]/, // Builder patterns
+        /Service$/, // UserService
+    ],
+    // C#
+    'csharp': [
+        /^(Get|Post|Put|Delete)/, // ASP.NET conventions
+        /Action$/, // MVC actions
+        /^On[A-Z]/, // Event handlers
+        /Async$/, // Async entry points
+    ],
+    // Go
+    'go': [
+        /Handler$/, // http.Handler pattern
+        /^Serve/, // ServeHTTP
+        /^New[A-Z]/, // Constructor pattern (returns new instance)
+        /^Make[A-Z]/, // Make functions
+    ],
+    // Rust
+    'rust': [
+        /^(get|post|put|delete)_handler$/i,
+        /^handle_/, // handle_request
+        /^new$/, // Constructor pattern
+        /^run$/, // run entry point
+        /^spawn/, // Async spawn
+    ],
+    // C - explicit main() boost (critical for C programs)
+    'c': [
+        /^main$/, // THE entry point
+        /^init_/, // Initialization functions
+        /^start_/, // Start functions
+        /^run_/, // Run functions
+    ],
+    // C++ - same as C plus class patterns
+    'cpp': [
+        /^main$/, // THE entry point
+        /^init_/,
+        /^Create[A-Z]/, // Factory patterns
+        /^Run$/, // Run methods
+        /^Start$/, // Start methods
+    ],
+};
+// ============================================================================
+// UTILITY PATTERNS - Functions that should be penalized
+// ============================================================================
+/**
+ * Patterns that indicate utility/helper functions (NOT entry points)
+ * These get penalized in scoring
+ */
+const UTILITY_PATTERNS = [
+    /^(get|set|is|has|can|should|will|did)[A-Z]/, // Accessors/predicates
+    /^_/, // Private by convention
+    /^(format|parse|validate|convert|transform)/i, // Transformation utilities
+    /^(log|debug|error|warn|info)$/i, // Logging
+    /^(to|from)[A-Z]/, // Conversions
+    /^(encode|decode)/i, // Encoding utilities
+    /^(serialize|deserialize)/i, // Serialization
+    /^(clone|copy|deep)/i, // Cloning utilities
+    /^(merge|extend|assign)/i, // Object utilities
+    /^(filter|map|reduce|sort|find)/i, // Collection utilities (standalone)
+    /Helper$/,
+    /Util$/,
+    /Utils$/,
+    /^utils?$/i,
+    /^helpers?$/i,
+];
+// ============================================================================
+// MAIN SCORING FUNCTION
+// ============================================================================
+/**
+ * Calculate an entry point score for a function/method
+ *
+ * Higher scores indicate better entry point candidates.
+ * Score = baseScore × exportMultiplier × nameMultiplier
+ *
+ * @param name - Function/method name
+ * @param language - Programming language
+ * @param isExported - Whether the function is exported/public
+ * @param callerCount - Number of functions that call this function
+ * @param calleeCount - Number of functions this function calls
+ * @returns Score and array of reasons explaining the score
+ */
+export function calculateEntryPointScore(name, language, isExported, callerCount, calleeCount, filePath = '' // Optional for backwards compatibility
+) {
+    const reasons = [];
+    // Must have outgoing calls to be an entry point (we need to trace forward)
+    if (calleeCount === 0) {
+        return { score: 0, reasons: ['no-outgoing-calls'] };
+    }
+    // Base score: call ratio (existing algorithm)
+    // High ratio = calls many, called by few = likely entry point
+    const baseScore = calleeCount / (callerCount + 1);
+    reasons.push(`base:${baseScore.toFixed(2)}`);
+    // Export bonus: exported/public functions are more likely entry points
+    const exportMultiplier = isExported ? 2.0 : 1.0;
+    if (isExported) {
+        reasons.push('exported');
+    }
+    // Name pattern scoring
+    let nameMultiplier = 1.0;
+    // Check negative patterns first (utilities get penalized)
+    if (UTILITY_PATTERNS.some(p => p.test(name))) {
+        nameMultiplier = 0.3; // Significant penalty
+        reasons.push('utility-pattern');
+    }
+    else {
+        // Check positive patterns
+        const universalPatterns = ENTRY_POINT_PATTERNS['*'] || [];
+        const langPatterns = ENTRY_POINT_PATTERNS[language] || [];
+        const allPatterns = [...universalPatterns, ...langPatterns];
+        if (allPatterns.some(p => p.test(name))) {
+            nameMultiplier = 1.5; // Bonus for matching entry point pattern
+            reasons.push('entry-pattern');
+        }
+    }
+    // Framework detection bonus (Phase 2)
+    let frameworkMultiplier = 1.0;
+    if (filePath) {
+        const frameworkHint = detectFrameworkFromPath(filePath);
+        if (frameworkHint) {
+            frameworkMultiplier = frameworkHint.entryPointMultiplier;
+            reasons.push(`framework:${frameworkHint.reason}`);
+        }
+    }
+    // Calculate final score
+    const finalScore = baseScore * exportMultiplier * nameMultiplier * frameworkMultiplier;
+    return {
+        score: finalScore,
+        reasons,
+    };
+}
+// ============================================================================
+// HELPER FUNCTIONS
+// ============================================================================
+/**
+ * Check if a file path is a test file (should be excluded from entry points)
+ * Covers common test file patterns across all supported languages
+ */
+export function isTestFile(filePath) {
+    const p = filePath.toLowerCase().replace(/\\/g, '/');
+    return (
+    // JavaScript/TypeScript test patterns
+    p.includes('.test.') ||
+        p.includes('.spec.') ||
+        p.includes('__tests__/') ||
+        p.includes('__mocks__/') ||
+        // Generic test folders
+        p.includes('/test/') ||
+        p.includes('/tests/') ||
+        p.includes('/testing/') ||
+        // Python test patterns
+        p.endsWith('_test.py') ||
+        p.includes('/test_') ||
+        // Go test patterns
+        p.endsWith('_test.go') ||
+        // Java test patterns
+        p.includes('/src/test/') ||
+        // Rust test patterns (inline tests are different, but test files)
+        p.includes('/tests/') ||
+        // C# test patterns
+        p.includes('.tests/') ||
+        p.includes('tests.cs'));
+}
+/**
+ * Check if a file path is likely a utility/helper file
+ * These might still have entry points but should be lower priority
+ */
+export function isUtilityFile(filePath) {
+    const p = filePath.toLowerCase().replace(/\\/g, '/');
+    return (p.includes('/utils/') ||
+        p.includes('/util/') ||
+        p.includes('/helpers/') ||
+        p.includes('/helper/') ||
+        p.includes('/common/') ||
+        p.includes('/shared/') ||
+        p.includes('/lib/') ||
+        p.endsWith('/utils.ts') ||
+        p.endsWith('/utils.js') ||
+        p.endsWith('/helpers.ts') ||
+        p.endsWith('/helpers.js') ||
+        p.endsWith('_utils.py') ||
+        p.endsWith('_helpers.py'));
+}

package/dist/core/ingestion/filesystem-walker.d.ts

@@ -0,0 +1,5 @@
+export interface FileEntry {
+    path: string;
+    content: string;
+}
+export declare const walkRepository: (repoPath: string, onProgress?: (current: number, total: number, filePath: string) => void) => Promise<FileEntry[]>;

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

@@ -0,0 +1,26 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { glob } from 'glob';
+import { shouldIgnorePath } from '../../config/ignore-service.js';
+export const walkRepository = async (repoPath, onProgress) => {
+    const files = await glob('**/*', {
+        cwd: repoPath,
+        nodir: true,
+        dot: false,
+    });
+    const filtered = files.filter(file => !shouldIgnorePath(file));
+    const entries = [];
+    for (let i = 0; i < filtered.length; i++) {
+        const relativePath = filtered[i];
+        const fullPath = path.join(repoPath, relativePath);
+        try {
+            const content = await fs.readFile(fullPath, 'utf-8');
+            entries.push({ path: relativePath.replace(/\\/g, '/'), content });
+            onProgress?.(i + 1, filtered.length, relativePath);
+        }
+        catch {
+            onProgress?.(i + 1, filtered.length, relativePath);
+        }
+    }
+    return entries;
+};

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

@@ -0,0 +1,38 @@
+/**
+ * Framework Detection
+ *
+ * Detects frameworks from file path patterns and provides entry point multipliers.
+ * This enables framework-aware entry point scoring.
+ *
+ * DESIGN: Returns null for unknown frameworks, which causes a 1.0 multiplier
+ * (no bonus, no penalty) - same behavior as before this feature.
+ */
+export interface FrameworkHint {
+    framework: string;
+    entryPointMultiplier: number;
+    reason: string;
+}
+/**
+ * Detect framework from file path patterns
+ *
+ * This provides entry point multipliers based on well-known framework conventions.
+ * Returns null if no framework pattern is detected (falls back to 1.0 multiplier).
+ */
+export declare function detectFrameworkFromPath(filePath: string): FrameworkHint | null;
+/**
+ * Patterns that indicate entry points within code (for future AST-based detection)
+ * These would require parsing decorators/annotations in the code itself.
+ */
+export declare const FRAMEWORK_AST_PATTERNS: {
+    nestjs: string[];
+    express: string[];
+    fastapi: string[];
+    flask: string[];
+    spring: string[];
+    jaxrs: string[];
+    aspnet: string[];
+    'go-http': string[];
+    actix: string[];
+    axum: string[];
+    rocket: string[];
+};

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

@@ -0,0 +1,183 @@
+/**
+ * Framework Detection
+ *
+ * Detects frameworks from file path patterns and provides entry point multipliers.
+ * This enables framework-aware entry point scoring.
+ *
+ * DESIGN: Returns null for unknown frameworks, which causes a 1.0 multiplier
+ * (no bonus, no penalty) - same behavior as before this feature.
+ */
+// ============================================================================
+// PATH-BASED FRAMEWORK DETECTION
+// ============================================================================
+/**
+ * Detect framework from file path patterns
+ *
+ * This provides entry point multipliers based on well-known framework conventions.
+ * Returns null if no framework pattern is detected (falls back to 1.0 multiplier).
+ */
+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; // Add leading slash so patterns like '/app/' match 'app/...'
+    }
+    // ========== JAVASCRIPT / TYPESCRIPT FRAMEWORKS ==========
+    // Next.js - Pages Router (high confidence)
+    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 - they're entry-ish but not the main entry)
+    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 - not all are entry points)
+    if ((p.includes('/components/') || p.includes('/views/')) &&
+        (p.endsWith('.tsx') || p.endsWith('.jsx'))) {
+        // Only boost if PascalCase filename (likely a component, not util)
+        const fileName = p.split('/').pop() || '';
+        if (/^[A-Z]/.test(fileName)) {
+            return { framework: 'react', entryPointMultiplier: 1.5, reason: 'react-component' };
+        }
+    }
+    // ========== PYTHON FRAMEWORKS ==========
+    // Django views (high confidence)
+    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 FRAMEWORKS ==========
+    // 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 (often entry points for business logic)
+    if ((p.includes('/service/') || p.includes('/services/')) && p.endsWith('.java')) {
+        return { framework: 'java-service', entryPointMultiplier: 1.8, reason: 'java-service' };
+    }
+    // ========== C# / .NET FRAMEWORKS ==========
+    // 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' };
+    }
+    // Blazor pages
+    if (p.includes('/pages/') && p.endsWith('.razor')) {
+        return { framework: 'blazor', entryPointMultiplier: 2.5, reason: 'blazor-page' };
+    }
+    // ========== GO FRAMEWORKS ==========
+    // 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 (THE entry point)
+    if (p.endsWith('/main.go') || p.endsWith('/cmd/') && p.endsWith('.go')) {
+        return { framework: 'go', entryPointMultiplier: 3.0, reason: 'go-main' };
+    }
+    // ========== RUST FRAMEWORKS ==========
+    // 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 (THE entry point)
+    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' };
+    }
+    // ========== 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 - return null for graceful fallback (1.0 multiplier)
+    return null;
+}
+// ============================================================================
+// FUTURE: AST-BASED PATTERNS (for Phase 3)
+// ============================================================================
+/**
+ * Patterns that indicate entry points within code (for future AST-based detection)
+ * These would require parsing decorators/annotations in the code itself.
+ */
+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]', '[Route]'],
+    // Go patterns (function signatures)
+    'go-http': ['http.Handler', 'http.HandlerFunc', 'ServeHTTP'],
+    // Rust macros
+    'actix': ['#[get', '#[post', '#[put', '#[delete'],
+    'axum': ['Router::new'],
+    'rocket': ['#[get', '#[post'],
+};

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

@@ -0,0 +1,14 @@
+/**
+ * Heritage Processor
+ *
+ * Extracts class inheritance relationships:
+ * - EXTENDS: Class extends another Class (TS, JS, Python)
+ * - IMPLEMENTS: Class implements an Interface (TS only)
+ */
+import { KnowledgeGraph } from '../graph/types.js';
+import { ASTCache } from './ast-cache.js';
+import { SymbolTable } from './symbol-table.js';
+export declare const processHeritage: (graph: KnowledgeGraph, files: {
+    path: string;
+    content: string;
+}[], astCache: ASTCache, symbolTable: SymbolTable, onProgress?: (current: number, total: number) => void) => Promise<void>;

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

@@ -0,0 +1,134 @@
+/**
+ * Heritage Processor
+ *
+ * Extracts class inheritance relationships:
+ * - EXTENDS: Class extends another Class (TS, JS, Python)
+ * - IMPLEMENTS: Class implements an Interface (TS only)
+ */
+import Parser from 'tree-sitter';
+import { loadParser, loadLanguage } from '../tree-sitter/parser-loader.js';
+import { LANGUAGE_QUERIES } from './tree-sitter-queries.js';
+import { generateId } from '../../lib/utils.js';
+import { getLanguageFromFilename, yieldToEventLoop } from './utils.js';
+export const processHeritage = async (graph, files, astCache, symbolTable, onProgress) => {
+    const parser = await loadParser();
+    for (let i = 0; i < files.length; i++) {
+        const file = files[i];
+        onProgress?.(i + 1, files.length);
+        if (i % 20 === 0)
+            await yieldToEventLoop();
+        // 1. Check language support
+        const language = getLanguageFromFilename(file.path);
+        if (!language)
+            continue;
+        const queryStr = LANGUAGE_QUERIES[language];
+        if (!queryStr)
+            continue;
+        // 2. Load the language
+        await loadLanguage(language, file.path);
+        // 3. Get AST
+        let tree = astCache.get(file.path);
+        let wasReparsed = false;
+        if (!tree) {
+            // Use larger bufferSize for files > 32KB
+            try {
+                tree = parser.parse(file.content, undefined, { bufferSize: 1024 * 256 });
+            }
+            catch (parseError) {
+                // Skip files that can't be parsed
+                continue;
+            }
+            wasReparsed = true;
+        }
+        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);
+            if (wasReparsed)
+                tree.delete?.();
+            continue;
+        }
+        // 4. Process heritage matches
+        matches.forEach(match => {
+            const captureMap = {};
+            match.captures.forEach(c => {
+                captureMap[c.name] = c.node;
+            });
+            // EXTENDS: Class extends another Class
+            if (captureMap['heritage.class'] && captureMap['heritage.extends']) {
+                const className = captureMap['heritage.class'].text;
+                const parentClassName = captureMap['heritage.extends'].text;
+                // Resolve both class IDs
+                const childId = symbolTable.lookupExact(file.path, className) ||
+                    symbolTable.lookupFuzzy(className)[0]?.nodeId ||
+                    generateId('Class', `${file.path}:${className}`);
+                const parentId = symbolTable.lookupFuzzy(parentClassName)[0]?.nodeId ||
+                    generateId('Class', `${parentClassName}`);
+                if (childId && parentId && childId !== parentId) {
+                    const relId = generateId('EXTENDS', `${childId}->${parentId}`);
+                    graph.addRelationship({
+                        id: relId,
+                        sourceId: childId,
+                        targetId: parentId,
+                        type: 'EXTENDS',
+                        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;
+                // Resolve class and interface IDs
+                const classId = symbolTable.lookupExact(file.path, className) ||
+                    symbolTable.lookupFuzzy(className)[0]?.nodeId ||
+                    generateId('Class', `${file.path}:${className}`);
+                const interfaceId = symbolTable.lookupFuzzy(interfaceName)[0]?.nodeId ||
+                    generateId('Interface', `${interfaceName}`);
+                if (classId && interfaceId) {
+                    const relId = generateId('IMPLEMENTS', `${classId}->${interfaceId}`);
+                    graph.addRelationship({
+                        id: relId,
+                        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;
+                // Resolve struct and trait IDs
+                const structId = symbolTable.lookupExact(file.path, structName) ||
+                    symbolTable.lookupFuzzy(structName)[0]?.nodeId ||
+                    generateId('Struct', `${file.path}:${structName}`);
+                const traitId = symbolTable.lookupFuzzy(traitName)[0]?.nodeId ||
+                    generateId('Trait', `${traitName}`);
+                if (structId && traitId) {
+                    const relId = generateId('IMPLEMENTS', `${structId}->${traitId}`);
+                    graph.addRelationship({
+                        id: relId,
+                        sourceId: structId,
+                        targetId: traitId,
+                        type: 'IMPLEMENTS',
+                        confidence: 1.0,
+                        reason: 'trait-impl',
+                    });
+                }
+            }
+        });
+        // Cleanup
+        if (wasReparsed) {
+            tree.delete?.();
+        }
+    }
+};

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

@@ -0,0 +1,8 @@
+import { KnowledgeGraph } from '../graph/types.js';
+import { ASTCache } from './ast-cache.js';
+export type ImportMap = Map<string, Set<string>>;
+export declare const createImportMap: () => ImportMap;
+export declare const processImports: (graph: KnowledgeGraph, files: {
+    path: string;
+    content: string;
+}[], astCache: ASTCache, importMap: ImportMap, onProgress?: (current: number, total: number) => void, repoRoot?: string) => Promise<void>;