@defrex/autobuild 0.8.0 → 0.10.0

package/packages/core/src/cli/store-opening.contract.ts

@@ -1,289 +0,0 @@
-/**
- * Shared behavioral contract for finite sessionless commands that own a
- * BuildStore. Register this against distinct command shells so selection,
- * credentials, production composition, and cleanup cannot drift per command.
- */
-import { describe, expect, test } from 'bun:test'
-import { existsSync } from 'node:fs'
-import { mkdtemp, rm } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import type { Exec } from '../ports/workspace/git-worktree'
-import { MemoryBuildStore } from '../store/memory'
-import { startStoreServer } from '../store/remote/server'
-import { mintToken } from '../store/remote/token'
-import type { BuildStore } from '../store/types'
-import type { StoreOpener } from './store-opening'
-
-const MAIN_REPO = '/main/repo'
-const LINKED_REPO = '/linked/worktree'
-
-const mainRepoExec: Exec = async (cmd) =>
-  cmd[1] === 'remote'
-    ? // No origin remote: identity falls back to the resolved checkout path.
-      { stdout: '', stderr: "error: No such remote 'origin'\n", exitCode: 2 }
-    : {
-        stdout: `${MAIN_REPO}/.git\n${MAIN_REPO}/.git\n${MAIN_REPO}\n`,
-        stderr: '',
-        exitCode: 0,
-      }
-
-const noGit: Exec = async () => ({
-  stdout: '',
-  stderr: 'not a git repository',
-  exitCode: 128,
-})
-
-export interface StoreOpeningCommandOpts {
-  targetRepo: string
-  env: Record<string, string | undefined>
-  exec: Exec
-  stdout: (line: string) => void
-  storeRef?: string
-  openStore?: StoreOpener
-}
-
-export interface StoreOpeningCommandAdapter {
-  run: (opts: StoreOpeningCommandOpts) => Promise<void>
-  /** Extract a command-specific marker proving it used canonical main-repo
-   * identity (for example a filtered build slug or a projected repo path). */
-  canonicalMarker: (stdout: string[]) => string | undefined
-  expectedCanonicalMarker: string
-}
-
-function trackedStore(
-  store: MemoryBuildStore,
-  opts: { failOperations?: boolean; onClose: () => void },
-): BuildStore {
-  return new Proxy(store, {
-    get(target, prop) {
-      if (prop === 'close') {
-        return async () => opts.onClose()
-      }
-      const value = Reflect.get(target, prop, target) as unknown
-      if (typeof value !== 'function') return value
-      if (opts.failOperations === true) {
-        return async () => {
-          throw new Error('store operation failed')
-        }
-      }
-      return value.bind(target) as unknown
-    },
-  }) as unknown as BuildStore
-}
-
-async function capture(
-  adapter: StoreOpeningCommandAdapter,
-  opts: Omit<StoreOpeningCommandOpts, 'stdout'>,
-): Promise<string[]> {
-  const stdout: string[] = []
-  await adapter.run({ ...opts, stdout: (line) => stdout.push(line) })
-  return stdout
-}
-
-export function describeStoreOpeningContract(
-  name: string,
-  adapter: StoreOpeningCommandAdapter,
-): void {
-  describe(`sessionless store-opening contract: ${name}`, () => {
-    test('shares reference precedence, normalization, URL preservation, and opaque token forwarding', async () => {
-      const store = new MemoryBuildStore()
-      const opened: Array<{ ref: string; token?: string }> = []
-      const openStore: StoreOpener = (ref, token) => {
-        opened.push({ ref, ...(token !== undefined ? { token } : {}) })
-        return store
-      }
-      const base = {
-        targetRepo: LINKED_REPO,
-        exec: mainRepoExec,
-        openStore,
-      }
-
-      await capture(adapter, {
-        ...base,
-        env: { AB_STORE: 'environment' },
-        storeRef: 'flag/../selected',
-      })
-      await capture(adapter, {
-        ...base,
-        env: { AB_STORE: 'environment/../selected-env' },
-      })
-      await capture(adapter, {
-        ...base,
-        env: { AB_STORE: '/absolute/state' },
-        storeRef: '  ',
-      })
-      await capture(adapter, {
-        ...base,
-        env: { AB_STORE: ' \t' },
-        storeRef: '',
-      })
-      await capture(adapter, {
-        ...base,
-        env: {},
-        storeRef: 'http://store.example.test/api',
-      })
-      await capture(adapter, {
-        ...base,
-        env: {},
-        storeRef: 'https://store.example.test/api?x=1',
-      })
-      await capture(adapter, {
-        ...base,
-        env: { AB_TOKEN: '' },
-        storeRef: 'https://store.example.test/empty-token',
-      })
-      await capture(adapter, {
-        ...base,
-        env: { AB_TOKEN: ' opaque token ' },
-        storeRef: 'https://store.example.test/opaque-token',
-      })
-
-      expect(opened).toEqual([
-        { ref: `${MAIN_REPO}/selected` },
-        { ref: `${MAIN_REPO}/selected-env` },
-        { ref: '/absolute/state' },
-        { ref: `${MAIN_REPO}/.autobuild` },
-        { ref: 'http://store.example.test/api' },
-        { ref: 'https://store.example.test/api?x=1' },
-        { ref: 'https://store.example.test/empty-token' },
-        {
-          ref: 'https://store.example.test/opaque-token',
-          token: ' opaque token ',
-        },
-      ])
-    })
-
-    test('uses canonical main-repository identity', async () => {
-      const store = new MemoryBuildStore()
-      await store.createBuild({ slug: 'main-build', repo: MAIN_REPO })
-      await store.createBuild({ slug: 'other-build', repo: '/other/repo' })
-      await store.ensureRepo(MAIN_REPO)
-      const stdout = await capture(adapter, {
-        targetRepo: LINKED_REPO,
-        env: {},
-        exec: mainRepoExec,
-        openStore: () => store,
-      })
-      expect(adapter.canonicalMarker(stdout)).toBe(adapter.expectedCanonicalMarker)
-    })
-
-    test('closes exactly once on success, store failure, and output failure', async () => {
-      const run = async (mode: 'success' | 'store' | 'output'): Promise<number> => {
-        const store = new MemoryBuildStore()
-        let closes = 0
-        const tracked = trackedStore(store, {
-          failOperations: mode === 'store',
-          onClose: () => {
-            closes += 1
-          },
-        })
-        const command = adapter.run({
-          targetRepo: LINKED_REPO,
-          env: {},
-          exec: mainRepoExec,
-          openStore: () => tracked,
-          stdout:
-            mode === 'output'
-              ? () => {
-                  throw new Error('output failed')
-                }
-              : () => {},
-        })
-        if (mode === 'success') await command
-        else {
-          await expect(command).rejects.toThrow(
-            mode === 'store' ? 'store operation failed' : 'output failed',
-          )
-        }
-        return closes
-      }
-
-      expect(await run('success')).toBe(1)
-      expect(await run('store')).toBe(1)
-      expect(await run('output')).toBe(1)
-    })
-
-    test('propagates opener failure without phantom cleanup', async () => {
-      let closes = 0
-      const unopened = new MemoryBuildStore()
-      unopened.close = async () => {
-        closes += 1
-      }
-      await expect(
-        adapter.run({
-          targetRepo: LINKED_REPO,
-          env: {},
-          exec: mainRepoExec,
-          stdout: () => {},
-          openStore: () => {
-            throw new Error('open failed')
-          },
-        }),
-      ).rejects.toThrow('open failed')
-      expect(closes).toBe(0)
-    })
-
-    test('production composition opens a local SQLite root', async () => {
-      const repo = await mkdtemp(join(tmpdir(), 'ab-store-opening-local-'))
-      try {
-        await adapter.run({
-          targetRepo: repo,
-          env: {},
-          exec: noGit,
-          stdout: () => {},
-          storeRef: 'state',
-        })
-        expect(existsSync(join(repo, 'state', 'autobuild.sqlite'))).toBe(true)
-      } finally {
-        await rm(repo, { recursive: true, force: true })
-      }
-    })
-
-    test('production composition forwards a token to remote HTTP and rejects missing or invalid credentials', async () => {
-      const secret = 'store-opening-secret'
-      const now = new Date('2026-07-15T12:00:00.000Z')
-      const backing = new MemoryBuildStore({ clock: () => now })
-      const server = startStoreServer({
-        store: backing,
-        secret,
-        clock: () => now,
-      })
-      const token = mintToken(secret, {
-        build: '*',
-        session: '*',
-        exp: now.getTime() + 60_000,
-      })
-      try {
-        await adapter.run({
-          targetRepo: LINKED_REPO,
-          env: { AB_TOKEN: token },
-          exec: mainRepoExec,
-          stdout: () => {},
-          storeRef: server.url,
-        })
-        await expect(
-          adapter.run({
-            targetRepo: LINKED_REPO,
-            env: {},
-            exec: mainRepoExec,
-            stdout: () => {},
-            storeRef: server.url,
-          }),
-        ).rejects.toThrow(/missing bearer token/)
-        await expect(
-          adapter.run({
-            targetRepo: LINKED_REPO,
-            env: { AB_TOKEN: 'invalid-token' },
-            exec: mainRepoExec,
-            stdout: () => {},
-            storeRef: server.url,
-          }),
-        ).rejects.toThrow(/invalid or expired token/)
-      } finally {
-        await server.stop()
-        await backing.close()
-      }
-    })
-  })
-}

package/packages/core/src/cli/testkit.ts

@@ -1,194 +0,0 @@
-/**
- * Test-support fixtures for the CLI suite — imported only by the colocated
- * `*.test.ts` files, never by production code (mirrors the src/testing rule).
- *
- * The store fixture is a seeded MemoryBuildStore (the reference adapter — its
- * behavior IS the contract, store/contract.ts) and the git fixtures are real
- * throwaway repos, matching the patterns in git-worktree.test.ts.
- */
-import { mkdir, writeFile } from 'node:fs/promises'
-import { join } from 'node:path'
-import type { EventEnvelope, EventWrite } from '../events/catalog'
-import { DISPATCHER } from '../events/envelope'
-import type { EventType } from '../events/payloads'
-import type { PrImageHostTarget } from '../ontology'
-import { sequentialIds } from '../ids'
-import { FakeForge } from '../ports/forge/fake'
-import { spawnExec } from '../ports/workspace/git-worktree'
-import { MemoryBuildStore } from '../store/memory'
-import type { BuildStore } from '../store/types'
-import { steppingClock } from '../testing/fixed'
-import type { CliEnv } from './env'
-import type { CliDeps } from './main'
-
-export const BUILD = 'auth-rate-limit'
-export const BRANCH = 'ab/auth-rate-limit'
-
-export function makeEnv(overrides: Partial<CliEnv> = {}): CliEnv {
-  return {
-    store: '/tmp/ab-store',
-    build: BUILD,
-    phase: 'implement',
-    round: 1,
-    session: 's_test',
-    ...overrides,
-  }
-}
-
-/** Build + `build.created` + spec@0 (`spec.imported`) — every phase's floor. */
-export async function seedStore(
-  opts: { imageHost?: PrImageHostTarget } = {},
-): Promise<MemoryBuildStore> {
-  const store = new MemoryBuildStore({ clock: steppingClock() })
-  await store.createBuild({ slug: BUILD, repo: 'acme/app', branch: BRANCH })
-  await store.append(BUILD, {
-    actor: DISPATCHER,
-    type: 'build.created',
-    payload: {
-      ticket: {
-        source: 'linear',
-        id: 'ENG-42',
-        url: 'https://linear.app/acme/issue/ENG-42',
-        title: 'Auth rate limiting',
-      },
-      repo: 'acme/app',
-      baseBranch: 'main',
-      ...(opts.imageHost !== undefined ? { pr: { imageHost: opts.imageHost } } : {}),
-    },
-  })
-  await store.putArtifact(BUILD, {
-    kind: 'spec',
-    content: '# Spec: auth rate limiting\n',
-  })
-  await store.append(BUILD, {
-    actor: DISPATCHER,
-    type: 'spec.imported',
-    payload: {
-      artifact: { kind: 'spec', rev: 0 },
-      ticket: { source: 'linear', id: 'ENG-42' },
-    },
-  })
-  return store
-}
-
-export interface TestDeps extends CliDeps {
-  forge: FakeForge
-  out: string[]
-  err: string[]
-}
-
-export function makeDeps(opts: {
-  store: MemoryBuildStore
-  env: CliEnv
-  workspacePath?: string
-  forge?: FakeForge
-}): TestDeps {
-  const out: string[] = []
-  const err: string[] = []
-  const forge = opts.forge ?? new FakeForge()
-  return {
-    store: opts.store,
-    env: opts.env,
-    workspacePath: opts.workspacePath ?? '/nonexistent-workspace',
-    forge,
-    exec: spawnExec,
-    ids: sequentialIds(),
-    clock: steppingClock(),
-    stdout: (line) => out.push(line),
-    stderr: (line) => err.push(line),
-    out,
-    err,
-  }
-}
-
-/**
- * Wrap a store so ONE build's compare-and-set append fails outright, to drive
- * the bulk walk's partial-progress path. Prototype-proxy idiom, as
- * `withRacingAppend` in bulk-control.test.ts; every other build and every other
- * operation delegates untouched, so the walk's real bookkeeping is what the
- * failure report is built from.
- */
-export function withFailingAppend(store: MemoryBuildStore, slug: string, error: Error): BuildStore {
-  const proxy = Object.create(store) as MemoryBuildStore
-  proxy.appendIfCurrent = async <T extends EventType>(
-    target: string,
-    expectedSeq: number,
-    event: EventWrite<T>,
-  ): Promise<EventEnvelope<T> | null> => {
-    if (target === slug) throw error
-    return store.appendIfCurrent(target, expectedSeq, event)
-  }
-  return proxy
-}
-
-// ── Real-git fixtures (identity pinned per invocation, like git-worktree.test) ─
-
-export const GIT_ID = [
-  '-c',
-  'user.email=ab@test.invalid',
-  '-c',
-  'user.name=ab-test',
-  '-c',
-  'commit.gpgsign=false',
-]
-
-export async function runGit(args: string[], cwd: string): Promise<string> {
-  const result = await spawnExec(['git', ...args], { cwd })
-  if (result.exitCode !== 0) {
-    throw new Error(`git ${args.join(' ')} failed: ${result.stderr}`)
-  }
-  return result.stdout.trim()
-}
-
-/**
- * A workspace repo on branch `ab/auth-rate-limit`, branched off `main`.
- * Deliberately does NOT gitignore `.ab/` — real repos don't either (§7:
- * establishing the gitignored scratch dir is the PRODUCT's job, via the
- * self-excluding `.ab/.gitignore` that `ab context` writes); a fixture that
- * hand-wrote the ignore would hide a regression in that mechanism.
- */
-export async function initWorkspaceRepo(dir: string, branch = BRANCH): Promise<void> {
-  await mkdir(dir, { recursive: true })
-  await runGit(['init', '-q', '-b', 'main'], dir)
-  await writeFile(join(dir, 'README.md'), 'fixture\n')
-  await runGit(['add', '.'], dir)
-  await runGit([...GIT_ID, 'commit', '-q', '-m', 'initial'], dir)
-  await runGit(['checkout', '-q', '-b', branch], dir)
-}
-
-/**
- * Attach a throwaway bare origin, seed its build ref at the local branch tip,
- * and seed `main` at an independently selected target commit. Directly moving
- * the bare target ref deliberately leaves operator-owned local/tracking refs
- * untouched, matching the real workspace boundary tests.
- */
-export async function initBareOrigin(
-  workspace: string,
-  remote: string,
-  branch = BRANCH,
-  target = 'HEAD',
-): Promise<void> {
-  const targetSha = await runGit(['rev-parse', '--verify', `${target}^{commit}`], workspace)
-  await mkdir(remote, { recursive: true })
-  await runGit(['init', '-q', '--bare'], remote)
-  await runGit(['remote', 'add', 'origin', remote], workspace)
-  await runGit(['push', '-q', 'origin', `${branch}:refs/heads/${branch}`], workspace)
-  await runGit(['update-ref', 'refs/heads/main', targetSha], remote)
-  await runGit(['symbolic-ref', 'HEAD', 'refs/heads/main'], remote)
-}
-
-export function remoteBranchHead(remote: string, branch = BRANCH): Promise<string> {
-  return runGit(['rev-parse', `refs/heads/${branch}`], remote)
-}
-
-export async function commitFile(
-  dir: string,
-  file: string,
-  content: string,
-  message: string,
-): Promise<string> {
-  await writeFile(join(dir, file), content)
-  await runGit(['add', file], dir)
-  await runGit([...GIT_ID, 'commit', '-q', '-m', message], dir)
-  return runGit(['rev-parse', 'HEAD'], dir)
-}

package/packages/core/src/markdown.ts

@@ -1,67 +0,0 @@
-/**
- * Approximate Markdown reference extraction, shared by the checks that ask
- * "does this link point at something that exists?".
- *
- * These are regexes, not a CommonMark parser. Reference-style targets
- * (`![alt][ref]`) and targets containing parentheses are invisible to them.
- * Both callers are link-existence checks, where an unseen reference fails
- * toward a loud complaint rather than a silent pass, so the approximation is
- * safe — but a false report is a signal to widen the parser, never to delete
- * the thing it failed to see.
- */
-
-/**
- * Blanks out fenced code blocks, preserving line count. A target inside a fence
- * is sample text, not a rendered reference. Backtick and tilde fences are
- * tracked separately so a `~~~` line inside a ``` block does not close it.
- */
-export function withoutFencedCode(markdown: string): string {
-  const lines = markdown.split('\n')
-  let fence: '`' | '~' | undefined
-  return lines
-    .map((line) => {
-      const opening = line.match(/^\s*(`{3,}|~{3,})/)
-      if (opening) {
-        const marker = opening[1]![0] as '`' | '~'
-        if (fence === undefined) fence = marker
-        else if (fence === marker) fence = undefined
-        return ''
-      }
-      return fence === undefined ? line : ''
-    })
-    .join('\n')
-}
-
-/**
- * Inline link and image targets, in source order. Angle brackets are unwrapped
- * and a title suffix is dropped, so `[a](<b.md> "T")` yields `b.md`.
- */
-export function markdownTargets(markdown: string): string[] {
-  const targets: string[] = []
-  for (const match of markdown.matchAll(/!?\[[^\]]*\]\(([^)]+)\)/g)) {
-    const inline = match[1]!.trim()
-    // An angle-bracketed destination runs to its closing `>`, and whatever
-    // follows is the title. The two must be read together: unwrapping first
-    // fails whenever a title is present (the text no longer ends in `>`), and
-    // splitting the title off first would truncate a bracketed destination that
-    // legitimately contains whitespace and a quote. A `<` with no closing `>`
-    // is malformed, and falls through to the unbracketed reading.
-    const closing = inline.startsWith('<') ? inline.indexOf('>') : -1
-    targets.push(closing === -1 ? inline.split(/\s+["']/u, 1)[0]! : inline.slice(1, closing))
-  }
-  return targets
-}
-
-/**
- * `src` attributes of raw `<img>` tags, in source order. Kept separate from
- * `markdownTargets` so callers that only care about Markdown syntax keep their
- * existing behaviour: Markdown permits raw HTML, and this repository's README
- * already mixes it in, so a centred hero image would otherwise be invisible.
- */
-export function htmlImageTargets(markdown: string): string[] {
-  const targets: string[] = []
-  for (const match of markdown.matchAll(/<img\b[^>]*?\ssrc\s*=\s*("([^"]*)"|'([^']*)')/giu)) {
-    targets.push((match[2] ?? match[3])!.trim())
-  }
-  return targets
-}