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

package/board/server/reduce-board-needs-you.ts

@@ -0,0 +1,283 @@
+/**
+ * What needs a person: a stuck ticket or run, a skipped or retried ticket,
+ * and the replies that resolve them.
+ */
+import type { BoardRecord } from './board-vocabulary'
+import {
+    RETRY_REFUSED_TEXT,
+    reasonText,
+    runReasonText,
+} from './reduce-board-reasons'
+import { clip } from './reduce-board-text'
+import {
+    DETAIL_MAX,
+    addNeedsYou,
+    resolveNeedsYou,
+    updateFinal,
+    updateTicket,
+    withTried,
+} from './reduce-board-update'
+
+import type { BoardState } from '../shared/board-state'
+import {
+    FINAL_KEY,
+    RUN_KEY,
+    allowedReplies,
+    ticketKey,
+} from '../shared/reply-actions'
+
+const skipTicket = ({
+    state,
+    ticket,
+    because,
+}: {
+    state: BoardState
+    ticket: number | null
+    because: number | null
+}): BoardState => {
+    if (ticket === null) return state
+    return resolveNeedsYou({
+        state: updateTicket({
+            state,
+            number: ticket,
+            update: (card) => ({
+                ...card,
+                stage: 'skipped',
+                role: null,
+                activity:
+                    because === null
+                        ? 'skipped'
+                        : `skipped: waits on skipped #${because}`,
+            }),
+        }),
+        key: ticketKey({ ticket }),
+    })
+}
+
+/**
+ * How the engine took a `retry`: `resume` changes nothing more than the
+ * reply did; `restart` builds the edited ticket from scratch (its new
+ * snapshot came just before); `refused` leaves it stuck, back in Needs you.
+ */
+const ticketRetried = ({
+    state,
+    record,
+}: {
+    state: BoardState
+    record: Extract<BoardRecord, { kind: 'ticket_retried' }>
+}): BoardState => {
+    const { ticket } = record
+    if (ticket === null) return state
+    switch (record.content.mode) {
+        case 'resume':
+            return state
+        case 'restart':
+            return updateTicket({
+                state,
+                number: ticket,
+                update: (card) => ({
+                    ...card,
+                    stage: 'building',
+                    step: 0,
+                    role: null,
+                    fix_round: 0,
+                    review_fix_round: 0,
+                    findings: null,
+                    open_check: null,
+                    failed_turn: null,
+                    activity: 'starting over from the edited ticket',
+                    tried: withTried({
+                        tried: card.tried,
+                        line: 'Started over from the edited ticket',
+                    }),
+                }),
+            })
+        case 'refused': {
+            const card = state.tickets.find((entry) => entry.number === ticket)
+            return addNeedsYou({
+                state: updateTicket({
+                    state,
+                    number: ticket,
+                    update: (entry) => ({
+                        ...entry,
+                        stage: 'stuck',
+                        role: null,
+                        activity: 'stuck',
+                    }),
+                }),
+                item: {
+                    key: ticketKey({ ticket }),
+                    ticket,
+                    subject: `Retry of #${ticket} was refused${card ? `: ${card.title}` : ''}`,
+                    reason: RETRY_REFUSED_TEXT,
+                    detail: clip({
+                        text: record.content.problems.join(' '),
+                        max: DETAIL_MAX,
+                    }),
+                    tried: card?.tried ?? [],
+                    replies: allowedReplies({
+                        key: ticketKey({ ticket }),
+                        ticket,
+                    }),
+                    since: record.time,
+                },
+            })
+        }
+    }
+}
+
+const replyReceived = ({
+    state,
+    record,
+}: {
+    state: BoardState
+    record: Extract<BoardRecord, { kind: 'reply_received' }>
+}): BoardState => {
+    const { word } = record.content
+    const ticket = record.content.ticket ?? record.ticket
+    switch (word) {
+        case 'retry':
+            if (ticket !== null) {
+                return resolveNeedsYou({
+                    state: updateTicket({
+                        state,
+                        number: ticket,
+                        update: (card) => ({
+                            ...card,
+                            stage: 'building',
+                            activity: 'retrying',
+                        }),
+                    }),
+                    key: ticketKey({ ticket }),
+                })
+            }
+            // A bare `retry` while the run is stuck on its budget adds its
+            // top-up (one whole budget for a retry journaled with none,
+            // #543); stuck for another reason, no budget. The final review
+            // is left as it is.
+            if (state.needs_you.some((item) => item.key === RUN_KEY)) {
+                const top_up =
+                    state.run_stuck_reason === 'run_budget'
+                        ? (record.content.top_up ?? state.run_budget_each)
+                        : 0
+                return resolveNeedsYou({
+                    state: {
+                        ...state,
+                        run_budget_tokens: state.run_budget_tokens + top_up,
+                        run_stuck_reason: null,
+                    },
+                    key: RUN_KEY,
+                })
+            }
+            return resolveNeedsYou({
+                state: updateFinal({
+                    state,
+                    update: (review) => ({ ...review, state: 'reviewing' }),
+                }),
+                key: FINAL_KEY,
+            })
+        case 'skip':
+            return skipTicket({ state, ticket, because: null })
+        case 'ship':
+            return resolveNeedsYou({
+                state: updateFinal({
+                    state,
+                    update: (review) => ({ ...review, state: 'passed' }),
+                }),
+                key: FINAL_KEY,
+            })
+        case 'stop':
+            return resolveNeedsYou({ state, key: null })
+    }
+}
+
+/** The record kinds of what needs a person. */
+export const NEEDS_YOU_KINDS = [
+    'ticket_stuck',
+    'run_stuck',
+    'reply_received',
+    'ticket_skipped',
+    'ticket_retried',
+    'reply_ignored',
+] as const
+
+type NeedsYouRecord = Extract<
+    BoardRecord,
+    { kind: (typeof NEEDS_YOU_KINDS)[number] }
+>
+
+/** Applies one record of NEEDS_YOU_KINDS to the board. */
+export const applyNeedsYouKind = ({
+    state,
+    record,
+}: {
+    state: BoardState
+    record: NeedsYouRecord
+}): BoardState => {
+    const { ticket } = record
+    switch (record.kind) {
+        case 'ticket_stuck': {
+            if (ticket === null) return state
+            const card = state.tickets.find((entry) => entry.number === ticket)
+            const stuck = updateTicket({
+                state,
+                number: ticket,
+                update: (entry) => ({
+                    ...entry,
+                    stage: 'stuck',
+                    role: null,
+                    activity: 'stuck',
+                }),
+            })
+            return addNeedsYou({
+                state: stuck,
+                item: {
+                    key: ticketKey({ ticket }),
+                    ticket,
+                    subject: `Ticket #${ticket} is stuck${card ? `: ${card.title}` : ''}`,
+                    reason: reasonText({ reason: record.content.reason }),
+                    detail: clip({
+                        text: record.content.detail,
+                        max: DETAIL_MAX,
+                    }),
+                    tried: card?.tried ?? [],
+                    replies: allowedReplies({
+                        key: ticketKey({ ticket }),
+                        ticket,
+                    }),
+                    since: record.time,
+                },
+            })
+        }
+        case 'run_stuck':
+            return addNeedsYou({
+                state: { ...state, run_stuck_reason: record.content.reason },
+                item: {
+                    key: RUN_KEY,
+                    ticket: null,
+                    subject: 'The run is stuck',
+                    reason: runReasonText({ reason: record.content.reason }),
+                    detail: clip({
+                        text: record.content.detail,
+                        max: DETAIL_MAX,
+                    }),
+                    tried: [],
+                    replies: allowedReplies({ key: RUN_KEY, ticket: null }),
+                    since: record.time,
+                },
+            })
+        case 'reply_received':
+            return replyReceived({ state, record })
+        case 'ticket_skipped':
+            return skipTicket({
+                state,
+                ticket,
+                because: record.content.because,
+            })
+        case 'ticket_retried':
+            return ticketRetried({ state, record })
+        // An ignored reply is only a chat row; the engine answered it.
+        case 'reply_ignored':
+            return state
+    }
+}

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

@@ -0,0 +1,59 @@
+/**
+ * Why a ticket, the final review, or the whole run is stuck, as codes and as
+ * words: the text a stuck card shows for each reason the engine journals.
+ */
+import { LOOP_CAP } from '../shared/board-state'
+
+const STUCK_REASONS: Record<string, string> = {
+    agent_failed: 'An agent failed on its last try.',
+    red_check_failed: 'The red check failed.',
+    nothing_new_to_test:
+        'The test-writer says the ticket changes no behavior, so there is nothing new to test. Label it refactor and retry it.',
+    leftovers_found:
+        'The leftover scan found files that must not be committed.',
+    gates_failed: 'The checks failed.',
+    bad_test:
+        'A test was sent back as bad, by the implementer or because it checks nothing.',
+    changes_requested: 'The ticket review asked for changes.',
+    join_failed: "The ticket couldn't join the run branch.",
+    join_gates_failed: 'The checks failed after the ticket joined.',
+    install_failed: 'Installing the dependencies failed.',
+    prepare_failed: "The repo's prepare command failed.",
+    setup_change_needed:
+        'An agent needs a test setup file changed; only you may change one.',
+    crashed: 'The engine crashed in the same step again and again.',
+    undo_refused:
+        'Undoing its join would have rewound the run branch over other work.',
+}
+
+/** Why a retry of an edited ticket was refused, in words. */
+export const RETRY_REFUSED_TEXT =
+    "Its new text or labels aren't ready to build."
+
+/** A stuck reason code in words. */
+export const reasonText = ({ reason }: { reason: string }): string =>
+    STUCK_REASONS[reason] ?? `${reason.replaceAll('_', ' ')}.`
+
+/** The final review's stuck reasons that read differently from a ticket's. */
+const FINAL_STUCK_REASONS: Record<string, string> = {
+    changes_requested: `The lenses still ask for changes after ${LOOP_CAP} fix rounds.`,
+    gates_failed: "The checks still fail on the final review's fixes.",
+    bad_test:
+        "The implementer sent back a bad test while fixing the final review's findings.",
+}
+
+/** A final review's stuck reason code in words. */
+export const finalReasonText = ({ reason }: { reason: string }): string =>
+    FINAL_STUCK_REASONS[reason] ?? reasonText({ reason })
+
+/** Why the whole run is stuck (`run_stuck`'s reason), in words. */
+const RUN_STUCK_REASONS: Record<string, string> = {
+    run_budget:
+        'The run used up its run budget of tokens. `retry` adds half a budget more, and `retry +3M` the amount named.',
+    pull_request_failed:
+        "The run's pull request didn't open. `retry` tries again, reusing a PR already open from the run branch.",
+}
+
+/** A run stuck reason code in words. */
+export const runReasonText = ({ reason }: { reason: string }): string =>
+    RUN_STUCK_REASONS[reason] ?? `${reason.replaceAll('_', ' ')}.`

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

@@ -0,0 +1,255 @@
+/**
+ * The run's own records: how it starts and resumes, its repo wait, intake
+ * and the spec's snapshot, the run branch, the pull request, and a stop.
+ */
+import type { BoardRecord, LeftOutList } from './board-vocabulary'
+import { numbersText } from './reduce-board-text'
+import { updateTicket, withTried } from './reduce-board-update'
+
+import {
+    DEFAULT_CONFIDENCE_BAR,
+    DEFAULT_RUN_BUDGET_TOKENS,
+    type BoardState,
+    type PersonTicket,
+    type RunInfo,
+} from '../shared/board-state'
+import { repoOfIssueUrl } from '../shared/reply-actions'
+
+/**
+ * The run's version note after a resume on Luca `resumed_on`: both versions
+ * when it differs from the one the run started on, else the note so far (a
+ * run that once changed version keeps saying so). Nothing when the journal
+ * doesn't say what the run started on.
+ */
+const versionNote = ({
+    run,
+    resumed_on,
+}: {
+    run: RunInfo
+    resumed_on: string
+}): string | null =>
+    run.started_on === null || run.started_on === resumed_on
+        ? run.version_note
+        : `This run started on Luca ${run.started_on} and resumed on Luca ${resumed_on}. It keeps going.`
+
+/**
+ * The tickets left out for a person (#499), with why in words, as the
+ * engine's PR says it.
+ *
+ * @example
+ * personTickets({ left_out: [{ number: 13, title: 'Link', reason: 'waits_on_person', waits_on: [12], through: [] }] })
+ * // [{ number: 13, title: 'Link', why: 'waits on #12, which is for a person' }]
+ */
+const personTickets = ({
+    left_out,
+}: {
+    left_out: LeftOutList
+}): PersonTicket[] =>
+    left_out.map(({ number, title, reason, waits_on, through }) => {
+        if (reason === 'for_a_person') {
+            return { number, title, why: 'for a person' }
+        }
+        const which =
+            waits_on.length === 1
+                ? 'which is for a person'
+                : 'which are for a person'
+        const via =
+            through.length === 0
+                ? ''
+                : ` (through ${numbersText({ numbers: through })})`
+        return {
+            number,
+            title,
+            why: `waits on ${numbersText({ numbers: waits_on })}, ${which}${via}`,
+        }
+    })
+
+/**
+ * The spec's owner and repo from intake's copy of the spec issue, keeping
+ * what the board knew when the record lacks them (older journals).
+ */
+const specOwner = ({
+    run,
+    spec,
+}: {
+    run: RunInfo
+    spec: { author?: string; url?: string }
+}): Pick<RunInfo, 'spec_author' | 'spec_repo'> => ({
+    spec_author:
+        spec.author === undefined || spec.author === ''
+            ? run.spec_author
+            : spec.author,
+    spec_repo:
+        (spec.url === undefined ? null : repoOfIssueUrl({ url: spec.url })) ??
+        run.spec_repo,
+})
+
+/** The record kinds the run's own records. */
+export const RUN_KINDS = [
+    'run_started',
+    'repo_wait_started',
+    'repo_wait_ended',
+    'engine_resumed',
+    'config_reloaded',
+    'config_reload_refused',
+    'intake_read',
+    'intake_refused',
+    'nothing_to_do',
+    'spec_snapshot',
+    'run_branch_created',
+    'run_stopped',
+    'pull_request_opened',
+    'worktrees_removed',
+] as const
+
+type RunRecord = Extract<BoardRecord, { kind: (typeof RUN_KINDS)[number] }>
+
+/** Applies one record of RUN_KINDS to the board. */
+export const applyRunKind = ({
+    state,
+    record,
+}: {
+    state: BoardState
+    record: RunRecord
+}): BoardState => {
+    const { ticket } = record
+    switch (record.kind) {
+        case 'run_started': {
+            const budget =
+                record.content.config?.run_budget_tokens ??
+                DEFAULT_RUN_BUDGET_TOKENS
+            return {
+                ...state,
+                run_budget_tokens: budget,
+                run_budget_each: budget,
+                confidence_bar:
+                    record.content.config?.models?.confidence_bar ??
+                    DEFAULT_CONFIDENCE_BAR,
+                run: {
+                    ...state.run,
+                    spec_number: record.content.spec_number,
+                    phase: 'intake',
+                    started_on: record.content.luca_version,
+                },
+            }
+        }
+        case 'repo_wait_started':
+            return {
+                ...state,
+                repo_wait: {
+                    runs: record.content.runs.map(({ run_id }) => run_id),
+                    since: record.time,
+                },
+            }
+        case 'repo_wait_ended':
+            return { ...state, repo_wait: null }
+        case 'engine_resumed':
+            return {
+                ...state,
+                run: {
+                    ...state.run,
+                    version_note: versionNote({
+                        run: state.run,
+                        resumed_on: record.content.luca_version,
+                    }),
+                },
+            }
+        // A resume's config reload (#516) is only a chat row.
+        case 'config_reloaded':
+        case 'config_reload_refused':
+            return state
+        case 'intake_read':
+            return {
+                ...state,
+                run: {
+                    ...state.run,
+                    spec_title:
+                        state.run.spec_title ?? record.content.spec.title,
+                    phase: 'intake',
+                    ...specOwner({ run: state.run, spec: record.content.spec }),
+                },
+            }
+        case 'intake_refused':
+            return {
+                ...state,
+                run: {
+                    ...state.run,
+                    phase: 'refused',
+                    refusal: record.content.problems.map(
+                        (problem) =>
+                            `${problem.ticket === null ? 'The run' : `#${problem.ticket}`}: missing ${problem.missing.join(', ')}`
+                    ),
+                },
+            }
+        case 'nothing_to_do':
+            return {
+                ...state,
+                for_a_person: personTickets({
+                    left_out: record.content.left_out,
+                }),
+                run: { ...state.run, phase: 'nothing_to_do' },
+            }
+        case 'spec_snapshot':
+            return {
+                ...state,
+                for_a_person: personTickets({
+                    left_out: record.content.left_out,
+                }),
+                run: {
+                    ...state.run,
+                    spec_number: record.content.spec.number,
+                    spec_title: record.content.spec.title,
+                    phase: 'building',
+                    ...specOwner({ run: state.run, spec: record.content.spec }),
+                },
+            }
+        case 'run_branch_created':
+            return {
+                ...state,
+                run: { ...state.run, branch: record.content.branch },
+            }
+        case 'run_stopped': {
+            const { reason, role, billing, crashed } = record.content
+            const stopped = updateTicket({
+                state,
+                number: ticket,
+                update: (card) => ({
+                    ...card,
+                    role: null,
+                    activity: 'run stopped',
+                    tried: withTried({
+                        tried: card.tried,
+                        line: `${billing ? 'Stopped for billing' : crashed ? 'Stopped after crashes' : 'The run stopped'}: ${reason}`,
+                    }),
+                }),
+            })
+            return {
+                ...stopped,
+                run: {
+                    ...stopped.run,
+                    stopped: {
+                        reason,
+                        role,
+                        ticket,
+                        billing,
+                        crashed,
+                        since: record.time,
+                    },
+                },
+            }
+        }
+        case 'pull_request_opened':
+            return {
+                ...state,
+                run: {
+                    ...state.run,
+                    phase: 'done',
+                    pr_url: record.content.url,
+                    pr_number: record.content.number,
+                },
+            }
+        // Removing the worktrees at the end changes nothing on the board.
+        case 'worktrees_removed':
+            return state
+    }
+}

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

@@ -0,0 +1,88 @@
+/**
+ * What depends on the whole board: which unstarted tickets are blocked,
+ * whether the final review is active, and the run's status.
+ */
+import type {
+    BoardState,
+    RunStatus,
+    TicketCard,
+    TicketStage,
+} from '../shared/board-state'
+import { RUN_KEY } from '../shared/reply-actions'
+
+/** A ticket's blockers inside this run that aren't done yet. */
+export const unfinishedBlockers = ({
+    state,
+    ticket,
+}: {
+    state: BoardState
+    ticket: TicketCard
+}): number[] =>
+    ticket.blockers.filter((number) => {
+        const blocker = state.tickets.find((card) => card.number === number)
+        return blocker !== undefined && blocker.stage !== 'done'
+    })
+
+/** The stages of a ticket the engine is working on. */
+const ACTIVE_STAGES = new Set<TicketStage>([
+    'building',
+    'reviewing',
+    'testing',
+    'fixing',
+    'joining',
+])
+
+const isActive = ({ state }: { state: BoardState }): boolean =>
+    state.tickets.some(
+        (ticket) => ticket.started && ACTIVE_STAGES.has(ticket.stage)
+    ) ||
+    state.final_review.state === 'reviewing' ||
+    state.final_review.state === 'fixing'
+
+const runStatus = ({ state }: { state: BoardState }): RunStatus => {
+    const { phase, engine_ended, stopped } = state.run
+    if (phase === 'done' || phase === 'refused' || phase === 'nothing_to_do')
+        return phase
+    if (stopped) return 'stopped'
+    if (engine_ended && !engine_ended.ok) return 'ended_with_error'
+    if (state.limit_wait) return 'limit_wait'
+    if (state.usage_line_wait) return 'usage_line_wait'
+    // Nothing new starts while the run is stuck on its budget.
+    if (state.needs_you.some((item) => item.key === RUN_KEY)) return 'stuck'
+    if (state.needs_you.length > 0 && !isActive({ state })) return 'stuck'
+    return phase
+}
+
+/**
+ * Recomputes what depends on the whole board: which unstarted tickets are
+ * blocked, whether the final review is active, and the run's status.
+ */
+export const settle = ({ state }: { state: BoardState }): BoardState => {
+    const tickets = state.tickets.map((ticket): TicketCard => {
+        if (ticket.started) return ticket
+        if (ticket.stage !== 'blocked' && ticket.stage !== 'building')
+            return ticket
+        const waiting = unfinishedBlockers({ state, ticket })
+        return waiting.length > 0
+            ? {
+                  ...ticket,
+                  stage: 'blocked',
+                  activity: `waits on ${waiting.map((number) => `#${number}`).join(', ')}`,
+              }
+            : { ...ticket, stage: 'building', activity: 'queued' }
+    })
+    const settledTickets = { ...state, tickets }
+    const active =
+        tickets.length > 0 &&
+        tickets.every(
+            (ticket) => ticket.stage === 'done' || ticket.stage === 'skipped'
+        )
+    const withReview = {
+        ...settledTickets,
+        final_review: { ...state.final_review, active },
+    }
+    return {
+        ...withReview,
+        run: { ...withReview.run, status: runStatus({ state: withReview }) },
+    }
+}