chore: add a changelog generation script

The intent here is to speed up the versioning and changelog generation.
We leverage changeset under the hood, but work around its issues with
pre-release config and peer dependencies.

Author: kanej

.changeset/config.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://unpkg.com/@changesets/[email protected]/schema.json",
-  "changelog": "@changesets/cli/changelog",
+  "changelog": false,
   "commit": false,
   "linked": [],
   "access": "public",

.changeset/small-buckets-ring.md

@@ -1,5 +1,6 @@
 ---
 "@nomicfoundation/hardhat-typechain": patch
+"hardhat": patch
 ---
 
 Added support for the `attach` method in `hardhat-typechain`.

scripts/generate-changelog.mjs

@@ -0,0 +1,247 @@
+import { readdir, readFile, writeFile, stat } from "node:fs/promises";
+import path from "node:path";
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+
+const execAsync = promisify(exec);
+
+const changesetDir = ".changeset";
+const packagesDir = "v-next";
+
+async function main() {
+  const changesets = await readAllNewChangsets();
+
+  validateChangesets(changesets);
+
+  const currentHardhatAlphaVersion = await readCurrentHardhatAlphaVersion();
+  const nextHardhatAlphaVersion = incrementHardhatAlphaVersion(
+    currentHardhatAlphaVersion
+  );
+
+  await createAllPackageChangesetFor(nextHardhatAlphaVersion);
+
+  await executeChangesetVersion();
+
+  await updateHardhatChangelog(nextHardhatAlphaVersion, changesets);
+}
+
+// Helper functions
+
+async function readAllNewChangsets() {
+  const allChangesetNames = (await readdir(changesetDir))
+    .filter((file) => file.endsWith(".md"))
+    .map((file) => file.slice(0, -3));
+
+  const alreadyAppliedChangesetNames = JSON.parse(
+    await readFile(path.join(changesetDir, "pre.json"))
+  );
+
+  const newChangesetNames = allChangesetNames.filter(
+    (name) => !alreadyAppliedChangesetNames.changesets.includes(name)
+  );
+
+  const changesets = [];
+
+  for (const newChangeSetName of newChangesetNames) {
+    const changesetFilePath = path.join(changesetDir, `${newChangeSetName}.md`);
+
+    const changesetContent = await readFile(changesetFilePath, "utf-8");
+
+    const { content, frontMatter } = parseFrontMatter(changesetContent);
+    const commitHash = await getAddingCommit(changesetFilePath);
+
+    changesets.push({
+      frontMatter,
+      content,
+      path: changesetFilePath,
+      commitHash,
+    });
+  }
+
+  return changesets;
+}
+
+function validateChangesets(changesets) {
+  if (changesets.length === 0) {
+    console.log("Error: No new changesets found.");
+    process.exit(1);
+  }
+
+  let validationFailed = false;
+
+  for (const { frontMatter, path: changesetPath } of changesets) {
+    if (!/^\s*"hardhat": patch$/m.test(frontMatter)) {
+      validationFailed = true;
+      console.log(
+        `Error: ${changesetPath}: No "hardhat: patch", every Alpha changeset must include hardhat`
+      );
+    }
+
+    if (/: (major|minor)\s*$/m.test(frontMatter)) {
+      validationFailed = true;
+      console.log(
+        `Error: ${changesetPath}: No "major" or "minor" changesets are allowed in Alpha`
+      );
+    }
+  }
+
+  if (validationFailed) {
+    process.exit(1);
+  }
+}
+
+async function readCurrentHardhatAlphaVersion() {
+  const hardhatPackageJson = JSON.parse(
+    await readFile(path.join("v-next", "hardhat", "package.json"))
+  );
+
+  return hardhatPackageJson.version;
+}
+
+function incrementHardhatAlphaVersion(version) {
+  const match = version.match(/(\d+\.\d+\.\d+)-next\.(\d+)/);
+
+  if (!match) {
+    console.log(`Unsupported version format: ${version}`);
+    process.exit(1);
+  }
+
+  const [, base, num] = match;
+  const nextNum = Number(num) + 1;
+
+  return `${base}-next.${nextNum}`;
+}
+
+async function createAllPackageChangesetFor(nextHardhatAlphaVersion) {
+  const releaseChangesetPath = path.join(
+    changesetDir,
+    `release-${nextHardhatAlphaVersion}.md`
+  );
+
+  const packageNames = await readAllPackageNames();
+
+  const releaseChangesetContent = `---
+${packageNames
+  .filter((name) => name !== "hardhat")
+  .map((name) => `"${name}": patch`)
+  .join("\n")}
+---
+
+Hardhat 3 Alpha release (${new Date().toISOString()})
+`;
+
+  await writeFile(releaseChangesetPath, releaseChangesetContent);
+}
+
+async function executeChangesetVersion() {
+  await execAsync("pnpm changeset version");
+  await execAsync("pnpm install");
+}
+
+async function updateHardhatChangelog(nextHardhatAlphaVersion, changesets) {
+  const newChangelogSection = generateChangelogFrom(
+    nextHardhatAlphaVersion,
+    changesets
+  );
+
+  const hardhatChangelogPath = path.join(
+    packagesDir,
+    "hardhat",
+    "CHANGELOG.md"
+  );
+
+  const currentChangelog = await readFile(hardhatChangelogPath, "utf-8");
+
+  const newChangelog = currentChangelog.replace(
+    "# hardhat\n",
+    newChangelogSection
+  );
+
+  await writeFile(hardhatChangelogPath, newChangelog);
+}
+
+async function readAllPackageNames() {
+  const ignoredChangesetPackages = JSON.parse(
+    await readFile(path.join(changesetDir, "config.json"))
+  ).ignore;
+
+  const subdirs = await readdir(packagesDir);
+
+  const packageNames = [];
+
+  for (const dir of subdirs) {
+    const packageJsonPath = path.join(packagesDir, dir, "package.json");
+
+    try {
+      const stats = await stat(packageJsonPath);
+
+      if (!stats.isFile()) {
+        continue;
+      }
+
+      const pkgJson = JSON.parse(await readFile(packageJsonPath, "utf8"));
+
+      if (ignoredChangesetPackages.includes(pkgJson.name)) {
+        continue;
+      }
+
+      packageNames.push(pkgJson.name);
+    } catch (error) {
+      console.log(error);
+      process.exit(1);
+    }
+  }
+
+  return packageNames.sort();
+}
+
+function generateChangelogFrom(nextHardhatAlphaVersion, changesets) {
+  const hardhatAlphaChangelog = `# hardhat
+
+## ${nextHardhatAlphaVersion}
+
+### Patch Changes
+
+${changesets
+  .map(({ content, commitHash }) =>
+    content
+      .trim()
+      .split("\n")
+      .map(
+        (entry) =>
+          `- ${
+            commitHash !== null ? `${commitHash.slice(0, 7)}: ` : ""
+          }${entry}`
+      )
+      .join("\n")
+  )
+  .join("\n")}
+`;
+
+  return hardhatAlphaChangelog;
+}
+
+function parseFrontMatter(markdown) {
+  const match = markdown.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+  if (!match) {
+    return { frontMatter: null, content: markdown };
+  }
+
+  return {
+    frontMatter: match[1],
+    content: match[2],
+  };
+}
+
+async function getAddingCommit(filePath) {
+  try {
+    const { stdout } = await execAsync(
+      `git log --diff-filter=A --follow --format=%h -- "${filePath}"`
+    );
+    return stdout.trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+await main();