aiwf 0.3.8 → 0.3.13

package/tests/integration/persona-context-application.test.js

@@ -1,508 +0,0 @@
-/**
- * 페르소나 컨텍스트 적용 시스템 테스트 스위트
- */
-
-// 모듈이 아직 구현되지 않았으므로 테스트 스킵
-// const ContextRuleParser = require('../../aiwf/ko/utils/context-rule-parser');
-// const PromptInjector = require('../../aiwf/ko/utils/prompt-injector');
-// const PersonaBehaviorValidator = require('../../aiwf/ko/utils/persona-behavior-validator');
-// const ContextUpdateManager = require('../../aiwf/ko/utils/context-update-manager');
-// 모듈이 아직 구현되지 않았으므로 테스트 스킵
-// const ContextTokenMonitor = require('../../aiwf/ko/utils/context-token-monitor');
-// const PersonaQualityEvaluator = require('../../aiwf/ko/utils/persona-quality-evaluator');
-// const fs = require('fs').promises;
-// const path = require('path');
-
-describe.skip('페르소나 컨텍스트 적용 시스템', () => {
-  let contextParser;
-  let promptInjector;
-  let behaviorValidator;
-  let updateManager;
-  let tokenMonitor;
-  let qualityEvaluator;
-
-  beforeEach(() => {
-    contextParser = new ContextRuleParser();
-    promptInjector = new PromptInjector();
-    behaviorValidator = new PersonaBehaviorValidator();
-    updateManager = new ContextUpdateManager();
-    tokenMonitor = new ContextTokenMonitor();
-    qualityEvaluator = new PersonaQualityEvaluator();
-  });
-
-  afterEach(() => {
-    // 리소스 정리
-    updateManager.stopWatching();
-    contextParser.clearCache();
-  });
-
-  describe('컨텍스트 규칙 파싱', () => {
-    test('페르소나 컨텍스트 규칙을 정확히 파싱해야 함', async () => {
-      const personaName = 'architect';
-      const context = await contextParser.parseContextRules(personaName);
-
-      expect(context).toBeDefined();
-      expect(context.persona_name).toBe(personaName);
-      expect(context.analysis_approach).toBeDefined();
-      expect(context.design_principles).toBeInstanceOf(Array);
-      expect(context.communication_style).toBeDefined();
-    });
-
-    test('존재하지 않는 페르소나는 기본 컨텍스트를 반환해야 함', async () => {
-      const context = await contextParser.parseContextRules('unknown_persona');
-
-      expect(context).toBeDefined();
-      expect(context.persona_name).toBe('unknown_persona');
-      expect(context.analysis_approach).toBe('일반적 접근');
-    });
-
-    test('모든 페르소나 컨텍스트를 한 번에 로드할 수 있어야 함', async () => {
-      const allContexts = await contextParser.loadAllPersonaContexts();
-
-      expect(Object.keys(allContexts)).toHaveLength(5);
-      expect(allContexts.architect).toBeDefined();
-      expect(allContexts.frontend).toBeDefined();
-      expect(allContexts.backend).toBeDefined();
-      expect(allContexts.data_analyst).toBeDefined();
-      expect(allContexts.security).toBeDefined();
-    });
-  });
-
-  describe('프롬프트 주입 메커니즘', () => {
-    test('컨텍스트를 프롬프트에 정확히 주입해야 함', async () => {
-      const originalPrompt = '시스템 아키텍처를 설계해주세요.';
-      const result = await promptInjector.injectContext(originalPrompt, 'architect');
-
-      expect(result.success).toBe(true);
-      expect(result.injectedPrompt).toContain('AI 페르소나 컨텍스트');
-      expect(result.injectedPrompt).toContain(originalPrompt);
-      expect(result.injectedPrompt).toContain('architect');
-    });
-
-    test('토큰 사용량을 정확히 계산해야 함', async () => {
-      const originalPrompt = '간단한 API를 만들어주세요.';
-      const result = await promptInjector.injectContext(originalPrompt, 'backend');
-
-      expect(result.tokenMetrics).toBeDefined();
-      expect(result.tokenMetrics.originalTokens).toBeGreaterThan(0);
-      expect(result.tokenMetrics.injectedTokens).toBeGreaterThan(
-        result.tokenMetrics.originalTokens
-      );
-      expect(result.tokenMetrics.contextTokens).toBeGreaterThan(0);
-    });
-
-    test('페르소나 전환이 올바르게 작동해야 함', async () => {
-      await promptInjector.switchPersona('frontend');
-      expect(promptInjector.getActivePersona()).toBe('frontend');
-
-      await promptInjector.switchPersona('backend');
-      expect(promptInjector.getActivePersona()).toBe('backend');
-    });
-
-    test('토큰 한계 초과 시 컨텍스트를 압축해야 함', async () => {
-      const largeContext = {
-        persona_name: 'test',
-        analysis_approach: 'test approach',
-        design_principles: Array(100).fill('principle'),
-        communication_style: 'test style',
-        content: 'x'.repeat(10000)
-      };
-
-      const compressed = await promptInjector.compressContext(largeContext, 1000);
-
-      expect(compressed.design_principles.length).toBeLessThanOrEqual(3);
-      expect(compressed.content).toContain('...');
-    });
-  });
-
-  describe('페르소나 행동 패턴 검증', () => {
-    test('아키텍트 페르소나 응답을 올바르게 검증해야 함', () => {
-      const response = `
-        시스템 아키텍처 설계를 위해 다음과 같은 구조를 제안합니다:
-        
-        1. 프레젠테이션 계층: React 기반 SPA
-        2. 비즈니스 로직 계층: Node.js 마이크로서비스
-        3. 데이터 계층: PostgreSQL + Redis 캐싱
-        
-        이 설계는 확장성과 유지보수성을 고려하여 모듈화된 구조로 구성되었습니다.
-      `;
-
-      const validation = behaviorValidator.validateResponse(
-        response,
-        'architect',
-        '시스템 아키텍처를 설계해주세요.'
-      );
-
-      expect(validation.valid).toBe(true);
-      expect(validation.scores.keywordMatch).toBeGreaterThan(0.5);
-      expect(validation.scores.structureMatch).toBeGreaterThan(0.5);
-    });
-
-    test('페르소나별 행동 패턴이 명확히 구분되어야 함', () => {
-      const prompt = '사용자 인증 시스템을 구현해주세요.';
-      
-      const responses = [
-        {
-          personaName: 'frontend',
-          response: 'UI에서 로그인 폼을 만들고 사용자 경험을 개선하는 애니메이션을 추가합니다.',
-          prompt
-        },
-        {
-          personaName: 'backend',
-          response: 'JWT 토큰 기반 인증 API를 구현하고 데이터베이스에 사용자 정보를 안전하게 저장합니다.',
-          prompt
-        },
-        {
-          personaName: 'security',
-          response: '보안 취약점을 방지하기 위해 암호화, 세션 관리, CSRF 방어 메커니즘을 구현합니다.',
-          prompt
-        }
-      ];
-
-      const comparison = behaviorValidator.comparePersonaBehaviors(responses);
-      
-      expect(comparison.overallDistinctiveness).toBeGreaterThan(0.3);
-      Object.values(comparison.pairwiseDifferences).forEach(diff => {
-        expect(diff.distinctiveness).toBeGreaterThan(0.2);
-      });
-    });
-
-    test('검증 통계가 정확히 생성되어야 함', () => {
-      // 여러 검증 수행
-      for (let i = 0; i < 5; i++) {
-        behaviorValidator.validateResponse(
-          '테스트 응답',
-          'architect',
-          '테스트 프롬프트'
-        );
-      }
-
-      const stats = behaviorValidator.generateStatistics('architect');
-      
-      expect(stats.totalValidations).toBe(5);
-      expect(stats.averageScore).toBeDefined();
-      expect(stats.validationRate).toBeDefined();
-    });
-  });
-
-  describe('실시간 컨텍스트 업데이트', () => {
-    test('컨텍스트 파일 변경을 감지해야 함', async () => {
-      const testPersona = 'test_persona';
-      const contextPath = path.join(
-        process.cwd(),
-        '.aiwf',
-        '07_AI_PERSONAS',
-        testPersona,
-        'context_rules.md'
-      );
-
-      // 이벤트 리스너 설정
-      const updatePromise = new Promise((resolve) => {
-        updateManager.once('contextUpdated', (data) => {
-          resolve(data);
-        });
-      });
-
-      // 감시 시작
-      updateManager.startWatching([testPersona]);
-
-      // 파일 생성/수정
-      await fs.mkdir(path.dirname(contextPath), { recursive: true });
-      await fs.writeFile(contextPath, `---
-persona_name: ${testPersona}
-analysis_approach: 테스트 접근법
----
-
-테스트 컨텍스트 내용`);
-
-      // 이벤트 대기 (타임아웃 설정)
-      const updateData = await Promise.race([
-        updatePromise,
-        new Promise((_, reject) => 
-          setTimeout(() => reject(new Error('Timeout')), 5000)
-        )
-      ]).catch(() => null);
-
-      // 정리
-      await fs.unlink(contextPath).catch(() => {});
-      await fs.rmdir(path.dirname(contextPath)).catch(() => {});
-
-      if (updateData) {
-        expect(updateData.persona).toBe(testPersona);
-        expect(updateData.context).toBeDefined();
-      }
-    }, 10000);
-
-    test('감시 상태를 올바르게 보고해야 함', () => {
-      updateManager.startWatching(['architect', 'frontend']);
-      const status = updateManager.getWatchStatus();
-
-      expect(status.activeWatchers).toContain('architect');
-      expect(status.activeWatchers).toContain('frontend');
-      expect(status.watcherCount).toBe(2);
-    });
-  });
-
-  describe('토큰 사용량 모니터링', () => {
-    test('컨텍스트 주입 토큰 사용량을 추적해야 함', async () => {
-      const injectionResult = await promptInjector.injectContext(
-        '테스트 프롬프트',
-        'architect'
-      );
-
-      const usage = await tokenMonitor.trackContextUsage(injectionResult);
-
-      expect(usage.personaName).toBe('architect');
-      expect(usage.contextTokens).toBeGreaterThan(0);
-      expect(usage.contextElements).toBeDefined();
-      expect(usage.contextElements.total).toBeGreaterThan(0);
-    });
-
-    test('토큰 임계값 초과 시 알림을 생성해야 함', async () => {
-      // 임계값 설정
-      tokenMonitor.setThresholds({ warning: 100, critical: 200 });
-
-      const mockInjectionResult = {
-        personaName: 'test',
-        tokenMetrics: {
-          originalTokens: 50,
-          contextTokens: 150,
-          injectedTokens: 200,
-          percentageIncrease: '300%'
-        },
-        context: {
-          persona_name: 'test',
-          content: 'x'.repeat(500)
-        }
-      };
-
-      const usage = await tokenMonitor.trackContextUsage(mockInjectionResult);
-
-      expect(usage.alert).toBeDefined();
-      expect(usage.alert.level).toBe('warning');
-    });
-
-    test('토큰 사용량 리포트를 생성해야 함', async () => {
-      // 테스트 데이터 추가
-      for (let i = 0; i < 3; i++) {
-        const result = await promptInjector.injectContext(
-          `테스트 프롬프트 ${i}`,
-          'architect'
-        );
-        await tokenMonitor.trackContextUsage(result);
-      }
-
-      const report = tokenMonitor.generateReport({ format: 'summary' });
-
-      expect(report.totalUsages).toBe(3);
-      expect(report.tokenStats).toBeDefined();
-      expect(report.personaSummary).toBeDefined();
-    });
-  });
-
-  describe('응답 품질 평가', () => {
-    test('페르소나 응답 품질을 정확히 평가해야 함', async () => {
-      const evaluationData = {
-        prompt: '마이크로서비스 아키텍처를 설계해주세요.',
-        response: `
-          마이크로서비스 아키텍처 설계:
-
-          1. 서비스 분해
-          - 사용자 서비스
-          - 주문 서비스
-          - 결제 서비스
-          - 알림 서비스
-
-          2. 통신 패턴
-          - REST API를 통한 동기 통신
-          - 메시지 큐를 통한 비동기 통신
-
-          3. 데이터 관리
-          - 서비스별 독립 데이터베이스
-          - 이벤트 소싱 패턴 적용
-
-          이 설계는 확장성과 독립적 배포를 고려했습니다.
-        `,
-        personaName: 'architect',
-        context: {
-          persona_name: 'architect',
-          analysis_approach: '시스템 설계 중심',
-          design_principles: ['확장성', '유지보수성', '성능'],
-          communication_style: '구조적이고 논리적'
-        }
-      };
-
-      const evaluation = await qualityEvaluator.evaluateResponse(evaluationData);
-
-      expect(evaluation.scores.final).toBeGreaterThan(0.7);
-      expect(evaluation.quality).toMatch(/excellent|good/);
-    });
-
-    test('여러 페르소나 응답을 비교 평가해야 함', async () => {
-      const prompt = 'RESTful API를 구현해주세요.';
-      const responses = [
-        {
-          personaName: 'architect',
-          response: 'API 설계 패턴과 전체 시스템 구조를 고려하여...',
-          context: await contextParser.parseContextRules('architect')
-        },
-        {
-          personaName: 'backend',
-          response: 'Express.js를 사용하여 RESTful 엔드포인트를 구현하고...',
-          context: await contextParser.parseContextRules('backend')
-        }
-      ];
-
-      const comparison = await qualityEvaluator.comparePersonaResponses(
-        responses,
-        prompt
-      );
-
-      expect(comparison.ranking).toBeDefined();
-      expect(comparison.ranking.length).toBe(2);
-      expect(comparison.bestPersona).toBeDefined();
-    });
-
-    test('평가 피드백과 권장사항을 제공해야 함', async () => {
-      const evaluationData = {
-        prompt: '보안 시스템을 설계해주세요.',
-        response: '보안은 중요합니다. SSL을 사용하세요.',
-        personaName: 'security',
-        context: await contextParser.parseContextRules('security')
-      };
-
-      const evaluation = await qualityEvaluator.evaluateResponse(evaluationData);
-
-      expect(evaluation.feedback).toBeDefined();
-      expect(evaluation.feedback.length).toBeGreaterThan(0);
-      expect(evaluation.recommendations).toBeDefined();
-      expect(evaluation.recommendations.length).toBeGreaterThan(0);
-    });
-  });
-
-  describe('통합 시나리오', () => {
-    test('전체 페르소나 컨텍스트 적용 플로우가 작동해야 함', async () => {
-      // 1. 페르소나 선택 및 컨텍스트 로드
-      const persona = 'architect';
-      const context = await contextParser.parseContextRules(persona);
-
-      // 2. 프롬프트 주입
-      const originalPrompt = '확장 가능한 웹 애플리케이션을 설계해주세요.';
-      const injectionResult = await promptInjector.injectContext(
-        originalPrompt,
-        persona
-      );
-
-      // 3. 토큰 사용량 추적
-      const tokenUsage = await tokenMonitor.trackContextUsage(injectionResult);
-
-      // 4. 모의 응답 생성 (실제로는 AI가 생성)
-      const mockResponse = `
-        확장 가능한 웹 애플리케이션 아키텍처:
-
-        1. 시스템 구조
-        - 마이크로서비스 기반 아키텍처
-        - 컨테이너화된 서비스 (Docker/Kubernetes)
-        - API Gateway 패턴
-
-        2. 확장성 전략
-        - 수평적 확장 가능한 서비스 설계
-        - 로드 밸런싱 및 자동 스케일링
-        - 캐싱 전략 (Redis)
-
-        3. 유지보수성
-        - 모듈화된 코드 구조
-        - CI/CD 파이프라인
-        - 모니터링 및 로깅 시스템
-
-        이 설계는 비즈니스 성장에 따른 확장성과 장기적인 유지보수를 고려했습니다.
-      `;
-
-      // 5. 행동 패턴 검증
-      const behaviorValidation = behaviorValidator.validateResponse(
-        mockResponse,
-        persona,
-        originalPrompt
-      );
-
-      // 6. 품질 평가
-      const qualityEvaluation = await qualityEvaluator.evaluateResponse({
-        prompt: originalPrompt,
-        response: mockResponse,
-        personaName: persona,
-        context: context
-      });
-
-      // 검증
-      expect(injectionResult.success).toBe(true);
-      expect(tokenUsage.contextTokens).toBeGreaterThan(0);
-      expect(behaviorValidation.valid).toBe(true);
-      expect(qualityEvaluation.scores.final).toBeGreaterThan(0.7);
-    });
-
-    test('페르소나 전환 시 컨텍스트가 올바르게 변경되어야 함', async () => {
-      // Frontend 페르소나로 시작
-      await promptInjector.switchPersona('frontend');
-      const frontendResult = await promptInjector.injectContext(
-        '로그인 화면을 만들어주세요.',
-        'frontend'
-      );
-
-      expect(frontendResult.context.persona_name).toBe('frontend');
-      expect(frontendResult.injectedPrompt).toContain('UI/UX');
-
-      // Backend 페르소나로 전환
-      await promptInjector.switchPersona('backend');
-      const backendResult = await promptInjector.injectContext(
-        '로그인 API를 만들어주세요.',
-        'backend'
-      );
-
-      expect(backendResult.context.persona_name).toBe('backend');
-      expect(backendResult.injectedPrompt).toContain('API');
-    });
-  });
-});
-
-describe('성능 및 최적화', () => {
-  test('컨텍스트 캐싱이 올바르게 작동해야 함', async () => {
-    const contextParser = new ContextRuleParser();
-    
-    // 첫 번째 로드 시간 측정
-    const start1 = Date.now();
-    await contextParser.parseContextRules('architect');
-    const time1 = Date.now() - start1;
-
-    // 두 번째 로드 시간 측정 (캐시됨)
-    const start2 = Date.now();
-    await contextParser.parseContextRules('architect');
-    const time2 = Date.now() - start2;
-
-    // 캐시된 로드가 더 빨라야 함
-    expect(time2).toBeLessThan(time1);
-  });
-
-  test('대용량 컨텍스트 처리 시 메모리 사용량이 적절해야 함', async () => {
-    const tokenMonitor = new ContextTokenMonitor();
-    
-    // 대용량 데이터 시뮬레이션
-    for (let i = 0; i < 100; i++) {
-      const mockResult = {
-        personaName: 'test',
-        tokenMetrics: {
-          originalTokens: 100,
-          contextTokens: 200,
-          injectedTokens: 300,
-          percentageIncrease: '200%'
-        },
-        context: { persona_name: 'test' }
-      };
-      
-      await tokenMonitor.trackContextUsage(mockResult);
-    }
-
-    // 메모리 사용량 확인 (히스토리 크기 제한 확인)
-    const report = tokenMonitor.generateReport();
-    expect(report.totalUsages).toBe(100);
-  });
-});

package/tests/integration/setup.js

@@ -1,174 +0,0 @@
-/**
- * 통합 테스트 환경 설정
- */
-
-import fs from 'fs/promises';
-import path from 'path';
-import { fileURLToPath } from 'url';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-// 테스트 유틸리티 함수들
-export const testUtils = {
-  /**
-   * 테스트용 임시 디렉토리 생성
-   */
-  async createTempDir(prefix = 'test-') {
-    const tempDir = path.join(__dirname, '../../tmp', `${prefix}${Date.now()}`);
-    await fs.mkdir(tempDir, { recursive: true });
-    return tempDir;
-  },
-
-  /**
-   * 테스트용 임시 디렉토리 정리
-   */
-  async cleanupTempDir(tempDir) {
-    try {
-      await fs.rm(tempDir, { recursive: true, force: true });
-    } catch (error) {
-      console.warn(`Failed to cleanup temp dir: ${tempDir}`, error);
-    }
-  },
-
-  /**
-   * 테스트용 AIWF 프로젝트 구조 생성
-   */
-  async createTestProjectStructure(baseDir) {
-    const aiwfDir = path.join(baseDir, '.aiwf');
-    const dirs = [
-      '00_PROJECT_MANIFEST.md',
-      '01_PROJECT',
-      '02_REQUIREMENTS', 
-      '03_SPRINTS',
-      '04_GENERAL_TASKS',
-      '05_DOCUMENTATION',
-      '06_FEATURE_LEDGERS',
-      '07_BUG_REPORTS',
-      '08_ADR',
-      '09_AI_TOOLS',
-      '10_PERSONAS',
-      '11_CONTEXT_COMPRESSION',
-      '99_TEMPLATES'
-    ];
-
-    await fs.mkdir(aiwfDir, { recursive: true });
-    
-    // 디렉토리 생성
-    for (const dir of dirs) {
-      if (!dir.endsWith('.md')) {
-        await fs.mkdir(path.join(aiwfDir, dir), { recursive: true });
-      }
-    }
-
-    // 기본 매니페스트 파일 생성
-    await fs.writeFile(
-      path.join(aiwfDir, '00_PROJECT_MANIFEST.md'),
-      `# Test Project Manifest
-프로젝트명: Test Project
-생성일: ${new Date().toISOString().split('T')[0]}
-`
-    );
-
-    return aiwfDir;
-  },
-
-  /**
-   * 파일 존재 여부 확인
-   */
-  async fileExists(filePath) {
-    try {
-      await fs.access(filePath);
-      return true;
-    } catch {
-      return false;
-    }
-  },
-
-  /**
-   * 디렉토리 존재 여부 확인
-   */
-  async dirExists(dirPath) {
-    try {
-      const stats = await fs.stat(dirPath);
-      return stats.isDirectory();
-    } catch {
-      return false;
-    }
-  },
-
-  /**
-   * JSON 파일 읽기
-   */
-  async readJsonFile(filePath) {
-    const content = await fs.readFile(filePath, 'utf8');
-    return JSON.parse(content);
-  },
-
-  /**
-   * 마크다운 파일 파싱 (간단한 프론트매터 파싱)
-   */
-  async parseMarkdownFile(filePath) {
-    const content = await fs.readFile(filePath, 'utf8');
-    const lines = content.split('\n');
-    
-    if (lines[0] === '---') {
-      const endIndex = lines.slice(1).indexOf('---') + 1;
-      if (endIndex > 0) {
-        const frontMatter = lines.slice(1, endIndex).join('\n');
-        const body = lines.slice(endIndex + 1).join('\n');
-        
-        // 간단한 YAML 파싱 (key: value 형태만)
-        const metadata = {};
-        frontMatter.split('\n').forEach(line => {
-          const match = line.match(/^(\w+):\s*(.*)$/);
-          if (match) {
-            metadata[match[1]] = match[2];
-          }
-        });
-        
-        return { metadata, body };
-      }
-    }
-    
-    return { metadata: {}, body: content };
-  }
-};
-
-// 테스트 픽스처 데이터
-export const testFixtures = {
-  featureLedger: {
-    id: 'TEST_FEATURE_001',
-    title: 'Test Feature',
-    description: 'Test feature description',
-    status: 'planned',
-    priority: 'medium',
-    milestone: 'M01',
-    created_at: '2025-07-09T02:55:00Z',
-    updated_at: '2025-07-09T02:55:00Z'
-  },
-
-  persona: {
-    id: 'architect',
-    name: 'Software Architect',
-    description: 'AI 페르소나 for software architecture',
-    context: 'You are an expert software architect...',
-    commands: ['design', 'review', 'optimize']
-  },
-
-  taskTemplate: {
-    task_id: 'TEST_TASK_001',
-    sprint_sequence_id: 'S01',
-    status: 'open',
-    complexity: 'Medium',
-    title: 'Test Task',
-    description: 'Test task description'
-  }
-};
-
-// 테스트 전역 설정
-export const testConfig = {
-  timeout: 30000,
-  tempDirPrefix: 'aiwf-test-',
-  testDataDir: path.join(__dirname, 'data')
-};