gitnexus 1.6.2-rc.8 → 1.6.2

package/dist/core/ingestion/import-resolvers/configs/python.js

@@ -0,0 +1,41 @@
+/**
+ * Python import resolution config.
+ * PEP 328 relative + proximity-based strategy, then standard fallback.
+ */
+import { SupportedLanguages } from '../../../../_shared/index.js';
+import { createStandardStrategy } from '../standard.js';
+import { resolvePythonImportInternal } from '../python.js';
+/**
+ * Python import resolution strategy — PEP 328 relative + proximity-based bare imports.
+ * Returns null to continue chain for non-relative imports.
+ * Absorbs unresolved relative imports (returns empty result to stop the chain).
+ */
+export const pythonImportStrategy = (rawImportPath, filePath, ctx) => {
+    const resolved = resolvePythonImportInternal(filePath, rawImportPath, ctx.allFilePaths);
+    if (resolved) {
+        ctx.resolveCache.set(`${filePath}::${rawImportPath}`, resolved);
+        return { kind: 'files', files: [resolved] };
+    }
+    // PEP 328: unresolved relative imports should not fall through to suffix matching
+    if (rawImportPath.startsWith('.'))
+        return { kind: 'files', files: [] };
+    // External dotted imports like `django.apps` should not fall through to generic
+    // suffix matching when the repo has unrelated local files such as `accounts/apps.py`.
+    // Keep suffix fallback only when the leading segment appears somewhere in-repo,
+    // which preserves existing internal absolute-import behavior like `accounts.models`.
+    const pathLike = rawImportPath.replace(/\./g, '/');
+    if (pathLike.includes('/')) {
+        const [leadingSegment] = pathLike.split('/').filter(Boolean);
+        const hasRepoCandidate = !!leadingSegment &&
+            (ctx.index.get(`${leadingSegment}.py`) !== undefined ||
+                ctx.index.get(`${leadingSegment}/__init__.py`) !== undefined ||
+                ctx.index.getFilesInDir(leadingSegment, '.py').length > 0);
+        if (!hasRepoCandidate)
+            return { kind: 'files', files: [] };
+    }
+    return null;
+};
+export const pythonImportConfig = {
+    language: SupportedLanguages.Python,
+    strategies: [pythonImportStrategy, createStandardStrategy(SupportedLanguages.Python)],
+};

package/dist/core/ingestion/import-resolvers/configs/ruby.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Ruby import resolution config.
+ * Require/require_relative suffix matching — no standard fallback.
+ */
+import type { ImportResolutionConfig, ImportResolverStrategy } from '../types.js';
+/** Ruby require/require_relative resolution strategy. */
+export declare const rubyRequireStrategy: ImportResolverStrategy;
+export declare const rubyImportConfig: ImportResolutionConfig;

package/dist/core/ingestion/import-resolvers/configs/ruby.js

@@ -0,0 +1,16 @@
+/**
+ * Ruby import resolution config.
+ * Require/require_relative suffix matching — no standard fallback.
+ */
+import { SupportedLanguages } from '../../../../_shared/index.js';
+import { suffixResolve } from '../utils.js';
+/** Ruby require/require_relative resolution strategy. */
+export const rubyRequireStrategy = (rawImportPath, _filePath, ctx) => {
+    const pathParts = rawImportPath.replace(/^\.\//, '').split('/').filter(Boolean);
+    const resolved = suffixResolve(pathParts, ctx.normalizedFileList, ctx.allFileList, ctx.index);
+    return resolved ? { kind: 'files', files: [resolved] } : null;
+};
+export const rubyImportConfig = {
+    language: SupportedLanguages.Ruby,
+    strategies: [rubyRequireStrategy],
+};

package/dist/core/ingestion/import-resolvers/configs/rust.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Rust import resolution config.
+ * Rust module strategy (grouped imports, crate/super/self paths), then standard fallback.
+ */
+import type { ImportResolutionConfig, ImportResolverStrategy } from '../types.js';
+/** Rust module resolution strategy — handles grouped imports and crate/super/self paths. */
+export declare const rustModuleStrategy: ImportResolverStrategy;
+export declare const rustImportConfig: ImportResolutionConfig;

package/dist/core/ingestion/import-resolvers/configs/rust.js

@@ -0,0 +1,54 @@
+/**
+ * Rust import resolution config.
+ * Rust module strategy (grouped imports, crate/super/self paths), then standard fallback.
+ */
+import { SupportedLanguages } from '../../../../_shared/index.js';
+import { createStandardStrategy } from '../standard.js';
+import { resolveRustImportInternal } from '../rust.js';
+/** Rust module resolution strategy — handles grouped imports and crate/super/self paths. */
+export const rustModuleStrategy = (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 = resolveRustImportInternal(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 = resolveRustImportInternal(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 = resolveRustImportInternal(filePath, pathPrefix, ctx.allFilePaths);
+        if (prefixResult)
+            return { kind: 'files', files: [prefixResult] };
+    }
+    return null;
+};
+export const rustImportConfig = {
+    language: SupportedLanguages.Rust,
+    strategies: [rustModuleStrategy, createStandardStrategy(SupportedLanguages.Rust)],
+};

package/dist/core/ingestion/import-resolvers/configs/swift.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Swift import resolution config.
+ * Package.swift target map strategy — no standard fallback (unresolved = external framework).
+ */
+import type { ImportResolutionConfig, ImportResolverStrategy } from '../types.js';
+/** Swift Package.swift target map resolution strategy. */
+export declare const swiftPackageStrategy: ImportResolverStrategy;
+export declare const swiftImportConfig: ImportResolutionConfig;

package/dist/core/ingestion/import-resolvers/{swift.js → configs/swift.js}

@@ -1,9 +1,10 @@
 /**
- * Swift module import resolution.
- * Handles module imports via Package.swift target map.
+ * Swift import resolution config.
+ * Package.swift target map strategy — no standard fallback (unresolved = external framework).
  */
-/** Swift: module imports via Package.swift target map. */
-export function resolveSwiftImport(rawImportPath, _filePath, ctx) {
+import { SupportedLanguages } from '../../../../_shared/index.js';
+/** Swift Package.swift target map resolution strategy. */
+export const swiftPackageStrategy = (rawImportPath, _filePath, ctx) => {
     const swiftPackageConfig = ctx.configs.swiftPackageConfig;
     if (swiftPackageConfig) {
         const targetDir = swiftPackageConfig.targets.get(rawImportPath);
@@ -21,4 +22,8 @@ export function resolveSwiftImport(rawImportPath, _filePath, ctx) {
         }
     }
     return null; // External framework (Foundation, UIKit, etc.)
-}
+};
+export const swiftImportConfig = {
+    language: SupportedLanguages.Swift,
+    strategies: [swiftPackageStrategy],
+};

package/dist/core/ingestion/import-resolvers/configs/typescript-javascript.d.ts

@@ -0,0 +1,9 @@
+/**
+ * TypeScript / JavaScript / Vue import resolution configs.
+ * All use standard resolution — TS/JS with tsconfig path aliases,
+ * Vue delegates to TypeScript's resolver.
+ */
+import type { ImportResolutionConfig } from '../types.js';
+export declare const typescriptImportConfig: ImportResolutionConfig;
+export declare const javascriptImportConfig: ImportResolutionConfig;
+export declare const vueImportConfig: ImportResolutionConfig;

package/dist/core/ingestion/import-resolvers/configs/typescript-javascript.js

@@ -0,0 +1,23 @@
+/**
+ * TypeScript / JavaScript / Vue import resolution configs.
+ * All use standard resolution — TS/JS with tsconfig path aliases,
+ * Vue delegates to TypeScript's resolver.
+ */
+import { SupportedLanguages } from '../../../../_shared/index.js';
+import { createStandardStrategy } from '../standard.js';
+export const typescriptImportConfig = {
+    language: SupportedLanguages.TypeScript,
+    strategies: [createStandardStrategy(SupportedLanguages.TypeScript)],
+};
+export const javascriptImportConfig = {
+    language: SupportedLanguages.JavaScript,
+    strategies: [createStandardStrategy(SupportedLanguages.JavaScript)],
+};
+// Vue SFCs are preprocessed into TypeScript upstream of import resolution,
+// so the resolver intentionally runs as TypeScript. `language: Vue` here is
+// documentation-only metadata (see `ImportResolutionConfig.language` JSDoc
+// and ARCHITECTURE.md §Vue); it is not consumed by `createImportResolver`.
+export const vueImportConfig = {
+    language: SupportedLanguages.Vue,
+    strategies: [createStandardStrategy(SupportedLanguages.TypeScript)],
+};

package/dist/core/ingestion/import-resolvers/csharp.d.ts

@@ -1,9 +1,10 @@
 /**
- * C# namespace import resolution.
- * Handles using-directive resolution via .csproj root namespace stripping.
+ * C# namespace import resolution — internal helpers.
+ *
+ * Strategy lives in configs/csharp.ts.
+ * This file contains shared helpers for namespace-based resolution.
  */
 import type { SuffixIndex } from './utils.js';
-import type { ImportResult, ResolveCtx } from './types.js';
 import type { CSharpProjectConfig } from '../language-config.js';
 /**
  * Resolve a C# using-directive import path to matching .cs files (low-level helper).
@@ -15,5 +16,3 @@ export declare function resolveCSharpImportInternal(importPath: string, csharpCo
  * Returns a suffix like "/ProjectDir/Models/" or null if no config matches.
  */
 export declare function resolveCSharpNamespaceDir(importPath: string, csharpConfigs: CSharpProjectConfig[]): string | null;
-/** C#: namespace-based resolution via .csproj configs, with suffix-match fallback. */
-export declare function resolveCSharpImport(rawImportPath: string, filePath: string, ctx: ResolveCtx): ImportResult;

package/dist/core/ingestion/import-resolvers/csharp.js

@@ -1,10 +1,10 @@
 /**
- * C# namespace import resolution.
- * Handles using-directive resolution via .csproj root namespace stripping.
+ * C# namespace import resolution — internal helpers.
+ *
+ * Strategy lives in configs/csharp.ts.
+ * This file contains shared helpers for namespace-based resolution.
  */
 import { suffixResolve } from './utils.js';
-import { SupportedLanguages } from '../../../_shared/index.js';
-import { resolveStandard } from './standard.js';
 /**
  * Resolve a C# using-directive import path to matching .cs files (low-level helper).
  * Tries single-file match first, then directory match for namespace imports.
@@ -113,19 +113,3 @@ export function resolveCSharpNamespaceDir(importPath, csharpConfigs) {
     }
     return null;
 }
-/** C#: namespace-based resolution via .csproj configs, with suffix-match fallback. */
-export function resolveCSharpImport(rawImportPath, filePath, ctx) {
-    const csharpConfigs = ctx.configs.csharpConfigs;
-    if (csharpConfigs.length > 0) {
-        const resolvedFiles = resolveCSharpImportInternal(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);
-}

package/dist/core/ingestion/import-resolvers/go.d.ts

@@ -1,8 +1,9 @@
 /**
- * Go package import resolution.
- * Handles Go module path-based package imports.
+ * Go package import resolution — internal helpers.
+ *
+ * Strategy lives in configs/go.ts.
+ * This file contains the shared helpers used by the strategy.
  */
-import type { ImportResult, ResolveCtx } from './types.js';
 import type { GoModuleConfig } from '../language-config.js';
 /**
  * Extract the package directory suffix from a Go import path.
@@ -14,5 +15,3 @@ export declare function resolveGoPackageDir(importPath: string, goModule: GoModu
  * Returns an array of file paths.
  */
 export declare function resolveGoPackage(importPath: string, goModule: GoModuleConfig, normalizedFileList: string[], allFileList: string[]): string[];
-/** Go: package-level imports via go.mod module path. */
-export declare function resolveGoImport(rawImportPath: string, filePath: string, ctx: ResolveCtx): ImportResult;

package/dist/core/ingestion/import-resolvers/go.js

@@ -1,9 +1,9 @@
 /**
- * Go package import resolution.
- * Handles Go module path-based package imports.
+ * Go package import resolution — internal helpers.
+ *
+ * Strategy lives in configs/go.ts.
+ * This file contains the shared helpers used by the strategy.
  */
-import { SupportedLanguages } from '../../../_shared/index.js';
-import { resolveStandard } from './standard.js';
 /**
  * Extract the package directory suffix from a Go import path.
  * Returns the suffix string (e.g., "/internal/auth/") or null if invalid.
@@ -44,18 +44,3 @@ export function resolveGoPackage(importPath, goModule, normalizedFileList, allFi
     }
     return matches;
 }
-/** Go: package-level imports via go.mod module path. */
-export 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);
-}

package/dist/core/ingestion/import-resolvers/jvm.d.ts

@@ -1,10 +1,12 @@
 /**
- * JVM import resolution (Java + Kotlin).
- * Handles wildcard imports, member/static imports, and Kotlin-specific patterns.
+ * JVM import resolution — internal helpers (Java + Kotlin).
+ *
+ * Strategies live in configs/jvm.ts.
+ * This file contains shared helpers for wildcard/member resolution
+ * and the Kotlin wildcard preprocessor.
  */
 import type { SuffixIndex } from './utils.js';
 import type { SyntaxNode } from '../utils/ast-helpers.js';
-import type { ImportResult, ResolveCtx } from './types.js';
 /** Kotlin file extensions for JVM resolver reuse */
 export declare const KOTLIN_EXTENSIONS: readonly string[];
 /**
@@ -23,10 +25,3 @@ export declare function resolveJvmWildcard(importPath: string, normalizedFileLis
  * Kotlin: "com.example.Constants.VALUE" -> resolve "com.example.Constants"
  */
 export declare function resolveJvmMemberImport(importPath: string, normalizedFileList: string[], allFileList: string[], extensions: readonly string[], index?: SuffixIndex): string | null;
-/** Java: JVM wildcard -> member import -> standard fallthrough */
-export declare function resolveJavaImport(rawImportPath: string, filePath: string, ctx: ResolveCtx): ImportResult;
-/**
- * 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).
- */
-export declare function resolveKotlinImport(rawImportPath: string, filePath: string, ctx: ResolveCtx): ImportResult;

package/dist/core/ingestion/import-resolvers/jvm.js

@@ -1,9 +1,10 @@
 /**
- * JVM import resolution (Java + Kotlin).
- * Handles wildcard imports, member/static imports, and Kotlin-specific patterns.
+ * JVM import resolution — internal helpers (Java + Kotlin).
+ *
+ * Strategies live in configs/jvm.ts.
+ * This file contains shared helpers for wildcard/member resolution
+ * and the Kotlin wildcard preprocessor.
  */
-import { SupportedLanguages } from '../../../_shared/index.js';
-import { resolveStandard } from './standard.js';
 /** Kotlin file extensions for JVM resolver reuse */
 export const KOTLIN_EXTENSIONS = ['.kt', '.kts'];
 /**
@@ -103,57 +104,3 @@ export function resolveJvmMemberImport(importPath, normalizedFileList, allFileLi
     }
     return null;
 }
-/** Java: JVM wildcard -> member import -> standard fallthrough */
-export 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).
- */
-export 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);
-}

package/dist/core/ingestion/import-resolvers/php.d.ts

@@ -1,9 +1,10 @@
 /**
- * PHP PSR-4 import resolution.
- * Handles use-statement resolution via composer.json autoload mappings.
+ * PHP PSR-4 import resolution — internal helpers.
+ *
+ * Strategy lives in configs/php.ts.
+ * This file contains the shared helper for PSR-4 resolution via composer.json.
  */
 import type { SuffixIndex } from './utils.js';
-import type { ImportResult, ResolveCtx } from './types.js';
 import type { ComposerConfig } from '../language-config.js';
 /**
  * Resolve a PHP use-statement import path using PSR-4 mappings (low-level helper).
@@ -21,5 +22,3 @@ import type { ComposerConfig } from '../language-config.js';
  * without parsing all candidate files.
  */
 export declare function resolvePhpImportInternal(importPath: string, composerConfig: ComposerConfig | null, allFiles: Set<string>, normalizedFileList: string[], allFileList: string[], index?: SuffixIndex): string | null;
-/** PHP: namespace-based resolution via composer.json PSR-4. */
-export declare function resolvePhpImport(rawImportPath: string, _filePath: string, ctx: ResolveCtx): ImportResult;

package/dist/core/ingestion/import-resolvers/php.js

@@ -1,6 +1,8 @@
 /**
- * PHP PSR-4 import resolution.
- * Handles use-statement resolution via composer.json autoload mappings.
+ * PHP PSR-4 import resolution — internal helpers.
+ *
+ * Strategy lives in configs/php.ts.
+ * This file contains the shared helper for PSR-4 resolution via composer.json.
  */
 import { suffixResolve } from './utils.js';
 /** Get or compute the sorted PSR-4 entries (cached after first call). */
@@ -73,8 +75,3 @@ export function resolvePhpImportInternal(importPath, composerConfig, allFiles, n
     const pathParts = normalized.split('/').filter(Boolean);
     return suffixResolve(pathParts, normalizedFileList, allFileList, index);
 }
-/** PHP: namespace-based resolution via composer.json PSR-4. */
-export function resolvePhpImport(rawImportPath, _filePath, ctx) {
-    const resolved = resolvePhpImportInternal(rawImportPath, ctx.configs.composerConfig, ctx.allFilePaths, ctx.normalizedFileList, ctx.allFileList, ctx.index);
-    return resolved ? { kind: 'files', files: [resolved] } : null;
-}

package/dist/core/ingestion/import-resolvers/python.d.ts

@@ -1,8 +1,10 @@
 /**
  * Python import resolution — PEP 328 relative imports and proximity-based bare imports.
  * Import system spec: PEP 302 (original), PEP 451 (current).
+ *
+ * Strategy lives in configs/python.ts.
+ * This file contains the shared internal helper used by the strategy and tests.
  */
-import type { ImportResult, ResolveCtx } from './types.js';
 /**
  * Resolve a Python import to a file path (low-level helper).
  *
@@ -18,8 +20,3 @@ import type { ImportResult, ResolveCtx } from './types.js';
  * Returns null to let the caller fall through to suffixResolve.
  */
 export declare function resolvePythonImportInternal(currentFile: string, importPath: string, allFiles: Set<string>): string | null;
-/**
- * Python: relative imports (PEP 328) + proximity-based bare imports.
- * Falls through to standard suffix resolution when proximity finds no match.
- */
-export declare function resolvePythonImport(rawImportPath: string, filePath: string, ctx: ResolveCtx): ImportResult;

package/dist/core/ingestion/import-resolvers/python.js

@@ -1,10 +1,11 @@
 /**
  * Python import resolution — PEP 328 relative imports and proximity-based bare imports.
  * Import system spec: PEP 302 (original), PEP 451 (current).
+ *
+ * Strategy lives in configs/python.ts.
+ * This file contains the shared internal helper used by the strategy and tests.
  */
 import { tryResolveWithExtensions } from './utils.js';
-import { SupportedLanguages } from '../../../_shared/index.js';
-import { resolveStandard } from './standard.js';
 /**
  * Resolve a Python import to a file path (low-level helper).
  *
@@ -66,19 +67,3 @@ export function resolvePythonImportInternal(currentFile, importPath, allFiles) {
     }
     return null;
 }
-/**
- * Python: relative imports (PEP 328) + proximity-based bare imports.
- * Falls through to standard suffix resolution when proximity finds no match.
- */
-export function resolvePythonImport(rawImportPath, filePath, ctx) {
-    const resolved = resolvePythonImportInternal(filePath, rawImportPath, ctx.allFilePaths);
-    if (resolved) {
-        // Store in resolveCache so other files importing the same module skip the
-        // ancestor walk. The cache key matches resolveStandard's convention.
-        ctx.resolveCache.set(`${filePath}::${rawImportPath}`, 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);
-}

package/dist/core/ingestion/import-resolvers/resolver-factory.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Import resolver factory — creates a composable import resolver from
+ * an ordered list of strategies.
+ *
+ * Mirrors the method-extractors/generic.ts and call-extractors/generic.ts
+ * pattern: declare a config per language, produce a runtime resolver via factory.
+ *
+ * Each strategy is tried in order. The first non-null result wins.
+ * A result with an empty `files` array is treated as "handled but unresolved"
+ * (stops the chain without producing import edges).
+ */
+import type { ImportResolverFn, ImportResolutionConfig } from './types.js';
+/**
+ * Create an ImportResolverFn from a declarative config.
+ *
+ * Chains strategies in declaration order — first non-null result wins.
+ * Returns null only if every strategy returns null.
+ *
+ * Error behaviour: if a strategy throws, the error propagates immediately
+ * and remaining strategies are not tried.  Strategies are expected to be
+ * pure data transforms that never throw; any unexpected exception indicates
+ * a bug in the strategy implementation.
+ */
+export declare function createImportResolver(config: ImportResolutionConfig): ImportResolverFn;

package/dist/core/ingestion/import-resolvers/resolver-factory.js

@@ -0,0 +1,33 @@
+/**
+ * Import resolver factory — creates a composable import resolver from
+ * an ordered list of strategies.
+ *
+ * Mirrors the method-extractors/generic.ts and call-extractors/generic.ts
+ * pattern: declare a config per language, produce a runtime resolver via factory.
+ *
+ * Each strategy is tried in order. The first non-null result wins.
+ * A result with an empty `files` array is treated as "handled but unresolved"
+ * (stops the chain without producing import edges).
+ */
+/**
+ * Create an ImportResolverFn from a declarative config.
+ *
+ * Chains strategies in declaration order — first non-null result wins.
+ * Returns null only if every strategy returns null.
+ *
+ * Error behaviour: if a strategy throws, the error propagates immediately
+ * and remaining strategies are not tried.  Strategies are expected to be
+ * pure data transforms that never throw; any unexpected exception indicates
+ * a bug in the strategy implementation.
+ */
+export function createImportResolver(config) {
+    const { strategies } = config;
+    return (rawImportPath, filePath, ctx) => {
+        for (const strategy of strategies) {
+            const result = strategy(rawImportPath, filePath, ctx);
+            if (result)
+                return result;
+        }
+        return null;
+    };
+}

package/dist/core/ingestion/import-resolvers/ruby.d.ts

@@ -1,9 +1,10 @@
 /**
- * Ruby require/require_relative import resolution.
- * Handles path resolution for Ruby's require and require_relative calls.
+ * Ruby require/require_relative import resolution — internal helpers.
+ *
+ * Strategy lives in configs/ruby.ts.
+ * This file only contains the low-level helper used by the strategy.
  */
 import type { SuffixIndex } from './utils.js';
-import type { ImportResult, ResolveCtx } from './types.js';
 /**
  * Resolve a Ruby require/require_relative path to a matching .rb file (low-level helper).
  *
@@ -11,5 +12,3 @@ import type { ImportResult, ResolveCtx } from './types.js';
  * require paths use suffix matching (gem-style paths like 'json', 'net/http').
  */
 export declare function resolveRubyImportInternal(importPath: string, normalizedFileList: string[], allFileList: string[], index?: SuffixIndex): string | null;
-/** Ruby: require / require_relative. */
-export declare function resolveRubyImport(rawImportPath: string, _filePath: string, ctx: ResolveCtx): ImportResult;

package/dist/core/ingestion/import-resolvers/ruby.js

@@ -1,6 +1,8 @@
 /**
- * Ruby require/require_relative import resolution.
- * Handles path resolution for Ruby's require and require_relative calls.
+ * Ruby require/require_relative import resolution — internal helpers.
+ *
+ * Strategy lives in configs/ruby.ts.
+ * This file only contains the low-level helper used by the strategy.
  */
 import { suffixResolve } from './utils.js';
 /**
@@ -13,8 +15,3 @@ export function resolveRubyImportInternal(importPath, normalizedFileList, allFil
     const pathParts = importPath.replace(/^\.\//, '').split('/').filter(Boolean);
     return suffixResolve(pathParts, normalizedFileList, allFileList, index);
 }
-/** Ruby: require / require_relative. */
-export function resolveRubyImport(rawImportPath, _filePath, ctx) {
-    const resolved = resolveRubyImportInternal(rawImportPath, ctx.normalizedFileList, ctx.allFileList, ctx.index);
-    return resolved ? { kind: 'files', files: [resolved] } : null;
-}

package/dist/core/ingestion/import-resolvers/rust.d.ts

@@ -1,8 +1,9 @@
 /**
- * Rust module import resolution.
- * Handles crate::, super::, self:: prefix paths and :: separators.
+ * Rust module import resolution — internal helpers.
+ *
+ * Strategy lives in configs/rust.ts.
+ * This file contains shared helpers used by the strategy and standard.ts.
  */
-import type { ImportResult, ResolveCtx } from './types.js';
 /**
  * Resolve Rust use-path to a file (low-level helper).
  * Handles crate::, super::, self:: prefixes and :: path separators.
@@ -14,5 +15,3 @@ export declare function resolveRustImportInternal(currentFile: string, importPat
  * (last segment might be a symbol name, not a module).
  */
 export declare function tryRustModulePath(modulePath: string, allFiles: Set<string>): string | null;
-/** Rust: expand grouped imports: use {crate::a, crate::b} and use crate::models::{User, Repo}. */
-export declare function resolveRustImport(rawImportPath: string, filePath: string, ctx: ResolveCtx): ImportResult;