gitnexus 1.6.6-rc.59 → 1.6.6-rc.60

package/dist/cli/i18n/en.d.ts

@@ -155,7 +155,7 @@ export declare const en: {
     readonly 'help.option.clean.all': "Clean all indexed repos";
     readonly 'help.option.clean.lbugSidecars': "Clean quarantined LadybugDB missing-shadow WAL sidecars";
     readonly 'help.option.wiki.force': "Force full regeneration even if up to date";
-    readonly 'help.option.wiki.provider': "LLM provider: openai or cursor (default: openai)";
+    readonly 'help.option.wiki.provider': "LLM provider: openai, openrouter, azure, custom, cursor, claude, or codex (default: openai)";
     readonly 'help.option.wiki.model': "LLM model or Azure deployment name (default: minimax/minimax-m2.5)";
     readonly 'help.option.wiki.baseUrl': "LLM API base URL. Azure v1: https://{resource}.openai.azure.com/openai/v1";
     readonly 'help.option.wiki.apiKey': "LLM API key or Azure api-key (saved to ~/.gitnexus/config.json)";

package/dist/cli/i18n/en.js

@@ -155,7 +155,7 @@ export const en = {
     'help.option.clean.all': 'Clean all indexed repos',
     'help.option.clean.lbugSidecars': 'Clean quarantined LadybugDB missing-shadow WAL sidecars',
     'help.option.wiki.force': 'Force full regeneration even if up to date',
-    'help.option.wiki.provider': 'LLM provider: openai or cursor (default: openai)',
+    'help.option.wiki.provider': 'LLM provider: openai, openrouter, azure, custom, cursor, claude, or codex (default: openai)',
     'help.option.wiki.model': 'LLM model or Azure deployment name (default: minimax/minimax-m2.5)',
     'help.option.wiki.baseUrl': 'LLM API base URL. Azure v1: https://{resource}.openai.azure.com/openai/v1',
     'help.option.wiki.apiKey': 'LLM API key or Azure api-key (saved to ~/.gitnexus/config.json)',

package/dist/cli/i18n/resources.d.ts

@@ -156,7 +156,7 @@ export declare const cliResources: {
         readonly 'help.option.clean.all': "Clean all indexed repos";
         readonly 'help.option.clean.lbugSidecars': "Clean quarantined LadybugDB missing-shadow WAL sidecars";
         readonly 'help.option.wiki.force': "Force full regeneration even if up to date";
-        readonly 'help.option.wiki.provider': "LLM provider: openai or cursor (default: openai)";
+        readonly 'help.option.wiki.provider': "LLM provider: openai, openrouter, azure, custom, cursor, claude, or codex (default: openai)";
         readonly 'help.option.wiki.model': "LLM model or Azure deployment name (default: minimax/minimax-m2.5)";
         readonly 'help.option.wiki.baseUrl': "LLM API base URL. Azure v1: https://{resource}.openai.azure.com/openai/v1";
         readonly 'help.option.wiki.apiKey': "LLM API key or Azure api-key (saved to ~/.gitnexus/config.json)";

package/dist/cli/i18n/zh-CN.js

@@ -155,7 +155,7 @@ export const zhCN = {
     'help.option.clean.all': '清理所有已索引仓库',
     'help.option.clean.lbugSidecars': '清理已隔离的 LadybugDB missing-shadow WAL sidecar',
     'help.option.wiki.force': '即使已是最新也强制完整重新生成',
-    'help.option.wiki.provider': 'LLM 提供商：openai 或 cursor（默认：openai）',
+    'help.option.wiki.provider': 'LLM 提供商：openai、openrouter、azure、custom、cursor、claude 或 codex（默认：openai）',
     'help.option.wiki.model': 'LLM 模型或 Azure deployment 名称（默认：minimax/minimax-m2.5）',
     'help.option.wiki.baseUrl': 'LLM API base URL。Azure v1：https://{resource}.openai.azure.com/openai/v1',
     'help.option.wiki.apiKey': 'LLM API key 或 Azure api-key（保存到 ~/.gitnexus/config.json）',

package/dist/cli/index.js

@@ -94,7 +94,7 @@ program
     .command('wiki [path]')
     .description('Generate repository wiki from knowledge graph')
     .option('-f, --force', 'Force full regeneration even if up to date')
-    .option('--provider <provider>', 'LLM provider: openai or cursor (default: openai)')
+    .option('--provider <provider>', 'LLM provider: openai, openrouter, azure, custom, cursor, claude, or codex (default: openai)')
     .option('--model <model>', 'LLM model or Azure deployment name (default: minimax/minimax-m2.5)')
     .option('--base-url <url>', 'LLM API base URL. Azure v1: https://{resource}.openai.azure.com/openai/v1')
     .option('--api-key <key>', 'LLM API key or Azure api-key (saved to ~/.gitnexus/config.json)')

package/dist/cli/wiki.js

@@ -13,6 +13,7 @@ import { getStoragePaths, loadMeta, loadCLIConfig, saveCLIConfig, } from '../sto
 import { WikiGenerator } from '../core/wiki/generator.js';
 import { resolveLLMConfig } from '../core/wiki/llm-client.js';
 import { detectCursorCLI } from '../core/wiki/cursor-client.js';
+import { detectLocalCLI } from '../core/wiki/local-cli-client.js';
 import { logger } from '../core/logger.js';
 function parsePositiveIntegerOption(value, flag, multiplier = 1) {
     if (value === undefined)
@@ -27,6 +28,16 @@ function parsePositiveIntegerOption(value, flag, multiplier = 1) {
     }
     return parsed;
 }
+function isLocalProvider(provider) {
+    return provider === 'cursor' || provider === 'claude' || provider === 'codex';
+}
+function localModelConfigKey(provider) {
+    if (provider === 'cursor')
+        return 'cursorModel';
+    if (provider === 'claude')
+        return 'claudeModel';
+    return 'codexModel';
+}
 /**
  * Prompt the user for input via stdin.
  */
@@ -163,10 +174,11 @@ const wikiCommandImpl = async (inputPath, options) => {
             updates.apiVersion = options.apiVersion;
         if (options.reasoningModel !== undefined)
             updates.isReasoningModel = options.reasoningModel;
-        // Save model to appropriate field based on provider
+        // Save model to appropriate field based on provider.
         if (options.model) {
-            if (options.provider === 'cursor') {
-                updates.cursorModel = options.model;
+            const targetProvider = options.provider ?? existing.provider;
+            if (isLocalProvider(targetProvider)) {
+                updates[localModelConfigKey(targetProvider)] = options.model;
             }
             else {
                 updates.model = options.model;
@@ -176,7 +188,7 @@ const wikiCommandImpl = async (inputPath, options) => {
         console.log('  Config saved to ~/.gitnexus/config.json\n');
     }
     const savedConfig = await loadCLIConfig();
-    const hasSavedConfig = !!(savedConfig.provider === 'cursor' ||
+    const hasSavedConfig = !!(isLocalProvider(savedConfig.provider) ||
         (savedConfig.apiKey && savedConfig.baseUrl));
     const hasCLIOverrides = !!(options?.apiKey ||
         options?.model ||
@@ -197,10 +209,10 @@ const wikiCommandImpl = async (inputPath, options) => {
     if (!hasSavedConfig && !hasCLIOverrides) {
         if (!process.stdin.isTTY) {
             // Non-interactive mode — need either API key or Cursor CLI
-            if (!llmConfig.apiKey && llmConfig.provider !== 'cursor') {
+            if (!llmConfig.apiKey && !isLocalProvider(llmConfig.provider)) {
                 console.log('  Error: No LLM API key found.');
                 console.log('  Set OPENAI_API_KEY or GITNEXUS_API_KEY environment variable,');
-                console.log('  or pass --api-key <key>, or use --provider cursor.\n');
+                console.log('  or pass --api-key <key>, or use --provider cursor|claude|codex.\n');
                 process.exitCode = 1;
                 return;
             }
@@ -208,37 +220,62 @@ const wikiCommandImpl = async (inputPath, options) => {
         }
         else {
             console.log("  No LLM configured. Let's set it up.\n");
-            console.log('  Supports OpenAI, OpenRouter, Azure, any OpenAI-compatible API, or Cursor CLI.\n');
-            // Check if Cursor CLI is available
+            console.log('  Supports OpenAI, OpenRouter, Azure, any OpenAI-compatible API, Cursor CLI, Claude CLI, or Codex CLI.\n');
+            // Check if local agent CLIs are available.
             const hasCursor = detectCursorCLI();
+            const hasClaude = detectLocalCLI('claude');
+            const hasCodex = detectLocalCLI('codex');
+            const localChoices = [];
             // Provider selection
             console.log('  [1] OpenAI (api.openai.com)');
             console.log('  [2] OpenRouter (openrouter.ai)');
             console.log('  [3] Azure OpenAI');
             console.log('  [4] Custom endpoint');
+            let nextChoice = 5;
             if (hasCursor) {
-                console.log('  [5] Cursor CLI (local, uses your Cursor subscription)');
+                const choice = String(nextChoice++);
+                localChoices.push({
+                    choice,
+                    provider: 'cursor',
+                });
+                console.log(`  [${choice}] Cursor CLI (local, uses your Cursor subscription)`);
+            }
+            if (hasClaude) {
+                const choice = String(nextChoice++);
+                localChoices.push({
+                    choice,
+                    provider: 'claude',
+                });
+                console.log(`  [${choice}] Claude CLI (local, uses your Claude Code login)`);
+            }
+            if (hasCodex) {
+                const choice = String(nextChoice++);
+                localChoices.push({
+                    choice,
+                    provider: 'codex',
+                });
+                console.log(`  [${choice}] Codex CLI (local, uses your Codex login)`);
             }
             console.log('');
-            const maxChoice = hasCursor ? '5' : '4';
+            const maxChoice = String(nextChoice - 1);
             const choice = await prompt(`  Select provider (1/${maxChoice}): `);
             let baseUrl;
             let defaultModel;
             let provider = 'openai';
             let key = '';
-            if (choice === '5' && hasCursor) {
-                // Cursor CLI selected - model defaults to 'auto' (Cursor's default)
-                provider = 'cursor';
+            const selectedLocal = localChoices.find((item) => item.choice === choice);
+            if (selectedLocal) {
+                // Local CLI selected - model defaults to the CLI's configured default.
+                provider = selectedLocal.provider;
                 baseUrl = '';
-                const modelInput = await prompt('  Model (leave empty for auto): ');
+                const modelInput = await prompt('  Model (leave empty for CLI default): ');
                 const model = modelInput || '';
-                // Save config for Cursor
-                const cursorConfig = { provider: 'cursor' };
+                const localConfig = { ...savedConfig, provider };
                 if (model)
-                    cursorConfig.cursorModel = model;
-                await saveCLIConfig(cursorConfig);
+                    localConfig[localModelConfigKey(provider)] = model;
+                await saveCLIConfig(localConfig);
                 console.log('  Config saved to ~/.gitnexus/config.json\n');
-                llmConfig = { ...llmConfig, provider: 'cursor', model, apiKey: '', baseUrl: '' };
+                llmConfig = { ...llmConfig, provider, model, apiKey: '', baseUrl: '' };
             }
             else if (choice === '3') {
                 // Azure OpenAI guided setup — minimal prompts
@@ -281,6 +318,7 @@ const wikiCommandImpl = async (inputPath, options) => {
                 // Always use v1 API format — no need for api-version
                 const azureBaseUrl = `${endpoint}/openai/v1`;
                 await saveCLIConfig({
+                    ...savedConfig,
                     apiKey: azureKey,
                     baseUrl: azureBaseUrl,
                     model: deploymentName,

package/dist/core/ingestion/languages/rust/arity.d.ts

@@ -0,0 +1,2 @@
+import type { Callsite, SymbolDefinition } from '../../../../_shared/index.js';
+export declare function rustArityCompatibility(def: SymbolDefinition, callsite: Callsite): 'compatible' | 'unknown' | 'incompatible';

package/dist/core/ingestion/languages/rust/arity.js

@@ -0,0 +1,13 @@
+export function rustArityCompatibility(def, callsite) {
+    const max = def.parameterCount;
+    const min = def.requiredParameterCount;
+    if (max === undefined && min === undefined)
+        return 'unknown';
+    if (!Number.isFinite(callsite.arity) || callsite.arity < 0)
+        return 'unknown';
+    if (min !== undefined && callsite.arity < min)
+        return 'incompatible';
+    if (max !== undefined && callsite.arity > max)
+        return 'incompatible';
+    return 'compatible';
+}

package/dist/core/ingestion/languages/rust/cache-stats.d.ts

@@ -0,0 +1,7 @@
+export declare function recordRustCacheHit(): void;
+export declare function recordRustCacheMiss(): void;
+export declare function getRustCaptureCacheStats(): {
+    readonly hits: number;
+    readonly misses: number;
+};
+export declare function resetRustCaptureCacheStats(): void;

package/dist/core/ingestion/languages/rust/cache-stats.js

@@ -0,0 +1,15 @@
+let hits = 0;
+let misses = 0;
+export function recordRustCacheHit() {
+    hits++;
+}
+export function recordRustCacheMiss() {
+    misses++;
+}
+export function getRustCaptureCacheStats() {
+    return { hits, misses };
+}
+export function resetRustCaptureCacheStats() {
+    hits = 0;
+    misses = 0;
+}

package/dist/core/ingestion/languages/rust/captures.d.ts

@@ -0,0 +1,2 @@
+import type { CaptureMatch } from '../../../../_shared/index.js';
+export declare function emitRustScopeCaptures(sourceText: string, _filePath: string, cachedTree?: unknown): readonly CaptureMatch[];

package/dist/core/ingestion/languages/rust/captures.js

@@ -0,0 +1,179 @@
+import { findNodeAtRange, nodeToCapture, syntheticCapture, } from '../../utils/ast-helpers.js';
+import { getRustParser, getRustScopeQuery } from './query.js';
+import { recordRustCacheHit, recordRustCacheMiss } from './cache-stats.js';
+import { splitRustUseDeclaration } from './import-decomposer.js';
+import { synthesizeRustReceiverBinding } from './receiver-binding.js';
+import { getTreeSitterBufferSize } from '../../constants.js';
+import { parseSourceSafe } from '../../../tree-sitter/safe-parse.js';
+export function emitRustScopeCaptures(sourceText, _filePath, cachedTree) {
+    let tree = cachedTree;
+    if (tree === undefined) {
+        tree = parseSourceSafe(getRustParser(), sourceText, undefined, {
+            bufferSize: getTreeSitterBufferSize(sourceText),
+        });
+        recordRustCacheMiss();
+    }
+    else {
+        recordRustCacheHit();
+    }
+    const rawMatches = getRustScopeQuery().matches(tree.rootNode);
+    const out = [];
+    for (const m of rawMatches) {
+        const grouped = {};
+        for (const c of m.captures) {
+            const tag = '@' + c.name;
+            if (tag.startsWith('@_'))
+                continue;
+            grouped[tag] = nodeToCapture(tag, c.node);
+        }
+        if (Object.keys(grouped).length === 0)
+            continue;
+        // Decompose use declarations into individual import captures
+        if (grouped['@import.statement'] !== undefined) {
+            const anchor = grouped['@import.statement'];
+            const useNode = findNodeAtRange(tree.rootNode, anchor.range, 'use_declaration');
+            if (useNode !== null) {
+                out.push(...splitRustUseDeclaration(useNode));
+                continue;
+            }
+        }
+        // Synthesize self receiver bindings for methods inside impl blocks
+        let cachedImplLookup;
+        if (grouped['@scope.function'] !== undefined) {
+            const scopeCap = grouped['@scope.function'];
+            const fnNode = findNodeAtRange(tree.rootNode, scopeCap.range, 'function_item');
+            if (fnNode !== null) {
+                const implNode = findEnclosingImpl(fnNode);
+                cachedImplLookup = { fnNode, implNode };
+                const receiver = synthesizeRustReceiverBinding(fnNode, implNode);
+                if (receiver !== null)
+                    out.push(receiver);
+            }
+        }
+        // Attach declaration arity for functions/methods
+        const declAnchor = grouped['@declaration.function'];
+        if (declAnchor !== undefined) {
+            const fnNode = findNodeAtRange(tree.rootNode, declAnchor.range, 'function_item');
+            if (fnNode !== null) {
+                const implNode = cachedImplLookup?.fnNode === fnNode
+                    ? cachedImplLookup.implNode
+                    : findEnclosingImpl(fnNode);
+                const traitNode = implNode === null ? findEnclosingTrait(fnNode) : null;
+                // Reclassify as method if inside an impl block or trait definition
+                if (implNode !== null || traitNode !== null) {
+                    const nameCap = grouped['@declaration.name'];
+                    delete grouped['@declaration.function'];
+                    grouped['@declaration.method'] = syntheticCapture('@declaration.method', fnNode, fnNode.text);
+                    if (nameCap !== undefined) {
+                        grouped['@declaration.name'] = nameCap;
+                    }
+                }
+                const arity = computeRustDeclarationArity(fnNode);
+                if (arity.parameterCount !== undefined) {
+                    grouped['@declaration.parameter-count'] = syntheticCapture('@declaration.parameter-count', fnNode, String(arity.parameterCount));
+                }
+                if (arity.requiredParameterCount !== undefined) {
+                    grouped['@declaration.required-parameter-count'] = syntheticCapture('@declaration.required-parameter-count', fnNode, String(arity.requiredParameterCount));
+                }
+            }
+        }
+        // Hoist return-type bindings from impl block functions to module level.
+        // The auto-hoist in the scope-extractor places a type binding whose
+        // anchor matches its innermost scope on the parent scope. By using the
+        // impl_item node as the anchor (which matches the impl's Class scope),
+        // the binding lands on the Module scope — making it visible to the
+        // compound receiver's hoistTypeBindingsToModule walk.
+        if (grouped['@type-binding.return'] !== undefined &&
+            grouped['@type-binding.name'] !== undefined) {
+            const tbReturnAnchor = grouped['@type-binding.return'];
+            const fnNode = findNodeAtRange(tree.rootNode, tbReturnAnchor.range, 'function_item');
+            if (fnNode !== null) {
+                const implNode = findEnclosingImpl(fnNode);
+                if (implNode !== null) {
+                    out.push({
+                        '@type-binding.name': syntheticCapture('@type-binding.name', implNode, grouped['@type-binding.name'].text),
+                        '@type-binding.type': syntheticCapture('@type-binding.type', implNode, grouped['@type-binding.type'].text),
+                        '@type-binding.return': syntheticCapture('@type-binding.return', implNode, tbReturnAnchor.text),
+                    });
+                }
+            }
+        }
+        // Attach call arity for call expressions
+        const callAnchor = grouped['@reference.call.free'] ??
+            grouped['@reference.call.member'] ??
+            grouped['@reference.call.constructor'];
+        if (callAnchor !== undefined) {
+            const callNode = findNodeAtRange(tree.rootNode, callAnchor.range, 'call_expression') ??
+                findNodeAtRange(tree.rootNode, callAnchor.range, 'struct_expression');
+            if (callNode !== null) {
+                const arity = computeRustCallArity(callNode);
+                grouped['@reference.arity'] = syntheticCapture('@reference.arity', callNode, String(arity));
+            }
+        }
+        out.push(grouped);
+    }
+    return out;
+}
+function findEnclosingImpl(node) {
+    let current = node.parent;
+    while (current !== null) {
+        if (current.type === 'impl_item')
+            return current;
+        if (current.type === 'source_file' || current.type === 'mod_item')
+            return null;
+        current = current.parent;
+    }
+    return null;
+}
+function findEnclosingTrait(node) {
+    let current = node.parent;
+    while (current !== null) {
+        if (current.type === 'trait_item')
+            return current;
+        if (current.type === 'source_file' || current.type === 'mod_item')
+            return null;
+        current = current.parent;
+    }
+    return null;
+}
+function computeRustDeclarationArity(fnNode) {
+    const params = fnNode.childForFieldName('parameters');
+    if (params === null)
+        return {};
+    let count = 0;
+    for (let i = 0; i < params.namedChildCount; i++) {
+        const child = params.namedChild(i);
+        if (child === null)
+            continue;
+        if (child.type === 'self_parameter')
+            continue;
+        if (child.type === 'parameter')
+            count++;
+    }
+    // Rust has no default parameters or overloading
+    return { parameterCount: count, requiredParameterCount: count };
+}
+function computeRustCallArity(callNode) {
+    if (callNode.type === 'struct_expression') {
+        const body = callNode.childForFieldName('body');
+        if (body === null)
+            return 0;
+        let count = 0;
+        for (let i = 0; i < body.namedChildCount; i++) {
+            const t = body.namedChild(i)?.type;
+            if (t === 'field_initializer' || t === 'shorthand_field_initializer')
+                count++;
+        }
+        return count;
+    }
+    const args = callNode.childForFieldName('arguments');
+    if (args === null)
+        return 0;
+    let count = 0;
+    for (let i = 0; i < args.namedChildCount; i++) {
+        const child = args.namedChild(i);
+        if (child !== null)
+            count++;
+    }
+    return count;
+}

package/dist/core/ingestion/languages/rust/import-decomposer.d.ts

@@ -0,0 +1,8 @@
+import type { CaptureMatch } from '../../../../_shared/index.js';
+import type { SyntaxNode } from '../../utils/ast-helpers.js';
+/**
+ * Decompose a Rust `use_declaration` into individual import captures.
+ * Handles simple paths, grouped imports ({A, B}), wildcards (*),
+ * renames (as), and `pub use` re-exports.
+ */
+export declare function splitRustUseDeclaration(node: SyntaxNode): CaptureMatch[];

package/dist/core/ingestion/languages/rust/import-decomposer.js

@@ -0,0 +1,164 @@
+import { syntheticCapture } from '../../utils/ast-helpers.js';
+/**
+ * Decompose a Rust `use_declaration` into individual import captures.
+ * Handles simple paths, grouped imports ({A, B}), wildcards (*),
+ * renames (as), and `pub use` re-exports.
+ */
+export function splitRustUseDeclaration(node) {
+    if (node.type !== 'use_declaration')
+        return [];
+    const isReexport = hasVisibilityModifier(node);
+    const argument = getUseArgument(node);
+    if (argument === null)
+        return [];
+    return decomposeUseArgument(argument, '', isReexport, node);
+}
+function hasVisibilityModifier(node) {
+    for (let i = 0; i < node.childCount; i++) {
+        if (node.child(i)?.type === 'visibility_modifier')
+            return true;
+    }
+    return false;
+}
+function getUseArgument(node) {
+    for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (child === null)
+            continue;
+        if (child.type === 'scoped_identifier' ||
+            child.type === 'scoped_use_list' ||
+            child.type === 'use_wildcard' ||
+            child.type === 'use_as_clause' ||
+            child.type === 'identifier' ||
+            child.type === 'use_list') {
+            return child;
+        }
+    }
+    return null;
+}
+function decomposeUseArgument(node, prefixPath, isReexport, anchor) {
+    switch (node.type) {
+        case 'scoped_identifier': {
+            const path = buildScopedPath(node);
+            const segments = path.split('::');
+            const name = segments[segments.length - 1];
+            return [
+                makeImportCapture(anchor, isReexport ? 'reexport' : 'named', joinPaths(prefixPath, path), name, undefined),
+            ];
+        }
+        case 'scoped_use_list': {
+            const pathNode = node.childForFieldName('path');
+            const listNode = node.childForFieldName('list');
+            const pathStr = pathNode ? buildNodePath(pathNode) : '';
+            const fullPrefix = joinPaths(prefixPath, pathStr);
+            if (listNode === null)
+                return [];
+            return decomposeUseList(listNode, fullPrefix, isReexport, anchor);
+        }
+        case 'use_list': {
+            return decomposeUseList(node, prefixPath, isReexport, anchor);
+        }
+        case 'use_wildcard': {
+            const wcPath = buildWildcardPath(node);
+            return [makeImportCapture(anchor, 'wildcard', joinPaths(prefixPath, wcPath), '*', undefined)];
+        }
+        case 'use_as_clause': {
+            const pathChild = node.childForFieldName('path');
+            const aliasChild = node.childForFieldName('alias');
+            if (pathChild === null || aliasChild === null)
+                return [];
+            const originalName = pathChild.type === 'scoped_identifier' ? buildScopedPath(pathChild) : pathChild.text;
+            const aliasName = aliasChild.text;
+            const segments = originalName.split('::');
+            const importedName = segments[segments.length - 1];
+            return [
+                makeImportCapture(anchor, isReexport ? 'reexport' : 'named', joinPaths(prefixPath, originalName), importedName, aliasName),
+            ];
+        }
+        case 'identifier': {
+            return [
+                makeImportCapture(anchor, isReexport ? 'reexport' : 'named', joinPaths(prefixPath, node.text), node.text, undefined),
+            ];
+        }
+        default:
+            return [];
+    }
+}
+function decomposeUseList(listNode, prefix, isReexport, anchor) {
+    const out = [];
+    for (let i = 0; i < listNode.namedChildCount; i++) {
+        const child = listNode.namedChild(i);
+        if (child === null)
+            continue;
+        if (child.type === 'self') {
+            // `use crate::models::{self}` — imports the module itself
+            const segments = prefix.split('::').filter(Boolean);
+            const name = segments[segments.length - 1] ?? 'self';
+            out.push(makeImportCapture(anchor, 'namespace', prefix, name, undefined));
+        }
+        else {
+            out.push(...decomposeUseArgument(child, prefix, isReexport, anchor));
+        }
+    }
+    return out;
+}
+function buildScopedPath(node) {
+    if (node.type === 'scoped_identifier') {
+        const parts = [];
+        collectScopedParts(node, parts);
+        return parts.join('::');
+    }
+    return node.text;
+}
+function collectScopedParts(node, parts) {
+    if (node.type === 'scoped_identifier') {
+        const pathNode = node.childForFieldName('path');
+        const nameNode = node.childForFieldName('name');
+        if (pathNode)
+            collectScopedParts(pathNode, parts);
+        if (nameNode)
+            parts.push(nameNode.text);
+    }
+    else {
+        parts.push(node.text);
+    }
+}
+function buildNodePath(node) {
+    if (node.type === 'scoped_identifier') {
+        return buildScopedPath(node);
+    }
+    return node.text;
+}
+function buildWildcardPath(node) {
+    for (let i = 0; i < node.childCount; i++) {
+        const child = node.child(i);
+        if (child === null)
+            continue;
+        if (child.type === 'scoped_identifier')
+            return buildScopedPath(child);
+        if (child.type === 'identifier')
+            return child.text;
+    }
+    return '';
+}
+function joinPaths(prefix, suffix) {
+    if (!prefix)
+        return suffix;
+    if (!suffix)
+        return prefix;
+    return `${prefix}::${suffix}`;
+}
+function makeImportCapture(anchor, kind, source, name, alias) {
+    return {
+        '@import.statement': syntheticCapture('@import.statement', anchor, anchor.text),
+        '@import.kind': syntheticCapture('@import.kind', anchor, kind),
+        '@import.source': syntheticCapture('@import.source', anchor, source),
+        '@import.name': syntheticCapture('@import.name', anchor, alias ?? name),
+        ...(alias !== undefined
+            ? {
+                '@import.alias': syntheticCapture('@import.alias', anchor, alias),
+                '@import.original-name': syntheticCapture('@import.original-name', anchor, name),
+            }
+            : {}),
+    };
+}

package/dist/core/ingestion/languages/rust/import-target.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Resolve a Rust `use` import path to a repo-relative file path.
+ *
+ * Rust module resolution rules:
+ *   - `crate::foo::bar` → `src/foo/bar.rs` or `src/foo/bar/mod.rs`
+ *   - `super::foo` → parent directory's `foo.rs` or `foo/mod.rs`
+ *   - `self::foo` → same directory's `foo.rs` or `foo/mod.rs`
+ *   - External crate imports (no `crate::`/`super::`/`self::`) → null
+ */
+export declare function resolveRustImportTarget(targetRaw: string, fromFile: string, allFilePaths: ReadonlySet<string>, _resolutionConfig?: unknown): string | readonly string[] | null;
+export interface RustResolveContext {
+    readonly fromFile: string;
+    readonly allFilePaths: ReadonlySet<string>;
+}