@haoyiyin/workflow 0.2.0 → 0.2.3

package/src/state/cleanup.ts

@@ -0,0 +1,118 @@
+/**
+ * State cleanup utilities
+ */
+import { readdir, rmdir } from 'fs/promises'
+import { join } from 'path'
+import type { PersistenceLayer } from './types.js'
+
+export interface CleanupOptions {
+  maxAgeDays: number
+  maxStates?: number
+  dryRun?: boolean
+}
+
+export interface CleanupResult {
+  deleted: number
+  archived: number
+  errors: string[]
+  paths: string[]
+}
+
+export async function cleanupOldStates(
+  persistence: PersistenceLayer,
+  options: CleanupOptions
+): Promise<CleanupResult> {
+  const result: CleanupResult = {
+    deleted: 0,
+    archived: 0,
+    errors: [],
+    paths: [],
+  }
+
+  try {
+    const ids = await persistence.list()
+    const now = Date.now()
+    const maxAgeMs = options.maxAgeDays * 24 * 60 * 60 * 1000
+
+    for (const id of ids) {
+      try {
+        const state = await persistence.read(id)
+        if (!state) continue
+
+        const age = now - new Date(state.updatedAt).getTime()
+
+        if (age > maxAgeMs) {
+          if (!options.dryRun) {
+            await persistence.archive(id)
+          }
+          result.archived++
+          result.paths.push(id)
+        }
+      } catch (error) {
+        result.errors.push(`Failed to process state ${id}: ${error}`)
+      }
+    }
+
+    return result
+  } catch (error) {
+    result.errors.push(`Cleanup failed: ${error}`)
+    return result
+  }
+}
+
+export async function cleanupEmptyDirs(basePath: string): Promise<void> {
+  try {
+    const entries = await readdir(basePath, { withFileTypes: true })
+
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        const fullPath = join(basePath, entry.name)
+        const files = await readdir(fullPath)
+
+        if (files.length === 0) {
+          await rmdir(fullPath)
+        }
+      }
+    }
+  } catch {
+    // Ignore errors
+  }
+}
+
+export async function getStateStats(basePath: string): Promise<{
+  total: number
+  active: number
+  archived: number
+  oldest?: Date
+  newest?: Date
+}> {
+  const stats = {
+    total: 0,
+    active: 0,
+    archived: 0,
+    oldest: undefined as Date | undefined,
+    newest: undefined as Date | undefined,
+  }
+
+  try {
+    // Count active states
+    const activePath = join(basePath, 'active')
+    const activeFiles = await readdir(activePath)
+    stats.active = activeFiles.filter((f) => f.endsWith('.json')).length
+
+    // Count archived states
+    const archivePath = join(basePath, 'archive')
+    const archiveDirs = await readdir(archivePath)
+    for (const dir of archiveDirs) {
+      const dirPath = join(archivePath, dir)
+      const files = await readdir(dirPath)
+      stats.archived += files.filter((f) => f.endsWith('.json')).length
+    }
+
+    stats.total = stats.active + stats.archived
+
+    return stats
+  } catch {
+    return stats
+  }
+}

package/src/state/index.ts

@@ -0,0 +1,8 @@
+/**
+ * State module index
+ */
+export type { ExecutionState, StateManager, PersistenceLayer, StateOptions } from './types.js'
+export { StateManagerImpl, createStateManager } from './manager.js'
+export { FilePersistence, createPersistence } from './persistence.js'
+export { validateState, isValidState, sanitizeState } from './validator.js'
+export { cleanupOldStates, cleanupEmptyDirs, getStateStats } from './cleanup.js'

package/src/state/manager.ts

@@ -0,0 +1,96 @@
+/**
+ * State manager implementation
+ */
+import { nanoid } from 'nanoid'
+import type {
+  ExecutionState,
+  StateManager,
+  PersistenceLayer,
+} from './types.js'
+import type { WorkflowConfig } from '../types.js'
+import { createPersistence } from './persistence.js'
+
+export class StateManagerImpl implements StateManager {
+  private persistence: PersistenceLayer
+
+  constructor(persistence: PersistenceLayer) {
+    this.persistence = persistence
+  }
+
+  async load(id: string): Promise<ExecutionState | null> {
+    return this.persistence.read(id)
+  }
+
+  async save(state: ExecutionState): Promise<void> {
+    const updated = {
+      ...state,
+      updatedAt: new Date(),
+    }
+    await this.persistence.write(updated)
+  }
+
+  async create(planId: string, _config: WorkflowConfig): Promise<ExecutionState> {
+    const now = new Date()
+    const state: ExecutionState = {
+      id: nanoid(),
+      planId,
+      completedTasks: [],
+      failedTasks: [],
+      startedAt: now,
+      updatedAt: now,
+      status: 'running',
+      context: {},
+    }
+    await this.persistence.write(state)
+    return state
+  }
+
+  async update(
+    id: string,
+    updates: Partial<ExecutionState>
+  ): Promise<ExecutionState> {
+    const existing = await this.persistence.read(id)
+    if (!existing) {
+      throw new Error(`State not found: ${id}`)
+    }
+
+    const updated: ExecutionState = {
+      ...existing,
+      ...updates,
+      id: existing.id,
+      updatedAt: new Date(),
+    }
+    await this.persistence.write(updated)
+    return updated
+  }
+
+  async archive(id: string): Promise<void> {
+    await this.persistence.archive(id)
+  }
+
+  async list(): Promise<ExecutionState[]> {
+    const ids = await this.persistence.list()
+    const states: ExecutionState[] = []
+    for (const id of ids) {
+      const state = await this.persistence.read(id)
+      if (state) {
+        states.push(state)
+      }
+    }
+    return states.sort(
+      (a, b) => b.updatedAt.getTime() - a.updatedAt.getTime()
+    )
+  }
+
+  async getActive(): Promise<ExecutionState | null> {
+    const states = await this.list()
+    return states.find((s) => s.status === 'running') || null
+  }
+}
+
+export function createStateManager(
+  config: WorkflowConfig
+): StateManager {
+  const persistence = createPersistence(config.statePath)
+  return new StateManagerImpl(persistence)
+}

package/src/state/persistence.ts

@@ -0,0 +1,77 @@
+/**
+ * File-based persistence layer for state
+ */
+import { join } from 'path'
+import { readFile, writeFile, mkdir, readdir, rename } from 'fs/promises'
+import { existsSync } from 'fs'
+import type { PersistenceLayer, ExecutionState } from './types.js'
+import { validateState, sanitizeState } from './validator.js'
+
+export class FilePersistence implements PersistenceLayer {
+  private basePath: string
+  private archivePath: string
+
+  constructor(basePath: string) {
+    this.basePath = join(basePath, 'active')
+    this.archivePath = join(basePath, 'archive')
+  }
+
+  async read(id: string): Promise<ExecutionState | null> {
+    const path = join(this.basePath, `${id}.json`)
+    try {
+      const data = await readFile(path, 'utf-8')
+      const parsed = JSON.parse(data)
+
+      // Validate state structure
+      const validation = validateState(parsed)
+      if (!validation.valid) {
+        console.warn(`[State] Invalid state file ${id}:`, validation.errors)
+        return null
+      }
+
+      // Sanitize dates and arrays
+      return sanitizeState(parsed)
+    } catch {
+      return null
+    }
+  }
+
+  async write(state: ExecutionState): Promise<void> {
+    await mkdir(this.basePath, { recursive: true })
+    const path = join(this.basePath, `${state.id}.json`)
+    await writeFile(path, JSON.stringify(state, null, 2))
+  }
+
+  async delete(id: string): Promise<void> {
+    const path = join(this.basePath, `${id}.json`)
+    try {
+      await import('fs/promises').then((fs) => fs.unlink(path))
+    } catch {
+      // Ignore if file doesn't exist
+    }
+  }
+
+  async list(): Promise<string[]> {
+    await mkdir(this.basePath, { recursive: true })
+    const files = await readdir(this.basePath)
+    return files
+      .filter((f) => f.endsWith('.json'))
+      .map((f) => f.replace('.json', ''))
+  }
+
+  async archive(id: string): Promise<void> {
+    const sourcePath = join(this.basePath, `${id}.json`)
+    const date = new Date().toISOString().split('T')[0]
+    const archiveDir = join(this.archivePath, date)
+    await mkdir(archiveDir, { recursive: true })
+    const targetPath = join(archiveDir, `${id}.json`)
+
+    if (existsSync(sourcePath)) {
+      await rename(sourcePath, targetPath)
+    }
+  }
+}
+
+export function createPersistence(basePath: string): PersistenceLayer {
+  return new FilePersistence(basePath)
+}

package/src/state/types.ts

@@ -0,0 +1,30 @@
+/**
+ * State management types
+ */
+import type { ExecutionState as CoreExecutionState, WorkflowConfig } from '../types.js'
+
+// Use alias to avoid naming conflicts
+export type ExecutionState = CoreExecutionState
+
+export interface StateManager {
+  load(id: string): Promise<ExecutionState | null>
+  save(state: ExecutionState): Promise<void>
+  create(planId: string, config: WorkflowConfig): Promise<ExecutionState>
+  update(id: string, updates: Partial<ExecutionState>): Promise<ExecutionState>
+  archive(id: string): Promise<void>
+  list(): Promise<ExecutionState[]>
+  getActive(): Promise<ExecutionState | null>
+}
+
+export interface PersistenceLayer {
+  read(id: string): Promise<ExecutionState | null>
+  write(state: ExecutionState): Promise<void>
+  delete(id: string): Promise<void>
+  list(): Promise<string[]>
+  archive(id: string): Promise<void>
+}
+
+export interface StateOptions {
+  statePath: string
+  autoArchive: boolean
+}

package/src/state/validator.ts

@@ -0,0 +1,78 @@
+/**
+ * State validation utilities
+ */
+import type { ExecutionState } from '../types.js'
+
+export interface ValidationResult {
+  valid: boolean
+  errors: string[]
+}
+
+export function validateState(state: unknown): ValidationResult {
+  const errors: string[] = []
+
+  if (!state || typeof state !== 'object') {
+    return { valid: false, errors: ['State must be an object'] }
+  }
+
+  const s = state as Record<string, unknown>
+
+  // Required fields
+  if (!s.id || typeof s.id !== 'string') {
+    errors.push('State must have a string id')
+  }
+
+  if (!s.planId || typeof s.planId !== 'string') {
+    errors.push('State must have a string planId')
+  }
+
+  if (!s.status || !['running', 'paused', 'completed', 'failed', 'cancelled'].includes(s.status as string)) {
+    errors.push('State must have a valid status')
+  }
+
+  if (!s.startedAt) {
+    errors.push('State must have startedAt')
+  }
+
+  if (!s.updatedAt) {
+    errors.push('State must have updatedAt')
+  }
+
+  // Optional arrays
+  if (s.completedTasks && !Array.isArray(s.completedTasks)) {
+    errors.push('completedTasks must be an array')
+  }
+
+  if (s.failedTasks && !Array.isArray(s.failedTasks)) {
+    errors.push('failedTasks must be an array')
+  }
+
+  if (s.context && typeof s.context !== 'object') {
+    errors.push('context must be an object')
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors,
+  }
+}
+
+export function isValidState(state: unknown): state is ExecutionState {
+  return validateState(state).valid
+}
+
+export function sanitizeState(state: ExecutionState): ExecutionState {
+  return {
+    ...state,
+    id: String(state.id),
+    planId: String(state.planId),
+    completedTasks: Array.isArray(state.completedTasks) ? state.completedTasks : [],
+    failedTasks: Array.isArray(state.failedTasks) ? state.failedTasks : [],
+    status: state.status || 'running',
+    context: typeof state.context === 'object' && state.context !== null
+      ? state.context
+      : {},
+    startedAt: state.startedAt ? new Date(state.startedAt) : new Date(),
+    updatedAt: state.updatedAt ? new Date(state.updatedAt) : new Date(),
+  }
+}

package/src/types.ts

@@ -0,0 +1,102 @@
+/**
+ * Global type definitions for yi-workflow
+ */
+
+// Core workflow types
+export interface WorkflowConfig {
+  planPath: string
+  statePath: string
+  autoCleanup: boolean
+  autoMerge: boolean
+  defaultModel: string
+  maxConcurrent: number
+}
+
+export interface Plan {
+  id: string
+  title: string
+  description: string
+  tasks: Task[]
+  createdAt: Date
+  updatedAt: Date
+  status: PlanStatus
+}
+
+export type PlanStatus = 'draft' | 'approved' | 'in_progress' | 'completed' | 'cancelled'
+
+export interface Task {
+  id: string
+  title: string
+  description: string
+  status: TaskStatus
+  dependencies: string[]
+  estimatedHours?: number
+  actualHours?: number
+}
+
+export type TaskStatus = 'pending' | 'in_progress' | 'completed' | 'blocked'
+
+// Execution state
+export interface ExecutionState {
+  id: string
+  planId: string
+  currentTaskId?: string
+  completedTasks: string[]
+  failedTasks: string[]
+  startedAt: Date
+  updatedAt: Date
+  status: ExecutionStatus
+  context: Record<string, unknown>
+}
+
+export type ExecutionStatus = 'running' | 'paused' | 'completed' | 'failed' | 'cancelled'
+
+// Hook types
+export type HookType = 'pre-plan' | 'post-plan' | 'pre-execute' | 'post-execute' | 'on-error'
+
+export interface HookContext {
+  config: WorkflowConfig
+  state?: ExecutionState
+  plan?: Plan
+  error?: Error
+}
+
+export interface HookDefinition {
+  type: HookType
+  name: string
+  execute: (context: HookContext) => Promise<void> | void
+}
+
+// Skill types
+export interface SkillDefinition {
+  name: string
+  description: string
+  requires?: string[]
+  hooks?: {
+    pre?: HookDefinition[]
+    post?: HookDefinition[]
+    error?: HookDefinition[]
+  }
+  execute: (input: unknown, context: SkillContext) => Promise<unknown>
+}
+
+export interface SkillContext {
+  config: WorkflowConfig
+  state: ExecutionState
+  logger: Logger
+}
+
+// Logger interface
+export interface Logger {
+  info: (message: string, ...args: unknown[]) => void
+  warn: (message: string, ...args: unknown[]) => void
+  error: (message: string, ...args: unknown[]) => void
+  debug: (message: string, ...args: unknown[]) => void
+}
+
+// CLI types
+export interface CLIOptions {
+  verbose?: boolean
+  config?: string
+  model?: string
+}