@mtaap/mcp 0.2.2 → 0.2.3

package/dist/cli.js

@@ -28,7 +28,7 @@ var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
 var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
 
 // src/version.ts
-var VERSION = "0.2.2";
+var VERSION = "0.2.3";
 
 // src/index.ts
 var import_zod3 = require("zod");
@@ -443,12 +443,33 @@ var AbandonTaskInputSchema = import_zod2.z.object({
   taskId: cuidOrPrefixedId,
   deleteBranch: import_zod2.z.boolean().optional()
 });
+var RequestChangesInputSchema = import_zod2.z.object({
+  projectId: cuidOrPrefixedId,
+  taskId: cuidOrPrefixedId,
+  reviewComments: import_zod2.z.string().min(1).max(5e3),
+  requestedChanges: import_zod2.z.array(import_zod2.z.string().min(1).max(500)).optional()
+});
+var ApproveTaskInputSchema = import_zod2.z.object({
+  projectId: cuidOrPrefixedId,
+  taskId: cuidOrPrefixedId,
+  reviewComments: import_zod2.z.string().max(2e3).optional()
+});
 var CreatePersonalProjectInputSchema = import_zod2.z.object({
   name: import_zod2.z.string().min(1).max(100),
   description: import_zod2.z.string().max(500).optional(),
   repositoryUrl: import_zod2.z.string().url()
 });
 var CheckActiveTaskInputSchema = import_zod2.z.object({});
+var CreateTaskMCPInputSchema = import_zod2.z.object({
+  projectId: cuidOrPrefixedId,
+  epicId: cuidOrPrefixedId.nullable().optional(),
+  title: import_zod2.z.string().min(1).max(200),
+  description: import_zod2.z.string().max(5e3),
+  priority: import_zod2.z.nativeEnum(TaskPriority).default(TaskPriority.MEDIUM),
+  acceptanceCriteria: import_zod2.z.array(import_zod2.z.object({
+    description: import_zod2.z.string().min(1).max(500)
+  })).min(1)
+});
 var CreateOrganizationInputSchema = import_zod2.z.object({
   name: import_zod2.z.string().min(1).max(255),
   slug: import_zod2.z.string().min(1).max(100).regex(/^[a-z0-9-]+$/).optional()
@@ -986,6 +1007,12 @@ var MCPApiClient = class {
       { name, description, repositoryUrl }
     );
   }
+  /**
+   * Create a task in a project
+   */
+  async createTask(input) {
+    return this.request("POST", "/api/mcp/tasks", input);
+  }
   /**
    * List tasks with optional filters
    */
@@ -1054,6 +1081,25 @@ var MCPApiClient = class {
   async addNote(taskId, content) {
     return this.request("POST", `/api/mcp/tasks/${taskId}/notes`, { content });
   }
+  /**
+   * Request changes on a task in review
+   */
+  async requestChanges(taskId, projectId, reviewComments, requestedChanges) {
+    return this.request("POST", `/api/mcp/tasks/${taskId}/request-changes`, {
+      projectId,
+      reviewComments,
+      requestedChanges
+    });
+  }
+  /**
+   * Approve a task in review and mark as DONE
+   */
+  async approveTask(taskId, projectId, reviewComments) {
+    return this.request("POST", `/api/mcp/tasks/${taskId}/approve`, {
+      projectId,
+      reviewComments
+    });
+  }
   /**
    * Get GitHub token
    */
@@ -1513,6 +1559,126 @@ async function createMCPServer() {
       }
     }
   );
+  server.registerTool(
+    "create_task",
+    {
+      description: "Create a new task in a project. Requires WRITE permission and project access.",
+      inputSchema: {
+        projectId: import_zod3.z.string().describe("The project ID to create the task in"),
+        epicId: import_zod3.z.string().nullable().optional().describe("Optional epic ID to associate the task with"),
+        title: import_zod3.z.string().describe("Task title (max 200 chars)"),
+        description: import_zod3.z.string().describe("Task description (max 5000 chars)"),
+        priority: import_zod3.z.nativeEnum(TaskPriority).optional().describe("Task priority: LOW, MEDIUM, HIGH, CRITICAL (default: MEDIUM)"),
+        acceptanceCriteria: import_zod3.z.array(
+          import_zod3.z.object({
+            description: import_zod3.z.string().describe("Acceptance criterion description (max 500 chars)")
+          })
+        ).describe("Array of acceptance criteria (at least 1 required)")
+      }
+    },
+    async (args) => {
+      assertApiKeyPermission(
+        mockApiKey,
+        ApiKeyPermission.WRITE,
+        "create_task"
+      );
+      const validated = CreateTaskMCPInputSchema.parse(args);
+      try {
+        const result = await apiClient.createTask({
+          projectId: validated.projectId,
+          epicId: validated.epicId,
+          title: validated.title,
+          description: validated.description,
+          priority: validated.priority,
+          acceptanceCriteria: validated.acceptanceCriteria
+        });
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        return handleApiError(error);
+      }
+    }
+  );
+  server.registerTool(
+    "request_changes",
+    {
+      description: "Submit review comments requesting changes on a task in REVIEW state",
+      inputSchema: {
+        projectId: import_zod3.z.string().describe("The project ID"),
+        taskId: import_zod3.z.string().describe("The task ID to review"),
+        reviewComments: import_zod3.z.string().describe("Review comments explaining requested changes (max 5000 chars)"),
+        requestedChanges: import_zod3.z.array(import_zod3.z.string()).optional().describe("List of specific changes requested")
+      }
+    },
+    async (args) => {
+      assertApiKeyPermission(
+        mockApiKey,
+        ApiKeyPermission.WRITE,
+        "request_changes"
+      );
+      const validated = RequestChangesInputSchema.parse(args);
+      try {
+        const result = await apiClient.requestChanges(
+          validated.taskId,
+          validated.projectId,
+          validated.reviewComments,
+          validated.requestedChanges
+        );
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        return handleApiError(error);
+      }
+    }
+  );
+  server.registerTool(
+    "approve_task",
+    {
+      description: "Approve a task in REVIEW state and mark it as DONE",
+      inputSchema: {
+        projectId: import_zod3.z.string().describe("The project ID"),
+        taskId: import_zod3.z.string().describe("The task ID to approve"),
+        reviewComments: import_zod3.z.string().optional().describe("Optional approval comments (max 2000 chars)")
+      }
+    },
+    async (args) => {
+      assertApiKeyPermission(
+        mockApiKey,
+        ApiKeyPermission.WRITE,
+        "approve_task"
+      );
+      const validated = ApproveTaskInputSchema.parse(args);
+      try {
+        const result = await apiClient.approveTask(
+          validated.taskId,
+          validated.projectId,
+          validated.reviewComments
+        );
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        return handleApiError(error);
+      }
+    }
+  );
   server.registerTool(
     "get_version",
     {