aiwf 0.3.21 → 0.3.23

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

@@ -1,217 +0,0 @@
-/**
- * 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

@@ -1,155 +0,0 @@
-/**
- * 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

@@ -1,328 +0,0 @@
-/**
- * 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() : '';
-  }
-}