@avi2dg/checks 0.20.0 → 0.22.0

package/scripts/quality-file.ts

@@ -1,347 +0,0 @@
-import { Console, Effect, FileSystem, JsonSchema, Path, Schema } from "effect";
-import { LintGates, QUALITY_FILE } from "./gates.ts";
-import { Size } from "./size-rules.ts";
-
-const SEGMENT = String.raw`(?!\.\.?(?:/|$))(?:\*\*|(?:[\w.@+-]|\*(?!\*))+)`;
-
-const FILE = String.raw`(?:[\w.@+-]|\*(?!\*))*\.\w+`;
-
-// oxlint matches a glob without a slash against a file's name at any depth, where tsc, the
-// language service and git match it at the root alone, so a glob names a directory first.
-// The language service drops an include ending in ** and oxlint reads a bare name as a file,
-// so a glob ends in a file name with an extension.
-const PathGlob = Schema.String.check(
-  Schema.isPattern(new RegExp(`^${SEGMENT}(?:/${SEGMENT})*/${FILE}$`), {
-    expected:
-      "a glob from the repository root such as src/**/*.ts: a directory first, * within a segment, ** as a whole one, a file name with an extension last",
-  }),
-).annotate({
-  identifier: "PathGlob",
-  description:
-    "A glob from the repository root that oxlint, the Effect language service and git read alike: a directory first, * within a segment, ** as a whole one, a file name with an extension last, and no braces, ?, [ or leading ./",
-});
-
-// Only checks-docs reads a doc glob, matching it from the root, so a file at the root names itself.
-const DocGlob = Schema.String.check(
-  Schema.isPattern(new RegExp(`^(?:${SEGMENT}/)*${FILE}$`), {
-    expected: "a glob from the repository root such as README.md or docs/**/*.md: * within a segment, ** as a whole one, a file name with an extension last",
-  }),
-).annotate({
-  identifier: "DocGlob",
-  description: "A glob from the repository root that checks-docs reads: * within a segment, ** as a whole one, a file name with an extension last",
-});
-
-const LITERAL_SEGMENT = String.raw`(?!\.\.?(?:/|$))[\w.@+-]+`;
-
-const DirectoryPath = Schema.String.check(
-  Schema.isPattern(new RegExp(`^${LITERAL_SEGMENT}(?:/${LITERAL_SEGMENT})*$`), {
-    expected: "a directory from the repository root such as src/billing, with no glob and no trailing slash",
-  }),
-).annotate({ identifier: "DirectoryPath" });
-
-const FilePath = Schema.String.check(
-  Schema.isPattern(new RegExp(`^(?:${LITERAL_SEGMENT}/)*[\\w.@+-]*\\.\\w+$`), {
-    expected: "a file from the repository root such as src/billing/index.ts, with no glob",
-  }),
-).annotate({ identifier: "FilePath" });
-
-export const PROOF_DIRECTORY = "tests/e2e/";
-
-const ProofPath = Schema.String.check(
-  Schema.isPattern(new RegExp(`^${PROOF_DIRECTORY}(?:${LITERAL_SEGMENT}/)*[\\w.@+-]+\\.test\\.tsx?$`), {
-    expected: `a test file under ${PROOF_DIRECTORY} such as ${PROOF_DIRECTORY}billing.test.ts`,
-  }),
-).annotate({ identifier: "ProofPath" });
-
-const Command = Schema.NonEmptyString.annotate({ identifier: "Command" });
-
-const RuleName = Schema.String.check(
-  Schema.isPattern(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, { expected: "a Rule name in kebab case" }),
-).annotate({ identifier: "RuleName" });
-
-export const Identity = Schema.Struct({ name: Schema.NonEmptyString, email: Schema.NonEmptyString }).annotate({
-  identifier: "Identity",
-});
-export type Identity = typeof Identity.Type;
-
-const CommitIdentity = Schema.Struct({
-  authors: Schema.NonEmptyArray(Identity).annotate({
-    description: "The identities allowed to author and commit, in place of the kit's default owner",
-  }),
-});
-
-const Gates = Schema.Struct({
-  ci: Schema.optionalKey(
-    Schema.NonEmptyArray(Command).annotate({
-      description: "The commands CI runs on every pull request to the default branch, each one plain command",
-    }),
-  ),
-  scheduled: Schema.optionalKey(
-    Schema.Array(Command).annotate({ description: "The commands a cron-scheduled workflow runs" }),
-  ),
-  lint: Schema.optionalKey(LintGates),
-});
-
-const EffectSources = Schema.Struct({
-  paths: Schema.NonEmptyArray(PathGlob).annotate({
-    description: "Where source is written in Effect, held to the Effect rules of oxlint and the language service",
-  }),
-  exempt: Schema.optionalKey(
-    Schema.Array(PathGlob).annotate({ description: "Files under paths the Effect rules pass over" }),
-  ),
-});
-
-const Library = Schema.Struct({
-  name: Schema.String.check(
-    Schema.isPattern(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, { expected: "a library name in kebab case" }),
-  ).annotate({ description: "The link checks-vendor manages under repos/" }),
-  package: Schema.NonEmptyString.annotate({ description: "The npm package whose installed version picks the tag" }),
-  repository: Schema.NonEmptyString.annotate({ description: "The git remote checks-vendor clones the tag from" }),
-  tag: Schema.String.check(Schema.isPattern(/\{version\}/, { expected: "a tag template holding {version}" })).annotate({
-    description: "The tag template, with {version} for the installed version",
-  }),
-  path: Schema.optionalKey(
-    FilePath.annotate({ description: "The manifest inside the clone holding the version; package.json when absent" }),
-  ),
-}).annotate({ identifier: "Library" });
-export type Library = typeof Library.Type;
-
-const Sources = Schema.Struct({
-  production: Schema.optionalKey(
-    Schema.Array(PathGlob).annotate({ description: "The source the repository ships, as against tests and tooling" }),
-  ),
-  libraries: Schema.optionalKey(
-    Schema.Array(Library).check(
-      Schema.makeFilter((libraries) => {
-        const repeated = duplicates(libraries.map((library) => library.name));
-        return repeated === undefined || `names ${repeated} more than once`;
-      }),
-    ).annotate({ description: "The libraries checks-vendor pins to a shared read-only clone" }),
-  ),
-  effect: Schema.optionalKey(EffectSources),
-});
-
-const Feature = Schema.Struct({
-  name: Schema.String.check(
-    Schema.isPattern(/^[a-z0-9]+(?:-[a-z0-9]+)*$/, { expected: "a feature name in kebab case" }),
-  ).annotate({ description: "The owner the dependency rule and the change signal name" }),
-  root: DirectoryPath.annotate({ description: "The directory the feature owns" }),
-  entries: Schema.NonEmptyArray(FilePath).annotate({
-    description: "The files under root that code outside it imports the feature through",
-  }),
-  allowFrom: Schema.optionalKey(
-    Schema.Array(PathGlob).annotate({
-      description: "Files outside root that may import past its entries, such as a CLI or a harness; tests/ always may",
-    }),
-  ),
-  proof: ProofPath.annotate({ description: "The end-to-end test that imports one of entries" }),
-}).check(
-  Schema.makeFilter(({ root, entries }) => {
-    const outside = entries.filter((entry) => !entry.startsWith(`${root}/`));
-    return outside.length === 0 || `lists ${outside.join(", ")} among its entries, outside its root ${root}`;
-  }),
-);
-export type Feature = typeof Feature.Type;
-
-function nests(outer: string, inner: string): boolean {
-  return outer === inner || inner.startsWith(`${outer}/`);
-}
-
-function duplicates(names: readonly string[]): string | undefined {
-  const repeated = names.filter((name, index) => names.indexOf(name) !== index);
-  return repeated.length === 0 ? undefined : [...new Set(repeated)].join(", ");
-}
-
-const Features = Schema.Array(Feature).check(
-  Schema.makeFilter((features) => {
-    const repeated = duplicates(features.map((feature) => feature.name));
-    if (repeated !== undefined) return `names ${repeated} more than once`;
-    for (const outer of features) {
-      const inner = features.find((other) => other !== outer && nests(outer.root, other.root));
-      if (inner !== undefined) return `gives ${inner.root} to both ${outer.name} and ${inner.name}`;
-    }
-    return true;
-  }),
-);
-
-const AgentRules = Schema.Struct({
-  on: Schema.optionalKey(Schema.Array(RuleName).annotate({ description: "Catalogued Rules switched on here" })),
-  off: Schema.optionalKey(Schema.Array(RuleName).annotate({ description: "Catalogued Rules switched off here" })),
-}).check(
-  Schema.makeFilter(({ on = [], off = [] }) => {
-    const both = on.filter((rule) => off.includes(rule));
-    return both.length === 0 || `switches ${both.join(", ")} both on and off`;
-  }),
-);
-
-export const MODES = ["tutorial", "how-to", "reference", "explanation"] as const;
-export type Mode = (typeof MODES)[number];
-
-const pagesIn = (mode: string) =>
-  Schema.optionalKey(Schema.Array(PathGlob).annotate({ description: `The pages written as ${mode}` }));
-
-const Docs = Schema.Struct({
-  pages: Schema.optionalKey(
-    Schema.Struct({
-      tutorial: pagesIn("a tutorial, which teaches by building one thing"),
-      "how-to": pagesIn("a how-to, which walks one task"),
-      reference: pagesIn("reference, which describes a thing to be looked up"),
-      explanation: pagesIn("an explanation, which says why"),
-    } satisfies Record<Mode, unknown>).annotate({
-      description: "The Diátaxis mode of each page, whose template checks-docs holds the page to; a page under docs/ needs one",
-    }),
-  ),
-  forConsumers: Schema.optionalKey(
-    Schema.Array(DocGlob).annotate({
-      description: "The living docs that speak to a repository installing this one, whose bun run commands checks-docs does not hold to this package.json",
-    }),
-  ),
-});
-export type Docs = typeof Docs.Type;
-
-export const Quality = Schema.Struct({
-  $schema: Schema.optionalKey(Schema.String),
-  defaultBranch: Schema.optionalKey(
-    Schema.NonEmptyString.annotate({ description: "The branch pull requests merge into; main when absent" }),
-  ),
-  gates: Schema.optionalKey(Gates),
-  commitIdentity: Schema.optionalKey(CommitIdentity),
-  sources: Schema.optionalKey(Sources),
-  size: Schema.optionalKey(Size),
-  features: Schema.optionalKey(
-    Features.annotate({
-      description: "The feature owners dependency-cruiser holds to their entries and checks-feature-owners maps a change to",
-    }),
-  ),
-  changeSignal: Schema.optionalKey(
-    Schema.Literal("advisory").annotate({
-      description: "Report which feature owners a change touches, without failing on it",
-    }),
-  ),
-  agentRules: Schema.optionalKey(AgentRules),
-  docs: Schema.optionalKey(Docs.annotate({ description: "What checks-docs reads to map a doc file to its template" })),
-})
-  .annotate({
-    title: QUALITY_FILE,
-    description: "What a repository has opted into from @avi2dg/checks, read by its bins and agent Rule selection",
-  })
-  .check(
-    Schema.makeFilter(
-      ({ size, sources }) =>
-        size === undefined || (sources?.production ?? []).length > 0 || "declares size, which holds no production file without sources.production",
-      {
-        toJsonSchema: () => ({
-          if: { required: ["size"] },
-          then: { required: ["sources"], properties: { sources: { required: ["production"], properties: { production: { minItems: 1 } } } } },
-        }),
-      },
-    ),
-    Schema.makeFilter(
-      ({ changeSignal, features = [] }) =>
-        changeSignal === undefined || features.length > 0 || "declares changeSignal, which maps a change to no owner without features",
-      {
-        toJsonSchema: () => ({
-          if: { required: ["changeSignal"] },
-          then: { required: ["features"], properties: { features: { minItems: 1 } } },
-        }),
-      },
-    ),
-  );
-export type Quality = typeof Quality.Type;
-
-export const LegacyManifest = Schema.Struct({
-  ciWiring: Schema.optionalKey(
-    Schema.Struct({
-      gates: Schema.optionalKey(Schema.NonEmptyArray(Command)),
-      scheduled: Schema.optionalKey(Schema.Array(Command)),
-      lintGates: Schema.optionalKey(LintGates),
-      defaultBranch: Schema.optionalKey(Schema.NonEmptyString),
-    }),
-  ),
-  commitIdentity: Schema.optionalKey(CommitIdentity),
-});
-type LegacyManifest = typeof LegacyManifest.Type;
-
-const LEGACY_KEYS = ["ciWiring", "commitIdentity"] as const;
-
-export type LegacyDeclaration = {
-  readonly keys: readonly (typeof LEGACY_KEYS)[number][];
-  readonly quality: Quality;
-};
-
-export class QualityUnreadable extends Schema.TaggedError<QualityUnreadable>()("QualityUnreadable", {
-  message: Schema.String,
-}) {}
-
-const MANIFEST = "package.json";
-
-export type Declared = {
-  readonly source: typeof QUALITY_FILE | typeof MANIFEST;
-  readonly quality: Quality;
-};
-
-const decodeQualityJson = Schema.decodeUnknownEffect(Schema.fromJsonString(Quality), { onExcessProperty: "error" });
-const decodeManifestJson = Schema.decodeUnknownEffect(Schema.fromJsonString(LegacyManifest));
-
-export const decodeQuality = (text: string, source: string): Effect.Effect<Quality, QualityUnreadable> =>
-  decodeQualityJson(text).pipe(Effect.mapError((cause) => new QualityUnreadable({ message: `${source}: ${cause.message}` })));
-
-function fromLegacy({ ciWiring, commitIdentity }: LegacyManifest): Quality {
-  const gates = {
-    ...(ciWiring?.gates === undefined ? {} : { ci: ciWiring.gates }),
-    ...(ciWiring?.scheduled === undefined ? {} : { scheduled: ciWiring.scheduled }),
-    ...(ciWiring?.lintGates === undefined ? {} : { lint: ciWiring.lintGates }),
-  };
-  return {
-    ...(ciWiring?.defaultBranch === undefined ? {} : { defaultBranch: ciWiring.defaultBranch }),
-    ...(Object.keys(gates).length === 0 ? {} : { gates }),
-    ...(commitIdentity === undefined ? {} : { commitIdentity }),
-  };
-}
-
-export const decodeManifest = (text: string, source: string): Effect.Effect<LegacyDeclaration, QualityUnreadable> =>
-  decodeManifestJson(text).pipe(
-    Effect.map((manifest) => ({
-      keys: LEGACY_KEYS.filter((key) => manifest[key] !== undefined),
-      quality: fromLegacy(manifest),
-    })),
-    Effect.mapError((cause) => new QualityUnreadable({ message: `${source}: ${cause.message}` })),
-  );
-
-const UNDECLARED: LegacyDeclaration = { keys: [], quality: {} };
-
-export const readQuality = Effect.fn("readQuality")(function* (root: string) {
-  const fs = yield* FileSystem.FileSystem;
-  const path = yield* Path.Path;
-  const read = (file: string) =>
-    fs
-      .readFileString(path.join(root, file))
-      .pipe(Effect.mapError((cause) => new QualityUnreadable({ message: `cannot read ${file}: ${cause.message}` })));
-
-  const legacy = (yield* fs.exists(path.join(root, MANIFEST)))
-    ? yield* decodeManifest(yield* read(MANIFEST), MANIFEST)
-    : UNDECLARED;
-  const keys = legacy.keys.join(" and ");
-  if (yield* fs.exists(path.join(root, QUALITY_FILE))) {
-    if (legacy.keys.length > 0) {
-      return yield* new QualityUnreadable({
-        message: `${MANIFEST} still sets ${keys}, which ${QUALITY_FILE} replaces; move what it holds there`,
-      });
-    }
-    return { source: QUALITY_FILE, quality: yield* decodeQuality(yield* read(QUALITY_FILE), QUALITY_FILE) } satisfies Declared;
-  }
-  if (legacy.keys.length > 0) {
-    const them = legacy.keys.length === 1 ? "it" : "them";
-    yield* Console.error(`${MANIFEST} sets ${keys}, which a later minor release stops reading; move ${them} into ${QUALITY_FILE}`);
-  }
-  return { source: MANIFEST, quality: legacy.quality } satisfies Declared;
-});
-
-export function renderJson(value: unknown): string {
-  return `${JSON.stringify(value, null, 2)}\n`;
-}
-
-export function qualityJsonSchema(): JsonSchema.JsonSchema {
-  const { schema, definitions } = Schema.toJsonSchemaDocument(Quality, { onExcessProperty: "error" });
-  return { $schema: JsonSchema.META_SCHEMA_URI_DRAFT_2020_12, ...schema, $defs: definitions };
-}

package/scripts/quality.ts

@@ -1,342 +0,0 @@
-#!/usr/bin/env bun
-import { Console, Effect, FileSystem, Path, Schema } from "effect";
-import kitOxlint from "../oxlintrc.json" with { type: "json" };
-import kitManifest from "../package.json" with { type: "json" };
-import effectLanguageService from "../presets/effect.language-service.json" with { type: "json" };
-import effectOxlint from "../presets/effect.oxlint.json" with { type: "json" };
-import { git } from "./git.ts";
-import { DEFAULT_BRANCH } from "./gates.ts";
-import { runMain, Usage } from "./main.ts";
-import { QualityUnreadable, readQuality, renderJson, type Quality } from "./quality-file.ts";
-import { invokes, plainCommand } from "./shell-command.ts";
-
-// oxlint resolves an override's files, and the language service an override's include, against the
-// directory of the config that holds it, so a fragment anywhere but the root matches nothing there.
-export const OXLINT_FRAGMENT = "oxlintrc.quality.json";
-export const TSCONFIG_FRAGMENT = "tsconfig.quality.json";
-export const SUITE_WORKFLOW = ".github/workflows/ci.yml";
-export const COMMITLINT_WORKFLOW = ".github/workflows/commitlint.yml";
-
-const NAME = "checks-quality";
-const USAGE = `usage: ${NAME} --check | generate`;
-const GENERATE = `${NAME} generate`;
-
-type EffectSources = NonNullable<NonNullable<Quality["sources"]>["effect"]>;
-
-export type Fragment = {
-  readonly file: typeof OXLINT_FRAGMENT | typeof TSCONFIG_FRAGMENT;
-  readonly extendedBy: string;
-  readonly reader: string;
-  readonly content: unknown;
-};
-
-export type GeneratedWorkflow = {
-  readonly file: typeof SUITE_WORKFLOW | typeof COMMITLINT_WORKFLOW;
-  readonly content: string;
-};
-
-export type WorkflowRecipe = {
-  readonly commitlintConfig: string;
-  readonly bunVersionFile: boolean;
-  readonly nodeVersionFile: boolean;
-};
-
-class NativeConfigUnreadable extends Schema.TaggedError<NativeConfigUnreadable>()("NativeConfigUnreadable", {
-  message: Schema.String,
-}) {}
-
-function oxlintFragment({ paths, exempt = [] }: EffectSources): unknown {
-  const override = {
-    files: paths,
-    ...(exempt.length === 0 ? {} : { excludeFiles: exempt }),
-    // An override that leaves out any of the kit's plugins turns on the category rules of the ones it adds.
-    plugins: [...kitOxlint.plugins, ...effectOxlint.plugins.filter((plugin) => !kitOxlint.plugins.includes(plugin))],
-    rules: effectOxlint.rules,
-  };
-  return {
-    $schema: "./node_modules/oxlint/configuration_schema.json",
-    // A config without plugins brings oxlint's default plugins into the one extending it.
-    plugins: kitOxlint.plugins,
-    overrides: [override],
-  };
-}
-
-function tsconfigFragment({ paths, exempt = [] }: EffectSources): unknown {
-  const override = { include: paths, ...(exempt.length === 0 ? {} : { exclude: exempt }), options: effectLanguageService };
-  return { compilerOptions: { plugins: [{ name: "@effect/language-service", overrides: [override] }] } };
-}
-
-const FRAGMENTS = [
-  {
-    file: OXLINT_FRAGMENT,
-    extendedBy: ".oxlintrc.json",
-    reader: "oxlint",
-    kitConfig: "./node_modules/@avi2dg/checks/oxlintrc.json",
-    kitRepositoryConfig: "./oxlintrc.json",
-    kitConfigReason: "so the kit's oxlint rules are not loaded",
-    build: oxlintFragment,
-  },
-  {
-    file: TSCONFIG_FRAGMENT,
-    extendedBy: "tsconfig.json",
-    reader: "the language service",
-    kitConfig: "@avi2dg/checks/tsconfig.effect.json",
-    kitRepositoryConfig: "./tsconfig.effect.json",
-    kitConfigReason: "the one accepted spelling of the kit's Effect config",
-    build: tsconfigFragment,
-  },
-] as const;
-
-export function fragmentsFor(quality: Quality): readonly Fragment[] {
-  const effect = quality.sources?.effect;
-  if (effect === undefined) return [];
-  return FRAGMENTS.map(({ file, extendedBy, reader, build }) => ({ file, extendedBy, reader, content: build(effect) }));
-}
-
-const OWN_COMMITLINT_CONFIG = "./commitlint.config.js";
-const KIT_COMMITLINT_CONFIG = "./node_modules/@avi2dg/checks/commitlint.config.js";
-
-function titleLint(commitlintConfig: string): string {
-  return `./node_modules/.bin/commitlint --config ${commitlintConfig} --edit "$RUNNER_TEMP/pr-title"`;
-}
-
-function runsInTitleLint(gate: string, commitlintConfig: string): boolean {
-  const words = plainCommand(gate);
-  return words !== undefined && invokes(plainCommand(titleLint(commitlintConfig)), words);
-}
-
-function runScalar(command: string): string {
-  return /(^[\s#&*!|>@`'"%{[-])|:\s|\s#|:$|[\n\\]/.test(command) ? JSON.stringify(command) : command;
-}
-
-export function commitlintWorkflow(commitlintConfig: string): string {
-  return `permissions:
-  contents: read
-on:
-  pull_request:
-    types: [opened, edited, synchronize, reopened]
-jobs:
-  commitlint:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v5
-      - uses: oven-sh/setup-bun@v2
-      - run: bun install --frozen-lockfile
-      # Only the title is linted: it is what a squash merge lands, with GitHub appending " (#N)" to it.
-      - run: printf '%s' "$PR_TITLE (#0000)" > "$RUNNER_TEMP/pr-title"
-        env:
-          PR_TITLE: \${{ github.event.pull_request.title }}
-      # A title starting with git's comment character lints as empty without this: commentChar moves off '#'.
-      - run: ${titleLint(commitlintConfig)}
-        env:
-          GIT_CONFIG_COUNT: "1"
-          GIT_CONFIG_KEY_0: core.commentChar
-          GIT_CONFIG_VALUE_0: "\\x01"
-`;
-}
-
-export function suiteWorkflow(defaultBranch: string, gates: readonly string[], bunVersionFile: boolean, nodeVersionFile: boolean): string {
-  const node = nodeVersionFile
-    ? "      - uses: actions/setup-node@v5\n        with:\n          node-version-file: .node-version\n"
-    : "";
-  const setup = bunVersionFile
-    ? "      - uses: oven-sh/setup-bun@v2\n        with:\n          bun-version-file: .bun-version\n"
-    : "      - uses: oven-sh/setup-bun@v2\n";
-  const steps = gates.map((gate) => `      - run: ${runScalar(gate)}\n`).join("");
-  return `name: ci\non:\n  push:\n    branches: [${defaultBranch}]\n  pull_request:\n    types: [opened, edited, synchronize, reopened]\njobs:\n  checks:\n    runs-on: ubuntu-latest\n    steps:\n      # The head, not GitHub's merge ref, so the tree the gates read is the commit the range ends at.\n      # The whole history, since the range starts where the head branched from the base branch.\n      - uses: actions/checkout@v5\n        with:\n          ref: \${{ github.event.pull_request.head.sha || github.sha }}\n          fetch-depth: 0\n${node}${setup}      - run: bun install --frozen-lockfile\n${steps}`;
-}
-
-export function workflowsFor(quality: Quality, recipe: WorkflowRecipe): readonly GeneratedWorkflow[] {
-  const commitlint: GeneratedWorkflow = {
-    file: COMMITLINT_WORKFLOW,
-    content: commitlintWorkflow(recipe.commitlintConfig),
-  };
-  if (quality.gates?.ci === undefined) return [commitlint];
-  const suite = quality.gates.ci.filter((gate) => !runsInTitleLint(gate, recipe.commitlintConfig));
-  return [
-    {
-      file: SUITE_WORKFLOW,
-      content: suiteWorkflow(quality.defaultBranch ?? DEFAULT_BRANCH, suite, recipe.bunVersionFile, recipe.nodeVersionFile),
-    },
-    commitlint,
-  ];
-}
-
-const NativeConfig = Schema.Struct({
-  extends: Schema.optionalKey(Schema.Union([Schema.String, Schema.Array(Schema.String)])),
-});
-const decodeNativeConfig = Schema.decodeUnknownEffect(NativeConfig);
-
-const parseJsonc = (text: string, file: string) =>
-  Effect.try({
-    try: (): unknown => Bun.JSONC.parse(text),
-    catch: (error) => new NativeConfigUnreadable({ message: `cannot parse ${file}: ${String(error)}` }),
-  });
-
-const extendsOf = Effect.fn("extendsOf")(function* (root: string, file: string) {
-  const fs = yield* FileSystem.FileSystem;
-  const path = yield* Path.Path;
-  const target = path.join(root, file);
-  if (!(yield* fs.exists(target))) return [];
-  const config = yield* fs.readFileString(target).pipe(
-    Effect.flatMap((text) => parseJsonc(text, file)),
-    Effect.flatMap(decodeNativeConfig),
-    Effect.mapError((cause) => new NativeConfigUnreadable({ message: `cannot read extends from ${file}: ${cause.message}` })),
-  );
-  const listed = config.extends ?? [];
-  return (typeof listed === "string" ? [listed] : listed).map((entry) => path.normalize(entry));
-});
-
-const decodeJson = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Unknown));
-
-const sameJson = (text: string, content: unknown): Effect.Effect<boolean> =>
-  decodeJson(text).pipe(
-    Effect.map((parsed) => Bun.deepEquals(parsed, content, true)),
-    Effect.orElseSucceed(() => false),
-  );
-
-const decodePackageName = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Struct({ name: Schema.optionalKey(Schema.String) })));
-
-const isKit = Effect.fn("isKit")(function* (root: string) {
-  const fs = yield* FileSystem.FileSystem;
-  const manifest = (yield* Path.Path).join(root, "package.json");
-  if (!(yield* fs.exists(manifest))) return false;
-  const { name } = yield* decodePackageName(yield* fs.readFileString(manifest)).pipe(
-    Effect.mapError((cause) => new QualityUnreadable({ message: `package.json: ${cause.message}` })),
-  );
-  return name === kitManifest.name;
-});
-
-const fragmentProblems = Effect.fn("fragmentProblems")(function* (root: string, source: string, expected: readonly Fragment[]) {
-  const fs = yield* FileSystem.FileSystem;
-  const path = yield* Path.Path;
-  const problems: string[] = [];
-  const kitRepository = yield* isKit(root);
-  for (const { file, extendedBy, reader, kitConfig, kitRepositoryConfig, kitConfigReason } of FRAGMENTS) {
-    const target = path.join(root, file);
-    const fragment = expected.find((candidate) => candidate.file === file);
-    const present = yield* fs.exists(target);
-    if (fragment === undefined) {
-      if (present) problems.push(`${file} is left over, since no sources.effect is declared; run ${GENERATE}`);
-      continue;
-    }
-    if (!present) {
-      problems.push(`${file} is missing; run ${GENERATE}`);
-    } else if (!(yield* sameJson(yield* fs.readFileString(target), fragment.content))) {
-      problems.push(`${file} is stale against ${source} and the kit's presets; run ${GENERATE}`);
-    }
-    const configured = yield* extendsOf(root, extendedBy);
-    if (!configured.includes(file)) {
-      problems.push(`${extendedBy} does not extend ./${file}, so ${reader} never reads it`);
-    }
-    const requiredKitConfig = kitRepository ? kitRepositoryConfig : kitConfig;
-    if (!configured.includes(path.normalize(requiredKitConfig))) {
-      problems.push(`${extendedBy} does not extend ${requiredKitConfig}, ${kitConfigReason}`);
-    }
-  }
-  return problems;
-});
-
-const unmatchedPaths = Effect.fn("unmatchedPaths")(function* (root: string, quality: Quality) {
-  const declared = [
-    ...(quality.sources?.production ?? []).map((glob) => ({
-      glob,
-      key: "sources.production",
-      holds: "no source to checks-size-budget or checks-repetition",
-    })),
-    ...(quality.sources?.effect?.paths ?? []).map((glob) => ({ glob, key: "sources.effect.paths", holds: "nothing to the Effect rules" })),
-  ];
-  const problems: string[] = [];
-  for (const { glob, key, holds } of declared) {
-    const matched = yield* git(["ls-files", "--cached", "--others", "--exclude-standard", "--", `:(glob)${glob}`], root);
-    if (matched.trim() === "") problems.push(`${key} ${glob} matches no file, so it holds ${holds}`);
-  }
-  return problems;
-});
-
-const recipeOf = Effect.fn("recipeOf")(function* (root: string) {
-  const fs = yield* FileSystem.FileSystem;
-  const path = yield* Path.Path;
-  return {
-    // The kit never installs itself, so its own tree lints with its root config.
-    commitlintConfig: (yield* isKit(root)) ? OWN_COMMITLINT_CONFIG : KIT_COMMITLINT_CONFIG,
-    bunVersionFile: yield* fs.exists(path.join(root, ".bun-version")),
-    nodeVersionFile: yield* fs.exists(path.join(root, ".node-version")),
-  } satisfies WorkflowRecipe;
-});
-
-const workflowProblems = Effect.fn("workflowProblems")(function* (
-  root: string,
-  source: string,
-  expected: readonly GeneratedWorkflow[],
-) {
-  const fs = yield* FileSystem.FileSystem;
-  const path = yield* Path.Path;
-  const problems: string[] = [];
-  for (const { file, content } of expected) {
-    const target = path.join(root, file);
-    if (!(yield* fs.exists(target))) {
-      problems.push(`${file} is missing; run ${GENERATE}`);
-    } else if ((yield* fs.readFileString(target)) !== content) {
-      problems.push(`${file} is stale against ${source} and the kit recipe; run ${GENERATE}`);
-    }
-  }
-  return problems;
-});
-
-const check = Effect.fn("check")(function* (root: string) {
-  const { source, quality } = yield* readQuality(root);
-  const expected = fragmentsFor(quality);
-  const workflows = workflowsFor(quality, yield* recipeOf(root));
-  const problems = [
-    ...(yield* fragmentProblems(root, source, expected)),
-    ...(yield* workflowProblems(root, source, workflows)),
-    ...(yield* unmatchedPaths(root, quality)),
-  ];
-  if (problems.length > 0) {
-    yield* Console.error([`${NAME}: ${problems.length} problem(s) with what ${source} declares:`, ...problems.map((line) => `  ${line}`)].join("\n"));
-    return false;
-  }
-  const held = [...expected.map((fragment) => fragment.file), ...workflows.map((workflow) => workflow.file)];
-  const verb = held.length === 1 ? "holds" : "hold";
-  yield* Console.log(
-    expected.length === 0
-      ? `${NAME}: no sources.effect is declared, so no fragment is generated; ${held.join(" and ")} ${verb} the kit recipe`
-      : `${NAME}: ${held.join(" and ")} ${verb} what ${source} declares`,
-  );
-  return true;
-});
-
-const generate = Effect.fn("generate")(function* (root: string) {
-  const fs = yield* FileSystem.FileSystem;
-  const path = yield* Path.Path;
-  const { quality } = yield* readQuality(root);
-  const expected = fragmentsFor(quality);
-  for (const { file } of FRAGMENTS) {
-    const target = path.join(root, file);
-    const fragment = expected.find((candidate) => candidate.file === file);
-    if (fragment !== undefined) {
-      yield* fs.writeFileString(target, renderJson(fragment.content));
-      yield* Console.log(`${NAME}: wrote ${file}`);
-    } else if (yield* fs.exists(target)) {
-      yield* fs.remove(target);
-      yield* Console.log(`${NAME}: removed ${file}`);
-    }
-  }
-  const workflows = workflowsFor(quality, yield* recipeOf(root));
-  yield* fs.makeDirectory(path.join(root, ".github", "workflows"), { recursive: true });
-  for (const { file, content } of workflows) {
-    yield* fs.writeFileString(path.join(root, file), content);
-    yield* Console.log(`${NAME}: wrote ${file}`);
-  }
-  return yield* check(root);
-});
-
-const main = Effect.gen(function* () {
-  const [mode, ...extra] = process.argv.slice(2);
-  if (extra.length > 0 || (mode !== "--check" && mode !== "generate")) return yield* new Usage({ message: USAGE });
-  const root = (yield* git(["rev-parse", "--show-toplevel"])).trim();
-  return mode === "generate" ? yield* generate(root) : yield* check(root);
-});
-
-if (import.meta.main) runMain(NAME, main);