musubi-sdd 6.1.2 → 6.2.1

package/src/dashboard/sprint-reporter.js

@@ -0,0 +1,378 @@
+/**
+ * SprintReporter Implementation
+ * 
+ * Generates sprint completion reports.
+ * 
+ * Requirement: IMP-6.2-003-04
+ * Design: Section 4.4
+ */
+
+const fs = require('fs').promises;
+const path = require('path');
+
+/**
+ * Default configuration
+ */
+const DEFAULT_CONFIG = {
+  storageDir: 'storage/reports'
+};
+
+/**
+ * SprintReporter
+ * 
+ * Generates and manages sprint reports.
+ */
+class SprintReporter {
+  /**
+   * @param {Object} config - Configuration options
+   */
+  constructor(config = {}) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+  }
+
+  /**
+   * Generate sprint completion report
+   * @param {Object} sprint - Sprint data
+   * @returns {Promise<Object>} Generated report
+   */
+  async generateReport(sprint) {
+    const report = {
+      id: `RPT-${sprint.id}-${Date.now()}`,
+      sprintId: sprint.id,
+      sprintName: sprint.name,
+      featureId: sprint.featureId,
+      generatedAt: new Date().toISOString(),
+      period: {
+        start: sprint.startDate,
+        end: sprint.endDate,
+        startedAt: sprint.startedAt,
+        completedAt: sprint.completedAt
+      },
+      metrics: this.calculateMetrics(sprint),
+      taskSummary: this.summarizeTasks(sprint),
+      velocityAnalysis: this.analyzeVelocity(sprint),
+      recommendations: this.generateRecommendations(sprint)
+    };
+
+    await this.saveReport(report);
+
+    return report;
+  }
+
+  /**
+   * Calculate sprint metrics
+   * @param {Object} sprint - Sprint data
+   * @returns {Object} Metrics
+   */
+  calculateMetrics(sprint) {
+    const tasks = sprint.tasks || [];
+    const totalPoints = tasks.reduce((sum, t) => sum + (t.storyPoints || 0), 0);
+    const completedTasks = tasks.filter(t => t.status === 'done');
+    const completedPoints = completedTasks.reduce((sum, t) => sum + (t.storyPoints || 0), 0);
+
+    const plannedVelocity = sprint.velocity || 0;
+    const actualVelocity = completedPoints;
+    const velocityDiff = actualVelocity - plannedVelocity;
+
+    return {
+      totalTasks: tasks.length,
+      completedTasks: completedTasks.length,
+      incompleteTasks: tasks.length - completedTasks.length,
+      totalPoints,
+      completedPoints,
+      remainingPoints: totalPoints - completedPoints,
+      completionRate: tasks.length > 0 
+        ? Math.round((completedTasks.length / tasks.length) * 100) 
+        : 0,
+      pointsCompletionRate: totalPoints > 0 
+        ? Math.round((completedPoints / totalPoints) * 100) 
+        : 0,
+      plannedVelocity,
+      actualVelocity,
+      velocityDiff,
+      velocityAccuracy: plannedVelocity > 0 
+        ? Math.round((actualVelocity / plannedVelocity) * 100) 
+        : 0
+    };
+  }
+
+  /**
+   * Summarize tasks by status and priority
+   * @param {Object} sprint - Sprint data
+   * @returns {Object} Task summary
+   */
+  summarizeTasks(sprint) {
+    const tasks = sprint.tasks || [];
+
+    const byStatus = {
+      todo: tasks.filter(t => t.status === 'todo'),
+      inProgress: tasks.filter(t => t.status === 'in-progress'),
+      done: tasks.filter(t => t.status === 'done')
+    };
+
+    const byPriority = {
+      critical: tasks.filter(t => t.priority === 'critical'),
+      high: tasks.filter(t => t.priority === 'high'),
+      medium: tasks.filter(t => t.priority === 'medium'),
+      low: tasks.filter(t => t.priority === 'low')
+    };
+
+    const completedByPriority = {
+      critical: byPriority.critical.filter(t => t.status === 'done').length,
+      high: byPriority.high.filter(t => t.status === 'done').length,
+      medium: byPriority.medium.filter(t => t.status === 'done').length,
+      low: byPriority.low.filter(t => t.status === 'done').length
+    };
+
+    return {
+      byStatus: {
+        todo: byStatus.todo.length,
+        inProgress: byStatus.inProgress.length,
+        done: byStatus.done.length
+      },
+      byPriority: {
+        critical: byPriority.critical.length,
+        high: byPriority.high.length,
+        medium: byPriority.medium.length,
+        low: byPriority.low.length
+      },
+      completedByPriority,
+      incompleteTasks: [...byStatus.todo, ...byStatus.inProgress].map(t => ({
+        id: t.id,
+        title: t.title,
+        priority: t.priority,
+        storyPoints: t.storyPoints,
+        status: t.status
+      }))
+    };
+  }
+
+  /**
+   * Analyze velocity trends
+   * @param {Object} sprint - Sprint data
+   * @returns {Object} Velocity analysis
+   */
+  analyzeVelocity(sprint) {
+    const metrics = this.calculateMetrics(sprint);
+    
+    let status;
+    if (metrics.velocityAccuracy >= 90 && metrics.velocityAccuracy <= 110) {
+      status = 'on-target';
+    } else if (metrics.velocityAccuracy > 110) {
+      status = 'over-performing';
+    } else if (metrics.velocityAccuracy >= 70) {
+      status = 'slightly-under';
+    } else {
+      status = 'under-performing';
+    }
+
+    return {
+      planned: metrics.plannedVelocity,
+      actual: metrics.actualVelocity,
+      difference: metrics.velocityDiff,
+      accuracy: metrics.velocityAccuracy,
+      status
+    };
+  }
+
+  /**
+   * Generate recommendations based on sprint results
+   * @param {Object} sprint - Sprint data
+   * @returns {Array} Recommendations
+   */
+  generateRecommendations(sprint) {
+    const recommendations = [];
+    const metrics = this.calculateMetrics(sprint);
+    const taskSummary = this.summarizeTasks(sprint);
+
+    // Velocity recommendations
+    if (metrics.velocityAccuracy < 70) {
+      recommendations.push({
+        type: 'velocity',
+        severity: 'high',
+        message: 'スプリントの実績ベロシティが計画の70%未満でした。次のスプリントでは計画ベロシティを下げることを検討してください。'
+      });
+    } else if (metrics.velocityAccuracy > 130) {
+      recommendations.push({
+        type: 'velocity',
+        severity: 'medium',
+        message: '計画以上のベロシティを達成しました。次のスプリントでは計画ベロシティを上げることを検討してください。'
+      });
+    }
+
+    // Incomplete critical tasks
+    const incompleteCritical = taskSummary.byPriority.critical - taskSummary.completedByPriority.critical;
+    if (incompleteCritical > 0) {
+      recommendations.push({
+        type: 'priority',
+        severity: 'critical',
+        message: `${incompleteCritical}件のクリティカルタスクが未完了です。次のスプリントで優先的に対応してください。`
+      });
+    }
+
+    // High number of incomplete tasks
+    if (metrics.completionRate < 50) {
+      recommendations.push({
+        type: 'planning',
+        severity: 'high',
+        message: 'タスク完了率が50%未満です。タスクの見積もりや優先順位付けの改善を検討してください。'
+      });
+    }
+
+    // Many in-progress tasks
+    if (taskSummary.byStatus.inProgress > 3) {
+      recommendations.push({
+        type: 'wip',
+        severity: 'medium',
+        message: '進行中のタスクが多すぎます。WIP制限を設けてフォーカスを高めることを検討してください。'
+      });
+    }
+
+    return recommendations;
+  }
+
+  /**
+   * Generate markdown report
+   * @param {Object} sprint - Sprint data
+   * @returns {Promise<string>} Markdown report
+   */
+  async generateMarkdownReport(sprint) {
+    const report = await this.generateReport(sprint);
+    const lines = [];
+
+    lines.push(`# Sprint Report: ${report.sprintName}`);
+    lines.push('');
+    lines.push(`**Generated:** ${report.generatedAt}`);
+    lines.push(`**Feature:** ${report.featureId || 'N/A'}`);
+    lines.push(`**Period:** ${report.period.start} - ${report.period.end}`);
+    lines.push('');
+
+    // Metrics
+    lines.push('## Metrics');
+    lines.push('');
+    lines.push('| Metric | Value |');
+    lines.push('|--------|-------|');
+    lines.push(`| Total Tasks | ${report.metrics.totalTasks} |`);
+    lines.push(`| Completed Tasks | ${report.metrics.completedTasks} |`);
+    lines.push(`| Completion Rate | ${report.metrics.completionRate}% |`);
+    lines.push(`| Total Points | ${report.metrics.totalPoints} |`);
+    lines.push(`| Completed Points | ${report.metrics.completedPoints} |`);
+    lines.push(`| Points Completion | ${report.metrics.pointsCompletionRate}% |`);
+    lines.push(`| Planned Velocity | ${report.metrics.plannedVelocity} |`);
+    lines.push(`| Actual Velocity | ${report.metrics.actualVelocity} |`);
+    lines.push(`| Velocity Accuracy | ${report.metrics.velocityAccuracy}% |`);
+    lines.push('');
+
+    // Velocity Analysis
+    lines.push('## Velocity Analysis');
+    lines.push('');
+    const va = report.velocityAnalysis;
+    const statusEmoji = {
+      'on-target': '✅',
+      'over-performing': '🚀',
+      'slightly-under': '⚠️',
+      'under-performing': '❌'
+    };
+    lines.push(`Status: ${statusEmoji[va.status] || '❓'} **${va.status}**`);
+    lines.push('');
+
+    // Task Summary
+    lines.push('## Task Summary');
+    lines.push('');
+    lines.push('### By Status');
+    lines.push(`- ⬜ Todo: ${report.taskSummary.byStatus.todo}`);
+    lines.push(`- 🔄 In Progress: ${report.taskSummary.byStatus.inProgress}`);
+    lines.push(`- ✅ Done: ${report.taskSummary.byStatus.done}`);
+    lines.push('');
+
+    lines.push('### By Priority');
+    lines.push(`- 🔴 Critical: ${report.taskSummary.completedByPriority.critical}/${report.taskSummary.byPriority.critical}`);
+    lines.push(`- 🟠 High: ${report.taskSummary.completedByPriority.high}/${report.taskSummary.byPriority.high}`);
+    lines.push(`- 🟡 Medium: ${report.taskSummary.completedByPriority.medium}/${report.taskSummary.byPriority.medium}`);
+    lines.push(`- 🟢 Low: ${report.taskSummary.completedByPriority.low}/${report.taskSummary.byPriority.low}`);
+    lines.push('');
+
+    // Incomplete Tasks
+    if (report.taskSummary.incompleteTasks.length > 0) {
+      lines.push('### Incomplete Tasks');
+      lines.push('');
+      for (const task of report.taskSummary.incompleteTasks) {
+        lines.push(`- **${task.id}**: ${task.title} (${task.priority}, ${task.storyPoints}pt)`);
+      }
+      lines.push('');
+    }
+
+    // Recommendations
+    if (report.recommendations.length > 0) {
+      lines.push('## Recommendations');
+      lines.push('');
+      const severityEmoji = {
+        critical: '🔴',
+        high: '🟠',
+        medium: '🟡',
+        low: '🟢'
+      };
+      for (const rec of report.recommendations) {
+        lines.push(`${severityEmoji[rec.severity] || '❓'} **${rec.type}**: ${rec.message}`);
+        lines.push('');
+      }
+    }
+
+    return lines.join('\n');
+  }
+
+  /**
+   * Save report to storage
+   * @param {Object} report - Report to save
+   */
+  async saveReport(report) {
+    await this.ensureStorageDir();
+    
+    const filePath = path.join(this.config.storageDir, `${report.id}.json`);
+    await fs.writeFile(filePath, JSON.stringify(report, null, 2), 'utf-8');
+  }
+
+  /**
+   * Load report from storage
+   * @param {string} reportId - Report ID
+   * @returns {Promise<Object|null>} Report
+   */
+  async loadReport(reportId) {
+    try {
+      const filePath = path.join(this.config.storageDir, `${reportId}.json`);
+      const content = await fs.readFile(filePath, 'utf-8');
+      return JSON.parse(content);
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * List reports for sprint
+   * @param {string} sprintId - Sprint ID
+   * @returns {Promise<Array>} Report list
+   */
+  async listReports(sprintId) {
+    try {
+      const files = await fs.readdir(this.config.storageDir);
+      return files
+        .filter(f => f.includes(sprintId) && f.endsWith('.json'))
+        .map(f => f.replace('.json', ''));
+    } catch {
+      return [];
+    }
+  }
+
+  /**
+   * Ensure storage directory exists
+   */
+  async ensureStorageDir() {
+    try {
+      await fs.access(this.config.storageDir);
+    } catch {
+      await fs.mkdir(this.config.storageDir, { recursive: true });
+    }
+  }
+}
+
+module.exports = { SprintReporter };

package/src/dashboard/transition-recorder.js

@@ -0,0 +1,209 @@
+/**
+ * TransitionRecorder Implementation
+ * 
+ * Records stage transitions with timestamps and reviewers.
+ * 
+ * Requirement: IMP-6.2-003-02
+ * Design: Section 4.2
+ */
+
+const fs = require('fs').promises;
+const path = require('path');
+
+/**
+ * Default configuration
+ */
+const DEFAULT_CONFIG = {
+  storageDir: 'storage/transitions'
+};
+
+/**
+ * TransitionRecorder
+ * 
+ * Records and manages workflow stage transitions.
+ */
+class TransitionRecorder {
+  /**
+   * @param {Object} config - Configuration options
+   */
+  constructor(config = {}) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+  }
+
+  /**
+   * Record a stage transition
+   * @param {string} featureId - Feature ID
+   * @param {Object} transition - Transition data
+   * @returns {Promise<Object>} Created transition record
+   */
+  async recordTransition(featureId, transition) {
+    const history = await this.getHistory(featureId) || {
+      featureId,
+      transitions: [],
+      createdAt: new Date().toISOString()
+    };
+
+    const record = {
+      id: `TR-${Date.now()}`,
+      fromStage: transition.fromStage,
+      toStage: transition.toStage,
+      status: transition.status || 'completed',
+      reviewer: transition.reviewer || null,
+      reviewResult: transition.reviewResult || null,
+      artifacts: transition.artifacts || [],
+      notes: transition.notes || null,
+      timestamp: new Date().toISOString()
+    };
+
+    history.transitions.push(record);
+    history.updatedAt = new Date().toISOString();
+
+    await this.saveHistory(featureId, history);
+
+    return record;
+  }
+
+  /**
+   * Get transition history for feature
+   * @param {string} featureId - Feature ID
+   * @returns {Promise<Object|null>} Transition history
+   */
+  async getHistory(featureId) {
+    try {
+      const filePath = path.join(
+        this.config.storageDir,
+        `${featureId}-transitions.json`
+      );
+      const content = await fs.readFile(filePath, 'utf-8');
+      return JSON.parse(content);
+    } catch {
+      return null;
+    }
+  }
+
+  /**
+   * Get last transition for feature
+   * @param {string} featureId - Feature ID
+   * @returns {Promise<Object|null>} Last transition record
+   */
+  async getLastTransition(featureId) {
+    const history = await this.getHistory(featureId);
+    if (!history || history.transitions.length === 0) {
+      return null;
+    }
+    return history.transitions[history.transitions.length - 1];
+  }
+
+  /**
+   * Get transitions to a specific stage
+   * @param {string} featureId - Feature ID
+   * @param {string} targetStage - Target stage
+   * @returns {Promise<Array>} Transitions to stage
+   */
+  async getTransitionsByStage(featureId, targetStage) {
+    const history = await this.getHistory(featureId);
+    if (!history) {
+      return [];
+    }
+    return history.transitions.filter(t => t.toStage === targetStage);
+  }
+
+  /**
+   * Calculate average transition time between stages
+   * @param {string} featureId - Feature ID
+   * @returns {Promise<number>} Average time in milliseconds
+   */
+  async calculateAverageTransitionTime(featureId) {
+    const history = await this.getHistory(featureId);
+    if (!history || history.transitions.length < 2) {
+      return 0;
+    }
+
+    const transitions = history.transitions;
+    let totalTime = 0;
+    let count = 0;
+
+    for (let i = 1; i < transitions.length; i++) {
+      const prev = new Date(transitions[i - 1].timestamp).getTime();
+      const curr = new Date(transitions[i].timestamp).getTime();
+      totalTime += curr - prev;
+      count++;
+    }
+
+    return count > 0 ? Math.round(totalTime / count) : 0;
+  }
+
+  /**
+   * Get transition statistics
+   * @param {string} featureId - Feature ID
+   * @returns {Promise<Object>} Transition statistics
+   */
+  async getTransitionStats(featureId) {
+    const history = await this.getHistory(featureId);
+    if (!history) {
+      return {
+        totalTransitions: 0,
+        successfulTransitions: 0,
+        failedTransitions: 0,
+        averageTime: 0,
+        stageTransitions: {}
+      };
+    }
+
+    const transitions = history.transitions;
+    const stageTransitions = {};
+
+    let successful = 0;
+    let failed = 0;
+
+    for (const t of transitions) {
+      if (t.status === 'completed') {
+        successful++;
+      } else if (t.status === 'failed' || t.status === 'rejected') {
+        failed++;
+      }
+
+      const key = `${t.fromStage}->${t.toStage}`;
+      stageTransitions[key] = (stageTransitions[key] || 0) + 1;
+    }
+
+    const averageTime = await this.calculateAverageTransitionTime(featureId);
+
+    return {
+      totalTransitions: transitions.length,
+      successfulTransitions: successful,
+      failedTransitions: failed,
+      averageTime,
+      stageTransitions
+    };
+  }
+
+  /**
+   * Save transition history
+   * @param {string} featureId - Feature ID
+   * @param {Object} history - History to save
+   */
+  async saveHistory(featureId, history) {
+    await this.ensureStorageDir();
+    
+    const filePath = path.join(
+      this.config.storageDir,
+      `${featureId}-transitions.json`
+    );
+
+    await fs.writeFile(filePath, JSON.stringify(history, null, 2), 'utf-8');
+  }
+
+  /**
+   * Ensure storage directory exists
+   */
+  async ensureStorageDir() {
+    try {
+      await fs.access(this.config.storageDir);
+    } catch {
+      await fs.mkdir(this.config.storageDir, { recursive: true });
+    }
+  }
+}
+
+module.exports = { TransitionRecorder };