gitnexus 1.5.3 → 1.6.0

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

@@ -2,11 +2,13 @@ import Parser from 'tree-sitter';
 import { loadParser, loadLanguage, isLanguageAvailable } from '../tree-sitter/parser-loader.js';
 import { getProvider } from './languages/index.js';
 import { generateId } from '../../lib/utils.js';
-import { getLanguageFromFilename } from '../../_shared/index.js';
+import { getLanguageFromFilename, SupportedLanguages } from '../../_shared/index.js';
+import { extractVueScript, isVueSetupTopLevel } from './vue-sfc-extractor.js';
 import { yieldToEventLoop } from './utils/event-loop.js';
-import { getDefinitionNodeFromCaptures, findEnclosingClassId, extractMethodSignature, getLabelFromCaptures, CLASS_CONTAINER_TYPES, } from './utils/ast-helpers.js';
+import { getDefinitionNodeFromCaptures, findEnclosingClassInfo, getLabelFromCaptures, CLASS_CONTAINER_TYPES, } from './utils/ast-helpers.js';
 import { detectFrameworkFromAST } from './framework-detection.js';
 import { buildTypeEnv } from './type-env.js';
+import { buildMethodProps, arityForIdFromInfo, typeTagForId, constTagForId, buildCollisionGroups, } from './utils/method-props.js';
 import { getTreeSitterBufferSize, TREE_SITTER_MAX_BUFFER } from './constants.js';
 // ============================================================================
 // Worker-based parallel parsing
@@ -31,7 +33,7 @@ const processParsingWithWorkers = async (graph, files, symbolTable, astCache, wo
             toolDefs: [],
             ormQueries: [],
             constructorBindings: [],
-            typeEnvBindings: [],
+            fileScopeBindings: [],
         };
     const total = files.length;
     // Dispatch to worker pool — pool handles splitting into chunks and sub-batching
@@ -49,7 +51,7 @@ const processParsingWithWorkers = async (graph, files, symbolTable, astCache, wo
     const allToolDefs = [];
     const allORMQueries = [];
     const allConstructorBindings = [];
-    const allTypeEnvBindings = [];
+    const fileScopeBindingsByFile = [];
     for (const result of chunkResults) {
         for (const node of result.nodes) {
             graph.addNode({
@@ -69,20 +71,33 @@ const processParsingWithWorkers = async (graph, files, symbolTable, astCache, wo
                 returnType: sym.returnType,
                 declaredType: sym.declaredType,
                 ownerId: sym.ownerId,
+                qualifiedName: sym.qualifiedName,
             });
         }
-        allImports.push(...result.imports);
-        allCalls.push(...result.calls);
-        allAssignments.push(...result.assignments);
-        allHeritage.push(...result.heritage);
-        allRoutes.push(...result.routes);
-        allFetchCalls.push(...result.fetchCalls);
-        allDecoratorRoutes.push(...result.decoratorRoutes);
-        allToolDefs.push(...result.toolDefs);
+        for (const _item of result.imports)
+            allImports.push(_item);
+        for (const _item of result.calls)
+            allCalls.push(_item);
+        for (const _item of result.assignments)
+            allAssignments.push(_item);
+        for (const _item of result.heritage)
+            allHeritage.push(_item);
+        for (const _item of result.routes)
+            allRoutes.push(_item);
+        for (const _item of result.fetchCalls)
+            allFetchCalls.push(_item);
+        for (const _item of result.decoratorRoutes)
+            allDecoratorRoutes.push(_item);
+        for (const _item of result.toolDefs)
+            allToolDefs.push(_item);
         if (result.ormQueries)
-            allORMQueries.push(...result.ormQueries);
-        allConstructorBindings.push(...result.constructorBindings);
-        allTypeEnvBindings.push(...result.typeEnvBindings);
+            for (const _item of result.ormQueries)
+                allORMQueries.push(_item);
+        for (const _item of result.constructorBindings)
+            allConstructorBindings.push(_item);
+        if (result.fileScopeBindings)
+            for (const _item of result.fileScopeBindings)
+                fileScopeBindingsByFile.push(_item);
     }
     // Merge and log skipped languages from workers
     const skippedLanguages = new Map();
@@ -110,7 +125,7 @@ const processParsingWithWorkers = async (graph, files, symbolTable, astCache, wo
         toolDefs: allToolDefs,
         ormQueries: allORMQueries,
         constructorBindings: allConstructorBindings,
-        typeEnvBindings: allTypeEnvBindings,
+        fileScopeBindings: fileScopeBindingsByFile,
     };
 };
 // ============================================================================
@@ -118,14 +133,14 @@ const processParsingWithWorkers = async (graph, files, symbolTable, astCache, wo
 // ============================================================================
 // 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 classInfoCache = new Map();
 const exportCache = new Map();
-const cachedFindEnclosingClassId = (node, filePath) => {
-    const cached = classIdCache.get(node);
+const cachedFindEnclosingClassInfo = (node, filePath) => {
+    const cached = classInfoCache.get(node);
     if (cached !== undefined)
         return cached;
-    const result = findEnclosingClassId(node, filePath);
-    classIdCache.set(node, result);
+    const result = findEnclosingClassInfo(node, filePath);
+    classInfoCache.set(node, result);
     return result;
 };
 const cachedExportCheck = (checker, node, name) => {
@@ -138,21 +153,36 @@ const cachedExportCheck = (checker, node, name) => {
 };
 // FieldExtractor cache for sequential path — same pattern as parse-worker.ts
 const seqFieldInfoCache = new Map();
+// MethodExtractor cache for sequential path — avoids re-traversing the same class
+// body once per method. Keyed on classNode.id (tree-sitter node identity number).
+const seqMethodExtractCache = new Map();
+// Derived method map + collision groups cache — avoids rebuilding per method.
+const seqMethodMapCache = new Map();
 function seqFindEnclosingClassNode(node) {
     let current = node.parent;
     while (current) {
-        if (CLASS_CONTAINER_TYPES.has(current.type))
+        if (CLASS_CONTAINER_TYPES.has(current.type)) {
+            // Return singleton_class directly so the method extractor sees it as
+            // the owner node and correctly marks methods as static. Name resolution
+            // for qualified names is handled separately by findEnclosingClassInfo.
             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). */
+/** 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). Implements the full {@link SymbolTableReader}
+ *  surface so future extractor additions don't silently fall off an
+ *  `as unknown as` cast. */
 const NOOP_SYMBOL_TABLE_SEQ = {
-    lookupExactAll: () => [],
     lookupExact: () => undefined,
     lookupExactFull: () => undefined,
+    lookupExactAll: () => [],
+    lookupCallableByName: () => [],
+    getFiles: () => [][Symbol.iterator](),
+    getStats: () => ({ fileCount: 0 }),
 };
 function seqGetFieldInfo(classNode, provider, context) {
     if (!provider.fieldExtractor)
@@ -177,9 +207,11 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, onF
     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();
+        classInfoCache.clear();
         exportCache.clear();
         seqFieldInfoCache.clear();
+        seqMethodExtractCache.clear();
+        seqMethodMapCache.clear();
         onFileProgress?.(i + 1, total, file.path);
         if (i % 20 === 0)
             await yieldToEventLoop();
@@ -194,6 +226,18 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, onF
         // Skip files larger than the max tree-sitter buffer (32 MB)
         if (file.content.length > TREE_SITTER_MAX_BUFFER)
             continue;
+        // Vue SFC preprocessing: extract <script> block content
+        let parseContent = file.content;
+        let lineOffset = 0;
+        let isVueSetup = false;
+        if (language === SupportedLanguages.Vue) {
+            const extracted = extractVueScript(file.content);
+            if (!extracted)
+                continue; // skip .vue files with no script block
+            parseContent = extracted.scriptContent;
+            lineOffset = extracted.lineOffset;
+            isVueSetup = extracted.isSetup;
+        }
         try {
             await loadLanguage(language, file.path);
         }
@@ -202,8 +246,8 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, onF
         }
         let tree;
         try {
-            tree = parser.parse(file.content, undefined, {
-                bufferSize: getTreeSitterBufferSize(file.content.length),
+            tree = parser.parse(parseContent, undefined, {
+                bufferSize: getTreeSitterBufferSize(parseContent.length),
             });
         }
         catch (parseError) {
@@ -227,90 +271,170 @@ 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)
+        // Build per-file type environment for FieldExtractor context (lightweight — skipped if no fieldExtractor).
+        //
+        // Note: this TypeEnv is intentionally NOT flushed into the BindingAccumulator.
+        // The accumulator feed happens later in `call-processor.ts` via its own
+        // `typeEnv.flush(accumulator)` call. Flushing here would double-count
+        // file-scope bindings and break the single-use invariant of `flush()`.
+        // See the BindingAccumulator class JSDoc for the full accumulator
+        // lifecycle and flush-site ownership rules.
         const typeEnv = provider.fieldExtractor
-            ? buildTypeEnv(tree, language, { enclosingFunctionFinder: provider.enclosingFunctionFinder })
+            ? buildTypeEnv(tree, language, {
+                enclosingFunctionFinder: provider.enclosingFunctionFinder,
+                extractFunctionName: provider.methodExtractor?.extractFunctionName,
+            })
             : null;
         matches.forEach((match) => {
             const captureMap = {};
             match.captures.forEach((c) => {
                 captureMap[c.name] = c.node;
             });
-            const nodeLabel = getLabelFromCaptures(captureMap, provider);
-            if (!nodeLabel)
+            const definitionNodeForRange = getDefinitionNodeFromCaptures(captureMap);
+            const definitionNode = getDefinitionNodeFromCaptures(captureMap);
+            const defaultNodeLabel = getLabelFromCaptures(captureMap, provider);
+            if (!defaultNodeLabel)
                 return;
             const nameNode = captureMap['name'];
+            const extractedClassSymbol = definitionNode && provider.classExtractor?.isTypeDeclaration(definitionNode)
+                ? provider.classExtractor.extract(definitionNode, {
+                    name: nameNode?.text,
+                    type: defaultNodeLabel,
+                })
+                : null;
+            const nodeLabel = extractedClassSymbol?.type ?? defaultNodeLabel;
             // Synthesize name for constructors without explicit @name capture (e.g. Swift init)
-            if (!nameNode && nodeLabel !== 'Constructor')
+            if (!nameNode && nodeLabel !== 'Constructor' && !extractedClassSymbol)
                 return;
-            const nodeName = nameNode ? nameNode.text : 'init';
-            const definitionNodeForRange = getDefinitionNodeFromCaptures(captureMap);
+            const nodeName = extractedClassSymbol?.name ?? (nameNode ? nameNode.text : 'init');
             const startLine = definitionNodeForRange
-                ? definitionNodeForRange.startPosition.row
+                ? definitionNodeForRange.startPosition.row + lineOffset
                 : nameNode
-                    ? nameNode.startPosition.row
-                    : 0;
-            const nodeId = generateId(nodeLabel, `${file.path}:${nodeName}`);
-            const definitionNode = getDefinitionNodeFromCaptures(captureMap);
-            const frameworkHint = definitionNode
-                ? detectFrameworkFromAST(language, (definitionNode.text || '').slice(0, 300))
+                    ? nameNode.startPosition.row + lineOffset
+                    : lineOffset;
+            // Compute enclosing class BEFORE node ID — needed to qualify method IDs
+            const needsOwner = nodeLabel === 'Method' ||
+                nodeLabel === 'Constructor' ||
+                nodeLabel === 'Property' ||
+                nodeLabel === 'Function';
+            const enclosingClassInfo = needsOwner
+                ? cachedFindEnclosingClassInfo(nameNode || definitionNodeForRange, file.path)
                 : null;
-            // Extract method signature for Method/Constructor nodes
-            const methodSig = nodeLabel === 'Function' || nodeLabel === 'Method' || nodeLabel === 'Constructor'
-                ? extractMethodSignature(definitionNode)
-                : undefined;
-            // 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 = provider.typeConfig;
-                if (tc?.extractReturnType) {
-                    const docReturn = tc.extractReturnType(definitionNode);
-                    if (docReturn)
-                        methodSig.returnType = docReturn;
+            const enclosingClassId = enclosingClassInfo?.classId ?? null;
+            // Qualify method/property IDs with enclosing class name to avoid collisions
+            // e.g. "Method:animal.dart:Animal.speak" vs "Method:animal.dart:Dog.speak"
+            const qualifiedName = enclosingClassInfo
+                ? `${enclosingClassInfo.className}.${nodeName}`
+                : nodeName;
+            // Extract method metadata for Function/Method/Constructor nodes BEFORE generating
+            // the node ID — parameterCount is needed to disambiguate overloaded methods.
+            // Use the per-language MethodExtractor for method metadata (isAbstract, isStatic,
+            // visibility, annotations, parameterCount, parameterTypes, returnType, etc.).
+            const isMethodLike = nodeLabel === 'Function' || nodeLabel === 'Method' || nodeLabel === 'Constructor';
+            let methodProps = {};
+            let arityForId; // raw param count for ID, even for variadic
+            let seqDefMethodInfo;
+            let seqDefMethods;
+            let seqClassNodeId;
+            if (isMethodLike && definitionNode) {
+                let enriched = false;
+                if (provider.methodExtractor) {
+                    // Try class-based extraction (method inside a class/struct/trait body)
+                    const classNode = seqFindEnclosingClassNode(definitionNode);
+                    if (classNode) {
+                        // Cache extract() results per class node to avoid re-traversing the
+                        // same class body for every method it contains (O(N) -> O(1) per hit).
+                        let result = seqMethodExtractCache.get(classNode.id);
+                        if (result === undefined) {
+                            result =
+                                provider.methodExtractor.extract(classNode, {
+                                    filePath: file.path,
+                                    language,
+                                }) ?? null;
+                            seqMethodExtractCache.set(classNode.id, result);
+                        }
+                        if (result?.methods?.length) {
+                            const defLine = definitionNode.startPosition.row + 1;
+                            const info = result.methods.find((m) => m.name === nodeName && m.line === defLine);
+                            if (info) {
+                                enriched = true;
+                                arityForId = arityForIdFromInfo(info);
+                                methodProps = buildMethodProps(info);
+                                seqDefMethodInfo = info;
+                                seqDefMethods = result.methods;
+                                seqClassNodeId = classNode.id;
+                            }
+                        }
+                    }
+                    // For top-level methods (e.g. Go method_declaration), try extractFromNode
+                    if (!enriched && provider.methodExtractor.extractFromNode) {
+                        const info = provider.methodExtractor.extractFromNode(definitionNode, {
+                            filePath: file.path,
+                            language,
+                        });
+                        if (info) {
+                            enriched = true;
+                            arityForId = arityForIdFromInfo(info);
+                            methodProps = buildMethodProps(info);
+                        }
+                    }
+                }
+            }
+            // Append #<paramCount> to Method/Constructor IDs to disambiguate overloads.
+            // Functions are not suffixed — they don't overload by name in the same scope.
+            // When same-arity collisions exist, append ~type1,type2 for further disambiguation.
+            const needsAritySuffix = nodeLabel === 'Method' || nodeLabel === 'Constructor';
+            let arityTag = needsAritySuffix && arityForId !== undefined ? `#${arityForId}` : '';
+            if (arityTag && seqDefMethods && seqDefMethodInfo && seqClassNodeId !== undefined) {
+                // Use cached method map + collision groups (built once per class, not per method)
+                let cached = seqMethodMapCache.get(seqClassNodeId);
+                if (!cached) {
+                    const tempMap = new Map();
+                    for (const m of seqDefMethods)
+                        tempMap.set(`${m.name}:${m.line}`, m);
+                    cached = { map: tempMap, groups: buildCollisionGroups(tempMap) };
+                    seqMethodMapCache.set(seqClassNodeId, cached);
                 }
+                arityTag += typeTagForId(cached.map, nodeName, arityForId, seqDefMethodInfo, language, cached.groups);
+                arityTag += constTagForId(cached.map, nodeName, arityForId, seqDefMethodInfo, cached.groups);
             }
+            const nodeId = generateId(nodeLabel, `${file.path}:${qualifiedName}${arityTag}`);
+            const classNodeForSymbol = definitionNodeForRange || definitionNode || nameNode;
+            const qualifiedTypeName = extractedClassSymbol?.qualifiedName ??
+                (classNodeForSymbol && provider.classExtractor?.isTypeDeclaration(classNodeForSymbol)
+                    ? (provider.classExtractor.extractQualifiedName(classNodeForSymbol, nodeName) ?? nodeName)
+                    : undefined);
+            const frameworkHint = definitionNode
+                ? detectFrameworkFromAST(language, (definitionNode.text || '').slice(0, 300))
+                : null;
             const node = {
                 id: nodeId,
                 label: nodeLabel,
                 properties: {
                     name: nodeName,
                     filePath: file.path,
-                    startLine: definitionNodeForRange ? definitionNodeForRange.startPosition.row : startLine,
-                    endLine: definitionNodeForRange ? definitionNodeForRange.endPosition.row : startLine,
+                    startLine: definitionNodeForRange
+                        ? definitionNodeForRange.startPosition.row + lineOffset
+                        : startLine,
+                    endLine: definitionNodeForRange
+                        ? definitionNodeForRange.endPosition.row + lineOffset
+                        : startLine,
                     language: language,
-                    isExported: cachedExportCheck(provider.exportChecker, nameNode || definitionNodeForRange, nodeName),
+                    isExported: language === SupportedLanguages.Vue && isVueSetup
+                        ? isVueSetupTopLevel(nameNode || definitionNodeForRange)
+                        : cachedExportCheck(provider.exportChecker, nameNode || definitionNodeForRange, nodeName),
+                    ...(qualifiedTypeName !== undefined ? { qualifiedName: qualifiedTypeName } : {}),
                     ...(frameworkHint
                         ? {
                             astFrameworkMultiplier: frameworkHint.entryPointMultiplier,
                             astFrameworkReason: frameworkHint.reason,
                         }
                         : {}),
-                    ...(methodSig
-                        ? {
-                            parameterCount: methodSig.parameterCount,
-                            ...(methodSig.requiredParameterCount !== undefined
-                                ? { requiredParameterCount: methodSig.requiredParameterCount }
-                                : {}),
-                            ...(methodSig.parameterTypes ? { parameterTypes: methodSig.parameterTypes } : {}),
-                            returnType: methodSig.returnType,
-                        }
-                        : {}),
+                    ...methodProps,
                 },
             };
             graph.addNode(node);
-            // 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
-                ? cachedFindEnclosingClassId(nameNode || definitionNodeForRange, file.path)
-                : null;
+            // enclosingClassId already computed above (before nodeId generation)
             // Extract declared type and field metadata for Property nodes
             let declaredType;
             let seqVisibility;
@@ -336,7 +460,7 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, onF
                         }
                     }
                 }
-                // All 14 languages register a FieldExtractor — no fallback needed.
+                // All 15 tree-sitter languages register a FieldExtractor — no fallback needed.
             }
             // Apply field metadata to the graph node retroactively
             if (seqVisibility !== undefined)
@@ -348,12 +472,13 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, onF
             if (declaredType !== undefined)
                 node.properties.declaredType = declaredType;
             symbolTable.add(file.path, nodeName, nodeId, nodeLabel, {
-                parameterCount: methodSig?.parameterCount,
-                requiredParameterCount: methodSig?.requiredParameterCount,
-                parameterTypes: methodSig?.parameterTypes,
-                returnType: methodSig?.returnType,
+                parameterCount: methodProps.parameterCount,
+                requiredParameterCount: methodProps.requiredParameterCount,
+                parameterTypes: methodProps.parameterTypes,
+                returnType: methodProps.returnType,
                 declaredType,
                 ownerId: enclosingClassId ?? undefined,
+                qualifiedName: qualifiedTypeName,
             });
             const fileId = generateId('File', file.path);
             const relId = generateId('DEFINES', `${fileId}->${nodeId}`);

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

@@ -12,6 +12,8 @@ export declare function topologicalLevelSort(importMap: ReadonlyMap<string, Read
 export interface PipelineOptions {
     /** Skip MRO, community detection, and process extraction for faster test runs. */
     skipGraphPhases?: boolean;
+    /** Force sequential parsing (no worker pool). Useful for testing the sequential path. */
+    skipWorkers?: boolean;
 }
 export declare const runPipelineFromRepo: (repoPath: string, onProgress: (progress: PipelineProgress) => void, options?: PipelineOptions) => Promise<PipelineResult>;
 export {};