gitnexus 1.3.11 → 1.4.0

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

@@ -0,0 +1,46 @@
+/** TypeScript path alias config parsed from tsconfig.json */
+export interface TsconfigPaths {
+    /** Map of alias prefix -> target prefix (e.g., "@/" -> "src/") */
+    aliases: Map<string, string>;
+    /** Base URL for path resolution (relative to repo root) */
+    baseUrl: string;
+}
+/** Go module config parsed from go.mod */
+export interface GoModuleConfig {
+    /** Module path (e.g., "github.com/user/repo") */
+    modulePath: string;
+}
+/** PHP Composer PSR-4 autoload config */
+export interface ComposerConfig {
+    /** Map of namespace prefix -> directory (e.g., "App\\" -> "app/") */
+    psr4: Map<string, string>;
+}
+/** C# project config parsed from .csproj files */
+export interface CSharpProjectConfig {
+    /** Root namespace from <RootNamespace> or assembly name (default: project directory name) */
+    rootNamespace: string;
+    /** Directory containing the .csproj file */
+    projectDir: string;
+}
+/** Swift Package Manager module config */
+export interface SwiftPackageConfig {
+    /** Map of target name -> source directory path (e.g., "SiuperModel" -> "Package/Sources/SiuperModel") */
+    targets: Map<string, string>;
+}
+/**
+ * Parse tsconfig.json to extract path aliases.
+ * Tries tsconfig.json, tsconfig.app.json, tsconfig.base.json in order.
+ */
+export declare function loadTsconfigPaths(repoRoot: string): Promise<TsconfigPaths | null>;
+/**
+ * Parse go.mod to extract module path.
+ */
+export declare function loadGoModulePath(repoRoot: string): Promise<GoModuleConfig | null>;
+/** Parse composer.json to extract PSR-4 autoload mappings (including autoload-dev). */
+export declare function loadComposerConfig(repoRoot: string): Promise<ComposerConfig | null>;
+/**
+ * Parse .csproj files to extract RootNamespace.
+ * Scans the repo root for .csproj files and returns configs for each.
+ */
+export declare function loadCSharpProjectConfig(repoRoot: string): Promise<CSharpProjectConfig[]>;
+export declare function loadSwiftPackageConfig(repoRoot: string): Promise<SwiftPackageConfig | null>;

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

@@ -0,0 +1,167 @@
+import fs from 'fs/promises';
+import path from 'path';
+const isDev = process.env.NODE_ENV === 'development';
+// ============================================================================
+// LANGUAGE-SPECIFIC CONFIG LOADERS
+// ============================================================================
+/**
+ * Parse tsconfig.json to extract path aliases.
+ * Tries tsconfig.json, tsconfig.app.json, tsconfig.base.json in order.
+ */
+export async function loadTsconfigPaths(repoRoot) {
+    const candidates = ['tsconfig.json', 'tsconfig.app.json', 'tsconfig.base.json'];
+    for (const filename of candidates) {
+        try {
+            const tsconfigPath = path.join(repoRoot, filename);
+            const raw = await fs.readFile(tsconfigPath, 'utf-8');
+            // Strip JSON comments (// and /* */ style) for robustness
+            const stripped = raw.replace(/\/\/.*$/gm, '').replace(/\/\*[\s\S]*?\*\//g, '');
+            const tsconfig = JSON.parse(stripped);
+            const compilerOptions = tsconfig.compilerOptions;
+            if (!compilerOptions?.paths)
+                continue;
+            const baseUrl = compilerOptions.baseUrl || '.';
+            const aliases = new Map();
+            for (const [pattern, targets] of Object.entries(compilerOptions.paths)) {
+                if (!Array.isArray(targets) || targets.length === 0)
+                    continue;
+                const target = targets[0];
+                // Convert glob patterns: "@/*" -> "@/", "src/*" -> "src/"
+                const aliasPrefix = pattern.endsWith('/*') ? pattern.slice(0, -1) : pattern;
+                const targetPrefix = target.endsWith('/*') ? target.slice(0, -1) : target;
+                aliases.set(aliasPrefix, targetPrefix);
+            }
+            if (aliases.size > 0) {
+                if (isDev) {
+                    console.log(`📦 Loaded ${aliases.size} path aliases from ${filename}`);
+                }
+                return { aliases, baseUrl };
+            }
+        }
+        catch {
+            // File doesn't exist or isn't valid JSON - try next
+        }
+    }
+    return null;
+}
+/**
+ * Parse go.mod to extract module path.
+ */
+export async function loadGoModulePath(repoRoot) {
+    try {
+        const goModPath = path.join(repoRoot, 'go.mod');
+        const content = await fs.readFile(goModPath, 'utf-8');
+        const match = content.match(/^module\s+(\S+)/m);
+        if (match) {
+            if (isDev) {
+                console.log(`📦 Loaded Go module path: ${match[1]}`);
+            }
+            return { modulePath: match[1] };
+        }
+    }
+    catch {
+        // No go.mod
+    }
+    return null;
+}
+/** Parse composer.json to extract PSR-4 autoload mappings (including autoload-dev). */
+export async function loadComposerConfig(repoRoot) {
+    try {
+        const composerPath = path.join(repoRoot, 'composer.json');
+        const raw = await fs.readFile(composerPath, 'utf-8');
+        const composer = JSON.parse(raw);
+        const psr4Raw = composer.autoload?.['psr-4'] ?? {};
+        const psr4Dev = composer['autoload-dev']?.['psr-4'] ?? {};
+        const merged = { ...psr4Raw, ...psr4Dev };
+        const psr4 = new Map();
+        for (const [ns, dir] of Object.entries(merged)) {
+            const nsNorm = ns.replace(/\\+$/, '');
+            const dirNorm = dir.replace(/\\/g, '/').replace(/\/+$/, '');
+            psr4.set(nsNorm, dirNorm);
+        }
+        if (isDev) {
+            console.log(`📦 Loaded ${psr4.size} PSR-4 mappings from composer.json`);
+        }
+        return { psr4 };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Parse .csproj files to extract RootNamespace.
+ * Scans the repo root for .csproj files and returns configs for each.
+ */
+export async function loadCSharpProjectConfig(repoRoot) {
+    const configs = [];
+    // BFS scan for .csproj files up to 5 levels deep, cap at 100 dirs to avoid runaway scanning
+    const scanQueue = [{ dir: repoRoot, depth: 0 }];
+    const maxDepth = 5;
+    const maxDirs = 100;
+    let dirsScanned = 0;
+    while (scanQueue.length > 0 && dirsScanned < maxDirs) {
+        const { dir, depth } = scanQueue.shift();
+        dirsScanned++;
+        try {
+            const entries = await fs.readdir(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.isDirectory() && depth < maxDepth) {
+                    // Skip common non-project directories
+                    if (entry.name === 'node_modules' || entry.name === '.git' || entry.name === 'bin' || entry.name === 'obj')
+                        continue;
+                    scanQueue.push({ dir: path.join(dir, entry.name), depth: depth + 1 });
+                }
+                if (entry.isFile() && entry.name.endsWith('.csproj')) {
+                    try {
+                        const csprojPath = path.join(dir, entry.name);
+                        const content = await fs.readFile(csprojPath, 'utf-8');
+                        const nsMatch = content.match(/<RootNamespace>\s*([^<]+)\s*<\/RootNamespace>/);
+                        const rootNamespace = nsMatch
+                            ? nsMatch[1].trim()
+                            : entry.name.replace(/\.csproj$/, '');
+                        const projectDir = path.relative(repoRoot, dir).replace(/\\/g, '/');
+                        configs.push({ rootNamespace, projectDir });
+                        if (isDev) {
+                            console.log(`📦 Loaded C# project: ${entry.name} (namespace: ${rootNamespace}, dir: ${projectDir})`);
+                        }
+                    }
+                    catch {
+                        // Can't read .csproj
+                    }
+                }
+            }
+        }
+        catch {
+            // Can't read directory
+        }
+    }
+    return configs;
+}
+export async function loadSwiftPackageConfig(repoRoot) {
+    // Swift imports are module-name based (e.g., `import SiuperModel`)
+    // SPM convention: Sources/<TargetName>/ or Package/Sources/<TargetName>/
+    // We scan for these directories to build a target map
+    const targets = new Map();
+    const sourceDirs = ['Sources', 'Package/Sources', 'src'];
+    for (const sourceDir of sourceDirs) {
+        try {
+            const fullPath = path.join(repoRoot, sourceDir);
+            const entries = await fs.readdir(fullPath, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.isDirectory()) {
+                    targets.set(entry.name, sourceDir + '/' + entry.name);
+                }
+            }
+        }
+        catch {
+            // Directory doesn't exist
+        }
+    }
+    if (targets.size > 0) {
+        if (isDev) {
+            console.log(`📦 Loaded ${targets.size} Swift package targets`);
+        }
+        return { targets };
+    }
+    return null;
+}

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

@@ -0,0 +1,45 @@
+/**
+ * MRO (Method Resolution Order) Processor
+ *
+ * Walks the inheritance DAG (EXTENDS/IMPLEMENTS edges), collects methods from
+ * each ancestor via HAS_METHOD edges, detects method-name collisions across
+ * parents, and applies language-specific resolution rules to emit OVERRIDES edges.
+ *
+ * Language-specific rules:
+ * - C++:       leftmost base class in declaration order wins
+ * - C#/Java:   class method wins over interface default; multiple interface
+ *              methods with same name are ambiguous (null resolution)
+ * - Python:    C3 linearization determines MRO; first in linearized order wins
+ * - Rust:      no auto-resolution — requires qualified syntax, resolvedTo = null
+ * - Default:   single inheritance — first definition wins
+ *
+ * OVERRIDES edge direction: Class → Method (not Method → Method).
+ * The source is the child class that inherits conflicting methods,
+ * the target is the winning ancestor method node.
+ * Cypher: MATCH (c:Class)-[r:CodeRelation {type: 'OVERRIDES'}]->(m:Method)
+ */
+import { KnowledgeGraph } from '../graph/types.js';
+import { SupportedLanguages } from '../../config/supported-languages.js';
+export interface MROEntry {
+    classId: string;
+    className: string;
+    language: SupportedLanguages;
+    mro: string[];
+    ambiguities: MethodAmbiguity[];
+}
+export interface MethodAmbiguity {
+    methodName: string;
+    definedIn: Array<{
+        classId: string;
+        className: string;
+        methodId: string;
+    }>;
+    resolvedTo: string | null;
+    reason: string;
+}
+export interface MROResult {
+    entries: MROEntry[];
+    overrideEdges: number;
+    ambiguityCount: number;
+}
+export declare function computeMRO(graph: KnowledgeGraph): MROResult;

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

@@ -0,0 +1,369 @@
+/**
+ * MRO (Method Resolution Order) Processor
+ *
+ * Walks the inheritance DAG (EXTENDS/IMPLEMENTS edges), collects methods from
+ * each ancestor via HAS_METHOD edges, detects method-name collisions across
+ * parents, and applies language-specific resolution rules to emit OVERRIDES edges.
+ *
+ * Language-specific rules:
+ * - C++:       leftmost base class in declaration order wins
+ * - C#/Java:   class method wins over interface default; multiple interface
+ *              methods with same name are ambiguous (null resolution)
+ * - Python:    C3 linearization determines MRO; first in linearized order wins
+ * - Rust:      no auto-resolution — requires qualified syntax, resolvedTo = null
+ * - Default:   single inheritance — first definition wins
+ *
+ * OVERRIDES edge direction: Class → Method (not Method → Method).
+ * The source is the child class that inherits conflicting methods,
+ * the target is the winning ancestor method node.
+ * Cypher: MATCH (c:Class)-[r:CodeRelation {type: 'OVERRIDES'}]->(m:Method)
+ */
+import { generateId } from '../../lib/utils.js';
+import { SupportedLanguages } from '../../config/supported-languages.js';
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+/** Collect EXTENDS, IMPLEMENTS, and HAS_METHOD adjacency from the graph. */
+function buildAdjacency(graph) {
+    // parentMap: childId → parentIds[] (in insertion / declaration order)
+    const parentMap = new Map();
+    // methodMap: classId → methodIds[]
+    const methodMap = new Map();
+    // Track which edge type each parent link came from
+    const parentEdgeType = new Map();
+    graph.forEachRelationship((rel) => {
+        if (rel.type === 'EXTENDS' || rel.type === 'IMPLEMENTS') {
+            let parents = parentMap.get(rel.sourceId);
+            if (!parents) {
+                parents = [];
+                parentMap.set(rel.sourceId, parents);
+            }
+            parents.push(rel.targetId);
+            let edgeTypes = parentEdgeType.get(rel.sourceId);
+            if (!edgeTypes) {
+                edgeTypes = new Map();
+                parentEdgeType.set(rel.sourceId, edgeTypes);
+            }
+            edgeTypes.set(rel.targetId, rel.type);
+        }
+        if (rel.type === 'HAS_METHOD') {
+            let methods = methodMap.get(rel.sourceId);
+            if (!methods) {
+                methods = [];
+                methodMap.set(rel.sourceId, methods);
+            }
+            methods.push(rel.targetId);
+        }
+    });
+    return { parentMap, methodMap, parentEdgeType };
+}
+/**
+ * Gather all ancestor IDs in BFS / topological order.
+ * Returns the linearized list of ancestor IDs (excluding the class itself).
+ */
+function gatherAncestors(classId, parentMap) {
+    const visited = new Set();
+    const order = [];
+    const queue = [...(parentMap.get(classId) ?? [])];
+    while (queue.length > 0) {
+        const id = queue.shift();
+        if (visited.has(id))
+            continue;
+        visited.add(id);
+        order.push(id);
+        const grandparents = parentMap.get(id);
+        if (grandparents) {
+            for (const gp of grandparents) {
+                if (!visited.has(gp))
+                    queue.push(gp);
+            }
+        }
+    }
+    return order;
+}
+// ---------------------------------------------------------------------------
+// C3 linearization (Python MRO)
+// ---------------------------------------------------------------------------
+/**
+ * Compute C3 linearization for a class given a parentMap.
+ * Returns an array of ancestor IDs in C3 order (excluding the class itself),
+ * or null if linearization fails (inconsistent or cyclic hierarchy).
+ */
+function c3Linearize(classId, parentMap, cache, inProgress) {
+    if (cache.has(classId))
+        return cache.get(classId);
+    // Cycle detection: if we're already computing this class, the hierarchy is cyclic
+    const visiting = inProgress ?? new Set();
+    if (visiting.has(classId)) {
+        cache.set(classId, null);
+        return null;
+    }
+    visiting.add(classId);
+    const directParents = parentMap.get(classId);
+    if (!directParents || directParents.length === 0) {
+        visiting.delete(classId);
+        cache.set(classId, []);
+        return [];
+    }
+    // Compute linearization for each parent first
+    const parentLinearizations = [];
+    for (const pid of directParents) {
+        const pLin = c3Linearize(pid, parentMap, cache, visiting);
+        if (pLin === null) {
+            visiting.delete(classId);
+            cache.set(classId, null);
+            return null;
+        }
+        parentLinearizations.push([pid, ...pLin]);
+    }
+    // Add the direct parents list as the final sequence
+    const sequences = [...parentLinearizations, [...directParents]];
+    const result = [];
+    while (sequences.some(s => s.length > 0)) {
+        // Find a good head: one that doesn't appear in the tail of any other sequence
+        let head = null;
+        for (const seq of sequences) {
+            if (seq.length === 0)
+                continue;
+            const candidate = seq[0];
+            const inTail = sequences.some(other => other.length > 1 && other.indexOf(candidate, 1) !== -1);
+            if (!inTail) {
+                head = candidate;
+                break;
+            }
+        }
+        if (head === null) {
+            // Inconsistent hierarchy
+            visiting.delete(classId);
+            cache.set(classId, null);
+            return null;
+        }
+        result.push(head);
+        // Remove the chosen head from all sequences
+        for (const seq of sequences) {
+            if (seq.length > 0 && seq[0] === head) {
+                seq.shift();
+            }
+        }
+    }
+    visiting.delete(classId);
+    cache.set(classId, result);
+    return result;
+}
+/** Resolve by MRO order — first ancestor in linearized order wins. */
+function resolveByMroOrder(methodName, defs, mroOrder, reasonPrefix) {
+    for (const ancestorId of mroOrder) {
+        const match = defs.find(d => d.classId === ancestorId);
+        if (match) {
+            return {
+                resolvedTo: match.methodId,
+                reason: `${reasonPrefix}: ${match.className}::${methodName}`,
+            };
+        }
+    }
+    return { resolvedTo: defs[0].methodId, reason: `${reasonPrefix} fallback: first definition` };
+}
+function resolveCsharpJava(methodName, defs, parentEdgeTypes) {
+    const classDefs = [];
+    const interfaceDefs = [];
+    for (const def of defs) {
+        const edgeType = parentEdgeTypes?.get(def.classId);
+        if (edgeType === 'IMPLEMENTS') {
+            interfaceDefs.push(def);
+        }
+        else {
+            classDefs.push(def);
+        }
+    }
+    if (classDefs.length > 0) {
+        return {
+            resolvedTo: classDefs[0].methodId,
+            reason: `class method wins: ${classDefs[0].className}::${methodName}`,
+        };
+    }
+    if (interfaceDefs.length > 1) {
+        return {
+            resolvedTo: null,
+            reason: `ambiguous: ${methodName} defined in multiple interfaces: ${interfaceDefs.map(d => d.className).join(', ')}`,
+        };
+    }
+    if (interfaceDefs.length === 1) {
+        return {
+            resolvedTo: interfaceDefs[0].methodId,
+            reason: `single interface default: ${interfaceDefs[0].className}::${methodName}`,
+        };
+    }
+    return { resolvedTo: null, reason: 'no resolution found' };
+}
+// ---------------------------------------------------------------------------
+// Main entry point
+// ---------------------------------------------------------------------------
+export function computeMRO(graph) {
+    const { parentMap, methodMap, parentEdgeType } = buildAdjacency(graph);
+    const c3Cache = new Map();
+    const entries = [];
+    let overrideEdges = 0;
+    let ambiguityCount = 0;
+    // Process every class that has at least one parent
+    for (const [classId, directParents] of parentMap) {
+        if (directParents.length === 0)
+            continue;
+        const classNode = graph.getNode(classId);
+        if (!classNode)
+            continue;
+        const language = classNode.properties.language;
+        if (!language)
+            continue;
+        const className = classNode.properties.name;
+        // Compute linearized MRO depending on language
+        let mroOrder;
+        if (language === SupportedLanguages.Python) {
+            const c3Result = c3Linearize(classId, parentMap, c3Cache);
+            mroOrder = c3Result ?? gatherAncestors(classId, parentMap);
+        }
+        else {
+            mroOrder = gatherAncestors(classId, parentMap);
+        }
+        // Get the parent names for the MRO entry
+        const mroNames = mroOrder
+            .map(id => graph.getNode(id)?.properties.name)
+            .filter((n) => n !== undefined);
+        // Collect methods from all ancestors, grouped by method name
+        const methodsByName = new Map();
+        for (const ancestorId of mroOrder) {
+            const ancestorNode = graph.getNode(ancestorId);
+            if (!ancestorNode)
+                continue;
+            const methods = methodMap.get(ancestorId) ?? [];
+            for (const methodId of methods) {
+                const methodNode = graph.getNode(methodId);
+                if (!methodNode)
+                    continue;
+                // Properties don't participate in method resolution order
+                if (methodNode.label === 'Property')
+                    continue;
+                const methodName = methodNode.properties.name;
+                let defs = methodsByName.get(methodName);
+                if (!defs) {
+                    defs = [];
+                    methodsByName.set(methodName, defs);
+                }
+                // Avoid duplicates (same method seen via multiple paths)
+                if (!defs.some(d => d.methodId === methodId)) {
+                    defs.push({
+                        classId: ancestorId,
+                        className: ancestorNode.properties.name,
+                        methodId,
+                    });
+                }
+            }
+        }
+        // Detect collisions: methods defined in 2+ different ancestors
+        const ambiguities = [];
+        // Compute transitive edge types once per class (only needed for C#/Java)
+        const needsEdgeTypes = language === SupportedLanguages.CSharp || language === SupportedLanguages.Java || language === SupportedLanguages.Kotlin;
+        const classEdgeTypes = needsEdgeTypes
+            ? buildTransitiveEdgeTypes(classId, parentMap, parentEdgeType)
+            : undefined;
+        for (const [methodName, defs] of methodsByName) {
+            if (defs.length < 2)
+                continue;
+            // Own method shadows inherited — no ambiguity
+            const ownMethods = methodMap.get(classId) ?? [];
+            const ownDefinesIt = ownMethods.some(mid => {
+                const mn = graph.getNode(mid);
+                return mn?.properties.name === methodName;
+            });
+            if (ownDefinesIt)
+                continue;
+            let resolution;
+            switch (language) {
+                case SupportedLanguages.CPlusPlus:
+                    resolution = resolveByMroOrder(methodName, defs, mroOrder, 'C++ leftmost base');
+                    break;
+                case SupportedLanguages.CSharp:
+                case SupportedLanguages.Java:
+                case SupportedLanguages.Kotlin:
+                    resolution = resolveCsharpJava(methodName, defs, classEdgeTypes);
+                    break;
+                case SupportedLanguages.Python:
+                    resolution = resolveByMroOrder(methodName, defs, mroOrder, 'Python C3 MRO');
+                    break;
+                case SupportedLanguages.Rust:
+                    resolution = {
+                        resolvedTo: null,
+                        reason: `Rust requires qualified syntax: <Type as Trait>::${methodName}()`,
+                    };
+                    break;
+                default:
+                    resolution = resolveByMroOrder(methodName, defs, mroOrder, 'first definition');
+                    break;
+            }
+            const ambiguity = {
+                methodName,
+                definedIn: defs,
+                resolvedTo: resolution.resolvedTo,
+                reason: resolution.reason,
+            };
+            ambiguities.push(ambiguity);
+            if (resolution.resolvedTo === null) {
+                ambiguityCount++;
+            }
+            // Emit OVERRIDES edge if resolution found
+            if (resolution.resolvedTo !== null) {
+                graph.addRelationship({
+                    id: generateId('OVERRIDES', `${classId}->${resolution.resolvedTo}`),
+                    sourceId: classId,
+                    targetId: resolution.resolvedTo,
+                    type: 'OVERRIDES',
+                    confidence: 1.0,
+                    reason: resolution.reason,
+                });
+                overrideEdges++;
+            }
+        }
+        entries.push({
+            classId,
+            className,
+            language,
+            mro: mroNames,
+            ambiguities,
+        });
+    }
+    return { entries, overrideEdges, ambiguityCount };
+}
+/**
+ * Build transitive edge types for a class using BFS from the class to all ancestors.
+ *
+ * Known limitation: BFS first-reach heuristic can misclassify an interface as
+ * EXTENDS if it's reachable via a class chain before being seen via IMPLEMENTS.
+ * E.g. if BaseClass also implements IFoo, IFoo may be classified as EXTENDS.
+ * This affects C#/Java/Kotlin conflict resolution in rare diamond hierarchies.
+ */
+function buildTransitiveEdgeTypes(classId, parentMap, parentEdgeType) {
+    const result = new Map();
+    const directEdges = parentEdgeType.get(classId);
+    if (!directEdges)
+        return result;
+    // BFS: propagate edge type from direct parents
+    const queue = [];
+    const directParents = parentMap.get(classId) ?? [];
+    for (const pid of directParents) {
+        const et = directEdges.get(pid) ?? 'EXTENDS';
+        if (!result.has(pid)) {
+            result.set(pid, et);
+            queue.push({ id: pid, edgeType: et });
+        }
+    }
+    while (queue.length > 0) {
+        const { id, edgeType } = queue.shift();
+        const grandparents = parentMap.get(id) ?? [];
+        for (const gp of grandparents) {
+            if (!result.has(gp)) {
+                result.set(gp, edgeType);
+                queue.push({ id: gp, edgeType });
+            }
+        }
+    }
+    return result;
+}

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

@@ -0,0 +1,61 @@
+import { SupportedLanguages } from '../../config/supported-languages.js';
+import type { SymbolTable, SymbolDefinition } from './symbol-table.js';
+import type { NamedImportMap } from './import-processor.js';
+/**
+ * Walk a named-binding re-export chain through NamedImportMap.
+ *
+ * When file A imports { User } from B, and B re-exports { User } from C,
+ * the NamedImportMap for A points to B, but B has no User definition.
+ * This function follows the chain: A→B→C until a definition is found.
+ *
+ * Returns the definitions found at the end of the chain, or null if the
+ * chain breaks (missing binding, circular reference, or depth exceeded).
+ * Max depth 5 to prevent infinite loops.
+ *
+ * @param allDefs Pre-computed `symbolTable.lookupFuzzy(name)` result — must be the
+ *               complete unfiltered result. Passing a file-filtered subset will cause
+ *               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;