aiwf 0.3.8 → 0.3.13

package/tests/application.test.js

@@ -1,260 +0,0 @@
-/**
- * 애플리케이션 메인 코드 테스트
- */
-
-import { spawn } from 'child_process';
-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 runApp(args = [], timeout = 10000) {
-  return new Promise((resolve, reject) => {
-    const appPath = path.join(__dirname, '..', 'src', 'cli', 'index.js');
-    const child = spawn('node', [appPath, ...args], {
-      stdio: 'pipe',
-      timeout: timeout
-    });
-
-    let stdout = '';
-    let stderr = '';
-
-    child.stdout.on('data', (data) => {
-      stdout += data.toString();
-    });
-
-    child.stderr.on('data', (data) => {
-      stderr += data.toString();
-    });
-
-    child.on('close', (code) => {
-      resolve({ code, stdout, stderr });
-    });
-
-    child.on('error', reject);
-
-    // 타임아웃 처리
-    setTimeout(() => {
-      child.kill();
-      reject(new Error('Process timeout'));
-    }, timeout);
-  });
-}
-
-describe('AIWF 애플리케이션 테스트', () => {
-  test('애플리케이션이 정상적으로 시작됨', async () => {
-    const result = await runApp(['--version']);
-    expect(result.code).toBe(0);
-  });
-
-  test('도움말 메시지가 표시됨', async () => {
-    const result = await runApp(['--help']);
-    expect(result.stdout).toContain('AIWF');
-    expect(result.stdout).toContain('설치');
-  });
-
-  test('버전 정보가 표시됨', async () => {
-    const result = await runApp(['--version']);
-    expect(result.stdout).toMatch(/\d+\.\d+\.\d+/);
-  });
-
-  test('잘못된 명령어에 대한 오류 처리', async () => {
-    const result = await runApp(['--invalid-option']);
-    expect(result.code).not.toBe(0);
-  });
-});
-
-describe('Language CLI 테스트', () => {
-  async function runLanguageCli(args = [], timeout = 5000) {
-    return new Promise((resolve, reject) => {
-      const cliPath = path.join(__dirname, '..', 'src', 'cli', 'language-cli.js');
-      const child = spawn('node', [cliPath, ...args], {
-        stdio: 'pipe',
-        timeout: timeout
-      });
-
-      let stdout = '';
-      let stderr = '';
-
-      child.stdout.on('data', (data) => {
-        stdout += data.toString();
-      });
-
-      child.stderr.on('data', (data) => {
-        stderr += data.toString();
-      });
-
-      child.on('close', (code) => {
-        resolve({ code, stdout, stderr });
-      });
-
-      child.on('error', reject);
-
-      setTimeout(() => {
-        child.kill();
-        reject(new Error('Process timeout'));
-      }, timeout);
-    });
-  }
-
-  test('언어 상태 확인', async () => {
-    const result = await runLanguageCli(['status']);
-    expect(result.code).toBe(0);
-    expect(result.stdout).toContain('언어 설정');
-  });
-
-  test('언어 CLI 도움말', async () => {
-    const result = await runLanguageCli(['--help']);
-    expect(result.stdout).toContain('언어 설정');
-  });
-});
-
-describe('설치 프로세스 테스트', () => {
-  let tempDir;
-
-  beforeEach(async () => {
-    tempDir = path.join(__dirname, 'temp_install_test');
-    await fs.mkdir(tempDir, { recursive: true });
-  });
-
-  afterEach(async () => {
-    await fs.rm(tempDir, { recursive: true, force: true });
-  });
-
-  test('임시 디렉토리에서 설치 시뮬레이션', async () => {
-    // 패키지 설치 시뮬레이션
-    const packageJsonPath = path.join(tempDir, 'package.json');
-    await fs.writeFile(packageJsonPath, JSON.stringify({
-      name: 'test-project',
-      version: '1.0.0',
-      scripts: {
-        test: 'echo "test"'
-      }
-    }, null, 2));
-
-    // 설치 프로세스 시뮬레이션
-    const result = await runApp(['--target', tempDir, '--dry-run']);
-    
-    // 드라이런 모드에서는 실제 설치하지 않고 계획만 보여줌
-    expect(result.code).toBe(0);
-  });
-
-  test('기존 프로젝트 감지', async () => {
-    // 기존 AIWF 프로젝트 시뮬레이션
-    const aiwfDir = path.join(tempDir, '.aiwf');
-    await fs.mkdir(aiwfDir, { recursive: true });
-    await fs.writeFile(path.join(aiwfDir, '00_PROJECT_MANIFEST.md'), '# Test Project');
-
-    const result = await runApp(['--target', tempDir, '--check']);
-    expect(result.code).toBe(0);
-  });
-});
-
-describe('명령어 유효성 검증 테스트', () => {
-  test('명령어 파일 구조 검증', async () => {
-    const koCommandsDir = path.join(__dirname, '..', 'claude-code', 'aiwf', 'ko', '.claude', 'commands', 'aiwf');
-    const enCommandsDir = path.join(__dirname, '..', 'claude-code', 'aiwf', 'en', '.claude', 'commands', 'aiwf');
-
-    // 한국어 명령어 파일 존재 확인
-    const koFiles = await fs.readdir(koCommandsDir);
-    expect(koFiles.length).toBeGreaterThan(0);
-
-    // 영어 명령어 파일 존재 확인
-    const enFiles = await fs.readdir(enCommandsDir);
-    expect(enFiles.length).toBeGreaterThan(0);
-
-    // 필수 명령어 파일 확인
-    const requiredCommands = ['aiwf_initialize.md', 'aiwf_test.md', 'aiwf_prime.md'];
-    
-    for (const command of requiredCommands) {
-      expect(koFiles).toContain(command);
-      expect(enFiles).toContain(command);
-    }
-  });
-
-  test('명령어 파일 내용 검증', async () => {
-    const koCommandsDir = path.join(__dirname, '..', 'claude-code', 'aiwf', 'ko', '.claude', 'commands', 'aiwf');
-    const testFile = path.join(koCommandsDir, 'aiwf_test.md');
-    
-    const content = await fs.readFile(testFile, 'utf8');
-    
-    // 마크다운 헤더 확인
-    expect(content).toMatch(/^#\s+.+/m);
-    
-    // 한국어 내용 확인
-    expect(content).toContain('테스트');
-  });
-});
-
-describe('설정 파일 관리 테스트', () => {
-  test('언어 설정 파일 읽기', async () => {
-    const configDir = path.join(__dirname, '..', '.aiwf', 'config');
-    
-    try {
-      await fs.access(configDir);
-      const files = await fs.readdir(configDir);
-      
-      if (files.includes('language.json')) {
-        const configPath = path.join(configDir, 'language.json');
-        const config = JSON.parse(await fs.readFile(configPath, 'utf8'));
-        
-        expect(config).toHaveProperty('language');
-        expect(['ko', 'en']).toContain(config.language);
-      }
-    } catch (error) {
-      // 설정 파일이 없는 경우는 정상 (기본값 사용)
-      expect(error.code).toBe('ENOENT');
-    }
-  });
-
-  test('기본 설정 생성', async () => {
-    const tempConfigDir = path.join(__dirname, 'temp_config');
-    await fs.mkdir(tempConfigDir, { recursive: true });
-    
-    const defaultConfig = {
-      language: 'ko',
-      version: '0.3.1',
-      created_at: new Date().toISOString()
-    };
-    
-    const configPath = path.join(tempConfigDir, 'language.json');
-    await fs.writeFile(configPath, JSON.stringify(defaultConfig, null, 2));
-    
-    const savedConfig = JSON.parse(await fs.readFile(configPath, 'utf8'));
-    expect(savedConfig.language).toBe('ko');
-    expect(savedConfig.version).toBe('0.3.1');
-    
-    await fs.rm(tempConfigDir, { recursive: true, force: true });
-  });
-});
-
-describe('오류 처리 테스트', () => {
-  test('존재하지 않는 디렉토리에 대한 오류 처리', async () => {
-    const result = await runApp(['--target', '/nonexistent/directory']);
-    expect(result.code).not.toBe(0);
-  });
-
-  test('권한 없는 디렉토리에 대한 오류 처리', async () => {
-    // 권한 테스트는 시스템에 따라 다르므로 간단히 처리
-    const result = await runApp(['--target', '/root']);
-    // 권한 오류가 발생하거나 정상 처리되어야 함
-    expect(typeof result.code).toBe('number');
-  });
-
-  test('잘못된 JSON 파일 처리', async () => {
-    const tempDir = path.join(__dirname, 'temp_invalid_json');
-    await fs.mkdir(tempDir, { recursive: true });
-    
-    const invalidJsonPath = path.join(tempDir, 'invalid.json');
-    await fs.writeFile(invalidJsonPath, '{ invalid json }');
-    
-    // 애플리케이션이 잘못된 JSON 파일을 만나도 크래시하지 않아야 함
-    const result = await runApp(['--target', tempDir]);
-    expect(typeof result.code).toBe('number');
-    
-    await fs.rm(tempDir, { recursive: true, force: true });
-  });
-});

package/tests/basic.test.js

@@ -1,62 +0,0 @@
-/**
- * 기본 프로젝트 구조 테스트
- */
-
-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('./.aiwf/bin/aiwf.js');
-  });
-});

package/tests/commands.test.js

@@ -1,127 +0,0 @@
-/**
- * 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

@@ -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);
-    });
-  });
-});