gitnexus 1.4.0 → 1.4.1

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

@@ -10,7 +10,16 @@ export interface WorkerExtractedData {
     heritage: ExtractedHeritage[];
     routes: ExtractedRoute[];
 }
-export { isNodeExported } from './export-detection.js';
+/**
+ * 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 declare const isNodeExported: (node: any, name: string, language: string) => boolean;
 export declare const processParsing: (graph: KnowledgeGraph, files: {
     path: string;
     content: string;

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

@@ -2,13 +2,178 @@ import Parser from 'tree-sitter';
 import { loadParser, loadLanguage } 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 { isNodeExported } from './export-detection.js';
+import { findSiblingChild, getLanguageFromFilename, yieldToEventLoop } from './utils.js';
 import { detectFrameworkFromAST } from './framework-detection.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';
+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;
+    }
+};
 // ============================================================================
 // Worker-based parallel parsing
 // ============================================================================
@@ -44,10 +209,7 @@ 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, {
-                parameterCount: sym.parameterCount,
-                ownerId: sym.ownerId,
-            });
+            symbolTable.add(sym.filePath, sym.name, sym.nodeId, sym.type);
         }
         allImports.push(...result.imports);
         allCalls.push(...result.calls);
@@ -72,8 +234,8 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, onF
         const language = getLanguageFromFilename(file.path);
         if (!language)
             continue;
-        // Skip files larger than the max tree-sitter buffer (32 MB)
-        if (file.content.length > TREE_SITTER_MAX_BUFFER)
+        // Skip very large files — they can crash tree-sitter or cause OOM
+        if (file.content.length > 512 * 1024)
             continue;
         try {
             await loadLanguage(language, file.path);
@@ -83,7 +245,7 @@ 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(file.content, undefined, { bufferSize: 1024 * 256 });
         }
         catch (parseError) {
             console.warn(`Skipping unparseable file: ${file.path}`);
@@ -168,15 +330,11 @@ 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}`);
+            const nodeId = generateId(nodeLabel, `${file.path}:${nodeName}:${startLine}`);
             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;
             const node = {
                 id: nodeId,
                 label: nodeLabel,
@@ -191,21 +349,10 @@ const processParsingSequential = async (graph, files, symbolTable, astCache, onF
                         astFrameworkMultiplier: frameworkHint.entryPointMultiplier,
                         astFrameworkReason: frameworkHint.reason,
                     } : {}),
-                    ...(methodSig ? {
-                        parameterCount: methodSig.parameterCount,
-                        returnType: methodSig.returnType,
-                    } : {}),
                 },
             };
             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 ? findEnclosingClassId(nameNode || definitionNodeForRange, file.path) : null;
-            symbolTable.add(file.path, nodeName, nodeId, nodeLabel, {
-                parameterCount: methodSig?.parameterCount,
-                ownerId: enclosingClassId ?? undefined,
-            });
+            symbolTable.add(file.path, nodeName, nodeId, nodeLabel);
             const fileId = generateId('File', file.path);
             const relId = generateId('DEFINES', `${fileId}->${nodeId}`);
             const relationship = {
@@ -217,17 +364,6 @@ 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: '',
-                });
-            }
         });
     }
 };

package/dist/core/ingestion/pipeline.js

@@ -1,10 +1,9 @@
 import { createKnowledgeGraph } from '../graph/graph.js';
 import { processStructure } from './structure-processor.js';
 import { processParsing } from './parsing-processor.js';
-import { processImports, processImportsFromExtracted, createImportMap, createPackageMap, createNamedImportMap, buildImportResolutionContext } from './import-processor.js';
+import { processImports, processImportsFromExtracted, createImportMap, buildImportResolutionContext } from './import-processor.js';
 import { processCalls, processCallsFromExtracted, processRoutesFromExtracted } from './call-processor.js';
 import { processHeritage, processHeritageFromExtracted } from './heritage-processor.js';
-import { computeMRO } from './mro-processor.js';
 import { processCommunities } from './community-processor.js';
 import { processProcesses } from './process-processor.js';
 import { createSymbolTable } from './symbol-table.js';
@@ -13,9 +12,6 @@ import { walkRepositoryPaths, readFileContents } from './filesystem-walker.js';
 import { getLanguageFromFilename } from './utils.js';
 import { isLanguageAvailable } from '../tree-sitter/parser-loader.js';
 import { createWorkerPool } from './workers/worker-pool.js';
-import fs from 'node:fs';
-import path from 'node:path';
-import { fileURLToPath, pathToFileURL } from 'node:url';
 const isDev = process.env.NODE_ENV === 'development';
 /** Max bytes of source content to load per parse chunk. Each chunk's source +
  *  parsed ASTs + extracted records + worker serialization overhead all live in
@@ -29,8 +25,6 @@ export const runPipelineFromRepo = async (repoPath, onProgress) => {
     const symbolTable = createSymbolTable();
     let astCache = createASTCache(AST_CACHE_CAP);
     const importMap = createImportMap();
-    const packageMap = createPackageMap();
-    const namedImportMap = createNamedImportMap();
     const cleanup = () => {
         astCache.clear();
         symbolTable.clear();
@@ -93,14 +87,6 @@ export const runPipelineFromRepo = async (repoPath, onProgress) => {
             console.warn(`Skipping ${count} ${lang} file(s) — ${lang} parser not available (native binding may not have built). Try: npm rebuild tree-sitter-${lang}`);
         }
         const totalParseable = parseableScanned.length;
-        if (totalParseable === 0) {
-            onProgress({
-                phase: 'parsing',
-                percent: 82,
-                message: 'No parseable files found — skipping parsing phase',
-                stats: { filesProcessed: 0, totalFiles: 0, nodesCreated: graph.nodeCount },
-            });
-        }
         // Build byte-budget chunks
         const chunks = [];
         let currentChunk = [];
@@ -130,21 +116,11 @@ export const runPipelineFromRepo = async (repoPath, onProgress) => {
         // Create worker pool once, reuse across chunks
         let workerPool;
         try {
-            let workerUrl = new URL('./workers/parse-worker.js', import.meta.url);
-            // When running under vitest, import.meta.url points to src/ where no .js exists.
-            // Fall back to the compiled dist/ worker so the pool can spawn real worker threads.
-            const thisDir = fileURLToPath(new URL('.', import.meta.url));
-            if (!fs.existsSync(fileURLToPath(workerUrl))) {
-                const distWorker = path.resolve(thisDir, '..', '..', '..', 'dist', 'core', 'ingestion', 'workers', 'parse-worker.js');
-                if (fs.existsSync(distWorker)) {
-                    workerUrl = pathToFileURL(distWorker);
-                }
-            }
+            const workerUrl = new URL('./workers/parse-worker.js', import.meta.url);
             workerPool = createWorkerPool(workerUrl);
         }
         catch (err) {
-            if (isDev)
-                console.warn('Worker pool creation failed, using sequential fallback:', err.message);
+            // Worker pool creation failed — sequential fallback
         }
         let filesParsedSoFar = 0;
         // AST cache sized for one chunk (sequential fallback uses it for import/call/heritage)
@@ -181,18 +157,22 @@ export const runPipelineFromRepo = async (repoPath, onProgress) => {
                 }, workerPool);
                 if (chunkWorkerData) {
                     // Imports
-                    await processImportsFromExtracted(graph, allPathObjects, chunkWorkerData.imports, importMap, undefined, repoPath, importCtx, packageMap, namedImportMap);
-                    // Calls + Heritage + Routes — resolve in parallel (no shared mutable state between them)
-                    // This is safe because each writes disjoint relationship types into idempotent id-keyed Maps,
-                    // and the single-threaded event loop prevents races between synchronous addRelationship calls.
-                    await Promise.all([
-                        processCallsFromExtracted(graph, chunkWorkerData.calls, symbolTable, importMap, packageMap, undefined, namedImportMap),
-                        processHeritageFromExtracted(graph, chunkWorkerData.heritage, symbolTable, importMap, packageMap),
-                        processRoutesFromExtracted(graph, chunkWorkerData.routes ?? [], symbolTable, importMap, packageMap),
-                    ]);
+                    await processImportsFromExtracted(graph, allPathObjects, chunkWorkerData.imports, importMap, undefined, repoPath, importCtx);
+                    // Calls — resolve immediately, then free the array
+                    if (chunkWorkerData.calls.length > 0) {
+                        await processCallsFromExtracted(graph, chunkWorkerData.calls, symbolTable, importMap);
+                    }
+                    // Heritage — resolve immediately, then free
+                    if (chunkWorkerData.heritage.length > 0) {
+                        await processHeritageFromExtracted(graph, chunkWorkerData.heritage, symbolTable);
+                    }
+                    // Routes — resolve immediately (Laravel route→controller CALLS edges)
+                    if (chunkWorkerData.routes && chunkWorkerData.routes.length > 0) {
+                        await processRoutesFromExtracted(graph, chunkWorkerData.routes, symbolTable, importMap);
+                    }
                 }
                 else {
-                    await processImports(graph, chunkFiles, astCache, importMap, undefined, repoPath, allPaths, packageMap, namedImportMap);
+                    await processImports(graph, chunkFiles, astCache, importMap, undefined, repoPath, allPaths);
                     sequentialChunkPaths.push(chunkPaths);
                 }
                 filesParsedSoFar += chunkFiles.length;
@@ -211,8 +191,8 @@ export const runPipelineFromRepo = async (repoPath, onProgress) => {
                 .filter(p => chunkContents.has(p))
                 .map(p => ({ path: p, content: chunkContents.get(p) }));
             astCache = createASTCache(chunkFiles.length);
-            await processCalls(graph, chunkFiles, astCache, symbolTable, importMap, packageMap, undefined, namedImportMap);
-            await processHeritage(graph, chunkFiles, astCache, symbolTable, importMap, packageMap);
+            await processCalls(graph, chunkFiles, astCache, symbolTable, importMap);
+            await processHeritage(graph, chunkFiles, astCache, symbolTable);
             astCache.clear();
         }
         // Free import resolution context — suffix index + resolve cache no longer needed
@@ -221,16 +201,13 @@ export const runPipelineFromRepo = async (repoPath, onProgress) => {
         importCtx.resolveCache.clear();
         importCtx.suffixIndex = null;
         importCtx.normalizedFileList = null;
-        // ── Phase 4.5: Method Resolution Order ──────────────────────────────
-        onProgress({
-            phase: 'parsing',
-            percent: 81,
-            message: 'Computing method resolution order...',
-            stats: { filesProcessed: totalFiles, totalFiles, nodesCreated: graph.nodeCount },
-        });
-        const mroResult = computeMRO(graph);
-        if (isDev && mroResult.entries.length > 0) {
-            console.log(`🔀 MRO: ${mroResult.entries.length} classes analyzed, ${mroResult.ambiguityCount} ambiguities found, ${mroResult.overrideEdges} OVERRIDES edges`);
+        if (isDev) {
+            let importsCount = 0;
+            for (const r of graph.iterRelationships()) {
+                if (r.type === 'IMPORTS')
+                    importsCount++;
+            }
+            console.log(`📊 Pipeline: graph has ${importsCount} IMPORTS, ${graph.relationshipCount} total relationships`);
         }
         // ── Phase 5: Communities ───────────────────────────────────────────
         onProgress({

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

@@ -10,7 +10,6 @@
  * Processes help agents understand how features work through the codebase.
  */
 import { calculateEntryPointScore, isTestFile } from './entry-point-scoring.js';
-import { SupportedLanguages } from '../../config/supported-languages.js';
 const isDev = process.env.NODE_ENV === 'development';
 const DEFAULT_CONFIG = {
     maxTraceDepth: 10,
@@ -179,7 +178,7 @@ const findEntryPoints = (graph, reverseCallsEdges, callsEdges) => {
         if (callees.length === 0)
             continue;
         // Calculate entry point score using new scoring system
-        const { score: baseScore, reasons } = calculateEntryPointScore(node.properties.name, node.properties.language ?? SupportedLanguages.JavaScript, node.properties.isExported ?? false, callers.length, callees.length, filePath // Pass filePath for framework detection
+        const { score: baseScore, reasons } = calculateEntryPointScore(node.properties.name, node.properties.language || 'javascript', node.properties.isExported ?? false, callers.length, callees.length, filePath // Pass filePath for framework detection
         );
         let score = baseScore;
         const astFrameworkMultiplier = node.properties.astFrameworkMultiplier ?? 1.0;

package/dist/core/ingestion/symbol-table.d.ts

@@ -2,28 +2,17 @@ export interface SymbolDefinition {
     nodeId: string;
     filePath: string;
     type: string;
-    parameterCount?: number;
-    /** Links Method/Constructor to owning Class/Struct/Trait nodeId */
-    ownerId?: string;
 }
 export interface SymbolTable {
     /**
      * Register a new symbol definition
      */
-    add: (filePath: string, name: string, nodeId: string, type: string, metadata?: {
-        parameterCount?: number;
-        ownerId?: string;
-    }) => void;
+    add: (filePath: string, name: string, nodeId: string, type: string) => void;
     /**
      * High Confidence: Look for a symbol specifically inside a file
      * Returns the Node ID if found
      */
     lookupExact: (filePath: string, name: string) => string | undefined;
-    /**
-     * High Confidence: Look for a symbol in a specific file, returning full definition.
-     * Includes type information needed for heritage resolution (Class vs Interface).
-     */
-    lookupExactFull: (filePath: string, name: string) => SymbolDefinition | undefined;
     /**
      * Low Confidence: Look for a symbol anywhere in the project
      * Used when imports are missing or for framework magic

package/dist/core/ingestion/symbol-table.js

@@ -1,34 +1,27 @@
 export const createSymbolTable = () => {
-    // 1. File-Specific Index — stores full SymbolDefinition for O(1) lookupExactFull
-    // Structure: FilePath -> (SymbolName -> SymbolDefinition)
+    // 1. File-Specific Index (The "Good" one)
+    // Structure: FilePath -> (SymbolName -> NodeID)
     const fileIndex = new Map();
     // 2. Global Reverse Index (The "Backup")
     // Structure: SymbolName -> [List of Definitions]
     const globalIndex = new Map();
-    const add = (filePath, name, nodeId, type, metadata) => {
-        const def = {
-            nodeId,
-            filePath,
-            type,
-            ...(metadata?.parameterCount !== undefined ? { parameterCount: metadata.parameterCount } : {}),
-            ...(metadata?.ownerId !== undefined ? { ownerId: metadata.ownerId } : {}),
-        };
-        // A. Add to File Index (shared reference — zero additional memory)
+    const add = (filePath, name, nodeId, type) => {
+        // A. Add to File Index
         if (!fileIndex.has(filePath)) {
             fileIndex.set(filePath, new Map());
         }
-        fileIndex.get(filePath).set(name, def);
-        // B. Add to Global Index (same object reference)
+        fileIndex.get(filePath).set(name, nodeId);
+        // B. Add to Global Index
         if (!globalIndex.has(name)) {
             globalIndex.set(name, []);
         }
-        globalIndex.get(name).push(def);
+        globalIndex.get(name).push({ nodeId, filePath, type });
     };
     const lookupExact = (filePath, name) => {
-        return fileIndex.get(filePath)?.get(name)?.nodeId;
-    };
-    const lookupExactFull = (filePath, name) => {
-        return fileIndex.get(filePath)?.get(name);
+        const fileSymbols = fileIndex.get(filePath);
+        if (!fileSymbols)
+            return undefined;
+        return fileSymbols.get(name);
     };
     const lookupFuzzy = (name) => {
         return globalIndex.get(name) || [];
@@ -41,5 +34,5 @@ export const createSymbolTable = () => {
         fileIndex.clear();
         globalIndex.clear();
     };
-    return { add, lookupExact, lookupExactFull, lookupFuzzy, getStats, clear };
+    return { add, lookupExact, lookupFuzzy, getStats, clear };
 };