@nahisaho/musubix-core 1.0.2 → 1.0.4

package/dist/cli/commands/requirements.js

@@ -12,10 +12,12 @@
  * @see DES-MUSUBIX-001 Section 16-C.1 - requirementsコマンド設計
  * @see TSK-062〜065 - Requirements CLI実装
  */
-import { readFile, writeFile, access } from 'fs/promises';
-import { resolve } from 'path';
+import { readFile, writeFile, access, mkdir } from 'fs/promises';
+import { resolve, join } from 'path';
+import { createInterface } from 'readline';
 import { ExitCode, getGlobalOptions, outputResult } from '../base.js';
 import { createEARSValidator, DEFAULT_EARS_OPTIONS, } from '../../validators/ears-validator.js';
+import { VERSION } from '../../version.js';
 /**
  * Parse EARS requirements from text
  */
@@ -83,6 +85,33 @@ export function registerRequirementsCommand(program) {
     const requirements = program
         .command('requirements')
         .description('Requirements analysis and validation');
+    // requirements new (interactive)
+    requirements
+        .command('new <feature>')
+        .description('Create new requirements through interactive dialogue')
+        .option('-i, --interactive', 'Enable interactive mode (default)', true)
+        .option('-o, --output <file>', 'Output file path')
+        .option('--no-interactive', 'Skip interactive mode')
+        .action(async (feature, options) => {
+        const globalOpts = getGlobalOptions(program);
+        try {
+            if (options.interactive !== false) {
+                await runInteractiveHearing(feature, options.output, globalOpts);
+            }
+            else {
+                // Generate minimal template without interaction
+                const outputPath = options.output ?? `storage/specs/REQ-${feature.toUpperCase()}-001.md`;
+                await generateMinimalTemplate(feature, outputPath, globalOpts);
+            }
+            process.exit(ExitCode.SUCCESS);
+        }
+        catch (error) {
+            if (!globalOpts.quiet) {
+                console.error(`❌ Failed: ${error.message}`);
+            }
+            process.exit(ExitCode.GENERAL_ERROR);
+        }
+    });
     // requirements analyze
     requirements
         .command('analyze <input>')
@@ -399,5 +428,718 @@ function generateMarkdownOutput(result) {
     }
     return output;
 }
+/**
+ * Predefined hearing questions (1問1答)
+ */
+const HEARING_QUESTIONS = [
+    {
+        id: 'purpose',
+        questionJa: 'この機能で解決したい「本当の課題」は何ですか？',
+        questionEn: 'What is the TRUE problem you want to solve with this feature?',
+        required: true,
+        followUp: '具体的なシナリオがあれば教えてください。',
+    },
+    {
+        id: 'targetUser',
+        questionJa: 'この機能を最も必要としているのは誰ですか？（ユーザー種別）',
+        questionEn: 'Who needs this feature the most? (user type)',
+        required: true,
+        followUp: 'そのユーザーの技術レベルは？',
+    },
+    {
+        id: 'successState',
+        questionJa: 'もしこの機能が完璧に動作したら、何が変わりますか？',
+        questionEn: 'If this feature works perfectly, what changes?',
+        required: true,
+    },
+    {
+        id: 'constraints',
+        questionJa: 'この機能で「絶対にやってはいけないこと」はありますか？',
+        questionEn: 'Are there any things this feature must NEVER do?',
+        required: true,
+        followUp: 'セキュリティやパフォーマンスの制約は？',
+    },
+    {
+        id: 'successCriteria',
+        questionJa: 'この機能が「成功した」と言えるのはどんな状態ですか？',
+        questionEn: 'What state indicates this feature is "successful"?',
+        required: true,
+        followUp: '測定可能な指標はありますか？',
+    },
+];
+/**
+ * Ask a single question and wait for response
+ */
+async function askQuestion(rl, question) {
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            resolve(answer.trim());
+        });
+    });
+}
+/**
+ * Read all input lines from pipe (non-TTY mode)
+ */
+async function readPipeInput() {
+    return new Promise((resolve) => {
+        const lines = [];
+        const rl = createInterface({
+            input: process.stdin,
+            output: process.stdout,
+            terminal: false,
+        });
+        rl.on('line', (line) => {
+            lines.push(line.trim());
+        });
+        rl.on('close', () => {
+            resolve(lines);
+        });
+    });
+}
+/**
+ * Run interactive hearing session
+ * Supports both TTY (interactive) and pipe (batch) input
+ */
+async function runInteractiveHearing(feature, outputPath, globalOpts) {
+    const isTTY = process.stdin.isTTY;
+    const context = {
+        feature,
+        purpose: '',
+        targetUser: '',
+        successState: '',
+        constraints: '',
+        successCriteria: '',
+        additionalContext: [],
+    };
+    if (!isTTY) {
+        // Pipe input mode - read all lines at once
+        if (!globalOpts.quiet) {
+            console.log('📋 MUSUBIX Requirements - Batch Input Mode');
+            console.log(`🎯 Feature: ${feature}\n`);
+        }
+        const lines = await readPipeInput();
+        // Map lines to questions (5 main questions + additional)
+        HEARING_QUESTIONS.forEach((q, i) => {
+            if (lines[i]) {
+                context[q.id] = lines[i];
+                if (!globalOpts.quiet) {
+                    console.log(`✓ ${q.id}: ${lines[i]}`);
+                }
+            }
+        });
+        // Remaining lines are additional context
+        for (let i = HEARING_QUESTIONS.length; i < lines.length; i++) {
+            if (lines[i]) {
+                context.additionalContext.push(lines[i]);
+            }
+        }
+    }
+    else {
+        // TTY mode - interactive questioning
+        const rl = createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        console.log('\n' + '═'.repeat(60));
+        console.log('📋 MUSUBIX Requirements - Interactive Hearing');
+        console.log('═'.repeat(60));
+        console.log(`\n🎯 Feature: ${feature}\n`);
+        console.log('1問1答で要件を明確化します。');
+        console.log('空欄でEnterを押すとスキップします。\n');
+        console.log('─'.repeat(60) + '\n');
+        try {
+            // Ask each question one by one
+            for (let i = 0; i < HEARING_QUESTIONS.length; i++) {
+                const q = HEARING_QUESTIONS[i];
+                const questionNum = `[${i + 1}/${HEARING_QUESTIONS.length}]`;
+                console.log(`${questionNum} ${q.questionJa}`);
+                console.log(`    (${q.questionEn})`);
+                const answer = await askQuestion(rl, '\n→ あなたの回答: ');
+                if (answer) {
+                    context[q.id] = answer;
+                    console.log(`✓ 記録しました\n`);
+                    // Ask follow-up if provided and answer was given
+                    if (q.followUp) {
+                        console.log(`   補足質問: ${q.followUp}`);
+                        const followUpAnswer = await askQuestion(rl, '   → (任意): ');
+                        if (followUpAnswer) {
+                            context.additionalContext.push(`${q.id}: ${followUpAnswer}`);
+                        }
+                    }
+                }
+                else if (q.required) {
+                    console.log('⚠️  この質問は重要ですが、後で追記できます。\n');
+                }
+                console.log('');
+            }
+            // Ask for additional requirements
+            console.log('─'.repeat(60));
+            console.log('\n追加の要件や考慮事項はありますか？（完了するには空欄でEnter）\n');
+            let additionalCount = 1;
+            while (true) {
+                const additional = await askQuestion(rl, `追加要件 ${additionalCount}: `);
+                if (!additional)
+                    break;
+                context.additionalContext.push(additional);
+                additionalCount++;
+            }
+            rl.close();
+        }
+        catch (error) {
+            rl.close();
+            throw error;
+        }
+    }
+    // Generate EARS requirements from context
+    if (!globalOpts.quiet) {
+        console.log('\n' + '═'.repeat(60));
+        console.log('📝 EARS要件を生成中...');
+        console.log('═'.repeat(60) + '\n');
+    }
+    const requirements = generateEARSFromContext(context);
+    const document = generateRequirementsDocument(context, requirements);
+    // Determine output path
+    const finalOutputPath = outputPath ?? join('storage', 'specs', `REQ-${feature.toUpperCase()}-001.md`);
+    const fullPath = resolve(process.cwd(), finalOutputPath);
+    // Ensure directory exists
+    const dir = resolve(fullPath, '..');
+    await mkdir(dir, { recursive: true });
+    // Write document
+    await writeFile(fullPath, document, 'utf-8');
+    console.log(`✅ 要件ドキュメントを生成しました: ${finalOutputPath}`);
+    console.log(`\n生成された要件数: ${requirements.length}\n`);
+    // Show preview
+    if (!globalOpts.quiet) {
+        console.log('─'.repeat(60));
+        console.log('📄 プレビュー:\n');
+        console.log(requirements.map((r, i) => `  ${i + 1}. ${r.text.substring(0, 70)}...`).join('\n'));
+        console.log('\n' + '─'.repeat(60));
+    }
+    // Automatic requirements review (Article IV & IX compliance)
+    console.log('\n' + '═'.repeat(60));
+    console.log('🔍 要件レビューを実行中...');
+    console.log('═'.repeat(60) + '\n');
+    const reviewResult = await reviewRequirements(requirements, context);
+    displayReviewResult(reviewResult, globalOpts.quiet ?? false);
+    // Save review result
+    const reviewPath = finalOutputPath.replace('.md', '-REVIEW.md');
+    await writeFile(resolve(process.cwd(), reviewPath), generateReviewDocument(reviewResult), 'utf-8');
+    console.log(`📋 レビュー結果を保存しました: ${reviewPath}`);
+    if (globalOpts.json) {
+        outputResult({
+            success: true,
+            outputPath: finalOutputPath,
+            requirements: requirements.length,
+            context,
+            review: reviewResult,
+        }, globalOpts);
+    }
+}
+/**
+ * Generate EARS requirements from hearing context
+ */
+function generateEARSFromContext(context) {
+    const requirements = [];
+    const feature = context.feature.toLowerCase();
+    let reqIndex = 1;
+    const genId = () => `REQ-${context.feature.toUpperCase()}-${String(reqIndex++).padStart(3, '0')}`;
+    // Generate from purpose (WHY) - Core functionality
+    if (context.purpose) {
+        requirements.push({
+            id: genId(),
+            pattern: 'ubiquitous',
+            text: `The system SHALL provide ${feature} functionality to ${context.purpose}`,
+            priority: 'P0',
+            rationale: `Core purpose: ${context.purpose}`,
+        });
+    }
+    // Generate from target user (WHO) - User-centric requirements
+    if (context.targetUser) {
+        requirements.push({
+            id: genId(),
+            pattern: 'event-driven',
+            text: `WHEN ${context.targetUser} accesses the ${feature}, the system SHALL respond within acceptable time`,
+            priority: 'P1',
+            rationale: `Target user: ${context.targetUser}`,
+        });
+    }
+    // Generate from success state (WHAT-IF) - Expected outcomes
+    if (context.successState) {
+        requirements.push({
+            id: genId(),
+            pattern: 'state-driven',
+            text: `WHILE the ${feature} is active, the system SHALL maintain ${context.successState}`,
+            priority: 'P1',
+            rationale: `Success state: ${context.successState}`,
+        });
+    }
+    // Generate from constraints - Unwanted behaviors
+    if (context.constraints) {
+        const constraints = context.constraints.split(/[,、。]/);
+        for (const constraint of constraints) {
+            if (constraint.trim()) {
+                requirements.push({
+                    id: genId(),
+                    pattern: 'unwanted',
+                    text: `IF ${constraint.trim()}, THEN the system SHALL prevent this behavior and notify the user`,
+                    priority: 'P0',
+                    rationale: `Constraint: ${constraint.trim()}`,
+                });
+            }
+        }
+    }
+    // Generate from success criteria - Validation requirements
+    if (context.successCriteria) {
+        requirements.push({
+            id: genId(),
+            pattern: 'ubiquitous',
+            text: `The system SHALL meet the following success criteria for ${feature}: ${context.successCriteria}`,
+            priority: 'P1',
+            rationale: `Success criteria: ${context.successCriteria}`,
+        });
+    }
+    // Generate from additional context
+    for (const additional of context.additionalContext) {
+        if (additional && !additional.includes(':')) {
+            requirements.push({
+                id: genId(),
+                pattern: 'optional',
+                text: `WHERE applicable, the system SHALL ${additional}`,
+                priority: 'P2',
+                rationale: 'Additional requirement from hearing',
+            });
+        }
+    }
+    return requirements;
+}
+/**
+ * Generate requirements document in Markdown format
+ */
+function generateRequirementsDocument(context, requirements) {
+    const now = new Date().toISOString().split('T')[0];
+    let doc = `# REQ-${context.feature.toUpperCase()}-001: ${context.feature} Requirements
+
+> Generated by MUSUBIX Interactive Hearing v${VERSION}
+> Date: ${now}
+
+## 1. Overview
+
+### 1.1 Feature
+**${context.feature}**
+
+### 1.2 Purpose (WHY)
+${context.purpose || '_Not specified_'}
+
+### 1.3 Target User (WHO)
+${context.targetUser || '_Not specified_'}
+
+### 1.4 Success State (WHAT-IF)
+${context.successState || '_Not specified_'}
+
+### 1.5 Constraints
+${context.constraints || '_Not specified_'}
+
+### 1.6 Success Criteria
+${context.successCriteria || '_Not specified_'}
+
+---
+
+## 2. EARS Requirements
+
+| ID | Pattern | Priority | Requirement |
+|----|---------|----------|-------------|
+${requirements.map(r => `| ${r.id} | ${r.pattern} | ${r.priority} | ${r.text.substring(0, 60)}... |`).join('\n')}
+
+---
+
+## 3. Detailed Requirements
+
+`;
+    for (const req of requirements) {
+        doc += `### ${req.id}
+
+**Pattern**: ${req.pattern}  
+**Priority**: ${req.priority}
+
+> ${req.text}
+
+*Rationale*: ${req.rationale}
+
+---
+
+`;
+    }
+    doc += `## 4. Additional Context
+
+${context.additionalContext.length > 0 ? context.additionalContext.map(c => `- ${c}`).join('\n') : '_No additional context_'}
+
+---
+
+## 5. Traceability
+
+| Requirement | Design | Test |
+|-------------|--------|------|
+${requirements.map(r => `| ${r.id} | DES-${context.feature.toUpperCase()}-??? | TST-${context.feature.toUpperCase()}-??? |`).join('\n')}
+
+---
+
+**Generated by**: MUSUBIX v${VERSION}  
+**Hearing Date**: ${now}
+`;
+    return doc;
+}
+/**
+ * Generate minimal template without interaction
+ */
+async function generateMinimalTemplate(feature, outputPath, globalOpts) {
+    const now = new Date().toISOString().split('T')[0];
+    const fullPath = resolve(process.cwd(), outputPath);
+    const template = `# REQ-${feature.toUpperCase()}-001: ${feature} Requirements
+
+> Generated by MUSUBIX v${VERSION}
+> Date: ${now}
+
+## 1. Overview
+
+### 1.1 Feature
+**${feature}**
+
+### 1.2 Purpose (WHY)
+_TODO: Define the purpose_
+
+### 1.3 Target User (WHO)
+_TODO: Define target users_
+
+### 1.4 Success Criteria
+_TODO: Define success criteria_
+
+---
+
+## 2. EARS Requirements
+
+### REQ-${feature.toUpperCase()}-001 (P0)
+
+**Pattern**: ubiquitous
+
+> The system SHALL [TODO: define core functionality]
+
+---
+
+### REQ-${feature.toUpperCase()}-002 (P1)
+
+**Pattern**: event-driven
+
+> WHEN [TODO: trigger event], the system SHALL [TODO: define response]
+
+---
+
+### REQ-${feature.toUpperCase()}-003 (P1)
+
+**Pattern**: state-driven
+
+> WHILE [TODO: state condition], the system SHALL [TODO: define behavior]
+
+---
+
+## 3. Traceability
+
+| Requirement | Design | Test |
+|-------------|--------|------|
+| REQ-${feature.toUpperCase()}-001 | DES-${feature.toUpperCase()}-??? | TST-${feature.toUpperCase()}-??? |
+
+---
+
+**Generated by**: MUSUBIX v${VERSION}
+`;
+    const dir = resolve(fullPath, '..');
+    await mkdir(dir, { recursive: true });
+    await writeFile(fullPath, template, 'utf-8');
+    if (!globalOpts.quiet) {
+        console.log(`✅ Template created: ${outputPath}`);
+    }
+}
+/**
+ * EARS pattern keywords for validation
+ */
+const EARS_KEYWORDS = {
+    ubiquitous: ['SHALL', 'system'],
+    'event-driven': ['WHEN', 'SHALL'],
+    'state-driven': ['WHILE', 'SHALL'],
+    unwanted: ['SHALL NOT', 'IF', 'THEN'],
+    optional: ['IF', 'THEN', 'SHALL'],
+};
+/**
+ * Review requirements for quality and completeness
+ */
+async function reviewRequirements(requirements, context) {
+    const findings = [];
+    const recommendations = [];
+    let passedChecks = 0;
+    let totalChecks = 0;
+    // 1. Check EARS format compliance (Article IV)
+    totalChecks++;
+    let earsCompliant = true;
+    for (const req of requirements) {
+        const keywords = EARS_KEYWORDS[req.pattern];
+        if (keywords) {
+            const hasKeywords = keywords.every(kw => req.text.toUpperCase().includes(kw.toUpperCase()));
+            if (!hasKeywords) {
+                earsCompliant = false;
+                findings.push({
+                    severity: 'error',
+                    category: 'ears',
+                    requirement: req.id,
+                    message: `EARS pattern '${req.pattern}' requires keywords: ${keywords.join(', ')}`,
+                    suggestion: `Rewrite requirement to include: ${keywords.join(', ')}`,
+                });
+            }
+        }
+    }
+    if (earsCompliant)
+        passedChecks++;
+    // 2. Check completeness (all 5Ws covered)
+    totalChecks++;
+    const completenessIssues = [];
+    if (!context.purpose)
+        completenessIssues.push('WHY (purpose)');
+    if (!context.targetUser)
+        completenessIssues.push('WHO (target user)');
+    if (!context.successState)
+        completenessIssues.push('WHAT-IF (success state)');
+    if (!context.constraints)
+        completenessIssues.push('CONSTRAINTS');
+    if (!context.successCriteria)
+        completenessIssues.push('SUCCESS CRITERIA');
+    if (completenessIssues.length > 0) {
+        findings.push({
+            severity: completenessIssues.length > 2 ? 'error' : 'warning',
+            category: 'completeness',
+            message: `Missing context: ${completenessIssues.join(', ')}`,
+            suggestion: 'Run interactive hearing again to fill missing information',
+        });
+    }
+    else {
+        passedChecks++;
+    }
+    // 3. Check testability
+    totalChecks++;
+    let allTestable = true;
+    for (const req of requirements) {
+        const hasVagueTerms = /always|never|all|any|best|optimal|fast|slow|many|few/i.test(req.text);
+        if (hasVagueTerms) {
+            allTestable = false;
+            findings.push({
+                severity: 'warning',
+                category: 'testability',
+                requirement: req.id,
+                message: 'Contains vague terms that may not be testable',
+                suggestion: 'Replace vague terms with specific, measurable criteria',
+            });
+        }
+    }
+    if (allTestable)
+        passedChecks++;
+    // 4. Check priority distribution
+    totalChecks++;
+    const priorityCounts = {
+        P0: requirements.filter(r => r.priority === 'P0').length,
+        P1: requirements.filter(r => r.priority === 'P1').length,
+        P2: requirements.filter(r => r.priority === 'P2').length,
+    };
+    if (priorityCounts.P0 === 0) {
+        findings.push({
+            severity: 'error',
+            category: 'completeness',
+            message: 'No P0 (must-have) requirements defined',
+            suggestion: 'Ensure at least one core requirement is marked as P0',
+        });
+    }
+    else if (priorityCounts.P0 > requirements.length * 0.5) {
+        findings.push({
+            severity: 'warning',
+            category: 'consistency',
+            message: `Too many P0 requirements (${priorityCounts.P0}/${requirements.length})`,
+            suggestion: 'Review priorities - not everything can be must-have',
+        });
+    }
+    else {
+        passedChecks++;
+    }
+    // 5. Check minimum requirements count
+    totalChecks++;
+    if (requirements.length < 3) {
+        findings.push({
+            severity: 'warning',
+            category: 'completeness',
+            message: `Only ${requirements.length} requirements defined`,
+            suggestion: 'Consider if more requirements are needed for complete coverage',
+        });
+    }
+    else {
+        passedChecks++;
+    }
+    // 6. Check for unique IDs
+    totalChecks++;
+    const ids = requirements.map(r => r.id);
+    const duplicateIds = ids.filter((id, i) => ids.indexOf(id) !== i);
+    if (duplicateIds.length > 0) {
+        findings.push({
+            severity: 'error',
+            category: 'consistency',
+            requirement: duplicateIds[0],
+            message: `Duplicate requirement ID: ${duplicateIds[0]}`,
+            suggestion: 'Ensure all requirement IDs are unique',
+        });
+    }
+    else {
+        passedChecks++;
+    }
+    // Generate recommendations
+    if (findings.filter(f => f.severity === 'error').length > 0) {
+        recommendations.push('⚠️ Address error-level findings before proceeding to design');
+    }
+    if (findings.filter(f => f.category === 'testability').length > 0) {
+        recommendations.push('📝 Make requirements more specific and measurable');
+    }
+    if (completenessIssues.length > 0) {
+        recommendations.push('🔄 Re-run interactive hearing to complete missing context');
+    }
+    if (requirements.length >= 3 && findings.filter(f => f.severity === 'error').length === 0) {
+        recommendations.push('✅ Requirements are ready for design phase');
+    }
+    const score = totalChecks > 0 ? Math.round((passedChecks / totalChecks) * 100) : 0;
+    return {
+        passed: findings.filter(f => f.severity === 'error').length === 0,
+        score,
+        totalChecks,
+        passedChecks,
+        findings,
+        recommendations,
+        constitutionCompliance: {
+            articleIV: earsCompliant,
+            articleV: true, // Traceability section is generated
+            articleIX: score >= 60,
+        },
+    };
+}
+/**
+ * Display review result
+ */
+function displayReviewResult(result, quiet) {
+    if (quiet)
+        return;
+    const statusIcon = result.passed ? '✅' : '❌';
+    console.log(`${statusIcon} レビュー結果: ${result.score}% (${result.passedChecks}/${result.totalChecks} checks)`);
+    console.log('');
+    // Constitution compliance
+    console.log('📜 憲法準拠状況:');
+    console.log(`   Article IV (EARS形式): ${result.constitutionCompliance.articleIV ? '✓' : '✗'}`);
+    console.log(`   Article V (トレーサビリティ): ${result.constitutionCompliance.articleV ? '✓' : '✗'}`);
+    console.log(`   Article IX (品質ゲート): ${result.constitutionCompliance.articleIX ? '✓' : '✗'}`);
+    console.log('');
+    // Findings
+    if (result.findings.length > 0) {
+        console.log('📋 発見事項:');
+        for (const finding of result.findings) {
+            const icon = finding.severity === 'error' ? '🔴' : finding.severity === 'warning' ? '🟡' : '🔵';
+            console.log(`   ${icon} [${finding.category}] ${finding.message}`);
+            if (finding.requirement) {
+                console.log(`      対象: ${finding.requirement}`);
+            }
+            if (finding.suggestion) {
+                console.log(`      💡 ${finding.suggestion}`);
+            }
+        }
+        console.log('');
+    }
+    // Recommendations
+    if (result.recommendations.length > 0) {
+        console.log('💡 推奨事項:');
+        for (const rec of result.recommendations) {
+            console.log(`   ${rec}`);
+        }
+        console.log('');
+    }
+}
+/**
+ * Generate review document
+ */
+function generateReviewDocument(result) {
+    const now = new Date().toISOString().split('T')[0];
+    let doc = `# Requirements Review Report
+
+> Generated by MUSUBIX v${VERSION}
+> Date: ${now}
+
+## Summary
+
+| Metric | Value |
+|--------|-------|
+| **Status** | ${result.passed ? '✅ PASSED' : '❌ FAILED'} |
+| **Score** | ${result.score}% |
+| **Checks Passed** | ${result.passedChecks}/${result.totalChecks} |
+
+## Constitution Compliance
+
+| Article | Name | Status |
+|---------|------|--------|
+| IV | EARS Format | ${result.constitutionCompliance.articleIV ? '✅ Compliant' : '❌ Non-compliant'} |
+| V | Traceability | ${result.constitutionCompliance.articleV ? '✅ Compliant' : '❌ Non-compliant'} |
+| IX | Quality Gates | ${result.constitutionCompliance.articleIX ? '✅ Compliant' : '❌ Non-compliant'} |
+
+## Findings
+
+`;
+    if (result.findings.length === 0) {
+        doc += '_No issues found._\n\n';
+    }
+    else {
+        const errors = result.findings.filter(f => f.severity === 'error');
+        const warnings = result.findings.filter(f => f.severity === 'warning');
+        const infos = result.findings.filter(f => f.severity === 'info');
+        if (errors.length > 0) {
+            doc += '### 🔴 Errors\n\n';
+            for (const f of errors) {
+                doc += `- **[${f.category}]** ${f.message}\n`;
+                if (f.requirement)
+                    doc += `  - Requirement: ${f.requirement}\n`;
+                if (f.suggestion)
+                    doc += `  - 💡 ${f.suggestion}\n`;
+            }
+            doc += '\n';
+        }
+        if (warnings.length > 0) {
+            doc += '### 🟡 Warnings\n\n';
+            for (const f of warnings) {
+                doc += `- **[${f.category}]** ${f.message}\n`;
+                if (f.requirement)
+                    doc += `  - Requirement: ${f.requirement}\n`;
+                if (f.suggestion)
+                    doc += `  - 💡 ${f.suggestion}\n`;
+            }
+            doc += '\n';
+        }
+        if (infos.length > 0) {
+            doc += '### 🔵 Info\n\n';
+            for (const f of infos) {
+                doc += `- **[${f.category}]** ${f.message}\n`;
+            }
+            doc += '\n';
+        }
+    }
+    doc += `## Recommendations
+
+`;
+    for (const rec of result.recommendations) {
+        doc += `- ${rec}\n`;
+    }
+    doc += `
+---
+
+**Reviewed by**: MUSUBIX Automated Review System
+**Review Date**: ${now}
+`;
+    return doc;
+}
 export { parseEARSRequirements };
 //# sourceMappingURL=requirements.js.map