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}`); } }