gitnexus 1.4.8 → 1.4.9

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

@@ -0,0 +1,16 @@
+/**
+ * Named binding types — shared across all per-language binding extractors.
+ *
+ * Extracted from import-resolution.ts to co-locate types with their consumers.
+ */
+import type { SyntaxNode } from '../utils/ast-helpers.js';
+/** A single named import binding: local name in the importing file and exported name from the source.
+ *  When `isModuleAlias` is true, the binding represents a Python `import X as Y` module alias
+ *  and is routed to moduleAliasMap instead of namedImportMap during import processing. */
+export interface NamedBinding {
+    local: string;
+    exported: string;
+    isModuleAlias?: boolean;
+}
+/** Per-language named binding extractor -- optional (returns undefined if language has no named imports). */
+export type NamedBindingExtractorFn = (importNode: SyntaxNode) => NamedBinding[] | undefined;

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

@@ -0,0 +1,6 @@
+/**
+ * Named binding types — shared across all per-language binding extractors.
+ *
+ * Extracted from import-resolution.ts to co-locate types with their consumers.
+ */
+export {};

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

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

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

@@ -0,0 +1,58 @@
+import { findChild } from '../utils/ast-helpers.js';
+export function extractTsNamedBindings(importNode) {
+    // import_statement > import_clause > named_imports > import_specifier*
+    const importClause = findChild(importNode, 'import_clause');
+    if (importClause) {
+        const namedImports = findChild(importClause, 'named_imports');
+        if (!namedImports)
+            return undefined; // default import, namespace import, or side-effect
+        const bindings = [];
+        for (let i = 0; i < namedImports.namedChildCount; i++) {
+            const specifier = namedImports.namedChild(i);
+            if (specifier?.type !== 'import_specifier')
+                continue;
+            const identifiers = [];
+            for (let j = 0; j < specifier.namedChildCount; j++) {
+                const child = specifier.namedChild(j);
+                if (child?.type === 'identifier')
+                    identifiers.push(child.text);
+            }
+            if (identifiers.length === 1) {
+                bindings.push({ local: identifiers[0], exported: identifiers[0] });
+            }
+            else if (identifiers.length === 2) {
+                // import { Foo as Bar } → exported='Foo', local='Bar'
+                bindings.push({ local: identifiers[1], exported: identifiers[0] });
+            }
+        }
+        return bindings.length > 0 ? bindings : undefined;
+    }
+    // Re-export: export { X } from './y' → export_statement > export_clause > export_specifier
+    const exportClause = findChild(importNode, 'export_clause');
+    if (exportClause) {
+        const bindings = [];
+        for (let i = 0; i < exportClause.namedChildCount; i++) {
+            const specifier = exportClause.namedChild(i);
+            if (specifier?.type !== 'export_specifier')
+                continue;
+            const identifiers = [];
+            for (let j = 0; j < specifier.namedChildCount; j++) {
+                const child = specifier.namedChild(j);
+                if (child?.type === 'identifier')
+                    identifiers.push(child.text);
+            }
+            if (identifiers.length === 1) {
+                // export { User } from './base' → re-exports User as User
+                bindings.push({ local: identifiers[0], exported: identifiers[0] });
+            }
+            else if (identifiers.length === 2) {
+                // export { Repo as Repository } from './models' → name=Repo, alias=Repository
+                // For re-exports, the first id is the source name, second is what's exported
+                // When another file imports { Repository }, they get Repo from the source
+                bindings.push({ local: identifiers[1], exported: identifiers[0] });
+            }
+        }
+        return bindings.length > 0 ? bindings : undefined;
+    }
+    return undefined;
+}

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

@@ -2,7 +2,7 @@ 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, ExtractedAssignment, ExtractedHeritage, ExtractedRoute, FileConstructorBindings, FileTypeEnvBindings } from './workers/parse-worker.js';
+import type { ExtractedImport, ExtractedCall, ExtractedAssignment, ExtractedHeritage, ExtractedRoute, ExtractedFetchCall, ExtractedDecoratorRoute, ExtractedToolDef, FileConstructorBindings, FileTypeEnvBindings, ExtractedORMQuery } from './workers/parse-worker.js';
 export type FileProgressCallback = (current: number, total: number, filePath: string) => void;
 export interface WorkerExtractedData {
     imports: ExtractedImport[];
@@ -10,6 +10,10 @@ export interface WorkerExtractedData {
     assignments: ExtractedAssignment[];
     heritage: ExtractedHeritage[];
     routes: ExtractedRoute[];
+    fetchCalls: ExtractedFetchCall[];
+    decoratorRoutes: ExtractedDecoratorRoute[];
+    toolDefs: ExtractedToolDef[];
+    ormQueries: ExtractedORMQuery[];
     constructorBindings: FileConstructorBindings[];
     typeEnvBindings: FileTypeEnvBindings[];
 }

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

@@ -1,12 +1,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 { getProvider } from './languages/index.js';
 import { generateId } from '../../lib/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 { getLanguageFromFilename } from './utils/language-detection.js';
+import { yieldToEventLoop } from './utils/event-loop.js';
+import { getDefinitionNodeFromCaptures, findEnclosingClassId, extractMethodSignature, getLabelFromCaptures, CLASS_CONTAINER_TYPES } from './utils/ast-helpers.js';
 import { detectFrameworkFromAST } from './framework-detection.js';
-import { typeConfigs } from './type-extractors/index.js';
+import { buildTypeEnv } from './type-env.js';
 import { getTreeSitterBufferSize, TREE_SITTER_MAX_BUFFER } from './constants.js';
 // ============================================================================
 // Worker-based parallel parsing
@@ -20,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: [], assignments: [], heritage: [], routes: [], constructorBindings: [], typeEnvBindings: [] };
+        return { imports: [], calls: [], assignments: [], heritage: [], routes: [], fetchCalls: [], decoratorRoutes: [], toolDefs: [], ormQueries: [], 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) => {
@@ -32,6 +32,10 @@ const processParsingWithWorkers = async (graph, files, symbolTable, astCache, wo
     const allAssignments = [];
     const allHeritage = [];
     const allRoutes = [];
+    const allFetchCalls = [];
+    const allDecoratorRoutes = [];
+    const allToolDefs = [];
+    const allORMQueries = [];
     const allConstructorBindings = [];
     const allTypeEnvBindings = [];
     for (const result of chunkResults) {
@@ -60,6 +64,11 @@ const processParsingWithWorkers = async (graph, files, symbolTable, astCache, wo
         allAssignments.push(...result.assignments);
         allHeritage.push(...result.heritage);
         allRoutes.push(...result.routes);
+        allFetchCalls.push(...result.fetchCalls);
+        allDecoratorRoutes.push(...result.decoratorRoutes);
+        allToolDefs.push(...result.toolDefs);
+        if (result.ormQueries)
+            allORMQueries.push(...result.ormQueries);
         allConstructorBindings.push(...result.constructorBindings);
         allTypeEnvBindings.push(...result.typeEnvBindings);
     }
@@ -78,17 +87,75 @@ const processParsingWithWorkers = async (graph, files, symbolTable, astCache, wo
     }
     // Final progress
     onFileProgress?.(total, total, 'done');
-    return { imports: allImports, calls: allCalls, assignments: allAssignments, heritage: allHeritage, routes: allRoutes, constructorBindings: allConstructorBindings, typeEnvBindings: allTypeEnvBindings };
+    return { imports: allImports, calls: allCalls, assignments: allAssignments, heritage: allHeritage, routes: allRoutes, fetchCalls: allFetchCalls, decoratorRoutes: allDecoratorRoutes, toolDefs: allToolDefs, ormQueries: allORMQueries, constructorBindings: allConstructorBindings, typeEnvBindings: allTypeEnvBindings };
 };
 // ============================================================================
 // Sequential fallback (original implementation)
 // ============================================================================
+// Inline caches to avoid repeated parent-walks per node (same pattern as parse-worker.ts).
+// Keyed by tree-sitter node reference — cleared at the start of each file.
+const classIdCache = new Map();
+const exportCache = new Map();
+const cachedFindEnclosingClassId = (node, filePath) => {
+    const cached = classIdCache.get(node);
+    if (cached !== undefined)
+        return cached;
+    const result = findEnclosingClassId(node, filePath);
+    classIdCache.set(node, result);
+    return result;
+};
+const cachedExportCheck = (checker, node, name) => {
+    const cached = exportCache.get(node);
+    if (cached !== undefined)
+        return cached;
+    const result = checker(node, name);
+    exportCache.set(node, result);
+    return result;
+};
+// FieldExtractor cache for sequential path — same pattern as parse-worker.ts
+const seqFieldInfoCache = new Map();
+function seqFindEnclosingClassNode(node) {
+    let current = node.parent;
+    while (current) {
+        if (CLASS_CONTAINER_TYPES.has(current.type))
+            return current;
+        current = current.parent;
+    }
+    return null;
+}
+/** Minimal no-op SymbolTable stub for FieldExtractorContext (sequential path has a real
+ *  SymbolTable, but it's incomplete at this stage — use the stub for safety). */
+const NOOP_SYMBOL_TABLE_SEQ = {
+    lookupExactAll: () => [],
+    lookupExact: () => undefined,
+    lookupExactFull: () => undefined,
+};
+function seqGetFieldInfo(classNode, provider, context) {
+    if (!provider.fieldExtractor)
+        return undefined;
+    const cacheKey = classNode.startIndex;
+    let cached = seqFieldInfoCache.get(cacheKey);
+    if (cached)
+        return cached;
+    const extracted = provider.fieldExtractor.extract(classNode, context);
+    if (!extracted?.fields?.length)
+        return undefined;
+    cached = new Map();
+    for (const field of extracted.fields)
+        cached.set(field.name, field);
+    seqFieldInfoCache.set(cacheKey, cached);
+    return cached;
+}
 const processParsingSequential = async (graph, files, symbolTable, astCache, onFileProgress) => {
     const parser = await loadParser();
     const total = files.length;
     const skippedLanguages = new Map();
     for (let i = 0; i < files.length; i++) {
         const file = files[i];
+        // Reset memoization before each new file (node refs are per-tree)
+        classIdCache.clear();
+        exportCache.clear();
+        seqFieldInfoCache.clear();
         onFileProgress?.(i + 1, total, file.path);
         if (i % 20 === 0)
             await yieldToEventLoop();
@@ -118,7 +185,8 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, onF
             continue;
         }
         astCache.set(file.path, tree);
-        const queryString = LANGUAGE_QUERIES[language];
+        const provider = getProvider(language);
+        const queryString = provider.treeSitterQueries;
         if (!queryString) {
             continue;
         }
@@ -133,12 +201,14 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, onF
             console.warn(`Query error for ${file.path}:`, queryError);
             continue;
         }
+        // Build per-file type environment for FieldExtractor context (lightweight — skipped if no fieldExtractor)
+        const typeEnv = provider.fieldExtractor ? buildTypeEnv(tree, language, { enclosingFunctionFinder: provider.enclosingFunctionFinder }) : null;
         matches.forEach(match => {
             const captureMap = {};
             match.captures.forEach(c => {
                 captureMap[c.name] = c.node;
             });
-            const nodeLabel = getLabelFromCaptures(captureMap, language);
+            const nodeLabel = getLabelFromCaptures(captureMap, provider);
             if (!nodeLabel)
                 return;
             const nameNode = captureMap['name'];
@@ -160,7 +230,7 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, onF
             // Language-specific return type fallback (e.g. Ruby YARD @return [Type])
             // Also upgrades uninformative AST types like PHP `array` with PHPDoc `@return User[]`
             if (methodSig && (!methodSig.returnType || methodSig.returnType === 'array' || methodSig.returnType === 'iterable') && definitionNode) {
-                const tc = typeConfigs[language];
+                const tc = provider.typeConfig;
                 if (tc?.extractReturnType) {
                     const docReturn = tc.extractReturnType(definitionNode);
                     if (docReturn)
@@ -176,7 +246,7 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, onF
                     startLine: definitionNodeForRange ? definitionNodeForRange.startPosition.row : startLine,
                     endLine: definitionNodeForRange ? definitionNodeForRange.endPosition.row : startLine,
                     language: language,
-                    isExported: isNodeExported(nameNode || definitionNodeForRange, nodeName, language),
+                    isExported: cachedExportCheck(provider.exportChecker, nameNode || definitionNodeForRange, nodeName),
                     ...(frameworkHint ? {
                         astFrameworkMultiplier: frameworkHint.entryPointMultiplier,
                         astFrameworkReason: frameworkHint.reason,
@@ -193,11 +263,40 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, onF
             // Compute enclosing class for Method/Constructor/Property/Function — used for both ownerId and HAS_METHOD
             // 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;
+            const enclosingClassId = needsOwner ? cachedFindEnclosingClassId(nameNode || definitionNodeForRange, file.path) : null;
+            // Extract declared type and field metadata for Property nodes
+            let declaredType;
+            let seqVisibility;
+            let seqIsStatic;
+            let seqIsReadonly;
+            if (nodeLabel === 'Property' && definitionNode) {
+                // FieldExtractor is the single source of truth when available
+                if (provider.fieldExtractor && typeEnv) {
+                    const classNode = seqFindEnclosingClassNode(definitionNode);
+                    if (classNode) {
+                        const fieldMap = seqGetFieldInfo(classNode, provider, {
+                            typeEnv, symbolTable: NOOP_SYMBOL_TABLE_SEQ, filePath: file.path, language,
+                        });
+                        const info = fieldMap?.get(nodeName);
+                        if (info) {
+                            declaredType = info.type ?? undefined;
+                            seqVisibility = info.visibility;
+                            seqIsStatic = info.isStatic;
+                            seqIsReadonly = info.isReadonly;
+                        }
+                    }
+                }
+                // All 14 languages register a FieldExtractor — no fallback needed.
+            }
+            // Apply field metadata to the graph node retroactively
+            if (seqVisibility !== undefined)
+                node.properties.visibility = seqVisibility;
+            if (seqIsStatic !== undefined)
+                node.properties.isStatic = seqIsStatic;
+            if (seqIsReadonly !== undefined)
+                node.properties.isReadonly = seqIsReadonly;
+            if (declaredType !== undefined)
+                node.properties.declaredType = declaredType;
             symbolTable.add(file.path, nodeName, nodeId, nodeLabel, {
                 parameterCount: methodSig?.parameterCount,
                 requiredParameterCount: methodSig?.requiredParameterCount,