aiwf 0.3.1 → 0.3.2

package/claude-code/aiwf/en/commands/feature_commit_report.js

@@ -0,0 +1,370 @@
+#!/usr/bin/env node
+
+const { Command } = require('commander');
+const chalk = require('chalk');
+const ora = require('ora');
+const fs = require('fs').promises;
+const path = require('path');
+const { 
+  getCommitsByFeatureId,
+  isGitRepository,
+  runGitCommand
+} = require('../utils/git-utils');
+const { 
+  findFeatureFile,
+  readFeatureFile
+} = require('../utils/feature-updater');
+
+const program = new Command();
+
+/**
+ * feature_commit_report 명령어
+ * Feature와 Git 커밋의 매핑 리포트 생성
+ */
+
+program
+  .name('feature_commit_report')
+  .description('Feature와 Git 커밋의 매핑 리포트를 생성합니다')
+  .option('-f, --feature <id>', '특정 Feature ID의 리포트만 생성')
+  .option('-s, --status <status>', 'Feature 상태별 필터링 (active|completed|archived)')
+  .option('-o, --output <path>', '리포트 출력 경로', './feature_commit_report.md')
+  .option('-F, --format <format>', '출력 형식 (markdown|json|html)', 'markdown')
+  .option('-d, --detailed', '상세 커밋 정보 포함')
+  .option('-t, --timeline', '타임라인 형식으로 표시')
+  .option('-v, --verbose', '상세 로그 출력')
+  .action(async (options) => {
+    const spinner = ora();
+    
+    try {
+      // Git 저장소 확인
+      if (!await isGitRepository()) {
+        console.error(chalk.red('❌ 현재 디렉토리는 Git 저장소가 아닙니다.'));
+        process.exit(1);
+      }
+      
+      spinner.start('Feature 정보 수집 중...');
+      
+      // Feature 파일 수집
+      const basePath = path.join(process.cwd(), '.aiwf', '06_FEATURE_LEDGERS');
+      const statuses = options.status ? [options.status] : ['active', 'completed', 'archived'];
+      const features = [];
+      
+      for (const status of statuses) {
+        const dirPath = path.join(basePath, status);
+        try {
+          const files = await fs.readdir(dirPath);
+          const featureFiles = files.filter(f => f.endsWith('.md'));
+          
+          for (const file of featureFiles) {
+            const featureId = file.split('_')[0];
+            
+            // 특정 Feature ID 필터링
+            if (options.feature && featureId !== options.feature) {
+              continue;
+            }
+            
+            const filePath = path.join(dirPath, file);
+            const { frontmatter } = await readFeatureFile(filePath);
+            
+            features.push({
+              id: featureId,
+              status: status,
+              title: frontmatter.title || 'Untitled',
+              milestone: frontmatter.milestone || 'N/A',
+              assignee: frontmatter.assignee || 'Unassigned',
+              created: frontmatter.created_date || 'Unknown',
+              updated: frontmatter.last_updated || 'Unknown',
+              gitCommits: frontmatter.git_commits || [],
+              progress: frontmatter.progress_percentage || 0
+            });
+          }
+        } catch (error) {
+          // 디렉토리가 없을 수 있음
+          continue;
+        }
+      }
+      
+      spinner.succeed(chalk.green(`${features.length}개 Feature 정보 수집 완료`));
+      
+      if (features.length === 0) {
+        console.log(chalk.yellow('리포트를 생성할 Feature가 없습니다.'));
+        return;
+      }
+      
+      // 각 Feature의 커밋 정보 수집
+      spinner.start('Git 커밋 정보 수집 중...');
+      const reportData = [];
+      
+      for (const feature of features) {
+        const commits = await getCommitsByFeatureId(feature.id);
+        
+        reportData.push({
+          ...feature,
+          commits: commits,
+          commitCount: commits.length,
+          firstCommit: commits.length > 0 ? commits[commits.length - 1] : null,
+          lastCommit: commits.length > 0 ? commits[0] : null
+        });
+      }
+      
+      spinner.succeed(chalk.green('커밋 정보 수집 완료'));
+      
+      // 리포트 생성
+      spinner.start('리포트 생성 중...');
+      
+      let reportContent;
+      switch (options.format) {
+        case 'json':
+          reportContent = generateJsonReport(reportData, options);
+          break;
+        case 'html':
+          reportContent = generateHtmlReport(reportData, options);
+          break;
+        case 'markdown':
+        default:
+          reportContent = generateMarkdownReport(reportData, options);
+      }
+      
+      // 리포트 저장
+      await fs.writeFile(options.output, reportContent, 'utf8');
+      spinner.succeed(chalk.green(`리포트 생성 완료: ${options.output}`));
+      
+      // 요약 정보 출력
+      console.log(chalk.cyan('\n📊 리포트 요약:'));
+      console.log(chalk.white(`   총 Feature: ${reportData.length}개`));
+      console.log(chalk.white(`   총 커밋: ${reportData.reduce((sum, f) => sum + f.commitCount, 0)}개`));
+      
+      const byStatus = {};
+      reportData.forEach(f => {
+        byStatus[f.status] = (byStatus[f.status] || 0) + 1;
+      });
+      
+      console.log(chalk.cyan('\n   상태별 분포:'));
+      Object.entries(byStatus).forEach(([status, count]) => {
+        const icon = status === 'active' ? '🟢' : status === 'completed' ? '✅' : '📦';
+        console.log(chalk.white(`     ${icon} ${status}: ${count}개`));
+      });
+      
+    } catch (error) {
+      spinner.fail(chalk.red('리포트 생성 중 오류 발생'));
+      console.error(chalk.red(error.message));
+      if (options.verbose) {
+        console.error(error.stack);
+      }
+      process.exit(1);
+    }
+  });
+
+/**
+ * Markdown 형식 리포트 생성
+ */
+function generateMarkdownReport(data, options) {
+  let report = '# Feature-Git Commit Mapping Report\n\n';
+  report += `Generated: ${new Date().toISOString()}\n\n`;
+  
+  // 요약 섹션
+  report += '## Summary\n\n';
+  report += `- Total Features: ${data.length}\n`;
+  report += `- Total Commits: ${data.reduce((sum, f) => sum + f.commitCount, 0)}\n`;
+  report += '\n';
+  
+  // 상태별 통계
+  const byStatus = {};
+  data.forEach(f => {
+    byStatus[f.status] = (byStatus[f.status] || []);
+    byStatus[f.status].push(f);
+  });
+  
+  report += '## Features by Status\n\n';
+  
+  Object.entries(byStatus).forEach(([status, features]) => {
+    report += `### ${status.charAt(0).toUpperCase() + status.slice(1)} (${features.length})\n\n`;
+    
+    features.forEach(feature => {
+      report += `#### ${feature.id}: ${feature.title}\n\n`;
+      report += `- **Milestone**: ${feature.milestone}\n`;
+      report += `- **Assignee**: ${feature.assignee}\n`;
+      report += `- **Progress**: ${feature.progress}%\n`;
+      report += `- **Commits**: ${feature.commitCount}\n`;
+      
+      if (feature.firstCommit) {
+        report += `- **First Commit**: ${feature.firstCommit.date.substring(0, 10)}\n`;
+        report += `- **Last Commit**: ${feature.lastCommit.date.substring(0, 10)}\n`;
+      }
+      
+      if (options.detailed && feature.commits.length > 0) {
+        report += '\n**Commit History**:\n\n';
+        feature.commits.forEach(commit => {
+          const shortHash = commit.hash.substring(0, 7);
+          const date = commit.date.substring(0, 10);
+          const message = commit.message.split('\n')[0];
+          report += `- \`${shortHash}\` (${date}): ${message}\n`;
+        });
+      }
+      
+      report += '\n';
+    });
+  });
+  
+  // 타임라인 뷰 (옵션)
+  if (options.timeline) {
+    report += '## Timeline View\n\n';
+    
+    // 모든 커밋을 날짜순으로 정렬
+    const allCommits = [];
+    data.forEach(feature => {
+      feature.commits.forEach(commit => {
+        allCommits.push({
+          ...commit,
+          featureId: feature.id,
+          featureTitle: feature.title
+        });
+      });
+    });
+    
+    allCommits.sort((a, b) => new Date(b.date) - new Date(a.date));
+    
+    let currentMonth = '';
+    allCommits.forEach(commit => {
+      const month = commit.date.substring(0, 7);
+      if (month !== currentMonth) {
+        currentMonth = month;
+        report += `\n### ${month}\n\n`;
+      }
+      
+      const shortHash = commit.hash.substring(0, 7);
+      const date = commit.date.substring(0, 10);
+      const message = commit.message.split('\n')[0];
+      report += `- **${date}** - ${commit.featureId}: ${message} (\`${shortHash}\`)\n`;
+    });
+  }
+  
+  return report;
+}
+
+/**
+ * JSON 형식 리포트 생성
+ */
+function generateJsonReport(data, options) {
+  const report = {
+    generated: new Date().toISOString(),
+    summary: {
+      totalFeatures: data.length,
+      totalCommits: data.reduce((sum, f) => sum + f.commitCount, 0),
+      byStatus: {}
+    },
+    features: []
+  };
+  
+  // 상태별 집계
+  data.forEach(f => {
+    report.summary.byStatus[f.status] = (report.summary.byStatus[f.status] || 0) + 1;
+  });
+  
+  // Feature 데이터
+  report.features = data.map(feature => {
+    const featureData = {
+      id: feature.id,
+      title: feature.title,
+      status: feature.status,
+      milestone: feature.milestone,
+      assignee: feature.assignee,
+      progress: feature.progress,
+      commitCount: feature.commitCount,
+      created: feature.created,
+      updated: feature.updated
+    };
+    
+    if (options.detailed) {
+      featureData.commits = feature.commits.map(commit => ({
+        hash: commit.hash,
+        author: commit.author,
+        date: commit.date,
+        message: commit.message
+      }));
+    }
+    
+    return featureData;
+  });
+  
+  return JSON.stringify(report, null, 2);
+}
+
+/**
+ * HTML 형식 리포트 생성
+ */
+function generateHtmlReport(data, options) {
+  let html = `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="UTF-8">
+  <title>Feature-Git Commit Mapping Report</title>
+  <style>
+    body { font-family: Arial, sans-serif; margin: 20px; }
+    h1, h2, h3 { color: #333; }
+    .summary { background: #f5f5f5; padding: 15px; border-radius: 5px; }
+    .feature { border: 1px solid #ddd; margin: 10px 0; padding: 15px; border-radius: 5px; }
+    .active { border-left: 4px solid #28a745; }
+    .completed { border-left: 4px solid #007bff; }
+    .archived { border-left: 4px solid #6c757d; }
+    .progress { background: #e9ecef; height: 20px; border-radius: 3px; }
+    .progress-bar { background: #007bff; height: 100%; border-radius: 3px; }
+    .commit { font-family: monospace; font-size: 0.9em; margin: 5px 0; }
+    code { background: #f5f5f5; padding: 2px 4px; border-radius: 3px; }
+  </style>
+</head>
+<body>
+  <h1>Feature-Git Commit Mapping Report</h1>
+  <p>Generated: ${new Date().toISOString()}</p>
+  
+  <div class="summary">
+    <h2>Summary</h2>
+    <ul>
+      <li>Total Features: ${data.length}</li>
+      <li>Total Commits: ${data.reduce((sum, f) => sum + f.commitCount, 0)}</li>
+    </ul>
+  </div>
+`;
+  
+  // Features by status
+  const byStatus = {};
+  data.forEach(f => {
+    byStatus[f.status] = (byStatus[f.status] || []);
+    byStatus[f.status].push(f);
+  });
+  
+  Object.entries(byStatus).forEach(([status, features]) => {
+    html += `<h2>${status.charAt(0).toUpperCase() + status.slice(1)} Features (${features.length})</h2>`;
+    
+    features.forEach(feature => {
+      html += `<div class="feature ${status}">`;
+      html += `<h3>${feature.id}: ${feature.title}</h3>`;
+      html += `<p><strong>Milestone:</strong> ${feature.milestone} | `;
+      html += `<strong>Assignee:</strong> ${feature.assignee} | `;
+      html += `<strong>Commits:</strong> ${feature.commitCount}</p>`;
+      
+      html += `<div class="progress">`;
+      html += `<div class="progress-bar" style="width: ${feature.progress}%"></div>`;
+      html += `</div>`;
+      html += `<p>Progress: ${feature.progress}%</p>`;
+      
+      if (options.detailed && feature.commits.length > 0) {
+        html += '<h4>Commit History:</h4>';
+        feature.commits.forEach(commit => {
+          const shortHash = commit.hash.substring(0, 7);
+          const date = commit.date.substring(0, 10);
+          const message = commit.message.split('\n')[0];
+          html += `<div class="commit"><code>${shortHash}</code> (${date}): ${message}</div>`;
+        });
+      }
+      
+      html += '</div>';
+    });
+  });
+  
+  html += '</body></html>';
+  return html;
+}
+
+// 명령어 실행
+program.parse(process.argv);

package/claude-code/aiwf/en/commands/scan_git_history.js

@@ -0,0 +1,234 @@
+#!/usr/bin/env node
+
+const { Command } = require('commander');
+const chalk = require('chalk');
+const ora = require('ora');
+const fs = require('fs').promises;
+const path = require('path');
+const { 
+  getFeatureRelatedCommits,
+  isGitRepository,
+  runGitCommand
+} = require('../utils/git-utils');
+const { 
+  syncFeatureWithGit,
+  findFeatureFile
+} = require('../utils/feature-updater');
+
+const program = new Command();
+
+/**
+ * scan_git_history 명령어
+ * 기존 Git 히스토리를 스캔하여 Feature와 연결
+ */
+
+program
+  .name('scan_git_history')
+  .description('기존 Git 히스토리를 스캔하여 Feature Ledger와 연결합니다')
+  .option('-s, --since <date>', '스캔 시작 날짜 (YYYY-MM-DD)', '2025-01-01')
+  .option('-u, --until <date>', '스캔 종료 날짜 (YYYY-MM-DD)', 'HEAD')
+  .option('-l, --limit <number>', '스캔할 최대 커밋 수', '1000')
+  .option('-d, --dry-run', '실제 업데이트 없이 결과만 표시')
+  .option('-f, --feature <id>', '특정 Feature ID만 스캔')
+  .option('-c, --create-missing', '누락된 Feature 파일 자동 생성')
+  .option('-v, --verbose', '상세 로그 출력')
+  .action(async (options) => {
+    const spinner = ora();
+    
+    try {
+      // Git 저장소 확인
+      if (!await isGitRepository()) {
+        console.error(chalk.red('❌ 현재 디렉토리는 Git 저장소가 아닙니다.'));
+        process.exit(1);
+      }
+      
+      console.log(chalk.cyan('🔍 Git 히스토리 스캔 시작'));
+      console.log(chalk.gray(`   기간: ${options.since} ~ ${options.until}`));
+      console.log(chalk.gray(`   최대 커밋 수: ${options.limit}`));
+      if (options.dryRun) {
+        console.log(chalk.yellow('   🏃 Dry-run 모드 (실제 업데이트 없음)'));
+      }
+      
+      spinner.start('Git 히스토리 분석 중...');
+      
+      // Git log 명령어로 커밋 목록 가져오기
+      let gitCommand = `log --since="${options.since}"`;
+      if (options.until !== 'HEAD') {
+        gitCommand += ` --until="${options.until}"`;
+      }
+      gitCommand += ` --max-count=${options.limit} --pretty=format:"%H"`;
+      
+      if (options.feature) {
+        gitCommand += ` --grep="${options.feature}"`;
+      } else {
+        gitCommand += ` --grep="FL[0-9]\\{3\\}"`;
+      }
+      
+      const commitHashes = await runGitCommand(gitCommand);
+      
+      if (!commitHashes) {
+        spinner.warn(chalk.yellow('Feature 관련 커밋을 찾을 수 없습니다.'));
+        return;
+      }
+      
+      const hashes = commitHashes.split('\n').filter(Boolean);
+      spinner.succeed(chalk.green(`${hashes.length}개의 관련 커밋 발견`));
+      
+      // 커밋 분석 및 Feature별 그룹화
+      spinner.start('커밋 분석 중...');
+      const { getCommitInfo } = require('../utils/git-utils');
+      const featureCommitMap = {};
+      const missingFeatures = new Set();
+      
+      for (const hash of hashes) {
+        const commitInfo = await getCommitInfo(hash);
+        
+        for (const featureId of commitInfo.featureIds) {
+          if (options.feature && featureId !== options.feature) {
+            continue;
+          }
+          
+          if (!featureCommitMap[featureId]) {
+            featureCommitMap[featureId] = [];
+          }
+          featureCommitMap[featureId].push(commitInfo);
+          
+          // Feature 파일 존재 확인
+          const featureFile = await findFeatureFile(featureId);
+          if (!featureFile) {
+            missingFeatures.add(featureId);
+          }
+        }
+      }
+      
+      spinner.succeed(chalk.green('커밋 분석 완료'));
+      
+      // 분석 결과 출력
+      console.log(chalk.cyan('\n📊 스캔 결과:'));
+      console.log(chalk.white(`   발견된 Feature: ${Object.keys(featureCommitMap).length}개`));
+      console.log(chalk.white(`   총 커밋 수: ${hashes.length}개`));
+      
+      if (missingFeatures.size > 0) {
+        console.log(chalk.yellow(`   누락된 Feature: ${missingFeatures.size}개`));
+        if (options.verbose) {
+          console.log(chalk.gray(`      ${[...missingFeatures].join(', ')}`));
+        }
+      }
+      
+      // Feature별 상세 정보
+      console.log(chalk.cyan('\n📋 Feature별 커밋 수:'));
+      for (const [featureId, commits] of Object.entries(featureCommitMap)) {
+        const isMissing = missingFeatures.has(featureId);
+        const statusIcon = isMissing ? '❌' : '✅';
+        const statusText = isMissing ? ' (파일 없음)' : '';
+        console.log(chalk.white(`   ${statusIcon} ${featureId}: ${commits.length}개 커밋${statusText}`));
+      }
+      
+      // 누락된 Feature 파일 생성 (옵션)
+      if (options.createMissing && missingFeatures.size > 0 && !options.dryRun) {
+        console.log(chalk.cyan('\n📝 누락된 Feature 파일 생성 중...'));
+        
+        for (const featureId of missingFeatures) {
+          spinner.start(`${featureId} 파일 생성 중...`);
+          
+          try {
+            // Feature 파일 생성
+            const featureDir = path.join(process.cwd(), '.aiwf', '06_FEATURE_LEDGERS', 'active');
+            await fs.mkdir(featureDir, { recursive: true });
+            
+            const fileName = `${featureId}_Auto_Generated.md`;
+            const filePath = path.join(featureDir, fileName);
+            
+            const content = `---
+feature_id: ${featureId}
+title: Auto Generated Feature
+status: active
+created_date: ${new Date().toISOString().substring(0, 10)}
+last_updated: ${new Date().toISOString().replace('T', ' ').substring(0, 16)}
+milestone: TBD
+sprint_ids: []
+tasks: []
+assignee: TBD
+tags: [auto-generated]
+---
+
+# Feature: Auto Generated Feature
+
+## Overview
+이 Feature는 Git 히스토리 스캔 중 자동으로 생성되었습니다.
+커밋 메시지에서 ${featureId} 참조가 발견되었지만 해당 Feature 파일이 없어 생성되었습니다.
+
+## Requirements
+- [ ] 실제 요구사항으로 업데이트 필요
+
+## Git History
+### Commits
+`;
+            
+            await fs.writeFile(filePath, content, 'utf8');
+            spinner.succeed(chalk.green(`✅ ${featureId} 파일 생성 완료`));
+            
+            // missingFeatures에서 제거
+            missingFeatures.delete(featureId);
+          } catch (error) {
+            spinner.fail(chalk.red(`❌ ${featureId} 파일 생성 실패: ${error.message}`));
+          }
+        }
+      }
+      
+      // Feature 업데이트
+      if (!options.dryRun) {
+        console.log(chalk.cyan('\n🔄 Feature 파일 업데이트 중...'));
+        
+        let successCount = 0;
+        let failCount = 0;
+        
+        for (const [featureId, commits] of Object.entries(featureCommitMap)) {
+          if (missingFeatures.has(featureId)) {
+            continue;
+          }
+          
+          spinner.start(`${featureId} 업데이트 중 (${commits.length}개 커밋)...`);
+          
+          try {
+            const { updateFeatureWithCommits } = require('../utils/feature-updater');
+            const success = await updateFeatureWithCommits(featureId, commits);
+            
+            if (success) {
+              spinner.succeed(chalk.green(`✅ ${featureId} 업데이트 완료`));
+              successCount++;
+            } else {
+              spinner.fail(chalk.red(`❌ ${featureId} 업데이트 실패`));
+              failCount++;
+            }
+          } catch (error) {
+            spinner.fail(chalk.red(`❌ ${featureId} 업데이트 중 오류: ${error.message}`));
+            failCount++;
+          }
+        }
+        
+        console.log(chalk.cyan('\n✨ 업데이트 완료!'));
+        console.log(chalk.green(`   성공: ${successCount}개`));
+        if (failCount > 0) {
+          console.log(chalk.red(`   실패: ${failCount}개`));
+        }
+      }
+      
+      // 추가 권장사항
+      if (missingFeatures.size > 0 && !options.createMissing) {
+        console.log(chalk.yellow('\n💡 팁:'));
+        console.log(chalk.gray('   --create-missing 옵션을 사용하면 누락된 Feature 파일을 자동으로 생성할 수 있습니다.'));
+      }
+      
+    } catch (error) {
+      spinner.fail(chalk.red('스캔 중 오류 발생'));
+      console.error(chalk.red(error.message));
+      if (options.verbose) {
+        console.error(error.stack);
+      }
+      process.exit(1);
+    }
+  });
+
+// 명령어 실행
+program.parse(process.argv);