@prmichaelsen/task-mcp 0.2.0

package/src/tools/task-add-message.ts

@@ -0,0 +1,64 @@
+/**
+ * MCP Tool: task_add_message
+ * 
+ * Add a message to the task conversation thread.
+ */
+
+import { FirebaseClient } from '@/client.js'
+
+export const taskAddMessageTool = {
+  name: 'task_add_message',
+  description: 'Add a message to the task conversation thread',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      task_id: {
+        type: 'string',
+        description: 'Task ID'
+      },
+      role: {
+        type: 'string',
+        enum: ['user', 'assistant', 'system'],
+        description: 'Message role'
+      },
+      content: {
+        type: 'string',
+        description: 'Message content'
+      },
+      metadata: {
+        type: 'object',
+        description: 'Optional metadata (JSON object)'
+      }
+    },
+    required: ['task_id', 'role', 'content']
+  }
+}
+
+export async function handleTaskAddMessage(
+  client: FirebaseClient,
+  args: { 
+    task_id: string
+    role: 'user' | 'assistant' | 'system'
+    content: string
+    metadata?: any
+  }
+): Promise<string> {
+  try {
+    const messageId = await client.addMessage(
+      args.task_id,
+      args.role,
+      args.content,
+      args.metadata
+    )
+    
+    return JSON.stringify({
+      success: true,
+      task_id: args.task_id,
+      message_id: messageId,
+      role: args.role,
+      message: 'Message added to task thread'
+    }, null, 2)
+  } catch (error) {
+    throw new Error(`Failed to add message: ${error instanceof Error ? error.message : String(error)}`)
+  }
+}

package/src/tools/task-complete-task-item.ts

@@ -0,0 +1,86 @@
+/**
+ * MCP Tool: task_complete_task_item
+ * 
+ * Mark a task item as complete and update milestone progress.
+ */
+
+import { FirebaseClient } from '@/client.js'
+
+export const taskCompleteTaskItemTool = {
+  name: 'task_complete_task_item',
+  description: 'Mark a task item as complete',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      task_id: {
+        type: 'string',
+        description: 'Task ID'
+      },
+      milestone_id: {
+        type: 'string',
+        description: 'Milestone ID'
+      },
+      task_item_id: {
+        type: 'string',
+        description: 'Task item ID to complete'
+      }
+    },
+    required: ['task_id', 'milestone_id', 'task_item_id']
+  }
+}
+
+export async function handleTaskCompleteTaskItem(
+  client: FirebaseClient,
+  args: { task_id: string; milestone_id: string; task_item_id: string }
+): Promise<string> {
+  try {
+    // Complete the task item
+    await client.completeTaskItem(args.task_id, args.milestone_id, args.task_item_id)
+    
+    // Get updated task to calculate new progress
+    const task = await client.getTask(args.task_id)
+    
+    if (!task) {
+      throw new Error('Task not found after update')
+    }
+    
+    // Find the milestone
+    const milestone = task.progress.milestones.find(m => m.id === args.milestone_id)
+    const milestoneItems = task.progress.tasks[args.milestone_id] || []
+    const completedCount = milestoneItems.filter(item => item.status === 'completed').length
+    
+    // Update milestone progress
+    const milestoneProgress = milestone ? Math.round((completedCount / milestoneItems.length) * 100) : 0
+    
+    if (milestone && milestone.progress !== milestoneProgress) {
+      await client.updateMilestone(args.task_id, args.milestone_id, {
+        progress: milestoneProgress,
+        tasks_completed: completedCount,
+        tasks_total: milestoneItems.length
+      })
+    }
+    
+    // Find next task
+    const nextTask = milestoneItems.find(
+      item => item.status === 'not_started' || item.status === 'in_progress'
+    )
+    
+    return JSON.stringify({
+      success: true,
+      task_id: args.task_id,
+      completed_task: args.task_item_id,
+      milestone_progress: milestoneProgress,
+      milestone_tasks_completed: completedCount,
+      milestone_tasks_total: milestoneItems.length,
+      next_task: nextTask ? {
+        id: nextTask.id,
+        name: nextTask.name
+      } : null,
+      message: nextTask 
+        ? `Task item completed. Next: ${nextTask.name}`
+        : 'Task item completed. Milestone complete!'
+    }, null, 2)
+  } catch (error) {
+    throw new Error(`Failed to complete task item: ${error instanceof Error ? error.message : String(error)}`)
+  }
+}

package/src/tools/task-create-milestone.ts

@@ -0,0 +1,67 @@
+/**
+ * MCP Tool: task_create_milestone
+ * 
+ * Create a new milestone in a task.
+ */
+
+import { FirebaseClient } from '@/client.js'
+import type { Milestone } from '@/schemas/task.js'
+
+export const taskCreateMilestoneTool = {
+  name: 'task_create_milestone',
+  description: 'Create a new milestone in a task',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      task_id: {
+        type: 'string',
+        description: 'Task ID'
+      },
+      milestone_id: {
+        type: 'string',
+        description: 'Unique milestone ID (e.g., "milestone-1")'
+      },
+      name: {
+        type: 'string',
+        description: 'Milestone name'
+      },
+      description: {
+        type: 'string',
+        description: 'Milestone description'
+      }
+    },
+    required: ['task_id', 'milestone_id', 'name', 'description']
+  }
+}
+
+export async function handleTaskCreateMilestone(
+  client: FirebaseClient,
+  args: { task_id: string; milestone_id: string; name: string; description: string }
+): Promise<string> {
+  try {
+    const milestone: Milestone = {
+      id: args.milestone_id,
+      name: args.name,
+      description: args.description,
+      status: 'not_started',
+      progress: 0,
+      tasks_completed: 0,
+      tasks_total: 0
+    }
+    
+    await client.createMilestone(args.task_id, milestone)
+    
+    return JSON.stringify({
+      success: true,
+      task_id: args.task_id,
+      milestone: {
+        id: milestone.id,
+        name: milestone.name,
+        description: milestone.description
+      },
+      message: `Milestone "${milestone.name}" created successfully`
+    }, null, 2)
+  } catch (error) {
+    throw new Error(`Failed to create milestone: ${error instanceof Error ? error.message : String(error)}`)
+  }
+}

package/src/tools/task-create-task-item.ts

@@ -0,0 +1,91 @@
+/**
+ * MCP Tool: task_create_task_item
+ * 
+ * Create a new task item within a milestone.
+ */
+
+import { FirebaseClient } from '@/client.js'
+import type { TaskItem } from '@/schemas/task.js'
+
+export const taskCreateTaskItemTool = {
+  name: 'task_create_task_item',
+  description: 'Create a new task item within a milestone',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      task_id: {
+        type: 'string',
+        description: 'Task ID'
+      },
+      milestone_id: {
+        type: 'string',
+        description: 'Milestone ID'
+      },
+      task_item_id: {
+        type: 'string',
+        description: 'Unique task item ID (e.g., "task-1")'
+      },
+      name: {
+        type: 'string',
+        description: 'Task item name'
+      },
+      description: {
+        type: 'string',
+        description: 'Task item description'
+      },
+      estimated_hours: {
+        type: 'number',
+        description: 'Estimated hours to complete (optional)'
+      }
+    },
+    required: ['task_id', 'milestone_id', 'task_item_id', 'name', 'description']
+  }
+}
+
+export async function handleTaskCreateTaskItem(
+  client: FirebaseClient,
+  args: { 
+    task_id: string
+    milestone_id: string
+    task_item_id: string
+    name: string
+    description: string
+    estimated_hours?: number
+  }
+): Promise<string> {
+  try {
+    const taskItem: TaskItem = {
+      id: args.task_item_id,
+      name: args.name,
+      description: args.description,
+      status: 'not_started',
+      estimated_hours: args.estimated_hours
+    }
+    
+    await client.createTaskItem(args.task_id, args.milestone_id, taskItem)
+    
+    // Update milestone task count
+    const task = await client.getTask(args.task_id)
+    if (task) {
+      const milestoneItems = task.progress.tasks[args.milestone_id] || []
+      await client.updateMilestone(args.task_id, args.milestone_id, {
+        tasks_total: milestoneItems.length
+      })
+    }
+    
+    return JSON.stringify({
+      success: true,
+      task_id: args.task_id,
+      milestone_id: args.milestone_id,
+      task_item: {
+        id: taskItem.id,
+        name: taskItem.name,
+        description: taskItem.description,
+        estimated_hours: taskItem.estimated_hours
+      },
+      message: `Task item "${taskItem.name}" created in milestone`
+    }, null, 2)
+  } catch (error) {
+    throw new Error(`Failed to create task item: ${error instanceof Error ? error.message : String(error)}`)
+  }
+}

package/src/tools/task-get-next-step.spec.ts

@@ -0,0 +1,136 @@
+/**
+ * Tests for task_get_next_step tool
+ */
+
+import { handleTaskGetNextStep, taskGetNextStepTool } from './task-get-next-step.js'
+import { FirebaseClient } from '@/client.js'
+import type { Task } from '@/schemas/task.js'
+
+jest.mock('@/client.js')
+
+describe('task_get_next_step', () => {
+  let mockClient: jest.Mocked<FirebaseClient>
+  
+  beforeEach(() => {
+    mockClient = {
+      getTask: jest.fn()
+    } as any
+  })
+  
+  describe('Tool Definition', () => {
+    it('should have correct name', () => {
+      expect(taskGetNextStepTool.name).toBe('task_get_next_step')
+    })
+    
+    it('should require task_id parameter', () => {
+      expect(taskGetNextStepTool.inputSchema.required).toContain('task_id')
+    })
+  })
+  
+  describe('Handler', () => {
+    it('should return paused status for paused task', async () => {
+      const mockTask: Task = {
+        id: 'task-123',
+        user_id: 'user-456',
+        title: 'Test Task',
+        description: 'Test',
+        status: 'paused',
+        created_at: '2026-02-16T00:00:00Z',
+        updated_at: '2026-02-16T00:00:00Z',
+        progress: {
+          current_milestone: '',
+          current_task: '',
+          overall_percentage: 0,
+          milestones: [],
+          tasks: {}
+        },
+        execution: { api_messages: [], task_messages: [], tool_results: [] },
+        config: { system_prompt: '', auto_approve: true },
+        metadata: undefined
+      }
+      
+      mockClient.getTask.mockResolvedValue(mockTask)
+      
+      const result = await handleTaskGetNextStep(mockClient, { task_id: 'task-123' })
+      const parsed = JSON.parse(result)
+      
+      expect(parsed.status).toBe('paused')
+      expect(parsed.instructions).toBeNull()
+    })
+    
+    it('should return no_milestone status when no milestones exist', async () => {
+      const mockTask: Task = {
+        id: 'task-123',
+        user_id: 'user-456',
+        title: 'Test Task',
+        description: 'Test',
+        status: 'in_progress',
+        created_at: '2026-02-16T00:00:00Z',
+        updated_at: '2026-02-16T00:00:00Z',
+        progress: {
+          current_milestone: '',
+          current_task: '',
+          overall_percentage: 0,
+          milestones: [],
+          tasks: {}
+        },
+        execution: { api_messages: [], task_messages: [], tool_results: [] },
+        config: { system_prompt: '', auto_approve: true },
+        metadata: undefined
+      }
+      
+      mockClient.getTask.mockResolvedValue(mockTask)
+      
+      const result = await handleTaskGetNextStep(mockClient, { task_id: 'task-123' })
+      const parsed = JSON.parse(result)
+      
+      expect(parsed.status).toBe('no_milestone')
+    })
+    
+    it('should return current task instructions', async () => {
+      const mockTask: Task = {
+        id: 'task-123',
+        user_id: 'user-456',
+        title: 'Test Task',
+        description: 'Test',
+        status: 'in_progress',
+        created_at: '2026-02-16T00:00:00Z',
+        updated_at: '2026-02-16T00:00:00Z',
+        progress: {
+          current_milestone: 'milestone-1',
+          current_task: 'task-1',
+          overall_percentage: 50,
+          milestones: [{
+            id: 'milestone-1',
+            name: 'Milestone 1',
+            description: 'First milestone',
+            status: 'in_progress',
+            progress: 50,
+            tasks_completed: 0,
+            tasks_total: 2
+          }],
+          tasks: {
+            'milestone-1': [{
+              id: 'task-1',
+              name: 'Task 1',
+              description: 'First task',
+              status: 'in_progress'
+            }]
+          }
+        },
+        execution: { api_messages: [], task_messages: [], tool_results: [] },
+        config: { system_prompt: '', auto_approve: true },
+        metadata: undefined
+      }
+      
+      mockClient.getTask.mockResolvedValue(mockTask)
+      
+      const result = await handleTaskGetNextStep(mockClient, { task_id: 'task-123' })
+      const parsed = JSON.parse(result)
+      
+      expect(parsed.status).toBe('in_progress')
+      expect(parsed.current_task.name).toBe('Task 1')
+      expect(parsed.instructions).toContain('Task 1')
+    })
+  })
+})

package/src/tools/task-get-next-step.ts

@@ -0,0 +1,125 @@
+/**
+ * MCP Tool: task_get_next_step
+ * 
+ * Get instructions for the next step in the current task.
+ * Returns the current task item with steps and verification criteria.
+ */
+
+import { FirebaseClient } from '@/client.js'
+
+export const taskGetNextStepTool = {
+  name: 'task_get_next_step',
+  description: 'Get instructions for the next step in the current task',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      task_id: {
+        type: 'string',
+        description: 'Task ID'
+      }
+    },
+    required: ['task_id']
+  }
+}
+
+export async function handleTaskGetNextStep(
+  client: FirebaseClient,
+  args: { task_id: string }
+): Promise<string> {
+  try {
+    const task = await client.getTask(args.task_id)
+    
+    if (!task) {
+      throw new Error(`Task not found: ${args.task_id}`)
+    }
+    
+    // Check if task is paused or completed
+    if (task.status === 'paused') {
+      return JSON.stringify({
+        status: 'paused',
+        message: 'Task is paused. Resume the task to continue.',
+        instructions: null
+      }, null, 2)
+    }
+    
+    if (task.status === 'completed') {
+      return JSON.stringify({
+        status: 'completed',
+        message: 'Task is already completed.',
+        instructions: null
+      }, null, 2)
+    }
+    
+    // Find current milestone
+    const currentMilestone = task.progress.milestones.find(
+      m => m.id === task.progress.current_milestone
+    )
+    
+    if (!currentMilestone) {
+      return JSON.stringify({
+        status: 'no_milestone',
+        message: 'No current milestone. Create milestones to begin work.',
+        instructions: 'Use task_create_milestone to add milestones to this task.'
+      }, null, 2)
+    }
+    
+    // Find current task item
+    const milestoneItems = task.progress.tasks[task.progress.current_milestone] || []
+    const currentTaskItem = milestoneItems.find(
+      item => item.id === task.progress.current_task
+    )
+    
+    if (!currentTaskItem) {
+      // Find next not_started or in_progress task
+      const nextTask = milestoneItems.find(
+        item => item.status === 'not_started' || item.status === 'in_progress'
+      )
+      
+      if (!nextTask) {
+        return JSON.stringify({
+          status: 'milestone_complete',
+          message: `Milestone "${currentMilestone.name}" is complete.`,
+          instructions: 'Move to the next milestone or complete the task.',
+          current_milestone: currentMilestone.name
+        }, null, 2)
+      }
+      
+      return JSON.stringify({
+        status: 'ready',
+        current_milestone: {
+          id: currentMilestone.id,
+          name: currentMilestone.name
+        },
+        next_task: {
+          id: nextTask.id,
+          name: nextTask.name,
+          description: nextTask.description,
+          status: nextTask.status,
+          estimated_hours: nextTask.estimated_hours
+        },
+        instructions: `Begin work on: ${nextTask.name}\n\nDescription: ${nextTask.description}`
+      }, null, 2)
+    }
+    
+    // Return current task item details
+    return JSON.stringify({
+      status: 'in_progress',
+      current_milestone: {
+        id: currentMilestone.id,
+        name: currentMilestone.name,
+        progress: currentMilestone.progress
+      },
+      current_task: {
+        id: currentTaskItem.id,
+        name: currentTaskItem.name,
+        description: currentTaskItem.description,
+        status: currentTaskItem.status,
+        estimated_hours: currentTaskItem.estimated_hours,
+        notes: currentTaskItem.notes
+      },
+      instructions: `Continue work on: ${currentTaskItem.name}\n\nDescription: ${currentTaskItem.description}${currentTaskItem.notes ? `\n\nNotes: ${currentTaskItem.notes}` : ''}`
+    }, null, 2)
+  } catch (error) {
+    throw new Error(`Failed to get next step: ${error instanceof Error ? error.message : String(error)}`)
+  }
+}