aiwf 0.1.0 → 0.3.1

package/tests/commands.test.js

@@ -0,0 +1,127 @@
+/**
+ * AIWF 명령어 파일 테스트
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+describe('AIWF 명령어 검증', () => {
+  test('명령어 디렉토리 구조가 올바르다', async () => {
+    const koDir = path.join(__dirname, '../claude-code/aiwf/ko/.claude/commands/aiwf');
+    const enDir = path.join(__dirname, '../claude-code/aiwf/en/.claude/commands/aiwf');
+    
+    const koFiles = await fs.readdir(koDir);
+    const enFiles = await fs.readdir(enDir);
+    
+    expect(koFiles.length).toBeGreaterThan(20);
+    expect(enFiles.length).toBeGreaterThan(20);
+    
+    // 한국어가 영어보다 파일이 많을 수 있음 (한국어 전용 명령어)
+    expect(koFiles.length).toBeGreaterThanOrEqual(enFiles.length);
+  });
+
+  test('한국어 명령어 디렉토리가 존재한다', async () => {
+    const koDir = path.join(__dirname, '../claude-code/aiwf/ko/.claude/commands/aiwf');
+    const stats = await fs.stat(koDir);
+    expect(stats.isDirectory()).toBe(true);
+  });
+
+  test('영어 명령어 디렉토리가 존재한다', async () => {
+    const enDir = path.join(__dirname, '../claude-code/aiwf/en/.claude/commands/aiwf');
+    const stats = await fs.stat(enDir);
+    expect(stats.isDirectory()).toBe(true);
+  });
+
+  test('필수 명령어 파일들이 존재한다', async () => {
+    const requiredCommands = [
+      'aiwf_initialize.md',
+      'aiwf_test.md',
+      'aiwf_prime.md',
+      'aiwf_do_task.md'
+    ];
+
+    const koDir = path.join(__dirname, '../claude-code/aiwf/ko/.claude/commands/aiwf');
+    const enDir = path.join(__dirname, '../claude-code/aiwf/en/.claude/commands/aiwf');
+
+    for (const command of requiredCommands) {
+      const koPath = path.join(koDir, command);
+      const enPath = path.join(enDir, command);
+      
+      const koExists = await fs.access(koPath).then(() => true).catch(() => false);
+      const enExists = await fs.access(enPath).then(() => true).catch(() => false);
+      
+      expect(koExists).toBe(true);
+      expect(enExists).toBe(true);
+    }
+  });
+
+  test('명령어 파일들이 유효한 마크다운 구조를 가진다', async () => {
+    const koDir = path.join(__dirname, '../claude-code/aiwf/ko/.claude/commands/aiwf');
+    const files = await fs.readdir(koDir);
+    const mdFiles = files.filter(file => file.endsWith('.md'));
+    
+    expect(mdFiles.length).toBeGreaterThan(0);
+    
+    // 첫 번째 파일만 샘플 테스트
+    const sampleFile = path.join(koDir, mdFiles[0]);
+    const content = await fs.readFile(sampleFile, 'utf-8');
+    
+    // 마크다운 파일은 최소한 하나의 헤더를 가져야 함
+    expect(content).toMatch(/^#\s+.+/m);
+  });
+
+  test('한국어 전용 명령어 파일 존재 검증', async () => {
+    const koDir = path.join(__dirname, '../claude-code/aiwf/ko/.claude/commands/aiwf');
+    const enDir = path.join(__dirname, '../claude-code/aiwf/en/.claude/commands/aiwf');
+    
+    const koFiles = await fs.readdir(koDir);
+    const enFiles = await fs.readdir(enDir);
+    
+    // aiwf_update_docs_kr.md는 한국어 전용이어야 함
+    const krSpecificFile = 'aiwf_update_docs_kr.md';
+    expect(koFiles).toContain(krSpecificFile);
+    
+    // 영어 버전에는 없어야 함 - 이 테스트는 실패할 것임
+    expect(enFiles).not.toContain(krSpecificFile);
+  });
+
+  test('한국어 명령어가 영어 명령어보다 많거나 같아야 함', async () => {
+    const koDir = path.join(__dirname, '../claude-code/aiwf/ko/.claude/commands/aiwf');
+    const enDir = path.join(__dirname, '../claude-code/aiwf/en/.claude/commands/aiwf');
+    
+    const koFiles = await fs.readdir(koDir);
+    const enFiles = await fs.readdir(enDir);
+    
+    // 한국어 버전이 영어보다 더 많은 명령어를 가질 수 있음 (한국어 전용 명령어)
+    expect(koFiles.length).toBeGreaterThanOrEqual(enFiles.length);
+  });
+
+  test('핵심 명령어들이 존재하는지 검증', async () => {
+    const koDir = path.join(__dirname, '../claude-code/aiwf/ko/.claude/commands/aiwf');
+    const coreCommands = ['aiwf_initialize.md', 'aiwf_prime.md', 'aiwf_test.md', 'aiwf_do_task.md'];
+    
+    const koFiles = await fs.readdir(koDir);
+    
+    coreCommands.forEach(command => {
+      expect(koFiles).toContain(command);
+    });
+  });
+
+  test('존재하지 않는 명령어 파일 테스트', async () => {
+    const nonExistentPath = path.join(__dirname, '../claude-code/aiwf/ko/.claude/commands/aiwf/non_existent_command.md');
+    
+    const exists = await fs.access(nonExistentPath).then(() => true).catch(() => false);
+    expect(exists).toBe(false);
+  });
+
+  test('잘못된 디렉토리 경로 테스트', async () => {
+    const invalidDir = path.join(__dirname, '../invalid/directory/path');
+    
+    const dirExists = await fs.access(invalidDir).then(() => true).catch(() => false);
+    expect(dirExists).toBe(false);
+  });
+});

package/tests/installer.test.js

@@ -0,0 +1,129 @@
+/**
+ * 인스톨러 기능 테스트
+ */
+
+import fs from 'fs';
+import path from 'path';
+import { execSync } from 'child_process';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+describe('AIWF 인스톨러 기능', () => {
+  let tempDir;
+
+  beforeEach(() => {
+    // 임시 테스트 디렉토리 생성
+    tempDir = path.join(__dirname, '../temp-test-installer');
+    if (fs.existsSync(tempDir)) {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    }
+    fs.mkdirSync(tempDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    // 테스트 후 정리
+    if (fs.existsSync(tempDir)) {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    }
+  });
+
+  test('버전 명령어가 올바르게 작동한다', () => {
+    const result = execSync('node index.js --version', { 
+      cwd: path.join(__dirname, '..'),
+      encoding: 'utf8',
+      timeout: 5000
+    });
+    expect(result.trim()).toMatch(/\d+\.\d+\.\d+/);
+  });
+
+  test('도움말 명령어가 올바르게 작동한다', () => {
+    const result = execSync('node index.js --help', { 
+      cwd: path.join(__dirname, '..'),
+      encoding: 'utf8',
+      timeout: 5000
+    });
+    expect(result).toContain('AIWF Installer');
+    expect(result).toContain('Options:');
+    expect(result).toContain('--force');
+  });
+
+  test('명령어 파일들이 올바른 형식인지 검증한다', () => {
+    const koCommandsDir = path.join(__dirname, '../claude-code/aiwf/ko/.claude/commands/aiwf');
+    const enCommandsDir = path.join(__dirname, '../claude-code/aiwf/en/.claude/commands/aiwf');
+    
+    expect(fs.existsSync(koCommandsDir)).toBe(true);
+    expect(fs.existsSync(enCommandsDir)).toBe(true);
+    
+    // 한국어 명령어 파일 검증
+    const koFiles = fs.readdirSync(koCommandsDir).filter(f => f.endsWith('.md'));
+    expect(koFiles.length).toBeGreaterThan(0);
+    
+    // 영어 명령어 파일 검증
+    const enFiles = fs.readdirSync(enCommandsDir).filter(f => f.endsWith('.md'));
+    expect(enFiles.length).toBeGreaterThan(0);
+    
+    // 최소한 몇 개의 핵심 명령어가 존재하는지 확인
+    const coreCommands = ['aiwf_initialize', 'aiwf_prime', 'aiwf_test'];
+    coreCommands.forEach(cmd => {
+      const koFile = path.join(koCommandsDir, `${cmd}.md`);
+      const enFile = path.join(enCommandsDir, `${cmd}.md`);
+      
+      expect(fs.existsSync(koFile) || fs.existsSync(enFile)).toBe(true);
+    });
+  });
+
+  test('AIWF 템플릿 구조가 올바르게 구성되어 있다', () => {
+    const koTemplatesDir = path.join(__dirname, '../claude-code/aiwf/ko/.aiwf');
+    const enTemplatesDir = path.join(__dirname, '../claude-code/aiwf/en/.aiwf');
+    
+    expect(fs.existsSync(koTemplatesDir)).toBe(true);
+    expect(fs.existsSync(enTemplatesDir)).toBe(true);
+    
+    // 필수 템플릿 디렉토리들 확인
+    const requiredDirs = ['99_TEMPLATES', '98_PROMPTS'];
+    
+    requiredDirs.forEach(dir => {
+      const koDir = path.join(koTemplatesDir, dir);
+      const enDir = path.join(enTemplatesDir, dir);
+      
+      expect(fs.existsSync(koDir) || fs.existsSync(enDir)).toBe(true);
+    });
+  });
+});
+
+describe('프로젝트 문서화', () => {
+  test('필수 문서 파일들이 존재한다', () => {
+    const requiredDocs = [
+      'README.md',
+      'README.ko.md',
+      'CLAUDE.md',
+      'docs/COMMANDS_GUIDE.md',
+      'docs/COMMANDS_GUIDE.ko.md'
+    ];
+    
+    requiredDocs.forEach(doc => {
+      const docPath = path.join(__dirname, '..', doc);
+      expect(fs.existsSync(docPath)).toBe(true);
+    });
+  });
+
+  test('다국어 지원이 일관되게 구현되어 있다', () => {
+    const koDir = path.join(__dirname, '../claude-code/aiwf/ko');
+    const enDir = path.join(__dirname, '../claude-code/aiwf/en');
+    
+    expect(fs.existsSync(koDir)).toBe(true);
+    expect(fs.existsSync(enDir)).toBe(true);
+    
+    // 각 언어 버전에 필수 구조가 있는지 확인
+    ['ko', 'en'].forEach(lang => {
+      const langDir = path.join(__dirname, `../claude-code/aiwf/${lang}`);
+      const claudeDir = path.join(langDir, '.claude/commands/aiwf');
+      const aiwfDir = path.join(langDir, '.aiwf');
+      
+      expect(fs.existsSync(claudeDir)).toBe(true);
+      expect(fs.existsSync(aiwfDir)).toBe(true);
+    });
+  });
+});

package/tests/language-utils.test.js

@@ -0,0 +1,271 @@
+/**
+ * 언어 관리 유틸리티 테스트
+ */
+
+import { jest } from '@jest/globals';
+import fs from 'fs/promises';
+import path from 'path';
+import {
+    detectLanguage,
+    loadUserLanguageConfig,
+    saveUserLanguageConfig,
+    getCommandPath,
+    resolveCommandPath,
+    getTemplatePath,
+    getLocalizedMessage,
+    switchLanguage,
+    getLanguageStatus,
+    SUPPORTED_LANGUAGES,
+    DEFAULT_LANGUAGE,
+    LANGUAGE_CONFIG_PATH
+} from '../language-utils.js';
+
+// 테스트용 임시 디렉토리
+const TEST_DIR = '.aiwf-test';
+const TEST_CONFIG_PATH = `${TEST_DIR}/config/language.json`;
+
+describe('Language Utils', () => {
+    beforeEach(async () => {
+        // 테스트 디렉토리 생성
+        await fs.mkdir(`${TEST_DIR}/config`, { recursive: true });
+        
+        // 환경 변수 초기화
+        delete process.env.LANG;
+        delete process.env.LC_ALL;
+        delete process.env.LANGUAGE;
+    });
+
+    afterEach(async () => {
+        // 테스트 디렉토리 정리
+        try {
+            await fs.rm(TEST_DIR, { recursive: true, force: true });
+        } catch (error) {
+            // 무시
+        }
+    });
+
+    describe('detectLanguage', () => {
+        test('should return default language when no settings exist', async () => {
+            const language = await detectLanguage();
+            expect(SUPPORTED_LANGUAGES).toContain(language);
+        });
+
+        test('should detect Korean from environment variables', async () => {
+            process.env.LANG = 'ko_KR.UTF-8';
+            const language = await detectLanguage();
+            expect(language).toBe('ko');
+        });
+
+        test('should detect English from environment variables', async () => {
+            process.env.LANG = 'en_US.UTF-8';
+            const language = await detectLanguage();
+            expect(language).toBe('en');
+        });
+
+        test('should return default language for unsupported locale', async () => {
+            process.env.LANG = 'ja_JP.UTF-8';
+            const language = await detectLanguage();
+            expect(language).toBe(DEFAULT_LANGUAGE);
+        });
+    });
+
+    describe('saveUserLanguageConfig and loadUserLanguageConfig', () => {
+        test('should save and load language configuration', async () => {
+            // 테스트용 경로로 저장
+            const config = {
+                language: 'ko',
+                auto_detect: true,
+                last_updated: new Date().toISOString(),
+                fallback: 'en'
+            };
+
+            await fs.writeFile(TEST_CONFIG_PATH, JSON.stringify(config, null, 2));
+
+            // 설정 파일 읽기 테스트는 실제 파일 시스템이 아닌 모의 구현을 사용해야 함
+            const savedContent = await fs.readFile(TEST_CONFIG_PATH, 'utf8');
+            const parsedConfig = JSON.parse(savedContent);
+            
+            expect(parsedConfig.language).toBe('ko');
+            expect(parsedConfig.auto_detect).toBe(true);
+            expect(parsedConfig.fallback).toBe('en');
+        });
+
+        test('should handle invalid language configuration', async () => {
+            const invalidConfig = { language: 'invalid' };
+            await fs.writeFile(TEST_CONFIG_PATH, JSON.stringify(invalidConfig));
+            
+            // 실제 함수가 유효성 검증을 수행한다고 가정
+            const savedContent = await fs.readFile(TEST_CONFIG_PATH, 'utf8');
+            const config = JSON.parse(savedContent);
+            
+            // 유효하지 않은 설정은 처리되지 않아야 함
+            expect(SUPPORTED_LANGUAGES).not.toContain(config.language);
+        });
+    });
+
+    describe('getCommandPath', () => {
+        test('should return correct path for Korean commands', () => {
+            const path = getCommandPath('aiwf_do_task', 'ko');
+            expect(path).toBe('claude-code/aiwf/ko/.claude/commands/aiwf/aiwf_do_task.md');
+        });
+
+        test('should return correct path for English commands', () => {
+            const path = getCommandPath('aiwf_do_task', 'en');
+            expect(path).toBe('claude-code/aiwf/en/.claude/commands/aiwf/aiwf_do_task.md');
+        });
+
+        test('should fallback to default language for invalid language', () => {
+            const path = getCommandPath('aiwf_do_task', 'invalid');
+            expect(path).toBe(`claude-code/aiwf/${DEFAULT_LANGUAGE}/.claude/commands/aiwf/aiwf_do_task.md`);
+        });
+
+        test('should use default language when no language specified', () => {
+            const path = getCommandPath('aiwf_do_task');
+            expect(path).toBe(`claude-code/aiwf/${DEFAULT_LANGUAGE}/.claude/commands/aiwf/aiwf_do_task.md`);
+        });
+    });
+
+    describe('getTemplatePath', () => {
+        test('should return correct template path for Korean', () => {
+            const path = getTemplatePath('task_template.md', 'ko');
+            expect(path).toBe('.aiwf/99_TEMPLATES/ko/task_template.md');
+        });
+
+        test('should return correct template path for English', () => {
+            const path = getTemplatePath('task_template.md', 'en');
+            expect(path).toBe('.aiwf/99_TEMPLATES/en/task_template.md');
+        });
+    });
+
+    describe('getLocalizedMessage', () => {
+        test('should return Korean message', () => {
+            const message = getLocalizedMessage('LANGUAGE_NOT_SUPPORTED', 'ko');
+            expect(message).toBe('지원되지 않는 언어입니다');
+        });
+
+        test('should return English message', () => {
+            const message = getLocalizedMessage('LANGUAGE_NOT_SUPPORTED', 'en');
+            expect(message).toBe('Language not supported');
+        });
+
+        test('should fallback to default language for invalid language', () => {
+            const message = getLocalizedMessage('LANGUAGE_NOT_SUPPORTED', 'invalid');
+            expect(message).toBe('Language not supported'); // DEFAULT_LANGUAGE가 'en'이라고 가정
+        });
+
+        test('should return key if message not found', () => {
+            const message = getLocalizedMessage('INVALID_KEY', 'ko');
+            expect(message).toBe('INVALID_KEY');
+        });
+    });
+
+    describe('switchLanguage', () => {
+        test('should validate supported language', async () => {
+            // 유효한 언어
+            const result1 = await switchLanguage('ko');
+            expect(['ko', 'en']).toContain('ko');
+            
+            // 유효하지 않은 언어는 예외를 발생시켜야 함
+            try {
+                await switchLanguage('invalid');
+                // 이 라인에 도달하면 안됨
+                expect(true).toBe(false);
+            } catch (error) {
+                expect(error.message).toContain('지원되지 않는 언어');
+            }
+        });
+    });
+
+    describe('constants', () => {
+        test('should have valid supported languages', () => {
+            expect(Array.isArray(SUPPORTED_LANGUAGES)).toBe(true);
+            expect(SUPPORTED_LANGUAGES.length).toBeGreaterThan(0);
+            expect(SUPPORTED_LANGUAGES).toContain('ko');
+            expect(SUPPORTED_LANGUAGES).toContain('en');
+        });
+
+        test('should have valid default language', () => {
+            expect(SUPPORTED_LANGUAGES).toContain(DEFAULT_LANGUAGE);
+        });
+
+        test('should have valid config path', () => {
+            expect(typeof LANGUAGE_CONFIG_PATH).toBe('string');
+            expect(LANGUAGE_CONFIG_PATH).toContain('.aiwf');
+            expect(LANGUAGE_CONFIG_PATH).toContain('language.json');
+        });
+    });
+});
+
+describe('Language Utils Integration', () => {
+    test('should work with real file system operations', async () => {
+        // 실제 파일 시스템을 사용한 통합 테스트
+        const testConfigDir = '.aiwf-integration-test/config';
+        const testConfigFile = `${testConfigDir}/language.json`;
+        
+        try {
+            // 테스트 디렉토리 생성
+            await fs.mkdir(testConfigDir, { recursive: true });
+            
+            // 설정 파일 생성
+            const config = {
+                language: 'ko',
+                auto_detect: false,
+                last_updated: new Date().toISOString(),
+                fallback: 'en'
+            };
+            
+            await fs.writeFile(testConfigFile, JSON.stringify(config, null, 2));
+            
+            // 파일 존재 확인
+            const exists = await fs.access(testConfigFile).then(() => true).catch(() => false);
+            expect(exists).toBe(true);
+            
+            // 내용 확인
+            const content = await fs.readFile(testConfigFile, 'utf8');
+            const parsedConfig = JSON.parse(content);
+            expect(parsedConfig.language).toBe('ko');
+            
+        } finally {
+            // 정리
+            try {
+                await fs.rm('.aiwf-integration-test', { recursive: true, force: true });
+            } catch (error) {
+                // 무시
+            }
+        }
+    });
+});
+
+describe('Error Handling', () => {
+    test('should handle file system errors gracefully', async () => {
+        // 존재하지 않는 디렉토리에서 설정 로드 시도
+        const originalConfigPath = LANGUAGE_CONFIG_PATH;
+        
+        // detectLanguage는 실패해도 기본값을 반환해야 함
+        const language = await detectLanguage();
+        expect(SUPPORTED_LANGUAGES).toContain(language);
+    });
+
+    test('should handle corrupt configuration files', async () => {
+        const testConfigDir = '.aiwf-error-test/config';
+        const testConfigFile = `${testConfigDir}/language.json`;
+        
+        try {
+            await fs.mkdir(testConfigDir, { recursive: true });
+            
+            // 잘못된 JSON 파일 생성
+            await fs.writeFile(testConfigFile, '{ invalid json }');
+            
+            // 손상된 설정 파일이 있어도 언어 감지는 정상 작동해야 함
+            const language = await detectLanguage();
+            expect(SUPPORTED_LANGUAGES).toContain(language);
+            
+        } finally {
+            try {
+                await fs.rm('.aiwf-error-test', { recursive: true, force: true });
+            } catch (error) {
+                // 무시
+            }
+        }
+    });
+});