task-while 0.0.1

package/src/agents/codex.ts

@@ -0,0 +1,231 @@
+import { buildImplementerPrompt } from '../prompts/implementer'
+import { buildReviewerPrompt } from '../prompts/reviewer'
+import {
+  implementOutputSchema,
+  reviewOutputSchema,
+  validateImplementOutput,
+  validateReviewOutput,
+} from '../schema/index'
+
+import type { CodexProviderOptions } from './provider-options'
+import type {
+  ImplementAgentInput,
+  ImplementerProvider,
+  ReviewAgentInput,
+  ReviewerProvider,
+} from './types'
+
+export interface CodexRunResult {
+  finalResponse: string
+}
+
+export interface CodexUsage {
+  cached_input_tokens: number
+  input_tokens: number
+  output_tokens: number
+}
+
+export interface CodexTurnFailedEvent {
+  error: CodexTurnFailedError
+  type: 'turn.failed'
+}
+
+export interface CodexItemEvent {
+  item: CodexItemPayload
+  type: 'item.completed' | 'item.started' | 'item.updated'
+}
+
+export interface CodexErrorEvent {
+  message: string
+  type: 'error'
+}
+
+export interface CodexThreadStartedEvent {
+  thread_id: string
+  type: 'thread.started'
+}
+
+export interface CodexTurnCompletedEvent {
+  type: 'turn.completed'
+  usage: CodexUsage
+}
+
+export interface CodexTurnStartedEvent {
+  type: 'turn.started'
+}
+
+export interface CodexTurnFailedError {
+  message: string
+}
+
+export interface CodexItemPayload {
+  text?: string
+  type: string
+}
+
+export type CodexThreadEvent =
+  | CodexErrorEvent
+  | CodexItemEvent
+  | CodexThreadStartedEvent
+  | CodexTurnCompletedEvent
+  | CodexTurnFailedEvent
+  | CodexTurnStartedEvent
+
+export type CodexThreadEventHandler = (event: CodexThreadEvent) => void
+
+export interface CodexRunStreamedResult {
+  events: AsyncGenerator<CodexThreadEvent>
+}
+
+export interface CodexThreadRunOptions {
+  outputSchema: Record<string, unknown>
+}
+
+export interface CodexThreadLike {
+  run: (
+    prompt: string,
+    options: CodexThreadRunOptions,
+  ) => Promise<CodexRunResult>
+  runStreamed?: (
+    prompt: string,
+    options: CodexThreadRunOptions,
+  ) => Promise<CodexRunStreamedResult>
+}
+
+export interface CodexStartThreadOptions {
+  model?: string
+  modelReasoningEffort?: 'high' | 'low' | 'medium' | 'minimal' | 'xhigh'
+  workingDirectory: string
+}
+
+export interface CodexClientLike {
+  startThread: (options: CodexStartThreadOptions) => CodexThreadLike
+}
+
+export interface CodexAgentClientOptions extends CodexProviderOptions {
+  onEvent?: CodexThreadEventHandler
+  workspaceRoot: string
+}
+
+export interface CodexStructuredInput {
+  outputSchema: Record<string, unknown>
+  prompt: string
+}
+
+async function defaultClientFactory(): Promise<CodexClientLike> {
+  const { Codex } = await import('@openai/codex-sdk')
+  return new Codex()
+}
+
+export class CodexAgentClient implements ImplementerProvider, ReviewerProvider {
+  private clientPromise: null | Promise<CodexClientLike> = null
+  public readonly name = 'codex'
+
+  public constructor(private readonly options: CodexAgentClientOptions) {}
+
+  private async collectStreamedTurn<T>(
+    thread: CodexThreadLike,
+    input: CodexStructuredInput,
+  ): Promise<T> {
+    const streamedTurn = await thread.runStreamed!(input.prompt, {
+      outputSchema: input.outputSchema,
+    })
+    let finalResponse = ''
+
+    for await (const event of streamedTurn.events) {
+      this.options.onEvent?.(event)
+
+      if (event.type === 'error') {
+        throw new Error(event.message)
+      }
+
+      if (event.type === 'turn.failed') {
+        throw new Error(event.error.message)
+      }
+
+      if (
+        event.type === 'item.completed' &&
+        event.item.type === 'agent_message'
+      ) {
+        finalResponse = event.item.text?.trim() ?? ''
+      }
+    }
+
+    if (!finalResponse) {
+      throw new Error('Codex agent client returned empty finalResponse')
+    }
+
+    try {
+      return JSON.parse(finalResponse) as T
+    } catch (error) {
+      throw new Error('Codex agent client returned non-JSON finalResponse', {
+        cause: error,
+      })
+    }
+  }
+
+  private async getClient(): Promise<CodexClientLike> {
+    this.clientPromise ??= defaultClientFactory()
+    return this.clientPromise
+  }
+
+  public async implement(input: ImplementAgentInput) {
+    const prompt = await buildImplementerPrompt(input)
+    const output = await this.invokeStructured<unknown>({
+      outputSchema: implementOutputSchema,
+      prompt,
+    })
+    return validateImplementOutput(output)
+  }
+
+  public async invokeStructured<T>(input: CodexStructuredInput): Promise<T> {
+    const client = await this.getClient()
+    const startThreadOptions: CodexStartThreadOptions = {
+      workingDirectory: this.options.workspaceRoot,
+    }
+
+    if (this.options.model) {
+      startThreadOptions.model = this.options.model
+    }
+
+    if (this.options.effort) {
+      startThreadOptions.modelReasoningEffort = this.options.effort
+    }
+
+    const thread = client.startThread(startThreadOptions)
+
+    if (this.options.onEvent && thread.runStreamed) {
+      return this.collectStreamedTurn<T>(thread, input)
+    }
+
+    const turn = await thread.run(input.prompt, {
+      outputSchema: input.outputSchema,
+    })
+    const response = turn.finalResponse.trim()
+    if (!response) {
+      throw new Error('Codex agent client returned empty finalResponse')
+    }
+    try {
+      return JSON.parse(response) as T
+    } catch (error) {
+      throw new Error('Codex agent client returned non-JSON finalResponse', {
+        cause: error,
+      })
+    }
+  }
+
+  public async review(input: ReviewAgentInput) {
+    const prompt = await buildReviewerPrompt(input)
+    const output = await this.invokeStructured<unknown>({
+      outputSchema: reviewOutputSchema,
+      prompt,
+    })
+    return validateReviewOutput(output)
+  }
+}
+
+export function createCodexProvider(
+  options: CodexAgentClientOptions,
+): ImplementerProvider & ReviewerProvider {
+  return new CodexAgentClient(options)
+}

package/src/agents/provider-options.ts

@@ -0,0 +1,45 @@
+import { z } from 'zod'
+
+const modelSchema = z.string().trim().min(1)
+
+export const codexEffortSchema = z.enum([
+  'minimal',
+  'low',
+  'medium',
+  'high',
+  'xhigh',
+])
+
+export const claudeEffortSchema = z.enum(['low', 'medium', 'high', 'max'])
+
+export const codexProviderOptionsSchema = z
+  .object({
+    effort: codexEffortSchema.optional(),
+    model: modelSchema.optional(),
+  })
+  .strict()
+
+export const claudeProviderOptionsSchema = z
+  .object({
+    effort: claudeEffortSchema.optional(),
+    model: modelSchema.optional(),
+  })
+  .strict()
+
+export type CodexProviderOptions = z.infer<typeof codexProviderOptionsSchema>
+export type ClaudeProviderOptions = z.infer<typeof claudeProviderOptionsSchema>
+
+export type WorkflowRoleProviderOptions =
+  | (ClaudeProviderOptions & { provider: 'claude' })
+  | (CodexProviderOptions & { provider: 'codex' })
+
+export function providerOptionsEqual(
+  left: WorkflowRoleProviderOptions,
+  right: WorkflowRoleProviderOptions,
+) {
+  return (
+    left.provider === right.provider &&
+    left.model === right.model &&
+    left.effort === right.effort
+  )
+}

package/src/agents/types.ts

@@ -0,0 +1,69 @@
+import type { PullRequestSnapshot } from '../core/runtime'
+import type { TaskPrompt } from '../task-sources/types'
+import type { ImplementOutput, ReviewFinding, ReviewOutput } from '../types'
+
+export interface ImplementAgentInput {
+  attempt: number
+  generation: number
+  lastFindings: ReviewFinding[]
+  prompt: TaskPrompt
+  taskHandle: string
+}
+
+export interface ReviewAgentInput {
+  actualChangedFiles: string[]
+  attempt: number
+  generation: number
+  implement: ImplementOutput
+  lastFindings: ReviewFinding[]
+  prompt: TaskPrompt
+  taskHandle: string
+}
+
+export interface ImplementerProvider {
+  implement: (input: ImplementAgentInput) => Promise<ImplementOutput>
+  readonly name: string
+}
+
+export interface ReviewerProvider {
+  readonly name: string
+  review: (input: ReviewAgentInput) => Promise<ReviewOutput>
+}
+
+export interface PullRequestReviewInput {
+  checkpointStartedAt: string
+  completionCriteria: string[]
+  pullRequest: PullRequestSnapshot
+  taskHandle: string
+}
+
+export interface PullRequestReviewApprovedResult {
+  kind: 'approved'
+  review: ReviewOutput
+}
+
+export interface PullRequestReviewPendingResult {
+  kind: 'pending'
+}
+
+export interface PullRequestReviewRejectedResult {
+  kind: 'rejected'
+  review: ReviewOutput
+}
+
+export type PullRequestReviewResult =
+  | PullRequestReviewApprovedResult
+  | PullRequestReviewPendingResult
+  | PullRequestReviewRejectedResult
+
+export interface RemoteReviewerProvider {
+  evaluatePullRequestReview: (
+    input: PullRequestReviewInput,
+  ) => Promise<PullRequestReviewResult>
+  readonly name: string
+}
+
+export interface WorkflowRoleProviders {
+  implementer: ImplementerProvider
+  reviewer: RemoteReviewerProvider | ReviewerProvider
+}

package/src/batch/config.ts

@@ -0,0 +1,109 @@
+import { readFile } from 'node:fs/promises'
+import path from 'node:path'
+
+import { parse } from 'yaml'
+import { z } from 'zod'
+
+import {
+  claudeProviderOptionsSchema,
+  codexProviderOptionsSchema,
+  type WorkflowRoleProviderOptions,
+} from '../agents/provider-options'
+
+export const batchProviderSchema = z.enum(['claude', 'codex'])
+
+const jsonSchemaSchema = z.custom<Record<string, unknown>>(
+  (value) =>
+    typeof value === 'object' && value !== null && !Array.isArray(value),
+  {
+    message: 'schema must be an object',
+  },
+)
+
+const globEntrySchema = z.string().trim().min(1)
+
+const globSchema = z
+  .union([globEntrySchema, z.array(globEntrySchema).min(1)])
+  .optional()
+
+const commonBatchConfigSchema = z
+  .object({
+    glob: globSchema,
+    prompt: z.string().trim().min(1),
+    schema: jsonSchemaSchema,
+  })
+  .strict()
+
+const batchConfigSchema = z.discriminatedUnion('provider', [
+  z
+    .object({
+      provider: z.literal('claude'),
+    })
+    .extend(claudeProviderOptionsSchema.shape)
+    .extend(commonBatchConfigSchema.shape)
+    .strict(),
+  z
+    .object({
+      provider: z.literal('codex'),
+    })
+    .extend(codexProviderOptionsSchema.shape)
+    .extend(commonBatchConfigSchema.shape)
+    .strict(),
+])
+
+export type BatchProviderName = WorkflowRoleProviderOptions['provider']
+
+interface BatchConfigBase {
+  configDir: string
+  configPath: string
+  glob: string[]
+  prompt: string
+  schema: Record<string, unknown>
+}
+
+export type BatchConfig = BatchConfigBase & WorkflowRoleProviderOptions
+
+export interface LoadBatchConfigInput {
+  configPath: string
+  cwd: string
+}
+
+function normalizeGlobConfig(glob: string | string[] | undefined) {
+  if (!glob) {
+    return ['**/*']
+  }
+  return typeof glob === 'string' ? [glob] : glob
+}
+
+export async function loadBatchConfig(
+  input: LoadBatchConfigInput,
+): Promise<BatchConfig> {
+  const configPath = path.resolve(input.cwd, input.configPath)
+  const configSource = await readFile(configPath, 'utf8')
+  const rawConfig = parse(configSource) ?? {}
+  const parsedConfig = batchConfigSchema.parse(rawConfig)
+  const configDir = path.dirname(configPath)
+  const baseConfig = {
+    configDir,
+    configPath,
+    glob: normalizeGlobConfig(parsedConfig.glob),
+    prompt: parsedConfig.prompt,
+    schema: parsedConfig.schema,
+  }
+
+  if (parsedConfig.provider === 'claude') {
+    return {
+      ...baseConfig,
+      provider: 'claude',
+      ...(parsedConfig.model ? { model: parsedConfig.model } : {}),
+      ...(parsedConfig.effort ? { effort: parsedConfig.effort } : {}),
+    }
+  }
+
+  return {
+    ...baseConfig,
+    provider: 'codex',
+    ...(parsedConfig.model ? { model: parsedConfig.model } : {}),
+    ...(parsedConfig.effort ? { effort: parsedConfig.effort } : {}),
+  }
+}

package/src/batch/discovery.ts

@@ -0,0 +1,35 @@
+import path from 'node:path'
+
+import { glob } from 'glob'
+
+export interface DiscoverBatchFilesInput {
+  baseDir: string
+  excludedFiles: Set<string>
+  patterns: string[]
+}
+
+function normalizeBatchPath(value: string) {
+  return value.split(path.sep).join('/')
+}
+
+export async function discoverBatchFiles(
+  input: DiscoverBatchFilesInput,
+): Promise<string[]> {
+  const excluded = new Set(
+    [...input.excludedFiles].map((filePath) =>
+      normalizeBatchPath(path.relative(input.baseDir, filePath)),
+    ),
+  )
+  const matched = await glob(input.patterns, {
+    absolute: false,
+    cwd: input.baseDir,
+    dot: true,
+    ignore: ['.git/**', 'node_modules/**'],
+    nodir: true,
+    posix: true,
+  })
+
+  return [...new Set(matched.map(normalizeBatchPath))]
+    .filter((filePath) => !excluded.has(filePath))
+    .sort((left, right) => left.localeCompare(right))
+}

package/src/batch/provider.ts

@@ -0,0 +1,79 @@
+import { ClaudeAgentClient } from '../agents/claude'
+import { CodexAgentClient } from '../agents/codex'
+
+import type { WorkflowRoleProviderOptions } from '../agents/provider-options'
+
+export interface BatchFileInput {
+  content: string
+  filePath: string
+  outputSchema: Record<string, unknown>
+  prompt: string
+}
+
+export interface BatchStructuredOutputProvider {
+  readonly name: string
+  runFile: (input: BatchFileInput) => Promise<unknown>
+}
+
+export type CreateBatchStructuredOutputProviderInput =
+  WorkflowRoleProviderOptions & {
+    workspaceRoot: string
+  }
+
+function buildBatchPrompt(input: BatchFileInput) {
+  return [
+    'Process exactly one file and return structured output only.',
+    input.prompt,
+    `File path: ${input.filePath}`,
+    'File content:',
+    input.content,
+  ].join('\n\n')
+}
+
+class CodexBatchStructuredOutputProvider implements BatchStructuredOutputProvider {
+  public readonly name = 'codex'
+
+  public constructor(private readonly client: CodexAgentClient) {}
+
+  public async runFile(input: BatchFileInput) {
+    return this.client.invokeStructured<unknown>({
+      outputSchema: input.outputSchema,
+      prompt: buildBatchPrompt(input),
+    })
+  }
+}
+
+class ClaudeBatchStructuredOutputProvider implements BatchStructuredOutputProvider {
+  public readonly name = 'claude'
+
+  public constructor(private readonly client: ClaudeAgentClient) {}
+
+  public async runFile(input: BatchFileInput) {
+    return this.client.invokeStructured<unknown>({
+      outputSchema: input.outputSchema,
+      prompt: buildBatchPrompt(input),
+    })
+  }
+}
+
+export function createBatchStructuredOutputProvider(
+  input: CreateBatchStructuredOutputProviderInput,
+): BatchStructuredOutputProvider {
+  if (input.provider === 'codex') {
+    return new CodexBatchStructuredOutputProvider(
+      new CodexAgentClient({
+        ...(input.effort ? { effort: input.effort } : {}),
+        ...(input.model ? { model: input.model } : {}),
+        workspaceRoot: input.workspaceRoot,
+      }),
+    )
+  }
+
+  return new ClaudeBatchStructuredOutputProvider(
+    new ClaudeAgentClient({
+      ...(input.effort ? { effort: input.effort } : {}),
+      ...(input.model ? { model: input.model } : {}),
+      workspaceRoot: input.workspaceRoot,
+    }),
+  )
+}