@workerstack/repo 0.0.0-stage → 0.1.0

package/cli/mutate-edges.test.ts

@@ -0,0 +1,150 @@
+import fs from "node:fs";
+import path from "node:path";
+import { afterEach, expect, it, vi } from "vitest";
+import { BASE, OUT, STRYKER_PKG, at, fakes, sim } from "./fixtures/mutate-fakes.ts";
+import { git, removePlanted, repoOnMain, tempDir } from "./fixtures/planted-repo.ts";
+import { main, runMutate } from "./mutate.ts";
+import { realDeps, realFs } from "./mutate-real-deps.ts";
+
+afterEach(removePlanted);
+
+it("runs git in its own repo with a hook's GIT_DIR and GIT_INDEX_FILE planted, and leaves the other repo alone", () => {
+  const other = repoOnMain({ "a.txt": "a\n" });
+  const source = repoOnMain({ "b.txt": "b\n" });
+  const planted = path.join(other, ".git", "planted-index");
+  vi.stubEnv("GIT_DIR", path.join(other, ".git"));
+  vi.stubEnv("GIT_INDEX_FILE", planted);
+  const deps = realDeps(source);
+  const clone = path.join(tempDir(), "clone");
+  const sha = deps.git(source, ["rev-parse", "HEAD"]).stdout.trim();
+  expect(sha).toBe(git(source, "rev-parse", "HEAD").trim());
+  expect(deps.git(source, ["clone", "-q", "--shared", source, clone]).code).toBe(0);
+  expect(deps.git(source, ["-C", clone, "checkout", "-q", "--detach", sha]).code).toBe(0);
+  expect(fs.readFileSync(path.join(clone, "b.txt"), "utf8").replaceAll("\r\n", "\n")).toBe("b\n"); // autocrlf may check out CRLF
+  expect(fs.existsSync(planted)).toBe(false);
+  vi.unstubAllEnvs();
+  expect(git(other, "status", "--porcelain")).toBe("");
+  expect(git(source, "status", "--porcelain")).toBe("");
+});
+
+it("reports a missing git or dir as a failed run instead of throwing", () => {
+  const run = realDeps("/").git(path.join(tempDir(), "missing"), ["status"]);
+  expect(run.code).not.toBe(0);
+  expect(run.stderr).not.toBe("");
+});
+
+it("reads and writes files, lists a dir, and tells a missing file and dir from an empty one", () => {
+  const real = realFs;
+  const dir = tempDir();
+  expect([real.read(path.join(dir, "x/y.json")), real.list(path.join(dir, "x"))]).toEqual([null, null]);
+  real.write(path.join(dir, "x/y.json"), "{}");
+  expect([real.read(path.join(dir, "x/y.json")), real.list(path.join(dir, "x"))]).toEqual(["{}", ["y.json"]]);
+  const base = real.mkdtemp("workerstack-mutate-test-");
+  expect(path.basename(base)).toMatch(/^workerstack-mutate-test-/);
+  real.rm(base);
+  expect(fs.existsSync(base)).toBe(false);
+});
+
+it("finds the config of the repo above cwd, its errors, and no config", async () => {
+  const root = tempDir();
+  fs.writeFileSync(path.join(root, "workerstack.config.ts"), 'export default { coverage: { mutate: ["lib/**"] } };\n');
+  fs.mkdirSync(path.join(root, "deep"));
+  expect(await realDeps(path.join(root, "deep")).config(path.join(root, "deep"))).toEqual({
+    root: fs.realpathSync(root),
+    mutate: ["lib/**"],
+    floors: "mutation-floors.json",
+  });
+  fs.writeFileSync(path.join(root, "workerstack.config.ts"), "export default { coverage: 5 };\n");
+  const bad = await realDeps(root).config(root);
+  expect(Array.isArray(bad) && bad[0]).toMatch(/^workerstack.config.ts: coverage/);
+  const none = await realDeps(tempDir()).config(tempDir());
+  expect(Array.isArray(none) && none[0]).toMatch(/^no workerstack.config.ts in/);
+});
+
+it("lists workspace package dirs, none for an unreadable manifest", () => {
+  const root = tempDir();
+  fs.writeFileSync(path.join(root, "package.json"), JSON.stringify({ workspaces: ["packages/*"] }));
+  fs.mkdirSync(path.join(root, "packages/a"), { recursive: true });
+  fs.writeFileSync(path.join(root, "packages/a/package.json"), "{}");
+  expect(realDeps(root).packages(root)).toEqual(["packages/a"]);
+  fs.writeFileSync(path.join(root, "package.json"), "[");
+  expect(realDeps(root).packages(root)).toEqual([]);
+});
+
+const args = ["--shard", "1/2", "--report", OUT];
+
+it.each(["{", "{}"])("treats a Stryker manifest %j as a missing install", async (manifest) => {
+  const f = fakes(sim());
+  const read = f.deps.fs.read;
+  f.deps.fs.read = (file) => (file === STRYKER_PKG ? manifest : read(file));
+  expect(await runMutate(args, f.deps)).toBe(1);
+  expect(f.err.join("")).toContain("install the mutation tool first");
+});
+
+it("takes a bin written as a string", async () => {
+  const f = fakes(sim());
+  const read = f.deps.fs.read;
+  f.deps.fs.read = (file) => (file === STRYKER_PKG ? '{"bin":"bin/s.js"}' : read(file));
+  expect(await runMutate(args, f.deps)).toBe(0);
+  expect(f.calls.some((c) => c.includes(path.join("core", "bin", "s.js")))).toBe(true);
+});
+
+it("refuses a raw report that is no JSON", async () => {
+  const f = fakes(sim());
+  f.deps.run = (a) => {
+    if (a[0] !== "install") f.deps.fs.write(path.join(BASE, "stryker-report.json"), "{");
+    return { code: 0, stdout: "", stderr: "" };
+  };
+  expect(await runMutate(args, f.deps)).toBe(1);
+  expect(f.err.join("")).toMatch(/Stryker wrote no readable report: .*JSON/);
+});
+
+it("says a failed install's stdout when its stderr is empty", async () => {
+  const f = fakes(sim());
+  f.deps.run = () => ({ code: 1, stdout: "lockfile had changes\n", stderr: "" });
+  expect(await runMutate(args, f.deps)).toBe(1);
+  expect(f.err.join("")).toBe("repo mutate: bun install --frozen-lockfile failed in the clone: lockfile had changes\n");
+});
+
+it("counts a tracked file the clone lacks as one empty line", async () => {
+  const f = fakes(sim({ tracked: ["src/a.ts", "src/b.ts", "src/gone.ts"] }));
+  expect(await runMutate(["--shard", "2/2", "--report", OUT], f.deps)).toBe(0);
+  expect(f.out.join("")).toContain("2 files, shard 2/2");
+});
+
+it("writes through the process streams, and main runs in the current directory", async () => {
+  const stdout = vi.spyOn(process.stdout, "write").mockReturnValue(true);
+  const stderr = vi.spyOn(process.stderr, "write").mockReturnValue(true);
+  try {
+    const deps = realDeps("/");
+    deps.out("to stdout\n");
+    deps.err("to stderr\n");
+    expect(await main(["--fast"])).toBe(1);
+    expect(stdout.mock.calls).toEqual([["to stdout\n"]]);
+    expect(stderr.mock.calls.map(([text]) => String(text))).toEqual([
+      "to stderr\n",
+      'repo mutate: unknown argument "--fast"; use --shard i/n, --report <file> or check <dir>\n',
+    ]);
+  } finally {
+    stdout.mockRestore();
+    stderr.mockRestore();
+  }
+});
+
+it("resolves a typed --report and check dir against the current directory, the default report against the root", async () => {
+  const run = fakes(sim());
+  run.deps.cwd = at("sub");
+  expect(await runMutate(["--shard", "1/2", "--report", "out/m.json"], run.deps)).toBe(0);
+  expect(run.files.has(at("sub", "out", "m.json"))).toBe(true);
+  expect(run.out.join("")).toContain("in out/m.json");
+  const whole = fakes(sim());
+  whole.deps.cwd = at("sub");
+  await runMutate([], whole.deps);
+  expect(whole.files.has(at(".tmp/repo/mutation/report.json"))).toBe(true);
+  const report = JSON.stringify({ head: "09ed564aaaa", shard: { index: 1, total: 1 }, files: {} });
+  const check = fakes(sim());
+  check.deps.cwd = at("sub");
+  check.files.set(at("sub", "reports", "mutation-1.json"), report);
+  expect(await runMutate(["check", "reports"], check.deps)).toBe(0);
+  expect(check.out.join("")).toContain("1 shard of 09ed564");
+});

package/cli/mutate-files.test.ts

@@ -0,0 +1,100 @@
+import { expect, it } from "vitest";
+import { parseArgs } from "./mutate-args.ts";
+import { selectFiles, splitShards } from "./mutate-files.ts";
+
+it("keeps the tracked files matching a glob, minus tests, fixtures and declaration files, sorted", () => {
+  const tracked = [
+    "src/z.ts",
+    "src/a.ts",
+    "src/a.test.ts",
+    "src/a.spec.tsx",
+    "src/fixtures/c.ts",
+    "src/deep/fixtures/d.ts",
+    "src/types.d.ts",
+    "lib/x.ts",
+    "docs/y.ts",
+  ];
+  expect(selectFiles(tracked, ["src/**/*.ts", "lib/*.ts"])).toEqual(["lib/x.ts", "src/a.ts", "src/z.ts"]);
+});
+
+it("returns nothing when no glob matches", () => {
+  expect(selectFiles(["a.ts"], ["src/**/*.ts"])).toEqual([]);
+});
+
+const lines = new Map([
+  ["a.ts", 50],
+  ["b.ts", 30],
+  ["c.ts", 30],
+  ["d.ts", 20],
+  ["e.ts", 10],
+]);
+
+it("balances the shards by line count and keeps each shard sorted", () => {
+  const shards = [1, 2].map((index) => splitShards([...lines.keys()], lines, { index, total: 2 }));
+  expect(shards).toEqual([
+    ["a.ts", "d.ts"],
+    ["b.ts", "c.ts", "e.ts"],
+  ]);
+});
+
+it("gives every file to exactly one shard, whatever the order it arrives in", () => {
+  const names = [...lines.keys()].reverse();
+  const all = [1, 2, 3].flatMap((index) => splitShards(names, lines, { index, total: 3 }));
+  expect(all.toSorted()).toEqual([...lines.keys()]);
+  expect(splitShards(names, lines, { index: 1, total: 3 })).toEqual(
+    splitShards([...lines.keys()], lines, { index: 1, total: 3 }),
+  );
+});
+
+it("hands one shard everything when there is one, and nothing to a shard past the files", () => {
+  expect(splitShards([...lines.keys()], lines, { index: 1, total: 1 })).toHaveLength(5);
+  expect(splitShards(["a.ts"], lines, { index: 2, total: 2 })).toEqual([]);
+});
+
+it("defaults to one full run with the default report", () => {
+  expect(parseArgs([])).toEqual({
+    kind: "run",
+    shard: { index: 1, total: 1 },
+    report: undefined,
+  });
+});
+
+it("reads --shard and --report, as two words or with =", () => {
+  expect(parseArgs(["--shard", "2/8", "--report", "r/m.json"])).toEqual({
+    kind: "run",
+    shard: { index: 2, total: 8 },
+    report: "r/m.json",
+  });
+  expect(parseArgs(["--shard=3/4", "--report=x.json"])).toMatchObject({ shard: { index: 3, total: 4 } });
+});
+
+it.each(["0/8", "9/8", "a/b", "2", "2/0", "1/2/3", ""])("refuses --shard %j", (value) => {
+  expect(parseArgs(["--shard", value])).toEqual({
+    kind: "error",
+    line: "--shard takes i/n with 1 <= i <= n, such as 2/8",
+  });
+});
+
+it("refuses --shard and --report without a value", () => {
+  expect(parseArgs(["--shard"])).toMatchObject({ kind: "error" });
+  expect(parseArgs(["--report"])).toEqual({ kind: "error", line: "--report takes a file path" });
+});
+
+it("reads check <dir> with and without --write", () => {
+  expect(parseArgs(["check", "reports"])).toEqual({ kind: "check", dir: "reports", write: false });
+  expect(parseArgs(["check", "reports", "--write"])).toEqual({ kind: "check", dir: "reports", write: true });
+  expect(parseArgs(["check", "--write", "reports"])).toEqual({ kind: "check", dir: "reports", write: true });
+});
+
+it("refuses check without a dir and anything it does not know", () => {
+  expect(parseArgs(["check"])).toEqual({ kind: "error", line: "check takes the dir of the shard reports" });
+  expect(parseArgs(["--fast"])).toEqual({
+    kind: "error",
+    line: 'unknown argument "--fast"; use --shard i/n, --report <file> or check <dir>',
+  });
+});
+
+it("weighs a file with no line count as nothing", () => {
+  const known = new Map([["a.ts", 5]]);
+  expect(splitShards(["a.ts", "ghost.ts"], known, { index: 2, total: 2 })).toEqual(["ghost.ts"]);
+});

package/cli/mutate-files.ts

@@ -0,0 +1,31 @@
+/** Which files `repo mutate` mutates, and how a run splits them into shards. */
+import path from "node:path";
+import { EXCLUDED } from "./mutate.constants.ts";
+import type { Shard } from "./mutate-args.ts";
+
+/** The tracked files matching one of `globs`, minus tests, fixtures and declaration files, sorted. */
+export function selectFiles(tracked: readonly string[], globs: readonly string[]): string[] {
+  return tracked
+    .filter((file) => globs.some((glob) => path.matchesGlob(file, glob)))
+    .filter((file) => !EXCLUDED.some((pattern) => pattern.test(file)))
+    .toSorted();
+}
+
+/** A shard being filled: its place, the lines handed to it so far and its files. */
+type Bin = { index: number; load: number; taken: string[] };
+
+/**
+ * The files of one shard: the sorted files, heaviest first, each handed to the lightest shard so far (the lowest
+ * index on a tie), so the same list always splits the same way and the shards stay near equal in lines.
+ */
+export function splitShards(files: readonly string[], lines: ReadonlyMap<string, number>, shard: Shard): string[] {
+  const size = (file: string) => lines.get(file) ?? 0;
+  const heaviest = files.toSorted((a, b) => size(b) - size(a) || a.localeCompare(b));
+  const shards = Array.from({ length: shard.total }, (_, at): Bin => ({ index: at + 1, load: 0, taken: [] }));
+  for (const file of heaviest) {
+    const lightest = shards.reduce((best, next) => (next.load < best.load ? next : best));
+    lightest.load += size(file);
+    lightest.taken.push(file);
+  }
+  return shards.flatMap((one) => (one.index === shard.index ? one.taken.toSorted() : []));
+}

package/cli/mutate-floors.test.ts

@@ -0,0 +1,91 @@
+import { expect, it } from "vitest";
+import { ROOT, at, fakes, rawReport, sim } from "./fixtures/mutate-fakes.ts";
+import { runMutate } from "./mutate.ts";
+import { packageOf, percentOf, tally } from "./mutate-floors.ts";
+
+const survivor = { line: 1, column: 1, mutator: "m", status: "Survived" } as const;
+
+it("scores killed over killed plus survivors, so errors, ignored and compile errors weigh nothing", () => {
+  const files = {
+    "a.ts": { killed: 8, survivors: [survivor, { ...survivor, status: "NoCoverage" as const }] },
+  };
+  const [score] = [...tally(files, []).values()];
+  expect(percentOf(score ?? { killed: 0, survivors: 0 })).toBe(80);
+});
+
+it("scores a package with no scored mutant as 100", () => {
+  expect(percentOf({ killed: 0, survivors: 0 })).toBe(100);
+});
+
+it("attributes a file to the deepest package dir holding it, else the root", () => {
+  const packages = ["packages/a", "packages/a/inner", "packages/ab"];
+  expect(packageOf("packages/a/src/x.ts", packages)).toBe("packages/a");
+  expect(packageOf("packages/a/inner/x.ts", packages)).toBe("packages/a/inner");
+  expect(packageOf("packages/ab/x.ts", packages)).toBe("packages/ab");
+  expect(packageOf("packages/other/x.ts", packages)).toBe(".");
+  const files = { "packages/a/x.ts": { killed: 1, survivors: [] }, "y.ts": { killed: 3, survivors: [survivor] } };
+  expect(Object.fromEntries(tally(files, packages))).toEqual({
+    "packages/a": { killed: 1, survivors: 0 },
+    ".": { killed: 3, survivors: 1 },
+  });
+});
+
+const TRACKED = ["packages/a/src/x.ts", "src/y.ts"];
+const FILES = { "packages/a/src/x.ts": "x\n", "src/y.ts": "y\n" };
+const REPORT = ".tmp/repo/mutation/report.json";
+
+function unsharded(floors: Record<string, number> | string | null) {
+  const report = rawReport({
+    "packages/a/src/x.ts": ["Killed", "Killed", "Timeout", "Survived", "CompileError"],
+    "src/y.ts": ["Killed", "NoCoverage"],
+  });
+  const config = { root: ROOT, mutate: ["**/src/*.ts"], floors: "mf.json" };
+  const f = fakes(sim({ tracked: TRACKED, sources: FILES, config, stryker: { code: 0, output: "", report } }), [
+    "packages/a",
+  ]);
+  if (floors !== null) f.files.set(at("mf.json"), typeof floors === "string" ? floors : JSON.stringify(floors));
+  return f;
+}
+
+it("prints each package's score against its floor and passes at or above every floor", async () => {
+  const f = unsharded({ ".": 50, "packages/a": 75 });
+  expect(await runMutate([], f.deps)).toBe(0);
+  expect(f.out.slice(1)).toEqual([
+    "mutate: 2 files, shard 1/1\n",
+    `mutate: . 50.00% (floor 50), 1 survivor in ${REPORT}\n`,
+    `mutate: packages/a 75.00% (floor 75), 1 survivor in ${REPORT}\n`,
+  ]);
+  expect(f.err).toEqual([]);
+  expect(JSON.parse(f.files.get(at(REPORT)) ?? "")).toMatchObject({ shard: { index: 1, total: 1 } });
+});
+
+it("fails a package below its floor, naming the floors file and the report", async () => {
+  const f = unsharded({ ".": 51, "packages/a": 75 });
+  expect(await runMutate([], f.deps)).toBe(1);
+  expect(f.err).toEqual([
+    `repo mutate: . scored 50.00%, below its floor of 51 in mf.json; see the survivors in ${REPORT}\n`,
+  ]);
+});
+
+it("holds a package with no floor to none, and runs with no floors file", async () => {
+  const f = unsharded(null);
+  expect(await runMutate([], f.deps)).toBe(0);
+  expect(f.out[2]).toBe(`mutate: . 50.00% (no floor), 1 survivor in ${REPORT}\n`);
+});
+
+it("refuses a floors file that is not a table of numbers", async () => {
+  const bad = unsharded('{ ".": "high" }');
+  expect(await runMutate([], bad.deps)).toBe(1);
+  expect(bad.err.join("")).toMatch(/^repo mutate: mf.json is not a floors file: .+\n$/);
+  const json = unsharded("{");
+  expect(await runMutate([], json.deps)).toBe(1);
+  expect(json.err.join("")).toContain("mf.json is not a floors file");
+});
+
+it("treats --shard 1/1 as the whole run and checks no floor for a real shard", async () => {
+  const whole = unsharded({ ".": 99 });
+  expect(await runMutate(["--shard", "1/1"], whole.deps)).toBe(1);
+  const part = unsharded({ ".": 99 });
+  expect(await runMutate(["--shard", "1/2"], part.deps)).toBe(0);
+  expect(part.err).toEqual([]);
+});

package/cli/mutate-floors.ts

@@ -0,0 +1,104 @@
+/** Scores per package and the floors they are held to: the formula, the floors file, and one run's verdict. */
+import path from "node:path";
+import { z } from "zod";
+import { fail, type MutateConfig, type MutateDeps } from "./mutate-deps.ts";
+import { parseJson, type FileScore, type Parsed, type ShardReport } from "./mutate-report.ts";
+import { ARROW, NEWLINE, OK, PERCENT, PERCENT_DIGITS, ROOT_PACKAGE } from "./mutate.constants.ts";
+
+/** A package's mutants: how many tests killed and how many lived. */
+export type Tally = { killed: number; survivors: number };
+/** The mutation score floors by package dir. */
+export type Floors = Record<string, number>;
+/** A package's score against its floor. */
+export type Verdict = { pkg: string; percent: number; floor: number | undefined; survivors: number };
+
+const buildFloorsSchema = () => z.record(z.string(), z.number());
+const floorsSchema = /* @__PURE__ */ buildFloorsSchema();
+
+/** (killed) / (killed + survivors) as a percent; a package with no scored mutant scores 100. */
+export function percentOf({ killed, survivors }: Tally): number {
+  const scored = killed + survivors;
+  return scored === 0 ? PERCENT : (killed / scored) * PERCENT;
+}
+
+/** The deepest package dir holding `file`, else the root. */
+export function packageOf(file: string, packages: readonly string[]): string {
+  const holding = packages.filter((dir) => file.startsWith(`${dir}/`));
+  return holding.toSorted((a, b) => b.length - a.length)[0] ?? ROOT_PACKAGE;
+}
+
+/** Each package's totals over `files`. */
+export function tally(files: Record<string, FileScore>, packages: readonly string[]): Map<string, Tally> {
+  const totals = new Map<string, Tally>();
+  for (const [file, score] of Object.entries(files)) {
+    const pkg = packageOf(file, packages);
+    const was = totals.get(pkg) ?? { killed: 0, survivors: 0 };
+    totals.set(pkg, { killed: was.killed + score.killed, survivors: was.survivors + score.survivors.length });
+  }
+  return totals;
+}
+
+/** The floors in `file` under `root`: none when it is missing, the reason when it is no table of numbers. */
+export function readFloors(deps: MutateDeps, root: string, file: string): Parsed<Floors> {
+  const text = deps.fs.read(path.join(root, file));
+  if (text === null) return { ok: true, value: {} };
+  const json = parseJson(text);
+  if (!json.ok) return json;
+  const parsed = floorsSchema.safeParse(json.value);
+  return parsed.success
+    ? { ok: true, value: parsed.data }
+    : { ok: false, reason: parsed.error.issues.map((issue) => issue.message).join("; ") };
+}
+
+/** Every package's score against its floor, sorted by package. */
+export function verdicts(totals: Map<string, Tally>, floors: Floors): Verdict[] {
+  return [...totals]
+    .toSorted(([a], [b]) => a.localeCompare(b))
+    .map(([pkg, t]) => ({ pkg, percent: percentOf(t), floor: floors[pkg], survivors: t.survivors }));
+}
+
+const isBelow = (v: Verdict): boolean => v.floor !== undefined && v.percent < v.floor;
+const percentText = (v: Verdict): string => `${v.percent.toFixed(PERCENT_DIGITS)}%`;
+const floorOf = (v: Verdict): number => Math.floor(v.percent);
+
+/** `pkg 89.86% (floor 89)`, with the floor's move when it is `raise`d: `(floor 85 → 89)`. */
+export function label(v: Verdict, raise: boolean): string {
+  const moved = raise && v.floor !== floorOf(v) && !isBelow(v);
+  const floor = v.floor === undefined ? "no floor" : `floor ${v.floor}`;
+  return `${v.pkg} ${percentText(v)} (${moved ? `floor ${v.floor ?? "new"} ${ARROW} ${floorOf(v)}` : floor})`;
+}
+
+/** One line per package below its floor, naming the floors file and where the survivors are. */
+export function failures(vs: Verdict[], file: string, where: string): string[] {
+  return vs
+    .filter(isBelow)
+    .map(
+      (v) =>
+        `${v.pkg} scored ${percentText(v)}, below its floor of ${v.floor} in ${file}; see the survivors in ${where}`,
+    );
+}
+
+/** The floors with each package raised to its whole score; none lowered, none dropped. */
+export function raised(floors: Floors, vs: Verdict[]): Floors {
+  return { ...floors, ...Object.fromEntries(vs.map((v) => [v.pkg, Math.max(v.floor ?? 0, floorOf(v))])) };
+}
+
+/** `1 survivor`, `2 survivors`. */
+export const plural = (n: number, word: string): string => `${n} ${word}${n === 1 ? "" : "s"}`;
+
+/** A whole run: its report, the config it ran under and the report path as the person typed it. */
+export type Judged = { report: ShardReport; config: MutateConfig; shown: string };
+
+/** An unsharded run's verdict: each package's line, then a line per package below its floor; 1 if any. */
+export function judgeRun(run: Judged, deps: MutateDeps): number {
+  const { report, config, shown } = run;
+  const floors = readFloors(deps, config.root, config.floors);
+  if (!floors.ok) return fail(deps, `${config.floors} is not a floors file: ${floors.reason}`);
+  const totals = tally(report.files, deps.packages(config.root));
+  const vs = verdicts(totals, floors.value);
+  for (const v of vs) {
+    deps.out(`mutate: ${label(v, false)}, ${plural(v.survivors, "survivor")} in ${shown}${NEWLINE}`);
+  }
+  const lines = failures(vs, config.floors, shown);
+  return lines.length > 0 ? fail(deps, ...lines) : OK;
+}

package/cli/mutate-real-deps.ts

@@ -0,0 +1,57 @@
+/** The real collaborators of `repo mutate`: git, bun, the file system, the config and the workspace. */
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { CONFIG_FILE, findRoot, loadConfig } from "./config.ts";
+import { childEnv } from "./env.ts";
+import type { MutateDeps, MutateFs } from "./mutate-deps.ts";
+import { captureBun, toolEnv, type Captured } from "./scripts/lint.ts";
+import { spawnSync } from "./spawn.ts";
+import { readWorkspace } from "./sync/workspace.ts";
+
+/** `git <args>` in `cwd`, run without any `GIT_*` variable a hook set, which would aim it at another repo. */
+function git(cwd: string, args: string[]): Captured {
+  const run = spawnSync("git", args, { cwd, encoding: "utf8", env: toolEnv(childEnv()) });
+  return { code: run.status ?? 1, stdout: run.stdout, stderr: run.error?.message ?? run.stderr };
+}
+
+export const realFs: MutateFs = {
+  mkdtemp: (prefix) => fs.mkdtempSync(path.join(os.tmpdir(), prefix)),
+  rm: (target) => fs.rmSync(target, { recursive: true, force: true }),
+  read: (file) => (fs.existsSync(file) ? fs.readFileSync(file, "utf8") : null),
+  write: (file, text) => {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    fs.writeFileSync(file, text);
+  },
+  list: (dir) => (fs.existsSync(dir) ? fs.readdirSync(dir) : null),
+};
+
+/** The root and the `coverage` keys of the repo holding `cwd`, or the lines that say why there is none. */
+async function config(cwd: string): ReturnType<MutateDeps["config"]> {
+  const root = findRoot(cwd);
+  if (root === null) return [`no ${CONFIG_FILE} in ${cwd} or any parent; run \`bun repo init\``];
+  const loaded = await loadConfig(root);
+  if (!loaded.ok) return loaded.errors;
+  return { root, mutate: loaded.config.coverage.mutate, floors: loaded.config.coverage.mutationFloors };
+}
+
+/** The workspace package dirs of `root`; an unreadable manifest is `repo check`'s to report, so none here. */
+function packages(root: string): string[] {
+  const read = readWorkspace(root);
+  return read.ok ? read.workspace.packages.map((pkg) => pkg.dir) : [];
+}
+
+/** The collaborators of a run in `cwd`. */
+export function realDeps(cwd: string): MutateDeps {
+  return {
+    cwd,
+    config,
+    packages,
+    git,
+    run: (args, where) => captureBun(args, where, childEnv()),
+    fs: realFs,
+    preload: path.join(import.meta.dirname, "stryker-preload.ts"),
+    out: (text) => process.stdout.write(text),
+    err: (text) => process.stderr.write(text),
+  };
+}

package/cli/mutate-real.test.ts

@@ -0,0 +1,96 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, expect, it } from "vitest";
+import { childEnv } from "./env.ts";
+import { git, removePlanted, tempDir, write } from "./fixtures/planted-repo.ts";
+import { runMutate } from "./mutate.ts";
+import { realDeps } from "./mutate-real-deps.ts";
+import { toolEnv } from "./scripts/lint.ts";
+import { spawnSync } from "./spawn.ts";
+
+afterEach(removePlanted);
+
+const SLOW = 120_000;
+const REPORT = ".tmp/repo/mutation/report.json";
+const TOOL = "10.1.1";
+const VITEST = "^5.1.0";
+const MATH = [
+  "export const add = (a: number, b: number): number => a + b;",
+  "export const sub = (a: number, b: number): number => a - b;",
+  "",
+].join("\n");
+const MATH_TEST = [
+  'import { expect, it } from "vitest";',
+  'import { add, sub } from "./math.ts";',
+  'it("adds", () => expect(add(2, 3)).toBe(5));',
+  'it("subtracts, weakly", () => expect(typeof sub(5, 3)).toBe("number"));',
+  "",
+].join("\n");
+const STR = "export const shout = (text: string): string => text.toUpperCase();\n";
+const STR_TEST = [
+  'import { expect, it } from "vitest";',
+  'import { shout } from "./str.ts";',
+  'it("shouts", () => expect(shout("a")).toBe("A"));',
+  "",
+].join("\n");
+
+/** Two sources and one weak test, committed with an installed lockfile, so a clone installs frozen from bun's cache. */
+function plantedRepo(): string {
+  const dir = tempDir();
+  const manifest = {
+    name: "planted",
+    private: true,
+    type: "module",
+    devDependencies: {
+      vitest: VITEST,
+      "@stryker-mutator/core": TOOL,
+      "@stryker-mutator/vitest-runner": TOOL,
+    },
+  };
+  write(dir, {
+    "package.json": manifest,
+    ".gitignore": "node_modules\n.tmp/\n",
+    "workerstack.config.ts": 'export default { packs: [], coverage: { mutate: ["src/**/*.ts"] } };\n',
+    "mutation-floors.json": { ".": 99 },
+    "src/math.ts": MATH,
+    "src/math.test.ts": MATH_TEST,
+    "src/str.ts": STR,
+    "src/str.test.ts": STR_TEST,
+  });
+  const installed = spawnSync(process.execPath, ["install"], { cwd: dir, encoding: "utf8", env: toolEnv(childEnv()) });
+  expect(installed.status, installed.stderr).toBe(0);
+  git(dir, "init", "-q", "-b", "main");
+  git(dir, "add", "-A");
+  git(dir, "commit", "-q", "-m", "planted");
+  return dir;
+}
+
+type Report = { files: Record<string, { survivors: { line: number; mutator: string }[] }> };
+
+const clones = (): string[] => fs.readdirSync(os.tmpdir()).filter((name) => name.startsWith("workerstack-mutate-"));
+
+it(
+  "runs real Stryker through repo mutate: reports the weak test's survivor and score, fails a floor above it, leaves the tree clean",
+  { timeout: SLOW },
+  async () => {
+    const dir = plantedRepo();
+    const before = clones();
+    const out: string[] = [];
+    const err: string[] = [];
+    const deps = { ...realDeps(dir), out: (t: string) => out.push(t), err: (t: string) => err.push(t) };
+    const code = await runMutate([], deps);
+    expect(err.join(""), out.join("")).toMatch(
+      /^repo mutate: \. scored \d+\.\d\d%, below its floor of 99 in mutation-floors\.json/,
+    );
+    expect(code).toBe(1);
+    expect(out.join("")).toMatch(/mutate: 2 files, shard 1\/1\nmutate: \. \d+\.\d\d% \(floor 99\), 1 survivor in /);
+    const text = fs.readFileSync(path.join(dir, REPORT), "utf8");
+    const report = JSON.parse(text) /* the shard report this command wrote */ as Report;
+    const survivors = (file: string) => report.files[file]?.survivors.map((s) => [s.line, s.mutator]);
+    expect(survivors("src/math.ts")).toEqual([[2, "ArithmeticOperator"]]);
+    expect(survivors("src/str.ts")).toEqual([]);
+    expect(git(dir, "status", "--porcelain")).toBe("");
+    expect(clones()).toEqual(before);
+  },
+);