wolfpack-mcp 1.0.52 → 1.0.53

package/dist/procedureTools.js

@@ -0,0 +1,208 @@
+/**
+ * Procedure MCP tool definitions and handlers.
+ * Enables agents to list, view, create, update, and delete procedures.
+ */
+import { z } from 'zod';
+export const PROCEDURE_TOOLS = [
+    {
+        name: 'list_procedures',
+        description: 'List procedures in a project. Returns name, status, version, tags, and case count. ' +
+            'Use get_procedure to see the full workflow definition.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                project_slug: {
+                    type: 'string',
+                    description: 'Project slug (required for multi-project users)',
+                },
+                search: { type: 'string', description: 'Search in name and description' },
+                active_only: { type: 'boolean', description: 'Only return active procedures' },
+                limit: { type: 'number', description: 'Maximum procedures to return' },
+                offset: { type: 'number', description: 'Procedures to skip for pagination' },
+            },
+        },
+    },
+    {
+        name: 'get_procedure',
+        description: 'Get full details of a procedure including its workflow definition (nodes and edges). ' +
+            'The definition uses a graph format: nodes have id, type (start/end/activity/decision/loop/parallel/wait), ' +
+            'position, and data; edges connect nodes via source/target IDs. ' +
+            'Accepts UUID or refId (requires project_slug for refId).',
+        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'],
+        },
+    },
+    {
+        name: 'create_procedure',
+        description: 'Create a new procedure. If no definition is provided, creates a default start→end workflow. ' +
+            'The definition is a graph with nodes and edges. Node types: start, end, activity, decision, loop, parallel, wait. ' +
+            'Each node needs id, type, position ({x, y}), and data (type-specific config). ' +
+            'Edges connect nodes: {id, source, target}. The procedure starts as inactive (isActive=false).',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: { type: 'string', description: 'Procedure name (unique per project)' },
+                description: { type: 'string', description: 'Short description' },
+                definition: {
+                    type: 'object',
+                    description: 'Workflow definition: { nodes: [{id, type, position: {x, y}, data: {...}}], edges: [{id, source, target}] }',
+                },
+                tags: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Tags for categorization',
+                },
+                project_slug: {
+                    type: 'string',
+                    description: 'Project slug (required for multi-project users)',
+                },
+            },
+            required: ['name'],
+        },
+    },
+    {
+        name: 'update_procedure',
+        description: 'Update a procedure. Only provide the fields you want to change. ' +
+            'Updating the definition auto-increments the version number. ' +
+            'Set isActive to true/false to activate/deactivate the procedure. ' +
+            'Accepts UUID or refId (requires project_slug for refId).',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                procedure_id: {
+                    type: 'string',
+                    description: 'Procedure UUID or refId number',
+                },
+                name: { type: 'string', description: 'Updated name' },
+                description: {
+                    type: ['string', 'null'],
+                    description: 'Updated description (null to clear)',
+                },
+                information: {
+                    type: ['string', 'null'],
+                    description: 'Extended documentation/guide (null to clear)',
+                },
+                definition: {
+                    type: 'object',
+                    description: 'Updated workflow definition: { nodes: [...], edges: [...] }. Changes increment version.',
+                },
+                is_active: { type: 'boolean', description: 'Activate or deactivate the procedure' },
+                tags: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Updated tags (replaces existing)',
+                },
+                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);
+    switch (name) {
+        case 'list_procedures': {
+            const parsed = z
+                .object({
+                project_slug: z.string().optional(),
+                search: z.string().optional(),
+                active_only: z.preprocess((v) => (typeof v === 'string' ? v === 'true' : v), z.boolean().optional()),
+                limit: z.coerce.number().optional(),
+                offset: z.coerce.number().optional(),
+            })
+                .parse(args);
+            const result = await client.listProcedures({
+                teamSlug: parsed.project_slug,
+                search: parsed.search,
+                activeOnly: parsed.active_only,
+                limit: parsed.limit,
+                offset: parsed.offset,
+            });
+            return { content: [{ type: 'text', text: text(result) }] };
+        }
+        case 'get_procedure': {
+            const parsed = z
+                .object({
+                procedure_id: z.string(),
+                project_slug: z.string().optional(),
+            })
+                .parse(args);
+            const procedure = await client.getProcedure(parsed.procedure_id, parsed.project_slug);
+            if (!procedure)
+                return { content: [{ type: 'text', text: 'Procedure not found' }] };
+            return { content: [{ type: 'text', text: text(procedure) }] };
+        }
+        case 'create_procedure': {
+            const parsed = z
+                .object({
+                name: z.string(),
+                description: z.string().optional(),
+                definition: z.preprocess((v) => (typeof v === 'string' ? JSON.parse(v) : v), z.any().optional()),
+                tags: z.array(z.string()).optional(),
+                project_slug: z.string().optional(),
+            })
+                .parse(args);
+            const procedure = await client.createProcedure({
+                name: parsed.name,
+                description: parsed.description,
+                definition: parsed.definition,
+                tags: parsed.tags,
+                teamSlug: parsed.project_slug,
+            });
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Created procedure "${procedure.name}" (refId: ${procedure.refId})\n\n${text(procedure)}`,
+                    },
+                ],
+            };
+        }
+        case 'update_procedure': {
+            const parsed = z
+                .object({
+                procedure_id: z.string(),
+                name: z.string().optional(),
+                description: z.string().nullable().optional(),
+                information: z.string().nullable().optional(),
+                definition: z.preprocess((v) => (typeof v === 'string' ? JSON.parse(v) : v), z.any().optional()),
+                is_active: z.preprocess((v) => (typeof v === 'string' ? v === 'true' : v), z.boolean().optional()),
+                tags: z.array(z.string()).optional(),
+                project_slug: z.string().optional(),
+            })
+                .parse(args);
+            const { procedure_id, project_slug, is_active, ...rest } = parsed;
+            const data = { ...rest };
+            if (is_active !== undefined)
+                data.isActive = is_active;
+            const procedure = await client.updateProcedure(procedure_id, data, project_slug);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Updated procedure "${procedure.name}" (v${procedure.version})\n\n${text(procedure)}`,
+                    },
+                ],
+            };
+        }
+        default:
+            return {
+                content: [{ type: 'text', text: `Unknown procedure tool: ${name}` }],
+                isError: true,
+            };
+    }
+}

package/package.json

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