Structured Workflow MCP

Instructions

Implementation Reference

• src/index.ts:210-223 (handler)

  MCP server request handler dispatches compare_analyze_guidance tool calls to handlePhaseGuidance function which returns phase-specific guidance JSON

  case 'setup_guidance':
  case 'audit_inventory_guidance':
  case 'compare_analyze_guidance':
  case 'question_determine_guidance':
  case 'refactor_guidance':
  case 'lint_guidance':
  case 'iterate_guidance':
  case 'present_guidance':
    return {
      content: [{
        type: 'text',
        text: JSON.stringify(await handlePhaseGuidance(name, sessionManager), null, 2)
      }]
    };

• src/tools/phaseGuidance.ts:52-65 (handler)

  Core handler function for all phase guidance tools including compare_analyze_guidance; routes to directive or suggestive mode based on session configuration

  export async function handlePhaseGuidance(
    phaseName: string,
    sessionManager: SessionManager
  ): Promise<PhaseGuidance> {
    const session = sessionManager.getSession();
    const isDirectiveMode = session?.workflowConfig !== undefined;
    
    // Route to appropriate guidance based on mode
    if (isDirectiveMode) {
      return getDirectiveGuidance(phaseName, sessionManager);
    } else {
      return getSuggestiveGuidance(phaseName, sessionManager);
    }
  }

• src/tools/phaseGuidance.ts:17-21 (schema)

  Input schema definition for the compare_analyze_guidance tool (empty object since no parameters required)

  {
    name: 'compare_analyze_guidance',
    description: 'Get guidance for the COMPARE/ANALYZE phase - evaluating approaches',
    inputSchema: { type: 'object', properties: {} }
  },

• src/tools/phaseGuidance.ts:5-50 (registration)

  Function that creates and returns the Tool[] array including compare_analyze_guidance; called during server initialization

  export function createPhaseGuidanceTools(): Tool[] {
    const phaseTools: Tool[] = [
      {
        name: 'setup_guidance',
        description: 'Get guidance for the SETUP phase - initialize workflow and establish patterns',
        inputSchema: { type: 'object', properties: {} }
      },
      {
        name: 'audit_inventory_guidance',
        description: 'Get guidance for the AUDIT_INVENTORY phase - analyze code and catalog changes',
        inputSchema: { type: 'object', properties: {} }
      },
      {
        name: 'compare_analyze_guidance',
        description: 'Get guidance for the COMPARE/ANALYZE phase - evaluating approaches',
        inputSchema: { type: 'object', properties: {} }
      },
      {
        name: 'question_determine_guidance',
        description: 'Get guidance for the QUESTION_DETERMINE phase - clarify and finalize plan',
        inputSchema: { type: 'object', properties: {} }
      },
      {
        name: 'refactor_guidance',
        description: 'Get guidance for the WRITE/REFACTOR phase - implementing changes',
        inputSchema: { type: 'object', properties: {} }
      },
      {
        name: 'lint_guidance',
        description: 'Get guidance for the LINT phase - verifying code quality',
        inputSchema: { type: 'object', properties: {} }
      },
      {
        name: 'iterate_guidance',
        description: 'Get guidance for the ITERATE phase - fixing issues',
        inputSchema: { type: 'object', properties: {} }
      },
      {
        name: 'present_guidance',
        description: 'Get guidance for the PRESENT phase - summarizing work',
        inputSchema: { type: 'object', properties: {} }
      }
    ];
  
    return phaseTools;
  }

• src/tools/phaseGuidance.ts:161-186 (helper)

  Static guidance content returned by the tool in suggestive mode, defining instructions, expected outputs, and next steps for COMPARE_ANALYZE phase

  compare_analyze_guidance: {
    phase: 'COMPARE_ANALYZE',
    objective: 'Evaluate different ways to implement the refactoring',
    instructions: [
      'Consider at least 2-3 different approaches',
      'Think about trade-offs for each approach',
      'Consider factors like complexity, risk, and maintainability',
      'Choose the approach that best fits the requirements',
      'Document why you chose your approach'
    ],
    suggestedApproach: [
      'Start with the simplest approach that could work',
      'Consider a more comprehensive approach',
      'Think about edge cases and error handling',
      'Evaluate performance implications if relevant',
      'Consider future extensibility'
    ],
    expectedOutput: {
      approaches: 'Description of each approach considered',
      prosAndCons: 'Advantages and disadvantages of each',
      recommendation: 'Your chosen approach',
      justification: 'Why this approach is best',
      alternativesIfNeeded: 'Fallback options if issues arise'
    },
    nextPhase: 'Use question_determine_guidance to clarify and finalize your strategy'
  },