code-graph-context 2.14.1 → 3.0.0

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

@@ -80,31 +80,13 @@ export const createSwarmPheromoneTool = (server) => {
                 .string()
                 .optional()
                 .describe('File path to mark (alternative to nodeId — auto-resolves to SourceFile node)'),
-            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), session_context (session working set)'),
-            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")'),
-            sessionId: z
-                .string()
-                .optional()
-                .describe('Session identifier for cross-session recovery (e.g., conversation ID)'),
-            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'),
+            type: z.enum(PHEROMONE_TYPES).describe('Pheromone type'),
+            intensity: z.number().min(0).max(1).optional().default(1.0).describe('Pheromone intensity'),
+            agentId: z.string().describe('Agent leaving the pheromone'),
+            swarmId: z.string().describe('Swarm ID for grouping related agents'),
+            sessionId: z.string().optional().describe('Session identifier for cross-session recovery'),
+            data: z.record(z.unknown()).optional().describe('Metadata to attach to the pheromone'),
+            remove: z.boolean().optional().default(false).describe('Remove instead of create/update'),
         },
     }, async ({ projectId, nodeId, filePath, type, intensity = 1.0, agentId, swarmId, sessionId, data, remove = false, }) => {
         const neo4jService = new Neo4jService();

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

@@ -109,33 +109,21 @@ export const createSwarmPostTaskTool = (server) => {
             swarmId: z.string().describe('Swarm ID for grouping related tasks'),
             title: z.string().min(1).max(200).describe('Short title for the task'),
             description: z.string().describe('Detailed description of what needs to be done'),
-            type: z
-                .enum(TASK_TYPES)
-                .optional()
-                .default('implement')
-                .describe('Task type: implement, refactor, fix, test, review, document, investigate, plan'),
+            type: z.enum(TASK_TYPES).optional().default('implement').describe('Task type'),
             priority: z
                 .enum(Object.keys(TASK_PRIORITIES))
                 .optional()
                 .default('normal')
-                .describe('Priority level: critical, high, normal, low, backlog'),
-            targetNodeIds: z
-                .array(z.string())
-                .optional()
-                .default([])
-                .describe('Code node IDs this task targets (from search_codebase)'),
-            targetFilePaths: z
-                .array(z.string())
-                .optional()
-                .default([])
-                .describe('File paths this task affects (alternative to nodeIds)'),
+                .describe('Task priority'),
+            targetNodeIds: z.array(z.string()).optional().default([]).describe('Code node IDs this task targets'),
+            targetFilePaths: z.array(z.string()).optional().default([]).describe('File paths this task affects'),
             dependencies: z
                 .array(z.string())
                 .optional()
                 .default([])
-                .describe('Task IDs that must be completed before this task can start'),
-            createdBy: z.string().describe('Agent ID or identifier of who created this task'),
-            metadata: z.record(z.unknown()).optional().describe('Additional metadata (context, acceptance criteria, etc.)'),
+                .describe('Task IDs that must complete before this task starts'),
+            createdBy: z.string().describe('Agent ID creating this task'),
+            metadata: z.record(z.unknown()).optional().describe('Additional metadata'),
         },
     }, async ({ projectId, swarmId, title, description, type = 'implement', priority = 'normal', targetNodeIds = [], targetFilePaths = [], dependencies = [], createdBy, metadata, }) => {
         const neo4jService = new Neo4jService();

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

@@ -0,0 +1,53 @@
+import { z } from 'zod';
+import { Neo4jService } from '../../storage/neo4j/neo4j.service.js';
+import { TOOL_NAMES, TOOL_METADATA } from '../constants.js';
+import { SwarmReleaseHandler, SwarmAbandonHandler } from '../handlers/swarm/index.js';
+import { createErrorResponse, createSuccessResponse, resolveProjectIdOrError, debugLog } from '../utils.js';
+export const createSwarmReleaseTaskTool = (server) => {
+    server.registerTool(TOOL_NAMES.swarmReleaseTask, {
+        title: TOOL_METADATA[TOOL_NAMES.swarmReleaseTask].title,
+        description: TOOL_METADATA[TOOL_NAMES.swarmReleaseTask].description,
+        inputSchema: {
+            projectId: z.string().describe('Project ID, name, or path'),
+            taskId: z.string().describe('Task ID to release'),
+            agentId: z.string().describe('Your agent identifier'),
+            reason: z.string().optional().describe('Reason for releasing or abandoning'),
+            trackAbandonment: z.boolean().optional().default(false).describe('Track as abandonment for retry metrics'),
+        },
+    }, async ({ projectId, taskId, agentId, reason, trackAbandonment = false }) => {
+        const neo4jService = new Neo4jService();
+        const projectResult = await resolveProjectIdOrError(projectId, neo4jService);
+        if (!projectResult.success) {
+            await neo4jService.close();
+            return projectResult.error;
+        }
+        const resolvedProjectId = projectResult.projectId;
+        try {
+            if (trackAbandonment) {
+                const { error, data } = await new SwarmAbandonHandler(neo4jService).abandon(resolvedProjectId, taskId, agentId, reason);
+                if (error) {
+                    return createErrorResponse(`Cannot abandon task ${taskId}. ` +
+                        (data ? `Current state: ${data.status}, claimedBy: ${data.claimedBy || 'none'}` : 'Task not found.'));
+                }
+                return createSuccessResponse(JSON.stringify({ action: 'abandoned', taskId: data.id, abandonCount: data.abandonCount }));
+            }
+            const { error, data } = await new SwarmReleaseHandler(neo4jService).release(resolvedProjectId, taskId, agentId, reason);
+            if (error) {
+                return createErrorResponse(`Cannot release task ${taskId}. ` +
+                    (data ? `Current state: ${data.status}, claimedBy: ${data.claimedBy || 'none'}` : 'Task not found.'));
+            }
+            return createSuccessResponse(JSON.stringify({
+                action: 'released',
+                taskId: data.id,
+                ...(data.abandonCount != null && { abandonCount: data.abandonCount }),
+            }));
+        }
+        catch (error) {
+            await debugLog('Swarm release task error', { error: String(error) });
+            return createErrorResponse(error instanceof Error ? error : String(error));
+        }
+        finally {
+            await neo4jService.close();
+        }
+    });
+};

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

@@ -99,46 +99,26 @@ export const createSwarmSenseTool = (server) => {
             types: z
                 .array(z.enum(PHEROMONE_TYPES))
                 .optional()
-                .describe('Filter by pheromone types. If empty, returns all types. Options: exploring, modifying, claiming, completed, warning, blocked, proposal, needs_review'),
-            nodeIds: z.array(z.string()).optional().describe('Filter by specific node IDs. If empty, searches all nodes.'),
-            filePaths: z
-                .array(z.string())
-                .optional()
-                .describe('Filter by file paths (resolves to SourceFile nodeIds). Also matches pheromones placed via filePath.'),
-            agentIds: z
-                .array(z.string())
-                .optional()
-                .describe('Filter by specific agent IDs. If empty, returns pheromones from all agents.'),
-            swarmId: z.string().optional().describe('Filter by swarm ID. If empty, returns pheromones from all swarms.'),
+                .describe('Filter by pheromone types'),
+            nodeIds: z.array(z.string()).optional().describe('Filter by specific node IDs'),
+            filePaths: z.array(z.string()).optional().describe('Filter by file paths (resolves to SourceFile nodeIds)'),
+            agentIds: z.array(z.string()).optional().describe('Filter by specific agent IDs'),
+            swarmId: z.string().optional().describe('Filter by swarm ID'),
             excludeAgentId: z
                 .string()
                 .optional()
-                .describe('Exclude pheromones from this agent ID (useful for seeing what OTHER agents are doing)'),
-            sessionId: z
-                .string()
-                .optional()
-                .describe('Filter pheromones by session ID. Use to recover context after compaction or session restart.'),
+                .describe('Exclude pheromones from this agent (see what others are doing)'),
+            sessionId: z.string().optional().describe('Filter by session ID for context recovery'),
             minIntensity: z
                 .number()
                 .min(0)
                 .max(1)
                 .optional()
                 .default(0.3)
-                .describe('Minimum effective intensity after decay (0.0-1.0, default: 0.3)'),
-            limit: z
-                .number()
-                .int()
-                .min(1)
-                .max(500)
-                .optional()
-                .default(50)
-                .describe('Maximum number of pheromones to return (default: 50, max: 500)'),
+                .describe('Minimum effective intensity after decay'),
+            limit: z.number().int().min(1).max(500).optional().default(50).describe('Maximum pheromones to return'),
             includeStats: z.boolean().optional().default(false).describe('Include summary statistics by pheromone type'),
-            cleanup: z
-                .boolean()
-                .optional()
-                .default(false)
-                .describe('Run cleanup of fully decayed pheromones (intensity < 0.01)'),
+            cleanup: z.boolean().optional().default(false).describe('Remove fully decayed pheromones'),
         },
     }, async ({ projectId, types, nodeIds, filePaths, agentIds, swarmId, excludeAgentId, sessionId, minIntensity = 0.3, limit = 50, includeStats = false, cleanup = false, }) => {
         const neo4jService = new Neo4jService();

package/dist/mcp/tools/traverse-from-node.tool.js

@@ -26,20 +26,9 @@ export const createTraverseFromNodeTool = (server) => {
                 .number()
                 .int()
                 .optional()
-                .describe(`Maximum depth to traverse (default: ${DEFAULTS.traversalDepth}, max: ${MAX_TRAVERSAL_DEPTH})`)
+                .describe('Maximum relationship traversal depth')
                 .default(DEFAULTS.traversalDepth),
-            skip: z
-                .number()
-                .int()
-                .optional()
-                .describe(`Number of results to skip for pagination (default: ${DEFAULTS.skipOffset})`)
-                .default(DEFAULTS.skipOffset),
-            limit: z
-                .number()
-                .int()
-                .optional()
-                .describe('Maximum results per page (default: 50). Use with skip for pagination.')
-                .default(50),
+            skip: z.number().int().optional().describe('Results to skip for pagination').default(DEFAULTS.skipOffset),
             direction: z
                 .enum(['OUTGOING', 'INCOMING', 'BOTH'])
                 .optional()
@@ -49,36 +38,25 @@ export const createTraverseFromNodeTool = (server) => {
                 .array(z.string())
                 .optional()
                 .describe('Filter by specific relationship types (e.g., ["INJECTS", "USES_REPOSITORY"]). If not specified, shows all relationships.'),
-            includeCode: z
-                .boolean()
-                .optional()
-                .describe('Include source code snippets in results (default: true, set to false for structure-only view)')
-                .default(true),
-            maxNodesPerChain: z
-                .number()
-                .int()
-                .optional()
-                .describe('Maximum chains to show per depth level (default: 5, applied independently at each depth)')
-                .default(5),
-            summaryOnly: z
-                .boolean()
-                .optional()
-                .describe('Return only summary with file paths and statistics (default: false)')
-                .default(false),
-            snippetLength: z
-                .number()
-                .int()
-                .optional()
-                .describe(`Code snippet character length when includeCode is true (default: ${DEFAULTS.codeSnippetLength})`)
-                .default(DEFAULTS.codeSnippetLength),
-            maxTotalNodes: z
-                .number()
-                .int()
+            displayOptions: z
+                .object({
+                includeCode: z.boolean().optional().default(true).describe('Include source code snippets'),
+                snippetLength: z
+                    .number()
+                    .int()
+                    .optional()
+                    .default(DEFAULTS.codeSnippetLength)
+                    .describe('Code snippet character limit'),
+                summaryOnly: z.boolean().optional().default(false).describe('Return only file paths and statistics'),
+                maxNodesPerChain: z.number().int().optional().default(5).describe('Maximum chains per depth level'),
+                maxTotalNodes: z.number().int().optional().default(50).describe('Maximum unique nodes across all depths'),
+                limit: z.number().int().optional().default(50).describe('Maximum results per page'),
+            })
                 .optional()
-                .describe('Maximum total unique nodes to return across all depths (default: 50). Limits output size.')
-                .default(50),
+                .describe('Output formatting options (all have sensible defaults)'),
         },
-    }, async ({ projectId, nodeId, filePath, maxDepth = DEFAULTS.traversalDepth, skip = DEFAULTS.skipOffset, limit = 50, direction = 'BOTH', relationshipTypes, includeCode = true, maxNodesPerChain = 5, summaryOnly = false, snippetLength = DEFAULTS.codeSnippetLength, maxTotalNodes = 50, }) => {
+    }, async ({ projectId, nodeId, filePath, maxDepth = DEFAULTS.traversalDepth, skip = DEFAULTS.skipOffset, direction = 'BOTH', relationshipTypes, displayOptions, }) => {
+        const { includeCode = true, snippetLength = DEFAULTS.codeSnippetLength, summaryOnly = false, maxNodesPerChain = 5, maxTotalNodes = 50, limit = 50, } = displayOptions ?? {};
         // Validate that either nodeId or filePath is provided
         if (!nodeId && !filePath) {
             return createErrorResponse('Either nodeId or filePath must be provided.');

package/dist/mcp/utils.js

@@ -2,7 +2,7 @@
  * MCP Server Utility Functions
  * Common utility functions used across the MCP server
  */
-import { resolveProjectIdFromInput } from '../core/utils/project-id.js';
+import { resolveProjectIdFromInput, LIST_PROJECTS_QUERY } from '../core/utils/project-id.js';
 import { MESSAGES } from './constants.js';
 export { debugLog } from '../core/utils/file-utils.js';
 /**
@@ -19,6 +19,39 @@ export const resolveProjectIdOrError = async (projectId, neo4jService) => {
         return { success: false, error: createErrorResponse(message) };
     }
 };
+/**
+ * Auto-resolve projectId when omitted. If only one project exists, use it.
+ * If multiple exist, return error listing them. If none, return error.
+ */
+export const autoResolveProjectId = async (projectId, neo4jService) => {
+    // If projectId provided, use normal resolution
+    if (projectId) {
+        return resolveProjectIdOrError(projectId, neo4jService);
+    }
+    // Auto-resolve: query all projects
+    try {
+        const projects = await neo4jService.run(LIST_PROJECTS_QUERY, {});
+        if (projects.length === 0) {
+            return {
+                success: false,
+                error: createErrorResponse('No projects found. Use parse_typescript_project to add a project first.'),
+            };
+        }
+        if (projects.length === 1) {
+            return { success: true, projectId: projects[0].projectId };
+        }
+        // Multiple projects — can't auto-resolve
+        const projectList = projects.map((p) => `  - ${p.name || p.projectId} (${p.projectId})`).join('\n');
+        return {
+            success: false,
+            error: createErrorResponse(`Multiple projects found. Specify projectId:\n${projectList}`),
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { success: false, error: createErrorResponse(message) };
+    }
+};
 /**
  * Standard error response format for MCP tools
  */
@@ -46,6 +79,13 @@ export const createSuccessResponse = (text) => {
         ],
     };
 };
+/**
+ * Standard "no results" response for MCP tools.
+ * Use instead of createSuccessResponse for empty result sets.
+ */
+export const createEmptyResponse = (message, suggestion) => {
+    return createSuccessResponse(JSON.stringify({ status: 'empty', message, ...(suggestion && { suggestion }) }));
+};
 /**
  * Truncate code to specified max length, showing first and last portions
  */

package/package.json

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