@workerstack/repo 0.0.0-stage → 0.1.0

package/cli/env.test.ts

@@ -0,0 +1,56 @@
+import { describe, expect, it, vi } from "vitest";
+import { childEnv, readEnv } from "./env.ts";
+
+/** The message of the error `run` throws, empty when it throws nothing. */
+function thrownBy(run: () => unknown): string {
+  try {
+    run();
+  } catch (error) {
+    return error instanceof Error ? error.message : "";
+  }
+  return "";
+}
+
+describe("readEnv", () => {
+  it("parses the given source", () => {
+    expect(readEnv({ HOME: "/home/x", PATH: "/bin" })).toMatchObject({ HOME: "/home/x", PATH: "/bin" });
+  });
+
+  it("leaves unset variables undefined", () => {
+    expect(readEnv({}).WORKSPACE_ACCOUNT).toBeUndefined();
+  });
+
+  it("reads process.env by default", () => {
+    vi.stubEnv("WORKSPACE_ACCOUNT", "me@example.com");
+    expect(readEnv().WORKSPACE_ACCOUNT).toBe("me@example.com");
+  });
+
+  it("throws one line per bad variable, naming it", () => {
+    const bad: Record<string, unknown> = { PATH: 1, HOME: 2 };
+    const lines = thrownBy(() => readEnv(bad)).split("\n");
+    expect(lines).toHaveLength(2);
+    expect(lines.every((line) => line.startsWith("repo: environment: "))).toBe(true);
+    expect(lines.some((line) => line.startsWith("repo: environment: HOME: "))).toBe(true);
+    expect(lines.some((line) => line.startsWith("repo: environment: PATH: "))).toBe(true);
+  });
+});
+
+describe("childEnv", () => {
+  it("copies process.env and applies overrides", () => {
+    vi.stubEnv("CHILD_ENV_KEPT", "kept");
+    vi.stubEnv("CHILD_ENV_REPLACED", "old");
+    const env = childEnv({ CHILD_ENV_REPLACED: "new", CHILD_ENV_ADDED: "added" });
+    expect(env).toMatchObject({ CHILD_ENV_KEPT: "kept", CHILD_ENV_REPLACED: "new", CHILD_ENV_ADDED: "added" });
+  });
+
+  it("drops an override that is undefined", () => {
+    vi.stubEnv("CHILD_ENV_GONE", "here");
+    expect("CHILD_ENV_GONE" in childEnv({ CHILD_ENV_GONE: undefined })).toBe(false);
+  });
+
+  it("returns a copy, not process.env", () => {
+    const env = childEnv();
+    env.CHILD_ENV_COPY = "x";
+    expect("CHILD_ENV_COPY" in childEnv()).toBe(false);
+  });
+});

package/cli/env.ts

@@ -0,0 +1,72 @@
+import { z } from "zod";
+
+/** Every variable this repo's code reads, sorted; add a name here to read it. */
+const ENV_VARIABLES = [
+  "CI",
+  "CLAUDE_EFFORT",
+  "CLAUDE_PROJECT_DIR",
+  "CLAUDE_SESSION_ID",
+  "ELEVENLABS_API_KEY",
+  "ELEVENLABS_MODEL_ID",
+  "ELEVENLABS_VOICE_ID",
+  "GITHUB_ACTIONS",
+  "GIT_CONFIG_GLOBAL",
+  "GIT_DIR",
+  "GROK_HOOK_EVENT",
+  "GROK_SESSION_ID",
+  "GROK_WORKSPACE_ROOT",
+  "HOME",
+  "LISTEN_DEVICE",
+  "LISTEN_FFMPEG_FORMAT",
+  "LISTEN_MODEL",
+  "LISTEN_SECONDS",
+  "LISTEN_STT",
+  "LISTEN_WHISPER_MODEL",
+  "NODE_PATH",
+  "OPENAI_API_KEY",
+  "OPENAI_TTS_MODEL",
+  "OPENAI_TTS_VOICE",
+  "PATH",
+  "PATHEXT",
+  "REPO_BOARD_HOME",
+  "REPO_BOARD_PROVIDER",
+  "REPO_BOARD_SESSION",
+  "REPO_BROWSER",
+  "REPO_E2E_KEEP",
+  "REPO_E2E_ROOT",
+  "REPO_E2E_TARBALL",
+  "SPEAK_PROVIDER",
+  "TURN_RECORD",
+  "TYPESAFE_API_KEY",
+  "USERPROFILE",
+  "WHISPER_MODEL",
+  "WORKSPACE_ACCOUNT",
+] as const;
+
+export type Env = { [Name in (typeof ENV_VARIABLES)[number]]?: string | undefined };
+
+/** Each variable is an optional string, unless a command cannot run without it. */
+function envSchema(): z.ZodType<Env, Record<string, unknown>> {
+  const text = z.string().optional();
+  return z.object(Object.fromEntries(ENV_VARIABLES.map((name) => [name, text])));
+}
+
+/** `repo: environment: <NAME>: <issue>`, one line per bad variable. */
+function describe(error: z.ZodError): string {
+  return error.issues.map((issue) => `repo: environment: ${issue.path.join(".")}: ${issue.message}`).join("\n");
+}
+
+/** The environment parsed against the schema; throws a line per bad variable. */
+export function readEnv(source: Record<string, unknown> = process.env): Env {
+  const parsed = envSchema().safeParse(source);
+  if (!parsed.success) throw new Error(describe(parsed.error));
+  return parsed.data;
+}
+
+/** A copy of the environment with `overrides` applied and every undefined value dropped, for spawn. */
+export function childEnv(overrides: Record<string, string | undefined> = {}): Record<string, string> {
+  const merged = { ...process.env, ...overrides };
+  return Object.fromEntries(
+    Object.entries(merged).filter((entry): entry is [string, string] => entry[1] !== undefined),
+  );
+}

package/cli/fixtures/base-config.ts

@@ -0,0 +1,13 @@
+import { DEFAULT_COMMIT, type ResolvedConfig } from "../config.ts";
+import { DEFAULT_NIGHTLY } from "../nightly-config.ts";
+import { DEFAULT_COVERAGE } from "../coverage-config.ts";
+
+/** The resolved-config keys a test rarely varies: the default commit limit, no lint.skip, no knip.ignore and the default coverage paths. */
+export const BASE_CONFIG: Pick<ResolvedConfig, "commit" | "lint" | "knip" | "coverage" | "nightly" | "tdd"> = {
+  commit: DEFAULT_COMMIT,
+  lint: { skip: [] },
+  knip: { ignore: [] },
+  coverage: DEFAULT_COVERAGE,
+  nightly: DEFAULT_NIGHTLY,
+  tdd: false,
+};

package/cli/fixtures/gate-world.ts

@@ -0,0 +1,48 @@
+import { gate } from "../release/gate.ts";
+import { spawnRunner } from "../scripts/ci-wait-run.ts";
+import type { Runner } from "../scripts/ci-wait.ts";
+import { commit, fakeGh, gitIn, NAME, type Behavior, type World } from "./release-world.ts";
+
+const CHANGELOG = (version: string): string =>
+  `# Changelog\n\n## [Unreleased]\n\n## [${version}] - 2026-11-09\n\n### Added\n\n- x\n\n## [0.1.0] - 2026-10-01\n\n### Added\n\n- first\n`;
+
+/** A gh that answers `repo view` with `branch` as the default branch (a failure for null) and the rest as the release world's. */
+export function ghFor(branch: string | null, behavior: Behavior = {}, calls: string[] = []): Runner {
+  const rest = fakeGh(behavior);
+  return (args, cwd) => {
+    calls.push(args.join(" "));
+    if (args[0] !== "repo") return rest(args, cwd);
+    const body = JSON.stringify({ defaultBranchRef: { name: branch } });
+    return branch === null ? { code: 1, stdout: "", stderr: "not found" } : { code: 0, stdout: body, stderr: "" };
+  };
+}
+
+/** What a release commit holds: the version in package.json, the tag's version, and whether it reaches origin. */
+export type Tagged = { version: string; tagVersion?: string; push?: boolean; changelog?: boolean };
+
+/** Commits `version` with its changelog section (unless `changelog` is false), tags it, and returns the short sha. */
+export function tagRelease(w: World, { version, tagVersion = version, push = true, changelog = true }: Tagged): string {
+  const files = { "package.json": { name: NAME, version }, ...(changelog ? { "CHANGELOG.md": CHANGELOG(version) } : {}) };
+  commit(w, `chore: release ${version}`, files, push);
+  gitIn(w.work, "tag", "-a", `${NAME}@${tagVersion}`, "-m", "t");
+  return gitIn(w.work, "rev-parse", "--short=7", "HEAD");
+}
+
+/** Runs `repo release gate` in the world's checkout with fakes of gh, the clock and the sleep. */
+export async function runGate(w: World, argv: string[], runner: Runner = ghFor("main")) {
+  const out: string[] = [];
+  const err: string[] = [];
+  let clock = 0;
+  const code = await gate(argv, {
+    cwd: w.work,
+    stdout: (s) => out.push(s),
+    stderr: (s) => err.push(s),
+    git: spawnRunner("git"),
+    gh: runner,
+    now: () => clock,
+    sleep: (ms) => ((clock += ms), Promise.resolve()),
+  });
+  return { code, out: out.join(""), err: err.join("") };
+}
+
+export const refused = (line: string) => ({ code: 1, out: "", err: `repo release gate: ${line}\n` });

package/cli/fixtures/knip-run.ts

@@ -0,0 +1,38 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import type { KnipRun } from "../knip-check.ts";
+import type { Workspace } from "../sync/workspace.ts";
+
+const dirs: string[] = [];
+
+/** Removes every root `knipRoot` made; call it from an `afterEach`. */
+export function removeKnipRoots(): void {
+  for (const dir of dirs.splice(0)) fs.rmSync(dir, { recursive: true, force: true });
+}
+
+/** A temp root holding `files` (path to text) and a manifest declaring `dependencies`, as its workspace. */
+export function knipRoot(files: Record<string, string>, dependencies: Record<string, string> = {}): Workspace {
+  const root = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), "workerstack-knip-")));
+  dirs.push(root);
+  const manifest = { name: "app", dependencies };
+  const all = { "package.json": JSON.stringify({ ...manifest, type: "module" }), ...files };
+  for (const [rel, text] of Object.entries(all)) {
+    fs.mkdirSync(path.dirname(path.join(root, rel)), { recursive: true });
+    fs.writeFileSync(path.join(root, rel), text);
+  }
+  return { root, manifest, packages: [] };
+}
+
+/** One knip json report: per file, the issues by type. */
+export const report = (...issues: Record<string, unknown>[]): string => JSON.stringify({ issues });
+
+/** A runner that answers with `stdout`, `code` and `stderr`, and records the arguments and cwd it was called with. */
+export function answering(stdout: string, code = 0, stderr = ""): KnipRun & { calls: [string[], string][] } {
+  const calls: [string[], string][] = [];
+  const run = (args: string[], cwd: string) => {
+    calls.push([args, cwd]);
+    return { code, stdout, stderr };
+  };
+  return Object.assign(run, { calls });
+}

package/cli/fixtures/mutate-fakes.ts

@@ -0,0 +1,137 @@
+import path from "node:path";
+import type { Captured } from "../scripts/lint.ts";
+import type { MutateConfig, MutateDeps } from "../mutate-deps.ts";
+
+export const SHA = "09ed564aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
+/** The repo root, a native absolute path (`C:\repo` on Windows). */
+export const ROOT = path.resolve("/repo");
+/** A native absolute path under the repo root. */
+export const at = (...parts: string[]): string => path.join(ROOT, ...parts);
+/** A native absolute path outside the repo, where a test asks for its report. */
+export const OUT = path.resolve("/out/m.json");
+export const BASE = path.resolve("/tmp/workerstack-mutate-1");
+export const CLONE = path.join(BASE, "repo");
+export const STRYKER_PKG = path.join(CLONE, "node_modules/@stryker-mutator/core/package.json");
+export const RUNNER_PKG = path.join(CLONE, "node_modules/@stryker-mutator/vitest-runner/package.json");
+const OK: Captured = { code: 0, stdout: "", stderr: "" };
+
+export type Sim = {
+  tracked: string[];
+  dirty: boolean;
+  /** The sources of the clone, by root-relative path. */
+  sources: Record<string, string>;
+  installed: boolean;
+  gitFails: string | null;
+  installFails: boolean;
+  /** What a Stryker run does: its exit, its output and the raw report it leaves. */
+  stryker: { code: number; output: string; report: unknown };
+  config: MutateConfig | string[];
+};
+
+const rawReport = (files: Record<string, string[]>) => ({
+  files: Object.fromEntries(
+    Object.entries(files).map(([file, statuses]) => [
+      file,
+      {
+        mutants: statuses.map((status, i) => ({
+          status,
+          mutatorName: "ArithmeticOperator",
+          location: { start: { line: i + 1, column: 2 } },
+        })),
+      },
+    ]),
+  ),
+});
+
+export function sim(over: Partial<Sim> = {}): Sim {
+  return {
+    tracked: ["src/a.ts", "src/b.ts", "src/a.test.ts", "src/fixtures/c.ts", "src/types.d.ts", "docs/x.ts"],
+    dirty: false,
+    sources: { "src/a.ts": "a\n".repeat(30), "src/b.ts": "b\n".repeat(10) },
+    installed: true,
+    gitFails: null,
+    installFails: false,
+    stryker: { code: 0, output: "", report: rawReport({ "src/a.ts": ["Killed", "Survived"], "src/b.ts": ["Killed"] }) },
+    config: { root: ROOT, mutate: ["src/**/*.ts"], floors: "mutation-floors.json" },
+    ...over,
+  };
+}
+
+export { rawReport };
+
+export type Fakes = { deps: MutateDeps; calls: string[]; out: string[]; err: string[]; files: Map<string, string> };
+
+type RawReport = { files?: Record<string, unknown> };
+type StrykerConfig = { mutate: string[]; jsonReporter: { fileName: string } };
+
+/** The raw report a Stryker run leaves: the planned one, cut to the files the run's config mutates. */
+function leave(state: Sim, files: Map<string, string>, configPath: string): void {
+  const config = JSON.parse(files.get(configPath) ?? "{}") /* the config the command wrote */ as StrykerConfig;
+  const planned = state.stryker.report as /* the test plants an object */ RawReport;
+  const mutated = Object.entries(typeof planned.files === "object" ? planned.files : {}).filter(([file]) => config.mutate.includes(file));
+  const planted = typeof planned.files === "object";
+  const report = planted ? { files: Object.fromEntries(mutated) } : planned;
+  files.set(config.jsonReporter.fileName, JSON.stringify(report));
+}
+
+function gitOf(state: Sim, calls: string[]): MutateDeps["git"] {
+  return (_cwd, args) => {
+    calls.push(`git ${args.join(" ")}`);
+    if (state.gitFails !== null && args.includes(state.gitFails)) return { code: 128, stdout: "", stderr: "boom\n" };
+    if (args[0] === "rev-parse") return { ...OK, stdout: `${SHA}\n` };
+    if (args[0] === "status") return { ...OK, stdout: state.dirty ? " M src/a.ts\n" : "" };
+    if (args[0] === "ls-tree") return { ...OK, stdout: `${state.tracked.join("\n")}\n` };
+    return OK;
+  };
+}
+
+function runOf(state: Sim, calls: string[], files: Map<string, string>): MutateDeps["run"] {
+  return (args, cwd) => {
+    calls.push(`bun ${args.join(" ")} @${cwd}`);
+    if (args[0] === "install") return state.installFails ? { code: 1, stdout: "", stderr: "lock\n" } : OK;
+    leave(state, files, args.at(-1) ?? "");
+    return { code: state.stryker.code, stdout: state.stryker.output, stderr: "" };
+  };
+}
+
+export function fakes(state: Sim = sim(), packages: string[] = []): Fakes {
+  const calls: string[] = [];
+  const files = new Map<string, string>();
+  const out: string[] = [];
+  const err: string[] = [];
+  const git = gitOf(state, calls);
+  const run = runOf(state, calls, files);
+  const deps: MutateDeps = {
+    cwd: ROOT,
+    config: async () => state.config,
+    packages: () => packages,
+    git,
+    run,
+    preload: "/pkg/cli/stryker-preload.ts",
+    out: (text) => out.push(text),
+    err: (text) => err.push(text),
+    fs: {
+      mkdtemp: (prefix) => {
+        calls.push(`mkdtemp ${prefix}`);
+        return BASE;
+      },
+      rm: (target) => {
+        calls.push(`rm ${target}`);
+        for (const key of [...files.keys()]) if (key.startsWith(target)) files.delete(key);
+      },
+      read: (file) => {
+        if (file === STRYKER_PKG || file === RUNNER_PKG) {
+          return state.installed ? JSON.stringify({ bin: { stryker: "bin/stryker.js" } }) : null;
+        }
+        const source = state.sources[path.relative(CLONE, file).replaceAll(path.sep, "/")];
+        return files.get(file) ?? source ?? null;
+      },
+      write: (file, text) => void files.set(file, text),
+      list: (dir) => {
+        const names = [...files.keys()].filter((k) => k.startsWith(`${dir}${path.sep}`)).map((k) => k.slice(dir.length + 1));
+        return names.length > 0 ? names : null;
+      },
+    },
+  };
+  return { deps, calls, out, err, files };
+}

package/cli/fixtures/planted-repo.ts

@@ -0,0 +1,50 @@
+import { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { childEnv } from "../env.ts";
+import { toolEnv } from "../scripts/lint.ts";
+
+const dirs: string[] = [];
+
+/** Removes every repo `tempDir` made; call it from an `afterEach`. */
+export function removePlanted(): void {
+  for (const dir of dirs.splice(0)) fs.rmSync(dir, { recursive: true, force: true });
+}
+
+const env = toolEnv(childEnv());
+
+/** Runs git in `cwd` with a committer identity and no signing. */
+export const git = (cwd: string, ...args: string[]) =>
+  execFileSync("git", ["-c", "user.name=t", "-c", "user.email=t@t", "-c", "commit.gpgsign=false", ...args], {
+    cwd,
+    env,
+    encoding: "utf8",
+  });
+
+/** A new temp dir, removed by `removePlanted`. */
+export function tempDir(): string {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "check-ratchets-"));
+  dirs.push(dir);
+  return dir;
+}
+
+/** Writes `files` (path → text, objects as JSON) under `dir`. */
+export function write(dir: string, files: Record<string, unknown>): void {
+  for (const [rel, content] of Object.entries(files)) {
+    fs.mkdirSync(path.dirname(path.join(dir, rel)), { recursive: true });
+    const text = typeof content === "string" ? content : `${JSON.stringify(content, null, 2)}\n`;
+    fs.writeFileSync(path.join(dir, rel), text);
+  }
+}
+
+/** A repo whose `main` commit holds `files`, with a `feature` branch checked out. */
+export function repoOnMain(files: Record<string, unknown>): string {
+  const dir = tempDir();
+  git(dir, "init", "-q", "-b", "main");
+  write(dir, files);
+  git(dir, "add", "-A");
+  git(dir, "commit", "-q", "-m", "main");
+  git(dir, "checkout", "-q", "-b", "feature");
+  return dir;
+}

package/cli/fixtures/publish-world.ts

@@ -0,0 +1,71 @@
+import { releasePublish } from "../release/publish.ts";
+import { spawnRunner } from "../scripts/ci-wait-run.ts";
+import type { Runner } from "../scripts/ci-wait.ts";
+import { NAME, type World } from "./release-world.ts";
+
+const DOC_URL = "https://registry.npmjs.org/@acme%2fapp";
+const ok = (stdout = "") => ({ code: 0, stdout, stderr: "" });
+
+/** What the fake registry holds: the package, a listed version, and how many tarball requests answer 404 first or fail. */
+export type Registry = { exists: boolean; listed: boolean; notServed: number; offline?: number; docFails?: number };
+/** What the fake npm does on `publish`: its exit code, and whether the version is listed afterwards. */
+export type Npm = { code: number; lists: boolean };
+export type Options = { ci?: boolean; npm?: Npm; packed?: { name: string; version: string }; bun?: Runner };
+
+/** A fetch over `registry` for `version` that records the urls it was asked for. */
+function registryFetch(registry: Registry, version: string, urls: string[]): (url: string) => Promise<Response> {
+  return (url) => {
+    urls.push(url);
+    if (url === DOC_URL && (registry.docFails ?? 0) > 0) {
+      registry.docFails = (registry.docFails ?? 0) - 1;
+      return Promise.resolve(new Response("down", { status: 503 }));
+    }
+    if (url === DOC_URL) {
+      const body = registry.exists
+        ? { versions: registry.listed ? { [version]: {} } : { "0.0.1": {} }, "dist-tags": { latest: "0.0.1" } }
+        : {};
+      return Promise.resolve(new Response(JSON.stringify(body), { status: registry.exists ? 200 : 404 }));
+    }
+    if ((registry.offline ?? 0) > 0) {
+      registry.offline = (registry.offline ?? 0) - 1;
+      return Promise.reject(new Error("offline"));
+    }
+    const served = registry.notServed <= 0;
+    registry.notServed -= 1;
+    return Promise.resolve(new Response("tgz", { status: served ? 200 : 404 }));
+  };
+}
+
+/** Runs `release publish` in the world's checkout against fakes of bun, tar, npm and the registry. */
+export async function publish(w: World, argv: string[], registry: Registry, options: Options = {}) {
+  const version = (argv[0] ?? "").split("@").pop() ?? "";
+  const out: string[] = [];
+  const err: string[] = [];
+  const npmCalls: string[] = [];
+  const urls: string[] = [];
+  const sleeps: number[] = [];
+  const bunCalls: string[] = [];
+  const npm: Runner = (args) => {
+    npmCalls.push(args.join(" "));
+    registry.listed = registry.listed || (options.npm?.lists ?? true);
+    return { code: options.npm?.code ?? 0, stdout: "", stderr: "" };
+  };
+  let clock = 0;
+  const code = await releasePublish(argv, {
+    cwd: w.work,
+    stdout: (s) => out.push(s),
+    stderr: (s) => err.push(s),
+    git: spawnRunner("git"),
+    bun: options.bun ?? ((args) => (bunCalls.push(args.join(" ")), ok())),
+    tar: () => ok(JSON.stringify(options.packed ?? { name: NAME, version })),
+    npm,
+    fetch: registryFetch(registry, version, urls),
+    now: () => clock,
+    sleep: (ms) => ((clock += ms), sleeps.push(ms), Promise.resolve()),
+    ci: options.ci ?? false,
+    tmp: "/tmp",
+    mkdtemp: (prefix) => `${prefix}x1`,
+    list: () => [`acme-app-${version}.tgz`],
+  });
+  return { code, out: out.join(""), err: err.join(""), npmCalls, bunCalls, urls, sleeps };
+}

package/cli/fixtures/red-proof-repo.ts

@@ -0,0 +1,72 @@
+import fs from "node:fs";
+import path from "node:path";
+import { git, tempDir, write } from "./planted-repo.ts";
+import type { RedProofResult, VitestRun } from "../red-proof.ts";
+
+/** This checkout's installed modules, which a planted repo links so its vitest resolves. */
+export const CHECKOUT_MODULES = path.resolve(import.meta.dirname, "..", "..", "node_modules");
+
+/** A test file body that passes (`ok`) or fails (`red`), importing `./x.ts` when `useX` is set. */
+export const PASS = `import { expect, it } from "vitest";\nit("p", () => expect(1).toBe(1));\n`;
+export const FAIL = `import { expect, it } from "vitest";\nit("f", () => expect(1).toBe(2));\n`;
+export const NEEDS_X = `import { expect, it } from "vitest";\nimport { x } from "./x.ts";\nit("x", () => expect(x()).toBe(1));\n`;
+
+/** Links the checkout's modules into `dir` so vitest resolves from there. */
+export function linkModules(dir: string): void {
+  fs.symlinkSync(CHECKOUT_MODULES, path.join(dir, "node_modules"));
+}
+
+/** A planted repo with one commit holding `files` (plus a package.json and a .gitignore), modules linked in. */
+export function plant(files: Record<string, unknown>, rootManifest = true): string {
+  const dir = tempDir();
+  git(dir, "init", "-q", "-b", "main");
+  write(dir, { ".gitignore": "node_modules\n.tmp\n", ...(rootManifest ? { "package.json": { name: "p" } } : {}) });
+  write(dir, files);
+  linkModules(dir);
+  git(dir, "add", "-A");
+  git(dir, "commit", "-q", "-m", "base");
+  return dir;
+}
+
+/** A planted repo with no commit yet. */
+export function plantUnborn(files: Record<string, unknown>): string {
+  const dir = tempDir();
+  git(dir, "init", "-q", "-b", "main");
+  write(dir, files);
+  git(dir, "add", "-A");
+  return dir;
+}
+
+/** Writes `files` and stages everything. */
+export function stage(dir: string, files: Record<string, unknown>): void {
+  write(dir, files);
+  git(dir, "add", "-A");
+}
+
+/** The name-status of the staged change, as `status\tpath` lines. */
+export const staged = (dir: string): string => git(dir, "diff", "--cached", "--name-status", "--no-renames");
+
+/** The vitest runner stand-in: calls `onRun` with the cwd and args, writes a report failing the files `fails` names. */
+export function fakeVitest(
+  fails: (file: string, cwd: string) => boolean,
+  onRun: (cwd: string, args: string[]) => void = () => undefined,
+): VitestRun {
+  return (args, cwd) => {
+    onRun(cwd, args);
+    const output = outputOf(args);
+    const files = args.filter((arg) => arg !== "run" && !arg.startsWith("-"));
+    const testResults = files.map((file) => ({
+      name: path.join(cwd, file),
+      status: fails(file, cwd) ? "failed" : "passed",
+    }));
+    fs.writeFileSync(output, JSON.stringify({ testResults }));
+    return { code: testResults.some((r) => r.status === "failed") ? 1 : 0, stderr: "" };
+  };
+}
+
+/** The problem a refusal carries, or an empty string for a pass. */
+export const problemOf = (result: RedProofResult): string => ("problem" in result ? result.problem : "");
+
+/** The `--outputFile=` path vitest was asked to write. */
+export const outputOf = (args: string[]): string =>
+  args.filter((arg) => arg.startsWith("--outputFile=")).join("").slice("--outputFile=".length);

package/cli/fixtures/release-context.ts

@@ -0,0 +1,15 @@
+import { BASE_CONFIG } from "./base-config.ts";
+import type { Pack } from "../config.ts";
+import type { SyncContext } from "../sync/outputs.ts";
+import type { PackageJson } from "../sync/workspace.ts";
+
+export const HEADER = "# Generated by repo sync. Do not edit.";
+
+export function context(packs: Pack[], manifest: PackageJson = {}, files: Record<string, string> = {}): SyncContext {
+  return {
+    root: "/repo",
+    config: { packs, agents: { hosts: [], skills: [] }, ...BASE_CONFIG },
+    workspace: { root: "/repo", manifest, packages: [] },
+    read: (rel) => files[rel] ?? null,
+  };
+}