aiwf 0.3.7 → 0.3.12

package/tests/installer.test.js

@@ -1,129 +0,0 @@
-/**
- * 인스톨러 기능 테스트
- */
-
-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 src/cli/index.js --version', { 
-      cwd: path.join(__dirname, '..'),
-      encoding: 'utf8',
-      timeout: 5000
-    });
-    expect(result.trim()).toMatch(/\d+\.\d+\.\d+/);
-  });
-
-  test('도움말 명령어가 올바르게 작동한다', () => {
-    const result = execSync('node src/cli/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/integration/ai-persona-system.test.js

@@ -1,396 +0,0 @@
-/**
- * AI Persona System Integration Tests
- */
-
-import { AIPersonaManager } from '../../src/lib/ai-persona-manager.js';
-import { ContextEngine } from '../../src/lib/context-engine.js';
-import { MetricsCollector } from '../../src/lib/metrics-collector.js';
-import { TaskAnalyzer } from '../../src/lib/task-analyzer.js';
-import fs from 'fs/promises';
-import path from 'path';
-import { fileURLToPath } from 'url';
-import { dirname } from 'path';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = dirname(__filename);
-
-describe('AI Persona System Integration', () => {
-  let personaManager;
-  let testDir;
-
-  beforeAll(async () => {
-    // Create test directory
-    testDir = path.join(__dirname, 'test-persona-system');
-    await fs.mkdir(testDir, { recursive: true });
-    
-    // Create test project structure
-    await createTestProjectStructure(testDir);
-  });
-
-  afterAll(async () => {
-    // Clean up test directory
-    await fs.rm(testDir, { recursive: true, force: true });
-  });
-
-  beforeEach(async () => {
-    // Initialize persona manager with test directory
-    personaManager = new AIPersonaManager({
-      personaConfigPath: path.join(testDir, '.aiwf', 'personas'),
-      metricsPath: path.join(testDir, '.aiwf', 'metrics'),
-      metricsEnabled: true,
-      autoDetectionEnabled: true
-    });
-    
-    await personaManager.init();
-  });
-
-  afterEach(async () => {
-    if (personaManager) {
-      await personaManager.cleanup();
-    }
-  });
-
-  describe('Full Workflow', () => {
-    test('complete debugging workflow with auto-detection', async () => {
-      // Simulate a debugging task
-      const task = {
-        command: 'debug the authentication error in login.js',
-        description: 'Users are getting 401 errors when trying to login'
-      };
-
-      // Detect optimal persona
-      const detectedPersona = await personaManager.detectOptimalPersona(task);
-      
-      // Should detect debugger persona
-      expect(detectedPersona).toBe('debugger');
-      expect(personaManager.currentPersona.name).toBe('debugger');
-
-      // Verify context rules are applied
-      const context = personaManager.contextEngine.getCurrentContext();
-      expect(context).toBeTruthy();
-      expect(context.personaOverlay).toBeTruthy();
-      expect(context.personaOverlay.systemPrompt).toContain('debugger mode');
-
-      // Simulate task completion
-      const sessionId = personaManager.metricsCollector.startSession(
-        personaManager.currentPersona,
-        task
-      );
-      
-      // Track some events
-      personaManager.metricsCollector.trackEvent('interaction', { type: 'code_analysis' });
-      personaManager.metricsCollector.trackEvent('interaction', { type: 'error_trace' });
-      personaManager.metricsCollector.trackEvent('task_completed', { success: true });
-      
-      // End session
-      const session = personaManager.metricsCollector.endSession('completed');
-      
-      expect(session).toBeTruthy();
-      expect(session.persona).toBe('debugger');
-      expect(session.metrics.completionStatus).toBe('completed');
-      expect(session.metrics.interactions).toBe(2);
-    });
-
-    test('architecture design workflow with manual switching', async () => {
-      // Manually switch to architect persona
-      await personaManager.switchPersona('architect', { manual: true });
-      
-      expect(personaManager.currentPersona.name).toBe('architect');
-      
-      // Verify architect-specific context
-      const context = personaManager.getPersonaContext('architect');
-      expect(context.priority).toContain('*.md');
-      expect(context.priority).toContain('*.yml');
-      expect(context.exclude).toContain('test/**');
-      
-      // Apply persona rules to content
-      const projectFiles = [
-        'src/index.js',
-        'test/test.js',
-        'architecture.md',
-        'design.yml'
-      ];
-      
-      const filtered = await personaManager.applyPersonaRules(
-        projectFiles,
-        'architect'
-      );
-      
-      // Should filter based on architect rules
-      expect(filtered).toBeTruthy();
-    });
-
-    test('multi-persona workflow for feature development', async () => {
-      const personas = ['architect', 'developer', 'reviewer', 'documenter'];
-      const history = [];
-
-      for (const personaName of personas) {
-        // Switch persona
-        await personaManager.switchPersona(personaName);
-        
-        // Simulate work
-        const sessionId = personaManager.metricsCollector.startSession(
-          personaName,
-          { type: 'feature_development', description: `${personaName} phase` }
-        );
-        
-        // Track events
-        personaManager.metricsCollector.trackEvent('interaction', { 
-          persona: personaName 
-        });
-        
-        // End session
-        const session = personaManager.metricsCollector.endSession('completed');
-        history.push(session);
-      }
-
-      // Verify workflow
-      expect(history).toHaveLength(4);
-      expect(history[0].persona).toBe('architect');
-      expect(history[3].persona).toBe('documenter');
-      
-      // Check persona history
-      expect(personaManager.personaHistory).toHaveLength(3); // Excludes last switch
-    });
-  });
-
-  describe('Performance and Metrics', () => {
-    test('collects and reports persona performance metrics', async () => {
-      // Simulate multiple sessions with different personas
-      const testSessions = [
-        { persona: 'debugger', task: 'fix bug', quality: 0.9, duration: 120000 },
-        { persona: 'debugger', task: 'trace error', quality: 0.8, duration: 180000 },
-        { persona: 'architect', task: 'design api', quality: 0.95, duration: 300000 },
-        { persona: 'optimizer', task: 'improve speed', quality: 0.85, duration: 240000 }
-      ];
-
-      for (const testSession of testSessions) {
-        await personaManager.switchPersona(testSession.persona);
-        
-        const sessionId = personaManager.metricsCollector.startSession(
-          testSession.persona,
-          { type: 'test', description: testSession.task }
-        );
-        
-        // Simulate work
-        await new Promise(resolve => setTimeout(resolve, 10));
-        
-        personaManager.metricsCollector.trackEvent('task_completed');
-        const session = personaManager.metricsCollector.endSession('completed');
-        
-        // Override quality metrics for testing
-        session.qualityMetrics = { overallScore: testSession.quality };
-      }
-
-      // Generate report
-      const report = await personaManager.generateReport();
-      
-      expect(report).toBeTruthy();
-      expect(report.summary).toBeTruthy();
-      expect(report.personaAnalysis).toBeTruthy();
-      expect(report.personaInsights).toBeTruthy();
-      
-      // Check debugger insights (2 sessions)
-      expect(report.personaInsights.debugger).toBeTruthy();
-      expect(report.personaInsights.debugger.effectiveness).toBeTruthy();
-    });
-
-    test('tracks token usage optimization', async () => {
-      // Switch to optimizer persona
-      await personaManager.switchPersona('optimizer');
-      
-      // Get context stats before
-      const statsBefore = personaManager.contextEngine.getContextStats();
-      
-      // Apply optimization
-      const largeContext = {
-        projectFiles: {
-          structure: generateLargeFileStructure(100),
-          recentFiles: Array(50).fill('file.js')
-        }
-      };
-      
-      const optimized = await personaManager.contextEngine.tokenOptimizer.optimize(
-        largeContext,
-        personaManager.currentPersona.contextRules,
-        personaManager.currentPersona.tokenAllocation
-      );
-      
-      // Verify optimization
-      expect(optimized.size).toBeLessThan(
-        personaManager.contextEngine.calculateContextSize(largeContext)
-      );
-    });
-  });
-
-  describe('Auto-Detection Accuracy', () => {
-    test('correctly identifies debugging tasks', async () => {
-      const debugTasks = [
-        'fix the null pointer exception',
-        'debug the login error',
-        'trace the memory leak',
-        'investigate why tests are failing'
-      ];
-
-      for (const command of debugTasks) {
-        const detected = await personaManager.detectOptimalPersona({ command });
-        expect(['debugger', 'developer']).toContain(detected);
-      }
-    });
-
-    test('correctly identifies architecture tasks', async () => {
-      const architectTasks = [
-        'design the microservices architecture',
-        'plan the system structure',
-        'create architectural diagram',
-        'define module interfaces'
-      ];
-
-      for (const command of architectTasks) {
-        const detected = await personaManager.detectOptimalPersona({ command });
-        expect(['architect', 'developer']).toContain(detected);
-      }
-    });
-
-    test('correctly identifies documentation tasks', async () => {
-      const docTasks = [
-        'write API documentation',
-        'create user guide',
-        'document the installation process',
-        'explain how the feature works'
-      ];
-
-      for (const command of docTasks) {
-        const detected = await personaManager.detectOptimalPersona({ command });
-        expect(['documenter', 'developer']).toContain(detected);
-      }
-    });
-  });
-
-  describe('Context Management', () => {
-    test('preserves base context across persona switches', async () => {
-      // Create base context
-      const baseFiles = ['app.js', 'config.js', 'package.json'];
-      
-      // Switch personas and verify base context preserved
-      const personas = ['architect', 'debugger', 'reviewer'];
-      
-      for (const persona of personas) {
-        await personaManager.switchPersona(persona);
-        
-        const context = personaManager.contextEngine.getCurrentContext();
-        expect(context).toBeTruthy();
-        
-        // Base context should be preserved
-        if (personaManager.contextEngine.baseContext) {
-          expect(context).toHaveProperty('environment');
-        }
-      }
-    });
-
-    test('applies persona-specific filtering correctly', async () => {
-      // Test architect filtering
-      await personaManager.switchPersona('architect');
-      
-      const files = {
-        'src/index.js': 'implementation',
-        'test/test.js': 'test code',
-        'docs/api.md': 'documentation',
-        'design/architecture.yml': 'architecture'
-      };
-      
-      const architectFiltered = await personaManager.applyPersonaRules(
-        Object.keys(files),
-        'architect'
-      );
-      
-      // Test debugger filtering
-      await personaManager.switchPersona('debugger');
-      
-      const debuggerFiltered = await personaManager.applyPersonaRules(
-        Object.keys(files),
-        'debugger'
-      );
-      
-      // Results should differ based on persona
-      expect(architectFiltered).not.toEqual(debuggerFiltered);
-    });
-  });
-
-  describe('Error Handling and Recovery', () => {
-    test('recovers from failed persona switch', async () => {
-      // Force an error in context engine
-      const originalApply = personaManager.contextEngine.applyPersonaRules;
-      personaManager.contextEngine.applyPersonaRules = jest.fn()
-        .mockRejectedValueOnce(new Error('Context error'));
-      
-      // Attempt switch
-      await expect(personaManager.switchPersona('architect')).rejects.toThrow();
-      
-      // Should still be in developer persona
-      expect(personaManager.currentPersona.name).toBe('developer');
-      
-      // Restore and retry
-      personaManager.contextEngine.applyPersonaRules = originalApply;
-      await personaManager.switchPersona('architect');
-      
-      expect(personaManager.currentPersona.name).toBe('architect');
-    });
-
-    test('handles metrics collection failure gracefully', async () => {
-      // Disable metrics
-      personaManager.options.metricsEnabled = false;
-      
-      // Operations should still work
-      await personaManager.switchPersona('reviewer');
-      const stats = await personaManager.getPersonaStats('reviewer');
-      
-      expect(stats).toHaveProperty('message', 'Metrics collection is disabled');
-      expect(personaManager.currentPersona.name).toBe('reviewer');
-    });
-  });
-});
-
-// Helper functions
-
-async function createTestProjectStructure(baseDir) {
-  // Create directories
-  const dirs = [
-    '.aiwf/personas',
-    '.aiwf/metrics',
-    'src',
-    'test',
-    'docs'
-  ];
-  
-  for (const dir of dirs) {
-    await fs.mkdir(path.join(baseDir, dir), { recursive: true });
-  }
-  
-  // Create sample files
-  const files = {
-    'src/index.js': 'console.log("Hello");',
-    'src/auth.js': 'function login() {}',
-    'test/test.js': 'describe("test", () => {});',
-    'docs/README.md': '# Project',
-    'package.json': JSON.stringify({ name: 'test-project' })
-  };
-  
-  for (const [file, content] of Object.entries(files)) {
-    await fs.writeFile(path.join(baseDir, file), content);
-  }
-}
-
-function generateLargeFileStructure(count) {
-  const structure = [];
-  
-  for (let i = 0; i < count; i++) {
-    structure.push({
-      type: 'file',
-      path: `src/file${i}.js`,
-      extension: '.js'
-    });
-  }
-  
-  return structure;
-}