compare_analyze_guidance

Evaluate and compare different approaches during development to select optimal solutions based on structured analysis criteria.

Instructions

Get guidance for the COMPARE/ANALYZE phase - evaluating approaches

Input Schema

TableJSON Schema

Name	Required	Description	Default
No arguments

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'
},

Structured Workflow MCP