aiwf 0.3.7 → 0.3.12

package/src/commands/yolo-config.js

@@ -0,0 +1,502 @@
+#!/usr/bin/env node
+
+/**
+ * YOLO 설정 파일 자동 생성 및 관리
+ * AIWF YOLO 모드의 설정을 초기화하고 관리하는 유틸리티
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+import chalk from 'chalk';
+import prompts from 'prompts';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+/**
+ * 프로젝트 루트 찾기
+ */
+async function findProjectRoot(startDir = process.cwd()) {
+  let currentDir = startDir;
+  
+  while (currentDir !== path.parse(currentDir).root) {
+    try {
+      await fs.access(path.join(currentDir, '.aiwf'));
+      return currentDir;
+    } catch {
+      currentDir = path.dirname(currentDir);
+    }
+  }
+  
+  throw new Error('.aiwf 디렉토리를 찾을 수 없습니다. AIWF 프로젝트 내에서 실행해주세요.');
+}
+
+/**
+ * YOLO 설정 파일 생성
+ */
+export async function createYoloConfig(options = {}) {
+  try {
+    const projectRoot = await findProjectRoot();
+    const configPath = path.join(projectRoot, '.aiwf', 'yolo-config.yaml');
+    const templatePath = path.join(__dirname, '..', 'config', 'yolo-config-template.yaml');
+    
+    // .aiwf 디렉토리 확인
+    const aiwfDir = path.join(projectRoot, '.aiwf');
+    await fs.mkdir(aiwfDir, { recursive: true });
+    
+    // 기존 설정 파일이 있는지 확인
+    let shouldOverwrite = false;
+    try {
+      await fs.access(configPath);
+      if (!options.force) {
+        const response = await prompts({
+          type: 'confirm',
+          name: 'overwrite',
+          message: 'YOLO 설정 파일이 이미 존재합니다. 덮어쓰시겠습니까?',
+          initial: false
+        });
+        shouldOverwrite = response.overwrite;
+      } else {
+        shouldOverwrite = true;
+      }
+    } catch {
+      shouldOverwrite = true;
+    }
+    
+    if (!shouldOverwrite) {
+      console.log(chalk.yellow('⏭️ YOLO 설정 파일 생성을 건너뜁니다.'));
+      return { success: false, skipped: true };
+    }
+    
+    // 템플릿 파일 복사
+    const templateContent = await fs.readFile(templatePath, 'utf-8');
+    
+    // 옵션에 따라 설정 커스터마이징
+    let customizedContent = templateContent;
+    
+    if (options.engineeringLevel) {
+      customizedContent = customizedContent.replace(
+        /engineering_level: minimal/,
+        `engineering_level: ${options.engineeringLevel}`
+      );
+    }
+    
+    if (options.focusMode) {
+      // 포커스 모드에 따른 규칙 조정
+      if (options.focusMode === 'strict') {
+        customizedContent = customizedContent.replace(
+          /no_gold_plating: true/,
+          'no_gold_plating: true\n  \n  # 엄격 모드 추가 규칙\n  strict_requirements: true\n  no_extras: true'
+        );
+      }
+    }
+    
+    await fs.writeFile(configPath, customizedContent);
+    
+    console.log(chalk.green('✅ YOLO 설정 파일이 생성되었습니다!'));
+    console.log(`📁 위치: ${chalk.cyan(configPath)}`);
+    
+    return { success: true, configPath };
+    
+  } catch (error) {
+    throw new Error(`YOLO 설정 파일 생성 실패: ${error.message}`);
+  }
+}
+
+/**
+ * 대화형 YOLO 설정 생성
+ */
+export async function createInteractiveYoloConfig() {
+  try {
+    console.log(chalk.bold('🛠️ YOLO 설정 마법사'));
+    console.log('');
+    console.log(chalk.gray('YOLO 모드의 동작을 커스터마이징할 수 있습니다.'));
+    console.log('');
+    
+    const responses = await prompts([
+      {
+        type: 'select',
+        name: 'engineeringLevel',
+        message: '엔지니어링 레벨을 선택하세요:',
+        choices: [
+          { title: '최소 (Minimal) - 빠른 프로토타입, 최소 구현', value: 'minimal' },
+          { title: '균형 (Balanced) - 품질과 속도의 균형', value: 'balanced' },
+          { title: '완전 (Complete) - 완전한 구현, 높은 품질', value: 'complete' }
+        ],
+        initial: 0
+      },
+      {
+        type: 'multiselect',
+        name: 'focusRules',
+        message: '포커스 규칙을 선택하세요 (스페이스바로 선택):',
+        choices: [
+          { title: '요구사항 우선 (requirement_first)', value: 'requirement_first', selected: true },
+          { title: '간단한 해결책 (simple_solution)', value: 'simple_solution', selected: true },
+          { title: '골드 플레이팅 방지 (no_gold_plating)', value: 'no_gold_plating', selected: true },
+          { title: '트랙 유지 (stay_on_track)', value: 'stay_on_track', selected: true },
+          { title: '리팩토링 제한 (limit_refactoring)', value: 'limit_refactoring', selected: false }
+        ],
+        min: 1
+      },
+      {
+        type: 'select',
+        name: 'executionMode',
+        message: '실행 모드를 선택하세요:',
+        choices: [
+          { title: '빠른 모드 - 최소 검증, 빠른 실행', value: 'fast' },
+          { title: '스마트 모드 - 컨텍스트 기반 의사결정', value: 'smart' },
+          { title: '안전 모드 - 철저한 검증', value: 'safe' }
+        ],
+        initial: 0
+      },
+      {
+        type: 'confirm',
+        name: 'enableCheckpoints',
+        message: '체크포인트 시스템을 활성화하시겠습니까?',
+        initial: true
+      },
+      {
+        type: prev => prev ? 'number' : null,
+        name: 'checkpointInterval',
+        message: '체크포인트 간격 (태스크 수):',
+        initial: 5,
+        min: 1,
+        max: 20
+      },
+      {
+        type: 'confirm',
+        name: 'autoCommit',
+        message: '태스크 완료 시 자동 커밋을 사용하시겠습니까?',
+        initial: false
+      },
+      {
+        type: 'number',
+        name: 'maxFileLines',
+        message: '최대 파일 크기 (줄 수):',
+        initial: 300,
+        min: 100,
+        max: 1000
+      },
+      {
+        type: 'number',
+        name: 'maxFunctionLines',
+        message: '최대 함수 크기 (줄 수):',
+        initial: 50,
+        min: 20,
+        max: 200
+      }
+    ]);
+    
+    // 응답이 중단된 경우 처리
+    if (!responses.engineeringLevel) {
+      console.log(chalk.yellow('⏭️ 설정 생성이 취소되었습니다.'));
+      return { success: false, cancelled: true };
+    }
+    
+    console.log('');
+    console.log(chalk.blue('🔧 YOLO 설정 파일 생성 중...'));
+    
+    // 커스텀 설정 파일 생성
+    const customConfig = await generateCustomConfig(responses);
+    const projectRoot = await findProjectRoot();
+    const configPath = path.join(projectRoot, '.aiwf', 'yolo-config.yaml');
+    
+    await fs.mkdir(path.dirname(configPath), { recursive: true });
+    await fs.writeFile(configPath, customConfig);
+    
+    console.log(chalk.green('✅ 커스텀 YOLO 설정이 생성되었습니다!'));
+    console.log(`📁 위치: ${chalk.cyan(configPath)}`);
+    console.log('');
+    
+    // 설정 요약 표시
+    console.log(chalk.bold('📋 설정 요약:'));
+    console.log(`  엔지니어링 레벨: ${chalk.yellow(responses.engineeringLevel)}`);
+    console.log(`  실행 모드: ${chalk.yellow(responses.executionMode)}`);
+    console.log(`  체크포인트: ${chalk.yellow(responses.enableCheckpoints ? '활성화' : '비활성화')}`);
+    console.log(`  자동 커밋: ${chalk.yellow(responses.autoCommit ? '활성화' : '비활성화')}`);
+    console.log(`  최대 파일 크기: ${chalk.blue(responses.maxFileLines)}줄`);
+    console.log('');
+    
+    console.log(chalk.green('🚀 이제 YOLO 모드를 실행할 준비가 되었습니다!'));
+    console.log(chalk.blue('Claude Code에서 /project:aiwf:yolo 를 실행하세요.'));
+    
+    return { success: true, configPath, config: responses };
+    
+  } catch (error) {
+    if (error.message.includes('cancelled')) {
+      console.log(chalk.yellow('⏭️ 설정 생성이 취소되었습니다.'));
+      return { success: false, cancelled: true };
+    }
+    throw error;
+  }
+}
+
+/**
+ * 커스텀 설정 파일 생성
+ */
+async function generateCustomConfig(responses) {
+  const config = `# YOLO Mode Configuration - AIWF 자율 실행 모드 설정
+# 마법사로 생성된 커스텀 설정
+
+# 엔지니어링 레벨 설정
+engineering_level: ${responses.engineeringLevel}
+
+# 포커스 규칙 - 곁길로 빠지지 않도록 제어
+focus_rules:
+${responses.focusRules.map(rule => {
+  switch(rule) {
+    case 'requirement_first': return '  # 요구사항 우선 - 명시된 요구사항만 구현\n  requirement_first: true';
+    case 'simple_solution': return '  # 간단한 해결책 선호\n  simple_solution: true';
+    case 'no_gold_plating': return '  # 골드 플레이팅 방지 - 필요 이상의 기능 추가 금지\n  no_gold_plating: true';
+    case 'stay_on_track': return '  # 트랙 유지 - 원래 목표에서 벗어나지 않음\n  stay_on_track: true';
+    case 'limit_refactoring': return '  # 리팩토링 제한 - 필수적인 경우만 허용\n  limit_refactoring: true';
+    default: return '';
+  }
+}).join('\n  \n')}
+
+# 실행 모드 설정
+execution:
+  # 스마트 모드 - 컨텍스트 기반 의사결정
+  smart_mode: ${responses.executionMode === 'smart'}
+  
+  # 빠른 실행 - 최소한의 검증만 수행
+  fast_mode: ${responses.executionMode === 'fast'}
+  
+  # 안전 모드 - 철저한 검증
+  safe_mode: ${responses.executionMode === 'safe'}
+  
+  # 테스트 실행 - 각 태스크 완료 후 테스트
+  run_tests: true
+  
+  # 커밋 자동화 - 태스크 완료 시 자동 커밋
+  auto_commit: ${responses.autoCommit}
+  
+  # 브랜치 전략
+  branch_strategy: feature  # feature, direct, worktree
+
+# 중단 조건 - 이러한 상황에서 YOLO 모드 중단
+breakpoints:
+  # 중요 파일 수정 시
+  critical_files:
+    - .env
+    - database/migrations/*
+    - config/production.js
+  
+  # 테스트 실패 임계값 (%)
+  test_failure_threshold: 10
+  
+  # 데이터베이스 스키마 변경 시
+  schema_changes: true
+  
+  # 보안 관련 변경 시
+  security_changes: true
+  
+  # 외부 API 통합 시
+  external_api: false
+
+# 진행률 리포트 설정
+reporting:
+  # 상세 레벨
+  verbosity: normal  # quiet, normal, verbose
+  
+  # 진행률 업데이트 빈도 (태스크 단위)
+  update_frequency: 1
+  
+  # 요약 리포트 생성
+  generate_summary: true
+  
+  # 메트릭 추적
+  track_metrics: true
+
+# 오버엔지니어링 방지 규칙
+overengineering_prevention:
+  # 최대 파일 크기 (줄)
+  max_file_lines: ${responses.maxFileLines}
+  
+  # 최대 함수 크기 (줄)
+  max_function_lines: ${responses.maxFunctionLines}
+  
+  # 최대 중첩 깊이
+  max_nesting_depth: 4
+  
+  # 추상화 레벨 제한
+  max_abstraction_layers: 3
+  
+  # 디자인 패턴 사용 제한
+  limit_design_patterns: true
+  
+  # 미래를 위한 코드 금지
+  no_future_proofing: true
+
+# 체크포인트 설정
+checkpoint:
+  # 체크포인트 활성화
+  enabled: ${responses.enableCheckpoints}
+  
+  # 체크포인트 간격 (태스크 수)
+  interval: ${responses.checkpointInterval || 5}
+  
+  # 복구 모드
+  recovery_mode: auto  # auto, manual, disabled
+  
+  # 상태 저장 위치
+  state_file: .aiwf/yolo-state.json
+
+# 태스크 우선순위 설정
+priority:
+  # 우선순위 가중치
+  weights:
+    urgency: 0.4
+    importance: 0.3
+    dependencies: 0.2
+    effort: 0.1
+  
+  # 의존성 우선 실행
+  dependency_first: true
+  
+  # 블로커 태스크 즉시 처리
+  handle_blockers: true
+
+# AI 페르소나 설정
+persona:
+  # 기본 페르소나
+  default: developer
+  
+  # 태스크별 페르소나 자동 선택
+  auto_select: true
+  
+  # 페르소나 전환 규칙
+  rules:
+    - pattern: "API|백엔드|서버"
+      persona: backend
+    - pattern: "UI|프론트|컴포넌트"
+      persona: frontend
+    - pattern: "테스트|검증|QA"
+      persona: tester
+
+# 성능 최적화
+performance:
+  # 병렬 실행 (실험적)
+  parallel_tasks: false
+  
+  # 캐시 활용
+  use_cache: true
+  
+  # 불필요한 파일 읽기 스킵
+  skip_unchanged: true
+  
+  # 압축 모드 사용
+  compression_mode: auto
+
+# 안전 장치
+safety:
+  # 드라이런 모드 - 실제 변경 없이 시뮬레이션
+  dry_run: false
+  
+  # 백업 생성
+  create_backup: true
+  
+  # 최대 실행 시간 (분)
+  max_runtime: 120
+  
+  # 확인 프롬프트 표시
+  confirmation_prompts: false`;
+
+  return config;
+}
+
+/**
+ * 현재 YOLO 설정 확인
+ */
+export async function showYoloConfig() {
+  try {
+    const projectRoot = await findProjectRoot();
+    const configPath = path.join(projectRoot, '.aiwf', 'yolo-config.yaml');
+    
+    try {
+      const configContent = await fs.readFile(configPath, 'utf-8');
+      
+      console.log(chalk.bold('🛠️ 현재 YOLO 설정:'));
+      console.log(`📁 위치: ${chalk.cyan(configPath)}`);
+      console.log('');
+      
+      // 주요 설정 추출
+      const engineeringLevel = configContent.match(/engineering_level:\s*(\w+)/)?.[1] || 'unknown';
+      const enabledRules = [];
+      
+      if (configContent.includes('requirement_first: true')) enabledRules.push('요구사항 우선');
+      if (configContent.includes('simple_solution: true')) enabledRules.push('간단한 해결책');
+      if (configContent.includes('no_gold_plating: true')) enabledRules.push('골드 플레이팅 방지');
+      if (configContent.includes('stay_on_track: true')) enabledRules.push('트랙 유지');
+      
+      const checkpointEnabled = configContent.includes('enabled: true');
+      const autoCommit = configContent.includes('auto_commit: true');
+      
+      console.log(chalk.bold('📋 주요 설정:'));
+      console.log(`  엔지니어링 레벨: ${chalk.yellow(engineeringLevel)}`);
+      console.log(`  포커스 규칙: ${chalk.blue(enabledRules.join(', '))}`);
+      console.log(`  체크포인트: ${chalk.yellow(checkpointEnabled ? '활성화' : '비활성화')}`);
+      console.log(`  자동 커밋: ${chalk.yellow(autoCommit ? '활성화' : '비활성화')}`);
+      console.log('');
+      
+      console.log(chalk.gray('전체 설정을 보려면 파일을 직접 확인하세요:'));
+      console.log(chalk.blue(`cat ${configPath}`));
+      
+    } catch (error) {
+      console.log(chalk.yellow('⚠️ YOLO 설정 파일이 없습니다.'));
+      console.log('');
+      console.log(chalk.gray('설정 파일을 생성하려면:'));
+      console.log(chalk.blue('aiwf yolo-config init'));
+    }
+    
+  } catch (error) {
+    throw new Error(`YOLO 설정 확인 실패: ${error.message}`);
+  }
+}
+
+/**
+ * CLI에서 실행될 때
+ */
+if (import.meta.url === `file://${process.argv[1]}`) {
+  const command = process.argv[2];
+  
+  switch (command) {
+    case 'init':
+      createYoloConfig({ force: process.argv.includes('--force') })
+        .catch(error => {
+          console.error(chalk.red(`오류: ${error.message}`));
+          process.exit(1);
+        });
+      break;
+      
+    case 'wizard':
+    case 'interactive':
+      createInteractiveYoloConfig()
+        .catch(error => {
+          console.error(chalk.red(`오류: ${error.message}`));
+          process.exit(1);
+        });
+      break;
+      
+    case 'show':
+    case 'status':
+      showYoloConfig()
+        .catch(error => {
+          console.error(chalk.red(`오류: ${error.message}`));
+          process.exit(1);
+        });
+      break;
+      
+    default:
+      console.log(chalk.bold('🛠️ YOLO 설정 관리'));
+      console.log('');
+      console.log(chalk.yellow('사용법:'));
+      console.log(`  ${chalk.blue('node yolo-config.js init')} - 기본 설정 파일 생성`);
+      console.log(`  ${chalk.blue('node yolo-config.js wizard')} - 대화형 설정 생성`);
+      console.log(`  ${chalk.blue('node yolo-config.js show')} - 현재 설정 확인`);
+      break;
+  }
+}
+
+export default { createYoloConfig, createInteractiveYoloConfig, showYoloConfig };

package/src/config/file-lists.js

@@ -0,0 +1,147 @@
+/**
+ * AIWF 설치 시 다운로드할 파일 목록들
+ * 이 파일은 GitHub에서 다운로드할 파일들의 사전 정의된 목록을 포함합니다.
+ * 
+ * ⚠️  이 파일은 자동 생성됩니다. 수동으로 편집하지 마세요!
+ * 업데이트하려면: npm run update:file-lists
+ * 
+ * Generated at: 2025-07-22T16:39:32.225Z
+ */
+
+// Claude Code 명령어 파일 목록 (한국어와 영어 공통)
+export const COMMAND_FILES = [
+  'aiwf_add_sprint_task.md',
+  'aiwf_analyze_milestone.md',
+  'aiwf_changelog.md',
+  'aiwf_check_state.md',
+  'aiwf_code_review.md',
+  'aiwf_commit.md',
+  'aiwf_compress_aggressive_persona.md',
+  'aiwf_compress_context.md',
+  'aiwf_compress_minimal_persona.md',
+  'aiwf_compress_stats.md',
+  'aiwf_compress_with_persona.md',
+  'aiwf_create_general_task.md',
+  'aiwf_create_milestone_plan.md',
+  'aiwf_create_prd.md',
+  'aiwf_create_sprint_tasks.md',
+  'aiwf_create_sprints_from_milestone.md',
+  'aiwf_create_testcase.md',
+  'aiwf_default_mode.md',
+  'aiwf_discuss_review.md',
+  'aiwf_do_task.md',
+  'aiwf_docs.md',
+  'aiwf_evaluate.md',
+  'aiwf_infinite.md',
+  'aiwf_initialize.md',
+  'aiwf_issue_create.md',
+  'aiwf_mermaid.md',
+  'aiwf_next_action.md',
+  'aiwf_persona_architect.md',
+  'aiwf_persona_backend.md',
+  'aiwf_persona_data_analyst.md',
+  'aiwf_persona_frontend.md',
+  'aiwf_persona_security.md',
+  'aiwf_persona_status.md',
+  'aiwf_pr_create.md',
+  'aiwf_prime.md',
+  'aiwf_project_review.md',
+  'aiwf_project_status.md',
+  'aiwf_smart_complete.md',
+  'aiwf_smart_start.md',
+  'aiwf_test.md',
+  'aiwf_testing_review.md',
+  'aiwf_tm-run-all-subtask.md',
+  'aiwf_transition.md',
+  'aiwf_ultrathink_code_advanced.md',
+  'aiwf_ultrathink_code_basic.md',
+  'aiwf_ultrathink_general.md',
+  'aiwf_update_docs.md',
+  'aiwf_update_state.md',
+  'aiwf_validate_state.md',
+  'aiwf_validate_workflow.md',
+  'aiwf_workflow_context.md',
+  'aiwf_yolo.md'
+];
+
+// 글로벌 룰 파일 목록
+export const GLOBAL_RULES_FILES = [
+  'code-style-guide.md',
+  'coding-principles.md',
+  'development-process.md',
+  'global-rules.md'
+];
+
+// 수동 룰 파일 목록
+export const MANUAL_RULES_FILES = [
+  'generate-plan-docs.md'
+];
+
+// 템플릿 파일 목록 (향후 추가 예정)
+export const TEMPLATE_FILES = [
+  // 템플릿 파일들이 추가되면 여기에 나열
+];
+
+// 프롬프트 파일 목록 (향후 추가 예정)
+export const PROMPT_FILES = [
+  // 프롬프트 파일들이 추가되면 여기에 나열
+];
+
+// 모든 파일 목록을 하나의 객체로 export
+export const FILE_LISTS = {
+  COMMAND_FILES,
+  GLOBAL_RULES_FILES,
+  MANUAL_RULES_FILES,
+  TEMPLATE_FILES,
+  PROMPT_FILES
+};
+
+// 개별 카테고리별 파일 수 정보
+export const FILE_COUNTS = {
+  commands: COMMAND_FILES.length,
+  globalRules: GLOBAL_RULES_FILES.length,
+  manualRules: MANUAL_RULES_FILES.length,
+  templates: TEMPLATE_FILES.length,
+  prompts: PROMPT_FILES.length,
+  total: COMMAND_FILES.length + GLOBAL_RULES_FILES.length + MANUAL_RULES_FILES.length + TEMPLATE_FILES.length + PROMPT_FILES.length
+};
+
+/**
+ * 특정 언어의 파일 존재 여부 확인을 위한 헬퍼 함수들
+ */
+
+/**
+ * 언어별로 존재하지 않을 수 있는 파일들을 필터링
+ * @param {Array<string>} fileList - 원본 파일 목록
+ * @param {string} language - 언어 코드 (ko, en)
+ * @returns {Array<string>} 필터링된 파일 목록
+ */
+export function filterFilesByLanguage(fileList, language) {
+  // 일부 파일들은 특정 언어에만 존재할 수 있음
+  const languageSpecificFiles = {
+    ko: [
+      // 한국어에만 있는 파일들 (현재는 없음)
+    ],
+    en: [
+      // 영어에만 있는 파일들 (현재는 없음)
+    ]
+  };
+  
+  // 현재는 모든 파일이 두 언어 모두 존재한다고 가정
+  return fileList;
+}
+
+/**
+ * 파일 목록 업데이트를 위한 헬퍼 함수
+ * 실제 디렉토리를 스캔하여 파일 목록을 업데이트할 수 있는 함수
+ */
+export function getLatestFileList() {
+  // 이 함수는 향후 자동 업데이트 기능 구현 시 사용
+  return {
+    commands: COMMAND_FILES,
+    globalRules: GLOBAL_RULES_FILES,
+    manualRules: MANUAL_RULES_FILES,
+    templates: TEMPLATE_FILES,
+    prompts: PROMPT_FILES
+  };
+}