code-graph-context 2.0.1 → 2.3.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,11 @@ export const TOOL_NAMES = {
     startWatchProject: 'start_watch_project',
     stopWatchProject: 'stop_watch_project',
     listWatchers: 'list_watchers',
+    detectDeadCode: 'detect_dead_code',
+    detectDuplicateCode: 'detect_duplicate_code',
+    swarmPheromone: 'swarm_pheromone',
+    swarmSense: 'swarm_sense',
+    swarmCleanup: 'swarm_cleanup',
 };
 // Tool Metadata
 export const TOOL_METADATA = {
@@ -93,10 +100,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 +277,203 @@ 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.`,
+    },
+    [TOOL_NAMES.swarmPheromone]: {
+        title: 'Swarm Pheromone',
+        description: `Leave a pheromone marker on a code node for stigmergic coordination between agents.
+
+**What is Stigmergy?**
+Agents coordinate indirectly by leaving markers (pheromones) on code nodes. Other agents sense these markers and adapt their behavior. No direct messaging needed.
+
+**Pheromone Types:**
+- exploring: "I'm looking at this" (2 min half-life)
+- modifying: "I'm actively working on this" (10 min half-life)
+- claiming: "This is my territory" (1 hour half-life)
+- completed: "I finished work here" (24 hour half-life)
+- warning: "Danger - don't touch" (never decays)
+- blocked: "I'm stuck on this" (5 min half-life)
+- proposal: "Proposed artifact awaiting approval" (1 hour half-life)
+- needs_review: "Someone should check this" (30 min half-life)
+
+**Parameters:**
+- nodeId: The code node ID to mark
+- type: Type of pheromone (see above)
+- agentId: Your unique agent identifier
+- swarmId: Swarm ID from orchestrator (for bulk cleanup)
+- intensity: 0.0-1.0, how strong the signal (default: 1.0)
+- data: Optional metadata (summary, reason, etc.)
+- remove: Set true to remove the pheromone
+
+**Workflow states** (exploring, claiming, modifying, completed, blocked) are mutually exclusive per agent+node. Setting one automatically removes others.
+
+**Usage Pattern:**
+1. Before starting work: swarm_sense to check what's claimed
+2. Claim your target: swarm_pheromone({ nodeId, type: "claiming", agentId, swarmId })
+3. Refresh periodically if working long
+4. Mark complete: swarm_pheromone({ nodeId, type: "completed", agentId, swarmId, data: { summary: "..." } })
+
+**Decay:**
+Pheromones automatically fade over time. If an agent dies, its markers decay and work becomes available again.`,
+    },
+    [TOOL_NAMES.swarmSense]: {
+        title: 'Swarm Sense',
+        description: `Query pheromones in the code graph to sense what other agents are doing.
+
+**What This Does:**
+Returns active pheromones with their current intensity (after decay). Use this to:
+- See what nodes are being worked on
+- Avoid conflicts with other agents
+- Find unclaimed work
+- Check if your dependencies are being modified
+
+**Parameters:**
+- swarmId: Filter by swarm ID (see only this swarm's pheromones)
+- types: Filter by pheromone types (e.g., ["modifying", "claiming"])
+- nodeIds: Check specific nodes
+- agentIds: Filter by specific agents
+- excludeAgentId: Exclude your own pheromones (see what OTHERS are doing)
+- minIntensity: Minimum intensity after decay (default: 0.3)
+- limit: Max results (default: 50)
+- includeStats: Get summary statistics by type
+- cleanup: Remove fully decayed pheromones (intensity < 0.01)
+
+**Usage Pattern:**
+\`\`\`
+// Before starting work, check what's taken
+swarm_sense({
+  types: ["modifying", "claiming"],
+  minIntensity: 0.3
+})
+
+// Check a specific node before modifying
+swarm_sense({
+  nodeIds: ["proj_xxx:Service:UserService"],
+  types: ["modifying", "warning"]
+})
+
+// See what other agents are doing (exclude self)
+swarm_sense({
+  excludeAgentId: "my-agent-id",
+  types: ["exploring", "modifying"]
+})
+\`\`\`
+
+**Decay:**
+Intensity decreases over time (exponential decay). A pheromone with intensity 0.25 is almost gone. Below minIntensity threshold, it's not returned.`,
+    },
+    [TOOL_NAMES.swarmCleanup]: {
+        title: 'Swarm Cleanup',
+        description: `Bulk delete pheromones after a swarm completes.
+
+**When to use:**
+Call this when a swarm finishes to clean up all its pheromones. Prevents pollution for future swarms.
+
+**Parameters:**
+- projectId: Required - the project
+- swarmId: Delete all pheromones from this swarm
+- agentId: Delete all pheromones from this specific agent
+- all: Set true to delete ALL pheromones in project (use with caution)
+- keepTypes: Pheromone types to preserve (default: ["warning"])
+- dryRun: Preview what would be deleted without deleting
+
+**Must specify one of:** swarmId, agentId, or all=true
+
+**Examples:**
+\`\`\`
+// Clean up after a swarm completes
+swarm_cleanup({ projectId: "backend", swarmId: "swarm_abc123" })
+
+// Preview what would be deleted
+swarm_cleanup({ projectId: "backend", swarmId: "swarm_abc123", dryRun: true })
+
+// Clean up a specific agent's pheromones
+swarm_cleanup({ projectId: "backend", agentId: "swarm_abc123_auth" })
+
+// Nuclear option: delete all (except warnings)
+swarm_cleanup({ projectId: "backend", all: true })
+\`\`\`
+
+**Note:** \`warning\` pheromones are preserved by default. Pass \`keepTypes: []\` to delete everything.`,
+    },
 };
 // Default Values
 export const DEFAULTS = {
@@ -263,6 +485,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 +557,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,13 @@ 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');
+            await debugLog('Incremental parse: no changes, returning early', {});
             return {
                 nodesUpdated: 0,
                 edgesUpdated: 0,
@@ -45,25 +45,35 @@ export const performIncrementalParse = async (projectPath, projectId, tsconfigPa
                 filesDeleted: filesToDelete.length,
             };
         }
+        await debugLog('Incremental parse: changes detected, continuing', { filesToReparse: filesToReparse.length });
         let savedCrossFileEdges = [];
         const filesToRemoveFromGraph = [...filesToDelete, ...filesToReparse];
         if (filesToRemoveFromGraph.length > 0) {
+            await debugLog('Incremental parse: getting cross-file edges', { count: filesToRemoveFromGraph.length });
             // Save cross-file edges before deletion
             savedCrossFileEdges = await getCrossFileEdges(neo4jService, filesToRemoveFromGraph, resolvedId);
-            await debugLog('Watch: saved cross-file edges', { count: savedCrossFileEdges.length });
+            await debugLog('Incremental parse: got cross-file edges', { savedCount: savedCrossFileEdges.length });
+            await debugLog('Incremental parse: deleting old subgraphs', {});
             // Delete old subgraphs
             await deleteSourceFileSubgraphs(neo4jService, filesToRemoveFromGraph, resolvedId);
+            await debugLog('Incremental parse: deleted old subgraphs', {});
         }
         let nodesImported = 0;
         let edgesImported = 0;
         if (filesToReparse.length > 0) {
+            await debugLog('Incremental parse: loading existing nodes', {});
             // Load existing nodes for edge detection
             const existingNodes = await loadExistingNodesForEdgeDetection(neo4jService, filesToRemoveFromGraph, resolvedId);
+            await debugLog('Incremental parse: loaded existing nodes', { count: existingNodes.length });
             parser.setExistingNodes(existingNodes);
+            await debugLog('Incremental parse: parsing workspace', { fileCount: filesToReparse.length });
             // Parse only changed files
             await parser.parseWorkspace(filesToReparse);
+            await debugLog('Incremental parse: parsed workspace', {});
             // Export graph data
+            await debugLog('Incremental parse: exporting to JSON', {});
             const { nodes, edges } = parser.exportToJson();
+            await debugLog('Incremental parse: exported to JSON', { nodeCount: nodes.length, edgeCount: edges.length });
             // Get framework schemas if available (use unknown as intermediate to access private property)
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
             const parserAny = parser;
@@ -82,26 +92,33 @@ export const performIncrementalParse = async (projectPath, projectId, tsconfigPa
                 },
             };
             // Write to JSON file (required by GraphGeneratorHandler)
+            await debugLog('Incremental parse: writing JSON file', {});
             const outputPath = join(projectPath, FILE_PATHS.graphOutput);
             writeFileSync(outputPath, JSON.stringify(graphData, null, LOG_CONFIG.jsonIndentation));
+            await debugLog('Incremental parse: wrote JSON file', { outputPath });
             // Update Project node
+            await debugLog('Incremental parse: updating project node', {});
             await neo4jService.run(UPSERT_PROJECT_QUERY, {
                 projectId: resolvedId,
                 path: projectPath,
                 name: projectName,
                 status: 'complete',
             });
+            await debugLog('Incremental parse: updated project node', {});
             // Import nodes and edges (clearExisting = false for incremental)
+            await debugLog('Incremental parse: starting graph import', {});
             graphHandler.setProjectId(resolvedId);
             try {
                 const result = await graphHandler.generateGraph(outputPath, DEFAULTS.batchSize, false);
                 nodesImported = result.nodesImported;
                 edgesImported = result.edgesImported;
+                await debugLog('Incremental parse: graph import completed', { nodesImported, edgesImported });
             }
             finally {
                 // Clean up temporary graph.json file
                 try {
                     unlinkSync(outputPath);
+                    await debugLog('Incremental parse: cleaned up temp file', {});
                 }
                 catch {
                     // Ignore cleanup errors - file may not exist or be inaccessible
@@ -124,10 +141,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
+            }
+        }
+    }
+}