aiwf 0.3.3 → 0.3.5

package/src/cli/index.js

@@ -0,0 +1,206 @@
+#!/usr/bin/env node
+
+import { program } from 'commander';
+import chalk from 'chalk';
+import { installAIWF } from '../lib/installer.js';
+import AIToolCommand from '../commands/ai-tool.js';
+import PersonaCommand from '../commands/persona.js';
+import { CacheCLI } from './cache-cli.js';
+
+// Parse version from package.json
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const packageJson = JSON.parse(readFileSync(join(__dirname, '../../package.json'), 'utf8'));
+
+// Main program setup
+program
+  .name('aiwf')
+  .version(packageJson.version)
+  .description('AIWF - AI Workflow Framework');
+
+// Install command (default action)
+program
+  .command('install', { isDefault: true })
+  .description('Install AIWF framework')
+  .option('-f, --force', 'Force install without prompts')
+  .action((options) => installAIWF({ ...options, debugLog: true }));
+
+// AI Tool command
+program
+  .command('ai-tool <subcommand> [tool-name]')
+  .description('Manage AI tool integrations')
+  .action(async (subcommand, toolName) => {
+    const aiToolCmd = new AIToolCommand();
+    const args = [subcommand];
+    if (toolName) args.push(toolName);
+    await aiToolCmd.execute(args);
+  });
+
+// Cache management commands
+const cache = program.command('cache');
+cache.description('Manage offline template cache');
+
+cache
+  .command('download')
+  .description('Download templates for offline use')
+  .option('--all', 'Download all templates')
+  .option('--type <type>', 'Download specific type (ai-tools, projects)')
+  .action(async (options) => {
+    const cacheCLI = new CacheCLI();
+    try {
+      await cacheCLI.init();
+      await cacheCLI.downloadCommand(options);
+    } catch (error) {
+      console.error(chalk.red('Cache download failed:', error.message));
+      process.exit(1);
+    } finally {
+      await cacheCLI.cleanup();
+    }
+  });
+
+cache
+  .command('list')
+  .description('List cached templates')
+  .option('--type <type>', 'Filter by type (ai-tools, projects)')
+  .action(async (options) => {
+    const cacheCLI = new CacheCLI();
+    try {
+      await cacheCLI.init();
+      await cacheCLI.listCommand(options);
+    } catch (error) {
+      console.error(chalk.red('Cache list failed:', error.message));
+      process.exit(1);
+    } finally {
+      await cacheCLI.cleanup();
+    }
+  });
+
+cache
+  .command('clean')
+  .description('Clean up cached templates')
+  .option('--all', 'Clear all cached templates')
+  .option('--max-age <days>', 'Maximum age in days (default: 7)', '7')
+  .action(async (options) => {
+    const cacheCLI = new CacheCLI();
+    try {
+      await cacheCLI.init();
+      await cacheCLI.cleanCommand(options);
+    } catch (error) {
+      console.error(chalk.red('Cache clean failed:', error.message));
+      process.exit(1);
+    } finally {
+      await cacheCLI.cleanup();
+    }
+  });
+
+cache
+  .command('update')
+  .description('Check for template updates')
+  .option('--install', 'Install available updates')
+  .action(async (options) => {
+    const cacheCLI = new CacheCLI();
+    try {
+      await cacheCLI.init();
+      await cacheCLI.updateCommand(options);
+    } catch (error) {
+      console.error(chalk.red('Cache update failed:', error.message));
+      process.exit(1);
+    } finally {
+      await cacheCLI.cleanup();
+    }
+  });
+
+cache
+  .command('status')
+  .description('Show cache system status')
+  .action(async () => {
+    const cacheCLI = new CacheCLI();
+    try {
+      await cacheCLI.init();
+      await cacheCLI.statusCommand();
+    } catch (error) {
+      console.error(chalk.red('Cache status failed:', error.message));
+      process.exit(1);
+    } finally {
+      await cacheCLI.cleanup();
+    }
+  });
+
+// Language management commands
+const lang = program.command('lang');
+lang.description('Manage language settings / 언어 설정 관리');
+
+lang
+  .command('status')
+  .alias('s')
+  .description('Show current language configuration / 현재 언어 설정 표시')
+  .action(async () => {
+    const { showLanguageStatus } = await import('./language-cli.js');
+    await showLanguageStatus();
+  });
+
+lang
+  .command('set [language]')
+  .alias('switch')
+  .description('Set or change language / 언어 설정 또는 변경')
+  .option('-a, --auto-detect [boolean]', 'Enable/disable auto detection / 자동 감지 활성화/비활성화')
+  .action(async (language, options) => {
+    const { setLanguage } = await import('./language-cli.js');
+    await setLanguage(language, options);
+  });
+
+lang
+  .command('reset')
+  .alias('r')
+  .description('Reset language configuration to auto-detection / 언어 설정을 자동 감지로 초기화')
+  .action(async () => {
+    const { resetLanguage } = await import('./language-cli.js');
+    await resetLanguage();
+  });
+
+// Persona management commands
+const persona = program.command('persona');
+persona.description('Manage AI personas / AI 페르소나 관리');
+
+persona
+  .command('status')
+  .alias('s')
+  .description('Show current persona status / 현재 페르소나 상태 표시')
+  .action(async () => {
+    const personaCmd = new PersonaCommand();
+    await personaCmd.showStatus();
+  });
+
+persona
+  .command('list')
+  .alias('ls')
+  .description('List available personas / 사용 가능한 페르소나 목록')
+  .action(async () => {
+    const personaCmd = new PersonaCommand();
+    await personaCmd.listPersonas();
+  });
+
+persona
+  .command('set <persona-name>')
+  .alias('switch')
+  .description('Switch to specific persona / 특정 페르소나로 전환')
+  .action(async (personaName) => {
+    const personaCmd = new PersonaCommand();
+    await personaCmd.setPersona(personaName);
+  });
+
+persona
+  .command('reset')
+  .alias('r')
+  .description('Reset to default persona / 기본 페르소나로 리셋')
+  .action(async () => {
+    const personaCmd = new PersonaCommand();
+    await personaCmd.resetPersona();
+  });
+
+// Parse command line arguments
+program.parse(process.argv);

package/{language-cli.js → src/cli/language-cli.js}

@@ -17,7 +17,7 @@ import {
     getLocalizedMessage,
     SUPPORTED_LANGUAGES,
     DEFAULT_LANGUAGE
-} from './language-utils.js';
+} from '../utils/language-utils.js';
 
 const program = new Command();
 
@@ -75,7 +75,7 @@ function getCliMessage(key, language = DEFAULT_LANGUAGE) {
 /**
  * 언어 설정 상태 표시
  */
-async function showLanguageStatus() {
+export async function showLanguageStatus() {
     try {
         const status = await getLanguageStatus();
         const currentLang = status.effectiveLanguage;
@@ -121,7 +121,7 @@ async function showLanguageStatus() {
 /**
  * 언어 설정 변경
  */
-async function setLanguage(language = null, options = {}) {
+export async function setLanguage(language = null, options = {}) {
     try {
         let targetLanguage = language;
         let autoDetect = options.autoDetect;
@@ -190,7 +190,7 @@ async function setLanguage(language = null, options = {}) {
 /**
  * 언어 설정 초기화
  */
-async function resetLanguage() {
+export async function resetLanguage() {
     try {
         const currentStatus = await getLanguageStatus();
         const currentLang = currentStatus.effectiveLanguage;
@@ -273,6 +273,13 @@ program
 
 // CLI 실행
 if (import.meta.url === `file://${process.argv[1]}`) {
+    // Deprecated 경고 표시
+    console.log(chalk.yellow('⚠️  DEPRECATED: `aiwf-lang` is deprecated.'));
+    console.log(chalk.yellow('   Please use `aiwf lang` instead:'));
+    console.log(chalk.gray('   aiwf-lang status  →  aiwf lang status'));
+    console.log(chalk.gray('   aiwf-lang set     →  aiwf lang set'));
+    console.log(chalk.gray('   aiwf-lang reset   →  aiwf lang reset\n'));
+    
     program.parse(process.argv);
 }
 

package/src/commands/cache-templates.js

@@ -0,0 +1,209 @@
+#!/usr/bin/env node
+
+const fs = require('fs-extra');
+const path = require('path');
+const https = require('https');
+const tar = require('tar');
+const chalk = require('chalk');
+const ora = require('ora');
+
+const CACHE_DIR = path.join(__dirname, '../.cache');
+const TEMPLATES_DIR = path.join(__dirname, '../templates');
+const DEPENDENCIES_CACHE = path.join(CACHE_DIR, 'dependencies');
+
+// 각 템플릿의 주요 의존성 목록
+const TEMPLATE_DEPENDENCIES = {
+  'web-app': [
+    'react@18',
+    'react-dom@18',
+    'vite@4',
+    'typescript@5',
+    'tailwindcss@3'
+  ],
+  'api-server': [
+    'express@4',
+    'typescript@5',
+    'jsonwebtoken@9',
+    'swagger-ui-express@5'
+  ],
+  'npm-library': [
+    'typescript@5',
+    'rollup@3',
+    'jest@29'
+  ]
+};
+
+async function cacheTemplates() {
+  console.log(chalk.cyan('\n📦 AIWF 템플릿 캐시 시스템\n'));
+
+  const spinner = ora('캐시 디렉토리 준비 중...').start();
+
+  try {
+    // 캐시 디렉토리 생성
+    await fs.ensureDir(CACHE_DIR);
+    await fs.ensureDir(DEPENDENCIES_CACHE);
+
+    spinner.text = '템플릿 압축 중...';
+
+    // 각 템플릿을 압축하여 캐시
+    const templates = await fs.readdir(TEMPLATES_DIR);
+    
+    for (const template of templates) {
+      const templatePath = path.join(TEMPLATES_DIR, template);
+      const stat = await fs.stat(templatePath);
+      
+      if (stat.isDirectory()) {
+        const cachePath = path.join(CACHE_DIR, `${template}.tar.gz`);
+        
+        await tar.create(
+          {
+            gzip: true,
+            file: cachePath,
+            cwd: TEMPLATES_DIR
+          },
+          [template]
+        );
+
+        spinner.text = `${template} 템플릿 캐시 완료`;
+      }
+    }
+
+    spinner.text = '템플릿 메타데이터 생성 중...';
+
+    // 캐시 메타데이터 생성
+    const metadata = {
+      version: require('../../package.json').version,
+      cachedAt: new Date().toISOString(),
+      templates: {},
+      dependencies: {}
+    };
+
+    for (const template of templates) {
+      const configPath = path.join(TEMPLATES_DIR, template, 'config.json');
+      if (await fs.pathExists(configPath)) {
+        const config = await fs.readJson(configPath);
+        metadata.templates[template] = {
+          name: config.name,
+          displayName: config.displayName,
+          description: config.description,
+          size: (await fs.stat(path.join(CACHE_DIR, `${template}.tar.gz`))).size
+        };
+      }
+    }
+
+    await fs.writeJson(path.join(CACHE_DIR, 'metadata.json'), metadata, { spaces: 2 });
+
+    spinner.succeed('템플릿 캐시 완료!');
+
+    // 캐시 통계 출력
+    console.log(chalk.green('\n✅ 캐시 생성 완료\n'));
+    console.log('캐시된 템플릿:');
+    for (const [template, info] of Object.entries(metadata.templates)) {
+      console.log(chalk.gray(`  - ${info.displayName}: ${(info.size / 1024).toFixed(2)} KB`));
+    }
+
+    const totalSize = Object.values(metadata.templates)
+      .reduce((sum, info) => sum + info.size, 0);
+    console.log(chalk.gray(`\n총 캐시 크기: ${(totalSize / 1024 / 1024).toFixed(2)} MB`));
+
+  } catch (error) {
+    spinner.fail('캐시 생성 중 오류가 발생했습니다.');
+    console.error(chalk.red(error.message));
+    process.exit(1);
+  }
+}
+
+async function restoreFromCache(templateName, targetPath) {
+  const cachePath = path.join(CACHE_DIR, `${templateName}.tar.gz`);
+  
+  if (!await fs.pathExists(cachePath)) {
+    throw new Error(`캐시된 템플릿을 찾을 수 없습니다: ${templateName}`);
+  }
+
+  await tar.extract({
+    file: cachePath,
+    cwd: targetPath
+  });
+
+  // 템플릿 내용을 상위 디렉토리로 이동
+  const extractedPath = path.join(targetPath, templateName, 'template');
+  const files = await fs.readdir(extractedPath);
+  
+  for (const file of files) {
+    await fs.move(
+      path.join(extractedPath, file),
+      path.join(targetPath, file)
+    );
+  }
+
+  // 임시 디렉토리 삭제
+  await fs.remove(path.join(targetPath, templateName));
+}
+
+async function checkCache() {
+  const metadataPath = path.join(CACHE_DIR, 'metadata.json');
+  
+  if (!await fs.pathExists(metadataPath)) {
+    return { valid: false, reason: '캐시가 존재하지 않습니다' };
+  }
+
+  const metadata = await fs.readJson(metadataPath);
+  const packageVersion = require('../../package.json').version;
+
+  if (metadata.version !== packageVersion) {
+    return { valid: false, reason: '버전이 일치하지 않습니다' };
+  }
+
+  // 캐시가 7일 이상 오래된 경우
+  const cacheAge = Date.now() - new Date(metadata.cachedAt).getTime();
+  const sevenDays = 7 * 24 * 60 * 60 * 1000;
+  
+  if (cacheAge > sevenDays) {
+    return { valid: false, reason: '캐시가 오래되었습니다' };
+  }
+
+  return { valid: true, metadata };
+}
+
+// CLI 명령어 처리
+if (require.main === module) {
+  const command = process.argv[2];
+
+  switch (command) {
+    case 'create':
+      cacheTemplates().catch(error => {
+        console.error(chalk.red('오류:', error.message));
+        process.exit(1);
+      });
+      break;
+
+    case 'check':
+      checkCache().then(result => {
+        if (result.valid) {
+          console.log(chalk.green('✅ 캐시가 유효합니다'));
+          console.log(chalk.gray(`생성일: ${result.metadata.cachedAt}`));
+        } else {
+          console.log(chalk.yellow(`⚠️  ${result.reason}`));
+        }
+      });
+      break;
+
+    case 'clear':
+      fs.remove(CACHE_DIR).then(() => {
+        console.log(chalk.green('✅ 캐시가 삭제되었습니다'));
+      });
+      break;
+
+    default:
+      console.log(`
+사용법: node cache-templates.js [command]
+
+명령어:
+  create  템플릿 캐시 생성
+  check   캐시 상태 확인
+  clear   캐시 삭제
+`);
+  }
+}
+
+module.exports = { cacheTemplates, restoreFromCache, checkCache };

package/src/commands/create-offline.js

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+const ora = require('ora');
+const { checkCache, restoreFromCache } = require('./cache-templates');
+
+async function createProjectOffline(template, projectName, targetDir) {
+  const spinner = ora('오프라인 모드로 프로젝트 생성 중...').start();
+
+  try {
+    // 캐시 확인
+    const cacheStatus = await checkCache();
+    
+    if (!cacheStatus.valid) {
+      spinner.fail(`캐시 문제: ${cacheStatus.reason}`);
+      console.log(chalk.yellow('\n온라인 모드로 전환하거나 캐시를 업데이트하세요.'));
+      return false;
+    }
+
+    spinner.text = '캐시에서 템플릿 복원 중...';
+
+    // 캐시에서 템플릿 복원
+    await restoreFromCache(template, targetDir);
+
+    // 플레이스홀더 교체
+    const replacements = {
+      '{{projectName}}': projectName,
+      '{{createdAt}}': new Date().toISOString(),
+      '{{year}}': new Date().getFullYear().toString()
+    };
+
+    await replacePlaceholders(targetDir, replacements);
+
+    spinner.succeed('프로젝트가 오프라인 모드로 생성되었습니다!');
+
+    console.log(chalk.green(`\n✅ ${projectName} 프로젝트가 생성되었습니다!\n`));
+    console.log(chalk.yellow('⚠️  오프라인 모드로 생성되었습니다.'));
+    console.log('인터넷 연결 후 다음 명령어를 실행하세요:\n');
+    console.log(chalk.cyan(`  cd ${targetDir}`));
+    console.log(chalk.cyan('  npm install\n'));
+
+    return true;
+
+  } catch (error) {
+    spinner.fail('오프라인 프로젝트 생성 실패');
+    throw error;
+  }
+}
+
+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() && file !== 'node_modules') {
+      await replacePlaceholders(filePath, replacements);
+    } else if (stat.isFile() && !file.endsWith('.jpg') && !file.endsWith('.png')) {
+      try {
+        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');
+      } catch (error) {
+        // 바이너리 파일 무시
+      }
+    }
+  }
+}
+
+// 네트워크 연결 확인
+function isOnline() {
+  return new Promise((resolve) => {
+    require('dns').lookup('registry.npmjs.org', (err) => {
+      resolve(!err);
+    });
+  });
+}
+
+module.exports = { createProjectOffline, isOnline };

package/src/commands/create-project.js

@@ -0,0 +1,151 @@
+#!/usr/bin/env node
+
+const fs = require('fs-extra');
+const path = require('path');
+const prompts = require('prompts');
+const chalk = require('chalk');
+const ora = require('ora');
+
+const TEMPLATES_DIR = path.join(__dirname, '../templates');
+
+async function createProject() {
+  console.log(chalk.cyan('\n🚀 AIWF 프로젝트 생성기\n'));
+
+  // 사용 가능한 템플릿 찾기
+  const templates = fs.readdirSync(TEMPLATES_DIR)
+    .filter(dir => fs.existsSync(path.join(TEMPLATES_DIR, dir, 'config.json')));
+
+  const templateConfigs = templates.map(template => {
+    const config = JSON.parse(
+      fs.readFileSync(path.join(TEMPLATES_DIR, template, 'config.json'), 'utf8')
+    );
+    return {
+      value: template,
+      title: config.displayName,
+      description: config.description
+    };
+  });
+
+  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 {
+    const templatePath = path.join(TEMPLATES_DIR, answers.template, '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 (require.main === module) {
+  createProject().catch(error => {
+    console.error(chalk.red('오류:', error.message));
+    process.exit(1);
+  });
+}
+
+module.exports = { createProject };