gitnexus 1.4.7 → 1.4.9

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/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

@@ -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
 // ---------------------------------------------------------------------------
@@ -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
@@ -215,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);
         }
@@ -260,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;
@@ -277,22 +282,21 @@ 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;
                 default:
@@ -316,7 +320,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-processor.d.ts

@@ -0,0 +1,18 @@
+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;

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;