code-graph-context 2.0.1 → 2.3.0

package/dist/mcp/tools/parse-typescript-project.tool.js

@@ -12,20 +12,16 @@ import { z } from 'zod';
 import { CORE_TYPESCRIPT_SCHEMA } from '../../core/config/schema.js';
 import { EmbeddingsService } from '../../core/embeddings/embeddings.service.js';
 import { ParserFactory } from '../../core/parsers/parser-factory.js';
+import { detectChangedFiles } from '../../core/utils/file-change-detection.js';
 import { resolveProjectId, getProjectName, UPSERT_PROJECT_QUERY, UPDATE_PROJECT_STATUS_QUERY, } from '../../core/utils/project-id.js';
 import { Neo4jService, QUERIES } from '../../storage/neo4j/neo4j.service.js';
-import { TOOL_NAMES, TOOL_METADATA, DEFAULTS, FILE_PATHS, LOG_CONFIG } from '../constants.js';
+import { TOOL_NAMES, TOOL_METADATA, DEFAULTS, FILE_PATHS, LOG_CONFIG, PARSING } from '../constants.js';
 import { deleteSourceFileSubgraphs, loadExistingNodesForEdgeDetection, getCrossFileEdges, } from '../handlers/cross-file-edge.helpers.js';
-import { detectChangedFiles } from '../../core/utils/file-change-detection.js';
 import { GraphGeneratorHandler } from '../handlers/graph-generator.handler.js';
 import { StreamingImportHandler } from '../handlers/streaming-import.handler.js';
 import { jobManager } from '../services/job-manager.js';
 import { watchManager } from '../services/watch-manager.js';
 import { createErrorResponse, createSuccessResponse, formatParseSuccess, formatParsePartialSuccess, debugLog, } from '../utils.js';
-// Threshold for using streaming import (files)
-const STREAMING_THRESHOLD = 100;
-// Worker thread timeout (30 minutes)
-const WORKER_TIMEOUT_MS = 30 * 60 * 1000;
 /**
  * Validates that a path exists and is accessible
  * @throws Error if path doesn't exist or isn't accessible
@@ -87,7 +83,7 @@ export const createParseTypescriptProjectTool = (server) => {
             chunkSize: z
                 .number()
                 .optional()
-                .default(50)
+                .default(100)
                 .describe('Files per chunk for streaming import (default: 50). Set to 0 to disable streaming.'),
             useStreaming: z
                 .enum(['auto', 'always', 'never'])
@@ -139,7 +135,7 @@ export const createParseTypescriptProjectTool = (server) => {
                 // Get path to worker script
                 const __filename = fileURLToPath(import.meta.url);
                 const __dirname = dirname(__filename);
-                const workerPath = join(__dirname, '..', 'workers', 'parse-worker.js');
+                const workerPath = join(__dirname, '..', 'workers', 'parse-coordinator.js');
                 // Create Worker thread to run parsing without blocking MCP server
                 const worker = new Worker(workerPath, {
                     workerData: {
@@ -168,10 +164,10 @@ export const createParseTypescriptProjectTool = (server) => {
                 const timeoutId = setTimeout(async () => {
                     const job = jobManager.getJob(jobId);
                     if (job && job.status === 'running') {
-                        jobManager.failJob(jobId, `Worker timed out after ${WORKER_TIMEOUT_MS / 60000} minutes`);
+                        jobManager.failJob(jobId, `Worker timed out after ${PARSING.workerTimeoutMs / 60000} minutes`);
                         await terminateWorker('timeout');
                     }
-                }, WORKER_TIMEOUT_MS);
+                }, PARSING.workerTimeoutMs);
                 // Handle progress messages from worker
                 worker.on('message', (msg) => {
                     if (msg.type === 'progress') {
@@ -216,16 +212,19 @@ export const createParseTypescriptProjectTool = (server) => {
             const embeddingsService = new EmbeddingsService();
             const graphGeneratorHandler = new GraphGeneratorHandler(neo4jService, embeddingsService);
             // Determine if we should use streaming import
+            // Use lazyLoad = true for consistent glob-based file discovery (matches incremental parse)
             const parser = projectType === 'auto'
-                ? await ParserFactory.createParserWithAutoDetection(projectPath, tsconfigPath, resolvedProjectId)
+                ? await ParserFactory.createParserWithAutoDetection(projectPath, tsconfigPath, resolvedProjectId, true)
                 : ParserFactory.createParser({
                     workspacePath: projectPath,
                     tsConfigPath: tsconfigPath,
                     projectType: projectType,
                     projectId: resolvedProjectId,
+                    lazyLoad: true,
                 });
-            const totalFiles = parser.getSourceFilePaths().length;
-            const shouldUseStreaming = useStreaming === 'always' || (useStreaming === 'auto' && totalFiles > STREAMING_THRESHOLD && chunkSize > 0);
+            const discoveredFiles = await parser.discoverSourceFiles();
+            const totalFiles = discoveredFiles.length;
+            const shouldUseStreaming = useStreaming === 'always' || (useStreaming === 'auto' && totalFiles > PARSING.streamingThreshold && chunkSize > 0);
             console.log(`📊 Project has ${totalFiles} files. Streaming: ${shouldUseStreaming ? 'enabled' : 'disabled'}`);
             if (shouldUseStreaming && clearExisting !== false) {
                 // Use streaming import for large projects
@@ -385,13 +384,15 @@ const parseProject = async (options) => {
     const { neo4jService, tsconfigPath, projectPath, projectId, clearExisting = true, projectType = 'auto' } = options;
     // Resolve projectId early - needed for incremental queries before parser is created
     const resolvedId = resolveProjectId(projectPath, projectId);
+    // Use lazyLoad = true for consistent glob-based file discovery (matches incremental parse)
     const parser = projectType === 'auto'
-        ? await ParserFactory.createParserWithAutoDetection(projectPath, tsconfigPath, resolvedId)
+        ? await ParserFactory.createParserWithAutoDetection(projectPath, tsconfigPath, resolvedId, true)
         : ParserFactory.createParser({
             workspacePath: projectPath,
             tsConfigPath: tsconfigPath,
             projectType: projectType,
             projectId: resolvedId,
+            lazyLoad: true,
         });
     let incrementalStats;
     let savedCrossFileEdges = [];

package/dist/mcp/tools/swarm-cleanup.tool.js

@@ -0,0 +1,157 @@
+/**
+ * Swarm Cleanup Tool
+ * Bulk delete pheromones after a swarm completes
+ */
+import { z } from 'zod';
+import { Neo4jService } from '../../storage/neo4j/neo4j.service.js';
+import { TOOL_NAMES, TOOL_METADATA } from '../constants.js';
+import { createErrorResponse, createSuccessResponse, resolveProjectIdOrError, debugLog } from '../utils.js';
+/**
+ * Neo4j query to delete pheromones by swarm ID
+ */
+const CLEANUP_BY_SWARM_QUERY = `
+  MATCH (p:Pheromone)
+  WHERE p.projectId = $projectId
+    AND p.swarmId = $swarmId
+    AND NOT p.type IN $keepTypes
+  WITH p, p.agentId as agentId, p.type as type
+  DETACH DELETE p
+  RETURN count(p) as deleted, collect(DISTINCT agentId) as agents, collect(DISTINCT type) as types
+`;
+/**
+ * Neo4j query to delete pheromones by agent ID
+ */
+const CLEANUP_BY_AGENT_QUERY = `
+  MATCH (p:Pheromone)
+  WHERE p.projectId = $projectId
+    AND p.agentId = $agentId
+    AND NOT p.type IN $keepTypes
+  WITH p, p.swarmId as swarmId, p.type as type
+  DETACH DELETE p
+  RETURN count(p) as deleted, collect(DISTINCT swarmId) as swarms, collect(DISTINCT type) as types
+`;
+/**
+ * Neo4j query to delete all pheromones in a project
+ */
+const CLEANUP_ALL_QUERY = `
+  MATCH (p:Pheromone)
+  WHERE p.projectId = $projectId
+    AND NOT p.type IN $keepTypes
+  WITH p, p.agentId as agentId, p.swarmId as swarmId, p.type as type
+  DETACH DELETE p
+  RETURN count(p) as deleted, collect(DISTINCT agentId) as agents, collect(DISTINCT swarmId) as swarms, collect(DISTINCT type) as types
+`;
+/**
+ * Count queries for dry run
+ */
+const COUNT_BY_SWARM_QUERY = `
+  MATCH (p:Pheromone)
+  WHERE p.projectId = $projectId AND p.swarmId = $swarmId AND NOT p.type IN $keepTypes
+  RETURN count(p) as count, collect(DISTINCT p.agentId) as agents, collect(DISTINCT p.type) as types
+`;
+const COUNT_BY_AGENT_QUERY = `
+  MATCH (p:Pheromone)
+  WHERE p.projectId = $projectId AND p.agentId = $agentId AND NOT p.type IN $keepTypes
+  RETURN count(p) as count, collect(DISTINCT p.swarmId) as swarms, collect(DISTINCT p.type) as types
+`;
+const COUNT_ALL_QUERY = `
+  MATCH (p:Pheromone)
+  WHERE p.projectId = $projectId AND NOT p.type IN $keepTypes
+  RETURN count(p) as count, collect(DISTINCT p.agentId) as agents, collect(DISTINCT p.swarmId) as swarms, collect(DISTINCT p.type) as types
+`;
+export const createSwarmCleanupTool = (server) => {
+    server.registerTool(TOOL_NAMES.swarmCleanup, {
+        title: TOOL_METADATA[TOOL_NAMES.swarmCleanup].title,
+        description: TOOL_METADATA[TOOL_NAMES.swarmCleanup].description,
+        inputSchema: {
+            projectId: z.string().describe('Project ID, name, or path'),
+            swarmId: z.string().optional().describe('Delete all pheromones from this swarm'),
+            agentId: z.string().optional().describe('Delete all pheromones from this agent'),
+            all: z.boolean().optional().default(false).describe('Delete ALL pheromones in project (use with caution)'),
+            keepTypes: z
+                .array(z.string())
+                .optional()
+                .default(['warning'])
+                .describe('Pheromone types to preserve (default: ["warning"])'),
+            dryRun: z.boolean().optional().default(false).describe('Preview what would be deleted without deleting'),
+        },
+    }, async ({ projectId, swarmId, agentId, all = false, keepTypes = ['warning'], dryRun = false }) => {
+        const neo4jService = new Neo4jService();
+        // Resolve project ID
+        const projectResult = await resolveProjectIdOrError(projectId, neo4jService);
+        if (!projectResult.success) {
+            await neo4jService.close();
+            return projectResult.error;
+        }
+        const resolvedProjectId = projectResult.projectId;
+        try {
+            // Validate: must specify swarmId, agentId, or all
+            if (!swarmId && !agentId && !all) {
+                return createErrorResponse('Must specify one of: swarmId, agentId, or all=true. Use dryRun=true to preview.');
+            }
+            await debugLog('Swarm cleanup operation', {
+                projectId: resolvedProjectId,
+                swarmId,
+                agentId,
+                all,
+                keepTypes,
+                dryRun,
+            });
+            const params = { projectId: resolvedProjectId, keepTypes };
+            let deleteQuery;
+            let countQuery;
+            let mode;
+            if (swarmId) {
+                params.swarmId = swarmId;
+                deleteQuery = CLEANUP_BY_SWARM_QUERY;
+                countQuery = COUNT_BY_SWARM_QUERY;
+                mode = 'swarm';
+            }
+            else if (agentId) {
+                params.agentId = agentId;
+                deleteQuery = CLEANUP_BY_AGENT_QUERY;
+                countQuery = COUNT_BY_AGENT_QUERY;
+                mode = 'agent';
+            }
+            else {
+                deleteQuery = CLEANUP_ALL_QUERY;
+                countQuery = COUNT_ALL_QUERY;
+                mode = 'all';
+            }
+            if (dryRun) {
+                const result = await neo4jService.run(countQuery, params);
+                const count = result[0]?.count ?? 0;
+                return createSuccessResponse(JSON.stringify({
+                    success: true,
+                    dryRun: true,
+                    mode,
+                    wouldDelete: typeof count === 'object' && 'toNumber' in count ? count.toNumber() : count,
+                    agents: result[0]?.agents ?? [],
+                    swarms: result[0]?.swarms ?? [],
+                    types: result[0]?.types ?? [],
+                    keepTypes,
+                    projectId: resolvedProjectId,
+                }));
+            }
+            const result = await neo4jService.run(deleteQuery, params);
+            const deleted = result[0]?.deleted ?? 0;
+            return createSuccessResponse(JSON.stringify({
+                success: true,
+                mode,
+                deleted: typeof deleted === 'object' && 'toNumber' in deleted ? deleted.toNumber() : deleted,
+                agents: result[0]?.agents ?? [],
+                swarms: result[0]?.swarms ?? [],
+                types: result[0]?.types ?? [],
+                keepTypes,
+                projectId: resolvedProjectId,
+            }));
+        }
+        catch (error) {
+            await debugLog('Swarm cleanup error', { error: String(error) });
+            return createErrorResponse(error instanceof Error ? error : String(error));
+        }
+        finally {
+            await neo4jService.close();
+        }
+    });
+};

package/dist/mcp/tools/swarm-constants.js

@@ -0,0 +1,35 @@
+/**
+ * Shared constants for swarm coordination tools
+ */
+/**
+ * Pheromone types and their half-lives in milliseconds.
+ * Half-life determines decay rate - after one half-life, intensity drops to 50%.
+ */
+export const PHEROMONE_CONFIG = {
+    exploring: { halfLife: 2 * 60 * 1000, description: 'Browsing/reading' },
+    modifying: { halfLife: 10 * 60 * 1000, description: 'Active work' },
+    claiming: { halfLife: 60 * 60 * 1000, description: 'Ownership' },
+    completed: { halfLife: 24 * 60 * 60 * 1000, description: 'Done' },
+    warning: { halfLife: -1, description: 'Never decays' },
+    blocked: { halfLife: 5 * 60 * 1000, description: 'Stuck' },
+    proposal: { halfLife: 60 * 60 * 1000, description: 'Awaiting approval' },
+    needs_review: { halfLife: 30 * 60 * 1000, description: 'Review requested' },
+};
+export const PHEROMONE_TYPES = Object.keys(PHEROMONE_CONFIG);
+/**
+ * Get half-life for a pheromone type.
+ * Returns -1 for types that never decay (e.g., warning).
+ */
+export const getHalfLife = (type) => {
+    return PHEROMONE_CONFIG[type]?.halfLife ?? PHEROMONE_CONFIG.exploring.halfLife;
+};
+/**
+ * Workflow states are mutually exclusive per agent+node.
+ * Setting one removes others in this group.
+ * Flags (warning, proposal, needs_review) can coexist with workflow states.
+ */
+export const WORKFLOW_STATES = ['exploring', 'claiming', 'modifying', 'completed', 'blocked'];
+/**
+ * Flags can coexist with workflow states.
+ */
+export const FLAG_TYPES = ['warning', 'proposal', 'needs_review'];

package/dist/mcp/tools/swarm-pheromone.tool.js

@@ -0,0 +1,196 @@
+/**
+ * Swarm Pheromone Tool
+ * Leave a pheromone marker on a code node for stigmergic coordination
+ */
+import { z } from 'zod';
+import { Neo4jService } from '../../storage/neo4j/neo4j.service.js';
+import { TOOL_NAMES, TOOL_METADATA } from '../constants.js';
+import { createErrorResponse, createSuccessResponse, resolveProjectIdOrError, debugLog } from '../utils.js';
+import { PHEROMONE_TYPES, WORKFLOW_STATES, getHalfLife } from './swarm-constants.js';
+/**
+ * Neo4j query to clean up other workflow states before setting a new one.
+ * Only runs for workflow state pheromones, not flags.
+ */
+const CLEANUP_WORKFLOW_STATES_QUERY = `
+  MATCH (p:Pheromone)
+  WHERE p.projectId = $projectId
+    AND p.nodeId = $nodeId
+    AND p.agentId = $agentId
+    AND p.swarmId = $swarmId
+    AND p.type IN $workflowStates
+    AND p.type <> $newType
+  DETACH DELETE p
+  RETURN count(p) as cleaned
+`;
+/**
+ * Neo4j query to create or update a pheromone
+ */
+const CREATE_PHEROMONE_QUERY = `
+  // Find the target code node (exclude other pheromones)
+  MATCH (target)
+  WHERE target.id = $nodeId
+    AND target.projectId = $projectId
+    AND NOT target:Pheromone
+  WITH target
+  LIMIT 1
+
+  // Create or update pheromone (scoped to project)
+  MERGE (p:Pheromone {projectId: $projectId, nodeId: $nodeId, agentId: $agentId, swarmId: $swarmId, type: $type})
+  ON CREATE SET
+    p.id = randomUUID(),
+    p.intensity = $intensity,
+    p.timestamp = timestamp(),
+    p.data = $data,
+    p.halfLife = $halfLife
+  ON MATCH SET
+    p.intensity = $intensity,
+    p.timestamp = timestamp(),
+    p.data = $data
+
+  // Create relationship to target node if it exists
+  WITH p, target
+  WHERE target IS NOT NULL
+  MERGE (p)-[:MARKS]->(target)
+
+  RETURN p.id as id, p.nodeId as nodeId, p.projectId as projectId, p.type as type, p.intensity as intensity,
+         p.timestamp as timestamp, p.agentId as agentId, p.swarmId as swarmId,
+         CASE WHEN target IS NOT NULL THEN true ELSE false END as linkedToNode
+`;
+/**
+ * Neo4j query to delete a pheromone
+ */
+const DELETE_PHEROMONE_QUERY = `
+  MATCH (p:Pheromone {projectId: $projectId, nodeId: $nodeId, agentId: $agentId, swarmId: $swarmId, type: $type})
+  DETACH DELETE p
+  RETURN count(p) as deleted
+`;
+export const createSwarmPheromoneTool = (server) => {
+    server.registerTool(TOOL_NAMES.swarmPheromone, {
+        title: TOOL_METADATA[TOOL_NAMES.swarmPheromone].title,
+        description: TOOL_METADATA[TOOL_NAMES.swarmPheromone].description,
+        inputSchema: {
+            projectId: z.string().describe('Project ID, name, or path (e.g., "backend" or "proj_a1b2c3d4e5f6")'),
+            nodeId: z.string().describe('The code node ID to mark with a pheromone'),
+            type: z
+                .enum(PHEROMONE_TYPES)
+                .describe('Type of pheromone: exploring (browsing), modifying (active work), claiming (ownership), completed (done), warning (danger), blocked (stuck), proposal (awaiting approval), needs_review (review request)'),
+            intensity: z
+                .number()
+                .min(0)
+                .max(1)
+                .optional()
+                .default(1.0)
+                .describe('Pheromone intensity from 0.0 to 1.0 (default: 1.0)'),
+            agentId: z.string().describe('Unique identifier for the agent leaving the pheromone'),
+            swarmId: z.string().describe('Swarm ID for grouping related agents (e.g., "swarm_xyz")'),
+            data: z
+                .record(z.unknown())
+                .optional()
+                .describe('Optional metadata to attach to the pheromone (e.g., summary, reason)'),
+            remove: z
+                .boolean()
+                .optional()
+                .default(false)
+                .describe('If true, removes the pheromone instead of creating/updating it'),
+        },
+    }, async ({ projectId, nodeId, type, intensity = 1.0, agentId, swarmId, data, remove = false }) => {
+        const neo4jService = new Neo4jService();
+        // Resolve project ID
+        const projectResult = await resolveProjectIdOrError(projectId, neo4jService);
+        if (!projectResult.success) {
+            await neo4jService.close();
+            return projectResult.error;
+        }
+        const resolvedProjectId = projectResult.projectId;
+        try {
+            if (remove) {
+                const result = await neo4jService.run(DELETE_PHEROMONE_QUERY, {
+                    projectId: resolvedProjectId,
+                    nodeId,
+                    agentId,
+                    swarmId,
+                    type,
+                });
+                const deleted = result[0]?.deleted ?? 0;
+                if (deleted > 0) {
+                    return createSuccessResponse(JSON.stringify({
+                        success: true,
+                        action: 'removed',
+                        projectId: resolvedProjectId,
+                        nodeId,
+                        type,
+                        agentId,
+                        swarmId,
+                    }));
+                }
+                else {
+                    return createSuccessResponse(JSON.stringify({
+                        success: true,
+                        action: 'not_found',
+                        message: 'No matching pheromone found to remove',
+                        projectId: resolvedProjectId,
+                        nodeId,
+                        type,
+                        agentId,
+                        swarmId,
+                    }));
+                }
+            }
+            // Create or update pheromone
+            const halfLife = getHalfLife(type);
+            const dataJson = data ? JSON.stringify(data) : null;
+            // If setting a workflow state, clean up other workflow states first
+            let cleanedStates = 0;
+            if (WORKFLOW_STATES.includes(type)) {
+                const cleanupResult = await neo4jService.run(CLEANUP_WORKFLOW_STATES_QUERY, {
+                    projectId: resolvedProjectId,
+                    nodeId,
+                    agentId,
+                    swarmId,
+                    workflowStates: WORKFLOW_STATES,
+                    newType: type,
+                });
+                cleanedStates = cleanupResult[0]?.cleaned ?? 0;
+            }
+            const result = await neo4jService.run(CREATE_PHEROMONE_QUERY, {
+                projectId: resolvedProjectId,
+                nodeId,
+                type,
+                intensity,
+                agentId,
+                swarmId,
+                data: dataJson,
+                halfLife,
+            });
+            if (result.length === 0) {
+                return createErrorResponse(`Failed to create pheromone. Node ${nodeId} may not exist in the graph.`);
+            }
+            const pheromone = result[0];
+            return createSuccessResponse(JSON.stringify({
+                success: true,
+                action: cleanedStates > 0 ? 'transitioned' : 'created',
+                previousStatesRemoved: cleanedStates,
+                pheromone: {
+                    id: pheromone.id,
+                    projectId: pheromone.projectId,
+                    nodeId: pheromone.nodeId,
+                    type: pheromone.type,
+                    intensity: pheromone.intensity,
+                    agentId: pheromone.agentId,
+                    swarmId: pheromone.swarmId,
+                    timestamp: pheromone.timestamp,
+                    linkedToNode: pheromone.linkedToNode,
+                    halfLifeMs: halfLife,
+                    expiresIn: halfLife < 0 ? 'never' : `${Math.round(halfLife / 60000)} minutes`,
+                },
+            }));
+        }
+        catch (error) {
+            await debugLog('Swarm pheromone error', { error: String(error) });
+            return createErrorResponse(error instanceof Error ? error : String(error));
+        }
+        finally {
+            await neo4jService.close();
+        }
+    });
+};