@prmichaelsen/task-mcp 0.2.0

package/src/tools/task-get-status.spec.ts

@@ -0,0 +1,213 @@
+/**
+ * Tests for task_get_status tool
+ */
+
+import { handleTaskGetStatus, taskGetStatusTool } from './task-get-status.js'
+import { FirebaseClient } from '@/client.js'
+import type { Task } from '@/schemas/task.js'
+
+// Mock FirebaseClient
+jest.mock('@/client.js')
+
+describe('task_get_status', () => {
+  let mockClient: jest.Mocked<FirebaseClient>
+  
+  beforeEach(() => {
+    mockClient = {
+      getTask: jest.fn()
+    } as any
+  })
+  
+  describe('Tool Definition', () => {
+    it('should have correct name', () => {
+      expect(taskGetStatusTool.name).toBe('task_get_status')
+    })
+    
+    it('should have description', () => {
+      expect(taskGetStatusTool.description).toBeTruthy()
+    })
+    
+    it('should require task_id parameter', () => {
+      expect(taskGetStatusTool.inputSchema.required).toContain('task_id')
+    })
+  })
+  
+  describe('Handler', () => {
+    it('should return task status for valid task', async () => {
+      const mockTask: Task = {
+        id: 'task-123',
+        user_id: 'user-456',
+        title: 'Test Task',
+        description: 'Test description',
+        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: 1,
+              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 handleTaskGetStatus(mockClient, { task_id: 'task-123' })
+      const parsed = JSON.parse(result)
+      
+      expect(parsed.task_id).toBe('task-123')
+      expect(parsed.task_title).toBe('Test Task')
+      expect(parsed.status).toBe('in_progress')
+      expect(parsed.overall_progress).toBe(50)
+      expect(parsed.current_milestone).toBeTruthy()
+      expect(parsed.current_milestone.name).toBe('Milestone 1')
+      expect(parsed.current_task).toBeTruthy()
+      expect(parsed.current_task.name).toBe('Task 1')
+    })
+    
+    it('should throw error if task not found', async () => {
+      mockClient.getTask.mockResolvedValue(null)
+      
+      await expect(
+        handleTaskGetStatus(mockClient, { task_id: 'nonexistent' })
+      ).rejects.toThrow('Task not found: nonexistent')
+    })
+    
+    it('should handle task with no current milestone', async () => {
+      const mockTask: Task = {
+        id: 'task-123',
+        user_id: 'user-456',
+        title: 'Test Task',
+        description: 'Test description',
+        status: 'not_started',
+        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 handleTaskGetStatus(mockClient, { task_id: 'task-123' })
+      const parsed = JSON.parse(result)
+      
+      expect(parsed.current_milestone).toBeNull()
+      expect(parsed.current_task).toBeNull()
+      expect(parsed.milestones_summary.total).toBe(0)
+    })
+    
+    it('should include milestones summary', async () => {
+      const mockTask: Task = {
+        id: 'task-123',
+        user_id: 'user-456',
+        title: 'Test Task',
+        description: 'Test description',
+        status: 'in_progress',
+        created_at: '2026-02-16T00:00:00Z',
+        updated_at: '2026-02-16T00:00:00Z',
+        progress: {
+          current_milestone: 'milestone-2',
+          current_task: '',
+          overall_percentage: 50,
+          milestones: [
+            {
+              id: 'milestone-1',
+              name: 'Milestone 1',
+              description: 'First',
+              status: 'completed',
+              progress: 100,
+              tasks_completed: 2,
+              tasks_total: 2
+            },
+            {
+              id: 'milestone-2',
+              name: 'Milestone 2',
+              description: 'Second',
+              status: 'in_progress',
+              progress: 50,
+              tasks_completed: 1,
+              tasks_total: 2
+            },
+            {
+              id: 'milestone-3',
+              name: 'Milestone 3',
+              description: 'Third',
+              status: 'not_started',
+              progress: 0,
+              tasks_completed: 0,
+              tasks_total: 2
+            }
+          ],
+          tasks: {}
+        },
+        execution: {
+          api_messages: [],
+          task_messages: [],
+          tool_results: []
+        },
+        config: {
+          
+          system_prompt: '',
+          auto_approve: true
+        },
+        metadata: undefined
+      }
+      
+      mockClient.getTask.mockResolvedValue(mockTask)
+      
+      const result = await handleTaskGetStatus(mockClient, { task_id: 'task-123' })
+      const parsed = JSON.parse(result)
+      
+      expect(parsed.milestones_summary.total).toBe(3)
+      expect(parsed.milestones_summary.completed).toBe(1)
+      expect(parsed.milestones_summary.in_progress).toBe(1)
+    })
+  })
+})

package/src/tools/task-get-status.ts

@@ -0,0 +1,77 @@
+/**
+ * MCP Tool: task_get_status
+ * 
+ * Get current task status and progress information.
+ * Returns task title, status, current milestone, and overall progress.
+ */
+
+import { FirebaseClient } from '@/client.js'
+
+export const taskGetStatusTool = {
+  name: 'task_get_status',
+  description: 'Get current task status and progress',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      task_id: {
+        type: 'string',
+        description: 'Task ID to get status for'
+      }
+    },
+    required: ['task_id']
+  }
+}
+
+export async function handleTaskGetStatus(
+  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}`)
+    }
+    
+    // Find current milestone details
+    const currentMilestone = task.progress.milestones.find(
+      m => m.id === task.progress.current_milestone
+    )
+    
+    // Find current task item details
+    let currentTaskItem = null
+    if (task.progress.current_task && task.progress.current_milestone) {
+      const milestoneItems = task.progress.tasks[task.progress.current_milestone] || []
+      currentTaskItem = milestoneItems.find(
+        item => item.id === task.progress.current_task
+      )
+    }
+    
+    return JSON.stringify({
+      task_id: task.id,
+      task_title: task.title,
+      status: task.status,
+      overall_progress: task.progress.overall_percentage,
+      current_milestone: currentMilestone ? {
+        id: currentMilestone.id,
+        name: currentMilestone.name,
+        status: currentMilestone.status,
+        progress: currentMilestone.progress,
+        tasks_completed: currentMilestone.tasks_completed,
+        tasks_total: currentMilestone.tasks_total
+      } : null,
+      current_task: currentTaskItem ? {
+        id: currentTaskItem.id,
+        name: currentTaskItem.name,
+        status: currentTaskItem.status
+      } : null,
+      milestones_summary: {
+        total: task.progress.milestones.length,
+        completed: task.progress.milestones.filter(m => m.status === 'completed').length,
+        in_progress: task.progress.milestones.filter(m => m.status === 'in_progress').length
+      }
+    }, null, 2)
+  } catch (error) {
+    throw new Error(`Failed to get task status: ${error instanceof Error ? error.message : String(error)}`)
+  }
+}

package/src/tools/task-report-completion.ts

@@ -0,0 +1,86 @@
+/**
+ * MCP Tool: task_report_completion
+ * 
+ * Agent reports completion of a task item and gets next instructions.
+ * This is a convenience tool that combines completing a task item and getting the next step.
+ */
+
+import { FirebaseClient } from '@/client.js'
+import { handleTaskCompleteTaskItem } from './task-complete-task-item.js'
+import { handleTaskGetNextStep } from './task-get-next-step.js'
+
+export const taskReportCompletionTool = {
+  name: 'task_report_completion',
+  description: 'Report completion of a task item and get next instructions',
+  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 that was completed'
+      },
+      notes: {
+        type: 'string',
+        description: 'Optional notes about the completion'
+      }
+    },
+    required: ['task_id', 'milestone_id', 'task_item_id']
+  }
+}
+
+export async function handleTaskReportCompletion(
+  client: FirebaseClient,
+  args: { 
+    task_id: string
+    milestone_id: string
+    task_item_id: string
+    notes?: string
+  }
+): Promise<string> {
+  try {
+    // Add notes if provided
+    if (args.notes) {
+      await client.updateTaskItem(
+        args.task_id,
+        args.milestone_id,
+        args.task_item_id,
+        { notes: args.notes }
+      )
+    }
+    
+    // Complete the task item
+    const completionResult = await handleTaskCompleteTaskItem(client, {
+      task_id: args.task_id,
+      milestone_id: args.milestone_id,
+      task_item_id: args.task_item_id
+    })
+    
+    // Get next step
+    const nextStepResult = await handleTaskGetNextStep(client, {
+      task_id: args.task_id
+    })
+    
+    const completion = JSON.parse(completionResult)
+    const nextStep = JSON.parse(nextStepResult)
+    
+    return JSON.stringify({
+      completion: {
+        success: completion.success,
+        completed_task: completion.completed_task,
+        milestone_progress: completion.milestone_progress
+      },
+      next_step: nextStep,
+      message: completion.message
+    }, null, 2)
+  } catch (error) {
+    throw new Error(`Failed to report completion: ${error instanceof Error ? error.message : String(error)}`)
+  }
+}

package/src/tools/task-update-progress.ts

@@ -0,0 +1,49 @@
+/**
+ * MCP Tool: task_update_progress
+ * 
+ * Update the overall progress percentage for a task.
+ */
+
+import { FirebaseClient } from '@/client.js'
+
+export const taskUpdateProgressTool = {
+  name: 'task_update_progress',
+  description: 'Update the overall progress percentage for a task',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      task_id: {
+        type: 'string',
+        description: 'Task ID'
+      },
+      percentage: {
+        type: 'number',
+        description: 'Progress percentage (0-100)',
+        minimum: 0,
+        maximum: 100
+      }
+    },
+    required: ['task_id', 'percentage']
+  }
+}
+
+export async function handleTaskUpdateProgress(
+  client: FirebaseClient,
+  args: { task_id: string; percentage: number }
+): Promise<string> {
+  try {
+    // Validate percentage
+    const percentage = Math.min(100, Math.max(0, args.percentage))
+    
+    await client.updateOverallProgress(args.task_id, percentage)
+    
+    return JSON.stringify({
+      success: true,
+      task_id: args.task_id,
+      progress: percentage,
+      message: `Progress updated to ${percentage}%`
+    }, null, 2)
+  } catch (error) {
+    throw new Error(`Failed to update progress: ${error instanceof Error ? error.message : String(error)}`)
+  }
+}

package/src/tools/tools.spec.ts

@@ -0,0 +1,194 @@
+/**
+ * Tests for remaining MCP tools
+ */
+
+import { handleTaskUpdateProgress } from './task-update-progress.js'
+import { handleTaskCompleteTaskItem } from './task-complete-task-item.js'
+import { handleTaskCreateMilestone } from './task-create-milestone.js'
+import { handleTaskCreateTaskItem } from './task-create-task-item.js'
+import { handleTaskAddMessage } from './task-add-message.js'
+import { FirebaseClient } from '@/client.js'
+import type { Task } from '@/schemas/task.js'
+
+jest.mock('@/client.js')
+
+describe('MCP Tools', () => {
+  let mockClient: jest.Mocked<FirebaseClient>
+  
+  beforeEach(() => {
+    mockClient = {
+      updateOverallProgress: jest.fn(),
+      completeTaskItem: jest.fn(),
+      getTask: jest.fn(),
+      updateMilestone: jest.fn(),
+      createMilestone: jest.fn(),
+      createTaskItem: jest.fn(),
+      addMessage: jest.fn()
+    } as any
+  })
+  
+  describe('task_update_progress', () => {
+    it('should update progress successfully', async () => {
+      mockClient.updateOverallProgress.mockResolvedValue(undefined)
+      
+      const result = await handleTaskUpdateProgress(mockClient, {
+        task_id: 'task-123',
+        percentage: 75
+      })
+      
+      const parsed = JSON.parse(result)
+      expect(parsed.success).toBe(true)
+      expect(parsed.progress).toBe(75)
+      expect(mockClient.updateOverallProgress).toHaveBeenCalledWith('task-123', 75)
+    })
+    
+    it('should clamp percentage to 0-100 range', async () => {
+      mockClient.updateOverallProgress.mockResolvedValue(undefined)
+      
+      await handleTaskUpdateProgress(mockClient, {
+        task_id: 'task-123',
+        percentage: 150
+      })
+      
+      expect(mockClient.updateOverallProgress).toHaveBeenCalledWith('task-123', 100)
+    })
+  })
+  
+  describe('task_complete_task_item', () => {
+    it('should complete task item and return next task', async () => {
+      const mockTask: Task = {
+        id: 'task-123',
+        user_id: 'user-456',
+        title: 'Test',
+        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: 0,
+          milestones: [{
+            id: 'milestone-1',
+            name: 'Milestone 1',
+            description: 'Test',
+            status: 'in_progress',
+            progress: 0,
+            tasks_completed: 0,
+            tasks_total: 2
+          }],
+          tasks: {
+            'milestone-1': [
+              { id: 'task-1', name: 'Task 1', description: 'Test', status: 'completed' },
+              { id: 'task-2', name: 'Task 2', description: 'Test', status: 'not_started' }
+            ]
+          }
+        },
+        execution: { api_messages: [], task_messages: [], tool_results: [] },
+        config: { system_prompt: '', auto_approve: true },
+        metadata: undefined
+      }
+      
+      mockClient.completeTaskItem.mockResolvedValue(undefined)
+      mockClient.getTask.mockResolvedValue(mockTask)
+      mockClient.updateMilestone.mockResolvedValue(undefined)
+      
+      const result = await handleTaskCompleteTaskItem(mockClient, {
+        task_id: 'task-123',
+        milestone_id: 'milestone-1',
+        task_item_id: 'task-1'
+      })
+      
+      const parsed = JSON.parse(result)
+      expect(parsed.success).toBe(true)
+      expect(parsed.next_task).toBeTruthy()
+      expect(parsed.next_task.name).toBe('Task 2')
+    })
+  })
+  
+  describe('task_create_milestone', () => {
+    it('should create milestone successfully', async () => {
+      mockClient.createMilestone.mockResolvedValue(undefined)
+      
+      const result = await handleTaskCreateMilestone(mockClient, {
+        task_id: 'task-123',
+        milestone_id: 'milestone-1',
+        name: 'Milestone 1',
+        description: 'Test milestone'
+      })
+      
+      const parsed = JSON.parse(result)
+      expect(parsed.success).toBe(true)
+      expect(parsed.milestone.name).toBe('Milestone 1')
+    })
+  })
+  
+  describe('task_create_task_item', () => {
+    it('should create task item successfully', async () => {
+      const mockTask: Task = {
+        id: 'task-123',
+        user_id: 'user-456',
+        title: 'Test',
+        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: '',
+          overall_percentage: 0,
+          milestones: [{
+            id: 'milestone-1',
+            name: 'Milestone 1',
+            description: 'Test',
+            status: 'in_progress',
+            progress: 0,
+            tasks_completed: 0,
+            tasks_total: 0
+          }],
+          tasks: {
+            'milestone-1': [
+              { id: 'task-1', name: 'Task 1', description: 'Test', status: 'not_started' }
+            ]
+          }
+        },
+        execution: { api_messages: [], task_messages: [], tool_results: [] },
+        config: { system_prompt: '', auto_approve: true },
+        metadata: undefined
+      }
+      
+      mockClient.createTaskItem.mockResolvedValue(undefined)
+      mockClient.getTask.mockResolvedValue(mockTask)
+      mockClient.updateMilestone.mockResolvedValue(undefined)
+      
+      const result = await handleTaskCreateTaskItem(mockClient, {
+        task_id: 'task-123',
+        milestone_id: 'milestone-1',
+        task_item_id: 'task-1',
+        name: 'Task 1',
+        description: 'Test task'
+      })
+      
+      const parsed = JSON.parse(result)
+      expect(parsed.success).toBe(true)
+      expect(parsed.task_item.name).toBe('Task 1')
+    })
+  })
+  
+  describe('task_add_message', () => {
+    it('should add message successfully', async () => {
+      mockClient.addMessage.mockResolvedValue('message-123')
+      
+      const result = await handleTaskAddMessage(mockClient, {
+        task_id: 'task-123',
+        role: 'assistant',
+        content: 'Test message'
+      })
+      
+      const parsed = JSON.parse(result)
+      expect(parsed.success).toBe(true)
+      expect(parsed.message_id).toBe('message-123')
+      expect(parsed.role).toBe('assistant')
+    })
+  })
+})

package/tsconfig.json

@@ -0,0 +1,31 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ES2022",
+    "moduleResolution": "node",
+    "lib": ["ES2022"],
+    "types": ["node", "jest"],
+    
+    "outDir": "./dist",
+    "rootDir": "./src",
+    
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["src/*"]
+    }
+  },
+  
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}