gitnexus 1.6.2-rc.18 → 1.6.2-rc.19

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

@@ -0,0 +1,7 @@
+/**
+ * C / C++ import resolution configs.
+ * Both use standard resolution for #include directives.
+ */
+import type { ImportResolutionConfig } from '../types.js';
+export declare const cImportConfig: ImportResolutionConfig;
+export declare const cppImportConfig: ImportResolutionConfig;

package/dist/core/ingestion/import-resolvers/configs/c-cpp.js

@@ -0,0 +1,14 @@
+/**
+ * C / C++ import resolution configs.
+ * Both use standard resolution for #include directives.
+ */
+import { SupportedLanguages } from '../../../../_shared/index.js';
+import { createStandardStrategy } from '../standard.js';
+export const cImportConfig = {
+    language: SupportedLanguages.C,
+    strategies: [createStandardStrategy(SupportedLanguages.C)],
+};
+export const cppImportConfig = {
+    language: SupportedLanguages.CPlusPlus,
+    strategies: [createStandardStrategy(SupportedLanguages.CPlusPlus)],
+};

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

@@ -0,0 +1,8 @@
+/**
+ * C# import resolution config.
+ * Namespace-based strategy via .csproj configs, then standard fallback.
+ */
+import type { ImportResolutionConfig, ImportResolverStrategy } from '../types.js';
+/** C# namespace-based resolution strategy via .csproj configs. */
+export declare const csharpNamespaceStrategy: ImportResolverStrategy;
+export declare const csharpImportConfig: ImportResolutionConfig;

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

@@ -0,0 +1,27 @@
+/**
+ * C# import resolution config.
+ * Namespace-based strategy via .csproj configs, then standard fallback.
+ */
+import { SupportedLanguages } from '../../../../_shared/index.js';
+import { createStandardStrategy } from '../standard.js';
+import { resolveCSharpImportInternal, resolveCSharpNamespaceDir } from '../csharp.js';
+/** C# namespace-based resolution strategy via .csproj configs. */
+export const csharpNamespaceStrategy = (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 null;
+};
+export const csharpImportConfig = {
+    language: SupportedLanguages.CSharp,
+    strategies: [csharpNamespaceStrategy, createStandardStrategy(SupportedLanguages.CSharp)],
+};

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

@@ -0,0 +1,17 @@
+/**
+ * Dart import resolution config.
+ * SDK/package strategy first, then relative import strategy (with ./ prepending).
+ */
+import type { ImportResolutionConfig, ImportResolverStrategy } from '../types.js';
+/**
+ * Dart SDK and package: import strategy.
+ * Absorbs dart: SDK imports and external packages (returns empty result to stop chain).
+ * Returns null for relative imports to let the next strategy handle them.
+ */
+export declare const dartPackageStrategy: ImportResolverStrategy;
+/**
+ * Dart relative import strategy — prepends "./" for bare relative paths,
+ * then delegates to standard resolution.
+ */
+export declare const dartRelativeStrategy: ImportResolverStrategy;
+export declare const dartImportConfig: ImportResolutionConfig;

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

@@ -1,21 +1,25 @@
 /**
- * Dart import resolution.
- * Handles package: imports (local packages) and relative imports.
- * SDK imports (dart:*) and external packages are skipped.
+ * Dart import resolution config.
+ * SDK/package strategy first, then relative import strategy (with ./ prepending).
  */
-import { resolveStandard } from './standard.js';
-import { SupportedLanguages } from '../../../_shared/index.js';
-export function resolveDartImport(rawImportPath, filePath, ctx) {
+import { SupportedLanguages } from '../../../../_shared/index.js';
+import { resolveStandard } from '../standard.js';
+/**
+ * Dart SDK and package: import strategy.
+ * Absorbs dart: SDK imports and external packages (returns empty result to stop chain).
+ * Returns null for relative imports to let the next strategy handle them.
+ */
+export const dartPackageStrategy = (rawImportPath, _filePath, ctx) => {
     // Strip surrounding quotes from configurable_uri capture
     const stripped = rawImportPath.replace(/^['"]|['"]$/g, '');
     // Skip dart: SDK imports (dart:async, dart:io, etc.)
     if (stripped.startsWith('dart:'))
-        return null;
+        return { kind: 'files', files: [] };
     // Local package: imports → resolve to lib/<path>
     if (stripped.startsWith('package:')) {
         const slashIdx = stripped.indexOf('/');
         if (slashIdx === -1)
-            return null;
+            return { kind: 'files', files: [] };
         const relPath = stripped.slice(slashIdx + 1);
         const candidates = [`lib/${relPath}`, relPath];
         const files = [];
@@ -31,14 +35,20 @@ export function resolveDartImport(rawImportPath, filePath, ctx) {
         }
         if (files.length > 0)
             return { kind: 'files', files };
-        return null;
+        return { kind: 'files', files: [] }; // external package
     }
-    // Relative imports — use standard resolution.
-    // Dart relative imports don't require a leading "./" (e.g. `import 'models.dart'`).
-    // The standard resolver only recognises paths starting with "." as relative, so
-    // prepend "./" when the path doesn't already start with "." to ensure correct
-    // same-directory resolution (without this, "models.dart" would be mangled by the
-    // generic dot-to-slash conversion intended for Java-style package imports).
+    return null;
+};
+/**
+ * Dart relative import strategy — prepends "./" for bare relative paths,
+ * then delegates to standard resolution.
+ */
+export const dartRelativeStrategy = (rawImportPath, filePath, ctx) => {
+    const stripped = rawImportPath.replace(/^['"]|['"]$/g, '');
     const relPath = stripped.startsWith('.') ? stripped : './' + stripped;
     return resolveStandard(relPath, filePath, ctx, SupportedLanguages.Dart);
-}
+};
+export const dartImportConfig = {
+    language: SupportedLanguages.Dart,
+    strategies: [dartPackageStrategy, dartRelativeStrategy],
+};

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

@@ -0,0 +1,8 @@
+/**
+ * Go import resolution config.
+ * Go-specific package strategy (go.mod), then standard fallback.
+ */
+import type { ImportResolutionConfig, ImportResolverStrategy } from '../types.js';
+/** Go-specific package resolution strategy — resolves go.mod-based package imports. */
+export declare const goPackageStrategy: ImportResolverStrategy;
+export declare const goImportConfig: ImportResolutionConfig;

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

@@ -0,0 +1,26 @@
+/**
+ * Go import resolution config.
+ * Go-specific package strategy (go.mod), then standard fallback.
+ */
+import { SupportedLanguages } from '../../../../_shared/index.js';
+import { createStandardStrategy } from '../standard.js';
+import { resolveGoPackageDir, resolveGoPackage } from '../go.js';
+/** Go-specific package resolution strategy — resolves go.mod-based package imports. */
+export const goPackageStrategy = (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 null;
+};
+export const goImportConfig = {
+    language: SupportedLanguages.Go,
+    strategies: [goPackageStrategy, createStandardStrategy(SupportedLanguages.Go)],
+};

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

@@ -0,0 +1,13 @@
+/**
+ * Java / Kotlin import resolution configs.
+ * JVM-specific wildcard/member strategy, then standard fallback.
+ */
+import type { ImportResolutionConfig, ImportResolverStrategy } from '../types.js';
+/** Java JVM resolution strategy — wildcard and member import resolution. */
+export declare const javaJvmStrategy: ImportResolverStrategy;
+/**
+ * Kotlin JVM resolution strategy — wildcard/member with Java-interop + top-level function imports.
+ */
+export declare const kotlinJvmStrategy: ImportResolverStrategy;
+export declare const javaImportConfig: ImportResolutionConfig;
+export declare const kotlinImportConfig: ImportResolutionConfig;

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

@@ -0,0 +1,68 @@
+/**
+ * Java / Kotlin import resolution configs.
+ * JVM-specific wildcard/member strategy, then standard fallback.
+ */
+import { SupportedLanguages } from '../../../../_shared/index.js';
+import { createStandardStrategy } from '../standard.js';
+import { resolveJvmWildcard, resolveJvmMemberImport, KOTLIN_EXTENSIONS } from '../jvm.js';
+/** Java JVM resolution strategy — wildcard and member import resolution. */
+export const javaJvmStrategy = (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 null;
+};
+/**
+ * Kotlin JVM resolution strategy — wildcard/member with Java-interop + top-level function imports.
+ */
+export const kotlinJvmStrategy = (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 null;
+};
+export const javaImportConfig = {
+    language: SupportedLanguages.Java,
+    strategies: [javaJvmStrategy, createStandardStrategy(SupportedLanguages.Java)],
+};
+export const kotlinImportConfig = {
+    language: SupportedLanguages.Kotlin,
+    strategies: [kotlinJvmStrategy, createStandardStrategy(SupportedLanguages.Kotlin)],
+};

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

@@ -0,0 +1,8 @@
+/**
+ * PHP import resolution config.
+ * PSR-4 strategy via composer.json — no standard fallback (PSR-4 includes its own suffix matching).
+ */
+import type { ImportResolutionConfig, ImportResolverStrategy } from '../types.js';
+/** PHP PSR-4 resolution strategy via composer.json autoload mappings. */
+export declare const phpPsr4Strategy: ImportResolverStrategy;
+export declare const phpImportConfig: ImportResolutionConfig;

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

@@ -0,0 +1,15 @@
+/**
+ * PHP import resolution config.
+ * PSR-4 strategy via composer.json — no standard fallback (PSR-4 includes its own suffix matching).
+ */
+import { SupportedLanguages } from '../../../../_shared/index.js';
+import { resolvePhpImportInternal } from '../php.js';
+/** PHP PSR-4 resolution strategy via composer.json autoload mappings. */
+export const phpPsr4Strategy = (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;
+};
+export const phpImportConfig = {
+    language: SupportedLanguages.PHP,
+    strategies: [phpPsr4Strategy],
+};

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

@@ -0,0 +1,12 @@
+/**
+ * Python import resolution config.
+ * PEP 328 relative + proximity-based strategy, then standard fallback.
+ */
+import type { ImportResolutionConfig, ImportResolverStrategy } from '../types.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 declare const pythonImportStrategy: ImportResolverStrategy;
+export declare const pythonImportConfig: ImportResolutionConfig;

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

@@ -0,0 +1,27 @@
+/**
+ * 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: [] };
+    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;