opencastle 0.10.7 → 0.12.0

package/src/cli/run/loop-executor.ts

@@ -0,0 +1,199 @@
+import { readFile } from 'node:fs/promises'
+import { spawn } from 'node:child_process'
+import type { ChildProcess } from 'node:child_process'
+import { resolve } from 'node:path'
+import { formatDuration } from './executor.js'
+import { parseTimeout } from './schema.js'
+import type {
+  TaskSpec,
+  LoopRunReport,
+  LoopIterationResult,
+  BackpressureResult,
+  AgentAdapter,
+  LoopReporter,
+  LoopExecutor,
+  Task,
+} from '../types.js'
+
+interface ActiveState {
+  task: Task | null
+  bpChild: ChildProcess | null
+}
+
+async function runBackpressureCommand(
+  command: string,
+  active: ActiveState,
+  timeoutMs: number,
+): Promise<BackpressureResult> {
+  return new Promise((res) => {
+    const child = spawn('sh', ['-c', command])
+    active.bpChild = child
+    let output = ''
+    let killed = false
+
+    const timer = setTimeout(() => {
+      killed = true
+      child.kill('SIGTERM')
+    }, timeoutMs)
+
+    child.stdout.on('data', (data: Buffer) => { output += data.toString() })
+    child.stderr.on('data', (data: Buffer) => { output += data.toString() })
+
+    child.on('close', (code: number | null) => {
+      clearTimeout(timer)
+      active.bpChild = null
+      const exitCode = code ?? 1
+      if (output.length > 5000) output = output.slice(0, 5000)
+      const timedOut = killed
+      res({
+        command,
+        exitCode: timedOut ? -1 : exitCode,
+        output: timedOut ? `Command timed out after ${timeoutMs}ms` : output,
+        passed: !timedOut && exitCode === 0,
+      })
+    })
+  })
+}
+
+async function runBackpressure(
+  commands: string[],
+  reporter: LoopReporter,
+  active: ActiveState,
+  timeoutMs: number,
+): Promise<{ passed: boolean; results: BackpressureResult[] }> {
+  const results: BackpressureResult[] = []
+  for (const command of commands) {
+    reporter.onBackpressureStart(command)
+    const result = await runBackpressureCommand(command, active, timeoutMs)
+    reporter.onBackpressureResult(result)
+    results.push(result)
+    if (!result.passed) return { passed: false, results }
+  }
+  return { passed: true, results }
+}
+
+export function createLoopExecutor(
+  spec: TaskSpec,
+  adapter: AgentAdapter,
+  reporter: LoopReporter,
+): LoopExecutor {
+  return {
+    async run(): Promise<LoopRunReport> {
+      const loop = spec.loop!
+      const startedAt = new Date()
+      const iterations: LoopIterationResult[] = []
+      let aborted = false
+      const active: ActiveState = { task: null, bpChild: null }
+      const timeoutMs = parseTimeout(loop.timeout)
+
+      const sigintHandler = () => {
+        aborted = true
+        if (active.task && typeof adapter.kill === 'function') {
+          adapter.kill(active.task)
+        }
+        if (active.bpChild && !active.bpChild.killed) {
+          active.bpChild.kill('SIGTERM')
+        }
+      }
+      process.on('SIGINT', sigintHandler)
+
+      let stoppedReason: LoopRunReport['stoppedReason'] = 'max-iterations'
+
+      try {
+        for (let i = 1; i <= loop.max_iterations; i++) {
+          if (aborted) {
+            stoppedReason = 'user-abort'
+            break
+          }
+
+          reporter.onIterationStart(i, loop.max_iterations)
+
+          // Re-read prompt from disk each iteration for latest content
+          const promptContent = await readFile(resolve(process.cwd(), loop.prompt), 'utf8')
+
+          const syntheticTask: Task = {
+            id: `loop-${i}`,
+            prompt: promptContent,
+            agent: 'autonomous',
+            timeout: loop.timeout,
+            depends_on: [],
+            files: [],
+            description: `Loop iteration ${i}`,
+            max_retries: 1,
+          }
+
+          const iterStart = Date.now()
+          active.task = syntheticTask
+          const adapterResult = await adapter.execute(syntheticTask, { verbose: spec._verbose })
+          active.task = null
+
+          if (!adapterResult.success) {
+            const duration = Date.now() - iterStart
+            const iterResult: LoopIterationResult = {
+              iteration: i,
+              status: 'failed',
+              duration,
+              output: adapterResult.output,
+              backpressureResults: [],
+            }
+            iterations.push(iterResult)
+            reporter.onIterationDone(i, iterResult)
+            stoppedReason = 'error'
+            break
+          }
+
+          let backpressureResults: BackpressureResult[] = []
+          if (loop.backpressure && loop.backpressure.length > 0) {
+            const bp = await runBackpressure(loop.backpressure, reporter, active, timeoutMs)
+            backpressureResults = bp.results
+            if (!bp.passed) {
+              const duration = Date.now() - iterStart
+              const iterResult: LoopIterationResult = {
+                iteration: i,
+                status: 'backpressure-fail',
+                duration,
+                output: adapterResult.output,
+                backpressureResults,
+              }
+              iterations.push(iterResult)
+              reporter.onIterationDone(i, iterResult)
+              stoppedReason = 'backpressure-fail'
+              break
+            }
+          }
+
+          const duration = Date.now() - iterStart
+          const iterResult: LoopIterationResult = {
+            iteration: i,
+            status: 'done',
+            duration,
+            output: adapterResult.output,
+            backpressureResults,
+          }
+          iterations.push(iterResult)
+          reporter.onIterationDone(i, iterResult)
+        }
+      } finally {
+        process.off('SIGINT', sigintHandler)
+      }
+
+      const completedAt = new Date()
+      const completedIterations = iterations.filter((it) => it.status === 'done').length
+
+      const report: LoopRunReport = {
+        name: spec.name,
+        mode: 'loop',
+        startedAt: startedAt.toISOString(),
+        completedAt: completedAt.toISOString(),
+        duration: formatDuration(completedAt.getTime() - startedAt.getTime()),
+        totalIterations: iterations.length,
+        completedIterations,
+        stoppedReason,
+        iterations,
+      }
+
+      await reporter.onComplete(report)
+      return report
+    },
+  }
+}

package/src/cli/run/loop-reporter.ts

@@ -0,0 +1,125 @@
+import { mkdir, writeFile } from 'node:fs/promises'
+import { resolve } from 'node:path'
+import { formatDuration } from './executor.js'
+import { c } from '../prompt.js'
+import { appendEvent } from '../log.js'
+import { appendLesson } from '../lesson.js'
+import type {
+  LoopRunReport,
+  LoopIterationResult,
+  BackpressureResult,
+  LoopReporter,
+} from '../types.js'
+
+const STOPPED_LABELS: Record<LoopRunReport['stoppedReason'], string> = {
+  'max-iterations': 'reached max iterations',
+  'plan-empty': 'plan exhausted',
+  'backpressure-fail': 'backpressure check failed',
+  'user-abort': 'aborted by user',
+  error: 'agent error',
+}
+
+export function createLoopReporter(
+  specName: string,
+  options: { reportDir?: string; verbose?: boolean } = {},
+): LoopReporter {
+  const reportDir = options.reportDir ?? resolve(process.cwd(), '.opencastle', 'runs')
+  const verbose = options.verbose ?? false
+
+  return {
+    onIterationStart(i: number, max: number): void {
+      console.log(`\n  \u21bb Iteration ${i}/${max}`)
+    },
+
+    onIterationDone(_i: number, result: LoopIterationResult): void {
+      const dur = formatDuration(result.duration)
+      if (result.status === 'done') {
+        console.log(`  ${c.green('\u2713')} Completed (${dur})`)
+      } else if (result.status === 'backpressure-fail') {
+        console.log(`  ${c.yellow('\u26a0')} Backpressure failed (${dur})`)
+      } else {
+        console.log(`  ${c.red('\u2717')} 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)}`)
+      }
+
+      appendEvent({
+        type: 'delegation',
+        timestamp: new Date().toISOString(),
+        session_id: specName,
+        agent: 'autonomous',
+        task: `Loop iteration ${_i}`,
+        mechanism: 'run-loop',
+        outcome: result.status === 'done' ? 'success' : result.status,
+        duration_sec: Math.round(result.duration / 1000),
+      }).catch(() => {})
+    },
+
+    onBackpressureStart(cmd: string): void {
+      console.log(`  \u23ce Running: ${cmd}`)
+    },
+
+    onBackpressureResult(result: BackpressureResult): void {
+      if (result.passed) {
+        console.log(`  ${c.green('\u2713')} Exit ${result.exitCode}`)
+      } else {
+        console.log(`  ${c.red('\u2717')} Exit ${result.exitCode}`)
+        if (result.output) {
+          const lines = result.output.split('\n').slice(0, 5)
+          for (const line of lines) console.log(`    ${line}`)
+        }
+      }
+    },
+
+    async onComplete(report: LoopRunReport): Promise<void> {
+      console.log(`\n  ${c.dim('\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500')}`)
+      console.log(`  ${c.bold('Loop complete:')} ${report.name}`)
+      console.log(`  Duration: ${report.duration}`)
+      console.log()
+      console.log(
+        `  Iterations: ${report.totalIterations} total \u2014 ` +
+          `${c.green(String(report.completedIterations))} completed`,
+      )
+      console.log(`  Stopped: ${STOPPED_LABELS[report.stoppedReason]}`)
+
+      try {
+        await mkdir(reportDir, { recursive: true })
+        const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19)
+        const reportPath = resolve(reportDir, `loop-${specName}-${timestamp}.json`)
+        await writeFile(reportPath, JSON.stringify(report, null, 2), 'utf8')
+        console.log(`  Report: ${reportPath}`)
+      } catch (err: unknown) {
+        console.log(`  \u2717 Could not write report: ${(err as Error).message}`)
+      }
+      await appendEvent({
+        type: 'session',
+        timestamp: new Date().toISOString(),
+        agent: 'opencastle-run',
+        task: `Loop: ${report.name}`,
+        outcome: report.stoppedReason === 'max-iterations' || report.stoppedReason === 'plan-empty' ? 'success' : 'failure',
+        duration_min: Math.round((new Date(report.completedAt).getTime() - new Date(report.startedAt).getTime()) / 60000),
+        mode: 'loop',
+        total_iterations: report.totalIterations,
+        completed_iterations: report.completedIterations,
+        stopped_reason: report.stoppedReason,
+      }).catch(() => {})
+
+      if (report.stoppedReason === 'error' || report.stoppedReason === 'backpressure-fail') {
+        const lastIter = report.iterations[report.iterations.length - 1]
+        await appendLesson({
+          title: `Run loop "${report.name}" stopped: ${report.stoppedReason}`,
+          category: 'general',
+          severity: 'medium',
+          problem: `Loop stopped after ${report.totalIterations} iterations due to ${report.stoppedReason}.${lastIter?.output ? ` Last output: ${lastIter.output.slice(0, 200)}` : ''}`,
+        }).catch(() => {})
+      }
+      console.log()
+    },
+  }
+}

package/src/cli/run/reporter.ts

@@ -2,6 +2,7 @@ import { mkdir, writeFile } from 'node:fs/promises'
 import { resolve } from 'node:path'
 import { formatDuration } from './executor.js'
 import { c } from '../prompt.js'
+import { appendEvent } from '../log.js'
 import type {
   TaskSpec,
   Task,
@@ -56,6 +57,17 @@ export function createReporter(spec: TaskSpec, options: ReporterOptions = {}): R
       if (verbose && result.output && result.status === 'done') {
         console.log(`    Output: ${result.output.slice(0, 500)}`)
       }
+
+      appendEvent({
+        type: 'delegation',
+        timestamp: new Date().toISOString(),
+        session_id: spec.name,
+        agent: task.agent,
+        task: `${task.id}: ${task.description}`,
+        mechanism: 'run-task',
+        outcome: result.status === 'done' ? 'success' : result.status,
+        duration_sec: Math.round(result.duration / 1000),
+      }).catch(() => {})
     },
 
     onTaskSkipped(task: Task, reason: string): void {
@@ -95,6 +107,23 @@ export function createReporter(spec: TaskSpec, options: ReporterOptions = {}): R
         console.log(`  ${ICONS.failed} Could not write report: ${(err as Error).message}`)
       }
 
+      await appendEvent({
+        type: 'session',
+        timestamp: new Date().toISOString(),
+        agent: 'opencastle-run',
+        model: spec.adapter,
+        task: `Run: ${report.name}`,
+        outcome: report.summary.failed > 0 || report.summary['timed-out'] > 0 ? 'failure' : 'success',
+        duration_min: Math.round((new Date(report.completedAt).getTime() - new Date(report.startedAt).getTime()) / 60000),
+        files_changed: 0,
+        retries: 0,
+        mode: 'tasks',
+        tasks_total: report.summary.total,
+        tasks_done: report.summary.done,
+        tasks_failed: report.summary.failed,
+        tasks_skipped: report.summary.skipped,
+      }).catch(() => {})
+
       console.log()
     },
   }
@@ -108,7 +137,7 @@ export function printExecutionPlan(spec: TaskSpec, phases: Task[][]): void {
   console.log(`  ${c.dim('Adapter:')}     ${c.cyan(spec.adapter)}`)
   console.log(`  ${c.dim('Concurrency:')} ${c.yellow(String(spec.concurrency))}`)
   console.log(`  ${c.dim('On failure:')}  ${c.yellow(spec.on_failure)}`)
-  console.log(`  ${c.dim('Tasks:')}       ${c.yellow(String(spec.tasks.length))}`)
+  console.log(`  ${c.dim('Tasks:')}       ${c.yellow(String(spec.tasks?.length ?? 0))}`)
   console.log(`  ${c.dim('──────────────────────────────────')}`)
 
   for (let i = 0; i < phases.length; i++) {