musubi-sdd 6.2.0 → 6.2.1

package/src/traceability/extractor.js

@@ -0,0 +1,294 @@
+/**
+ * TraceabilityExtractor Implementation
+ * 
+ * Extracts requirement ID patterns from code, tests, commits, and documents.
+ * 
+ * Requirement: IMP-6.2-004-01
+ * Design: Section 5.1
+ */
+
+const fs = require('fs').promises;
+const path = require('path');
+const { exec } = require('child_process');
+const { promisify } = require('util');
+
+const execAsync = promisify(exec);
+
+/**
+ * Requirement ID patterns
+ */
+const REQ_PATTERNS = [
+  /REQ-[A-Z0-9]+-\d{3}/g,              // REQ-XXX-NNN
+  /IMP-\d+\.\d+-\d{3}(?:-\d{2})?/g,    // IMP-6.2-001 or IMP-6.2-001-01
+  /FEAT-\d{3}/g,                        // FEAT-001
+  /TASK-\d{3}/g,                        // TASK-001
+];
+
+/**
+ * Default configuration
+ */
+const DEFAULT_CONFIG = {
+  sourceDir: 'src',
+  testDir: 'tests',
+  docDir: 'docs',
+  includePatterns: ['*.js', '*.ts', '*.tsx', '*.jsx', '*.md'],
+  excludePatterns: ['node_modules/**', '*.test.js', '*.spec.js'],
+  scanCommits: false,
+  maxCommits: 100
+};
+
+/**
+ * TraceabilityExtractor
+ * 
+ * Extracts requirement references from various sources.
+ */
+class TraceabilityExtractor {
+  /**
+   * @param {Object} config - Configuration options
+   */
+  constructor(config = {}) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+  }
+
+  /**
+   * Extract references from a single file
+   * @param {string} filePath - Path to file
+   * @param {string} sourceType - Type of source (code|test|document)
+   * @returns {Promise<Array>} Requirement references
+   */
+  async extractFromFile(filePath, sourceType) {
+    try {
+      await fs.access(filePath);
+      const content = await fs.readFile(filePath, 'utf-8');
+      
+      return this.extractFromContent(content, filePath, sourceType);
+    } catch {
+      return [];
+    }
+  }
+
+  /**
+   * Extract references from content string
+   * @param {string} content - File content
+   * @param {string} filePath - File path
+   * @param {string} sourceType - Source type
+   * @returns {Array} Requirement references
+   */
+  extractFromContent(content, filePath, sourceType) {
+    const refs = [];
+    const lines = content.split('\n');
+    const now = new Date().toISOString();
+
+    for (let lineNum = 0; lineNum < lines.length; lineNum++) {
+      const line = lines[lineNum];
+
+      for (const pattern of REQ_PATTERNS) {
+        // Reset regex state
+        pattern.lastIndex = 0;
+        
+        let match;
+        while ((match = pattern.exec(line)) !== null) {
+          refs.push({
+            requirementId: match[0],
+            sourceType,
+            filePath,
+            lineNumber: lineNum + 1,
+            context: line.trim().substring(0, 100),
+            foundAt: now
+          });
+        }
+      }
+    }
+
+    return refs;
+  }
+
+  /**
+   * Extract references from git commits
+   * @returns {Promise<Array>} Requirement references from commits
+   */
+  async extractFromCommits() {
+    const refs = [];
+    const now = new Date().toISOString();
+
+    try {
+      const maxCommits = this.config.maxCommits || 100;
+      const { stdout } = await execAsync(
+        `git log -${maxCommits} --format="%H|%s|%ad|%ae" --date=short`
+      );
+
+      const lines = stdout.trim().split('\n').filter(l => l.length > 0);
+
+      for (const line of lines) {
+        const [hash, message, date, author] = line.split('|');
+
+        for (const pattern of REQ_PATTERNS) {
+          pattern.lastIndex = 0;
+          
+          let match;
+          while ((match = pattern.exec(message)) !== null) {
+            refs.push({
+              requirementId: match[0],
+              sourceType: 'commit',
+              commitHash: hash,
+              commitMessage: message,
+              context: message,
+              foundAt: now
+            });
+          }
+        }
+      }
+    } catch {
+      // Git not available or not in a git repo
+    }
+
+    return refs;
+  }
+
+  /**
+   * Scan a directory for references
+   * @param {string} dirPath - Directory path
+   * @param {string} sourceType - Source type
+   * @returns {Promise<Array>} Requirement references
+   */
+  async scanDirectory(dirPath, sourceType) {
+    const refs = [];
+
+    try {
+      const entries = await fs.readdir(dirPath);
+
+      for (const entry of entries) {
+        const fullPath = path.join(dirPath, entry);
+        const stat = await fs.stat(fullPath);
+
+        if (stat.isDirectory()) {
+          // Skip excluded directories
+          if (this.isExcluded(entry)) continue;
+          
+          const subRefs = await this.scanDirectory(fullPath, sourceType);
+          refs.push(...subRefs);
+        } else if (stat.isFile() && this.shouldInclude(entry)) {
+          const fileRefs = await this.extractFromFile(fullPath, sourceType);
+          refs.push(...fileRefs);
+        }
+      }
+    } catch {
+      // Directory not accessible
+    }
+
+    return refs;
+  }
+
+  /**
+   * Extract from all configured sources
+   * @returns {Promise<Array>} All requirement references
+   */
+  async extractAll() {
+    const refs = [];
+
+    // Extract from source code
+    if (this.config.sourceDir) {
+      const codeRefs = await this.scanDirectory(this.config.sourceDir, 'code');
+      refs.push(...codeRefs);
+    }
+
+    // Extract from tests
+    if (this.config.testDir) {
+      const testRefs = await this.scanDirectory(this.config.testDir, 'test');
+      refs.push(...testRefs);
+    }
+
+    // Extract from documents
+    if (this.config.docDir) {
+      const docRefs = await this.scanDirectory(this.config.docDir, 'document');
+      refs.push(...docRefs);
+    }
+
+    // Extract from commits
+    if (this.config.scanCommits) {
+      const commitRefs = await this.extractFromCommits();
+      refs.push(...commitRefs);
+    }
+
+    return refs;
+  }
+
+  /**
+   * Group references by requirement ID
+   * @param {Array} refs - References to group
+   * @returns {Map<string, Array>} Grouped references
+   */
+  groupByRequirement(refs) {
+    const grouped = new Map();
+
+    for (const ref of refs) {
+      const existing = grouped.get(ref.requirementId) || [];
+      existing.push(ref);
+      grouped.set(ref.requirementId, existing);
+    }
+
+    return grouped;
+  }
+
+  /**
+   * Check if file should be included
+   * @param {string} filename - Filename to check
+   * @returns {boolean} Should include
+   */
+  shouldInclude(filename) {
+    const includePatterns = this.config.includePatterns || [];
+    const excludePatterns = this.config.excludePatterns || [];
+
+    // Check exclude patterns first
+    for (const pattern of excludePatterns) {
+      if (this.matchPattern(filename, pattern)) {
+        return false;
+      }
+    }
+
+    // Check include patterns
+    for (const pattern of includePatterns) {
+      if (this.matchPattern(filename, pattern)) {
+        return true;
+      }
+    }
+
+    return includePatterns.length === 0;
+  }
+
+  /**
+   * Check if directory/file should be excluded
+   * @param {string} name - Name to check
+   * @returns {boolean} Should exclude
+   */
+  isExcluded(name) {
+    const excludePatterns = this.config.excludePatterns || [];
+    
+    for (const pattern of excludePatterns) {
+      if (pattern.includes('**')) {
+        // Glob pattern with directory
+        const dirPattern = pattern.split('**')[0].replace(/\/$/, '');
+        if (name === dirPattern) return true;
+      }
+    }
+
+    return name === 'node_modules' || name.startsWith('.');
+  }
+
+  /**
+   * Simple glob pattern matching
+   * @param {string} filename - Filename to match
+   * @param {string} pattern - Pattern to match against
+   * @returns {boolean} Matches
+   */
+  matchPattern(filename, pattern) {
+    // Convert glob pattern to regex
+    const regexPattern = pattern
+      .replace(/\./g, '\\.')
+      .replace(/\*/g, '.*');
+    
+    return new RegExp(`^${regexPattern}$`).test(filename);
+  }
+}
+
+module.exports = { TraceabilityExtractor };

package/src/traceability/gap-detector.js

@@ -0,0 +1,230 @@
+/**
+ * GapDetector Implementation
+ * 
+ * Detects requirements without implementation or tests.
+ * 
+ * Requirement: IMP-6.2-004-02
+ * Design: Section 5.2
+ */
+
+/**
+ * Severity levels for gaps
+ */
+const SEVERITY_MAP = {
+  'no-test': 'critical',
+  'no-code': 'high',
+  'no-design': 'medium',
+  'no-commit': 'low'
+};
+
+/**
+ * Severity ordering for sorting
+ */
+const SEVERITY_ORDER = {
+  'critical': 0,
+  'high': 1,
+  'medium': 2,
+  'low': 3
+};
+
+/**
+ * Suggestions for each gap type
+ */
+const SUGGESTIONS = {
+  'no-test': 'この要件に対するテストを作成してください。Article III (Test-First) に従い、実装前にテストを書くことを推奨します。',
+  'no-code': '要件の実装が必要です。設計ドキュメントを参照して実装を開始してください。',
+  'no-design': '設計ドキュメントを作成してください。C4モデルに従い、コンポーネント図とADRを追加することを推奨します。',
+  'no-commit': 'この要件に関連するコミットがありません。コミットメッセージに要件IDを含めてください。'
+};
+
+/**
+ * GapDetector
+ * 
+ * Detects gaps in traceability between requirements and artifacts.
+ */
+class GapDetector {
+  /**
+   * Detect all gaps in traceability links
+   * @param {Array} links - Traceability links
+   * @returns {Array} Detected gaps
+   */
+  detectGaps(links) {
+    const gaps = [];
+
+    for (const link of links) {
+      // Check for design gap
+      if (link.design.length === 0) {
+        gaps.push(this.createGap(link.requirementId, 'no-design'));
+      }
+
+      // Check for code gap
+      if (link.code.length === 0) {
+        gaps.push(this.createGap(link.requirementId, 'no-code'));
+      }
+
+      // Check for test gap
+      if (link.tests.length === 0) {
+        gaps.push(this.createGap(link.requirementId, 'no-test'));
+      }
+    }
+
+    return gaps;
+  }
+
+  /**
+   * Create a gap entry
+   * @param {string} requirementId - Requirement ID
+   * @param {string} gapType - Gap type
+   * @returns {Object} Gap entry
+   */
+  createGap(requirementId, gapType) {
+    return {
+      requirementId,
+      gapType,
+      severity: SEVERITY_MAP[gapType],
+      suggestion: SUGGESTIONS[gapType]
+    };
+  }
+
+  /**
+   * Analyze a traceability matrix for gaps
+   * @param {Object} matrix - Traceability matrix
+   * @returns {Object} Gap analysis
+   */
+  analyzeMatrix(matrix) {
+    const links = Object.values(matrix.requirements);
+    const gaps = this.detectGaps(links);
+
+    return this.calculateAnalysis(gaps);
+  }
+
+  /**
+   * Calculate gap analysis
+   * @param {Array} gaps - Detected gaps
+   * @returns {Object} Gap analysis
+   */
+  calculateAnalysis(gaps) {
+    const gapsByType = {};
+    const gapsByRequirement = {};
+
+    let criticalGaps = 0;
+    let highGaps = 0;
+    let mediumGaps = 0;
+    let lowGaps = 0;
+
+    for (const gap of gaps) {
+      // Count by type
+      gapsByType[gap.gapType] = (gapsByType[gap.gapType] || 0) + 1;
+
+      // Count by requirement
+      gapsByRequirement[gap.requirementId] = 
+        (gapsByRequirement[gap.requirementId] || 0) + 1;
+
+      // Count by severity
+      switch (gap.severity) {
+        case 'critical':
+          criticalGaps++;
+          break;
+        case 'high':
+          highGaps++;
+          break;
+        case 'medium':
+          mediumGaps++;
+          break;
+        case 'low':
+          lowGaps++;
+          break;
+      }
+    }
+
+    return {
+      totalGaps: gaps.length,
+      criticalGaps,
+      highGaps,
+      mediumGaps,
+      lowGaps,
+      gapsByType,
+      gapsByRequirement
+    };
+  }
+
+  /**
+   * Generate a gap report
+   * @param {Array} links - Traceability links
+   * @returns {Object} Gap report
+   */
+  getGapReport(links) {
+    const gaps = this.detectGaps(links);
+    const sortedGaps = this.sortGapsBySeverity(gaps);
+    const summary = this.calculateAnalysis(gaps);
+
+    return {
+      generatedAt: new Date().toISOString(),
+      gaps: sortedGaps,
+      summary
+    };
+  }
+
+  /**
+   * Sort gaps by severity (critical first)
+   * @param {Array} gaps - Gaps to sort
+   * @returns {Array} Sorted gaps
+   */
+  sortGapsBySeverity(gaps) {
+    return [...gaps].sort((a, b) => {
+      return SEVERITY_ORDER[a.severity] - SEVERITY_ORDER[b.severity];
+    });
+  }
+
+  /**
+   * Filter gaps by severity
+   * @param {Array} gaps - Gaps to filter
+   * @param {string} severity - Severity to filter by
+   * @returns {Array} Filtered gaps
+   */
+  filterGapsBySeverity(gaps, severity) {
+    return gaps.filter(g => g.severity === severity);
+  }
+
+  /**
+   * Get unique requirement IDs that have gaps
+   * @param {Array} links - Traceability links
+   * @returns {Array} Requirement IDs with gaps
+   */
+  getRequirementsWithGaps(links) {
+    const gaps = this.detectGaps(links);
+    const reqIds = new Set();
+
+    for (const gap of gaps) {
+      reqIds.add(gap.requirementId);
+    }
+
+    return Array.from(reqIds);
+  }
+
+  /**
+   * Check if a specific requirement has critical gaps
+   * @param {Object} link - Traceability link
+   * @returns {boolean} Has critical gap
+   */
+  hasCriticalGap(link) {
+    // No tests is critical
+    return link.tests.length === 0;
+  }
+
+  /**
+   * Get gap coverage percentage
+   * @param {Array} links - Traceability links
+   * @returns {number} Coverage percentage
+   */
+  getGapCoverage(links) {
+    if (links.length === 0) return 100;
+
+    const reqsWithGaps = this.getRequirementsWithGaps(links);
+    const covered = links.length - reqsWithGaps.length;
+    
+    return Math.round((covered / links.length) * 100);
+  }
+}
+
+module.exports = { GapDetector };

package/src/traceability/index.js

@@ -0,0 +1,15 @@
+/**
+ * Traceability Module
+ * 
+ * Requirement: IMP-6.2-004
+ */
+
+const { TraceabilityExtractor } = require('./extractor');
+const { GapDetector } = require('./gap-detector');
+const { MatrixStorage } = require('./matrix-storage');
+
+module.exports = {
+  TraceabilityExtractor,
+  GapDetector,
+  MatrixStorage
+};