gitnexus 1.4.8 → 1.4.10

package/dist/mcp/tools.js

@@ -58,10 +58,10 @@ WHEN TO USE: Complex structural queries that search/explore can't answer. READ g
 AFTER THIS: Use context() on result symbols for deeper context.
 
 SCHEMA:
-- Nodes: File, Folder, Function, Class, Interface, Method, CodeElement, Community, Process
+- Nodes: File, Folder, Function, Class, Interface, Method, CodeElement, Community, Process, Route, Tool
 - Multi-language nodes (use backticks): \`Struct\`, \`Enum\`, \`Trait\`, \`Impl\`, etc.
 - All edges via single CodeRelation table with 'type' property
-- Edge types: CONTAINS, DEFINES, CALLS, IMPORTS, EXTENDS, IMPLEMENTS, HAS_METHOD, HAS_PROPERTY, ACCESSES, OVERRIDES, MEMBER_OF, STEP_IN_PROCESS
+- Edge types: CONTAINS, DEFINES, CALLS, IMPORTS, EXTENDS, IMPLEMENTS, HAS_METHOD, HAS_PROPERTY, ACCESSES, OVERRIDES, MEMBER_OF, STEP_IN_PROCESS, HANDLES_ROUTE, FETCHES, HANDLES_TOOL, ENTRY_POINT_OF
 - Edge properties: type (STRING), confidence (DOUBLE), reason (STRING), step (INT32)
 
 EXAMPLES:
@@ -209,4 +209,73 @@ Confidence: 1.0 = certain, <0.8 = fuzzy match`,
             required: ['target', 'direction'],
         },
     },
+    {
+        name: 'route_map',
+        description: `Show API route mappings: which components/hooks fetch which API endpoints, and which handler files serve them.
+
+WHEN TO USE: Understanding API consumption patterns, finding orphaned routes. For pre-change analysis, prefer \`api_impact\` which combines this data with mismatch detection and risk assessment.
+AFTER THIS: Use impact() on specific route handlers to see full blast radius.
+
+Returns: route nodes with their handlers, middleware wrapper chains (e.g., withAuth, withRateLimit), and consumers.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                route: { type: 'string', description: 'Filter by route path (e.g., "/api/grants"). Omit for all routes.' },
+                repo: { type: 'string', description: 'Repository name or path. Omit if only one repo is indexed.' },
+            },
+            required: [],
+        },
+    },
+    {
+        name: 'tool_map',
+        description: `Show MCP/RPC tool definitions: which tools are defined, where they're handled, and their descriptions.
+
+WHEN TO USE: Understanding tool APIs, finding tool implementations, impact analysis for tool changes.
+
+Returns: tool nodes with their handler files and descriptions.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                tool: { type: 'string', description: 'Filter by tool name. Omit for all tools.' },
+                repo: { type: 'string', description: 'Repository name or path.' },
+            },
+            required: [],
+        },
+    },
+    {
+        name: 'shape_check',
+        description: `Check response shapes for API routes against their consumers' property accesses.
+
+WHEN TO USE: Detecting mismatches between what an API route returns and what consumers expect. Finding shape drift. For pre-change analysis, prefer \`api_impact\` which combines this data with mismatch detection and risk assessment.
+REQUIRES: Route nodes with responseKeys (extracted from .json({...}) calls during indexing).
+
+Returns routes that have both detected response keys AND consumers. Shows top-level keys each endpoint returns (e.g., data, pagination, error) and what keys each consumer accesses. Reports MISMATCH status when a consumer accesses keys not present in the route's response shape.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                route: { type: 'string', description: 'Check a specific route (e.g., "/api/grants"). Omit to check all routes.' },
+                repo: { type: 'string', description: 'Repository name or path. Omit if only one repo is indexed.' },
+            },
+            required: [],
+        },
+    },
+    {
+        name: 'api_impact',
+        description: `Pre-change impact report for an API route handler.
+
+WHEN TO USE: BEFORE modifying any API route handler. Shows what consumers depend on, what response fields they access, what middleware protects the route, and what execution flows it triggers. Requires at least "route" or "file" parameter.
+
+Risk levels: LOW (0-3 consumers), MEDIUM (4-9 or any mismatches), HIGH (10+ consumers or mismatches with 4+ consumers). Mismatches with confidence "low" indicate the consumer file fetches multiple routes — property attribution is approximate.
+
+Returns: single route object when one match, or { routes: [...], total: N } for multiple matches. Combines route_map, shape_check, and impact data.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                route: { type: 'string', description: 'Route path (e.g., "/api/grants")' },
+                file: { type: 'string', description: 'Handler file path (alternative to route)' },
+                repo: { type: 'string', description: 'Repository name or path.' },
+            },
+            required: [],
+        },
+    },
 ];

package/dist/storage/repo-manager.d.ts

@@ -119,10 +119,13 @@ export declare const unregisterRepo: (repoPath: string) => Promise<void>;
 export declare const listRegisteredRepos: (opts?: {
     validate?: boolean;
 }) => Promise<RegistryEntry[]>;
+export type LLMProvider = 'openai' | 'cursor';
 export interface CLIConfig {
     apiKey?: string;
     model?: string;
     baseUrl?: string;
+    provider?: LLMProvider;
+    cursorModel?: string;
 }
 /**
  * Get the path to the global CLI config file

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitnexus",
-  "version": "1.4.8",
+  "version": "1.4.10",
   "description": "Graph-powered code intelligence for AI agents. Index any codebase, query via MCP or CLI.",
   "author": "Abhigyan Patwari",
   "license": "PolyForm-Noncommercial-1.0.0",
@@ -46,7 +46,6 @@
     "test:watch": "vitest",
     "test:coverage": "vitest run --coverage",
     "prepare": "npm run build",
-    "postinstall": "node scripts/patch-tree-sitter-swift.cjs",
     "prepack": "npm run build && chmod +x dist/cli/index.js"
   },
   "dependencies": {
@@ -66,21 +65,22 @@
     "mnemonist": "^0.39.0",
     "onnxruntime-node": "^1.24.0",
     "pandemonium": "^2.4.0",
-    "tree-sitter": "^0.21.0",
-    "tree-sitter-c": "^0.21.0",
-    "tree-sitter-c-sharp": "^0.21.0",
-    "tree-sitter-cpp": "^0.22.0",
-    "tree-sitter-go": "^0.21.0",
-    "tree-sitter-java": "^0.21.0",
-    "tree-sitter-javascript": "^0.21.0",
-    "tree-sitter-php": "^0.23.12",
-    "tree-sitter-python": "^0.21.0",
+    "tree-sitter": "^0.21.1",
+    "tree-sitter-c": "0.23.2",
+    "tree-sitter-c-sharp": "^0.23.1",
+    "tree-sitter-cpp": "^0.23.4",
+    "tree-sitter-go": "^0.23.0",
+    "tree-sitter-java": "^0.23.5",
+    "tree-sitter-javascript": "^0.23.0",
+    "tree-sitter-php": "^0.23.0",
+    "tree-sitter-python": "0.23.4",
     "tree-sitter-ruby": "^0.23.1",
-    "tree-sitter-rust": "^0.21.0",
-    "tree-sitter-typescript": "^0.21.0",
+    "tree-sitter-rust": "0.23.1",
+    "tree-sitter-typescript": "^0.23.2",
     "uuid": "^13.0.0"
   },
   "optionalDependencies": {
+    "tree-sitter-dart": "github:UserNobody14/tree-sitter-dart#80e23c07b64494f7e21090bb3450223ef0b192f4",
     "tree-sitter-kotlin": "^0.3.8",
     "tree-sitter-swift": "^0.6.0"
   },
@@ -102,6 +102,6 @@
     }
   },
   "engines": {
-    "node": ">=18.0.0"
+    "node": ">=20.0.0"
   }
 }

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

@@ -1,101 +0,0 @@
-/**
- * Import Resolution Dispatch
- *
- * Per-language dispatch table for import resolution and named binding extraction.
- * Replaces the 120-line if-chain in resolveLanguageImport() and the 7-branch
- * dispatch in extractNamedBindings() with a single table lookup each.
- *
- * Follows the existing ExportChecker / CallRouter pattern:
- *   - Function aliases (not interfaces) to avoid megamorphic inline-cache issues
- *   - `satisfies Record<SupportedLanguages, ...>` for compile-time exhaustiveness
- *   - Const dispatch table — configs are accessed via ctx.configs at call time
- */
-import { SupportedLanguages } from '../../config/supported-languages.js';
-import type { SyntaxNode } from './utils.js';
-import type { TsconfigPaths, GoModuleConfig, CSharpProjectConfig, ComposerConfig } from './resolvers/index.js';
-import type { SwiftPackageConfig } from './language-config.js';
-import { extractTsNamedBindings, extractPythonNamedBindings, extractKotlinNamedBindings, extractRustNamedBindings, extractPhpNamedBindings, extractCsharpNamedBindings, extractJavaNamedBindings } from './named-binding-extraction.js';
-import type { ImportResolutionContext } from './import-processor.js';
-/**
- * Result of resolving an import via language-specific dispatch.
- * - 'files': resolved to one or more files -> add to ImportMap
- * - 'package': resolved to a directory -> add graph edges + store dirSuffix in PackageMap
- * - null: no resolution (external dependency, etc.)
- */
-export type ImportResult = {
-    kind: 'files';
-    files: string[];
-} | {
-    kind: 'package';
-    files: string[];
-    dirSuffix: string;
-} | null;
-/** Bundled language-specific configs loaded once per ingestion run. */
-export interface ImportConfigs {
-    tsconfigPaths: TsconfigPaths | null;
-    goModule: GoModuleConfig | null;
-    composerConfig: ComposerConfig | null;
-    swiftPackageConfig: SwiftPackageConfig | null;
-    csharpConfigs: CSharpProjectConfig[];
-}
-/** Full context for import resolution: file lookups + language configs. */
-export interface ResolveCtx extends ImportResolutionContext {
-    configs: ImportConfigs;
-}
-/** Per-language import resolver -- function alias matching ExportChecker/CallRouter pattern. */
-export type ImportResolverFn = (rawImportPath: string, filePath: string, resolveCtx: ResolveCtx) => ImportResult;
-/** A single named import binding: local name in the importing file and exported name from the source.
- *  When `isModuleAlias` is true, the binding represents a Python `import X as Y` module alias
- *  and is routed to moduleAliasMap instead of namedImportMap during import processing. */
-export interface NamedBinding {
-    local: string;
-    exported: string;
-    isModuleAlias?: boolean;
-}
-/**
- * Clean and preprocess a raw import source text into a resolved import path.
- * Strips quotes/angle brackets (universal) and applies language-specific
- * transformations (currently only Kotlin wildcard import detection).
- */
-export declare function preprocessImportPath(sourceText: string, importNode: SyntaxNode, language: SupportedLanguages): string | null;
-/**
- * Per-language import resolver dispatch table.
- * Configs are accessed via ctx.configs at call time — no factory closure needed.
- * Each resolver encapsulates the full resolution flow for its language, including
- * fallthrough to standard resolution where appropriate.
- */
-export declare const importResolvers: {
-    javascript: (raw: string, fp: string, ctx: ResolveCtx) => ImportResult;
-    typescript: (raw: string, fp: string, ctx: ResolveCtx) => ImportResult;
-    python: (raw: string, fp: string, ctx: ResolveCtx) => ImportResult;
-    java: (raw: string, fp: string, ctx: ResolveCtx) => ImportResult;
-    c: (raw: string, fp: string, ctx: ResolveCtx) => ImportResult;
-    cpp: (raw: string, fp: string, ctx: ResolveCtx) => ImportResult;
-    csharp: (raw: string, fp: string, ctx: ResolveCtx) => ImportResult;
-    go: (raw: string, fp: string, ctx: ResolveCtx) => ImportResult;
-    ruby: (raw: string, fp: string, ctx: ResolveCtx) => ImportResult;
-    rust: (raw: string, fp: string, ctx: ResolveCtx) => ImportResult;
-    php: (raw: string, fp: string, ctx: ResolveCtx) => ImportResult;
-    kotlin: (raw: string, fp: string, ctx: ResolveCtx) => ImportResult;
-    swift: (raw: string, fp: string, ctx: ResolveCtx) => ImportResult;
-};
-/**
- * Per-language named binding extractor dispatch table.
- * Languages with whole-module import semantics (Go, Ruby, C/C++, Swift) return undefined --
- * their bindings are synthesized post-parse by synthesizeWildcardImportBindings() in pipeline.ts.
- */
-export declare const namedBindingExtractors: {
-    javascript: typeof extractTsNamedBindings;
-    typescript: typeof extractTsNamedBindings;
-    python: typeof extractPythonNamedBindings;
-    java: typeof extractJavaNamedBindings;
-    c: any;
-    cpp: any;
-    csharp: typeof extractCsharpNamedBindings;
-    go: any;
-    ruby: any;
-    rust: typeof extractRustNamedBindings;
-    php: typeof extractPhpNamedBindings;
-    kotlin: typeof extractKotlinNamedBindings;
-    swift: any;
-};

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

@@ -1,251 +0,0 @@
-/**
- * Import Resolution Dispatch
- *
- * Per-language dispatch table for import resolution and named binding extraction.
- * Replaces the 120-line if-chain in resolveLanguageImport() and the 7-branch
- * dispatch in extractNamedBindings() with a single table lookup each.
- *
- * Follows the existing ExportChecker / CallRouter pattern:
- *   - Function aliases (not interfaces) to avoid megamorphic inline-cache issues
- *   - `satisfies Record<SupportedLanguages, ...>` for compile-time exhaustiveness
- *   - Const dispatch table — configs are accessed via ctx.configs at call time
- */
-import { SupportedLanguages } from '../../config/supported-languages.js';
-import { KOTLIN_EXTENSIONS, appendKotlinWildcard, resolveJvmWildcard, resolveJvmMemberImport, resolveGoPackageDir, resolveGoPackage, resolveCSharpImport as resolveCSharpImportHelper, resolveCSharpNamespaceDir, resolvePhpImport as resolvePhpImportHelper, resolveRustImport as resolveRustImportHelper, resolveRubyImport as resolveRubyImportHelper, resolvePythonImport as resolvePythonImportHelper, resolveImportPath, } from './resolvers/index.js';
-import { extractTsNamedBindings, extractPythonNamedBindings, extractKotlinNamedBindings, extractRustNamedBindings, extractPhpNamedBindings, extractCsharpNamedBindings, extractJavaNamedBindings, } from './named-binding-extraction.js';
-// ============================================================================
-// Import path preprocessing
-// ============================================================================
-/**
- * Clean and preprocess a raw import source text into a resolved import path.
- * Strips quotes/angle brackets (universal) and applies language-specific
- * transformations (currently only Kotlin wildcard import detection).
- */
-export function preprocessImportPath(sourceText, importNode, language) {
-    const cleaned = sourceText.replace(/['"<>]/g, '');
-    // Defense-in-depth: reject null bytes and control characters (matches Ruby call-routing pattern)
-    if (!cleaned || cleaned.length > 2048 || /[\x00-\x1f]/.test(cleaned))
-        return null;
-    if (language === SupportedLanguages.Kotlin) {
-        return appendKotlinWildcard(cleaned, importNode);
-    }
-    return cleaned;
-}
-// ============================================================================
-// Per-language resolver functions
-// ============================================================================
-/**
- * Standard single-file resolution (TS/JS/C/C++ and fallback for other languages).
- * Handles relative imports, tsconfig path aliases, and suffix matching.
- */
-function resolveStandard(rawImportPath, filePath, ctx, language) {
-    const resolvedPath = resolveImportPath(filePath, rawImportPath, ctx.allFilePaths, ctx.allFileList, ctx.normalizedFileList, ctx.resolveCache, language, ctx.configs.tsconfigPaths, ctx.index);
-    return resolvedPath ? { kind: 'files', files: [resolvedPath] } : null;
-}
-/** Java: JVM wildcard -> member import -> standard fallthrough */
-function resolveJavaImport(rawImportPath, filePath, ctx) {
-    if (rawImportPath.endsWith('.*')) {
-        const matchedFiles = resolveJvmWildcard(rawImportPath, ctx.normalizedFileList, ctx.allFileList, ['.java'], ctx.index);
-        if (matchedFiles.length > 0)
-            return { kind: 'files', files: matchedFiles };
-    }
-    else {
-        const memberResolved = resolveJvmMemberImport(rawImportPath, ctx.normalizedFileList, ctx.allFileList, ['.java'], ctx.index);
-        if (memberResolved)
-            return { kind: 'files', files: [memberResolved] };
-    }
-    return resolveStandard(rawImportPath, filePath, ctx, SupportedLanguages.Java);
-}
-/**
- * Kotlin: JVM wildcard/member with Java-interop fallback -> top-level function imports -> standard.
- * Kotlin can import from .kt/.kts files OR from .java files (Java interop).
- */
-function resolveKotlinImport(rawImportPath, filePath, ctx) {
-    if (rawImportPath.endsWith('.*')) {
-        const matchedFiles = resolveJvmWildcard(rawImportPath, ctx.normalizedFileList, ctx.allFileList, KOTLIN_EXTENSIONS, ctx.index);
-        if (matchedFiles.length === 0) {
-            const javaMatches = resolveJvmWildcard(rawImportPath, ctx.normalizedFileList, ctx.allFileList, ['.java'], ctx.index);
-            if (javaMatches.length > 0)
-                return { kind: 'files', files: javaMatches };
-        }
-        if (matchedFiles.length > 0)
-            return { kind: 'files', files: matchedFiles };
-    }
-    else {
-        let memberResolved = resolveJvmMemberImport(rawImportPath, ctx.normalizedFileList, ctx.allFileList, KOTLIN_EXTENSIONS, ctx.index);
-        if (!memberResolved) {
-            memberResolved = resolveJvmMemberImport(rawImportPath, ctx.normalizedFileList, ctx.allFileList, ['.java'], ctx.index);
-        }
-        if (memberResolved)
-            return { kind: 'files', files: [memberResolved] };
-        // Kotlin: top-level function imports (e.g. import models.getUser) have only 2 segments,
-        // which resolveJvmMemberImport skips (requires >=3). Fall back to package-directory scan
-        // for lowercase last segments (function/property imports). Uppercase last segments
-        // (class imports like models.User) fall through to standard suffix resolution.
-        const segments = rawImportPath.split('.');
-        const lastSeg = segments[segments.length - 1];
-        if (segments.length >= 2 && lastSeg[0] && lastSeg[0] === lastSeg[0].toLowerCase()) {
-            const pkgWildcard = segments.slice(0, -1).join('.') + '.*';
-            let dirFiles = resolveJvmWildcard(pkgWildcard, ctx.normalizedFileList, ctx.allFileList, KOTLIN_EXTENSIONS, ctx.index);
-            if (dirFiles.length === 0) {
-                dirFiles = resolveJvmWildcard(pkgWildcard, ctx.normalizedFileList, ctx.allFileList, ['.java'], ctx.index);
-            }
-            if (dirFiles.length > 0)
-                return { kind: 'files', files: dirFiles };
-        }
-    }
-    return resolveStandard(rawImportPath, filePath, ctx, SupportedLanguages.Kotlin);
-}
-/** Go: package-level imports via go.mod module path. */
-function resolveGoImport(rawImportPath, filePath, ctx) {
-    const goModule = ctx.configs.goModule;
-    if (goModule && rawImportPath.startsWith(goModule.modulePath)) {
-        const pkgSuffix = resolveGoPackageDir(rawImportPath, goModule);
-        if (pkgSuffix) {
-            const pkgFiles = resolveGoPackage(rawImportPath, goModule, ctx.normalizedFileList, ctx.allFileList);
-            if (pkgFiles.length > 0) {
-                return { kind: 'package', files: pkgFiles, dirSuffix: pkgSuffix };
-            }
-        }
-        // Fall through if no files found (package might be external)
-    }
-    return resolveStandard(rawImportPath, filePath, ctx, SupportedLanguages.Go);
-}
-/** C#: namespace-based resolution via .csproj configs, with suffix-match fallback. */
-function resolveCSharpImportDispatch(rawImportPath, filePath, ctx) {
-    const csharpConfigs = ctx.configs.csharpConfigs;
-    if (csharpConfigs.length > 0) {
-        const resolvedFiles = resolveCSharpImportHelper(rawImportPath, csharpConfigs, ctx.normalizedFileList, ctx.allFileList, ctx.index);
-        if (resolvedFiles.length > 1) {
-            const dirSuffix = resolveCSharpNamespaceDir(rawImportPath, csharpConfigs);
-            if (dirSuffix) {
-                return { kind: 'package', files: resolvedFiles, dirSuffix };
-            }
-        }
-        if (resolvedFiles.length > 0)
-            return { kind: 'files', files: resolvedFiles };
-    }
-    return resolveStandard(rawImportPath, filePath, ctx, SupportedLanguages.CSharp);
-}
-/** PHP: namespace-based resolution via composer.json PSR-4. */
-function resolvePhpImportDispatch(rawImportPath, _filePath, ctx) {
-    const resolved = resolvePhpImportHelper(rawImportPath, ctx.configs.composerConfig, ctx.allFilePaths, ctx.normalizedFileList, ctx.allFileList, ctx.index);
-    return resolved ? { kind: 'files', files: [resolved] } : null;
-}
-/** Swift: module imports via Package.swift target map. */
-function resolveSwiftImportDispatch(rawImportPath, _filePath, ctx) {
-    const swiftPackageConfig = ctx.configs.swiftPackageConfig;
-    if (swiftPackageConfig) {
-        const targetDir = swiftPackageConfig.targets.get(rawImportPath);
-        if (targetDir) {
-            const dirPrefix = targetDir + '/';
-            const files = [];
-            for (let i = 0; i < ctx.normalizedFileList.length; i++) {
-                if (ctx.normalizedFileList[i].startsWith(dirPrefix) && ctx.normalizedFileList[i].endsWith('.swift')) {
-                    files.push(ctx.allFileList[i]);
-                }
-            }
-            if (files.length > 0)
-                return { kind: 'files', files };
-        }
-    }
-    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.
- */
-function resolvePythonImportDispatch(rawImportPath, filePath, ctx) {
-    const resolved = resolvePythonImportHelper(filePath, rawImportPath, ctx.allFilePaths);
-    if (resolved)
-        return { kind: 'files', files: [resolved] };
-    if (rawImportPath.startsWith('.'))
-        return null; // relative but unresolved -- don't suffix-match
-    return resolveStandard(rawImportPath, filePath, ctx, SupportedLanguages.Python);
-}
-/** Ruby: require / require_relative. */
-function resolveRubyImportDispatch(rawImportPath, _filePath, ctx) {
-    const resolved = resolveRubyImportHelper(rawImportPath, ctx.normalizedFileList, ctx.allFileList, ctx.index);
-    return resolved ? { kind: 'files', files: [resolved] } : null;
-}
-/** Rust: expand grouped imports: use {crate::a, crate::b} and use crate::models::{User, Repo}. */
-function resolveRustImportDispatch(rawImportPath, filePath, ctx) {
-    // Top-level grouped: use {crate::a, crate::b}
-    if (rawImportPath.startsWith('{') && rawImportPath.endsWith('}')) {
-        const inner = rawImportPath.slice(1, -1);
-        const parts = inner.split(',').map(p => p.trim()).filter(Boolean);
-        const resolved = [];
-        for (const part of parts) {
-            const r = resolveRustImportHelper(filePath, part, ctx.allFilePaths);
-            if (r)
-                resolved.push(r);
-        }
-        return resolved.length > 0 ? { kind: 'files', files: resolved } : null;
-    }
-    // Scoped grouped: use crate::models::{User, Repo}
-    const braceIdx = rawImportPath.indexOf('::{');
-    if (braceIdx !== -1 && rawImportPath.endsWith('}')) {
-        const pathPrefix = rawImportPath.substring(0, braceIdx);
-        const braceContent = rawImportPath.substring(braceIdx + 3, rawImportPath.length - 1);
-        const items = braceContent.split(',').map(s => s.trim()).filter(Boolean);
-        const resolved = [];
-        for (const item of items) {
-            // Handle `use crate::models::{User, Repo as R}` — strip alias for resolution
-            const itemName = item.includes(' as ') ? item.split(' as ')[0].trim() : item;
-            const r = resolveRustImportHelper(filePath, `${pathPrefix}::${itemName}`, ctx.allFilePaths);
-            if (r)
-                resolved.push(r);
-        }
-        if (resolved.length > 0)
-            return { kind: 'files', files: resolved };
-        // Fallback: resolve the prefix path itself (e.g. crate::models -> models.rs)
-        const prefixResult = resolveRustImportHelper(filePath, pathPrefix, ctx.allFilePaths);
-        if (prefixResult)
-            return { kind: 'files', files: [prefixResult] };
-    }
-    return resolveStandard(rawImportPath, filePath, ctx, SupportedLanguages.Rust);
-}
-// ============================================================================
-// Dispatch tables
-// ============================================================================
-/**
- * Per-language import resolver dispatch table.
- * Configs are accessed via ctx.configs at call time — no factory closure needed.
- * Each resolver encapsulates the full resolution flow for its language, including
- * fallthrough to standard resolution where appropriate.
- */
-export const importResolvers = {
-    [SupportedLanguages.JavaScript]: (raw, fp, ctx) => resolveStandard(raw, fp, ctx, SupportedLanguages.JavaScript),
-    [SupportedLanguages.TypeScript]: (raw, fp, ctx) => resolveStandard(raw, fp, ctx, SupportedLanguages.TypeScript),
-    [SupportedLanguages.Python]: (raw, fp, ctx) => resolvePythonImportDispatch(raw, fp, ctx),
-    [SupportedLanguages.Java]: (raw, fp, ctx) => resolveJavaImport(raw, fp, ctx),
-    [SupportedLanguages.C]: (raw, fp, ctx) => resolveStandard(raw, fp, ctx, SupportedLanguages.C),
-    [SupportedLanguages.CPlusPlus]: (raw, fp, ctx) => resolveStandard(raw, fp, ctx, SupportedLanguages.CPlusPlus),
-    [SupportedLanguages.CSharp]: (raw, fp, ctx) => resolveCSharpImportDispatch(raw, fp, ctx),
-    [SupportedLanguages.Go]: (raw, fp, ctx) => resolveGoImport(raw, fp, ctx),
-    [SupportedLanguages.Ruby]: (raw, fp, ctx) => resolveRubyImportDispatch(raw, fp, ctx),
-    [SupportedLanguages.Rust]: (raw, fp, ctx) => resolveRustImportDispatch(raw, fp, ctx),
-    [SupportedLanguages.PHP]: (raw, fp, ctx) => resolvePhpImportDispatch(raw, fp, ctx),
-    [SupportedLanguages.Kotlin]: (raw, fp, ctx) => resolveKotlinImport(raw, fp, ctx),
-    [SupportedLanguages.Swift]: (raw, fp, ctx) => resolveSwiftImportDispatch(raw, fp, ctx),
-};
-/**
- * Per-language named binding extractor dispatch table.
- * Languages with whole-module import semantics (Go, Ruby, C/C++, Swift) return undefined --
- * their bindings are synthesized post-parse by synthesizeWildcardImportBindings() in pipeline.ts.
- */
-export const namedBindingExtractors = {
-    [SupportedLanguages.JavaScript]: extractTsNamedBindings,
-    [SupportedLanguages.TypeScript]: extractTsNamedBindings,
-    [SupportedLanguages.Python]: extractPythonNamedBindings,
-    [SupportedLanguages.Java]: extractJavaNamedBindings,
-    [SupportedLanguages.C]: undefined,
-    [SupportedLanguages.CPlusPlus]: undefined,
-    [SupportedLanguages.CSharp]: extractCsharpNamedBindings,
-    [SupportedLanguages.Go]: undefined,
-    [SupportedLanguages.Ruby]: undefined,
-    [SupportedLanguages.Rust]: extractRustNamedBindings,
-    [SupportedLanguages.PHP]: extractPhpNamedBindings,
-    [SupportedLanguages.Kotlin]: extractKotlinNamedBindings,
-    [SupportedLanguages.Swift]: undefined,
-};