gitnexus 1.4.6 → 1.4.8

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

@@ -1,4 +1,4 @@
-import { SupportedLanguages } from '../../config/supported-languages.js';
+import { findChild } from './resolvers/utils.js';
 /**
  * Walk a named-binding re-export chain through NamedImportMap.
  *
@@ -41,40 +41,6 @@ export function walkBindingChain(name, currentFilePath, symbolTable, namedImport
     }
     return 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 function extractNamedBindings(importNode, language) {
-    if (language === SupportedLanguages.TypeScript || language === SupportedLanguages.JavaScript) {
-        return extractTsNamedBindings(importNode);
-    }
-    if (language === SupportedLanguages.Python) {
-        return extractPythonNamedBindings(importNode);
-    }
-    if (language === SupportedLanguages.Kotlin) {
-        return extractKotlinNamedBindings(importNode);
-    }
-    if (language === SupportedLanguages.Rust) {
-        return extractRustNamedBindings(importNode);
-    }
-    if (language === SupportedLanguages.PHP) {
-        return extractPhpNamedBindings(importNode);
-    }
-    if (language === SupportedLanguages.CSharp) {
-        return extractCsharpNamedBindings(importNode);
-    }
-    if (language === SupportedLanguages.Java) {
-        return extractJavaNamedBindings(importNode);
-    }
-    return undefined;
-}
 export function extractTsNamedBindings(importNode) {
     // import_statement > import_clause > named_imports > import_specifier*
     const importClause = findChild(importNode, 'import_clause');
@@ -133,34 +99,52 @@ export function extractTsNamedBindings(importNode) {
     return undefined;
 }
 export function extractPythonNamedBindings(importNode) {
-    // Only from import_from_statement, not plain import_statement
-    if (importNode.type !== 'import_from_statement')
-        return undefined;
-    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)
+    // 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;
-            // This is an imported name: from x import User
-            const name = child.text;
-            if (name)
-                bindings.push({ local: name, exported: name });
+            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 });
+                }
+            }
         }
-        if (child.type === 'aliased_import') {
-            // from x import Repo as R
+        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 });
+                bindings.push({ local: aliasIdent.text, exported: dottedName.text, isModuleAlias: true });
             }
         }
+        return bindings.length > 0 ? bindings : undefined;
     }
-    return bindings.length > 0 ? bindings : undefined;
+    return undefined;
 }
 export function extractKotlinNamedBindings(importNode) {
     // import_header > identifier + import_alias > simple_identifier
@@ -180,15 +164,21 @@ export function extractKotlinNamedBindings(importNode) {
         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 lowercase last segments — those are member/function imports (e.g.,
-    // import util.OneArg.writeAudit), not class imports. Multiple member imports
+    // 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.
-    if (exportedName[0] && exportedName[0] === exportedName[0].toLowerCase())
-        return undefined;
+    // 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 }];
 }
 export function extractRustNamedBindings(importNode) {
@@ -260,6 +250,12 @@ export function extractPhpNamedBindings(importNode) {
     // 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 = [];
@@ -311,11 +307,20 @@ export function extractPhpNamedBindings(importNode) {
     return bindings.length > 0 ? bindings : undefined;
 }
 export function extractCsharpNamedBindings(importNode) {
-    // using_directive with identifier (alias) + qualified_name (target)
+    // 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)
@@ -323,22 +328,34 @@ export function extractCsharpNamedBindings(importNode) {
         else if (child?.type === 'qualified_name')
             qualifiedName = child;
     }
-    if (!aliasIdent || !qualifiedName)
-        return undefined;
-    const fullText = qualifiedName.text;
-    const exportedName = fullText.includes('.') ? fullText.split('.').pop() : fullText;
-    return [{ local: aliasIdent.text, exported: exportedName }];
+    // 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;
 }
 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) — skip those
+    // 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)
@@ -347,17 +364,10 @@ export function extractJavaNamedBindings(importNode) {
     const lastDot = fullText.lastIndexOf('.');
     if (lastDot === -1)
         return undefined;
-    const className = fullText.slice(lastDot + 1);
-    // Skip lowercase names — those are package imports, not class imports
-    if (className[0] && className[0] === className[0].toLowerCase())
+    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: className, exported: className }];
-}
-function findChild(node, type) {
-    for (let i = 0; i < node.namedChildCount; i++) {
-        const child = node.namedChild(i);
-        if (child?.type === type)
-            return child;
-    }
-    return null;
+    return [{ local: name, exported: name }];
 }

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

@@ -2,16 +2,17 @@ import { KnowledgeGraph } from '../graph/types.js';
 import { SymbolTable } from './symbol-table.js';
 import { ASTCache } from './ast-cache.js';
 import { WorkerPool } from './workers/worker-pool.js';
-import type { ExtractedImport, ExtractedCall, ExtractedHeritage, ExtractedRoute, FileConstructorBindings } from './workers/parse-worker.js';
+import type { ExtractedImport, ExtractedCall, ExtractedAssignment, ExtractedHeritage, ExtractedRoute, FileConstructorBindings, FileTypeEnvBindings } from './workers/parse-worker.js';
 export type FileProgressCallback = (current: number, total: number, filePath: string) => void;
 export interface WorkerExtractedData {
     imports: ExtractedImport[];
     calls: ExtractedCall[];
+    assignments: ExtractedAssignment[];
     heritage: ExtractedHeritage[];
     routes: ExtractedRoute[];
     constructorBindings: FileConstructorBindings[];
+    typeEnvBindings: FileTypeEnvBindings[];
 }
-export { isNodeExported } from './export-detection.js';
 export declare const processParsing: (graph: KnowledgeGraph, files: {
     path: string;
     content: string;

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

@@ -2,14 +2,12 @@ import Parser from 'tree-sitter';
 import { loadParser, loadLanguage, isLanguageAvailable } from '../tree-sitter/parser-loader.js';
 import { LANGUAGE_QUERIES } from './tree-sitter-queries.js';
 import { generateId } from '../../lib/utils.js';
-import { getLanguageFromFilename, yieldToEventLoop, getDefinitionNodeFromCaptures, findEnclosingClassId, extractMethodSignature } from './utils.js';
+import { getLanguageFromFilename, yieldToEventLoop, getDefinitionNodeFromCaptures, findEnclosingClassId, extractMethodSignature, getLabelFromCaptures } from './utils.js';
+import { extractPropertyDeclaredType } from './type-extractors/shared.js';
 import { isNodeExported } from './export-detection.js';
 import { detectFrameworkFromAST } from './framework-detection.js';
 import { typeConfigs } from './type-extractors/index.js';
 import { getTreeSitterBufferSize, TREE_SITTER_MAX_BUFFER } from './constants.js';
-// isNodeExported imported from ./export-detection.js (shared module)
-// Re-export for backward compatibility with any external consumers
-export { isNodeExported } from './export-detection.js';
 // ============================================================================
 // Worker-based parallel parsing
 // ============================================================================
@@ -22,7 +20,7 @@ const processParsingWithWorkers = async (graph, files, symbolTable, astCache, wo
             parseableFiles.push({ path: file.path, content: file.content });
     }
     if (parseableFiles.length === 0)
-        return { imports: [], calls: [], heritage: [], routes: [], constructorBindings: [] };
+        return { imports: [], calls: [], assignments: [], heritage: [], routes: [], constructorBindings: [], typeEnvBindings: [] };
     const total = files.length;
     // Dispatch to worker pool — pool handles splitting into chunks and sub-batching
     const chunkResults = await workerPool.dispatch(parseableFiles, (filesProcessed) => {
@@ -31,9 +29,11 @@ const processParsingWithWorkers = async (graph, files, symbolTable, astCache, wo
     // Merge results from all workers into graph and symbol table
     const allImports = [];
     const allCalls = [];
+    const allAssignments = [];
     const allHeritage = [];
     const allRoutes = [];
     const allConstructorBindings = [];
+    const allTypeEnvBindings = [];
     for (const result of chunkResults) {
         for (const node of result.nodes) {
             graph.addNode({
@@ -48,15 +48,20 @@ const processParsingWithWorkers = async (graph, files, symbolTable, astCache, wo
         for (const sym of result.symbols) {
             symbolTable.add(sym.filePath, sym.name, sym.nodeId, sym.type, {
                 parameterCount: sym.parameterCount,
+                requiredParameterCount: sym.requiredParameterCount,
+                parameterTypes: sym.parameterTypes,
                 returnType: sym.returnType,
+                declaredType: sym.declaredType,
                 ownerId: sym.ownerId,
             });
         }
         allImports.push(...result.imports);
         allCalls.push(...result.calls);
+        allAssignments.push(...result.assignments);
         allHeritage.push(...result.heritage);
         allRoutes.push(...result.routes);
         allConstructorBindings.push(...result.constructorBindings);
+        allTypeEnvBindings.push(...result.typeEnvBindings);
     }
     // Merge and log skipped languages from workers
     const skippedLanguages = new Map();
@@ -73,7 +78,7 @@ const processParsingWithWorkers = async (graph, files, symbolTable, astCache, wo
     }
     // Final progress
     onFileProgress?.(total, total, 'done');
-    return { imports: allImports, calls: allCalls, heritage: allHeritage, routes: allRoutes, constructorBindings: allConstructorBindings };
+    return { imports: allImports, calls: allCalls, assignments: allAssignments, heritage: allHeritage, routes: allRoutes, constructorBindings: allConstructorBindings, typeEnvBindings: allTypeEnvBindings };
 };
 // ============================================================================
 // Sequential fallback (original implementation)
@@ -133,62 +138,14 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, onF
             match.captures.forEach(c => {
                 captureMap[c.name] = c.node;
             });
-            if (captureMap['import']) {
+            const nodeLabel = getLabelFromCaptures(captureMap, language);
+            if (!nodeLabel)
                 return;
-            }
-            if (captureMap['call']) {
-                return;
-            }
             const nameNode = captureMap['name'];
             // Synthesize name for constructors without explicit @name capture (e.g. Swift init)
-            if (!nameNode && !captureMap['definition.constructor'])
+            if (!nameNode && nodeLabel !== 'Constructor')
                 return;
             const nodeName = nameNode ? nameNode.text : 'init';
-            let nodeLabel = 'CodeElement';
-            if (captureMap['definition.function'])
-                nodeLabel = 'Function';
-            else if (captureMap['definition.class'])
-                nodeLabel = 'Class';
-            else if (captureMap['definition.interface'])
-                nodeLabel = 'Interface';
-            else if (captureMap['definition.method'])
-                nodeLabel = 'Method';
-            else if (captureMap['definition.struct'])
-                nodeLabel = 'Struct';
-            else if (captureMap['definition.enum'])
-                nodeLabel = 'Enum';
-            else if (captureMap['definition.namespace'])
-                nodeLabel = 'Namespace';
-            else if (captureMap['definition.module'])
-                nodeLabel = 'Module';
-            else if (captureMap['definition.trait'])
-                nodeLabel = 'Trait';
-            else if (captureMap['definition.impl'])
-                nodeLabel = 'Impl';
-            else if (captureMap['definition.type'])
-                nodeLabel = 'TypeAlias';
-            else if (captureMap['definition.const'])
-                nodeLabel = 'Const';
-            else if (captureMap['definition.static'])
-                nodeLabel = 'Static';
-            else if (captureMap['definition.typedef'])
-                nodeLabel = 'Typedef';
-            else if (captureMap['definition.macro'])
-                nodeLabel = 'Macro';
-            else if (captureMap['definition.union'])
-                nodeLabel = 'Union';
-            else if (captureMap['definition.property'])
-                nodeLabel = 'Property';
-            else if (captureMap['definition.record'])
-                nodeLabel = 'Record';
-            else if (captureMap['definition.delegate'])
-                nodeLabel = 'Delegate';
-            else if (captureMap['definition.annotation'])
-                nodeLabel = 'Annotation';
-            else if (captureMap['definition.constructor'])
-                nodeLabel = 'Constructor';
-            else if (captureMap['definition.template'])
-                nodeLabel = 'Template';
             const definitionNodeForRange = getDefinitionNodeFromCaptures(captureMap);
             const startLine = definitionNodeForRange ? definitionNodeForRange.startPosition.row : (nameNode ? nameNode.startPosition.row : 0);
             const nodeId = generateId(nodeLabel, `${file.path}:${nodeName}`);
@@ -226,6 +183,8 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, onF
                     } : {}),
                     ...(methodSig ? {
                         parameterCount: methodSig.parameterCount,
+                        ...(methodSig.requiredParameterCount !== undefined ? { requiredParameterCount: methodSig.requiredParameterCount } : {}),
+                        ...(methodSig.parameterTypes ? { parameterTypes: methodSig.parameterTypes } : {}),
                         returnType: methodSig.returnType,
                     } : {}),
                 },
@@ -235,9 +194,16 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, onF
             // Function is included because Kotlin/Rust/Python capture class methods as Function nodes
             const needsOwner = nodeLabel === 'Method' || nodeLabel === 'Constructor' || nodeLabel === 'Property' || nodeLabel === 'Function';
             const enclosingClassId = needsOwner ? findEnclosingClassId(nameNode || definitionNodeForRange, file.path) : null;
+            // Extract declared type for Property nodes (field/property type annotations)
+            const declaredType = (nodeLabel === 'Property' && definitionNode)
+                ? extractPropertyDeclaredType(definitionNode)
+                : undefined;
             symbolTable.add(file.path, nodeName, nodeId, nodeLabel, {
                 parameterCount: methodSig?.parameterCount,
+                requiredParameterCount: methodSig?.requiredParameterCount,
+                parameterTypes: methodSig?.parameterTypes,
                 returnType: methodSig?.returnType,
+                declaredType,
                 ownerId: enclosingClassId ?? undefined,
             });
             const fileId = generateId('File', file.path);
@@ -251,13 +217,14 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, onF
                 reason: '',
             };
             graph.addRelationship(relationship);
-            // ── HAS_METHOD: link method/constructor/property to enclosing class ──
+            // ── HAS_METHOD / HAS_PROPERTY: link member to enclosing class ──
             if (enclosingClassId) {
+                const memberEdgeType = nodeLabel === 'Property' ? 'HAS_PROPERTY' : 'HAS_METHOD';
                 graph.addRelationship({
-                    id: generateId('HAS_METHOD', `${enclosingClassId}->${nodeId}`),
+                    id: generateId(memberEdgeType, `${enclosingClassId}->${nodeId}`),
                     sourceId: enclosingClassId,
                     targetId: nodeId,
-                    type: 'HAS_METHOD',
+                    type: memberEdgeType,
                     confidence: 1.0,
                     reason: '',
                 });

package/dist/core/ingestion/pipeline.d.ts

@@ -1,6 +1,16 @@
 import { PipelineProgress, PipelineResult } from '../../types/pipeline.js';
+/** A group of files with no mutual dependencies, safe to process in parallel. */
+type IndependentFileGroup = readonly string[];
+/** Kahn's algorithm: returns files grouped by topological level.
+ *  Files in the same level have no mutual dependencies — safe to process in parallel.
+ *  Files in cycles are returned as a final group (no cross-cycle propagation). */
+export declare function topologicalLevelSort(importMap: ReadonlyMap<string, ReadonlySet<string>>): {
+    levels: readonly IndependentFileGroup[];
+    cycleCount: number;
+};
 export interface PipelineOptions {
     /** Skip MRO, community detection, and process extraction for faster test runs. */
     skipGraphPhases?: boolean;
 }
 export declare const runPipelineFromRepo: (repoPath: string, onProgress: (progress: PipelineProgress) => void, options?: PipelineOptions) => Promise<PipelineResult>;
+export {};