aiwf 0.3.8 → 0.3.12

package/src/cli/index.js

@@ -8,10 +8,13 @@ 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 FeatureCommand from '../commands/feature.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
 import { readFileSync } from 'fs';
@@ -250,55 +253,6 @@ program
     await compressCmd.execute(args);
   });
 
-// Feature ledger management commands
-const feature = program.command('feature');
-feature.description('Manage feature development tracking / 기능 개발 추적 관리');
-
-feature
-  .command('list')
-  .alias('ls')
-  .description('List all features / 모든 기능 목록')
-  .action(async () => {
-    const featureCmd = new FeatureCommand();
-    await featureCmd.execute(['list']);
-  });
-
-feature
-  .command('create <name> [description...]')
-  .alias('add')
-  .description('Create a new feature / 새 기능 생성')
-  .action(async (name, description) => {
-    const featureCmd = new FeatureCommand();
-    const args = ['create', name];
-    if (description) args.push(...description);
-    await featureCmd.execute(args);
-  });
-
-feature
-  .command('update <featureId> <status>')
-  .description('Update feature status / 기능 상태 업데이트')
-  .action(async (featureId, status) => {
-    const featureCmd = new FeatureCommand();
-    await featureCmd.execute(['update', featureId, status]);
-  });
-
-feature
-  .command('status [featureId]')
-  .description('Show feature status / 기능 상태 표시')
-  .action(async (featureId) => {
-    const featureCmd = new FeatureCommand();
-    const args = ['status'];
-    if (featureId) args.push(featureId);
-    await featureCmd.execute(args);
-  });
-
-feature
-  .command('sync')
-  .description('Sync with git commits / Git 커밋과 동기화')
-  .action(async () => {
-    const featureCmd = new FeatureCommand();
-    await featureCmd.execute(['sync']);
-  });
 
 // Token tracking commands
 const token = program.command('token');
@@ -391,5 +345,338 @@ evaluate
     await evaluateCmd.execute(['criteria']);
   });
 
+// State management commands
+const state = program.command('state');
+state.description('Manage task state index / 태스크 상태 인덱스 관리');
+
+state
+  .command('init')
+  .description('Initialize state index / 상태 인덱스 초기화')
+  .action(async () => {
+    const stateCmd = new StateCommand();
+    await stateCmd.execute(['init']);
+  });
+
+state
+  .command('update')
+  .alias('u')
+  .description('Update state index / 상태 인덱스 업데이트')
+  .action(async () => {
+    const stateCmd = new StateCommand();
+    await stateCmd.execute(['update']);
+  });
+
+state
+  .command('show')
+  .alias('s')
+  .description('Show current state / 현재 상태 표시')
+  .action(async () => {
+    const stateCmd = new StateCommand();
+    await stateCmd.execute(['show']);
+  });
+
+state
+  .command('focus <task-id>')
+  .alias('f')
+  .description('Focus on a task / 태스크에 포커스')
+  .action(async (taskId) => {
+    const stateCmd = new StateCommand();
+    await stateCmd.execute(['focus', taskId]);
+  });
+
+state
+  .command('complete <task-id>')
+  .alias('c')
+  .description('Mark task as completed / 태스크 완료 처리')
+  .action(async (taskId) => {
+    const stateCmd = new StateCommand();
+    await stateCmd.execute(['complete', taskId]);
+  });
+
+state
+  .command('next')
+  .alias('n')
+  .description('Suggest next actions / 다음 작업 제안')
+  .action(async () => {
+    const stateCmd = new StateCommand();
+    await stateCmd.execute(['next']);
+  });
+
+// Sprint management commands (YOLO focused)
+const sprint = program.command('sprint');
+sprint.description('Independent sprint management / 독립 스프린트 관리');
+
+sprint
+  .command('independent [name]')
+  .alias('ind')
+  .description('Create independent sprint / 독립 스프린트 생성')
+  .option('--from-readme', 'Extract from README TODOs / README TODO에서 추출')
+  .option('--from-issue <number>', 'Create from GitHub issue / GitHub 이슈에서 생성')
+  .option('--minimal', 'Minimal engineering level / 최소 엔지니어링 레벨')
+  .option('--balanced', 'Balanced engineering level / 균형 엔지니어링 레벨')
+  .option('--complete', 'Complete engineering level / 완전 엔지니어링 레벨')
+  .option('--description <desc>', 'Sprint description / 스프린트 설명')
+  .action(async (name, options) => {
+    try {
+      console.log(chalk.blue('🚀 독립 스프린트 생성 중...'));
+      
+      // 엔지니어링 레벨 결정
+      let engineeringLevel = 'minimal';
+      if (options.balanced) engineeringLevel = 'balanced';
+      else if (options.complete) engineeringLevel = 'complete';
+      
+      const sprintOptions = {
+        name,
+        description: options.description,
+        engineeringLevel,
+        fromReadme: options.fromReadme,
+        fromIssue: options.fromIssue,
+        minimal: engineeringLevel === 'minimal'
+      };
+      
+      const result = await createIndependentSprint(sprintOptions);
+      
+      if (result.success) {
+        console.log('');
+        console.log(chalk.green('✅ 독립 스프린트 생성 완료!'));
+        console.log(`  스프린트 ID: ${chalk.cyan(result.sprintId)}`);
+        console.log(`  태스크 수: ${chalk.blue(result.tasks)}개`);
+        console.log('');
+        console.log(chalk.bold('🚀 다음 단계:'));
+        console.log(`  Claude Code에서 ${chalk.cyan(`/project:aiwf:yolo ${result.sprintId}`)} 실행`);
+      }
+    } catch (error) {
+      console.error(chalk.red('❌ 독립 스프린트 생성 실패:'), error.message);
+      process.exit(1);
+    }
+  });
+
+// YOLO configuration commands  
+const yoloConfig = program.command('yolo-config');
+yoloConfig.description('YOLO configuration management / YOLO 설정 관리');
+
+yoloConfig
+  .command('init')
+  .description('Initialize YOLO configuration / YOLO 설정 초기화')
+  .option('-f, --force', 'Force overwrite existing config / 기존 설정 덮어쓰기')
+  .action(async (options) => {
+    try {
+      const result = await createYoloConfig(options);
+      if (result.success) {
+        console.log(chalk.green('✅ YOLO 설정이 초기화되었습니다!'));
+        console.log(`📁 위치: ${chalk.cyan(result.configPath)}`);
+      } else if (result.skipped) {
+        console.log(chalk.yellow('⏭️ 설정 파일이 이미 존재합니다.'));
+      }
+    } catch (error) {
+      console.error(chalk.red('❌ YOLO 설정 초기화 실패:'), error.message);
+      process.exit(1);
+    }
+  });
+
+yoloConfig
+  .command('wizard')
+  .alias('interactive')
+  .description('Interactive YOLO configuration wizard / 대화형 YOLO 설정 마법사')
+  .action(async () => {
+    try {
+      const result = await createInteractiveYoloConfig();
+      if (!result.success && result.cancelled) {
+        process.exit(0);
+      }
+    } catch (error) {
+      console.error(chalk.red('❌ YOLO 설정 마법사 실패:'), error.message);
+      process.exit(1);
+    }
+  });
+
+yoloConfig
+  .command('show')
+  .alias('status')
+  .description('Show current YOLO configuration / 현재 YOLO 설정 확인')
+  .action(async () => {
+    try {
+      await showYoloConfig();
+    } catch (error) {
+      console.error(chalk.red('❌ YOLO 설정 확인 실패:'), error.message);
+      process.exit(1);
+    }
+  });
+
+// Checkpoint management commands (YOLO recovery)
+const checkpoint = program.command('checkpoint');
+checkpoint.description('YOLO checkpoint management / YOLO 체크포인트 관리');
+
+checkpoint
+  .command('list')
+  .alias('ls')
+  .description('List available checkpoints / 사용 가능한 체크포인트 목록')
+  .option('--limit <n>', 'Limit number of checkpoints / 체크포인트 수 제한', '10')
+  .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 checkpoints = await manager.listCheckpoints();
+      
+      console.log(chalk.bold('📊 체크포인트 목록:'));
+      console.log('');
+      
+      if (checkpoints.length === 0) {
+        console.log(chalk.yellow('📭 체크포인트가 없습니다.'));
+        return;
+      }
+      
+      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)}개 완료`);
+        console.log('');
+      }
+    } catch (error) {
+      console.error(chalk.red('❌ 체크포인트 목록 조회 실패:'), error.message);
+      process.exit(1);
+    }
+  });
+
+checkpoint
+  .command('restore <checkpointId>')
+  .description('Restore from checkpoint / 체크포인트에서 복구')
+  .action(async (checkpointId) => {
+    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.initialize();
+      
+      console.log(chalk.blue(`🔄 체크포인트 ${checkpointId}에서 복구 중...`));
+      
+      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 모드를 다시 실행할 수 있습니다.'));
+      }
+    } catch (error) {
+      console.error(chalk.red('❌ 체크포인트 복구 실패:'), error.message);
+      process.exit(1);
+    }
+  });
+
+checkpoint
+  .command('status')
+  .description('Show current YOLO session status / 현재 YOLO 세션 상태')
+  .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.bold('📊 YOLO 세션 상태:'));
+      console.log('');
+      
+      if (!manager.currentState.session_id) {
+        console.log(chalk.yellow('📭 활성 YOLO 세션이 없습니다.'));
+        return;
+      }
+      
+      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);
+      process.exit(1);
+    }
+  });
+
+// GitHub integration commands
+const github = program.command('github');
+github.description('GitHub integration / GitHub 통합');
+
+github
+  .command('issue <task-id>')
+  .description('Create GitHub issue from task / 태스크에서 GitHub 이슈 생성')
+  .action(async (taskId) => {
+    try {
+      const { GitHubIntegration } = await import('../lib/github-integration.js');
+      const ghIntegration = new GitHubIntegration();
+      await ghIntegration.createIssue(taskId);
+    } catch (error) {
+      console.error(chalk.red(`GitHub issue creation failed: ${error.message}`));
+      process.exit(1);
+    }
+  });
+
+github
+  .command('pr [task-id]')
+  .description('Create pull request for completed task / 완료된 태스크로 PR 생성')
+  .action(async (taskId) => {
+    try {
+      const { GitHubIntegration } = await import('../lib/github-integration.js');
+      const ghIntegration = new GitHubIntegration();
+      await ghIntegration.createPullRequest(taskId);
+    } catch (error) {
+      console.error(chalk.red(`Pull request creation failed: ${error.message}`));
+      process.exit(1);
+    }
+  });
+
+github
+  .command('sync')
+  .description('Sync GitHub issues with AIWF tasks / GitHub 이슈와 AIWF 태스크 동기화')
+  .action(async () => {
+    try {
+      const { GitHubIntegration } = await import('../lib/github-integration.js');
+      const ghIntegration = new GitHubIntegration();
+      await ghIntegration.syncIssues();
+    } catch (error) {
+      console.error(chalk.red(`GitHub sync failed: ${error.message}`));
+      process.exit(1);
+    }
+  });
+
 // Parse command line arguments
 program.parse(process.argv);

package/src/cli/sprint-cli.js

@@ -0,0 +1,287 @@
+#!/usr/bin/env node
+
+/**
+ * AIWF 스프린트 CLI
+ * 독립 스프린트 생성 및 관리를 위한 명령어 인터페이스
+ */
+
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { createIndependentSprint } from '../commands/sprint-independent.js';
+
+const program = new Command();
+
+program
+  .name('aiwf-sprint')
+  .description('AIWF 독립 스프린트 관리 도구')
+  .version('0.3.12');
+
+// 독립 스프린트 생성 명령어
+program
+  .command('independent [name]')
+  .alias('ind')
+  .description('독립 스프린트 생성')
+  .option('--from-readme', 'README에서 TODO 추출하여 스프린트 생성')
+  .option('--from-issue <number>', 'GitHub 이슈에서 스프린트 생성')
+  .option('--minimal', '최소 엔지니어링 레벨 설정 (기본값)')
+  .option('--balanced', '균형 엔지니어링 레벨 설정')
+  .option('--complete', '완전 엔지니어링 레벨 설정')
+  .option('--description <desc>', '스프린트 설명')
+  .action(async (name, options) => {
+    try {
+      console.log(chalk.blue('🚀 독립 스프린트 생성 중...'));
+      console.log('');
+      
+      // 엔지니어링 레벨 결정
+      let engineeringLevel = 'minimal';
+      if (options.balanced) engineeringLevel = 'balanced';
+      else if (options.complete) engineeringLevel = 'complete';
+      
+      // 옵션 구성
+      const sprintOptions = {
+        name,
+        description: options.description,
+        engineeringLevel,
+        fromReadme: options.fromReadme,
+        fromIssue: options.fromIssue,
+        minimal: engineeringLevel === 'minimal'
+      };
+      
+      // 독립 스프린트 생성
+      const result = await createIndependentSprint(sprintOptions);
+      
+      if (result.success) {
+        console.log('');
+        console.log(chalk.green('✅ 독립 스프린트 생성 완료!'));
+        console.log('');
+        console.log(chalk.bold('📋 생성된 스프린트 정보:'));
+        console.log(`  스프린트 ID: ${chalk.cyan(result.sprintId)}`);
+        console.log(`  태스크 수: ${chalk.blue(result.tasks)}개`);
+        console.log('');
+        console.log(chalk.bold('🚀 다음 단계:'));
+        console.log(`  1. Claude Code에서 ${chalk.cyan(`/project:aiwf:yolo ${result.sprintId}`)} 실행`);
+        console.log(`  2. 또는 ${chalk.cyan(`/project:aiwf:yolo --from-independent`)} 실행`);
+        console.log('');
+        console.log(chalk.gray('💡 팁: YOLO 모드로 전체 스프린트를 자동 완성할 수 있습니다!'));
+      }
+      
+    } catch (error) {
+      console.error(chalk.red('❌ 독립 스프린트 생성 실패:'), error.message);
+      process.exit(1);
+    }
+  });
+
+// 스프린트 목록 보기
+program
+  .command('list')
+  .alias('ls')
+  .description('현재 프로젝트의 모든 스프린트 목록')
+  .option('--status <status>', '상태별 필터링 (active, completed, pending)')
+  .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 sprintsDir = path.join(currentDir, '.aiwf', '03_SPRINTS');
+      
+      try {
+        const entries = await fs.readdir(sprintsDir);
+        const sprintDirs = entries.filter(entry => entry.match(/^S\d+_/));
+        
+        if (sprintDirs.length === 0) {
+          console.log(chalk.yellow('📭 스프린트가 없습니다.'));
+          console.log('');
+          console.log(chalk.gray('새 독립 스프린트를 생성하려면:'));
+          console.log(chalk.blue('  aiwf-sprint independent "프로젝트 이름"'));
+          return;
+        }
+        
+        console.log(chalk.bold('📊 스프린트 목록:'));
+        console.log('');
+        
+        for (const sprintDir of sprintDirs.sort()) {
+          const sprintPath = path.join(sprintsDir, sprintDir);
+          const sprintId = sprintDir.match(/^(S\d+)_/)[1];
+          
+          // 스프린트 메타 파일 읽기
+          try {
+            const metaFiles = (await fs.readdir(sprintPath)).filter(f => f.includes('meta.md'));
+            if (metaFiles.length > 0) {
+              const metaContent = await fs.readFile(path.join(sprintPath, metaFiles[0]), 'utf-8');
+              const statusMatch = metaContent.match(/\*\*상태\*\*:\s*(\w+)/);
+              const typeMatch = metaContent.match(/\*\*타입\*\*:\s*([^\n]+)/);
+              
+              const status = statusMatch ? statusMatch[1] : 'unknown';
+              const type = typeMatch ? typeMatch[1].trim() : 'normal';
+              
+              // 상태 필터링
+              if (options.status && status !== options.status) {
+                continue;
+              }
+              
+              const statusIcon = status === 'active' ? '🔄' : 
+                                status === 'completed' ? '✅' : '⏳';
+              const typeIcon = type.includes('독립') ? '🚀' : '📋';
+              
+              console.log(`${statusIcon} ${typeIcon} ${chalk.cyan(sprintId)} - ${chalk.white(sprintDir.split('_').slice(1).join('_'))}`);
+              console.log(`    상태: ${chalk.yellow(status)} | 타입: ${chalk.gray(type)}`);
+              
+              // 태스크 수 계산
+              const taskFiles = (await fs.readdir(sprintPath)).filter(f => f.match(/^T\d+_/));
+              console.log(`    태스크: ${chalk.blue(taskFiles.length)}개`);
+            }
+          } catch (error) {
+            console.log(`${chalk.red('❌')} ${chalk.cyan(sprintId)} - ${chalk.gray('메타데이터 읽기 실패')}`);
+          }
+          
+          console.log('');
+        }
+        
+      } catch (error) {
+        console.log(chalk.yellow('📭 스프린트 디렉토리가 없습니다.'));
+      }
+      
+    } catch (error) {
+      console.error(chalk.red('❌ 스프린트 목록 조회 실패:'), error.message);
+      process.exit(1);
+    }
+  });
+
+// 스프린트 상태 확인
+program
+  .command('status <sprintId>')
+  .description('특정 스프린트의 상세 상태 확인')
+  .action(async (sprintId) => {
+    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 sprintsDir = path.join(currentDir, '.aiwf', '03_SPRINTS');
+      const entries = await fs.readdir(sprintsDir);
+      const sprintDir = entries.find(entry => entry.startsWith(`${sprintId}_`));
+      
+      if (!sprintDir) {
+        console.error(chalk.red(`❌ 스프린트 ${sprintId}를 찾을 수 없습니다.`));
+        process.exit(1);
+      }
+      
+      const sprintPath = path.join(sprintsDir, sprintDir);
+      
+      console.log(chalk.bold(`📊 스프린트 ${sprintId} 상태`));
+      console.log('');
+      
+      // 메타 파일 읽기
+      const metaFiles = (await fs.readdir(sprintPath)).filter(f => f.includes('meta.md'));
+      if (metaFiles.length > 0) {
+        const metaContent = await fs.readFile(path.join(sprintPath, metaFiles[0]), 'utf-8');
+        
+        const statusMatch = metaContent.match(/\*\*상태\*\*:\s*(\w+)/);
+        const typeMatch = metaContent.match(/\*\*타입\*\*:\s*([^\n]+)/);
+        const createdMatch = metaContent.match(/\*\*생성일\*\*:\s*([^\n]+)/);
+        
+        console.log(`상태: ${chalk.yellow(statusMatch ? statusMatch[1] : 'unknown')}`);
+        console.log(`타입: ${chalk.blue(typeMatch ? typeMatch[1].trim() : 'normal')}`);
+        console.log(`생성일: ${chalk.gray(createdMatch ? createdMatch[1].trim() : 'unknown')}`);
+        console.log('');
+      }
+      
+      // 태스크 목록
+      const taskFiles = (await fs.readdir(sprintPath)).filter(f => f.match(/^T\d+_/));
+      console.log(chalk.bold(`📋 태스크 목록 (${taskFiles.length}개):`));
+      console.log('');
+      
+      for (const taskFile of taskFiles.sort()) {
+        const taskContent = await fs.readFile(path.join(sprintPath, taskFile), 'utf-8');
+        const taskId = taskFile.match(/^(T\d+)_/)[1];
+        const statusMatch = taskContent.match(/\*\*상태\*\*:\s*(\w+)/);
+        const titleMatch = taskContent.match(/^#\s+T\d+:\s*(.+)$/m);
+        
+        const status = statusMatch ? statusMatch[1] : 'pending';
+        const title = titleMatch ? titleMatch[1].trim() : taskFile;
+        
+        const statusIcon = status === 'completed' ? '✅' : 
+                          status === 'in_progress' ? '🔄' : '⏳';
+        
+        console.log(`${statusIcon} ${chalk.cyan(taskId)} - ${chalk.white(title)}`);
+        console.log(`    상태: ${chalk.yellow(status)}`);
+        console.log('');
+      }
+      
+    } catch (error) {
+      console.error(chalk.red('❌ 스프린트 상태 확인 실패:'), error.message);
+      process.exit(1);
+    }
+  });
+
+// 도움말 명령어
+program
+  .command('help')
+  .description('AIWF 스프린트 명령어 도움말')
+  .action(() => {
+    console.log(chalk.bold('🚀 AIWF 스프린트 CLI 도움말'));
+    console.log('');
+    console.log(chalk.yellow('📋 주요 명령어:'));
+    console.log('');
+    console.log(`  ${chalk.cyan('aiwf-sprint independent [name]')} - 독립 스프린트 생성`);
+    console.log(`  ${chalk.cyan('aiwf-sprint list')} - 스프린트 목록 보기`);
+    console.log(`  ${chalk.cyan('aiwf-sprint status <id>')} - 스프린트 상태 확인`);
+    console.log('');
+    console.log(chalk.yellow('🔧 독립 스프린트 옵션:'));
+    console.log('');
+    console.log(`  ${chalk.blue('--from-readme')} - README TODO에서 자동 추출`);
+    console.log(`  ${chalk.blue('--from-issue <번호>')} - GitHub 이슈에서 생성`);
+    console.log(`  ${chalk.blue('--minimal')} - 최소 엔지니어링 레벨 (기본값)`);
+    console.log(`  ${chalk.blue('--balanced')} - 균형 엔지니어링 레벨`);
+    console.log(`  ${chalk.blue('--complete')} - 완전 엔지니어링 레벨`);
+    console.log('');
+    console.log(chalk.yellow('💡 사용 예시:'));
+    console.log('');
+    console.log(`  ${chalk.gray('# README TODO로 독립 스프린트 생성')}`);
+    console.log(`  ${chalk.blue('aiwf-sprint independent --from-readme')}`);
+    console.log('');
+    console.log(`  ${chalk.gray('# GitHub 이슈로 스프린트 생성')}`);
+    console.log(`  ${chalk.blue('aiwf-sprint independent --from-issue 123')}`);
+    console.log('');
+    console.log(`  ${chalk.gray('# 균형 레벨로 커스텀 스프린트 생성')}`);
+    console.log(`  ${chalk.blue('aiwf-sprint independent "API 개발" --balanced')}`);
+    console.log('');
+    console.log(chalk.green('✨ 생성 후 Claude Code에서 `/project:aiwf:yolo [스프린트ID]`로 실행하세요!'));
+  });
+
+// 에러 핸들링
+program.on('command:*', () => {
+  console.error(chalk.red('❌ 알 수 없는 명령어입니다.'));
+  console.log('');
+  console.log(chalk.blue('도움말을 보려면: aiwf-sprint help'));
+  process.exit(1);
+});
+
+// CLI 실행
+program.parse(process.argv);
+
+// 인수가 없으면 도움말 표시
+if (!process.argv.slice(2).length) {
+  program.outputHelp();
+}