@workerstack/repo 0.0.0-stage → 0.1.0

package/cli/release/version.test.ts

@@ -0,0 +1,118 @@
+import { describe, expect, it } from "vitest";
+import { nextVersion, type Mode } from "./version.ts";
+
+const commit = (subject: string, body = "") => ({ subject, body });
+const AUTO: Mode = { kind: "auto" };
+type Options = { mode?: Mode; first?: boolean };
+const next = (current: string, subjects: string[], { mode = AUTO, first = false }: Options = {}) =>
+  nextVersion({ current, commits: subjects.map((subject) => commit(subject)), mode, first });
+
+describe("below 1.0", () => {
+  it("makes a breaking commit a minor and everything else a patch", () => {
+    expect(next("0.1.0", ["feat!: drop x"])).toEqual({ ok: true, version: "0.2.0" });
+    expect(next("0.1.3", ["fix(cli)!: rename y"])).toEqual({ ok: true, version: "0.2.0" });
+    expect(next("0.1.0", ["feat: add x"])).toEqual({ ok: true, version: "0.1.1" });
+    expect(next("0.1.0", ["fix: x"])).toEqual({ ok: true, version: "0.1.1" });
+    expect(next("0.1.0", ["perf: x"])).toEqual({ ok: true, version: "0.1.1" });
+    expect(next("0.1.0", ["revert: x"])).toEqual({ ok: true, version: "0.1.1" });
+  });
+
+  it("reads a BREAKING CHANGE footer as breaking", () => {
+    const got = nextVersion({
+      current: "0.4.2",
+      commits: [commit("feat: x", "why\n\nBREAKING CHANGE: the flag is gone")],
+      mode: AUTO,
+      first: false,
+    });
+    expect(got).toEqual({ ok: true, version: "0.5.0" });
+  });
+});
+
+describe("from 1.0", () => {
+  it("bumps major for breaking, minor for feat and patch for fix, perf and revert", () => {
+    expect(next("1.2.3", ["feat!: x"])).toEqual({ ok: true, version: "2.0.0" });
+    expect(next("1.2.3", ["feat: x"])).toEqual({ ok: true, version: "1.3.0" });
+    expect(next("1.2.3", ["fix: x"])).toEqual({ ok: true, version: "1.2.4" });
+    expect(next("1.2.3", ["perf(a): x"])).toEqual({ ok: true, version: "1.2.4" });
+    expect(next("1.2.3", ["revert: x"])).toEqual({ ok: true, version: "1.2.4" });
+  });
+
+  it("reads the footer and lets the highest commit win", () => {
+    const footer = commit("fix: x", "BREAKING-CHANGE: gone");
+    expect(nextVersion({ current: "1.2.3", commits: [footer], mode: AUTO, first: false })).toEqual({
+      ok: true,
+      version: "2.0.0",
+    });
+    expect(next("1.2.3", ["fix: a", "feat: b", "docs: c"])).toEqual({ ok: true, version: "1.3.0" });
+  });
+
+  it("ignores a body line that only mentions the footer", () => {
+    const mention = commit("fix: x", "see BREAKING CHANGE: in the docs");
+    expect(nextVersion({ current: "1.2.3", commits: [mention], mode: AUTO, first: false })).toEqual({
+      ok: true,
+      version: "1.2.4",
+    });
+  });
+
+  it("finds nothing to release in chore, docs, refactor, test and unparsable subjects", () => {
+    const none = { ok: false, reason: "nothing" };
+    expect(next("1.2.3", ["chore: x", "docs: y", "refactor: z", "test: w", "not conventional"])).toEqual(none);
+    expect(next("1.2.3", [])).toEqual(none);
+  });
+});
+
+describe("first release", () => {
+  it("releases 0.1.0 from 0.0.0 with no tag, whatever the commits", () => {
+    expect(next("0.0.0", ["chore: x"], { first: true })).toEqual({ ok: true, version: "0.1.0" });
+    expect(next("0.0.0", [], { mode: { kind: "pre", id: "rc" }, first: true })).toEqual({
+      ok: true,
+      version: "0.1.0-rc.0",
+    });
+    expect(next("0.0.0", [], { mode: { kind: "stable" }, first: true })).toEqual({ ok: true, version: "1.0.0" });
+  });
+});
+
+describe("--stable", () => {
+  it("moves a 0.x version to 1.0.0 even with nothing else to release", () => {
+    expect(next("0.4.2", ["fix: x"], { mode: { kind: "stable" } })).toEqual({ ok: true, version: "1.0.0" });
+    expect(next("0.4.2", [], { mode: { kind: "stable" } })).toEqual({ ok: true, version: "1.0.0" });
+    expect(next("0.9.0-rc.1", [], { mode: { kind: "stable" } })).toEqual({ ok: true, version: "1.0.0" });
+  });
+
+  it("refuses a 1.x version", () => {
+    expect(next("1.2.0", ["feat: x"], { mode: { kind: "stable" } })).toEqual({ ok: false, reason: "stable" });
+  });
+});
+
+describe("--pre", () => {
+  const rc: Mode = { kind: "pre", id: "rc" };
+
+  it("starts a prerelease on the computed version", () => {
+    expect(next("1.0.0", ["feat: x"], { mode: rc })).toEqual({ ok: true, version: "1.1.0-rc.0" });
+  });
+
+  it("counts up on the same base and id, and starts again on a new id", () => {
+    expect(next("1.1.0-rc.0", ["fix: x"], { mode: rc })).toEqual({ ok: true, version: "1.1.0-rc.1" });
+    expect(next("1.1.0-rc.1", ["fix: x"], { mode: { kind: "pre", id: "beta" } })).toEqual({
+      ok: true,
+      version: "1.1.0-beta.0",
+    });
+  });
+
+  it("finds nothing to release without a releasable commit", () => {
+    expect(next("1.1.0-rc.0", ["chore: x"], { mode: rc })).toEqual({ ok: false, reason: "nothing" });
+  });
+});
+
+describe("graduation", () => {
+  it("releases the base of a prerelease with a plain release, whatever the commits", () => {
+    expect(next("1.1.0-rc.1", [])).toEqual({ ok: true, version: "1.1.0" });
+    expect(next("0.2.0-rc.0", ["chore: x"])).toEqual({ ok: true, version: "0.2.0" });
+  });
+});
+
+describe("a version that is not semver", () => {
+  it("is nothing to bump from", () => {
+    expect(next("latest", ["feat: x"])).toEqual({ ok: false, reason: "version" });
+  });
+});

package/cli/release/version.ts

@@ -0,0 +1,69 @@
+import { HEADER, isBreaking } from "../conventional.ts";
+import { FIRST_VERSION, MINOR_TYPES, PATCH_TYPES, SEMVER, STABLE_MAJOR, STABLE_VERSION } from "./release.constants.ts";
+
+/** One commit since the last release: its subject line and the rest of its message. */
+export type Commit = { subject: string; body: string };
+/** What the person asked for: the next version by the commits, the 1.0.0 move, or a prerelease with an id. */
+export type Mode = { kind: "auto" } | { kind: "stable" } | { kind: "pre"; id: string };
+export type BumpInput = { current: string; commits: readonly Commit[]; mode: Mode; first: boolean };
+/** The next version, or why there is none: nothing releasable, a 1.x `--stable`, a version that is not semver. */
+export type Next = { ok: true; version: string } | { ok: false; reason: "nothing" | "stable" | "version" };
+
+type Level = "major" | "minor" | "patch";
+export type Parts = { major: number; minor: number; patch: number; id: string | undefined; n: number };
+
+/** The numbers of a semver version and its prerelease id and number; null for any other text. */
+export function parseSemver(version: string): Parts | null {
+  const match = SEMVER.exec(version);
+  if (match === null) return null;
+  const [, major, minor, patch, id, n] = match;
+  return { major: Number(major), minor: Number(minor), patch: Number(patch), id, n: Number(n ?? 0) };
+}
+
+/** The highest bump the commits ask for, as 1.0 and later read them; null when none is releasable. */
+function levelOf(commits: readonly Commit[]): Level | null {
+  let level: Level | null = null;
+  for (const { subject, body } of commits) {
+    const type = HEADER.exec(subject)?.groups?.["type"] ?? "";
+    if (isBreaking(subject, body.split("\n"))) return "major";
+    if (MINOR_TYPES.includes(type)) level = "minor";
+    else if (PATCH_TYPES.includes(type) && level === null) level = "patch";
+  }
+  return level;
+}
+
+function bump({ major, minor, patch }: Parts, level: Level): string {
+  // Below 1.0 a minor carries the breaking changes, so a breaking commit is a minor and the rest are patches.
+  const stable = major >= STABLE_MAJOR;
+  if (level === "major" && stable) return `${major + 1}.0.0`;
+  if (level === "major" || (level === "minor" && stable)) return `${major}.${minor + 1}.0`;
+  return `${major}.${minor}.${patch + 1}`;
+}
+
+const base = ({ major, minor, patch }: Parts): string => `${major}.${minor}.${patch}`;
+
+const ok = (version: string): Next => ({ ok: true, version });
+const fail = (reason: "nothing" | "stable" | "version"): Next => ({ ok: false, reason });
+
+/** The release version before any prerelease suffix: `from`'s own base when `keepBase`, else the bump `level` asks for. */
+function targetOf(from: Parts, level: Level | null, keepBase: boolean): string | null {
+  if (level === null) return null;
+  return keepBase ? base(from) : bump(from, level);
+}
+
+/** The version `--stable` or a graduation sets whatever the commits say; null when neither applies. */
+function fixedVersion(from: Parts, mode: Mode): Next | null {
+  if (mode.kind === "stable") return from.major === 0 ? ok(STABLE_VERSION) : fail("stable");
+  return mode.kind === "auto" && from.id !== undefined ? ok(base(from)) : null;
+}
+
+/** The version after `current`, per the commits since its release and the mode. */
+export function nextVersion({ current, commits, mode, first }: BumpInput): Next {
+  const from = parseSemver(current);
+  if (from === null) return fail("version");
+  const fixed = fixedVersion(from, mode);
+  if (fixed !== null) return fixed;
+  const target = first ? FIRST_VERSION : targetOf(from, levelOf(commits), mode.kind === "pre" && from.id !== undefined);
+  if (target === null) return fail("nothing");
+  return mode.kind === "pre" ? ok(`${target}-${mode.id}.${from.id === mode.id ? from.n + 1 : 0}`) : ok(target);
+}

package/cli/release/wait.test.ts

@@ -0,0 +1,101 @@
+import { describe, expect, it } from "vitest";
+import { releaseWait } from "./wait.ts";
+
+type Answer = () => Response | Error;
+const doc = (versions: string[], tags: Record<string, string>): Answer => {
+  const body = { versions: Object.fromEntries(versions.map((v) => [v, {}])), "dist-tags": tags };
+  return () => new Response(JSON.stringify(body));
+};
+const MISSING: Answer = () => new Response("{}", { status: 404 });
+const SPEC = "@workerstack/repo@1.1.0-rc.0";
+
+/** Runs `release wait`; `answers` are the registry's replies in order, the last repeating. */
+async function wait(argv: string[], answers: Answer[]) {
+  const out: string[] = [];
+  const err: string[] = [];
+  const urls: string[] = [];
+  const sleeps: number[] = [];
+  let clock = 0;
+  const fetcher = (url: string): Promise<Response> => {
+    urls.push(url);
+    const got = (answers.length > 1 ? answers.shift() : answers[0])?.();
+    return got instanceof Response ? Promise.resolve(got) : Promise.reject(got);
+  };
+  const sleep = (ms: number): Promise<void> => {
+    clock += ms;
+    sleeps.push(ms);
+    return Promise.resolve();
+  };
+  const io = {
+    stdout: (s: string) => out.push(s),
+    stderr: (s: string) => err.push(s),
+    fetch: fetcher,
+    sleep,
+    now: () => clock,
+  };
+  const code = await releaseWait(argv, io);
+  return { code, out: out.join(""), err: err.join(""), urls, sleeps };
+}
+
+describe("repo release wait finds the version", () => {
+  it("prints the version and its dist-tag when the registry has it at once", async () => {
+    const got = await wait([SPEC], [doc(["1.0.0", "1.1.0-rc.0"], { latest: "1.0.0", next: "1.1.0-rc.0" })]);
+    expect(got).toEqual({
+      code: 0,
+      out: "published 1.1.0-rc.0 under next\n",
+      err: "",
+      urls: ["https://registry.npmjs.org/@workerstack%2frepo"],
+      sleeps: [],
+    });
+  });
+
+  it("prints just the version when no dist-tag points at it", async () => {
+    const got = await wait(["@workerstack/database@0.22.0"], [doc(["0.22.0", "0.23.0"], { latest: "0.23.0" })]);
+    expect(got).toMatchObject({ code: 0, out: "published 0.22.0\n" });
+    expect(got.urls).toEqual(["https://registry.npmjs.org/@workerstack%2fdatabase"]);
+  });
+
+  it("looks again every 10 seconds, through a miss, a failure and a bad body", async () => {
+    const bad: Answer = () => new Response("not json");
+    const offline: Answer = () => new Error("offline");
+    const got = await wait([SPEC], [MISSING, offline, bad, doc(["1.1.0-rc.0"], { next: "1.1.0-rc.0" })]);
+    expect(got).toMatchObject({ code: 0, out: "published 1.1.0-rc.0 under next\n" });
+    expect(got.sleeps).toEqual([10_000, 10_000, 10_000]);
+  });
+});
+
+describe("repo release wait through a registry that does not answer", () => {
+  it("keeps polling past a server error and an answer that is not a package", async () => {
+    const down: Answer = () => new Response("down", { status: 503 });
+    const odd: Answer = () => new Response('{"x":1}');
+    const got = await wait([SPEC], [down, odd, doc(["1.1.0-rc.0"], { next: "1.1.0-rc.0" })]);
+    expect(got).toMatchObject({ code: 0, out: "published 1.1.0-rc.0 under next\n", sleeps: [10_000, 10_000] });
+  });
+
+  it("gives up after 15 minutes of server errors", async () => {
+    const got = await wait([SPEC], [() => new Response("down", { status: 503 })]);
+    expect(got).toMatchObject({ code: 1, out: "" });
+    expect(got.sleeps).toHaveLength(90);
+  });
+});
+
+describe("repo release wait gives up", () => {
+  it("after 15 minutes without the version", async () => {
+    const got = await wait([SPEC], [doc(["1.0.0"], { latest: "1.0.0" })]);
+    expect(got.code).toBe(1);
+    expect(got.out).toBe("");
+    expect(got.err).toBe(
+      "repo release wait: @workerstack/repo@1.1.0-rc.0 is not on npm after 15 minutes; see gh run list --workflow release\n",
+    );
+    expect(got.sleeps).toHaveLength(90);
+    expect(got.urls).toHaveLength(91);
+  });
+
+  it.each([[[]], [["@workerstack/repo"]], [["repo@"]], [["a", "b"]]])(
+    "asks for <name>@<version> for the arguments %j",
+    async (argv) => {
+      const line = "repo release wait: name the tag as <name>@<version>, e.g. @workerstack/repo@1.0.0\n";
+      expect(await wait(argv, [MISSING])).toMatchObject({ code: 1, out: "", err: line, urls: [] });
+    },
+  );
+});

package/cli/release/wait.ts

@@ -0,0 +1,95 @@
+import { z } from "zod";
+import {
+  ENCODED_SLASH,
+  NOT_A_DOCUMENT,
+  NOT_FOUND,
+  REGISTRY,
+  SCOPE_SLASH,
+  WAIT_GIVE_UP_MINUTES,
+  WAIT_GIVE_UP_MS,
+  WAIT_POLL_MS,
+} from "./release.constants.ts";
+import { WAIT_PREFIX, WAIT_USAGE, notOnNpm, published } from "./release-messages.constants.ts";
+
+/** Where `repo release wait` prints and what it reaches the registry, the clock and the sleep through. */
+export type WaitIo = {
+  stdout: (text: string) => void;
+  stderr: (text: string) => void;
+  fetch: (url: string) => Promise<Response>;
+  now: () => number;
+  sleep: (ms: number) => Promise<void>;
+};
+
+/** The part of the registry's document for a package that a release reads. */
+type RegistryDoc = { versions: Record<string, unknown>; "dist-tags": Record<string, string> };
+
+const documentSchema = (): z.ZodType<RegistryDoc> =>
+  z.object({ versions: z.record(z.string(), z.unknown()), "dist-tags": z.record(z.string(), z.string()) });
+
+/** A package name and the version of it a tag or `wait` names. */
+export type Spec = { name: string; version: string };
+
+/** `<name>@<version>` split at its last `@` (a scope's `@` leads the name); null when there is no version. */
+export function splitSpec(spec: string): Spec | null {
+  const at = spec.lastIndexOf("@");
+  return at > 0 && at < spec.length - 1 ? { name: spec.slice(0, at), version: spec.slice(at + 1) } : null;
+}
+
+/** What the registry said about a package: its document, that it is not there (404), or why it did not answer. */
+export type RegistryAnswer =
+  | { kind: "found"; doc: RegistryDoc }
+  | { kind: "missing" }
+  | { kind: "unreachable"; why: string };
+
+/** Asks the registry for `name`; any answer but a document or a 404 is `unreachable` with its status or error. */
+export async function registryDoc(fetcher: WaitIo["fetch"], name: string): Promise<RegistryAnswer> {
+  try {
+    const response = await fetcher(`${REGISTRY}${name.replace(SCOPE_SLASH, ENCODED_SLASH)}`);
+    if (response.status === NOT_FOUND) return { kind: "missing" };
+    if (!response.ok) return { kind: "unreachable", why: `HTTP ${response.status}` };
+    const parsed = documentSchema().safeParse(await response.json());
+    return parsed.success ? { kind: "found", doc: parsed.data } : { kind: "unreachable", why: NOT_A_DOCUMENT };
+  } catch (error) {
+    return {
+      kind: "unreachable",
+      why: (error /* a failed fetch or a body that is not JSON throws an Error */ as Error).message,
+    };
+  }
+}
+
+/** The dist-tag pointing at `version` when the answer lists it, `{}` when it lists it with no tag, null otherwise. */
+export function listing(answer: RegistryAnswer, version: string): { tag?: string } | null {
+  if (answer.kind !== "found" || !(version in answer.doc.versions)) return null;
+  const tag = Object.entries(answer.doc["dist-tags"]).find(([, pointed]) => pointed === version)?.[0];
+  return tag === undefined ? {} : { tag };
+}
+
+/** Where `poll` reads the clock and sleeps. */
+export type PollIo = Pick<WaitIo, "now" | "sleep">;
+
+/** Looks with `probe` until it answers, every `WAIT_POLL_MS`, for up to `WAIT_GIVE_UP_MS` after `started`; null on giving up. */
+export async function poll<T>(io: PollIo, probe: () => Promise<T | null>, started: number): Promise<T | null> {
+  const found = await probe();
+  if (found !== null) return found;
+  if (io.now() - started >= WAIT_GIVE_UP_MS) return null;
+  await io.sleep(WAIT_POLL_MS);
+  return poll(io, probe, started);
+}
+
+/** `repo release wait <name>@<version>`: polls npm every 10 seconds for up to 15 minutes. */
+export async function releaseWait(argv: readonly string[], io: WaitIo): Promise<number> {
+  const spec = argv[0] ?? "";
+  const parts = argv.length === 1 ? splitSpec(spec) : null;
+  if (parts === null) {
+    io.stderr(`${WAIT_PREFIX}${WAIT_USAGE}\n`);
+    return 1;
+  }
+  const probe = async () => listing(await registryDoc(io.fetch, parts.name), parts.version);
+  const found = await poll(io, probe, io.now());
+  if (found === null) {
+    io.stderr(`${WAIT_PREFIX}${notOnNpm(spec, WAIT_GIVE_UP_MINUTES)}\n`);
+    return 1;
+  }
+  io.stdout(`${published(parts.version, found.tag)}\n`);
+  return 0;
+}

package/cli/script-diagnostics.test.ts

@@ -0,0 +1,76 @@
+import { execFileSync } from "node:child_process";
+import { afterEach, expect, it } from "vitest";
+import { cleanTemps, hit, NAMES_NOTHING, NUMBER, plant, SLOW } from "./magic/fixtures/magic-repo.ts";
+import { checkRejectionsAt, checkScriptsAt, scriptDiagnostics } from "./script-diagnostics.ts";
+
+afterEach(cleanTemps);
+
+const GUARD = "repo(guard-rejects)";
+const UNTESTED = (name: string) =>
+  `${name} is never asserted false; add expect(${name}(<an input it must reject>)).toBe(false) to a test`;
+
+it("scriptDiagnostics joins the magic hits and the untested guards, in file and line order", { timeout: SLOW }, () => {
+  const source =
+    "export const isList = (value: unknown): value is unknown[] => Array.isArray(value);\nexport const n = (): number => 7;\n";
+  const root = plant({ "src/a.ts": source });
+  expect(scriptDiagnostics(root, ["src/a.ts"])).toEqual({
+    ok: true,
+    value: [hit("src/a.ts:1:14", GUARD, UNTESTED("isList")), hit("src/a.ts:2:32", NUMBER, NAMES_NOTHING("7"))],
+  });
+});
+
+it("scriptDiagnostics reports a tsconfig.json that only the guards read, over a test file", { timeout: SLOW }, () => {
+  const root = plant({ "pkg/tsconfig.json": "{", "pkg/a.test.ts": "export {};\n" });
+  const found = scriptDiagnostics(root, ["pkg/a.test.ts"]);
+  expect(found.ok ? [] : found.errors).toEqual([expect.stringMatching(/^pkg\/tsconfig\.json: .+/)]);
+});
+
+/** A git checkout with a config of `packs` and `skip`, and `files`. */
+function checkout(files: Record<string, string>, config: object): string {
+  const root = plant({ ...files, "workerstack.config.ts": `export default ${JSON.stringify(config)};\n` });
+  execFileSync("git", ["init", "-q"], { cwd: root });
+  return root;
+}
+
+it("checkScriptsAt gives every hit of the checkout and those its skips leave", async () => {
+  const skip = { files: ["src/a.ts"], rules: ["repo/magic-number"], reason: "tuning lives here" };
+  const root = checkout(
+    { "src/a.ts": "export const f = () => 5000;\n", "src/b.ts": "export const g = () => 7;\n" },
+    { packs: ["standards"], lint: { skip: [skip] } },
+  );
+  const a = hit("src/a.ts:1:24", NUMBER, NAMES_NOTHING("5000"));
+  const b = hit("src/b.ts:1:24", NUMBER, NAMES_NOTHING("7"));
+  expect(await checkScriptsAt(root)).toEqual({ all: [a, b], kept: [b], problems: [] });
+});
+
+it("checkScriptsAt checks nothing without a config or the standards pack, and reports what stops it", async () => {
+  const none = { all: [], kept: [], problems: [] };
+  expect(await checkScriptsAt(plant({ "src/a.ts": "export const f = () => 5;\n" }))).toEqual(none);
+  const docs = checkout({ "src/a.ts": "export const f = () => 5;\n" }, { packs: ["docs"] });
+  expect(await checkScriptsAt(docs)).toEqual(none);
+  const broken = checkout(
+    { "pkg/tsconfig.json": "{", "pkg/a.ts": "export const f = () => 5;\n" },
+    { packs: ["standards"] },
+  );
+  expect((await checkScriptsAt(broken)).problems).toEqual([expect.stringMatching(/^pkg\/tsconfig\.json: .+/)]);
+  const plain = plant({ "workerstack.config.ts": 'export default { packs: ["standards"] };\n' });
+  expect((await checkScriptsAt(plain)).problems).toEqual([expect.stringMatching(/^git ls-files failed: /)]);
+});
+
+it(
+  "checkRejectionsAt checks every reject file of a standards checkout, and nothing without the pack",
+  { timeout: SLOW },
+  async () => {
+    const files = {
+      "src/a.reject.ts": "export const a: number = 'x';\n",
+      "src/b.ts": "export const b: number = 'x';\n",
+    };
+    expect(await checkRejectionsAt(checkout(files, { packs: ["standards"] }))).toEqual([
+      "src/a.reject.ts: line 1 fails unmarked: TS2322: Type 'string' is not assignable to type 'number'.",
+    ]);
+    expect(await checkRejectionsAt(checkout(files, { packs: ["docs"] }))).toEqual([]);
+    expect(await checkRejectionsAt(plant(files))).toEqual([]);
+    const plain = plant({ "workerstack.config.ts": 'export default { packs: ["standards"] };\n' });
+    expect(await checkRejectionsAt(plain)).toEqual([expect.stringMatching(/^git ls-files failed: /)]);
+  },
+);

package/cli/script-diagnostics.ts

@@ -0,0 +1,62 @@
+/**
+ * The checks run as scripts on the TypeScript compiler API, joined for `repo check`, `repo turn` and `repo lint
+ * --baseline`: the magic literals and the untested guards as lint diagnostics the baseline counts, and the reject files
+ * check prints. Apart from `check-magic.ts` and `check-guards.ts`, which this imports, so neither imports the other.
+ */
+import { sourceFiles } from "./check-comments.ts";
+import { guardDiagnostics } from "./guard-diagnostics.ts";
+import { magicDiagnostics, withoutSkipped } from "./check-magic.ts";
+import { rejectionProblems } from "./check-rejections.ts";
+import { findRoot, loadConfig, type LintSkip } from "./config.ts";
+import type { Diagnostic, Result } from "./scripts/lint-baseline.ts";
+
+/** `repo check`'s script hits: all of them for the skip report, those no skip turns off for the baseline. */
+export type ScriptCheck = { all: Diagnostic[]; kept: Diagnostic[]; problems: string[] };
+/** A standards checkout's root, `lint.skip` and source files; null without a config or the pack. */
+type Checkout = { root: string; skips: readonly LintSkip[]; files: Result<string[]> } | null;
+
+const NONE: ScriptCheck = { all: [], kept: [], problems: [] };
+
+const byKey = (a: string, b: string) => Number(a > b) - Number(a < b);
+/** File order, then line and column: within one file the lines differ from the position on, read as numbers. */
+const byPlace = (a: Diagnostic, b: Diagnostic): number =>
+  byKey(a.file, b.file) || a.line.localeCompare(b.line, "en", { numeric: true });
+
+/**
+ * The magic hits and untested guards of `files` (root-relative POSIX paths), in file then position order; the guards
+ * of the sources a test among them imports too. Or why a tsconfig.json could not be read.
+ */
+export function scriptDiagnostics(root: string, files: readonly string[]): Result<Diagnostic[]> {
+  const magic = magicDiagnostics(root, files);
+  if (!magic.ok) return magic;
+  const guards = guardDiagnostics(root, files);
+  if (!guards.ok) return guards;
+  return { ok: true, value: [...magic.value, ...guards.value].sort(byPlace) };
+}
+
+async function checkoutAt(cwd: string): Promise<Checkout> {
+  const root = findRoot(cwd);
+  if (root === null) return null;
+  const loaded = await loadConfig(root);
+  if (!loaded.ok || !loaded.config.packs.includes("standards")) return null;
+  const listed = sourceFiles(root);
+  const files: Result<string[]> = listed.ok ? { ok: true, value: listed.files } : listed;
+  return { root, skips: loaded.config.lint.skip, files };
+}
+
+/** `repo check`'s script hits for the repo at `cwd`: none without a config or the standards pack. */
+export async function checkScriptsAt(cwd: string): Promise<ScriptCheck> {
+  const checkout = await checkoutAt(cwd);
+  if (checkout === null) return NONE;
+  if (!checkout.files.ok) return { ...NONE, problems: checkout.files.errors };
+  const found = scriptDiagnostics(checkout.root, checkout.files.value);
+  if (!found.ok) return { ...NONE, problems: found.errors };
+  return { all: found.value, kept: withoutSkipped(found.value, checkout.skips, checkout.files.value), problems: [] };
+}
+
+/** `repo check`'s reject file problems for the repo at `cwd`: none without a config or the standards pack. */
+export async function checkRejectionsAt(cwd: string): Promise<string[]> {
+  const checkout = await checkoutAt(cwd);
+  if (checkout === null) return [];
+  return checkout.files.ok ? rejectionProblems(checkout.root, checkout.files.value) : checkout.files.errors;
+}