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

package/board/server/reduce-board-steps.ts

@@ -0,0 +1,226 @@
+/**
+ * The steps the engine journals: the one a ticket is in, or the ones the
+ * run itself is running, and the stage a step puts a ticket in.
+ */
+import type { BoardRecord } from './board-vocabulary'
+import { roleWords } from './reduce-board-text'
+import { updateTicket } from './reduce-board-update'
+
+import {
+    BASELINE_STEP_TEXT,
+    type BoardState,
+    type TicketCard,
+    type TicketStage,
+} from '../shared/board-state'
+
+/** A step's action type in words, when it reads better than its name. */
+const STEP_WORDS: Record<string, string> = {
+    install_dependencies: 'installing packages',
+    run_baseline_tests: BASELINE_STEP_TEXT,
+    run_red_check: 'running the red check',
+    run_gates: 'running the checks',
+    run_final_gates: 'running the checks',
+    run_final_slow_tests: 'running the slow tests',
+    join_run_branch: 'joining the run branch',
+    push_run_branch: 'pushing the run branch',
+    push_final_fixes: 'pushing the run branch',
+    write_changeset: 'writing the changeset',
+    open_pull_request: 'opening the pull request',
+    mark_already_done: 'noting the work is already done',
+    close_ticket: 'closing the ticket',
+}
+
+/**
+ * A `step_started`'s step in words: an agent's turn (`<type>:<role>`)
+ * waits for its role; any other step as `STEP_WORDS` has it, else its
+ * action type.
+ *
+ * @example
+ * stepText({ step: 'run_gates' }) // 'running the checks'
+ * stepText({ step: 'follow_up_agent:implementer' }) // 'waiting for the implementer'
+ */
+export const stepText = ({ step }: { step: string }): string => {
+    const colon = step.indexOf(':')
+    if (colon >= 0) {
+        return `waiting for the ${roleWords({ role: step.slice(colon + 1) })}`
+    }
+    return STEP_WORDS[step] ?? step.replaceAll('_', ' ')
+}
+
+/** The run's running steps, and the newest of them as its current step. */
+const withRunSteps = ({
+    state,
+    run_steps,
+}: {
+    state: BoardState
+    run_steps: BoardState['run_steps']
+}): BoardState => {
+    const newest = run_steps.at(-1)
+    return {
+        ...state,
+        run_steps,
+        current_step: newest
+            ? { text: newest.text, since: newest.since }
+            : null,
+    }
+}
+
+/** No step running anywhere: the engine ended, or the run stopped. */
+export const withoutSteps = ({ state }: { state: BoardState }): BoardState =>
+    withRunSteps({
+        state: {
+            ...state,
+            tickets: state.tickets.map((card) =>
+                card.current_step === null
+                    ? card
+                    : { ...card, current_step: null }
+            ),
+        },
+        run_steps: [],
+    })
+
+/** The stages a step doesn't move a ticket out of. */
+const SETTLED_STAGES = new Set<TicketStage>(['stuck', 'done', 'skipped'])
+
+/**
+ * The stage a ticket's step puts it in (#549): the red check and the checks
+ * are testing, but the checks after joining are still joining; joining and
+ * pushing the run branch are joining. Any other step, or a stuck, done or
+ * skipped ticket, keeps its stage.
+ */
+const stepStage = ({
+    card,
+    step,
+}: {
+    card: TicketCard
+    step: string
+}): TicketStage => {
+    if (SETTLED_STAGES.has(card.stage)) return card.stage
+    switch (step) {
+        case 'run_red_check':
+            return 'testing'
+        case 'run_gates':
+            return card.stage === 'joining' ? 'joining' : 'testing'
+        case 'join_run_branch':
+        case 'push_run_branch':
+            return 'joining'
+        default:
+            return card.stage
+    }
+}
+
+/**
+ * A step began: it is its ticket's current step, or one of the run's, and
+ * it sets the ticket's stage. A new step on the same key (a crash's redo)
+ * replaces the one before it.
+ */
+const stepStarted = ({
+    state,
+    record,
+}: {
+    state: BoardState
+    record: Extract<BoardRecord, { kind: 'step_started' }>
+}): BoardState => {
+    // A replayed journal of an engine that ended has no step running.
+    const ended = state.run.engine_ended !== null
+    const current_step = {
+        text: stepText({ step: record.content.step }),
+        since: record.time,
+    }
+    if (record.ticket !== null) {
+        return updateTicket({
+            state,
+            number: record.ticket,
+            update: (card) => ({
+                ...card,
+                stage: stepStage({ card, step: record.content.step }),
+                current_step: ended ? card.current_step : current_step,
+                // Its next step ends any wait.
+                wait: null,
+            }),
+        })
+    }
+    if (ended) return state
+    const { key } = record.content
+    return withRunSteps({
+        state,
+        run_steps: [
+            ...state.run_steps.filter((step) => step.key !== key),
+            { key, ...current_step },
+        ],
+    })
+}
+
+const stepEnded = ({
+    state,
+    record,
+}: {
+    state: BoardState
+    record: Extract<BoardRecord, { kind: 'step_ended' }>
+}): BoardState => {
+    if (record.ticket !== null) {
+        return updateTicket({
+            state,
+            number: record.ticket,
+            // Between steps now: what it waits for is worked out on the
+            // card, unless the engine journals it (`ticket_waiting`).
+            update: (card) => ({
+                ...card,
+                current_step: null,
+                wait: { for: null, on_ticket: null, since: record.time },
+            }),
+        })
+    }
+    return withRunSteps({
+        state,
+        run_steps: state.run_steps.filter(
+            (step) => step.key !== record.content.key
+        ),
+    })
+}
+
+/** A ticket began to wait between steps, for what the engine says (#559). */
+const ticketWaiting = ({
+    state,
+    record,
+}: {
+    state: BoardState
+    record: Extract<BoardRecord, { kind: 'ticket_waiting' }>
+}): BoardState => {
+    const { for: waiting_for, on_ticket, since } = record.content
+    return updateTicket({
+        state,
+        number: record.ticket,
+        update: (card) => ({
+            ...card,
+            wait: { for: waiting_for, on_ticket, since },
+        }),
+    })
+}
+
+/** The record kinds of a step, and of a wait between steps. */
+export const STEP_KINDS = [
+    'step_started',
+    'step_ended',
+    'ticket_waiting',
+] as const
+
+type StepRecord = Extract<BoardRecord, { kind: (typeof STEP_KINDS)[number] }>
+
+/** Applies one record of STEP_KINDS to the board. */
+export const applyStepKind = ({
+    state,
+    record,
+}: {
+    state: BoardState
+    record: StepRecord
+}): BoardState => {
+    switch (record.kind) {
+        case 'step_started':
+            return stepStarted({ state, record })
+        case 'step_ended':
+            return stepEnded({ state, record })
+        case 'ticket_waiting':
+            return ticketWaiting({ state, record })
+    }
+}

package/board/server/reduce-board-text.ts

@@ -0,0 +1,139 @@
+/**
+ * Words for the reducer: short pure functions that turn ids, counts and
+ * record fields into the texts a card or row shows. They hold no board
+ * state.
+ */
+import type { BoardRecord } from './board-vocabulary'
+
+import type { FindingCounts } from '../shared/board-state'
+
+/** Longest single "tried" line kept in state. */
+export const LINE_MAX = 240
+
+/**
+ * A commit's short sha, as git and GitHub show it.
+ *
+ * @example
+ * shortSha({ sha: '3559c25f5a1b' }) // '3559c25'
+ */
+export const shortSha = ({ sha }: { sha: string }): string => sha.slice(0, 7)
+
+/**
+ * An already-done ticket's activity (#484): calm, with the commits that
+ * did its work.
+ *
+ * @example
+ * alreadyDoneText({ shas: ['3559c25f5a1b'] }) // 'already done · 3559c25'
+ */
+export const alreadyDoneText = ({ shas }: { shas: string[] }): string =>
+    ['already done', ...shas.map((sha) => shortSha({ sha }))].join(' · ')
+
+/** Cuts `text` to `max` characters, ending in "…" when it was longer. */
+export const clip = ({ text, max }: { text: string; max: number }): string =>
+    text.length > max ? `${text.slice(0, max - 1)}…` : text
+
+export const firstLine = ({ text }: { text: string }): string =>
+    clip({ text: text.split('\n')[0] ?? '', max: LINE_MAX })
+
+/** How an agent turn failed, in words: `agent_failed`'s `failure`. */
+const FAILURES: Record<string, string> = {
+    agent: 'failed',
+    result: 'gave no usable result',
+    guard: "broke its role's rules (the changes were undone)",
+    engine: 'could not run (an engine-side failure; a fresh agent starts)',
+}
+
+/** An `agent_failed` failure kind in words. */
+export const failureText = ({ failure }: { failure: string }): string =>
+    FAILURES[failure] ?? `failed (${failure})`
+
+/** Issue numbers as `#12`, `#12 and #13`, or `#12, #13 and #14`. */
+export const numbersText = ({ numbers }: { numbers: number[] }): string => {
+    const refs = numbers.map((number) => `#${number}`)
+    const last = refs.at(-1) ?? ''
+    return refs.length <= 1
+        ? last
+        : `${refs.slice(0, -1).join(', ')} and ${last}`
+}
+
+/**
+ * A role in words: a final review lens's role (`security-lens`) reads
+ * "security lens"; any other role as it is.
+ *
+ * @example
+ * roleWords({ role: 'security-lens' }) // 'security lens'
+ */
+export const roleWords = ({ role }: { role: string }): string =>
+    role.endsWith('-lens') ? `${role.slice(0, -'-lens'.length)} lens` : role
+
+/** A ticket review's findings counted by severity. */
+export const countFindings = ({
+    findings,
+}: {
+    findings: { severity: 'blocker' | 'should_fix' | 'nit' }[]
+}): FindingCounts => ({
+    blocker: findings.filter((finding) => finding.severity === 'blocker')
+        .length,
+    should_fix: findings.filter((finding) => finding.severity === 'should_fix')
+        .length,
+    nit: findings.filter((finding) => finding.severity === 'nit').length,
+})
+
+const plural = ({ count, word }: { count: number; word: string }) =>
+    `${count} ${word}${count === 1 ? '' : 's'}`
+
+/**
+ * A ticket review's finding counts in words, such as "1 blocker, 2
+ * should-fix, 2 nits". Nits are left out unless `nits` is set; `null` when
+ * nothing is left to say.
+ *
+ * @example
+ * reviewCountsText({ findings: { blocker: 2, should_fix: 1, nit: 1 }, nits: false })
+ * // '2 blockers, 1 should-fix'
+ */
+export const reviewCountsText = ({
+    findings,
+    nits,
+}: {
+    findings: FindingCounts
+    nits: boolean
+}): string | null => {
+    const parts = [
+        findings.blocker > 0
+            ? plural({ count: findings.blocker, word: 'blocker' })
+            : null,
+        findings.should_fix > 0 ? `${findings.should_fix} should-fix` : null,
+        nits && findings.nit > 0
+            ? plural({ count: findings.nit, word: 'nit' })
+            : null,
+    ].filter((part) => part !== null)
+    return parts.length > 0 ? parts.join(', ') : null
+}
+
+/** What happened when a ticket was sent back onto the run branch, in words. */
+export const rebasedText = ({
+    content,
+}: {
+    content: Extract<BoardRecord, { kind: 'ticket_rebased' }>['content']
+}): string => {
+    if (content.cause === 'join_gates') {
+        return 'The checks failed after joining; fixing on top of the run branch'
+    }
+    const files = [...content.tests, ...content.code]
+    return files.length === 0
+        ? 'Clashed with the run branch; fixing on top of it'
+        : `Clashed with the run branch in ${files.join(', ')}`
+}
+
+/** A test sent back to the test-writer after a rebase (#489), in words. */
+export const testsSentBackText = ({
+    content,
+}: {
+    content: Extract<BoardRecord, { kind: 'tests_sent_back' }>['content']
+}): string => {
+    const test = [content.bad_test.file, content.bad_test.name]
+        .filter(Boolean)
+        .join(' > ')
+    const joined = content.joined.map(({ ticket }) => `#${ticket}`).join(', ')
+    return `Test update ${content.round}: ${test || 'a test'} is wrong on the run branch${joined === '' ? '' : ` after ${joined} joined`}; back to the test-writer`
+}

package/board/server/reduce-board-ticket-checks.ts

@@ -0,0 +1,168 @@
+/**
+ * A ticket's checks while it builds: the red check, commits, the leftover
+ * scan, and the checks (the final review's too).
+ */
+import type { BoardRecord } from './board-vocabulary'
+import {
+    finalTried,
+    testCounts,
+    updateTicket,
+    withTried,
+} from './reduce-board-update'
+
+import type { BoardState } from '../shared/board-state'
+
+const gatesRun = ({
+    state,
+    record,
+}: {
+    state: BoardState
+    record: Extract<BoardRecord, { kind: 'gates_run' }>
+}): BoardState => {
+    const { ok, target, checks } = record.content
+    const failed = checks
+        .filter((check) => !check.ok)
+        .map((check) => check.name)
+        .join(', ')
+    const afterJoin = target === 'run_branch'
+    // The final review's slow tests, after round 1's lenses (#563).
+    if (target === 'final_slow') {
+        return ok
+            ? state
+            : finalTried({
+                  state,
+                  line: `The final review's slow tests failed: ${failed || 'no detail'}`,
+              })
+    }
+    // The final review's fixes are checked on the run branch, with no ticket.
+    if (record.ticket === null) {
+        return ok
+            ? state
+            : finalTried({
+                  state,
+                  line: `The checks failed on the final review's fixes: ${failed || 'no detail'}`,
+              })
+    }
+    return updateTicket({
+        state,
+        number: record.ticket,
+        update: (card) => {
+            if (ok) {
+                return afterJoin
+                    ? { ...card, activity: 'checks passed after joining' }
+                    : {
+                          ...card,
+                          step: 4,
+                          open_check: null,
+                          fix_round: 0,
+                          activity: 'checks passed',
+                      }
+            }
+            return {
+                ...card,
+                step: afterJoin ? card.step : 3,
+                open_check: afterJoin ? card.open_check : 'gates',
+                activity: afterJoin
+                    ? 'checks failed after joining'
+                    : 'checks failed',
+                tried: withTried({
+                    tried: card.tried,
+                    line: `${afterJoin ? 'After joining, the' : 'The'} checks failed: ${failed || 'no detail'}`,
+                }),
+            }
+        },
+    })
+}
+
+/** The record kinds of a ticket's checks. */
+export const TICKET_CHECKS_KINDS = [
+    'red_check',
+    'leftover_scan',
+    'commit_made',
+    'gates_run',
+] as const
+
+type TicketChecksRecord = Extract<
+    BoardRecord,
+    { kind: (typeof TICKET_CHECKS_KINDS)[number] }
+>
+
+/** Applies one record of TICKET_CHECKS_KINDS to the board. */
+export const applyTicketChecksKind = ({
+    state,
+    record,
+}: {
+    state: BoardState
+    record: TicketChecksRecord
+}): BoardState => {
+    const { ticket } = record
+    switch (record.kind) {
+        case 'red_check':
+            return updateTicket({
+                state,
+                number: ticket,
+                update: (card) => ({
+                    ...card,
+                    step: record.content.ok ? 2 : 1,
+                    open_check: record.content.ok ? null : 'red_check',
+                    fix_round: record.content.ok ? 0 : card.fix_round,
+                    activity: record.content.ok
+                        ? 'red check passed'
+                        : 'red check failed',
+                    tests: record.content.tests
+                        ? testCounts({ cases: record.content.tests.cases })
+                        : card.tests,
+                    tried: record.content.ok
+                        ? card.tried
+                        : withTried({
+                              tried: card.tried,
+                              line: `The red check failed: ${record.content.problems[0] ?? 'no detail'}`,
+                          }),
+                }),
+            })
+        case 'leftover_scan':
+            if (record.content.hits.length === 0) return state
+            if (ticket === null) {
+                return finalTried({
+                    state,
+                    line: `The leftover scan found ${record.content.hits.map((hit) => hit.path).join(', ')} in the final review's fixes`,
+                })
+            }
+            return updateTicket({
+                state,
+                number: ticket,
+                update: (card) => ({
+                    ...card,
+                    activity: 'leftovers found',
+                    tried: withTried({
+                        tried: card.tried,
+                        line: `The leftover scan found ${record.content.hits.map((hit) => hit.path).join(', ')}`,
+                    }),
+                }),
+            })
+        case 'commit_made':
+            return updateTicket({
+                state,
+                number: ticket,
+                update: (card) => {
+                    switch (record.content.stage) {
+                        case 'green':
+                            return {
+                                ...card,
+                                step: 4,
+                                activity: 'code committed',
+                            }
+                        case 'fix':
+                            return {
+                                ...card,
+                                activity: 'review fixes committed',
+                            }
+                        default:
+                            return { ...card, activity: 'tests committed' }
+                    }
+                },
+            })
+        case 'gates_run':
+            return gatesRun({ state, record })
+    }
+}

package/board/server/reduce-board-ticket-join.ts

@@ -0,0 +1,144 @@
+/**
+ * A ticket's way onto the run branch: joining, being sent back to fix on top
+ * of it, being pushed, or being found already done.
+ */
+import type { BoardRecord } from './board-vocabulary'
+import {
+    alreadyDoneText,
+    rebasedText,
+    testsSentBackText,
+} from './reduce-board-text'
+import { updateTicket, withTried } from './reduce-board-update'
+
+import { ALL_STEPS_DONE, type BoardState } from '../shared/board-state'
+
+/**
+ * A ticket sent back onto the run branch is fixed on top of it: its tests
+ * first if test files clashed, else its code; then the checks and a fresh
+ * review, whose fix rounds count from zero again.
+ */
+const ticketRebased = ({
+    state,
+    record,
+}: {
+    state: BoardState
+    record: Extract<BoardRecord, { kind: 'ticket_rebased' }>
+}): BoardState =>
+    updateTicket({
+        state,
+        number: record.ticket,
+        update: (card) => ({
+            ...card,
+            stage: 'fixing',
+            step: record.content.tests.length > 0 ? 0 : 2,
+            role: null,
+            fix_round: 0,
+            // The engine starts the ticket's review loop over on top of the
+            // run branch: a fresh reviewer, fresh review fix rounds.
+            review_fix_round: 0,
+            findings: null,
+            open_check: null,
+            failed_turn: null,
+            activity: 'fixing on the run branch',
+            tried: withTried({
+                tried: card.tried,
+                line: rebasedText({ content: record.content }),
+            }),
+        }),
+    })
+
+/** The record kinds of a ticket's way onto the run branch. */
+export const TICKET_JOIN_KINDS = [
+    'ticket_joined',
+    'ticket_rebased',
+    'tests_sent_back',
+    'run_branch_pushed',
+    'ticket_already_done',
+    'ticket_closed',
+] as const
+
+type TicketJoinRecord = Extract<
+    BoardRecord,
+    { kind: (typeof TICKET_JOIN_KINDS)[number] }
+>
+
+/** Applies one record of TICKET_JOIN_KINDS to the board. */
+export const applyTicketJoinKind = ({
+    state,
+    record,
+}: {
+    state: BoardState
+    record: TicketJoinRecord
+}): BoardState => {
+    const { ticket } = record
+    switch (record.kind) {
+        case 'ticket_joined':
+            return updateTicket({
+                state,
+                number: ticket,
+                // Joined, it is done once its checks there pass and the run
+                // branch is pushed.
+                update: (card) =>
+                    record.content.ok
+                        ? {
+                              ...card,
+                              stage: 'joining',
+                              step: ALL_STEPS_DONE,
+                              role: null,
+                              activity: 'joined',
+                          }
+                        : {
+                              ...card,
+                              activity: 'join failed',
+                              tried: withTried({
+                                  tried: card.tried,
+                                  line: `Joining the run branch failed: ${record.content.error ?? 'no detail'}`,
+                              }),
+                          },
+            })
+        case 'ticket_rebased':
+            return ticketRebased({ state, record })
+        case 'tests_sent_back':
+            return updateTicket({
+                state,
+                number: ticket,
+                update: (card) => ({
+                    ...card,
+                    stage: 'fixing',
+                    step: 0,
+                    role: null,
+                    activity: 'updating tests for the run branch',
+                    tried: withTried({
+                        tried: card.tried,
+                        line: testsSentBackText({ content: record.content }),
+                    }),
+                }),
+            })
+        case 'run_branch_pushed':
+            return updateTicket({
+                state,
+                number: ticket,
+                update: (card) =>
+                    card.stage === 'joining' || card.stage === 'done'
+                        ? { ...card, stage: 'done', activity: 'pushed' }
+                        : card,
+            })
+        // Done, not stuck (#484): its work was already on the base branch.
+        case 'ticket_already_done':
+            return updateTicket({
+                state,
+                number: ticket,
+                update: (card) => ({
+                    ...card,
+                    stage: 'done',
+                    step: ALL_STEPS_DONE,
+                    role: null,
+                    open_check: null,
+                    activity: alreadyDoneText({ shas: record.content.shas }),
+                }),
+            })
+        // Its closing changes nothing the board shows.
+        case 'ticket_closed':
+            return state
+    }
+}