code-graph-context 2.5.2 → 2.5.4

package/dist/core/embeddings/natural-language-to-cypher.service.js

@@ -4,7 +4,7 @@ import { getTimeoutConfig } from '../config/timeouts.js';
 export class NaturalLanguageToCypherService {
     assistantId;
     openai;
-    MODEL = 'gpt-4o-mini'; // Using GPT-4 Turbo
+    MODEL = 'gpt-4o'; // GPT-4o for better Cypher generation accuracy
     schemaPath = null;
     cachedSemanticTypes = null;
     messageInstructions = `

package/dist/mcp/tools/swarm-claim-task.tool.js

@@ -66,9 +66,9 @@ const CLAIM_TASK_BY_ID_QUERY = `
  * Uses APOC locking to prevent race conditions between parallel workers
  */
 const CLAIM_NEXT_TASK_QUERY = `
-  // Find available tasks not blocked by dependencies
+  // Find available or blocked tasks (blocked tasks may have deps completed now)
   MATCH (t:SwarmTask {projectId: $projectId, swarmId: $swarmId})
-  WHERE t.status = 'available'
+  WHERE t.status IN ['available', 'blocked']
     AND ($types IS NULL OR size($types) = 0 OR t.type IN $types)
     AND ($minPriority IS NULL OR t.priorityScore >= $minPriority)
 
@@ -86,7 +86,7 @@ const CLAIM_NEXT_TASK_QUERY = `
   CALL apoc.lock.nodes([t])
 
   // Double-check status after acquiring lock (another worker may have claimed it)
-  WITH t WHERE t.status = 'available'
+  WITH t WHERE t.status IN ['available', 'blocked']
 
   // Atomic claim
   SET t.status = 'claimed',

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

@@ -9,7 +9,7 @@ import { createErrorResponse, createSuccessResponse, resolveProjectIdOrError, de
 /**
  * Neo4j query to delete pheromones by swarm ID
  */
-const CLEANUP_BY_SWARM_QUERY = `
+const CLEANUP_PHEROMONES_BY_SWARM_QUERY = `
   MATCH (p:Pheromone)
   WHERE p.projectId = $projectId
     AND p.swarmId = $swarmId
@@ -18,6 +18,17 @@ const CLEANUP_BY_SWARM_QUERY = `
   DETACH DELETE p
   RETURN count(p) as deleted, collect(DISTINCT agentId) as agents, collect(DISTINCT type) as types
 `;
+/**
+ * Neo4j query to delete SwarmTask nodes by swarm ID
+ */
+const CLEANUP_TASKS_BY_SWARM_QUERY = `
+  MATCH (t:SwarmTask)
+  WHERE t.projectId = $projectId
+    AND t.swarmId = $swarmId
+  WITH t, t.status as status
+  DETACH DELETE t
+  RETURN count(t) as deleted, collect(DISTINCT status) as statuses
+`;
 /**
  * Neo4j query to delete pheromones by agent ID
  */
@@ -44,11 +55,16 @@ const CLEANUP_ALL_QUERY = `
 /**
  * Count queries for dry run
  */
-const COUNT_BY_SWARM_QUERY = `
+const COUNT_PHEROMONES_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_TASKS_BY_SWARM_QUERY = `
+  MATCH (t:SwarmTask)
+  WHERE t.projectId = $projectId AND t.swarmId = $swarmId
+  RETURN count(t) as count, collect(DISTINCT t.status) as statuses
+`;
 const COUNT_BY_AGENT_QUERY = `
   MATCH (p:Pheromone)
   WHERE p.projectId = $projectId AND p.agentId = $agentId AND NOT p.type IN $keepTypes
@@ -65,9 +81,14 @@ export const createSwarmCleanupTool = (server) => {
         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'),
+            swarmId: z.string().optional().describe('Delete all pheromones and tasks 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)'),
+            includeTasks: z
+                .boolean()
+                .optional()
+                .default(true)
+                .describe('Also delete SwarmTask nodes (default: true, only applies when swarmId is provided)'),
             keepTypes: z
                 .array(z.string())
                 .optional()
@@ -75,7 +96,7 @@ export const createSwarmCleanupTool = (server) => {
                 .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 }) => {
+    }, async ({ projectId, swarmId, agentId, all = false, includeTasks = true, keepTypes = ['warning'], dryRun = false }) => {
         const neo4jService = new Neo4jService();
         // Resolve project ID
         const projectResult = await resolveProjectIdOrError(projectId, neo4jService);
@@ -98,52 +119,83 @@ export const createSwarmCleanupTool = (server) => {
                 dryRun,
             });
             const params = { projectId: resolvedProjectId, keepTypes };
-            let deleteQuery;
-            let countQuery;
+            let pheromoneDeleteQuery;
+            let pheromoneCountQuery;
             let mode;
             if (swarmId) {
                 params.swarmId = swarmId;
-                deleteQuery = CLEANUP_BY_SWARM_QUERY;
-                countQuery = COUNT_BY_SWARM_QUERY;
+                pheromoneDeleteQuery = CLEANUP_PHEROMONES_BY_SWARM_QUERY;
+                pheromoneCountQuery = COUNT_PHEROMONES_BY_SWARM_QUERY;
                 mode = 'swarm';
             }
             else if (agentId) {
                 params.agentId = agentId;
-                deleteQuery = CLEANUP_BY_AGENT_QUERY;
-                countQuery = COUNT_BY_AGENT_QUERY;
+                pheromoneDeleteQuery = CLEANUP_BY_AGENT_QUERY;
+                pheromoneCountQuery = COUNT_BY_AGENT_QUERY;
                 mode = 'agent';
             }
             else {
-                deleteQuery = CLEANUP_ALL_QUERY;
-                countQuery = COUNT_ALL_QUERY;
+                pheromoneDeleteQuery = CLEANUP_ALL_QUERY;
+                pheromoneCountQuery = COUNT_ALL_QUERY;
                 mode = 'all';
             }
             if (dryRun) {
-                const result = await neo4jService.run(countQuery, params);
-                const count = result[0]?.count ?? 0;
+                const pheromoneResult = await neo4jService.run(pheromoneCountQuery, params);
+                const pheromoneCount = pheromoneResult[0]?.count ?? 0;
+                let taskCount = 0;
+                let taskStatuses = [];
+                if (swarmId && includeTasks) {
+                    const taskResult = await neo4jService.run(COUNT_TASKS_BY_SWARM_QUERY, params);
+                    taskCount = taskResult[0]?.count ?? 0;
+                    taskCount = typeof taskCount === 'object' && 'toNumber' in taskCount ? taskCount.toNumber() : taskCount;
+                    taskStatuses = taskResult[0]?.statuses ?? [];
+                }
                 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 ?? [],
+                    pheromones: {
+                        wouldDelete: typeof pheromoneCount === 'object' && 'toNumber' in pheromoneCount ? pheromoneCount.toNumber() : pheromoneCount,
+                        agents: pheromoneResult[0]?.agents ?? [],
+                        types: pheromoneResult[0]?.types ?? [],
+                    },
+                    tasks: swarmId && includeTasks ? {
+                        wouldDelete: taskCount,
+                        statuses: taskStatuses,
+                    } : null,
                     keepTypes,
                     projectId: resolvedProjectId,
                 }));
             }
-            const result = await neo4jService.run(deleteQuery, params);
-            const deleted = result[0]?.deleted ?? 0;
+            // Delete pheromones
+            const pheromoneResult = await neo4jService.run(pheromoneDeleteQuery, params);
+            const pheromonesDeleted = pheromoneResult[0]?.deleted ?? 0;
+            // Delete tasks if swarmId provided and includeTasks is true
+            let tasksDeleted = 0;
+            let taskStatuses = [];
+            if (swarmId && includeTasks) {
+                const taskResult = await neo4jService.run(CLEANUP_TASKS_BY_SWARM_QUERY, params);
+                tasksDeleted = taskResult[0]?.deleted ?? 0;
+                tasksDeleted = typeof tasksDeleted === 'object' && 'toNumber' in tasksDeleted ? tasksDeleted.toNumber() : tasksDeleted;
+                taskStatuses = taskResult[0]?.statuses ?? [];
+            }
             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 ?? [],
+                pheromones: {
+                    deleted: typeof pheromonesDeleted === 'object' && 'toNumber' in pheromonesDeleted ? pheromonesDeleted.toNumber() : pheromonesDeleted,
+                    agents: pheromoneResult[0]?.agents ?? [],
+                    types: pheromoneResult[0]?.types ?? [],
+                },
+                tasks: swarmId && includeTasks ? {
+                    deleted: tasksDeleted,
+                    statuses: taskStatuses,
+                } : null,
                 keepTypes,
                 projectId: resolvedProjectId,
+                message: swarmId && includeTasks
+                    ? `Cleaned up ${pheromonesDeleted} pheromones and ${tasksDeleted} tasks`
+                    : `Cleaned up ${pheromonesDeleted} pheromones`,
             }));
         }
         catch (error) {

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

@@ -352,33 +352,129 @@ export const createSwarmOrchestrateTool = (server) => {
  */
 function generateWorkerInstructions(swarmId, projectId, maxAgents, taskCount) {
     const recommendedAgents = Math.min(maxAgents, Math.ceil(taskCount / 2), taskCount);
-    return `
-## Worker Agent Instructions
+    // Generate unique agent IDs for each worker
+    const agentIds = Array.from({ length: recommendedAgents }, (_, i) => `${swarmId}_worker_${i + 1}`);
+    const workerPrompt = `You are a swarm worker agent.
+- Agent ID: {AGENT_ID}
+- Swarm ID: ${swarmId}
+- Project: ${projectId}
 
-To execute this swarm, spawn ${recommendedAgents} worker agent(s) using the Task tool:
+## CRITICAL RULES
+1. NEVER fabricate node IDs - get them from graph tool responses
+2. ALWAYS use the blackboard task queue (swarm_claim_task, swarm_complete_task)
+3. Use graph tools (traverse_from_node, search_codebase) to understand context
+4. Exit when swarm_claim_task returns "no_tasks"
 
-\`\`\`
-Task({
-  subagent_type: "general-purpose",
-  prompt: "You are a swarm worker for swarm ${swarmId}. Project: ${projectId}.
+## WORKFLOW - Follow these steps exactly:
 
-Your workflow:
-1. swarm_sense({ projectId: '${projectId}', swarmId: '${swarmId}', types: ['modifying', 'claiming'] })
-2. swarm_claim_task({ projectId: '${projectId}', swarmId: '${swarmId}', agentId: '<your-id>' })
-3. If task claimed: execute it, then swarm_complete_task with action: 'complete'
-4. Loop until no tasks remain
+### Step 1: Claim a task from the blackboard
+swarm_claim_task({
+  projectId: "${projectId}",
+  swarmId: "${swarmId}",
+  agentId: "{AGENT_ID}"
+})
+// If returns "no_tasks" → exit, swarm is complete
+// Otherwise you now own the returned task
 
-Always leave pheromones when working. Exit when swarm_get_tasks shows no available/in_progress tasks.",
-  run_in_background: true
+### Step 2: Start working and check for conflicts
+swarm_claim_task({
+  projectId: "${projectId}",
+  swarmId: "${swarmId}",
+  agentId: "{AGENT_ID}",
+  taskId: "<TASK_ID_FROM_STEP_1>",
+  action: "start"
 })
+
+// Check if another agent is working on related code
+swarm_sense({
+  projectId: "${projectId}",
+  swarmId: "${swarmId}",
+  types: ["modifying", "warning"],
+  excludeAgentId: "{AGENT_ID}"
+})
+
+### Step 3: Understand the code context (USE GRAPH TOOLS!)
+// Use traverse_from_node to see relationships and callers
+traverse_from_node({
+  projectId: "${projectId}",
+  filePath: "<TARGET_FILE_FROM_TASK>",
+  maxDepth: 2,
+  includeCode: true
+})
+
+// Or search for related code
+search_codebase({
+  projectId: "${projectId}",
+  query: "<WHAT_YOU_NEED_TO_UNDERSTAND>"
+})
+
+### Step 4: Do the work
+- Use Read tool for full source code of files to modify
+- Use Edit tool to make changes
+- Mark nodes you're modifying:
+swarm_pheromone({
+  projectId: "${projectId}",
+  nodeId: "<NODE_ID_FROM_GRAPH>",
+  type: "modifying",
+  agentId: "{AGENT_ID}",
+  swarmId: "${swarmId}"
+})
+
+### Step 5: Complete the task via blackboard
+swarm_pheromone({
+  projectId: "${projectId}",
+  nodeId: "<NODE_ID>",
+  type: "completed",
+  agentId: "{AGENT_ID}",
+  swarmId: "${swarmId}",
+  data: { summary: "<WHAT_YOU_DID>" }
+})
+
+swarm_complete_task({
+  projectId: "${projectId}",
+  taskId: "<TASK_ID>",
+  agentId: "{AGENT_ID}",
+  action: "complete",
+  summary: "<DESCRIBE_WHAT_YOU_DID>",
+  filesChanged: ["<LIST_OF_FILES_YOU_MODIFIED>"]
+})
+
+### Step 6: Loop back to Step 1
+Claim the next available task. Continue until no tasks remain.
+
+## IF YOU GET STUCK
+swarm_complete_task({
+  projectId: "${projectId}",
+  taskId: "<TASK_ID>",
+  agentId: "{AGENT_ID}",
+  action: "fail",
+  reason: "<WHY_YOU_ARE_STUCK>",
+  retryable: true
+})
+Then claim another task.`;
+    const taskCalls = agentIds.map(agentId => {
+        const prompt = workerPrompt.replace(/\{AGENT_ID\}/g, agentId);
+        return `Task({
+  subagent_type: "general-purpose",
+  run_in_background: false,
+  prompt: \`${prompt}\`
+})`;
+    }).join('\n\n');
+    return `
+## Worker Agent Instructions
+
+Spawn ${recommendedAgents} worker agent(s) IN PARALLEL (all Task calls in ONE message):
+
+\`\`\`javascript
+${taskCalls}
 \`\`\`
 
-Launch ${recommendedAgents} agents in parallel for optimal execution.
+**CRITICAL:** Include ALL ${recommendedAgents} Task calls in a single message to run them in parallel.
 
 ## Monitoring Progress
 
 Check swarm progress:
-\`\`\`
+\`\`\`javascript
 swarm_get_tasks({
   projectId: "${projectId}",
   swarmId: "${swarmId}",
@@ -386,9 +482,9 @@ swarm_get_tasks({
 })
 \`\`\`
 
-## Cleanup (after completion)
+## Cleanup (after all workers complete)
 
-\`\`\`
+\`\`\`javascript
 swarm_cleanup({
   projectId: "${projectId}",
   swarmId: "${swarmId}"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "code-graph-context",
-  "version": "2.5.2",
+  "version": "2.5.4",
   "description": "MCP server that builds code graphs to provide rich context to LLMs",
   "type": "module",
   "homepage": "https://github.com/drewdrewH/code-graph-context#readme",