@avi2dg/checks 0.6.0 → 0.8.0

package/scripts/lint.ts

@@ -0,0 +1,162 @@
+#!/usr/bin/env bun
+import { Config, Console, Effect, FileSystem, Option, Path, Schema } from "effect";
+import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
+import { DEFAULT_BRANCH, KIT_GATES, type KitGate } from "./gates.ts";
+import { git } from "./git.ts";
+import { runMain, Usage } from "./main.ts";
+
+type Range = {
+  readonly refs: readonly [tip: string] | readonly [base: string, head: string];
+  readonly source: string;
+};
+
+type Outcome = "passed" | "violated" | "undecided";
+
+class RangeUnresolved extends Schema.TaggedError<RangeUnresolved>()("RangeUnresolved", {
+  message: Schema.String,
+}) {}
+
+class GatesUndecided extends Schema.TaggedError<GatesUndecided>()("GatesUndecided", {
+  message: Schema.String,
+}) {}
+
+const NAME = "checks-lint";
+const USAGE = "usage: lint.ts [<base-ref> <head-ref>]";
+const PULL_REQUEST_EVENT = "pull_request";
+const SHALLOW_HINT = "a CI checkout needs actions/checkout fetch-depth: 0";
+
+const decodePullRequestEvent = Schema.decodeUnknownEffect(
+  Schema.fromJsonString(
+    Schema.Struct({
+      pull_request: Schema.Struct({
+        number: Schema.Int,
+        base: Schema.Struct({ ref: Schema.String }),
+        head: Schema.Struct({ sha: Schema.String }),
+      }),
+    }),
+  ),
+);
+
+const pullRequestEnds = Effect.fn("pullRequestEnds")(function* (eventPath: string) {
+  const fs = yield* FileSystem.FileSystem;
+  const { pull_request: pullRequest } = yield* fs.readFileString(eventPath).pipe(
+    Effect.flatMap(decodePullRequestEvent),
+    Effect.mapError(
+      (cause) => new RangeUnresolved({ message: `cannot read the pull request from ${eventPath}: ${cause.message}` }),
+    ),
+  );
+  return {
+    base: `origin/${pullRequest.base.ref}`,
+    head: pullRequest.head.sha,
+    source: `pull request #${pullRequest.number} into ${pullRequest.base.ref}`,
+  };
+});
+
+const decodeManifest = Schema.decodeUnknownEffect(
+  Schema.fromJsonString(
+    Schema.Struct({
+      ciWiring: Schema.optionalKey(Schema.Struct({ defaultBranch: Schema.optionalKey(Schema.NonEmptyString) })),
+    }),
+  ),
+);
+
+const declaredDefaultBranch = Effect.gen(function* () {
+  const root = (yield* git(["rev-parse", "--show-toplevel"])).trim();
+  const manifest = (yield* Path.Path).join(root, "package.json");
+  const { ciWiring } = yield* (yield* FileSystem.FileSystem).readFileString(manifest).pipe(Effect.flatMap(decodeManifest));
+  return ciWiring?.defaultBranch ?? DEFAULT_BRANCH;
+}).pipe(
+  Effect.mapError((cause) => new RangeUnresolved({ message: `cannot read ciWiring.defaultBranch: ${cause.message}` })),
+);
+
+const localEnds = git(["symbolic-ref", "--quiet", "--short", "refs/remotes/origin/HEAD"]).pipe(
+  Effect.map((ref) => ref.trim()),
+  Effect.catchTag("GitFailure", () => declaredDefaultBranch.pipe(Effect.map((branch) => `origin/${branch}`))),
+  Effect.map((base) => ({ base, head: "HEAD", source: `HEAD against ${base}` })),
+);
+
+const endsOf = Effect.fn("endsOf")(function* (args: readonly string[]) {
+  const [base, head, ...extra] = args;
+  if (base !== undefined && head !== undefined && extra.length === 0) {
+    return { base, head, source: `${head} against ${base}` };
+  }
+  if (base !== undefined) return yield* new Usage({ message: USAGE });
+
+  const event = yield* Config.all({
+    name: Config.option(Config.String("GITHUB_EVENT_NAME")),
+    path: Config.option(Config.String("GITHUB_EVENT_PATH")),
+  }).pipe(Effect.mapError((cause) => new RangeUnresolved({ message: cause.message })));
+  if (Option.isSome(event.name) && event.name.value === PULL_REQUEST_EVENT) {
+    if (Option.isNone(event.path)) {
+      return yield* new RangeUnresolved({ message: `${PULL_REQUEST_EVENT} sets no GITHUB_EVENT_PATH` });
+    }
+    return yield* pullRequestEnds(event.path.value);
+  }
+  return yield* localEnds;
+});
+
+const commitOf = (ref: string) =>
+  git(["rev-parse", "--verify", "--end-of-options", `${ref}^{commit}`]).pipe(
+    Effect.map((sha) => sha.trim()),
+    Effect.mapError(
+      (cause) => new RangeUnresolved({ message: `${ref} is not a commit in this clone; ${SHALLOW_HINT}: ${cause.message}` }),
+    ),
+  );
+
+// 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[]) {
+  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()),
+    Effect.mapError(
+      () => new RangeUnresolved({ message: `${ends.base} and ${ends.head} share no commit in this clone; ${SHALLOW_HINT}` }),
+    ),
+  );
+  return { refs: base === head ? [head] : [base, head], source: ends.source } satisfies Range;
+});
+
+function describe({ refs }: Range): string {
+  return refs.length === 1 ? `tip ${refs[0]}` : `range ${refs[0]}..${refs[1]}`;
+}
+
+function outcomeOf(exitCode: number): Outcome {
+  if (exitCode === 0) return "passed";
+  return exitCode === 1 ? "violated" : "undecided";
+}
+
+const runGate = Effect.fn("runGate")(function* (gate: KitGate, range: Range) {
+  const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
+  const script = (yield* Path.Path).join(import.meta.dir, gate.script);
+  const program = gate.script.endsWith(".sh") ? "sh" : process.execPath;
+  const args = gate.reads === "range" ? [script, ...range.refs] : [script];
+  const exitCode = yield* spawner
+    .exitCode(ChildProcess.make(program, args, { stdin: "ignore", stdout: "inherit", stderr: "inherit" }))
+    .pipe(
+      Effect.catch((cause) =>
+        Console.error(`${NAME}: cannot run ${gate.bin}: ${cause.message}`).pipe(Effect.as(ChildProcessSpawner.ExitCode(2))),
+      ),
+    );
+  return { gate, outcome: outcomeOf(exitCode) };
+});
+
+const lint = Effect.gen(function* () {
+  const range = yield* resolveRange(process.argv.slice(2));
+  yield* Console.log(`${NAME}: ${describe(range)} from ${range.source}`);
+
+  const verdicts = yield* Effect.forEach(KIT_GATES, (gate) => runGate(gate, range));
+  const failed = verdicts.filter((verdict) => verdict.outcome !== "passed");
+  if (failed.length === 0) {
+    yield* Console.log(`${NAME}: ${KIT_GATES.length} gate(s) pass`);
+    return true;
+  }
+  const summary = `${failed.length} of ${KIT_GATES.length} gate(s) failed: ${failed.map((verdict) => verdict.gate.bin).join(", ")}`;
+  if (failed.every((verdict) => verdict.outcome === "undecided")) {
+    return yield* new GatesUndecided({ message: summary });
+  }
+  yield* Console.error(`${NAME}: ${summary}`);
+  return false;
+});
+
+if (import.meta.main) runMain(NAME, lint);

package/scripts/main.ts

@@ -0,0 +1,28 @@
+import { BunRuntime, BunServices } from "@effect/platform-bun";
+import { Cause, Console, Effect, Exit, Schema } from "effect";
+
+const PASSED = 0;
+const VIOLATED = 1;
+const UNDECIDED = 2;
+const INTERRUPTED = 130;
+
+export class Usage extends Schema.TaggedError<Usage>()("Usage", {
+  message: Schema.String,
+}) {}
+
+function statusOf<A, E>(exit: Exit.Exit<A, E>): number {
+  if (Exit.isSuccess(exit)) return typeof exit.value === "number" ? exit.value : UNDECIDED;
+  return Cause.hasInterruptsOnly(exit.cause) ? INTERRUPTED : UNDECIDED;
+}
+
+export function runMain<E extends { readonly message: string }>(
+  name: string,
+  passes: Effect.Effect<boolean, E, BunServices.BunServices>,
+): void {
+  const program = passes.pipe(
+    Effect.map((passed) => (passed ? PASSED : VIOLATED)),
+    Effect.catch((failure) => Console.error(`${name}: ${failure.message}`).pipe(Effect.as(UNDECIDED))),
+    Effect.provide(BunServices.layer),
+  );
+  BunRuntime.runMain(program, { teardown: (exit, onExit) => onExit(statusOf(exit)) });
+}

package/scripts/mutation-compare.ts

@@ -1,5 +1,6 @@
 #!/usr/bin/env bun
-import { readFile } from "node:fs/promises";
+import { Console, Effect, FileSystem, Schema } from "effect";
+import { runMain, Usage } from "./main.ts";
 
 export type Tally = {
   readonly killed: number;
@@ -25,42 +26,31 @@ export type Options = {
   readonly advisory: boolean;
 };
 
-export class ReportError extends Error {}
+export class ReportError extends Schema.TaggedError<ReportError>()("ReportError", {
+  message: Schema.String,
+}) {}
 
 const DETECTED = new Set(["Killed", "Timeout"]);
 const UNDETECTED = new Set(["Survived", "NoCoverage"]);
 const USAGE = "usage: mutation-compare.ts [--advisory] <base-report> <head-report>";
 
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null;
-}
-
-export function parseReport(text: string): Map<string, readonly string[]> {
-  let parsed: unknown;
-  try {
-    parsed = JSON.parse(text);
-  } catch {
-    throw new ReportError("mutation-compare: report is not valid JSON");
-  }
-  if (!isRecord(parsed) || !isRecord(parsed["files"])) {
-    throw new ReportError("mutation-compare: report has no files table");
-  }
-  const files = new Map<string, readonly string[]>();
-  for (const [path, entry] of Object.entries(parsed["files"])) {
-    if (!isRecord(entry) || !Array.isArray(entry["mutants"])) {
-      throw new ReportError(`mutation-compare: ${path} has no mutants list`);
-    }
-    const statuses: string[] = [];
-    for (const mutant of entry["mutants"]) {
-      if (!isRecord(mutant) || typeof mutant["status"] !== "string") {
-        throw new ReportError(`mutation-compare: ${path} carries a mutant without a status`);
-      }
-      statuses.push(mutant["status"]);
-    }
-    files.set(path, statuses);
-  }
-  return files;
-}
+const Report = Schema.fromJsonString(
+  Schema.Struct({
+    files: Schema.Record(
+      Schema.String,
+      Schema.Struct({ mutants: Schema.Array(Schema.Struct({ status: Schema.String })) }),
+    ),
+  }),
+);
+const decodeReport = Schema.decodeUnknownEffect(Report);
+
+export const parseReport = (source: string, text: string): Effect.Effect<Map<string, readonly string[]>, ReportError> =>
+  decodeReport(text).pipe(
+    Effect.map(
+      ({ files }) => new Map(Object.entries(files).map(([path, { mutants }]) => [path, mutants.map(({ status }) => status)])),
+    ),
+    Effect.mapError((cause) => new ReportError({ message: `${source} is not a Stryker mutation report: ${cause.message}` })),
+  );
 
 function tally(statuses: readonly string[]): Tally {
   let killed = 0;
@@ -136,38 +126,34 @@ export function formatComparison(comparison: Comparison, advisory: boolean): str
   return lines.join("\n");
 }
 
-export function parseArgs(argv: readonly string[]): Options {
+export const parseArgs = Effect.fnUntraced(function* (argv: readonly string[]): Effect.fn.Return<Options, Usage> {
   let advisory = false;
   const paths: string[] = [];
   for (const arg of argv) {
     if (arg === "--advisory") advisory = true;
-    else if (arg.startsWith("--")) throw new ReportError(`${USAGE}: unknown flag ${arg}`);
+    else if (arg.startsWith("--")) return yield* new Usage({ message: `${USAGE}: unknown flag ${arg}` });
     else paths.push(arg);
   }
-  if (paths.length !== 2 || paths[0] === undefined || paths[1] === undefined) throw new ReportError(USAGE);
-  return { basePath: paths[0], headPath: paths[1], advisory };
-}
+  const [basePath, headPath, ...extra] = paths;
+  if (basePath === undefined || headPath === undefined || extra.length > 0) return yield* new Usage({ message: USAGE });
+  return { basePath, headPath, advisory };
+});
 
-export function exitFor(comparison: Comparison, advisory: boolean): number {
-  return comparison.regression && !advisory ? 1 : 0;
+export function passes(comparison: Comparison, advisory: boolean): boolean {
+  return advisory || !comparison.regression;
 }
 
-async function load(path: string): Promise<string> {
-  try {
-    return await readFile(path, "utf8");
-  } catch {
-    throw new ReportError(`mutation-compare: cannot read ${path}`);
-  }
-}
+const load = Effect.fn("load")(function* (path: string) {
+  const fs = yield* FileSystem.FileSystem;
+  const text = yield* fs.readFileString(path).pipe(Effect.mapError(() => new ReportError({ message: `cannot read ${path}` })));
+  return yield* parseReport(path, text);
+});
 
-if (import.meta.main) {
-  try {
-    const options = parseArgs(process.argv.slice(2));
-    const comparison = compareReports(parseReport(await load(options.basePath)), parseReport(await load(options.headPath)));
-    console.log(formatComparison(comparison, options.advisory));
-    process.exit(exitFor(comparison, options.advisory));
-  } catch (error) {
-    console.error(error instanceof ReportError ? error.message : `mutation-compare: ${String(error)}`);
-    process.exit(2);
-  }
-}
+const compare = Effect.gen(function* () {
+  const options = yield* parseArgs(process.argv.slice(2));
+  const comparison = compareReports(yield* load(options.basePath), yield* load(options.headPath));
+  yield* Console.log(formatComparison(comparison, options.advisory));
+  return passes(comparison, options.advisory);
+});
+
+if (import.meta.main) runMain("mutation-compare", compare);

package/scripts/suppressions-ratchet.ts

@@ -1,4 +1,8 @@
 #!/usr/bin/env bun
+import { Console, Effect, Schema } from "effect";
+import { git } from "./git.ts";
+import { runMain, Usage } from "./main.ts";
+
 export const SUPPRESSIONS = "oxlint-suppressions.json";
 
 export type Suppressions = ReadonlyMap<string, ReadonlyMap<string, number>>;
@@ -13,44 +17,37 @@ export type Ratchet = {
   readonly rises: readonly Rise[];
 };
 
-export class SuppressionsError extends Error {}
+export class SuppressionsError extends Schema.TaggedError<SuppressionsError>()("SuppressionsError", {
+  message: Schema.String,
+}) {}
 
 const USAGE = "usage: suppressions-ratchet.ts <ref> | <base-ref> <head-ref>";
 
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-function isCount(value: unknown): value is number {
-  return typeof value === "number" && Number.isInteger(value) && value >= 0;
-}
-
-export function parseSuppressions(text: string, where: string): Suppressions {
-  let parsed: unknown;
-  try {
-    parsed = JSON.parse(text);
-  } catch {
-    throw new SuppressionsError(`suppressions-ratchet: ${where} is not valid JSON`);
-  }
-  if (!isRecord(parsed)) {
-    throw new SuppressionsError(`suppressions-ratchet: ${where} is not an object of files`);
-  }
-  const files = new Map<string, ReadonlyMap<string, number>>();
-  for (const [file, rules] of Object.entries(parsed)) {
-    if (!isRecord(rules)) {
-      throw new SuppressionsError(`suppressions-ratchet: ${where} holds ${file} without an object of rules`);
-    }
+const parseJson = Schema.decodeUnknownEffect(Schema.fromJsonString(Schema.Unknown));
+const decodeObject = Schema.decodeUnknownEffect(Schema.Record(Schema.String, Schema.Unknown));
+const decodeEntry = Schema.decodeUnknownEffect(Schema.Struct({ count: Schema.Int.check(Schema.isGreaterThanOrEqualTo(0)) }));
+
+export const parseSuppressions = Effect.fn("parseSuppressions")(function* (
+  text: string,
+  where: string,
+): Effect.fn.Return<Suppressions, SuppressionsError> {
+  const refuse = (reason: string) => () => new SuppressionsError({ message: `${where} ${reason}` });
+  const parsed = yield* parseJson(text).pipe(Effect.mapError(refuse("is not valid JSON")));
+  const files = yield* decodeObject(parsed).pipe(Effect.mapError(refuse("is not an object of files")));
+  const suppressions = new Map<string, ReadonlyMap<string, number>>();
+  for (const [file, rules] of Object.entries(files)) {
+    const entries = yield* decodeObject(rules).pipe(Effect.mapError(refuse(`holds ${file} without an object of rules`)));
     const counts = new Map<string, number>();
-    for (const [rule, entry] of Object.entries(rules)) {
-      if (!isRecord(entry) || !isCount(entry["count"])) {
-        throw new SuppressionsError(`suppressions-ratchet: ${where} holds ${file} ${rule} without a whole count`);
-      }
-      counts.set(rule, entry["count"]);
+    for (const [rule, entry] of Object.entries(entries)) {
+      const { count } = yield* decodeEntry(entry).pipe(
+        Effect.mapError(refuse(`holds ${file} ${rule} without a whole count`)),
+      );
+      counts.set(rule, count);
     }
-    files.set(file, counts);
+    suppressions.set(file, counts);
   }
-  return files;
-}
+  return suppressions;
+});
 
 export function compareSuppressions(base: Suppressions, head: Suppressions): Ratchet {
   const rises: Rise[] = [];
@@ -91,52 +88,38 @@ export function report({ counted, lowered, rises }: Ratchet): string {
   ].join("\n");
 }
 
-function die(message: string): never {
-  console.error(message);
-  process.exit(2);
-}
-
-function git(...args: readonly string[]): string {
-  const result = Bun.spawnSync(["git", ...args], { stdout: "pipe", stderr: "pipe" });
-  if (!result.success) {
-    die(`suppressions-ratchet: git ${args.join(" ")}: ${result.stderr.toString().trim()}`);
-  }
-  return result.stdout.toString();
-}
-
-function commitOf(rev: string): string {
-  return git("rev-parse", "--verify", `${rev}^{commit}`).trim();
-}
-
-function mergeBase(base: string, head: string): string {
-  const result = Bun.spawnSync(["git", "merge-base", base, head], { stdout: "pipe", stderr: "pipe" });
-  if (!result.success) die(`suppressions-ratchet: ${base} and ${head} share no commit`);
-  return result.stdout.toString().trim();
-}
-
-function suppressionsAt(commit: string): Suppressions {
-  const blob = git("ls-tree", "--object-only", commit, "--", SUPPRESSIONS).trim();
-  if (blob === "") return new Map();
-  try {
-    return parseSuppressions(git("cat-file", "blob", blob), `${SUPPRESSIONS} at ${commit}`);
-  } catch (error) {
-    return die(error instanceof SuppressionsError ? error.message : `suppressions-ratchet: ${String(error)}`);
-  }
-}
-
-export function runRange(base: string, head: string): Ratchet {
-  const headCommit = commitOf(head);
+const commitOf = Effect.fn("commitOf")(function* (rev: string) {
+  return (yield* git(["rev-parse", "--verify", `${rev}^{commit}`])).trim();
+});
+
+const mergeBase = Effect.fn("mergeBase")(function* (base: string, head: string) {
+  const commit = yield* git(["merge-base", base, head]).pipe(
+    Effect.mapError(() => new SuppressionsError({ message: `${base} and ${head} share no commit` })),
+  );
+  return commit.trim();
+});
+
+const suppressionsAt = Effect.fn("suppressionsAt")(function* (commit: string) {
+  const blob = (yield* git(["ls-tree", "--object-only", commit, "--", SUPPRESSIONS])).trim();
+  if (blob === "") return new Map() satisfies Suppressions;
+  return yield* parseSuppressions(yield* git(["cat-file", "blob", blob]), `${SUPPRESSIONS} at ${commit}`);
+});
+
+export const runRange = Effect.fn("runRange")(function* (base: string, head: string) {
+  const headCommit = yield* commitOf(head);
   // At the base tip, a count the base branch lowered after the head branched off would read as a rise at the head.
-  const branchPoint = mergeBase(commitOf(base), headCommit);
-  return compareSuppressions(suppressionsAt(branchPoint), suppressionsAt(headCommit));
-}
+  const branchPoint = yield* mergeBase(yield* commitOf(base), headCommit);
+  return compareSuppressions(yield* suppressionsAt(branchPoint), yield* suppressionsAt(headCommit));
+});
 
-if (import.meta.main) {
+const ratchet = Effect.gen(function* () {
   const [first, second, ...extra] = process.argv.slice(2);
-  if (first === undefined || extra.length > 0) die(USAGE);
+  if (first === undefined || extra.length > 0) return yield* new Usage({ message: USAGE });
 
-  const ratchet = second !== undefined ? runRange(first, second) : runRange(`${first}^`, first);
+  const result = second !== undefined ? yield* runRange(first, second) : yield* runRange(`${first}^`, first);
 
-  console.log(report(ratchet));
-  process.exit(ratchet.rises.length === 0 ? 0 : 1);
-}
+  yield* Console.log(report(result));
+  return result.rises.length === 0;
+});
+
+if (import.meta.main) runMain("suppressions-ratchet", ratchet);