wolfpack-mcp 1.0.97 → 1.0.98

package/dist/client.js

@@ -240,6 +240,13 @@ export class WolfpackClient {
             throw error;
         }
     }
+    // Dependency methods (#2331)
+    async setWorkItemDependencies(workItemId, dependsOnRefIds, teamSlug) {
+        return this.api.put(this.withTeamSlug(`/work-items/${workItemId}/dependencies`, teamSlug), { dependsOnRefIds });
+    }
+    async getWorkItemDependencyGraph(workItemId, teamSlug) {
+        return this.api.get(this.withTeamSlug(`/work-items/${workItemId}/dependency-graph`, teamSlug));
+    }
     // Review check methods
     async listWorkItemChecks(filter, teamSlug) {
         const params = new URLSearchParams();

package/dist/index.js

@@ -216,6 +216,29 @@ const SubmitWorkItemFormSchema = z.object({
         .optional()
         .describe('Project slug (required for multi-project users, use list_projects to get slugs)'),
 });
+// #2331 — reference numbers, accepted as numbers or as "#2322" the way agents
+// write them, so an ordered plan can be transcribed without reformatting.
+const dependsOnRefIds = () => z
+    .array(z.union([z.number(), z.string()]))
+    .transform((refs) => refs.map((ref) => Number(String(ref).replace(/^#/, ''))))
+    .refine((refs) => refs.every(Number.isInteger), {
+    message: 'depends_on must be work item reference numbers, e.g. [2322] or ["#2322"]',
+});
+const SetWorkItemDependenciesSchema = z.object({
+    work_item_id: refIdString().describe('The refId of the work item that follows the others'),
+    depends_on: dependsOnRefIds().describe('Reference numbers of the prerequisites. Replaces the whole set; pass [] to clear.'),
+    project_slug: z
+        .string()
+        .optional()
+        .describe('Project slug (required for multi-project users, use list_projects to get slugs)'),
+});
+const GetWorkItemDependencyGraphSchema = z.object({
+    work_item_id: refIdString().describe('The refId of the work item'),
+    project_slug: z
+        .string()
+        .optional()
+        .describe('Project slug (required for multi-project users, use list_projects to get slugs)'),
+});
 const WorkPoolMemberSchema = z.object({
     work_pool: z.string().describe('Work pool id or name'),
     user_id: z.string().describe('The user id to add or remove'),
@@ -369,6 +392,9 @@ const CreateWorkItemSchema = z.object({
         .string()
         .optional()
         .describe('Link to a radar/initiative item. Accepts refId ("5" or "#r5") or UUID.'),
+    depends_on: dependsOnRefIds()
+        .optional()
+        .describe('Reference numbers of work items that must finish before this one starts'),
 });
 const CreateIssueSchema = z.object({
     project_slug: z
@@ -1269,6 +1295,56 @@ class WolfpackMCPServer {
                             required: ['work_item_id', 'check_id', 'status'],
                         },
                     },
+                    {
+                        name: 'set_work_item_dependencies',
+                        description: 'Record which work items must finish before this one can start, so the board knows the order ' +
+                            'and the pickup gate enforces it. Use this when you file or plan a set of ordered items, instead ' +
+                            'of writing "Follows #2322" into a description — a description is prose nothing enforces. ' +
+                            'A bare #N is a WORK ITEM refId, and depends_on takes those reference numbers. ' +
+                            'REPLACES the whole set: pass every prerequisite you want the item to have, and [] to clear it. ' +
+                            'An item may not depend on itself, nor on anything that already depends on it — either would leave ' +
+                            'it permanently blocked, and both are refused with 400 naming the item. ' +
+                            'Requires the mcp:work_items:manage_dependencies permission, which is separate from ' +
+                            "mcp:work_items:update: updating your own item does not let you order other people's work. " +
+                            'Returns what the item now depends on, what follows it, and which prerequisites are still unfinished.',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                work_item_id: {
+                                    type: 'string',
+                                    description: 'The refId of the work item that follows the others',
+                                },
+                                depends_on: {
+                                    type: 'array',
+                                    items: { type: ['number', 'string'] },
+                                    description: 'Reference numbers of the prerequisites, as 2322 or "#2322". Replaces the whole set; pass [] to clear.',
+                                },
+                                project_slug: {
+                                    type: 'string',
+                                    description: 'Project slug (required for multi-project users, use list_projects to get slugs)',
+                                },
+                            },
+                            required: ['work_item_id', 'depends_on'],
+                        },
+                    },
+                    {
+                        name: 'get_work_item_dependency_graph',
+                        description: 'The whole chain of ordered work around one work item — the prerequisites above it and the work ' +
+                            'that follows below — as nodes and edges, each item appearing exactly once. An edge runs from the ' +
+                            "item that must finish to the item that waits on it. Use it to see a plan's shape; " +
+                            "get_work_item already gives one item's own dependsOn, nextItems and blockedBy.",
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                work_item_id: { type: 'string', description: 'The refId of the work item' },
+                                project_slug: {
+                                    type: 'string',
+                                    description: 'Project slug (required for multi-project users, use list_projects to get slugs)',
+                                },
+                            },
+                            required: ['work_item_id'],
+                        },
+                    },
                     // Radar Item (Initiative/Roadmap) tools
                     {
                         name: 'list_radar_items',
@@ -1459,6 +1535,9 @@ class WolfpackMCPServer {
                         name: 'create_work_item',
                         description: 'Create a new work item in your current project (auto-selected for single-project users, or use list_projects first for multi-project). Requires mcp:work_items:create permission. ' +
                             'Agents: work you file lands unassigned in the backlog, whatever status you ask for, and waits there for the Delivery Lead to approve and assign it. ' +
+                            'ORDERED WORK: when you file a set of items that must happen in order, give each one depends_on ' +
+                            'naming the reference numbers it follows, rather than writing "Follows #2322" into the description — ' +
+                            'that way the board knows the order and the pickup gate enforces it. ' +
                             CONTENT_LINKING_HELP,
                         inputSchema: {
                             type: 'object',
@@ -1508,6 +1587,11 @@ class WolfpackMCPServer {
                                     type: 'string',
                                     description: 'Link to a radar/initiative item. Accepts refId (e.g. "5" or "#r5") or UUID.',
                                 },
+                                depends_on: {
+                                    type: 'array',
+                                    items: { type: ['number', 'string'] },
+                                    description: 'Reference numbers of work items that must finish before this one starts, as 2322 or "#2322". Filing an ordered set one call each needs mcp:work_items:manage_dependencies.',
+                                },
                             },
                             required: ['title'],
                         },
@@ -2787,6 +2871,48 @@ class WolfpackMCPServer {
                             ],
                         };
                     }
+                    case 'set_work_item_dependencies': {
+                        const parsed = SetWorkItemDependenciesSchema.parse(args);
+                        const teamSlug = parsed.project_slug || this.client.getProjectSlug() || undefined;
+                        const dependencies = await this.client.setWorkItemDependencies(parsed.work_item_id, parsed.depends_on, teamSlug);
+                        const name = (items) => items.map((item) => `#${item.refId} "${item.title}"`).join(', ');
+                        const summary = dependencies.dependsOn.length === 0
+                            ? `#${parsed.work_item_id} now depends on nothing`
+                            : `#${parsed.work_item_id} now depends on ${name(dependencies.dependsOn)}` +
+                                (dependencies.blockedBy.length > 0
+                                    ? `, and cannot start until ${name(dependencies.blockedBy)} finishes`
+                                    : ', all of which have finished');
+                        return {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: `${summary}\n\n${JSON.stringify(stripUuids(dependencies), null, 2)}`,
+                                },
+                            ],
+                        };
+                    }
+                    case 'get_work_item_dependency_graph': {
+                        const parsed = GetWorkItemDependencyGraphSchema.parse(args);
+                        const teamSlug = parsed.project_slug || this.client.getProjectSlug() || undefined;
+                        const graph = await this.client.getWorkItemDependencyGraph(parsed.work_item_id, teamSlug);
+                        // Edges name nodes by UUID, which agents never see, so they are
+                        // rewritten as reference numbers before the UUIDs are stripped —
+                        // dropping them would leave a list of items and no order at all
+                        const byId = new Map(graph.nodes.map((node) => [node.id, node.refId]));
+                        return {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: JSON.stringify({
+                                        root: `#${byId.get(graph.rootId)}`,
+                                        items: stripUuids(graph.nodes),
+                                        // Each entry reads "A must finish before B can start"
+                                        mustFinishBefore: graph.edges.map((edge) => `#${byId.get(edge.from)} → #${byId.get(edge.to)}`),
+                                    }, null, 2),
+                                },
+                            ],
+                        };
+                    }
                     // Radar Item handlers
                     case 'list_radar_items': {
                         const parsed = ListRadarItemsSchema.parse(args);
@@ -2906,6 +3032,7 @@ class WolfpackMCPServer {
                             leadingUserId: parsed.leading_user_id,
                             categoryId: parsed.category_id,
                             radarItemId,
+                            dependsOnRefIds: parsed.depends_on,
                             teamSlug,
                         });
                         return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wolfpack-mcp",
-  "version": "1.0.97",
+  "version": "1.0.98",
   "description": "MCP server for Wolfpack AI-enhanced software delivery tools",
   "main": "dist/index.js",
   "type": "module",