@allpepper/task-orchestrator 0.1.0

package/src/tools/manage-sections.ts

@@ -0,0 +1,388 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import { createSuccessResponse, createErrorResponse, uuidSchema, optionalUuidSchema } from './registry';
+import {
+  addSection,
+  updateSection,
+  updateSectionText,
+  deleteSection,
+  reorderSections,
+  bulkCreateSections,
+  bulkDeleteSections
+} from '../repos/sections';
+
+/**
+ * Register the manage_sections MCP tool
+ *
+ * Provides comprehensive section management with operations: add, update, updateText, delete, reorder, bulkCreate, bulkDelete.
+ */
+export function registerManageSectionsTool(server: McpServer): void {
+  server.tool(
+    'manage_sections',
+    'Manage sections with operations: add (create new), update (modify fields), updateText (update content only), delete (remove), reorder (change ordinals), bulkCreate (create multiple), bulkDelete (remove multiple).',
+    {
+      operation: z.enum(['add', 'update', 'updateText', 'delete', 'reorder', 'bulkCreate', 'bulkDelete']).describe('The operation to perform'),
+      entityType: z.enum(['PROJECT', 'FEATURE', 'TASK']).optional().describe('Required for: add, bulkCreate'),
+      entityId: optionalUuidSchema.describe('Required for: add, reorder, bulkCreate'),
+      sectionId: optionalUuidSchema.describe('Required for: update, updateText, delete'),
+      title: z.string().optional().describe('Section title (for add/update)'),
+      usageDescription: z.string().optional().describe('Description of how to use this section (for add/update)'),
+      content: z.string().optional().describe('Section content (for add/update/updateText)'),
+      contentFormat: z.enum(['PLAIN_TEXT', 'MARKDOWN', 'JSON', 'CODE']).optional().describe('Content format (for add/update)'),
+      tags: z.string().optional().describe('Comma-separated tags (for add/update)'),
+      ordinal: z.number().int().optional().describe('Display order (for add)'),
+      version: z.number().int().optional().describe('Required for: update, updateText (for optimistic locking)'),
+      orderedIds: z.string().optional().describe('Comma-separated section IDs in new order (for reorder)'),
+      sections: z.string().optional().describe('JSON array of sections to create (for bulkCreate)'),
+      sectionIds: z.string().optional().describe('Comma-separated section IDs to delete (for bulkDelete)')
+    },
+    async (params) => {
+      try {
+        switch (params.operation) {
+          case 'add': {
+            // Validate required parameters
+            if (!params.entityType || !params.entityId || !params.title || !params.usageDescription || !params.content) {
+              return {
+                content: [{
+                  type: 'text' as const,
+                  text: JSON.stringify(
+                    createErrorResponse('Missing required parameters for add: entityType, entityId, title, usageDescription, content'),
+                    null,
+                    2
+                  )
+                }]
+              };
+            }
+
+            const result = addSection({
+              entityType: params.entityType,
+              entityId: params.entityId,
+              title: params.title,
+              usageDescription: params.usageDescription,
+              content: params.content,
+              contentFormat: params.contentFormat,
+              ordinal: params.ordinal,
+              tags: params.tags
+            });
+
+            if (!result.success) {
+              return {
+                content: [{
+                  type: 'text' as const,
+                  text: JSON.stringify(createErrorResponse(result.error), null, 2)
+                }]
+              };
+            }
+
+            return {
+              content: [{
+                type: 'text' as const,
+                text: JSON.stringify(
+                  createSuccessResponse('Section added successfully', result.data),
+                  null,
+                  2
+                )
+              }]
+            };
+          }
+
+          case 'update': {
+            // Validate required parameters
+            if (!params.sectionId || params.version === undefined) {
+              return {
+                content: [{
+                  type: 'text' as const,
+                  text: JSON.stringify(
+                    createErrorResponse('Missing required parameters for update: sectionId, version'),
+                    null,
+                    2
+                  )
+                }]
+              };
+            }
+
+            const result = updateSection(params.sectionId, {
+              title: params.title,
+              usageDescription: params.usageDescription,
+              content: params.content,
+              contentFormat: params.contentFormat,
+              tags: params.tags,
+              version: params.version
+            });
+
+            if (!result.success) {
+              return {
+                content: [{
+                  type: 'text' as const,
+                  text: JSON.stringify(createErrorResponse(result.error), null, 2)
+                }]
+              };
+            }
+
+            return {
+              content: [{
+                type: 'text' as const,
+                text: JSON.stringify(
+                  createSuccessResponse('Section updated successfully', result.data),
+                  null,
+                  2
+                )
+              }]
+            };
+          }
+
+          case 'updateText': {
+            // Validate required parameters
+            if (!params.sectionId || !params.content || params.version === undefined) {
+              return {
+                content: [{
+                  type: 'text' as const,
+                  text: JSON.stringify(
+                    createErrorResponse('Missing required parameters for updateText: sectionId, content, version'),
+                    null,
+                    2
+                  )
+                }]
+              };
+            }
+
+            const result = updateSectionText(params.sectionId, params.content, params.version);
+
+            if (!result.success) {
+              return {
+                content: [{
+                  type: 'text' as const,
+                  text: JSON.stringify(createErrorResponse(result.error), null, 2)
+                }]
+              };
+            }
+
+            return {
+              content: [{
+                type: 'text' as const,
+                text: JSON.stringify(
+                  createSuccessResponse('Section text updated successfully', result.data),
+                  null,
+                  2
+                )
+              }]
+            };
+          }
+
+          case 'delete': {
+            // Validate required parameters
+            if (!params.sectionId) {
+              return {
+                content: [{
+                  type: 'text' as const,
+                  text: JSON.stringify(
+                    createErrorResponse('Missing required parameter for delete: sectionId'),
+                    null,
+                    2
+                  )
+                }]
+              };
+            }
+
+            const result = deleteSection(params.sectionId);
+
+            if (!result.success) {
+              return {
+                content: [{
+                  type: 'text' as const,
+                  text: JSON.stringify(createErrorResponse(result.error), null, 2)
+                }]
+              };
+            }
+
+            return {
+              content: [{
+                type: 'text' as const,
+                text: JSON.stringify(
+                  createSuccessResponse('Section deleted successfully', { deleted: result.data }),
+                  null,
+                  2
+                )
+              }]
+            };
+          }
+
+          case 'reorder': {
+            // Validate required parameters
+            if (!params.entityId || !params.entityType || !params.orderedIds) {
+              return {
+                content: [{
+                  type: 'text' as const,
+                  text: JSON.stringify(
+                    createErrorResponse('Missing required parameters for reorder: entityId, entityType, orderedIds'),
+                    null,
+                    2
+                  )
+                }]
+              };
+            }
+
+            const orderedIds = params.orderedIds.split(',').map(id => id.trim().replace(/-/g, ''));
+            const result = reorderSections(params.entityId, params.entityType, orderedIds);
+
+            if (!result.success) {
+              return {
+                content: [{
+                  type: 'text' as const,
+                  text: JSON.stringify(createErrorResponse(result.error), null, 2)
+                }]
+              };
+            }
+
+            return {
+              content: [{
+                type: 'text' as const,
+                text: JSON.stringify(
+                  createSuccessResponse('Sections reordered successfully', { reordered: result.data }),
+                  null,
+                  2
+                )
+              }]
+            };
+          }
+
+          case 'bulkCreate': {
+            // Validate required parameters
+            if (!params.sections) {
+              return {
+                content: [{
+                  type: 'text' as const,
+                  text: JSON.stringify(
+                    createErrorResponse('Missing required parameter for bulkCreate: sections (JSON array string)'),
+                    null,
+                    2
+                  )
+                }]
+              };
+            }
+
+            if (!params.entityType || !params.entityId) {
+              return {
+                content: [{
+                  type: 'text' as const,
+                  text: JSON.stringify(
+                    createErrorResponse('Missing required parameters for bulkCreate: entityType, entityId'),
+                    null,
+                    2
+                  )
+                }]
+              };
+            }
+
+            let sectionsArray;
+            try {
+              sectionsArray = JSON.parse(params.sections);
+            } catch (error) {
+              return {
+                content: [{
+                  type: 'text' as const,
+                  text: JSON.stringify(
+                    createErrorResponse('Invalid JSON format for sections parameter'),
+                    null,
+                    2
+                  )
+                }]
+              };
+            }
+
+            // Inject entityType and entityId from top-level params into each section
+            const enrichedSections = sectionsArray.map((section: any) => ({
+              ...section,
+              entityType: params.entityType,
+              entityId: params.entityId,
+            }));
+
+            const result = bulkCreateSections(enrichedSections);
+
+            if (!result.success) {
+              return {
+                content: [{
+                  type: 'text' as const,
+                  text: JSON.stringify(createErrorResponse(result.error), null, 2)
+                }]
+              };
+            }
+
+            return {
+              content: [{
+                type: 'text' as const,
+                text: JSON.stringify(
+                  createSuccessResponse('Sections bulk created successfully', result.data),
+                  null,
+                  2
+                )
+              }]
+            };
+          }
+
+          case 'bulkDelete': {
+            // Validate required parameters
+            if (!params.sectionIds) {
+              return {
+                content: [{
+                  type: 'text' as const,
+                  text: JSON.stringify(
+                    createErrorResponse('Missing required parameter for bulkDelete: sectionIds'),
+                    null,
+                    2
+                  )
+                }]
+              };
+            }
+
+            const sectionIds = params.sectionIds.split(',').map(id => id.trim().replace(/-/g, ''));
+            const result = bulkDeleteSections(sectionIds);
+
+            if (!result.success) {
+              return {
+                content: [{
+                  type: 'text' as const,
+                  text: JSON.stringify(createErrorResponse(result.error), null, 2)
+                }]
+              };
+            }
+
+            return {
+              content: [{
+                type: 'text' as const,
+                text: JSON.stringify(
+                  createSuccessResponse('Sections bulk deleted successfully', { deletedCount: result.data }),
+                  null,
+                  2
+                )
+              }]
+            };
+          }
+
+          default:
+            return {
+              content: [{
+                type: 'text' as const,
+                text: JSON.stringify(
+                  createErrorResponse(`Invalid operation: ${params.operation}`),
+                  null,
+                  2
+                )
+              }]
+            };
+        }
+      } catch (error: any) {
+        return {
+          content: [{
+            type: 'text' as const,
+            text: JSON.stringify(
+              createErrorResponse(error.message || 'Failed to manage section'),
+              null,
+              2
+            )
+          }]
+        };
+      }
+    }
+  );
+}

package/src/tools/manage-template.ts

@@ -0,0 +1,313 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import { createSuccessResponse, createErrorResponse, uuidSchema, optionalUuidSchema } from './registry';
+import {
+  createTemplate,
+  updateTemplate,
+  deleteTemplate,
+  enableTemplate,
+  disableTemplate,
+  addTemplateSection
+} from '../repos/templates';
+
+/**
+ * Registers the `manage_template` MCP tool.
+ *
+ * Operations:
+ * - create: Create a new template
+ * - update: Update an existing template
+ * - delete: Delete a template
+ * - enable: Enable a template
+ * - disable: Disable a template
+ * - addSection: Add a section to a template
+ */
+export function registerManageTemplateTool(server: McpServer): void {
+  server.tool(
+    'manage_template',
+    'Manage templates with operations: create, update, delete, enable, disable, or addSection',
+    {
+      operation: z.enum(['create', 'update', 'delete', 'enable', 'disable', 'addSection']),
+      id: optionalUuidSchema,
+      name: z.string().optional(),
+      description: z.string().optional(),
+      targetEntityType: z.string().optional(),
+      isBuiltIn: z.boolean().optional(),
+      isProtected: z.boolean().optional(),
+      createdBy: z.string().optional(),
+      tags: z.string().optional(),
+      // Section-specific parameters (for addSection operation)
+      title: z.string().optional(),
+      usageDescription: z.string().optional(),
+      contentSample: z.string().optional(),
+      contentFormat: z.string().optional(),
+      isRequired: z.boolean().optional(),
+      ordinal: z.number().int().optional()
+    },
+    async (params: any) => {
+      try {
+        const operation = params.operation;
+
+        // Validate ID for operations that require it
+        const requiresId = ['update', 'delete', 'enable', 'disable', 'addSection'];
+        if (requiresId.includes(operation) && !params.id) {
+          return {
+            content: [{
+              type: 'text' as const,
+              text: JSON.stringify(
+                createErrorResponse(`Template ID is required for ${operation} operation`),
+                null,
+                2
+              )
+            }]
+          };
+        }
+
+        switch (operation) {
+          case 'create': {
+            // Validate required parameters for create
+            if (!params.name || !params.description || !params.targetEntityType) {
+              return {
+                content: [{
+                  type: 'text' as const,
+                  text: JSON.stringify(
+                    createErrorResponse('name, description, and targetEntityType are required for create operation'),
+                    null,
+                    2
+                  )
+                }]
+              };
+            }
+
+            const result = createTemplate({
+              name: params.name,
+              description: params.description,
+              targetEntityType: params.targetEntityType,
+              isBuiltIn: params.isBuiltIn,
+              isProtected: params.isProtected,
+              createdBy: params.createdBy,
+              tags: params.tags
+            });
+
+            if (!result.success) {
+              return {
+                content: [{
+                  type: 'text' as const,
+                  text: JSON.stringify(
+                    createErrorResponse(result.error || 'Failed to create template'),
+                    null,
+                    2
+                  )
+                }]
+              };
+            }
+
+            return {
+              content: [{
+                type: 'text' as const,
+                text: JSON.stringify(
+                  createSuccessResponse('Template created successfully', result.data),
+                  null,
+                  2
+                )
+              }]
+            };
+          }
+
+          case 'update': {
+            const updateParams: any = {};
+            if (params.name !== undefined) updateParams.name = params.name;
+            if (params.description !== undefined) updateParams.description = params.description;
+            if (params.tags !== undefined) updateParams.tags = params.tags;
+
+            const result = updateTemplate(params.id!, updateParams);
+
+            if (!result.success) {
+              return {
+                content: [{
+                  type: 'text' as const,
+                  text: JSON.stringify(
+                    createErrorResponse(result.error || 'Failed to update template'),
+                    null,
+                    2
+                  )
+                }]
+              };
+            }
+
+            return {
+              content: [{
+                type: 'text' as const,
+                text: JSON.stringify(
+                  createSuccessResponse('Template updated successfully', result.data),
+                  null,
+                  2
+                )
+              }]
+            };
+          }
+
+          case 'delete': {
+            const result = deleteTemplate(params.id!);
+
+            if (!result.success) {
+              return {
+                content: [{
+                  type: 'text' as const,
+                  text: JSON.stringify(
+                    createErrorResponse(result.error || 'Failed to delete template'),
+                    null,
+                    2
+                  )
+                }]
+              };
+            }
+
+            return {
+              content: [{
+                type: 'text' as const,
+                text: JSON.stringify(
+                  createSuccessResponse('Template deleted successfully', { deleted: true }),
+                  null,
+                  2
+                )
+              }]
+            };
+          }
+
+          case 'enable': {
+            const result = enableTemplate(params.id!);
+
+            if (!result.success) {
+              return {
+                content: [{
+                  type: 'text' as const,
+                  text: JSON.stringify(
+                    createErrorResponse(result.error || 'Failed to enable template'),
+                    null,
+                    2
+                  )
+                }]
+              };
+            }
+
+            return {
+              content: [{
+                type: 'text' as const,
+                text: JSON.stringify(
+                  createSuccessResponse('Template enabled successfully', result.data),
+                  null,
+                  2
+                )
+              }]
+            };
+          }
+
+          case 'disable': {
+            const result = disableTemplate(params.id!);
+
+            if (!result.success) {
+              return {
+                content: [{
+                  type: 'text' as const,
+                  text: JSON.stringify(
+                    createErrorResponse(result.error || 'Failed to disable template'),
+                    null,
+                    2
+                  )
+                }]
+              };
+            }
+
+            return {
+              content: [{
+                type: 'text' as const,
+                text: JSON.stringify(
+                  createSuccessResponse('Template disabled successfully', result.data),
+                  null,
+                  2
+                )
+              }]
+            };
+          }
+
+          case 'addSection': {
+            // Validate required parameters for addSection
+            if (!params.title || !params.usageDescription || !params.contentSample) {
+              return {
+                content: [{
+                  type: 'text' as const,
+                  text: JSON.stringify(
+                    createErrorResponse('title, usageDescription, and contentSample are required for addSection operation'),
+                    null,
+                    2
+                  )
+                }]
+              };
+            }
+
+            const result = addTemplateSection({
+              templateId: params.id!,
+              title: params.title,
+              usageDescription: params.usageDescription,
+              contentSample: params.contentSample,
+              contentFormat: params.contentFormat,
+              isRequired: params.isRequired,
+              tags: params.tags,
+              ordinal: params.ordinal
+            });
+
+            if (!result.success) {
+              return {
+                content: [{
+                  type: 'text' as const,
+                  text: JSON.stringify(
+                    createErrorResponse(result.error || 'Failed to add template section'),
+                    null,
+                    2
+                  )
+                }]
+              };
+            }
+
+            return {
+              content: [{
+                type: 'text' as const,
+                text: JSON.stringify(
+                  createSuccessResponse('Template section added successfully', result.data),
+                  null,
+                  2
+                )
+              }]
+            };
+          }
+
+          default:
+            return {
+              content: [{
+                type: 'text' as const,
+                text: JSON.stringify(
+                  createErrorResponse(`Invalid operation: ${operation}`),
+                  null,
+                  2
+                )
+              }]
+            };
+        }
+      } catch (error: any) {
+        return {
+          content: [{
+            type: 'text' as const,
+            text: JSON.stringify(
+              createErrorResponse(
+                'Internal error',
+                error.message || 'Unknown error occurred'
+              ),
+              null,
+              2
+            )
+          }]
+        };
+      }
+    }
+  );
+}