hatchkit 0.1.43 → 0.1.45

package/scripts/release-bump.mjs

@@ -54,9 +54,35 @@ pkg.version = next;
 writeFileSync(pkgPath, `${JSON.stringify(pkg, null, 2)}\n`, "utf-8");
 console.log(`  release-bump: ${current} → ${next}`);
 
-// Stage + commit + tag from the repo root so the path in the commit
-// is `cli/package.json` regardless of where the script was invoked.
-sh(`git add ${JSON.stringify(join("cli", "package.json"))}`, { cwd: repoRoot });
+// Bump `@hatchkit/dev-*` workspace packages in lockstep with the CLI.
+// The CLI's runtime references the plugin version range as
+// `^${cliVersion}` (see devPluginNextVersionRange in dev-setup.ts), so
+// every release must guarantee the plugin packages exist on npm at the
+// same version. release-packages.mjs publishes them right after this
+// script bumps + commits the lockstep set.
+const stagedPaths = [join("cli", "package.json")];
+const lockstepPackages = ["dev-shared", "dev-plugin-next", "dev-plugin-vite"];
+for (const name of lockstepPackages) {
+  const subPath = join(repoRoot, "packages", name, "package.json");
+  let subPkg;
+  try {
+    subPkg = JSON.parse(readFileSync(subPath, "utf-8"));
+  } catch (err) {
+    console.error(`  release-bump: missing packages/${name}/package.json — ${err.message}`);
+    process.exit(1);
+  }
+  if (subPkg.version === next) continue;
+  subPkg.version = next;
+  writeFileSync(subPath, `${JSON.stringify(subPkg, null, 2)}\n`, "utf-8");
+  stagedPaths.push(join("packages", name, "package.json"));
+  console.log(`  release-bump: packages/${name} → ${next}`);
+}
+
+// Stage + commit + tag from the repo root so the paths in the commit
+// are repo-relative regardless of where the script was invoked.
+for (const p of stagedPaths) {
+  sh(`git add ${JSON.stringify(p)}`, { cwd: repoRoot });
+}
 sh(`git commit -m ${JSON.stringify(`chore: release v${next}`)}`, { cwd: repoRoot });
 sh(`git tag ${JSON.stringify(`v${next}`)}`, { cwd: repoRoot });
 console.log(`  release-bump: committed + tagged v${next}`);

package/scripts/release-packages.mjs

@@ -0,0 +1,131 @@
+#!/usr/bin/env node
+/*
+ * release-packages — build + publish the `@hatchkit/dev-*` workspace
+ * packages alongside the CLI. Runs BEFORE the CLI itself publishes so
+ * that scaffolds generated by the just-published CLI find their plugin
+ * dep on the registry.
+ *
+ * Publish order is topological:
+ *   1. @hatchkit/dev-shared        (no @hatchkit/* deps)
+ *   2. @hatchkit/dev-plugin-next   (depends on dev-shared)
+ *   3. @hatchkit/dev-plugin-vite   (depends on dev-shared)
+ *
+ * Version sync: every `@hatchkit/dev-*` package matches the CLI's
+ * version. release-bump.mjs handles the bump in lockstep, so by the
+ * time we get here the package.jsons are already aligned. This script
+ * verifies that invariant and refuses to publish if anything drifted
+ * (a manual `npm version` in one package would do it).
+ *
+ * Idempotent w.r.t. already-published versions: each `npm publish`
+ * that hits "you cannot publish over the previously published versions"
+ * is treated as success (the version already exists on npm — that's
+ * what we wanted). Real failures (auth, network) propagate.
+ *
+ * Skip with RELEASE_SKIP_PACKAGES=1.
+ */
+
+import { execSync, spawnSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+if (process.env.RELEASE_SKIP_PACKAGES === "1") {
+  console.log("  release-packages: RELEASE_SKIP_PACKAGES=1 — skipping.");
+  process.exit(0);
+}
+
+const here = dirname(fileURLToPath(import.meta.url));
+const cliDir = join(here, "..");
+const repoRoot = sh("git rev-parse --show-toplevel");
+
+const PACKAGES = ["dev-shared", "dev-plugin-next", "dev-plugin-vite"];
+
+const cliVersion = readJson(join(cliDir, "package.json")).version;
+if (!cliVersion) {
+  console.error("  release-packages: couldn't read cli/package.json version. Aborting.");
+  process.exit(1);
+}
+
+// Sanity check: every dev-* package must already be bumped to cliVersion.
+// release-bump.mjs does this; if someone skipped it, fail loud.
+for (const name of PACKAGES) {
+  const pkgPath = join(repoRoot, "packages", name, "package.json");
+  if (!existsSync(pkgPath)) {
+    console.error(`  release-packages: missing packages/${name}/package.json — aborting.`);
+    process.exit(1);
+  }
+  const pkg = readJson(pkgPath);
+  if (pkg.version !== cliVersion) {
+    console.error(
+      `  release-packages: packages/${name}/package.json is at ${pkg.version} but CLI is at ${cliVersion}.`,
+    );
+    console.error(
+      "  release-bump.mjs should have aligned these. Did you run a release flow out of order?",
+    );
+    process.exit(1);
+  }
+}
+
+console.log(`  release-packages: aligning @hatchkit/dev-* packages at v${cliVersion}.`);
+
+for (const name of PACKAGES) {
+  const pkgDir = join(repoRoot, "packages", name);
+  console.log(`\n  ── packages/${name}`);
+
+  // Build the workspace package. pnpm honours each package's own build
+  // script (tsc → dist).
+  shStream("pnpm", ["run", "build"], { cwd: pkgDir });
+
+  // Publish. pnpm publish from the package dir handles workspace:*
+  // dep rewrites (the dev plugins both depend on @hatchkit/dev-shared
+  // via workspace:*; pnpm replaces with the matching real version on
+  // publish). `--no-git-checks` because release-prep.mjs already
+  // confirmed the tree is clean and the commit/tag came from
+  // release-bump.mjs.
+  const publish = spawnSync(
+    "pnpm",
+    ["publish", "--access", "public", "--no-git-checks"],
+    { cwd: pkgDir, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" },
+  );
+  process.stdout.write(publish.stdout);
+  if (publish.status === 0) continue;
+
+  // Treat "version already published" as success — the goal is "this
+  // version exists on npm", and re-runs of a partially-completed
+  // release should be self-healing rather than re-bumping.
+  const stderr = publish.stderr ?? "";
+  if (
+    /You cannot publish over the previously published versions?/i.test(stderr) ||
+    /403 Forbidden.*cannot publish over/i.test(stderr)
+  ) {
+    console.log(`  release-packages: @hatchkit/${name}@${cliVersion} already on npm — skipping.`);
+    continue;
+  }
+
+  console.error(`\n  ✗ release-packages: pnpm publish failed for ${name}.\n`);
+  process.stderr.write(stderr);
+  process.exit(1);
+}
+
+console.log(`\n  ✓ release-packages: all @hatchkit/dev-* packages at v${cliVersion} on npm.`);
+
+function readJson(path) {
+  try {
+    return JSON.parse(readFileSync(path, "utf-8"));
+  } catch (err) {
+    console.error(`  release-packages: couldn't read ${path} — ${err.message}`);
+    process.exit(1);
+  }
+}
+
+function sh(cmd, opts = {}) {
+  return execSync(cmd, { encoding: "utf-8", ...opts }).trim();
+}
+
+function shStream(bin, args, opts = {}) {
+  const res = spawnSync(bin, args, { stdio: "inherit", ...opts });
+  if (res.status !== 0) {
+    console.error(`  release-packages: ${bin} ${args.join(" ")} failed (exit ${res.status}).`);
+    process.exit(res.status ?? 1);
+  }
+}