aiwf 0.3.3 → 0.3.5

package/src/commands/persona.js

@@ -0,0 +1,288 @@
+#!/usr/bin/env node
+
+/**
+ * AI 페르소나 명령어
+ * AI 행동 페르소나 관리 및 전환
+ */
+
+import { AIPersonaManager } from '../lib/ai-persona-manager.js';
+import path from 'path';
+import chalk from 'chalk';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+class PersonaCommand {
+  constructor() {
+    this.personaManager = null;
+  }
+
+  /**
+   * 페르소나 매니저 초기화
+   */
+  async initPersonaManager() {
+    if (!this.personaManager) {
+      this.personaManager = new AIPersonaManager({
+        personaConfigPath: path.join(process.cwd(), '.aiwf', 'personas'),
+        metricsPath: path.join(process.cwd(), '.aiwf', 'metrics'),
+        metricsEnabled: true,
+        autoDetectionEnabled: true
+      });
+      
+      await this.personaManager.init();
+    }
+    
+    return this.personaManager;
+  }
+
+  /**
+   * 페르소나 상태 표시
+   */
+  async showStatus() {
+    try {
+      // 파일에서 현재 페르소나 읽기
+      const fs = await import('fs/promises');
+      const path = await import('path');
+      const personaFile = path.join(process.cwd(), '.aiwf', 'personas', 'current.json');
+      
+      try {
+        const content = await fs.readFile(personaFile, 'utf-8');
+        const currentPersona = JSON.parse(content);
+        
+        console.log(chalk.cyan('🎭 현재 AI 페르소나 상태'));
+        console.log(chalk.gray('-'.repeat(50)));
+        console.log(`현재 페르소나: ${chalk.yellow(currentPersona.name)}`);
+        console.log(`설명: ${currentPersona.description}`);
+        console.log(`활성화 시간: ${new Date(currentPersona.activatedAt).toLocaleString('ko-KR')}`);
+        
+        const behaviors = this.getKoreanBehaviors(currentPersona.name);
+        if (behaviors.length > 0) {
+          console.log('\n주요 동작:');
+          behaviors.forEach(behavior => {
+            console.log(`  • ${behavior}`);
+          });
+        }
+
+        console.log(chalk.gray('\n' + '-'.repeat(50)));
+        console.log(chalk.green('✅ 페르소나가 활성화되어 있습니다.'));
+        
+      } catch (fileError) {
+        console.log(chalk.yellow('⚠️  현재 활성화된 페르소나가 없습니다.'));
+        console.log(chalk.gray('사용 가능한 페르소나 목록을 보려면: aiwf persona list'));
+        console.log(chalk.gray('페르소나를 설정하려면: aiwf persona set <페르소나명>'));
+      }
+      
+    } catch (error) {
+      console.error(chalk.red('❌ 페르소나 상태 확인 중 오류가 발생했습니다:'), error.message);
+      console.error(error.stack);
+    }
+  }
+
+  /**
+   * 페르소나 목록 표시
+   */
+  async listPersonas() {
+    try {
+      console.log(chalk.cyan('🎭 사용 가능한 AI 페르소나'));
+      console.log(chalk.gray('-'.repeat(50)));
+      
+      // 기본 페르소나 목록을 하드코딩으로 표시 (초기화 문제 회피)
+      const defaultPersonas = [
+        { name: 'architect', description: '시스템 설계 및 아키텍처 전문가' },
+        { name: 'developer', description: '일반 개발자 (기본값)' },
+        { name: 'reviewer', description: '코드 리뷰 및 품질 관리 전문가' },
+        { name: 'debugger', description: '디버깅 및 문제 해결 전문가' },
+        { name: 'optimizer', description: '성능 최적화 전문가' },
+        { name: 'security', description: '보안 및 취약점 분석 전문가' },
+        { name: 'documenter', description: '문서화 및 기술 작성 전문가' }
+      ];
+      
+      defaultPersonas.forEach(persona => {
+        const displayName = chalk.yellow(persona.name);
+        console.log(`  ${displayName} - ${persona.description}`);
+      });
+      
+      console.log(chalk.gray('\n' + '-'.repeat(50)));
+      console.log(chalk.gray('사용법: aiwf persona set <페르소나명>'));
+      
+    } catch (error) {
+      console.error(chalk.red('❌ 페르소나 목록 조회 중 오류가 발생했습니다:'), error.message);
+      console.error(error.stack);
+    }
+  }
+
+  /**
+   * 페르소나 전환
+   */
+  async setPersona(personaName) {
+    if (!personaName) {
+      console.error(chalk.red('❌ 페르소나 이름을 지정해주세요.'));
+      console.log(chalk.gray('사용법: aiwf persona set <페르소나명>'));
+      console.log(chalk.gray('사용 가능한 페르소나: aiwf persona list'));
+      return;
+    }
+
+    try {
+      // 유효한 페르소나인지 확인
+      const validPersonas = ['architect', 'developer', 'reviewer', 'debugger', 'optimizer', 'security', 'documenter'];
+      
+      if (!validPersonas.includes(personaName)) {
+        console.error(chalk.red(`❌ 페르소나 '${personaName}'를 찾을 수 없습니다.`));
+        console.log(chalk.gray('사용 가능한 페르소나: aiwf persona list'));
+        return;
+      }
+
+      // 간단한 페르소나 설정 (파일 기반)
+      const fs = await import('fs/promises');
+      const path = await import('path');
+      const personaDir = path.join(process.cwd(), '.aiwf', 'personas');
+      
+      // 디렉토리 생성
+      await fs.mkdir(personaDir, { recursive: true });
+      
+      // 현재 페르소나 저장
+      const personaConfig = {
+        name: personaName,
+        description: this.getKoreanDescription(personaName),
+        activatedAt: new Date().toISOString()
+      };
+      
+      await fs.writeFile(
+        path.join(personaDir, 'current.json'),
+        JSON.stringify(personaConfig, null, 2)
+      );
+      
+      console.log(chalk.green('🎭 AI 페르소나 활성화 완료'));
+      console.log(chalk.gray('-'.repeat(50)));
+      console.log(`현재 페르소나: ${chalk.yellow(personaName)}`);
+      console.log(`전문 분야: ${this.getKoreanDescription(personaName)}`);
+      console.log(chalk.gray('-'.repeat(50)));
+      console.log(chalk.green('✅ 페르소나가 성공적으로 활성화되었습니다.'));
+      
+    } catch (error) {
+      console.error(chalk.red('❌ 페르소나 전환 중 오류가 발생했습니다:'), error.message);
+      console.error(error.stack);
+    }
+  }
+
+  /**
+   * 페르소나 리셋
+   */
+  async resetPersona() {
+    try {
+      // 기본 페르소나(developer)로 리셋
+      await this.setPersona('developer');
+      console.log(chalk.green('🔄 페르소나가 기본값(developer)으로 리셋되었습니다.'));
+      
+    } catch (error) {
+      console.error(chalk.red('❌ 페르소나 리셋 중 오류가 발생했습니다:'), error.message);
+      console.error(error.stack);
+    }
+  }
+
+  /**
+   * 명령어 실행
+   */
+  async execute(args) {
+    const [subcommand, ...restArgs] = args;
+
+    switch (subcommand) {
+      case 'status':
+        await this.showStatus();
+        break;
+      case 'list':
+        await this.listPersonas();
+        break;
+      case 'set':
+        await this.setPersona(restArgs[0]);
+        break;
+      case 'reset':
+        await this.resetPersona();
+        break;
+      default:
+        this.showHelp();
+        break;
+    }
+  }
+
+  /**
+   * 도움말 표시
+   */
+  showHelp() {
+    console.log(chalk.cyan('🎭 AIWF 페르소나 관리'));
+    console.log(chalk.gray('-'.repeat(50)));
+    console.log('사용법: aiwf persona <명령어> [옵션]');
+    console.log('');
+    console.log('명령어:');
+    console.log('  status              현재 페르소나 상태 표시');
+    console.log('  list                사용 가능한 페르소나 목록');
+    console.log('  set <페르소나명>     특정 페르소나로 전환');
+    console.log('  reset               기본 페르소나로 리셋');
+    console.log('');
+    console.log('예시:');
+    console.log('  aiwf persona status');
+    console.log('  aiwf persona list');
+    console.log('  aiwf persona set architect');
+    console.log('  aiwf persona reset');
+  }
+
+  /**
+   * 한국어 설명 가져오기
+   */
+  getKoreanDescription(persona) {
+    const descriptions = {
+      architect: '시스템 설계 및 아키텍처 전문가',
+      developer: '일반 개발자 (기본값)',
+      reviewer: '코드 리뷰 및 품질 관리 전문가',
+      debugger: '디버깅 및 문제 해결 전문가',
+      optimizer: '성능 최적화 전문가',
+      security: '보안 및 취약점 분석 전문가',
+      devops: 'DevOps 및 인프라 관리 전문가',
+      tester: '테스트 및 QA 전문가',
+      documenter: '문서화 및 기술 작성 전문가',
+      mentor: '멘토링 및 교육 전문가'
+    };
+    
+    return descriptions[persona] || '설명 없음';
+  }
+
+  /**
+   * 한국어 동작 설명 가져오기
+   */
+  getKoreanBehaviors(persona) {
+    const behaviors = {
+      architect: [
+        '큰 그림과 전체 시스템 구조에 집중',
+        '확장성과 유지보수성 우선시',
+        '디자인 패턴과 아키텍처 원칙 적용',
+        '통합 지점과 인터페이스 고려'
+      ],
+      developer: [
+        '실용적이고 효율적인 코드 작성',
+        '베스트 프랙티스 적용',
+        '가독성과 유지보수성 중시'
+      ],
+      reviewer: [
+        '코드 품질과 표준 준수 확인',
+        '잠재적 버그와 개선점 식별',
+        '성능과 보안 측면 검토'
+      ],
+      debugger: [
+        '문제의 근본 원인 분석',
+        '체계적인 디버깅 접근',
+        '재현 가능한 테스트 케이스 생성'
+      ],
+      optimizer: [
+        '성능 병목 지점 식별',
+        '메모리 사용량 최적화',
+        '알고리즘 효율성 개선'
+      ]
+    };
+    
+    return behaviors[persona] || ['기본 동작'];
+  }
+}
+
+export default PersonaCommand;

package/src/lib/backup-manager.js

@@ -0,0 +1,270 @@
+import fs from 'fs/promises';
+import path from 'path';
+import ora from 'ora';
+import chalk from 'chalk';
+import { 
+  TOOL_DIRS, 
+  AIWF_DIRS, 
+  FILES,
+  getBackupDirName as getBackupDirNamePath 
+} from '../utils/paths.js';
+
+let BACKUP_DIR = null;
+
+/**
+ * Generate backup directory name with timestamp
+ * @returns {string} Backup directory name
+ */
+function getBackupDirName() {
+  return getBackupDirNamePath();
+}
+
+/**
+ * Backup a single file with proper naming convention
+ * @param {string} filePath - File to backup
+ * @param {string} backupDir - Backup directory path
+ * @returns {Promise<string|null>} Backup file path or null
+ */
+async function backupFile(filePath, backupDir) {
+  try {
+    const exists = await fs.access(filePath).then(() => true).catch(() => false);
+    if (exists) {
+      await fs.mkdir(backupDir, { recursive: true });
+      const backupPath = `${filePath}.bak`;
+      await fs.copyFile(filePath, backupPath);
+      
+      // Tool-specific backup file naming rules
+      let bakFileName;
+      if (filePath.startsWith(TOOL_DIRS.CLAUDE_COMMANDS + '/')) {
+        // Claude Code command files
+        const relativePath = filePath.substring(TOOL_DIRS.CLAUDE_COMMANDS.length + 1);
+        bakFileName = `claude-commands-aiwf-${relativePath.replace(/\//g, '-')}.bak`;
+      } else if (filePath.startsWith(TOOL_DIRS.GEMINI_PROMPTS + '/')) {
+        // Gemini CLI prompt files
+        const relativePath = filePath.substring(TOOL_DIRS.GEMINI_PROMPTS.length + 1);
+        bakFileName = `gemini-prompts-aiwf-${relativePath.replace(/\//g, '-')}.bak`;
+      } else if (filePath.startsWith(TOOL_DIRS.CURSOR_RULES + '/')) {
+        // Cursor rule files
+        const relativePath = filePath.substring(TOOL_DIRS.CURSOR_RULES.length + 1);
+        bakFileName = `cursor-rules-${relativePath.replace(/\//g, '-')}.bak`;
+      } else if (filePath.startsWith(TOOL_DIRS.WINDSURF_RULES + '/')) {
+        // Windsurf rule files
+        const relativePath = filePath.substring(TOOL_DIRS.WINDSURF_RULES.length + 1);
+        bakFileName = `windsurf-rules-${relativePath.replace(/\//g, '-')}.bak`;
+      } else if (filePath.startsWith(AIWF_DIRS.ROOT + '/')) {
+        // AIWF core files
+        const relativePath = filePath.substring(AIWF_DIRS.ROOT.length + 1);
+        bakFileName = `aiwf-${relativePath.replace(/\//g, '-')}.bak`;
+      } else {
+        // Other files
+        bakFileName = path.basename(filePath) + '.bak';
+      }
+      
+      const destPath = path.join(backupDir, bakFileName);
+      await fs.rename(backupPath, destPath);
+      return destPath;
+    }
+  } catch (error) {
+    // Backup failed, but continue
+  }
+  return null;
+}
+
+/**
+ * Backup commands and documentation files
+ * @param {Object} messages - Localized messages
+ * @param {string} [commandsDir] - Commands directory
+ * @returns {Promise<Array<string>>} Array of backed up file paths
+ */
+async function backupCommandsAndDocs(messages, commandsDir = TOOL_DIRS.CLAUDE_COMMANDS) {
+  if (!BACKUP_DIR) BACKUP_DIR = getBackupDirName();
+  const spinner = ora(messages.backingUp).start();
+  const backedUpFiles = [];
+  await fs.mkdir(BACKUP_DIR, { recursive: true });
+  
+  try {
+    // Files that will be updated and need backup
+    const filesToBackup = Object.values(FILES.CLAUDE_MD);
+    
+    // Backup CLAUDE.md files
+    for (const file of filesToBackup) {
+      const backupPath = await backupFile(file, BACKUP_DIR);
+      if (backupPath) {
+        backedUpFiles.push(backupPath);
+      }
+    }
+    
+    // Backup all command files
+    const commandsExist = await fs.access(commandsDir).then(() => true).catch(() => false);
+    if (commandsExist) {
+      try {
+        const commandFiles = await fs.readdir(commandsDir);
+        for (const file of commandFiles) {
+          const filePath = path.join(commandsDir, file);
+          const stat = await fs.stat(filePath);
+          if (stat.isFile() && file.endsWith('.md')) {
+            const backupPath = await backupFile(filePath, BACKUP_DIR);
+            if (backupPath) {
+              backedUpFiles.push(backupPath);
+            }
+          }
+        }
+      } catch (error) {
+        // Commands directory might be empty or have issues
+      }
+    }
+    
+    // Backup IDE rule files (Cursor)
+    const cursorRulesExist = await fs.access(TOOL_DIRS.CURSOR_RULES).then(() => true).catch(() => false);
+    if (cursorRulesExist) {
+      try {
+        const cursorFiles = await fs.readdir(TOOL_DIRS.CURSOR_RULES);
+        for (const file of cursorFiles) {
+          if (file.endsWith('.mdc')) {
+            const filePath = path.join(TOOL_DIRS.CURSOR_RULES, file);
+            const backupPath = await backupFile(filePath, BACKUP_DIR);
+            if (backupPath) {
+              backedUpFiles.push(backupPath);
+            }
+          }
+        }
+      } catch (error) {
+        // Cursor rules directory might have issues
+      }
+    }
+    
+    // Backup IDE rule files (Windsurf)
+    const windsurfRulesExist = await fs.access(TOOL_DIRS.WINDSURF_RULES).then(() => true).catch(() => false);
+    if (windsurfRulesExist) {
+      try {
+        const windsurfFiles = await fs.readdir(TOOL_DIRS.WINDSURF_RULES);
+        for (const file of windsurfFiles) {
+          if (file.endsWith('.md')) {
+            const filePath = path.join(TOOL_DIRS.WINDSURF_RULES, file);
+            const backupPath = await backupFile(filePath, BACKUP_DIR);
+            if (backupPath) {
+              backedUpFiles.push(backupPath);
+            }
+          }
+        }
+      } catch (error) {
+        // Windsurf rules directory might have issues
+      }
+    }
+    
+    if (backedUpFiles.length > 0) {
+      spinner.succeed(chalk.green(messages.backupComplete.replace('{count}', backedUpFiles.length)));
+    } else {
+      spinner.succeed(chalk.gray(messages.noFilesToBackup));
+    }
+    return backedUpFiles;
+  } catch (error) {
+    spinner.fail(chalk.red(messages.backupFailed));
+    throw error;
+  }
+}
+
+/**
+ * Restore files from backup
+ * @param {Object} spinner - Ora spinner instance
+ * @param {Object} messages - Localized messages
+ * @returns {Promise<void>}
+ */
+async function restoreFromBackup(spinner, messages) {
+  if (!BACKUP_DIR) return;
+  
+  try {
+    spinner.text = messages.restoringBackup;
+    
+    // Get all backup files
+    const backupFiles = await fs.readdir(BACKUP_DIR);
+    let restoredCount = 0;
+    
+    for (const bakFile of backupFiles) {
+      if (bakFile.endsWith('.bak')) {
+        const backupPath = path.join(BACKUP_DIR, bakFile);
+        let originalPath;
+        
+        // Determine original path from backup filename
+        if (bakFile.startsWith('claude-commands-aiwf-')) {
+          const relativePath = bakFile
+            .replace('claude-commands-aiwf-', '')
+            .replace('.bak', '')
+            .replace(/-/g, '/');
+          originalPath = path.join(TOOL_DIRS.CLAUDE_COMMANDS, relativePath);
+        } else if (bakFile.startsWith('gemini-prompts-aiwf-')) {
+          const relativePath = bakFile
+            .replace('gemini-prompts-aiwf-', '')
+            .replace('.bak', '')
+            .replace(/-/g, '/');
+          originalPath = path.join(TOOL_DIRS.GEMINI_PROMPTS, relativePath);
+        } else if (bakFile.startsWith('cursor-rules-')) {
+          const relativePath = bakFile
+            .replace('cursor-rules-', '')
+            .replace('.bak', '')
+            .replace(/-/g, '/');
+          originalPath = path.join(TOOL_DIRS.CURSOR_RULES, relativePath);
+        } else if (bakFile.startsWith('windsurf-rules-')) {
+          const relativePath = bakFile
+            .replace('windsurf-rules-', '')
+            .replace('.bak', '')
+            .replace(/-/g, '/');
+          originalPath = path.join(TOOL_DIRS.WINDSURF_RULES, relativePath);
+        } else if (bakFile.startsWith('aiwf-')) {
+          const relativePath = bakFile
+            .replace('aiwf-', '')
+            .replace('.bak', '')
+            .replace(/-/g, '/');
+          originalPath = path.join(AIWF_DIRS.ROOT, relativePath);
+        } else {
+          // Simple filename.ext.bak format
+          originalPath = bakFile.replace('.bak', '');
+        }
+        
+        try {
+          // Ensure directory exists
+          await fs.mkdir(path.dirname(originalPath), { recursive: true });
+          // Copy backup to original location
+          await fs.copyFile(backupPath, originalPath);
+          restoredCount++;
+        } catch (error) {
+          // Individual file restore failed, continue with others
+        }
+      }
+    }
+    
+    // Clean up backup directory
+    await fs.rm(BACKUP_DIR, { recursive: true, force: true });
+    BACKUP_DIR = null;
+    
+    spinner.text = messages.backupRestored.replace('{count}', restoredCount);
+  } catch (error) {
+    spinner.fail(chalk.red(messages.restoreFailed));
+    throw error;
+  }
+}
+
+/**
+ * Get current backup directory
+ * @returns {string|null} Current backup directory path
+ */
+function getCurrentBackupDir() {
+  return BACKUP_DIR;
+}
+
+/**
+ * Set backup directory
+ * @param {string} dir - Backup directory path
+ */
+function setBackupDir(dir) {
+  BACKUP_DIR = dir;
+}
+
+export {
+  getBackupDirName,
+  backupFile,
+  backupCommandsAndDocs,
+  restoreFromBackup,
+  getCurrentBackupDir,
+  setBackupDir
+};