aiwf 0.3.18 → 0.3.19

package/src/cli/index.js

@@ -555,6 +555,69 @@ checkpoint
     }
   });
 
+checkpoint
+  .command('add [type]')
+  .alias('create')
+  .description('Create a checkpoint / 체크포인트 생성')
+  .option('-m, --message <text>', 'Description for the checkpoint / 체크포인트 설명')
+  .option('--meta <json>', 'Additional metadata as JSON / 추가 메타데이터(JSON)')
+  .option('--cleanup <n>', 'Keep only last N checkpoints after creating / 생성 후 최근 N개만 보존')
+  .action(async (type, options) => {
+    try {
+      const fs = await import('fs/promises');
+      const path = await import('path');
+      let currentDir = process.cwd();
+
+      // 프로젝트 루트 탐색 (.aiwf 기준)
+      while (currentDir !== path.parse(currentDir).root) {
+        try {
+          await fs.access(path.join(currentDir, '.aiwf'));
+          break;
+        } catch {
+          currentDir = path.dirname(currentDir);
+        }
+      }
+
+      const manager = new CheckpointManager(currentDir);
+      await manager.initialize();
+
+      // 메타데이터 구성
+      const metadata = {};
+      if (options.message) metadata.message = options.message;
+      if (options.meta) {
+        try {
+          const parsed = JSON.parse(options.meta);
+          Object.assign(metadata, parsed);
+        } catch (e) {
+          console.error(chalk.red('❌ --meta 값이 올바른 JSON 형식이 아닙니다.'));
+          process.exit(1);
+        }
+      }
+
+      const cpType = type || 'manual';
+      const checkpointId = await manager.createCheckpoint(cpType, metadata);
+
+      console.log(chalk.green('✅ 체크포인트 생성 완료!'));
+      console.log(`  ID: ${chalk.cyan(checkpointId)}  유형: ${chalk.yellow(cpType)}`);
+      if (metadata.message) {
+        console.log(`  메시지: ${chalk.blue(metadata.message)}`);
+      }
+
+      if (options.cleanup) {
+        const keep = parseInt(options.cleanup, 10);
+        if (!Number.isNaN(keep) && keep > 0) {
+          await manager.cleanup(keep);
+          console.log(`🧹 최근 ${chalk.cyan(keep)}개만 보존하도록 정리했습니다.`);
+        } else {
+          console.log(chalk.yellow('⚠️ --cleanup 값이 유효하지 않아 정리를 건너뜁니다. 정수로 입력하세요.'));
+        }
+      }
+    } catch (error) {
+      console.error(chalk.red('❌ 체크포인트 생성 실패:'), error.message);
+      process.exit(1);
+    }
+  });
+
 checkpoint
   .command('restore <checkpointId>')
   .description('Restore from checkpoint / 체크포인트에서 복구')
@@ -632,6 +695,281 @@ checkpoint
     }
   });
 
+// 체크포인트 리포트 생성
+checkpoint
+  .command('report')
+  .description('Generate progress report / 진행 상황 리포트 생성')
+  .action(async () => {
+    try {
+      const fs = await import('fs/promises');
+      const path = await import('path');
+      let currentDir = process.cwd();
+      
+      while (currentDir !== path.parse(currentDir).root) {
+        try {
+          await fs.access(path.join(currentDir, '.aiwf'));
+          break;
+        } catch {
+          currentDir = path.dirname(currentDir);
+        }
+      }
+      
+      const manager = new CheckpointManager(currentDir);
+      await manager.loadState();
+      
+      console.log(chalk.blue('📊 진행 상황 리포트 생성 중...'));
+      console.log('');
+      
+      const report = await manager.generateProgressReport();
+      
+      console.log(chalk.bold('🎯 YOLO 세션 리포트'));
+      console.log(''.padEnd(50, '='));
+      console.log('');
+      
+      // 세션 정보
+      console.log(chalk.bold('📋 세션 정보:'));
+      console.log(`  ID: ${chalk.cyan(report.session.id)}`);
+      console.log(`  시작: ${chalk.gray(new Date(report.session.started).toLocaleString())}`);
+      console.log(`  스프린트: ${chalk.blue(report.session.sprint || 'N/A')}`);
+      console.log('');
+      
+      // 진행 상황
+      console.log(chalk.bold('📈 진행 상황:'));
+      console.log(`  완료: ${chalk.green(report.progress.completed)}개`);
+      console.log(`  실패: ${chalk.red(report.progress.failed)}개`);
+      console.log(`  건너뜀: ${chalk.yellow(report.progress.skipped)}개`);
+      console.log('');
+      
+      // 성능 지표
+      console.log(chalk.bold('⏱️ 성능 지표:'));
+      console.log(`  총 시간: ${chalk.blue(report.performance.total_time)}`);
+      console.log(`  평균 태스크 시간: ${chalk.blue(report.performance.avg_task_time)}`);
+      console.log(`  성공률: ${chalk.green(report.performance.success_rate)}`);
+      
+    } catch (error) {
+      console.error(chalk.red('❌ 리포트 생성 실패:'), error.message);
+      process.exit(1);
+    }
+  });
+
+// 체크포인트 정리
+checkpoint
+  .command('clean')
+  .description('Clean old checkpoints / 오래된 체크포인트 정리')
+  .option('--keep <n>', 'Number of checkpoints to keep / 유지할 체크포인트 수', '10')
+  .option('--dry-run', 'Preview without deletion / 실제 삭제 없이 미리보기')
+  .action(async (options) => {
+    try {
+      const fs = await import('fs/promises');
+      const path = await import('path');
+      let currentDir = process.cwd();
+      
+      while (currentDir !== path.parse(currentDir).root) {
+        try {
+          await fs.access(path.join(currentDir, '.aiwf'));
+          break;
+        } catch {
+          currentDir = path.dirname(currentDir);
+        }
+      }
+      
+      const manager = new CheckpointManager(currentDir);
+      const keepLast = parseInt(options.keep);
+      
+      console.log(chalk.blue(`🧹 체크포인트 정리 중... (최근 ${keepLast}개 유지)`));
+      
+      if (options.dryRun) {
+        console.log(chalk.yellow('🔍 드라이런 모드: 실제 삭제는 수행하지 않습니다.'));
+        const checkpoints = await manager.listCheckpoints();
+        if (checkpoints.length <= keepLast) {
+          console.log(chalk.green('✅ 정리할 체크포인트가 없습니다.'));
+        } else {
+          const toDelete = checkpoints.slice(keepLast);
+          console.log(chalk.yellow(`삭제 예정 체크포인트 (${toDelete.length}개):`));
+          for (const cp of toDelete) {
+            console.log(`  ${chalk.red('🗑️')} ${chalk.cyan(cp.id)}`);
+          }
+        }
+      } else {
+        await manager.cleanup(keepLast);
+        console.log(chalk.green('✅ 체크포인트 정리 완료!'));
+      }
+      
+    } catch (error) {
+      console.error(chalk.red('❌ 체크포인트 정리 실패:'), error.message);
+      process.exit(1);
+    }
+  });
+
+// Engineering Guard commands (오버엔지니어링 방지)
+const guard = program.command('guard');
+guard.description('Engineering guard for overengineering prevention / 오버엔지니어링 방지 가드');
+
+guard
+  .command('check [path]')
+  .description('Check project complexity / 프로젝트 복잡도 검사')
+  .option('--config <path>', 'YOLO config file path / YOLO 설정 파일 경로', '.aiwf/yolo-config.yaml')
+  .action(async (targetPath, options) => {
+    try {
+      const { EngineeringGuard } = await import('../utils/engineering-guard.js');
+      const guard = new EngineeringGuard();
+      
+      // 설정 파일 로드
+      await guard.loadConfig(options.config);
+      
+      const checkPath = targetPath || process.cwd();
+      console.log(chalk.blue(`🔍 복잡도 검사 중: ${checkPath}`));
+      console.log('');
+      
+      const report = await guard.checkProject(checkPath);
+      
+      // 결과 출력
+      console.log(chalk.bold('📊 복잡도 분석 결과:'));
+      console.log(`  총 위반사항: ${chalk.yellow(report.summary.total_violations)}`);
+      console.log(`  높은 심각도: ${chalk.red(report.summary.high_severity)}`);
+      console.log(`  중간 심각도: ${chalk.yellow(report.summary.medium_severity)}`);
+      console.log(`  경고사항: ${chalk.blue(report.summary.warnings)}`);
+      console.log('');
+      
+      if (report.violations && report.violations.length > 0) {
+        console.log(chalk.bold('🚨 위반사항:'));
+        for (const violation of report.violations.slice(0, 10)) {
+          const icon = violation.severity === 'high' ? '❌' : 
+                      violation.severity === 'medium' ? '⚠️' : '💡';
+          console.log(`  ${icon} ${chalk.cyan(violation.type)}: ${violation.file || violation.message}`);
+          if (violation.details) {
+            console.log(`      ${chalk.gray(violation.details)}`);
+          }
+        }
+        console.log('');
+      }
+      
+      if (report.recommendations && report.recommendations.length > 0) {
+        console.log(chalk.bold('💡 권장사항:'));
+        for (const rec of report.recommendations) {
+          console.log(`  • ${chalk.green(rec)}`);
+        }
+        console.log('');
+      }
+      
+      // 통과/실패 판정
+      if (report.passed) {
+        console.log(chalk.green('✅ 복잡도 기준 통과'));
+      } else {
+        console.log(chalk.red('❌ 복잡도 기준 초과 - 리팩토링 필요'));
+      }
+      
+    } catch (error) {
+      console.error(chalk.red('❌ 복잡도 검사 실패:'), error.message);
+      process.exit(1);
+    }
+  });
+
+guard
+  .command('quick [path]')
+  .description('Quick complexity check / 빠른 복잡도 체크')
+  .action(async (targetPath) => {
+    try {
+      const { quickCheck } = await import('../utils/engineering-guard.js');
+      
+      const checkPath = targetPath || process.cwd();
+      console.log(chalk.blue(`⚡ 빠른 복잡도 체크: ${checkPath}`));
+      
+      const report = await quickCheck(checkPath);
+      
+      if (report.summary.high_severity > 0) {
+        console.log(chalk.red('⚠️ 오버엔지니어링 위험 감지!'));
+        console.log('권장사항:', report.recommendations.join(', '));
+      } else {
+        console.log(chalk.green('✅ 복잡도 양호'));
+      }
+      
+    } catch (error) {
+      console.error(chalk.red('❌ 빠른 체크 실패:'), error.message);
+      process.exit(1);
+    }
+  });
+
+guard
+  .command('init')
+  .description('Initialize YOLO config with guard settings / YOLO 설정 초기화')
+  .action(async () => {
+    try {
+      const fs = await import('fs/promises');
+      const path = await import('path');
+      const yaml = await import('js-yaml');
+      
+      const configPath = path.join(process.cwd(), '.aiwf', 'yolo-config.yaml');
+      
+      // 기본 설정 생성
+      const defaultConfig = {
+        engineering_level: 'minimal',
+        focus_rules: ['requirement_first', 'simple_solution', 'no_gold_plating', 'stay_on_track'],
+        overengineering_prevention: {
+          max_file_lines: 300,
+          max_function_lines: 50,
+          max_nesting_depth: 4,
+          max_abstraction_layers: 3,
+          limit_design_patterns: true,
+          no_future_proofing: true,
+          enforce_yagni: true
+        }
+      };
+      
+      // .aiwf 디렉토리 생성
+      await fs.mkdir(path.dirname(configPath), { recursive: true });
+      
+      // 설정 파일 쓰기
+      await fs.writeFile(configPath, yaml.dump(defaultConfig), 'utf-8');
+      
+      console.log(chalk.green('✅ YOLO 설정 파일 생성 완료!'));
+      console.log(`  경로: ${chalk.cyan(configPath)}`);
+      console.log('');
+      console.log(chalk.bold('🛡️ 오버엔지니어링 방지 설정:'));
+      console.log(`  파일 크기 제한: ${chalk.yellow('300')}줄`);
+      console.log(`  함수 크기 제한: ${chalk.yellow('50')}줄`);
+      console.log(`  중첩 깊이 제한: ${chalk.yellow('4')}레벨`);
+      console.log(`  YAGNI 원칙: ${chalk.green('적용')}`);
+      
+    } catch (error) {
+      console.error(chalk.red('❌ 설정 초기화 실패:'), error.message);
+      process.exit(1);
+    }
+  });
+
+guard
+  .command('feedback [area]')
+  .description('Get engineering feedback for area / 특정 영역 피드백 받기')
+  .action(async (area) => {
+    try {
+      const { EngineeringGuard } = await import('../utils/engineering-guard.js');
+      const guard = new EngineeringGuard();
+      
+      // 설정 파일 로드 시도
+      await guard.loadConfig('.aiwf/yolo-config.yaml');
+      
+      const targetArea = area || 'current_task_area';
+      console.log(chalk.blue(`💡 엔지니어링 피드백 제공: ${targetArea}`));
+      console.log('');
+      
+      const feedback = await guard.provideFeedback(targetArea);
+      
+      if (feedback && feedback.length > 0) {
+        for (const item of feedback) {
+          const icon = item.level === 'error' ? '❌' :
+                      item.level === 'warning' ? '⚠️' : '💡';
+          console.log(`${icon} ${item.message}`);
+        }
+      } else {
+        console.log(chalk.green('✅ 현재 영역은 복잡도 기준을 만족합니다.'));
+      }
+      
+    } catch (error) {
+      console.error(chalk.red('❌ 피드백 생성 실패:'), error.message);
+      process.exit(1);
+    }
+  });
+
 // GitHub integration commands
 const github = program.command('github');
 github.description('GitHub integration / GitHub 통합');

package/src/lib/backup-manager.js

@@ -5,8 +5,7 @@ import chalk from 'chalk';
 import { 
   TOOL_DIRS, 
   AIWF_DIRS, 
-  FILES,
-  getBackupDirName as getBackupDirNamePath 
+  FILES
 } from '../utils/paths.js';
 
 let BACKUP_DIR = null;
@@ -16,7 +15,9 @@ let BACKUP_DIR = null;
  * @returns {string} Backup directory name
  */
 function getBackupDirName() {
-  return getBackupDirNamePath();
+  const now = new Date();
+  const timestamp = now.toISOString().replace(/[:.]/g, '-').slice(0, -5);
+  return `backup-${timestamp}`;
 }
 
 /**

package/src/lib/installer.js

@@ -34,7 +34,6 @@ import {
 import {
   FILES,
   TOOL_DIRS,
-  TEMP_DIRS,
   AIWF_DIRS,
   BASE_DIRS,
   getAllAiwfDirectories,
@@ -507,14 +506,112 @@ async function updateCommands(languagePath, spinner, msg, debugLog) {
   }
 }
 
+/**
+ * Check if tool directories exist and handle them
+ * @param {Object} spinner - Ora spinner instance
+ * @param {Object} msg - Localized messages
+ * @param {boolean} debugLog - Debug mode flag
+ * @returns {Promise<Object>} Directory status info
+ */
+async function checkAndHandleExistingToolDirs(spinner, msg, debugLog) {
+  const toolDirStatus = {
+    cursor: {
+      exists: false,
+      hadFiles: false,
+      backedUp: false
+    },
+    windsurf: {
+      exists: false,
+      hadFiles: false,
+      backedUp: false
+    }
+  };
+
+  // Check Cursor directory
+  try {
+    await fs.access(TOOL_DIRS.CURSOR_RULES);
+    toolDirStatus.cursor.exists = true;
+    
+    const cursorFiles = await fs.readdir(TOOL_DIRS.CURSOR_RULES);
+    const mdcFiles = cursorFiles.filter(file => file.endsWith('.mdc'));
+    
+    if (mdcFiles.length > 0) {
+      toolDirStatus.cursor.hadFiles = true;
+      logWithSpinner(spinner, `${msg.foundExistingCursor} (${mdcFiles.length} files)`, debugLog);
+      
+      // Backup existing files
+      logWithSpinner(spinner, msg.backingUpToolFiles, debugLog);
+      const backupDir = path.join(TOOL_DIRS.CURSOR_RULES, `backup_${Date.now()}`);
+      await fs.mkdir(backupDir, { recursive: true });
+      
+      for (const file of mdcFiles) {
+        const srcPath = path.join(TOOL_DIRS.CURSOR_RULES, file);
+        const backupPath = path.join(backupDir, file);
+        await fs.copyFile(srcPath, backupPath);
+      }
+      
+      toolDirStatus.cursor.backedUp = true;
+      logWithSpinner(spinner, `${msg.toolBackupCreated}: ${backupDir}`, debugLog);
+      
+      // Remove existing files
+      for (const file of mdcFiles) {
+        await fs.unlink(path.join(TOOL_DIRS.CURSOR_RULES, file));
+      }
+    }
+  } catch (error) {
+    // Directory doesn't exist, that's fine
+    logWithSpinner(spinner, `Cursor rules directory not found, will create new`, debugLog);
+  }
+
+  // Check Windsurf directory
+  try {
+    await fs.access(TOOL_DIRS.WINDSURF_RULES);
+    toolDirStatus.windsurf.exists = true;
+    
+    const windsurfFiles = await fs.readdir(TOOL_DIRS.WINDSURF_RULES);
+    const mdFiles = windsurfFiles.filter(file => file.endsWith('.md'));
+    
+    if (mdFiles.length > 0) {
+      toolDirStatus.windsurf.hadFiles = true;
+      logWithSpinner(spinner, `${msg.foundExistingWindsurf} (${mdFiles.length} files)`, debugLog);
+      
+      // Backup existing files
+      logWithSpinner(spinner, msg.backingUpToolFiles, debugLog);
+      const backupDir = path.join(TOOL_DIRS.WINDSURF_RULES, `backup_${Date.now()}`);
+      await fs.mkdir(backupDir, { recursive: true });
+      
+      for (const file of mdFiles) {
+        const srcPath = path.join(TOOL_DIRS.WINDSURF_RULES, file);
+        const backupPath = path.join(backupDir, file);
+        await fs.copyFile(srcPath, backupPath);
+      }
+      
+      toolDirStatus.windsurf.backedUp = true;
+      logWithSpinner(spinner, `${msg.toolBackupCreated}: ${backupDir}`, debugLog);
+      
+      // Remove existing files
+      for (const file of mdFiles) {
+        await fs.unlink(path.join(TOOL_DIRS.WINDSURF_RULES, file));
+      }
+    }
+  } catch (error) {
+    // Directory doesn't exist, that's fine
+    logWithSpinner(spinner, `Windsurf rules directory not found, will create new`, debugLog);
+  }
+
+  return toolDirStatus;
+}
+
 /**
  * Download and process rules
  * @param {Object} spinner - Ora spinner instance
-{{ ... }}
  * @param {Object} msg - Localized messages
  * @param {boolean} debugLog - Debug mode flag
  */
 async function downloadAndProcessRules(spinner, msg, debugLog) {
+  // Check and handle existing tool directories first
+  logWithSpinner(spinner, msg.checkingExistingTools, debugLog);
+  const toolDirStatus = await checkAndHandleExistingToolDirs(spinner, msg, debugLog);
   // Try to download from GitHub first, fallback to local files
   const tmpRulesGlobal = path.join(os.tmpdir(), 'aiwf-rules-global');
   const tmpRulesManual = path.join(os.tmpdir(), 'aiwf-rules-manual');
@@ -670,6 +767,32 @@ async function downloadAndProcessRules(spinner, msg, debugLog) {
   } catch (error) {
     logWithSpinner(spinner, `No rules/manual directory found`, debugLog);
   }
+
+  // Success message for tool rules installation
+  logWithSpinner(spinner, msg.toolRulesInstalled, debugLog);
+
+  // Display installation results for tool directories
+  if (toolDirStatus.cursor.backedUp || toolDirStatus.windsurf.backedUp) {
+    console.log(chalk.cyan(`\n📂 Tool Directory Installation Results:`));
+    
+    if (toolDirStatus.cursor.backedUp) {
+      console.log(chalk.yellow(`   • Cursor: Existing rules backed up and replaced`));
+    } else if (toolDirStatus.cursor.exists) {
+      console.log(chalk.green(`   • Cursor: Rules installed (directory was empty)`));
+    } else {
+      console.log(chalk.green(`   • Cursor: Rules installed (new directory)`));
+    }
+    
+    if (toolDirStatus.windsurf.backedUp) {
+      console.log(chalk.yellow(`   • Windsurf: Existing rules backed up and replaced`));
+    } else if (toolDirStatus.windsurf.exists) {
+      console.log(chalk.green(`   • Windsurf: Rules installed (directory was empty)`));
+    } else {
+      console.log(chalk.green(`   • Windsurf: Rules installed (new directory)`));
+    }
+  }
+
+  return toolDirStatus;
 }
 
 /**
@@ -819,7 +942,7 @@ export async function installAIWF(options = {}) {
     await updateCommands(languagePath, spinner, msg, debugLog);
 
     // Download and process rules
-    await downloadAndProcessRules(spinner, msg, debugLog);
+    const toolDirStatus = await downloadAndProcessRules(spinner, msg, debugLog);
 
     // Restore project files if needed
     if (projectBackupDir) {