@avi2dg/checks 0.21.0 → 0.23.0

package/scripts/ci-wiring.ts

@@ -1,9 +1,8 @@
 #!/usr/bin/env bun
 import { Console, Effect, FileSystem, Path, Schema } from "effect";
-import { git } from "./git.ts";
+import { defaultBranch, git } from "./git.ts";
 import { runMain } from "./main.ts";
-import { DEFAULT_BRANCH, ENTRY_POINT, EVERY_REPOSITORY, KIT_GATES, QUALITY_FILE, selectedGates, type KitGate } from "./gates.ts";
-import { readQuality, type Quality } from "./quality-file.ts";
+import { ENTRY_POINT, KIT_GATES, type KitGate } from "./gates.ts";
 import { invokes, mentions, plainCommand, type Command } from "./shell-command.ts";
 
 export type { Command };
@@ -15,7 +14,6 @@ export type Gate = {
 
 export type Declaration = {
   readonly gates: readonly Gate[];
-  readonly scheduled: readonly Gate[];
   readonly defaultBranch: string;
   readonly lintGates: readonly KitGate[];
 };
@@ -30,12 +28,6 @@ export type BlockedInvocation = {
   readonly blocker: string;
 };
 
-export type Omission = {
-  readonly gate: string;
-  readonly content: string;
-  readonly files: readonly [string, ...string[]];
-};
-
 export type Gap = {
   readonly gate: string;
   readonly entryPoint?: string;
@@ -55,6 +47,10 @@ export class WiringError extends Schema.TaggedError<WiringError>()("WiringError"
 }) {}
 
 const WORKFLOWS = ".github/workflows";
+const SCRIPTED = ["lint", "build", "typecheck", "test"];
+const BUILT_TREE = "git diff --exit-code";
+const TITLE_LINT = "./node_modules/.bin/commitlint";
+const Manifest = Schema.Struct({ scripts: Schema.optionalKey(Schema.Record(Schema.String, Schema.String)) });
 // Without these a pull_request workflow never sees the commits a pull request pushes.
 const GATING_TYPES = ["opened", "synchronize"];
 const CONSTANTS = new Map([
@@ -120,13 +116,6 @@ const pullRequestTrigger = (branch: string): Trigger => (workflow) => {
   return undefined;
 };
 
-const scheduleTrigger: Trigger = (workflow) => {
-  const on = isRecord(workflow.document) ? workflow.document["on"] : undefined;
-  const schedule = isRecord(on) ? on["schedule"] : undefined;
-  const crons = Array.isArray(schedule) ? schedule.filter((entry) => isRecord(entry) && typeof entry["cron"] === "string") : [];
-  return crons.length > 0 ? undefined : `${workflow.path} does not trigger on a schedule`;
-};
-
 // GitHub prefixes any other if: with success(), so only a status function overrides a needed job's skip.
 function skippedBy(jobs: Readonly<Record<string, unknown>>, id: string, seen: readonly string[]): string | undefined {
   const job = jobs[id];
@@ -219,10 +208,6 @@ export function findGaps(declaration: Declaration, workflows: readonly Workflow[
   return gapsAmong(declaration.gates, runSteps(workflows, pullRequestTrigger(declaration.defaultBranch)), declaration.lintGates);
 }
 
-export function findScheduledGaps(declaration: Declaration, workflows: readonly Workflow[]): readonly Gap[] {
-  return gapsAmong(declaration.scheduled, runSteps(workflows, scheduleTrigger), declaration.lintGates);
-}
-
 function gapLines(gaps: readonly Gap[]): readonly string[] {
   const lines: string[] = [];
   for (const gap of gaps) {
@@ -241,73 +226,21 @@ export function formatReport(declaration: Declaration, gaps: readonly Gap[]): st
   return [`ci-wiring: ${gaps.length} of ${declaration.gates.length} gate(s) do not run on ${target}:`, ...gapLines(gaps)].join("\n");
 }
 
-export function formatScheduledReport(declaration: Declaration, gaps: readonly Gap[]): string {
-  const total = declaration.scheduled.length;
-  if (gaps.length === 0) return `ci-wiring: ${total} scheduled command(s) run on a schedule`;
-  return [`ci-wiring: ${gaps.length} of ${total} scheduled command(s) do not run on a schedule:`, ...gapLines(gaps)].join("\n");
+export function requiredCommands(scripts: readonly string[]): readonly string[] {
+  return [
+    ...SCRIPTED.filter((name) => scripts.includes(name)).flatMap((name) =>
+      name === "build" ? [`bun run ${name}`, BUILT_TREE] : [`bun run ${name}`],
+    ),
+    TITLE_LINT,
+  ];
 }
 
-const plainCommands = Effect.fnUntraced(function* (
-  listed: readonly string[],
-  subject: string,
-): Effect.fn.Return<readonly Gate[], WiringError> {
-  const gates: Gate[] = [];
-  for (const command of listed) {
-    const words = plainCommand(command);
-    if (words === undefined) {
-      return yield* new WiringError({ message: `${subject} ${JSON.stringify(command)} is not one plain command` });
-    }
-    gates.push({ command, words });
-  }
-  return gates;
-});
-
-export const parseDeclaration = Effect.fnUntraced(function* (
-  { defaultBranch, gates: declared }: Quality,
-  source: string,
-): Effect.fn.Return<Declaration, WiringError> {
-  if (declared?.ci === undefined) {
-    return yield* new WiringError({ message: `${QUALITY_FILE} declares no gates.ci, a non-empty array of commands` });
-  }
+export function declarationFor(scripts: readonly string[], branch: string): Declaration {
   return {
-    gates: yield* plainCommands(declared.ci, `${source} gate`),
-    scheduled: yield* plainCommands(declared.scheduled ?? [], `${source} scheduled command`),
-    defaultBranch: defaultBranch ?? DEFAULT_BRANCH,
-    lintGates: selectedGates(declared.lint),
+    gates: requiredCommands(scripts).map((command) => ({ command, words: command.split(" ") })),
+    defaultBranch: branch,
+    lintGates: KIT_GATES,
   };
-});
-
-function omittedFrom(lintGates: readonly KitGate[]): readonly KitGate[] {
-  return KIT_GATES.filter((gate) => !lintGates.includes(gate));
-}
-
-export const findOmissions = Effect.fn("findOmissions")(function* (root: string, lintGates: readonly KitGate[]) {
-  const omissions: Omission[] = [];
-  for (const gate of omittedFrom(lintGates)) {
-    // LintGates refuses a selection that leaves out a gate every repository runs.
-    if (gate.appliesTo === EVERY_REPOSITORY) continue;
-    const { pathspecs, content } = gate.appliesTo;
-    const [first, ...rest] = (yield* git(["ls-files", "-z", "--", ...pathspecs], root)).split("\0").filter(Boolean);
-    if (first !== undefined) omissions.push({ gate: gate.bin, content, files: [first, ...rest] });
-  }
-  return omissions;
-});
-
-function sample([first, ...rest]: Omission["files"]): string {
-  return rest.length === 0 ? first : `${first} and ${rest.length} more`;
-}
-
-export function formatOmissions(lintGates: readonly KitGate[], omissions: readonly Omission[]): string | undefined {
-  const omitted = omittedFrom(lintGates);
-  if (omitted.length === 0) return undefined;
-  if (omissions.length === 0) {
-    const bins = omitted.map((gate) => gate.bin).join(", ");
-    return `ci-wiring: ${QUALITY_FILE} gates.lint leaves out ${bins}, none of which this repository's contents make applicable`;
-  }
-  return [
-    `ci-wiring: ${QUALITY_FILE} gates.lint leaves out ${omissions.length} gate(s) this repository's contents make applicable:`,
-    ...omissions.map(({ gate, content, files }) => `  ${gate}: the repository tracks ${content} (${sample(files)})`),
-  ].join("\n");
 }
 
 export const parseWorkflow = (path: string, text: string): Effect.Effect<Workflow, WiringError> =>
@@ -317,8 +250,15 @@ export const parseWorkflow = (path: string, text: string): Effect.Effect<Workflo
   });
 
 export const readDeclaration = Effect.fn("readDeclaration")(function* (root: string) {
-  const { source, quality } = yield* readQuality(root);
-  return yield* parseDeclaration(quality, source);
+  const fs = yield* FileSystem.FileSystem;
+  const file = (yield* Path.Path).join(root, "package.json");
+  const { scripts = {} } = (yield* fs.exists(file))
+    ? yield* fs.readFileString(file).pipe(
+        Effect.flatMap(Schema.decodeUnknownEffect(Schema.fromJsonString(Manifest))),
+        Effect.mapError((cause) => new WiringError({ message: `cannot read ${file}: ${cause.message}` })),
+      )
+    : Manifest.make({});
+  return declarationFor(Object.keys(scripts), yield* defaultBranch(root));
 });
 
 export const readWorkflows = Effect.fn("readWorkflows")(function* (root: string) {
@@ -338,21 +278,12 @@ export const readWorkflows = Effect.fn("readWorkflows")(function* (root: string)
 
 const wiring = Effect.gen(function* () {
   const root = (yield* git(["rev-parse", "--show-toplevel"])).trim();
-  const declaration = yield* readDeclaration(root);
   const workflows = yield* readWorkflows(root);
+  const declaration = yield* readDeclaration(root);
   const gaps = findGaps(declaration, workflows);
-  const omissions = yield* findOmissions(root, declaration.lintGates);
   const gapReport = formatReport(declaration, gaps);
   yield* gaps.length > 0 ? Console.error(gapReport) : Console.log(gapReport);
-  const omissionReport = formatOmissions(declaration.lintGates, omissions);
-  if (omissionReport !== undefined) {
-    yield* omissions.length > 0 ? Console.error(omissionReport) : Console.log(omissionReport);
-  }
-  if (declaration.scheduled.length === 0) return gaps.length === 0 && omissions.length === 0;
-  const scheduledGaps = findScheduledGaps(declaration, workflows);
-  const scheduledReport = formatScheduledReport(declaration, scheduledGaps);
-  yield* scheduledGaps.length > 0 ? Console.error(scheduledReport) : Console.log(scheduledReport);
-  return gaps.length === 0 && omissions.length === 0 && scheduledGaps.length === 0;
+  return gaps.length === 0;
 });
 
 if (import.meta.main) runMain("ci-wiring", wiring);

package/scripts/commit-identity.ts

@@ -1,8 +1,9 @@
 #!/usr/bin/env bun
-import { Console, Effect, Schema } from "effect";
+import { Console, Effect, FileSystem, Path, Schema } from "effect";
 import { git, refArgs } from "./git.ts";
 import { runMain } from "./main.ts";
-import { readQuality, type Identity } from "./quality-file.ts";
+
+type Identity = { readonly name: string; readonly email: string };
 
 type Commit = {
   readonly sha: string;
@@ -38,9 +39,36 @@ function render(identity: Identity): string {
   return `${identity.name} <${identity.email}>`;
 }
 
+const Person = Schema.Union([
+  Schema.String,
+  Schema.Struct({
+    name: Schema.String,
+    email: Schema.optionalKey(Schema.String),
+    url: Schema.optionalKey(Schema.String),
+  }),
+]);
+const Authors = Schema.Struct({
+  author: Schema.optionalKey(Person),
+  contributors: Schema.optionalKey(Schema.Array(Person)),
+});
+
+function identityOf(person: typeof Person.Type): Identity | undefined {
+  const name = typeof person === "string" ? (/^[^(<]*/.exec(person)?.[0] ?? "").trim() : person.name;
+  const email = typeof person === "string" ? /<([^<>]+)>/.exec(person)?.[1] : person.email;
+  return name === "" || email === undefined || email === "" ? undefined : { name, email };
+}
+
 const allowedAuthors = Effect.gen(function* () {
-  const { quality } = yield* readQuality((yield* git(["rev-parse", "--show-toplevel"])).trim());
-  return quality.commitIdentity?.authors ?? DEFAULT_AUTHORS;
+  const root = (yield* git(["rev-parse", "--show-toplevel"])).trim();
+  const fs = yield* FileSystem.FileSystem;
+  const file = (yield* Path.Path).join(root, "package.json");
+  if (!(yield* fs.exists(file))) return DEFAULT_AUTHORS;
+  const manifest = yield* fs.readFileString(file).pipe(Effect.flatMap(Schema.decodeUnknownEffect(Schema.fromJsonString(Authors))));
+  const listed = [manifest.author, ...(manifest.contributors ?? [])]
+    .filter((entry) => entry !== undefined)
+    .map(identityOf)
+    .filter((entry) => entry !== undefined);
+  return listed.length === 0 ? DEFAULT_AUTHORS : listed;
 });
 
 const readCommits = Effect.fn("readCommits")(function* (revisions: readonly string[]) {

package/scripts/doc-rules.ts

@@ -1,3 +1,4 @@
+import { Option, Result, Schema } from "effect";
 import {
   firstText,
   marked,
@@ -10,14 +11,12 @@ import {
   type Violation,
   VERSION,
 } from "./doc-outline.ts";
-import { ADR_STATUSES, TEMPLATES, templateFile, type Kind, type Title } from "./doc-templates.ts";
+import { ADR_STATUSES, MODES, TEMPLATES, templateFile, type Kind, type Title } from "./doc-templates.ts";
 import { ADR_DIRECTORY, DOCS_DIRECTORY } from "./prose-matchers.ts";
-import { MODES, type Docs, type Mode } from "./quality-file.ts";
 
 export type Placement =
   | { readonly type: "judged"; readonly kind: Kind }
   | { readonly type: "undeclared" }
-  | { readonly type: "ambiguous"; readonly modes: readonly Mode[] }
   | { readonly type: "unjudged" };
 
 export type Doc = {
@@ -37,14 +36,29 @@ export const ROOT_FILES: ReadonlyMap<string, Kind> = new Map<string, Kind>([
   ["CONTRIBUTING.md", "how-to"],
 ]);
 
-export function placementOf(path: string, docs: Docs | undefined): Placement {
+const FRONT_MATTER = /^---\r?\n(?:([\s\S]*?)\r?\n)?(?:---|\.\.\.)[ \t]*(?:\r?\n|$)/;
+const Fields = Schema.Struct({ kind: Schema.optionalKey(Schema.String), audience: Schema.optionalKey(Schema.String) });
+const decodeFields = Schema.decodeUnknownOption(Fields);
+
+function frontMatterOf(text: string): { readonly text: string; readonly fields: typeof Fields.Type } {
+  const match = FRONT_MATTER.exec(text);
+  if (match === null) return { text: "", fields: {} };
+  const parsed = Result.getOrUndefined(Result.try(() => Bun.YAML.parse(match[1] ?? "")));
+  return { text: match[0], fields: Option.getOrElse(decodeFields(parsed), () => ({})) };
+}
+
+export function speaksToConsumers(text: string): boolean {
+  return frontMatterOf(text).fields.audience === "consumers";
+}
+
+export function placementOf(path: string, text = ""): Placement {
   const root = ROOT_FILES.get(path);
   if (root !== undefined) return { type: "judged", kind: root };
   if (!path.endsWith(".md") || path === ADR_INDEX) return { type: "unjudged" };
   if (path.startsWith(ADR_DIRECTORY)) return { type: "judged", kind: "adr" };
-  const modes = MODES.filter((mode) => (docs?.pages?.[mode] ?? []).some((glob) => new Bun.Glob(glob).match(path)));
-  const [mode, ...others] = modes;
-  if (mode !== undefined) return others.length === 0 ? { type: "judged", kind: mode } : { type: "ambiguous", modes };
+  const named = frontMatterOf(text).fields.kind;
+  const mode = MODES.find((known) => known === named);
+  if (mode !== undefined) return { type: "judged", kind: mode };
   return path.startsWith(DOCS_DIRECTORY) ? { type: "undeclared" } : { type: "unjudged" };
 }
 
@@ -171,20 +185,21 @@ function exactProblems(kind: Kind, expected: string, actual: string): readonly V
 export function judge(kind: Kind, doc: Doc, records: readonly string[]): readonly Violation[] {
   const template = TEMPLATES[kind];
   if (template.shape === "exact") return exactProblems(kind, template.text, doc.text);
-  const outline = parseOutline(doc.text);
+  const frontMatter = frontMatterOf(doc.text).text;
+  const outline = parseOutline(doc.text.slice(frontMatter.length));
+  const lineOffset = frontMatter === "" ? 0 : frontMatter.split("\n").length - 1;
   const title = titleOf(outline);
   return [
     ...outlineProblems(outline),
     ...(title === undefined ? [] : titleProblems(template.title, title)),
     ...matchSections(outline.sections, template.sections, 2, title?.line ?? 1),
     ...kindProblems(kind, doc, outline, records),
-  ].toSorted((a, b) => a.line - b.line);
+  ].map(({ line, message }) => ({ line: line + lineOffset, message })).toSorted((a, b) => a.line - b.line);
 }
 
 export function placementProblem(placement: Placement): string | undefined {
   if (placement.type === "undeclared") {
-    return `is a page under ${DOCS_DIRECTORY} with no mode; declare it under docs.pages in quality.json as ${MODES.join(", ")}`;
+    return `is a page under ${DOCS_DIRECTORY} with no mode; add kind: ${MODES.join(", ")} in YAML front matter`;
   }
-  if (placement.type === "ambiguous") return `is declared under docs.pages as ${placement.modes.join(" and ")}, and a page has one mode`;
   return undefined;
 }

package/scripts/doc-templates.ts

@@ -1,5 +1,6 @@
 import { slotLabel, type FixedSlot, type HeadingRule, type OpenSlot, type Presence, type Slot } from "./doc-outline.ts";
-import { MODES } from "./quality-file.ts";
+
+export const MODES = ["tutorial", "how-to", "reference", "explanation"] as const;
 
 export const KINDS = ["readme", "changelog", "adr", "agents", "claude", ...MODES] as const;
 export type Kind = (typeof KINDS)[number];

package/scripts/docs.ts

@@ -1,12 +1,11 @@
 #!/usr/bin/env bun
 import { Console, Effect } from "effect";
 import { rootsOf, unresolvedIn, type Judging, type Unresolved } from "./doc-references.ts";
-import { ADR_DIRECTORY, judge, placementOf, placementProblem, type Placement } from "./doc-rules.ts";
+import { ADR_DIRECTORY, judge, placementOf, placementProblem, speaksToConsumers, type Placement } from "./doc-rules.ts";
 import { readTexts, snapshotAt, stillMissing } from "./doc-snapshot.ts";
 import { changedLines, changedPaths, git, pathsAt, rangeEnds, refArgs } from "./git.ts";
 import { runMain } from "./main.ts";
 import { isLivingDoc, proseFindings, readerOf } from "./prose-matchers.ts";
-import { readQuality } from "./quality-file.ts";
 
 type Finding = {
   readonly path: string;
@@ -82,29 +81,27 @@ const referenceFindings = Effect.fn("referenceFindings")(function* (range: Range
 });
 
 const runDocs = Effect.fn("runDocs")(function* (root: string, base: string, head: string) {
-  const { quality } = yield* readQuality(root);
   const changes = yield* changedPaths(base, head, MARKDOWN, root);
   const touched = new Set(changes.flatMap((change) => (change.kind === "deleted" ? [] : [change.path])));
   const renamedFrom = new Map(changes.flatMap((change) => (change.kind === "renamed" ? [[change.path, change.from] as const] : [])));
   const changed = yield* changedLines(base, head, MARKDOWN, root);
   const present = yield* pathsAt(head, MARKDOWN, root);
   const records = present.filter((path) => path.startsWith(ADR_DIRECTORY));
-  const judged = present.map((path) => ({ path, placement: placementOf(path, quality.docs) })).filter(({ placement }) => placement.type !== "unjudged");
   const living = present.filter(isLivingDoc);
   const proseDocs = present.flatMap((path) => {
     const reader = readerOf(path);
     return reader === undefined ? [] : [{ path, reader }];
   });
-  const texts = yield* readTexts(root, head, [...new Set([...judged.map(({ path }) => path), ...proseDocs.map(({ path }) => path)])]);
+  const texts = yield* readTexts(root, head, [...new Set([...present.filter((path) => path.endsWith(".md")), ...proseDocs.map(({ path }) => path)])]);
   const text = (path: string): string => texts.get(path) ?? "";
+  const judged = present.map((path) => ({ path, placement: placementOf(path, text(path)) })).filter(({ placement }) => placement.type !== "unjudged");
 
   const templated = judged.flatMap(({ path, placement }) => templateFindings(path, text(path), placement, records));
   const edited = proseDocs.filter(({ path }) => changed.has(path));
   const prose = edited.flatMap(({ path, reader }) =>
     proseFindings(text(path), reader, changed.get(path)).map(({ line, message }) => ({ path, line, message })),
   );
-  const forConsumers = (quality.docs?.forConsumers ?? []).map((glob) => new Bun.Glob(glob));
-  const judging = (path: string): Judging => ({ commands: !forConsumers.some((glob) => glob.match(path)) });
+  const judging = (path: string): Judging => ({ commands: !speaksToConsumers(text(path)) });
   // A directory the range deletes still belongs to this repository, so a path under it is stale rather than another repository's.
   const roots = rootsOf(yield* pathsAt(base, [], root));
   const references = yield* referenceFindings(

package/scripts/gates.ts

@@ -1,5 +1,3 @@
-import { Schema } from "effect";
-
 export type Program = {
   readonly bin: string;
   readonly script: string;
@@ -24,12 +22,8 @@ export const TEST_ENTRY_POINT: Program = { bin: "checks-test", script: "test.ts"
 
 export const DEFAULT_BRANCH = "main";
 
-export const QUALITY_FILE = "quality.json";
-
 const TYPESCRIPT_SOURCE: TrackedContent = { pathspecs: ["*.ts", "*.tsx"], content: "TypeScript source" };
 
-const QUALITY_DECLARATION: TrackedContent = { pathspecs: [QUALITY_FILE], content: `a ${QUALITY_FILE}` };
-
 export const KIT_GATES = [
   { bin: "checks-lint-coverage", script: "lint-coverage.sh", reads: "tree", appliesTo: TYPESCRIPT_SOURCE },
   { bin: "checks-test-layout", script: "test-layout.ts", reads: "tree", appliesTo: TYPESCRIPT_SOURCE },
@@ -38,29 +32,6 @@ export const KIT_GATES = [
   { bin: "checks-suppressions-ratchet", script: "suppressions-ratchet.ts", reads: "range", appliesTo: EVERY_REPOSITORY },
   { bin: "checks-ci-wiring", script: "ci-wiring.ts", reads: "tree", appliesTo: EVERY_REPOSITORY },
   { bin: "checks-docs", script: "docs.ts", reads: "range", appliesTo: EVERY_REPOSITORY },
-  { bin: "checks-quality", script: "quality.ts", reads: "tree", args: ["--check"], appliesTo: QUALITY_DECLARATION },
-  { bin: "checks-size-budget", script: "size-budget.ts", reads: "range", appliesTo: TYPESCRIPT_SOURCE },
   { bin: "checks-repetition", script: "repetition.ts", reads: "range", appliesTo: TYPESCRIPT_SOURCE },
-  { bin: "checks-feature-owners", script: "feature-owners.ts", reads: "range", appliesTo: TYPESCRIPT_SOURCE },
   { bin: "checks-quarantine-clock", script: "quarantine-clock.ts", reads: "range", appliesTo: EVERY_REPOSITORY },
 ] as const satisfies readonly KitGate[];
-
-const UNCONDITIONAL = KIT_GATES.filter((gate) => gate.appliesTo === EVERY_REPOSITORY).map((gate) => gate.bin);
-
-// A selection without ci-wiring would go unchecked under checks-lint, so a gate every repository runs
-// is refused where checks-lint decodes the selection, not by ci-wiring.
-export const LintGates = Schema.Array(Schema.Literals(KIT_GATES.map((gate) => gate.bin))).check(
-  Schema.makeFilter(
-    (selected) => {
-      const missing = UNCONDITIONAL.filter((bin) => !selected.includes(bin));
-      if (missing.length === 0) return true;
-      const verb = missing.length === 1 ? "applies" : "apply";
-      return `checks-lint must run ${missing.join(", ")}, which ${verb} to ${EVERY_REPOSITORY}`;
-    },
-    { toJsonSchema: () => ({ allOf: UNCONDITIONAL.map((bin) => ({ contains: { const: bin } })) }) },
-  ),
-);
-
-export function selectedGates(lintGates: typeof LintGates.Type | undefined): readonly KitGate[] {
-  return lintGates === undefined ? KIT_GATES : KIT_GATES.filter((gate) => lintGates.includes(gate.bin));
-}

package/scripts/git.ts

@@ -1,5 +1,6 @@
-import { Effect, Path, Schema, Stream } from "effect";
+import { Config, Effect, FileSystem, Path, Schema, Stream } from "effect";
 import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
+import { DEFAULT_BRANCH } from "./gates.ts";
 import { Usage } from "./main.ts";
 
 export class GitFailure extends Schema.TaggedError<GitFailure>()("GitFailure", {
@@ -37,6 +38,28 @@ export const git = Effect.fn("git")(function* (args: readonly string[], cwd?: st
   return stdout;
 });
 
+const decodeEventRepository = Schema.decodeUnknownEffect(
+  Schema.fromJsonString(Schema.Struct({ repository: Schema.Struct({ default_branch: Schema.NonEmptyString }) })),
+);
+
+// actions/checkout records no remote HEAD, so a push run in CI reads the branch from GitHub's event instead.
+export const defaultBranch = Effect.fn("defaultBranch")(function* (cwd?: string) {
+  const base = yield* Config.String("GITHUB_BASE_REF").pipe(Config.withDefault(""));
+  if (base !== "") return base;
+  const recorded = yield* git(["symbolic-ref", "--quiet", "--short", "refs/remotes/origin/HEAD"], cwd).pipe(
+    Effect.map((ref) => ref.trim().replace(/^origin\//, "")),
+    Effect.catchTag("GitFailure", () => Effect.succeed("")),
+  );
+  if (recorded !== "") return recorded;
+  const eventPath = yield* Config.String("GITHUB_EVENT_PATH").pipe(Config.withDefault(""));
+  if (eventPath === "") return DEFAULT_BRANCH;
+  return yield* (yield* FileSystem.FileSystem).readFileString(eventPath).pipe(
+    Effect.flatMap(decodeEventRepository),
+    Effect.map(({ repository }) => repository.default_branch),
+    Effect.orElseSucceed(() => DEFAULT_BRANCH),
+  );
+});
+
 export type Change =
   | { readonly kind: "written" | "deleted"; readonly path: string }
   | { readonly kind: "renamed"; readonly from: string; readonly path: string; readonly edited: boolean };

package/scripts/lint.ts

@@ -1,10 +1,9 @@
 #!/usr/bin/env bun
 import { Config, Console, Effect, FileSystem, Option, Path, Schema } from "effect";
 import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
-import { DEFAULT_BRANCH, selectedGates, type KitGate } from "./gates.ts";
-import { git } from "./git.ts";
+import { EVERY_REPOSITORY, KIT_GATES, type KitGate } from "./gates.ts";
+import { defaultBranch, git } from "./git.ts";
 import { runMain, Usage } from "./main.ts";
-import { readQuality } from "./quality-file.ts";
 
 type Range = {
   readonly refs: readonly [tip: string] | readonly [base: string, head: string];
@@ -56,17 +55,6 @@ const pullRequestEnds = Effect.fn("pullRequestEnds")(function* (eventPath: strin
   return pullRequestEndsOf(pullRequest);
 });
 
-const readWiring = Effect.gen(function* () {
-  const { source, quality } = yield* readQuality((yield* git(["rev-parse", "--show-toplevel"])).trim());
-  return { source, defaultBranch: quality.defaultBranch ?? DEFAULT_BRANCH, lintGates: quality.gates?.lint };
-});
-
-// Decides the base ref `git symbolic-ref` already resolved, or the repository's declared
-// default branch when that ref is absent, such as a checkout with no remote HEAD symlink.
-export function originRefOf(symbolicRef: string | undefined, defaultBranch: string): string {
-  return symbolicRef ?? `origin/${defaultBranch}`;
-}
-
 // A clone holding any remote-tracking ref but not the default branch is a shallow CI checkout,
 // where judging HEAD alone would pass every commit before it unchecked. No origin ref means no remote-tracking ref at all.
 export function localEndsOf(originRef: string | undefined): { base: string; head: string; source: string } {
@@ -74,18 +62,11 @@ export function localEndsOf(originRef: string | undefined): { base: string; head
   return { base: originRef, head: "HEAD", source: `HEAD against ${originRef}` };
 }
 
-const originRef = (defaultBranch: string) =>
-  git(["symbolic-ref", "--quiet", "--short", "refs/remotes/origin/HEAD"]).pipe(
-    Effect.map((ref) => ref.trim()),
-    Effect.catchTag("GitFailure", () => Effect.succeed(undefined)),
-    Effect.map((symbolicRef) => originRefOf(symbolicRef, defaultBranch)),
-  );
-
-const localEnds = Effect.fn("localEnds")(function* (defaultBranch: string) {
+const localEnds = Effect.gen(function* () {
   const remoteTracking = yield* git(["for-each-ref", "--count=1", "refs/remotes/"]).pipe(
     Effect.mapError((cause) => new RangeUnresolved({ message: cause.message })),
   );
-  return localEndsOf(remoteTracking.trim() === "" ? undefined : yield* originRef(defaultBranch));
+  return localEndsOf(remoteTracking.trim() === "" ? undefined : `origin/${yield* defaultBranch()}`);
 });
 
 // Decides which source of range ends the arguments and the pull request env vars select,
@@ -107,7 +88,7 @@ export function selectEnds(args: readonly string[], eventName: string | undefine
   return { kind: "local" };
 }
 
-const endsOf = Effect.fn("endsOf")(function* (args: readonly string[], defaultBranch: string) {
+const endsOf = Effect.fn("endsOf")(function* (args: readonly string[]) {
   const event = yield* Config.all({
     name: Config.option(Config.String("GITHUB_EVENT_NAME")),
     path: Config.option(Config.String("GITHUB_EVENT_PATH")),
@@ -127,7 +108,7 @@ const endsOf = Effect.fn("endsOf")(function* (args: readonly string[], defaultBr
     case "pull-request-unresolved":
       return yield* new RangeUnresolved({ message: `${PULL_REQUEST_EVENT} sets no GITHUB_EVENT_PATH` });
     case "local":
-      return yield* localEnds(defaultBranch);
+      return yield* localEnds;
   }
 });
 
@@ -147,8 +128,8 @@ export function rangeOf(base: string, head: string): Range["refs"] {
 
 // From the base branch's tip, every range gate would charge the head with the commits the base
 // branch gained after the head branched off.
-const resolveRange = Effect.fn("resolveRange")(function* (args: readonly string[], defaultBranch: string) {
-  const ends = yield* endsOf(args, defaultBranch);
+const resolveRange = Effect.fn("resolveRange")(function* (args: readonly string[]) {
+  const ends = yield* endsOf(args);
   const head = yield* commitOf(ends.head);
   const base = yield* git(["merge-base", yield* commitOf(ends.base), head]).pipe(
     Effect.map((sha) => sha.trim()),
@@ -184,14 +165,14 @@ const runGate = Effect.fn("runGate")(function* (gate: KitGate, range: Range) {
 });
 
 const lint = Effect.gen(function* () {
-  const { source, defaultBranch, lintGates } = yield* readWiring;
-  const range = yield* resolveRange(process.argv.slice(2), defaultBranch);
+  const root = (yield* git(["rev-parse", "--show-toplevel"])).trim();
+  const range = yield* resolveRange(process.argv.slice(2));
   yield* Console.log(`${NAME}: ${describe(range)} from ${range.source}`);
-  const gates = selectedGates(lintGates);
-  if (lintGates !== undefined) {
-    yield* Console.log(`${NAME}: ${source} selects ${gates.map((gate) => gate.bin).join(", ")}`);
-  }
-
+  const gates = yield* Effect.filter(KIT_GATES, (gate) =>
+    gate.appliesTo === EVERY_REPOSITORY
+      ? Effect.succeed(true)
+      : git(["ls-files", "--", ...gate.appliesTo.pathspecs], root).pipe(Effect.map((files) => files.trim() !== "")),
+  );
   const verdicts = yield* Effect.forEach(gates, (gate) => runGate(gate, range));
   const failed = verdicts.filter((verdict) => verdict.outcome !== "passed");
   if (failed.length === 0) {

package/scripts/range-gate.ts

@@ -1,9 +1,8 @@
 import { Effect } from "effect";
 import { git, refArgs } from "./git.ts";
-import { readQuality } from "./quality-file.ts";
 
 export const rangeGateInputs = Effect.fn("rangeGateInputs")(function* (usage: string) {
   const refs = yield* refArgs(process.argv.slice(2), usage);
   const root = (yield* git(["rev-parse", "--show-toplevel"])).trim();
-  return { refs, root, ...(yield* readQuality(root)) };
+  return { refs, root };
 });