gitnexus 1.4.6 → 1.4.8

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

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

package/dist/core/ingestion/language-config.d.ts

@@ -1,3 +1,4 @@
+import type { ImportConfigs } from './import-resolution.js';
 /** TypeScript path alias config parsed from tsconfig.json */
 export interface TsconfigPaths {
     /** Map of alias prefix -> target prefix (e.g., "@/" -> "src/") */
@@ -44,3 +45,5 @@ export declare function loadComposerConfig(repoRoot: string): Promise<ComposerCo
  */
 export declare function loadCSharpProjectConfig(repoRoot: string): Promise<CSharpProjectConfig[]>;
 export declare function loadSwiftPackageConfig(repoRoot: string): Promise<SwiftPackageConfig | null>;
+/** Load all language-specific configs once for an ingestion run. */
+export declare function loadImportConfigs(repoRoot: string): Promise<ImportConfigs>;

package/dist/core/ingestion/language-config.js

@@ -165,3 +165,16 @@ export async function loadSwiftPackageConfig(repoRoot) {
     }
     return null;
 }
+// ============================================================================
+// BUNDLED CONFIG LOADER
+// ============================================================================
+/** Load all language-specific configs once for an ingestion run. */
+export async function loadImportConfigs(repoRoot) {
+    return {
+        tsconfigPaths: await loadTsconfigPaths(repoRoot),
+        goModule: await loadGoModulePath(repoRoot),
+        composerConfig: await loadComposerConfig(repoRoot),
+        swiftPackageConfig: await loadSwiftPackageConfig(repoRoot),
+        csharpConfigs: await loadCSharpProjectConfig(repoRoot),
+    };
+}

package/dist/core/ingestion/markdown-processor.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Markdown Processor
+ *
+ * Extracts structure from .md files using regex (no tree-sitter dependency).
+ * Creates Section nodes for headings with hierarchy, and IMPORTS edges for
+ * cross-file links.
+ */
+import { KnowledgeGraph } from '../graph/types.js';
+interface MdFile {
+    path: string;
+    content: string;
+}
+export declare const processMarkdown: (graph: KnowledgeGraph, files: MdFile[], allPathSet: Set<string>) => {
+    sections: number;
+    links: number;
+};
+export {};

package/dist/core/ingestion/markdown-processor.js

@@ -0,0 +1,124 @@
+/**
+ * Markdown Processor
+ *
+ * Extracts structure from .md files using regex (no tree-sitter dependency).
+ * Creates Section nodes for headings with hierarchy, and IMPORTS edges for
+ * cross-file links.
+ */
+import path from 'node:path';
+import { generateId } from '../../lib/utils.js';
+const HEADING_RE = /^(#{1,6})\s+(.+)$/;
+const LINK_RE = /\[([^\]]*)\]\(([^)]+)\)/g;
+const MD_EXTENSIONS = new Set(['.md', '.mdx']);
+export const processMarkdown = (graph, files, allPathSet) => {
+    let totalSections = 0;
+    let totalLinks = 0;
+    for (const file of files) {
+        const ext = path.extname(file.path).toLowerCase();
+        if (!MD_EXTENSIONS.has(ext))
+            continue;
+        const fileNodeId = generateId('File', file.path);
+        // Skip if file node doesn't exist (shouldn't happen, structure-processor creates it)
+        if (!graph.getNode(fileNodeId))
+            continue;
+        const lines = file.content.split('\n');
+        // --- Extract headings and build hierarchy ---
+        // First pass: collect all heading positions so we can compute endLine spans
+        const headings = [];
+        for (let i = 0; i < lines.length; i++) {
+            const match = lines[i].match(HEADING_RE);
+            if (!match)
+                continue;
+            headings.push({
+                level: match[1].length,
+                heading: match[2].trim(),
+                lineNum: i + 1, // 1-indexed
+            });
+        }
+        // Second pass: create nodes with proper endLine spans
+        const sectionStack = [];
+        for (let h = 0; h < headings.length; h++) {
+            const { level, heading, lineNum } = headings[h];
+            // endLine = line before next heading at same or higher level, or EOF
+            let endLine = lines.length;
+            for (let j = h + 1; j < headings.length; j++) {
+                if (headings[j].level <= level) {
+                    endLine = headings[j].lineNum - 1;
+                    break;
+                }
+            }
+            const sectionId = generateId('Section', `${file.path}:L${lineNum}:${heading}`);
+            const node = {
+                id: sectionId,
+                label: 'Section',
+                properties: {
+                    name: heading,
+                    filePath: file.path,
+                    startLine: lineNum,
+                    endLine,
+                    level,
+                    description: `h${level}`,
+                },
+            };
+            graph.addNode(node);
+            totalSections++;
+            // Find parent: pop stack until we find a level strictly less than current
+            while (sectionStack.length > 0 && sectionStack[sectionStack.length - 1].level >= level) {
+                sectionStack.pop();
+            }
+            const parentId = sectionStack.length > 0
+                ? sectionStack[sectionStack.length - 1].id
+                : fileNodeId;
+            graph.addRelationship({
+                id: generateId('CONTAINS', `${parentId}->${sectionId}`),
+                type: 'CONTAINS',
+                sourceId: parentId,
+                targetId: sectionId,
+                confidence: 1.0,
+                reason: 'markdown-heading',
+            });
+            sectionStack.push({ level, id: sectionId });
+        }
+        // --- Extract links to other files in the repo ---
+        const fileDir = path.dirname(file.path);
+        const seenLinks = new Set();
+        let linkMatch;
+        LINK_RE.lastIndex = 0;
+        while ((linkMatch = LINK_RE.exec(file.content)) !== null) {
+            const href = linkMatch[2];
+            // Skip external URLs, anchors, and mailto
+            if (href.startsWith('http://') || href.startsWith('https://') ||
+                href.startsWith('#') || href.startsWith('mailto:')) {
+                continue;
+            }
+            // Strip anchor fragments from local links
+            const cleanHref = href.split('#')[0];
+            if (!cleanHref)
+                continue;
+            // Resolve relative to the file's directory, then normalize
+            const resolved = path.posix.normalize(path.posix.join(fileDir, cleanHref));
+            if (allPathSet.has(resolved)) {
+                const targetFileId = generateId('File', resolved);
+                // Skip if target file node doesn't exist
+                if (!graph.getNode(targetFileId))
+                    continue;
+                // Dedup: skip if we've already linked this file pair
+                const linkKey = `${fileNodeId}->${targetFileId}`;
+                if (seenLinks.has(linkKey))
+                    continue;
+                seenLinks.add(linkKey);
+                const relId = generateId('IMPORTS', linkKey);
+                graph.addRelationship({
+                    id: relId,
+                    type: 'IMPORTS',
+                    sourceId: fileNodeId,
+                    targetId: targetFileId,
+                    confidence: 0.8,
+                    reason: 'markdown-link',
+                });
+                totalLinks++;
+            }
+        }
+    }
+    return { sections: totalSections, links: totalLinks };
+};

package/dist/core/ingestion/mro-processor.js

@@ -158,10 +158,11 @@ function resolveByMroOrder(methodName, defs, mroOrder, reasonPrefix) {
             return {
                 resolvedTo: match.methodId,
                 reason: `${reasonPrefix}: ${match.className}::${methodName}`,
+                confidence: 0.9, // MRO-ordered resolution
             };
         }
     }
-    return { resolvedTo: defs[0].methodId, reason: `${reasonPrefix} fallback: first definition` };
+    return { resolvedTo: defs[0].methodId, reason: `${reasonPrefix} fallback: first definition`, confidence: 0.7 };
 }
 function resolveCsharpJava(methodName, defs, parentEdgeTypes) {
     const classDefs = [];
@@ -179,21 +180,24 @@ function resolveCsharpJava(methodName, defs, parentEdgeTypes) {
         return {
             resolvedTo: classDefs[0].methodId,
             reason: `class method wins: ${classDefs[0].className}::${methodName}`,
+            confidence: 0.95, // Class method is authoritative
         };
     }
     if (interfaceDefs.length > 1) {
         return {
             resolvedTo: null,
             reason: `ambiguous: ${methodName} defined in multiple interfaces: ${interfaceDefs.map(d => d.className).join(', ')}`,
+            confidence: 0.5,
         };
     }
     if (interfaceDefs.length === 1) {
         return {
             resolvedTo: interfaceDefs[0].methodId,
             reason: `single interface default: ${interfaceDefs[0].className}::${methodName}`,
+            confidence: 0.85, // Single interface, unambiguous
         };
     }
-    return { resolvedTo: null, reason: 'no resolution found' };
+    return { resolvedTo: null, reason: 'no resolution found', confidence: 0.5 };
 }
 // ---------------------------------------------------------------------------
 // Main entry point
@@ -293,6 +297,7 @@ export function computeMRO(graph) {
                     resolution = {
                         resolvedTo: null,
                         reason: `Rust requires qualified syntax: <Type as Trait>::${methodName}()`,
+                        confidence: 0.5,
                     };
                     break;
                 default:
@@ -316,7 +321,7 @@ export function computeMRO(graph) {
                     sourceId: classId,
                     targetId: resolution.resolvedTo,
                     type: 'OVERRIDES',
-                    confidence: 1.0,
+                    confidence: resolution.confidence,
                     reason: resolution.reason,
                 });
                 overrideEdges++;

package/dist/core/ingestion/named-binding-extraction.d.ts

@@ -1,6 +1,7 @@
-import { SupportedLanguages } from '../../config/supported-languages.js';
 import type { SymbolTable, SymbolDefinition } from './symbol-table.js';
 import type { NamedImportMap } from './import-processor.js';
+import type { NamedBinding } from './import-resolution.js';
+import type { SyntaxNode } from './utils.js';
 /**
  * Walk a named-binding re-export chain through NamedImportMap.
  *
@@ -17,45 +18,10 @@ import type { NamedImportMap } from './import-processor.js';
  *               silent misses at depth=0 for non-aliased bindings.
  */
 export declare function walkBindingChain(name: string, currentFilePath: string, symbolTable: SymbolTable, namedImportMap: NamedImportMap, allDefs: SymbolDefinition[]): SymbolDefinition[] | null;
-/**
- * Extract named bindings from an import AST node.
- * Returns undefined if the import is not a named import (e.g., import * or default).
- *
- * TS: import { User, Repo as R } from './models'
- *   → [{local:'User', exported:'User'}, {local:'R', exported:'Repo'}]
- *
- * Python: from models import User, Repo as R
- *   → [{local:'User', exported:'User'}, {local:'R', exported:'Repo'}]
- */
-export declare function extractNamedBindings(importNode: any, language: SupportedLanguages): {
-    local: string;
-    exported: string;
-}[] | undefined;
-export declare function extractTsNamedBindings(importNode: any): {
-    local: string;
-    exported: string;
-}[] | undefined;
-export declare function extractPythonNamedBindings(importNode: any): {
-    local: string;
-    exported: string;
-}[] | undefined;
-export declare function extractKotlinNamedBindings(importNode: any): {
-    local: string;
-    exported: string;
-}[] | undefined;
-export declare function extractRustNamedBindings(importNode: any): {
-    local: string;
-    exported: string;
-}[] | undefined;
-export declare function extractPhpNamedBindings(importNode: any): {
-    local: string;
-    exported: string;
-}[] | undefined;
-export declare function extractCsharpNamedBindings(importNode: any): {
-    local: string;
-    exported: string;
-}[] | undefined;
-export declare function extractJavaNamedBindings(importNode: any): {
-    local: string;
-    exported: string;
-}[] | undefined;
+export declare function extractTsNamedBindings(importNode: SyntaxNode): NamedBinding[] | undefined;
+export declare function extractPythonNamedBindings(importNode: SyntaxNode): NamedBinding[] | undefined;
+export declare function extractKotlinNamedBindings(importNode: SyntaxNode): NamedBinding[] | undefined;
+export declare function extractRustNamedBindings(importNode: SyntaxNode): NamedBinding[] | undefined;
+export declare function extractPhpNamedBindings(importNode: SyntaxNode): NamedBinding[] | undefined;
+export declare function extractCsharpNamedBindings(importNode: SyntaxNode): NamedBinding[] | undefined;
+export declare function extractJavaNamedBindings(importNode: SyntaxNode): NamedBinding[] | undefined;