get_next_task

Instructions

Implementation Reference

• src/infrastructure/tools/ai-tasks/GetNextTaskTool.ts:27-127 (handler)

  Main handler function that executes the get_next_task tool logic: processes arguments, generates mock tasks, applies filters, sorts by priority/complexity, generates AI analysis, and returns formatted recommendations.

  async function executeGetNextTask(args: GetNextTaskArgs): Promise<MCPResponse> {
    const taskService = new TaskGenerationService();
    
    try {
      // For now, create mock tasks for demonstration
      // In a full implementation, this would integrate with ResourceManager
      const mockTasks = [
        {
          id: 'task-1',
          title: 'Set up project infrastructure',
          description: 'Initialize project structure, CI/CD, and development environment',
          priority: 'high',
          complexity: 4,
          estimatedHours: 8,
          status: 'pending',
          dependencies: [],
          tags: ['setup', 'infrastructure']
        },
        {
          id: 'task-2', 
          title: 'Implement user authentication',
          description: 'Create login, registration, and password reset functionality',
          priority: 'critical',
          complexity: 6,
          estimatedHours: 16,
          status: 'pending',
          dependencies: ['task-1'],
          tags: ['auth', 'security']
        },
        {
          id: 'task-3',
          title: 'Design database schema',
          description: 'Create database tables and relationships for core entities',
          priority: 'high',
          complexity: 5,
          estimatedHours: 12,
          status: 'pending',
          dependencies: ['task-1'],
          tags: ['database', 'design']
        }
      ];
  
      // Apply filters
      let filteredTasks = mockTasks;
      
      if (args.maxComplexity) {
        filteredTasks = filteredTasks.filter(task => task.complexity <= args.maxComplexity!);
      }
      
      if (args.assignee) {
        // Would filter by assignee in real implementation
      }
  
      // Get recommendations (simplified)
      const recommendations = filteredTasks
        .sort((a, b) => {
          // Sort by priority first, then complexity
          const priorityOrder = { critical: 4, high: 3, medium: 2, low: 1 };
          const priorityDiff = (priorityOrder[b.priority as keyof typeof priorityOrder] || 0) - 
                             (priorityOrder[a.priority as keyof typeof priorityOrder] || 0);
          if (priorityDiff !== 0) return priorityDiff;
          return a.complexity - b.complexity; // Prefer lower complexity
        })
        .slice(0, args.limit);
  
      // Calculate sprint fit
      const totalHours = recommendations.reduce((sum, task) => sum + task.estimatedHours, 0);
      const sprintCapacity = args.sprintCapacity || 40;
      const sprintFit = totalHours <= sprintCapacity;
  
      // Generate AI analysis
      const analysis = args.includeAnalysis ? generateTaskAnalysis(recommendations, args) : null;
  
      // Format response
      const summary = formatNextTaskRecommendations(recommendations, analysis, {
        totalHours,
        sprintCapacity,
        sprintFit,
        filtersApplied: getAppliedFilters(args)
      });
      
      return ToolResultFormatter.formatSuccess('get_next_task', {
        summary,
        recommendations,
        analysis,
        metrics: {
          totalTasks: recommendations.length,
          totalHours,
          sprintCapacity,
          sprintFit
        }
      });
  
    } catch (error) {
      process.stderr.write(`Error in get_next_task tool: ${error}\n`);
      return ToolResultFormatter.formatSuccess('get_next_task', {
        error: `Failed to get task recommendations: ${error instanceof Error ? error.message : 'Unknown error'}`,
        success: false
      });
    }
  }

• src/infrastructure/tools/ai-tasks/GetNextTaskTool.ts:8-20 (schema)

  Zod schema defining the input parameters for the get_next_task tool, including optional filters like projectId, assignee, sprintCapacity, etc.

  const getNextTaskSchema = z.object({
    projectId: z.string().optional().describe('Filter tasks by specific project ID'),
    featureId: z.string().optional().describe('Filter tasks by specific feature ID'),
    assignee: z.string().optional().describe('Filter tasks for specific team member'),
    teamSkills: z.array(z.string()).optional().describe('Team skills to match against task requirements'),
    sprintCapacity: z.number().optional().describe('Available hours in current sprint (default: 40)'),
    currentPhase: z.enum(['planning', 'development', 'testing', 'review', 'deployment']).optional()
      .describe('Focus on tasks in specific phase'),
    excludeBlocked: z.boolean().default(true).describe('Whether to exclude blocked tasks'),
    maxComplexity: z.number().min(1).max(10).optional().describe('Maximum task complexity to consider'),
    includeAnalysis: z.boolean().default(true).describe('Whether to include detailed AI analysis'),
    limit: z.number().min(1).max(20).default(5).describe('Maximum number of tasks to recommend')
  });

• src/infrastructure/tools/ToolRegistry.ts:192-199 (registration)

  Registration of the getNextTaskTool in the central ToolRegistry singleton during initialization of built-in AI task management tools.

  this.registerTool(addFeatureTool);
  this.registerTool(generatePRDTool);
  this.registerTool(parsePRDTool);
  this.registerTool(getNextTaskTool);
  this.registerTool(analyzeTaskComplexityTool);
  this.registerTool(expandTaskTool);
  this.registerTool(enhancePRDTool);
  this.registerTool(createTraceabilityMatrixTool);

• src/index.ts:368-369 (registration)

  Dispatch case in the MCP server request handler that routes 'call_tool' requests for get_next_task to the executeGetNextTask function.

  case "get_next_task":
    return await executeGetNextTask(args);

• src/infrastructure/tools/ai-tasks/GetNextTaskTool.ts:287-305 (schema)

  ToolDefinition object for get_next_task including name, description, schema reference, and usage examples.

  export const getNextTaskTool: ToolDefinition<GetNextTaskArgs> = {
    name: "get_next_task",
    description: "Get AI-powered recommendations for the next task to work on based on priorities, dependencies, team capacity, and current project state",
    schema: getNextTaskSchema as unknown as ToolSchema<GetNextTaskArgs>,
    examples: [
      {
        name: "Get next task for development",
        description: "Get the next recommended task for a developer with specific skills",
        args: {
          teamSkills: ["typescript", "react", "node.js"],
          sprintCapacity: 40,
          maxComplexity: 7,
          excludeBlocked: true,
          includeAnalysis: true,
          limit: 3
        }
      }
    ]
  };