code-graph-context 2.0.0 → 2.2.0

package/dist/core/workspace/workspace-detector.js

@@ -44,6 +44,13 @@ export class WorkspaceDetector {
         if (hasTurboJson) {
             return 'turborepo';
         }
+        // Check for Nx (has nx.json) - check before pnpm/npm since Nx can coexist with them
+        const nxJsonPath = path.join(rootPath, 'nx.json');
+        const hasNxJson = await this.fileExists(nxJsonPath);
+        await debugLog('Checking for nx.json', { path: nxJsonPath, exists: hasNxJson });
+        if (hasNxJson) {
+            return 'nx';
+        }
         // Check for pnpm workspaces (has pnpm-workspace.yaml)
         const pnpmWorkspacePath = path.join(rootPath, 'pnpm-workspace.yaml');
         const hasPnpmWorkspace = await this.fileExists(pnpmWorkspacePath);
@@ -99,6 +106,43 @@ export class WorkspaceDetector {
                 // Turborepo default patterns
                 return ['apps/*', 'packages/*'];
             }
+            case 'nx': {
+                // For Nx, scan for all project.json files to find all projects
+                // This is more reliable than workspaces since Nx projects may not be in package.json workspaces
+                const projectJsonFiles = await glob('**/project.json', {
+                    cwd: rootPath,
+                    ignore: ['**/node_modules/**', '**/dist/**', '**/build/**'],
+                    absolute: false,
+                });
+                // Extract unique parent directories (the project roots)
+                const projectDirs = new Set();
+                for (const projectJsonPath of projectJsonFiles) {
+                    const projectDir = path.dirname(projectJsonPath);
+                    if (projectDir !== '.') {
+                        projectDirs.add(projectDir);
+                    }
+                }
+                if (projectDirs.size > 0) {
+                    await debugLog('Found Nx projects via project.json scan', { count: projectDirs.size });
+                    return Array.from(projectDirs);
+                }
+                // Fallback to package.json workspaces if no project.json files found
+                const packageJsonPath = path.join(rootPath, 'package.json');
+                try {
+                    const packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf-8'));
+                    if (Array.isArray(packageJson.workspaces)) {
+                        return packageJson.workspaces;
+                    }
+                    if (packageJson.workspaces?.packages) {
+                        return packageJson.workspaces.packages;
+                    }
+                }
+                catch {
+                    // Fall through to defaults
+                }
+                // Nx default patterns
+                return ['apps/*', 'libs/*', 'packages/*', 'src/*/*'];
+            }
             case 'yarn':
             case 'npm': {
                 // Read from package.json workspaces
@@ -151,16 +195,26 @@ export class WorkspaceDetector {
                 if (seenPaths.has(packagePath))
                     continue;
                 seenPaths.add(packagePath);
-                // Check if this is a valid package (has package.json)
+                // Check if this is a valid package (has package.json) or Nx project (has project.json)
                 const packageJsonPath = path.join(packagePath, 'package.json');
-                if (!(await this.fileExists(packageJsonPath))) {
+                const projectJsonPath = path.join(packagePath, 'project.json');
+                const hasPackageJson = await this.fileExists(packageJsonPath);
+                const hasProjectJson = await this.fileExists(projectJsonPath);
+                if (!hasPackageJson && !hasProjectJson) {
                     continue;
                 }
-                // Read package name
+                // Read package/project name
                 let packageName;
                 try {
-                    const packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf-8'));
-                    packageName = packageJson.name ?? path.basename(packagePath);
+                    if (hasPackageJson) {
+                        const packageJson = JSON.parse(await fs.readFile(packageJsonPath, 'utf-8'));
+                        packageName = packageJson.name ?? path.basename(packagePath);
+                    }
+                    else {
+                        // Nx project.json - try to read name from it
+                        const projectJson = JSON.parse(await fs.readFile(projectJsonPath, 'utf-8'));
+                        packageName = projectJson.name ?? path.basename(packagePath);
+                    }
                 }
                 catch {
                     packageName = path.basename(packagePath);

package/dist/mcp/constants.js

@@ -2,6 +2,8 @@
  * MCP Server Constants
  * All constants used throughout the MCP server implementation
  */
+// Re-export shared constants
+export { LOG_CONFIG } from '../constants.js';
 // Server Configuration
 export const MCP_SERVER_CONFIG = {
     name: 'codebase-graph',
@@ -27,6 +29,8 @@ export const TOOL_NAMES = {
     startWatchProject: 'start_watch_project',
     stopWatchProject: 'stop_watch_project',
     listWatchers: 'list_watchers',
+    detectDeadCode: 'detect_dead_code',
+    detectDuplicateCode: 'detect_duplicate_code',
 };
 // Tool Metadata
 export const TOOL_METADATA = {
@@ -93,10 +97,28 @@ Use list_projects to see available projects and get the project name.
 
 **Tips:**
 - Import nodes store file paths, not module names (use 'path containing X')
-- Node types: SourceFile, ClassDeclaration, FunctionDeclaration, MethodDeclaration, InterfaceDeclaration
-- Relationships: CONTAINS, IMPORTS, HAS_PARAMETER, IMPLEMENTS, EXTENDS, HAS_MEMBER
+- Node types: SourceFile, Class, Function, Method, Interface, Property, Parameter, Constructor, Import, Export, Decorator, Enum, Variable, TypeAlias
+- Relationships: CONTAINS, IMPORTS, EXTENDS, IMPLEMENTS, HAS_MEMBER, HAS_PARAMETER, TYPED_AS, CALLS, DECORATED_WITH
 - For NestJS, use semanticType property instead of decorators (e.g., semanticType = 'NestController')
 
+**Relationships (Core):**
+- CONTAINS: File/class contains members
+- HAS_MEMBER: Class/interface has methods/properties
+- HAS_PARAMETER: Method/function has parameters
+- IMPORTS: SourceFile imports another
+- EXPORTS: SourceFile exports items
+- EXTENDS: Class/interface extends another
+- IMPLEMENTS: Class implements interface(s)
+- CALLS: Method/function calls another
+- TYPED_AS: Parameter/property has type annotation
+- DECORATED_WITH: Node has decorators
+
+**Relationships (NestJS/Framework):**
+- INJECTS: Service/controller injects dependency
+- EXPOSES: Controller exposes HTTP endpoints
+- MODULE_IMPORTS, MODULE_PROVIDES, MODULE_EXPORTS: NestJS module system
+- GUARDED_BY, TRANSFORMED_BY, INTERCEPTED_BY: Security/middleware
+
 **Query Phrasing:**
 Phrase queries using properties known to exist (filePath, name) rather than abstract concepts:
 - Use "in account folder" or "filePath contains /account/" instead of "in account module"
@@ -252,6 +274,86 @@ Returns information about each watcher:
 
 Use stop_watch_project to stop a watcher.`,
     },
+    [TOOL_NAMES.detectDeadCode]: {
+        title: 'Detect Dead Code',
+        description: `Identify potentially unused code in the codebase including exports never imported, private methods never called, and orphan interfaces.
+
+**Before analyzing:**
+Use list_projects to see available projects and get the project name.
+
+Returns:
+- Risk level (LOW/MEDIUM/HIGH/CRITICAL) based on dead code count
+- Dead code items with confidence levels (HIGH/MEDIUM/LOW) and categories
+- Grouped by type (methods, classes, interfaces, etc.)
+- Grouped by category (library-export, ui-component, internal-unused)
+- Affected files list
+- Excluded entry points for audit (controllers, modules, etc.)
+
+Parameters:
+- projectId: Project name, path, or ID (required)
+- excludePatterns: Additional file patterns to exclude (e.g., ["*.config.ts", "*.seed.ts"])
+- excludeSemanticTypes: Additional semantic types to exclude (e.g., ["EntityClass", "DTOClass"])
+- excludeLibraryExports: Exclude all items from packages/* directories (default: false)
+- excludeCoreTypes: Exclude specific AST types (e.g., ["InterfaceDeclaration", "EnumDeclaration"])
+- includeEntryPoints: Include excluded entry points in audit section (default: true)
+- minConfidence: Minimum confidence to include (LOW/MEDIUM/HIGH, default: LOW)
+- filterCategory: Filter by category (library-export, ui-component, internal-unused, all) (default: all)
+- summaryOnly: Return only statistics without full dead code list (default: false)
+- limit: Maximum items per page (default: 100, max: 500)
+- offset: Number of items to skip for pagination (default: 0)
+
+**Categories:**
+- library-export: Exports from packages/* directories (may be used by external consumers)
+- ui-component: Exports from components/ui/* (component library, intentionally broad API)
+- internal-unused: Regular internal code that appears unused
+
+**Auto-excluded entry points:**
+- Semantic types: NestController, NestModule, NestGuard, NestPipe, NestInterceptor, NestFilter, NestProvider, NestService, HttpEndpoint
+- File patterns: main.ts, *.module.ts, *.controller.ts, index.ts
+
+**Confidence levels:**
+- HIGH: Exported but never imported or referenced
+- MEDIUM: Private with no internal calls
+- LOW: Could be used dynamically
+
+Use filterCategory=internal-unused for actionable dead code cleanup.`,
+    },
+    [TOOL_NAMES.detectDuplicateCode]: {
+        title: 'Detect Duplicate Code',
+        description: `Find duplicate code patterns using structural (AST hash) and semantic (embedding similarity) analysis.
+
+**Before analyzing:**
+Use list_projects to see available projects and get the project name.
+
+Returns:
+- Duplicate groups with similarity scores
+- Confidence levels (HIGH/MEDIUM/LOW)
+- Grouped by detection type (structural, semantic)
+- Recommendations for each duplicate group
+- Affected files list
+
+Parameters:
+- projectId: Project name, path, or ID (required)
+- type: Detection approach - "structural", "semantic", or "all" (default: all)
+- minSimilarity: Minimum similarity for semantic duplicates (0.5-1.0, default: 0.80)
+- includeCode: Include source code snippets (default: false)
+- maxResults: Maximum duplicate groups per page (default: 20, max: 100)
+- scope: Node types to analyze - "methods", "functions", "classes", or "all" (default: all)
+- summaryOnly: Return only statistics without full duplicates list (default: false)
+- offset: Number of groups to skip for pagination (default: 0)
+
+**Detection Types:**
+- structural: Finds exact duplicates by normalized code hash (ignores formatting, variable names, literals)
+- semantic: Finds similar code using embedding similarity (catches different implementations of same logic)
+- all: Runs both detection types
+
+**Similarity Thresholds:**
+- 0.90+: Very high similarity, almost certainly duplicates
+- 0.85-0.90: High similarity, likely duplicates with minor variations
+- 0.80-0.85: Moderate similarity, worth reviewing
+
+Use this to identify refactoring opportunities and reduce code duplication.`,
+    },
 };
 // Default Values
 export const DEFAULTS = {
@@ -263,6 +365,43 @@ export const DEFAULTS = {
     chainSnippetLength: 700,
     maxEmbeddingChars: 30000, // ~7500 tokens, under 8192 limit for text-embedding-3-large
 };
+// Parsing Configuration
+export const PARSING = {
+    /** File count threshold to trigger parallel parsing with worker pool */
+    parallelThreshold: 500,
+    /** File count threshold to trigger streaming import */
+    streamingThreshold: 100,
+    /** Default number of files per chunk */
+    defaultChunkSize: 100,
+    /** Worker timeout in milliseconds (30 minutes) */
+    workerTimeoutMs: 30 * 60 * 1000,
+};
+// Job Management
+export const JOBS = {
+    /** Interval for cleaning up completed/stale jobs (5 minutes) */
+    cleanupIntervalMs: 5 * 60 * 1000,
+    /** Maximum number of jobs to keep in memory */
+    maxJobs: 100,
+};
+// Watch Mode Configuration
+export const WATCH = {
+    /** Default debounce delay before processing file changes */
+    defaultDebounceMs: 1000,
+    /** Maximum concurrent file watchers */
+    maxWatchers: 10,
+    /** Maximum pending file change events before dropping */
+    maxPendingEvents: 1000,
+    /** Default exclude patterns for file watching */
+    excludePatterns: [
+        '**/node_modules/**',
+        '**/dist/**',
+        '**/build/**',
+        '**/.git/**',
+        '**/*.d.ts',
+        '**/*.js',
+        '**/*.map',
+    ],
+};
 // Messages
 export const MESSAGES = {
     errors: {
@@ -298,9 +437,3 @@ export const MESSAGES = {
         startingServer: 'Starting MCP server...',
     },
 };
-// Logging Configuration
-export const LOG_CONFIG = {
-    timestampFormat: 'iso',
-    logSeparator: '---',
-    jsonIndentation: 2,
-};

package/dist/mcp/handlers/graph-generator.handler.js

@@ -73,6 +73,7 @@ export class GraphGeneratorHandler {
         await this.neo4jService.run(QUERIES.CREATE_PROJECT_INDEX_SOURCEFILE);
         await this.neo4jService.run(QUERIES.CREATE_PROJECT_ID_INDEX_EMBEDDED);
         await this.neo4jService.run(QUERIES.CREATE_PROJECT_ID_INDEX_SOURCEFILE);
+        await this.neo4jService.run(QUERIES.CREATE_NORMALIZED_HASH_INDEX);
         await debugLog('Project indexes created');
     }
     async importNodes(nodes, batchSize) {

package/dist/mcp/handlers/incremental-parse.handler.js

@@ -23,7 +23,7 @@ export const performIncrementalParse = async (projectPath, projectId, tsconfigPa
     const embeddingsService = new EmbeddingsService();
     const graphHandler = new GraphGeneratorHandler(neo4jService, embeddingsService);
     try {
-        await debugLog('Incremental parse started (watch)', { projectPath, projectId });
+        await debugLog('Incremental parse started', { projectPath, projectId });
         // Resolve project ID
         const resolvedId = resolveProjectId(projectPath, projectId);
         const projectName = await getProjectName(projectPath);
@@ -31,13 +31,12 @@ export const performIncrementalParse = async (projectPath, projectId, tsconfigPa
         const parser = await ParserFactory.createParserWithAutoDetection(projectPath, tsconfigPath, resolvedId, true);
         // Detect changed files
         const { filesToReparse, filesToDelete } = await detectChangedFiles(projectPath, neo4jService, resolvedId);
-        await debugLog('Watch incremental change detection', {
+        await debugLog('Incremental change detection', {
             filesToReparse: filesToReparse.length,
             filesToDelete: filesToDelete.length,
         });
         // If no changes, return early
         if (filesToReparse.length === 0 && filesToDelete.length === 0) {
-            await debugLog('Watch incremental: no changes detected');
             return {
                 nodesUpdated: 0,
                 edgesUpdated: 0,
@@ -50,7 +49,6 @@ export const performIncrementalParse = async (projectPath, projectId, tsconfigPa
         if (filesToRemoveFromGraph.length > 0) {
             // Save cross-file edges before deletion
             savedCrossFileEdges = await getCrossFileEdges(neo4jService, filesToRemoveFromGraph, resolvedId);
-            await debugLog('Watch: saved cross-file edges', { count: savedCrossFileEdges.length });
             // Delete old subgraphs
             await deleteSourceFileSubgraphs(neo4jService, filesToRemoveFromGraph, resolvedId);
         }
@@ -124,10 +122,9 @@ export const performIncrementalParse = async (projectPath, projectId, tsconfigPa
                     ? Number(firstResult.recreatedCount) || 0
                     : 0;
                 edgesImported += recreatedCount;
-                await debugLog('Watch: cross-file edges recreated', { recreatedCount });
             }
         }
-        await debugLog('Watch incremental parse completed', {
+        await debugLog('Incremental parse completed', {
             nodesImported,
             edgesImported,
             filesReparsed: filesToReparse.length,

package/dist/mcp/handlers/parallel-import.handler.js

@@ -0,0 +1,136 @@
+/**
+ * Parallel Import Handler
+ * Orchestrates parallel chunk parsing using a worker pool with pipelined import.
+ * Used for large codebases (>= PARSING.parallelThreshold files).
+ */
+import { join } from 'path';
+import { ProgressReporter } from '../../core/utils/progress-reporter.js';
+import { debugLog } from '../utils.js';
+import { ChunkWorkerPool } from '../workers/chunk-worker-pool.js';
+export class ParallelImportHandler {
+    graphGeneratorHandler;
+    progressReporter;
+    constructor(graphGeneratorHandler) {
+        this.graphGeneratorHandler = graphGeneratorHandler;
+        this.progressReporter = new ProgressReporter();
+    }
+    /**
+     * Import a project using parallel worker pool with pipelined import.
+     * Chunks are distributed to workers, and imports happen as chunks complete.
+     */
+    async importProjectParallel(parser, sourceFiles, config) {
+        const startTime = Date.now();
+        if (config.onProgress) {
+            this.progressReporter.setCallback(config.onProgress);
+        }
+        const totalFiles = sourceFiles.length;
+        let totalNodesImported = 0;
+        let totalEdgesImported = 0;
+        const chunks = this.createChunks(sourceFiles, config.chunkSize);
+        this.progressReporter.report({
+            phase: 'parsing',
+            current: 0,
+            total: totalFiles,
+            message: `Starting parallel parse of ${totalFiles} files in ${chunks.length} chunks`,
+            details: { chunkIndex: 0, totalChunks: chunks.length },
+        });
+        await debugLog('Using parallel chunk workers', { totalFiles, chunkCount: chunks.length });
+        const pool = new ChunkWorkerPool({
+            projectPath: config.projectPath,
+            tsconfigPath: config.tsconfigPath,
+            projectId: config.projectId,
+            projectType: config.projectType,
+        });
+        // Pipelined: import starts as soon as each chunk completes parsing
+        const poolResult = await pool.processChunks(chunks, async (result, stats) => {
+            await this.importToNeo4j(result.nodes, result.edges);
+            totalNodesImported += result.nodes.length;
+            totalEdgesImported += result.edges.length;
+            // Accumulate nodes for cross-chunk edge resolution
+            parser.addParsedNodesFromChunk(result.nodes);
+            // Merge shared context from workers for enabling cross-chunk references
+            if (result.sharedContext && result.sharedContext.length > 0) {
+                parser.mergeSerializedSharedContext(result.sharedContext);
+            }
+            // Collect deferred edges for resolution after all chunks complete
+            if (result.deferredEdges && result.deferredEdges.length > 0) {
+                parser.mergeDeferredEdges(result.deferredEdges);
+            }
+            this.progressReporter.report({
+                phase: 'parsing',
+                current: stats.chunksCompleted * config.chunkSize,
+                total: totalFiles,
+                message: `Chunk ${stats.chunksCompleted}/${stats.totalChunks}: ${totalNodesImported} nodes, ${totalEdgesImported} edges`,
+                details: {
+                    nodesCreated: totalNodesImported,
+                    edgesCreated: totalEdgesImported,
+                    chunkIndex: stats.chunksCompleted,
+                    totalChunks: stats.totalChunks,
+                },
+            });
+            debugLog(`Chunk ${result.chunkIndex + 1}/${stats.totalChunks}: ${result.nodes.length} nodes, ${result.edges.length} edges (imported)`);
+        });
+        debugLog(`Parallel parse+import complete: ${poolResult.totalNodes} nodes, ${poolResult.totalEdges} edges in ${poolResult.elapsedMs}ms`);
+        this.progressReporter.report({
+            phase: 'resolving',
+            current: totalFiles,
+            total: totalFiles,
+            message: 'Resolving cross-chunk edges',
+            details: {
+                nodesCreated: totalNodesImported,
+                edgesCreated: totalEdgesImported,
+                chunkIndex: chunks.length,
+                totalChunks: chunks.length,
+            },
+        });
+        const resolvedEdges = await parser.resolveDeferredEdges();
+        if (resolvedEdges.length > 0) {
+            await this.importToNeo4j([], resolvedEdges);
+            totalEdgesImported += resolvedEdges.length;
+            await debugLog(`Resolved ${resolvedEdges.length} cross-chunk edges`);
+        }
+        parser.loadFrameworkSchemasForType(config.projectType);
+        const enhancedEdges = await parser.applyEdgeEnhancementsManually();
+        if (enhancedEdges.length > 0) {
+            await this.importToNeo4j([], enhancedEdges);
+            totalEdgesImported += enhancedEdges.length;
+            await debugLog(`Created ${enhancedEdges.length} edges from enhancements`);
+        }
+        parser.clearParsedData();
+        const elapsedMs = Date.now() - startTime;
+        return {
+            nodesImported: totalNodesImported,
+            edgesImported: totalEdgesImported,
+            filesProcessed: totalFiles,
+            chunksProcessed: chunks.length,
+            elapsedMs,
+        };
+    }
+    createChunks(files, chunkSize) {
+        const chunks = [];
+        for (let i = 0; i < files.length; i += chunkSize) {
+            chunks.push(files.slice(i, i + chunkSize));
+        }
+        return chunks;
+    }
+    async importToNeo4j(nodes, edges) {
+        if (nodes.length === 0 && edges.length === 0)
+            return;
+        const fs = await import('fs/promises');
+        const { randomBytes } = await import('crypto');
+        const { tmpdir } = await import('os');
+        const tempPath = join(tmpdir(), `chunk-${Date.now()}-${randomBytes(8).toString('hex')}.json`);
+        try {
+            await fs.writeFile(tempPath, JSON.stringify({ nodes, edges, metadata: { parallel: true } }));
+            await this.graphGeneratorHandler.generateGraph(tempPath, 100, false);
+        }
+        finally {
+            try {
+                await fs.unlink(tempPath);
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+        }
+    }
+}

package/dist/mcp/handlers/streaming-import.handler.js

@@ -33,36 +33,33 @@ export class StreamingImportHandler {
         if (config.onProgress) {
             this.progressReporter.setCallback(config.onProgress);
         }
-        // Set project ID on graph generator
-        this.graphGeneratorHandler.setProjectId(config.projectId);
-        // Phase 1: Get discovered files (already discovered by worker, this returns cached result)
         const allFilePaths = await parser.discoverSourceFiles();
-        console.log(`📁 Found ${allFilePaths.length} files to parse`);
         await debugLog('Streaming import started', {
             totalFiles: allFilePaths.length,
             chunkSize: config.chunkSize,
         });
-        // Create chunks
+        this.progressReporter.report({
+            phase: 'parsing',
+            current: 0,
+            total: allFilePaths.length,
+            message: `Starting streaming import of ${allFilePaths.length} files in chunks of ~${config.chunkSize}`,
+        });
         const chunks = [];
         for (let i = 0; i < allFilePaths.length; i += config.chunkSize) {
             chunks.push(allFilePaths.slice(i, i + config.chunkSize));
         }
-        console.log(`📦 Split into ${chunks.length} chunks of ~${config.chunkSize} files each`);
         let totalNodesImported = 0;
         let totalEdgesImported = 0;
-        // Phase 2: Parse and import chunks
         for (let chunkIndex = 0; chunkIndex < chunks.length; chunkIndex++) {
             const chunk = chunks[chunkIndex];
             const filesProcessed = chunkIndex * config.chunkSize + chunk.length;
-            console.log(`\n🔄 Processing chunk ${chunkIndex + 1}/${chunks.length} (${chunk.length} files)`);
             try {
-                // Parse the chunk (skip edge resolution for streaming)
+                // Skip edge resolution during chunk parsing - resolve after all chunks complete
                 const { nodes, edges } = await parser.parseChunk(chunk, true);
-                // Add parsed nodes to existing nodes for cross-chunk edge resolution
+                // Accumulate nodes for cross-chunk edge resolution
                 parser.addExistingNodesFromChunk(nodes);
-                // Import to Neo4j if we have data
                 if (nodes.length > 0 || edges.length > 0) {
-                    await debugLog('Importing chunk - generating embeddings', {
+                    await debugLog('Importing chunk', {
                         chunkIndex: chunkIndex + 1,
                         totalChunks: chunks.length,
                         nodeCount: nodes.length,
@@ -72,14 +69,12 @@ export class StreamingImportHandler {
                     totalEdgesImported += edges.length;
                 }
                 else {
-                    console.warn(`⚠️ Chunk ${chunkIndex + 1} produced 0 nodes/edges from ${chunk.length} files`);
                     await debugLog('Empty chunk result', {
                         chunkIndex: chunkIndex + 1,
                         fileCount: chunk.length,
                         sampleFiles: chunk.slice(0, 3),
                     });
                 }
-                // Report progress with all relevant data
                 await this.progressReporter.report({
                     phase: 'importing',
                     current: filesProcessed,
@@ -94,10 +89,8 @@ export class StreamingImportHandler {
                         totalChunks: chunks.length,
                     },
                 });
-                console.log(`✅ Chunk ${chunkIndex + 1}: ${nodes.length} nodes, ${edges.length} edges imported`);
             }
             catch (chunkError) {
-                console.error(`❌ Error processing chunk ${chunkIndex + 1}:`, chunkError);
                 await debugLog('Chunk processing error', {
                     chunkIndex: chunkIndex + 1,
                     fileCount: chunk.length,
@@ -105,40 +98,24 @@ export class StreamingImportHandler {
                     error: chunkError instanceof Error ? chunkError.message : String(chunkError),
                     stack: chunkError instanceof Error ? chunkError.stack : undefined,
                 });
-                // Re-throw to fail the entire import - don't silently continue
                 throw chunkError;
             }
-            // Note: Don't clear parsed data during streaming - we need accumulated nodes for cross-chunk edge resolution
-            // Memory usage is bounded because we only keep Neo4jNode references (not full AST)
         }
-        // Phase 3: Resolve cross-chunk deferred edges
         await this.progressReporter.reportResolving(0, totalEdgesImported);
-        console.log('\n🔗 Resolving cross-chunk edges...');
-        const resolvedEdges = await parser.resolveDeferredEdgesManually();
+        const resolvedEdges = await parser.resolveDeferredEdges();
         if (resolvedEdges.length > 0) {
             await this.importEdgesToNeo4j(resolvedEdges);
             totalEdgesImported += resolvedEdges.length;
-            console.log(`✅ Resolved ${resolvedEdges.length} cross-chunk edges`);
-        }
-        else {
-            console.log('ℹ️ No cross-chunk edges to resolve');
+            await debugLog(`Resolved ${resolvedEdges.length} cross-chunk edges`);
         }
-        // Phase 3b: Apply edge enhancements on all accumulated nodes
-        // This catches context-dependent edges (like INTERNAL_API_CALL) that span chunks
-        console.log('\n🔗 Applying edge enhancements on all nodes...');
         const enhancedEdges = await parser.applyEdgeEnhancementsManually();
         if (enhancedEdges.length > 0) {
             await this.importEdgesToNeo4j(enhancedEdges);
             totalEdgesImported += enhancedEdges.length;
-            console.log(`✅ Created ${enhancedEdges.length} edges from edge enhancements`);
+            await debugLog(`Created ${enhancedEdges.length} edges from edge enhancements`);
         }
-        else {
-            console.log('ℹ️ No edges from edge enhancements');
-        }
-        // Clear accumulated data now that edge resolution is complete
         parser.clearParsedData();
         await this.progressReporter.reportResolving(resolvedEdges.length, resolvedEdges.length);
-        // Phase 4: Complete
         const elapsedMs = Date.now() - startTime;
         await this.progressReporter.reportComplete(totalNodesImported, totalEdgesImported);
         const result = {
@@ -148,32 +125,17 @@ export class StreamingImportHandler {
             chunksProcessed: chunks.length,
             elapsedMs,
         };
-        console.log(`\n🎉 Streaming import complete!`);
-        console.log(`   Files: ${allFilePaths.length}`);
-        console.log(`   Nodes: ${totalNodesImported}`);
-        console.log(`   Edges: ${totalEdgesImported}`);
-        console.log(`   Time: ${(elapsedMs / 1000).toFixed(2)}s`);
         await debugLog('Streaming import completed', result);
         return result;
     }
-    /**
-     * Import a chunk of nodes and edges to Neo4j using the graph generator handler
-     */
     async importChunkToNeo4j(nodes, edges) {
-        // Write to temporary JSON and use existing import mechanism
-        // This reuses the batched embedding and import logic
         const tempPath = generateTempPath('chunk');
         const fs = await import('fs/promises');
         try {
-            await fs.writeFile(tempPath, JSON.stringify({
-                nodes,
-                edges,
-                metadata: { chunked: true },
-            }));
+            await fs.writeFile(tempPath, JSON.stringify({ nodes, edges, metadata: { chunked: true } }));
             await this.graphGeneratorHandler.generateGraph(tempPath, DEFAULTS.batchSize, false);
         }
         finally {
-            // Clean up temp file
             try {
                 await fs.unlink(tempPath);
             }
@@ -182,20 +144,13 @@ export class StreamingImportHandler {
             }
         }
     }
-    /**
-     * Import resolved edges to Neo4j
-     */
     async importEdgesToNeo4j(edges) {
         if (edges.length === 0)
             return;
         const tempPath = generateTempPath('edges');
         const fs = await import('fs/promises');
         try {
-            await fs.writeFile(tempPath, JSON.stringify({
-                nodes: [],
-                edges,
-                metadata: { edgesOnly: true },
-            }));
+            await fs.writeFile(tempPath, JSON.stringify({ nodes: [], edges, metadata: { edgesOnly: true } }));
             await this.graphGeneratorHandler.generateGraph(tempPath, DEFAULTS.batchSize, false);
         }
         finally {

package/dist/mcp/mcp.server.js

@@ -18,8 +18,8 @@ import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { MCP_SERVER_CONFIG, MESSAGES } from './constants.js';
 import { performIncrementalParse } from './handlers/incremental-parse.handler.js';
-import { watchManager } from './services/watch-manager.js';
 import { initializeServices } from './service-init.js';
+import { watchManager } from './services/watch-manager.js';
 import { registerAllTools } from './tools/index.js';
 import { debugLog } from './utils.js';
 /**