wolfpack-mcp 1.0.84 → 1.0.86

package/dist/client.js

@@ -891,6 +891,22 @@ export class WolfpackClient {
         const { teamSlug, ...body } = data;
         return this.api.post(this.withTeamSlug(`/procedures/${procedureId}/start`, teamSlug), body);
     }
+    async listCases(options) {
+        const params = new URLSearchParams();
+        if (options?.teamSlug)
+            params.append('teamSlug', options.teamSlug);
+        if (options?.procedureId)
+            params.append('procedureId', options.procedureId);
+        if (options?.status)
+            params.append('status', options.status);
+        return this.fetchAllPages('/cases', params);
+    }
+    async upgradeCase(caseId, teamSlug, resumeNodeId) {
+        return this.api.post(this.withTeamSlug(`/cases/${caseId}/upgrade`, teamSlug), resumeNodeId ? { resumeNodeId } : {});
+    }
+    async upgradeProcedureCases(procedureId, teamSlug) {
+        return this.api.post(this.withTeamSlug(`/procedures/${procedureId}/upgrade-cases`, teamSlug), {});
+    }
     // ─── Agent Self-Introspection ──────────────────────────────────────────────
     async getSelf() {
         return this.api.get('/self');

package/dist/index.js

@@ -13,6 +13,7 @@ import { AGENT_BUILDER_TOOLS, handleAgentBuilderTool } from './agentBuilderTools
 import { PROCEDURE_TOOLS, handleProcedureTool } from './procedureTools.js';
 import { AGENT_SELF_TOOLS, AGENT_MEMORY_TOOLS, handleAgentSelfTool } from './agentSelfTools.js';
 import { resolveRadarItemId } from './resolveRadarItemId.js';
+import { SERVER_INSTRUCTIONS } from './serverInstructions.js';
 import { fetch as proxyFetch } from './proxyFetch.js';
 // Get current package version
 const require = createRequire(import.meta.url);
@@ -717,6 +718,7 @@ class WolfpackMCPServer {
                 tools: { listChanged: true },
                 logging: {},
             },
+            instructions: SERVER_INSTRUCTIONS,
         });
         this.setupHandlers();
     }
@@ -744,7 +746,7 @@ class WolfpackMCPServer {
                             'Other document types REQUIRE a prefix and are never bare numbers: ' +
                             '#i1 or #issue-1 for issues, #r1 or #roadmap-1 for roadmap/radar, ' +
                             '#j1 or #journal-1 for journal, #c1 or #case-1 for cases, #p1 or #proc-1 for procedures. ' +
-                            'Wiki pages are referenced by path (e.g. /docs/setup). There is no ambiguity: bare #N = work item.',
+                            'Wiki pages are referenced by path (e.g. /docs/setup). There is no ambiguity: bare #N = work item, and never a GitHub issue or pull request — read a number as a GitHub reference only when the user says GitHub, PR, or gh.',
                         inputSchema: {
                             type: 'object',
                             properties: {},
@@ -861,7 +863,7 @@ class WolfpackMCPServer {
                     },
                     {
                         name: 'get_work_item',
-                        description: 'Get a specific work item/task by reference number. This is the DEFAULT lookup when a user says "#1" or "work on #42" — bare #N always means a work item. ' +
+                        description: 'Get a specific work item/task by reference number. This is the DEFAULT lookup when a user says "#1" or "work on #42" — bare #N always means a work item, never a GitHub issue: use this tool, not `gh issue view`. ' +
                             'Returns full details including description (markdown notes). ' +
                             'Call this before updating to see current content. ' +
                             'WORKFLOW: When asked to work on an item, check its status and follow the required state transitions ' +

package/dist/procedureTools.js

@@ -195,6 +195,79 @@ export const PROCEDURE_TOOLS = [
             required: ['procedure_id'],
         },
     },
+    {
+        name: 'list_cases',
+        description: 'List cases, newest first, optionally filtered to one procedure and/or one status ' +
+            '(running, paused, completed, failed, cancelled). Each case shows the procedure version it ' +
+            'runs and `behind: true` when the procedure has since been edited — a running case that is ' +
+            'behind can be moved on with upgrade_case.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                procedure_id: {
+                    type: 'string',
+                    description: 'Only cases of this procedure (UUID or refId number)',
+                },
+                status: {
+                    type: 'string',
+                    description: 'Only cases in this status, e.g. "running"',
+                },
+                project_slug: {
+                    type: 'string',
+                    description: 'Project slug (required when using a refId, or with access to several projects)',
+                },
+            },
+        },
+    },
+    {
+        name: 'upgrade_case',
+        description: 'Move a running (or paused) case onto the latest version of its procedure. The case resumes ' +
+            'at the node it is waiting at, keeping its variables and earlier activity outputs; nothing ' +
+            'before that node runs again. Refused — with the reason — when the case is not running, is ' +
+            'already on the current version, or its current node id is not in the new version — then pass ' +
+            'resume_node_id to choose the node of the new version it should continue from (see ' +
+            'get_procedure for the node ids), or cancel the case and start the procedure again from the ' +
+            'work item.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                case_id: {
+                    type: 'string',
+                    description: 'Case UUID or refId number',
+                },
+                resume_node_id: {
+                    type: 'string',
+                    description: 'Node id of the new version to resume at. Defaults to the node the case is waiting at; ' +
+                        'required when that node no longer exists in the new version.',
+                },
+                project_slug: {
+                    type: 'string',
+                    description: 'Project slug (required when using refId)',
+                },
+            },
+            required: ['case_id'],
+        },
+    },
+    {
+        name: 'upgrade_procedure_cases',
+        description: 'Upgrade every running case of a procedure that is still on an older version onto the ' +
+            'current one (see upgrade_case). Cases are upgraded one at a time; the result lists the cases ' +
+            'upgraded and, for each case skipped, why.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                procedure_id: {
+                    type: 'string',
+                    description: 'Procedure UUID or refId number',
+                },
+                project_slug: {
+                    type: 'string',
+                    description: 'Project slug (required when using refId)',
+                },
+            },
+            required: ['procedure_id'],
+        },
+    },
 ];
 export async function handleProcedureTool(name, args, client) {
     const text = (t) => JSON.stringify(t, null, 2);
@@ -315,6 +388,55 @@ export async function handleProcedureTool(name, args, client) {
                 ],
             };
         }
+        case 'list_cases': {
+            const parsed = z
+                .object({
+                procedure_id: z.string().optional(),
+                status: z.string().optional(),
+                project_slug: z.string().optional(),
+            })
+                .parse(args);
+            const result = await client.listCases({
+                procedureId: parsed.procedure_id,
+                status: parsed.status,
+                teamSlug: parsed.project_slug,
+            });
+            return { content: [{ type: 'text', text: text(result) }] };
+        }
+        case 'upgrade_case': {
+            const parsed = z
+                .object({
+                case_id: z.string(),
+                resume_node_id: z.string().optional(),
+                project_slug: z.string().optional(),
+            })
+                .parse(args);
+            const result = await client.upgradeCase(parsed.case_id, parsed.project_slug, parsed.resume_node_id);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Upgraded case #${result.caseRefId} from v${result.fromVersion} to v${result.toVersion}; ` +
+                            `it resumes at "${result.resumeNodeLabel}" (${result.resumeNodeId})\n\n${text(result)}`,
+                    },
+                ],
+            };
+        }
+        case 'upgrade_procedure_cases': {
+            const parsed = z
+                .object({ procedure_id: z.string(), project_slug: z.string().optional() })
+                .parse(args);
+            const result = await client.upgradeProcedureCases(parsed.procedure_id, parsed.project_slug);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Upgraded ${result.upgraded.length} case(s), skipped ${result.skipped.length}\n\n` +
+                            text(result),
+                    },
+                ],
+            };
+        }
         default:
             return {
                 content: [{ type: 'text', text: `Unknown procedure tool: ${name}` }],

package/dist/serverInitialize.test.js

@@ -0,0 +1,42 @@
+import { describe, it, expect } from 'vitest';
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { fileURLToPath } from 'url';
+import { SERVER_INSTRUCTIONS } from './serverInstructions.js';
+const entryPoint = fileURLToPath(new URL('./index.ts', import.meta.url));
+// The constant existing is not the fix — a client only sees it if the server
+// hands it back in the `initialize` result (#1373). index.ts starts the server
+// at import, so this drives the real thing over stdio instead.
+//
+// The handshake completes before any tool call, so nothing here needs a live
+// backend: the key only has to look like one for validateConfig to let the
+// process start, and the API URL is pointed at a closed port so the server's
+// background capabilities fetch fails immediately rather than calling out to
+// whatever WOLFPACK_API_URL the developer's own environment is set to.
+const SERVER_ENV = {
+    ...process.env,
+    WOLFPACK_API_KEY: 'wfp_sk_test',
+    WOLFPACK_API_URL: 'http://127.0.0.1:1',
+    WOLFPACK_PROJECT_SLUG: '',
+    WOLFPACK_TEAM_SLUG: '',
+    WOLFPACK_ORG_SLUG: '',
+};
+describe('the stdio server initialize', () => {
+    it('advertises the reference-convention instructions to the client', async () => {
+        const client = new Client({ name: 'test', version: '1.0.0' });
+        const transport = new StdioClientTransport({
+            // tsx directly, not via npx: the transport kills the process it spawned,
+            // and an npx wrapper would leave the server orphaned behind it.
+            command: process.execPath,
+            args: ['--import', 'tsx', entryPoint],
+            env: SERVER_ENV,
+        });
+        await client.connect(transport);
+        try {
+            expect(client.getInstructions()).toBe(SERVER_INSTRUCTIONS);
+        }
+        finally {
+            await client.close();
+        }
+    }, 60_000);
+});

package/dist/serverInstructions.js

@@ -0,0 +1,20 @@
+/**
+ * Server instructions, returned in the MCP `initialize` result.
+ *
+ * Clients put this in the system prompt, which makes it the only text that
+ * reaches the model *before* it decides what to do. Tool descriptions do not:
+ * they are read once the model is already choosing between tools, and "work on
+ * #123" in a git repository sends it to `gh issue view` instead (#1373). The
+ * reference convention therefore lives here, and names the GitHub reading it is
+ * over-ruling rather than only the Wolfpack one.
+ *
+ * Mirrored in `packages/backend/src/mcp/serverInstructions.ts` for the remote
+ * server — the two servers have no shared package, and already keep their tool
+ * descriptions in step by hand.
+ */
+export const SERVER_INSTRUCTIONS = `Wolfpack is this project's tracker. Its references override the usual GitHub reading of "#N".
+
+- A bare "#123" — "work on #123", "look at #42" — is ALWAYS a Wolfpack work item. Call get_work_item. Do not run \`gh issue view\`, and do not search GitHub for it.
+- Read a number as a GitHub issue or pull request only when the user says GitHub, PR, or gh — "the GitHub issue #123", "PR #123".
+- Every other Wolfpack type needs its prefix and is never a bare number: #i123 issues, #r123 roadmap/initiatives, #j123 journal entries, #c123 cases, #p123 procedures. Wiki pages are addressed by path, e.g. /docs/setup.
+- On its own, "issue" means a Wolfpack issue (#i123). A GitHub issue is only ever called a GitHub issue.`;

package/dist/serverInstructions.test.js

@@ -0,0 +1,31 @@
+import { describe, it, expect } from 'vitest';
+import { SERVER_INSTRUCTIONS } from './serverInstructions.js';
+describe('SERVER_INSTRUCTIONS', () => {
+    it('claims a bare #N for work items before any tool is chosen (#1373)', () => {
+        // The whole point of the instructions field: a client puts it in the system
+        // prompt, so it is read before the model decides between get_work_item and
+        // reaching for the shell.
+        expect(SERVER_INSTRUCTIONS).toContain('#123');
+        expect(SERVER_INSTRUCTIONS).toContain('work item');
+        expect(SERVER_INSTRUCTIONS).toContain('get_work_item');
+    });
+    it('names the GitHub reading it is over-ruling', () => {
+        // "bare #N is not a Wolfpack issue" was already on the tools and did not
+        // help: the rival reading is a GitHub one, so it has to be named.
+        expect(SERVER_INSTRUCTIONS).toContain('gh issue');
+        expect(SERVER_INSTRUCTIONS).toContain('GitHub');
+    });
+    it('says when a number IS a GitHub reference, so the rule can be applied', () => {
+        // A rule with no exception gets ignored the first time the user genuinely
+        // means a pull request.
+        expect(SERVER_INSTRUCTIONS).toMatch(/only when .*GitHub/i);
+    });
+    it('covers every prefixed reference type so nothing else is guessed at', () => {
+        for (const prefix of ['#i', '#r', '#j', '#c', '#p']) {
+            expect(SERVER_INSTRUCTIONS).toContain(`${prefix}123`);
+        }
+    });
+    it('stays short enough to sit in a system prompt', () => {
+        expect(SERVER_INSTRUCTIONS.length).toBeLessThan(1200);
+    });
+});

package/package.json

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