task-master-neo-sdlc/mcp-server/src/tools/tdd-workflow.js

Enhanced task management system with Neo SDLC agents and MCP tools for comprehensive, AI-driven software development lifecycle management.

/**
 * TDD Workflow MCP Tool
 * 
 * Provides a tool for running TDD workflows for tasks.
 */

import { createToolResponse } from '../core/utils/tool-utils.js';
import { log } from '../../../scripts/modules/utils.js';
import { findTaskById, readJSON } from '../../../scripts/modules/task-manager.js';
import { createAndExecuteTDDWorkflow } from '../../../scripts/modules/ai-services.js';

/**
 * Register the TDD workflow tool with the MCP server
 * @param {Object} server - MCP server instance
 */
export function registerTDDWorkflowTool(server) {
  server.registerTool({
    name: 'tdd_workflow',
    description: 'Run a TDD workflow for a task',
    parameters: {
      type: 'object',
      properties: {
        task_id: {
          type: 'string',
          description: 'ID of the task to run TDD workflow for'
        },
        test_framework: {
          type: 'string',
          description: 'Test framework to use (jest, vitest, mocha, etc.)',
          required: false
        },
        coverage: {
          type: ['string', 'number'],
          description: 'Test coverage threshold (percentage)',
          required: false
        },
        test_types: {
          type: 'string',
          description: 'Test types to run (comma-separated: unit,integration,e2e)',
          required: false
        },
        use_ai: {
          type: 'boolean',
          description: 'Whether to use AI-powered test generation',
          required: false
        },
        setup_cicd: {
          type: 'boolean',
          description: 'Whether to set up CI/CD integration',
          required: false
        },
        collect_metrics: {
          type: 'boolean',
          description: 'Whether to collect and analyze test metrics',
          required: false
        },
        generate_report: {
          type: 'boolean',
          description: 'Whether to generate a test report',
          required: false
        },
        project_root: {
          type: 'string',
          description: 'Project root directory',
          required: false
        }
      },
      required: ['task_id']
    },
    execute: executeTDDWorkflow
  });
}

/**
 * Execute the TDD workflow tool
 * @param {Object} params - Tool parameters
 * @param {Object} context - Tool context
 * @returns {Promise<Object>} Tool response
 */
async function executeTDDWorkflow(params, context) {
  const { session, mcpLog } = context;
  
  try {
    mcpLog.info(`Running TDD workflow for task ${params.task_id}`);
    
    // Parse parameters
    const taskId = parseInt(params.task_id, 10);
    const testFramework = params.test_framework;
    const coverage = params.coverage ? parseInt(params.coverage, 10) : 80;
    const testTypes = params.test_types ? params.test_types.split(',').map(type => type.trim()) : ['unit'];
    const useAI = params.use_ai !== undefined ? params.use_ai : true;
    const setupCICD = params.setup_cicd !== undefined ? params.setup_cicd : false;
    const collectMetrics = params.collect_metrics !== undefined ? params.collect_metrics : true;
    const generateReport = params.generate_report !== undefined ? params.generate_report : true;
    const projectRoot = params.project_root || process.cwd();
    
    // Validate task ID
    if (isNaN(taskId) || taskId <= 0) {
      return createToolResponse({
        error: `Invalid task ID: ${params.task_id}. Task ID must be a positive integer.`
      });
    }
    
    // Get the task
    const tasksPath = 'tasks/tasks.json';
    let tasks;
    
    try {
      tasks = readJSON(tasksPath);
    } catch (error) {
      return createToolResponse({
        error: `Error reading tasks file: ${error.message}`
      });
    }
    
    const task = findTaskById(tasks, taskId);
    
    if (!task) {
      return createToolResponse({
        error: `Task with ID ${taskId} not found`
      });
    }
    
    // Create Agent Workflow System
    const agentWorkflowSystem = {
      projectRoot,
      agents: new Map(),
      registerAgent: async (agent) => {
        agentWorkflowSystem.agents.set(agent.id, agent);
        return agent;
      },
      fetchTaskMasterTaskById: async (id) => {
        return task;
      }
    };
    
    // Run TDD workflow
    mcpLog.info(`Running TDD workflow for task ${taskId}: ${task.title}`);
    mcpLog.info(`Project root: ${projectRoot}`);
    mcpLog.info(`Test framework: ${testFramework || 'auto-detect'}`);
    mcpLog.info(`Test types: ${testTypes.join(', ')}`);
    mcpLog.info(`Coverage threshold: ${coverage}%`);
    mcpLog.info(`AI-powered test generation: ${useAI ? 'enabled' : 'disabled'}`);
    
    const result = await createAndExecuteTDDWorkflow(task, agentWorkflowSystem, {
      testFramework,
      testTypes,
      coverage,
      useAI,
      setupCICD,
      collectMetrics,
      generateReport
    }, session);
    
    mcpLog.info(`TDD workflow completed with ${result.result.success ? 'success' : 'failure'}`);
    
    // Return the result
    return createToolResponse({
      workflow_id: result.workflow.id,
      success: result.result.success,
      test_framework: result.workflow.testConfig.framework,
      project_type: result.projectType,
      test_results: {
        passed: result.result.success,
        message: result.result.message,
        metrics: result.result.metrics
      },
      existing_frameworks: result.existingFrameworks,
      recommended_frameworks: result.recommendedFrameworks
    });
  } catch (error) {
    mcpLog.error(`Error executing TDD workflow: ${error.message}`);
    
    return createToolResponse({
      error: `Error executing TDD workflow: ${error.message}`
    });
  }
}