aiwf 0.3.22 → 0.4.0

package/src/lib/rollback-manager.js

@@ -1,418 +0,0 @@
-import fs from 'fs/promises';
-import path from 'path';
-import ora from 'ora';
-import chalk from 'chalk';
-import { getMessages } from '../utils/messages.js';
-import { getToolDirectory as getToolDirectoryPath } from '../utils/paths.js';
-
-// Backup file patterns for each tool
-const BACKUP_PATTERNS = {
-  claudeCode: /^claude-commands-aiwf-.*\.bak$/,
-  geminiCLI: /^gemini-prompts-aiwf-.*\.bak$/,
-  cursor: /^cursor-rules-.*\.bak$/,
-  windsurf: /^windsurf-rules-.*\.bak$/,
-  aiwf: /^aiwf-.*\.bak$/
-};
-
-// Backup file prefixes
-const BACKUP_PREFIXES = {
-  claudeCode: 'claude-commands-aiwf-',
-  geminiCLI: 'gemini-prompts-aiwf-',
-  cursor: 'cursor-rules-',
-  windsurf: 'windsurf-rules-',
-  aiwf: 'aiwf-'
-};
-
-// Tool names for localization
-const TOOL_NAMES = {
-  ko: {
-    aiwf: 'AIWF 코어 구조',
-    claudeCode: 'Claude Code 명령어',
-    'claude-code': 'Claude Code 명령어',
-    geminiCLI: 'Gemini-CLI 프롬프트',
-    'gemini-cli': 'Gemini-CLI 프롬프트',
-    cursor: 'Cursor IDE 규칙',
-    windsurf: 'Windsurf IDE 규칙'
-  },
-  en: {
-    aiwf: 'AIWF Core Structure',
-    claudeCode: 'Claude Code Commands',
-    'claude-code': 'Claude Code Commands',
-    geminiCLI: 'Gemini-CLI Prompts',
-    'gemini-cli': 'Gemini-CLI Prompts',
-    cursor: 'Cursor IDE Rules',
-    windsurf: 'Windsurf IDE Rules'
-  }
-};
-
-/**
- * Get tool directory path
- * @param {string} tool - Tool name
- * @returns {string|null} Directory path or null
- */
-export function getToolDirectory(tool) {
-  return getToolDirectoryPath(tool);
-}
-
-/**
- * Get localized tool name
- * @param {string} tool - Tool name
- * @param {string} language - Language code
- * @returns {string} Localized tool name
- */
-export function getToolName(tool, language) {
-  return TOOL_NAMES[language]?.[tool] || tool;
-}
-
-/**
- * Restore original path from backup filename
- * @param {string} backupFileName - Backup file name
- * @param {string} tool - Tool name
- * @returns {string|null} Original path or null
- */
-function restoreOriginalPath(backupFileName, tool) {
-  const baseDir = getToolDirectory(tool);
-  if (!baseDir) return null;
-
-  let originalFileName = backupFileName;
-
-  // Remove tool-specific prefix
-  const prefix = BACKUP_PREFIXES[tool];
-  if (prefix && originalFileName.startsWith(prefix)) {
-    originalFileName = originalFileName.substring(prefix.length);
-  }
-
-  // Remove .bak extension
-  if (originalFileName.endsWith('.bak')) {
-    originalFileName = originalFileName.substring(0, originalFileName.length - 4);
-  }
-
-  // Replace hyphens with slashes (subdirectory structure)
-  originalFileName = originalFileName.replace(/-/g, '/');
-
-  return path.join(baseDir, originalFileName);
-}
-
-/**
- * Get backup files for a specific tool
- * @param {string} tool - Tool name
- * @param {string} backupDir - Backup directory path
- * @returns {Promise<Array>} Array of backup file info
- */
-async function getBackupFilesForTool(tool, backupDir) {
-  const toolBackupFiles = [];
-
-  try {
-    const backupFiles = await fs.readdir(backupDir);
-    const pattern = BACKUP_PATTERNS[tool];
-
-    if (pattern) {
-      const matchingFiles = backupFiles.filter(file => pattern.test(file));
-      for (const file of matchingFiles) {
-        toolBackupFiles.push({
-          backupFile: path.join(backupDir, file),
-          originalPath: restoreOriginalPath(file, tool)
-        });
-      }
-    }
-  } catch (error) {
-    // Backup directory doesn't exist or can't be read
-  }
-
-  return toolBackupFiles;
-}
-
-/**
- * Restore a single backup file
- * @param {Object} backup - Backup file info
- * @returns {Promise<boolean>} Success status
- */
-async function restoreBackupFile(backup) {
-  try {
-    // Ensure target directory exists
-    const targetDir = path.dirname(backup.originalPath);
-    await fs.mkdir(targetDir, { recursive: true });
-
-    // Copy backup file to original location
-    await fs.copyFile(backup.backupFile, backup.originalPath);
-    return true;
-  } catch (error) {
-    return false;
-  }
-}
-
-/**
- * Rollback a specific tool
- * @param {string} tool - Tool name
- * @param {string} backupDir - Backup directory path
- * @param {string} language - Language code
- * @returns {Promise<Object>} Rollback result
- */
-export async function rollbackTool(tool, backupDir, language = 'ko') {
-  const messages = getMessages(language);
-  const spinner = ora(
-    language === 'ko' ? `${tool} 도구를 롤백하는 중...` : `Rolling back ${tool}...`
-  ).start();
-
-  try {
-    // 1. Remove tool directory
-    const toolDir = getToolDirectory(tool);
-    if (toolDir) {
-      const dirExists = await fs
-        .access(toolDir)
-        .then(() => true)
-        .catch(() => false);
-      if (dirExists) {
-        await fs.rm(toolDir, { recursive: true, force: true });
-        spinner.text =
-          language === 'ko' ? `${tool} 디렉토리 삭제 완료` : `${tool} directory removed`;
-      }
-    }
-
-    // 2. Restore from backup
-    const backupFiles = await getBackupFilesForTool(tool, backupDir);
-    let restoredCount = 0;
-
-    for (const backup of backupFiles) {
-      const restored = await restoreBackupFile(backup);
-      if (restored) {
-        restoredCount++;
-      }
-    }
-
-    if (restoredCount > 0) {
-      spinner.succeed(
-        chalk.green(
-          language === 'ko'
-            ? `${tool} 롤백 완료 (${restoredCount}개 파일 복원)`
-            : `${tool} rolled back successfully (${restoredCount} files restored)`
-        )
-      );
-      return { success: true, restoredCount };
-    } else {
-      spinner.warn(
-        chalk.yellow(
-          language === 'ko'
-            ? `${tool} 롤백: 복원할 백업 파일이 없음`
-            : `${tool} rollback: No backup files to restore`
-        )
-      );
-      return { success: true, restoredCount: 0 };
-    }
-  } catch (error) {
-    spinner.fail(
-      chalk.red(
-        language === 'ko'
-          ? `${tool} 롤백 실패: ${error.message}`
-          : `Failed to rollback ${tool}: ${error.message}`
-      )
-    );
-    return { success: false, error: error.message };
-  }
-}
-
-/**
- * Enhanced rollback function with backup directory
- * @param {string} tool - Tool name
- * @param {string} backupDir - Backup directory path
- * @param {string} language - Language code
- * @returns {Promise<boolean>} Success status
- */
-export async function rollbackToolEnhanced(tool, backupDir, language = 'ko') {
-  const spinner = ora(`Rolling back ${tool}...`).start();
-
-  try {
-    // Get tool directory mapping
-    const toolDir = getToolDirectory(tool);
-    if (!toolDir) {
-      spinner.fail(`Unknown tool: ${tool}`);
-      return false;
-    }
-
-    // Remove installed directory
-    try {
-      await fs.access(toolDir);
-      await fs.rm(toolDir, { recursive: true, force: true });
-      spinner.text = `Removed ${toolDir}`;
-    } catch (error) {
-      // Directory doesn't exist, skip
-    }
-
-    // Restore from backup if available
-    if (backupDir) {
-      const backupFiles = await getBackupFilesForTool(tool, backupDir);
-      for (const backup of backupFiles) {
-        await restoreBackupFile(backup);
-        spinner.text = `Restored ${backup.originalPath}`;
-      }
-    }
-
-    spinner.succeed(`${tool} rolled back successfully`);
-    return true;
-  } catch (error) {
-    spinner.fail(`Failed to rollback ${tool}: ${error.message}`);
-    return false;
-  }
-}
-
-/**
- * Generate installation report
- * @param {Object} validationResults - Validation results
- * @param {string} language - Language code
- * @param {string} installationType - Installation type
- */
-export function generateInstallationReport(
-  validationResults,
-  language,
-  installationType = 'install'
-) {
-  const messages = getMessages(language);
-
-  // Header
-  console.log(chalk.blue.bold('\n' + '='.repeat(60)));
-  console.log(
-    chalk.blue.bold(
-      language === 'ko'
-        ? '🔍 AIWF 설치 검증 및 리포트'
-        : '🔍 AIWF Installation Validation & Report'
-    )
-  );
-  console.log(chalk.blue.bold('='.repeat(60)));
-
-  // Installation type
-  const installTypeText = {
-    install: language === 'ko' ? '새 설치' : 'Fresh Installation',
-    update: language === 'ko' ? '업데이트' : 'Update',
-    reinstall: language === 'ko' ? '재설치' : 'Reinstallation'
-  };
-  console.log(
-    chalk.gray(
-      `설치 유형 / Installation Type: ${installTypeText[installationType] || installTypeText.install}`
-    )
-  );
-  console.log(chalk.gray(`검증 시간 / Validation Time: ${new Date().toLocaleString()}`));
-
-  // Overall summary
-  const { overall } = validationResults;
-  const statusIcon = overall.success ? '✅' : '❌';
-  const statusColor = overall.success ? chalk.green : chalk.red;
-
-  console.log(
-    statusColor(
-      `\n${statusIcon} 전체 상태 / Overall Status: ${overall.success ? 'PASSED' : 'FAILED'}`
-    )
-  );
-  console.log(chalk.gray(`   검증한 도구 / Tools Checked: ${overall.toolsChecked}`));
-  console.log(chalk.gray(`   성공한 도구 / Tools Passed: ${overall.toolsPassed}`));
-
-  if (overall.toolsFailed > 0) {
-    console.log(chalk.red(`   실패한 도구 / Tools Failed: ${overall.toolsFailed}`));
-    console.log(chalk.red(`   총 이슈 수 / Total Issues: ${overall.totalIssues}`));
-  }
-
-  // Individual tool results
-  console.log(chalk.blue('\n=== 개별 도구 결과 / Individual Tool Results ==='));
-
-  for (const [toolName, result] of Object.entries(validationResults.tools)) {
-    const toolIcon = result.success ? '✅' : '❌';
-    const toolColor = result.success ? chalk.green : chalk.red;
-
-    console.log(toolColor(`\n${toolIcon} ${result.description} (${toolName})`));
-    console.log(chalk.gray(`   디렉토리 / Directory: ${result.baseDir}`));
-    console.log(chalk.gray(`   파일 수 / Files Found: ${result.checks.fileCount}`));
-    console.log(
-      chalk.gray(`   총 크기 / Total Size: ${(result.checks.totalSize / 1024).toFixed(2)} KB`)
-    );
-
-    if (result.checks.issues.length > 0) {
-      console.log(chalk.red(`   이슈 / Issues:`));
-      for (const issue of result.checks.issues) {
-        console.log(chalk.red(`     • ${issue}`));
-      }
-    }
-
-    if (result.checks.requiredFiles.length > 0) {
-      console.log(chalk.gray(`   필수 파일 / Required Files:`));
-      for (const fileCheck of result.checks.requiredFiles) {
-        const fileIcon = fileCheck.valid ? '✅' : '❌';
-        const fileColor = fileCheck.valid ? chalk.gray : chalk.red;
-        console.log(
-          fileColor(
-            `     ${fileIcon} ${fileCheck.file} (${(fileCheck.size / 1024).toFixed(2)} KB)`
-          )
-        );
-      }
-    }
-  }
-
-  // Recommendations
-  console.log(chalk.blue('\n=== 권장사항 / Recommendations ==='));
-  if (overall.success) {
-    console.log(chalk.green('🎉 모든 도구가 올바르게 설치되어 검증되었습니다!'));
-    console.log(chalk.green('🎉 All tools are properly installed and validated!'));
-    console.log(chalk.blue('\n다음 단계 / Next Steps:'));
-    console.log(chalk.white('   1. Claude Code에서 프로젝트를 열어보세요'));
-    console.log(chalk.white('   2. /project:aiwf:initialize 명령어로 프로젝트를 초기화하세요'));
-    console.log(chalk.white('   3. 프로젝트 관리를 시작하세요!'));
-  } else {
-    console.log(chalk.yellow('⚠️  일부 이슈가 발견되었습니다. 위의 세부사항을 확인하세요.'));
-    console.log(chalk.yellow('⚠️  Some issues were found. See details above.'));
-
-    // Solutions for failed tools
-    const failedTools = Object.entries(validationResults.tools)
-      .filter(([_, result]) => !result.success)
-      .map(([tool, _]) => tool);
-
-    if (failedTools.length > 0) {
-      console.log(chalk.blue('\n해결 방안 / Solutions:'));
-      console.log(chalk.yellow('   • 전체 재설치를 시도해보세요'));
-      console.log(chalk.yellow('   • 실패한 도구만 롤백 후 다시 설치하세요'));
-      console.log(chalk.yellow('   • 네트워크 연결을 확인하고 다시 시도하세요'));
-    }
-  }
-
-  console.log(chalk.blue.bold('\n' + '='.repeat(60)));
-}
-
-/**
- * Enhanced installation report generation
- * @param {Object} results - Installation results
- * @param {string} language - Language code
- */
-export function generateInstallationReportEnhanced(results, language) {
-  const msg = getMessages(language);
-
-  console.log(
-    '\n' + chalk.bold(language === 'ko' ? '📋 설치 리포트' : '📋 Installation Report')
-  );
-  console.log('─'.repeat(50));
-
-  if (results.success.length > 0) {
-    console.log(
-      chalk.green(
-        language === 'ko' ? '✅ 성공적으로 설치된 도구:' : '✅ Successfully Installed Tools:'
-      )
-    );
-    results.success.forEach(tool => {
-      console.log(chalk.green(`  ✓ ${getToolName(tool, language)}`));
-    });
-  }
-
-  if (results.failed.length > 0) {
-    console.log(
-      chalk.red(language === 'ko' ? '\n❌ 설치 실패한 도구:' : '\n❌ Failed to Install:')
-    );
-    results.failed.forEach(({ tool, reason }) => {
-      console.log(chalk.red(`  ✗ ${getToolName(tool, language)}: ${reason}`));
-    });
-  }
-
-  if (results.warnings.length > 0) {
-    console.log(chalk.yellow(language === 'ko' ? '\n⚠️ 경고:' : '\n⚠️ Warnings:'));
-    results.warnings.forEach(warning => {
-      console.log(chalk.yellow(`  ⚠ ${warning}`));
-    });
-  }
-
-  console.log('─'.repeat(50));
-}

package/src/lib/state/priority-calculator.js

@@ -1,217 +0,0 @@
-/**
- * AIWF Priority Calculator
- * 태스크 우선순위 계산 및 관리
- */
-
-export class PriorityCalculator {
-  constructor(workflowRules) {
-    this.weights = workflowRules?.priority_weights || {
-      urgency: 0.4,
-      importance: 0.3,
-      dependencies: 0.2,
-      effort: 0.1
-    };
-  }
-
-  /**
-   * 태스크의 긴급도 계산
-   * - 마감일까지 남은 시간
-   * - 차단된 다른 태스크 수
-   * - 마일스톤 내 위치
-   */
-  calculateUrgency(task, stateIndex) {
-    let urgencyScore = 0;
-
-    // 마감일 기반 점수 (0-1)
-    if (task.due_date) {
-      const dueDate = new Date(task.due_date);
-      const now = new Date();
-      const daysUntilDue = Math.ceil((dueDate - now) / (1000 * 60 * 60 * 24));
-      
-      if (daysUntilDue <= 0) urgencyScore += 1.0;      // 이미 지남
-      else if (daysUntilDue <= 1) urgencyScore += 0.9; // 1일 이내
-      else if (daysUntilDue <= 3) urgencyScore += 0.7; // 3일 이내
-      else if (daysUntilDue <= 7) urgencyScore += 0.5; // 1주 이내
-      else urgencyScore += Math.max(0, 1 - daysUntilDue / 30); // 선형 감소
-    }
-
-    // 차단된 태스크 수 기반 점수
-    const blockedByThis = this.countTasksBlockedBy(task.id, stateIndex);
-    urgencyScore += Math.min(blockedByThis * 0.2, 0.5);
-
-    // 스프린트 진행도 기반 점수
-    if (task.sprint_id && stateIndex.sprint_summary[task.sprint_id]) {
-      const sprintProgress = stateIndex.sprint_summary[task.sprint_id].progress || 0;
-      if (sprintProgress > 0.8) urgencyScore += 0.3; // 스프린트 거의 완료
-      else if (sprintProgress > 0.5) urgencyScore += 0.1;
-    }
-
-    return Math.min(urgencyScore, 1.0);
-  }
-
-  /**
-   * 태스크의 중요도 계산
-   * - 비즈니스 가치
-   * - 아키텍처적 영향
-   * - 프로젝트 목표와의 연관성
-   */
-  calculateImportance(task, stateIndex) {
-    let importanceScore = 0;
-
-    // 태스크 타입별 기본 중요도
-    const typeWeights = {
-      'architecture': 0.9,
-      'security': 0.8,
-      'core-feature': 0.7,
-      'bug-fix': 0.6,
-      'enhancement': 0.5,
-      'documentation': 0.3,
-      'refactoring': 0.4,
-      'testing': 0.5
-    };
-
-    importanceScore += typeWeights[task.type] || 0.5;
-
-    // 마일스톤 중요도 반영
-    if (task.milestone_id) {
-      const milestoneId = task.milestone_id;
-      // M01, M02 등에서 숫자 추출하여 초기 마일스톤일수록 높은 점수
-      const milestoneNum = parseInt(milestoneId.replace(/\D/g, ''));
-      if (milestoneNum <= 2) importanceScore += 0.2;
-      else if (milestoneNum <= 5) importanceScore += 0.1;
-    }
-
-    // 태그 기반 중요도 조정
-    if (task.tags) {
-      if (task.tags.includes('critical')) importanceScore += 0.3;
-      if (task.tags.includes('high-priority')) importanceScore += 0.2;
-      if (task.tags.includes('low-priority')) importanceScore -= 0.2;
-    }
-
-    return Math.min(importanceScore, 1.0);
-  }
-
-  /**
-   * 종속성 점수 계산
-   * - 이 태스크에 의존하는 태스크 수
-   * - 이 태스크가 의존하는 태스크의 완료 상태
-   */
-  calculateDependencyScore(task, stateIndex) {
-    let dependencyScore = 0;
-
-    // 이 태스크를 차단하는 미완료 종속성
-    const blockingDependencies = task.dependencies?.filter(depId => {
-      const depTask = stateIndex.tasks[depId];
-      return depTask && depTask.status !== 'completed';
-    }) || [];
-
-    if (blockingDependencies.length === 0) {
-      dependencyScore += 0.5; // 차단 요소 없음
-    } else {
-      dependencyScore -= blockingDependencies.length * 0.2; // 차단 요소마다 감점
-    }
-
-    // 이 태스크에 의존하는 태스크 수
-    const dependentCount = this.countTasksBlockedBy(task.id, stateIndex);
-    dependencyScore += Math.min(dependentCount * 0.15, 0.5);
-
-    return Math.max(0, Math.min(dependencyScore, 1.0));
-  }
-
-  /**
-   * 노력 점수 계산 (낮을수록 높은 점수)
-   * - 예상 작업 시간
-   * - 복잡도
-   * - 필요한 리소스
-   */
-  calculateEffortScore(task) {
-    let effortScore = 1.0; // 기본값: 쉬운 태스크
-
-    // 예상 시간 기반 점수
-    if (task.estimated_hours) {
-      if (task.estimated_hours <= 1) effortScore = 1.0;      // 1시간 이하
-      else if (task.estimated_hours <= 4) effortScore = 0.8; // 4시간 이하
-      else if (task.estimated_hours <= 8) effortScore = 0.6; // 1일 이하
-      else if (task.estimated_hours <= 16) effortScore = 0.4; // 2일 이하
-      else effortScore = 0.2; // 2일 초과
-    }
-
-    // 복잡도 기반 조정
-    if (task.complexity) {
-      const complexityWeights = {
-        'low': 1.0,
-        'medium': 0.7,
-        'high': 0.4,
-        'very-high': 0.2
-      };
-      effortScore *= complexityWeights[task.complexity] || 0.7;
-    }
-
-    // 태그 기반 조정 (간단한 태스크들)
-    if (task.tags) {
-      if (task.tags.includes('quick-fix')) effortScore += 0.2;
-      if (task.tags.includes('research-heavy')) effortScore -= 0.3;
-    }
-
-    return Math.max(0.1, Math.min(effortScore, 1.0));
-  }
-
-  /**
-   * 전체 우선순위 점수 계산
-   */
-  calculatePriority(task, stateIndex) {
-    const urgency = this.calculateUrgency(task, stateIndex);
-    const importance = this.calculateImportance(task, stateIndex);
-    const dependency = this.calculateDependencyScore(task, stateIndex);
-    const effort = this.calculateEffortScore(task);
-
-    const priority = (
-      urgency * this.weights.urgency +
-      importance * this.weights.importance +
-      dependency * this.weights.dependencies +
-      effort * this.weights.effort
-    );
-
-    return {
-      total: Math.round(priority * 100) / 100,
-      breakdown: {
-        urgency: Math.round(urgency * 100) / 100,
-        importance: Math.round(importance * 100) / 100,
-        dependency: Math.round(dependency * 100) / 100,
-        effort: Math.round(effort * 100) / 100
-      }
-    };
-  }
-
-  /**
-   * 특정 태스크에 의해 차단된 태스크 수 계산
-   */
-  countTasksBlockedBy(taskId, stateIndex) {
-    let count = 0;
-    for (const [, task] of Object.entries(stateIndex.tasks)) {
-      if (task.dependencies?.includes(taskId) && task.status !== 'completed') {
-        count++;
-      }
-    }
-    return count;
-  }
-
-  /**
-   * 모든 태스크의 우선순위 재계산
-   */
-  recalculateAllPriorities(stateIndex) {
-    const updatedTasks = {};
-    
-    for (const [taskId, task] of Object.entries(stateIndex.tasks)) {
-      const priorityData = this.calculatePriority(task, stateIndex);
-      updatedTasks[taskId] = {
-        ...task,
-        priority_score: priorityData.total,
-        priority_breakdown: priorityData.breakdown,
-        last_priority_update: new Date().toISOString()
-      };
-    }
-
-    return updatedTasks;
-  }
-}