gitnexus 1.6.2-rc.17 → 1.6.2-rc.19

package/dist/core/group/extractors/http-patterns/node.js

@@ -7,6 +7,9 @@ import { compilePatterns, runCompiledPatterns, unquoteLiteral, } from '../tree-s
  *   - Express `router.get(...)` / `app.post(...)` providers
  *   - `fetch(url)` / `fetch(url, { method: 'POST' })` consumers
  *   - `axios.get(url)` / `axios.delete(url)` consumers
+ *   - `axios({ method, url })` object-form consumers
+ *   - jQuery `$.get(url)` / `$.post(url, ...)` shorthand consumers
+ *   - jQuery `$.ajax({ url, method | type })` consumers
  *
  * Because the JavaScript and TypeScript tree-sitter grammars share
  * node type names for every construct we query, pattern sources are
@@ -86,6 +89,45 @@ const AXIOS_SPEC = {
       arguments: (arguments . [(string) (template_string)] @path))
   `,
 };
+// ─── Consumer: jQuery shorthand $.get(url) / $.post(url, ...) ────────
+// `$` is a valid JS identifier, so tree-sitter parses `$.get(...)` as a
+// call_expression whose function is a member_expression on identifier `$`.
+const JQUERY_SHORTHAND_SPEC = {
+    meta: {},
+    query: `
+    (call_expression
+      function: (member_expression
+        object: (identifier) @obj (#eq? @obj "$")
+        property: (property_identifier) @http_method (#match? @http_method "^(get|post)$"))
+      arguments: (arguments . [(string) (template_string)] @path))
+  `,
+};
+// ─── Consumer: jQuery $.ajax({ url, method|type }) ───────────────────
+// The query captures the options object only; key/value pairs are read
+// programmatically via `readStringProp` below, which tolerates any key
+// order and accepts either `method:` or `type:` (jQuery supports both).
+const JQUERY_AJAX_SPEC = {
+    meta: {},
+    query: `
+    (call_expression
+      function: (member_expression
+        object: (identifier) @obj (#eq? @obj "$")
+        property: (property_identifier) @fn (#eq? @fn "ajax"))
+      arguments: (arguments (object) @options))
+  `,
+};
+// ─── Consumer: axios({ method, url }) object form ────────────────────
+// Distinct from AXIOS_SPEC above because the call target is an identifier
+// (`axios`) rather than a member expression (`axios.get`). As with the
+// jQuery ajax form, option keys are resolved programmatically.
+const AXIOS_OBJECT_SPEC = {
+    meta: {},
+    query: `
+    (call_expression
+      function: (identifier) @fn (#eq? @fn "axios")
+      arguments: (arguments (object) @options))
+  `,
+};
 function compileBundle(language, name) {
     const mk = (spec, suffix) => compilePatterns({
         name: `${name}-${suffix}`,
@@ -99,6 +141,9 @@ function compileBundle(language, name) {
         fetchNoOptions: mk(FETCH_NO_OPTIONS_SPEC, 'fetch-no-options'),
         fetchWithOptions: mk(FETCH_WITH_OPTIONS_SPEC, 'fetch-with-options'),
         axios: mk(AXIOS_SPEC, 'axios'),
+        jqueryShorthand: mk(JQUERY_SHORTHAND_SPEC, 'jquery-shorthand'),
+        jqueryAjax: mk(JQUERY_AJAX_SPEC, 'jquery-ajax'),
+        axiosObject: mk(AXIOS_OBJECT_SPEC, 'axios-object'),
     };
 }
 const JAVASCRIPT_BUNDLE = compileBundle(JavaScript, 'javascript-http');
@@ -130,6 +175,32 @@ function joinPath(prefix, sub) {
         return `/${cleanSub}`;
     return `/${cleanPrefix}/${cleanSub}`;
 }
+/**
+ * Walk `pair` children of an `object` literal and return the unquoted
+ * string/template_string value for the first pair whose key matches one
+ * of `keyNames`. Returns null when no matching pair is present or the
+ * value is not a string literal. Used by the jQuery ajax / axios object
+ * consumers to resolve `url` / `method` / `type` keys in any order.
+ */
+function readStringProp(objectNode, keyNames) {
+    for (let i = 0; i < objectNode.namedChildCount; i++) {
+        const pair = objectNode.namedChild(i);
+        if (!pair || pair.type !== 'pair')
+            continue;
+        const keyNode = pair.childForFieldName('key');
+        const valueNode = pair.childForFieldName('value');
+        if (!keyNode || !valueNode)
+            continue;
+        if (!keyNames.includes(keyNode.text))
+            continue;
+        if (valueNode.type !== 'string' && valueNode.type !== 'template_string')
+            continue;
+        const lit = unquoteLiteral(valueNode.text);
+        if (lit !== null)
+            return lit;
+    }
+    return null;
+}
 /**
  * For a standalone `decorator` node (child of class_body / program),
  * find the related `class_declaration` node that it decorates. In
@@ -335,6 +406,65 @@ function scanBundle(bundle, tree) {
             confidence: 0.7,
         });
     }
+    // Consumer: jQuery shorthand $.get(url) / $.post(url, ...)
+    for (const match of runCompiledPatterns(bundle.jqueryShorthand, tree)) {
+        const methodNode = match.captures.http_method;
+        const pathNode = match.captures.path;
+        if (!methodNode || !pathNode)
+            continue;
+        const path = unquoteLiteral(pathNode.text);
+        if (path === null)
+            continue;
+        out.push({
+            role: 'consumer',
+            framework: 'jquery',
+            method: methodNode.text.toUpperCase(),
+            path,
+            name: null,
+            confidence: 0.7,
+        });
+    }
+    // Consumer: jQuery $.ajax({ url, method|type }). jQuery accepts either
+    // `method:` or `type:`; both default to GET when absent.
+    for (const match of runCompiledPatterns(bundle.jqueryAjax, tree)) {
+        const optionsNode = match.captures.options;
+        if (!optionsNode)
+            continue;
+        const path = readStringProp(optionsNode, ['url']);
+        if (path === null)
+            continue;
+        const rawMethod = readStringProp(optionsNode, ['method', 'type']);
+        const method = (rawMethod ?? 'GET').toUpperCase();
+        out.push({
+            role: 'consumer',
+            framework: 'jquery',
+            method,
+            path,
+            name: null,
+            confidence: 0.7,
+        });
+    }
+    // Consumer: axios({ method, url }) object form. Structurally distinct
+    // from axios.<verb>(url) (identifier vs member_expression call), so no
+    // dedup against the member-form loop above is required.
+    for (const match of runCompiledPatterns(bundle.axiosObject, tree)) {
+        const optionsNode = match.captures.options;
+        if (!optionsNode)
+            continue;
+        const path = readStringProp(optionsNode, ['url']);
+        if (path === null)
+            continue;
+        const rawMethod = readStringProp(optionsNode, ['method']);
+        const method = (rawMethod ?? 'GET').toUpperCase();
+        out.push({
+            role: 'consumer',
+            framework: 'axios',
+            method,
+            path,
+            name: null,
+            confidence: 0.7,
+        });
+    }
     return out;
 }
 export const JAVASCRIPT_HTTP_PLUGIN = {

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;