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

package/engine/testing/checkouts-fixtures.ts

@@ -0,0 +1,48 @@
+import { mkdir, symlink } from 'node:fs/promises'
+import { join } from 'node:path'
+
+import { $ } from 'bun'
+
+/** The folders a skill helper can be started from, for one repo and none. */
+export type Checkouts = {
+    /** The main checkout: where a run's `run_started` repo points. */
+    main: string
+    /** A `git worktree add` of the main checkout. */
+    worktree: string
+    /** A folder inside the main checkout. */
+    subfolder: string
+    /** A symlink to the main checkout. */
+    link: string
+    /** A folder in no git repo. */
+    outside: string
+}
+
+/**
+ * Real throwaway checkouts under `dir`: a git repo with one commit, a
+ * worktree of it, a subfolder, a symlink to it, and a folder outside git.
+ * For the `/luca-unstick` and `/luca-retro` helpers' repo lookup, which must
+ * find the same runs from each of them.
+ *
+ * @example
+ * const { main, worktree } = await makeCheckouts({ dir })
+ */
+export const makeCheckouts = async ({
+    dir,
+}: {
+    dir: string
+}): Promise<Checkouts> => {
+    const main = join(dir, 'app')
+    const worktree = join(dir, 'app-worktree')
+    const subfolder = join(main, 'src', 'deep')
+    const link = join(dir, 'app-link')
+    const outside = join(dir, 'not-git')
+    await mkdir(subfolder, { recursive: true })
+    await mkdir(outside, { recursive: true })
+    await Bun.write(join(subfolder, 'a.txt'), 'a\n')
+    await $`git init -q -b main && git add -A && git -c user.name=t -c user.email=t@t -c commit.gpgsign=false commit -qm init`
+        .cwd(main)
+        .quiet()
+    await $`git worktree add -q -b side ${worktree}`.cwd(main).quiet()
+    await symlink(main, link)
+    return { main, worktree, subfolder, link, outside }
+}

package/engine/testing/final-review-fixtures.ts

@@ -4,6 +4,7 @@ import {
     type Finding,
     type FindingRuling,
     type LensName,
+    type MergeDanger,
 } from '../agents/role-results'
 import type { JournalEntry, StuckReason } from '../journal/journal-record'
 
@@ -22,6 +23,8 @@ export const finalReviewStarted = ({
     lenses,
     files,
     rules,
+    slow_due,
+    fresh,
 }: {
     round: number
     /** Defaults to `b0`, where the fixtures' run branch starts. */
@@ -33,6 +36,16 @@ export const finalReviewStarted = ({
     /** Defaults to `src/sum.ts` and its test. */
     files?: string[]
     rules?: { path: string; text: string | null }[]
+    /**
+     * Round 1's slow tests are due (#563). Left out, the record has no
+     * `slow_due`, as an older engine's has none.
+     */
+    slow_due?: boolean
+    /**
+     * The final review's fresh pass (#548). Left out, the record has no
+     * `fresh`, as an older engine's has none.
+     */
+    fresh?: boolean
 }): JournalEntry => ({
     kind: 'final_review_started',
     ticket: null,
@@ -44,6 +57,8 @@ export const finalReviewStarted = ({
         lenses: lenses ?? [...LENS_NAMES],
         files: files ?? ['src/sum.test.ts', 'src/sum.ts'],
         rules: rules ?? [],
+        ...(slow_due === undefined ? {} : { slow_due }),
+        ...(fresh === undefined ? {} : { fresh }),
     },
 })
 
@@ -79,12 +94,18 @@ export const lensReviewed = ({
     findings,
     rulings,
     assumptions,
+    summary_picture,
+    merge_danger,
 }: {
     lens: LensName
     round: number
     findings?: Finding[]
     rulings?: FindingRuling[]
     assumptions?: string[]
+    /** The integration lens's Summary picture (#513); left out by default. */
+    summary_picture?: string | null
+    /** The integration lens's Merge Danger (#513); left out by default. */
+    merge_danger?: MergeDanger | null
 }): JournalEntry[] => {
     const list = findings ?? []
     const role = lensRole({ lens })
@@ -118,6 +139,10 @@ export const lensReviewed = ({
                     rulings: rulings ?? [],
                     summary: `The ${lens} lens looked.`,
                     assumptions: assumptions ?? [],
+                    ...(summary_picture === undefined
+                        ? {}
+                        : { summary_picture }),
+                    ...(merge_danger === undefined ? {} : { merge_danger }),
                 },
             },
         },
@@ -148,6 +173,8 @@ export const lensRound = ({
     findings,
     from_sha,
     head_sha,
+    slow_due,
+    fresh,
 }: {
     round: number
     /** Defaults to every lens. */
@@ -155,16 +182,50 @@ export const lensRound = ({
     findings?: Partial<Record<LensName, Finding[]>>
     from_sha?: string
     head_sha?: string
+    /** The round's slow tests are due (#563); see `finalReviewStarted`. */
+    slow_due?: boolean
+    /** The fresh pass (#548); see `finalReviewStarted`. */
+    fresh?: boolean
 }): JournalEntry[] => {
     const due = lenses ?? [...LENS_NAMES]
     return [
-        finalReviewStarted({ round, lenses: due, from_sha, head_sha }),
+        finalReviewStarted({
+            round,
+            lenses: due,
+            from_sha,
+            head_sha,
+            slow_due,
+            fresh,
+        }),
         ...due.flatMap((lens) =>
             lensReviewed({ lens, round, findings: findings?.[lens] })
         ),
     ]
 }
 
+/**
+ * The final review's slow tests on the run branch (#563): `bun test
+ * .e2e.test`, passing or failing.
+ */
+export const slowTestsRun = ({ ok }: { ok: boolean }): JournalEntry => ({
+    kind: 'gates_run',
+    ticket: null,
+    role: null,
+    content: {
+        target: 'final_slow',
+        ok,
+        checks: [
+            {
+                name: 'slow_test',
+                command: 'bun test .e2e.test',
+                ok,
+                exit_code: ok ? 0 : 1,
+                output: ok ? '' : '1 fail',
+            },
+        ],
+    },
+})
+
 /** A final review fix round starts. */
 export const finalReviewFixing = ({
     round,

package/engine/testing/final-review-steps.ts

@@ -0,0 +1,143 @@
+import {
+    commitMade,
+    gatesRun,
+    implemented,
+    intakePassed,
+    leftoverScan,
+    practiceTicket,
+    pushed,
+    runBranchCreated,
+    testsWritten,
+    ticketBuilt,
+    withInstalls,
+} from './build-fixtures'
+import {
+    finalReviewFixing,
+    lensFinding,
+    lensRound,
+} from './final-review-fixtures'
+import { recordsFrom } from './intake-fixtures'
+
+import { decideSteps, type EngineAction } from '../core/decide'
+import type { JournalEntry } from '../journal/journal-record'
+
+/**
+ * The final review's decision-step tests' shared journal: practice ticket
+ * #11 built and pushed, its lens findings, and its fix rounds, with the
+ * steps the decision step takes after them.
+ */
+
+export const TICKET = practiceTicket({ number: 11 })
+
+/** Every step the decision step can take now, after these entries. */
+export const stepsAfter = (
+    entries: JournalEntry[],
+    tickets = [TICKET]
+): EngineAction[] =>
+    decideSteps({
+        records: recordsFrom({
+            entries: [
+                ...intakePassed({ tickets }),
+                ...withInstalls({ entries }),
+            ],
+        }),
+    })
+
+/** The one step the decision step takes after these entries. */
+export const stepAfter = (entries: JournalEntry[]): EngineAction => {
+    const steps = stepsAfter(entries)
+    if (steps.length !== 1) {
+        throw new Error(steps.map(({ type }) => type).join(', '))
+    }
+    return steps[0] as EngineAction
+}
+
+/** The run branch with ticket #11 built, joined, and pushed. */
+export const built = (): JournalEntry[] => [
+    runBranchCreated(),
+    ...ticketBuilt({ ticket: 11 }),
+]
+
+/** The prompt of the `launch_lens` step for this lens. */
+export const lensPrompt = (steps: EngineAction[], lens: string): string => {
+    const step = steps.find(
+        (entry) => entry.type === 'launch_lens' && entry.lens === lens
+    )
+    if (step?.type !== 'launch_lens') throw new Error(`no ${lens} lens`)
+    return step.prompt
+}
+
+export const SECURITY = lensFinding({ id: 'S1', title: 'Sum trusts its input' })
+export const ARCH_TEST = lensFinding({
+    id: 'A1',
+    kind: 'test',
+    severity: 'blocker',
+    title: 'The tests reach into private helpers',
+    file: 'src/sum.test.ts',
+})
+export const NIT = lensFinding({
+    id: 'N1',
+    severity: 'nit',
+    title: 'Shorter name',
+})
+
+/** Round 1 with a code finding (security), a test finding (architecture), and a nit. */
+export const findingsRound = (): JournalEntry[] =>
+    lensRound({
+        round: 1,
+        findings: {
+            security: [SECURITY],
+            architecture: [ARCH_TEST],
+            simplification: [NIT],
+        },
+    })
+
+/** Fix round 1 answered: the test-writer, then a fresh implementer. */
+export const fixersAnswered = ({
+    security,
+}: {
+    security: 'fixed' | 'wont_fix'
+}): JournalEntry[] => [
+    finalReviewFixing({ round: 1 }),
+    testsWritten({
+        ticket: null,
+        finding_responses: [
+            { finding_id: 'architecture-A1', response: 'fixed', reason: '' },
+        ],
+    }),
+    implemented({
+        ticket: null,
+        finding_responses: [
+            {
+                finding_id: 'security-S1',
+                response: security,
+                reason: security === 'fixed' ? '' : 'Inputs are typed numbers.',
+            },
+        ],
+    }),
+]
+
+/** The fixes pass the gates, are committed as `sha`, and pushed. */
+export const fixesLanded = ({ sha }: { sha: string }): JournalEntry[] => [
+    gatesRun({ ticket: null, target: 'run_branch', ok: true }),
+    leftoverScan({ ticket: null, stage: 'fix' }),
+    commitMade({ ticket: null, stage: 'fix', sha, files: ['src/sum.ts'] }),
+    pushed({ ticket: null, sha }),
+]
+
+/** A whole fix round of the security finding, up to its push. */
+export const securityFixRound = ({
+    round,
+}: {
+    round: number
+}): JournalEntry[] => [
+    finalReviewFixing({ round }),
+    implemented({
+        ticket: null,
+        session_id: `impl-${round}`,
+        finding_responses: [
+            { finding_id: 'security-S1', response: 'fixed', reason: '' },
+        ],
+    }),
+    ...fixesLanded({ sha: `fix-${round}` }),
+]

package/engine/testing/limit-fixtures.ts

@@ -0,0 +1,85 @@
+/**
+ * Journal entry builders for plan limits: a `rate_limit_event`'s reading as
+ * the SDK sends it, a limit wait started and ended, and a billing stop.
+ */
+import type { JournalEntry } from '../journal/journal-record'
+
+/** Seconds since the epoch for an ISO time, as `resetsAt` gives it. */
+export const epochSeconds = (iso: string): number =>
+    Math.floor(Date.parse(iso) / 1000)
+
+/**
+ * One `rate_limit_event`'s info as the SDK sends it, with the windows'
+ * utilization under `unifiedWindows` as real readings have it.
+ */
+export const rateLimitReading = ({
+    status,
+    rate_limit_type,
+    resets_at,
+    is_using_overage,
+    windows,
+}: {
+    status: 'allowed' | 'allowed_warning' | 'rejected'
+    /** Defaults to `five_hour`. */
+    rate_limit_type?: string
+    /** An ISO time; leave it out for a reading with no `resetsAt`. */
+    resets_at?: string
+    is_using_overage?: boolean
+    /** Utilization (0 to 1) per window, such as `{ five_hour: 0.2 }`. */
+    windows?: Record<string, number>
+}): Record<string, unknown> => ({
+    status,
+    rateLimitType: rate_limit_type ?? 'five_hour',
+    ...(resets_at === undefined ? {} : { resetsAt: epochSeconds(resets_at) }),
+    overageStatus: 'rejected',
+    overageDisabledReason: 'org_level_disabled',
+    isUsingOverage: is_using_overage ?? false,
+    unifiedWindows: Object.fromEntries(
+        Object.entries(windows ?? {}).map(([name, utilization]) => [
+            name,
+            { utilization },
+        ])
+    ),
+})
+
+/** A limit wait started, hit by #11's test-writer unless told otherwise. */
+export const limitWaitStarted = ({
+    until,
+    resets_at,
+    rate_limit_type,
+}: {
+    until: string
+    resets_at: string | null
+    /** Defaults to `five_hour`. */
+    rate_limit_type?: string
+}): JournalEntry => ({
+    kind: 'limit_wait_started',
+    ticket: null,
+    role: null,
+    content: {
+        until,
+        resets_at,
+        rate_limit_type: rate_limit_type ?? 'five_hour',
+        hit_ticket: 11,
+        hit_role: 'test-writer',
+    },
+})
+
+export const limitWaitEnded = ({ until }: { until: string }): JournalEntry => ({
+    kind: 'limit_wait_ended',
+    ticket: null,
+    role: null,
+    content: { until },
+})
+
+/** The run stopped for good on a sign of per-token billing. */
+export const billingStopped = ({
+    reason,
+}: {
+    reason: string
+}): JournalEntry => ({
+    kind: 'run_stopped',
+    ticket: null,
+    role: null,
+    content: { reason, role: null, billing: true },
+})

package/engine/testing/live-file-fixtures.ts

@@ -0,0 +1,57 @@
+import { readFileSync } from 'node:fs'
+import { join } from 'node:path'
+
+import { LiveFileSchema, type LiveFile } from '../core/live-file'
+
+/**
+ * The run's live file (#628) as the engine's tests read it: `live.json`
+ * parsed with the writer's own schema (`core/live-file.ts`), never cast, so
+ * a field the writer renames or drops fails the test that reads it.
+ * The board reads the same file with its own, more forgiving schemas
+ * (`packages/board/server/live-file.ts`).
+ */
+
+export {
+    LiveFileSchema,
+    type LiveAgent,
+    type LiveFile,
+    type LiveHelper,
+    type LiveWait,
+} from '../core/live-file'
+
+/** The live file of the practice run (`run-1`) in `dir`. */
+export const liveFileIn = (dir: string): string =>
+    join(dir, 'runs', 'run-1', 'live.json')
+
+/**
+ * The live file at `file`, or `null` while there is none. A file that is
+ * there but doesn't fit `LiveFileSchema` throws, naming the field.
+ */
+export const readLive = (file: string): LiveFile | null => {
+    let json: unknown
+    try {
+        json = JSON.parse(readFileSync(file, 'utf8'))
+    } catch {
+        return null
+    }
+    return LiveFileSchema.parse(json)
+}
+
+/** The live file once `until` holds for it, or `null` after `ms`. */
+export const waitForLive = async ({
+    file,
+    until,
+    ms = 3000,
+}: {
+    file: string
+    until: (live: LiveFile) => boolean
+    ms?: number
+}): Promise<LiveFile | null> => {
+    const deadline = Date.now() + ms
+    while (Date.now() < deadline) {
+        const live = readLive(file)
+        if (live !== null && until(live)) return live
+        await Bun.sleep(20)
+    }
+    return null
+}

package/engine/testing/practice-repo.ts

@@ -189,14 +189,16 @@ export const HAPPY_TURNS: ScriptedTurn[] = [
 ]
 
 /**
- * The turns, then a clean final review of spec #10 and an empty learner to
- * fall back on: the scripted launcher plays the first unused turn of a
- * role, so lens and learner turns in `turns` go first, a lens the turns
- * don't script approves, and a learner they don't script learns nothing.
+ * The turns, then two clean final review rounds of spec #10 (round 1's, and
+ * the fresh pass's after a fix round, #548) and an empty learner to fall
+ * back on: the scripted launcher plays the first unused turn of a role, so
+ * lens and learner turns in `turns` go first, a lens the turns don't script
+ * approves, and a learner they don't script learns nothing.
  */
 const withCleanLenses = (turns: ScriptedTurn[]): ScriptedTurn[] => [
     ...turns,
     ...CLEAN_LENS_TURNS(10),
+    ...CLEAN_LENS_TURNS(10),
     EMPTY_LEARNER_TURN(10),
 ]
 
@@ -347,6 +349,7 @@ export const createPracticeRepo = async ({
         memory,
         git: wrapGit,
         journal: wrapJournal,
+        live_file,
     }: {
         /**
          * Scripted agents' turns, then a clean final review for any lens they
@@ -385,6 +388,8 @@ export const createPracticeRepo = async ({
          * Defaults to the journal as is.
          */
         journal?: (real: Journal) => Journal
+        /** Where the engine keeps the run's live file (#628). Left out, it keeps none. */
+        live_file?: string
     }) => {
         const loaded = await loadEngineConfig({ repo_root: repo })
         if (!loaded.ok) throw new Error(loaded.error)
@@ -419,6 +424,7 @@ export const createPracticeRepo = async ({
                 memory === undefined
                     ? undefined
                     : { client: memory.client, timeout_ms: memory.timeout_ms },
+            live_file,
         })
         return {
             action,

package/engine/testing/practice-run.ts

@@ -20,7 +20,7 @@ import {
  * with a second ticket on top, so the board shows a blocked ticket waiting
  * and then building. No GitHub, no models, no setup.
  *
- * Seam 2 (`core/run-one-ticket.test.ts`) runs on `practice-repo.ts` itself.
+ * Seam 2 (`core/run-one-ticket.e2e.test.ts`) runs on `practice-repo.ts` itself.
  */
 
 export { makePracticeRepo, PRACTICE_SPEC_NUMBER }

package/engine/testing/reply-fixtures.ts

@@ -0,0 +1,88 @@
+/**
+ * Journal entry builders for a stuck ticket and the owner's reply: the stuck
+ * report, a comment read, a reply word taken, and a ticket retried or skipped.
+ */
+import { SPEC_OWNER } from './intake-fixtures'
+
+import type { JournalEntry } from '../journal/journal-record'
+
+/** The engine told the spec issue that a ticket is stuck, in comment `comment_id`. */
+export const stuckReported = ({
+    ticket,
+    comment_id,
+}: {
+    ticket: number
+    /** Defaults to 100 + the ticket number. */
+    comment_id?: number
+}): JournalEntry => ({
+    kind: 'stuck_reported',
+    ticket,
+    role: null,
+    content: { comment_id: comment_id ?? 100 + ticket, body: 'stuck' },
+})
+
+/** A comment the engine read on the spec issue. */
+export const commentRead = ({
+    comment_id,
+    body,
+    author,
+}: {
+    comment_id: number
+    body: string
+    /** Defaults to the spec's owner. */
+    author?: string
+}): JournalEntry => ({
+    kind: 'comment_read',
+    ticket: null,
+    role: null,
+    content: { comment_id, author: author ?? SPEC_OWNER, body },
+})
+
+/** The engine took a reply word from the spec's owner. */
+export const replyReceived = ({
+    word,
+    ticket,
+    comment_id,
+}: {
+    word: 'retry' | 'skip' | 'stop' | 'ship'
+    ticket: number | null
+    comment_id: number
+}): JournalEntry => ({
+    kind: 'reply_received',
+    ticket,
+    role: null,
+    content: { word, ticket, comment_id, author: SPEC_OWNER },
+})
+
+/** A retried ticket: resumed, started over, or refused. */
+export const ticketRetried = ({
+    ticket,
+    mode,
+}: {
+    ticket: number
+    mode: 'resume' | 'restart' | 'refused'
+}): JournalEntry => ({
+    kind: 'ticket_retried',
+    ticket,
+    role: null,
+    content: {
+        mode,
+        base_sha: mode === 'restart' ? 'tip-sha' : null,
+        problems: mode === 'refused' ? ['no criteria'] : [],
+        answer_id: null,
+    },
+})
+
+/** A ticket left out of the run. */
+export const ticketSkipped = ({
+    ticket,
+    because,
+}: {
+    ticket: number
+    because?: number
+}): JournalEntry => ({
+    kind: 'ticket_skipped',
+    ticket,
+    role: null,
+    content: { because: because ?? null },
+})