@alecsibilia/luca 14.0.0-alpha.2 → 14.0.0-alpha.21

package/engine/core/decide-build-early.ts

@@ -0,0 +1,108 @@
+/**
+ * The build steps that settle the run before any ticket moves: a `stop`
+ * reply or an open PR winds the run down (`haltSteps`), and the run branch's
+ * install (`installSteps`), which a failure holds every ticket back on. Pure.
+ */
+import { stuck, type BuildAction } from './build-action'
+import { notRemoved, type BuildView } from './decide-build-view'
+import { installFailure } from './decide-ticket'
+
+import type { RunState } from '../journal/replay'
+
+/**
+ * The steps that end the run (a `stop` reply, or an open PR), or `null` when
+ * the run goes on.
+ */
+export const haltSteps = ({
+    state,
+    view,
+}: {
+    state: RunState
+    view: BuildView
+}): BuildAction[] | null => {
+    const { run_branch, numbers, progress, finished } = view
+    const { pull_request } = state
+    if (state.stop !== null) {
+        // Nothing new starts; finished tickets' worktrees go, the rest stay.
+        const paths = notRemoved({
+            state,
+            paths: numbers.flatMap((number) => {
+                const { worktree } = progress(number)
+                return finished(number) && worktree !== null
+                    ? [worktree.path]
+                    : []
+            }),
+        })
+        if (paths.length > 0) return [{ type: 'remove_worktrees', paths }]
+        return [{ type: 'done', outcome: 'stopped_by_user' }]
+    }
+
+    if (pull_request !== null) {
+        const paths = notRemoved({
+            state,
+            paths: [
+                ...numbers.flatMap((number) => {
+                    const { worktree } = progress(number)
+                    return worktree === null ? [] : [worktree.path]
+                }),
+                run_branch.path,
+            ],
+        })
+        if (paths.length > 0) return [{ type: 'remove_worktrees', paths }]
+        return [{ type: 'done', outcome: 'pr_opened', pull_request }]
+    }
+
+    return null
+}
+
+/**
+ * The run branch's install, or the stuck ticket a failed one holds the run on
+ * (with the owner's `replies`), or `null` when the run branch is installed.
+ */
+export const installSteps = ({
+    state,
+    view,
+    replies,
+}: {
+    state: RunState
+    view: BuildView
+    replies: BuildAction[]
+}): BuildAction[] | null => {
+    const { numbers, finished, skipped, isStuck, stuckSteps } = view
+    const { run_branch_install } = state
+    if (run_branch_install === null) {
+        return [
+            {
+                type: 'install_dependencies',
+                target: 'run_branch',
+                ticket: null,
+            },
+        ]
+    }
+    const runBranchFailure = installFailure({
+        install: run_branch_install,
+        where: "the run branch's checkout",
+    })
+
+    if (runBranchFailure !== null) {
+        // Nothing builds on a run branch whose install failed: the first
+        // ticket is stuck on it until a retry installs it again.
+        if (numbers.some(isStuck)) {
+            return [...numbers.filter(isStuck).flatMap(stuckSteps), ...replies]
+        }
+        const first = numbers.find(
+            (number) => !finished(number) && !skipped(number)
+        )
+        if (first !== undefined) {
+            return [
+                stuck({
+                    ticket: first,
+                    reason: 'install_failed',
+                    detail: runBranchFailure,
+                }),
+            ]
+        }
+    }
+
+    return null
+}

package/engine/core/decide-build-ending.ts

@@ -0,0 +1,145 @@
+/**
+ * The build steps once no ticket can move: closing the already-done tickets
+ * when none joined, the final review, the changeset, and the PR
+ * (`finishSteps`). Pure.
+ */
+import { closeTicketStep } from './already-done'
+import type { BuildAction } from './build-action'
+import { changesetStep } from './changeset'
+import { notRemoved, type BuildView } from './decide-build-view'
+import { decideFinalReview } from './decide-final-review'
+import { finalStuckSteps } from './decide-stuck'
+import { pullRequestText } from './pull-request-text'
+
+import type { RunState } from '../journal/replay'
+
+/**
+ * The steps when no ticket can move now: the already-done tickets closed, the
+ * final review, the changeset, and the PR. `replies` are the owner's replies
+ * a stuck final review takes.
+ */
+export const finishSteps = ({
+    state,
+    view,
+    replies,
+}: {
+    state: RunState
+    view: BuildView
+    replies: BuildAction[]
+}): BuildAction[] => {
+    const {
+        spec_number,
+        snapshot,
+        run_branch,
+        base_branch,
+        run_notes,
+        numbers,
+        progress,
+        pushed,
+        alreadyDone,
+        finished,
+        skipped,
+    } = view
+
+    if (
+        numbers.every((number) => finished(number) || skipped(number)) &&
+        !numbers.some(pushed)
+    ) {
+        // No ticket joined the run branch: no PR, and nothing left to build.
+        // The engine closes the already-done tickets itself (#484).
+        const closing = numbers.filter(
+            (number) => alreadyDone(number) && !progress(number).closed
+        )
+        if (closing.length > 0) {
+            return closing.map((number) =>
+                closeTicketStep({
+                    spec_number,
+                    base_branch,
+                    ticket: number,
+                    shas: progress(number).already_done?.shas ?? [],
+                })
+            )
+        }
+        const paths = notRemoved({
+            state,
+            paths: [
+                ...numbers.flatMap((number) => {
+                    const { worktree } = progress(number)
+                    return worktree === null ? [] : [worktree.path]
+                }),
+                run_branch.path,
+            ],
+        })
+        if (paths.length > 0) return [{ type: 'remove_worktrees', paths }]
+        if (numbers.some(skipped)) {
+            return [{ type: 'done', outcome: 'all_skipped' }]
+        }
+        // Every ticket's work was already done: nothing to do.
+        return [
+            {
+                type: 'finish_nothing_to_do',
+                closed_tickets: snapshot.closed_tickets,
+                already_done: numbers.filter(alreadyDone),
+            },
+        ]
+    }
+    if (numbers.every((number) => finished(number) || skipped(number))) {
+        const final = decideFinalReview({
+            review: state.final_review,
+            crashes: state.crashes,
+            snapshot,
+            run_branch,
+            run_branch_gates: state.run_branch_gates,
+            run_notes,
+            setup_files: state.config?.test_setup_files ?? [],
+        })
+        if (final.status === 'working') return final.actions
+        if (final.status === 'stuck') {
+            // The run branch's worktree stays for a retry.
+            const paths = notRemoved({
+                state,
+                paths: numbers.flatMap((number) => {
+                    const { worktree } = progress(number)
+                    return worktree === null ? [] : [worktree.path]
+                }),
+            })
+            if (paths.length > 0) return [{ type: 'remove_worktrees', paths }]
+            // The owner hears of it, and the run waits for their reply.
+            return [
+                ...finalStuckSteps({ state, spec_number, run_branch }),
+                ...replies,
+            ]
+        }
+        if (state.changesets && state.changeset === null) {
+            return [
+                {
+                    type: 'write_changeset',
+                    branch: run_branch.branch,
+                    ...changesetStep({ spec: snapshot.spec }),
+                },
+            ]
+        }
+        return [
+            {
+                type: 'open_pull_request',
+                head: run_branch.branch,
+                base: base_branch,
+                ...pullRequestText({
+                    snapshot,
+                    tickets: state.tickets,
+                    final_review: state.final_review,
+                    memory_saves: state.memory.saved?.saves ?? [],
+                }),
+            },
+        ]
+    }
+    return [
+        {
+            type: 'invalid_journal',
+            reason: `No ticket can move: ${numbers
+                .filter((number) => !finished(number))
+                .map((number) => `#${number}`)
+                .join(', ')} wait on tickets that never join.`,
+        },
+    ]
+}

package/engine/core/decide-build-helpers.ts

@@ -0,0 +1,87 @@
+import { decide } from './decide'
+
+import type { JournalEntry } from '../journal/journal-record'
+import {
+    baselineTests,
+    commitMade,
+    implemented,
+    intakePassed,
+    leftoverScan,
+    practiceTicket,
+    redCheck,
+    runBranchCreated,
+    testsWritten,
+    ticketBuilt,
+    ticketWorktreeCreated,
+    withInstalls,
+    worktreeReset,
+} from '../testing/build-fixtures'
+import { recordsFrom } from '../testing/intake-fixtures'
+import { REFACTOR_LABEL } from '../tracker/tracker'
+
+/**
+ * Helpers shared by the tests of the decision steps for building a ticket
+ * (`decide-build.test.ts` and the `decide-build-*.test.ts` files beside it).
+ */
+
+export const TICKET = practiceTicket({ number: 11 })
+
+/**
+ * Decide on a run with one ticket (#11) and these entries after intake. Each
+ * new worktree gets a passing install unless the entries list one.
+ */
+export const decideAfter = (entries: JournalEntry[]) =>
+    decide({
+        records: recordsFrom({
+            entries: [
+                ...intakePassed({ tickets: [TICKET] }),
+                ...withInstalls({ entries }),
+            ],
+        }),
+    })
+
+/** The steps of ticket #11 up to and including the step at `index`. */
+export const stepsUpTo = (index: number) => [
+    runBranchCreated(),
+    ...ticketBuilt({ ticket: 11 }).slice(0, index + 1),
+]
+
+/** Ticket #11 up to its first bad-test bounce and the worktree reset. */
+export const bounced = (): JournalEntry[] => [
+    ...stepsUpTo(5),
+    implemented({ ticket: 11, outcome: 'bad_test' }),
+    worktreeReset({ ticket: 11 }),
+]
+
+/** After the bounce: fresh tests, a passing red check, the second red commit. */
+export const replaced = (): JournalEntry[] => [
+    ...bounced(),
+    testsWritten({ ticket: 11, session_id: 'tw-2' }),
+    redCheck({ ticket: 11, ok: true }),
+    leftoverScan({ ticket: 11, stage: 'red' }),
+    commitMade({ ticket: 11, stage: 'red' }),
+]
+
+export const REFACTOR_TICKET = practiceTicket({
+    number: 11,
+    title: 'Split sum into its own file',
+    labels: ['ready-for-agent', REFACTOR_LABEL],
+})
+
+/** Decide on a run whose one ticket (#11) is a refactor ticket. */
+export const decideRefactorAfter = (entries: JournalEntry[]) =>
+    decide({
+        records: recordsFrom({
+            entries: [
+                ...intakePassed({ tickets: [REFACTOR_TICKET] }),
+                ...withInstalls({
+                    entries: [
+                        runBranchCreated(),
+                        ticketWorktreeCreated({ ticket: 11 }),
+                    ],
+                }),
+                baselineTests({ ticket: 11 }),
+                ...entries,
+            ],
+        }),
+    })

package/engine/core/decide-build-tickets.ts

@@ -0,0 +1,207 @@
+/**
+ * Each ticket's next build step (`ticketSteps`): its worktree, the step its
+ * progress calls for, a skip, a crash, or its stuck steps, with the join queue
+ * deciding which approved ticket joins the run branch. A ticket with no step
+ * now because it waits on purpose (its `TicketWait`) waits for another
+ * ticket's shared baseline, the join queue, or the start queue. Pure.
+ */
+import sortBy from 'lodash/sortBy'
+
+import { stuck, type BuildAction } from './build-action'
+import type { BuildView } from './decide-build-view'
+import { crashDetail, crashedOut } from './decide-crashes'
+import { skipDependent } from './decide-stuck'
+import {
+    baselineRunner,
+    nextTicketStep,
+    sharedBaselineStep,
+} from './decide-ticket'
+
+import type { RunState, TicketProgress } from '../journal/replay'
+
+/**
+ * A ticket held on purpose between steps (#559): for `baseline`, another
+ * ticket's shared baseline tests; for `join`, the join queue; for `start`,
+ * the start queue; each on `on_ticket`.
+ */
+export type TicketWait = {
+    ticket: number
+    for: 'baseline' | 'join' | 'start'
+    on_ticket: number | null
+}
+
+/** A ticket's next steps, or the wait that holds it. */
+type TicketPlan = { steps: BuildAction[]; wait: TicketWait | null }
+
+const NOTHING: TicketPlan = { steps: [], wait: null }
+
+/**
+ * Whether a ticket's review finally approved it (no fix round open) and it
+ * has not pushed yet: it waits in the join queue, or is joining.
+ */
+const inJoinQueue = (progress: TicketProgress): boolean =>
+    progress.approved_seq !== null &&
+    progress.review_fix === null &&
+    progress.pushed === null
+
+/** Each ticket's plan: its next step, at most one, or what it waits for. */
+const ticketPlans = ({
+    state,
+    view,
+}: {
+    state: RunState
+    view: BuildView
+}): TicketPlan[] => {
+    const {
+        spec_number,
+        snapshot,
+        run_branch,
+        base_branch,
+        run_notes,
+        numbers,
+        progress,
+        skipped,
+        finished,
+        isStuck,
+        stuckSteps,
+    } = view
+
+    // A ticket already on the run branch finishes its join first (#519): a
+    // retried ticket approved earlier never joins on top of it.
+    const queue = sortBy(
+        numbers.filter(
+            (number) =>
+                inJoinQueue(progress(number)) &&
+                !isStuck(number) &&
+                !skipped(number)
+        ),
+        [
+            (number) => progress(number).joined === null,
+            (number) => progress(number).approved_seq,
+        ]
+    )
+    // A stuck ticket's join is undone before any new ticket starts on it
+    // or joins on top of it (#519): a join on top would be undone with it.
+    const stuckJoinOnRunBranch = numbers.some(
+        (number) =>
+            isStuck(number) &&
+            progress(number).joined?.ok === true &&
+            progress(number).pushed === null
+    )
+    const joiner = stuckJoinOnRunBranch ? null : (queue[0] ?? null)
+    const can_move = (other: number) =>
+        !finished(other) && !skipped(other) && !isStuck(other)
+
+    return numbers.map((number): TicketPlan => {
+        const ticket = snapshot.tickets[number]
+        const ticketProgress = progress(number)
+        if (ticket === undefined || finished(number)) return NOTHING
+        if (skipped(number)) return NOTHING
+        // The same step cut off by crashes too often is not taken again.
+        const crash = crashedOut({
+            crashes: state.crashes,
+            keys: (key) => key === String(number),
+        })
+        if (crash !== null) {
+            return {
+                steps: [
+                    stuck({
+                        ticket: number,
+                        reason: 'crashed',
+                        detail: crashDetail({ crash }),
+                    }),
+                ],
+                wait: null,
+            }
+        }
+        if (isStuck(number)) return { steps: stuckSteps(number), wait: null }
+        const skippedBlocker = ticket.blockers.find(skipped)
+        if (skippedBlocker !== undefined) {
+            return {
+                steps: [
+                    skipDependent({
+                        ticket: number,
+                        because: skippedBlocker,
+                        spec_number,
+                    }),
+                ],
+                wait: null,
+            }
+        }
+        if (ticketProgress.worktree === null) {
+            const unblocked =
+                !stuckJoinOnRunBranch && ticket.blockers.every(finished)
+            if (unblocked && queue.length === 0) {
+                return {
+                    steps: [
+                        {
+                            type: 'create_ticket_worktree',
+                            ticket: number,
+                            run_branch: run_branch.branch,
+                        },
+                    ],
+                    wait: null,
+                }
+            }
+            // Unblocked, it starts once the join queue is empty.
+            return unblocked
+                ? {
+                      steps: [],
+                      wait: {
+                          ticket: number,
+                          for: 'start',
+                          on_ticket: queue[0] ?? null,
+                      },
+                  }
+                : NOTHING
+        }
+        const baseline = { number, numbers, progress, can_move }
+        const step = nextTicketStep({
+            snapshot,
+            ticket,
+            progress: ticketProgress,
+            run_notes,
+            run_branch,
+            base_branch,
+            joiner: number === joiner,
+            setup_files: state.config?.test_setup_files ?? [],
+            baseline_step:
+                ticketProgress.baseline === null
+                    ? sharedBaselineStep(baseline)
+                    : null,
+        })
+        if (step !== null) return { steps: [step], wait: null }
+        if (ticketProgress.baseline === null) {
+            return {
+                steps: [],
+                wait: {
+                    ticket: number,
+                    for: 'baseline',
+                    on_ticket: baselineRunner(baseline),
+                },
+            }
+        }
+        return inJoinQueue(ticketProgress) && number !== joiner
+            ? {
+                  steps: [],
+                  wait: { ticket: number, for: 'join', on_ticket: joiner },
+              }
+            : NOTHING
+    })
+}
+
+/**
+ * The next step of each ticket that can move now, at most one per ticket,
+ * and the tickets that wait on purpose between steps now, in ticket order:
+ * one decision, so a wait is only ever one that left its ticket no step.
+ */
+export const ticketSteps = (args: {
+    state: RunState
+    view: BuildView
+}): { steps: BuildAction[]; waits: TicketWait[] } => {
+    const plans = ticketPlans(args)
+    return {
+        steps: plans.flatMap(({ steps }) => steps),
+        waits: plans.flatMap(({ wait }) => (wait === null ? [] : [wait])),
+    }
+}

package/engine/core/decide-build-view.ts

@@ -0,0 +1,103 @@
+/**
+ * What the build half of the decision step reads about a run's tickets: the
+ * tickets in order, each one's progress, whether it is skipped, pushed,
+ * already done, finished, or stuck, and its stuck steps (`buildViewOf`). Pure.
+ */
+import type { BuildAction } from './build-action'
+import { newestRunNotes } from './build-launch'
+import { stuckTicketSteps } from './decide-stuck'
+
+import {
+    EMPTY_TICKET_PROGRESS,
+    type ReplayedRunNote,
+    type ReplayedSnapshot,
+    type ReplayedWorktree,
+    type RunState,
+    type TicketProgress,
+} from '../journal/replay'
+
+/** The worktrees not removed yet, of these paths. */
+export const notRemoved = ({
+    paths,
+    state,
+}: {
+    paths: string[]
+    state: RunState
+}): string[] => paths.filter((path) => !state.removed_worktrees.includes(path))
+
+/** A run's tickets, as the build half of the decision step reads them. */
+export type BuildView = {
+    spec_number: number
+    snapshot: ReplayedSnapshot
+    run_branch: ReplayedWorktree
+    base_branch: string
+    run_notes: ReplayedRunNote[]
+    /** The run's tickets that intake snapshotted, in order. */
+    numbers: number[]
+    progress: (number: number) => TicketProgress
+    skipped: (number: number) => boolean
+    pushed: (number: number) => boolean
+    alreadyDone: (number: number) => boolean
+    /** Pushed, or its work was already on the base branch (#484). */
+    finished: (number: number) => boolean
+    isStuck: (number: number) => boolean
+    /** The steps that tell the owner a ticket is stuck, and take its reply. */
+    stuckSteps: (number: number) => BuildAction[]
+}
+
+/** The view of a run that has a run branch and a snapshot. */
+export const buildViewOf = ({
+    state,
+    spec_number,
+    snapshot,
+    run_branch,
+}: {
+    state: RunState
+    spec_number: number
+    snapshot: ReplayedSnapshot
+    run_branch: ReplayedWorktree
+}): BuildView => {
+    const base_branch = state.base_branch ?? 'main'
+    const run_notes = newestRunNotes({ run_notes: state.run_notes })
+    const numbers = snapshot.ticket_order.filter(
+        (number) => snapshot.tickets[number] !== undefined
+    )
+    const progress = (number: number): TicketProgress =>
+        state.tickets[number] ?? EMPTY_TICKET_PROGRESS
+
+    const skipped = (number: number) => progress(number).skipped !== null
+    const pushed = (number: number) =>
+        !numbers.includes(number) || progress(number).pushed !== null
+    const alreadyDone = (number: number) =>
+        progress(number).already_done !== null
+    /** Pushed, or its work was already on the base branch (#484). */
+    const finished = (number: number) => pushed(number) || alreadyDone(number)
+    const stuckSteps = (number: number): BuildAction[] => {
+        const ticket = snapshot.tickets[number]
+        return ticket === undefined
+            ? []
+            : stuckTicketSteps({
+                  spec_number,
+                  ticket,
+                  progress: progress(number),
+              })
+    }
+    const isStuck = (number: number) =>
+        progress(number).stuck !== null && !skipped(number)
+
+    return {
+        spec_number,
+        snapshot,
+        run_branch,
+        base_branch,
+        run_notes,
+        numbers,
+        progress,
+        skipped,
+        pushed,
+        alreadyDone,
+        finished,
+        isStuck,
+        stuckSteps,
+    }
+}