aiwf 0.3.21 → 0.3.23

package/src/commands/ai-tool.js

@@ -1,383 +0,0 @@
-#!/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;

package/src/commands/compress.js

@@ -1,60 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * AIWF 컨텍스트 압축 명령어
- * 대용량 컨텍스트를 효율적으로 압축하여 토큰 사용량 감소
- */
-
-import { ResourceLoader } from '../lib/resource-loader.js';
-import chalk from 'chalk';
-
-class CompressCommand {
-  constructor() {
-    this.resourceLoader = new ResourceLoader();
-  }
-
-  /**
-   * 압축 명령어 실행
-   */
-  async execute(args) {
-    try {
-      // compress-context 모듈 동적 로드
-      const compressModule = await this.resourceLoader.loadUtil('compress-context.js');
-      const executeCompressContext = compressModule.executeCompressContext || compressModule.default;
-      
-      if (typeof executeCompressContext !== 'function') {
-        throw new Error('compress-context 모듈을 로드할 수 없습니다.');
-      }
-      
-      // 실행
-      await executeCompressContext(args);
-      
-    } catch (error) {
-      console.error(chalk.red('❌ 압축 실행 중 오류가 발생했습니다:'), error.message);
-      this.showHelp();
-    }
-  }
-
-  /**
-   * 도움말 표시
-   */
-  showHelp() {
-    console.log(chalk.cyan('\n🗜️  AIWF 컨텍스트 압축'));
-    console.log(chalk.gray('-'.repeat(50)));
-    console.log('사용법: aiwf compress [옵션] [경로]');
-    console.log('');
-    console.log('옵션:');
-    console.log('  aggressive    공격적 압축 (50-70% 토큰 감소)');
-    console.log('  balanced      균형잡힌 압축 (30-50% 토큰 감소) [기본값]');
-    console.log('  minimal       최소 압축 (10-30% 토큰 감소)');
-    console.log('  --persona     페르소나 인식 압축 활성화');
-    console.log('');
-    console.log('예시:');
-    console.log('  aiwf compress                    # 기본 압축');
-    console.log('  aiwf compress aggressive         # 공격적 압축');
-    console.log('  aiwf compress --persona balanced # 페르소나 인식 압축');
-    console.log('  aiwf compress .aiwf              # 특정 경로 압축');
-  }
-}
-
-export default CompressCommand;

package/src/commands/create-project.js

@@ -1,160 +0,0 @@
-#!/usr/bin/env node
-
-import fs from 'fs-extra';
-import path from 'path';
-import { fileURLToPath } from 'url';
-import prompts from 'prompts';
-import chalk from 'chalk';
-import ora from 'ora';
-import { ResourceLoader } from '../lib/resource-loader.js';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-// ResourceLoader를 사용하여 템플릿 관리
-const resourceLoader = new ResourceLoader();
-
-async function createProject() {
-  console.log(chalk.cyan('\n🚀 AIWF 프로젝트 생성기\n'));
-
-  // ResourceLoader를 사용하여 템플릿 찾기
-  const templates = await resourceLoader.listTemplates();
-  
-  const templateConfigs = [];
-  for (const template of templates) {
-    try {
-      const config = await resourceLoader.loadTemplateConfig(template);
-      templateConfigs.push({
-        value: template,
-        title: config.displayName,
-        description: config.description
-      });
-    } catch (error) {
-      console.error(`템플릿 ${template} 로드 실패:`, error.message);
-    }
-  }
-
-  const questions = [
-    {
-      type: 'select',
-      name: 'template',
-      message: '템플릿을 선택하세요',
-      choices: templateConfigs,
-    },
-    {
-      type: 'text',
-      name: 'projectName',
-      message: '프로젝트 이름',
-      validate: value => {
-        if (!value) return '프로젝트 이름을 입력하세요';
-        if (!/^[a-z0-9-]+$/.test(value)) {
-          return '소문자, 숫자, 하이픈만 사용 가능합니다';
-        }
-        return true;
-      }
-    },
-    {
-      type: prev => prev === 'npm-library' ? 'text' : null,
-      name: 'description',
-      message: '프로젝트 설명',
-      initial: 'A new AIWF project'
-    },
-    {
-      type: prev => prev === 'npm-library' ? 'text' : null,
-      name: 'author',
-      message: '작성자',
-      initial: ''
-    },
-    {
-      type: 'text',
-      name: 'directory',
-      message: '프로젝트 디렉토리',
-      initial: prev => prev.projectName,
-      validate: value => {
-        if (!value) return '디렉토리를 입력하세요';
-        if (fs.existsSync(value)) {
-          return '이미 존재하는 디렉토리입니다';
-        }
-        return true;
-      }
-    }
-  ];
-
-  const answers = await prompts(questions);
-
-  if (!answers.template || !answers.projectName) {
-    console.log(chalk.red('\n❌ 프로젝트 생성이 취소되었습니다.'));
-    return;
-  }
-
-  const spinner = ora('프로젝트 생성 중...').start();
-
-  try {
-    // ResourceLoader를 사용하여 템플릿 경로 가져오기
-    const templatePath = await resourceLoader.getTemplatePath(answers.template);
-    const targetPath = path.resolve(answers.directory);
-
-    // 템플릿 복사
-    await fs.copy(templatePath, targetPath);
-
-    // 플레이스홀더 교체
-    const replacements = {
-      '{{projectName}}': answers.projectName,
-      '{{description}}': answers.description || '',
-      '{{author}}': answers.author || '',
-      '{{year}}': new Date().getFullYear().toString(),
-      '{{createdAt}}': new Date().toISOString(),
-      '{{username}}': answers.author?.toLowerCase().replace(/\s+/g, '') || 'username'
-    };
-
-    // 모든 파일에서 플레이스홀더 교체
-    await replacePlaceholders(targetPath, replacements);
-
-    spinner.succeed('프로젝트가 성공적으로 생성되었습니다!');
-
-    console.log(chalk.green(`\n✅ ${answers.projectName} 프로젝트가 생성되었습니다!\n`));
-    console.log('다음 명령어로 시작하세요:\n');
-    console.log(chalk.cyan(`  cd ${answers.directory}`));
-    console.log(chalk.cyan('  npm install'));
-    console.log(chalk.cyan('  npm run dev\n'));
-    console.log('AIWF 명령어:');
-    console.log(chalk.gray('  npm run aiwf status   # 프로젝트 상태 확인'));
-    console.log(chalk.gray('  npm run aiwf feature  # Feature Ledger 관리\n'));
-
-  } catch (error) {
-    spinner.fail('프로젝트 생성 중 오류가 발생했습니다.');
-    console.error(chalk.red(error.message));
-    process.exit(1);
-  }
-}
-
-async function replacePlaceholders(dir, replacements) {
-  const files = await fs.readdir(dir);
-
-  for (const file of files) {
-    const filePath = path.join(dir, file);
-    const stat = await fs.stat(filePath);
-
-    if (stat.isDirectory()) {
-      await replacePlaceholders(filePath, replacements);
-    } else if (stat.isFile()) {
-      let content = await fs.readFile(filePath, 'utf8');
-      
-      for (const [placeholder, value] of Object.entries(replacements)) {
-        content = content.replace(new RegExp(placeholder, 'g'), value);
-      }
-
-      await fs.writeFile(filePath, content, 'utf8');
-    }
-  }
-}
-
-// CLI 실행
-if (import.meta.url === `file://${process.argv[1]}`) {
-  createProject().catch(error => {
-    console.error(chalk.red('오류:', error.message));
-    process.exit(1);
-  });
-}
-
-export { createProject };