gitnexus 1.4.8 → 1.4.9

package/dist/core/ingestion/languages/swift.js

@@ -0,0 +1,133 @@
+/**
+ * Swift Language Provider
+ *
+ * Assembles all Swift-specific ingestion capabilities into a single
+ * LanguageProvider, following the Strategy pattern used by the pipeline.
+ *
+ * Key Swift traits:
+ *   - importSemantics: 'wildcard' (Swift imports entire modules)
+ *   - heritageDefaultEdge: 'IMPLEMENTS' (protocols are more common than class inheritance)
+ *   - implicitImportWirer: all files in the same SPM target see each other
+ */
+import { SupportedLanguages } from '../../../config/supported-languages.js';
+import { defineLanguage } from '../language-provider.js';
+import { typeConfig as swiftConfig } from '../type-extractors/swift.js';
+import { swiftExportChecker } from '../export-detection.js';
+import { resolveSwiftImport } from '../import-resolvers/swift.js';
+import { SWIFT_QUERIES } from '../tree-sitter-queries.js';
+import { createFieldExtractor } from '../field-extractors/generic.js';
+import { swiftConfig as swiftFieldConfig } from '../field-extractors/configs/swift.js';
+/**
+ * Group Swift files by SPM target for implicit module visibility.
+ * If SwiftPackageConfig is available, use target -> directory mappings.
+ * Otherwise, group all Swift files under a single "default" target
+ * (assumes a single-module Xcode project).
+ */
+function groupSwiftFilesByTarget(swiftFiles, swiftPackageConfig) {
+    // No SPM config -> single target (common for Xcode projects)
+    if (!swiftPackageConfig || swiftPackageConfig.targets.size === 0) {
+        return new Map([['__default__', swiftFiles]]);
+    }
+    // Pre-convert target dirs to normalized prefix format once
+    const targets = [...swiftPackageConfig.targets.entries()].map(([name, dir]) => ({ name, prefix: dir.replace(/\\/g, '/') + '/' }));
+    const groups = new Map();
+    const defaultGroup = [];
+    for (const file of swiftFiles) {
+        const normalized = file.includes('\\') ? file.replace(/\\/g, '/') : file;
+        let assigned = false;
+        for (const { name, prefix } of targets) {
+            const idx = normalized.indexOf(prefix);
+            if (idx === 0 || (idx > 0 && normalized[idx - 1] === '/')) {
+                let group = groups.get(name);
+                if (!group) {
+                    group = [];
+                    groups.set(name, group);
+                }
+                group.push(file);
+                assigned = true;
+                break;
+            }
+        }
+        if (!assigned)
+            defaultGroup.push(file);
+    }
+    if (defaultGroup.length > 0)
+        groups.set('__default__', defaultGroup);
+    return groups;
+}
+/**
+ * Wire implicit inter-file imports for Swift.
+ * All files in the same SPM target see each other (full module visibility).
+ * Two fast paths avoid unnecessary work:
+ *   1. No existing imports for src -> emit all (m-1) edges without Set.has checks
+ *   2. Existing imports present -> skip already-connected pairs
+ */
+function wireSwiftImplicitImports(swiftFiles, importMap, addImportEdge, projectConfig) {
+    const configs = projectConfig;
+    const targetGroups = groupSwiftFilesByTarget(swiftFiles, configs?.swiftPackageConfig ?? null);
+    for (const group of targetGroups.values()) {
+        const m = group.length;
+        if (m <= 1)
+            continue;
+        // All-pairs implicit edges: O(m²) is inherent for full module visibility.
+        for (let i = 0; i < m; i++) {
+            const src = group[i];
+            const existing = importMap.get(src);
+            if (!existing || existing.size === 0) {
+                // Fast path: no prior imports — emit all peers unconditionally
+                for (let j = 0; j < m; j++) {
+                    if (i !== j)
+                        addImportEdge(src, group[j]);
+                }
+            }
+            else {
+                // Dedup path: skip already-connected pairs
+                for (let j = 0; j < m; j++) {
+                    if (i !== j && !existing.has(group[j])) {
+                        addImportEdge(src, group[j]);
+                    }
+                }
+            }
+        }
+    }
+}
+const BUILT_INS = new Set([
+    'print', 'debugPrint', 'dump', 'fatalError', 'precondition', 'preconditionFailure',
+    'assert', 'assertionFailure', 'NSLog',
+    'abs', 'min', 'max', 'zip', 'stride', 'sequence', 'repeatElement',
+    'swap', 'withUnsafePointer', 'withUnsafeMutablePointer', 'withUnsafeBytes',
+    'autoreleasepool', 'unsafeBitCast', 'unsafeDowncast', 'numericCast',
+    'type', 'MemoryLayout',
+    'map', 'flatMap', 'compactMap', 'filter', 'reduce', 'forEach', 'contains',
+    'first', 'last', 'prefix', 'suffix', 'dropFirst', 'dropLast',
+    'sorted', 'reversed', 'enumerated', 'joined', 'split',
+    'append', 'insert', 'remove', 'removeAll', 'removeFirst', 'removeLast',
+    'isEmpty', 'count', 'index', 'startIndex', 'endIndex',
+    'addSubview', 'removeFromSuperview', 'layoutSubviews', 'setNeedsLayout',
+    'layoutIfNeeded', 'setNeedsDisplay', 'invalidateIntrinsicContentSize',
+    'addTarget', 'removeTarget', 'addGestureRecognizer',
+    'addConstraint', 'addConstraints', 'removeConstraint', 'removeConstraints',
+    'NSLocalizedString', 'Bundle',
+    'reloadData', 'reloadSections', 'reloadRows', 'performBatchUpdates',
+    'register', 'dequeueReusableCell', 'dequeueReusableSupplementaryView',
+    'beginUpdates', 'endUpdates', 'insertRows', 'deleteRows', 'insertSections', 'deleteSections',
+    'present', 'dismiss', 'pushViewController', 'popViewController', 'popToRootViewController',
+    'performSegue', 'prepare',
+    'DispatchQueue', 'async', 'sync', 'asyncAfter',
+    'Task', 'withCheckedContinuation', 'withCheckedThrowingContinuation',
+    'sink', 'store', 'assign', 'receive', 'subscribe',
+    'addObserver', 'removeObserver', 'post', 'NotificationCenter',
+]);
+export const swiftProvider = defineLanguage({
+    id: SupportedLanguages.Swift,
+    extensions: ['.swift'],
+    treeSitterQueries: SWIFT_QUERIES,
+    typeConfig: swiftConfig,
+    exportChecker: swiftExportChecker,
+    importResolver: resolveSwiftImport,
+    importSemantics: 'wildcard',
+    heritageDefaultEdge: 'IMPLEMENTS',
+    fieldExtractor: createFieldExtractor(swiftFieldConfig),
+    implicitImportWirer: wireSwiftImplicitImports,
+    builtInNames: BUILT_INS,
+});

package/dist/core/ingestion/languages/typescript.d.ts

@@ -0,0 +1,10 @@
+/**
+ * TypeScript and JavaScript language providers.
+ *
+ * Both languages share the same type extraction config (typescriptConfig),
+ * export checker (tsExportChecker), and named binding extractor
+ * (extractTsNamedBindings). They differ in file extensions, tree-sitter
+ * queries (TypeScript grammar has interface/type nodes), and language ID.
+ */
+export declare const typescriptProvider: import("../language-provider.js").LanguageProvider;
+export declare const javascriptProvider: import("../language-provider.js").LanguageProvider;

package/dist/core/ingestion/languages/typescript.js

@@ -0,0 +1,60 @@
+/**
+ * TypeScript and JavaScript language providers.
+ *
+ * Both languages share the same type extraction config (typescriptConfig),
+ * export checker (tsExportChecker), and named binding extractor
+ * (extractTsNamedBindings). They differ in file extensions, tree-sitter
+ * queries (TypeScript grammar has interface/type nodes), and language ID.
+ */
+import { SupportedLanguages } from '../../../config/supported-languages.js';
+import { defineLanguage } from '../language-provider.js';
+import { typeConfig as typescriptConfig } from '../type-extractors/typescript.js';
+import { tsExportChecker } from '../export-detection.js';
+import { resolveTypescriptImport, resolveJavascriptImport } from '../import-resolvers/standard.js';
+import { extractTsNamedBindings } from '../named-bindings/typescript.js';
+import { TYPESCRIPT_QUERIES, JAVASCRIPT_QUERIES } from '../tree-sitter-queries.js';
+import { typescriptFieldExtractor } from '../field-extractors/typescript.js';
+import { createFieldExtractor } from '../field-extractors/generic.js';
+import { javascriptConfig } from '../field-extractors/configs/typescript-javascript.js';
+const BUILT_INS = new Set([
+    'console', 'log', 'warn', 'error', 'info', 'debug',
+    'setTimeout', 'setInterval', 'clearTimeout', 'clearInterval',
+    'parseInt', 'parseFloat', 'isNaN', 'isFinite',
+    'encodeURI', 'decodeURI', 'encodeURIComponent', 'decodeURIComponent',
+    'JSON', 'parse', 'stringify',
+    'Object', 'Array', 'String', 'Number', 'Boolean', 'Symbol', 'BigInt',
+    'Map', 'Set', 'WeakMap', 'WeakSet',
+    'Promise', 'resolve', 'reject', 'then', 'catch', 'finally',
+    'Math', 'Date', 'RegExp', 'Error',
+    'require', 'import', 'export', 'fetch', 'Response', 'Request',
+    'useState', 'useEffect', 'useCallback', 'useMemo', 'useRef', 'useContext',
+    'useReducer', 'useLayoutEffect', 'useImperativeHandle', 'useDebugValue',
+    'createElement', 'createContext', 'createRef', 'forwardRef', 'memo', 'lazy',
+    'map', 'filter', 'reduce', 'forEach', 'find', 'findIndex', 'some', 'every',
+    'includes', 'indexOf', 'slice', 'splice', 'concat', 'join', 'split',
+    'push', 'pop', 'shift', 'unshift', 'sort', 'reverse',
+    'keys', 'values', 'entries', 'assign', 'freeze', 'seal',
+    'hasOwnProperty', 'toString', 'valueOf',
+]);
+export const typescriptProvider = defineLanguage({
+    id: SupportedLanguages.TypeScript,
+    extensions: ['.ts', '.tsx'],
+    treeSitterQueries: TYPESCRIPT_QUERIES,
+    typeConfig: typescriptConfig,
+    exportChecker: tsExportChecker,
+    importResolver: resolveTypescriptImport,
+    namedBindingExtractor: extractTsNamedBindings,
+    fieldExtractor: typescriptFieldExtractor,
+    builtInNames: BUILT_INS,
+});
+export const javascriptProvider = defineLanguage({
+    id: SupportedLanguages.JavaScript,
+    extensions: ['.js', '.jsx'],
+    treeSitterQueries: JAVASCRIPT_QUERIES,
+    typeConfig: typescriptConfig,
+    exportChecker: tsExportChecker,
+    importResolver: resolveJavascriptImport,
+    namedBindingExtractor: extractTsNamedBindings,
+    fieldExtractor: createFieldExtractor(javascriptConfig),
+    builtInNames: BUILT_INS,
+});

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

@@ -19,7 +19,7 @@
  * Cypher: MATCH (c:Class)-[r:CodeRelation {type: 'OVERRIDES'}]->(m:Method)
  */
 import { generateId } from '../../lib/utils.js';
-import { SupportedLanguages } from '../../config/supported-languages.js';
+import { getProvider } from './languages/index.js';
 // ---------------------------------------------------------------------------
 // Internal helpers
 // ---------------------------------------------------------------------------
@@ -219,9 +219,10 @@ export function computeMRO(graph) {
         if (!language)
             continue;
         const className = classNode.properties.name;
-        // Compute linearized MRO depending on language
+        // Compute linearized MRO depending on language strategy
+        const provider = getProvider(language);
         let mroOrder;
-        if (language === SupportedLanguages.Python) {
+        if (provider.mroStrategy === 'c3') {
             const c3Result = c3Linearize(classId, parentMap, c3Cache);
             mroOrder = c3Result ?? gatherAncestors(classId, parentMap);
         }
@@ -264,8 +265,8 @@ export function computeMRO(graph) {
         }
         // 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;
+        // Compute transitive edge types once per class (only needed for implements-split languages)
+        const needsEdgeTypes = provider.mroStrategy === 'implements-split';
         const classEdgeTypes = needsEdgeTypes
             ? buildTransitiveEdgeTypes(classId, parentMap, parentEdgeType)
             : undefined;
@@ -281,22 +282,20 @@ export function computeMRO(graph) {
             if (ownDefinesIt)
                 continue;
             let resolution;
-            switch (language) {
-                case SupportedLanguages.CPlusPlus:
-                    resolution = resolveByMroOrder(methodName, defs, mroOrder, 'C++ leftmost base');
+            switch (provider.mroStrategy) {
+                case 'leftmost-base':
+                    resolution = resolveByMroOrder(methodName, defs, mroOrder, 'leftmost base');
                     break;
-                case SupportedLanguages.CSharp:
-                case SupportedLanguages.Java:
-                case SupportedLanguages.Kotlin:
+                case 'implements-split':
                     resolution = resolveCsharpJava(methodName, defs, classEdgeTypes);
                     break;
-                case SupportedLanguages.Python:
-                    resolution = resolveByMroOrder(methodName, defs, mroOrder, 'Python C3 MRO');
+                case 'c3':
+                    resolution = resolveByMroOrder(methodName, defs, mroOrder, 'C3 MRO');
                     break;
-                case SupportedLanguages.Rust:
+                case 'qualified-syntax':
                     resolution = {
                         resolvedTo: null,
-                        reason: `Rust requires qualified syntax: <Type as Trait>::${methodName}()`,
+                        reason: `requires qualified syntax: <Type as Trait>::${methodName}()`,
                         confidence: 0.5,
                     };
                     break;

package/dist/core/ingestion/{named-binding-extraction.d.ts → named-binding-processor.d.ts}

@@ -1,7 +1,5 @@
 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.
  *
@@ -18,10 +16,3 @@ import type { SyntaxNode } from './utils.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;
-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;

package/dist/core/ingestion/named-binding-processor.js

@@ -0,0 +1,42 @@
+/**
+ * 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 function walkBindingChain(name, currentFilePath, symbolTable, namedImportMap, allDefs) {
+    let lookupFile = currentFilePath;
+    let lookupName = name;
+    const visited = new Set();
+    for (let depth = 0; depth < 5; depth++) {
+        const bindings = namedImportMap.get(lookupFile);
+        if (!bindings)
+            return null;
+        const binding = bindings.get(lookupName);
+        if (!binding)
+            return null;
+        const key = `${binding.sourcePath}:${binding.exportedName}`;
+        if (visited.has(key))
+            return null; // circular
+        visited.add(key);
+        const targetName = binding.exportedName;
+        const resolvedDefs = targetName !== lookupName || depth > 0
+            ? symbolTable.lookupFuzzy(targetName).filter(def => def.filePath === binding.sourcePath)
+            : allDefs.filter(def => def.filePath === binding.sourcePath);
+        if (resolvedDefs.length > 0)
+            return resolvedDefs;
+        // No definition in source file → follow re-export chain
+        lookupFile = binding.sourcePath;
+        lookupName = targetName;
+    }
+    return null;
+}

package/dist/core/ingestion/named-bindings/csharp.d.ts

@@ -0,0 +1,3 @@
+import type { SyntaxNode } from '../utils/ast-helpers.js';
+import type { NamedBinding } from './types.js';
+export declare function extractCSharpNamedBindings(importNode: SyntaxNode): NamedBinding[] | undefined;

package/dist/core/ingestion/named-bindings/csharp.js

@@ -0,0 +1,37 @@
+export function extractCSharpNamedBindings(importNode) {
+    // using_directive — three forms:
+    //   using Alias = NS.Type;          → aliasIdent + qualifiedName
+    //   using static NS.Type;           → static + qualifiedName (no alias)
+    //   using NS;                       → qualifiedName only (namespace, not capturable)
+    if (importNode.type !== 'using_directive')
+        return undefined;
+    let aliasIdent = null;
+    let qualifiedName = null;
+    let isStatic = false;
+    for (let i = 0; i < importNode.childCount; i++) {
+        const child = importNode.child(i);
+        if (child?.text === 'static')
+            isStatic = true;
+    }
+    for (let i = 0; i < importNode.namedChildCount; i++) {
+        const child = importNode.namedChild(i);
+        if (child?.type === 'identifier' && !aliasIdent)
+            aliasIdent = child;
+        else if (child?.type === 'qualified_name')
+            qualifiedName = child;
+    }
+    // Form 1: using Alias = NS.Type;
+    if (aliasIdent && qualifiedName) {
+        const fullText = qualifiedName.text;
+        const exportedName = fullText.includes('.') ? fullText.split('.').pop() : fullText;
+        return [{ local: aliasIdent.text, exported: exportedName }];
+    }
+    // Form 2: using static NS.Type; — last segment is the class name
+    if (isStatic && qualifiedName) {
+        const fullText = qualifiedName.text;
+        const lastSegment = fullText.includes('.') ? fullText.split('.').pop() : fullText;
+        return [{ local: lastSegment, exported: lastSegment }];
+    }
+    // Form 3: using NS; — namespace import, can't resolve to per-symbol bindings
+    return undefined;
+}

package/dist/core/ingestion/named-bindings/java.d.ts

@@ -0,0 +1,3 @@
+import { type SyntaxNode } from '../utils/ast-helpers.js';
+import type { NamedBinding } from './types.js';
+export declare function extractJavaNamedBindings(importNode: SyntaxNode): NamedBinding[] | undefined;

package/dist/core/ingestion/named-bindings/java.js

@@ -0,0 +1,29 @@
+import { findChild } from '../utils/ast-helpers.js';
+export function extractJavaNamedBindings(importNode) {
+    // import_declaration > scoped_identifier "com.example.models.User"
+    // Wildcard imports (.*) don't produce named bindings
+    if (importNode.type !== 'import_declaration')
+        return undefined;
+    // Check for asterisk (wildcard import) and static modifier
+    let isStatic = false;
+    for (let i = 0; i < importNode.childCount; i++) {
+        const child = importNode.child(i);
+        if (child?.type === 'asterisk')
+            return undefined;
+        if (child?.text === 'static')
+            isStatic = true;
+    }
+    const scopedId = findChild(importNode, 'scoped_identifier');
+    if (!scopedId)
+        return undefined;
+    const fullText = scopedId.text;
+    const lastDot = fullText.lastIndexOf('.');
+    if (lastDot === -1)
+        return undefined;
+    const name = fullText.slice(lastDot + 1);
+    // Non-static: skip lowercase names — those are package imports, not class imports.
+    // Static: allow lowercase — `import static models.UserFactory.getUser` imports a method.
+    if (!isStatic && name[0] && name[0] === name[0].toLowerCase())
+        return undefined;
+    return [{ local: name, exported: name }];
+}

package/dist/core/ingestion/named-bindings/kotlin.d.ts

@@ -0,0 +1,3 @@
+import { type SyntaxNode } from '../utils/ast-helpers.js';
+import type { NamedBinding } from './types.js';
+export declare function extractKotlinNamedBindings(importNode: SyntaxNode): NamedBinding[] | undefined;

package/dist/core/ingestion/named-bindings/kotlin.js

@@ -0,0 +1,36 @@
+import { findChild } from '../utils/ast-helpers.js';
+export function extractKotlinNamedBindings(importNode) {
+    // import_header > identifier + import_alias > simple_identifier
+    if (importNode.type !== 'import_header')
+        return undefined;
+    const fullIdent = findChild(importNode, 'identifier');
+    if (!fullIdent)
+        return undefined;
+    const fullText = fullIdent.text;
+    const exportedName = fullText.includes('.') ? fullText.split('.').pop() : fullText;
+    const importAlias = findChild(importNode, 'import_alias');
+    if (importAlias) {
+        // Aliased: import com.example.User as U
+        const aliasIdent = findChild(importAlias, 'simple_identifier');
+        if (!aliasIdent)
+            return undefined;
+        return [{ local: aliasIdent.text, exported: exportedName }];
+    }
+    // Non-aliased: import com.example.User → local="User", exported="User"
+    // Also handles top-level function imports: import models.getUser → local="getUser"
+    // Skip wildcard imports (ending in *)
+    if (fullText.endsWith('.*') || fullText.endsWith('*'))
+        return undefined;
+    // Skip class-member imports (e.g., import util.OneArg.writeAudit) where the
+    // second-to-last segment is PascalCase (a class name). Multiple member imports
+    // with the same function name would collide in NamedImportMap, breaking
+    // arity-based disambiguation. Top-level function imports (import models.getUser)
+    // and class imports (import models.User) have package-only prefixes.
+    const segments = fullText.split('.');
+    if (segments.length >= 3) {
+        const parentSegment = segments[segments.length - 2];
+        if (parentSegment[0] && parentSegment[0] === parentSegment[0].toUpperCase())
+            return undefined;
+    }
+    return [{ local: exportedName, exported: exportedName }];
+}

package/dist/core/ingestion/named-bindings/php.d.ts

@@ -0,0 +1,3 @@
+import type { SyntaxNode } from '../utils/ast-helpers.js';
+import type { NamedBinding } from './types.js';
+export declare function extractPhpNamedBindings(importNode: SyntaxNode): NamedBinding[] | undefined;

package/dist/core/ingestion/named-bindings/php.js

@@ -0,0 +1,61 @@
+export function extractPhpNamedBindings(importNode) {
+    // namespace_use_declaration > namespace_use_clause* (flat)
+    // namespace_use_declaration > namespace_use_group > namespace_use_clause* (grouped)
+    if (importNode.type !== 'namespace_use_declaration')
+        return undefined;
+    // Skip 'use function' and 'use const' declarations — these import callables/constants,
+    // not class types, and should not be added to namedImportMap as type bindings.
+    const useTypeNode = importNode.childForFieldName?.('type');
+    if (useTypeNode && (useTypeNode.text === 'function' || useTypeNode.text === 'const')) {
+        return undefined;
+    }
+    const bindings = [];
+    // Collect all clauses — from direct children AND from namespace_use_group
+    const clauses = [];
+    for (let i = 0; i < importNode.namedChildCount; i++) {
+        const child = importNode.namedChild(i);
+        if (child?.type === 'namespace_use_clause') {
+            clauses.push(child);
+        }
+        else if (child?.type === 'namespace_use_group') {
+            for (let j = 0; j < child.namedChildCount; j++) {
+                const groupChild = child.namedChild(j);
+                if (groupChild?.type === 'namespace_use_clause')
+                    clauses.push(groupChild);
+            }
+        }
+    }
+    for (const clause of clauses) {
+        // Flat imports: qualified_name + name (alias)
+        let qualifiedName = null;
+        const names = [];
+        for (let j = 0; j < clause.namedChildCount; j++) {
+            const child = clause.namedChild(j);
+            if (child?.type === 'qualified_name')
+                qualifiedName = child;
+            else if (child?.type === 'name')
+                names.push(child);
+        }
+        if (qualifiedName && names.length > 0) {
+            // Flat aliased import: use App\Models\Repo as R;
+            const fullText = qualifiedName.text;
+            const exportedName = fullText.includes('\\') ? fullText.split('\\').pop() : fullText;
+            bindings.push({ local: names[0].text, exported: exportedName });
+        }
+        else if (qualifiedName && names.length === 0) {
+            // Flat non-aliased import: use App\Models\User;
+            const fullText = qualifiedName.text;
+            const lastSegment = fullText.includes('\\') ? fullText.split('\\').pop() : fullText;
+            bindings.push({ local: lastSegment, exported: lastSegment });
+        }
+        else if (!qualifiedName && names.length >= 2) {
+            // Grouped aliased import: {Repo as R} — first name = exported, second = alias
+            bindings.push({ local: names[1].text, exported: names[0].text });
+        }
+        else if (!qualifiedName && names.length === 1) {
+            // Grouped non-aliased import: {User} in use App\Models\{User, Repo as R}
+            bindings.push({ local: names[0].text, exported: names[0].text });
+        }
+    }
+    return bindings.length > 0 ? bindings : undefined;
+}

package/dist/core/ingestion/named-bindings/python.d.ts

@@ -0,0 +1,3 @@
+import { type SyntaxNode } from '../utils/ast-helpers.js';
+import type { NamedBinding } from './types.js';
+export declare function extractPythonNamedBindings(importNode: SyntaxNode): NamedBinding[] | undefined;

package/dist/core/ingestion/named-bindings/python.js

@@ -0,0 +1,49 @@
+import { findChild } from '../utils/ast-helpers.js';
+export function extractPythonNamedBindings(importNode) {
+    // Handle: from x import User, Repo as R
+    if (importNode.type === 'import_from_statement') {
+        const bindings = [];
+        for (let i = 0; i < importNode.namedChildCount; i++) {
+            const child = importNode.namedChild(i);
+            if (!child)
+                continue;
+            if (child.type === 'dotted_name') {
+                // Skip the module_name (first dotted_name is the source module)
+                const fieldName = importNode.childForFieldName?.('module_name');
+                if (fieldName && child.startIndex === fieldName.startIndex)
+                    continue;
+                // This is an imported name: from x import User
+                const name = child.text;
+                if (name)
+                    bindings.push({ local: name, exported: name });
+            }
+            if (child.type === 'aliased_import') {
+                // from x import Repo as R
+                const dottedName = findChild(child, 'dotted_name');
+                const aliasIdent = findChild(child, 'identifier');
+                if (dottedName && aliasIdent) {
+                    bindings.push({ local: aliasIdent.text, exported: dottedName.text });
+                }
+            }
+        }
+        return bindings.length > 0 ? bindings : undefined;
+    }
+    // Handle: import numpy as np  (import_statement with aliased_import child)
+    // Tagged with isModuleAlias so applyImportResult routes these directly to
+    // moduleAliasMap (e.g. "np" → "numpy.py") instead of namedImportMap.
+    if (importNode.type === 'import_statement') {
+        const bindings = [];
+        for (let i = 0; i < importNode.namedChildCount; i++) {
+            const child = importNode.namedChild(i);
+            if (!child || child.type !== 'aliased_import')
+                continue;
+            const dottedName = findChild(child, 'dotted_name');
+            const aliasIdent = findChild(child, 'identifier');
+            if (dottedName && aliasIdent) {
+                bindings.push({ local: aliasIdent.text, exported: dottedName.text, isModuleAlias: true });
+            }
+        }
+        return bindings.length > 0 ? bindings : undefined;
+    }
+    return undefined;
+}

package/dist/core/ingestion/named-bindings/rust.d.ts

@@ -0,0 +1,3 @@
+import type { SyntaxNode } from '../utils/ast-helpers.js';
+import type { NamedBinding } from './types.js';
+export declare function extractRustNamedBindings(importNode: SyntaxNode): NamedBinding[] | undefined;

package/dist/core/ingestion/named-bindings/rust.js

@@ -0,0 +1,64 @@
+export function extractRustNamedBindings(importNode) {
+    // use_declaration may contain use_as_clause at any depth
+    if (importNode.type !== 'use_declaration')
+        return undefined;
+    const bindings = [];
+    collectRustBindings(importNode, bindings);
+    return bindings.length > 0 ? bindings : undefined;
+}
+function collectRustBindings(node, bindings) {
+    if (node.type === 'use_as_clause') {
+        // First identifier = exported name, second identifier = local alias
+        const idents = [];
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (child?.type === 'identifier')
+                idents.push(child.text);
+            // For scoped_identifier, extract the last segment
+            if (child?.type === 'scoped_identifier') {
+                const nameNode = child.childForFieldName?.('name');
+                if (nameNode)
+                    idents.push(nameNode.text);
+            }
+        }
+        if (idents.length === 2) {
+            bindings.push({ local: idents[1], exported: idents[0] });
+        }
+        return;
+    }
+    // Terminal identifier in a use_list: use crate::models::{User, Repo}
+    if (node.type === 'identifier' && node.parent?.type === 'use_list') {
+        bindings.push({ local: node.text, exported: node.text });
+        return;
+    }
+    // Skip scoped_identifier that serves as path prefix in scoped_use_list
+    // e.g. use crate::models::{User, Repo} — the path node "crate::models" is not an importable symbol
+    if (node.type === 'scoped_identifier' && node.parent?.type === 'scoped_use_list') {
+        return; // path prefix — the use_list sibling handles the actual symbols
+    }
+    // Terminal scoped_identifier: use crate::models::User;
+    // Only extract if this is a leaf (no deeper use_list/use_as_clause/scoped_use_list)
+    if (node.type === 'scoped_identifier') {
+        let hasDeeper = false;
+        for (let i = 0; i < node.namedChildCount; i++) {
+            const child = node.namedChild(i);
+            if (child?.type === 'use_list' || child?.type === 'use_as_clause' || child?.type === 'scoped_use_list') {
+                hasDeeper = true;
+                break;
+            }
+        }
+        if (!hasDeeper) {
+            const nameNode = node.childForFieldName?.('name');
+            if (nameNode) {
+                bindings.push({ local: nameNode.text, exported: nameNode.text });
+            }
+            return;
+        }
+    }
+    // Recurse into children
+    for (let i = 0; i < node.namedChildCount; i++) {
+        const child = node.namedChild(i);
+        if (child)
+            collectRustBindings(child, bindings);
+    }
+}