gitnexus 1.4.1 → 1.4.6

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

@@ -1,179 +1,15 @@
 import Parser from 'tree-sitter';
-import { loadParser, loadLanguage } from '../tree-sitter/parser-loader.js';
+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 { findSiblingChild, getLanguageFromFilename, yieldToEventLoop } from './utils.js';
+import { getLanguageFromFilename, yieldToEventLoop, getDefinitionNodeFromCaptures, findEnclosingClassId, extractMethodSignature } from './utils.js';
+import { isNodeExported } from './export-detection.js';
 import { detectFrameworkFromAST } from './framework-detection.js';
-const DEFINITION_CAPTURE_KEYS = [
-    'definition.function',
-    'definition.class',
-    'definition.interface',
-    'definition.method',
-    'definition.struct',
-    'definition.enum',
-    'definition.namespace',
-    'definition.module',
-    'definition.trait',
-    'definition.impl',
-    'definition.type',
-    'definition.const',
-    'definition.static',
-    'definition.typedef',
-    'definition.macro',
-    'definition.union',
-    'definition.property',
-    'definition.record',
-    'definition.delegate',
-    'definition.annotation',
-    'definition.constructor',
-    'definition.template',
-];
-const getDefinitionNodeFromCaptures = (captureMap) => {
-    for (const key of DEFINITION_CAPTURE_KEYS) {
-        if (captureMap[key])
-            return captureMap[key];
-    }
-    return null;
-};
-// ============================================================================
-// EXPORT DETECTION - Language-specific visibility detection
-// ============================================================================
-/**
- * Check if a symbol (function, class, etc.) is exported/public
- * Handles all 9 supported languages with explicit logic
- *
- * @param node - The AST node for the symbol name
- * @param name - The symbol name
- * @param language - The programming language
- * @returns true if the symbol is exported/public
- */
-export const isNodeExported = (node, name, language) => {
-    let current = node;
-    switch (language) {
-        // JavaScript/TypeScript: Check for export keyword in ancestors
-        case 'javascript':
-        case 'typescript':
-            while (current) {
-                const type = current.type;
-                if (type === 'export_statement' ||
-                    type === 'export_specifier' ||
-                    type === 'lexical_declaration' && current.parent?.type === 'export_statement') {
-                    return true;
-                }
-                // Also check if text starts with 'export '
-                if (current.text?.startsWith('export ')) {
-                    return true;
-                }
-                current = current.parent;
-            }
-            return false;
-        // Python: Public if no leading underscore (convention)
-        case 'python':
-            return !name.startsWith('_');
-        // Java: Check for 'public' modifier
-        // In tree-sitter Java, modifiers are siblings of the name node, not parents
-        case 'java':
-            while (current) {
-                // Check if this node or any sibling is a 'modifiers' node containing 'public'
-                if (current.parent) {
-                    const parent = current.parent;
-                    // Check all children of the parent for modifiers
-                    for (let i = 0; i < parent.childCount; i++) {
-                        const child = parent.child(i);
-                        if (child?.type === 'modifiers' && child.text?.includes('public')) {
-                            return true;
-                        }
-                    }
-                    // Also check if the parent's text starts with 'public' (fallback)
-                    if (parent.type === 'method_declaration' || parent.type === 'constructor_declaration') {
-                        if (parent.text?.trimStart().startsWith('public')) {
-                            return true;
-                        }
-                    }
-                }
-                current = current.parent;
-            }
-            return false;
-        // C#: Check for 'public' modifier in ancestors
-        case 'csharp':
-            while (current) {
-                if (current.type === 'modifier' || current.type === 'modifiers') {
-                    if (current.text?.includes('public'))
-                        return true;
-                }
-                current = current.parent;
-            }
-            return false;
-        // Go: Uppercase first letter = exported
-        case 'go':
-            if (name.length === 0)
-                return false;
-            const first = name[0];
-            // Must be uppercase letter (not a number or symbol)
-            return first === first.toUpperCase() && first !== first.toLowerCase();
-        // Rust: Check for 'pub' visibility modifier
-        case 'rust':
-            while (current) {
-                if (current.type === 'visibility_modifier') {
-                    if (current.text?.includes('pub'))
-                        return true;
-                }
-                current = current.parent;
-            }
-            return false;
-        // Kotlin: Default visibility is public (unlike Java)
-        // visibility_modifier is inside modifiers, a sibling of the name node within the declaration
-        case 'kotlin':
-            while (current) {
-                if (current.parent) {
-                    const visMod = findSiblingChild(current.parent, 'modifiers', 'visibility_modifier');
-                    if (visMod) {
-                        const text = visMod.text;
-                        if (text === 'private' || text === 'internal' || text === 'protected')
-                            return false;
-                        if (text === 'public')
-                            return true;
-                    }
-                }
-                current = current.parent;
-            }
-            // No visibility modifier = public (Kotlin default)
-            return true;
-        // C/C++: No native export concept at language level
-        // Entry points will be detected via name patterns (main, etc.)
-        case 'c':
-        case 'cpp':
-            return false;
-        // Swift: Check for 'public' or 'open' access modifiers
-        case 'swift':
-            while (current) {
-                if (current.type === 'modifiers' || current.type === 'visibility_modifier') {
-                    const text = current.text || '';
-                    if (text.includes('public') || text.includes('open'))
-                        return true;
-                }
-                current = current.parent;
-            }
-            return false;
-        // PHP: Check for visibility modifier or top-level scope
-        case 'php':
-            while (current) {
-                if (current.type === 'class_declaration' ||
-                    current.type === 'interface_declaration' ||
-                    current.type === 'trait_declaration' ||
-                    current.type === 'enum_declaration') {
-                    return true;
-                }
-                if (current.type === 'visibility_modifier') {
-                    return current.text === 'public';
-                }
-                current = current.parent;
-            }
-            return true; // Top-level functions are globally accessible
-        default:
-            return false;
-    }
-};
+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
 // ============================================================================
@@ -186,7 +22,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: [] };
+        return { imports: [], calls: [], heritage: [], routes: [], constructorBindings: [] };
     const total = files.length;
     // Dispatch to worker pool — pool handles splitting into chunks and sub-batching
     const chunkResults = await workerPool.dispatch(parseableFiles, (filesProcessed) => {
@@ -197,6 +33,7 @@ const processParsingWithWorkers = async (graph, files, symbolTable, astCache, wo
     const allCalls = [];
     const allHeritage = [];
     const allRoutes = [];
+    const allConstructorBindings = [];
     for (const result of chunkResults) {
         for (const node of result.nodes) {
             graph.addNode({
@@ -209,16 +46,34 @@ const processParsingWithWorkers = async (graph, files, symbolTable, astCache, wo
             graph.addRelationship(rel);
         }
         for (const sym of result.symbols) {
-            symbolTable.add(sym.filePath, sym.name, sym.nodeId, sym.type);
+            symbolTable.add(sym.filePath, sym.name, sym.nodeId, sym.type, {
+                parameterCount: sym.parameterCount,
+                returnType: sym.returnType,
+                ownerId: sym.ownerId,
+            });
         }
         allImports.push(...result.imports);
         allCalls.push(...result.calls);
         allHeritage.push(...result.heritage);
         allRoutes.push(...result.routes);
+        allConstructorBindings.push(...result.constructorBindings);
+    }
+    // Merge and log skipped languages from workers
+    const skippedLanguages = new Map();
+    for (const result of chunkResults) {
+        for (const [lang, count] of Object.entries(result.skippedLanguages)) {
+            skippedLanguages.set(lang, (skippedLanguages.get(lang) || 0) + count);
+        }
+    }
+    if (skippedLanguages.size > 0) {
+        const summary = Array.from(skippedLanguages.entries())
+            .map(([lang, count]) => `${lang}: ${count}`)
+            .join(', ');
+        console.warn(`  Skipped unsupported languages: ${summary}`);
     }
     // Final progress
     onFileProgress?.(total, total, 'done');
-    return { imports: allImports, calls: allCalls, heritage: allHeritage, routes: allRoutes };
+    return { imports: allImports, calls: allCalls, heritage: allHeritage, routes: allRoutes, constructorBindings: allConstructorBindings };
 };
 // ============================================================================
 // Sequential fallback (original implementation)
@@ -226,6 +81,7 @@ const processParsingWithWorkers = async (graph, files, symbolTable, astCache, wo
 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];
         onFileProgress?.(i + 1, total, file.path);
@@ -234,18 +90,23 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, onF
         const language = getLanguageFromFilename(file.path);
         if (!language)
             continue;
-        // Skip very large files — they can crash tree-sitter or cause OOM
-        if (file.content.length > 512 * 1024)
+        // Skip unsupported languages (e.g. Swift when tree-sitter-swift not installed)
+        if (!isLanguageAvailable(language)) {
+            skippedLanguages.set(language, (skippedLanguages.get(language) || 0) + 1);
+            continue;
+        }
+        // Skip files larger than the max tree-sitter buffer (32 MB)
+        if (file.content.length > TREE_SITTER_MAX_BUFFER)
             continue;
         try {
             await loadLanguage(language, file.path);
         }
         catch {
-            continue; // parser unavailable — already warned in pipeline
+            continue; // parser unavailable — safety net
         }
         let tree;
         try {
-            tree = parser.parse(file.content, undefined, { bufferSize: 1024 * 256 });
+            tree = parser.parse(file.content, undefined, { bufferSize: getTreeSitterBufferSize(file.content.length) });
         }
         catch (parseError) {
             console.warn(`Skipping unparseable file: ${file.path}`);
@@ -330,11 +191,25 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, onF
                 nodeLabel = 'Template';
             const definitionNodeForRange = getDefinitionNodeFromCaptures(captureMap);
             const startLine = definitionNodeForRange ? definitionNodeForRange.startPosition.row : (nameNode ? nameNode.startPosition.row : 0);
-            const nodeId = generateId(nodeLabel, `${file.path}:${nodeName}:${startLine}`);
+            const nodeId = generateId(nodeLabel, `${file.path}:${nodeName}`);
             const definitionNode = getDefinitionNodeFromCaptures(captureMap);
             const frameworkHint = definitionNode
                 ? detectFrameworkFromAST(language, (definitionNode.text || '').slice(0, 300))
                 : 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 = typeConfigs[language];
+                if (tc?.extractReturnType) {
+                    const docReturn = tc.extractReturnType(definitionNode);
+                    if (docReturn)
+                        methodSig.returnType = docReturn;
+                }
+            }
             const node = {
                 id: nodeId,
                 label: nodeLabel,
@@ -349,10 +224,22 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, onF
                         astFrameworkMultiplier: frameworkHint.entryPointMultiplier,
                         astFrameworkReason: frameworkHint.reason,
                     } : {}),
+                    ...(methodSig ? {
+                        parameterCount: methodSig.parameterCount,
+                        returnType: methodSig.returnType,
+                    } : {}),
                 },
             };
             graph.addNode(node);
-            symbolTable.add(file.path, nodeName, nodeId, nodeLabel);
+            // 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;
+            symbolTable.add(file.path, nodeName, nodeId, nodeLabel, {
+                parameterCount: methodSig?.parameterCount,
+                returnType: methodSig?.returnType,
+                ownerId: enclosingClassId ?? undefined,
+            });
             const fileId = generateId('File', file.path);
             const relId = generateId('DEFINES', `${fileId}->${nodeId}`);
             const relationship = {
@@ -364,8 +251,25 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, onF
                 reason: '',
             };
             graph.addRelationship(relationship);
+            // ── HAS_METHOD: link method/constructor/property to enclosing class ──
+            if (enclosingClassId) {
+                graph.addRelationship({
+                    id: generateId('HAS_METHOD', `${enclosingClassId}->${nodeId}`),
+                    sourceId: enclosingClassId,
+                    targetId: nodeId,
+                    type: 'HAS_METHOD',
+                    confidence: 1.0,
+                    reason: '',
+                });
+            }
         });
     }
+    if (skippedLanguages.size > 0) {
+        const summary = Array.from(skippedLanguages.entries())
+            .map(([lang, count]) => `${lang}: ${count}`)
+            .join(', ');
+        console.warn(`  Skipped unsupported languages: ${summary}`);
+    }
 };
 // ============================================================================
 // Public API

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

@@ -1,2 +1,6 @@
 import { PipelineProgress, PipelineResult } from '../../types/pipeline.js';
-export declare const runPipelineFromRepo: (repoPath: string, onProgress: (progress: PipelineProgress) => void) => Promise<PipelineResult>;
+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>;