aiwf 0.3.1 → 0.3.2

package/scripts/run-integration-tests.js

@@ -0,0 +1,317 @@
+#!/usr/bin/env node
+
+/**
+ * 통합 테스트 실행 자동화 스크립트
+ */
+
+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);
+
+// 색상 출력을 위한 헬퍼
+const colors = {
+  reset: '\x1b[0m',
+  bright: '\x1b[1m',
+  red: '\x1b[31m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  magenta: '\x1b[35m',
+  cyan: '\x1b[36m'
+};
+
+const log = {
+  info: (msg) => console.log(`${colors.blue}[INFO]${colors.reset} ${msg}`),
+  success: (msg) => console.log(`${colors.green}[SUCCESS]${colors.reset} ${msg}`),
+  warning: (msg) => console.log(`${colors.yellow}[WARNING]${colors.reset} ${msg}`),
+  error: (msg) => console.log(`${colors.red}[ERROR]${colors.reset} ${msg}`),
+  header: (msg) => console.log(`${colors.bright}${colors.cyan}${msg}${colors.reset}`)
+};
+
+async function runCommand(command, args, options = {}) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(command, args, {
+      stdio: 'inherit',
+      shell: true,
+      ...options
+    });
+
+    child.on('close', (code) => {
+      if (code === 0) {
+        resolve(code);
+      } else {
+        reject(new Error(`Command failed with exit code ${code}`));
+      }
+    });
+
+    child.on('error', reject);
+  });
+}
+
+async function checkTestEnvironment() {
+  log.info('테스트 환경 확인 중...');
+  
+  // Node.js 버전 확인
+  const nodeVersion = process.version;
+  log.info(`Node.js 버전: ${nodeVersion}`);
+  
+  // 필요한 디렉토리 확인
+  const requiredDirs = [
+    'tests',
+    'tests/integration'
+  ];
+  
+  for (const dir of requiredDirs) {
+    const dirPath = path.join(__dirname, '..', dir);
+    try {
+      await fs.access(dirPath);
+      log.success(`디렉토리 확인: ${dir}`);
+    } catch {
+      log.error(`디렉토리 누락: ${dir}`);
+      return false;
+    }
+  }
+  
+  return true;
+}
+
+async function runBasicTests() {
+  log.header('=== 기본 테스트 실행 ===');
+  
+  try {
+    await runCommand('npm', ['test', '--', '--testPathPattern=tests/(?!integration).*\\.test\\.js$']);
+    log.success('기본 테스트 완료');
+    return true;
+  } catch (error) {
+    log.error('기본 테스트 실패');
+    return false;
+  }
+}
+
+async function runIntegrationTests() {
+  log.header('=== 통합 테스트 실행 ===');
+  
+  try {
+    await runCommand('npm', ['test', '--', '--testPathPattern=tests/integration/.*\\.test\\.js$']);
+    log.success('통합 테스트 완료');
+    return true;
+  } catch (error) {
+    log.error('통합 테스트 실패');
+    return false;
+  }
+}
+
+async function runCoverageReport() {
+  log.header('=== 커버리지 리포트 생성 ===');
+  
+  try {
+    await runCommand('npm', ['test', '--', '--coverage']);
+    log.success('커버리지 리포트 생성 완료');
+    
+    // 커버리지 결과 파일 확인
+    const coverageFile = path.join(__dirname, '..', 'coverage', 'coverage-summary.json');
+    try {
+      const coverageData = JSON.parse(await fs.readFile(coverageFile, 'utf8'));
+      const total = coverageData.total;
+      
+      log.info(`커버리지 결과:`);
+      log.info(`  - Lines: ${total.lines.pct}%`);
+      log.info(`  - Functions: ${total.functions.pct}%`);
+      log.info(`  - Branches: ${total.branches.pct}%`);
+      log.info(`  - Statements: ${total.statements.pct}%`);
+      
+      // 80% 이상 커버리지 확인
+      const threshold = 80;
+      const coverageOK = total.lines.pct >= threshold && 
+                        total.functions.pct >= threshold && 
+                        total.branches.pct >= threshold && 
+                        total.statements.pct >= threshold;
+      
+      if (coverageOK) {
+        log.success(`커버리지 목표 달성 (${threshold}% 이상)`);
+      } else {
+        log.warning(`커버리지 목표 미달성 (${threshold}% 미만)`);
+      }
+      
+      return coverageOK;
+    } catch (error) {
+      log.warning('커버리지 결과 파일을 읽을 수 없습니다.');
+      return false;
+    }
+  } catch (error) {
+    log.error('커버리지 리포트 생성 실패');
+    return false;
+  }
+}
+
+async function generateTestReport() {
+  log.header('=== 테스트 리포트 생성 ===');
+  
+  const reportData = {
+    timestamp: new Date().toISOString(),
+    testSuites: {
+      basic: { executed: false, passed: false },
+      integration: { executed: false, passed: false },
+      coverage: { executed: false, passed: false }
+    },
+    summary: {
+      totalTests: 0,
+      passedTests: 0,
+      failedTests: 0,
+      coverageThreshold: '80%'
+    }
+  };
+  
+  // 테스트 결과 수집
+  try {
+    const testResults = await runCommand('npm', ['test', '--', '--json', '--outputFile=test-results.json'], {
+      stdio: 'pipe'
+    });
+    
+    try {
+      const resultsFile = path.join(__dirname, '..', 'test-results.json');
+      const results = JSON.parse(await fs.readFile(resultsFile, 'utf8'));
+      
+      reportData.summary.totalTests = results.numTotalTests;
+      reportData.summary.passedTests = results.numPassedTests;
+      reportData.summary.failedTests = results.numFailedTests;
+      
+      // 임시 파일 정리
+      await fs.unlink(resultsFile);
+    } catch (error) {
+      log.warning('테스트 결과 파일을 읽을 수 없습니다.');
+    }
+  } catch (error) {
+    log.warning('테스트 결과 수집 중 오류가 발생했습니다.');
+  }
+  
+  // 리포트 파일 생성
+  const reportPath = path.join(__dirname, '..', 'test-report.json');
+  await fs.writeFile(reportPath, JSON.stringify(reportData, null, 2));
+  
+  log.success(`테스트 리포트 생성: ${reportPath}`);
+  return true;
+}
+
+async function cleanupTestFiles() {
+  log.info('테스트 임시 파일 정리 중...');
+  
+  const tempDirs = [
+    path.join(__dirname, '..', 'tmp'),
+    path.join(__dirname, '..', 'coverage')
+  ];
+  
+  for (const dir of tempDirs) {
+    try {
+      await fs.rm(dir, { recursive: true, force: true });
+      log.success(`정리 완료: ${dir}`);
+    } catch (error) {
+      // 디렉토리가 존재하지 않는 경우는 무시
+    }
+  }
+}
+
+async function main() {
+  log.header('🧪 AIWF 통합 테스트 Suite 실행');
+  
+  const startTime = Date.now();
+  let allTestsPassed = true;
+  
+  try {
+    // 1. 테스트 환경 확인
+    if (!await checkTestEnvironment()) {
+      log.error('테스트 환경 확인 실패');
+      process.exit(1);
+    }
+    
+    // 2. 기본 테스트 실행
+    const basicTestsOK = await runBasicTests();
+    if (!basicTestsOK) {
+      allTestsPassed = false;
+    }
+    
+    // 3. 통합 테스트 실행
+    const integrationTestsOK = await runIntegrationTests();
+    if (!integrationTestsOK) {
+      allTestsPassed = false;
+    }
+    
+    // 4. 커버리지 리포트 생성
+    const coverageOK = await runCoverageReport();
+    if (!coverageOK) {
+      allTestsPassed = false;
+    }
+    
+    // 5. 테스트 리포트 생성
+    await generateTestReport();
+    
+    // 6. 정리
+    await cleanupTestFiles();
+    
+    const endTime = Date.now();
+    const duration = Math.round((endTime - startTime) / 1000);
+    
+    log.header('=== 테스트 실행 완료 ===');
+    log.info(`총 실행 시간: ${duration}초`);
+    
+    if (allTestsPassed) {
+      log.success('모든 테스트가 성공적으로 완료되었습니다! 🎉');
+      process.exit(0);
+    } else {
+      log.error('일부 테스트가 실패했습니다. 자세한 내용을 확인해 주세요.');
+      process.exit(1);
+    }
+    
+  } catch (error) {
+    log.error(`테스트 실행 중 오류 발생: ${error.message}`);
+    process.exit(1);
+  }
+}
+
+// 명령줄 인수 처리
+const args = process.argv.slice(2);
+if (args.includes('--help') || args.includes('-h')) {
+  console.log(`
+AIWF 통합 테스트 Suite 실행 스크립트
+
+사용법:
+  node scripts/run-integration-tests.js [옵션]
+
+옵션:
+  --help, -h        이 도움말 표시
+  --basic-only      기본 테스트만 실행
+  --integration-only 통합 테스트만 실행
+  --coverage-only   커버리지 리포트만 생성
+  --no-cleanup      테스트 후 정리 작업 생략
+
+예시:
+  node scripts/run-integration-tests.js
+  node scripts/run-integration-tests.js --basic-only
+  node scripts/run-integration-tests.js --coverage-only
+`);
+  process.exit(0);
+}
+
+// 개별 테스트 실행 옵션
+if (args.includes('--basic-only')) {
+  (async () => {
+    await checkTestEnvironment();
+    await runBasicTests();
+  })();
+} else if (args.includes('--integration-only')) {
+  (async () => {
+    await checkTestEnvironment();
+    await runIntegrationTests();
+  })();
+} else if (args.includes('--coverage-only')) {
+  (async () => {
+    await checkTestEnvironment();
+    await runCoverageReport();
+  })();
+} else {
+  main();
+}

package/src/commands/ai-tool.js

@@ -0,0 +1,383 @@
+#!/usr/bin/env node
+
+import fs from 'fs-extra';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import chalk from 'chalk';
+import ora from 'ora';
+// import { table } from 'table'; // 임시로 비활성화
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+/**
+ * AI Tool integration command for AIWF
+ * Manages AI tool templates and configurations
+ */
+export class AIToolCommand {
+  constructor() {
+    this.toolsPath = path.join(process.cwd(), '.aiwf', 'ai-tools');
+    this.availableTools = ['claude-code', 'github-copilot', 'cursor', 'windsurf', 'augment'];
+  }
+
+  /**
+   * Main command handler
+   */
+  async execute(args) {
+    const subcommand = args[0];
+    const toolName = args[1];
+
+    switch (subcommand) {
+      case 'install':
+        return await this.install(toolName);
+      case 'list':
+        return await this.list();
+      case 'update':
+        return await this.update(toolName);
+      case 'verify':
+        return await this.verify(toolName);
+      case 'check':
+        return await this.check(toolName);
+      case 'version':
+        return await this.version(toolName);
+      default:
+        return this.showHelp();
+    }
+  }
+
+  /**
+   * Install an AI tool template
+   */
+  async install(toolName) {
+    if (!toolName) {
+      console.error(chalk.red('Error: Tool name is required'));
+      console.log('Usage: aiwf ai-tool install <tool-name>');
+      console.log(`Available tools: ${this.availableTools.join(', ')}`);
+      return;
+    }
+
+    if (!this.availableTools.includes(toolName)) {
+      console.error(chalk.red(`Error: Unknown tool '${toolName}'`));
+      console.log(`Available tools: ${this.availableTools.join(', ')}`);
+      return;
+    }
+
+    const spinner = ora(`Installing ${toolName} template...`).start();
+
+    try {
+      const toolPath = path.join(this.toolsPath, toolName);
+      const configPath = path.join(toolPath, 'config.json');
+
+      // Check if tool template exists
+      if (!await fs.pathExists(configPath)) {
+        spinner.fail(`Template for ${toolName} not found`);
+        return;
+      }
+
+      // Read configuration
+      const config = await fs.readJson(configPath);
+      
+      // Copy template files
+      for (const fileToCopy of config.files_to_copy) {
+        const sourcePath = path.join(toolPath, fileToCopy.source);
+        const destPath = path.join(process.cwd(), fileToCopy.destination);
+
+        if (await fs.pathExists(sourcePath)) {
+          await fs.copy(sourcePath, destPath, { overwrite: true });
+          spinner.text = `Copying ${fileToCopy.destination}...`;
+        }
+      }
+
+      // Run setup commands if any
+      if (config.setup_commands && config.setup_commands.length > 0) {
+        spinner.text = 'Running setup commands...';
+        const { exec } = await import('child_process');
+        const { promisify } = await import('util');
+        const execAsync = promisify(exec);
+
+        for (const command of config.setup_commands) {
+          await execAsync(command);
+        }
+      }
+
+      // Create installation record
+      const installRecord = {
+        tool: toolName,
+        version: config.version,
+        installedAt: new Date().toISOString(),
+        features: config.features
+      };
+
+      const recordPath = path.join(process.cwd(), '.aiwf', 'ai-tools-installed.json');
+      let installedTools = {};
+      
+      if (await fs.pathExists(recordPath)) {
+        installedTools = await fs.readJson(recordPath);
+      }
+
+      installedTools[toolName] = installRecord;
+      await fs.writeJson(recordPath, installedTools, { spaces: 2 });
+
+      spinner.succeed(chalk.green(`Successfully installed ${toolName} template`));
+      
+      // Show post-installation message
+      console.log('\n' + chalk.cyan('Next steps:'));
+      console.log(`1. Review the installed files`);
+      console.log(`2. Customize settings as needed`);
+      console.log(`3. Read the documentation in .aiwf/ai-tools/${toolName}/README.md`);
+
+      // Show feature status
+      if (config.features) {
+        console.log('\n' + chalk.cyan('Enabled features:'));
+        Object.entries(config.features).forEach(([feature, enabled]) => {
+          if (enabled) {
+            console.log(`  ✓ ${feature}`);
+          }
+        });
+      }
+
+    } catch (error) {
+      spinner.fail(`Failed to install ${toolName}: ${error.message}`);
+      console.error(chalk.red(error.stack));
+    }
+  }
+
+  /**
+   * List available and installed AI tools
+   */
+  async list() {
+    console.log(chalk.cyan('\n🤖 AI Tool Templates\n'));
+
+    const installedPath = path.join(process.cwd(), '.aiwf', 'ai-tools-installed.json');
+    let installedTools = {};
+
+    if (await fs.pathExists(installedPath)) {
+      installedTools = await fs.readJson(installedPath);
+    }
+
+    const tableData = [
+      ['Tool', 'Status', 'Version', 'Features']
+    ];
+
+    for (const toolName of this.availableTools) {
+      const toolPath = path.join(this.toolsPath, toolName);
+      const configPath = path.join(toolPath, 'config.json');
+
+      if (await fs.pathExists(configPath)) {
+        const config = await fs.readJson(configPath);
+        const isInstalled = installedTools[toolName] ? '✓ Installed' : 'Available';
+        const status = isInstalled === '✓ Installed' ? chalk.green(isInstalled) : chalk.gray(isInstalled);
+        const version = installedTools[toolName]?.version || config.version;
+        const features = Object.entries(config.features)
+          .filter(([_, enabled]) => enabled)
+          .map(([feature]) => feature)
+          .slice(0, 3)
+          .join(', ') + (Object.keys(config.features).length > 3 ? '...' : '');
+
+        tableData.push([
+          chalk.bold(toolName),
+          status,
+          version,
+          features
+        ]);
+      }
+    }
+
+    console.log(table(tableData, {
+      border: {
+        topBody: '─',
+        topJoin: '┬',
+        topLeft: '┌',
+        topRight: '┐',
+        bottomBody: '─',
+        bottomJoin: '┴',
+        bottomLeft: '└',
+        bottomRight: '┘',
+        bodyLeft: '│',
+        bodyRight: '│',
+        bodyJoin: '│',
+        joinBody: '─',
+        joinLeft: '├',
+        joinRight: '┤',
+        joinJoin: '┼'
+      }
+    }));
+
+    console.log('\n' + chalk.cyan('Commands:'));
+    console.log('  Install a tool:  aiwf ai-tool install <tool-name>');
+    console.log('  Update a tool:   aiwf ai-tool update <tool-name>');
+    console.log('  Verify a tool:   aiwf ai-tool verify <tool-name>');
+  }
+
+  /**
+   * Update an installed AI tool template
+   */
+  async update(toolName) {
+    if (!toolName) {
+      console.error(chalk.red('Error: Tool name is required'));
+      return;
+    }
+
+    const installedPath = path.join(process.cwd(), '.aiwf', 'ai-tools-installed.json');
+    
+    if (!await fs.pathExists(installedPath)) {
+      console.error(chalk.red('No AI tools installed'));
+      return;
+    }
+
+    const installedTools = await fs.readJson(installedPath);
+
+    if (!installedTools[toolName]) {
+      console.error(chalk.red(`${toolName} is not installed`));
+      return;
+    }
+
+    console.log(chalk.cyan(`Updating ${toolName}...`));
+    
+    // Reinstall with latest template
+    await this.install(toolName);
+  }
+
+  /**
+   * Verify an installed AI tool
+   */
+  async verify(toolName) {
+    if (!toolName) {
+      console.error(chalk.red('Error: Tool name is required'));
+      return;
+    }
+
+    const spinner = ora(`Verifying ${toolName} installation...`).start();
+
+    try {
+      const toolPath = path.join(this.toolsPath, toolName);
+      const configPath = path.join(toolPath, 'config.json');
+      const config = await fs.readJson(configPath);
+
+      let allFilesExist = true;
+      const missingFiles = [];
+
+      // Check if all required files exist
+      for (const fileToCopy of config.files_to_copy) {
+        const destPath = path.join(process.cwd(), fileToCopy.destination);
+        if (!await fs.pathExists(destPath)) {
+          allFilesExist = false;
+          missingFiles.push(fileToCopy.destination);
+        }
+      }
+
+      if (allFilesExist) {
+        spinner.succeed(chalk.green(`${toolName} installation verified successfully`));
+      } else {
+        spinner.fail(chalk.red(`${toolName} installation incomplete`));
+        console.log(chalk.yellow('\nMissing files:'));
+        missingFiles.forEach(file => console.log(`  - ${file}`));
+        console.log(chalk.cyan(`\nRun 'aiwf ai-tool install ${toolName}' to fix`));
+      }
+
+    } catch (error) {
+      spinner.fail(`Failed to verify ${toolName}: ${error.message}`);
+    }
+  }
+
+  /**
+   * Check for updates for a tool
+   */
+  async check(toolName) {
+    if (!toolName) {
+      // Check all installed tools
+      const installedPath = path.join(process.cwd(), '.aiwf', 'ai-tools-installed.json');
+      
+      if (!await fs.pathExists(installedPath)) {
+        console.log(chalk.yellow('No AI tools installed'));
+        return;
+      }
+
+      const installedTools = await fs.readJson(installedPath);
+      console.log(chalk.cyan('\nChecking for updates...\n'));
+
+      for (const [tool, info] of Object.entries(installedTools)) {
+        await this.checkSingleTool(tool, info.version);
+      }
+    } else {
+      await this.checkSingleTool(toolName);
+    }
+  }
+
+  /**
+   * Check a single tool for updates
+   */
+  async checkSingleTool(toolName, installedVersion) {
+    const toolPath = path.join(this.toolsPath, toolName);
+    const configPath = path.join(toolPath, 'config.json');
+
+    if (await fs.pathExists(configPath)) {
+      const config = await fs.readJson(configPath);
+      const latestVersion = config.version;
+
+      if (!installedVersion) {
+        // Get installed version
+        const installedPath = path.join(process.cwd(), '.aiwf', 'ai-tools-installed.json');
+        if (await fs.pathExists(installedPath)) {
+          const installedTools = await fs.readJson(installedPath);
+          installedVersion = installedTools[toolName]?.version;
+        }
+      }
+
+      if (installedVersion && installedVersion !== latestVersion) {
+        console.log(chalk.yellow(`${toolName}: Update available (${installedVersion} → ${latestVersion})`));
+      } else if (installedVersion) {
+        console.log(chalk.green(`${toolName}: Up to date (${latestVersion})`));
+      } else {
+        console.log(chalk.gray(`${toolName}: Not installed`));
+      }
+    }
+  }
+
+  /**
+   * Show version of a tool
+   */
+  async version(toolName) {
+    if (!toolName) {
+      console.error(chalk.red('Error: Tool name is required'));
+      return;
+    }
+
+    const installedPath = path.join(process.cwd(), '.aiwf', 'ai-tools-installed.json');
+    
+    if (await fs.pathExists(installedPath)) {
+      const installedTools = await fs.readJson(installedPath);
+      if (installedTools[toolName]) {
+        console.log(`${toolName}: ${installedTools[toolName].version}`);
+        return;
+      }
+    }
+
+    console.log(chalk.yellow(`${toolName} is not installed`));
+  }
+
+  /**
+   * Show help message
+   */
+  showHelp() {
+    console.log(chalk.cyan('\n🤖 AIWF AI Tool Integration\n'));
+    console.log('Usage: aiwf ai-tool <command> [tool-name]');
+    console.log('\nCommands:');
+    console.log('  install <tool>   Install an AI tool template');
+    console.log('  list             List available and installed tools');
+    console.log('  update <tool>    Update an installed tool');
+    console.log('  verify <tool>    Verify tool installation');
+    console.log('  check [tool]     Check for updates');
+    console.log('  version <tool>   Show installed version');
+    console.log('\nAvailable tools:');
+    this.availableTools.forEach(tool => {
+      console.log(`  - ${tool}`);
+    });
+    console.log('\nExamples:');
+    console.log('  aiwf ai-tool install claude-code');
+    console.log('  aiwf ai-tool list');
+    console.log('  aiwf ai-tool update cursor');
+  }
+}
+
+// Export for use in main CLI
+export default AIToolCommand;