@allpepper/task-orchestrator 0.1.0

package/src/tools/query-container.ts

@@ -0,0 +1,296 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import { createSuccessResponse, createErrorResponse, uuidSchema, optionalUuidSchema } from './registry';
+import {
+  createProject,
+  getProject,
+  updateProject,
+  deleteProject,
+  searchProjects,
+  getProjectOverview,
+} from '../repos/projects';
+import {
+  createFeature,
+  getFeature,
+  updateFeature,
+  deleteFeature,
+  searchFeatures,
+  getFeatureOverview,
+} from '../repos/features';
+import {
+  createTask,
+  getTask,
+  updateTask,
+  deleteTask,
+  searchTasks,
+  setTaskStatus,
+} from '../repos/tasks';
+import { getSections } from '../repos/sections';
+import type { TaskCounts } from '../repos/base';
+
+/**
+ * Unified query_container tool - read operations for containers
+ *
+ * Operations:
+ * - get: Retrieve a single container by ID
+ * - search: Search containers with filters
+ * - overview: Get global overview (all) or scoped overview (by ID + hierarchy)
+ */
+export function registerQueryContainerTool(server: McpServer): void {
+  server.tool(
+    'query_container',
+    'Unified read operations for containers (project, feature, task). Supports get, search, and overview operations.',
+    {
+      operation: z.enum(['get', 'search', 'overview']),
+      containerType: z.enum(['project', 'feature', 'task']),
+      id: optionalUuidSchema,
+      query: z.string().optional(),
+      status: z.string().optional(),
+      priority: z.string().optional(),
+      tags: z.string().optional(),
+      projectId: optionalUuidSchema,
+      featureId: optionalUuidSchema,
+      limit: z.number().int().optional().default(20),
+      offset: z.number().int().optional().default(0),
+      includeSections: z.boolean().optional().default(false),
+    },
+    async (params) => {
+      try {
+        const { operation, containerType, id } = params;
+
+        // ===== GET OPERATION =====
+        if (operation === 'get') {
+          if (!id) {
+            const response = createErrorResponse('id is required for get operation');
+            return {
+              content: [{ type: 'text' as const, text: JSON.stringify(response, null, 2) }],
+            };
+          }
+
+          // Dispatch based on container type
+          let result;
+          if (containerType === 'project') {
+            result = getProject(id);
+          } else if (containerType === 'feature') {
+            result = getFeature(id);
+          } else {
+            result = getTask(id);
+          }
+
+          if (!result.success) {
+            const response = createErrorResponse(result.error || 'Failed to get container');
+            return {
+              content: [{ type: 'text' as const, text: JSON.stringify(response, null, 2) }],
+            };
+          }
+
+          let data: any = { [containerType]: result.data };
+
+          // Include sections if requested
+          if (params.includeSections) {
+            const entityTypeMap = {
+              project: 'PROJECT',
+              feature: 'FEATURE',
+              task: 'TASK',
+            };
+            const sectionsResult = getSections(id, entityTypeMap[containerType]);
+            if (sectionsResult.success) {
+              data.sections = sectionsResult.data;
+            }
+          }
+
+          // Include task counts for features
+          if (containerType === 'feature') {
+            const overviewResult = getFeatureOverview(id);
+            if (overviewResult.success) {
+              data.taskCounts = overviewResult.data.taskCounts;
+            }
+          }
+
+          // Include task counts for projects
+          if (containerType === 'project') {
+            const overviewResult = getProjectOverview(id);
+            if (overviewResult.success) {
+              data.taskCounts = overviewResult.data.taskCounts;
+            }
+          }
+
+          const response = createSuccessResponse(`${containerType} retrieved successfully`, data);
+          return {
+            content: [{ type: 'text' as const, text: JSON.stringify(response, null, 2) }],
+          };
+        }
+
+        // ===== SEARCH OPERATION =====
+        if (operation === 'search') {
+          const searchParams = {
+            query: params.query,
+            status: params.status,
+            priority: params.priority,
+            tags: params.tags,
+            projectId: params.projectId,
+            featureId: params.featureId,
+            limit: params.limit ?? 20,
+            offset: params.offset ?? 0,
+          };
+
+          let result;
+          if (containerType === 'project') {
+            result = searchProjects(searchParams);
+          } else if (containerType === 'feature') {
+            result = searchFeatures(searchParams);
+          } else {
+            result = searchTasks(searchParams);
+          }
+
+          if (!result.success) {
+            const response = createErrorResponse(result.error || 'Search failed');
+            return {
+              content: [{ type: 'text' as const, text: JSON.stringify(response, null, 2) }],
+            };
+          }
+
+          const response = createSuccessResponse(
+            `Found ${result.data.length} ${containerType}(s)`,
+            {
+              items: result.data,
+              count: result.data.length,
+              limit: params.limit ?? 20,
+              offset: params.offset ?? 0,
+            }
+          );
+          return {
+            content: [{ type: 'text' as const, text: JSON.stringify(response, null, 2) }],
+          };
+        }
+
+        // ===== OVERVIEW OPERATION =====
+        if (operation === 'overview') {
+          // Global overview - search all with filters
+          if (!id) {
+            const searchParams = {
+              query: params.query,
+              status: params.status,
+              priority: params.priority,
+              tags: params.tags,
+              projectId: params.projectId,
+              featureId: params.featureId,
+              limit: params.limit ?? 20,
+              offset: params.offset ?? 0,
+            };
+
+            let result;
+            if (containerType === 'project') {
+              result = searchProjects(searchParams);
+            } else if (containerType === 'feature') {
+              result = searchFeatures(searchParams);
+            } else {
+              result = searchTasks(searchParams);
+            }
+
+            if (!result.success) {
+              const response = createErrorResponse(result.error || 'Overview failed');
+              return {
+                content: [{ type: 'text' as const, text: JSON.stringify(response, null, 2) }],
+              };
+            }
+
+            const response = createSuccessResponse(
+              `Global ${containerType} overview`,
+              {
+                items: result.data,
+                count: result.data.length,
+                limit: params.limit ?? 20,
+                offset: params.offset ?? 0,
+              }
+            );
+            return {
+              content: [{ type: 'text' as const, text: JSON.stringify(response, null, 2) }],
+            };
+          }
+
+          // Scoped overview - entity + hierarchy
+          if (containerType === 'project') {
+            const overviewResult = getProjectOverview(id);
+            if (!overviewResult.success) {
+              const response = createErrorResponse(
+                'error' in overviewResult ? overviewResult.error : 'Failed to get project overview'
+              );
+              return {
+                content: [{ type: 'text' as const, text: JSON.stringify(response, null, 2) }],
+              };
+            }
+
+            // Get features for this project
+            const featuresResult = searchFeatures({ projectId: id, limit: 100 });
+            const features = featuresResult.success ? featuresResult.data : [];
+
+            const response = createSuccessResponse('Project overview retrieved', {
+              project: overviewResult.data.project,
+              taskCounts: overviewResult.data.taskCounts,
+              features,
+            });
+            return {
+              content: [{ type: 'text' as const, text: JSON.stringify(response, null, 2) }],
+            };
+          }
+
+          if (containerType === 'feature') {
+            const overviewResult = getFeatureOverview(id);
+            if (!overviewResult.success) {
+              const response = createErrorResponse(
+                'error' in overviewResult ? overviewResult.error : 'Failed to get feature overview'
+              );
+              return {
+                content: [{ type: 'text' as const, text: JSON.stringify(response, null, 2) }],
+              };
+            }
+
+            // Get tasks for this feature
+            const tasksResult = searchTasks({ featureId: id, limit: 100 });
+            const tasks = tasksResult.success ? tasksResult.data : [];
+
+            const response = createSuccessResponse('Feature overview retrieved', {
+              feature: overviewResult.data.feature,
+              taskCounts: overviewResult.data.taskCounts,
+              tasks,
+            });
+            return {
+              content: [{ type: 'text' as const, text: JSON.stringify(response, null, 2) }],
+            };
+          }
+
+          if (containerType === 'task') {
+            const taskResult = getTask(id);
+            if (!taskResult.success) {
+              const response = createErrorResponse(
+                'error' in taskResult ? taskResult.error : 'Failed to get task overview'
+              );
+              return {
+                content: [{ type: 'text' as const, text: JSON.stringify(response, null, 2) }],
+              };
+            }
+
+            // For tasks, just return the task (dependencies could be added in future)
+            const response = createSuccessResponse('Task overview retrieved', {
+              task: taskResult.data,
+            });
+            return {
+              content: [{ type: 'text' as const, text: JSON.stringify(response, null, 2) }],
+            };
+          }
+        }
+
+        const response = createErrorResponse('Invalid operation');
+        return {
+          content: [{ type: 'text' as const, text: JSON.stringify(response, null, 2) }],
+        };
+      } catch (error: any) {
+        const response = createErrorResponse(error.message || 'Internal error');
+        return {
+          content: [{ type: 'text' as const, text: JSON.stringify(response, null, 2) }],
+        };
+      }
+    }
+  );
+}

package/src/tools/query-dependencies.ts

@@ -0,0 +1,68 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import { createSuccessResponse, createErrorResponse, uuidSchema } from './registry';
+import { getDependencies } from '../repos/dependencies';
+
+/**
+ * Register the query_dependencies MCP tool.
+ *
+ * Queries dependencies for a task with optional direction filtering.
+ *
+ * @param server - The MCP server instance to register the tool with
+ */
+export function registerQueryDependenciesTool(server: McpServer): void {
+  server.tool(
+    'query_dependencies',
+    'Query dependencies for a task',
+    {
+      taskId: uuidSchema.describe('Task ID'),
+      direction: z
+        .enum(['dependencies', 'dependents', 'both'])
+        .optional()
+        .default('both')
+        .describe('Direction filter: dependencies, dependents, or both'),
+    },
+    async (params) => {
+      try {
+        const result = getDependencies(params.taskId, params.direction);
+
+        if (result.success === false) {
+          return {
+            content: [
+              {
+                type: 'text' as const,
+                text: JSON.stringify(
+                  createErrorResponse(result.error, result.code),
+                  null,
+                  2
+                ),
+              },
+            ],
+          };
+        }
+
+        return {
+          content: [
+            {
+              type: 'text' as const,
+              text: JSON.stringify(
+                createSuccessResponse('Dependencies retrieved', result.data),
+                null,
+                2
+              ),
+            },
+          ],
+        };
+      } catch (error: any) {
+        return {
+          content: [
+            {
+              type: 'text' as const,
+              text: JSON.stringify(createErrorResponse(error.message), null, 2),
+            },
+          ],
+        };
+      }
+    }
+  );
+}

package/src/tools/query-sections.ts

@@ -0,0 +1,70 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import { createSuccessResponse, createErrorResponse, uuidSchema } from './registry';
+import { getSections } from '../repos/sections';
+
+/**
+ * Register the query_sections MCP tool
+ *
+ * Retrieves sections for a given entity with optional filtering and content inclusion.
+ */
+export function registerQuerySectionsTool(server: McpServer): void {
+  server.tool(
+    'query_sections',
+    'Retrieve sections for an entity (PROJECT, FEATURE, or TASK). Supports filtering by tags, section IDs, and optional content exclusion for token savings.',
+    {
+      entityType: z.enum(['PROJECT', 'FEATURE', 'TASK']).describe('The type of entity to query sections for'),
+      entityId: uuidSchema.describe('The UUID of the entity'),
+      includeContent: z.boolean().optional().default(true).describe('Set to false to exclude content field for token savings'),
+      tags: z.string().optional().describe('Comma-separated list of tags to filter sections'),
+      sectionIds: z.string().optional().describe('Comma-separated list of section IDs to filter')
+    },
+    async (params) => {
+      try {
+        // Parse sectionIds if provided
+        const sectionIds = params.sectionIds
+          ? params.sectionIds.split(',').map(id => id.trim().replace(/-/g, ''))
+          : undefined;
+
+        // Call getSections with parsed parameters
+        const result = getSections(params.entityId, params.entityType, {
+          includeContent: params.includeContent,
+          tags: params.tags,
+          sectionIds
+        });
+
+        // Handle result
+        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 retrieved successfully', result.data),
+              null,
+              2
+            )
+          }]
+        };
+      } catch (error: any) {
+        return {
+          content: [{
+            type: 'text' as const,
+            text: JSON.stringify(
+              createErrorResponse(error.message || 'Failed to query sections'),
+              null,
+              2
+            )
+          }]
+        };
+      }
+    }
+  );
+}

package/src/tools/query-templates.ts

@@ -0,0 +1,137 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod';
+import { createSuccessResponse, createErrorResponse, uuidSchema, optionalUuidSchema } from './registry';
+import { getTemplate, listTemplates } from '../repos/templates';
+
+/**
+ * Registers the `query_templates` MCP tool.
+ *
+ * Operations:
+ * - get: Retrieve a single template by ID
+ * - list: List templates with optional filters
+ */
+export function registerQueryTemplatesTool(server: McpServer): void {
+  server.tool(
+    'query_templates',
+    'Query templates with operations: get (retrieve single template) or list (retrieve multiple templates with filters)',
+    {
+      operation: z.enum(['get', 'list']),
+      id: optionalUuidSchema,
+      includeSections: z.boolean().optional().default(false),
+      targetEntityType: z.string().optional(),
+      isBuiltIn: z.boolean().optional(),
+      isEnabled: z.boolean().optional(),
+      tags: z.string().optional()
+    },
+    async (params: any) => {
+      try {
+        const operation = params.operation;
+
+        if (operation === 'get') {
+          // Validate required parameters for get
+          if (!params.id) {
+            return {
+              content: [{
+                type: 'text' as const,
+                text: JSON.stringify(
+                  createErrorResponse('Template ID is required for get operation'),
+                  null,
+                  2
+                )
+              }]
+            };
+          }
+
+          const includeSections = params.includeSections ?? false;
+          const result = getTemplate(params.id, includeSections);
+
+          if (!result.success) {
+            return {
+              content: [{
+                type: 'text' as const,
+                text: JSON.stringify(
+                  createErrorResponse(result.error || 'Failed to get template'),
+                  null,
+                  2
+                )
+              }]
+            };
+          }
+
+          return {
+            content: [{
+              type: 'text' as const,
+              text: JSON.stringify(
+                createSuccessResponse('Template retrieved successfully', result.data),
+                null,
+                2
+              )
+            }]
+          };
+        } else if (operation === 'list') {
+          // Build filter parameters
+          const filters = {
+            targetEntityType: params.targetEntityType,
+            isBuiltIn: params.isBuiltIn,
+            isEnabled: params.isEnabled,
+            tags: params.tags
+          };
+
+          const result = listTemplates(filters);
+
+          if (!result.success) {
+            return {
+              content: [{
+                type: 'text' as const,
+                text: JSON.stringify(
+                  createErrorResponse(result.error || 'Failed to list templates'),
+                  null,
+                  2
+                )
+              }]
+            };
+          }
+
+          return {
+            content: [{
+              type: 'text' as const,
+              text: JSON.stringify(
+                createSuccessResponse(
+                  `Found ${result.data.length} template(s)`,
+                  result.data
+                ),
+                null,
+                2
+              )
+            }]
+          };
+        } else {
+          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
+            )
+          }]
+        };
+      }
+    }
+  );
+}