@mtaap/mcp 0.2.5 → 0.2.7

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.5";
+var VERSION = "0.2.7";
 
 // src/index.ts
 var import_zod3 = require("zod");
@@ -36,12 +36,20 @@ var import_zod3 = require("zod");
 // ../../packages/core/dist/constants/enums.js
 var TaskState;
 (function(TaskState2) {
+  TaskState2["DRAFT"] = "DRAFT";
+  TaskState2["TODO"] = "TODO";
   TaskState2["BACKLOG"] = "BACKLOG";
   TaskState2["READY"] = "READY";
   TaskState2["IN_PROGRESS"] = "IN_PROGRESS";
   TaskState2["REVIEW"] = "REVIEW";
   TaskState2["DONE"] = "DONE";
 })(TaskState || (TaskState = {}));
+var VerificationStatus;
+(function(VerificationStatus2) {
+  VerificationStatus2["PENDING"] = "PENDING";
+  VerificationStatus2["PASSED"] = "PASSED";
+  VerificationStatus2["NEEDS_REVISION"] = "NEEDS_REVISION";
+})(VerificationStatus || (VerificationStatus = {}));
 var UserRole;
 (function(UserRole2) {
   UserRole2["ADMIN"] = "ADMIN";
@@ -106,6 +114,8 @@ var WebSocketEventType;
   WebSocketEventType2["TASK_COMPLETED"] = "task.completed";
   WebSocketEventType2["TASK_ERROR"] = "task.error";
   WebSocketEventType2["TASK_STATE_CHANGED"] = "task.state_changed";
+  WebSocketEventType2["TASK_UPDATED"] = "task.updated";
+  WebSocketEventType2["TASK_DELETED"] = "task.deleted";
   WebSocketEventType2["MEMBER_JOINED"] = "member.joined";
 })(WebSocketEventType || (WebSocketEventType = {}));
 var AuthProvider;
@@ -132,16 +142,20 @@ var EventType;
 
 // ../../packages/core/dist/constants/state-machine.js
 var VALID_TRANSITIONS = {
-  [TaskState.BACKLOG]: [TaskState.READY],
-  [TaskState.READY]: [TaskState.BACKLOG, TaskState.IN_PROGRESS],
+  [TaskState.DRAFT]: [TaskState.TODO],
+  [TaskState.TODO]: [TaskState.DRAFT, TaskState.IN_PROGRESS],
+  // Deprecated: BACKLOG transitions to DRAFT (its replacement)
+  [TaskState.BACKLOG]: [TaskState.DRAFT, TaskState.TODO],
+  // Deprecated: READY transitions to TODO (its replacement)
+  [TaskState.READY]: [TaskState.TODO, TaskState.IN_PROGRESS],
   [TaskState.IN_PROGRESS]: [
-    TaskState.BACKLOG,
-    TaskState.READY,
+    TaskState.DRAFT,
+    TaskState.TODO,
     TaskState.REVIEW
   ],
   [TaskState.REVIEW]: [
-    TaskState.BACKLOG,
-    TaskState.READY,
+    TaskState.DRAFT,
+    TaskState.TODO,
     TaskState.IN_PROGRESS,
     TaskState.DONE
   ],
@@ -412,7 +426,7 @@ var GetTaskInputSchema = import_zod2.z.object({
 var AssignTaskInputSchema = import_zod2.z.object({
   projectId: cuidOrPrefixedId,
   taskId: cuidOrPrefixedId,
-  expectedState: import_zod2.z.nativeEnum(TaskState).default(TaskState.READY)
+  expectedState: import_zod2.z.nativeEnum(TaskState).default(TaskState.TODO)
 });
 var UpdateProgressInputSchema = import_zod2.z.object({
   taskId: cuidOrPrefixedId,
@@ -596,6 +610,38 @@ var RegisterInputSchema = import_zod2.z.object({
   name: import_zod2.z.string().min(1).max(255),
   organizationSlug: import_zod2.z.string().min(1).max(100).regex(/^[a-z0-9-]+$/).optional()
 });
+var VerifyTaskInputSchema = import_zod2.z.object({
+  projectId: cuidOrPrefixedId,
+  taskId: cuidOrPrefixedId,
+  approved: import_zod2.z.boolean(),
+  feedback: import_zod2.z.string().max(5e3).optional()
+});
+var GetTaskPromptInputSchema = import_zod2.z.object({
+  projectId: cuidOrPrefixedId,
+  taskId: cuidOrPrefixedId
+});
+var UpdateTaskMCPInputSchema = import_zod2.z.object({
+  projectId: cuidOrPrefixedId,
+  taskId: cuidOrPrefixedId,
+  title: import_zod2.z.string().min(1).max(200).optional(),
+  description: import_zod2.z.string().max(5e3).optional(),
+  priority: import_zod2.z.nativeEnum(TaskPriority).optional(),
+  acceptanceCriteria: import_zod2.z.array(import_zod2.z.object({
+    id: import_zod2.z.string().optional(),
+    description: import_zod2.z.string().min(1).max(500)
+  })).optional()
+});
+var ReportBranchInputSchema = import_zod2.z.object({
+  projectId: cuidOrPrefixedId,
+  taskId: cuidOrPrefixedId,
+  branchName: import_zod2.z.string().min(1).max(100)
+});
+var ReportPRInputSchema = import_zod2.z.object({
+  projectId: cuidOrPrefixedId,
+  taskId: cuidOrPrefixedId,
+  pullRequestUrl: import_zod2.z.string().url(),
+  pullRequestNumber: import_zod2.z.number().int().positive()
+});
 
 // ../../packages/core/dist/logging/metrics.js
 var metrics = /* @__PURE__ */ new Map();
@@ -1045,7 +1091,7 @@ var MCPApiClient = class {
   /**
    * Assign task to current user and create branch
    */
-  async assignTask(taskId, projectId, expectedState = TaskState.READY) {
+  async assignTask(taskId, projectId, expectedState = TaskState.TODO) {
     return this.request("POST", `/api/mcp/tasks/${taskId}/assign`, {
       projectId,
       expectedState
@@ -1058,7 +1104,8 @@ var MCPApiClient = class {
     return this.request("POST", `/api/mcp/tasks/${taskId}/progress`, data);
   }
   /**
-   * Complete task and create PR
+   * Complete task and prepare for PR creation.
+   * Returns PR suggestions for the agent to use when creating the PR locally.
    */
   async completeTask(taskId, projectId, pullRequestTitle, pullRequestBody) {
     return this.request("POST", `/api/mcp/tasks/${taskId}/complete`, {
@@ -1128,11 +1175,51 @@ var MCPApiClient = class {
     });
   }
   /**
-   * Get GitHub token
+   * Report branch created by agent
    */
-  async getGitHubToken(organizationId) {
-    const path = organizationId ? `/api/mcp/github-token?organizationId=${encodeURIComponent(organizationId)}` : "/api/mcp/github-token";
-    return this.request("GET", path);
+  async reportBranch(taskId, projectId, branchName) {
+    return this.request("POST", `/api/mcp/tasks/${taskId}/branch`, {
+      projectId,
+      branchName
+    });
+  }
+  /**
+   * Report PR created by agent
+   */
+  async reportPR(taskId, projectId, pullRequestUrl, pullRequestNumber) {
+    return this.request("POST", `/api/mcp/tasks/${taskId}/pr`, {
+      projectId,
+      pullRequestUrl,
+      pullRequestNumber
+    });
+  }
+  /**
+   * Verify a DRAFT task to move it to TODO state
+   */
+  async verifyTask(taskId, projectId, approved, feedback) {
+    return this.request("POST", `/api/mcp/tasks/${taskId}/verify`, {
+      projectId,
+      approved,
+      feedback
+    });
+  }
+  /**
+   * Get state-appropriate prompt for a task
+   */
+  async getTaskPrompt(taskId, projectId) {
+    return this.request(
+      "GET",
+      `/api/mcp/tasks/${taskId}/prompt?projectId=${encodeURIComponent(projectId)}`
+    );
+  }
+  /**
+   * Update task details (DRAFT/TODO states only)
+   */
+  async updateTask(taskId, projectId, data) {
+    return this.request("PATCH", `/api/mcp/tasks/${taskId}`, {
+      projectId,
+      ...data
+    });
   }
 };
 function createApiClientFromEnv() {
@@ -1185,44 +1272,76 @@ TOOL CATEGORIES:
    - list_projects, get_project_context, get_version
 
 2. Task Management (READ/WRITE):
-   - list_tasks, get_task, create_task, archive_task, unarchive_task
+   - list_tasks, get_task, create_task, update_task, archive_task, unarchive_task
+
+3. Task Verification (WRITE):
+   - verify_task, get_task_prompt
 
-3. Task Execution (WRITE):
+4. Task Execution (WRITE):
    - assign_task, update_progress, add_note, complete_task, abandon_task, report_error
 
-4. Code Review (WRITE):
+5. Git Operations (WRITE):
+   - report_branch, report_pr
+
+6. Code Review (WRITE):
    - request_changes, approve_task
 
-5. Session Management (READ):
+7. Session Management (READ):
    - check_active_task
 
 WORKFLOWS:
 
+Task Creation & Verification:
+  create_task -> get_task_prompt (DRAFT) -> verify_task(approved=true) -> task moves to TODO
+
 Standard Task Workflow:
-  list_projects -> get_project_context -> list_tasks(state=READY) -> get_task -> assign_task -> [update_progress...] -> complete_task
+  list_projects -> get_project_context -> list_tasks(state=TODO) -> get_task -> get_task_prompt (TODO)
+  -> assign_task (returns suggested branch name)
+  -> git checkout -b <branchName> (local git command)
+  -> git push -u origin <branchName> (local git command)
+  -> report_branch (tell server about the branch)
+  -> [update_progress...]
+  -> complete_task (returns PR suggestions)
+  -> gh pr create (local gh command)
+  -> report_pr (tell server about the PR)
 
 Resume Workflow:
-  check_active_task -> (if active) get_task -> update_progress -> complete_task
+  check_active_task -> (if active) get_task -> get_task_prompt (IN_PROGRESS) -> update_progress -> complete_task
 
 Review Workflow:
   list_tasks(state=REVIEW) -> get_task -> approve_task OR request_changes
 
+Task Editing:
+  update_task (DRAFT/TODO only) -> if was TODO, reverts to DRAFT -> verify_task again
+
 Error Recovery:
-  report_error -> abandon_task(deleteBranch=false) -> list_tasks -> assign_task (retry or pick different task)
-  (abandon_task returns IN_PROGRESS tasks to READY state)
+  report_error -> abandon_task -> list_tasks -> assign_task (retry or pick different task)
+  (abandon_task returns IN_PROGRESS tasks to TODO state)
+
+GIT OPERATIONS NOTE:
+  The agent handles all git operations locally. After assign_task returns a suggested branch name,
+  the agent creates the branch with git, pushes it, and reports it via report_branch.
+  After complete_task returns PR suggestions, the agent creates the PR with gh, and reports it via report_pr.
+  This eliminates the need for GitHub tokens on the server.
 
 TASK STATE FLOW:
-  BACKLOG -> READY -> IN_PROGRESS -> REVIEW -> DONE
+  DRAFT -> TODO -> IN_PROGRESS -> REVIEW -> DONE
+  (verify_task: DRAFT -> TODO)
+  (update_task on TODO: reverts to DRAFT)
   (request_changes: REVIEW -> IN_PROGRESS)
-  (abandon_task: IN_PROGRESS -> READY)
+  (abandon_task: IN_PROGRESS -> TODO)
 
 CONSTRAINTS:
+- DRAFT tasks must be verified before assignment
+- verify_task requires programmatic validation (title 10+ chars, description 50+ chars, criteria 20+ chars each)
+- update_task only works on DRAFT and TODO states
 - assign_task is atomic - fails if already claimed
-- Only READY tasks can be assigned
+- Only TODO tasks can be assigned
 - complete_task requires IN_PROGRESS state
 - request_changes/approve_task require REVIEW state
 - Always check_active_task before starting new work
-- Call update_progress frequently to checkpoint`;
+- Call update_progress frequently to checkpoint
+- Agent must have git/gh CLI configured for local git operations`;
 async function createMCPServer() {
   const server = new import_mcp.McpServer(
     {
@@ -1279,7 +1398,7 @@ async function createMCPServer() {
   server.registerTool(
     "list_tasks",
     {
-      description: "Query tasks with filters. Use state=READY for assignable tasks, state=REVIEW for pending reviews.",
+      description: "Query tasks with filters. Use state=TODO for assignable tasks, state=REVIEW for pending reviews.",
       inputSchema: {
         projectId: import_zod3.z.string().optional().describe("Filter by project ID"),
         state: import_zod3.z.nativeEnum(TaskState).optional().describe("Filter by task state"),
@@ -1339,11 +1458,11 @@ async function createMCPServer() {
   server.registerTool(
     "assign_task",
     {
-      description: "Atomically claim a task and create git branch. Race-safe - fails if already assigned. Task must be READY.",
+      description: "Atomically claim a task and create git branch. Race-safe - fails if already assigned. Task must be TODO.",
       inputSchema: {
         projectId: import_zod3.z.string().describe("The project ID"),
         taskId: import_zod3.z.string().describe("The task ID to assign"),
-        expectedState: import_zod3.z.nativeEnum(TaskState).optional().describe("Expected task state (default: READY)")
+        expectedState: import_zod3.z.nativeEnum(TaskState).optional().describe("Expected task state (default: TODO)")
       }
     },
     async (args) => {
@@ -1412,7 +1531,7 @@ async function createMCPServer() {
   server.registerTool(
     "complete_task",
     {
-      description: "Finish task and create pull request. Moves task to REVIEW. Requires IN_PROGRESS state.",
+      description: "Prepare task for PR creation. Returns PR suggestions. After creating PR locally, call report_pr to transition to REVIEW. Requires IN_PROGRESS state.",
       inputSchema: {
         projectId: import_zod3.z.string().describe("The project ID"),
         taskId: import_zod3.z.string().describe("The task ID to complete"),
@@ -1570,7 +1689,7 @@ async function createMCPServer() {
   server.registerTool(
     "abandon_task",
     {
-      description: "Release task assignment and optionally clean up branch. Task returns to READY. Use after errors.",
+      description: "Release task assignment and optionally clean up branch. Task returns to TODO. Use after errors.",
       inputSchema: {
         projectId: import_zod3.z.string().describe("The project ID"),
         taskId: import_zod3.z.string().describe("The task ID to abandon"),
@@ -1603,6 +1722,80 @@ async function createMCPServer() {
       }
     }
   );
+  server.registerTool(
+    "report_branch",
+    {
+      description: "Report a branch created by the agent. Call after using git to create and push a branch. Task must be IN_PROGRESS.",
+      inputSchema: {
+        projectId: import_zod3.z.string().describe("The project ID"),
+        taskId: import_zod3.z.string().describe("The task ID"),
+        branchName: import_zod3.z.string().describe("Name of the branch created (e.g., feature/TASK-123-fix-login)")
+      }
+    },
+    async (args) => {
+      assertApiKeyPermission(
+        mockApiKey,
+        ApiKeyPermission.WRITE,
+        "report_branch"
+      );
+      const validated = ReportBranchInputSchema.parse(args);
+      try {
+        const result = await apiClient.reportBranch(
+          validated.taskId,
+          validated.projectId,
+          validated.branchName
+        );
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        return handleApiError(error);
+      }
+    }
+  );
+  server.registerTool(
+    "report_pr",
+    {
+      description: "Report a PR created by the agent. Call after using gh pr create. Transitions task to REVIEW state.",
+      inputSchema: {
+        projectId: import_zod3.z.string().describe("The project ID"),
+        taskId: import_zod3.z.string().describe("The task ID"),
+        pullRequestUrl: import_zod3.z.string().describe("Full URL of the created PR (e.g., https://github.com/owner/repo/pull/123)"),
+        pullRequestNumber: import_zod3.z.number().describe("PR number (e.g., 123)")
+      }
+    },
+    async (args) => {
+      assertApiKeyPermission(
+        mockApiKey,
+        ApiKeyPermission.WRITE,
+        "report_pr"
+      );
+      const validated = ReportPRInputSchema.parse(args);
+      try {
+        const result = await apiClient.reportPR(
+          validated.taskId,
+          validated.projectId,
+          validated.pullRequestUrl,
+          validated.pullRequestNumber
+        );
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        return handleApiError(error);
+      }
+    }
+  );
   server.registerTool(
     "archive_task",
     {
@@ -1710,7 +1903,7 @@ async function createMCPServer() {
   server.registerTool(
     "create_task",
     {
-      description: "Create task with title, description, acceptance criteria. Starts in BACKLOG. Priority: LOW/MEDIUM/HIGH/CRITICAL.",
+      description: "Create task with title, description, acceptance criteria. Starts in DRAFT. Priority: LOW/MEDIUM/HIGH/CRITICAL.",
       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"),
@@ -1827,6 +2020,119 @@ async function createMCPServer() {
       }
     }
   );
+  server.registerTool(
+    "verify_task",
+    {
+      description: "Verify a DRAFT task and move it to TODO state. Requires task to pass programmatic validation (title 10+ chars, description 50+ chars, each criterion 20+ chars). If approved=false, stores feedback with NEEDS_REVISION status.",
+      inputSchema: {
+        projectId: import_zod3.z.string().describe("The project ID"),
+        taskId: import_zod3.z.string().describe("The task ID to verify"),
+        approved: import_zod3.z.boolean().describe("Whether to approve the task"),
+        feedback: import_zod3.z.string().optional().describe("Feedback for the task (required if not approved)")
+      }
+    },
+    async (args) => {
+      assertApiKeyPermission(mockApiKey, ApiKeyPermission.WRITE, "verify_task");
+      const validated = VerifyTaskInputSchema.parse(args);
+      try {
+        const result = await apiClient.verifyTask(
+          validated.taskId,
+          validated.projectId,
+          validated.approved,
+          validated.feedback
+        );
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        return handleApiError(error);
+      }
+    }
+  );
+  server.registerTool(
+    "get_task_prompt",
+    {
+      description: "Get state-appropriate prompt for a task. Returns verify prompt for DRAFT, assignment prompt for TODO, or continue prompt for IN_PROGRESS tasks.",
+      inputSchema: {
+        projectId: import_zod3.z.string().describe("The project ID"),
+        taskId: import_zod3.z.string().describe("The task ID")
+      }
+    },
+    async (args) => {
+      assertApiKeyPermission(
+        mockApiKey,
+        ApiKeyPermission.READ,
+        "get_task_prompt"
+      );
+      const validated = GetTaskPromptInputSchema.parse(args);
+      try {
+        const result = await apiClient.getTaskPrompt(
+          validated.taskId,
+          validated.projectId
+        );
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify(result, null, 2)
+            }
+          ]
+        };
+      } catch (error) {
+        return handleApiError(error);
+      }
+    }
+  );
+  server.registerTool(
+    "update_task",
+    {
+      description: "Update task details (title, description, priority, acceptanceCriteria). Only works for DRAFT and TODO states. If task is in TODO state, it reverts to DRAFT and requires re-verification.",
+      inputSchema: {
+        projectId: import_zod3.z.string().describe("The project ID"),
+        taskId: import_zod3.z.string().describe("The task ID to update"),
+        title: import_zod3.z.string().optional().describe("New task title"),
+        description: import_zod3.z.string().optional().describe("New task description"),
+        priority: import_zod3.z.nativeEnum(TaskPriority).optional().describe("New task priority"),
+        acceptanceCriteria: import_zod3.z.array(
+          import_zod3.z.object({
+            id: import_zod3.z.string().optional().describe("Existing criterion ID (for updates)"),
+            description: import_zod3.z.string().describe("Criterion description")
+          })
+        ).optional().describe("New acceptance criteria (replaces existing)")
+      }
+    },
+    async (args) => {
+      assertApiKeyPermission(mockApiKey, ApiKeyPermission.WRITE, "update_task");
+      const validated = UpdateTaskMCPInputSchema.parse(args);
+      try {
+        const result = await apiClient.updateTask(
+          validated.taskId,
+          validated.projectId,
+          {
+            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(
     "get_version",
     {