aiwf 0.1.0 → 0.3.1

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
+};

package/scripts/validate-commands.js

@@ -0,0 +1,254 @@
+#!/usr/bin/env node
+
+/**
+ * AIWF 명령어 파일 일관성 검증 도구
+ * 
+ * 이 스크립트는 다음을 검증합니다:
+ * 1. 한국어/영어 명령어 파일 간의 일관성
+ * 2. 명령어 파일명과 실제 명령어명의 매칭
+ * 3. 누락된 명령어 파일 식별
+ * 4. GitHub URL 참조 일관성
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+
+// 색상 출력을 위한 ANSI 코드
+const colors = {
+    reset: '\x1b[0m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    cyan: '\x1b[36m',
+    gray: '\x1b[90m'
+};
+
+// chalk 대체 함수
+const chalk = {
+    red: (text) => `${colors.red}${text}${colors.reset}`,
+    green: (text) => `${colors.green}${text}${colors.reset}`,
+    yellow: (text) => `${colors.yellow}${text}${colors.reset}`,
+    blue: (text) => `${colors.blue}${text}${colors.reset}`,
+    cyan: (text) => `${colors.cyan}${text}${colors.reset}`,
+    gray: (text) => `${colors.gray}${text}${colors.reset}`,
+    bold: (text) => `\x1b[1m${text}${colors.reset}`
+};
+
+const KO_COMMANDS_DIR = 'claude-code/aiwf/ko/.claude/commands/aiwf';
+const EN_COMMANDS_DIR = 'claude-code/aiwf/en/.claude/commands/aiwf';
+
+// 명령어 파일 메타데이터 추출
+async function extractCommandMetadata(filePath) {
+    try {
+        const content = await fs.readFile(filePath, 'utf-8');
+        const lines = content.split('\n');
+        
+        // YAML frontmatter 찾기
+        if (lines[0] === '---') {
+            const endIndex = lines.findIndex((line, index) => index > 0 && line === '---');
+            if (endIndex !== -1) {
+                const frontmatter = lines.slice(1, endIndex).join('\n');
+                // 간단한 YAML 파싱 (name 추출)
+                const nameMatch = frontmatter.match(/name:\s*["']?([^"'\n]+)["']?/);
+                const descMatch = frontmatter.match(/description:\s*["']?([^"'\n]+)["']?/);
+                
+                return {
+                    name: nameMatch ? nameMatch[1] : null,
+                    description: descMatch ? descMatch[1] : null,
+                    hasFrontmatter: true
+                };
+            }
+        }
+        
+        // 첫 번째 헤더에서 명령어명 추출
+        const headerMatch = content.match(/^#\s+(.+)/m);
+        return {
+            name: headerMatch ? headerMatch[1] : null,
+            description: null,
+            hasFrontmatter: false
+        };
+    } catch (error) {
+        return { error: error.message };
+    }
+}
+
+// 디렉토리의 모든 명령어 파일 스캔
+async function scanCommandsDirectory(dir) {
+    const commands = {};
+    
+    try {
+        const files = await fs.readdir(dir);
+        const mdFiles = files.filter(file => file.endsWith('.md'));
+        
+        for (const file of mdFiles) {
+            const filePath = path.join(dir, file);
+            const metadata = await extractCommandMetadata(filePath);
+            commands[file] = {
+                ...metadata,
+                path: filePath
+            };
+        }
+    } catch (error) {
+        console.error(chalk.red(`Error scanning directory ${dir}: ${error.message}`));
+    }
+    
+    return commands;
+}
+
+// GitHub URL 참조 검증
+async function validateGitHubUrls(filePath) {
+    try {
+        const content = await fs.readFile(filePath, 'utf-8');
+        const moonklabsRefs = content.match(/moonklabs\/aiwf/g) || [];
+        const aiwfRefs = content.match(/aiwf\/aiwf/g) || [];
+        
+        return {
+            moonklabsCount: moonklabsRefs.length,
+            aiwfCount: aiwfRefs.length,
+            hasInconsistentUrls: moonklabsRefs.length > 0
+        };
+    } catch (error) {
+        return { error: error.message };
+    }
+}
+
+// 명령어 파일 검증
+async function validateCommands() {
+    console.log(chalk.blue(chalk.bold('\n🔍 AIWF Command Files Validation\n')));
+    console.log('='.repeat(50));
+    
+    // 1. 디렉토리 스캔
+    console.log(chalk.cyan('\n1. 디렉토리 스캔 중...'));
+    const koCommands = await scanCommandsDirectory(KO_COMMANDS_DIR);
+    const enCommands = await scanCommandsDirectory(EN_COMMANDS_DIR);
+    
+    console.log(chalk.gray(`   한국어 명령어: ${Object.keys(koCommands).length}개`));
+    console.log(chalk.gray(`   영어 명령어: ${Object.keys(enCommands).length}개`));
+    
+    // 2. 명령어 일관성 검증
+    console.log(chalk.cyan('\n2. 명령어 일관성 검증 중...'));
+    
+    const allFiles = new Set([...Object.keys(koCommands), ...Object.keys(enCommands)]);
+    const issues = [];
+    
+    for (const fileName of allFiles) {
+        const koExists = koCommands[fileName];
+        const enExists = enCommands[fileName];
+        
+        if (!koExists) {
+            issues.push({
+                type: 'missing_ko',
+                file: fileName,
+                message: `한국어 버전 누락: ${fileName}`
+            });
+        }
+        
+        if (!enExists) {
+            issues.push({
+                type: 'missing_en',
+                file: fileName,
+                message: `영어 버전 누락: ${fileName}`
+            });
+        }
+        
+        // 명령어명 일관성 검증 (언어가 다르므로 생략)
+        if (koExists && enExists && koExists.name && enExists.name) {
+            // 언어가 다르므로 명령어명이 다른 것은 정상
+            // 이 검증은 제거
+        }
+    }
+    
+    // 3. update_docs 명령어 검증
+    console.log(chalk.cyan('\n3. update_docs 명령어 검증 중...'));
+    
+    const updateDocsFiles = [
+        'aiwf_update_docs.md',
+        'aiwf_docs.md'
+    ];
+    
+    const updateDocsStatus = {};
+    for (const file of updateDocsFiles) {
+        updateDocsStatus[file] = {
+            ko: !!koCommands[file],
+            en: !!enCommands[file]
+        };
+    }
+    
+    // 4. GitHub URL 검증
+    console.log(chalk.cyan('\n4. GitHub URL 참조 검증 중...'));
+    
+    const urlIssues = [];
+    for (const [fileName, command] of Object.entries({ ...koCommands, ...enCommands })) {
+        if (command.path) {
+            const urlCheck = await validateGitHubUrls(command.path);
+            if (urlCheck.hasInconsistentUrls) {
+                urlIssues.push({
+                    file: fileName,
+                    path: command.path,
+                    moonklabsCount: urlCheck.moonklabsCount
+                });
+            }
+        }
+    }
+    
+    // 결과 출력
+    console.log(chalk.blue(chalk.bold('\n📋 검증 결과\n')));
+    console.log('='.repeat(50));
+    
+    // 일관성 이슈
+    if (issues.length > 0) {
+        console.log(chalk.red(`\n❌ 발견된 이슈 (${issues.length}개):`));
+        for (const issue of issues) {
+            console.log(chalk.red(`   • ${issue.message}`));
+        }
+    } else {
+        console.log(chalk.green('\n✅ 명령어 일관성 검증 통과'));
+    }
+    
+    // update_docs 상태
+    console.log(chalk.blue('\n📝 update_docs 명령어 상태:'));
+    for (const [file, status] of Object.entries(updateDocsStatus)) {
+        const koIcon = status.ko ? '✅' : '❌';
+        const enIcon = status.en ? '✅' : '❌';
+        console.log(chalk.gray(`   ${file}: KO ${koIcon} EN ${enIcon}`));
+    }
+    
+    // GitHub URL 이슈
+    if (urlIssues.length > 0) {
+        console.log(chalk.yellow(`\n⚠️ GitHub URL 이슈 (${urlIssues.length}개):`));
+        for (const issue of urlIssues) {
+            console.log(chalk.yellow(`   • ${issue.file}: moonklabs/aiwf 참조 ${issue.moonklabsCount}개`));
+        }
+    } else {
+        console.log(chalk.green('\n✅ GitHub URL 참조 검증 통과'));
+    }
+    
+    // 요약
+    console.log(chalk.blue(chalk.bold('\n📊 요약:')));
+    console.log(chalk.gray(`   총 명령어 파일: ${allFiles.size}개`));
+    console.log(chalk.gray(`   한국어/영어 쌍: ${Math.min(Object.keys(koCommands).length, Object.keys(enCommands).length)}개`));
+    console.log(chalk.gray(`   일관성 이슈: ${issues.length}개`));
+    console.log(chalk.gray(`   URL 이슈: ${urlIssues.length}개`));
+    
+    const overallSuccess = issues.length === 0 && urlIssues.length === 0;
+    console.log(overallSuccess ? 
+        chalk.green('\n🎉 모든 검증 통과!') : 
+        chalk.red('\n⚠️ 일부 이슈가 발견되었습니다.')
+    );
+    
+    return {
+        success: overallSuccess,
+        issues,
+        urlIssues,
+        updateDocsStatus,
+        totalFiles: allFiles.size
+    };
+}
+
+// 메인 실행
+if (import.meta.url === `file://${process.argv[1]}`) {
+    validateCommands().catch(console.error);
+}
+
+export { validateCommands };

package/tests/basic.test.js

@@ -0,0 +1,62 @@
+/**
+ * 기본 프로젝트 구조 테스트
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+describe('프로젝트 기본 구조', () => {
+  test('package.json 파일이 존재한다', () => {
+    const packagePath = path.join(__dirname, '../package.json');
+    expect(fs.existsSync(packagePath)).toBe(true);
+  });
+
+  test('메인 실행 파일 index.js가 존재한다', () => {
+    const indexPath = path.join(__dirname, '../index.js');
+    expect(fs.existsSync(indexPath)).toBe(true);
+  });
+
+  test('AIWF 프레임워크 디렉토리가 존재한다', () => {
+    const aiwfPath = path.join(__dirname, '../claude-code/aiwf');
+    expect(fs.existsSync(aiwfPath)).toBe(true);
+  });
+
+  test('한국어 버전 디렉토리가 존재한다', () => {
+    const koPath = path.join(__dirname, '../claude-code/aiwf/ko');
+    expect(fs.existsSync(koPath)).toBe(true);
+  });
+
+  test('영어 버전 디렉토리가 존재한다', () => {
+    const enPath = path.join(__dirname, '../claude-code/aiwf/en');
+    expect(fs.existsSync(enPath)).toBe(true);
+  });
+});
+
+describe('패키지 구성 검증', () => {
+  let packageJson;
+
+  beforeAll(() => {
+    const packagePath = path.join(__dirname, '../package.json');
+    packageJson = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+  });
+
+  test('패키지 이름이 올바르다', () => {
+    expect(packageJson.name).toBe('aiwf');
+  });
+
+  test('필수 의존성이 설치되어 있다', () => {
+    expect(packageJson.dependencies).toHaveProperty('commander');
+    expect(packageJson.dependencies).toHaveProperty('chalk');
+    expect(packageJson.dependencies).toHaveProperty('ora');
+    expect(packageJson.dependencies).toHaveProperty('prompts');
+  });
+
+  test('bin 명령어가 설정되어 있다', () => {
+    expect(packageJson.bin).toHaveProperty('aiwf');
+    expect(packageJson.bin.aiwf).toBe('./index.js');
+  });
+});