wolfpack-mcp 1.0.104 → 1.0.105

package/README.md

@@ -309,6 +309,49 @@ Update an existing journal entry.
 - `entry_id` (required): The entry UUID
 - `title`, `content` (optional)
 
+### Ideas (the Idea Factory)
+
+Offered to a key holding `mcp:ideas:read` on a project where the `idea-factory` feature is
+switched on. There is no archive tool: archiving is the Idea Factory's delete, and MCP does not
+surface deletes.
+
+#### `list_ideas`
+
+List the live ideas in a project. Each carries a stage and a boost count, and the response says
+whether your own boost for today in that project is already spent.
+
+- `sort` (optional): `popular` (default), `updated` or `newest`
+- `limit`, `offset` (optional): Pagination
+
+#### `get_idea`
+
+Get a single idea, with its tags and the reference numbers of any work items being built from it.
+
+- `idea_id` (required): The idea refId (number)
+
+#### `create_idea`
+
+Raise a new idea. It starts at the `spark` stage with no boosts.
+
+- `title` (required): Idea title
+- `content` (required): Markdown content
+
+#### `update_idea`
+
+Update an idea, or move it to another stage.
+
+- `idea_id` (required): The idea refId (number)
+- `title`, `content` (optional)
+- `stage` (optional): `spark`, `exploring`, `building`, `shipped` or `parked`
+
+#### `boost_idea`
+
+Vote for an idea by spending your boost. One boost per project per day, whichever idea you spend
+it on — spending it again the same day is refused rather than counted. Takes `mcp:ideas:boost`,
+which is separate from `mcp:ideas:update`: voting is participation, not editing.
+
+- `idea_id` (required): The idea refId (number)
+
 ### Comments
 
 #### `list_work_item_comments`

package/dist/client.js

@@ -489,6 +489,33 @@ export class WolfpackClient {
     async updateJournalEntry(entryId, data, teamSlug) {
         return this.api.patch(this.withTeamSlug(`/journal-entries/${encodeURIComponent(entryId)}`, teamSlug), data);
     }
+    // Idea methods (the Idea Factory)
+    async listIdeas(options) {
+        const params = new URLSearchParams();
+        if (options?.teamSlug)
+            params.append('teamSlug', options.teamSlug);
+        if (options?.sort)
+            params.append('sort', options.sort);
+        if (options?.limit !== undefined)
+            params.append('limit', options.limit.toString());
+        if (options?.offset !== undefined)
+            params.append('offset', options.offset.toString());
+        const query = params.toString();
+        return this.api.get(`/ideas${query ? `?${query}` : ''}`);
+    }
+    async getIdea(ideaId, teamSlug) {
+        return this.api.get(this.withTeamSlug(`/ideas/${encodeURIComponent(ideaId)}`, teamSlug));
+    }
+    async createIdea(data) {
+        const { teamSlug, ...rest } = data;
+        return this.api.post('/ideas', { ...rest, teamSlug });
+    }
+    async updateIdea(ideaId, data, teamSlug) {
+        return this.api.put(this.withTeamSlug(`/ideas/${encodeURIComponent(ideaId)}`, teamSlug), data);
+    }
+    async boostIdea(ideaId, teamSlug) {
+        return this.api.post(this.withTeamSlug(`/ideas/${encodeURIComponent(ideaId)}/boost`, teamSlug), {});
+    }
     // Comment methods
     async listWorkItemComments(workItemId, teamSlug) {
         return this.api.get(this.withTeamSlug(`/work-items/${workItemId}/comments`, teamSlug));

package/dist/index.js

@@ -534,6 +534,37 @@ const UpdateJournalEntrySchema = z.object({
         .optional()
         .describe('Project slug (required for multi-project users, use list_projects to get slugs)'),
 });
+// Idea schemas (the Idea Factory)
+const PROJECT_SLUG_DESCRIPTION = 'Project slug (required for multi-project users, use list_projects to get slugs)';
+const ListIdeasSchema = z.object({
+    sort: z
+        .string()
+        .optional()
+        .describe('Ordering: "popular" (default, most boosted first), "updated", or "newest"'),
+    limit: z.number().optional().describe('Maximum number of ideas to return'),
+    offset: z.number().optional().describe('Number of ideas to skip'),
+    project_slug: z.string().optional().describe(PROJECT_SLUG_DESCRIPTION),
+});
+const GetIdeaSchema = z.object({
+    idea_id: refIdString().describe('The idea refId (number)'),
+    project_slug: z.string().optional().describe(PROJECT_SLUG_DESCRIPTION),
+});
+const CreateIdeaSchema = z.object({
+    title: z.string().describe('Idea title'),
+    content: z.string().describe('Idea content (markdown)'),
+    project_slug: z.string().optional().describe(PROJECT_SLUG_DESCRIPTION),
+});
+const UpdateIdeaSchema = z.object({
+    idea_id: refIdString().describe('The idea refId (number)'),
+    title: z.string().optional().describe('Updated title'),
+    content: z.string().optional().describe('Updated content (markdown)'),
+    stage: z.string().optional().describe('New stage: spark, exploring, building, shipped or parked'),
+    project_slug: z.string().optional().describe(PROJECT_SLUG_DESCRIPTION),
+});
+const BoostIdeaSchema = z.object({
+    idea_id: refIdString().describe('The idea refId (number)'),
+    project_slug: z.string().optional().describe(PROJECT_SLUG_DESCRIPTION),
+});
 // Comment schemas
 const ListWorkItemCommentsSchema = z.object({
     work_item_id: refIdString().describe('The work item refId (number)'),
@@ -1512,6 +1543,71 @@ class WolfpackMCPServer {
                             ],
                         };
                     }
+                    // Idea handlers (the Idea Factory)
+                    case 'list_ideas': {
+                        const parsed = ListIdeasSchema.parse(args);
+                        const result = await this.client.listIdeas({
+                            teamSlug: parsed.project_slug || this.client.getProjectSlug() || undefined,
+                            sort: parsed.sort,
+                            limit: parsed.limit,
+                            offset: parsed.offset,
+                        });
+                        const spent = result.boostSpentToday
+                            ? 'Your boost for today in this project is already spent.'
+                            : 'Your boost for today in this project is unspent.';
+                        let text = `${spent}\n\n${JSON.stringify(stripUuids(result.items), null, 2)}`;
+                        if (result.total > result.items.length) {
+                            text = `Note: Showing ${result.items.length} of ${result.total} ideas. Use limit/offset for pagination.\n\n${text}`;
+                        }
+                        return { content: [{ type: 'text', text }] };
+                    }
+                    case 'get_idea': {
+                        const parsed = GetIdeaSchema.parse(args);
+                        const idea = await this.client.getIdea(parsed.idea_id, parsed.project_slug || this.client.getProjectSlug() || undefined);
+                        return {
+                            content: [{ type: 'text', text: JSON.stringify(stripUuids(idea), null, 2) }],
+                        };
+                    }
+                    case 'create_idea': {
+                        const parsed = CreateIdeaSchema.parse(args);
+                        const idea = await this.client.createIdea({
+                            title: parsed.title,
+                            content: parsed.content,
+                            teamSlug: parsed.project_slug || this.client.getProjectSlug() || undefined,
+                        });
+                        return {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: `Created idea #${idea.refId}: ${idea.title}\n\n${JSON.stringify(stripUuids(idea), null, 2)}`,
+                                },
+                            ],
+                        };
+                    }
+                    case 'update_idea': {
+                        const parsed = UpdateIdeaSchema.parse(args);
+                        const idea = await this.client.updateIdea(parsed.idea_id, { title: parsed.title, content: parsed.content, stage: parsed.stage }, parsed.project_slug || this.client.getProjectSlug() || undefined);
+                        return {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: `Updated idea #${idea.refId}: ${idea.title} (${idea.stage})\n\n${JSON.stringify(stripUuids(idea), null, 2)}`,
+                                },
+                            ],
+                        };
+                    }
+                    case 'boost_idea': {
+                        const parsed = BoostIdeaSchema.parse(args);
+                        const idea = await this.client.boostIdea(parsed.idea_id, parsed.project_slug || this.client.getProjectSlug() || undefined);
+                        return {
+                            content: [
+                                {
+                                    type: 'text',
+                                    text: `Boosted idea #${idea.refId}: ${idea.title} now has ${idea.boostCount} boost(s). That was your boost for today in this project.`,
+                                },
+                            ],
+                        };
+                    }
                     // Comment handlers
                     case 'list_work_item_comments': {
                         const parsed = ListWorkItemCommentsSchema.parse(args);

package/dist/toolCatalogue.js

@@ -1146,6 +1146,124 @@ export const TOOL_CATALOGUE = [
             required: ['entry_id'],
         },
     },
+    // Idea Factory tools (#2473). Gated on the `ideas` capability, which the backend
+    // grants a key holding mcp:ideas:read once the `idea-factory` flag is on for it.
+    // No archive tool: archiving is the Idea Factory's delete, and MCP does not
+    // surface deletes (packages/mcp/CLAUDE.md).
+    {
+        name: 'list_ideas',
+        permission: 'mcp:ideas:read',
+        capability: 'ideas',
+        description: 'List the live ideas in a project (the Idea Factory). Use when user asks about "ideas", ' +
+            '"the idea factory", "what has been suggested", or "what are we thinking about". ' +
+            'Each idea carries a stage (spark, exploring, building, shipped, parked) and a boostCount — ' +
+            'the number of members who have voted for it. The response also says whether your own boost ' +
+            'for today in this project has already been spent.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                sort: {
+                    type: 'string',
+                    description: 'Ordering: "popular" (default, most boosted first), "updated", or "newest"',
+                },
+                limit: { type: 'number', description: 'Maximum number of ideas to return' },
+                offset: { type: 'number', description: 'Number of ideas to skip' },
+                project_slug: {
+                    type: 'string',
+                    description: 'Project slug (required for multi-project users, use list_projects to get slugs)',
+                },
+            },
+        },
+    },
+    {
+        name: 'get_idea',
+        permission: 'mcp:ideas:read',
+        capability: 'ideas',
+        description: 'Get a single idea by its refId, with its full content, stage, tags, boost count and the ' +
+            'refIds of any work items being built from it.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                idea_id: { type: 'string', description: 'The idea refId (number)' },
+                project_slug: {
+                    type: 'string',
+                    description: 'Project slug (required for multi-project users, use list_projects to get slugs)',
+                },
+            },
+            required: ['idea_id'],
+        },
+    },
+    {
+        name: 'create_idea',
+        permission: 'mcp:ideas:create',
+        capability: 'ideas',
+        description: 'Raise a new idea in the Idea Factory. Use when user wants to "suggest", "raise an idea", ' +
+            '"add to the idea factory", or "capture a thought". A new idea starts at the "spark" stage ' +
+            'with no boosts. Requires mcp:ideas:create permission. ' +
+            CONTENT_LINKING_HELP,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                title: { type: 'string', description: 'Idea title' },
+                content: { type: 'string', description: 'Idea content (markdown)' },
+                // No tag_ids: the service takes tag UUIDs and the MCP surface strips UUIDs
+                // from every response, so an agent never holds one to send back. Tag an
+                // idea in the UI.
+                project_slug: {
+                    type: 'string',
+                    description: 'Project slug (required for multi-project users, use list_projects to get slugs)',
+                },
+            },
+            required: ['title', 'content'],
+        },
+    },
+    {
+        name: 'update_idea',
+        permission: 'mcp:ideas:update',
+        capability: 'ideas',
+        description: 'Update an idea, or move it to another stage. The stages are "spark" (just raised), ' +
+            '"exploring", "building", "shipped" and "parked" — moving an idea along is how the project ' +
+            'sees what became of it. Requires mcp:ideas:update permission. ' +
+            CONTENT_LINKING_HELP,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                idea_id: { type: 'string', description: 'The idea refId (number)' },
+                title: { type: 'string', description: 'Updated title' },
+                content: { type: 'string', description: 'Updated content (markdown)' },
+                stage: {
+                    type: 'string',
+                    description: 'New stage: spark, exploring, building, shipped or parked',
+                },
+                project_slug: {
+                    type: 'string',
+                    description: 'Project slug (required for multi-project users, use list_projects to get slugs)',
+                },
+            },
+            required: ['idea_id'],
+        },
+    },
+    {
+        name: 'boost_idea',
+        permission: 'mcp:ideas:boost',
+        capability: 'ideas',
+        description: 'Vote for an idea by spending your boost. Use when user wants to "vote for", "boost", ' +
+            '"back" or "+1" an idea. You get ONE boost per project per day, whichever idea you spend ' +
+            'it on, so it is a choice between ideas rather than a click — spending it again the same ' +
+            'day is refused rather than counted. Requires mcp:ideas:boost permission, which is separate ' +
+            'from mcp:ideas:update: voting is participation, not editing.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                idea_id: { type: 'string', description: 'The idea refId (number)' },
+                project_slug: {
+                    type: 'string',
+                    description: 'Project slug (required for multi-project users, use list_projects to get slugs)',
+                },
+            },
+            required: ['idea_id'],
+        },
+    },
     // Comment tools
     {
         name: 'list_work_item_comments',

package/dist/toolCatalogue.test.js

@@ -61,13 +61,16 @@ describe('the MCP tool catalogue', () => {
             .map((param) => `${tool.name}.${param}`));
         expect(unforwarded).toEqual([]);
     });
-    it('offers the procedure tools over stdio only to a key with that capability', () => {
-        const withProcedures = stdioTools(['procedures']).map((t) => t.name);
+    // Every capability in the catalogue, not just `procedures`: a family added with
+    // its `capability` left off is offered to every key, and nothing else notices.
+    it.each([...new Set(TOOL_CATALOGUE.map((t) => t.capability).filter(Boolean))])('offers the %s tools over stdio only to a key with that capability', (capability) => {
+        const gated = TOOL_CATALOGUE.filter((t) => t.capability === capability).map((t) => t.name);
+        const withIt = stdioTools([capability]).map((t) => t.name);
         const without = stdioTools([]).map((t) => t.name);
-        expect(withProcedures).toContain('start_case');
-        expect(without).not.toContain('start_case');
+        expect(withIt).toEqual(expect.arrayContaining(gated));
+        gated.forEach((name) => expect(without).not.toContain(name));
         // Gating is the only difference: nothing else drops out.
-        expect(withProcedures.length - without.length).toBe(TOOL_CATALOGUE.filter((t) => t.capability === 'procedures').length);
+        expect(withIt.length - without.length).toBe(gated.length);
     });
     it('offers a tool over stdio only to a key holding its scope', () => {
         // #2428 — the list told an agent it could do things the 403 then refused.

package/package.json

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