@haoyiyin/workflow 0.2.2 → 0.2.4

package/src/persistence/plan-md.ts

@@ -0,0 +1,141 @@
+/**
+ * PLAN.md manager for execution plan persistence
+ */
+import { promises as fs } from 'fs'
+import { dirname } from 'path'
+import type { Plan, Task, PlanMdManager as IPlanMdManager } from './types.js'
+
+export class PlanMdManager implements IPlanMdManager {
+  private planPath: string
+
+  constructor(planPath: string = '.pi/state/PLAN.md') {
+    this.planPath = planPath
+  }
+
+  async writePlan(plan: Plan): Promise<void> {
+    // Ensure directory exists
+    await fs.mkdir(dirname(this.planPath), { recursive: true })
+
+    const content = this.generatePlanMarkdown(plan)
+    await fs.writeFile(this.planPath, content, 'utf-8')
+  }
+
+  async readPlan(): Promise<Plan> {
+    const content = await fs.readFile(this.planPath, 'utf-8')
+    return this.parsePlan(content)
+  }
+
+  async updateTaskStatus(taskId: string, status: 'pending' | 'in_progress' | 'complete'): Promise<void> {
+    const content = await fs.readFile(this.planPath, 'utf-8')
+    const statusChar = status === 'complete' ? 'x' : status === 'in_progress' ? '~' : ' '
+    const updated = content.replace(
+      new RegExp(`- \\[.] ${taskId}:`),
+      `- [${statusChar}] ${taskId}:`
+    )
+    await fs.writeFile(this.planPath, updated, 'utf-8')
+  }
+
+  private generatePlanMarkdown(plan: Plan): string {
+    return `# Execution Plan
+
+## Goal
+${plan.goal}
+
+## Tasks
+${plan.tasks.map(t => `- [ ] ${t.id}: ${t.description} (${t.estimatedComplexity})`).join('\n')}
+
+## Dependencies
+${Object.entries(plan.dependencies).length > 0
+      ? Object.entries(plan.dependencies).map(([task, deps]) => `- ${task}: ${deps.join(', ')}`).join('\n')
+      : '- No dependencies'
+    }
+
+## Waves
+${plan.waves.map(w => `- ${w.id}: ${w.tasks.join(', ')}`).join('\n')}
+
+## Verification Criteria
+${plan.verificationCriteria.map(c => `- ${c}`).join('\n')}
+
+## Estimated Effort
+- Total Tasks: ${plan.tasks.length}
+- Parallel Waves: ${plan.waves.length}
+- Estimated Duration: ${plan.estimatedDuration}ms
+
+## Rationale
+${plan.rationale}
+`
+  }
+
+  private parsePlan(content: string): Plan {
+    const goalMatch = content.match(/## Goal\n(.+)/)
+    const tasksMatch = content.match(/## Tasks\n([\s\S]*?)(?=\n## |$)/)
+    const depsMatch = content.match(/## Dependencies\n([\s\S]*?)(?=\n## |$)/)
+    const wavesMatch = content.match(/## Waves\n([\s\S]*?)(?=\n## |$)/)
+    const criteriaMatch = content.match(/## Verification Criteria\n([\s\S]*?)(?=\n## |$)/)
+    const durationMatch = content.match(/- Estimated Duration: (\d+)/)
+    const rationaleMatch = content.match(/## Rationale\n([\s\S]*?)(?=\n## |$)/)
+
+    // Parse tasks
+    const tasks: Task[] = []
+    if (tasksMatch) {
+      const taskLines = tasksMatch[1].split('\n').filter(l => l.trim().startsWith('- ['))
+      for (const line of taskLines) {
+        const match = line.match(/- \[[x\s~]]\s+(\w+):\s+(.+)\s+\((\w+)\)/)
+        if (match) {
+          tasks.push({
+            id: match[1],
+            description: match[2],
+            estimatedComplexity: match[3] as 'low' | 'medium' | 'high'
+          })
+        }
+      }
+    }
+
+    // Parse dependencies
+    const dependencies: Record<string, string[]> = {}
+    if (depsMatch && depsMatch[1].trim() !== '- No dependencies') {
+      const depLines = depsMatch[1].split('\n').filter(l => l.trim().startsWith('- '))
+      for (const line of depLines) {
+        const match = line.match(/- (\w+):\s*(.+)/)
+        if (match) {
+          dependencies[match[1]] = match[2].split(',').map(s => s.trim()).filter(s => s)
+        }
+      }
+    }
+
+    // Parse waves
+    const waves = []
+    if (wavesMatch) {
+      const waveLines = wavesMatch[1].split('\n').filter(l => l.trim().startsWith('- '))
+      for (const line of waveLines) {
+        const match = line.match(/- (\w+):\s*(.+)/)
+        if (match) {
+          waves.push({
+            id: match[1],
+            tasks: match[2].split(',').map(s => s.trim()).filter(s => s)
+          })
+        }
+      }
+    }
+
+    // Parse verification criteria
+    const verificationCriteria: string[] = []
+    if (criteriaMatch) {
+      const criteriaLines = criteriaMatch[1].split('\n').filter(l => l.trim().startsWith('- '))
+      for (const line of criteriaLines) {
+        const criterion = line.replace(/^- /, '').trim()
+        if (criterion) verificationCriteria.push(criterion)
+      }
+    }
+
+    return {
+      goal: goalMatch?.[1] || '',
+      tasks,
+      dependencies,
+      waves,
+      verificationCriteria,
+      estimatedDuration: durationMatch ? parseInt(durationMatch[1], 10) : 0,
+      rationale: rationaleMatch?.[1]?.trim() || ''
+    }
+  }
+}

package/src/persistence/state-md.ts

@@ -0,0 +1,167 @@
+/**
+ * STATE.md manager for workflow state persistence
+ */
+import { promises as fs } from 'fs'
+import { dirname } from 'path'
+import type { WorkflowState, Plan, TaskResult, VerificationResult, StateMdManager as IStateMdManager } from './types.js'
+
+export class StateMdManager implements IStateMdManager {
+  private statePath: string
+
+  constructor(statePath: string = '.pi/state/STATE.md') {
+    this.statePath = statePath
+  }
+
+  async initialize(goal: string): Promise<void> {
+    // Ensure directory exists
+    await fs.mkdir(dirname(this.statePath), { recursive: true })
+
+    const content = `# Workflow State
+
+## Goal
+${goal}
+
+## Status
+- Phase: planning
+- Started: ${new Date().toISOString()}
+- Last Updated: ${new Date().toISOString()}
+
+## Plan
+<!-- Populated by plan skill -->
+
+## Completed Tasks
+<!-- Updated during execution -->
+
+## Verification Results
+<!-- Populated by verify phase -->
+
+## Token Usage
+- Plan Phase: 0
+- Execute Phase: 0
+- Verify Phase: 0
+- Total: 0 / 1000000
+`
+    await fs.writeFile(this.statePath, content, 'utf-8')
+  }
+
+  async updatePhase(phase: WorkflowState['phase']): Promise<void> {
+    const content = await fs.readFile(this.statePath, 'utf-8')
+    const updated = content.replace(
+      /- Phase: .*/,
+      `- Phase: ${phase}`
+    ).replace(
+      /- Last Updated: .*/,
+      `- Last Updated: ${new Date().toISOString()}`
+    )
+    await fs.writeFile(this.statePath, updated, 'utf-8')
+  }
+
+  async recordPlan(plan: Plan): Promise<void> {
+    const content = await fs.readFile(this.statePath, 'utf-8')
+    const planSection = this.formatPlanSection(plan)
+    const updated = this.replaceSection(content, 'Plan', planSection)
+    await fs.writeFile(this.statePath, updated, 'utf-8')
+  }
+
+  async recordTaskComplete(taskId: string, result: TaskResult): Promise<void> {
+    const content = await fs.readFile(this.statePath, 'utf-8')
+    const entry = `- [x] ${taskId}: ${result.success ? '✓' : '✗'} (${result.duration}ms) - ${result.notes || ''}\n`
+    const updated = this.appendToSection(content, 'Completed Tasks', entry)
+    await fs.writeFile(this.statePath, updated, 'utf-8')
+  }
+
+  async recordVerification(verification: VerificationResult): Promise<void> {
+    const content = await fs.readFile(this.statePath, 'utf-8')
+    const verificationSection = this.formatVerificationSection(verification)
+    const updated = this.replaceSection(content, 'Verification Results', verificationSection)
+    await fs.writeFile(this.statePath, updated, 'utf-8')
+  }
+
+  async readCurrentState(): Promise<WorkflowState> {
+    const content = await fs.readFile(this.statePath, 'utf-8')
+    return this.parseState(content)
+  }
+
+  private formatPlanSection(plan: Plan): string {
+    return `
+### Goal
+${plan.goal}
+
+### Tasks (${plan.tasks.length})
+${plan.tasks.map(t => `- ${t.id}: ${t.description} (${t.estimatedComplexity})`).join('\n')}
+
+### Waves (${plan.waves.length})
+${plan.waves.map(w => `- ${w.id}: ${w.tasks.join(', ')}`).join('\n')}
+
+### Verification Criteria
+${plan.verificationCriteria.map(c => `- ${c}`).join('\n')}
+
+### Estimated Duration
+${plan.estimatedDuration}ms
+
+### Rationale
+${plan.rationale}
+`
+  }
+
+  private formatVerificationSection(verification: VerificationResult): string {
+    const results: string[] = []
+    if (verification.dimensions.goals) {
+      results.push(`- Goals: ${verification.dimensions.goals.success ? '✓ PASS' : '✗ FAIL'}`)
+    }
+    if (verification.dimensions.quality) {
+      results.push(`- Quality: ${verification.dimensions.quality.success ? '✓ PASS' : '✗ FAIL'}`)
+    }
+    if (verification.dimensions.tests) {
+      results.push(`- Tests: ${verification.dimensions.tests.success ? '✓ PASS' : '✗ FAIL'}`)
+    }
+    results.push(`- Overall: ${verification.success ? '✓ PASSED' : '✗ FAILED'}`)
+
+    return `
+${results.join('\n')}
+`
+  }
+
+  private replaceSection(content: string, sectionName: string, newContent: string): string {
+    const pattern = new RegExp(`(## ${sectionName}\\n)([\\s\\S]*?)(?=\\n## |$)`, 'g')
+    return content.replace(pattern, `## ${sectionName}\n${newContent}\n`)
+  }
+
+  private appendToSection(content: string, sectionName: string, entry: string): string {
+    const pattern = new RegExp(`(## ${sectionName}\\n)([\\s\\S]*?)(?=\\n## |$)`, 'g')
+    const match = pattern.exec(content)
+    if (match) {
+      const current = match[2] || ''
+      return content.replace(pattern, `## ${sectionName}\n${current}${entry}`)
+    }
+    return content
+  }
+
+  private parseState(content: string): WorkflowState {
+    const phaseMatch = content.match(/- Phase: (\w+)/)
+    const goalMatch = content.match(/## Goal\n(.+)/)
+    const startedMatch = content.match(/- Started: (.+)/)
+    const totalMatch = content.match(/### Tasks \((\d+)\)/)
+    const completedMatch = content.match(/## Completed Tasks\n([\s\S]*?)(?=\n## |$)/)
+
+    const completedTasks = completedMatch
+      ? completedMatch[1].split('\n').filter(l => l.trim().startsWith('- [x]')).length
+      : 0
+
+    const totalTasks = totalMatch ? parseInt(totalMatch[1], 10) : 0
+
+    return {
+      goal: goalMatch?.[1] || '',
+      phase: (phaseMatch?.[1] as WorkflowState['phase']) || 'planning',
+      started: startedMatch?.[1] || new Date().toISOString(),
+      lastUpdated: new Date().toISOString(),
+      totalTasks,
+      completedTasks: [],
+      tokenUsage: {
+        used: 0,
+        limit: 1000000,
+        percentage: 0
+      }
+    }
+  }
+}

package/src/persistence/types.ts

@@ -0,0 +1,89 @@
+/**
+ * Persistence layer types for STATE.md and PLAN.md
+ */
+
+export interface Task {
+  id: string
+  description: string
+  estimatedComplexity: 'low' | 'medium' | 'high'
+  relatedFiles?: string[]
+  verificationCriteria?: string[]
+}
+
+export interface Wave {
+  id: string
+  tasks: string[]
+}
+
+export interface Plan {
+  goal: string
+  tasks: Task[]
+  dependencies: Record<string, string[]>
+  waves: Wave[]
+  verificationCriteria: string[]
+  estimatedDuration: number
+  rationale: string
+}
+
+export interface TaskResult {
+  taskId: string
+  success: boolean
+  filesModified: string[]
+  testsAdded: string[]
+  duration: number
+  notes: string
+  error?: string
+  phases?: { phase: string; status: string; command?: string; evidence?: string }[]
+  worktreePath?: string
+  branchName?: string
+}
+
+export interface VerificationResult {
+  success: boolean
+  dimensions: {
+    goals?: DimensionResult
+    quality?: DimensionResult
+    tests?: DimensionResult
+  }
+}
+
+export interface DimensionResult {
+  success: boolean
+  details?: unknown
+  evidence?: string[]
+  gaps?: string[]
+}
+
+export interface WorkflowState {
+  goal: string
+  phase: 'planning' | 'executing' | 'verifying' | 'complete'
+  started: string
+  lastUpdated: string
+  totalTasks: number
+  completedTasks: TaskResult[]
+  tokenUsage: {
+    used: number
+    limit: number
+    percentage: number
+  }
+}
+
+export interface StateMdManager {
+  initialize(goal: string): Promise<void>
+  updatePhase(phase: WorkflowState['phase']): Promise<void>
+  recordPlan(plan: Plan): Promise<void>
+  recordTaskComplete(taskId: string, result: TaskResult): Promise<void>
+  recordVerification(verification: VerificationResult): Promise<void>
+  readCurrentState(): Promise<WorkflowState>
+}
+
+export interface PlanMdManager {
+  writePlan(plan: Plan): Promise<void>
+  readPlan(): Promise<Plan>
+  updateTaskStatus(taskId: string, status: 'pending' | 'in_progress' | 'complete'): Promise<void>
+}
+
+export interface PersistenceManager {
+  state: StateMdManager
+  plan: PlanMdManager
+}