aiwf 0.3.0 → 0.3.2

package/scripts/run-integration-tests.js

@@ -0,0 +1,317 @@
+#!/usr/bin/env node
+
+/**
+ * 통합 테스트 실행 자동화 스크립트
+ */
+
+import { spawn } from 'child_process';
+import fs from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// 색상 출력을 위한 헬퍼
+const colors = {
+  reset: '\x1b[0m',
+  bright: '\x1b[1m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  magenta: '\x1b[35m',
+  cyan: '\x1b[36m'
+};
+
+const log = {
+  info: (msg) => console.log(`${colors.blue}[INFO]${colors.reset} ${msg}`),
+  success: (msg) => console.log(`${colors.green}[SUCCESS]${colors.reset} ${msg}`),
+  warning: (msg) => console.log(`${colors.yellow}[WARNING]${colors.reset} ${msg}`),
+  error: (msg) => console.log(`${colors.red}[ERROR]${colors.reset} ${msg}`),
+  header: (msg) => console.log(`${colors.bright}${colors.cyan}${msg}${colors.reset}`)
+};
+
+async function runCommand(command, args, options = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      stdio: 'inherit',
+      shell: true,
+      ...options
+    });
+
+    child.on('close', (code) => {
+      if (code === 0) {
+        resolve(code);
+      } else {
+        reject(new Error(`Command failed with exit code ${code}`));
+      }
+    });
+
+    child.on('error', reject);
+  });
+}
+
+async function checkTestEnvironment() {
+  log.info('테스트 환경 확인 중...');
+  
+  // Node.js 버전 확인
+  const nodeVersion = process.version;
+  log.info(`Node.js 버전: ${nodeVersion}`);
+  
+  // 필요한 디렉토리 확인
+  const requiredDirs = [
+    'tests',
+    'tests/integration'
+  ];
+  
+  for (const dir of requiredDirs) {
+    const dirPath = path.join(__dirname, '..', dir);
+    try {
+      await fs.access(dirPath);
+      log.success(`디렉토리 확인: ${dir}`);
+    } catch {
+      log.error(`디렉토리 누락: ${dir}`);
+      return false;
+    }
+  }
+  
+  return true;
+}
+
+async function runBasicTests() {
+  log.header('=== 기본 테스트 실행 ===');
+  
+  try {
+    await runCommand('npm', ['test', '--', '--testPathPattern=tests/(?!integration).*\\.test\\.js$']);
+    log.success('기본 테스트 완료');
+    return true;
+  } catch (error) {
+    log.error('기본 테스트 실패');
+    return false;
+  }
+}
+
+async function runIntegrationTests() {
+  log.header('=== 통합 테스트 실행 ===');
+  
+  try {
+    await runCommand('npm', ['test', '--', '--testPathPattern=tests/integration/.*\\.test\\.js$']);
+    log.success('통합 테스트 완료');
+    return true;
+  } catch (error) {
+    log.error('통합 테스트 실패');
+    return false;
+  }
+}
+
+async function runCoverageReport() {
+  log.header('=== 커버리지 리포트 생성 ===');
+  
+  try {
+    await runCommand('npm', ['test', '--', '--coverage']);
+    log.success('커버리지 리포트 생성 완료');
+    
+    // 커버리지 결과 파일 확인
+    const coverageFile = path.join(__dirname, '..', 'coverage', 'coverage-summary.json');
+    try {
+      const coverageData = JSON.parse(await fs.readFile(coverageFile, 'utf8'));
+      const total = coverageData.total;
+      
+      log.info(`커버리지 결과:`);
+      log.info(`  - Lines: ${total.lines.pct}%`);
+      log.info(`  - Functions: ${total.functions.pct}%`);
+      log.info(`  - Branches: ${total.branches.pct}%`);
+      log.info(`  - Statements: ${total.statements.pct}%`);
+      
+      // 80% 이상 커버리지 확인
+      const threshold = 80;
+      const coverageOK = total.lines.pct >= threshold && 
+                        total.functions.pct >= threshold && 
+                        total.branches.pct >= threshold && 
+                        total.statements.pct >= threshold;
+      
+      if (coverageOK) {
+        log.success(`커버리지 목표 달성 (${threshold}% 이상)`);
+      } else {
+        log.warning(`커버리지 목표 미달성 (${threshold}% 미만)`);
+      }
+      
+      return coverageOK;
+    } catch (error) {
+      log.warning('커버리지 결과 파일을 읽을 수 없습니다.');
+      return false;
+    }
+  } catch (error) {
+    log.error('커버리지 리포트 생성 실패');
+    return false;
+  }
+}
+
+async function generateTestReport() {
+  log.header('=== 테스트 리포트 생성 ===');
+  
+  const reportData = {
+    timestamp: new Date().toISOString(),
+    testSuites: {
+      basic: { executed: false, passed: false },
+      integration: { executed: false, passed: false },
+      coverage: { executed: false, passed: false }
+    },
+    summary: {
+      totalTests: 0,
+      passedTests: 0,
+      failedTests: 0,
+      coverageThreshold: '80%'
+    }
+  };
+  
+  // 테스트 결과 수집
+  try {
+    const testResults = await runCommand('npm', ['test', '--', '--json', '--outputFile=test-results.json'], {
+      stdio: 'pipe'
+    });
+    
+    try {
+      const resultsFile = path.join(__dirname, '..', 'test-results.json');
+      const results = JSON.parse(await fs.readFile(resultsFile, 'utf8'));
+      
+      reportData.summary.totalTests = results.numTotalTests;
+      reportData.summary.passedTests = results.numPassedTests;
+      reportData.summary.failedTests = results.numFailedTests;
+      
+      // 임시 파일 정리
+      await fs.unlink(resultsFile);
+    } catch (error) {
+      log.warning('테스트 결과 파일을 읽을 수 없습니다.');
+    }
+  } catch (error) {
+    log.warning('테스트 결과 수집 중 오류가 발생했습니다.');
+  }
+  
+  // 리포트 파일 생성
+  const reportPath = path.join(__dirname, '..', 'test-report.json');
+  await fs.writeFile(reportPath, JSON.stringify(reportData, null, 2));
+  
+  log.success(`테스트 리포트 생성: ${reportPath}`);
+  return true;
+}
+
+async function cleanupTestFiles() {
+  log.info('테스트 임시 파일 정리 중...');
+  
+  const tempDirs = [
+    path.join(__dirname, '..', 'tmp'),
+    path.join(__dirname, '..', 'coverage')
+  ];
+  
+  for (const dir of tempDirs) {
+    try {
+      await fs.rm(dir, { recursive: true, force: true });
+      log.success(`정리 완료: ${dir}`);
+    } catch (error) {
+      // 디렉토리가 존재하지 않는 경우는 무시
+    }
+  }
+}
+
+async function main() {
+  log.header('🧪 AIWF 통합 테스트 Suite 실행');
+  
+  const startTime = Date.now();
+  let allTestsPassed = true;
+  
+  try {
+    // 1. 테스트 환경 확인
+    if (!await checkTestEnvironment()) {
+      log.error('테스트 환경 확인 실패');
+      process.exit(1);
+    }
+    
+    // 2. 기본 테스트 실행
+    const basicTestsOK = await runBasicTests();
+    if (!basicTestsOK) {
+      allTestsPassed = false;
+    }
+    
+    // 3. 통합 테스트 실행
+    const integrationTestsOK = await runIntegrationTests();
+    if (!integrationTestsOK) {
+      allTestsPassed = false;
+    }
+    
+    // 4. 커버리지 리포트 생성
+    const coverageOK = await runCoverageReport();
+    if (!coverageOK) {
+      allTestsPassed = false;
+    }
+    
+    // 5. 테스트 리포트 생성
+    await generateTestReport();
+    
+    // 6. 정리
+    await cleanupTestFiles();
+    
+    const endTime = Date.now();
+    const duration = Math.round((endTime - startTime) / 1000);
+    
+    log.header('=== 테스트 실행 완료 ===');
+    log.info(`총 실행 시간: ${duration}초`);
+    
+    if (allTestsPassed) {
+      log.success('모든 테스트가 성공적으로 완료되었습니다! 🎉');
+      process.exit(0);
+    } else {
+      log.error('일부 테스트가 실패했습니다. 자세한 내용을 확인해 주세요.');
+      process.exit(1);
+    }
+    
+  } catch (error) {
+    log.error(`테스트 실행 중 오류 발생: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+// 명령줄 인수 처리
+const args = process.argv.slice(2);
+if (args.includes('--help') || args.includes('-h')) {
+  console.log(`
+AIWF 통합 테스트 Suite 실행 스크립트
+
+사용법:
+  node scripts/run-integration-tests.js [옵션]
+
+옵션:
+  --help, -h        이 도움말 표시
+  --basic-only      기본 테스트만 실행
+  --integration-only 통합 테스트만 실행
+  --coverage-only   커버리지 리포트만 생성
+  --no-cleanup      테스트 후 정리 작업 생략
+
+예시:
+  node scripts/run-integration-tests.js
+  node scripts/run-integration-tests.js --basic-only
+  node scripts/run-integration-tests.js --coverage-only
+`);
+  process.exit(0);
+}
+
+// 개별 테스트 실행 옵션
+if (args.includes('--basic-only')) {
+  (async () => {
+    await checkTestEnvironment();
+    await runBasicTests();
+  })();
+} else if (args.includes('--integration-only')) {
+  (async () => {
+    await checkTestEnvironment();
+    await runIntegrationTests();
+  })();
+} else if (args.includes('--coverage-only')) {
+  (async () => {
+    await checkTestEnvironment();
+    await runCoverageReport();
+  })();
+} else {
+  main();
+}

package/scripts/validate-commands.cjs

@@ -0,0 +1,338 @@
+#!/usr/bin/env node
+
+/**
+ * AIWF 명령어 파일 일관성 검증 도구
+ * 
+ * 이 스크립트는 다음을 검증합니다:
+ * 1. 한국어/영어 명령어 파일 간의 일관성
+ * 2. 명령어 파일명과 실제 명령어명의 매칭
+ * 3. 누락된 명령어 파일 식별
+ * 4. GitHub URL 참조 일관성
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// 색상 출력을 위한 ANSI 코드
+const colors = {
+    reset: '\x1b[0m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    cyan: '\x1b[36m'
+};
+
+function log(message, color = 'reset') {
+    console.log(`${colors[color]}${message}${colors.reset}`);
+}
+
+// 명령어 파일 경로
+const KOREAN_COMMANDS_PATH = path.join(__dirname, '../claude-code/aiwf/ko/.claude/commands/aiwf');
+const ENGLISH_COMMANDS_PATH = path.join(__dirname, '../claude-code/aiwf/en/.claude/commands/aiwf');
+
+/**
+ * 디렉토리에서 명령어 파일 목록을 가져옵니다
+ */
+function getCommandFiles(dirPath) {
+    try {
+        return fs.readdirSync(dirPath)
+            .filter(file => file.endsWith('.md'))
+            .map(file => ({
+                filename: file,
+                path: path.join(dirPath, file)
+            }));
+    } catch (error) {
+        log(`디렉토리를 읽을 수 없습니다: ${dirPath}`, 'red');
+        return [];
+    }
+}
+
+/**
+ * 명령어 파일에서 메타데이터를 추출합니다
+ */
+function extractCommandMetadata(filePath) {
+    try {
+        const content = fs.readFileSync(filePath, 'utf8');
+        const lines = content.split('\n');
+        
+        // 파일명에서 명령어명 추출 (aiwf_*.md → aiwf_*)
+        const filename = path.basename(filePath, '.md');
+        
+        // 첫 번째 # 제목 찾기
+        const titleLine = lines.find(line => line.startsWith('# '));
+        const title = titleLine ? titleLine.substring(2).trim() : '';
+        
+        // frontmatter에서 name 필드 찾기 (있는 경우)
+        let frontmatterName = '';
+        if (content.startsWith('---')) {
+            const frontmatterEnd = content.indexOf('---', 3);
+            if (frontmatterEnd > 0) {
+                const frontmatter = content.substring(0, frontmatterEnd);
+                const nameMatch = frontmatter.match(/name:\s*["']?([^"'\n]+)["']?/);
+                if (nameMatch) {
+                    frontmatterName = nameMatch[1];
+                }
+            }
+        }
+        
+        return {
+            filename,
+            title,
+            frontmatterName,
+            path: filePath
+        };
+    } catch (error) {
+        log(`파일을 읽을 수 없습니다: ${filePath}`, 'red');
+        return null;
+    }
+}
+
+/**
+ * 한국어와 영어 명령어 파일의 일관성을 검증합니다
+ */
+function validateConsistency() {
+    log('\n=== 명령어 파일 일관성 검증 ===', 'cyan');
+    
+    const koreanFiles = getCommandFiles(KOREAN_COMMANDS_PATH);
+    const englishFiles = getCommandFiles(ENGLISH_COMMANDS_PATH);
+    
+    log(`한국어 명령어 파일: ${koreanFiles.length}개`, 'blue');
+    log(`영어 명령어 파일: ${englishFiles.length}개`, 'blue');
+    
+    // 파일명 기준으로 매칭 (한국어는 _kr 접미사 제거)
+    const koreanFileMap = new Map();
+    const englishFileMap = new Map();
+    
+    koreanFiles.forEach(file => {
+        const normalizedName = file.filename.replace('_kr.md', '.md');
+        koreanFileMap.set(normalizedName, file);
+    });
+    
+    englishFiles.forEach(file => {
+        englishFileMap.set(file.filename, file);
+    });
+    
+    // 누락된 파일 확인
+    const allFileNames = new Set([...koreanFileMap.keys(), ...englishFileMap.keys()]);
+    const missingInKorean = [];
+    const missingInEnglish = [];
+    
+    allFileNames.forEach(filename => {
+        if (!koreanFileMap.has(filename)) {
+            missingInKorean.push(filename);
+        }
+        if (!englishFileMap.has(filename)) {
+            missingInEnglish.push(filename);
+        }
+    });
+    
+    // 결과 출력
+    if (missingInKorean.length > 0) {
+        log('\n한국어 버전에서 누락된 파일:', 'yellow');
+        missingInKorean.forEach(file => log(`  - ${file}`, 'red'));
+    }
+    
+    if (missingInEnglish.length > 0) {
+        log('\n영어 버전에서 누락된 파일:', 'yellow');
+        missingInEnglish.forEach(file => log(`  - ${file}`, 'red'));
+    }
+    
+    if (missingInKorean.length === 0 && missingInEnglish.length === 0) {
+        log('\n✅ 모든 명령어 파일이 한국어/영어 버전으로 존재합니다', 'green');
+    }
+    
+    return {
+        koreanFiles: koreanFileMap,
+        englishFiles: englishFileMap,
+        missingInKorean,
+        missingInEnglish
+    };
+}
+
+/**
+ * 명령어 파일의 메타데이터를 검증합니다
+ */
+function validateMetadata() {
+    log('\n=== 명령어 메타데이터 검증 ===', 'cyan');
+    
+    const koreanFiles = getCommandFiles(KOREAN_COMMANDS_PATH);
+    const englishFiles = getCommandFiles(ENGLISH_COMMANDS_PATH);
+    
+    let issues = 0;
+    
+    // 한국어 파일 검증
+    log('\n한국어 명령어 파일 검증:', 'blue');
+    koreanFiles.forEach(file => {
+        const metadata = extractCommandMetadata(file.path);
+        if (metadata) {
+            if (!metadata.title) {
+                log(`  ❌ ${file.filename}: 제목이 없습니다`, 'red');
+                issues++;
+            } else {
+                log(`  ✅ ${file.filename}: ${metadata.title}`, 'green');
+            }
+        }
+    });
+    
+    // 영어 파일 검증
+    log('\n영어 명령어 파일 검증:', 'blue');
+    englishFiles.forEach(file => {
+        const metadata = extractCommandMetadata(file.path);
+        if (metadata) {
+            if (!metadata.title) {
+                log(`  ❌ ${file.filename}: 제목이 없습니다`, 'red');
+                issues++;
+            } else {
+                log(`  ✅ ${file.filename}: ${metadata.title}`, 'green');
+            }
+        }
+    });
+    
+    if (issues === 0) {
+        log('\n✅ 모든 명령어 파일의 메타데이터가 올바릅니다', 'green');
+    } else {
+        log(`\n❌ ${issues}개의 메타데이터 이슈가 발견되었습니다`, 'red');
+    }
+    
+    return issues;
+}
+
+/**
+ * GitHub URL 참조를 검증합니다
+ */
+function validateGitHubUrls() {
+    log('\n=== GitHub URL 참조 검증 ===', 'cyan');
+    
+    const allFiles = [
+        ...getCommandFiles(KOREAN_COMMANDS_PATH),
+        ...getCommandFiles(ENGLISH_COMMANDS_PATH)
+    ];
+    
+    let issues = 0;
+    
+    allFiles.forEach(file => {
+        const content = fs.readFileSync(file.path, 'utf8');
+        
+        // moonklabs/aiwf 패턴 검색
+        if (content.includes('moonklabs/aiwf')) {
+            log(`  ❌ ${file.filename}: 'moonklabs/aiwf' 참조 발견`, 'red');
+            issues++;
+        }
+        
+        // aiwf/aiwf 패턴 확인
+        if (content.includes('aiwf/aiwf')) {
+            log(`  ✅ ${file.filename}: 올바른 'aiwf/aiwf' 참조`, 'green');
+        }
+    });
+    
+    if (issues === 0) {
+        log('\n✅ 모든 GitHub URL 참조가 올바릅니다', 'green');
+    } else {
+        log(`\n❌ ${issues}개의 잘못된 GitHub URL 참조가 발견되었습니다`, 'red');
+    }
+    
+    return issues;
+}
+
+/**
+ * 특정 명령어 파일이 누락되었는지 확인합니다
+ */
+function checkSpecificCommands() {
+    log('\n=== 특정 명령어 파일 확인 ===', 'cyan');
+    
+    const requiredCommands = [
+        'aiwf_update_docs.md',     // 영어 버전
+        'aiwf_update_docs_kr.md'   // 한국어 버전
+    ];
+    
+    let issues = 0;
+    
+    requiredCommands.forEach(commandFile => {
+        const isKorean = commandFile.includes('_kr');
+        const dirPath = isKorean ? KOREAN_COMMANDS_PATH : ENGLISH_COMMANDS_PATH;
+        const filePath = path.join(dirPath, commandFile);
+        
+        if (fs.existsSync(filePath)) {
+            log(`  ✅ ${commandFile}: 존재`, 'green');
+        } else {
+            log(`  ❌ ${commandFile}: 누락`, 'red');
+            issues++;
+        }
+    });
+    
+    // aiwf_docs.md가 있는지 확인 (기존 파일)
+    const legacyDocsKo = path.join(KOREAN_COMMANDS_PATH, 'aiwf_docs.md');
+    const legacyDocsEn = path.join(ENGLISH_COMMANDS_PATH, 'aiwf_docs.md');
+    
+    if (fs.existsSync(legacyDocsKo)) {
+        log(`  ℹ️  aiwf_docs.md (한국어): 기존 파일 존재`, 'yellow');
+    }
+    
+    if (fs.existsSync(legacyDocsEn)) {
+        log(`  ℹ️  aiwf_docs.md (영어): 기존 파일 존재`, 'yellow');
+    }
+    
+    return issues;
+}
+
+/**
+ * 검증 요약을 출력합니다
+ */
+function printSummary(results) {
+    log('\n=== 검증 요약 ===', 'cyan');
+    
+    const totalIssues = results.metadataIssues + results.githubUrlIssues + results.specificCommandIssues;
+    
+    log(`총 발견된 이슈: ${totalIssues}개`, totalIssues > 0 ? 'red' : 'green');
+    log(`- 메타데이터 이슈: ${results.metadataIssues}개`, 'blue');
+    log(`- GitHub URL 이슈: ${results.githubUrlIssues}개`, 'blue');
+    log(`- 누락된 특정 명령어: ${results.specificCommandIssues}개`, 'blue');
+    log(`- 한국어 버전 누락: ${results.consistency.missingInKorean.length}개`, 'blue');
+    log(`- 영어 버전 누락: ${results.consistency.missingInEnglish.length}개`, 'blue');
+    
+    if (totalIssues === 0) {
+        log('\n🎉 모든 검증이 통과되었습니다!', 'green');
+        return true;
+    } else {
+        log('\n⚠️  일부 이슈가 발견되었습니다. 위의 내용을 확인해주세요.', 'red');
+        return false;
+    }
+}
+
+/**
+ * 메인 실행 함수
+ */
+function main() {
+    log('AIWF 명령어 파일 일관성 검증 도구', 'cyan');
+    log('====================================', 'cyan');
+    
+    const consistency = validateConsistency();
+    const metadataIssues = validateMetadata();
+    const githubUrlIssues = validateGitHubUrls();
+    const specificCommandIssues = checkSpecificCommands();
+    
+    const results = {
+        consistency,
+        metadataIssues,
+        githubUrlIssues,
+        specificCommandIssues
+    };
+    
+    const success = printSummary(results);
+    
+    // 종료 코드 설정
+    process.exit(success ? 0 : 1);
+}
+
+// 스크립트가 직접 실행될 때만 main 함수 호출
+if (require.main === module) {
+    main();
+}
+
+module.exports = {
+    validateConsistency,
+    validateMetadata,
+    validateGitHubUrls,
+    checkSpecificCommands
+};