opencastle 0.1.0

package/src/cli/run/executor.ts

@@ -0,0 +1,292 @@
+import { parseTimeout } from './schema.js'
+import type {
+  Task,
+  TaskSpec,
+  TaskStatus,
+  TaskResult,
+  RunReport,
+  RunSummary,
+  AgentAdapter,
+  ExecuteResult,
+  Reporter,
+  Executor,
+  TimeoutHandle,
+} from '../types.js'
+
+/**
+ * Topological sort of tasks based on `depends_on` edges.
+ * Returns groups (phases) of tasks that can run in parallel.
+ */
+export function buildPhases(tasks: Task[]): Task[][] {
+  const taskMap = new Map<string, Task>()
+  for (const t of tasks) taskMap.set(t.id, t)
+
+  const inDegree = new Map<string, number>()
+  const dependents = new Map<string, string[]>()
+
+  for (const t of tasks) {
+    inDegree.set(t.id, (t.depends_on || []).length)
+    dependents.set(t.id, [])
+  }
+
+  for (const t of tasks) {
+    for (const dep of t.depends_on || []) {
+      dependents.get(dep)!.push(t.id)
+    }
+  }
+
+  const phases: Task[][] = []
+  const remaining = new Set(tasks.map((t) => t.id))
+
+  while (remaining.size > 0) {
+    const phase: Task[] = []
+    for (const id of remaining) {
+      if (inDegree.get(id) === 0) {
+        phase.push(taskMap.get(id)!)
+      }
+    }
+
+    if (phase.length === 0) {
+      // Should not happen if cycle detection passed
+      throw new Error('Cannot resolve task order — possible circular dependency')
+    }
+
+    phases.push(phase)
+
+    for (const t of phase) {
+      remaining.delete(t.id)
+      for (const depId of dependents.get(t.id)!) {
+        inDegree.set(depId, inDegree.get(depId)! - 1)
+      }
+    }
+  }
+
+  return phases
+}
+
+/**
+ * Create a task executor.
+ */
+export function createExecutor(
+  spec: TaskSpec,
+  adapter: AgentAdapter,
+  reporter: Reporter
+): Executor {
+  const phases = buildPhases(spec.tasks)
+  const statuses = new Map<string, TaskStatus>()
+  const results = new Map<string, TaskResult | null>()
+  const startTimes = new Map<string, number>()
+
+  for (const t of spec.tasks) {
+    statuses.set(t.id, 'pending')
+    results.set(t.id, null)
+  }
+
+  /**
+   * Execute a single task with timeout enforcement.
+   */
+  async function executeTask(task: Task): Promise<TaskResult> {
+    const timeoutMs = parseTimeout(task.timeout)
+    statuses.set(task.id, 'running')
+    startTimes.set(task.id, Date.now())
+    reporter.onTaskStart(task)
+
+    try {
+      const timeout = timeoutPromise(timeoutMs, task.id)
+      const result = await Promise.race([
+        adapter.execute(task, { verbose: spec._verbose }),
+        timeout.promise,
+      ])
+
+      const duration = Date.now() - startTimes.get(task.id)!
+
+      if (result._timedOut) {
+        // Kill the orphaned child process
+        if (typeof adapter.kill === 'function') {
+          adapter.kill(task)
+        }
+        statuses.set(task.id, 'timed-out')
+        const taskResult: TaskResult = {
+          id: task.id,
+          status: 'timed-out',
+          duration,
+          output: `Task timed out after ${task.timeout}`,
+          exitCode: -1,
+        }
+        results.set(task.id, taskResult)
+        reporter.onTaskDone(task, taskResult)
+        return taskResult
+      }
+
+      // Task completed normally — cancel the timeout timer
+      timeout.clear()
+      const status: TaskStatus = result.success ? 'done' : 'failed'
+      statuses.set(task.id, status)
+      const taskResult: TaskResult = {
+        id: task.id,
+        status,
+        duration,
+        output: result.output || '',
+        exitCode: result.exitCode,
+      }
+      results.set(task.id, taskResult)
+      reporter.onTaskDone(task, taskResult)
+      return taskResult
+    } catch (err: unknown) {
+      const duration = Date.now() - startTimes.get(task.id)!
+      statuses.set(task.id, 'failed')
+      const taskResult: TaskResult = {
+        id: task.id,
+        status: 'failed',
+        duration,
+        output: (err as Error).message,
+        exitCode: -1,
+      }
+      results.set(task.id, taskResult)
+      reporter.onTaskDone(task, taskResult)
+      return taskResult
+    }
+  }
+
+  /**
+   * Skip a task and all its transitive dependents.
+   */
+  function skipTask(taskId: string, reason: string): void {
+    if (statuses.get(taskId) !== 'pending') return
+    statuses.set(taskId, 'skipped')
+    const task = spec.tasks.find((t) => t.id === taskId)!
+    results.set(taskId, {
+      id: taskId,
+      status: 'skipped',
+      duration: 0,
+      output: reason,
+      exitCode: -1,
+    })
+    reporter.onTaskSkipped(task, reason)
+
+    // Recursively skip dependents
+    for (const t of spec.tasks) {
+      if ((t.depends_on || []).includes(taskId)) {
+        skipTask(t.id, `dependency "${taskId}" was skipped/failed`)
+      }
+    }
+  }
+
+  /**
+   * Run all tasks respecting phases and concurrency.
+   */
+  async function run(): Promise<RunReport> {
+    const startedAt = new Date()
+    let halted = false
+
+    for (let phaseIdx = 0; phaseIdx < phases.length; phaseIdx++) {
+      if (halted) break
+
+      const phase = phases[phaseIdx]
+      const eligible = phase.filter((t) => statuses.get(t.id) === 'pending')
+
+      if (eligible.length === 0) continue
+
+      reporter.onPhaseStart(phaseIdx + 1, eligible)
+
+      // Process eligible tasks in batches limited by concurrency
+      const concurrency = spec.concurrency
+      for (let i = 0; i < eligible.length; i += concurrency) {
+        if (halted) break
+        const batch = eligible.slice(i, i + concurrency)
+        const batchResults = await Promise.all(batch.map(executeTask))
+
+        for (const r of batchResults) {
+          if (r.status === 'failed' || r.status === 'timed-out') {
+            if (spec.on_failure === 'stop') {
+              halted = true
+              // Skip all remaining tasks
+              for (const t of spec.tasks) {
+                if (statuses.get(t.id) === 'pending') {
+                  skipTask(t.id, 'execution halted due to on_failure: stop')
+                }
+              }
+            } else {
+              // on_failure: continue — skip dependents of this failed task
+              for (const t of spec.tasks) {
+                if ((t.depends_on || []).includes(r.id)) {
+                  skipTask(t.id, `dependency "${r.id}" failed`)
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+
+    const completedAt = new Date()
+    const allResults: TaskResult[] = spec.tasks.map(
+      (t) =>
+        results.get(t.id) || {
+          id: t.id,
+          status: statuses.get(t.id) as TaskStatus,
+          duration: 0,
+          output: '',
+          exitCode: -1,
+        }
+    )
+
+    const summary: RunSummary = {
+      total: spec.tasks.length,
+      done: 0,
+      failed: 0,
+      skipped: 0,
+      'timed-out': 0,
+    }
+    for (const r of allResults) {
+      if (r.status in summary) {
+        (summary as unknown as Record<string, number>)[r.status]++
+      }
+    }
+
+    const finalReport: RunReport = {
+      name: spec.name,
+      startedAt: startedAt.toISOString(),
+      completedAt: completedAt.toISOString(),
+      duration: formatDuration(completedAt.getTime() - startedAt.getTime()),
+      summary,
+      tasks: allResults,
+    }
+
+    await reporter.onComplete(finalReport)
+
+    return finalReport
+  }
+
+  return {
+    run,
+    getPhases: () => phases,
+  }
+}
+
+/**
+ * Create a timeout promise that resolves with a sentinel.
+ * Returns { promise, clear } so the timer can be cancelled after normal completion.
+ */
+function timeoutPromise(ms: number, taskId: string): TimeoutHandle {
+  let timerId: ReturnType<typeof setTimeout>
+  const promise = new Promise<ExecuteResult>((resolve) => {
+    timerId = setTimeout(() => resolve({ _timedOut: true, taskId, success: false, output: '', exitCode: -1 }), ms)
+  })
+  return { promise, clear: () => clearTimeout(timerId) }
+}
+
+/**
+ * Format a duration in ms to a human-readable string.
+ */
+export function formatDuration(ms: number): string {
+  if (ms < 1000) return `${ms}ms`
+  const seconds = Math.floor(ms / 1000)
+  if (seconds < 60) return `${seconds}s`
+  const minutes = Math.floor(seconds / 60)
+  const remSec = seconds % 60
+  if (minutes < 60) return remSec > 0 ? `${minutes}m ${remSec}s` : `${minutes}m`
+  const hours = Math.floor(minutes / 60)
+  const remMin = minutes % 60
+  return remMin > 0 ? `${hours}h ${remMin}m` : `${hours}h`
+}

package/src/cli/run/reporter.ts

@@ -0,0 +1,129 @@
+import { mkdir, writeFile } from 'node:fs/promises'
+import { resolve } from 'node:path'
+import { formatDuration } from './executor.js'
+import type {
+  TaskSpec,
+  Task,
+  TaskResult,
+  RunReport,
+  Reporter,
+  ReporterOptions,
+} from '../types.js'
+
+/**
+ * Status icons for terminal output.
+ */
+const ICONS: Record<string, string> = {
+  start: '▶',
+  done: '✓',
+  failed: '✗',
+  skipped: '⊘',
+  'timed-out': '⏱',
+}
+
+/**
+ * Create a reporter that prints progress to the terminal and writes a JSON report.
+ */
+export function createReporter(spec: TaskSpec, options: ReporterOptions = {}): Reporter {
+  const reportDir = options.reportDir || resolve(process.cwd(), '.opencastle', 'runs')
+  const verbose = options.verbose || false
+
+  return {
+    onTaskStart(task: Task): void {
+      console.log(`  ${ICONS.start} [${task.id}] ${task.description}`)
+    },
+
+    onTaskDone(task: Task, result: TaskResult): void {
+      const dur = formatDuration(result.duration)
+      if (result.status === 'done') {
+        console.log(`  ${ICONS.done} [${task.id}] completed (${dur})`)
+      } else if (result.status === 'timed-out') {
+        console.log(`  ${ICONS['timed-out']} [${task.id}] timed out after ${task.timeout}`)
+      } else {
+        console.log(`  ${ICONS.failed} [${task.id}] failed (${dur})`)
+        if (result.output) {
+          const lines = result.output.split('\n').slice(0, 5)
+          for (const line of lines) {
+            console.log(`    ${line}`)
+          }
+          if (result.output.split('\n').length > 5) {
+            console.log(`    ... (truncated)`)
+          }
+        }
+      }
+
+      if (verbose && result.output && result.status === 'done') {
+        console.log(`    Output: ${result.output.slice(0, 500)}`)
+      }
+    },
+
+    onTaskSkipped(task: Task, reason: string): void {
+      console.log(`  ${ICONS.skipped} [${task.id}] skipped — ${reason}`)
+    },
+
+    onPhaseStart(phase: number, tasks: Task[]): void {
+      const ids = tasks.map((t) => t.id).join(', ')
+      console.log(`\n  Phase ${phase}: ${ids}`)
+    },
+
+    async onComplete(report: RunReport): Promise<void> {
+      console.log(`\n  ──────────────────────────────────`)
+      console.log(`  Run complete: ${report.name}`)
+      console.log(`  Duration: ${report.duration}`)
+      console.log()
+
+      const s = report.summary
+      const parts: string[] = []
+      if (s.done > 0) parts.push(`${s.done} done`)
+      if (s.failed > 0) parts.push(`${s.failed} failed`)
+      if (s.skipped > 0) parts.push(`${s.skipped} skipped`)
+      if (s['timed-out'] > 0) parts.push(`${s['timed-out']} timed out`)
+      console.log(`  Tasks: ${s.total} total — ${parts.join(', ')}`)
+
+      // Write JSON report
+      try {
+        await mkdir(reportDir, { recursive: true })
+        const timestamp = new Date()
+          .toISOString()
+          .replace(/[:.]/g, '-')
+          .slice(0, 19)
+        const reportPath = resolve(reportDir, `${timestamp}.json`)
+        await writeFile(reportPath, JSON.stringify(report, null, 2), 'utf8')
+        console.log(`  Report: ${reportPath}`)
+      } catch (err: unknown) {
+        console.log(`  ${ICONS.failed} Could not write report: ${(err as Error).message}`)
+      }
+
+      console.log()
+    },
+  }
+}
+
+/**
+ * Print the execution plan (dry-run mode).
+ */
+export function printExecutionPlan(spec: TaskSpec, phases: Task[][]): void {
+  console.log(`\n  🏰 Execution Plan: ${spec.name}`)
+  console.log(`  Adapter: ${spec.adapter}`)
+  console.log(`  Concurrency: ${spec.concurrency}`)
+  console.log(`  On failure: ${spec.on_failure}`)
+  console.log(`  Tasks: ${spec.tasks.length}`)
+  console.log()
+
+  for (let i = 0; i < phases.length; i++) {
+    const phase = phases[i]
+    console.log(`  Phase ${i + 1}:`)
+    for (const task of phase) {
+      const deps =
+        task.depends_on.length > 0
+          ? ` (after: ${task.depends_on.join(', ')})`
+          : ''
+      const files =
+        task.files.length > 0 ? ` [${task.files.join(', ')}]` : ''
+      console.log(
+        `    ${task.id} — ${task.description} [${task.agent}, ${task.timeout}]${deps}${files}`
+      )
+    }
+  }
+  console.log()
+}