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

package/engine/core/environment-rerun.ts

@@ -0,0 +1,83 @@
+/**
+ * A writer's `environment` answer (#613): when its rerun makes the ticket
+ * (or the final review) stuck as `environment_failed`, and the stuck
+ * detail, with the agent's evidence and the clipped output. Pure.
+ */
+import { MAX_ENVIRONMENT_RERUNS } from './loop-caps'
+
+import type {
+    EnvironmentRerun,
+    ReplayedGates,
+    ReplayedRedCheck,
+} from '../journal/replay'
+import { clipOutput } from '../shell/run-command'
+
+/** A red check or a gate run. */
+type CheckRun = ReplayedRedCheck | ReplayedGates
+
+/**
+ * Longest output kept per failed check in the stuck detail, so the stuck
+ * comment shows its start and its end.
+ */
+const OUTPUT_MAX = 2000
+
+/** How a check failed: the red check's problems, or the failed gates' names. */
+const failureKey = (run: CheckRun): string =>
+    'checks' in run
+        ? run.checks
+              .filter(({ ok }) => !ok)
+              .map(({ name }) => name)
+              .sort()
+              .join('\n')
+        : [...run.problems].sort().join('\n')
+
+/** The failure, with its clipped output. */
+const failureText = (run: CheckRun): string =>
+    'checks' in run
+        ? run.checks
+              .filter(({ ok }) => !ok)
+              .map(
+                  ({ name, output }) =>
+                      `${name} failed:\n${clipOutput({ text: output, max: OUTPUT_MAX })}`
+              )
+              .join('\n\n')
+        : [
+              `The red check's problems:\n${run.problems.map((problem) => `- ${problem}`).join('\n')}`,
+              `Test output:\n${clipOutput({ text: run.output, max: OUTPUT_MAX })}`,
+          ].join('\n\n')
+
+/**
+ * Why an `environment` answer leaves the work stuck, or `null` to go on:
+ * its rerun is past the cap of `MAX_ENVIRONMENT_RERUNS`, or `latest`, the
+ * rerun, failed the same way (the same problems, or the same failed
+ * gates). `latest` is `null` while the rerun is due.
+ */
+export const environmentFailedDetail = ({
+    environment,
+    reruns,
+    latest,
+}: {
+    environment: EnvironmentRerun | null
+    /** `environment` answers so far, this one included. */
+    reruns: number
+    latest: CheckRun | null
+}): string | null => {
+    if (environment === null) return null
+    const answer = `The ${environment.role} answered "environment": ${environment.evidence}`
+    if (latest === null) {
+        if (reruns <= MAX_ENVIRONMENT_RERUNS) return null
+        return [
+            answer,
+            `That is past the cap of ${MAX_ENVIRONMENT_RERUNS} environment reruns, so the check did not run again. It failed like this:`,
+            failureText(environment.failed),
+        ].join('\n\n')
+    }
+    if (latest.ok || failureKey(latest) !== failureKey(environment.failed)) {
+        return null
+    }
+    return [
+        answer,
+        'The engine reran the check, and it failed the same way:',
+        failureText(latest),
+    ].join('\n\n')
+}

package/engine/core/evidence-text.ts

@@ -0,0 +1,84 @@
+import type { TicketProgress, ReplayedSnapshot } from '../journal/replay'
+import { REFACTOR_LABEL } from '../tracker/tracker'
+
+/** The most test names one ticket's Evidence line lists (#513). */
+export const MAX_EVIDENCE_TESTS = 5
+
+/** The longest test name an Evidence line shows; a longer one is clipped. */
+export const MAX_EVIDENCE_NAME = 80
+
+const EVIDENCE_INTRO =
+    "Each ticket's new tests failed before its code was written (the red check), and pass now (the gates)."
+
+const clipName = (name: string): string =>
+    name.length > MAX_EVIDENCE_NAME
+        ? `${name.slice(0, MAX_EVIDENCE_NAME - 1)}…`
+        : name
+
+/** Up to `MAX_EVIDENCE_TESTS` names, then how many more. */
+const namesText = (names: string[]): string => {
+    const shown = names.slice(0, MAX_EVIDENCE_TESTS).map(clipName)
+    const more = names.length - shown.length
+    return more > 0 ? `${shown.join(', ')}, and ${more} more` : shown.join(', ')
+}
+
+/** One ticket's Evidence line. */
+const evidenceLine = ({
+    number,
+    progress,
+    refactor,
+}: {
+    number: number
+    progress: TicketProgress | undefined
+    refactor: boolean
+}): string => {
+    if ((progress?.already_done ?? null) !== null) {
+        return `- #${number}: already done on the base branch, so no new tests.`
+    }
+    if (refactor) {
+        return `- #${number}: a refactor, so no new tests; the old tests still pass.`
+    }
+    const red_tests = progress?.red_tests ?? []
+    if (red_tests.length === 0) return `- #${number}: no red check recorded.`
+    const one = red_tests.length === 1
+    const count = `${red_tests.length} new ${one ? 'test' : 'tests'} failed first`
+    const passed =
+        progress?.gates?.ok === true || progress?.join_gates?.ok === true
+    const how = passed
+        ? `, now ${one ? 'passes' : 'pass'}`
+        : `; the gates have not passed ${one ? 'it' : 'them'} yet`
+    return `- #${number}: ${count}${how}: ${namesText(red_tests.map(({ name }) => name))}`
+}
+
+/**
+ * The PR's Evidence section (#513), from the journal alone: for each ticket
+ * in the run (not the skipped ones), the new tests its red check proved
+ * fail first, and whether the gates pass them now. An already-done ticket
+ * and a refactor ticket say why they have no new tests. Each line names at
+ * most `MAX_EVIDENCE_TESTS` tests. With no ticket in the run, `''`.
+ *
+ * @example
+ * evidenceSection({ snapshot, tickets })
+ * // "## Evidence\n\n...\n\n- #11: 1 new test failed first, now passes: sum adds two numbers"
+ */
+export const evidenceSection = ({
+    snapshot,
+    tickets,
+}: {
+    snapshot: ReplayedSnapshot
+    tickets: Record<number, TicketProgress>
+}): string => {
+    const lines = snapshot.ticket_order
+        .filter((number) => (tickets[number]?.skipped ?? null) === null)
+        .map((number) =>
+            evidenceLine({
+                number,
+                progress: tickets[number],
+                refactor:
+                    snapshot.tickets[number]?.labels.includes(REFACTOR_LABEL) ??
+                    false,
+            })
+        )
+    if (lines.length === 0) return ''
+    return `## Evidence\n\n${EVIDENCE_INTRO}\n\n${lines.join('\n')}`
+}

package/engine/core/execute-action.ts

@@ -0,0 +1,303 @@
+/**
+ * Carries out one action: sends it to the module for its kind of step, or
+ * journals it straight away.
+ */
+import { basename, dirname } from 'node:path'
+
+import type { EngineAction } from './decide'
+import { isFinalReviewAction } from './decide-final-review'
+import { isMemoryAction } from './decide-memory'
+import { executeAlreadyDoneAction } from './execute-already-done'
+import {
+    buildContext,
+    executeBuildAction,
+    type BuildDeps,
+} from './execute-build'
+import { writeChangeset } from './execute-changeset'
+import {
+    executeFinalReviewAction,
+    shipFinalReviewIn,
+} from './execute-final-review'
+import { readIntake, refuseIntake } from './execute-intake'
+import { executeMemoryAction } from './execute-memory'
+import { openPullRequest } from './execute-pull-request'
+import {
+    executeRepoWaitAction,
+    type GoingRunsReader,
+} from './execute-repo-wait'
+import { executeStuckAction } from './execute-stuck'
+import { executePlanAction, executeUsageLineAction } from './execute-waits'
+
+import type { Journal } from '../journal/journal'
+import { SYSTEM_CLOCK, type EngineClock } from '../limits/limit-wait'
+import {
+    DEFAULT_USAGE_LINES,
+    LINE_OF,
+    type UsageLines,
+} from '../limits/usage-line'
+import type { MemoryDeps } from '../memory/memory-client'
+import type { CommentStep } from '../tracker/post-comment-once'
+import type { Tracker } from '../tracker/tracker'
+
+/**
+ * Which try of its step an action is: the seq of the step's first try (its
+ * first `step_started`), and whether this try redoes one a crash cut off.
+ * A redo adopts the side effects its first try left behind: its comments,
+ * its PR, its worktrees and commits.
+ */
+export type StepTry = { first_seq: number; redo: boolean }
+
+/**
+ * Carries out one action: talks to the tracker, then records what happened in
+ * the journal. The only impure half of the engine; `decide` picks the action.
+ *
+ * Stop actions (`done`, `invalid_journal`) do nothing here.
+ */
+export const executeAction = async ({
+    action,
+    journal,
+    tracker,
+    build,
+    clock,
+    reply_poll_ms,
+    memory,
+    step,
+    read_usage_lines,
+    going_runs,
+}: {
+    action: EngineAction
+    journal: Journal
+    tracker: Tracker
+    /** Needed for every step after intake. */
+    build?: BuildDeps
+    /** Limit waits and reply waits sleep by it. Defaults to `SYSTEM_CLOCK`. */
+    clock?: EngineClock
+    /** How long a reply wait sleeps before it reads the spec issue. */
+    reply_poll_ms?: number
+    /** The memory client, for a run with memory on (#370). */
+    memory?: MemoryDeps
+    /**
+     * Which try of its step this is, from the scheduler. Left out, it is a
+     * first try, numbered after the journal's last record.
+     */
+    step?: StepTry
+    /**
+     * Reads the `luca-board` usage lines, again before each nap of a
+     * usage-line wait. Left out, the lines never change during a wait.
+     */
+    read_usage_lines?: () => Promise<UsageLines>
+    /**
+     * Lists the unfinished runs, again before each nap of a repo wait.
+     * Left out, no other run is going.
+     */
+    going_runs?: GoingRunsReader
+}): Promise<void> => {
+    const tried: CommentStep = {
+        run_id: basename(dirname(journal.file)),
+        ...(step ?? {
+            first_seq: (journal.read().at(-1)?.seq ?? 0) + 1,
+            redo: false,
+        }),
+    }
+    if (isMemoryAction(action)) {
+        return executeMemoryAction({
+            action,
+            journal,
+            tracker,
+            memory,
+            build,
+            step: tried,
+        })
+    }
+    switch (action.type) {
+        case 'report_stuck':
+        case 'wait_for_reply':
+        case 'take_reply':
+        case 'ignore_reply':
+        case 'skip_ticket':
+        case 'report_final_review_stuck':
+        case 'retry_final_review':
+        case 'mark_run_stuck':
+        case 'report_run_stuck':
+            return executeStuckAction({
+                action,
+                journal,
+                tracker,
+                clock: clock ?? SYSTEM_CLOCK,
+                reply_poll_ms,
+                step: tried,
+            })
+        case 'stop_for_crashes':
+            journal.append({
+                kind: 'run_stopped',
+                ticket: null,
+                role: null,
+                content: {
+                    reason: action.reason,
+                    role: null,
+                    billing: false,
+                    crashed: true,
+                },
+            })
+            return
+        case 'record_usage':
+            journal.append({
+                kind: 'usage_recorded',
+                ticket: action.usage.ticket,
+                role: null,
+                content: action.usage,
+            })
+            return
+        case 'start_limit_wait':
+        case 'wait_for_limit':
+        case 'stop_for_billing':
+            return executePlanAction({
+                action,
+                journal,
+                tracker,
+                clock: clock ?? SYSTEM_CLOCK,
+                step: tried,
+            })
+        case 'start_usage_line_wait':
+        case 'wait_for_usage_line':
+            return executeUsageLineAction({
+                action,
+                journal,
+                tracker,
+                clock: clock ?? SYSTEM_CLOCK,
+                read_usage_lines:
+                    read_usage_lines ??
+                    (async () => ({
+                        ...DEFAULT_USAGE_LINES,
+                        [LINE_OF[action.window]]: action.line,
+                    })),
+                step: tried,
+            })
+        case 'start_repo_wait':
+        case 'wait_for_repo':
+            return executeRepoWaitAction({
+                action,
+                journal,
+                tracker,
+                clock: clock ?? SYSTEM_CLOCK,
+                going_runs,
+                step: tried,
+            })
+        case 'read_intake':
+            return readIntake({
+                spec_number: action.spec_number,
+                journal,
+                tracker,
+            })
+        case 'refuse_intake':
+            return refuseIntake({
+                spec_number: action.spec_number,
+                problems: action.problems,
+                journal,
+                tracker,
+                step: tried,
+            })
+        case 'mark_already_done':
+        case 'close_ticket':
+            return executeAlreadyDoneAction({
+                action,
+                journal,
+                tracker,
+                step: tried,
+            })
+        case 'finish_nothing_to_do':
+            journal.append({
+                kind: 'nothing_to_do',
+                ticket: null,
+                role: null,
+                content: {
+                    closed_tickets: action.closed_tickets,
+                    already_done: action.already_done,
+                    left_out: action.left_out ?? [],
+                },
+            })
+            return
+        case 'snapshot_intake': {
+            const { spec, tickets, closed_tickets, left_out } = action.snapshot
+            journal.append({
+                kind: 'spec_snapshot',
+                ticket: spec.number,
+                role: null,
+                content: {
+                    spec,
+                    ticket_order: tickets.map((ticket) => ticket.number),
+                    closed_tickets,
+                    left_out,
+                },
+            })
+            for (const ticket of tickets) {
+                journal.append({
+                    kind: 'ticket_snapshot',
+                    ticket: ticket.number,
+                    role: null,
+                    content: ticket,
+                })
+            }
+            return
+        }
+        case 'invalid_journal':
+        case 'done':
+            return
+        default:
+            if (build === undefined) {
+                throw new Error(
+                    `The engine needs a git adapter and an agent launcher to ${action.type}.`
+                )
+            }
+            if (isFinalReviewAction(action)) {
+                return executeFinalReviewAction({
+                    action,
+                    context: buildContext({
+                        journal,
+                        tracker,
+                        step: tried,
+                        ...build,
+                    }),
+                })
+            }
+            if (action.type === 'write_changeset') {
+                return writeChangeset({
+                    action,
+                    context: buildContext({
+                        journal,
+                        tracker,
+                        step: tried,
+                        ...build,
+                    }),
+                })
+            }
+            if (action.type === 'open_pull_request') {
+                return openPullRequest({
+                    action,
+                    context: buildContext({
+                        journal,
+                        tracker,
+                        step: tried,
+                        ...build,
+                    }),
+                })
+            }
+            if (action.type === 'ship_final_review') {
+                return shipFinalReviewIn({
+                    context: buildContext({
+                        journal,
+                        tracker,
+                        step: tried,
+                        ...build,
+                    }),
+                })
+            }
+            return executeBuildAction({
+                action,
+                journal,
+                tracker,
+                step: tried,
+                ...build,
+            })
+    }
+}

package/engine/core/execute-already-done-check.ts

@@ -0,0 +1,133 @@
+/**
+ * The `check_already_done` step: a test-writer's `already_done` evidence
+ * checked in the ticket's worktree, journaled as `already_done_checked`.
+ */
+import { existsSync } from 'node:fs'
+import { join } from 'node:path'
+
+import uniq from 'lodash/uniq'
+import uniqBy from 'lodash/uniqBy'
+
+import {
+    reportFile,
+    testFilesIn,
+    ticketWorktree,
+    type BuildContext,
+} from './build-context'
+import type { BuildAction } from './decide-build'
+import { leaveOutIn, ticketChanges, watchPrepare } from './worktree-changes'
+
+import {
+    bunTestCommands,
+    hasSlowTests,
+    testTimeoutOf,
+} from '../config/engine-config'
+import { checkAlreadyDone } from '../gates/already-done-check'
+import { prepareCheck } from '../gates/gate-runner'
+import {
+    fileTestsCommand,
+    onlyTestFiles,
+    runBunTests,
+} from '../gates/test-runner'
+
+/**
+ * Checks a test-writer's `already_done` evidence (#495) in the ticket's
+ * worktree, then journals the check (`already_done_checked`): where git
+ * finds each named commit, next to the commit the worktree started from,
+ * and a run of just the named test files that exist, are test files, and
+ * are as they are on the base, after the prepare command if the config has
+ * one. With a slow command (#564), the named files, slow ones included, run
+ * with plain `bun test`. What the check means is `checkAlreadyDone`'s; replay
+ * makes a failed one a failed try for the test-writer.
+ */
+export const checkAlreadyDoneIn = async ({
+    context,
+    action,
+}: {
+    context: BuildContext
+    action: Extract<BuildAction, { type: 'check_already_done' }>
+}) => {
+    const { path } = ticketWorktree({
+        state: context.state,
+        ticket: action.ticket,
+    })
+    const commits = []
+    for (const { sha } of uniqBy(action.done_by, 'sha')) {
+        const place = await context.git.commitOnBase({
+            cwd: path,
+            sha,
+            base: action.base_sha,
+        })
+        commits.push({ sha, place })
+    }
+    const files = uniq(
+        action.criteria.flatMap(({ tests }) => tests.map(({ file }) => file))
+    )
+    const missing = files.filter((file) => !existsSync(join(path, file)))
+    const test_files = await testFilesIn({ context, cwd: path })
+    const changed = (
+        await ticketChanges({
+            context,
+            cwd: path,
+            leave_out: await leaveOutIn({
+                context,
+                cwd: path,
+                ticket: action.ticket,
+            }),
+        })
+    ).map((change) => change.path)
+    const runnable = files.filter(
+        (file) =>
+            !missing.includes(file) &&
+            test_files.includes(file) &&
+            !changed.includes(file)
+    )
+    const prepare =
+        runnable.length === 0
+            ? null
+            : await watchPrepare({
+                  context,
+                  cwd: path,
+                  ticket: action.ticket,
+                  run: () =>
+                      prepareCheck({ config: context.config, cwd: path }),
+              })
+    const run =
+        runnable.length === 0 || (prepare !== null && !prepare.ok)
+            ? null
+            : await runBunTests({
+                  cwd: path,
+                  // With a slow command, the fast command would leave out
+                  // the slow files named (#564): plain `bun test` runs all.
+                  commands: hasSlowTests({ config: context.config })
+                      ? [fileTestsCommand({ files: runnable })]
+                      : bunTestCommands(context).map((command) =>
+                            onlyTestFiles({ command, files: runnable })
+                        ),
+                  test_files: runnable,
+                  timeout_ms: testTimeoutOf({ config: context.config }),
+                  test_concurrency: context.config.test_concurrency,
+                  report_file: await reportFile({
+                      context,
+                      ticket: action.ticket,
+                      label: 'already-done',
+                  }),
+              })
+    const { ok, problems } = checkAlreadyDone({
+        base_sha: action.base_sha,
+        criteria_ids: action.criteria_ids,
+        criteria: action.criteria,
+        commits,
+        missing,
+        test_files,
+        changed,
+        prepare,
+        run,
+    })
+    context.journal.append({
+        kind: 'already_done_checked',
+        ticket: action.ticket,
+        role: null,
+        content: { ok, problems, base_sha: action.base_sha, tests: run },
+    })
+}