gitnexus 1.4.0 → 1.4.5

package/dist/core/ingestion/call-routing.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Shared Ruby call routing logic.
+ *
+ * Ruby expresses imports, heritage (mixins), and property definitions as
+ * method calls rather than syntax-level constructs. This module provides a
+ * routing function used by the CLI call-processor, CLI parse-worker, and
+ * the web call-processor so that the classification logic lives in one place.
+ *
+ * NOTE: This file is intentionally duplicated in gitnexus-web/ because the
+ * two packages have separate build targets (Node native vs WASM/browser).
+ * Keep both copies in sync until a shared package is introduced.
+ */
+import { SupportedLanguages } from '../../config/supported-languages.js';
+/** null = this call was not routed; fall through to default call handling */
+export type CallRoutingResult = RubyCallRouting | null;
+export type CallRouter = (calledName: string, callNode: any) => CallRoutingResult;
+/** Per-language call routing. noRouting = no special routing (normal call processing) */
+export declare const callRouters: Record<SupportedLanguages, CallRouter>;
+export type RubyCallRouting = {
+    kind: 'import';
+    importPath: string;
+    isRelative: boolean;
+} | {
+    kind: 'heritage';
+    items: RubyHeritageItem[];
+} | {
+    kind: 'properties';
+    items: RubyPropertyItem[];
+} | {
+    kind: 'call';
+} | {
+    kind: 'skip';
+};
+export interface RubyHeritageItem {
+    enclosingClass: string;
+    mixinName: string;
+    heritageKind: 'include' | 'extend' | 'prepend';
+}
+export type RubyAccessorType = 'attr_accessor' | 'attr_reader' | 'attr_writer';
+export interface RubyPropertyItem {
+    propName: string;
+    accessorType: RubyAccessorType;
+    startLine: number;
+    endLine: number;
+}
+/**
+ * Classify a Ruby call node and extract its semantic payload.
+ *
+ * @param calledName - The method name (e.g. 'require', 'include', 'attr_accessor')
+ * @param callNode   - The tree-sitter `call` AST node
+ * @returns A discriminated union describing the call's semantic role
+ */
+export declare function routeRubyCall(calledName: string, callNode: any): RubyCallRouting;

package/dist/core/ingestion/call-routing.js

@@ -0,0 +1,108 @@
+/**
+ * Shared Ruby call routing logic.
+ *
+ * Ruby expresses imports, heritage (mixins), and property definitions as
+ * method calls rather than syntax-level constructs. This module provides a
+ * routing function used by the CLI call-processor, CLI parse-worker, and
+ * the web call-processor so that the classification logic lives in one place.
+ *
+ * NOTE: This file is intentionally duplicated in gitnexus-web/ because the
+ * two packages have separate build targets (Node native vs WASM/browser).
+ * Keep both copies in sync until a shared package is introduced.
+ */
+import { SupportedLanguages } from '../../config/supported-languages.js';
+/** No-op router: returns null for every call (passthrough to normal processing) */
+const noRouting = () => null;
+/** Per-language call routing. noRouting = no special routing (normal call processing) */
+export const callRouters = {
+    [SupportedLanguages.JavaScript]: noRouting,
+    [SupportedLanguages.TypeScript]: noRouting,
+    [SupportedLanguages.Python]: noRouting,
+    [SupportedLanguages.Java]: noRouting,
+    [SupportedLanguages.Kotlin]: noRouting,
+    [SupportedLanguages.Go]: noRouting,
+    [SupportedLanguages.Rust]: noRouting,
+    [SupportedLanguages.CSharp]: noRouting,
+    [SupportedLanguages.PHP]: noRouting,
+    [SupportedLanguages.Swift]: noRouting,
+    [SupportedLanguages.CPlusPlus]: noRouting,
+    [SupportedLanguages.C]: noRouting,
+    [SupportedLanguages.Ruby]: routeRubyCall,
+};
+// ── Pre-allocated singletons for common return values ────────────────────────
+const CALL_RESULT = { kind: 'call' };
+const SKIP_RESULT = { kind: 'skip' };
+/** Max depth for parent-walking loops to prevent pathological AST traversals */
+const MAX_PARENT_DEPTH = 50;
+// ── Routing function ────────────────────────────────────────────────────────
+/**
+ * Classify a Ruby call node and extract its semantic payload.
+ *
+ * @param calledName - The method name (e.g. 'require', 'include', 'attr_accessor')
+ * @param callNode   - The tree-sitter `call` AST node
+ * @returns A discriminated union describing the call's semantic role
+ */
+export function routeRubyCall(calledName, callNode) {
+    // ── require / require_relative → import ─────────────────────────────────
+    if (calledName === 'require' || calledName === 'require_relative') {
+        const argList = callNode.childForFieldName?.('arguments');
+        const stringNode = argList?.children?.find((c) => c.type === 'string');
+        const contentNode = stringNode?.children?.find((c) => c.type === 'string_content');
+        if (!contentNode)
+            return SKIP_RESULT;
+        let importPath = contentNode.text;
+        // Validate: reject null bytes, control chars, excessively long paths
+        if (!importPath || importPath.length > 1024 || /[\x00-\x1f]/.test(importPath)) {
+            return SKIP_RESULT;
+        }
+        const isRelative = calledName === 'require_relative';
+        if (isRelative && !importPath.startsWith('.')) {
+            importPath = './' + importPath;
+        }
+        return { kind: 'import', importPath, isRelative };
+    }
+    // ── include / extend / prepend → heritage (mixin) ──────────────────────
+    if (calledName === 'include' || calledName === 'extend' || calledName === 'prepend') {
+        let enclosingClass = null;
+        let current = callNode.parent;
+        let depth = 0;
+        while (current && ++depth <= MAX_PARENT_DEPTH) {
+            if (current.type === 'class' || current.type === 'module') {
+                const nameNode = current.childForFieldName?.('name');
+                if (nameNode) {
+                    enclosingClass = nameNode.text;
+                    break;
+                }
+            }
+            current = current.parent;
+        }
+        if (!enclosingClass)
+            return SKIP_RESULT;
+        const items = [];
+        const argList = callNode.childForFieldName?.('arguments');
+        for (const arg of (argList?.children ?? [])) {
+            if (arg.type === 'constant' || arg.type === 'scope_resolution') {
+                items.push({ enclosingClass, mixinName: arg.text, heritageKind: calledName });
+            }
+        }
+        return items.length > 0 ? { kind: 'heritage', items } : SKIP_RESULT;
+    }
+    // ── attr_accessor / attr_reader / attr_writer → property definitions ───
+    if (calledName === 'attr_accessor' || calledName === 'attr_reader' || calledName === 'attr_writer') {
+        const items = [];
+        const argList = callNode.childForFieldName?.('arguments');
+        for (const arg of (argList?.children ?? [])) {
+            if (arg.type === 'simple_symbol') {
+                items.push({
+                    propName: arg.text.startsWith(':') ? arg.text.slice(1) : arg.text,
+                    accessorType: calledName,
+                    startLine: arg.startPosition.row,
+                    endLine: arg.endPosition.row,
+                });
+            }
+        }
+        return items.length > 0 ? { kind: 'properties', items } : SKIP_RESULT;
+    }
+    // ── Everything else → regular call ─────────────────────────────────────
+    return CALL_RESULT;
+}

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

@@ -12,7 +12,7 @@
 import { detectFrameworkFromPath } from './framework-detection.js';
 import { SupportedLanguages } from '../../config/supported-languages.js';
 // ============================================================================
-// NAME PATTERNS - All 9 supported languages
+// NAME PATTERNS - All 11 supported languages
 // ============================================================================
 /**
  * Common entry point naming patterns by language
@@ -178,6 +178,12 @@ const ENTRY_POINT_PATTERNS = {
         /^save$/, // Repository::save()
         /^delete$/, // Repository::delete()
     ],
+    // Ruby
+    [SupportedLanguages.Ruby]: [
+        /^call$/, // Service objects (MyService.call)
+        /^perform$/, // Background jobs (Sidekiq, ActiveJob)
+        /^execute$/, // Command pattern
+    ],
 };
 /** Pre-computed merged patterns (universal + language-specific) to avoid per-call array allocation. */
 const MERGED_ENTRY_POINT_PATTERNS = {};
@@ -318,7 +324,12 @@ export function isTestFile(filePath) {
         p.endsWith('test.php') ||
         p.endsWith('spec.php') ||
         p.includes('/tests/feature/') ||
-        p.includes('/tests/unit/'));
+        p.includes('/tests/unit/') ||
+        // Ruby test patterns
+        p.endsWith('_spec.rb') ||
+        p.endsWith('_test.rb') ||
+        p.includes('/spec/') ||
+        p.includes('/test/fixtures/'));
 }
 /**
  * Check if a file path is likely a utility/helper file

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

@@ -211,6 +211,7 @@ const exportCheckers = {
     [SupportedLanguages.CPlusPlus]: cCppExportChecker,
     [SupportedLanguages.PHP]: phpExportChecker,
     [SupportedLanguages.Swift]: swiftExportChecker,
+    [SupportedLanguages.Ruby]: (_node, _name) => true,
 };
 // ============================================================================
 // Public API

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

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

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

@@ -255,6 +255,15 @@ export function detectFrameworkFromPath(filePath) {
     if (p.includes('/repositories/') && p.endsWith('.php')) {
         return { framework: 'laravel', entryPointMultiplier: 1.5, reason: 'laravel-repository' };
     }
+    // ========== RUBY ==========
+    // Ruby: bin/ or exe/ (CLI entry points)
+    if ((p.includes('/bin/') || p.includes('/exe/')) && p.endsWith('.rb')) {
+        return { framework: 'ruby', entryPointMultiplier: 2.5, reason: 'ruby-executable' };
+    }
+    // Ruby: Rakefile or *.rake (task definitions)
+    if (p.endsWith('/rakefile') || p.endsWith('.rake')) {
+        return { framework: 'ruby', entryPointMultiplier: 1.5, reason: 'ruby-rake' };
+    }
     // ========== SWIFT / iOS ==========
     // iOS App entry points (highest priority)
     if (p.endsWith('/appdelegate.swift') || p.endsWith('/scenedelegate.swift') || p.endsWith('/app.swift')) {

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

@@ -15,15 +15,14 @@
  */
 import { KnowledgeGraph } from '../graph/types.js';
 import { ASTCache } from './ast-cache.js';
-import { SymbolTable } from './symbol-table.js';
 import type { ExtractedHeritage } from './workers/parse-worker.js';
-import type { ImportMap, PackageMap } from './import-processor.js';
+import type { ResolutionContext } from './resolution-context.js';
 export declare const processHeritage: (graph: KnowledgeGraph, files: {
     path: string;
     content: string;
-}[], astCache: ASTCache, symbolTable: SymbolTable, importMap: ImportMap, packageMap?: PackageMap, onProgress?: (current: number, total: number) => void) => Promise<void>;
+}[], astCache: ASTCache, ctx: ResolutionContext, onProgress?: (current: number, total: number) => void) => Promise<void>;
 /**
  * Fast path: resolve pre-extracted heritage from workers.
  * No AST parsing — workers already extracted className + parentName + kind.
  */
-export declare const processHeritageFromExtracted: (graph: KnowledgeGraph, extractedHeritage: ExtractedHeritage[], symbolTable: SymbolTable, importMap: ImportMap, packageMap?: PackageMap, onProgress?: (current: number, total: number) => void) => Promise<void>;
+export declare const processHeritageFromExtracted: (graph: KnowledgeGraph, extractedHeritage: ExtractedHeritage[], ctx: ResolutionContext, onProgress?: (current: number, total: number) => void) => Promise<void>;

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

@@ -20,7 +20,6 @@ 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';
-import { resolveSymbol } from './symbol-resolver.js';
 /** C#/Java convention: interfaces start with I followed by an uppercase letter */
 const INTERFACE_NAME_RE = /^I[A-Z]/;
 /**
@@ -31,10 +30,10 @@ const INTERFACE_NAME_RE = /^I[A-Z]/;
  *   - Swift: default IMPLEMENTS (protocol conformance is the norm)
  *   - All others: default EXTENDS
  */
-const resolveExtendsType = (parentName, currentFilePath, symbolTable, importMap, language, packageMap) => {
-    const resolved = resolveSymbol(parentName, currentFilePath, symbolTable, importMap, packageMap);
-    if (resolved) {
-        const isInterface = resolved.type === 'Interface';
+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' };
@@ -51,7 +50,22 @@ const resolveExtendsType = (parentName, currentFilePath, symbolTable, importMap,
     }
     return { type: 'EXTENDS', idPrefix: 'Class' };
 };
-export const processHeritage = async (graph, files, astCache, symbolTable, importMap, packageMap, onProgress) => {
+/**
+ * Resolve a symbol ID for heritage, with fallback to generated ID.
+ * Uses ctx.resolve() → pick first candidate's nodeId → generate synthetic ID.
+ */
+const resolveHeritageId = (name, filePath, ctx, fallbackLabel, fallbackKey) => {
+    const resolved = ctx.resolve(name, filePath);
+    if (resolved && resolved.candidates.length > 0) {
+        // For global with multiple candidates, refuse (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;
@@ -77,7 +91,6 @@ export const processHeritage = async (graph, files, astCache, symbolTable, impor
         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 {
@@ -87,7 +100,6 @@ export const processHeritage = async (graph, files, astCache, symbolTable, impor
                 // Skip files that can't be parsed
                 continue;
             }
-            wasReparsed = true;
             // Cache re-parsed tree for potential future use
             astCache.set(file.path, tree);
         }
@@ -119,12 +131,9 @@ export const processHeritage = async (graph, files, astCache, symbolTable, impor
                 }
                 const className = captureMap['heritage.class'].text;
                 const parentClassName = captureMap['heritage.extends'].text;
-                const { type: relType, idPrefix } = resolveExtendsType(parentClassName, file.path, symbolTable, importMap, language, packageMap);
-                const childId = symbolTable.lookupExact(file.path, className) ||
-                    resolveSymbol(className, file.path, symbolTable, importMap, packageMap)?.nodeId ||
-                    generateId('Class', `${file.path}:${className}`);
-                const parentId = resolveSymbol(parentClassName, file.path, symbolTable, importMap, packageMap)?.nodeId ||
-                    generateId(idPrefix, `${parentClassName}`);
+                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}`),
@@ -140,16 +149,11 @@ export const processHeritage = async (graph, files, astCache, symbolTable, impor
             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) ||
-                    resolveSymbol(className, file.path, symbolTable, importMap, packageMap)?.nodeId ||
-                    generateId('Class', `${file.path}:${className}`);
-                const interfaceId = resolveSymbol(interfaceName, file.path, symbolTable, importMap, packageMap)?.nodeId ||
-                    generateId('Interface', `${interfaceName}`);
+                const classId = resolveHeritageId(className, file.path, ctx, 'Class', `${file.path}:${className}`);
+                const interfaceId = resolveHeritageId(interfaceName, file.path, ctx, 'Interface');
                 if (classId && interfaceId) {
-                    const relId = generateId('IMPLEMENTS', `${classId}->${interfaceId}`);
                     graph.addRelationship({
-                        id: relId,
+                        id: generateId('IMPLEMENTS', `${classId}->${interfaceId}`),
                         sourceId: classId,
                         targetId: interfaceId,
                         type: 'IMPLEMENTS',
@@ -162,16 +166,11 @@ export const processHeritage = async (graph, files, astCache, symbolTable, impor
             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) ||
-                    resolveSymbol(structName, file.path, symbolTable, importMap, packageMap)?.nodeId ||
-                    generateId('Struct', `${file.path}:${structName}`);
-                const traitId = resolveSymbol(traitName, file.path, symbolTable, importMap, packageMap)?.nodeId ||
-                    generateId('Trait', `${traitName}`);
+                const structId = resolveHeritageId(structName, file.path, ctx, 'Struct', `${file.path}:${structName}`);
+                const traitId = resolveHeritageId(traitName, file.path, ctx, 'Trait');
                 if (structId && traitId) {
-                    const relId = generateId('IMPLEMENTS', `${structId}->${traitId}`);
                     graph.addRelationship({
-                        id: relId,
+                        id: generateId('IMPLEMENTS', `${structId}->${traitId}`),
                         sourceId: structId,
                         targetId: traitId,
                         type: 'IMPLEMENTS',
@@ -193,7 +192,7 @@ export const processHeritage = async (graph, files, astCache, symbolTable, impor
  * Fast path: resolve pre-extracted heritage from workers.
  * No AST parsing — workers already extracted className + parentName + kind.
  */
-export const processHeritageFromExtracted = async (graph, extractedHeritage, symbolTable, importMap, packageMap, onProgress) => {
+export const processHeritageFromExtracted = async (graph, extractedHeritage, ctx, onProgress) => {
     const total = extractedHeritage.length;
     for (let i = 0; i < extractedHeritage.length; i++) {
         if (i % 500 === 0) {
@@ -205,12 +204,9 @@ export const processHeritageFromExtracted = async (graph, extractedHeritage, sym
             const fileLanguage = getLanguageFromFilename(h.filePath);
             if (!fileLanguage)
                 continue;
-            const { type: relType, idPrefix } = resolveExtendsType(h.parentName, h.filePath, symbolTable, importMap, fileLanguage, packageMap);
-            const childId = symbolTable.lookupExact(h.filePath, h.className) ||
-                resolveSymbol(h.className, h.filePath, symbolTable, importMap, packageMap)?.nodeId ||
-                generateId('Class', `${h.filePath}:${h.className}`);
-            const parentId = resolveSymbol(h.parentName, h.filePath, symbolTable, importMap, packageMap)?.nodeId ||
-                generateId(idPrefix, `${h.parentName}`);
+            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}`),
@@ -223,11 +219,8 @@ export const processHeritageFromExtracted = async (graph, extractedHeritage, sym
             }
         }
         else if (h.kind === 'implements') {
-            const classId = symbolTable.lookupExact(h.filePath, h.className) ||
-                resolveSymbol(h.className, h.filePath, symbolTable, importMap, packageMap)?.nodeId ||
-                generateId('Class', `${h.filePath}:${h.className}`);
-            const interfaceId = resolveSymbol(h.parentName, h.filePath, symbolTable, importMap, packageMap)?.nodeId ||
-                generateId('Interface', `${h.parentName}`);
+            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}`),
@@ -239,20 +232,17 @@ export const processHeritageFromExtracted = async (graph, extractedHeritage, sym
                 });
             }
         }
-        else if (h.kind === 'trait-impl') {
-            const structId = symbolTable.lookupExact(h.filePath, h.className) ||
-                resolveSymbol(h.className, h.filePath, symbolTable, importMap, packageMap)?.nodeId ||
-                generateId('Struct', `${h.filePath}:${h.className}`);
-            const traitId = resolveSymbol(h.parentName, h.filePath, symbolTable, importMap, packageMap)?.nodeId ||
-                generateId('Trait', `${h.parentName}`);
+        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}`),
+                    id: generateId('IMPLEMENTS', `${structId}->${traitId}:${h.kind}`),
                     sourceId: structId,
                     targetId: traitId,
                     type: 'IMPLEMENTS',
                     confidence: 1.0,
-                    reason: 'trait-impl',
+                    reason: h.kind,
                 });
             }
         }

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

@@ -1,18 +1,16 @@
 import { KnowledgeGraph } from '../graph/types.js';
 import { ASTCache } from './ast-cache.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';
 export type ImportMap = Map<string, Set<string>>;
-export declare const createImportMap: () => ImportMap;
 export type PackageMap = Map<string, Set<string>>;
-export declare const createPackageMap: () => PackageMap;
 export interface NamedImportBinding {
     sourcePath: string;
     exportedName: string;
 }
 export type NamedImportMap = Map<string, Map<string, NamedImportBinding>>;
-export declare const createNamedImportMap: () => NamedImportMap;
 /**
  * Check if a file path is directly inside a package directory identified by its suffix.
  * Used by the symbol resolver for Go and C# directory-level import matching.
@@ -30,7 +28,7 @@ export declare function buildImportResolutionContext(allPaths: string[]): Import
 export declare const processImports: (graph: KnowledgeGraph, files: {
     path: string;
     content: string;
-}[], astCache: ASTCache, importMap: ImportMap, onProgress?: (current: number, total: number) => void, repoRoot?: string, allPaths?: string[], packageMap?: PackageMap, namedImportMap?: NamedImportMap) => Promise<void>;
+}[], astCache: ASTCache, ctx: ResolutionContext, onProgress?: (current: number, total: number) => void, repoRoot?: string, allPaths?: string[]) => Promise<void>;
 export declare const processImportsFromExtracted: (graph: KnowledgeGraph, files: {
     path: string;
-}[], extractedImports: ExtractedImport[], importMap: ImportMap, onProgress?: (current: number, total: number) => void, repoRoot?: string, prebuiltCtx?: ImportResolutionContext, packageMap?: PackageMap, namedImportMap?: NamedImportMap) => Promise<void>;
+}[], extractedImports: ExtractedImport[], ctx: ResolutionContext, onProgress?: (current: number, total: number) => void, repoRoot?: string, prebuiltCtx?: ImportResolutionContext) => Promise<void>;

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

@@ -7,11 +7,9 @@ import { SupportedLanguages } from '../../config/supported-languages.js';
 import { extractNamedBindings } from './named-binding-extraction.js';
 import { getTreeSitterBufferSize } from './constants.js';
 import { loadTsconfigPaths, loadGoModulePath, loadComposerConfig, loadCSharpProjectConfig, loadSwiftPackageConfig, } from './language-config.js';
-import { buildSuffixIndex, resolveImportPath, appendKotlinWildcard, KOTLIN_EXTENSIONS, resolveJvmWildcard, resolveJvmMemberImport, resolveGoPackageDir, resolveGoPackage, resolveCSharpImport, resolveCSharpNamespaceDir, resolvePhpImport, resolveRustImport, } from './resolvers/index.js';
+import { buildSuffixIndex, resolveImportPath, appendKotlinWildcard, KOTLIN_EXTENSIONS, resolveJvmWildcard, resolveJvmMemberImport, resolveGoPackageDir, resolveGoPackage, resolveCSharpImport, resolveCSharpNamespaceDir, resolvePhpImport, resolveRustImport, resolveRubyImport, resolvePythonImport, } from './resolvers/index.js';
+import { callRouters } from './call-routing.js';
 const isDev = process.env.NODE_ENV === 'development';
-export const createImportMap = () => new Map();
-export const createPackageMap = () => new Map();
-export const createNamedImportMap = () => new Map();
 /**
  * Check if a file path is directly inside a package directory identified by its suffix.
  * Used by the symbol resolver for Go and C# directory-level import matching.
@@ -107,6 +105,20 @@ function resolveLanguageImport(filePath, rawImportPath, language, configs, ctx)
         }
         return null; // External framework (Foundation, UIKit, etc.)
     }
+    // Python: relative imports (PEP 328) + proximity-based bare imports
+    // Falls through to standard suffix resolution when proximity finds no match.
+    if (language === SupportedLanguages.Python) {
+        const resolved = resolvePythonImport(filePath, rawImportPath, allFilePaths);
+        if (resolved)
+            return { kind: 'files', files: [resolved] };
+        if (rawImportPath.startsWith('.'))
+            return null; // relative but unresolved — don't suffix-match
+    }
+    // Ruby: require / require_relative
+    if (language === SupportedLanguages.Ruby) {
+        const resolved = resolveRubyImport(rawImportPath, normalizedFileList, allFileList, index);
+        return resolved ? { kind: 'files', files: [resolved] } : null;
+    }
     // Rust: expand top-level grouped imports: use {crate::a, crate::b}
     if (language === SupportedLanguages.Rust && rawImportPath.startsWith('{') && rawImportPath.endsWith('}')) {
         const inner = rawImportPath.slice(1, -1);
@@ -161,7 +173,10 @@ function applyImportResult(result, filePath, importMap, packageMap, addImportEdg
 // ============================================================================
 // MAIN IMPORT PROCESSOR
 // ============================================================================
-export const processImports = async (graph, files, astCache, importMap, onProgress, repoRoot, allPaths, packageMap, namedImportMap) => {
+export const processImports = async (graph, files, astCache, ctx, onProgress, repoRoot, allPaths) => {
+    const importMap = ctx.importMap;
+    const packageMap = ctx.packageMap;
+    const namedImportMap = ctx.namedImportMap;
     // Use allPaths (full repo) when available for cross-chunk resolution, else fall back to chunk files
     const allFileList = allPaths ?? files.map(f => f.path);
     const allFilePaths = new Set(allFileList);
@@ -185,7 +200,7 @@ export const processImports = async (graph, files, astCache, importMap, onProgre
         swiftPackageConfig: await loadSwiftPackageConfig(effectiveRoot),
         csharpConfigs: await loadCSharpProjectConfig(effectiveRoot),
     };
-    const ctx = { allFilePaths, allFileList, normalizedFileList, index, resolveCache };
+    const resolveCtx = { allFilePaths, allFileList, normalizedFileList, index, resolveCache };
     // Helper: add an IMPORTS edge to the graph only (no ImportMap update)
     const addImportGraphEdge = (filePath, resolvedPath) => {
         const sourceId = generateId('File', filePath);
@@ -281,10 +296,23 @@ export const processImports = async (graph, files, astCache, importMap, onProgre
                     ? appendKotlinWildcard(sourceNode.text.replace(/['"<>]/g, ''), captureMap['import'])
                     : sourceNode.text.replace(/['"<>]/g, '');
                 totalImportsFound++;
-                const result = resolveLanguageImport(file.path, rawImportPath, language, configs, ctx);
+                const result = resolveLanguageImport(file.path, rawImportPath, language, configs, resolveCtx);
                 const bindings = namedImportMap ? extractNamedBindings(captureMap['import'], language) : undefined;
                 applyImportResult(result, file.path, importMap, packageMap, addImportEdge, addImportGraphEdge, bindings, namedImportMap);
             }
+            // ---- Language-specific call-as-import routing (Ruby require, etc.) ----
+            if (captureMap['call']) {
+                const callNameNode = captureMap['call.name'];
+                if (callNameNode) {
+                    const callRouter = callRouters[language];
+                    const routed = callRouter(callNameNode.text, captureMap['call']);
+                    if (routed && routed.kind === 'import') {
+                        totalImportsFound++;
+                        const result = resolveLanguageImport(file.path, routed.importPath, language, configs, resolveCtx);
+                        applyImportResult(result, file.path, importMap, packageMap, addImportEdge, addImportGraphEdge);
+                    }
+                }
+            }
         });
         // Tree is now owned by the LRU cache — no manual delete needed
     }
@@ -300,9 +328,12 @@ export const processImports = async (graph, files, astCache, importMap, onProgre
 // ============================================================================
 // FAST PATH: Resolve pre-extracted imports (no parsing needed)
 // ============================================================================
-export const processImportsFromExtracted = async (graph, files, extractedImports, importMap, onProgress, repoRoot, prebuiltCtx, packageMap, namedImportMap) => {
-    const ctx = prebuiltCtx ?? buildImportResolutionContext(files.map(f => f.path));
-    const { allFilePaths, allFileList, normalizedFileList, suffixIndex: index, resolveCache } = ctx;
+export const processImportsFromExtracted = async (graph, files, extractedImports, ctx, onProgress, repoRoot, prebuiltCtx) => {
+    const importMap = ctx.importMap;
+    const packageMap = ctx.packageMap;
+    const namedImportMap = ctx.namedImportMap;
+    const importCtx = prebuiltCtx ?? buildImportResolutionContext(files.map(f => f.path));
+    const { allFilePaths, allFileList, normalizedFileList, suffixIndex: index, resolveCache } = importCtx;
     let totalImportsFound = 0;
     let totalImportsResolved = 0;
     const effectiveRoot = repoRoot || '';

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

@@ -2,13 +2,14 @@ import { KnowledgeGraph } from '../graph/types.js';
 import { SymbolTable } from './symbol-table.js';
 import { ASTCache } from './ast-cache.js';
 import { WorkerPool } from './workers/worker-pool.js';
-import type { ExtractedImport, ExtractedCall, ExtractedHeritage, ExtractedRoute } from './workers/parse-worker.js';
+import type { ExtractedImport, ExtractedCall, ExtractedHeritage, ExtractedRoute, FileConstructorBindings } from './workers/parse-worker.js';
 export type FileProgressCallback = (current: number, total: number, filePath: string) => void;
 export interface WorkerExtractedData {
     imports: ExtractedImport[];
     calls: ExtractedCall[];
     heritage: ExtractedHeritage[];
     routes: ExtractedRoute[];
+    constructorBindings: FileConstructorBindings[];
 }
 export { isNodeExported } from './export-detection.js';
 export declare const processParsing: (graph: KnowledgeGraph, files: {