@mtaap/mcp 0.2.2 → 0.2.4

package/dist/index.js

@@ -37,7 +37,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.4";
 
 // src/index.ts
 var import_zod3 = require("zod");
@@ -411,7 +411,8 @@ var ListProjectsInputSchema = import_zod2.z.object({
 var ListTasksInputSchema = import_zod2.z.object({
   projectId: import_zod2.z.string().optional(),
   state: import_zod2.z.nativeEnum(TaskState).optional(),
-  assigneeId: import_zod2.z.string().optional()
+  assigneeId: import_zod2.z.string().optional(),
+  includeArchived: import_zod2.z.boolean().optional()
 });
 var cuidOrPrefixedId = import_zod2.z.string().regex(/^([a-z0-9]+|[a-z]+_[a-zA-Z0-9]+)$/);
 var GetTaskInputSchema = import_zod2.z.object({
@@ -452,12 +453,41 @@ 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 ArchiveTaskInputSchema = import_zod2.z.object({
+  projectId: cuidOrPrefixedId,
+  taskId: cuidOrPrefixedId
+});
+var UnarchiveTaskInputSchema = import_zod2.z.object({
+  projectId: cuidOrPrefixedId,
+  taskId: cuidOrPrefixedId
+});
 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()
@@ -995,6 +1025,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
    */
@@ -1003,6 +1039,7 @@ var MCPApiClient = class {
     if (filters.projectId) params.set("projectId", filters.projectId);
     if (filters.state) params.set("state", filters.state);
     if (filters.assigneeId) params.set("assigneeId", filters.assigneeId);
+    if (filters.includeArchived) params.set("includeArchived", "true");
     const queryString = params.toString();
     const path = queryString ? `/api/mcp/tasks?${queryString}` : "/api/mcp/tasks";
     return this.request("GET", path);
@@ -1047,6 +1084,22 @@ var MCPApiClient = class {
       deleteBranch
     });
   }
+  /**
+   * Archive a task (soft delete)
+   */
+  async archiveTask(taskId, projectId) {
+    return this.request("POST", `/api/mcp/tasks/${taskId}/archive`, {
+      projectId
+    });
+  }
+  /**
+   * Unarchive a task (restore)
+   */
+  async unarchiveTask(taskId, projectId) {
+    return this.request("DELETE", `/api/mcp/tasks/${taskId}/archive`, {
+      projectId
+    });
+  }
   /**
    * Report task error
    */
@@ -1063,6 +1116,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
    */
@@ -1168,7 +1240,8 @@ async function createMCPServer() {
       inputSchema: {
         projectId: import_zod3.z.string().optional().describe("Filter by project ID"),
         state: import_zod3.z.nativeEnum(TaskState).optional().describe("Filter by task state"),
-        assigneeId: import_zod3.z.string().optional().describe("Filter by assignee ID")
+        assigneeId: import_zod3.z.string().optional().describe("Filter by assignee ID"),
+        includeArchived: import_zod3.z.boolean().optional().describe("Include archived tasks (default: false)")
       }
     },
     async (args) => {
@@ -1178,7 +1251,8 @@ async function createMCPServer() {
         const tasks = await apiClient.listTasks({
           projectId: validated.projectId,
           state: validated.state,
-          assigneeId: validated.assigneeId
+          assigneeId: validated.assigneeId,
+          includeArchived: validated.includeArchived
         });
         return {
           content: [
@@ -1486,6 +1560,74 @@ async function createMCPServer() {
       }
     }
   );
+  server.registerTool(
+    "archive_task",
+    {
+      description: "Archive a task (soft delete). Task can be restored later.",
+      inputSchema: {
+        projectId: import_zod3.z.string().describe("The project ID"),
+        taskId: import_zod3.z.string().describe("The task ID to archive")
+      }
+    },
+    async (args) => {
+      assertApiKeyPermission(
+        mockApiKey,
+        ApiKeyPermission.WRITE,
+        "archive_task"
+      );
+      const validated = ArchiveTaskInputSchema.parse(args);
+      try {
+        const result = await apiClient.archiveTask(
+          validated.taskId,
+          validated.projectId
+        );
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        return handleApiError(error);
+      }
+    }
+  );
+  server.registerTool(
+    "unarchive_task",
+    {
+      description: "Restore an archived task",
+      inputSchema: {
+        projectId: import_zod3.z.string().describe("The project ID"),
+        taskId: import_zod3.z.string().describe("The task ID to restore")
+      }
+    },
+    async (args) => {
+      assertApiKeyPermission(
+        mockApiKey,
+        ApiKeyPermission.WRITE,
+        "unarchive_task"
+      );
+      const validated = UnarchiveTaskInputSchema.parse(args);
+      try {
+        const result = await apiClient.unarchiveTask(
+          validated.taskId,
+          validated.projectId
+        );
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        return handleApiError(error);
+      }
+    }
+  );
   server.registerTool(
     "create_personal_project",
     {
@@ -1522,6 +1664,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",
     {