musubi-sdd 0.7.0 → 0.8.0

package/README.ja.md

@@ -13,7 +13,7 @@ MUSUBIは、6つの主要フレームワークのベスト機能を統合した
   - GitHub Copilot & Cursor: AGENTS.md（公式サポート）
   - その他4エージェント: AGENTS.md（互換形式）
 - 📋 **憲法ガバナンス** - 9つの不変条項 + フェーズ-1ゲートによる品質保証
-- 📝 **EARS要件形式** - 完全なトレーサビリティを持つ明確な要件
+- 📝 **EARS要件ジェネレーター** - 5つのEARSパターンで明確な要件を作成（v0.8.0）
 - 🔄 **差分仕様** - ブラウンフィールドおよびグリーンフィールドプロジェクト対応
 - 🧭 **自動更新プロジェクトメモリ** - ステアリングシステムがアーキテクチャ、技術スタック、製品コンテキストを維持
 - 🚀 **自動オンボーディング** - `musubi-onboard` が既存プロジェクトを分析し、ステアリングドキュメントを生成（2-5分）
@@ -104,6 +104,13 @@ musubi-validate article 3           # テストファースト原則を検証
 musubi-validate gates               # フェーズ-1ゲートを検証
 musubi-validate complexity          # 複雑度制限をチェック
 musubi-validate all -v              # 詳細付き完全検証
+
+# EARS要件の作成（v0.8.0）
+musubi-requirements init "ユーザー認証"  # 要件ドキュメント初期化
+musubi-requirements add                 # インタラクティブに要件追加
+musubi-requirements list                # 全要件リスト表示
+musubi-requirements validate            # EARS形式検証
+musubi-requirements trace               # トレーサビリティマトリクス表示
 ```
 
 ### プロジェクトタイプ

package/README.md

@@ -17,7 +17,7 @@ MUSUBI is a comprehensive SDD (Specification Driven Development) framework that
   - GitHub Copilot & Cursor: AGENTS.md (official support)
   - Other 4 agents: AGENTS.md (compatible format)
 - 📋 **Constitutional Governance** - 9 immutable articles + Phase -1 Gates for quality enforcement
-- 📝 **EARS Requirements Format** - Unambiguous requirements with complete traceability
+- 📝 **EARS Requirements Generator** - Create unambiguous requirements with 5 EARS patterns (v0.8.0)
 - 🔄 **Delta Specifications** - Brownfield and greenfield project support
 - 🧭 **Auto-Updating Project Memory** - Steering system maintains architecture, tech stack, and product context
 - 🚀 **Automatic Onboarding** - `musubi-onboard` analyzes existing projects and generates steering docs (2-5 minutes)
@@ -108,9 +108,13 @@ musubi-validate article 3           # Validate Test-First Imperative
 musubi-validate gates               # Validate Phase -1 Gates
 musubi-validate complexity          # Check complexity limits
 musubi-validate all -v              # Full validation with details
-```
-musubi-share sync                   # Sync across AI platforms
-musubi-share status                 # Show sharing status
+
+# Create EARS requirements (v0.8.0)
+musubi-requirements init "User Authentication"  # Initialize requirements doc
+musubi-requirements add                         # Add requirement interactively
+musubi-requirements list                        # List all requirements
+musubi-requirements validate                    # Validate EARS format
+musubi-requirements trace                       # Show traceability matrix
 ```
 
 ### Project Types

package/bin/musubi-requirements.js

@@ -0,0 +1,330 @@
+#!/usr/bin/env node
+
+/**
+ * MUSUBI Requirements Generator CLI
+ * 
+ * Generates EARS (Easy Approach to Requirements Syntax) formatted requirements
+ * Supports 5 EARS patterns for unambiguous specification
+ * 
+ * Usage:
+ *   musubi-requirements init <feature>          # Initialize requirements document
+ *   musubi-requirements add <pattern> <title>   # Add requirement with EARS pattern
+ *   musubi-requirements list                    # List all requirements
+ *   musubi-requirements validate                # Validate EARS format compliance
+ *   musubi-requirements trace                   # Show traceability matrix
+ */
+
+const { Command } = require('commander');
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const RequirementsGenerator = require('../src/generators/requirements');
+
+const program = new Command();
+
+program
+  .name('musubi-requirements')
+  .description('EARS Requirements Generator - Create unambiguous specifications')
+  .version('0.8.0');
+
+// Initialize requirements document
+program
+  .command('init <feature>')
+  .description('Initialize requirements document for a feature')
+  .option('-o, --output <path>', 'Output directory', 'docs/requirements')
+  .option('-a, --author <name>', 'Author name')
+  .option('--project <name>', 'Project name')
+  .action(async (feature, options) => {
+    try {
+      console.log(chalk.bold(`\n📋 Initializing requirements for: ${feature}\n`));
+      
+      const generator = new RequirementsGenerator(process.cwd());
+      const result = await generator.init(feature, options);
+      
+      console.log(chalk.green('✓ Requirements document created'));
+      console.log(chalk.dim(`  ${result.path}`));
+      console.log();
+      console.log(chalk.bold('Next steps:'));
+      console.log(chalk.dim(`  1. Edit ${result.path}`));
+      console.log(chalk.dim('  2. Add requirements: musubi-requirements add <pattern> <title>'));
+      console.log(chalk.dim('  3. Validate: musubi-requirements validate'));
+      console.log();
+      
+      process.exit(0);
+    } catch (error) {
+      console.error(chalk.red('✗ Error:'), error.message);
+      process.exit(1);
+    }
+  });
+
+// Add requirement with EARS pattern
+program
+  .command('add')
+  .description('Add requirement with EARS pattern (interactive)')
+  .option('-f, --file <path>', 'Requirements file path')
+  .option('-p, --pattern <type>', 'EARS pattern (ubiquitous|event|state|unwanted|optional)')
+  .option('-t, --title <text>', 'Requirement title')
+  .action(async (options) => {
+    try {
+      console.log(chalk.bold('\n📝 Add EARS Requirement\n'));
+      
+      const generator = new RequirementsGenerator(process.cwd());
+      
+      // Find requirements file
+      let reqFile = options.file;
+      if (!reqFile) {
+        const files = await generator.findRequirementsFiles();
+        if (files.length === 0) {
+          console.error(chalk.red('✗ No requirements files found'));
+          console.log(chalk.dim('  Run: musubi-requirements init <feature>'));
+          process.exit(1);
+        }
+        
+        if (files.length === 1) {
+          reqFile = files[0];
+        } else {
+          const answer = await inquirer.prompt([{
+            type: 'list',
+            name: 'file',
+            message: 'Select requirements file:',
+            choices: files
+          }]);
+          reqFile = answer.file;
+        }
+      }
+      
+      // Interactive prompts if not provided
+      let pattern = options.pattern;
+      let title = options.title;
+      
+      if (!pattern || !title) {
+        const answers = await inquirer.prompt([
+          {
+            type: 'list',
+            name: 'pattern',
+            message: 'Select EARS pattern:',
+            choices: [
+              { name: 'Ubiquitous - The [system] SHALL [requirement]', value: 'ubiquitous' },
+              { name: 'Event-Driven - WHEN [event], THEN [system] SHALL [response]', value: 'event' },
+              { name: 'State-Driven - WHILE [state], [system] SHALL [response]', value: 'state' },
+              { name: 'Unwanted Behavior - IF [error], THEN [system] SHALL [response]', value: 'unwanted' },
+              { name: 'Optional Feature - WHERE [feature], [system] SHALL [response]', value: 'optional' }
+            ],
+            when: () => !pattern
+          },
+          {
+            type: 'input',
+            name: 'title',
+            message: 'Requirement title:',
+            when: () => !title,
+            validate: (input) => input.length > 0 || 'Title is required'
+          },
+          {
+            type: 'input',
+            name: 'system',
+            message: 'System/component name:',
+            default: 'system'
+          },
+          {
+            type: 'input',
+            name: 'statement',
+            message: (answers) => {
+              const prompts = {
+                ubiquitous: 'What SHALL the system do?',
+                event: 'What event triggers this? (WHEN...)',
+                state: 'What state/condition? (WHILE...)',
+                unwanted: 'What error/unwanted condition? (IF...)',
+                optional: 'What optional feature? (WHERE...)'
+              };
+              return prompts[answers.pattern || pattern];
+            },
+            validate: (input) => input.length > 0 || 'Statement is required'
+          },
+          {
+            type: 'input',
+            name: 'response',
+            message: 'What SHALL the system do? (response)',
+            validate: (input) => input.length > 0 || 'Response is required'
+          },
+          {
+            type: 'input',
+            name: 'criteria',
+            message: 'Acceptance criteria (comma-separated):',
+            filter: (input) => input.split(',').map(s => s.trim()).filter(s => s.length > 0)
+          }
+        ]);
+        
+        pattern = pattern || answers.pattern;
+        title = title || answers.title;
+        
+        const requirement = {
+          pattern,
+          title,
+          system: answers.system,
+          statement: answers.statement,
+          response: answers.response,
+          criteria: answers.criteria
+        };
+        
+        const result = await generator.addRequirement(reqFile, requirement);
+        
+        console.log(chalk.green('\n✓ Requirement added:'));
+        console.log(chalk.dim(`  ${result.id}: ${title}`));
+        console.log(chalk.bold('\n📄 EARS Statement:'));
+        console.log(chalk.cyan(result.statement));
+        console.log();
+        
+        process.exit(0);
+      }
+    } catch (error) {
+      console.error(chalk.red('✗ Error:'), error.message);
+      process.exit(1);
+    }
+  });
+
+// List all requirements
+program
+  .command('list')
+  .description('List all requirements in the project')
+  .option('-f, --file <path>', 'Specific requirements file')
+  .option('--format <type>', 'Output format (table|json|markdown)', 'table')
+  .action(async (options) => {
+    try {
+      const generator = new RequirementsGenerator(process.cwd());
+      const requirements = await generator.listRequirements(options.file);
+      
+      if (requirements.length === 0) {
+        console.log(chalk.yellow('No requirements found'));
+        process.exit(0);
+      }
+      
+      console.log(chalk.bold(`\n📋 Requirements (${requirements.length} total)\n`));
+      
+      if (options.format === 'json') {
+        console.log(JSON.stringify(requirements, null, 2));
+      } else if (options.format === 'markdown') {
+        requirements.forEach(req => {
+          console.log(`## ${req.id}: ${req.title}`);
+          console.log();
+          console.log(`**Pattern**: ${req.pattern}`);
+          console.log();
+          console.log(req.statement);
+          console.log();
+        });
+      } else {
+        // Table format
+        requirements.forEach(req => {
+          console.log(chalk.bold(`${req.id}: ${req.title}`));
+          console.log(chalk.dim(`  Pattern: ${req.pattern}`));
+          console.log(chalk.cyan(`  ${req.statement.substring(0, 100)}...`));
+          console.log();
+        });
+      }
+      
+      process.exit(0);
+    } catch (error) {
+      console.error(chalk.red('✗ Error:'), error.message);
+      process.exit(1);
+    }
+  });
+
+// Validate EARS format compliance
+program
+  .command('validate')
+  .description('Validate requirements against EARS format')
+  .option('-f, --file <path>', 'Specific requirements file')
+  .option('-v, --verbose', 'Show detailed validation results')
+  .action(async (options) => {
+    try {
+      console.log(chalk.bold('\n🔍 Validating EARS Requirements\n'));
+      
+      const generator = new RequirementsGenerator(process.cwd());
+      const results = await generator.validate(options.file);
+      
+      if (results.passed) {
+        console.log(chalk.green('✓ All requirements valid\n'));
+      } else {
+        console.log(chalk.red('✗ Validation failed\n'));
+      }
+      
+      console.log(chalk.bold('Summary:'));
+      console.log(chalk.dim(`  Total: ${results.total}`));
+      console.log(chalk.green(`  Valid: ${results.valid}`));
+      console.log(chalk.red(`  Invalid: ${results.invalid}`));
+      console.log();
+      
+      if (results.violations.length > 0) {
+        console.log(chalk.bold.red('Violations:'));
+        results.violations.forEach(v => {
+          console.log(chalk.red(`  • ${v}`));
+        });
+        console.log();
+      }
+      
+      if (options.verbose && results.details) {
+        console.log(chalk.bold('Details:'));
+        results.details.forEach(d => {
+          const icon = d.valid ? chalk.green('✓') : chalk.red('✗');
+          console.log(`  ${icon} ${d.id}: ${d.message}`);
+        });
+        console.log();
+      }
+      
+      process.exit(results.passed ? 0 : 1);
+    } catch (error) {
+      console.error(chalk.red('✗ Error:'), error.message);
+      process.exit(1);
+    }
+  });
+
+// Show traceability matrix
+program
+  .command('trace')
+  .description('Show requirements traceability matrix')
+  .option('-f, --file <path>', 'Specific requirements file')
+  .option('--format <type>', 'Output format (table|json|markdown)', 'table')
+  .action(async (options) => {
+    try {
+      console.log(chalk.bold('\n📊 Requirements Traceability Matrix\n'));
+      
+      const generator = new RequirementsGenerator(process.cwd());
+      const matrix = await generator.generateTraceabilityMatrix(options.file);
+      
+      if (options.format === 'json') {
+        console.log(JSON.stringify(matrix, null, 2));
+      } else {
+        console.log(chalk.bold('| Requirement | Design | Code | Tests | Status |'));
+        console.log('|-------------|--------|------|-------|--------|');
+        
+        matrix.forEach(row => {
+          const design = row.design ? '✓' : '-';
+          const code = row.code ? '✓' : '-';
+          const tests = row.tests ? '✓' : '-';
+          const status = row.complete ? chalk.green('Complete') : chalk.yellow('Incomplete');
+          
+          console.log(`| ${row.id} | ${design} | ${code} | ${tests} | ${status} |`);
+        });
+        console.log();
+        
+        const complete = matrix.filter(r => r.complete).length;
+        const total = matrix.length;
+        const percentage = total > 0 ? Math.round((complete / total) * 100) : 0;
+        
+        console.log(chalk.bold('Coverage:'));
+        console.log(chalk.dim(`  ${complete}/${total} requirements traced (${percentage}%)`));
+        console.log();
+      }
+      
+      process.exit(0);
+    } catch (error) {
+      console.error(chalk.red('✗ Error:'), error.message);
+      process.exit(1);
+    }
+  });
+
+// Parse arguments
+program.parse(process.argv);
+
+// Show help if no command provided
+if (!process.argv.slice(2).length) {
+  program.outputHelp();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "musubi-sdd",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "Ultimate Specification Driven Development Tool with 25 Agents for 7 AI Coding Platforms (Claude Code, GitHub Copilot, Cursor, Gemini CLI, Windsurf, Codex, Qwen Code)",
   "main": "src/index.js",
   "bin": {
@@ -11,7 +11,8 @@
     "musubi-sync": "bin/musubi-sync.js",
     "musubi-analyze": "bin/musubi-analyze.js",
     "musubi-share": "bin/musubi-share.js",
-    "musubi-validate": "bin/musubi-validate.js"
+    "musubi-validate": "bin/musubi-validate.js",
+    "musubi-requirements": "bin/musubi-requirements.js"
   },
   "scripts": {
     "test": "jest",

package/src/generators/requirements.js

@@ -0,0 +1,425 @@
+/**
+ * MUSUBI Requirements Generator
+ * 
+ * Generates EARS (Easy Approach to Requirements Syntax) formatted requirements
+ * Complies with Article IV of MUSUBI Constitution
+ * 
+ * EARS Patterns:
+ * 1. Ubiquitous: The [system] SHALL [requirement]
+ * 2. Event-Driven: WHEN [event], THEN [system] SHALL [response]
+ * 3. State-Driven: WHILE [state], [system] SHALL [response]
+ * 4. Unwanted Behavior: IF [error], THEN [system] SHALL [response]
+ * 5. Optional Feature: WHERE [feature], [system] SHALL [response]
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+const { glob } = require('glob');
+
+class RequirementsGenerator {
+  constructor(rootDir) {
+    this.rootDir = rootDir;
+    this.templatePath = path.join(__dirname, '../src/templates/shared/documents/requirements.md');
+  }
+
+  /**
+   * Initialize requirements document for a feature
+   * @param {string} feature - Feature name
+   * @param {object} options - Options (output, author, project)
+   * @returns {Promise<object>} Result with path
+   */
+  async init(feature, options = {}) {
+    const outputDir = path.join(this.rootDir, options.output || 'docs/requirements');
+    await fs.ensureDir(outputDir);
+
+    const fileName = `${this.slugify(feature)}.md`;
+    const filePath = path.join(outputDir, fileName);
+
+    // Check if file exists
+    if (await fs.pathExists(filePath)) {
+      throw new Error(`Requirements file already exists: ${filePath}`);
+    }
+
+    // Load template
+    const template = await fs.readFile(this.templatePath, 'utf-8');
+
+    // Get project name from package.json
+    let projectName = options.project;
+    if (!projectName) {
+      try {
+        const pkg = await fs.readJSON(path.join(this.rootDir, 'package.json'));
+        projectName = pkg.name || 'Project';
+      } catch {
+        projectName = 'Project';
+      }
+    }
+
+    // Get author from git config or options
+    let author = options.author;
+    if (!author) {
+      try {
+        const { execSync } = require('child_process');
+        author = execSync('git config user.name', { encoding: 'utf-8' }).trim();
+      } catch {
+        author = 'Author';
+      }
+    }
+
+    // Replace template variables
+    const content = template
+      .replace(/\{\{FEATURE_NAME\}\}/g, feature)
+      .replace(/\{\{PROJECT_NAME\}\}/g, projectName)
+      .replace(/\{\{DATE\}\}/g, new Date().toISOString().split('T')[0])
+      .replace(/\{\{AUTHOR\}\}/g, author)
+      .replace(/\{\{COMPONENT\}\}/g, this.slugify(feature).toUpperCase());
+
+    await fs.writeFile(filePath, content, 'utf-8');
+
+    return { path: filePath };
+  }
+
+  /**
+   * Find all requirements files in the project
+   * @returns {Promise<string[]>} List of requirements file paths
+   */
+  async findRequirementsFiles() {
+    const patterns = [
+      'docs/requirements/**/*.md',
+      'docs/requirements/*.md',
+      'requirements/**/*.md',
+      'requirements/*.md'
+    ];
+
+    const files = [];
+    for (const pattern of patterns) {
+      const matches = await glob(pattern, { cwd: this.rootDir, absolute: true });
+      files.push(...matches);
+    }
+
+    return [...new Set(files)];
+  }
+
+  /**
+   * Add requirement to file
+   * @param {string} filePath - Requirements file path
+   * @param {object} requirement - Requirement data
+   * @returns {Promise<object>} Result with ID and statement
+   */
+  async addRequirement(filePath, requirement) {
+    // Read existing file
+    const content = await fs.readFile(filePath, 'utf-8');
+
+    // Generate requirement ID
+    const id = this.generateRequirementId(content, requirement.component);
+
+    // Generate EARS statement
+    const statement = this.generateEARSStatement(requirement);
+
+    // Format requirement section
+    const section = this.formatRequirementSection(id, requirement.title, statement, requirement.criteria);
+
+    // Find insertion point (end of Functional Requirements section)
+    const insertionPoint = this.findInsertionPoint(content);
+    const newContent = content.slice(0, insertionPoint) + section + '\n' + content.slice(insertionPoint);
+
+    await fs.writeFile(filePath, newContent, 'utf-8');
+
+    return { id, statement };
+  }
+
+  /**
+   * Generate unique requirement ID
+   * @param {string} content - File content
+   * @param {string} component - Component name
+   * @returns {string} Requirement ID (REQ-XXX-NNN)
+   */
+  generateRequirementId(content, component = 'FEATURE') {
+    const prefix = `REQ-${component.toUpperCase()}-`;
+    const regex = new RegExp(`${this.escapeRegex(prefix)}(\\d+)`, 'g');
+    
+    let maxNum = 0;
+    let match;
+    while ((match = regex.exec(content)) !== null) {
+      const num = parseInt(match[1], 10);
+      if (num > maxNum) maxNum = num;
+    }
+
+    const nextNum = (maxNum + 1).toString().padStart(3, '0');
+    return `${prefix}${nextNum}`;
+  }
+
+  /**
+   * Generate EARS statement based on pattern
+   * @param {object} data - Requirement data
+   * @returns {string} EARS statement
+   */
+  generateEARSStatement(data) {
+    const { pattern, system, statement, response } = data;
+
+    switch (pattern) {
+    case 'ubiquitous':
+      return `The ${system} SHALL ${response}.`;
+
+    case 'event':
+      return `WHEN ${statement}, THEN the ${system} SHALL ${response}.`;
+
+    case 'state':
+      return `WHILE ${statement}, the ${system} SHALL ${response}.`;
+
+    case 'unwanted':
+      return `IF ${statement}, THEN the ${system} SHALL ${response}.`;
+
+    case 'optional':
+      return `WHERE ${statement}, the ${system} SHALL ${response}.`;
+
+    default:
+      throw new Error(`Unknown EARS pattern: ${pattern}`);
+    }
+  }
+
+  /**
+   * Format requirement section
+   * @param {string} id - Requirement ID
+   * @param {string} title - Title
+   * @param {string} statement - EARS statement
+   * @param {string[]} criteria - Acceptance criteria
+   * @returns {string} Formatted section
+   */
+  formatRequirementSection(id, title, statement, criteria = []) {
+    let section = `### ${id}: ${title}\n\n`;
+    section += `${statement}\n\n`;
+
+    if (criteria.length > 0) {
+      section += '**Acceptance Criteria:**\n';
+      criteria.forEach(criterion => {
+        section += `- ${criterion}\n`;
+      });
+      section += '\n';
+    }
+
+    return section;
+  }
+
+  /**
+   * Find insertion point in document
+   * @param {string} content - Document content
+   * @returns {number} Insertion index
+   */
+  findInsertionPoint(content) {
+    // Find end of Functional Requirements section
+    const functionalMatch = content.match(/## Functional Requirements/);
+    if (!functionalMatch) {
+      throw new Error('Functional Requirements section not found');
+    }
+
+    // Find next section header
+    const afterFunctional = content.slice(functionalMatch.index + functionalMatch[0].length);
+    const nextSectionMatch = afterFunctional.match(/\n## [^#]/);
+
+    if (nextSectionMatch) {
+      return functionalMatch.index + functionalMatch[0].length + nextSectionMatch.index;
+    }
+
+    // If no next section, append at end
+    return content.length;
+  }
+
+  /**
+   * List all requirements in file(s)
+   * @param {string} [filePath] - Specific file path
+   * @returns {Promise<object[]>} List of requirements
+   */
+  async listRequirements(filePath = null) {
+    const files = filePath ? [filePath] : await this.findRequirementsFiles();
+    const requirements = [];
+
+    for (const file of files) {
+      const content = await fs.readFile(file, 'utf-8');
+      const reqs = this.parseRequirements(content);
+      requirements.push(...reqs);
+    }
+
+    return requirements;
+  }
+
+  /**
+   * Parse requirements from content
+   * @param {string} content - File content
+   * @returns {object[]} List of requirements
+   */
+  parseRequirements(content) {
+    const requirements = [];
+    const reqRegex = /### (REQ-[A-Z]+-\d+): (.+?)\n\n(.+?)(?=\n###|\n##|$)/gs;
+
+    let match;
+    while ((match = reqRegex.exec(content)) !== null) {
+      const [, id, title, body] = match;
+      const pattern = this.detectEARSPattern(body);
+
+      requirements.push({
+        id,
+        title,
+        statement: body.trim(),
+        pattern
+      });
+    }
+
+    return requirements;
+  }
+
+  /**
+   * Detect EARS pattern in statement
+   * @param {string} statement - EARS statement
+   * @returns {string} Pattern type
+   */
+  detectEARSPattern(statement) {
+    if (statement.startsWith('WHEN')) return 'event';
+    if (statement.startsWith('WHILE')) return 'state';
+    if (statement.startsWith('IF')) return 'unwanted';
+    if (statement.startsWith('WHERE')) return 'optional';
+    if (statement.match(/^The .+ SHALL/)) return 'ubiquitous';
+    return 'unknown';
+  }
+
+  /**
+   * Validate requirements against EARS format
+   * @param {string} [filePath] - Specific file path
+   * @returns {Promise<object>} Validation results
+   */
+  async validate(filePath = null) {
+    const requirements = await this.listRequirements(filePath);
+    const violations = [];
+    const details = [];
+
+    for (const req of requirements) {
+      const errors = this.validateEARSFormat(req);
+      
+      if (errors.length > 0) {
+        violations.push(`${req.id}: ${errors.join(', ')}`);
+        details.push({
+          id: req.id,
+          valid: false,
+          message: errors.join(', ')
+        });
+      } else {
+        details.push({
+          id: req.id,
+          valid: true,
+          message: 'Valid EARS format'
+        });
+      }
+    }
+
+    return {
+      passed: violations.length === 0,
+      total: requirements.length,
+      valid: requirements.length - violations.length,
+      invalid: violations.length,
+      violations,
+      details
+    };
+  }
+
+  /**
+   * Validate single requirement EARS format
+   * @param {object} requirement - Requirement object
+   * @returns {string[]} List of errors
+   */
+  validateEARSFormat(requirement) {
+    const errors = [];
+    const { statement, pattern } = requirement;
+
+    // Check if pattern is recognized
+    if (pattern === 'unknown') {
+      errors.push('Unknown EARS pattern');
+      return errors;
+    }
+
+    // Check for SHALL keyword
+    if (!statement.includes('SHALL')) {
+      errors.push('Missing SHALL keyword');
+    }
+
+    // Pattern-specific validation
+    switch (pattern) {
+    case 'event':
+      if (!statement.startsWith('WHEN') || !statement.includes('THEN')) {
+        errors.push('Event-driven pattern must use WHEN...THEN');
+      }
+      break;
+
+    case 'state':
+      if (!statement.startsWith('WHILE')) {
+        errors.push('State-driven pattern must start with WHILE');
+      }
+      break;
+
+    case 'unwanted':
+      if (!statement.startsWith('IF') || !statement.includes('THEN')) {
+        errors.push('Unwanted behavior pattern must use IF...THEN');
+      }
+      break;
+
+    case 'optional':
+      if (!statement.startsWith('WHERE')) {
+        errors.push('Optional feature pattern must start with WHERE');
+      }
+      break;
+
+    case 'ubiquitous':
+      if (!statement.match(/^The .+ SHALL/)) {
+        errors.push('Ubiquitous pattern must use "The [system] SHALL"');
+      }
+      break;
+    }
+
+    return errors;
+  }
+
+  /**
+   * Generate traceability matrix
+   * @param {string} [filePath] - Specific file path
+   * @returns {Promise<object[]>} Traceability matrix
+   */
+  async generateTraceabilityMatrix(filePath = null) {
+    const requirements = await this.listRequirements(filePath);
+    const matrix = [];
+
+    for (const req of requirements) {
+      // TODO: Scan design docs, code, and tests for traceability
+      matrix.push({
+        id: req.id,
+        title: req.title,
+        design: false,
+        code: false,
+        tests: false,
+        complete: false
+      });
+    }
+
+    return matrix;
+  }
+
+  /**
+   * Convert string to slug
+   * @param {string} str - Input string
+   * @returns {string} Slug
+   */
+  slugify(str) {
+    return str
+      .toLowerCase()
+      .replace(/[^a-z0-9]+/g, '-')
+      .replace(/^-|-$/g, '');
+  }
+
+  /**
+   * Escape regex special characters
+   * @param {string} str - Input string
+   * @returns {string} Escaped string
+   */
+  escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  }
+}
+
+module.exports = RequirementsGenerator;