@veewo/gitnexus 1.3.4

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

@@ -0,0 +1,15 @@
+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 } from './workers/parse-worker.js';
+export type FileProgressCallback = (current: number, total: number, filePath: string) => void;
+export interface WorkerExtractedData {
+    imports: ExtractedImport[];
+    calls: ExtractedCall[];
+    heritage: ExtractedHeritage[];
+}
+export declare const processParsing: (graph: KnowledgeGraph, files: {
+    path: string;
+    content: string;
+}[], symbolTable: SymbolTable, astCache: ASTCache, onFileProgress?: FileProgressCallback, workerPool?: WorkerPool) => Promise<WorkerExtractedData | null>;

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

@@ -0,0 +1,291 @@
+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 } from './utils.js';
+// ============================================================================
+// 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
+ */
+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;
+        // 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;
+        default:
+            return false;
+    }
+};
+// ============================================================================
+// Worker-based parallel parsing
+// ============================================================================
+const processParsingWithWorkers = async (graph, files, symbolTable, astCache, workerPool, onFileProgress) => {
+    // Filter to parseable files only
+    const parseableFiles = [];
+    for (const file of files) {
+        const lang = getLanguageFromFilename(file.path);
+        if (lang)
+            parseableFiles.push({ path: file.path, content: file.content });
+    }
+    if (parseableFiles.length === 0)
+        return { imports: [], calls: [], heritage: [] };
+    const total = files.length;
+    // Dispatch to worker pool — pool handles splitting into chunks and sub-batching
+    const chunkResults = await workerPool.dispatch(parseableFiles, (filesProcessed) => {
+        onFileProgress?.(Math.min(filesProcessed, total), total, 'Parsing...');
+    });
+    // Merge results from all workers into graph and symbol table
+    const allImports = [];
+    const allCalls = [];
+    const allHeritage = [];
+    for (const result of chunkResults) {
+        for (const node of result.nodes) {
+            graph.addNode({
+                id: node.id,
+                label: node.label,
+                properties: node.properties,
+            });
+        }
+        for (const rel of result.relationships) {
+            graph.addRelationship(rel);
+        }
+        for (const sym of result.symbols) {
+            symbolTable.add(sym.filePath, sym.name, sym.nodeId, sym.type);
+        }
+        allImports.push(...result.imports);
+        allCalls.push(...result.calls);
+        allHeritage.push(...result.heritage);
+    }
+    // Final progress
+    onFileProgress?.(total, total, 'done');
+    return { imports: allImports, calls: allCalls, heritage: allHeritage };
+};
+// ============================================================================
+// Sequential fallback (original implementation)
+// ============================================================================
+const processParsingSequential = async (graph, files, symbolTable, astCache, onFileProgress) => {
+    const parser = await loadParser();
+    const total = files.length;
+    for (let i = 0; i < files.length; i++) {
+        const file = files[i];
+        onFileProgress?.(i + 1, total, file.path);
+        if (i % 20 === 0)
+            await yieldToEventLoop();
+        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)
+            continue;
+        await loadLanguage(language, file.path);
+        let tree;
+        try {
+            tree = parser.parse(file.content, undefined, { bufferSize: 1024 * 256 });
+        }
+        catch (parseError) {
+            console.warn(`Skipping unparseable file: ${file.path}`);
+            continue;
+        }
+        astCache.set(file.path, tree);
+        const queryString = LANGUAGE_QUERIES[language];
+        if (!queryString) {
+            continue;
+        }
+        let query;
+        let matches;
+        try {
+            const language = parser.getLanguage();
+            query = new Parser.Query(language, queryString);
+            matches = query.matches(tree.rootNode);
+        }
+        catch (queryError) {
+            console.warn(`Query error for ${file.path}:`, queryError);
+            continue;
+        }
+        matches.forEach(match => {
+            const captureMap = {};
+            match.captures.forEach(c => {
+                captureMap[c.name] = c.node;
+            });
+            if (captureMap['import']) {
+                return;
+            }
+            if (captureMap['call']) {
+                return;
+            }
+            const nameNode = captureMap['name'];
+            if (!nameNode)
+                return;
+            const nodeName = nameNode.text;
+            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 nodeId = generateId(nodeLabel, `${file.path}:${nodeName}`);
+            const node = {
+                id: nodeId,
+                label: nodeLabel,
+                properties: {
+                    name: nodeName,
+                    filePath: file.path,
+                    startLine: nameNode.startPosition.row + 1,
+                    endLine: nameNode.endPosition.row + 1,
+                    language: language,
+                    isExported: isNodeExported(nameNode, nodeName, language),
+                }
+            };
+            graph.addNode(node);
+            symbolTable.add(file.path, nodeName, nodeId, nodeLabel);
+            const fileId = generateId('File', file.path);
+            const relId = generateId('DEFINES', `${fileId}->${nodeId}`);
+            const relationship = {
+                id: relId,
+                sourceId: fileId,
+                targetId: nodeId,
+                type: 'DEFINES',
+                confidence: 1.0,
+                reason: '',
+            };
+            graph.addRelationship(relationship);
+        });
+    }
+};
+// ============================================================================
+// Public API
+// ============================================================================
+export const processParsing = async (graph, files, symbolTable, astCache, onFileProgress, workerPool) => {
+    if (workerPool) {
+        try {
+            return await processParsingWithWorkers(graph, files, symbolTable, astCache, workerPool, onFileProgress);
+        }
+        catch (err) {
+            console.warn('Worker pool parsing failed, falling back to sequential:', err instanceof Error ? err.message : err);
+        }
+    }
+    // Fallback: sequential parsing (no pre-extracted data)
+    await processParsingSequential(graph, files, symbolTable, astCache, onFileProgress);
+    return null;
+};

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

@@ -0,0 +1,5 @@
+import { PipelineProgress, PipelineResult } from '../../types/pipeline.js';
+export declare const runPipelineFromRepo: (repoPath: string, onProgress: (progress: PipelineProgress) => void, options?: {
+    includeExtensions?: string[];
+    scopeRules?: string[];
+}) => Promise<PipelineResult>;

package/dist/core/ingestion/pipeline.js

@@ -0,0 +1,323 @@
+import { createKnowledgeGraph } from '../graph/graph.js';
+import { processStructure } from './structure-processor.js';
+import { processParsing } from './parsing-processor.js';
+import { processImports, processImportsFromExtracted, createImportMap, buildImportResolutionContext } from './import-processor.js';
+import { processCalls, processCallsFromExtracted } from './call-processor.js';
+import { processHeritage, processHeritageFromExtracted } from './heritage-processor.js';
+import { processCommunities } from './community-processor.js';
+import { processProcesses } from './process-processor.js';
+import { createSymbolTable } from './symbol-table.js';
+import { createASTCache } from './ast-cache.js';
+import { walkRepositoryPaths, readFileContents } from './filesystem-walker.js';
+import { getLanguageFromFilename } from './utils.js';
+import { createWorkerPool } from './workers/worker-pool.js';
+import { selectEntriesByScopeRules } from './scope-filter.js';
+import path from 'path';
+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
+ *  memory simultaneously, so this must be conservative. 20MB source ≈ 200-400MB
+ *  peak working memory per chunk after parse expansion. */
+const CHUNK_BYTE_BUDGET = 20 * 1024 * 1024; // 20MB
+/** Max AST trees to keep in LRU cache */
+const AST_CACHE_CAP = 50;
+export const runPipelineFromRepo = async (repoPath, onProgress, options) => {
+    const graph = createKnowledgeGraph();
+    const symbolTable = createSymbolTable();
+    let astCache = createASTCache(AST_CACHE_CAP);
+    const importMap = createImportMap();
+    const cleanup = () => {
+        astCache.clear();
+        symbolTable.clear();
+    };
+    try {
+        // ── Phase 1: Scan paths only (no content read) ─────────────────────
+        onProgress({
+            phase: 'extracting',
+            percent: 0,
+            message: 'Scanning repository...',
+        });
+        const scannedFiles = await walkRepositoryPaths(repoPath, (current, total, filePath) => {
+            const scanProgress = Math.round((current / total) * 15);
+            onProgress({
+                phase: 'extracting',
+                percent: scanProgress,
+                message: 'Scanning repository...',
+                detail: filePath,
+                stats: { filesProcessed: current, totalFiles: total, nodesCreated: graph.nodeCount },
+            });
+        });
+        const scopeSelection = selectEntriesByScopeRules(scannedFiles, options?.scopeRules || []);
+        const scopedFiles = scopeSelection.selected;
+        if (scopeSelection.diagnostics.appliedRuleCount > 0 && scopedFiles.length === 0) {
+            throw new Error('Scope filters matched zero files. Check --scope-manifest/--scope-prefix.');
+        }
+        const includeExtensions = new Set((options?.includeExtensions || [])
+            .map(ext => ext.trim().toLowerCase())
+            .filter(Boolean)
+            .map(ext => (ext.startsWith('.') ? ext : `.${ext}`)));
+        const extensionFiltered = includeExtensions.size > 0
+            ? scopedFiles.filter(f => includeExtensions.has(path.extname(f.path).toLowerCase()))
+            : scopedFiles;
+        const totalFiles = extensionFiltered.length;
+        onProgress({
+            phase: 'extracting',
+            percent: 15,
+            message: 'Repository scanned successfully',
+            stats: { filesProcessed: totalFiles, totalFiles, nodesCreated: graph.nodeCount },
+        });
+        // ── Phase 2: Structure (paths only — no content needed) ────────────
+        onProgress({
+            phase: 'structure',
+            percent: 15,
+            message: 'Analyzing project structure...',
+            stats: { filesProcessed: 0, totalFiles, nodesCreated: graph.nodeCount },
+        });
+        const allPaths = extensionFiltered.map(f => f.path);
+        processStructure(graph, allPaths);
+        onProgress({
+            phase: 'structure',
+            percent: 20,
+            message: 'Project structure analyzed',
+            stats: { filesProcessed: totalFiles, totalFiles, nodesCreated: graph.nodeCount },
+        });
+        // ── Phase 3+4: Chunked read + parse ────────────────────────────────
+        // Group parseable files into byte-budget chunks so only ~20MB of source
+        // is in memory at a time. Each chunk is: read → parse → extract → free.
+        const parseableScanned = extensionFiltered.filter(f => getLanguageFromFilename(f.path));
+        const totalParseable = parseableScanned.length;
+        // Build byte-budget chunks
+        const chunks = [];
+        let currentChunk = [];
+        let currentBytes = 0;
+        for (const file of parseableScanned) {
+            if (currentChunk.length > 0 && currentBytes + file.size > CHUNK_BYTE_BUDGET) {
+                chunks.push(currentChunk);
+                currentChunk = [];
+                currentBytes = 0;
+            }
+            currentChunk.push(file.path);
+            currentBytes += file.size;
+        }
+        if (currentChunk.length > 0)
+            chunks.push(currentChunk);
+        const numChunks = chunks.length;
+        if (isDev) {
+            const totalMB = parseableScanned.reduce((s, f) => s + f.size, 0) / (1024 * 1024);
+            console.log(`📂 Scan: ${totalFiles} paths, ${totalParseable} parseable (${totalMB.toFixed(0)}MB), ${numChunks} chunks @ ${CHUNK_BYTE_BUDGET / (1024 * 1024)}MB budget`);
+        }
+        onProgress({
+            phase: 'parsing',
+            percent: 20,
+            message: `Parsing ${totalParseable} files in ${numChunks} chunk${numChunks !== 1 ? 's' : ''}...`,
+            stats: { filesProcessed: 0, totalFiles: totalParseable, nodesCreated: graph.nodeCount },
+        });
+        // Create worker pool once, reuse across chunks
+        let workerPool;
+        try {
+            const workerUrl = new URL('./workers/parse-worker.js', import.meta.url);
+            workerPool = createWorkerPool(workerUrl);
+        }
+        catch (err) {
+            // Worker pool creation failed — sequential fallback
+        }
+        let filesParsedSoFar = 0;
+        // AST cache sized for one chunk (sequential fallback uses it for import/call/heritage)
+        const maxChunkFiles = chunks.reduce((max, c) => Math.max(max, c.length), 0);
+        astCache = createASTCache(maxChunkFiles);
+        // Build import resolution context once — suffix index, file lists, resolve cache.
+        // Reused across all chunks to avoid rebuilding O(files × path_depth) structures.
+        const importCtx = buildImportResolutionContext(allPaths);
+        const allPathObjects = allPaths.map(p => ({ path: p }));
+        // Single-pass: parse + resolve imports/calls/heritage per chunk.
+        // Calls/heritage use the symbol table built so far (symbols from earlier chunks
+        // are already registered). This trades ~5% cross-chunk resolution accuracy for
+        // 200-400MB less memory — critical for Linux-kernel-scale repos.
+        const sequentialChunkPaths = [];
+        try {
+            for (let chunkIdx = 0; chunkIdx < numChunks; chunkIdx++) {
+                const chunkPaths = chunks[chunkIdx];
+                // Read content for this chunk only
+                const chunkContents = await readFileContents(repoPath, chunkPaths);
+                const chunkFiles = chunkPaths
+                    .filter(p => chunkContents.has(p))
+                    .map(p => ({ path: p, content: chunkContents.get(p) }));
+                // Parse this chunk (workers or sequential fallback)
+                const chunkWorkerData = await processParsing(graph, chunkFiles, symbolTable, astCache, (current, _total, filePath) => {
+                    const globalCurrent = filesParsedSoFar + current;
+                    const parsingProgress = 20 + ((globalCurrent / totalParseable) * 62);
+                    onProgress({
+                        phase: 'parsing',
+                        percent: Math.round(parsingProgress),
+                        message: `Parsing chunk ${chunkIdx + 1}/${numChunks}...`,
+                        detail: filePath,
+                        stats: { filesProcessed: globalCurrent, totalFiles: totalParseable, nodesCreated: graph.nodeCount },
+                    });
+                }, workerPool);
+                if (chunkWorkerData) {
+                    // Imports
+                    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);
+                    }
+                }
+                else {
+                    await processImports(graph, chunkFiles, astCache, importMap, undefined, repoPath, allPaths);
+                    sequentialChunkPaths.push(chunkPaths);
+                }
+                filesParsedSoFar += chunkFiles.length;
+                // Clear AST cache between chunks to free memory
+                astCache.clear();
+                // chunkContents + chunkFiles + chunkWorkerData go out of scope → GC reclaims
+            }
+        }
+        finally {
+            await workerPool?.terminate();
+        }
+        // Sequential fallback chunks: re-read source for call/heritage resolution
+        for (const chunkPaths of sequentialChunkPaths) {
+            const chunkContents = await readFileContents(repoPath, chunkPaths);
+            const chunkFiles = chunkPaths
+                .filter(p => chunkContents.has(p))
+                .map(p => ({ path: p, content: chunkContents.get(p) }));
+            astCache = createASTCache(chunkFiles.length);
+            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
+        // (allPathObjects and importCtx hold ~94MB+ for large repos)
+        allPathObjects.length = 0;
+        importCtx.resolveCache.clear();
+        importCtx.suffixIndex = null;
+        importCtx.normalizedFileList = null;
+        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({
+            phase: 'communities',
+            percent: 82,
+            message: 'Detecting code communities...',
+            stats: { filesProcessed: totalFiles, totalFiles, nodesCreated: graph.nodeCount },
+        });
+        const communityResult = await processCommunities(graph, (message, progress) => {
+            const communityProgress = 82 + (progress * 0.10);
+            onProgress({
+                phase: 'communities',
+                percent: Math.round(communityProgress),
+                message,
+                stats: { filesProcessed: totalFiles, totalFiles, nodesCreated: graph.nodeCount },
+            });
+        });
+        if (isDev) {
+            console.log(`🏘️ Community detection: ${communityResult.stats.totalCommunities} communities found (modularity: ${communityResult.stats.modularity.toFixed(3)})`);
+        }
+        communityResult.communities.forEach(comm => {
+            graph.addNode({
+                id: comm.id,
+                label: 'Community',
+                properties: {
+                    name: comm.label,
+                    filePath: '',
+                    heuristicLabel: comm.heuristicLabel,
+                    cohesion: comm.cohesion,
+                    symbolCount: comm.symbolCount,
+                }
+            });
+        });
+        communityResult.memberships.forEach(membership => {
+            graph.addRelationship({
+                id: `${membership.nodeId}_member_of_${membership.communityId}`,
+                type: 'MEMBER_OF',
+                sourceId: membership.nodeId,
+                targetId: membership.communityId,
+                confidence: 1.0,
+                reason: 'leiden-algorithm',
+            });
+        });
+        // ── Phase 6: Processes ─────────────────────────────────────────────
+        onProgress({
+            phase: 'processes',
+            percent: 94,
+            message: 'Detecting execution flows...',
+            stats: { filesProcessed: totalFiles, totalFiles, nodesCreated: graph.nodeCount },
+        });
+        let symbolCount = 0;
+        graph.forEachNode(n => { if (n.label !== 'File')
+            symbolCount++; });
+        const dynamicMaxProcesses = Math.max(20, Math.min(300, Math.round(symbolCount / 10)));
+        const processResult = await processProcesses(graph, communityResult.memberships, (message, progress) => {
+            const processProgress = 94 + (progress * 0.05);
+            onProgress({
+                phase: 'processes',
+                percent: Math.round(processProgress),
+                message,
+                stats: { filesProcessed: totalFiles, totalFiles, nodesCreated: graph.nodeCount },
+            });
+        }, { maxProcesses: dynamicMaxProcesses, minSteps: 3 });
+        if (isDev) {
+            console.log(`🔄 Process detection: ${processResult.stats.totalProcesses} processes found (${processResult.stats.crossCommunityCount} cross-community)`);
+        }
+        processResult.processes.forEach(proc => {
+            graph.addNode({
+                id: proc.id,
+                label: 'Process',
+                properties: {
+                    name: proc.label,
+                    filePath: '',
+                    heuristicLabel: proc.heuristicLabel,
+                    processType: proc.processType,
+                    stepCount: proc.stepCount,
+                    communities: proc.communities,
+                    entryPointId: proc.entryPointId,
+                    terminalId: proc.terminalId,
+                }
+            });
+        });
+        processResult.steps.forEach(step => {
+            graph.addRelationship({
+                id: `${step.nodeId}_step_${step.step}_${step.processId}`,
+                type: 'STEP_IN_PROCESS',
+                sourceId: step.nodeId,
+                targetId: step.processId,
+                confidence: 1.0,
+                reason: 'trace-detection',
+                step: step.step,
+            });
+        });
+        onProgress({
+            phase: 'complete',
+            percent: 100,
+            message: `Graph complete! ${communityResult.stats.totalCommunities} communities, ${processResult.stats.totalProcesses} processes detected.`,
+            stats: {
+                filesProcessed: totalFiles,
+                totalFiles,
+                nodesCreated: graph.nodeCount
+            },
+        });
+        astCache.clear();
+        return {
+            graph,
+            repoPath,
+            totalFileCount: totalFiles,
+            communityResult,
+            processResult,
+            scopeDiagnostics: scopeSelection.diagnostics,
+        };
+    }
+    catch (error) {
+        cleanup();
+        throw error;
+    }
+};