aiwf 0.3.22 → 0.4.0

package/src/commands/state.js

@@ -1,1164 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * AIWF State Management Command
- * 중앙 상태 인덱스를 통한 프로젝트 상태 관리
- */
-
-import fs from 'fs/promises';
-import path from 'path';
-import chalk from 'chalk';
-import ora from 'ora';
-import { glob } from 'glob';
-
-export default class StateCommand {
-  constructor() {
-    this.stateFile = 'task-state-index.json';
-    this.workflowRulesFile = 'workflow-rules.json';
-    this.projectRoot = null;
-    this.aiwfPath = null;
-    this.workflowRules = null;
-  }
-
-  async execute(args) {
-    const subcommand = args[0] || 'show';
-    
-    try {
-      // 프로젝트 루트 찾기
-      this.projectRoot = await this.findProjectRoot();
-      this.aiwfPath = path.join(this.projectRoot, '.aiwf');
-      
-      switch (subcommand) {
-        case 'update':
-          await this.updateStateIndex();
-          break;
-        case 'show':
-          await this.showState();
-          break;
-        case 'focus':
-          await this.focusTask(args[1]);
-          break;
-        case 'complete':
-          await this.completeTask(args[1]);
-          break;
-        case 'next':
-          await this.suggestNext();
-          break;
-        case 'init':
-          await this.initStateIndex();
-          break;
-        case 'validate':
-          await this.validateCommand();
-          break;
-        default:
-          console.error(chalk.red(`Unknown subcommand: ${subcommand}`));
-          this.showHelp();
-      }
-    } catch (error) {
-      console.error(chalk.red(`Error: ${error.message}`));
-      process.exit(1);
-    }
-  }
-
-  async findProjectRoot(startDir = process.cwd()) {
-    let currentDir = startDir;
-    
-    while (currentDir !== path.parse(currentDir).root) {
-      try {
-        const aiwfPath = path.join(currentDir, '.aiwf');
-        await fs.access(aiwfPath);
-        return currentDir;
-      } catch {
-        currentDir = path.dirname(currentDir);
-      }
-    }
-    
-    throw new Error('.aiwf directory not found. Are you in an AIWF project?');
-  }
-
-  async initStateIndex() {
-    const spinner = ora('Initializing state index...').start();
-    
-    try {
-      const indexPath = path.join(this.aiwfPath, this.stateFile);
-      const exists = await this.fileExists(indexPath);
-      
-      if (exists) {
-        spinner.warn('State index already exists');
-        return;
-      }
-
-      const initialState = {
-        version: '1.0.0',
-        last_updated: new Date().toISOString(),
-        last_updated_by: 'aiwf-state-init',
-        project_info: {
-          name: path.basename(this.projectRoot),
-          current_milestone: null,
-          current_sprint: null,
-          phase: 'planning'
-        },
-        current_focus: {
-          primary_task: null,
-          secondary_tasks: [],
-          blocked_tasks: [],
-          last_worked_on: null,
-          session_notes: ''
-        },
-        tasks: {},
-        sprint_summary: {},
-        next_actions: [],
-        ai_context: {
-          last_session: new Date().toISOString(),
-          session_count: 0,
-          learned_patterns: {},
-          working_hours: {}
-        },
-        metrics: {
-          total_tasks: 0,
-          completed_tasks: 0,
-          in_progress_tasks: 0,
-          pending_tasks: 0,
-          blocked_tasks: 0,
-          overall_progress: 0
-        }
-      };
-
-      await fs.writeFile(indexPath, JSON.stringify(initialState, null, 2));
-      spinner.succeed('State index initialized successfully');
-    } catch (error) {
-      spinner.fail(`Failed to initialize state index: ${error.message}`);
-      throw error;
-    }
-  }
-
-  async updateStateIndex() {
-    const spinner = ora('Updating state index...').start();
-    
-    try {
-      const indexPath = path.join(this.aiwfPath, this.stateFile);
-      let stateIndex = await this.loadStateIndex();
-      
-      if (!stateIndex) {
-        spinner.info('State index not found. Creating new one...');
-        await this.initStateIndex();
-        stateIndex = await this.loadStateIndex();
-      }
-
-      // 스프린트 폴더들 스캔
-      const sprintDirs = await glob('03_SPRINTS/S*/', { cwd: this.aiwfPath });
-      let totalTasks = 0;
-      let completedTasks = 0;
-      let inProgressTasks = 0;
-      let pendingTasks = 0;
-      let blockedTasks = 0;
-
-      // 각 스프린트 폴더에서 태스크 파일들 스캔
-      for (const sprintDir of sprintDirs) {
-        const sprintPath = path.join(this.aiwfPath, sprintDir);
-        const sprintId = path.basename(sprintDir).split('_')[0];
-        
-        // 스프린트 메타 파일 읽기
-        const metaFiles = await glob('*_sprint_meta.md', { cwd: sprintPath });
-        let sprintName = sprintDir;
-        let sprintStatus = 'active';
-        
-        if (metaFiles.length > 0) {
-          const metaContent = await fs.readFile(path.join(sprintPath, metaFiles[0]), 'utf-8');
-          const nameMatch = metaContent.match(/^#\s+(.+)$/m);
-          if (nameMatch) sprintName = nameMatch[1];
-          
-          // 스프린트 상태 확인
-          if (metaContent.includes('상태: 완료') || metaContent.includes('Status: Completed')) {
-            sprintStatus = 'completed';
-          } else if (metaContent.includes('상태: 계획') || metaContent.includes('Status: Planning')) {
-            sprintStatus = 'planning';
-          }
-        }
-
-        // 태스크 파일들 스캔
-        const taskFiles = await glob('T*.md', { cwd: sprintPath });
-        const sprintTasks = taskFiles.filter(f => !f.includes('_template'));
-        
-        let sprintCompleted = 0;
-        let sprintInProgress = 0;
-        let sprintPending = 0;
-        
-        for (const taskFile of sprintTasks) {
-          totalTasks++;
-          const taskPath = path.join(sprintPath, taskFile);
-          const taskContent = await fs.readFile(taskPath, 'utf-8');
-          
-          // 태스크 ID 추출
-          const taskId = taskFile.replace('.md', '').split('_').slice(0, 3).join('_');
-          
-          // 태스크 정보 파싱
-          const titleMatch = taskContent.match(/^#\s+T\d+:\s+(.+)$/m);
-          const statusMatch = taskContent.match(/\*\*상태\*\*:\s*(\w+)|\*\*Status\*\*:\s*(\w+)/i);
-          const milestoneMatch = taskContent.match(/\*\*마일스톤\*\*:\s*(M\d+)|\*\*Milestone\*\*:\s*(M\d+)/i);
-          
-          const title = titleMatch ? titleMatch[1] : taskFile;
-          const status = statusMatch ? (statusMatch[1] || statusMatch[2]).toLowerCase() : 'pending';
-          const milestone = milestoneMatch ? (milestoneMatch[1] || milestoneMatch[2]) : 'M01';
-          
-          // 태스크 상태 카운트
-          switch (status) {
-            case 'completed':
-            case 'done':
-              completedTasks++;
-              sprintCompleted++;
-              break;
-            case 'in_progress':
-            case 'in-progress':
-            case 'active':
-              inProgressTasks++;
-              sprintInProgress++;
-              if (!stateIndex.current_focus.primary_task) {
-                stateIndex.current_focus.primary_task = taskId;
-              }
-              break;
-            case 'blocked':
-              blockedTasks++;
-              break;
-            default:
-              pendingTasks++;
-              sprintPending++;
-          }
-          
-          // 태스크 정보 업데이트
-          stateIndex.tasks[taskId] = {
-            id: taskId,
-            title: title,
-            status: status,
-            sprint: sprintId,
-            milestone: milestone,
-            location: path.relative(this.projectRoot, taskPath),
-            last_updated: new Date().toISOString()
-          };
-          
-          // OUTPUT LOG 확인
-          if (taskContent.includes('## OUTPUT LOG')) {
-            const outputSection = taskContent.split('## OUTPUT LOG')[1];
-            if (outputSection.includes('✅') || outputSection.includes('완료')) {
-              stateIndex.tasks[taskId].status = 'completed';
-            }
-          }
-        }
-        
-        // 스프린트 요약 업데이트
-        stateIndex.sprint_summary[sprintId] = {
-          name: sprintName,
-          status: sprintStatus,
-          total_tasks: sprintTasks.length,
-          completed_tasks: sprintCompleted,
-          in_progress_tasks: sprintInProgress,
-          pending_tasks: sprintPending,
-          completion_rate: sprintTasks.length > 0 ? Math.round((sprintCompleted / sprintTasks.length) * 100) : 0
-        };
-      }
-
-      // 현재 마일스톤/스프린트 찾기
-      const manifestPath = path.join(this.aiwfPath, '00_PROJECT_MANIFEST.md');
-      if (await this.fileExists(manifestPath)) {
-        const manifestContent = await fs.readFile(manifestPath, 'utf-8');
-        const currentMilestoneMatch = manifestContent.match(/\*\*현재 마일스톤\*\*:\s*(M\d+)|\*\*Current Milestone\*\*:\s*(M\d+)/);
-        const currentSprintMatch = manifestContent.match(/\*\*활성 스프린트\*\*:\s*(S\d+)|\*\*Active Sprint\*\*:\s*(S\d+)/);
-        
-        if (currentMilestoneMatch) {
-          stateIndex.project_info.current_milestone = currentMilestoneMatch[1] || currentMilestoneMatch[2];
-        }
-        if (currentSprintMatch) {
-          stateIndex.project_info.current_sprint = currentSprintMatch[1] || currentSprintMatch[2];
-        }
-      }
-
-      // 메트릭스 업데이트
-      stateIndex.metrics = {
-        total_tasks: totalTasks,
-        completed_tasks: completedTasks,
-        in_progress_tasks: inProgressTasks,
-        pending_tasks: pendingTasks,
-        blocked_tasks: blockedTasks,
-        overall_progress: totalTasks > 0 ? Math.round((completedTasks / totalTasks) * 100) : 0
-      };
-
-      // 워크플로우 규칙 로드
-      if (!this.workflowRules) {
-        this.workflowRules = await this.loadWorkflowRules();
-      }
-
-      // 의존성 분석
-      const dependencies = await this.analyzeDependencies(stateIndex);
-      
-      // 다음 액션 제안을 우선순위 기반으로 생성
-      stateIndex.next_actions = [];
-      const taskPriorities = [];
-      
-      // 모든 태스크의 우선순위 계산
-      Object.values(stateIndex.tasks).forEach(task => {
-        // 의존성 정보 추가
-        task.dependencies = dependencies[task.id]?.dependsOn || [];
-        task.blockedBy = dependencies[task.id]?.blockedBy || [];
-        task.blocks = dependencies[task.id]?.blocks || [];
-        
-        // 우선순위 계산
-        const priority = this.calculateTaskPriority(task, stateIndex);
-        taskPriorities.push({ task, priority, dependencies: dependencies[task.id] });
-      });
-      
-      // 우선순위로 정렬
-      taskPriorities.sort((a, b) => b.priority - a.priority);
-      
-      // 진행 중인 태스크 우선
-      taskPriorities.forEach(({ task, priority }) => {
-        if (task.status === 'in_progress') {
-          stateIndex.next_actions.push({
-            priority: 'high',
-            score: priority,
-            action: `Continue working on ${task.title}`,
-            task_id: task.id,
-            reason: 'Already in progress',
-            estimated_time: '2-4 hours',
-            blockedBy: task.blockedBy
-          });
-        }
-      });
-      
-      // 차단되지 않은 대기 중인 태스크 추가
-      taskPriorities.forEach(({ task, priority }) => {
-        if (task.status === 'pending' && 
-            task.sprint === stateIndex.project_info.current_sprint &&
-            task.blockedBy.length === 0) {
-          stateIndex.next_actions.push({
-            priority: priority >= 70 ? 'high' : priority >= 40 ? 'medium' : 'low',
-            score: priority,
-            action: `Start ${task.title}`,
-            task_id: task.id,
-            reason: task.blocks.length > 0 ? `Blocks ${task.blocks.length} other tasks` : 'Ready to start',
-            estimated_time: '4-8 hours',
-            dependencies: task.dependencies
-          });
-        }
-      });
-      
-      // 차단된 태스크 정보
-      taskPriorities.forEach(({ task, priority }) => {
-        if (task.status === 'pending' && task.blockedBy.length > 0) {
-          stateIndex.next_actions.push({
-            priority: 'blocked',
-            score: priority,
-            action: `Blocked: ${task.title}`,
-            task_id: task.id,
-            reason: `Waiting for: ${task.blockedBy.join(', ')}`,
-            blockedBy: task.blockedBy
-          });
-        }
-      });
-      
-      // 워크플로우 검증
-      const validation = await this.validateWorkflow(stateIndex);
-      stateIndex.workflow_validation = validation;
-
-      // 타임스탬프 업데이트
-      stateIndex.last_updated = new Date().toISOString();
-      stateIndex.last_updated_by = 'aiwf-state-update';
-
-      // 저장
-      await fs.writeFile(indexPath, JSON.stringify(stateIndex, null, 2));
-      
-      spinner.succeed(`State index updated: ${totalTasks} tasks tracked`);
-      console.log(chalk.green(`  ✅ Completed: ${completedTasks}`));
-      console.log(chalk.yellow(`  🔄 In Progress: ${inProgressTasks}`));
-      console.log(chalk.blue(`  ⏳ Pending: ${pendingTasks}`));
-      console.log(chalk.red(`  ❌ Blocked: ${blockedTasks}`));
-      console.log(chalk.cyan(`  📊 Overall Progress: ${stateIndex.metrics.overall_progress}%`));
-      
-    } catch (error) {
-      spinner.fail(`Failed to update state index: ${error.message}`);
-      throw error;
-    }
-  }
-
-  async showState() {
-    try {
-      const stateIndex = await this.loadStateIndex();
-      if (!stateIndex) {
-        console.log(chalk.yellow('No state index found. Run "aiwf state init" or "aiwf state update" first.'));
-        return;
-      }
-
-      console.log(chalk.bold('\n🏗️  AIWF Project State\n'));
-      
-      // 프로젝트 정보
-      console.log(chalk.cyan('📋 Project Information:'));
-      console.log(`  Name: ${stateIndex.project_info.name}`);
-      console.log(`  Current Milestone: ${stateIndex.project_info.current_milestone || 'None'}`);
-      console.log(`  Active Sprint: ${stateIndex.project_info.current_sprint || 'None'}`);
-      console.log(`  Phase: ${stateIndex.project_info.phase}`);
-      console.log(`  Last Updated: ${new Date(stateIndex.last_updated).toLocaleString()}`);
-      
-      // 현재 포커스
-      console.log(chalk.yellow('\n🎯 Current Focus:'));
-      if (stateIndex.current_focus.primary_task) {
-        const task = stateIndex.tasks[stateIndex.current_focus.primary_task];
-        if (task) {
-          console.log(`  Primary Task: ${task.id} - ${task.title}`);
-          console.log(`  Status: ${task.status}`);
-        }
-      } else {
-        console.log('  No task currently in focus');
-      }
-      
-      // 메트릭스
-      console.log(chalk.green('\n📊 Metrics:'));
-      const m = stateIndex.metrics;
-      console.log(`  Total Tasks: ${m.total_tasks}`);
-      console.log(`  Completed: ${m.completed_tasks} (${Math.round((m.completed_tasks/m.total_tasks)*100) || 0}%)`);
-      console.log(`  In Progress: ${m.in_progress_tasks}`);
-      console.log(`  Pending: ${m.pending_tasks}`);
-      console.log(`  Blocked: ${m.blocked_tasks}`);
-      
-      // 진행률 바
-      const progressBar = this.createProgressBar(m.overall_progress);
-      console.log(`\n  Overall Progress: ${progressBar} ${m.overall_progress}%`);
-      
-      // 다음 액션
-      if (stateIndex.next_actions.length > 0) {
-        console.log(chalk.magenta('\n🚀 Next Actions:'));
-        stateIndex.next_actions.slice(0, 3).forEach((action, i) => {
-          const priority = action.priority === 'high' ? '🔴' : action.priority === 'medium' ? '🟡' : '🟢';
-          console.log(`  ${i + 1}. ${priority} ${action.action} (${action.estimated_time})`);
-        });
-      }
-      
-      // 스프린트 요약
-      const activeSprints = Object.entries(stateIndex.sprint_summary)
-        .filter(([_, sprint]) => sprint.status === 'active');
-      
-      if (activeSprints.length > 0) {
-        console.log(chalk.blue('\n📅 Active Sprints:'));
-        activeSprints.forEach(([id, sprint]) => {
-          const sprintProgress = this.createProgressBar(sprint.completion_rate);
-          console.log(`  ${id}: ${sprint.name}`);
-          console.log(`    Progress: ${sprintProgress} ${sprint.completion_rate}%`);
-          console.log(`    Tasks: ${sprint.completed_tasks}/${sprint.total_tasks} completed`);
-        });
-      }
-      
-      console.log('');
-    } catch (error) {
-      console.error(chalk.red(`Failed to show state: ${error.message}`));
-      throw error;
-    }
-  }
-
-  async focusTask(taskId) {
-    if (!taskId) {
-      console.error(chalk.red('Please provide a task ID'));
-      return;
-    }
-
-    const spinner = ora(`Setting focus to ${taskId}...`).start();
-    
-    try {
-      const stateIndex = await this.loadStateIndex();
-      if (!stateIndex) {
-        spinner.fail('No state index found. Run "aiwf state update" first.');
-        return;
-      }
-
-      if (!stateIndex.tasks[taskId]) {
-        spinner.fail(`Task ${taskId} not found in state index.`);
-        return;
-      }
-
-      const task = stateIndex.tasks[taskId];
-      stateIndex.current_focus.primary_task = taskId;
-      stateIndex.current_focus.last_worked_on = taskId;
-      stateIndex.current_focus.session_notes = `Focused on ${task.title}`;
-      
-      // AI 컨텍스트 업데이트
-      stateIndex.ai_context.last_session = new Date().toISOString();
-      stateIndex.ai_context.session_count++;
-
-      await this.saveStateIndex(stateIndex);
-      
-      spinner.succeed(`Focus set to ${taskId}: ${task.title}`);
-      console.log(chalk.cyan(`\n📍 Task Location: ${task.location}`));
-      console.log(chalk.yellow(`📊 Current Status: ${task.status}`));
-      
-      // 관련 태스크 표시
-      const relatedTasks = Object.values(stateIndex.tasks)
-        .filter(t => t.sprint === task.sprint && t.id !== taskId && t.status !== 'completed');
-      
-      if (relatedTasks.length > 0) {
-        console.log(chalk.dim('\n📎 Related tasks in same sprint:'));
-        relatedTasks.forEach(t => {
-          console.log(chalk.dim(`   - ${t.id}: ${t.title} (${t.status})`));
-        });
-      }
-    } catch (error) {
-      spinner.fail(`Failed to set focus: ${error.message}`);
-      throw error;
-    }
-  }
-
-  async completeTask(taskId) {
-    if (!taskId) {
-      console.error(chalk.red('Please provide a task ID'));
-      return;
-    }
-
-    const spinner = ora(`Marking ${taskId} as completed...`).start();
-    
-    try {
-      const stateIndex = await this.loadStateIndex();
-      if (!stateIndex) {
-        spinner.fail('No state index found. Run "aiwf state update" first.');
-        return;
-      }
-
-      if (!stateIndex.tasks[taskId]) {
-        spinner.fail(`Task ${taskId} not found in state index.`);
-        return;
-      }
-
-      const task = stateIndex.tasks[taskId];
-      const previousStatus = task.status;
-      
-      // 태스크 상태 업데이트
-      task.status = 'completed';
-      task.completed = new Date().toISOString();
-      
-      // 메트릭스 업데이트
-      if (previousStatus !== 'completed') {
-        stateIndex.metrics.completed_tasks++;
-        if (previousStatus === 'in_progress') {
-          stateIndex.metrics.in_progress_tasks--;
-        } else if (previousStatus === 'pending') {
-          stateIndex.metrics.pending_tasks--;
-        }
-        
-        // 전체 진행률 재계산
-        stateIndex.metrics.overall_progress = Math.round(
-          (stateIndex.metrics.completed_tasks / stateIndex.metrics.total_tasks) * 100
-        );
-      }
-      
-      // 현재 포커스가 완료된 태스크였다면 비우기
-      if (stateIndex.current_focus.primary_task === taskId) {
-        stateIndex.current_focus.primary_task = null;
-        stateIndex.current_focus.session_notes = `Completed ${task.title}`;
-      }
-      
-      // 스프린트 요약 업데이트
-      const sprint = stateIndex.sprint_summary[task.sprint];
-      if (sprint && previousStatus !== 'completed') {
-        sprint.completed_tasks++;
-        sprint.completion_rate = Math.round(
-          (sprint.completed_tasks / sprint.total_tasks) * 100
-        );
-        
-        if (previousStatus === 'in_progress') {
-          sprint.in_progress_tasks--;
-        } else if (previousStatus === 'pending') {
-          sprint.pending_tasks--;
-        }
-      }
-
-      await this.saveStateIndex(stateIndex);
-      
-      spinner.succeed(`Task ${taskId} marked as completed!`);
-      console.log(chalk.green(`\n✅ ${task.title}`));
-      console.log(chalk.cyan(`📊 Sprint ${task.sprint} progress: ${sprint.completion_rate}%`));
-      console.log(chalk.cyan(`📈 Overall progress: ${stateIndex.metrics.overall_progress}%`));
-      
-      // 다음 추천 태스크
-      await this.suggestNext();
-      
-    } catch (error) {
-      spinner.fail(`Failed to complete task: ${error.message}`);
-      throw error;
-    }
-  }
-
-  async suggestNext() {
-    try {
-      const stateIndex = await this.loadStateIndex();
-      if (!stateIndex) {
-        console.log(chalk.yellow('No state index found. Run "aiwf state update" first.'));
-        return;
-      }
-
-      if (!this.workflowRules) {
-        this.workflowRules = await this.loadWorkflowRules();
-      }
-
-      console.log(chalk.bold('\n🎯 Workflow-Based Next Actions:\n'));
-      
-      // 워크플로우 검증 결과 표시
-      if (stateIndex.workflow_validation) {
-        const { errors, warnings, suggestions } = stateIndex.workflow_validation;
-        
-        if (errors.length > 0) {
-          console.log(chalk.red('❌ Workflow Errors:'));
-          errors.forEach(error => {
-            console.log(`  - ${error.message}`);
-          });
-          console.log('');
-        }
-        
-        if (suggestions.length > 0) {
-          console.log(chalk.yellow('💡 Workflow Suggestions:'));
-          suggestions.forEach(suggestion => {
-            console.log(`  - ${suggestion.message}`);
-          });
-          console.log('');
-        }
-      }
-      
-      // 우선순위 기반 액션 표시
-      const actions = stateIndex.next_actions || [];
-      const inProgress = actions.filter(a => a.task_id && stateIndex.tasks[a.task_id]?.status === 'in_progress');
-      const ready = actions.filter(a => a.priority !== 'blocked' && !inProgress.find(ip => ip.task_id === a.task_id));
-      const blocked = actions.filter(a => a.priority === 'blocked');
-      
-      if (inProgress.length > 0) {
-        console.log(chalk.yellow('🔄 Continue In-Progress Tasks:'));
-        inProgress.forEach(action => {
-          const task = stateIndex.tasks[action.task_id];
-          console.log(`  ${chalk.yellow('→')} ${task.id}: ${task.title}`);
-          console.log(chalk.dim(`     Priority Score: ${action.score}/100`));
-          console.log(chalk.dim(`     Location: ${task.location}`));
-          if (task.blocks?.length > 0) {
-            console.log(chalk.cyan(`     🔗 Blocks: ${task.blocks.join(', ')}`));
-          }
-        });
-      }
-      
-      if (ready.length > 0) {
-        console.log(chalk.blue('\n📋 Ready to Start (Priority Order):'));
-        ready.slice(0, 5).forEach((action, i) => {
-          const task = stateIndex.tasks[action.task_id];
-          const priorityIcon = action.priority === 'high' ? '🔴' : action.priority === 'medium' ? '🟡' : '🟢';
-          console.log(`  ${i + 1}. ${priorityIcon} ${task.id}: ${task.title}`);
-          console.log(chalk.dim(`     Priority Score: ${action.score}/100 - ${action.reason}`));
-          console.log(chalk.dim(`     Location: ${task.location}`));
-          if (task.blocks?.length > 0) {
-            console.log(chalk.cyan(`     🔗 Unblocks: ${task.blocks.join(', ')}`));
-          }
-        });
-      }
-      
-      if (blocked.length > 0) {
-        console.log(chalk.red('\n⛔ Blocked Tasks:'));
-        blocked.slice(0, 3).forEach(action => {
-          const task = stateIndex.tasks[action.task_id];
-          console.log(`  ❌ ${task.id}: ${task.title}`);
-          console.log(chalk.dim(`     ${action.reason}`));
-          console.log(chalk.dim(`     Priority Score: ${action.score}/100 (when unblocked)`));
-        });
-      }
-      
-      // 병렬 작업 기회 식별
-      if (this.workflowRules.ai_behavior.suggest_parallelization && ready.length >= 2) {
-        const parallelizable = ready.filter(a => {
-          const task = stateIndex.tasks[a.task_id];
-          // 서로 의존하지 않는 태스크 찾기
-          return !ready.some(other => 
-            other.task_id !== a.task_id && 
-            (task.dependencies.includes(other.task_id) || 
-             stateIndex.tasks[other.task_id].dependencies.includes(task.id))
-          );
-        });
-        
-        if (parallelizable.length >= 2) {
-          console.log(chalk.magenta('\n⚡ Parallel Work Opportunity:'));
-          console.log('  These tasks can be worked on simultaneously:');
-          parallelizable.slice(0, 3).forEach(action => {
-            const task = stateIndex.tasks[action.task_id];
-            console.log(`  - ${task.id}: ${task.title}`);
-          });
-        }
-      }
-      
-      // 스프린트 전환 조건 확인
-      const currentSprint = stateIndex.project_info.current_sprint;
-      if (currentSprint && stateIndex.sprint_summary[currentSprint]) {
-        const sprint = stateIndex.sprint_summary[currentSprint];
-        
-        if (sprint.completion_rate === 100) {
-          console.log(chalk.green(`\n🎉 Sprint ${currentSprint} Complete!`));
-          console.log('  Next actions:');
-          console.log('  1. Run sprint review: aiwf sprint review');
-          console.log('  2. Transition to next sprint: aiwf transition sprint');
-          console.log('  3. Update project documentation');
-        } else if (sprint.completion_rate >= 80) {
-          console.log(chalk.yellow(`\n📊 Sprint ${currentSprint} is ${sprint.completion_rate}% complete`));
-          console.log('  Consider:');
-          console.log('  - Preparing next sprint tasks');
-          console.log('  - Reviewing remaining tasks');
-          console.log('  - Planning sprint transition');
-        }
-      }
-      
-      console.log(chalk.dim('\n💡 Commands:'));
-      console.log(chalk.dim('  Start task: aiwf state focus <task-id>'));
-      console.log(chalk.dim('  Update state: aiwf state update'));
-      console.log(chalk.dim('  Validate workflow: aiwf validate workflow'));
-      
-    } catch (error) {
-      console.error(chalk.red(`Failed to suggest next actions: ${error.message}`));
-      throw error;
-    }
-  }
-
-  async loadStateIndex() {
-    try {
-      const indexPath = path.join(this.aiwfPath, this.stateFile);
-      const exists = await this.fileExists(indexPath);
-      
-      if (!exists) {
-        return null;
-      }
-      
-      const content = await fs.readFile(indexPath, 'utf-8');
-      return JSON.parse(content);
-    } catch (error) {
-      throw new Error(`Failed to load state index: ${error.message}`);
-    }
-  }
-
-  async loadWorkflowRules() {
-    try {
-      const rulesPath = path.join(this.aiwfPath, this.workflowRulesFile);
-      const exists = await this.fileExists(rulesPath);
-      
-      if (!exists) {
-        // 기본 워크플로우 규칙 생성
-        const defaultRules = {
-          version: '1.0.0',
-          hierarchy: {
-            milestone: {
-              contains: 'sprints',
-              completion_rule: 'all_sprints_completed',
-              transition_rule: 'manual_review_required'
-            },
-            sprint: {
-              contains: 'tasks',
-              completion_rule: 'all_tasks_completed',
-              transition_rule: 'auto_when_complete',
-              preparation_rule: '80_percent_trigger'
-            },
-            task: {
-              completion_rule: 'acceptance_criteria_met',
-              transition_rule: 'immediate'
-            }
-          },
-          priority_matrix: {
-            factors: {
-              urgency: { weight: 0.4, range: [1, 5] },
-              importance: { weight: 0.3, range: [1, 5] },
-              dependencies_blocking: { weight: 0.2, range: [0, 10] },
-              effort: { weight: 0.1, range: [1, 10] }
-            },
-            calculation: 'weighted_sum'
-          },
-          dependency_rules: {
-            strict_mode: true,
-            allow_circular: false,
-            max_chain_length: 10
-          },
-          transition_rules: {
-            task_to_task: {
-              conditions: ['current_complete', 'next_unblocked'],
-              auto_transition: true
-            },
-            sprint_to_sprint: {
-              conditions: ['current_80_percent', 'next_planned'],
-              auto_transition: false,
-              requires_approval: true
-            },
-            milestone_to_milestone: {
-              conditions: ['current_complete', 'review_passed'],
-              auto_transition: false,
-              requires_approval: true
-            }
-          },
-          ai_behavior: {
-            decision_mode: 'conservative',
-            auto_prioritize: true,
-            suggest_parallelization: true,
-            risk_tolerance: 'low'
-          }
-        };
-        
-        await fs.writeFile(rulesPath, JSON.stringify(defaultRules, null, 2));
-        return defaultRules;
-      }
-      
-      const content = await fs.readFile(rulesPath, 'utf-8');
-      return JSON.parse(content);
-    } catch (error) {
-      throw new Error(`Failed to load workflow rules: ${error.message}`);
-    }
-  }
-
-  async saveStateIndex(stateIndex) {
-    try {
-      const indexPath = path.join(this.aiwfPath, this.stateFile);
-      stateIndex.last_updated = new Date().toISOString();
-      await fs.writeFile(indexPath, JSON.stringify(stateIndex, null, 2));
-    } catch (error) {
-      throw new Error(`Failed to save state index: ${error.message}`);
-    }
-  }
-
-  async fileExists(filePath) {
-    try {
-      await fs.access(filePath);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  createProgressBar(percentage) {
-    const width = 20;
-    const filled = Math.round((percentage / 100) * width);
-    const empty = width - filled;
-    return `[${chalk.green('█'.repeat(filled))}${chalk.gray('░'.repeat(empty))}]`;
-  }
-
-  calculateTaskPriority(task, stateIndex) {
-    if (!this.workflowRules || !this.workflowRules.priority_matrix) {
-      return 50; // 기본 우선순위
-    }
-
-    const factors = this.workflowRules.priority_matrix.factors;
-    let totalWeight = 0;
-    let weightedSum = 0;
-
-    // 긴급도 계산 (마감일 기반)
-    const urgency = task.deadline ? this.calculateUrgency(task.deadline) : 3;
-    weightedSum += urgency * factors.urgency.weight;
-    totalWeight += factors.urgency.weight;
-
-    // 중요도 (마일스톤/스프린트 우선순위 기반)
-    const importance = task.priority === 'high' ? 5 : task.priority === 'medium' ? 3 : 1;
-    weightedSum += importance * factors.importance.weight;
-    totalWeight += factors.importance.weight;
-
-    // 블로킹 의존성 수
-    const blockingCount = this.countBlockingDependencies(task, stateIndex);
-    weightedSum += blockingCount * factors.dependencies_blocking.weight;
-    totalWeight += factors.dependencies_blocking.weight;
-
-    // 노력 (예상 시간 기반)
-    const effort = task.estimated_hours ? Math.min(task.estimated_hours / 8, 10) : 5;
-    weightedSum += (10 - effort) * factors.effort.weight; // 낮은 노력이 높은 우선순위
-
-    return Math.round((weightedSum / totalWeight) * 20); // 0-100 스케일로 변환
-  }
-
-  calculateUrgency(deadline) {
-    const now = new Date();
-    const deadlineDate = new Date(deadline);
-    const daysUntilDeadline = Math.floor((deadlineDate - now) / (1000 * 60 * 60 * 24));
-    
-    if (daysUntilDeadline <= 1) return 5;
-    if (daysUntilDeadline <= 3) return 4;
-    if (daysUntilDeadline <= 7) return 3;
-    if (daysUntilDeadline <= 14) return 2;
-    return 1;
-  }
-
-  countBlockingDependencies(task, stateIndex) {
-    // 이 태스크를 의존하는 다른 태스크 수 계산
-    let count = 0;
-    Object.values(stateIndex.tasks).forEach(otherTask => {
-      if (otherTask.dependencies && otherTask.dependencies.includes(task.id)) {
-        count++;
-      }
-    });
-    return Math.min(count, 10);
-  }
-
-  async analyzeDependencies(stateIndex) {
-    const dependencies = {};
-    
-    // 태스크 파일에서 의존성 정보 추출
-    for (const [taskId, task] of Object.entries(stateIndex.tasks)) {
-      dependencies[taskId] = {
-        dependsOn: [],
-        blockedBy: [],
-        blocks: []
-      };
-      
-      // 태스크 파일 읽기
-      try {
-        const taskPath = path.join(this.projectRoot, task.location);
-        const taskContent = await fs.readFile(taskPath, 'utf-8');
-        
-        // 의존성 섹션 찾기
-        const dependencyMatch = taskContent.match(/##\s*의존성.*?\n([\s\S]*?)(?=\n##|$)/i);
-        if (dependencyMatch) {
-          const depSection = dependencyMatch[1];
-          const taskRefs = depSection.match(/T\d+_S\d+/g) || [];
-          dependencies[taskId].dependsOn = taskRefs.filter(ref => ref !== taskId);
-        }
-      } catch (error) {
-        console.warn(`Could not analyze dependencies for ${taskId}: ${error.message}`);
-      }
-    }
-    
-    // 역방향 의존성 계산
-    for (const [taskId, deps] of Object.entries(dependencies)) {
-      deps.dependsOn.forEach(depId => {
-        if (dependencies[depId]) {
-          dependencies[depId].blocks.push(taskId);
-        }
-      });
-    }
-    
-    // 블로킹 태스크 확인
-    for (const [taskId, deps] of Object.entries(dependencies)) {
-      deps.dependsOn.forEach(depId => {
-        const depTask = stateIndex.tasks[depId];
-        if (depTask && depTask.status !== 'completed') {
-          deps.blockedBy.push(depId);
-        }
-      });
-    }
-    
-    return dependencies;
-  }
-
-  async validateWorkflow(stateIndex) {
-    const errors = [];
-    const warnings = [];
-    const suggestions = [];
-    
-    if (!this.workflowRules) {
-      this.workflowRules = await this.loadWorkflowRules();
-    }
-    
-    // 스프린트-태스크 일관성 검증
-    for (const [sprintId, sprint] of Object.entries(stateIndex.sprint_summary)) {
-      if (sprint.status === 'completed') {
-        const incompleteTasks = Object.values(stateIndex.tasks)
-          .filter(t => t.sprint === sprintId && t.status !== 'completed');
-        
-        if (incompleteTasks.length > 0) {
-          errors.push({
-            type: 'INCONSISTENT_STATE',
-            message: `Sprint ${sprintId} marked complete but has ${incompleteTasks.length} incomplete tasks`,
-            sprint: sprintId,
-            tasks: incompleteTasks.map(t => t.id)
-          });
-        }
-      }
-    }
-    
-    // 의존성 순환 확인
-    const dependencies = await this.analyzeDependencies(stateIndex);
-    const cycles = this.detectCycles(dependencies);
-    if (cycles.length > 0) {
-      errors.push({
-        type: 'CIRCULAR_DEPENDENCY',
-        message: 'Circular dependencies detected',
-        cycles: cycles
-      });
-    }
-    
-    // 80% 규칙 확인
-    const currentSprint = stateIndex.project_info.current_sprint;
-    if (currentSprint && stateIndex.sprint_summary[currentSprint]) {
-      const sprint = stateIndex.sprint_summary[currentSprint];
-      if (sprint.completion_rate >= 80 && sprint.completion_rate < 100) {
-        suggestions.push({
-          type: 'SPRINT_PREPARATION',
-          message: `Sprint ${currentSprint} is ${sprint.completion_rate}% complete. Consider preparing the next sprint.`,
-          sprint: currentSprint
-        });
-      }
-    }
-    
-    return { errors, warnings, suggestions };
-  }
-
-  detectCycles(dependencies) {
-    const cycles = [];
-    const visited = new Set();
-    const recursionStack = new Set();
-    
-    const dfs = (taskId, path = []) => {
-      if (recursionStack.has(taskId)) {
-        const cycleStart = path.indexOf(taskId);
-        cycles.push(path.slice(cycleStart));
-        return;
-      }
-      
-      if (visited.has(taskId)) return;
-      
-      visited.add(taskId);
-      recursionStack.add(taskId);
-      path.push(taskId);
-      
-      const deps = dependencies[taskId]?.dependsOn || [];
-      deps.forEach(depId => dfs(depId, [...path]));
-      
-      recursionStack.delete(taskId);
-    };
-    
-    Object.keys(dependencies).forEach(taskId => {
-      if (!visited.has(taskId)) {
-        dfs(taskId);
-      }
-    });
-    
-    return cycles;
-  }
-
-  async validateCommand() {
-    const spinner = ora('Validating workflow...').start();
-    
-    try {
-      // 상태 인덱스 로드
-      const stateIndex = await this.loadStateIndex();
-      if (!stateIndex) {
-        spinner.fail('No state index found. Run "aiwf state update" first.');
-        return;
-      }
-      
-      // 워크플로우 규칙 로드
-      if (!this.workflowRules) {
-        this.workflowRules = await this.loadWorkflowRules();
-      }
-      
-      // 검증 실행
-      const validation = await this.validateWorkflow(stateIndex);
-      spinner.stop();
-      
-      console.log(chalk.bold('\n🔍 Workflow Validation Report\n'));
-      
-      const { errors, warnings, suggestions } = validation;
-      const totalIssues = errors.length + warnings.length;
-      
-      if (totalIssues === 0) {
-        console.log(chalk.green('✅ Workflow validation passed!'));
-        console.log(chalk.dim('  No errors or warnings found.'));
-      } else {
-        console.log(chalk.yellow(`Found ${totalIssues} issue(s):`));
-      }
-      
-      // 오류 표시
-      if (errors.length > 0) {
-        console.log(chalk.red(`\n❌ Errors (${errors.length}):`));
-        errors.forEach((error, i) => {
-          console.log(chalk.red(`  ${i + 1}. ${error.type}`));
-          console.log(`     ${error.message}`);
-          if (error.tasks) {
-            console.log(chalk.dim(`     Affected tasks: ${error.tasks.join(', ')}`));
-          }
-          if (error.cycles) {
-            error.cycles.forEach(cycle => {
-              console.log(chalk.dim(`     Cycle: ${cycle.join(' → ')} → ${cycle[0]}`));
-            });
-          }
-        });
-      }
-      
-      // 경고 표시
-      if (warnings.length > 0) {
-        console.log(chalk.yellow(`\n⚠️  Warnings (${warnings.length}):`));
-        warnings.forEach((warning, i) => {
-          console.log(chalk.yellow(`  ${i + 1}. ${warning.type}`));
-          console.log(`     ${warning.message}`);
-        });
-      }
-      
-      // 제안사항 표시
-      if (suggestions.length > 0) {
-        console.log(chalk.cyan(`\n💡 Suggestions (${suggestions.length}):`));
-        suggestions.forEach((suggestion, i) => {
-          console.log(chalk.cyan(`  ${i + 1}. ${suggestion.type}`));
-          console.log(`     ${suggestion.message}`);
-        });
-      }
-      
-      // 통계 표시
-      console.log(chalk.bold('\n📊 Workflow Statistics:'));
-      console.log(`  Total Tasks: ${Object.keys(stateIndex.tasks).length}`);
-      console.log(`  Active Sprints: ${Object.values(stateIndex.sprint_summary).filter(s => s.status === 'active').length}`);
-      console.log(`  Overall Progress: ${stateIndex.metrics.overall_progress}%`);
-      
-      // 의존성 분석
-      const dependencies = await this.analyzeDependencies(stateIndex);
-      const tasksWithDeps = Object.values(dependencies).filter(d => d.dependsOn.length > 0).length;
-      const blockedTasks = Object.values(dependencies).filter(d => d.blockedBy.length > 0).length;
-      
-      console.log(chalk.bold('\n🔗 Dependency Analysis:'));
-      console.log(`  Tasks with dependencies: ${tasksWithDeps}`);
-      console.log(`  Currently blocked tasks: ${blockedTasks}`);
-      console.log(`  Circular dependencies: ${errors.filter(e => e.type === 'CIRCULAR_DEPENDENCY').length}`);
-      
-      // 권장 조치
-      if (totalIssues > 0 || suggestions.length > 0) {
-        console.log(chalk.bold('\n🎯 Recommended Actions:'));
-        if (errors.some(e => e.type === 'INCONSISTENT_STATE')) {
-          console.log('  1. Fix inconsistent sprint/task states');
-          console.log('     - Update task statuses to match sprint status');
-          console.log('     - Or reopen completed sprints if needed');
-        }
-        if (errors.some(e => e.type === 'CIRCULAR_DEPENDENCY')) {
-          console.log('  2. Resolve circular dependencies');
-          console.log('     - Review and break dependency cycles');
-          console.log('     - Restructure tasks if necessary');
-        }
-        if (suggestions.some(s => s.type === 'SPRINT_PREPARATION')) {
-          console.log('  3. Prepare next sprint');
-          console.log('     - Current sprint is nearing completion');
-          console.log('     - Create tasks for the next sprint');
-        }
-      }
-      
-      console.log('');
-      
-    } catch (error) {
-      spinner.fail(`Validation failed: ${error.message}`);
-      throw error;
-    }
-  }
-
-  showHelp() {
-    console.log('\nUsage: aiwf state <subcommand> [options]');
-    console.log('\nSubcommands:');
-    console.log('  init            Initialize a new state index');
-    console.log('  update          Update state index by scanning all task files');
-    console.log('  show            Show current project state');
-    console.log('  focus <id>      Set focus to a specific task');
-    console.log('  complete <id>   Mark a task as completed');
-    console.log('  next            Suggest next actions based on workflow rules');
-    console.log('  validate        Validate workflow consistency and dependencies');
-    console.log('\nExamples:');
-    console.log('  aiwf state update          # Scan and update all task states');
-    console.log('  aiwf state show            # Display current project state');
-    console.log('  aiwf state focus T03_S02   # Start working on a task');
-    console.log('  aiwf state complete T03_S02 # Mark task as completed');
-    console.log('  aiwf state next            # Get smart task recommendations');
-    console.log('  aiwf state validate        # Check workflow health');
-    console.log('\nWorkflow Features:');
-    console.log('  - Priority-based task recommendations');
-    console.log('  - Dependency tracking and validation');
-    console.log('  - Sprint 80% rule notifications');
-    console.log('  - Parallel work opportunity detection');
-    console.log('  - Workflow consistency validation');
-  }
-}
-
-// CLI 실행
-if (import.meta.url === `file://${process.argv[1]}`) {
-  const command = new StateCommand();
-  command.execute(process.argv.slice(2));
-}