task-while 0.0.1 → 0.0.3

package/src/runtime/fs-runtime.ts

@@ -1,209 +0,0 @@
-import { appendFile, readFile } from 'node:fs/promises'
-import path from 'node:path'
-
-import * as fsExtra from 'fs-extra'
-
-import {
-  validateFinalReport,
-  validateImplementArtifact,
-  validateIntegrateArtifact,
-  validateReviewArtifact,
-  validateTaskGraph,
-  validateWorkflowEvent,
-  validateWorkflowState,
-} from '../schema/index'
-import { writeJsonAtomic } from '../utils/fs'
-import { GitRuntime } from './git'
-import { GitHubRuntime } from './github'
-import { createRuntimePaths } from './path-layout'
-
-import type { AttemptArtifactKey, OrchestratorRuntime } from '../core/runtime'
-import type { TaskSourceSession } from '../task-sources/types'
-
-function createArtifactDir(
-  featureDir: string,
-  taskId: string,
-  generation: number,
-  attempt: number,
-) {
-  const runtimePaths = createRuntimePaths(featureDir)
-  return path.join(
-    runtimePaths.tasksDir,
-    taskId,
-    `g${generation}`,
-    `a${attempt}`,
-  )
-}
-
-async function readTextFileIfExists(filePath: string) {
-  const exists = await fsExtra.pathExists(filePath)
-  if (!exists) {
-    return null
-  }
-  return readFile(filePath, 'utf8')
-}
-
-async function readValidatedJsonFileIfExists<T>(
-  filePath: string,
-  validate: (value: unknown) => T,
-): Promise<null | T> {
-  const raw = await readTextFileIfExists(filePath)
-  if (raw === null) {
-    return null
-  }
-  return validate(JSON.parse(raw))
-}
-
-export interface CreateOrchestratorRuntimeInput {
-  featureDir: string
-  taskSource?: TaskSourceSession
-  workspaceRoot: string
-}
-
-export function createOrchestratorRuntime(
-  input: CreateOrchestratorRuntimeInput,
-): OrchestratorRuntime {
-  const runtimePaths = createRuntimePaths(input.featureDir)
-
-  return {
-    git: new GitRuntime(input.workspaceRoot, runtimePaths.runtimeDir),
-    github: new GitHubRuntime(input.workspaceRoot),
-    store: {
-      async appendEvent(event) {
-        const value = validateWorkflowEvent(event)
-        await fsExtra.ensureDir(path.dirname(runtimePaths.events))
-        await appendFile(runtimePaths.events, `${JSON.stringify(value)}\n`)
-      },
-      async loadGraph() {
-        return readValidatedJsonFileIfExists(
-          runtimePaths.graph,
-          validateTaskGraph,
-        )
-      },
-      async loadImplementArtifact(key: AttemptArtifactKey) {
-        const filePath = path.join(
-          createArtifactDir(
-            input.featureDir,
-            key.taskHandle,
-            key.generation,
-            key.attempt,
-          ),
-          'implement.json',
-        )
-        return readValidatedJsonFileIfExists(
-          filePath,
-          validateImplementArtifact,
-        )
-      },
-      async loadReviewArtifact(key: AttemptArtifactKey) {
-        const filePath = path.join(
-          createArtifactDir(
-            input.featureDir,
-            key.taskHandle,
-            key.generation,
-            key.attempt,
-          ),
-          'review.json',
-        )
-        return readValidatedJsonFileIfExists(filePath, validateReviewArtifact)
-      },
-      async loadState() {
-        return readValidatedJsonFileIfExists(
-          runtimePaths.state,
-          validateWorkflowState,
-        )
-      },
-      async readReport() {
-        return readValidatedJsonFileIfExists(
-          runtimePaths.report,
-          validateFinalReport,
-        )
-      },
-      async reset() {
-        await fsExtra.remove(runtimePaths.runtimeDir)
-      },
-      async saveGraph(graph) {
-        await writeJsonAtomic(runtimePaths.graph, validateTaskGraph(graph))
-      },
-      async saveImplementArtifact(artifact) {
-        const value = validateImplementArtifact(artifact)
-        const targetPath = path.join(
-          createArtifactDir(
-            input.featureDir,
-            artifact.taskHandle,
-            artifact.generation,
-            artifact.attempt,
-          ),
-          'implement.json',
-        )
-        await writeJsonAtomic(targetPath, value)
-      },
-      async saveIntegrateArtifact(artifact) {
-        const value = validateIntegrateArtifact(artifact)
-        const targetPath = path.join(
-          createArtifactDir(
-            input.featureDir,
-            artifact.taskHandle,
-            artifact.generation,
-            artifact.attempt,
-          ),
-          'integrate.json',
-        )
-        await writeJsonAtomic(targetPath, value)
-      },
-      async saveReport(report) {
-        await writeJsonAtomic(runtimePaths.report, validateFinalReport(report))
-      },
-      async saveReviewArtifact(artifact) {
-        const value = validateReviewArtifact(artifact)
-        const targetPath = path.join(
-          createArtifactDir(
-            input.featureDir,
-            artifact.taskHandle,
-            artifact.generation,
-            artifact.attempt,
-          ),
-          'review.json',
-        )
-        await writeJsonAtomic(targetPath, value)
-      },
-      async saveState(state) {
-        await writeJsonAtomic(runtimePaths.state, validateWorkflowState(state))
-      },
-    },
-    taskSource:
-      input.taskSource ??
-      ({
-        async applyTaskCompletion() {
-          throw new Error('task source is not configured')
-        },
-        buildCommitSubject() {
-          throw new Error('task source is not configured')
-        },
-        async buildImplementPrompt() {
-          throw new Error('task source is not configured')
-        },
-        async buildReviewPrompt() {
-          throw new Error('task source is not configured')
-        },
-        async getCompletionCriteria() {
-          throw new Error('task source is not configured')
-        },
-        getTaskDependencies() {
-          throw new Error('task source is not configured')
-        },
-        async isTaskCompleted() {
-          throw new Error('task source is not configured')
-        },
-        listTasks() {
-          throw new Error('task source is not configured')
-        },
-        resolveTaskSelector() {
-          throw new Error('task source is not configured')
-        },
-        async revertTaskCompletion() {
-          throw new Error('task source is not configured')
-        },
-      } satisfies TaskSourceSession),
-  }
-}

package/src/workflow/direct-preset.ts

@@ -1,44 +0,0 @@
-import { finalizeTaskCheckbox } from './finalize-task-checkbox'
-
-import type { ReviewerProvider } from '../agents/types'
-import type { DirectWorkflowPreset } from './preset'
-
-export interface CreateDirectWorkflowPresetInput {
-  reviewer: ReviewerProvider
-}
-
-export function createDirectWorkflowPreset(
-  input: CreateDirectWorkflowPresetInput,
-): DirectWorkflowPreset {
-  return {
-    mode: 'direct',
-    async integrate(context) {
-      const { commitSha } = await finalizeTaskCheckbox({
-        commitMessage: context.commitMessage,
-        runtime: context.runtime,
-        taskHandle: context.taskHandle,
-      })
-      return {
-        kind: 'completed',
-        result: {
-          commitSha,
-          summary: 'integrated',
-        },
-      }
-    },
-    async review(context) {
-      const review = await input.reviewer.review({
-        actualChangedFiles: context.actualChangedFiles,
-        attempt: context.attempt,
-        generation: context.generation,
-        implement: context.implement,
-        lastFindings: context.lastFindings,
-        prompt: context.prompt,
-        taskHandle: context.taskHandle,
-      })
-      return review.verdict === 'pass'
-        ? { kind: 'approved', review }
-        : { kind: 'rejected', review }
-    },
-  }
-}

package/src/workflow/preset.ts

@@ -1,86 +0,0 @@
-import type { WorkflowRoleProviders } from '../agents/types'
-import type { OrchestratorRuntime } from '../core/runtime'
-import type { TaskPrompt } from '../task-sources/types'
-import type { ImplementOutput, ReviewFinding, ReviewOutput } from '../types'
-
-export type WorkflowMode = 'direct' | 'pull-request'
-
-export interface DirectReviewPhaseContext {
-  actualChangedFiles: string[]
-  attempt: number
-  commitMessage: string
-  generation: number
-  implement: ImplementOutput
-  lastFindings: ReviewFinding[]
-  prompt: TaskPrompt
-  taskHandle: string
-}
-
-export interface PullRequestReviewPhaseContext {
-  attempt: number
-  commitMessage: string
-  completionCriteria: string[]
-  generation?: number
-  implement?: ImplementOutput
-  lastFindings?: never[]
-  runtime: OrchestratorRuntime
-  taskHandle: string
-}
-
-export interface ApprovedReviewPhaseResult {
-  kind: 'approved'
-  review: ReviewOutput
-}
-
-export interface RejectedReviewPhaseResult {
-  kind: 'rejected'
-  review: ReviewOutput
-}
-
-export type ReviewPhaseResult =
-  | ApprovedReviewPhaseResult
-  | RejectedReviewPhaseResult
-
-export interface IntegratePhaseContext {
-  commitMessage: string
-  runtime: OrchestratorRuntime
-  taskHandle: string
-}
-
-export interface IntegratePhaseResult {
-  kind: 'completed'
-  result: IntegrateResult
-}
-
-export interface IntegrateResult {
-  commitSha: string
-  summary: string
-}
-
-export interface DirectWorkflowPreset {
-  integrate: (context: IntegratePhaseContext) => Promise<IntegratePhaseResult>
-  readonly mode: 'direct'
-  review: (context: DirectReviewPhaseContext) => Promise<ReviewPhaseResult>
-}
-
-export interface PullRequestWorkflowPreset {
-  integrate: (context: IntegratePhaseContext) => Promise<IntegratePhaseResult>
-  readonly mode: 'pull-request'
-  review: (context: PullRequestReviewPhaseContext) => Promise<ReviewPhaseResult>
-}
-
-export type WorkflowPreset = DirectWorkflowPreset | PullRequestWorkflowPreset
-
-export function isPullRequestWorkflowPreset(
-  preset: WorkflowPreset,
-): preset is PullRequestWorkflowPreset {
-  return preset.mode === 'pull-request'
-}
-
-export interface WorkflowRuntime {
-  preset: WorkflowPreset
-  roles: WorkflowRoleProviders
-}
-
-export { createDirectWorkflowPreset } from './direct-preset'
-export { createPullRequestWorkflowPreset } from './pull-request-preset'

package/src/workflow/pull-request-preset.ts

@@ -1,312 +0,0 @@
-import { finalizeTaskCheckbox } from './finalize-task-checkbox'
-
-import type {
-  PullRequestReviewResult,
-  RemoteReviewerProvider,
-} from '../agents/types'
-import type { OrchestratorRuntime, PullRequestRef } from '../core/runtime'
-import type {
-  IntegratePhaseResult,
-  PullRequestReviewPhaseContext,
-  PullRequestWorkflowPreset,
-  ReviewPhaseResult,
-} from './preset'
-
-const DEFAULT_BASE_BRANCH = 'main'
-const DEFAULT_REVIEW_POLL_INTERVAL_MS = 60_000
-
-function toTaskBranchName(commitMessage: string) {
-  const slug = commitMessage
-    .replace(/^Task\s+/i, '')
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, '-')
-    .replace(/^-+|-+$/g, '')
-  return `task/${slug}`
-}
-
-function createCheckpointCommitMessage(commitMessage: string, attempt: number) {
-  return `checkpoint: ${commitMessage} (attempt ${attempt})`
-}
-
-function createPullRequestBody(context: PullRequestReviewPhaseContext) {
-  return [
-    `Task: ${context.commitMessage}`,
-    `Attempt: ${context.attempt}`,
-    '',
-    'Managed by task-while.',
-  ].join('\n')
-}
-
-interface EnsureTaskBranchInput {
-  branchName: string
-  restoreFromRemote: boolean
-  runtime: OrchestratorRuntime
-}
-
-async function ensureTaskBranch(input: EnsureTaskBranchInput) {
-  const currentBranch = await input.runtime.git.getCurrentBranch()
-  if (currentBranch === input.branchName) {
-    return
-  }
-  try {
-    await input.runtime.git.checkoutBranch(input.branchName)
-  } catch {
-    if (input.restoreFromRemote) {
-      await input.runtime.git.checkoutRemoteBranch(input.branchName)
-      return
-    }
-    await input.runtime.git.checkoutBranch(input.branchName, {
-      create: true,
-      startPoint: DEFAULT_BASE_BRANCH,
-    })
-  }
-}
-
-interface EnsurePullRequestInput {
-  branchName: string
-  branchNeedsPush: boolean
-  context: PullRequestReviewPhaseContext
-  existingPullRequest: null | PullRequestRef
-}
-
-async function ensurePullRequest(
-  input: EnsurePullRequestInput,
-): Promise<PullRequestRef> {
-  let pullRequest = input.existingPullRequest
-
-  if (input.branchNeedsPush || !pullRequest) {
-    await input.context.runtime.git.pushBranch(input.branchName)
-  }
-
-  if (pullRequest) {
-    return pullRequest
-  }
-
-  pullRequest = await input.context.runtime.github.createPullRequest({
-    baseBranch: DEFAULT_BASE_BRANCH,
-    body: createPullRequestBody(input.context),
-    headBranch: input.branchName,
-    title: input.context.commitMessage,
-  })
-  return pullRequest
-}
-
-interface WaitForRemoteReviewInput {
-  checkpointStartedAt: string
-  context: PullRequestReviewPhaseContext
-  pullRequest: PullRequestRef
-  reviewer: RemoteReviewerProvider
-  sleep: SleepFunction
-}
-
-type SleepFunction = (ms: number) => Promise<void>
-
-async function waitForRemoteReview(
-  input: WaitForRemoteReviewInput,
-): Promise<ReviewPhaseResult> {
-  const evaluateReview = async () => {
-    const snapshot = await input.context.runtime.github.getPullRequestSnapshot({
-      pullRequestNumber: input.pullRequest.number,
-    })
-    return input.reviewer.evaluatePullRequestReview({
-      checkpointStartedAt: input.checkpointStartedAt,
-      completionCriteria: input.context.completionCriteria,
-      pullRequest: snapshot,
-      taskHandle: input.context.taskHandle,
-    })
-  }
-
-  let result: PullRequestReviewResult = await evaluateReview()
-  while (result.kind === 'pending') {
-    await input.sleep(DEFAULT_REVIEW_POLL_INTERVAL_MS)
-    result = await evaluateReview()
-  }
-  return result
-}
-
-function toLocalCleanupWarning(error: unknown) {
-  return error instanceof Error ? error.message : String(error)
-}
-
-interface CleanupAfterMergeInput {
-  branchName: string
-  runtime: OrchestratorRuntime
-}
-
-async function cleanupAfterMerge(input: CleanupAfterMergeInput) {
-  const warnings: string[] = []
-  let onBaseBranch = false
-
-  try {
-    await input.runtime.git.checkoutBranch(DEFAULT_BASE_BRANCH)
-    onBaseBranch = true
-  } catch (error) {
-    warnings.push(
-      `checkout ${DEFAULT_BASE_BRANCH} failed: ${toLocalCleanupWarning(error)}`,
-    )
-  }
-
-  if (!onBaseBranch) {
-    return warnings
-  }
-
-  try {
-    await input.runtime.git.pullFastForward(DEFAULT_BASE_BRANCH)
-  } catch (error) {
-    warnings.push(
-      `pull ${DEFAULT_BASE_BRANCH} failed: ${toLocalCleanupWarning(error)}`,
-    )
-  }
-
-  try {
-    await input.runtime.git.deleteLocalBranch(input.branchName)
-  } catch (error) {
-    warnings.push(`delete local branch failed: ${toLocalCleanupWarning(error)}`)
-  }
-
-  return warnings
-}
-
-interface SummarizeIntegrateResultInput {
-  status: 'already integrated' | 'integrated'
-  warnings: string[]
-}
-
-function summarizeIntegrateResult(input: SummarizeIntegrateResultInput) {
-  return input.warnings.length === 0
-    ? input.status
-    : `${input.status}; local cleanup warning: ${input.warnings.join('; ')}`
-}
-
-export interface CreatePullRequestWorkflowPresetInput {
-  reviewer: RemoteReviewerProvider
-  sleep?: SleepFunction
-}
-
-export function createPullRequestWorkflowPreset(
-  input: CreatePullRequestWorkflowPresetInput,
-): PullRequestWorkflowPreset {
-  const sleep =
-    input.sleep ??
-    (async (ms: number) => {
-      await new Promise((resolve) => {
-        setTimeout(resolve, ms)
-      })
-    })
-
-  return {
-    mode: 'pull-request',
-    async integrate(context): Promise<IntegratePhaseResult> {
-      const branchName = toTaskBranchName(context.commitMessage)
-      const openPullRequest =
-        await context.runtime.github.findOpenPullRequestByHeadBranch({
-          headBranch: branchName,
-        })
-      if (openPullRequest) {
-        await ensureTaskBranch({
-          branchName,
-          restoreFromRemote: true,
-          runtime: context.runtime,
-        })
-        const taskChecked = await context.runtime.taskSource.isTaskCompleted(
-          context.taskHandle,
-        )
-        if (!taskChecked) {
-          await finalizeTaskCheckbox({
-            commitMessage: context.commitMessage,
-            runtime: context.runtime,
-            taskHandle: context.taskHandle,
-          })
-        }
-        await context.runtime.git.pushBranch(branchName)
-        const mergeResult = await context.runtime.github.squashMergePullRequest(
-          {
-            pullRequestNumber: openPullRequest.number,
-            subject: context.commitMessage,
-          },
-        )
-        const warnings = await cleanupAfterMerge({
-          branchName,
-          runtime: context.runtime,
-        })
-
-        return {
-          kind: 'completed',
-          result: {
-            commitSha: mergeResult.commitSha,
-            summary: summarizeIntegrateResult({
-              status: 'integrated',
-              warnings,
-            }),
-          },
-        }
-      }
-
-      const mergedPullRequest =
-        await context.runtime.github.findMergedPullRequestByHeadBranch({
-          headBranch: branchName,
-        })
-      if (!mergedPullRequest) {
-        throw new Error(
-          `Missing open or merged pull request for branch ${branchName}`,
-        )
-      }
-      const warnings = await cleanupAfterMerge({
-        branchName,
-        runtime: context.runtime,
-      })
-
-      return {
-        kind: 'completed',
-        result: {
-          commitSha: mergedPullRequest.mergeCommitSha,
-          summary: summarizeIntegrateResult({
-            status: 'already integrated',
-            warnings,
-          }),
-        },
-      }
-    },
-    async review(context): Promise<ReviewPhaseResult> {
-      const branchName = toTaskBranchName(context.commitMessage)
-      const checkpointMessage = createCheckpointCommitMessage(
-        context.commitMessage,
-        context.attempt,
-      )
-      const existingPullRequest =
-        await context.runtime.github.findOpenPullRequestByHeadBranch({
-          headBranch: branchName,
-        })
-      await ensureTaskBranch({
-        branchName,
-        restoreFromRemote: existingPullRequest !== null,
-        runtime: context.runtime,
-      })
-
-      const headSubject = await context.runtime.git.getHeadSubject()
-      if (headSubject !== checkpointMessage) {
-        await context.runtime.git.commitTask({
-          message: checkpointMessage,
-        })
-      }
-
-      const checkpointStartedAt = await context.runtime.git.getHeadTimestamp()
-      const pullRequest = await ensurePullRequest({
-        branchName,
-        branchNeedsPush: true,
-        context,
-        existingPullRequest,
-      })
-
-      return waitForRemoteReview({
-        checkpointStartedAt,
-        context,
-        pullRequest,
-        reviewer: input.reviewer,
-        sleep,
-      })
-    },
-  }
-}
-
-export { DEFAULT_REVIEW_POLL_INTERVAL_MS, toTaskBranchName }