Hi-AI

Instructions

Implementation Reference

• src/tools/planning/analyzeRequirements.ts:37-199 (handler)

  Main handler function that performs requirements analysis: parses input list, applies MoSCoW prioritization, assesses type/complexity/risk/effort/stakeholders, generates breakdowns and formatted Markdown report with recommendations.

  export async function analyzeRequirements(args: {
    requirements: string;
    stakeholders?: string;
    constraints?: string;
    analysisMethod?: string;
  }): Promise<ToolResult> {
    const {
      requirements,
      stakeholders = 'end users, product owner, development team',
      constraints = 'standard timeline and budget constraints',
      analysisMethod = 'moscow'
    } = args;
  
    // Parse requirements
    const requirementList = requirements.split(/[,\n]/).map(r => r.trim()).filter(r => r.length > 0);
    const stakeholderList = stakeholders.split(',').map(s => s.trim());
  
    const analyzedRequirements: Requirement[] = requirementList.map((req, index) => {
      const reqId = `REQ-${String(index + 1).padStart(3, '0')}`;
      
      // Determine requirement type
      let type: 'functional' | 'non-functional' | 'business' | 'technical' = 'functional';
      if (req.toLowerCase().includes('performance') || req.toLowerCase().includes('security') || req.toLowerCase().includes('scalability')) {
        type = 'non-functional';
      } else if (req.toLowerCase().includes('business') || req.toLowerCase().includes('revenue') || req.toLowerCase().includes('cost')) {
        type = 'business';
      } else if (req.toLowerCase().includes('infrastructure') || req.toLowerCase().includes('architecture') || req.toLowerCase().includes('database')) {
        type = 'technical';
      }
  
      // Determine priority using MoSCoW
      let priority: 'must-have' | 'should-have' | 'could-have' | 'wont-have' = 'should-have';
      if (req.toLowerCase().includes('critical') || req.toLowerCase().includes('essential') || req.toLowerCase().includes('required')) {
        priority = 'must-have';
      } else if (req.toLowerCase().includes('important') || req.toLowerCase().includes('needed')) {
        priority = 'should-have';
      } else if (req.toLowerCase().includes('nice') || req.toLowerCase().includes('optional') || req.toLowerCase().includes('enhancement')) {
        priority = 'could-have';
      } else if (req.toLowerCase().includes('future') || req.toLowerCase().includes('later') || req.toLowerCase().includes('v2')) {
        priority = 'wont-have';
      }
  
      // Assess complexity
      let complexity: 'low' | 'medium' | 'high' = 'medium';
      if (req.length > 100 || req.toLowerCase().includes('complex') || req.toLowerCase().includes('integration') || req.toLowerCase().includes('advanced')) {
        complexity = 'high';
      } else if (req.length < 50 || req.toLowerCase().includes('simple') || req.toLowerCase().includes('basic')) {
        complexity = 'low';
      }
  
      // Assess risk
      let risk: 'low' | 'medium' | 'high' = 'low';
      if (req.toLowerCase().includes('external') || req.toLowerCase().includes('third-party') || req.toLowerCase().includes('new technology')) {
        risk = 'high';
      } else if (req.toLowerCase().includes('integration') || req.toLowerCase().includes('performance') || complexity === 'high') {
        risk = 'medium';
      }
  
      // Estimate effort
      let estimatedEffort = '1-5 days';
      if (complexity === 'high') {
        estimatedEffort = '1-3 weeks';
      } else if (complexity === 'low') {
        estimatedEffort = '1-2 days';
      }
  
      // Determine relevant stakeholders
      const relevantStakeholders = stakeholderList.filter(stakeholder => {
        if (type === 'business' && stakeholder.toLowerCase().includes('owner')) return true;
        if (type === 'technical' && stakeholder.toLowerCase().includes('developer')) return true;
        if (type === 'functional' && stakeholder.toLowerCase().includes('user')) return true;
        return true; // Include all by default
      });
  
      return {
        id: reqId,
        title: req.length > 50 ? req.substring(0, 47) + '...' : req,
        description: req,
        type,
        priority,
        complexity,
        risk,
        dependencies: [],
        estimatedEffort,
        stakeholders: relevantStakeholders
      };
    });
  
    const analysis = {
      action: 'analyze_requirements',
      method: analysisMethod,
      totalRequirements: analyzedRequirements.length,
      requirements: analyzedRequirements,
      priorityBreakdown: {
        mustHave: analyzedRequirements.filter(r => r.priority === 'must-have').length,
        shouldHave: analyzedRequirements.filter(r => r.priority === 'should-have').length,
        couldHave: analyzedRequirements.filter(r => r.priority === 'could-have').length,
        wontHave: analyzedRequirements.filter(r => r.priority === 'wont-have').length
      },
      typeBreakdown: {
        functional: analyzedRequirements.filter(r => r.type === 'functional').length,
        nonFunctional: analyzedRequirements.filter(r => r.type === 'non-functional').length,
        business: analyzedRequirements.filter(r => r.type === 'business').length,
        technical: analyzedRequirements.filter(r => r.type === 'technical').length
      },
      riskAssessment: {
        high: analyzedRequirements.filter(r => r.risk === 'high').length,
        medium: analyzedRequirements.filter(r => r.risk === 'medium').length,
        low: analyzedRequirements.filter(r => r.risk === 'low').length
      },
      recommendations: [
        'Focus on Must-Have requirements for MVP',
        'Validate high-risk requirements early',
        'Consider Should-Have items for post-MVP releases',
        'Review Could-Have items based on resource availability',
        'Plan technical requirements to support functional ones'
      ],
      constraints: constraints,
      status: 'success'
    };
  
    // Format output
    let formattedOutput = `# Requirements Analysis\n\n`;
    formattedOutput += `**Analysis Method:** ${analysisMethod.toUpperCase()}  \n`;
    formattedOutput += `**Total Requirements:** ${analysis.totalRequirements}  \n`;
    formattedOutput += `**Constraints:** ${constraints}\n\n`;
  
    formattedOutput += `## Priority Breakdown (MoSCoW)\n`;
    formattedOutput += `- **Must Have:** ${analysis.priorityBreakdown.mustHave}\n`;
    formattedOutput += `- **Should Have:** ${analysis.priorityBreakdown.shouldHave}\n`;
    formattedOutput += `- **Could Have:** ${analysis.priorityBreakdown.couldHave}\n`;
    formattedOutput += `- **Won't Have:** ${analysis.priorityBreakdown.wontHave}\n\n`;
  
    formattedOutput += `## Risk Assessment\n`;
    formattedOutput += `- **High Risk:** ${analysis.riskAssessment.high} requirements\n`;
    formattedOutput += `- **Medium Risk:** ${analysis.riskAssessment.medium} requirements\n`;
    formattedOutput += `- **Low Risk:** ${analysis.riskAssessment.low} requirements\n\n`;
  
    formattedOutput += `## Detailed Requirements\n\n`;
  
    // Group by priority
    const priorities = ['must-have', 'should-have', 'could-have', 'wont-have'] as const;
    priorities.forEach(priority => {
      const reqsForPriority = analyzedRequirements.filter(r => r.priority === priority);
      if (reqsForPriority.length > 0) {
        formattedOutput += `### ${priority.toUpperCase().replace('-', ' ')} (${reqsForPriority.length})\n\n`;
        reqsForPriority.forEach(req => {
          formattedOutput += `**${req.id}:** ${req.title}  \n`;
          formattedOutput += `*Type:* ${req.type} | *Complexity:* ${req.complexity} | *Risk:* ${req.risk} | *Effort:* ${req.estimatedEffort}  \n`;
          formattedOutput += `*Stakeholders:* ${req.stakeholders.join(', ')}\n\n`;
        });
      }
    });
  
    formattedOutput += `## Recommendations\n`;
    analysis.recommendations.forEach(rec => {
      formattedOutput += `- ${rec}\n`;
    });
  
    return {
      content: [{ type: 'text', text: formattedOutput }]
    };
  }

• src/tools/planning/analyzeRequirements.ts:18-35 (schema)

  Input/output schema definition for the tool, defining parameters like requirements (required), stakeholders, constraints, analysisMethod (default 'moscow').

  export const analyzeRequirementsDefinition: ToolDefinition = {
    name: 'analyze_requirements',
    description: 'requirements analysis|what we need|requirements analysis|what we need|analyze requirements|essential features - Analyze project requirements',
    inputSchema: {
      type: 'object',
      properties: {
        requirements: { type: 'string', description: 'List of requirements to analyze' },
        stakeholders: { type: 'string', description: 'Project stakeholders (e.g., users, admins, developers, ...)' },
        constraints: { type: 'string', description: 'Project constraints (timeline, budget, technical, ...)' },
        analysisMethod: { type: 'string', description: 'Analysis method', enum: ['moscow', 'kano', 'value-effort'], default: 'moscow' }
      },
      required: ['requirements']
    },
    annotations: {
      title: 'Analyze Requirements',
      audience: ['user', 'assistant']
    }
  };

• src/index.ts:104-160 (registration)

  Tool is registered by including analyzeRequirementsDefinition in the main tools array used for ListTools endpoint.

  const tools: ToolDefinition[] = [
    // Time Utility Tools
    getCurrentTimeDefinition,
  
    // Semantic Code Analysis Tools (Serena-inspired)
    findSymbolDefinition,
    findReferencesDefinition,
  
    // Sequential Thinking Tools
    createThinkingChainDefinition,
    analyzeProblemDefinition,
    stepByStepAnalysisDefinition,
    breakDownProblemDefinition,
    thinkAloudProcessDefinition,
    formatAsPlanDefinition,
  
    // Browser Development Tools
    monitorConsoleLogsDefinition,
    inspectNetworkRequestsDefinition,
  
    // Memory Management Tools
    saveMemoryDefinition,
    recallMemoryDefinition,
    listMemoriesDefinition,
    deleteMemoryDefinition,
    searchMemoriesDefinition,
    updateMemoryDefinition,
    autoSaveContextDefinition,
    restoreSessionContextDefinition,
    prioritizeMemoryDefinition,
    startSessionDefinition,
  
    // Convention Tools
    getCodingGuideDefinition,
    applyQualityRulesDefinition,
    validateCodeQualityDefinition,
    analyzeComplexityDefinition,
    checkCouplingCohesionDefinition,
    suggestImprovementsDefinition,
  
    // Planning Tools
    generatePrdDefinition,
    createUserStoriesDefinition,
    analyzeRequirementsDefinition,
    featureRoadmapDefinition,
  
    // Prompt Enhancement Tools
    enhancePromptDefinition,
    analyzePromptDefinition,
    enhancePromptGeminiDefinition,
  
    // Reasoning Tools
    applyReasoningFrameworkDefinition,
  
    // UI Preview Tools
    previewUiAsciiDefinition
  ];

• src/index.ts:603-700 (registration)

  Dispatch registration: switch case in executeToolCall function that invokes analyzeRequirements handler for 'analyze_requirements' tool name.

  async function executeToolCall(name: string, args: unknown): Promise<CallToolResult> {
    switch (name) {
      // Time Utility Tools
      case 'get_current_time':
        return await getCurrentTime(args as any) as CallToolResult;
  
      // Semantic Code Analysis Tools
      case 'find_symbol':
        return await findSymbol(args as any) as CallToolResult;
      case 'find_references':
        return await findReferences(args as any) as CallToolResult;
  
      // Sequential Thinking Tools
      case 'create_thinking_chain':
        return await createThinkingChain(args as any) as CallToolResult;
      case 'analyze_problem':
        return await analyzeProblem(args as any) as CallToolResult;
      case 'step_by_step_analysis':
        return await stepByStepAnalysis(args as any) as CallToolResult;
      case 'break_down_problem':
        return await breakDownProblem(args as any) as CallToolResult;
      case 'think_aloud_process':
        return await thinkAloudProcess(args as any) as CallToolResult;
      case 'format_as_plan':
        return await formatAsPlan(args as any) as CallToolResult;
  
      // Browser Development Tools
      case 'monitor_console_logs':
        return await monitorConsoleLogs(args as any) as CallToolResult;
      case 'inspect_network_requests':
        return await inspectNetworkRequests(args as any) as CallToolResult;
  
      // Memory Management Tools
      case 'save_memory':
        return await saveMemory(args as any) as CallToolResult;
      case 'recall_memory':
        return await recallMemory(args as any) as CallToolResult;
      case 'list_memories':
        return await listMemories(args as any) as CallToolResult;
      case 'delete_memory':
        return await deleteMemory(args as any) as CallToolResult;
      case 'search_memories':
        return await searchMemoriesHandler(args as any) as CallToolResult;
      case 'update_memory':
        return await updateMemory(args as any) as CallToolResult;
      case 'auto_save_context':
        return await autoSaveContext(args as any) as CallToolResult;
      case 'restore_session_context':
        return await restoreSessionContext(args as any) as CallToolResult;
      case 'prioritize_memory':
        return await prioritizeMemory(args as any) as CallToolResult;
      case 'start_session':
        return await startSession(args as any) as CallToolResult;
  
      // Convention Tools
      case 'get_coding_guide':
        return await getCodingGuide(args as any) as CallToolResult;
      case 'apply_quality_rules':
        return await applyQualityRules(args as any) as CallToolResult;
      case 'validate_code_quality':
        return await validateCodeQuality(args as any) as CallToolResult;
      case 'analyze_complexity':
        return await analyzeComplexity(args as any) as CallToolResult;
      case 'check_coupling_cohesion':
        return await checkCouplingCohesion(args as any) as CallToolResult;
      case 'suggest_improvements':
        return await suggestImprovements(args as any) as CallToolResult;
  
      // Planning Tools
      case 'generate_prd':
        return await generatePrd(args as any) as CallToolResult;
      case 'create_user_stories':
        return await createUserStories(args as any) as CallToolResult;
      case 'analyze_requirements':
        return await analyzeRequirements(args as any) as CallToolResult;
      case 'feature_roadmap':
        return await featureRoadmap(args as any) as CallToolResult;
  
      // Prompt Enhancement Tools
      case 'enhance_prompt':
        return await enhancePrompt(args as any) as CallToolResult;
      case 'analyze_prompt':
        return await analyzePrompt(args as any) as CallToolResult;
      case 'enhance_prompt_gemini':
        return await enhancePromptGemini(args as any) as CallToolResult;
  
      // Reasoning Tools
      case 'apply_reasoning_framework':
        return await applyReasoningFramework(args as any) as CallToolResult;
  
      // UI Preview Tools
      case 'preview_ui_ascii':
        return await previewUiAscii(args as any) as CallToolResult;
  
      default:
        throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
    }
  }