aiwf 0.3.7 → 0.3.12

package/src/lib/state/priority-calculator.js

@@ -0,0 +1,217 @@
+/**
+ * AIWF Priority Calculator
+ * 태스크 우선순위 계산 및 관리
+ */
+
+export class PriorityCalculator {
+  constructor(workflowRules) {
+    this.weights = workflowRules?.priority_weights || {
+      urgency: 0.4,
+      importance: 0.3,
+      dependencies: 0.2,
+      effort: 0.1
+    };
+  }
+
+  /**
+   * 태스크의 긴급도 계산
+   * - 마감일까지 남은 시간
+   * - 차단된 다른 태스크 수
+   * - 마일스톤 내 위치
+   */
+  calculateUrgency(task, stateIndex) {
+    let urgencyScore = 0;
+
+    // 마감일 기반 점수 (0-1)
+    if (task.due_date) {
+      const dueDate = new Date(task.due_date);
+      const now = new Date();
+      const daysUntilDue = Math.ceil((dueDate - now) / (1000 * 60 * 60 * 24));
+      
+      if (daysUntilDue <= 0) urgencyScore += 1.0;      // 이미 지남
+      else if (daysUntilDue <= 1) urgencyScore += 0.9; // 1일 이내
+      else if (daysUntilDue <= 3) urgencyScore += 0.7; // 3일 이내
+      else if (daysUntilDue <= 7) urgencyScore += 0.5; // 1주 이내
+      else urgencyScore += Math.max(0, 1 - daysUntilDue / 30); // 선형 감소
+    }
+
+    // 차단된 태스크 수 기반 점수
+    const blockedByThis = this.countTasksBlockedBy(task.id, stateIndex);
+    urgencyScore += Math.min(blockedByThis * 0.2, 0.5);
+
+    // 스프린트 진행도 기반 점수
+    if (task.sprint_id && stateIndex.sprint_summary[task.sprint_id]) {
+      const sprintProgress = stateIndex.sprint_summary[task.sprint_id].progress || 0;
+      if (sprintProgress > 0.8) urgencyScore += 0.3; // 스프린트 거의 완료
+      else if (sprintProgress > 0.5) urgencyScore += 0.1;
+    }
+
+    return Math.min(urgencyScore, 1.0);
+  }
+
+  /**
+   * 태스크의 중요도 계산
+   * - 비즈니스 가치
+   * - 아키텍처적 영향
+   * - 프로젝트 목표와의 연관성
+   */
+  calculateImportance(task, stateIndex) {
+    let importanceScore = 0;
+
+    // 태스크 타입별 기본 중요도
+    const typeWeights = {
+      'architecture': 0.9,
+      'security': 0.8,
+      'core-feature': 0.7,
+      'bug-fix': 0.6,
+      'enhancement': 0.5,
+      'documentation': 0.3,
+      'refactoring': 0.4,
+      'testing': 0.5
+    };
+
+    importanceScore += typeWeights[task.type] || 0.5;
+
+    // 마일스톤 중요도 반영
+    if (task.milestone_id) {
+      const milestoneId = task.milestone_id;
+      // M01, M02 등에서 숫자 추출하여 초기 마일스톤일수록 높은 점수
+      const milestoneNum = parseInt(milestoneId.replace(/\D/g, ''));
+      if (milestoneNum <= 2) importanceScore += 0.2;
+      else if (milestoneNum <= 5) importanceScore += 0.1;
+    }
+
+    // 태그 기반 중요도 조정
+    if (task.tags) {
+      if (task.tags.includes('critical')) importanceScore += 0.3;
+      if (task.tags.includes('high-priority')) importanceScore += 0.2;
+      if (task.tags.includes('low-priority')) importanceScore -= 0.2;
+    }
+
+    return Math.min(importanceScore, 1.0);
+  }
+
+  /**
+   * 종속성 점수 계산
+   * - 이 태스크에 의존하는 태스크 수
+   * - 이 태스크가 의존하는 태스크의 완료 상태
+   */
+  calculateDependencyScore(task, stateIndex) {
+    let dependencyScore = 0;
+
+    // 이 태스크를 차단하는 미완료 종속성
+    const blockingDependencies = task.dependencies?.filter(depId => {
+      const depTask = stateIndex.tasks[depId];
+      return depTask && depTask.status !== 'completed';
+    }) || [];
+
+    if (blockingDependencies.length === 0) {
+      dependencyScore += 0.5; // 차단 요소 없음
+    } else {
+      dependencyScore -= blockingDependencies.length * 0.2; // 차단 요소마다 감점
+    }
+
+    // 이 태스크에 의존하는 태스크 수
+    const dependentCount = this.countTasksBlockedBy(task.id, stateIndex);
+    dependencyScore += Math.min(dependentCount * 0.15, 0.5);
+
+    return Math.max(0, Math.min(dependencyScore, 1.0));
+  }
+
+  /**
+   * 노력 점수 계산 (낮을수록 높은 점수)
+   * - 예상 작업 시간
+   * - 복잡도
+   * - 필요한 리소스
+   */
+  calculateEffortScore(task) {
+    let effortScore = 1.0; // 기본값: 쉬운 태스크
+
+    // 예상 시간 기반 점수
+    if (task.estimated_hours) {
+      if (task.estimated_hours <= 1) effortScore = 1.0;      // 1시간 이하
+      else if (task.estimated_hours <= 4) effortScore = 0.8; // 4시간 이하
+      else if (task.estimated_hours <= 8) effortScore = 0.6; // 1일 이하
+      else if (task.estimated_hours <= 16) effortScore = 0.4; // 2일 이하
+      else effortScore = 0.2; // 2일 초과
+    }
+
+    // 복잡도 기반 조정
+    if (task.complexity) {
+      const complexityWeights = {
+        'low': 1.0,
+        'medium': 0.7,
+        'high': 0.4,
+        'very-high': 0.2
+      };
+      effortScore *= complexityWeights[task.complexity] || 0.7;
+    }
+
+    // 태그 기반 조정 (간단한 태스크들)
+    if (task.tags) {
+      if (task.tags.includes('quick-fix')) effortScore += 0.2;
+      if (task.tags.includes('research-heavy')) effortScore -= 0.3;
+    }
+
+    return Math.max(0.1, Math.min(effortScore, 1.0));
+  }
+
+  /**
+   * 전체 우선순위 점수 계산
+   */
+  calculatePriority(task, stateIndex) {
+    const urgency = this.calculateUrgency(task, stateIndex);
+    const importance = this.calculateImportance(task, stateIndex);
+    const dependency = this.calculateDependencyScore(task, stateIndex);
+    const effort = this.calculateEffortScore(task);
+
+    const priority = (
+      urgency * this.weights.urgency +
+      importance * this.weights.importance +
+      dependency * this.weights.dependencies +
+      effort * this.weights.effort
+    );
+
+    return {
+      total: Math.round(priority * 100) / 100,
+      breakdown: {
+        urgency: Math.round(urgency * 100) / 100,
+        importance: Math.round(importance * 100) / 100,
+        dependency: Math.round(dependency * 100) / 100,
+        effort: Math.round(effort * 100) / 100
+      }
+    };
+  }
+
+  /**
+   * 특정 태스크에 의해 차단된 태스크 수 계산
+   */
+  countTasksBlockedBy(taskId, stateIndex) {
+    let count = 0;
+    for (const [, task] of Object.entries(stateIndex.tasks)) {
+      if (task.dependencies?.includes(taskId) && task.status !== 'completed') {
+        count++;
+      }
+    }
+    return count;
+  }
+
+  /**
+   * 모든 태스크의 우선순위 재계산
+   */
+  recalculateAllPriorities(stateIndex) {
+    const updatedTasks = {};
+    
+    for (const [taskId, task] of Object.entries(stateIndex.tasks)) {
+      const priorityData = this.calculatePriority(task, stateIndex);
+      updatedTasks[taskId] = {
+        ...task,
+        priority_score: priorityData.total,
+        priority_breakdown: priorityData.breakdown,
+        last_priority_update: new Date().toISOString()
+      };
+    }
+
+    return updatedTasks;
+  }
+}

package/src/lib/state/state-index.js

@@ -0,0 +1,155 @@
+/**
+ * AIWF State Index Manager
+ * 중앙 상태 인덱스 파일의 생성, 로드, 저장을 담당
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+import { existsSync } from 'fs';
+
+export class StateIndexManager {
+  constructor(aiwfPath) {
+    this.aiwfPath = aiwfPath;
+    this.stateFile = 'task-state-index.json';
+    this.workflowRulesFile = 'workflow-rules.json';
+  }
+
+  get indexPath() {
+    return path.join(this.aiwfPath, this.stateFile);
+  }
+
+  get workflowRulesPath() {
+    return path.join(this.aiwfPath, this.workflowRulesFile);
+  }
+
+  /**
+   * 파일 존재 여부 확인
+   */
+  async fileExists(filePath) {
+    try {
+      await fs.access(filePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  /**
+   * 초기 상태 구조 생성
+   */
+  createInitialState(projectRoot) {
+    return {
+      version: '1.0.0',
+      last_updated: new Date().toISOString(),
+      last_updated_by: 'aiwf-state-init',
+      project_info: {
+        name: path.basename(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
+      }
+    };
+  }
+
+  /**
+   * 상태 인덱스 초기화
+   */
+  async initializeIndex(projectRoot) {
+    const exists = await this.fileExists(this.indexPath);
+    
+    if (exists) {
+      return { success: false, message: 'State index already exists' };
+    }
+
+    const initialState = this.createInitialState(projectRoot);
+    await fs.writeFile(this.indexPath, JSON.stringify(initialState, null, 2));
+    
+    return { success: true, message: 'State index initialized successfully' };
+  }
+
+  /**
+   * 상태 인덱스 로드
+   */
+  async loadIndex() {
+    if (!existsSync(this.indexPath)) {
+      return null;
+    }
+
+    try {
+      const content = await fs.readFile(this.indexPath, 'utf8');
+      return JSON.parse(content);
+    } catch (error) {
+      throw new Error(`Failed to load state index: ${error.message}`);
+    }
+  }
+
+  /**
+   * 상태 인덱스 저장
+   */
+  async saveIndex(stateIndex) {
+    stateIndex.last_updated = new Date().toISOString();
+    stateIndex.last_updated_by = 'aiwf-state-update';
+    
+    await fs.writeFile(this.indexPath, JSON.stringify(stateIndex, null, 2));
+  }
+
+  /**
+   * 워크플로우 규칙 로드
+   */
+  async loadWorkflowRules() {
+    if (!existsSync(this.workflowRulesPath)) {
+      // 기본 워크플로우 규칙 생성
+      const defaultRules = {
+        priority_weights: {
+          urgency: 0.4,
+          importance: 0.3,
+          dependencies: 0.2,
+          effort: 0.1
+        },
+        completion_threshold: 0.8,
+        max_active_tasks: 3,
+        dependency_timeout_days: 7,
+        status_transitions: {
+          'pending': ['in_progress', 'blocked'],
+          'in_progress': ['completed', 'blocked', 'pending'],
+          'blocked': ['in_progress', 'pending'],
+          'completed': []
+        }
+      };
+      
+      await fs.writeFile(this.workflowRulesPath, JSON.stringify(defaultRules, null, 2));
+      return defaultRules;
+    }
+
+    try {
+      const content = await fs.readFile(this.workflowRulesPath, 'utf8');
+      return JSON.parse(content);
+    } catch (error) {
+      throw new Error(`Failed to load workflow rules: ${error.message}`);
+    }
+  }
+}

package/src/lib/state/task-scanner.js

@@ -0,0 +1,328 @@
+/**
+ * AIWF Task Scanner
+ * 프로젝트 디렉토리에서 태스크 파일들을 스캔하고 파싱
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+import { glob } from 'glob';
+
+export class TaskScanner {
+  constructor(aiwfPath) {
+    this.aiwfPath = aiwfPath;
+  }
+
+  /**
+   * 스프린트 디렉토리 스캔
+   */
+  async scanSprintDirectories() {
+    try {
+      const sprintDirs = await glob('03_SPRINTS/S*/', { cwd: this.aiwfPath });
+      const sprintData = {};
+
+      for (const sprintDir of sprintDirs) {
+        const sprintId = path.basename(sprintDir);
+        const fullSprintPath = path.join(this.aiwfPath, sprintDir);
+        
+        // 스프린트 메타 파일 찾기
+        const metaFiles = await glob('*_meta.md', { cwd: fullSprintPath });
+        let sprintMeta = {};
+        
+        if (metaFiles.length > 0) {
+          const metaPath = path.join(fullSprintPath, metaFiles[0]);
+          sprintMeta = await this.parseSprintMeta(metaPath);
+        }
+
+        // 태스크 파일들 스캔
+        const taskFiles = await glob('T*.md', { cwd: fullSprintPath });
+        const tasks = {};
+        
+        for (const taskFile of taskFiles) {
+          const taskPath = path.join(fullSprintPath, taskFile);
+          const taskData = await this.parseTaskFile(taskPath, sprintId);
+          if (taskData) {
+            tasks[taskData.id] = taskData;
+          }
+        }
+
+        sprintData[sprintId] = {
+          meta: sprintMeta,
+          tasks: tasks,
+          task_count: taskFiles.length,
+          path: sprintDir
+        };
+      }
+
+      return sprintData;
+    } catch (error) {
+      throw new Error(`Failed to scan sprint directories: ${error.message}`);
+    }
+  }
+
+  /**
+   * 일반 태스크 디렉토리 스캔
+   */
+  async scanGeneralTasks() {
+    try {
+      const generalTasksPath = path.join(this.aiwfPath, '04_GENERAL_TASKS');
+      const taskFiles = await glob('*.md', { cwd: generalTasksPath });
+      const tasks = {};
+
+      for (const taskFile of taskFiles) {
+        const taskPath = path.join(generalTasksPath, taskFile);
+        const taskData = await this.parseTaskFile(taskPath, 'general');
+        if (taskData) {
+          tasks[taskData.id] = taskData;
+        }
+      }
+
+      return tasks;
+    } catch (error) {
+      // 일반 태스크 디렉토리가 없으면 빈 객체 반환
+      return {};
+    }
+  }
+
+  /**
+   * 스프린트 메타 파일 파싱
+   */
+  async parseSprintMeta(filePath) {
+    try {
+      const content = await fs.readFile(filePath, 'utf8');
+      const meta = {
+        status: 'planned',
+        progress: 0,
+        start_date: null,
+        end_date: null,
+        goals: [],
+        deliverables: []
+      };
+
+      // YAML frontmatter 파싱
+      const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+      if (frontmatterMatch) {
+        const frontmatter = frontmatterMatch[1];
+        
+        // 간단한 YAML 파싱 (key: value 형태)
+        const lines = frontmatter.split('\n');
+        for (const line of lines) {
+          const [key, ...valueParts] = line.split(':');
+          if (key && valueParts.length > 0) {
+            const value = valueParts.join(':').trim();
+            meta[key.trim()] = value;
+          }
+        }
+      }
+
+      // 본문에서 목표와 결과물 추출
+      const bodyContent = content.replace(/^---\n[\s\S]*?\n---\n/, '');
+      
+      // 목표 섹션 찾기
+      const goalsMatch = bodyContent.match(/## 목표[^#]*?((?:- .*\n?)*)/i);
+      if (goalsMatch) {
+        meta.goals = goalsMatch[1]
+          .split('\n')
+          .filter(line => line.trim().startsWith('-'))
+          .map(line => line.replace(/^-\s*/, '').trim());
+      }
+
+      // 결과물 섹션 찾기
+      const deliverablesMatch = bodyContent.match(/## 결과물[^#]*?((?:- .*\n?)*)/i);
+      if (deliverablesMatch) {
+        meta.deliverables = deliverablesMatch[1]
+          .split('\n')
+          .filter(line => line.trim().startsWith('-'))
+          .map(line => line.replace(/^-\s*/, '').trim());
+      }
+
+      return meta;
+    } catch (error) {
+      console.warn(`Failed to parse sprint meta ${filePath}: ${error.message}`);
+      return {};
+    }
+  }
+
+  /**
+   * 태스크 파일 파싱
+   */
+  async parseTaskFile(filePath, sprintId) {
+    try {
+      const content = await fs.readFile(filePath, 'utf8');
+      const fileName = path.basename(filePath, '.md');
+      
+      const task = {
+        id: fileName,
+        sprint_id: sprintId,
+        title: this.extractTitle(content),
+        status: this.determineStatus(content),
+        description: this.extractDescription(content),
+        tags: this.extractTags(content),
+        dependencies: this.extractDependencies(content),
+        assignee: this.extractAssignee(content),
+        created_date: this.extractCreatedDate(filePath),
+        updated_date: this.extractUpdatedDate(filePath),
+        estimated_hours: this.extractEstimatedHours(content),
+        complexity: this.extractComplexity(content),
+        type: this.extractTaskType(content),
+        milestone_id: this.extractMilestoneId(sprintId),
+        file_path: filePath,
+        progress_notes: this.extractProgressNotes(content)
+      };
+
+      return task;
+    } catch (error) {
+      console.warn(`Failed to parse task file ${filePath}: ${error.message}`);
+      return null;
+    }
+  }
+
+  /**
+   * 태스크 제목 추출
+   */
+  extractTitle(content) {
+    const titleMatch = content.match(/^#\s+(.+)$/m);
+    return titleMatch ? titleMatch[1].trim() : 'Untitled Task';
+  }
+
+  /**
+   * 태스크 상태 결정
+   */
+  determineStatus(content) {
+    // OUTPUT LOG에서 완료 표시 확인
+    if (content.includes('## OUTPUT LOG') || content.includes('✅ 완료')) {
+      const outputSection = content.match(/## OUTPUT LOG([\s\S]*?)(?=##|$)/i);
+      if (outputSection && outputSection[1].trim().length > 50) {
+        return 'completed';
+      }
+    }
+
+    // 진행 중 표시 확인
+    if (content.includes('🔄') || content.includes('진행 중') || content.includes('in progress')) {
+      return 'in_progress';
+    }
+
+    // 차단됨 표시 확인
+    if (content.includes('❌') || content.includes('차단') || content.includes('blocked')) {
+      return 'blocked';
+    }
+
+    return 'pending';
+  }
+
+  /**
+   * 태스크 설명 추출
+   */
+  extractDescription(content) {
+    // 첫 번째 헤더 다음부터 두 번째 헤더 전까지
+    const descMatch = content.match(/^#[^#\n]*\n([\s\S]*?)(?=\n##|\n#|$)/);
+    return descMatch ? descMatch[1].trim().substring(0, 200) : '';
+  }
+
+  /**
+   * 태그 추출
+   */
+  extractTags(content) {
+    const tagMatches = content.match(/#(\w+)/g);
+    return tagMatches ? tagMatches.map(tag => tag.substring(1)) : [];
+  }
+
+  /**
+   * 종속성 추출
+   */
+  extractDependencies(content) {
+    const depMatches = content.match(/depends on:?\s*([T\d\s,]+)/i);
+    if (depMatches) {
+      return depMatches[1]
+        .split(/[,\s]+/)
+        .filter(dep => dep.match(/^T\d+$/))
+        .map(dep => dep.trim());
+    }
+    return [];
+  }
+
+  /**
+   * 담당자 추출
+   */
+  extractAssignee(content) {
+    const assigneeMatch = content.match(/assignee:?\s*([^\n]+)/i);
+    return assigneeMatch ? assigneeMatch[1].trim() : null;
+  }
+
+  /**
+   * 생성일 추출 (파일 생성 시간 기반)
+   */
+  async extractCreatedDate(filePath) {
+    try {
+      const stats = await fs.stat(filePath);
+      return stats.birthtime.toISOString();
+    } catch {
+      return new Date().toISOString();
+    }
+  }
+
+  /**
+   * 수정일 추출 (파일 수정 시간 기반)
+   */
+  async extractUpdatedDate(filePath) {
+    try {
+      const stats = await fs.stat(filePath);
+      return stats.mtime.toISOString();
+    } catch {
+      return new Date().toISOString();
+    }
+  }
+
+  /**
+   * 예상 시간 추출
+   */
+  extractEstimatedHours(content) {
+    const hourMatch = content.match(/estimated:?\s*(\d+\.?\d*)\s*hours?/i);
+    return hourMatch ? parseFloat(hourMatch[1]) : null;
+  }
+
+  /**
+   * 복잡도 추출
+   */
+  extractComplexity(content) {
+    const complexityMatch = content.match(/complexity:?\s*(low|medium|high|very-high)/i);
+    return complexityMatch ? complexityMatch[1].toLowerCase() : null;
+  }
+
+  /**
+   * 태스크 타입 추출
+   */
+  extractTaskType(content) {
+    const typeMatch = content.match(/type:?\s*([^\n]+)/i);
+    if (typeMatch) {
+      return typeMatch[1].trim().toLowerCase();
+    }
+
+    // 제목이나 내용에서 타입 추정
+    const title = this.extractTitle(content).toLowerCase();
+    if (title.includes('bug') || title.includes('fix')) return 'bug-fix';
+    if (title.includes('test')) return 'testing';
+    if (title.includes('doc')) return 'documentation';
+    if (title.includes('refactor')) return 'refactoring';
+    if (title.includes('feature')) return 'core-feature';
+    
+    return 'enhancement';
+  }
+
+  /**
+   * 마일스톤 ID 추출 (스프린트 ID에서)
+   */
+  extractMilestoneId(sprintId) {
+    if (sprintId === 'general') return null;
+    
+    const milestoneMatch = sprintId.match(/S\d+_M(\d+)/);
+    return milestoneMatch ? `M${milestoneMatch[1].padStart(2, '0')}` : null;
+  }
+
+  /**
+   * 진행 노트 추출
+   */
+  extractProgressNotes(content) {
+    const notesMatch = content.match(/## 진행 상황([\s\S]*?)(?=##|$)/i);
+    return notesMatch ? notesMatch[1].trim() : '';
+  }
+}