@amritk/nish 0.12.0 → 0.14.0

package/scripts/changelog-gen.mjs

@@ -54,11 +54,11 @@
 // tool behaved before. Use it for the first release after the convention
 // lands, or write the history up by hand in `changelog/<version>.intro.md`,
 // which renders above the sections.
-import fs from "node:fs";
-import path from "node:path";
-import { execFileSync } from "node:child_process";
+import fs from "node:fs"
+import path from "node:path"
+import { execFileSync } from "node:child_process"
 
-const root = path.resolve(import.meta.dirname, "..");
+const root = path.resolve(import.meta.dirname, "..")
 
 /**
  * The repository the entries link into, from `package.json#repository`. Read
@@ -68,14 +68,14 @@ const root = path.resolve(import.meta.dirname, "..");
  */
 const REPO_URL = (() => {
   try {
-    const { repository } = JSON.parse(fs.readFileSync(path.join(root, "package.json"), "utf8"));
-    const url = typeof repository === "string" ? repository : repository?.url;
-    const m = /github\.com[/:]([^/]+\/[^/]+?)(?:\.git)?$/.exec(url ?? "");
-    return m ? `https://github.com/${m[1]}` : undefined;
+    const { repository } = JSON.parse(fs.readFileSync(path.join(root, "package.json"), "utf8"))
+    const url = typeof repository === "string" ? repository : repository?.url
+    const m = /github\.com[/:]([^/]+\/[^/]+?)(?:\.git)?$/.exec(url ?? "")
+    return m ? `https://github.com/${m[1]}` : undefined
   } catch {
-    return undefined;
+    return undefined
   }
-})();
+})()
 
 /** Conventional-commit types, in the order a release renders them. */
 const TYPES = [
@@ -91,20 +91,20 @@ const TYPES = [
   // Only reachable under --include-unconventional; ordinarily a subject that
   // does not classify is skipped rather than filed here.
   ["other", "Uncategorised"],
-];
+]
 
 /** The types a subject may name. `other` is this tool's bucket, not a type. */
-const CONVENTIONAL_TYPES = TYPES.filter(([k]) => k !== "other").map(([k]) => k);
+const CONVENTIONAL_TYPES = TYPES.filter(([k]) => k !== "other").map(([k]) => k)
 
 /**
  * Trailers that are bookkeeping rather than content. They are stripped from
  * every body: a release note is for the reader, and who co-authored a commit
  * or which session produced it is not part of what changed.
  */
-const DROPPED_TRAILERS = /^(Co-Authored-By|Claude-Session|Signed-off-by|Reviewed-by):/i;
+const DROPPED_TRAILERS = /^(Co-Authored-By|Claude-Session|Signed-off-by|Reviewed-by):/i
 
 /** Trailers this tool reads. Everything else is left in the body. */
-const KNOWN_TRAILERS = /^(Measured|Refs|Tests|Release-Note|Release-As|BREAKING[ -]CHANGE):\s*(.*)$/i;
+const KNOWN_TRAILERS = /^(Measured|Refs|Tests|Release-Note|Release-As|BREAKING[ -]CHANGE):\s*(.*)$/i
 
 /**
  * GitHub ends a squashed body with a rule when the branch had more than one
@@ -112,10 +112,10 @@ const KNOWN_TRAILERS = /^(Measured|Refs|Tests|Release-Note|Release-As|BREAKING[
  * so it goes the way the bookkeeping trailers do. It sits above the
  * co-authorship trailers rather than at the end, so it comes off the prose.
  */
-const SQUASH_RULE = /\n[ \t]*\n[ \t]*-{3,}[ \t]*$/;
+const SQUASH_RULE = /\n[ \t]*\n[ \t]*-{3,}[ \t]*$/
 
-function git(args, quiet = false) {
-  return execFileSync("git", args, {
+const git = (args, quiet = false) =>
+  execFileSync("git", args, {
     cwd: root,
     encoding: "utf8",
     maxBuffer: 64 * 1024 * 1024,
@@ -124,15 +124,14 @@ function git(args, quiet = false) {
     // below -- but inheriting stderr would print a fatal error during a run
     // that succeeded, which is how a green log gets read as a broken one.
     stdio: quiet ? ["ignore", "pipe", "ignore"] : undefined,
-  });
-}
+  })
 
 /** The previous release tag, or undefined when this is the first release. */
-function lastTag() {
+const lastTag = () => {
   try {
-    return git(["describe", "--tags", "--abbrev=0", "--match", "v*"], true).trim() || undefined;
+    return git(["describe", "--tags", "--abbrev=0", "--match", "v*"], true).trim() || undefined
   } catch {
-    return undefined; // no tags yet: the first release covers the whole history
+    return undefined // no tags yet: the first release covers the whole history
   }
 }
 
@@ -140,53 +139,83 @@ function lastTag() {
  * Split a commit body into prose and trailers. Only a trailing run of
  * trailer-shaped lines counts, so a colon inside the prose is safe.
  */
-function splitTrailers(body) {
-  const lines = body.replace(/\r\n/g, "\n").split("\n");
-  const trailers = [];
-  let end = lines.length;
+const splitTrailers = (body) => {
+  const lines = body.replace(/\r\n/g, "\n").split("\n")
+  const trailers = []
+  let end = lines.length
   while (end > 0) {
-    const line = lines[end - 1];
+    const line = lines[end - 1]
     if (line.trim() === "") {
-      end -= 1;
-      continue;
+      end -= 1
+      continue
     }
     if (DROPPED_TRAILERS.test(line) || KNOWN_TRAILERS.test(line)) {
-      trailers.unshift(line);
-      end -= 1;
-      continue;
+      trailers.unshift(line)
+      end -= 1
+      continue
     }
-    break;
+    break
   }
-  return { prose: lines.slice(0, end).join("\n").trim(), trailers };
+  return { prose: lines.slice(0, end).join("\n").trim(), trailers }
 }
 
-function parseTrailers(lines) {
-  const out = { metrics: [], refs: [], tests: [], releaseNote: undefined, releaseAs: [], breaking: undefined };
+const parseTrailers = (lines) => {
+  const out = {
+    metrics: [],
+    refs: [],
+    tests: [],
+    releaseNote: undefined,
+    releaseAs: [],
+    breaking: undefined,
+  }
   for (const line of lines) {
-    if (DROPPED_TRAILERS.test(line)) continue;
-    const m = line.match(KNOWN_TRAILERS);
-    if (!m) continue;
-    const key = m[1].toLowerCase().replace(/[ -]/g, "");
-    const value = m[2].trim();
-    if (key === "measured") out.metrics.push(value);
-    else if (key === "refs") out.refs.push(...value.split(",").map((s) => s.trim()).filter(Boolean));
-    else if (key === "tests") out.tests.push(...value.split(",").map((s) => s.trim()).filter(Boolean));
-    else if (key === "releasenote") out.releaseNote = value;
-    else if (key === "releaseas") out.releaseAs.push(value);
-    else if (key === "breakingchange") out.breaking = value;
+    if (DROPPED_TRAILERS.test(line)) {
+      continue
+    }
+    const m = line.match(KNOWN_TRAILERS)
+    if (!m) {
+      continue
+    }
+    const key = m[1].toLowerCase().replace(/[ -]/g, "")
+    const value = m[2].trim()
+    if (key === "measured") {
+      out.metrics.push(value)
+    } else if (key === "refs") {
+      out.refs.push(
+        ...value
+          .split(",")
+          .map((s) => s.trim())
+          .filter(Boolean)
+      )
+    } else if (key === "tests") {
+      out.tests.push(
+        ...value
+          .split(",")
+          .map((s) => s.trim())
+          .filter(Boolean)
+      )
+    } else if (key === "releasenote") {
+      out.releaseNote = value
+    } else if (key === "releaseas") {
+      out.releaseAs.push(value)
+    } else if (key === "breakingchange") {
+      out.breaking = value
+    }
   }
-  return out;
+  return out
 }
 
 /** `type(scope)!: subject`, or undefined when the subject is not conventional. */
-function parseSubject(subject) {
-  const m = subject.match(/^([a-z]+)(?:\(([^)]+)\))?(!)?:\s*(.+)$/);
-  if (!m) return undefined;
-  return { type: m[1], scope: m[2], bang: Boolean(m[3]), title: m[4].trim() };
+const parseSubject = (subject) => {
+  const m = subject.match(/^([a-z]+)(?:\(([^)]+)\))?(!)?:\s*(.+)$/)
+  if (!m) {
+    return undefined
+  }
+  return { type: m[1], scope: m[2], bang: Boolean(m[3]), title: m[4].trim() }
 }
 
 /** A stable, human-readable anchor. The website links entries by this. */
-function slug(title, taken) {
+const slug = (title, taken) => {
   const base =
     title
       .toLowerCase()
@@ -195,11 +224,13 @@ function slug(title, taken) {
       .replace(/^-|-$/g, "")
       .split("-")
       .slice(0, 8)
-      .join("-") || "entry";
-  let id = base;
-  for (let n = 2; taken.has(id); n += 1) id = `${base}-${n}`;
-  taken.add(id);
-  return id;
+      .join("-") || "entry"
+  let id = base
+  for (let n = 2; taken.has(id); n += 1) {
+    id = `${base}-${n}`
+  }
+  taken.add(id)
+  return id
 }
 
 /**
@@ -218,35 +249,41 @@ function slug(title, taken) {
  * someone asked for is not lost because the commit that asked was the
  * work-in-progress half of a merge.
  */
-function collect(from, to, includeUnconventional = false) {
-  const range = from ? `${from}..${to}` : to;
+const collect = (fromRef, toRef, withUnconventional = false) => {
+  const range = fromRef ? `${fromRef}..${toRef}` : toRef
   // \x00 between fields and \x1e between records: a commit body contains
   // newlines and may contain anything else, so the separators must be bytes
   // that cannot appear in one.
-  const raw = git(["log", "--no-merges", "--reverse", `--format=%H%x00%an%x00%aI%x00%s%x00%b%x1e`, range]);
-  const taken = new Set();
-  const entries = [];
-  const skipped = [];
-  const releaseAs = [];
+  const raw = git(["log", "--no-merges", "--reverse", "--format=%H%x00%an%x00%aI%x00%s%x00%b%x1e", range])
+  const taken = new Set()
+  const entries = []
+  const skipped = []
+  const releaseAs = []
 
   for (const record of raw.split("\x1e")) {
-    const text = record.replace(/^\n/, "");
-    if (!text.trim()) continue;
-    const [sha, author, date, subject, body = ""] = text.split("\x00");
-    const { prose: rawProse, trailers } = splitTrailers(body);
-    const t = parseTrailers(trailers);
-    for (const version of t.releaseAs) releaseAs.push({ version, commit: `${sha.slice(0, 7)} ${subject}` });
-
-    const parsed = parseSubject(subject);
-    const classified = parsed !== undefined && CONVENTIONAL_TYPES.includes(parsed.type);
+    const text = record.replace(/^\n/, "")
+    if (!text.trim()) {
+      continue
+    }
+    const [sha, author, date, subject, body = ""] = text.split("\x00")
+    const { prose: rawProse, trailers } = splitTrailers(body)
+    const t = parseTrailers(trailers)
+    for (const version of t.releaseAs) {
+      releaseAs.push({ version, commit: `${sha.slice(0, 7)} ${subject}` })
+    }
+
+    const parsed = parseSubject(subject)
+    const classified = parsed !== undefined && CONVENTIONAL_TYPES.includes(parsed.type)
     if (!classified) {
-      skipped.push(`${sha.slice(0, 7)} ${subject}`);
-      if (!includeUnconventional) continue;
+      skipped.push(`${sha.slice(0, 7)} ${subject}`)
+      if (!withUnconventional) {
+        continue
+      }
     }
 
-    const prose = rawProse.replace(SQUASH_RULE, "");
-    const title = parsed ? parsed.title : subject;
-    const pr = /\(#(\d+)\)\s*$/.exec(subject)?.[1];
+    const prose = rawProse.replace(SQUASH_RULE, "")
+    const title = parsed ? parsed.title : subject
+    const pr = /\(#(\d+)\)\s*$/.exec(subject)?.[1]
 
     entries.push({
       id: slug(title, taken),
@@ -263,26 +300,35 @@ function collect(from, to, includeUnconventional = false) {
       pr: pr ? Number(pr) : undefined,
       author,
       date: date.slice(0, 10),
-    });
+    })
   }
-  return { entries, skipped, releaseAs };
+  return { entries, skipped, releaseAs }
 }
 
-function renderMarkdown(release) {
-  const out = [];
-  if (release.intro) out.push(release.intro.trim(), "");
+const renderMarkdown = (releaseData) => {
+  const out = []
+  if (releaseData.intro) {
+    out.push(releaseData.intro.trim(), "")
+  }
 
-  const group = (predicate) => release.entries.filter(predicate).map(renderEntry);
+  const group = (predicate) => releaseData.entries.filter(predicate).map(renderEntry)
 
-  const breaking = group((e) => e.breaking);
-  if (breaking.length > 0) out.push("### Breaking changes", "", ...breaking, "");
+  const breaking = group((e) => e.breaking)
+  if (breaking.length > 0) {
+    out.push("### Breaking changes", "", ...breaking, "")
+  }
 
   for (const [type, heading] of TYPES) {
-    const lines = group((e) => e.type === type && !e.breaking);
-    if (lines.length === 0) continue;
-    out.push(`### ${heading}`, "", ...lines, "");
+    const lines = group((e) => e.type === type && !e.breaking)
+    if (lines.length === 0) {
+      continue
+    }
+    out.push(`### ${heading}`, "", ...lines, "")
   }
-  return `${out.join("\n").replace(/\n{3,}/g, "\n\n").trim()}\n`;
+  return `${out
+    .join("\n")
+    .replace(/\n{3,}/g, "\n\n")
+    .trim()}\n`
 }
 
 /**
@@ -290,11 +336,15 @@ function renderMarkdown(release) {
  * commit when it landed without one. Every line carries one, so the index
  * always leads somewhere.
  */
-function entryLink(e) {
-  if (e.pr) return REPO_URL ? `[#${e.pr}](${REPO_URL}/pull/${e.pr})` : `#${e.pr}`;
-  const sha = e.commits[0];
-  if (!sha) return undefined;
-  return REPO_URL ? `[\`${sha}\`](${REPO_URL}/commit/${sha})` : `\`${sha}\``;
+const entryLink = (e) => {
+  if (e.pr) {
+    return REPO_URL ? `[#${e.pr}](${REPO_URL}/pull/${e.pr})` : `#${e.pr}`
+  }
+  const sha = e.commits[0]
+  if (!sha) {
+    return undefined
+  }
+  return REPO_URL ? `[\`${sha}\`](${REPO_URL}/commit/${sha})` : `\`${sha}\``
 }
 
 /**
@@ -303,10 +353,10 @@ function entryLink(e) {
  * title are joined and the first letter is raised -- unless the title starts
  * with `code`, which keeps its backtick and its case.
  */
-function renderEntry(e) {
-  const title = e.title.startsWith("`") ? e.title : e.title.charAt(0).toUpperCase() + e.title.slice(1);
-  const link = entryLink(e);
-  return `- ${e.scope ? `${e.scope}: ` : ""}${title}${link ? ` (${link})` : ""}`;
+const renderEntry = (e) => {
+  const title = e.title.startsWith("`") ? e.title : e.title.charAt(0).toUpperCase() + e.title.slice(1)
+  const link = entryLink(e)
+  return `- ${e.scope ? `${e.scope}: ` : ""}${title}${link ? ` (${link})` : ""}`
 }
 
 /**
@@ -319,29 +369,33 @@ function renderEntry(e) {
  * same branch is ordinary semver -- a break moves the major, a `feat` the
  * minor, anything else the patch -- so nothing changes here when 1.0 is cut.
  */
-function impliedVersion(current, entries, previousTag) {
+const impliedVersion = (current, commits, previousTag) => {
   // The first release is 0.1.0 whatever the commits say. Every commit before
   // the convention existed is typed `other`, so a type-driven bump would read
   // the entire history as a patch and ship 0.0.1 — a number that would claim
   // the compiler is a bug-fix on nothing. 0.1.0 is also what the seed policy
   // already names as the base case (docs/wp12-release.md, "The bootstrap seed").
-  if (!previousTag) return [0, 1, 0];
-  const [major, minor, patch] = current.split(".").map(Number);
-  if (entries.some((e) => e.breaking)) return major === 0 ? [0, minor + 1, 0] : [major + 1, 0, 0];
-  if (entries.some((e) => e.type === "feat")) return [major, minor + 1, 0];
-  return [major, minor, patch + 1];
+  if (!previousTag) {
+    return [0, 1, 0]
+  }
+  const [major, minor, patch] = current.split(".").map(Number)
+  if (commits.some((e) => e.breaking)) {
+    return major === 0 ? [0, minor + 1, 0] : [major + 1, 0, 0]
+  }
+  if (commits.some((e) => e.type === "feat")) {
+    return [major, minor + 1, 0]
+  }
+  return [major, minor, patch + 1]
 }
 
 /** `X.Y.Z` as three numbers, or undefined when it is not one. No `v`, no pre-release, no leading zeros. */
-function parseVersion(text) {
-  const m = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/.exec(text);
-  return m ? [Number(m[1]), Number(m[2]), Number(m[3])] : undefined;
+const parseVersion = (text) => {
+  const m = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/.exec(text)
+  return m ? [Number(m[1]), Number(m[2]), Number(m[3])] : undefined
 }
 
 /** Negative, zero or positive as `a` is below, at or above `b`. */
-function compareVersions(a, b) {
-  return a[0] - b[0] || a[1] - b[1] || a[2] - b[2];
-}
+const compareVersions = (a, b) => a[0] - b[0] || a[1] - b[1] || a[2] - b[2]
 
 /**
  * The next version: the one the commits imply, unless a `Release-As: X.Y.Z`
@@ -357,133 +411,145 @@ function compareVersions(a, b) {
  * release PR proposing some other number without saying so would be worse than
  * the train stopping.
  */
-function nextVersion(current, entries, previousTag, releaseAs = []) {
-  const implied = impliedVersion(current, entries, previousTag);
-  let chosen;
-  const byCommit = new Map();
-  for (const request of releaseAs) {
-    const parsed = parseVersion(request.version);
+const nextVersion = (current, commits, previousTag, releaseAsTrailers = []) => {
+  const implied = impliedVersion(current, commits, previousTag)
+  let chosen
+  const byCommit = new Map()
+  for (const request of releaseAsTrailers) {
+    const parsed = parseVersion(request.version)
     if (!parsed) {
       return {
         error: `malformed trailer \`Release-As: ${request.version}\` on ${request.commit}; the value is a version, X.Y.Z`,
-      };
+      }
     }
-    const earlier = byCommit.get(request.commit);
+    const earlier = byCommit.get(request.commit)
     if (earlier !== undefined && earlier !== request.version) {
       return {
         error: `two trailers on ${request.commit} disagree: \`Release-As: ${earlier}\` and \`Release-As: ${request.version}\`; a commit asks for one version`,
-      };
+      }
+    }
+    byCommit.set(request.commit, request.version)
+    if (!chosen || compareVersions(parsed, chosen.parsed) > 0) {
+      chosen = { ...request, parsed }
     }
-    byCommit.set(request.commit, request.version);
-    if (!chosen || compareVersions(parsed, chosen.parsed) > 0) chosen = { ...request, parsed };
   }
-  if (!chosen) return { version: implied.join(".") };
+  if (!chosen) {
+    return { version: implied.join(".") }
+  }
   if (compareVersions(chosen.parsed, implied) < 0) {
     return {
       error:
         `trailer \`Release-As: ${chosen.version}\` on ${chosen.commit} is below ${implied.join(".")}, ` +
         `the version the commits since ${previousTag ?? "the start of the history"} imply; ` +
         "a trailer may raise the next version, never lower it",
-    };
+    }
   }
-  return { version: chosen.version };
+  return { version: chosen.version }
 }
 
 // ---- CLI ---------------------------------------------------------------------------------------
 
-const argv = process.argv.slice(2);
-function flag(name, fallback) {
-  const i = argv.indexOf(`--${name}`);
-  return i === -1 ? fallback : argv[i + 1];
+const argv = process.argv.slice(2)
+const flag = (name, fallback) => {
+  const i = argv.indexOf(`--${name}`)
+  return i === -1 ? fallback : argv[i + 1]
 }
 
 // Validating one subject line. This lives here rather than in the workflow so
 // that what CI enforces and what the generator parses are the same rule: a
 // title the check accepts and the generator files under "Uncategorised" would
 // be worse than no check at all.
-const checkSubject = flag("check-subject", undefined);
+const checkSubject = flag("check-subject", undefined)
 if (checkSubject !== undefined) {
-  const parsed = parseSubject(checkSubject);
+  const parsed = parseSubject(checkSubject)
   if (!parsed) {
-    console.error(`not a conventional commit subject:\n\n    ${checkSubject}\n`);
-    console.error(`Expected \`type(scope): subject\`, where type is one of: ${CONVENTIONAL_TYPES.join(", ")}.`);
-    console.error(`A \`!\` after the type or scope marks a breaking change.\n`);
-    console.error(`Examples:\n    feat(checker): accept non-generic type aliases`);
-    console.error(`    perf(codegen)!: hoist the array header out of element loops`);
-    console.error(`\nThe subject becomes the heading in the release notes, so write it for a reader.`);
-    process.exit(1);
+    console.error(`not a conventional commit subject:\n\n    ${checkSubject}\n`)
+    console.error(
+      `Expected \`type(scope): subject\`, where type is one of: ${CONVENTIONAL_TYPES.join(", ")}.`
+    )
+    console.error("A `!` after the type or scope marks a breaking change.\n")
+    console.error("Examples:\n    feat(checker): accept non-generic type aliases")
+    console.error("    perf(codegen)!: hoist the array header out of element loops")
+    console.error("\nThe subject becomes the heading in the release notes, so write it for a reader.")
+    process.exit(1)
   }
   if (!CONVENTIONAL_TYPES.includes(parsed.type)) {
-    console.error(`unknown type \`${parsed.type}\` in:\n\n    ${checkSubject}\n`);
-    console.error(`Use one of: ${CONVENTIONAL_TYPES.join(", ")}.`);
-    process.exit(1);
+    console.error(`unknown type \`${parsed.type}\` in:\n\n    ${checkSubject}\n`)
+    console.error(`Use one of: ${CONVENTIONAL_TYPES.join(", ")}.`)
+    process.exit(1)
   }
   if (/[.]$/.test(parsed.title)) {
-    console.error(`subject ends with a full stop:\n\n    ${checkSubject}\n`);
-    console.error("It is a heading, not a sentence.");
-    process.exit(1);
+    console.error(`subject ends with a full stop:\n\n    ${checkSubject}\n`)
+    console.error("It is a heading, not a sentence.")
+    process.exit(1)
   }
-  console.log(`ok: ${parsed.type}${parsed.scope ? `(${parsed.scope})` : ""}${parsed.bang ? "!" : ""} — ${parsed.title}`);
-  process.exit(0);
+  console.log(
+    `ok: ${parsed.type}${parsed.scope ? `(${parsed.scope})` : ""}${parsed.bang ? "!" : ""} — ${parsed.title}`
+  )
+  process.exit(0)
 }
 
 // Rendering an already-written release: the release job must publish exactly
 // the file the release PR was reviewed with, not a fresh walk of the log that
 // could differ by a commit.
-const fromJson = flag("from-json", undefined);
+const fromJson = flag("from-json", undefined)
 if (fromJson) {
-  const stored = JSON.parse(fs.readFileSync(fromJson, "utf8"));
-  process.stdout.write(renderMarkdown(stored));
-  process.exit(0);
+  const stored = JSON.parse(fs.readFileSync(fromJson, "utf8"))
+  process.stdout.write(renderMarkdown(stored))
+  process.exit(0)
 }
 
-const pkgVersion = JSON.parse(fs.readFileSync(path.join(root, "package.json"), "utf8")).version;
-const version = flag("version", pkgVersion);
-const from = flag("from", lastTag());
-const to = flag("to", "HEAD");
-const stdoutKind = flag("stdout", "md");
-const write = argv.includes("--write");
-const includeUnconventional = argv.includes("--include-unconventional");
+const pkgVersion = JSON.parse(fs.readFileSync(path.join(root, "package.json"), "utf8")).version
+const version = flag("version", pkgVersion)
+const from = flag("from", lastTag())
+const to = flag("to", "HEAD")
+const stdoutKind = flag("stdout", "md")
+const write = argv.includes("--write")
+const includeUnconventional = argv.includes("--include-unconventional")
 
-const { entries, skipped, releaseAs } = collect(from, to, includeUnconventional);
+const { entries, skipped, releaseAs } = collect(from, to, includeUnconventional)
 
 // `--next` answers the version and nothing else, for the release PR to name
 // itself and to bump package.json with. Everything release-pr.yml writes reads
 // this one line, so a `Release-As:` trailer reaches all of it here.
 if (argv.includes("--next")) {
-  const next = nextVersion(pkgVersion, entries, from, releaseAs);
+  const next = nextVersion(pkgVersion, entries, from, releaseAs)
   if (next.error) {
-    console.error(`changelog-gen: ${next.error}`);
-    process.exit(1);
+    console.error(`changelog-gen: ${next.error}`)
+    process.exit(1)
   }
-  process.stdout.write(`${next.version}\n`);
-  process.exit(0);
+  process.stdout.write(`${next.version}\n`)
+  process.exit(0)
 }
 
 // Skipped is not silent: the subjects are named, because a change that belongs
 // in the notes and was written without a type is a defect to fix in the
 // commit, not something for a reader of the notes to discover missing.
 if (skipped.length > 0 && !includeUnconventional) {
-  const shown = skipped.slice(0, 20);
+  const shown = skipped.slice(0, 20)
   console.error(
     `changelog-gen: skipped ${skipped.length} commit${skipped.length === 1 ? "" : "s"} whose subject is not a conventional commit:`
-  );
-  for (const line of shown) console.error(`  ${line}`);
-  if (skipped.length > shown.length) console.error(`  ... and ${skipped.length - shown.length} more`);
-  console.error("Pass --include-unconventional to file them under \"Uncategorised\" instead.");
+  )
+  for (const line of shown) {
+    console.error(`  ${line}`)
+  }
+  if (skipped.length > shown.length) {
+    console.error(`  ... and ${skipped.length - shown.length} more`)
+  }
+  console.error('Pass --include-unconventional to file them under "Uncategorised" instead.')
 }
 
 if (entries.length === 0) {
-  const range = from ? `${from}..${to}` : to;
+  const range = from ? `${from}..${to}` : to
   console.error(
     skipped.length > 0
       ? `changelog-gen: no commit in ${range} carries a conventional subject (${skipped.length} skipped, listed above), so the release has no entries; fix the subjects or pass --include-unconventional`
       : `changelog-gen: no commits in ${range}; a release with no changes is a mistake, not an empty section`
-  );
-  process.exit(1);
+  )
+  process.exit(1)
 }
 
-const introPath = path.join(root, "changelog", `${version}.intro.md`);
+const introPath = path.join(root, "changelog", `${version}.intro.md`)
 const release = {
   version,
   date: new Date().toISOString().slice(0, 10),
@@ -491,38 +557,40 @@ const release = {
   range: { from: from ?? null, to: git(["rev-parse", "--short", to]).trim() },
   intro: fs.existsSync(introPath) ? fs.readFileSync(introPath, "utf8").trim() : undefined,
   entries,
-};
+}
 
-const jsonDir = path.join(root, "changelog");
-const jsonPath = path.join(jsonDir, `${version}.json`);
-const markdown = renderMarkdown(release);
+const jsonDir = path.join(root, "changelog")
+const jsonPath = path.join(jsonDir, `${version}.json`)
+const markdown = renderMarkdown(release)
 
 if (write) {
-  fs.mkdirSync(jsonDir, { recursive: true });
-  fs.writeFileSync(jsonPath, `${JSON.stringify(release, null, 2)}\n`);
+  fs.mkdirSync(jsonDir, { recursive: true })
+  fs.writeFileSync(jsonPath, `${JSON.stringify(release, null, 2)}\n`)
 
   // Splice the rendered section into CHANGELOG.md under `## [Unreleased]`,
   // which is where the file's own header says a release section goes.
-  const changelogPath = path.join(root, "CHANGELOG.md");
-  const current = fs.readFileSync(changelogPath, "utf8");
-  const marker = "## [Unreleased]";
+  const changelogPath = path.join(root, "CHANGELOG.md")
+  const current = fs.readFileSync(changelogPath, "utf8")
+  const marker = "## [Unreleased]"
   if (!current.includes(marker)) {
-    console.error(`changelog-gen: CHANGELOG.md has no \`${marker}\` heading to write under`);
-    process.exit(1);
+    console.error(`changelog-gen: CHANGELOG.md has no \`${marker}\` heading to write under`)
+    process.exit(1)
+  }
+  const section = `${marker}\n\n## [${version}] - ${release.date}\n\n${markdown}`
+  let next = current.replace(marker, section)
+  const link = `[${version}]: https://github.com/amritk/nish/releases/tag/v${version}`
+  if (!next.includes(link)) {
+    next = `${next.trimEnd()}\n${link}\n`
   }
-  const section = `${marker}\n\n## [${version}] - ${release.date}\n\n${markdown}`;
-  let next = current.replace(marker, section);
-  const link = `[${version}]: https://github.com/amritk/nish/releases/tag/v${version}`;
-  if (!next.includes(link)) next = `${next.trimEnd()}\n${link}\n`;
-  fs.writeFileSync(changelogPath, next);
+  fs.writeFileSync(changelogPath, next)
 
-  console.error(`changelog-gen: wrote changelog/${version}.json and the CHANGELOG.md section`);
+  console.error(`changelog-gen: wrote changelog/${version}.json and the CHANGELOG.md section`)
 }
 
 if (includeUnconventional && skipped.length > 0) {
   console.error(
     `changelog-gen: ${skipped.length} of ${entries.length} commits are not conventional and landed under "Uncategorised"`
-  );
+  )
 }
 
-process.stdout.write(stdoutKind === "json" ? `${JSON.stringify(release, null, 2)}\n` : markdown);
+process.stdout.write(stdoutKind === "json" ? `${JSON.stringify(release, null, 2)}\n` : markdown)