aiwf 0.3.0 → 0.3.2

package/tests/integration/test-persona-aware-compression.js

@@ -0,0 +1,93 @@
+/**
+ * 페르소나 인식 압축 통합 테스트
+ */
+
+import { PersonaAwareCompressor } from '../../claude-code/aiwf/ko/utils/persona-aware-compressor.js';
+import fs from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+async function testPersonaAwareCompression() {
+  console.log('🧪 페르소나 인식 압축 테스트 시작...\n');
+
+  // 테스트용 마크다운 컨텐츠
+  const testContent = `
+# 시스템 아키텍처 문서
+
+## 개요
+이 문서는 전체 시스템의 아키텍처를 설명합니다. 확장성과 유지보수성을 고려한 설계입니다.
+
+## 컴포넌트 구조
+- API Gateway: 모든 요청의 진입점
+- 마이크로서비스: 독립적인 서비스 단위
+- 데이터베이스: PostgreSQL 클러스터
+
+## 보안 고려사항
+- JWT 기반 인증
+- API 키 관리
+- SQL 인젝션 방어
+
+## 프론트엔드 UI
+- React 컴포넌트 구조
+- 반응형 디자인
+- 접근성 준수
+
+## 데이터 분석
+- 실시간 지표 수집
+- 통계적 분석
+- 시각화 대시보드
+`;
+
+  try {
+    // 테스트 시나리오 1: 페르소나 없이 압축
+    console.log('📌 시나리오 1: 일반 압축');
+    const normalCompressor = new PersonaAwareCompressor('balanced');
+    const normalResult = await normalCompressor.compress(testContent);
+    
+    console.log(`- 원본 토큰: ${normalResult.originalTokens}`);
+    console.log(`- 압축 토큰: ${normalResult.compressedTokens}`);
+    console.log(`- 압축률: ${normalResult.compressionRatio}%`);
+    console.log(`- 페르소나: ${normalResult.metadata?.persona || '없음'}\n`);
+
+    // 테스트 시나리오 2: 각 페르소나로 압축
+    const personas = ['architect', 'security', 'frontend', 'backend', 'data_analyst'];
+    
+    for (const persona of personas) {
+      console.log(`📌 시나리오 2-${personas.indexOf(persona) + 1}: ${persona} 페르소나 압축`);
+      
+      // 임시 페르소나 파일 생성
+      const personaPath = path.join(__dirname, '../../.aiwf/current_persona.json');
+      await fs.mkdir(path.dirname(personaPath), { recursive: true });
+      await fs.writeFile(personaPath, JSON.stringify({
+        persona: persona,
+        timestamp: new Date().toISOString()
+      }));
+      
+      const personaCompressor = new PersonaAwareCompressor('balanced');
+      const personaResult = await personaCompressor.compress(testContent);
+      
+      console.log(`- 압축률: ${personaResult.compressionRatio}%`);
+      console.log(`- 패턴 보존율: ${personaResult.metadata?.validation?.patternPreservationRate || 'N/A'}%`);
+      console.log(`- 페르소나 정렬: ${personaResult.metadata?.validation?.personaAligned ? '✓' : '✗'}`);
+      
+      // 압축된 내용에서 페르소나 특화 키워드 확인
+      const preserved = personaCompressor.personaStrategies[persona].preservePatterns
+        .filter(pattern => personaResult.compressed.includes(pattern));
+      console.log(`- 보존된 키워드: ${preserved.slice(0, 3).join(', ')}...\n`);
+    }
+
+    // 정리
+    await fs.unlink(path.join(__dirname, '../../.aiwf/current_persona.json')).catch(() => {});
+    
+    console.log('✅ 모든 테스트 완료!');
+    
+  } catch (error) {
+    console.error('❌ 테스트 실패:', error.message);
+  }
+}
+
+// 테스트 실행
+testPersonaAwareCompression();

package/tests/language-utils.test.js

@@ -0,0 +1,287 @@
+/**
+ * 언어 관리 유틸리티 테스트
+ */
+
+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', () => {
+    let originalConfigExists = false;
+    let originalConfigContent = null;
+
+    beforeEach(async () => {
+        // 테스트 디렉토리 생성
+        await fs.mkdir(`${TEST_DIR}/config`, { recursive: true });
+        
+        // 기존 설정 파일 백업
+        try {
+            originalConfigContent = await fs.readFile(LANGUAGE_CONFIG_PATH, 'utf8');
+            originalConfigExists = true;
+            // 기존 설정 파일 임시 제거
+            await fs.unlink(LANGUAGE_CONFIG_PATH);
+        } catch (error) {
+            originalConfigExists = false;
+        }
+        
+        // 환경 변수 초기화
+        delete process.env.LANG;
+        delete process.env.LC_ALL;
+        delete process.env.LANGUAGE;
+    });
+
+    afterEach(async () => {
+        // 기존 설정 파일 복원
+        if (originalConfigExists && originalConfigContent) {
+            await fs.mkdir(path.dirname(LANGUAGE_CONFIG_PATH), { recursive: true });
+            await fs.writeFile(LANGUAGE_CONFIG_PATH, originalConfigContent, 'utf8');
+        }
+        
+        // 테스트 디렉토리 정리
+        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(result1.success).toBe(true);
+            expect(result1.newLanguage).toBe('ko');
+            
+            // 유효하지 않은 언어는 실패 객체를 반환해야 함
+            const result2 = await switchLanguage('invalid');
+            expect(result2.success).toBe(false);
+            expect(result2.error).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) {
+                // 무시
+            }
+        }
+    });
+});