musubi-sdd 0.8.4 → 0.8.5

package/README.ja.md

@@ -129,6 +129,15 @@ musubi-tasks list --priority P0         # 重要タスクのみ表示
 musubi-tasks update 001 "In Progress"   # タスクステータス更新
 musubi-tasks validate                   # タスク完全性を検証
 musubi-tasks graph                      # 依存関係グラフ表示
+
+# エンドツーエンドトレーサビリティ（v0.8.5）
+musubi-trace matrix                             # トレーサビリティマトリクス生成
+musubi-trace matrix --format markdown > trace.md # Markdownにエクスポート
+musubi-trace coverage                           # カバレッジ統計計算
+musubi-trace coverage --min-coverage 100        # 100%カバレッジ要求
+musubi-trace gaps                               # 孤立した要件/コード検出
+musubi-trace requirement REQ-AUTH-001           # 特定要件をトレース
+musubi-trace validate                           # 100%トレーサビリティ検証（第5条）
 ```
 
 ### プロジェクトタイプ

package/README.md

@@ -133,6 +133,15 @@ musubi-tasks list --priority P0                 # List critical tasks
 musubi-tasks update 001 "In Progress"           # Update task status
 musubi-tasks validate                           # Validate task completeness
 musubi-tasks graph                              # Show dependency graph
+
+# End-to-end traceability (v0.8.5)
+musubi-trace matrix                             # Generate traceability matrix
+musubi-trace matrix --format markdown > trace.md # Export to markdown
+musubi-trace coverage                           # Calculate coverage statistics
+musubi-trace coverage --min-coverage 100        # Require 100% coverage
+musubi-trace gaps                               # Detect orphaned requirements/code
+musubi-trace requirement REQ-AUTH-001           # Trace specific requirement
+musubi-trace validate                           # Validate 100% traceability (Article V)
 ```
 
 ### Project Types

package/bin/musubi-trace.js

@@ -0,0 +1,367 @@
+#!/usr/bin/env node
+
+/**
+ * MUSUBI Traceability System CLI
+ * 
+ * Provides end-to-end traceability from requirements to code to tests
+ * Ensures 100% coverage and detects gaps
+ * 
+ * Usage:
+ *   musubi-trace matrix                      # Generate full traceability matrix
+ *   musubi-trace coverage                    # Calculate requirement coverage
+ *   musubi-trace gaps                        # Detect orphaned requirements/code
+ *   musubi-trace requirement <id>            # Trace specific requirement
+ *   musubi-trace validate                    # Validate 100% coverage
+ */
+
+const { Command } = require('commander');
+const chalk = require('chalk');
+const TraceabilityAnalyzer = require('../src/analyzers/traceability');
+
+const program = new Command();
+
+program
+  .name('musubi-trace')
+  .description('MUSUBI Traceability System - End-to-end requirement traceability')
+  .version('0.8.5');
+
+// Generate traceability matrix
+program
+  .command('matrix')
+  .description('Generate full traceability matrix')
+  .option('-f, --format <type>', 'Output format (table|markdown|json|html)', 'table')
+  .option('-o, --output <path>', 'Output file path')
+  .option('--requirements <path>', 'Requirements directory', 'docs/requirements')
+  .option('--design <path>', 'Design directory', 'docs/design')
+  .option('--tasks <path>', 'Tasks directory', 'docs/tasks')
+  .option('--code <path>', 'Source code directory', 'src')
+  .option('--tests <path>', 'Tests directory', 'tests')
+  .action(async (options) => {
+    try {
+      console.log(chalk.bold('\n📊 Generating Traceability Matrix\n'));
+      
+      const analyzer = new TraceabilityAnalyzer(process.cwd());
+      const matrix = await analyzer.generateMatrix(options);
+      
+      if (options.output) {
+        const fs = require('fs-extra');
+        await fs.writeFile(options.output, analyzer.formatMatrix(matrix, options.format), 'utf-8');
+        console.log(chalk.green(`✓ Matrix saved to ${options.output}`));
+      } else {
+        console.log(analyzer.formatMatrix(matrix, options.format));
+      }
+      
+      console.log();
+      console.log(chalk.bold('Summary:'));
+      console.log(chalk.dim(`  Requirements: ${matrix.summary.totalRequirements}`));
+      console.log(chalk.dim(`  With Design: ${matrix.summary.withDesign} (${matrix.summary.designCoverage}%)`));
+      console.log(chalk.dim(`  With Tasks: ${matrix.summary.withTasks} (${matrix.summary.tasksCoverage}%)`));
+      console.log(chalk.dim(`  With Code: ${matrix.summary.withCode} (${matrix.summary.codeCoverage}%)`));
+      console.log(chalk.dim(`  With Tests: ${matrix.summary.withTests} (${matrix.summary.testsCoverage}%)`));
+      console.log();
+      
+      process.exit(0);
+    } catch (error) {
+      console.error(chalk.red('✗ Error:'), error.message);
+      process.exit(1);
+    }
+  });
+
+// Calculate coverage
+program
+  .command('coverage')
+  .description('Calculate requirement coverage statistics')
+  .option('--requirements <path>', 'Requirements directory', 'docs/requirements')
+  .option('--design <path>', 'Design directory', 'docs/design')
+  .option('--tasks <path>', 'Tasks directory', 'docs/tasks')
+  .option('--code <path>', 'Source code directory', 'src')
+  .option('--tests <path>', 'Tests directory', 'tests')
+  .option('--min-coverage <percent>', 'Minimum required coverage', '100')
+  .action(async (options) => {
+    try {
+      console.log(chalk.bold('\n📈 Calculating Coverage\n'));
+      
+      const analyzer = new TraceabilityAnalyzer(process.cwd());
+      const coverage = await analyzer.calculateCoverage(options);
+      
+      const minCoverage = parseInt(options.minCoverage);
+      
+      console.log(chalk.bold('Coverage Report:'));
+      console.log();
+      
+      const stages = [
+        { name: 'Requirements → Design', value: coverage.designCoverage, color: coverage.designCoverage >= minCoverage ? chalk.green : chalk.red },
+        { name: 'Requirements → Tasks', value: coverage.tasksCoverage, color: coverage.tasksCoverage >= minCoverage ? chalk.green : chalk.red },
+        { name: 'Requirements → Code', value: coverage.codeCoverage, color: coverage.codeCoverage >= minCoverage ? chalk.green : chalk.red },
+        { name: 'Requirements → Tests', value: coverage.testsCoverage, color: coverage.testsCoverage >= minCoverage ? chalk.green : chalk.red }
+      ];
+      
+      stages.forEach(stage => {
+        const bar = '█'.repeat(Math.floor(stage.value / 2));
+        console.log(stage.color(`  ${stage.name.padEnd(25)} ${bar} ${stage.value}%`));
+      });
+      
+      console.log();
+      console.log(chalk.bold('Overall Coverage:'));
+      const overallColor = coverage.overall >= minCoverage ? chalk.green : chalk.red;
+      console.log(overallColor(`  ${coverage.overall}% (min: ${minCoverage}%)`));
+      console.log();
+      
+      if (coverage.overall >= minCoverage) {
+        console.log(chalk.green('✓ Coverage meets requirements\n'));
+        process.exit(0);
+      } else {
+        console.log(chalk.red('✗ Coverage below minimum threshold\n'));
+        process.exit(1);
+      }
+    } catch (error) {
+      console.error(chalk.red('✗ Error:'), error.message);
+      process.exit(1);
+    }
+  });
+
+// Detect gaps
+program
+  .command('gaps')
+  .description('Detect orphaned requirements, design, tasks, and untested code')
+  .option('--requirements <path>', 'Requirements directory', 'docs/requirements')
+  .option('--design <path>', 'Design directory', 'docs/design')
+  .option('--tasks <path>', 'Tasks directory', 'docs/tasks')
+  .option('--code <path>', 'Source code directory', 'src')
+  .option('--tests <path>', 'Tests directory', 'tests')
+  .option('-v, --verbose', 'Show detailed gap information')
+  .action(async (options) => {
+    try {
+      console.log(chalk.bold('\n🔍 Detecting Gaps\n'));
+      
+      const analyzer = new TraceabilityAnalyzer(process.cwd());
+      const gaps = await analyzer.detectGaps(options);
+      
+      let hasGaps = false;
+      
+      if (gaps.orphanedRequirements.length > 0) {
+        hasGaps = true;
+        console.log(chalk.red.bold('Orphaned Requirements (no design/tasks):'));
+        gaps.orphanedRequirements.forEach(req => {
+          console.log(chalk.red(`  • ${req.id}: ${req.title}`));
+          if (options.verbose && req.file) {
+            console.log(chalk.dim(`    ${req.file}`));
+          }
+        });
+        console.log();
+      }
+      
+      if (gaps.orphanedDesign.length > 0) {
+        hasGaps = true;
+        console.log(chalk.yellow.bold('Orphaned Design (no requirements):'));
+        gaps.orphanedDesign.forEach(design => {
+          console.log(chalk.yellow(`  • ${design.id}: ${design.title}`));
+          if (options.verbose && design.file) {
+            console.log(chalk.dim(`    ${design.file}`));
+          }
+        });
+        console.log();
+      }
+      
+      if (gaps.orphanedTasks.length > 0) {
+        hasGaps = true;
+        console.log(chalk.yellow.bold('Orphaned Tasks (no requirements):'));
+        gaps.orphanedTasks.forEach(task => {
+          console.log(chalk.yellow(`  • ${task.id}: ${task.title}`));
+          if (options.verbose && task.file) {
+            console.log(chalk.dim(`    ${task.file}`));
+          }
+        });
+        console.log();
+      }
+      
+      if (gaps.untestedCode.length > 0) {
+        hasGaps = true;
+        console.log(chalk.red.bold('Untested Code (no test coverage):'));
+        gaps.untestedCode.forEach(code => {
+          console.log(chalk.red(`  • ${code.file}:${code.function || code.class}`));
+          if (options.verbose && code.lines) {
+            console.log(chalk.dim(`    Lines: ${code.lines}`));
+          }
+        });
+        console.log();
+      }
+      
+      if (gaps.missingTests.length > 0) {
+        hasGaps = true;
+        console.log(chalk.red.bold('Missing Tests (requirements not tested):'));
+        gaps.missingTests.forEach(req => {
+          console.log(chalk.red(`  • ${req.id}: ${req.title}`));
+        });
+        console.log();
+      }
+      
+      if (!hasGaps) {
+        console.log(chalk.green('✓ No gaps detected - 100% traceability!\n'));
+        process.exit(0);
+      } else {
+        console.log(chalk.bold('Gap Summary:'));
+        console.log(chalk.dim(`  Orphaned Requirements: ${gaps.orphanedRequirements.length}`));
+        console.log(chalk.dim(`  Orphaned Design: ${gaps.orphanedDesign.length}`));
+        console.log(chalk.dim(`  Orphaned Tasks: ${gaps.orphanedTasks.length}`));
+        console.log(chalk.dim(`  Untested Code: ${gaps.untestedCode.length}`));
+        console.log(chalk.dim(`  Missing Tests: ${gaps.missingTests.length}`));
+        console.log();
+        process.exit(1);
+      }
+    } catch (error) {
+      console.error(chalk.red('✗ Error:'), error.message);
+      process.exit(1);
+    }
+  });
+
+// Trace specific requirement
+program
+  .command('requirement <id>')
+  .description('Trace specific requirement through design, tasks, code, and tests')
+  .option('--requirements <path>', 'Requirements directory', 'docs/requirements')
+  .option('--design <path>', 'Design directory', 'docs/design')
+  .option('--tasks <path>', 'Tasks directory', 'docs/tasks')
+  .option('--code <path>', 'Source code directory', 'src')
+  .option('--tests <path>', 'Tests directory', 'tests')
+  .action(async (id, options) => {
+    try {
+      console.log(chalk.bold(`\n🔗 Tracing Requirement: ${id}\n`));
+      
+      const analyzer = new TraceabilityAnalyzer(process.cwd());
+      const trace = await analyzer.traceRequirement(id, options);
+      
+      if (!trace.requirement) {
+        console.log(chalk.red(`✗ Requirement ${id} not found\n`));
+        process.exit(1);
+      }
+      
+      console.log(chalk.bold('Requirement:'));
+      console.log(chalk.cyan(`  ${trace.requirement.id}: ${trace.requirement.title}`));
+      console.log(chalk.dim(`  ${trace.requirement.file}`));
+      console.log();
+      
+      if (trace.design.length > 0) {
+        console.log(chalk.bold('Design:'));
+        trace.design.forEach(d => {
+          console.log(chalk.green(`  ✓ ${d.id}: ${d.title}`));
+          console.log(chalk.dim(`    ${d.file}`));
+        });
+        console.log();
+      } else {
+        console.log(chalk.yellow('⚠ No design found\n'));
+      }
+      
+      if (trace.tasks.length > 0) {
+        console.log(chalk.bold('Tasks:'));
+        trace.tasks.forEach(t => {
+          console.log(chalk.green(`  ✓ ${t.id}: ${t.title} (${t.status})`));
+          console.log(chalk.dim(`    ${t.file}`));
+        });
+        console.log();
+      } else {
+        console.log(chalk.yellow('⚠ No tasks found\n'));
+      }
+      
+      if (trace.code.length > 0) {
+        console.log(chalk.bold('Code:'));
+        trace.code.forEach(c => {
+          console.log(chalk.green(`  ✓ ${c.file}:${c.function || c.class}`));
+          console.log(chalk.dim(`    Lines: ${c.lines}`));
+        });
+        console.log();
+      } else {
+        console.log(chalk.yellow('⚠ No code implementation found\n'));
+      }
+      
+      if (trace.tests.length > 0) {
+        console.log(chalk.bold('Tests:'));
+        trace.tests.forEach(t => {
+          console.log(chalk.green(`  ✓ ${t.file}:${t.test}`));
+          console.log(chalk.dim(`    Status: ${t.status || 'passing'}`));
+        });
+        console.log();
+      } else {
+        console.log(chalk.red('✗ No tests found\n'));
+      }
+      
+      const coverage = {
+        design: trace.design.length > 0,
+        tasks: trace.tasks.length > 0,
+        code: trace.code.length > 0,
+        tests: trace.tests.length > 0
+      };
+      
+      const coveragePercent = Object.values(coverage).filter(Boolean).length * 25;
+      const coverageColor = coveragePercent === 100 ? chalk.green : coveragePercent >= 75 ? chalk.yellow : chalk.red;
+      
+      console.log(chalk.bold('Coverage:'));
+      console.log(coverageColor(`  ${coveragePercent}% (${Object.values(coverage).filter(Boolean).length}/4 stages)`));
+      console.log();
+      
+      process.exit(coveragePercent === 100 ? 0 : 1);
+    } catch (error) {
+      console.error(chalk.red('✗ Error:'), error.message);
+      process.exit(1);
+    }
+  });
+
+// Validate 100% coverage
+program
+  .command('validate')
+  .description('Validate 100% traceability coverage (Constitutional Article V)')
+  .option('--requirements <path>', 'Requirements directory', 'docs/requirements')
+  .option('--design <path>', 'Design directory', 'docs/design')
+  .option('--tasks <path>', 'Tasks directory', 'docs/tasks')
+  .option('--code <path>', 'Source code directory', 'src')
+  .option('--tests <path>', 'Tests directory', 'tests')
+  .option('--strict', 'Fail on any gaps (default: true)', true)
+  .action(async (options) => {
+    try {
+      console.log(chalk.bold('\n🔍 Validating Traceability (Article V)\n'));
+      
+      const analyzer = new TraceabilityAnalyzer(process.cwd());
+      const validation = await analyzer.validate(options);
+      
+      console.log(chalk.bold('Article V: Complete Traceability'));
+      console.log();
+      
+      if (validation.passed) {
+        console.log(chalk.green('✓ 100% traceability achieved'));
+        console.log(chalk.dim(`  Requirements: ${validation.coverage.totalRequirements}`));
+        console.log(chalk.dim(`  Design Coverage: ${validation.coverage.designCoverage}%`));
+        console.log(chalk.dim(`  Tasks Coverage: ${validation.coverage.tasksCoverage}%`));
+        console.log(chalk.dim(`  Code Coverage: ${validation.coverage.codeCoverage}%`));
+        console.log(chalk.dim(`  Test Coverage: ${validation.coverage.testsCoverage}%`));
+        console.log();
+        process.exit(0);
+      } else {
+        console.log(chalk.red('✗ Traceability gaps detected'));
+        console.log();
+        
+        if (validation.gaps.orphanedRequirements.length > 0) {
+          console.log(chalk.red(`  Orphaned Requirements: ${validation.gaps.orphanedRequirements.length}`));
+        }
+        if (validation.gaps.untestedCode.length > 0) {
+          console.log(chalk.red(`  Untested Code: ${validation.gaps.untestedCode.length}`));
+        }
+        if (validation.gaps.missingTests.length > 0) {
+          console.log(chalk.red(`  Missing Tests: ${validation.gaps.missingTests.length}`));
+        }
+        
+        console.log();
+        console.log(chalk.dim('Run `musubi-trace gaps` for detailed gap analysis'));
+        console.log();
+        process.exit(1);
+      }
+    } catch (error) {
+      console.error(chalk.red('✗ Error:'), error.message);
+      process.exit(1);
+    }
+  });
+
+program.parse(process.argv);
+
+if (!process.argv.slice(2).length) {
+  program.outputHelp();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "musubi-sdd",
-  "version": "0.8.4",
+  "version": "0.8.5",
   "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": {
@@ -14,7 +14,8 @@
     "musubi-validate": "bin/musubi-validate.js",
     "musubi-requirements": "bin/musubi-requirements.js",
     "musubi-design": "bin/musubi-design.js",
-    "musubi-tasks": "bin/musubi-tasks.js"
+    "musubi-tasks": "bin/musubi-tasks.js",
+    "musubi-trace": "bin/musubi-trace.js"
   },
   "scripts": {
     "test": "jest",

package/src/analyzers/traceability.js

@@ -0,0 +1,524 @@
+/**
+ * MUSUBI Traceability Analyzer
+ * 
+ * Provides end-to-end traceability from requirements to code to tests
+ * Implements Constitutional Article V: Complete Traceability
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+const glob = require('glob');
+
+class TraceabilityAnalyzer {
+  constructor(workspaceRoot) {
+    this.workspaceRoot = workspaceRoot;
+  }
+
+  /**
+   * Generate full traceability matrix
+   */
+  async generateMatrix(options = {}) {
+    const requirements = await this.findRequirements(options.requirements || 'docs/requirements');
+    const design = await this.findDesign(options.design || 'docs/design');
+    const tasks = await this.findTasks(options.tasks || 'docs/tasks');
+    const code = await this.findCode(options.code || 'src');
+    const tests = await this.findTests(options.tests || 'tests');
+
+    const matrix = [];
+
+    for (const req of requirements) {
+      const relatedDesign = design.filter(d => this.linksToRequirement(d, req.id));
+      const relatedTasks = tasks.filter(t => this.linksToRequirement(t, req.id));
+      const relatedCode = code.filter(c => this.linksToRequirement(c, req.id));
+      const relatedTests = tests.filter(t => this.linksToRequirement(t, req.id));
+
+      matrix.push({
+        requirement: req,
+        design: relatedDesign,
+        tasks: relatedTasks,
+        code: relatedCode,
+        tests: relatedTests,
+        coverage: {
+          design: relatedDesign.length > 0,
+          tasks: relatedTasks.length > 0,
+          code: relatedCode.length > 0,
+          tests: relatedTests.length > 0
+        }
+      });
+    }
+
+    const summary = this.calculateMatrixSummary(matrix);
+
+    return { matrix, summary };
+  }
+
+  /**
+   * Calculate coverage statistics
+   */
+  async calculateCoverage(options = {}) {
+    const { matrix, summary } = await this.generateMatrix(options);
+
+    const overall = Math.round(
+      (summary.designCoverage + summary.tasksCoverage + summary.codeCoverage + summary.testsCoverage) / 4
+    );
+
+    return {
+      totalRequirements: summary.totalRequirements,
+      withDesign: summary.withDesign,
+      withTasks: summary.withTasks,
+      withCode: summary.withCode,
+      withTests: summary.withTests,
+      designCoverage: summary.designCoverage,
+      tasksCoverage: summary.tasksCoverage,
+      codeCoverage: summary.codeCoverage,
+      testsCoverage: summary.testsCoverage,
+      overall
+    };
+  }
+
+  /**
+   * Detect gaps in traceability
+   */
+  async detectGaps(options = {}) {
+    const requirements = await this.findRequirements(options.requirements || 'docs/requirements');
+    const design = await this.findDesign(options.design || 'docs/design');
+    const tasks = await this.findTasks(options.tasks || 'docs/tasks');
+    const code = await this.findCode(options.code || 'src');
+    const tests = await this.findTests(options.tests || 'tests');
+
+    const orphanedRequirements = [];
+    const orphanedDesign = [];
+    const orphanedTasks = [];
+    const untestedCode = [];
+    const missingTests = [];
+
+    // Find orphaned requirements (no design or tasks)
+    for (const req of requirements) {
+      const hasDesign = design.some(d => this.linksToRequirement(d, req.id));
+      const hasTasks = tasks.some(t => this.linksToRequirement(t, req.id));
+      
+      if (!hasDesign && !hasTasks) {
+        orphanedRequirements.push(req);
+      }
+      
+      // Check for missing tests
+      const hasTests = tests.some(t => this.linksToRequirement(t, req.id));
+      if (!hasTests) {
+        missingTests.push(req);
+      }
+    }
+
+    // Find orphaned design (no requirements)
+    for (const d of design) {
+      const hasRequirement = requirements.some(r => this.linksToRequirement(d, r.id));
+      if (!hasRequirement) {
+        orphanedDesign.push(d);
+      }
+    }
+
+    // Find orphaned tasks (no requirements)
+    for (const t of tasks) {
+      const hasRequirement = requirements.some(r => this.linksToRequirement(t, r.id));
+      if (!hasRequirement) {
+        orphanedTasks.push(t);
+      }
+    }
+
+    // Find untested code
+    for (const c of code) {
+      const hasTest = tests.some(t => this.testCoversCode(t, c));
+      if (!hasTest) {
+        untestedCode.push(c);
+      }
+    }
+
+    return {
+      orphanedRequirements,
+      orphanedDesign,
+      orphanedTasks,
+      untestedCode,
+      missingTests
+    };
+  }
+
+  /**
+   * Trace specific requirement
+   */
+  async traceRequirement(requirementId, options = {}) {
+    const requirements = await this.findRequirements(options.requirements || 'docs/requirements');
+    const design = await this.findDesign(options.design || 'docs/design');
+    const tasks = await this.findTasks(options.tasks || 'docs/tasks');
+    const code = await this.findCode(options.code || 'src');
+    const tests = await this.findTests(options.tests || 'tests');
+
+    const requirement = requirements.find(r => r.id === requirementId);
+    if (!requirement) {
+      return { requirement: null, design: [], tasks: [], code: [], tests: [] };
+    }
+
+    const relatedDesign = design.filter(d => this.linksToRequirement(d, requirementId));
+    const relatedTasks = tasks.filter(t => this.linksToRequirement(t, requirementId));
+    const relatedCode = code.filter(c => this.linksToRequirement(c, requirementId));
+    const relatedTests = tests.filter(t => this.linksToRequirement(t, requirementId));
+
+    return {
+      requirement,
+      design: relatedDesign,
+      tasks: relatedTasks,
+      code: relatedCode,
+      tests: relatedTests
+    };
+  }
+
+  /**
+   * Validate 100% traceability coverage
+   */
+  async validate(options = {}) {
+    const coverage = await this.calculateCoverage(options);
+    const gaps = await this.detectGaps(options);
+
+    const passed = coverage.overall === 100 && 
+                   gaps.orphanedRequirements.length === 0 &&
+                   gaps.untestedCode.length === 0 &&
+                   gaps.missingTests.length === 0;
+
+    return {
+      passed,
+      coverage,
+      gaps
+    };
+  }
+
+  /**
+   * Format matrix for output
+   */
+  formatMatrix(matrixData, format = 'table') {
+    const { matrix, summary } = matrixData;
+
+    if (format === 'json') {
+      return JSON.stringify(matrixData, null, 2);
+    }
+
+    if (format === 'html') {
+      return this.formatMatrixHTML(matrix, summary);
+    }
+
+    if (format === 'markdown') {
+      return this.formatMatrixMarkdown(matrix, summary);
+    }
+
+    // Default: table format
+    return this.formatMatrixTable(matrix, summary);
+  }
+
+  /**
+   * Format matrix as table
+   */
+  formatMatrixTable(matrix, _summary) {
+    const chalk = require('chalk');
+    let output = '';
+
+    output += chalk.bold('Requirement Traceability Matrix\n\n');
+    output += chalk.dim('REQ ID'.padEnd(20) + 'Design'.padEnd(10) + 'Tasks'.padEnd(10) + 'Code'.padEnd(10) + 'Tests'.padEnd(10)) + '\n';
+    output += chalk.dim('-'.repeat(60)) + '\n';
+
+    matrix.forEach(row => {
+      const designIcon = row.coverage.design ? chalk.green('✓') : chalk.red('✗');
+      const tasksIcon = row.coverage.tasks ? chalk.green('✓') : chalk.red('✗');
+      const codeIcon = row.coverage.code ? chalk.green('✓') : chalk.red('✗');
+      const testsIcon = row.coverage.tests ? chalk.green('✓') : chalk.red('✗');
+
+      output += `${row.requirement.id.padEnd(20)}${designIcon.padEnd(10)}${tasksIcon.padEnd(10)}${codeIcon.padEnd(10)}${testsIcon.padEnd(10)}\n`;
+    });
+
+    return output;
+  }
+
+  /**
+   * Format matrix as markdown
+   */
+  formatMatrixMarkdown(matrix, summary) {
+    let output = '# Requirement Traceability Matrix\n\n';
+    output += `Generated: ${new Date().toISOString()}\n\n`;
+    output += '## Summary\n\n';
+    output += `- Total Requirements: ${summary.totalRequirements}\n`;
+    output += `- Design Coverage: ${summary.designCoverage}%\n`;
+    output += `- Tasks Coverage: ${summary.tasksCoverage}%\n`;
+    output += `- Code Coverage: ${summary.codeCoverage}%\n`;
+    output += `- Test Coverage: ${summary.testsCoverage}%\n\n`;
+    output += '## Matrix\n\n';
+    output += '| Requirement ID | Title | Design | Tasks | Code | Tests |\n';
+    output += '|---------------|-------|--------|-------|------|-------|\n';
+
+    matrix.forEach(row => {
+      const designIcon = row.coverage.design ? '✓' : '✗';
+      const tasksIcon = row.coverage.tasks ? '✓' : '✗';
+      const codeIcon = row.coverage.code ? '✓' : '✗';
+      const testsIcon = row.coverage.tests ? '✓' : '✗';
+
+      output += `| ${row.requirement.id} | ${row.requirement.title} | ${designIcon} | ${tasksIcon} | ${codeIcon} | ${testsIcon} |\n`;
+    });
+
+    return output;
+  }
+
+  /**
+   * Format matrix as HTML
+   */
+  formatMatrixHTML(matrix, summary) {
+    let html = '<!DOCTYPE html>\n<html>\n<head>\n';
+    html += '<title>Requirement Traceability Matrix</title>\n';
+    html += '<style>\n';
+    html += 'body { font-family: Arial, sans-serif; margin: 20px; }\n';
+    html += 'table { border-collapse: collapse; width: 100%; }\n';
+    html += 'th, td { border: 1px solid #ddd; padding: 8px; text-align: left; }\n';
+    html += 'th { background-color: #4CAF50; color: white; }\n';
+    html += '.pass { color: green; }\n';
+    html += '.fail { color: red; }\n';
+    html += '</style>\n</head>\n<body>\n';
+    html += '<h1>Requirement Traceability Matrix</h1>\n';
+    html += `<p>Generated: ${new Date().toISOString()}</p>\n`;
+    html += '<h2>Summary</h2>\n<ul>\n';
+    html += `<li>Total Requirements: ${summary.totalRequirements}</li>\n`;
+    html += `<li>Design Coverage: ${summary.designCoverage}%</li>\n`;
+    html += `<li>Tasks Coverage: ${summary.tasksCoverage}%</li>\n`;
+    html += `<li>Code Coverage: ${summary.codeCoverage}%</li>\n`;
+    html += `<li>Test Coverage: ${summary.testsCoverage}%</li>\n`;
+    html += '</ul>\n<h2>Matrix</h2>\n';
+    html += '<table>\n<tr><th>Requirement ID</th><th>Title</th><th>Design</th><th>Tasks</th><th>Code</th><th>Tests</th></tr>\n';
+
+    matrix.forEach(row => {
+      const designClass = row.coverage.design ? 'pass' : 'fail';
+      const tasksClass = row.coverage.tasks ? 'pass' : 'fail';
+      const codeClass = row.coverage.code ? 'pass' : 'fail';
+      const testsClass = row.coverage.tests ? 'pass' : 'fail';
+
+      html += `<tr><td>${row.requirement.id}</td><td>${row.requirement.title}</td>`;
+      html += `<td class="${designClass}">${row.coverage.design ? '✓' : '✗'}</td>`;
+      html += `<td class="${tasksClass}">${row.coverage.tasks ? '✓' : '✗'}</td>`;
+      html += `<td class="${codeClass}">${row.coverage.code ? '✓' : '✗'}</td>`;
+      html += `<td class="${testsClass}">${row.coverage.tests ? '✓' : '✗'}</td></tr>\n`;
+    });
+
+    html += '</table>\n</body>\n</html>';
+    return html;
+  }
+
+  /**
+   * Calculate matrix summary statistics
+   */
+  calculateMatrixSummary(matrix) {
+    const totalRequirements = matrix.length;
+    const withDesign = matrix.filter(r => r.coverage.design).length;
+    const withTasks = matrix.filter(r => r.coverage.tasks).length;
+    const withCode = matrix.filter(r => r.coverage.code).length;
+    const withTests = matrix.filter(r => r.coverage.tests).length;
+
+    return {
+      totalRequirements,
+      withDesign,
+      withTasks,
+      withCode,
+      withTests,
+      designCoverage: totalRequirements > 0 ? Math.round((withDesign / totalRequirements) * 100) : 0,
+      tasksCoverage: totalRequirements > 0 ? Math.round((withTasks / totalRequirements) * 100) : 0,
+      codeCoverage: totalRequirements > 0 ? Math.round((withCode / totalRequirements) * 100) : 0,
+      testsCoverage: totalRequirements > 0 ? Math.round((withTests / totalRequirements) * 100) : 0
+    };
+  }
+
+  /**
+   * Find all requirements
+   */
+  async findRequirements(reqDir) {
+    const reqPath = path.join(this.workspaceRoot, reqDir);
+    if (!await fs.pathExists(reqPath)) {
+      return [];
+    }
+
+    const files = glob.sync('**/*.md', { cwd: reqPath, absolute: true });
+    const requirements = [];
+
+    for (const file of files) {
+      const content = await fs.readFile(file, 'utf-8');
+      const reqMatches = content.matchAll(/### (REQ-[A-Z0-9]+-\d{3}): (.+)/g);
+
+      for (const match of reqMatches) {
+        requirements.push({
+          id: match[1],
+          title: match[2],
+          file: path.relative(this.workspaceRoot, file),
+          content
+        });
+      }
+    }
+
+    return requirements;
+  }
+
+  /**
+   * Find all design documents
+   */
+  async findDesign(designDir) {
+    const designPath = path.join(this.workspaceRoot, designDir);
+    if (!await fs.pathExists(designPath)) {
+      return [];
+    }
+
+    const files = glob.sync('**/*.md', { cwd: designPath, absolute: true });
+    const designs = [];
+
+    for (const file of files) {
+      const content = await fs.readFile(file, 'utf-8');
+      
+      // Extract C4 diagrams and ADRs
+      const c4Matches = content.matchAll(/### (Level \d: .+)/g);
+      const adrMatches = content.matchAll(/### (ADR-\d{3}): (.+)/g);
+
+      for (const match of c4Matches) {
+        designs.push({
+          id: match[1],
+          title: match[1],
+          type: 'C4',
+          file: path.relative(this.workspaceRoot, file),
+          content
+        });
+      }
+
+      for (const match of adrMatches) {
+        designs.push({
+          id: match[1],
+          title: match[2],
+          type: 'ADR',
+          file: path.relative(this.workspaceRoot, file),
+          content
+        });
+      }
+    }
+
+    return designs;
+  }
+
+  /**
+   * Find all tasks
+   */
+  async findTasks(tasksDir) {
+    const tasksPath = path.join(this.workspaceRoot, tasksDir);
+    if (!await fs.pathExists(tasksPath)) {
+      return [];
+    }
+
+    const files = glob.sync('**/*.md', { cwd: tasksPath, absolute: true });
+    const tasks = [];
+
+    for (const file of files) {
+      const content = await fs.readFile(file, 'utf-8');
+      const taskMatches = content.matchAll(/### (TASK-\d{3}): (.+)/g);
+
+      for (const match of taskMatches) {
+        // Extract status - look for **Status**: pattern after task heading
+        const taskSection = content.substring(match.index);
+        const statusMatch = taskSection.match(/\*\*Status\*\*:\s*(\w+)/);
+        
+        tasks.push({
+          id: match[1],
+          title: match[2],
+          status: statusMatch ? statusMatch[1] : 'Unknown',
+          file: path.relative(this.workspaceRoot, file),
+          content
+        });
+      }
+    }
+
+    return tasks;
+  }
+
+  /**
+   * Find all code files
+   */
+  async findCode(codeDir) {
+    const codePath = path.join(this.workspaceRoot, codeDir);
+    if (!await fs.pathExists(codePath)) {
+      return [];
+    }
+
+    const files = glob.sync('**/*.{js,ts,jsx,tsx,py,java,go,rs}', { cwd: codePath, absolute: true });
+    const code = [];
+
+    for (const file of files) {
+      const content = await fs.readFile(file, 'utf-8');
+      
+      // Extract functions and classes with REQ references
+      const functionMatches = content.matchAll(/(?:function|const|let|var)\s+(\w+)|class\s+(\w+)/g);
+      
+      for (const match of functionMatches) {
+        code.push({
+          file: path.relative(this.workspaceRoot, file),
+          function: match[1],
+          class: match[2],
+          lines: this.getLineNumber(content, match.index),
+          content
+        });
+      }
+    }
+
+    return code;
+  }
+
+  /**
+   * Find all test files
+   */
+  async findTests(testsDir) {
+    const testsPath = path.join(this.workspaceRoot, testsDir);
+    if (!await fs.pathExists(testsPath)) {
+      return [];
+    }
+
+    const files = glob.sync('**/*.{test,spec}.{js,ts,jsx,tsx,py,java,go,rs}', { cwd: testsPath, absolute: true });
+    const tests = [];
+
+    for (const file of files) {
+      const content = await fs.readFile(file, 'utf-8');
+      
+      // Extract test cases
+      const testMatches = content.matchAll(/(?:test|it|describe)\(['"](.+?)['"]/g);
+      
+      for (const match of testMatches) {
+        tests.push({
+          file: path.relative(this.workspaceRoot, file),
+          test: match[1],
+          content
+        });
+      }
+    }
+
+    return tests;
+  }
+
+  /**
+   * Check if document links to requirement
+   */
+  linksToRequirement(doc, requirementId) {
+    return doc.content.includes(requirementId);
+  }
+
+  /**
+   * Check if test covers code
+   */
+  testCoversCode(test, code) {
+    // Simple heuristic: test file path matches code file path
+    const testBase = path.basename(test.file, path.extname(test.file)).replace(/\.(test|spec)$/, '');
+    const codeBase = path.basename(code.file, path.extname(code.file));
+    
+    return testBase === codeBase || test.content.includes(code.function) || test.content.includes(code.class);
+  }
+
+  /**
+   * Get line number from content index
+   */
+  getLineNumber(content, index) {
+    return content.substring(0, index).split('\n').length;
+  }
+}
+
+module.exports = TraceabilityAnalyzer;