mcp-github-project-manager

---
phase: 06-sub-issues-status-updates
plan: 03
type: execute
wave: 2
depends_on: ["06-01"]
files_modified:
  - src/infrastructure/tools/schemas/status-update-schemas.ts
  - src/infrastructure/tools/status-update-tools.ts
  - src/infrastructure/tools/ToolSchemas.ts
  - src/infrastructure/tools/ToolRegistry.ts
autonomous: true

must_haves:
  truths:
    - "create_status_update tool creates project status update"
    - "list_status_updates tool returns paginated list"
    - "get_status_update tool retrieves single status update"
  artifacts:
    - path: "src/infrastructure/tools/schemas/status-update-schemas.ts"
      provides: "Zod schemas for status update tool inputs and outputs"
      exports: ["CreateStatusUpdateInputSchema", "StatusUpdateOutputSchema", "StatusUpdateListOutputSchema"]
    - path: "src/infrastructure/tools/status-update-tools.ts"
      provides: "3 MCP tool definitions and executors"
      exports: ["createStatusUpdateTool", "listStatusUpdatesTool", "getStatusUpdateTool"]
    - path: "src/infrastructure/tools/ToolRegistry.ts"
      provides: "Tool registration for all status update tools"
      contains: "createStatusUpdateTool"
  key_links:
    - from: "status-update-tools.ts"
      to: "GitHubStatusUpdateRepository"
      via: "executor functions"
      pattern: "createStatusUpdateRepository"
    - from: "ToolRegistry.ts"
      to: "status-update-tools.ts"
      via: "import and registration"
      pattern: "import.*status-update-tools"
---

<objective>
Create 3 MCP tools for project status update management (GHAPI-06 to GHAPI-08).

Purpose: Enable MCP clients to manage GitHub project status updates.
Output: 3 fully-annotated MCP tools with schemas, executors, and proper registration.
</objective>

<execution_context>
@/Users/vivek/.claude/get-shit-done/workflows/execute-plan.md
@/Users/vivek/.claude/get-shit-done/templates/summary.md
</execution_context>

<context>
@.planning/PROJECT.md
@.planning/ROADMAP.md
@.planning/STATE.md
@.planning/phases/06-sub-issues-status-updates/06-RESEARCH.md
@.planning/phases/06-sub-issues-status-updates/06-01-SUMMARY.md
@src/infrastructure/tools/health-tools.ts
@src/infrastructure/tools/ToolSchemas.ts
@src/infrastructure/tools/annotations/tool-annotations.ts
@src/infrastructure/tools/schemas/project-schemas.ts
</context>

<tasks>

<task type="auto">
  <name>Task 1: Create status update Zod schemas</name>
  <files>src/infrastructure/tools/schemas/status-update-schemas.ts</files>
  <action>
Create Zod schemas for status update tools in a new file:

**Input Schemas:**

1. `CreateStatusUpdateInputSchema`:
   - projectId: z.string() - Project node ID (PVT_...)
   - body: z.string().min(1) - Status update body (required, markdown supported)
   - status: z.enum(['ON_TRACK', 'AT_RISK', 'OFF_TRACK', 'COMPLETE', 'INACTIVE']).optional()
   - startDate: z.string().optional() - ISO 8601 date (YYYY-MM-DD)
   - targetDate: z.string().optional() - ISO 8601 date (YYYY-MM-DD)

2. `ListStatusUpdatesInputSchema`:
   - projectId: z.string() - Project node ID
   - first: z.number().optional().default(10)
   - after: z.string().optional() - Cursor for pagination

3. `GetStatusUpdateInputSchema`:
   - statusUpdateId: z.string() - Status update node ID

**Output Schemas:**

1. `StatusUpdateOutputSchema`:
   - id: z.string()
   - body: z.string()
   - bodyHTML: z.string()
   - status: z.enum(['ON_TRACK', 'AT_RISK', 'OFF_TRACK', 'COMPLETE', 'INACTIVE']).nullable()
   - startDate: z.string().nullable()
   - targetDate: z.string().nullable()
   - createdAt: z.string()
   - creator: z.object({
       login: z.string()
     })

2. `StatusUpdateListOutputSchema`:
   - statusUpdates: z.array(StatusUpdateOutputSchema)
   - pageInfo: z.object({
       hasNextPage: z.boolean(),
       endCursor: z.string().nullable()
     })
   - totalCount: z.number()

Export all schemas and inferred types.
  </action>
  <verify>TypeScript compiles. `grep -c "z.object" src/infrastructure/tools/schemas/status-update-schemas.ts` shows schemas defined.</verify>
  <done>status-update-schemas.ts exists with all input and output Zod schemas.</done>
</task>

<task type="auto">
  <name>Task 2: Create status update tool definitions and executors</name>
  <files>src/infrastructure/tools/status-update-tools.ts</files>
  <action>
Create 3 MCP tool definitions following health-tools.ts pattern:

**1. create_status_update (GHAPI-06)**
- name: "create_status_update"
- title: "Create Status Update"
- description: "Creates a new status update for a GitHub project"
- annotations: ANNOTATION_PATTERNS.create
- schema: CreateStatusUpdateInputSchema
- outputSchema: StatusUpdateOutputSchema
- examples: Include example with body and ON_TRACK status

Executor `executeCreateStatusUpdate`:
1. Get token from process.env.GITHUB_TOKEN
2. Create GitHubRepositoryFactory (use owner/repo from project context or dummy values since projectId is global)
3. Create GitHubStatusUpdateRepository
4. Call createStatusUpdate
5. Return structured result with structuredContent

**2. list_status_updates (GHAPI-07)**
- name: "list_status_updates"
- title: "List Status Updates"
- description: "Lists status updates for a GitHub project with pagination"
- annotations: ANNOTATION_PATTERNS.readOnly
- schema: ListStatusUpdatesInputSchema
- outputSchema: StatusUpdateListOutputSchema
- examples: Include example with projectId and first: 10

Executor `executeListStatusUpdates`:
1. Get token from process.env.GITHUB_TOKEN
2. Create repository
3. Call listStatusUpdates with pagination params
4. Return structured result

**3. get_status_update (GHAPI-08)**
- name: "get_status_update"
- title: "Get Status Update"
- description: "Gets a single status update by ID"
- annotations: ANNOTATION_PATTERNS.readOnly
- schema: GetStatusUpdateInputSchema
- outputSchema: StatusUpdateOutputSchema.nullable()
- examples: Include example with statusUpdateId

Executor `executeGetStatusUpdate`:
1. Get token from process.env.GITHUB_TOKEN
2. Create repository
3. Call getStatusUpdate
4. Return structured result (null if not found)

Each executor must:
1. Handle errors with appropriate MCP error codes
2. Return structuredContent for object results
3. Use consistent error messages

Export all tool definitions and executor functions.
  </action>
  <verify>TypeScript compiles. `grep -c "ToolDefinition" src/infrastructure/tools/status-update-tools.ts` shows 3 tool definitions.</verify>
  <done>status-update-tools.ts exports 3 tool definitions with executors.</done>
</task>

<task type="auto">
  <name>Task 3: Register status update tools in ToolRegistry</name>
  <files>src/infrastructure/tools/ToolSchemas.ts, src/infrastructure/tools/ToolRegistry.ts</files>
  <action>
**In ToolSchemas.ts:**
1. Import all status update tools from status-update-tools.ts
2. Re-export them (following existing pattern)

**In ToolRegistry.ts:**
1. Import status update tools:
   ```typescript
   import {
     createStatusUpdateTool,
     listStatusUpdatesTool,
     getStatusUpdateTool,
     executeCreateStatusUpdate,
     executeListStatusUpdates,
     executeGetStatusUpdate,
   } from "./status-update-tools.js";
   ```

2. Add to tools array in registerTools():
   ```typescript
   createStatusUpdateTool,
   listStatusUpdatesTool,
   getStatusUpdateTool,
   ```

3. Add executor mappings in executeTool switch:
   ```typescript
   case "create_status_update":
     return executeCreateStatusUpdate(args);
   case "list_status_updates":
     return executeListStatusUpdates(args);
   case "get_status_update":
     return executeGetStatusUpdate(args);
   ```

Follow the exact patterns used for health_check tool and sub-issue tools.
  </action>
  <verify>TypeScript compiles. `npm run build` succeeds. `grep -c "status_update" src/infrastructure/tools/ToolRegistry.ts` shows all tools registered.</verify>
  <done>All 3 status update tools registered in ToolRegistry with executors wired.</done>
</task>

</tasks>

<verification>
1. `npm run build` succeeds with no TypeScript errors
2. All 3 tools have proper annotations matching research matrix
3. All tools have output schemas matching Zod schemas
4. ToolRegistry registers all 3 status update tools
5. `grep -r "ANNOTATION_PATTERNS" src/infrastructure/tools/status-update-tools.ts` confirms annotation usage
</verification>

<success_criteria>
- 3 Zod input schemas and 2 output schemas defined
- 3 tool definitions with annotations, schemas, and outputSchemas
- 3 executor functions that call GitHubStatusUpdateRepository
- All tools registered in ToolRegistry
- TypeScript compiles without errors
</success_criteria>

<output>
After completion, create `.planning/phases/06-sub-issues-status-updates/06-03-SUMMARY.md`
</output>