aiwf 0.3.18 → 0.3.20

package/src/cli/index.js

@@ -4,16 +4,9 @@ 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';
 import { addTaskToSprint } from '../commands/sprint-task.js';
-import CompressCommand from '../commands/compress.js';
-import TokenCommand from '../commands/token.js';
-import EvaluateCommand from '../commands/evaluate.js';
-import { createProject } from '../commands/create-project.js';
 import StateCommand from '../commands/state.js';
 import { createIndependentSprint } from '../commands/sprint-independent.js';
-import { CheckpointManager } from '../utils/checkpoint-manager.js';
 import { createYoloConfig, createInteractiveYoloConfig, showYoloConfig } from '../commands/yolo-config.js';
 
 // Parse version from package.json
@@ -50,94 +43,7 @@ program
   });
 
 // 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();
-    }
-  });
+// (removed) cache command group
 
 // Language management commands
 const lang = program.command('lang');
@@ -171,45 +77,7 @@ lang
     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();
-  });
+// (removed) persona command group
 
 // Sprint task management command
 program
@@ -225,125 +93,14 @@ program
     }
   });
 
-// Create project command
-program
-  .command('create-project')
-  .alias('create')
-  .description('Create a new AIWF project / 새 AIWF 프로젝트 생성')
-  .action(async () => {
-    try {
-      await createProject();
-    } catch (error) {
-      console.error(chalk.red(`오류: ${error.message}`));
-      process.exit(1);
-    }
-  });
+// (removed) create-project command
 
-// Context compression command
-program
-  .command('compress [mode] [path]')
-  .description('Compress context for token optimization / 토큰 최적화를 위한 컨텍스트 압축')
-  .option('--persona, -p', 'Enable persona-aware compression / 페르소나 인식 압축 활성화')
-  .action(async (mode, path, options) => {
-    const compressCmd = new CompressCommand();
-    const args = [];
-    if (mode) args.push(mode);
-    if (path) args.push(path);
-    if (options.persona) args.push('--persona');
-    await compressCmd.execute(args);
-  });
+// (removed) compress command
 
 
-// Token tracking commands
-const token = program.command('token');
-token.description('Manage token usage tracking / 토큰 사용량 추적 관리');
+// (removed) token command group
 
-token
-  .command('status')
-  .alias('s')
-  .description('Show token usage status / 토큰 사용 현황 표시')
-  .action(async () => {
-    const tokenCmd = new TokenCommand();
-    await tokenCmd.execute(['status']);
-  });
-
-token
-  .command('report [period]')
-  .description('Generate usage report / 사용 리포트 생성')
-  .action(async (period) => {
-    const tokenCmd = new TokenCommand();
-    const args = ['report'];
-    if (period) args.push(period);
-    await tokenCmd.execute(args);
-  });
-
-token
-  .command('track <input> <output>')
-  .description('Manually track token usage / 토큰 사용량 수동 기록')
-  .action(async (input, output) => {
-    const tokenCmd = new TokenCommand();
-    await tokenCmd.execute(['track', input, output]);
-  });
-
-token
-  .command('limit <type> <value>')
-  .description('Set usage limits / 사용 한도 설정')
-  .action(async (type, value) => {
-    const tokenCmd = new TokenCommand();
-    await tokenCmd.execute(['limit', type, value]);
-  });
-
-token
-  .command('reset')
-  .description('Reset tracking data / 추적 데이터 초기화')
-  .action(async () => {
-    const tokenCmd = new TokenCommand();
-    await tokenCmd.execute(['reset']);
-  });
-
-// Evaluation commands
-const evaluate = program.command('evaluate');
-evaluate.description('Evaluate AI responses and code quality / AI 응답 및 코드 품질 평가');
-
-evaluate
-  .command('response <file>')
-  .description('Evaluate AI response quality / AI 응답 품질 평가')
-  .action(async (file) => {
-    const evaluateCmd = new EvaluateCommand();
-    await evaluateCmd.execute(['response', file]);
-  });
-
-evaluate
-  .command('code <file>')
-  .description('Evaluate code quality / 코드 품질 평가')
-  .action(async (file) => {
-    const evaluateCmd = new EvaluateCommand();
-    await evaluateCmd.execute(['code', file]);
-  });
-
-evaluate
-  .command('persona <file> <persona>')
-  .description('Evaluate persona appropriateness / 페르소나 적합성 평가')
-  .action(async (file, persona) => {
-    const evaluateCmd = new EvaluateCommand();
-    await evaluateCmd.execute(['persona', file, persona]);
-  });
-
-evaluate
-  .command('report')
-  .description('Generate evaluation report / 평가 리포트 생성')
-  .action(async () => {
-    const evaluateCmd = new EvaluateCommand();
-    await evaluateCmd.execute(['report']);
-  });
-
-evaluate
-  .command('criteria')
-  .description('Show evaluation criteria / 평가 기준 표시')
-  .action(async () => {
-    const evaluateCmd = new EvaluateCommand();
-    await evaluateCmd.execute(['criteria']);
-  });
+// (removed) evaluate command group
 
 // State management commands
 const state = program.command('state');
@@ -503,131 +260,173 @@ yoloConfig
     }
   });
 
-// Checkpoint management commands (YOLO recovery)
-const checkpoint = program.command('checkpoint');
-checkpoint.description('YOLO checkpoint management / YOLO 체크포인트 관리');
+// (removed) checkpoint command group
 
-checkpoint
-  .command('list')
-  .alias('ls')
-  .description('List available checkpoints / 사용 가능한 체크포인트 목록')
-  .option('--limit <n>', 'Limit number of checkpoints / 체크포인트 수 제한', '10')
-  .action(async (options) => {
+// 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 fs = await import('fs/promises');
-      const path = await import('path');
-      let currentDir = process.cwd();
+      const { EngineeringGuard } = await import('../utils/engineering-guard.js');
+      const guard = new EngineeringGuard();
       
-      while (currentDir !== path.parse(currentDir).root) {
-        try {
-          await fs.access(path.join(currentDir, '.aiwf'));
-          break;
-        } catch {
-          currentDir = path.dirname(currentDir);
-        }
-      }
+      // 설정 파일 로드
+      await guard.loadConfig(options.config);
       
-      const manager = new CheckpointManager(currentDir);
-      const checkpoints = await manager.listCheckpoints();
+      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.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 (checkpoints.length === 0) {
-        console.log(chalk.yellow('📭 체크포인트가 없습니다.'));
-        return;
+      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('');
       }
       
-      const limit = parseInt(options.limit);
-      const limitedCheckpoints = checkpoints.slice(0, limit);
-      
-      for (const cp of limitedCheckpoints) {
-        const typeIcon = cp.type === 'session_start' ? '🚀' :
-                        cp.type === 'task_complete' ? '✅' : '🔄';
-        console.log(`${typeIcon} ${chalk.cyan(cp.id)} - ${chalk.yellow(cp.type)}`);
-        console.log(`    태스크: ${chalk.blue(cp.tasks_completed)}개 완료`);
+      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);
+      console.error(chalk.red('❌ 복잡도 검사 실패:'), error.message);
       process.exit(1);
     }
   });
 
-checkpoint
-  .command('restore <checkpointId>')
-  .description('Restore from checkpoint / 체크포인트에서 복구')
-  .action(async (checkpointId) => {
+guard
+  .command('quick [path]')
+  .description('Quick complexity check / 빠른 복잡도 체크')
+  .action(async (targetPath) => {
     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 { quickCheck } = await import('../utils/engineering-guard.js');
       
-      const manager = new CheckpointManager(currentDir);
-      await manager.initialize();
+      const checkPath = targetPath || process.cwd();
+      console.log(chalk.blue(`⚡ 빠른 복잡도 체크: ${checkPath}`));
       
-      console.log(chalk.blue(`🔄 체크포인트 ${checkpointId}에서 복구 중...`));
+      const report = await quickCheck(checkPath);
       
-      const result = await manager.restoreFromCheckpoint(checkpointId);
-      
-      if (result.success) {
-        console.log(chalk.green('✅ 체크포인트 복구 성공!'));
-        console.log(`  세션 ID: ${chalk.cyan(result.checkpoint.state_snapshot.session_id)}`);
-        console.log(`  스프린트: ${chalk.blue(result.checkpoint.state_snapshot.sprint_id || 'N/A')}`);
-        console.log('');
-        console.log(chalk.green('🚀 복구 완료! YOLO 모드를 다시 실행할 수 있습니다.'));
+      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);
+      console.error(chalk.red('❌ 빠른 체크 실패:'), error.message);
       process.exit(1);
     }
   });
 
-checkpoint
-  .command('status')
-  .description('Show current YOLO session status / 현재 YOLO 세션 상태')
+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');
-      let currentDir = process.cwd();
+      const yaml = await import('js-yaml');
       
-      while (currentDir !== path.parse(currentDir).root) {
-        try {
-          await fs.access(path.join(currentDir, '.aiwf'));
-          break;
-        } catch {
-          currentDir = path.dirname(currentDir);
+      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();
       
-      const manager = new CheckpointManager(currentDir);
-      await manager.loadState();
+      // 설정 파일 로드 시도
+      await guard.loadConfig('.aiwf/yolo-config.yaml');
       
-      console.log(chalk.bold('📊 YOLO 세션 상태:'));
+      const targetArea = area || 'current_task_area';
+      console.log(chalk.blue(`💡 엔지니어링 피드백 제공: ${targetArea}`));
       console.log('');
       
-      if (!manager.currentState.session_id) {
-        console.log(chalk.yellow('📭 활성 YOLO 세션이 없습니다.'));
-        return;
+      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('✅ 현재 영역은 복잡도 기준을 만족합니다.'));
       }
       
-      console.log(`세션 ID: ${chalk.cyan(manager.currentState.session_id)}`);
-      console.log(`스프린트: ${chalk.blue(manager.currentState.sprint_id || 'N/A')}`);
-      console.log(`완료된 태스크: ${chalk.green(manager.currentState.completed_tasks.length)}개`);
-      console.log(`체크포인트: ${chalk.blue(manager.currentState.checkpoints.length)}개`);
     } catch (error) {
-      console.error(chalk.red('❌ 상태 확인 실패:'), error.message);
+      console.error(chalk.red('❌ 피드백 생성 실패:'), error.message);
       process.exit(1);
     }
   });

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}`;
 }
 
 /**