task-while 0.0.1 → 0.0.3

package/src/core/engine-helpers.ts

@@ -1,114 +0,0 @@
-import type {
-  PendingTaskState,
-  ReviewFinding,
-  ReviewOutput,
-  ReviewVerdict,
-  TaskGraph,
-  TaskState,
-  TaskTopologyEntry,
-  WorkflowState,
-} from '../types'
-
-export function cloneState(state: WorkflowState): WorkflowState {
-  return structuredClone(state)
-}
-
-export function createBaseTaskState(): PendingTaskState {
-  return {
-    attempt: 0,
-    generation: 1,
-    invalidatedBy: null,
-    lastFindings: [],
-    status: 'pending',
-  }
-}
-
-export function getTask(
-  graph: TaskGraph,
-  taskHandle: string,
-): TaskTopologyEntry {
-  const task = graph.tasks.find((item) => item.handle === taskHandle)
-  if (!task) {
-    throw new Error(`Unknown task: ${taskHandle}`)
-  }
-  return task
-}
-
-export function getTaskState(
-  state: WorkflowState,
-  taskHandle: string,
-): TaskState {
-  const taskState = state.tasks[taskHandle]
-  if (!taskState) {
-    throw new Error(`Missing state for task ${taskHandle}`)
-  }
-  return taskState
-}
-
-export function canStartTask(
-  graph: TaskGraph,
-  state: WorkflowState,
-  taskHandle: string,
-) {
-  const task = getTask(graph, taskHandle)
-  return task.dependsOn.every(
-    (dependency) => state.tasks[dependency]?.status === 'done',
-  )
-}
-
-export function getMaxIterations(graph: TaskGraph) {
-  return graph.maxIterations
-}
-
-export function withReviewMetadata(
-  taskState: TaskState,
-  input: WithReviewMetadataInput,
-) {
-  const next = {
-    attempt: taskState.attempt,
-    generation: taskState.generation,
-    invalidatedBy: taskState.invalidatedBy,
-    lastFindings: taskState.lastFindings,
-    ...(taskState.lastReviewVerdict
-      ? { lastReviewVerdict: taskState.lastReviewVerdict }
-      : {}),
-  }
-  if (input.findings) {
-    next.lastFindings = input.findings
-  }
-  if (input.reviewVerdict) {
-    next.lastReviewVerdict = input.reviewVerdict
-  }
-  return next
-}
-
-export interface WithReviewMetadataInput {
-  findings?: ReviewFinding[]
-  reviewVerdict?: ReviewVerdict
-}
-
-export interface ZeroGateInput {
-  review: ReviewOutput
-}
-
-export function shouldPassZeroGate(input: ZeroGateInput) {
-  return (
-    input.review.verdict === 'pass' &&
-    input.review.findings.length === 0 &&
-    input.review.acceptanceChecks.every((check) => check.status === 'pass')
-  )
-}
-
-export function collectDescendants(
-  graph: TaskGraph,
-  taskHandle: string,
-  seen = new Set<string>(),
-) {
-  for (const task of graph.tasks) {
-    if (task.dependsOn.includes(taskHandle) && !seen.has(task.handle)) {
-      seen.add(task.handle)
-      collectDescendants(graph, task.handle, seen)
-    }
-  }
-  return seen
-}

package/src/core/engine-outcomes.ts

@@ -1,166 +0,0 @@
-import {
-  cloneState,
-  getMaxIterations,
-  getTaskState,
-  shouldPassZeroGate,
-  withReviewMetadata,
-} from './engine-helpers'
-
-import type {
-  FinalReport,
-  ReviewOutput,
-  TaskGraph,
-  WorkflowState,
-} from '../types'
-
-export function recordReviewApproved(
-  state: WorkflowState,
-  taskHandle: string,
-  review: ReviewOutput,
-): WorkflowState {
-  const next = cloneState(state)
-  const taskState = getTaskState(next, taskHandle)
-  if (taskState.status !== 'running' || taskState.stage !== 'review') {
-    throw new Error(`Task ${taskHandle} is not reviewing`)
-  }
-  if (review.verdict !== 'pass') {
-    throw new Error(`Task ${taskHandle} review is not approved`)
-  }
-  next.tasks[taskHandle] = {
-    ...withReviewMetadata(taskState, {
-      findings: review.findings,
-      reviewVerdict: review.verdict,
-    }),
-    stage: 'integrate',
-    status: 'running',
-  }
-  return next
-}
-
-export function recordIntegrateResult(
-  _graph: TaskGraph,
-  state: WorkflowState,
-  taskHandle: string,
-  input: RecordIntegrateResultInput,
-): WorkflowState {
-  const next = cloneState(state)
-  const taskState = getTaskState(next, taskHandle)
-  if (taskState.status !== 'running' || taskState.stage !== 'integrate') {
-    throw new Error(`Task ${taskHandle} is not integrating`)
-  }
-  if (!shouldPassZeroGate(input)) {
-    throw new Error(
-      `Task ${taskHandle} integration requires an approved review`,
-    )
-  }
-  next.currentTaskHandle = null
-  next.tasks[taskHandle] = {
-    ...withReviewMetadata(taskState, {
-      findings: input.review.findings,
-      reviewVerdict: input.review.verdict,
-    }),
-    commitSha: input.commitSha,
-    status: 'done',
-  }
-  return next
-}
-
-export interface RecordIntegrateResultInput {
-  commitSha: string
-  review: ReviewOutput
-}
-
-export function recordCommitFailure(
-  graph: TaskGraph,
-  state: WorkflowState,
-  taskHandle: string,
-  reason: string,
-): WorkflowState {
-  const next = cloneState(state)
-  const taskState = getTaskState(next, taskHandle)
-  next.currentTaskHandle = null
-  const metadata = withReviewMetadata(taskState, {
-    reviewVerdict: 'pass',
-  })
-  next.tasks[taskHandle] =
-    taskState.attempt >= getMaxIterations(graph)
-      ? {
-          ...metadata,
-          reason,
-          status: 'blocked',
-        }
-      : {
-          ...metadata,
-          status: 'rework',
-        }
-  return next
-}
-
-export function recordReviewFailure(
-  graph: TaskGraph,
-  state: WorkflowState,
-  taskHandle: string,
-  reason: string,
-): WorkflowState {
-  const next = cloneState(state)
-  const taskState = getTaskState(next, taskHandle)
-  next.currentTaskHandle = null
-  next.tasks[taskHandle] =
-    taskState.attempt >= getMaxIterations(graph)
-      ? {
-          ...withReviewMetadata(taskState, {}),
-          reason,
-          status: 'blocked',
-        }
-      : {
-          ...withReviewMetadata(taskState, {}),
-          status: 'rework',
-        }
-  return next
-}
-
-export function buildReport(
-  graph: TaskGraph,
-  state: WorkflowState,
-  generatedAt: string,
-): FinalReport {
-  const tasks = graph.tasks.map((task) => {
-    const taskState = getTaskState(state, task.handle)
-    return {
-      attempt: taskState.attempt,
-      generation: taskState.generation,
-      taskHandle: task.handle,
-      ...('commitSha' in taskState ? { commitSha: taskState.commitSha } : {}),
-      ...(taskState.lastReviewVerdict
-        ? { lastReviewVerdict: taskState.lastReviewVerdict }
-        : {}),
-      ...('reason' in taskState ? { reason: taskState.reason } : {}),
-      status: taskState.status,
-    }
-  })
-
-  const blockedTasks = tasks.filter((task) => task.status === 'blocked').length
-  const completedTasks = tasks.filter((task) => task.status === 'done').length
-  const replanTasks = tasks.filter((task) => task.status === 'replan').length
-  const finalStatus =
-    replanTasks > 0
-      ? 'replan_required'
-      : blockedTasks > 0
-        ? 'blocked'
-        : completedTasks === tasks.length
-          ? 'completed'
-          : 'in_progress'
-
-  return {
-    featureId: graph.featureId,
-    generatedAt,
-    tasks,
-    summary: {
-      blockedTasks,
-      completedTasks,
-      finalStatus,
-      replanTasks,
-      totalTasks: tasks.length,
-    },
-  }
-}

package/src/core/engine.ts

@@ -1,223 +0,0 @@
-import {
-  canStartTask,
-  cloneState,
-  createBaseTaskState,
-  getMaxIterations,
-  getTaskState,
-  shouldPassZeroGate,
-  withReviewMetadata,
-} from './engine-helpers'
-
-import type { ReviewOutput, TaskGraph, WorkflowState } from '../types'
-
-export {
-  buildReport,
-  recordCommitFailure,
-  recordIntegrateResult,
-  recordReviewApproved,
-  recordReviewFailure,
-} from './engine-outcomes'
-
-export function createInitialWorkflowState(graph: TaskGraph): WorkflowState {
-  return {
-    currentTaskHandle: null,
-    featureId: graph.featureId,
-    tasks: Object.fromEntries(
-      graph.tasks.map((task) => [task.handle, createBaseTaskState()]),
-    ),
-  }
-}
-
-export function alignStateWithGraph(
-  graph: TaskGraph,
-  state: WorkflowState,
-  options?: AlignStateWithGraphOptions,
-): WorkflowState {
-  const next = cloneState(state)
-  const alignedTasks = Object.fromEntries(
-    graph.tasks.map((task) => {
-      const existing = next.tasks[task.handle] ?? createBaseTaskState()
-      if (existing.status === 'running') {
-        if (
-          (options?.preserveRunningReview && existing.stage === 'review') ||
-          (options?.preserveRunningIntegrate && existing.stage === 'integrate')
-        ) {
-          return [task.handle, existing]
-        }
-        return [
-          task.handle,
-          {
-            attempt: existing.attempt,
-            generation: existing.generation,
-            invalidatedBy: existing.invalidatedBy,
-            lastFindings: existing.lastFindings,
-            ...(existing.lastReviewVerdict
-              ? { lastReviewVerdict: existing.lastReviewVerdict }
-              : {}),
-            status: 'rework' as const,
-          },
-        ]
-      }
-      return [task.handle, existing]
-    }),
-  )
-
-  return {
-    featureId: graph.featureId,
-    tasks: alignedTasks,
-    currentTaskHandle:
-      next.currentTaskHandle && alignedTasks[next.currentTaskHandle]
-        ? next.currentTaskHandle
-        : null,
-  }
-}
-
-export function selectNextRunnableTask(
-  graph: TaskGraph,
-  state: WorkflowState,
-): null | string {
-  return (
-    graph.tasks.find((task) => {
-      const taskState = state.tasks[task.handle]
-      if (!taskState) {
-        return false
-      }
-      if (taskState.status === 'rework') {
-        return true
-      }
-      return (
-        taskState.status === 'pending' &&
-        canStartTask(graph, state, task.handle)
-      )
-    })?.handle ?? null
-  )
-}
-
-export function startAttempt(
-  graph: TaskGraph,
-  state: WorkflowState,
-  taskHandle: string,
-): WorkflowState {
-  const taskState = getTaskState(state, taskHandle)
-  if (taskState.status !== 'pending' && taskState.status !== 'rework') {
-    throw new Error(`Task ${taskHandle} is not runnable`)
-  }
-  if (
-    taskState.status === 'pending' &&
-    !canStartTask(graph, state, taskHandle)
-  ) {
-    throw new Error(`Task ${taskHandle} dependencies are not completed`)
-  }
-  const next = cloneState(state)
-  const current = getTaskState(next, taskHandle)
-  next.currentTaskHandle = taskHandle
-  next.tasks[taskHandle] = {
-    ...current,
-    attempt: current.attempt + 1,
-    invalidatedBy: null,
-    stage: 'implement',
-    status: 'running',
-  }
-  return next
-}
-
-export function recordImplementSuccess(
-  state: WorkflowState,
-  taskHandle: string,
-): WorkflowState {
-  const next = cloneState(state)
-  const taskState = getTaskState(next, taskHandle)
-  if (taskState.status !== 'running' || taskState.stage !== 'implement') {
-    throw new Error(`Task ${taskHandle} is not implementing`)
-  }
-  next.tasks[taskHandle] = {
-    ...taskState,
-    stage: 'review',
-    status: 'running',
-  }
-  return next
-}
-
-export function recordImplementFailure(
-  graph: TaskGraph,
-  state: WorkflowState,
-  taskHandle: string,
-  reason: string,
-): WorkflowState {
-  const next = cloneState(state)
-  const taskState = getTaskState(next, taskHandle)
-  next.currentTaskHandle = null
-  next.tasks[taskHandle] =
-    taskState.attempt >= getMaxIterations(graph)
-      ? {
-          ...withReviewMetadata(taskState, {}),
-          reason,
-          status: 'blocked',
-        }
-      : {
-          ...withReviewMetadata(taskState, {}),
-          status: 'rework',
-        }
-  return next
-}
-
-export function recordReviewResult(
-  graph: TaskGraph,
-  state: WorkflowState,
-  taskHandle: string,
-  input: RecordReviewResultInput,
-): WorkflowState {
-  const next = cloneState(state)
-  const taskState = getTaskState(next, taskHandle)
-  next.currentTaskHandle = null
-  const metadata = withReviewMetadata(taskState, {
-    findings: input.review.findings,
-    reviewVerdict: input.review.verdict,
-  })
-
-  if (shouldPassZeroGate(input)) {
-    throw new Error(
-      `Task ${taskHandle} requires integrate result after approved review`,
-    )
-  }
-
-  if (input.review.verdict === 'replan') {
-    next.tasks[taskHandle] = {
-      ...metadata,
-      reason: input.review.summary,
-      status: 'replan',
-    }
-    return next
-  }
-
-  if (input.review.verdict === 'blocked') {
-    next.tasks[taskHandle] = {
-      ...metadata,
-      reason: input.review.summary,
-      status: 'blocked',
-    }
-    return next
-  }
-
-  next.tasks[taskHandle] =
-    taskState.attempt >= getMaxIterations(graph)
-      ? {
-          ...metadata,
-          reason: input.review.summary,
-          status: 'blocked',
-        }
-      : {
-          ...metadata,
-          status: 'rework',
-        }
-  return next
-}
-
-export interface AlignStateWithGraphOptions {
-  preserveRunningIntegrate?: boolean
-  preserveRunningReview?: boolean
-}
-
-export interface RecordReviewResultInput {
-  review: ReviewOutput
-}

package/src/core/orchestrator-helpers.ts

@@ -1,52 +0,0 @@
-import { buildReport } from './engine'
-
-import type {
-  ImplementArtifact,
-  ReviewArtifact,
-  TaskGraph,
-  WorkflowEvent,
-  WorkflowState,
-} from '../types'
-import type { OrchestratorRuntime } from './runtime'
-
-export function now() {
-  return new Date().toISOString()
-}
-
-export async function persistState(
-  runtime: OrchestratorRuntime,
-  graph: TaskGraph,
-  state: WorkflowState,
-) {
-  await runtime.store.saveState(state)
-  const report = buildReport(graph, state, now())
-  await runtime.store.saveReport(report)
-  return report
-}
-
-export async function appendEvent(
-  runtime: OrchestratorRuntime,
-  event: WorkflowEvent,
-) {
-  await runtime.store.appendEvent(event)
-}
-
-export async function persistCommittedArtifacts(
-  runtime: OrchestratorRuntime,
-  input: PersistCommittedArtifactsInput,
-) {
-  await runtime.store.saveImplementArtifact({
-    ...input.implementArtifact,
-    commitSha: input.commitSha,
-  })
-  await runtime.store.saveReviewArtifact({
-    ...input.reviewArtifact,
-    commitSha: input.commitSha,
-  })
-}
-
-export interface PersistCommittedArtifactsInput {
-  commitSha: string
-  implementArtifact: ImplementArtifact
-  reviewArtifact: ReviewArtifact
-}

package/src/core/orchestrator-integrate-resume.ts

@@ -1,149 +0,0 @@
-import {
-  isPullRequestWorkflowPreset,
-  type WorkflowRuntime,
-} from '../workflow/preset'
-import { recordCommitFailure, recordIntegrateResult } from './engine'
-import {
-  appendEvent,
-  now,
-  persistCommittedArtifacts,
-  persistState,
-} from './orchestrator-helpers'
-
-import type {
-  FinalReport,
-  IntegrateArtifact,
-  TaskGraph,
-  WorkflowState,
-} from '../types'
-import type { OrchestratorRuntime } from './runtime'
-
-export interface ResumePullRequestIntegrateInput {
-  graph: TaskGraph
-  runtime: OrchestratorRuntime
-  state: WorkflowState
-  workflow: WorkflowRuntime
-}
-
-export interface ResumePullRequestIntegrateResult {
-  report: FinalReport
-  state: WorkflowState
-}
-
-export async function resumePullRequestIntegrate(
-  input: ResumePullRequestIntegrateInput,
-): Promise<null | ResumePullRequestIntegrateResult> {
-  if (
-    !isPullRequestWorkflowPreset(input.workflow.preset) ||
-    !input.state.currentTaskHandle
-  ) {
-    return null
-  }
-
-  const taskHandle = input.state.currentTaskHandle
-  const taskState = input.state.tasks[taskHandle]
-  if (taskState?.status !== 'running' || taskState.stage !== 'integrate') {
-    return null
-  }
-
-  const artifactKey = {
-    attempt: taskState.attempt,
-    generation: taskState.generation,
-    taskHandle,
-  }
-  const [implementArtifact, reviewArtifact] = await Promise.all([
-    input.runtime.store.loadImplementArtifact(artifactKey),
-    input.runtime.store.loadReviewArtifact(artifactKey),
-  ])
-
-  if (!implementArtifact || !reviewArtifact) {
-    const reason = `Cannot resume integrate for ${taskHandle} without persisted implement and review artifacts`
-    const nextState = recordCommitFailure(
-      input.graph,
-      input.state,
-      taskHandle,
-      reason,
-    )
-    await appendEvent(input.runtime, {
-      attempt: taskState.attempt,
-      detail: reason,
-      generation: taskState.generation,
-      taskHandle,
-      timestamp: now(),
-      type: 'integrate_failed',
-    })
-    const report = await persistState(input.runtime, input.graph, nextState)
-    return {
-      report,
-      state: nextState,
-    }
-  }
-
-  const commitMessage = input.runtime.taskSource.buildCommitSubject(taskHandle)
-
-  let integrateResult
-  try {
-    integrateResult = await input.workflow.preset.integrate({
-      commitMessage,
-      runtime: input.runtime,
-      taskHandle,
-    })
-  } catch (error) {
-    const reason = error instanceof Error ? error.message : String(error)
-    const nextState = recordCommitFailure(
-      input.graph,
-      input.state,
-      taskHandle,
-      reason,
-    )
-    await appendEvent(input.runtime, {
-      attempt: taskState.attempt,
-      detail: reason,
-      generation: taskState.generation,
-      taskHandle,
-      timestamp: now(),
-      type: 'integrate_failed',
-    })
-    const report = await persistState(input.runtime, input.graph, nextState)
-    return {
-      report,
-      state: nextState,
-    }
-  }
-
-  const integrateArtifact: IntegrateArtifact = {
-    attempt: taskState.attempt,
-    createdAt: now(),
-    generation: taskState.generation,
-    result: integrateResult.result,
-    taskHandle,
-  }
-  const nextState = recordIntegrateResult(
-    input.graph,
-    input.state,
-    taskHandle,
-    {
-      commitSha: integrateResult.result.commitSha,
-      review: reviewArtifact.result,
-    },
-  )
-  const report = await persistState(input.runtime, input.graph, nextState)
-  await appendEvent(input.runtime, {
-    attempt: taskState.attempt,
-    detail: integrateResult.result.summary,
-    generation: taskState.generation,
-    taskHandle,
-    timestamp: now(),
-    type: 'integrate_completed',
-  })
-  await input.runtime.store.saveIntegrateArtifact(integrateArtifact)
-  await persistCommittedArtifacts(input.runtime, {
-    commitSha: integrateResult.result.commitSha,
-    implementArtifact,
-    reviewArtifact,
-  })
-  return {
-    report,
-    state: nextState,
-  }
-}