@haoyiyin/workflow 0.2.2 → 0.2.3

package/src/hooks/builtin/on-error.ts

@@ -0,0 +1,23 @@
+/**
+ * On-error hook - runs when errors occur
+ */
+import type { HookContext } from '../types.js'
+
+export const name = 'on-error'
+
+export async function execute(context: HookContext): Promise<void> {
+  const { error, state } = context
+
+  console.error('[on-error] Error occurred:', error?.message || 'Unknown error')
+
+  // Save error state
+  if (state) {
+    console.log(`[on-error] State preserved: ${state.id}`)
+  }
+
+  // Suggest recovery actions
+  console.log('[on-error] Suggested actions:')
+  console.log('  1. Check error logs')
+  console.log('  2. Review state file')
+  console.log('  3. Resume with: yi-workflow resume')
+}

package/src/hooks/builtin/post-execute.ts

@@ -0,0 +1,40 @@
+/**
+ * Post-execute hook - runs after plan execution
+ */
+import type { HookContext } from '../types.js'
+
+export const name = 'post-execute'
+
+export async function execute(context: HookContext): Promise<void> {
+  const { config, state, plan } = context
+
+  if (!state) {
+    console.warn('[post-execute] No execution state')
+    return
+  }
+
+  console.log(`[post-execute] Execution ${state.status}`)
+
+  // Auto-commit if configured
+  if (config.autoMerge && state.status === 'completed') {
+    try {
+      const { hasUncommittedChanges, commitChanges } = await import(
+        '../../utils/git.js'
+      )
+      if (hasUncommittedChanges(process.cwd())) {
+        const message = plan
+          ? `feat: implement ${plan.title}`
+          : 'feat: workflow implementation'
+        commitChanges(process.cwd(), message)
+        console.log('[post-execute] Changes committed')
+      }
+    } catch {
+      console.warn('[post-execute] Git operations failed')
+    }
+  }
+
+  // Cleanup if configured
+  if (config.autoCleanup) {
+    console.log('[post-execute] Cleanup scheduled')
+  }
+}

package/src/hooks/builtin/post-plan.ts

@@ -0,0 +1,23 @@
+/**
+ * Post-plan hook - runs after plan creation
+ */
+import type { HookContext } from '../types.js'
+
+export const name = 'post-plan'
+
+export async function execute(context: HookContext): Promise<void> {
+  const { config, plan } = context
+
+  if (!plan) {
+    console.warn('[post-plan] No plan in context')
+    return
+  }
+
+  console.log(`[post-plan] Plan created: ${plan.title}`)
+  console.log(`[post-plan] Tasks: ${plan.tasks.length}`)
+
+  // Auto-trigger execute-plan if configured
+  if (config.autoMerge && plan.status === 'approved') {
+    console.log('[post-plan] Plan approved, ready for execution')
+  }
+}

package/src/hooks/builtin/pre-execute.ts

@@ -0,0 +1,30 @@
+/**
+ * Pre-execute hook - runs before plan execution
+ */
+import type { HookContext } from '../types.js'
+
+export const name = 'pre-execute'
+
+export async function execute(context: HookContext): Promise<void> {
+  const { plan } = context
+
+  if (!plan) {
+    throw new Error('No plan to execute')
+  }
+
+  // Load plan into state
+  console.log(`[pre-execute] Loading plan: ${plan.title}`)
+
+  // Check for uncommitted changes
+  try {
+    const { hasUncommittedChanges } = await import('../../utils/git.js')
+    if (hasUncommittedChanges(process.cwd())) {
+      console.warn('[pre-execute] Uncommitted changes detected')
+    }
+  } catch {
+    // Not a git repo, ignore
+  }
+
+  // Initialize execution state
+  console.log('[pre-execute] Execution state initialized')
+}

package/src/hooks/builtin/pre-plan.ts

@@ -0,0 +1,26 @@
+/**
+ * Pre-plan hook - runs before plan creation
+ */
+import type { HookContext } from '../types.js'
+
+export const name = 'pre-plan'
+
+export async function execute(context: HookContext): Promise<void> {
+  const { config } = context
+
+  // Ensure plan directory exists
+  const fs = await import('fs/promises')
+  await fs.mkdir(config.planPath, { recursive: true })
+
+  // Check git repository
+  try {
+    const { getCurrentBranch } = await import('../../utils/git.js')
+    const branch = getCurrentBranch(process.cwd())
+    console.log(`[pre-plan] Current branch: ${branch}`)
+  } catch {
+    console.warn('[pre-plan] Not in a git repository')
+  }
+
+  // Load any existing context
+  console.log('[pre-plan] Environment ready')
+}

package/src/hooks/index.ts

@@ -0,0 +1,7 @@
+/**
+ * Hooks module index
+ */
+export type { HookDefinition, HookType, HookContext, HookHandler, HookManagerInterface, HookRegistry, BuiltInHookConfig } from './types.js'
+export { HookManager, createHookManager } from './manager.js'
+export { HookLoader, createHookLoader } from './loader.js'
+export * as builtin from './builtin/index.js'

package/src/hooks/loader.ts

@@ -0,0 +1,98 @@
+/**
+ * Hook loader - loads hooks from the filesystem
+ */
+import { readdir } from 'fs/promises'
+import { join } from 'path'
+import type { HookDefinition, HookManagerInterface } from './types.js'
+
+export interface HookLoaderOptions {
+  builtinPath: string
+  customPath?: string
+}
+
+export class HookLoader {
+  private options: HookLoaderOptions
+
+  constructor(options: HookLoaderOptions) {
+    this.options = options
+  }
+
+  async loadInto(manager: HookManagerInterface): Promise<void> {
+    // Load built-in hooks
+    await this.loadBuiltinHooks(manager)
+
+    // Load custom hooks if path provided
+    if (this.options.customPath) {
+      await this.loadCustomHooks(manager)
+    }
+  }
+
+  private async loadBuiltinHooks(manager: HookManagerInterface): Promise<void> {
+    try {
+      const files = await readdir(this.options.builtinPath)
+      const hookFiles = files.filter(
+        (f) => f.endsWith('.js') && !f.endsWith('.d.ts') && f !== 'index.js'
+      )
+
+      for (const file of hookFiles) {
+        const hookPath = join(this.options.builtinPath, file)
+        await this.loadHookFile(manager, hookPath)
+      }
+    } catch {
+      // No built-in hooks directory
+    }
+  }
+
+  private async loadCustomHooks(manager: HookManagerInterface): Promise<void> {
+    try {
+      const files = await readdir(this.options.customPath!)
+      const hookFiles = files.filter((f) => f.endsWith('.js') && !f.endsWith('.d.ts'))
+
+      for (const file of hookFiles) {
+        const hookPath = join(this.options.customPath!, file)
+        await this.loadHookFile(manager, hookPath)
+      }
+    } catch {
+      // No custom hooks directory
+    }
+  }
+
+  private async loadHookFile(
+    manager: HookManagerInterface,
+    hookPath: string
+  ): Promise<void> {
+    try {
+      const module = await import(hookPath)
+
+      // Support both named exports and default export
+      const hook: HookDefinition = module.default || {
+        type: module.type,
+        name: module.name,
+        execute: module.execute,
+      }
+
+      if (this.validateHook(hook)) {
+        manager.register(hook)
+      } else {
+        console.warn(`[HookLoader] Invalid hook in ${hookPath}`)
+      }
+    } catch (error) {
+      console.error(`[HookLoader] Failed to load ${hookPath}:`, error)
+    }
+  }
+
+  private validateHook(hook: unknown): hook is HookDefinition {
+    if (!hook || typeof hook !== 'object') return false
+
+    const h = hook as Record<string, unknown>
+    return (
+      typeof h.type === 'string' &&
+      typeof h.name === 'string' &&
+      typeof h.execute === 'function'
+    )
+  }
+}
+
+export function createHookLoader(options: HookLoaderOptions): HookLoader {
+  return new HookLoader(options)
+}

package/src/hooks/manager.ts

@@ -0,0 +1,99 @@
+/**
+ * Hook manager - manages hook registration and execution
+ */
+import type {
+  HookDefinition,
+  HookType,
+  HookContext,
+  HookManagerInterface,
+  HookRegistry,
+} from './types.js'
+
+export class HookManager implements HookManagerInterface {
+  private registry: HookRegistry
+  private enabled: Map<string, boolean>
+  private priorities: Map<string, number>
+
+  constructor() {
+    this.registry = {
+      prePlan: [],
+      postPlan: [],
+      preExecute: [],
+      postExecute: [],
+      onError: [],
+    }
+    this.enabled = new Map()
+    this.priorities = new Map()
+  }
+
+  register(hook: HookDefinition, priority = 0): void {
+    const key = this.getRegistryKey(hook.type)
+    this.registry[key].push(hook)
+    this.priorities.set(hook.name, priority)
+    this.enabled.set(hook.name, true)
+
+    // Sort by priority (higher first)
+    this.registry[key].sort((a, b) => {
+      const pa = this.priorities.get(a.name) ?? 0
+      const pb = this.priorities.get(b.name) ?? 0
+      return pb - pa
+    })
+
+    console.log(`[HookManager] Registered: ${hook.name} (${hook.type}, priority: ${priority})`)
+  }
+
+  enable(name: string): void {
+    this.enabled.set(name, true)
+  }
+
+  disable(name: string): void {
+    this.enabled.set(name, false)
+  }
+
+  isEnabled(name: string): boolean {
+    return this.enabled.get(name) ?? true
+  }
+
+  unregister(name: string): void {
+    for (const key of Object.keys(this.registry) as Array<keyof HookRegistry>) {
+      this.registry[key] = this.registry[key].filter((h) => h.name !== name)
+    }
+    console.log(`[HookManager] Unregistered: ${name}`)
+  }
+
+  async execute(type: HookType, context: HookContext): Promise<void> {
+    const key = this.getRegistryKey(type)
+    const hooks = this.registry[key].filter((h) => this.isEnabled(h.name))
+
+    console.log(`[HookManager] Executing ${hooks.length} hooks for ${type}`)
+
+    for (const hook of hooks) {
+      try {
+        await hook.execute(context)
+      } catch (error) {
+        console.error(`[HookManager] Hook ${hook.name} failed:`, error)
+        throw error
+      }
+    }
+  }
+
+  getHooks(type: HookType): HookDefinition[] {
+    const key = this.getRegistryKey(type)
+    return [...this.registry[key]]
+  }
+
+  private getRegistryKey(type: HookType): keyof HookRegistry {
+    const mapping: Record<HookType, keyof HookRegistry> = {
+      'pre-plan': 'prePlan',
+      'post-plan': 'postPlan',
+      'pre-execute': 'preExecute',
+      'post-execute': 'postExecute',
+      'on-error': 'onError',
+    }
+    return mapping[type]
+  }
+}
+
+export function createHookManager(): HookManager {
+  return new HookManager()
+}

package/src/hooks/types-enhanced.ts

@@ -0,0 +1,38 @@
+/**
+ * Enhanced hook type definitions
+ */
+
+export enum HookType {
+  // Existing hooks
+  PRE_PLAN = 'pre-plan',
+  POST_PLAN = 'post-plan',
+  PRE_EXECUTE = 'pre-execute',
+  POST_EXECUTE = 'post-execute',
+  ON_ERROR = 'on-error',
+
+  // Persistence hooks
+  STATE_CHANGE = 'state-change',
+  TASK_COMPLETE = 'task-complete',
+  WAVE_START = 'wave-start',
+  WAVE_COMPLETE = 'wave-complete',
+
+  // Lifecycle hooks
+  MILESTONE_START = 'milestone-start',
+  MILESTONE_COMPLETE = 'milestone-complete',
+  MILESTONE_FAIL = 'milestone-fail'
+}
+
+export interface HookContext {
+  [key: string]: unknown
+}
+
+export interface HookDefinition {
+  type: HookType
+  name: string
+  priority: number
+  execute: (context: HookContext) => Promise<void>
+}
+
+export interface HookManager {
+  execute(type: HookType, context: HookContext): Promise<void>
+}

package/src/hooks/types.ts

@@ -0,0 +1,35 @@
+/**
+ * Hook type definitions
+ */
+import type {
+  HookDefinition,
+  HookType,
+  HookContext,
+} from '../types.js'
+
+export { HookDefinition, HookType, HookContext }
+
+export interface HookManagerInterface {
+  register(hook: HookDefinition, priority?: number): void
+  unregister(name: string): void
+  execute(type: HookType, context: HookContext): Promise<void>
+  getHooks(type: HookType): HookDefinition[]
+  enable(name: string): void
+  disable(name: string): void
+  isEnabled(name: string): boolean
+}
+
+export interface HookRegistry {
+  prePlan: HookDefinition[]
+  postPlan: HookDefinition[]
+  preExecute: HookDefinition[]
+  postExecute: HookDefinition[]
+  onError: HookDefinition[]
+}
+
+export type HookHandler = (context: HookContext) => Promise<void> | void
+
+export interface BuiltInHookConfig {
+  enabled: boolean
+  priority?: number
+}

package/src/index.ts

@@ -0,0 +1,127 @@
+/**
+ * yi-workflow - Production workflow skills for coding agents
+ *
+ * Core Architecture:
+ * 1. Main Agent = Orchestrator only (NEVER executes work)
+ * 2. Router = Classifies ALL user input and dispatches to subagents
+ * 3. Subagents = Do ALL actual work
+ * 4. Guard = Enforces Main Agent never does prohibited operations
+ */
+
+// Export core types from global types
+export type {
+  WorkflowConfig,
+  Plan,
+  PlanStatus,
+  Task,
+  TaskStatus,
+  ExecutionState,
+  ExecutionStatus,
+  HookType,
+  HookContext,
+  HookDefinition,
+  Logger,
+  CLIOptions,
+} from './types.js'
+
+// Export hooks
+export { HookManager, createHookManager } from './hooks/manager.js'
+export { HookLoader, createHookLoader } from './hooks/loader.js'
+export type {
+  HookHandler,
+  HookManagerInterface,
+  HookRegistry,
+  BuiltInHookConfig,
+} from './hooks/types.js'
+
+// Export state
+export { StateManagerImpl, createStateManager } from './state/manager.js'
+export { FilePersistence, createPersistence } from './state/persistence.js'
+export { validateState, isValidState, sanitizeState } from './state/validator.js'
+export { cleanupOldStates, cleanupEmptyDirs, getStateStats } from './state/cleanup.js'
+export type {
+  StateManager,
+  PersistenceLayer,
+  StateOptions,
+} from './state/types.js'
+
+// Export skills
+export { Skill } from './skills/skill.js'
+export { Registry, createRegistry } from './skills/registry.js'
+export { toPlanSkill } from './skills/to-plan/index.js'
+export { executePlanSkill } from './skills/execute-plan/index.js'
+export { quickTaskSkill } from './skills/quick-task/index.js'
+export { reviewDiffSkill } from './skills/review-diff/index.js'
+export { tddSkill } from './skills/tdd/index.js'
+export { systematicDebuggingSkill } from './skills/systematic-debugging/index.js'
+export { agentsMdSkill } from './skills/agents-md/index.js'
+export type {
+  SkillDefinition,
+  SkillRegistry,
+  SkillContext,
+  ExecutionResult,
+} from './skills/types.js'
+
+// Export agents - dispatcher
+export { SubagentDispatcher, createDispatcher, createProcessExecutor } from './agents/dispatcher.js'
+export type {
+  SubagentExecutor,
+  ExecutorOptions,
+  ExecutorResult,
+  ProcessExecutorConfig,
+  DispatcherOptions,
+} from './agents/dispatcher.js'
+
+// Export agents - types
+export type {
+  SubagentConfig,
+  SubagentResult,
+  SubagentArtifact,
+  SubagentRole,
+  MainAgentGuard,
+} from './agents/types.js'
+
+// Export agents - contracts
+export {
+  explorerContract,
+  implementerContract,
+  reviewerContract,
+  debuggerContract,
+  verifierContract,
+} from './agents/contracts.js'
+export type {
+  ExplorerParams,
+  ImplementerParams,
+  ReviewerParams,
+  DebuggerParams,
+  VerifierParams,
+} from './agents/contracts.js'
+
+// Export router
+export { createRouter } from './router/router.js'
+export type { Router } from './router/router.js'
+export { ROUTE_KEYWORDS, MAIN_AGENT_PROHIBITED } from './router/types.js'
+export type {
+  IntentClassification,
+  IntentType,
+  RouterConfig,
+  RoutingDecision,
+  RouterInput,
+  RouterOutput,
+  SubagentContract,
+  PermissionSet,
+} from './router/types.js'
+
+// Export guard
+export { createMainAgentGuard } from './guard/main-agent.js'
+export type {
+  GuardConfig,
+  ProhibitedOperations,
+  OperationRequest,
+  GuardDecision,
+} from './guard/main-agent.js'
+
+// Export utils
+export { createLogger } from './utils/logger.js'
+export { getCurrentBranch, getBaseBranch, isWorktree } from './utils/git.js'
+export { getPlansPath, getStatePath } from './utils/paths.js'

package/src/persistence/index.ts

@@ -0,0 +1,17 @@
+/**
+ * Persistence layer exports
+ */
+export { StateMdManager } from './state-md.js'
+export { PlanMdManager } from './plan-md.js'
+export type {
+  Task,
+  Wave,
+  Plan,
+  TaskResult,
+  VerificationResult,
+  DimensionResult,
+  WorkflowState,
+  StateMdManager as IStateMdManager,
+  PlanMdManager as IPlanMdManager,
+  PersistenceManager
+} from './types.js'