aiwf 0.3.0 → 0.3.2

package/scripts/validate-commands.js

@@ -0,0 +1,254 @@
+#!/usr/bin/env node
+
+/**
+ * AIWF 명령어 파일 일관성 검증 도구
+ * 
+ * 이 스크립트는 다음을 검증합니다:
+ * 1. 한국어/영어 명령어 파일 간의 일관성
+ * 2. 명령어 파일명과 실제 명령어명의 매칭
+ * 3. 누락된 명령어 파일 식별
+ * 4. GitHub URL 참조 일관성
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+
+// 색상 출력을 위한 ANSI 코드
+const colors = {
+    reset: '\x1b[0m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    cyan: '\x1b[36m',
+    gray: '\x1b[90m'
+};
+
+// chalk 대체 함수
+const chalk = {
+    red: (text) => `${colors.red}${text}${colors.reset}`,
+    green: (text) => `${colors.green}${text}${colors.reset}`,
+    yellow: (text) => `${colors.yellow}${text}${colors.reset}`,
+    blue: (text) => `${colors.blue}${text}${colors.reset}`,
+    cyan: (text) => `${colors.cyan}${text}${colors.reset}`,
+    gray: (text) => `${colors.gray}${text}${colors.reset}`,
+    bold: (text) => `\x1b[1m${text}${colors.reset}`
+};
+
+const KO_COMMANDS_DIR = 'claude-code/aiwf/ko/.claude/commands/aiwf';
+const EN_COMMANDS_DIR = 'claude-code/aiwf/en/.claude/commands/aiwf';
+
+// 명령어 파일 메타데이터 추출
+async function extractCommandMetadata(filePath) {
+    try {
+        const content = await fs.readFile(filePath, 'utf-8');
+        const lines = content.split('\n');
+        
+        // YAML frontmatter 찾기
+        if (lines[0] === '---') {
+            const endIndex = lines.findIndex((line, index) => index > 0 && line === '---');
+            if (endIndex !== -1) {
+                const frontmatter = lines.slice(1, endIndex).join('\n');
+                // 간단한 YAML 파싱 (name 추출)
+                const nameMatch = frontmatter.match(/name:\s*["']?([^"'\n]+)["']?/);
+                const descMatch = frontmatter.match(/description:\s*["']?([^"'\n]+)["']?/);
+                
+                return {
+                    name: nameMatch ? nameMatch[1] : null,
+                    description: descMatch ? descMatch[1] : null,
+                    hasFrontmatter: true
+                };
+            }
+        }
+        
+        // 첫 번째 헤더에서 명령어명 추출
+        const headerMatch = content.match(/^#\s+(.+)/m);
+        return {
+            name: headerMatch ? headerMatch[1] : null,
+            description: null,
+            hasFrontmatter: false
+        };
+    } catch (error) {
+        return { error: error.message };
+    }
+}
+
+// 디렉토리의 모든 명령어 파일 스캔
+async function scanCommandsDirectory(dir) {
+    const commands = {};
+    
+    try {
+        const files = await fs.readdir(dir);
+        const mdFiles = files.filter(file => file.endsWith('.md'));
+        
+        for (const file of mdFiles) {
+            const filePath = path.join(dir, file);
+            const metadata = await extractCommandMetadata(filePath);
+            commands[file] = {
+                ...metadata,
+                path: filePath
+            };
+        }
+    } catch (error) {
+        console.error(chalk.red(`Error scanning directory ${dir}: ${error.message}`));
+    }
+    
+    return commands;
+}
+
+// GitHub URL 참조 검증
+async function validateGitHubUrls(filePath) {
+    try {
+        const content = await fs.readFile(filePath, 'utf-8');
+        const moonklabsRefs = content.match(/moonklabs\/aiwf/g) || [];
+        const aiwfRefs = content.match(/aiwf\/aiwf/g) || [];
+        
+        return {
+            moonklabsCount: moonklabsRefs.length,
+            aiwfCount: aiwfRefs.length,
+            hasInconsistentUrls: moonklabsRefs.length > 0
+        };
+    } catch (error) {
+        return { error: error.message };
+    }
+}
+
+// 명령어 파일 검증
+async function validateCommands() {
+    console.log(chalk.blue(chalk.bold('\n🔍 AIWF Command Files Validation\n')));
+    console.log('='.repeat(50));
+    
+    // 1. 디렉토리 스캔
+    console.log(chalk.cyan('\n1. 디렉토리 스캔 중...'));
+    const koCommands = await scanCommandsDirectory(KO_COMMANDS_DIR);
+    const enCommands = await scanCommandsDirectory(EN_COMMANDS_DIR);
+    
+    console.log(chalk.gray(`   한국어 명령어: ${Object.keys(koCommands).length}개`));
+    console.log(chalk.gray(`   영어 명령어: ${Object.keys(enCommands).length}개`));
+    
+    // 2. 명령어 일관성 검증
+    console.log(chalk.cyan('\n2. 명령어 일관성 검증 중...'));
+    
+    const allFiles = new Set([...Object.keys(koCommands), ...Object.keys(enCommands)]);
+    const issues = [];
+    
+    for (const fileName of allFiles) {
+        const koExists = koCommands[fileName];
+        const enExists = enCommands[fileName];
+        
+        if (!koExists) {
+            issues.push({
+                type: 'missing_ko',
+                file: fileName,
+                message: `한국어 버전 누락: ${fileName}`
+            });
+        }
+        
+        if (!enExists) {
+            issues.push({
+                type: 'missing_en',
+                file: fileName,
+                message: `영어 버전 누락: ${fileName}`
+            });
+        }
+        
+        // 명령어명 일관성 검증 (언어가 다르므로 생략)
+        if (koExists && enExists && koExists.name && enExists.name) {
+            // 언어가 다르므로 명령어명이 다른 것은 정상
+            // 이 검증은 제거
+        }
+    }
+    
+    // 3. update_docs 명령어 검증
+    console.log(chalk.cyan('\n3. update_docs 명령어 검증 중...'));
+    
+    const updateDocsFiles = [
+        'aiwf_update_docs.md',
+        'aiwf_docs.md'
+    ];
+    
+    const updateDocsStatus = {};
+    for (const file of updateDocsFiles) {
+        updateDocsStatus[file] = {
+            ko: !!koCommands[file],
+            en: !!enCommands[file]
+        };
+    }
+    
+    // 4. GitHub URL 검증
+    console.log(chalk.cyan('\n4. GitHub URL 참조 검증 중...'));
+    
+    const urlIssues = [];
+    for (const [fileName, command] of Object.entries({ ...koCommands, ...enCommands })) {
+        if (command.path) {
+            const urlCheck = await validateGitHubUrls(command.path);
+            if (urlCheck.hasInconsistentUrls) {
+                urlIssues.push({
+                    file: fileName,
+                    path: command.path,
+                    moonklabsCount: urlCheck.moonklabsCount
+                });
+            }
+        }
+    }
+    
+    // 결과 출력
+    console.log(chalk.blue(chalk.bold('\n📋 검증 결과\n')));
+    console.log('='.repeat(50));
+    
+    // 일관성 이슈
+    if (issues.length > 0) {
+        console.log(chalk.red(`\n❌ 발견된 이슈 (${issues.length}개):`));
+        for (const issue of issues) {
+            console.log(chalk.red(`   • ${issue.message}`));
+        }
+    } else {
+        console.log(chalk.green('\n✅ 명령어 일관성 검증 통과'));
+    }
+    
+    // update_docs 상태
+    console.log(chalk.blue('\n📝 update_docs 명령어 상태:'));
+    for (const [file, status] of Object.entries(updateDocsStatus)) {
+        const koIcon = status.ko ? '✅' : '❌';
+        const enIcon = status.en ? '✅' : '❌';
+        console.log(chalk.gray(`   ${file}: KO ${koIcon} EN ${enIcon}`));
+    }
+    
+    // GitHub URL 이슈
+    if (urlIssues.length > 0) {
+        console.log(chalk.yellow(`\n⚠️ GitHub URL 이슈 (${urlIssues.length}개):`));
+        for (const issue of urlIssues) {
+            console.log(chalk.yellow(`   • ${issue.file}: moonklabs/aiwf 참조 ${issue.moonklabsCount}개`));
+        }
+    } else {
+        console.log(chalk.green('\n✅ GitHub URL 참조 검증 통과'));
+    }
+    
+    // 요약
+    console.log(chalk.blue(chalk.bold('\n📊 요약:')));
+    console.log(chalk.gray(`   총 명령어 파일: ${allFiles.size}개`));
+    console.log(chalk.gray(`   한국어/영어 쌍: ${Math.min(Object.keys(koCommands).length, Object.keys(enCommands).length)}개`));
+    console.log(chalk.gray(`   일관성 이슈: ${issues.length}개`));
+    console.log(chalk.gray(`   URL 이슈: ${urlIssues.length}개`));
+    
+    const overallSuccess = issues.length === 0 && urlIssues.length === 0;
+    console.log(overallSuccess ? 
+        chalk.green('\n🎉 모든 검증 통과!') : 
+        chalk.red('\n⚠️ 일부 이슈가 발견되었습니다.')
+    );
+    
+    return {
+        success: overallSuccess,
+        issues,
+        urlIssues,
+        updateDocsStatus,
+        totalFiles: allFiles.size
+    };
+}
+
+// 메인 실행
+if (import.meta.url === `file://${process.argv[1]}`) {
+    validateCommands().catch(console.error);
+}
+
+export { validateCommands };

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;