opencastle 0.23.1 → 0.24.0

package/src/cli/convoy/engine.ts

@@ -14,6 +14,7 @@ import type { TaskRecord, ConvoyStatus } from './types.js'
 import { buildPhases, formatDuration } from '../run/executor.js'
 import { parseTimeout } from '../run/schema.js'
 import { getAdapter, detectAdapter } from '../run/adapters/index.js'
+import { c } from '../prompt.js'
 
 const execFile = promisify(execFileCb)
 
@@ -37,7 +38,7 @@ export interface ConvoyResult {
   status: ConvoyStatus
   summary: { total: number; done: number; failed: number; skipped: number; timedOut: number }
   duration: string
-  gateResults?: Array<{ command: string; exitCode: number; passed: boolean }>
+  gateResults?: Array<{ command: string; exitCode: number; passed: boolean; output?: string }>
   cost?: { total_tokens: number }
 }
 
@@ -95,6 +96,8 @@ async function runConvoy(
   verbose: boolean,
   startTime: number,
 ): Promise<ConvoyResult> {
+  const totalTasks = spec.tasks?.length ?? 0
+  let completedCount = 0
   const activeTaskMap = new Map<string, Task>()
   const taskAdapterMap = new Map<string, AgentAdapter>()
 
@@ -123,7 +126,7 @@ async function runConvoy(
     const task = allTasks.find(t => t.id === taskId)
     if (!task || task.status !== 'pending') return
     store.updateTaskStatus(taskId, convoyId, 'skipped', { output: reason })
-    if (verbose) process.stdout.write(`\u2298 ${taskId}\n`)
+    process.stdout.write(`  ${c.dim('⊘')} ${c.bold(`[${taskId}]`)} skipped\n`)
     events.emit('task_skipped', { reason }, { convoy_id: convoyId, task_id: taskId })
     for (const t of allTasks) {
       const deps = t.depends_on ? (JSON.parse(t.depends_on) as string[]) : []
@@ -206,7 +209,7 @@ async function runConvoy(
     const task = taskRecordToTask(taskRecord)
     activeTaskMap.set(taskRecord.id, task)
 
-    if (verbose) process.stdout.write(`\u25b6 ${taskRecord.id}\n`)
+    process.stdout.write(`  ${c.cyan('▶')} ${c.bold(`[${taskRecord.id}]`)} ${taskRecord.agent}${worktreePath ? c.dim(' (worktree)') : ''}\n`)
     events.emit(
       'task_started',
       { worker_id: workerId },
@@ -252,11 +255,7 @@ async function runConvoy(
           finished_at: null,
         })
         store.updateWorkerStatus(workerId, 'killed', { finished_at: finishedAt })
-        if (verbose) {
-          process.stdout.write(
-            `\u23f1 ${taskRecord.id}  retry ${freshRecord.retries + 1}/${freshRecord.max_retries}\n`,
-          )
-        }
+        process.stdout.write(`  ${c.yellow('⟳')} ${c.bold(`[${taskRecord.id}]`)} timed out, retry ${freshRecord.retries + 1}/${freshRecord.max_retries}\n`)
       } else {
         store.withTransaction(() => {
           store.updateTaskStatus(taskRecord.id, convoyId, 'timed-out', {
@@ -265,7 +264,8 @@ async function runConvoy(
           })
           store.updateWorkerStatus(workerId, 'failed', { finished_at: finishedAt })
         })
-        if (verbose) process.stdout.write(`\u23f1 ${taskRecord.id}\n`)
+        completedCount++
+        process.stdout.write(`  ${c.red('⏱')} ${c.bold(`[${taskRecord.id}]`)} timed out ${c.dim(`[${completedCount}/${totalTasks}]`)}\n`)
         events.emit(
           'task_failed',
           { reason: 'timeout', worker_id: workerId },
@@ -308,7 +308,8 @@ async function runConvoy(
         })
         store.updateWorkerStatus(workerId, 'done', { finished_at: finishedAt })
       })
-      if (verbose) process.stdout.write(`\u2713 ${taskRecord.id}  ${elapsed}\n`)
+      completedCount++
+      process.stdout.write(`  ${c.green('✓')} ${c.bold(`[${taskRecord.id}]`)} ${elapsed} ${c.dim(`[${completedCount}/${totalTasks}]`)}\n`)
       events.emit(
         'task_done',
         { exit_code: result.exitCode, worker_id: workerId },
@@ -332,11 +333,7 @@ async function runConvoy(
         finished_at: null,
       })
       store.updateWorkerStatus(workerId, 'failed', { finished_at: finishedAt })
-      if (verbose) {
-        process.stdout.write(
-          `\u2717 ${taskRecord.id}  retry ${freshRecord.retries + 1}/${freshRecord.max_retries}\n`,
-        )
-      }
+      process.stdout.write(`  ${c.yellow('⟳')} ${c.bold(`[${taskRecord.id}]`)} retry ${freshRecord.retries + 1}/${freshRecord.max_retries}\n`)
     } else {
       store.withTransaction(() => {
         store.updateTaskStatus(taskRecord.id, convoyId, 'failed', {
@@ -346,7 +343,12 @@ async function runConvoy(
         })
         store.updateWorkerStatus(workerId, 'failed', { finished_at: finishedAt })
       })
-      if (verbose) process.stdout.write(`\u2717 ${taskRecord.id}\n`)
+      completedCount++
+      process.stdout.write(`  ${c.red('✗')} ${c.bold(`[${taskRecord.id}]`)} failed ${elapsed} ${c.dim(`[${completedCount}/${totalTasks}]`)}\n`)
+      if (verbose) {
+        const outputPreview = result.output.split('\n').slice(0, 5).join('\n')
+        process.stdout.write(`${outputPreview}\n`)
+      }
       events.emit(
         'task_failed',
         { reason: 'error', exit_code: result.exitCode, worker_id: workerId },
@@ -359,10 +361,19 @@ async function runConvoy(
 
   // ── Main execution loop ───────────────────────────────────────────────────
 
+  let lastPhase = -1
   try {
     let ready = store.getReadyTasks(convoyId)
     const concurrency = spec.concurrency ?? 1
     while (ready.length > 0) {
+      for (const t of ready) {
+        if (t.phase !== lastPhase) {
+          lastPhase = t.phase
+          const tasksInPhase = ready.filter(r => r.phase === t.phase)
+          const ids = tasksInPhase.map(r => r.id).join(', ')
+          process.stdout.write(`\n  ${c.bold(`Phase ${t.phase + 1}:`)} ${c.dim(ids)}\n`)
+        }
+      }
       for (let i = 0; i < ready.length; i += concurrency) {
         await Promise.all(ready.slice(i, i + concurrency).map(t => executeOneTask(t)))
       }
@@ -374,20 +385,66 @@ async function runConvoy(
 
   // ── Validation gates ──────────────────────────────────────────────────────
 
-  const gateResults: Array<{ command: string; exitCode: number; passed: boolean }> = []
-  if (spec.gates && spec.gates.length > 0) {
+  const maxGateRetries = spec.gate_retries ?? 0
+  let gateAttempt = 0
+  let gateResults: Array<{ command: string; exitCode: number; passed: boolean; output?: string }> = []
+
+  while (gateAttempt <= maxGateRetries) {
+    if (!spec.gates || spec.gates.length === 0) break
+
+    gateResults = []
+    process.stdout.write(`\n  ${c.bold(gateAttempt === 0 ? 'Gates:' : `Gates (retry ${gateAttempt}/${maxGateRetries}):`)}\n`)
+
     for (const command of spec.gates) {
       try {
         await execFile('sh', ['-c', command], { cwd: basePath })
         gateResults.push({ command, exitCode: 0, passed: true })
+        process.stdout.write(`  ${c.green('✓')} ${c.dim(command)}\n`)
       } catch (err) {
-        const code =
-          typeof (err as { code?: unknown }).code === 'number'
-            ? (err as { code: number }).code
-            : 1
-        gateResults.push({ command, exitCode: code, passed: false })
+        const execErr = err as Error & { code?: unknown; stderr?: string; stdout?: string }
+        const code = typeof execErr.code === 'number' ? execErr.code : 1
+        const output = execErr.stderr || execErr.stdout || execErr.message || ''
+        gateResults.push({ command, exitCode: code, passed: false, output })
+        process.stdout.write(`  ${c.red('✗')} ${c.dim(command)}\n`)
       }
     }
+
+    const failedGates = gateResults.filter(g => !g.passed)
+    if (failedGates.length === 0) break // All gates passed
+
+    // Can we retry?
+    if (gateAttempt >= maxGateRetries) break // No more retries
+
+    // Create and execute a fix task
+    gateAttempt++
+    const failureSummary = failedGates
+      .map(g => `Command: ${g.command}\nExit code: ${g.exitCode}\nOutput:\n${g.output ?? '(no output)'}`)
+      .join('\n\n---\n\n')
+
+    const fixPrompt = `The following validation gates failed after all convoy tasks completed. Fix the issues so these commands pass.\n\n${failureSummary}`
+    const fixTaskId = `gate-fix-${gateAttempt}`
+
+    process.stdout.write(`\n  ${c.yellow('⟳')} ${c.bold(`[${fixTaskId}]`)} fixing gate failures (attempt ${gateAttempt}/${maxGateRetries})\n`)
+
+    const fixTask: Task = {
+      id: fixTaskId,
+      prompt: fixPrompt,
+      agent: spec.defaults?.agent ?? 'developer',
+      timeout: spec.defaults?.timeout ?? '30m',
+      depends_on: [],
+      files: [],
+      description: `Auto-fix gate failures (attempt ${gateAttempt})`,
+      max_retries: 0,
+    }
+
+    const fixResult = await adapter.execute(fixTask, { verbose, cwd: basePath })
+
+    if (fixResult.success) {
+      process.stdout.write(`  ${c.green('✓')} ${c.bold(`[${fixTaskId}]`)} fix applied\n`)
+    } else {
+      process.stdout.write(`  ${c.red('✗')} ${c.bold(`[${fixTaskId}]`)} fix failed\n`)
+      break // Don't retry if the fix task itself fails
+    }
   }
 
   // ── Final status & summary ────────────────────────────────────────────────

package/src/cli/dashboard.ts

@@ -222,6 +222,11 @@ export async function startDashboardServer(
   const actualPort = await tryListen(server, port)
   const resolvedUrl = `http://localhost:${actualPort}`
 
+  if (options.openBrowser) {
+    const fullUrl = options.convoyId ? `${resolvedUrl}/?convoy=${options.convoyId}` : resolvedUrl
+    openUrl(fullUrl)
+  }
+
   return { server, port: actualPort, url: resolvedUrl }
 }
 
@@ -245,7 +250,7 @@ export default async function dashboard({
     }
   }
 
-  const dashResult = await startDashboardServer({ port, seed, pkgRoot, convoyId })
+  const dashResult = await startDashboardServer({ port, seed, pkgRoot, convoyId, openBrowser })
 
   console.log('')
   console.log('  \u{1F3F0} OpenCastle Dashboard')
@@ -273,10 +278,6 @@ export default async function dashboard({
   console.log('  Press Ctrl+C to stop')
   console.log('')
 
-  if (openBrowser) {
-    openUrl(convoyId ? `${dashResult.url}/?convoy=${convoyId}` : dashResult.url)
-  }
-
   // Graceful shutdown
   process.on('SIGINT', () => {
     console.log('\n  Dashboard stopped.\n')

package/src/cli/run/adapters/claude.ts

@@ -0,0 +1,238 @@
+import { spawn } from 'node:child_process'
+import { parseTimeout } from '../schema.js'
+import type { Task, ExecuteOptions, ExecuteResult, TokenUsage } from '../../types.js'
+
+// Adapter name
+export const name = 'claude'
+
+// Module-level state for mode selection
+let mode: 'sdk' | 'cli' | null = null
+
+// SDK dynamic import check
+async function sdkAvailable(): Promise<boolean> {
+  try {
+    await import('@anthropic-ai/agent-sdk')
+    return true
+  } catch {
+    return false
+  }
+}
+
+// CLI check
+async function cliAvailable(): Promise<boolean> {
+  return new Promise((resolve) => {
+    const proc = spawn('which', ['claude'], { stdio: 'pipe' })
+    proc.on('close', (code) => resolve(code === 0))
+    proc.on('error', () => resolve(false))
+  })
+}
+
+export async function isAvailable(): Promise<boolean> {
+  if (await sdkAvailable()) {
+    mode = 'sdk'
+    return true
+  }
+  if (await cliAvailable()) {
+    mode = 'cli'
+    return true
+  }
+  return false
+}
+
+// --- SDK implementation (from claude-sdk.ts) ---
+// Local type stubs for @anthropic-ai/agent-sdk
+interface AgentSession {
+  on(event: string, handler: (...args: unknown[]) => void): void
+  sendAndWait(msg: { prompt: string }, timeoutMs: number): Promise<unknown>
+  abort(): Promise<void>
+  destroy(): Promise<void>
+}
+interface SessionCreateOptions {
+  onPermissionRequest?: unknown
+  cwd?: string
+  systemMessage?: { content: string }
+  infiniteSessions?: { enabled: boolean }
+  streaming?: boolean
+}
+interface ClaudeAgentClient {
+  start(): Promise<void>
+  createSession(options: SessionCreateOptions): Promise<AgentSession>
+}
+let clientPromise: Promise<ClaudeAgentClient> | null = null
+let cachedApproveAll: unknown = null
+const activeSessions = new Map<string, AgentSession>()
+
+async function getClient(): Promise<ClaudeAgentClient> {
+  if (!clientPromise) {
+    clientPromise = (async () => {
+      const sdk = await import('@anthropic-ai/agent-sdk') as Record<string, unknown>
+      const { AgentClient, approveAll } = sdk as {
+        AgentClient: new (opts: { autoStart: boolean; logLevel: string }) => ClaudeAgentClient
+        approveAll: unknown
+      }
+      cachedApproveAll = approveAll
+      const client = new AgentClient({
+        autoStart: false,
+        logLevel: 'error',
+      })
+      await client.start()
+      return client
+    })()
+  }
+  return clientPromise
+}
+
+async function executeViaSdk(task: Task, options: ExecuteOptions = {}): Promise<ExecuteResult> {
+  let prompt = `You are a ${task.agent}. ${task.prompt}`
+  if (task.files && task.files.length > 0) {
+    prompt += `\n\nOnly modify files under: ${task.files.join(', ')}`
+  }
+  const client = await getClient()
+  const session = await client.createSession({
+    onPermissionRequest: cachedApproveAll!,
+    cwd: options.cwd ?? process.cwd(),
+    systemMessage: {
+      content: [
+        `You are a ${task.agent}.`,
+        'Work autonomously without asking questions.',
+        'Follow all instructions precisely.',
+      ].join(' '),
+    },
+    infiniteSessions: { enabled: false },
+    ...(options.verbose ? { streaming: true } : {}),
+  })
+  activeSessions.set(task.id, session)
+  if (options.verbose) {
+    session.on('assistant.message_delta', (...args: unknown[]) => {
+      const event = args[0] as { data: { deltaContent: string } }
+      process.stdout.write(event.data.deltaContent)
+    })
+  }
+  try {
+    const timeoutMs = parseTimeout(task.timeout)
+    const response = await session.sendAndWait({ prompt }, timeoutMs)
+    const data = (response as any)?.data as Record<string, unknown> | undefined
+    const output = (data?.content as string | undefined) ?? ''
+    const rawUsage = data?.usage ?? (response as any)?.usage
+    const u = rawUsage as Record<string, number> | undefined
+    const usageResult = u
+      ? {
+          prompt_tokens: u.prompt_tokens ?? u.promptTokens,
+          completion_tokens: u.completion_tokens ?? u.completionTokens,
+          total_tokens: u.total_tokens ?? u.totalTokens,
+        }
+      : undefined
+    return {
+      success: true,
+      output: output.slice(0, 10_000),
+      exitCode: 0,
+      usage: usageResult,
+    }
+  } catch (err: unknown) {
+    return {
+      success: false,
+      output: `Claude Agent SDK error: ${(err as Error).message}`,
+      exitCode: 1,
+    }
+  } finally {
+    activeSessions.delete(task.id)
+    await session.destroy().catch(() => {})
+  }
+}
+
+function killSdk(task: Task): void {
+  const session = activeSessions.get(task.id)
+  if (session) {
+    session.abort().catch(() => {})
+    session.destroy().catch(() => {})
+    activeSessions.delete(task.id)
+  }
+}
+
+// --- CLI implementation (from claude-code.ts) ---
+async function executeViaCli(task: Task, options: ExecuteOptions = {}): Promise<ExecuteResult> {
+  let prompt = `You are a ${task.agent}. ${task.prompt}`
+  if (task.files && task.files.length > 0) {
+    prompt += `\n\nOnly modify files under: ${task.files.join(', ')}`
+  }
+  const args = [
+    '-p',
+    prompt,
+    '--output-format',
+    'json',
+    '--max-turns',
+    '50',
+  ]
+  return new Promise((resolve) => {
+    const proc = spawn('claude', args, {
+      stdio: ['ignore', 'pipe', 'pipe'],
+      env: { ...process.env },
+      cwd: options?.cwd ?? process.cwd(),
+    })
+    let stdout = ''
+    let stderr = ''
+    proc.stdout.on('data', (chunk: Buffer) => {
+      stdout += chunk.toString()
+      if (options.verbose) {
+        process.stdout.write(chunk)
+      }
+    })
+    proc.stderr.on('data', (chunk: Buffer) => {
+      stderr += chunk.toString()
+      if (options.verbose) {
+        process.stderr.write(chunk)
+      }
+    })
+    proc.on('close', (code) => {
+      const output = [stdout, stderr].filter(Boolean).join('\n')
+      let usage: TokenUsage | undefined
+      try {
+        const parsedJson = JSON.parse(stdout) as Record<string, unknown>
+        const u = parsedJson?.usage as Record<string, number> | undefined
+        if (u) {
+          const promptTokens = (u.input_tokens ?? u.prompt_tokens) as number | undefined
+          const completionTokens = (u.output_tokens ?? u.completion_tokens) as number | undefined
+          const total = ((promptTokens ?? 0) + (completionTokens ?? 0)) || undefined
+          usage = { prompt_tokens: promptTokens, completion_tokens: completionTokens, total_tokens: total }
+        }
+      } catch { /* not JSON or no usage — graceful degradation */ }
+      resolve({
+        success: code === 0,
+        output: output.slice(0, 10000),
+        exitCode: code ?? -1,
+        usage,
+      })
+    })
+    proc.on('error', (err) => {
+      resolve({
+        success: false,
+        output: `Failed to spawn claude: ${err.message}`,
+        exitCode: -1,
+      })
+    })
+    task._process = proc
+  })
+}
+
+function killCli(task: Task): void {
+  if (task._process && !task._process.killed) {
+    task._process.kill('SIGTERM')
+    setTimeout(() => {
+      if (task._process && !task._process.killed) {
+        task._process.kill('SIGKILL')
+      }
+    }, 5000)
+  }
+}
+
+// --- Unified interface ---
+export async function execute(task: Task, options: ExecuteOptions = {}): Promise<ExecuteResult> {
+  if (!mode) await isAvailable()
+  if (mode === 'sdk') return executeViaSdk(task, options)
+  return executeViaCli(task, options)
+}
+
+export function kill(task: Task): void {
+  if (mode === 'sdk') killSdk(task)
+  else killCli(task)
+}