@dbx-tools/projen 0.9.5 → 0.9.7

package/tasks/python-registry.ts

@@ -1,7 +1,7 @@
 import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { resolve } from "node:path";
-import { exec } from "@dbx-tools/core";
+import * as exec from "@dbx-tools/core/exec";
 import { net } from "@dbx-tools/shared-core";
 
 export interface LocalPythonRegistry {

package/tasks/release-bootstrap.ts

@@ -3,7 +3,7 @@
 
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join, resolve } from "node:path";
-import { project } from "@dbx-tools/core";
+import * as projectUtils from "@dbx-tools/core/project-utils";
 import { json, log } from "@dbx-tools/shared-core";
 import { Command } from "commander";
 import type { ReleaseUnitGraph } from "../src/release-catalog.ts";
@@ -53,7 +53,7 @@ if (import.meta.main) {
   new Command()
     .option("--root <path>", "repository root")
     .action((options: { root?: string }) => {
-      bootstrapReleaseUnits(resolve(options.root ?? project.root() ?? process.cwd()));
+      bootstrapReleaseUnits(resolve(options.root ?? projectUtils.root() ?? process.cwd()));
     })
     .parse();
 }

package/tasks/release-plan.ts

@@ -3,7 +3,7 @@
 
 import { appendFileSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, resolve } from "node:path";
-import { exec } from "@dbx-tools/core";
+import * as exec from "@dbx-tools/core/exec";
 import { json, log } from "@dbx-tools/shared-core";
 import { Command } from "commander";
 import type { ReleaseUnitGraph } from "../src/release-catalog.ts";

package/tasks/release-please.ts

@@ -3,7 +3,7 @@
 
 import { appendFileSync, readFileSync } from "node:fs";
 import { resolve } from "node:path";
-import { exec } from "@dbx-tools/core";
+import * as exec from "@dbx-tools/core/exec";
 import { log } from "@dbx-tools/shared-core";
 import { Command } from "commander";
 import { GitHub } from "release-please";

package/tasks/release-pr.ts

@@ -10,8 +10,9 @@
 import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { exec, project } from "@dbx-tools/core";
-import { async as asyncModule, json, log, object } from "@dbx-tools/shared-core";
+import * as exec from "@dbx-tools/core/exec";
+import * as projectUtils from "@dbx-tools/core/project-utils";
+import { asyncUtils, json, log, object } from "@dbx-tools/shared-core";
 import { Command } from "commander";
 import { publishLocalRelease } from "./local-publish.ts";
 import { generateReleaseSummary } from "./release-summary.ts";
@@ -23,6 +24,16 @@ import {
   type ReleaseOs,
   type VersionLevel,
 } from "../src/_release-platform.ts";
+import {
+  captureTaskCommand,
+  runTaskCommand,
+  runTaskCommandAsync,
+  taskCommandSucceeds,
+} from "../src/_task-command.ts";
+import {
+  RELEASE_SUMMARY_PROVIDER_NAMES,
+  type ReleaseSummaryProviderName,
+} from "../src/release-dispatch.ts";
 import {
   githubAccountSupportsWorkflowChanges,
   githubAuthenticatedAccounts,
@@ -32,10 +43,6 @@ import {
   githubTokenArguments,
   githubTokenEnvironmentName,
 } from "../src/release-github.ts";
-import {
-  RELEASE_SUMMARY_PROVIDER_NAMES,
-  type ReleaseSummaryProviderName,
-} from "../src/release-dispatch.ts";
 import {
   readWorkspaceVersion,
   resolveBaseVersion,
@@ -49,14 +56,9 @@ function git(
   args: string[],
   { capture = false, check = true }: { capture?: boolean; check?: boolean } = {},
 ): string {
-  const result = exec.spawnSync("git", args, {
-    cwd: root,
-    stdout: capture ? "capture" : "inherit",
-    stderr: capture ? "ignore" : "inherit",
-    stdin: "ignore",
-    check,
-  });
-  return result.stdout?.trim() ?? "";
+  if (capture) return captureTaskCommand(root, "git", args, { check });
+  runTaskCommand(root, "git", args);
+  return "";
 }
 
 function pushCurrentBranch(root: string, branch: string): void {
@@ -68,84 +70,7 @@ function pushCurrentBranch(root: string, branch: string): void {
 }
 
 function gitSucceeds(root: string, args: string[]): boolean {
-  return (
-    exec.spawnSync("git", args, {
-      cwd: root,
-      stdout: "ignore",
-      stderr: "ignore",
-      stdin: "ignore",
-      check: false,
-    }).exitCode === 0
-  );
-}
-
-function commandSucceeds(
-  root: string,
-  command: string,
-  args: string[],
-  env?: NodeJS.ProcessEnv,
-): boolean {
-  return (
-    exec.spawnSync(command, args, {
-      cwd: root,
-      env,
-      stdout: "ignore",
-      stderr: "ignore",
-      stdin: "ignore",
-      check: false,
-    }).exitCode === 0
-  );
-}
-
-function run(root: string, command: string, args: string[], env?: NodeJS.ProcessEnv): void {
-  exec.spawnSync(command, args, {
-    cwd: root,
-    env,
-    stdout: "inherit",
-    stderr: "inherit",
-    stdin: "ignore",
-    check: true,
-  });
-}
-
-/** Run one release command with inherited output and a hard timeout. */
-async function runWithTimeout(
-  root: string,
-  command: string,
-  args: string[],
-  env: NodeJS.ProcessEnv,
-  timeoutMs: number,
-): Promise<void> {
-  await exec.spawn(command, args, {
-    cwd: root,
-    env,
-    stdout: "inherit",
-    stderr: "inherit",
-    stdin: "ignore",
-    signal: AbortSignal.timeout(timeoutMs),
-    check: true,
-  });
-}
-
-/** Capture one non-interactive command without throwing on a nonzero exit. */
-function captureCommand(
-  root: string,
-  command: string,
-  args: string[],
-  env: NodeJS.ProcessEnv,
-): string {
-  return (
-    exec
-      .spawnSync(command, args, {
-        cwd: root,
-        env,
-        stdout: "capture",
-        stderr: "ignore",
-        stdin: "ignore",
-        check: false,
-      })
-      .stdout?.trim() ?? ""
-  );
+  return taskCommandSucceeds(root, "git", args);
 }
 
 /** Wait for required checks and return the merged pull request commit. */
@@ -155,16 +80,15 @@ async function waitForPullRequestMerge(
   env: NodeJS.ProcessEnv,
   timeoutMs: number,
 ): Promise<string> {
-  await runWithTimeout(
+  await runTaskCommandAsync(
     root,
     "gh",
     ["pr", "checks", releaseBranch, "--watch", "--fail-fast", "--required", "--interval", "10"],
-    env,
-    timeoutMs,
+    { env, signal: AbortSignal.timeout(timeoutMs) },
   );
   const deadline = Date.now() + timeoutMs;
   while (Date.now() < deadline) {
-    const state = captureCommand(
+    const state = captureTaskCommand(
       root,
       "gh",
       [
@@ -176,12 +100,12 @@ async function waitForPullRequestMerge(
         "--jq",
         '[.state, (.mergeCommit.oid // "")] | @tsv',
       ],
-      env,
+      { env },
     );
     const [status, mergeSha] = state.split("\t");
     if (status === "MERGED" && mergeSha) return mergeSha;
     if (status === "CLOSED") throw new Error(`Release pull request closed without merging`);
-    await asyncModule.sleep(2_000);
+    await asyncUtils.sleep(2_000);
   }
   throw new Error(`Release pull request did not merge within ${timeoutMs}ms`);
 }
@@ -197,7 +121,7 @@ async function waitForReleaseWorkflow(
   const deadline = Date.now() + timeoutMs;
   let runId = "";
   while (Date.now() < deadline) {
-    runId = captureCommand(
+    runId = captureTaskCommand(
       root,
       "gh",
       [
@@ -218,13 +142,16 @@ async function waitForReleaseWorkflow(
         "--jq",
         ".[0].databaseId // empty",
       ],
-      env,
+      { env },
     );
     if (runId) break;
-    await asyncModule.sleep(5_000);
+    await asyncUtils.sleep(5_000);
   }
   if (!runId) throw new Error(`Release workflow did not start within ${timeoutMs}ms`);
-  await runWithTimeout(root, "gh", ["run", "watch", runId, "--exit-status"], env, timeoutMs);
+  await runTaskCommandAsync(root, "gh", ["run", "watch", runId, "--exit-status"], {
+    env,
+    signal: AbortSignal.timeout(timeoutMs),
+  });
 }
 
 function githubAccount(root: string): {
@@ -234,7 +161,7 @@ function githubAccount(root: string): {
   login: string;
   token: string;
 } {
-  const repository = project.repositoryUrl(root);
+  const repository = projectUtils.repositoryUrl(root);
   if (!repository) throw new Error("Release preparation requires a GitHub repository");
   const identity = githubRepositoryIdentity(repository);
   const status = exec
@@ -375,7 +302,7 @@ program
       wait: boolean;
       waitTimeoutMinutes: string;
     }) => {
-      const root = project.root() ?? process.cwd();
+      const root = projectUtils.root() ?? process.cwd();
       const waitTimeoutMinutes = object.toNumber(opts.waitTimeoutMinutes, {
         separators: false,
         percent: false,
@@ -397,6 +324,15 @@ program
         includeComponentTags: false,
       }).version;
       const next = resolveNextVersion(root, [opts.prefix], opts.level, { fetch: false });
+      const releaseVersionScript = fileURLToPath(new URL("./release-version.ts", import.meta.url));
+      runTaskCommand(root, process.execPath, [
+        releaseVersionScript,
+        "--version",
+        next.version,
+        "--prefix",
+        opts.prefix,
+        "--assert-next",
+      ]);
       const releaseTag = `${opts.prefix}${next.version}`;
       const releaseBranch = `release/${releaseTag}`;
       const releaseRoot = join(root, ".worktrees", releaseTag);
@@ -454,11 +390,11 @@ program
         }
         logger.info(`resuming ${releaseBranch} in ${releaseRoot}`);
       }
-      run(releaseRoot, process.execPath, ["install"]);
+      runTaskCommand(releaseRoot, process.execPath, ["install"]);
 
       const bumpScript = fileURLToPath(new URL("./bump.ts", import.meta.url));
       const versionCheckScript = fileURLToPath(new URL("./version-check.ts", import.meta.url));
-      run(releaseRoot, process.execPath, [
+      runTaskCommand(releaseRoot, process.execPath, [
         bumpScript,
         "--level",
         opts.level,
@@ -471,19 +407,19 @@ program
         throw new Error(`Release preparation did not produce ${next.version}`);
       }
 
-      run(releaseRoot, process.execPath, [versionCheckScript]);
+      runTaskCommand(releaseRoot, process.execPath, [versionCheckScript]);
       if (opts.validate) {
         for (const task of opts.validateTask) {
-          run(releaseRoot, process.execPath, ["run", task]);
+          runTaskCommand(releaseRoot, process.execPath, ["run", task]);
         }
         if (existsSync(join(releaseRoot, "Cargo.toml"))) {
-          run(releaseRoot, "cargo", [
+          runTaskCommand(releaseRoot, "cargo", [
             "test",
             "--workspace",
             ...(existsSync(join(releaseRoot, "Cargo.lock")) ? ["--locked"] : []),
           ]);
         }
-        run(releaseRoot, process.execPath, ["run", "compile"]);
+        runTaskCommand(releaseRoot, process.execPath, ["run", "compile"]);
       } else {
         logger.warn("release validation skipped by --no-validate");
       }
@@ -495,11 +431,12 @@ program
           localPypi: opts.localPypi,
           pythonRoot: opts.pythonRoot,
           localCargo: opts.localCargo,
+          reuseValidatedNodeCompile: opts.validate,
         });
       } else {
         logger.info("local publication skipped by --no-local-publish");
       }
-      run(releaseRoot, process.execPath, [versionCheckScript]);
+      runTaskCommand(releaseRoot, process.execPath, [versionCheckScript]);
       const releaseSummary = opts.releaseSummary
         ? await generateReleaseSummary({
             root: releaseRoot,
@@ -537,8 +474,14 @@ program
         [githubTokenEnvironmentName(account.hostname)]: account.token,
       };
       const ensurePullRequest = (): void => {
-        if (commandSucceeds(root, "gh", ["pr", "view", releaseBranch], githubEnvironment)) return;
-        run(
+        if (
+          taskCommandSucceeds(root, "gh", ["pr", "view", releaseBranch], {
+            env: githubEnvironment,
+          })
+        ) {
+          return;
+        }
+        runTaskCommand(
           root,
           "gh",
           [
@@ -553,12 +496,14 @@ program
             "--body",
             body,
           ],
-          githubEnvironment,
+          { env: githubEnvironment },
         );
       };
       ensurePullRequest();
       if (opts.approve) {
-        run(root, "gh", ["pr", "merge", releaseBranch, "--auto", "--merge"], githubEnvironment);
+        runTaskCommand(root, "gh", ["pr", "merge", releaseBranch, "--auto", "--merge"], {
+          env: githubEnvironment,
+        });
       }
       git(root, ["worktree", "remove", "--force", releaseRoot]);
       git(root, ["branch", "--delete", "--force", releaseBranch]);

package/tasks/release-request.ts

@@ -3,10 +3,11 @@
 
 import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, resolve } from "node:path";
-import { exec, project } from "@dbx-tools/core";
-import { log, string } from "@dbx-tools/shared-core";
+import * as projectUtils from "@dbx-tools/core/project-utils";
+import { log, stringUtils } from "@dbx-tools/shared-core";
 import { Command } from "commander";
 import { selectReleaseSummary } from "./release-summary.ts";
+import { captureTaskCommand, runTaskCommand } from "../src/_task-command.ts";
 
 const logger = log.logger("projen:release-request");
 
@@ -33,13 +34,7 @@ export async function prepareReleaseRequest(
   }
   const baseRef = options.push === false ? options.baseBranch : `origin/${options.baseBranch}`;
   if (options.synthesize !== false) {
-    exec.spawnSync(process.execPath, ["x", "projen"], {
-      cwd: root,
-      stdout: "inherit",
-      stderr: "inherit",
-      stdin: "ignore",
-      check: true,
-    });
+    runTaskCommand(root, process.execPath, ["x", "projen"]);
   }
   const dirty = capture(root, ["status", "--porcelain"]);
   if (dirty) {
@@ -74,7 +69,7 @@ export async function prepareReleaseRequest(
     throw new Error(`Release requests must run from a branch other than ${options.baseBranch}`);
   }
 
-  const customNotes = string.trimToNull(
+  const customNotes = stringUtils.trimToNull(
     options.notesFile ? readFileSync(resolve(root, options.notesFile), "utf8") : options.notes,
   );
   const notes =
@@ -130,27 +125,11 @@ async function generateRequestNotes(root: string, range: string): Promise<string
 }
 
 function capture(root: string, args: string[]): string {
-  return (
-    exec
-      .spawnSync("git", args, {
-        cwd: root,
-        stdout: "capture",
-        stderr: "inherit",
-        stdin: "ignore",
-        check: true,
-      })
-      .stdout?.trim() ?? ""
-  );
+  return captureTaskCommand(root, "git", args, { check: true, stderr: "inherit" });
 }
 
 function run(root: string, args: string[]): void {
-  exec.spawnSync("git", args, {
-    cwd: root,
-    stdout: "inherit",
-    stderr: "inherit",
-    stdin: "ignore",
-    check: true,
-  });
+  runTaskCommand(root, "git", args);
 }
 
 /** Restore option text after Projen forwards task arguments without shell quoting. */
@@ -175,7 +154,7 @@ if (import.meta.main) {
           throw new Error("Use --notes or --notes-file, not both");
         }
         await prepareReleaseRequest({
-          root: project.root() ?? process.cwd(),
+          root: projectUtils.root() ?? process.cwd(),
           baseBranch: options.base,
           message: optionText(options.message),
           notes: optionText(options.notes),

package/tasks/release-summary-units.ts

@@ -3,10 +3,10 @@
 
 import { existsSync, readFileSync, readdirSync, rmSync } from "node:fs";
 import { join, resolve } from "node:path";
-import { exec } from "@dbx-tools/core";
 import { log } from "@dbx-tools/shared-core";
 import { Command } from "commander";
 import { generateReleaseSummary } from "./release-summary.ts";
+import { captureTaskCommand } from "../src/_task-command.ts";
 import type { ReleaseUnitGraph } from "../src/release-catalog.ts";
 import type { ReleasePlan } from "../src/release-plan.ts";
 
@@ -71,12 +71,5 @@ function requestNotes(root: string): { summary?: string; paths: string[] } {
 }
 
 function gitCapture(root: string, args: string[]): string {
-  const result = exec.spawnSync("git", args, {
-    cwd: root,
-    stdout: "capture",
-    stderr: "ignore",
-    stdin: "ignore",
-    check: false,
-  });
-  return result.exitCode === 0 ? (result.stdout?.trim() ?? "") : "";
+  return captureTaskCommand(root, "git", args);
 }

package/tasks/release-summary.ts

@@ -6,8 +6,10 @@
  */
 import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
-import { exec } from "@dbx-tools/core";
-import { json, log, object, string } from "@dbx-tools/shared-core";
+import * as exec from "@dbx-tools/core/exec";
+import * as projectUtils from "@dbx-tools/core/project-utils";
+import { json, log, object, stringUtils } from "@dbx-tools/shared-core";
+import { captureTaskCommand } from "../src/_task-command.ts";
 import {
   RELEASE_SUMMARY_PROVIDER_NAMES,
   releaseSummaryFile,
@@ -84,30 +86,23 @@ export type ReleaseSummaryRunner = (
 ) => string | undefined | Promise<string | undefined>;
 
 function capture(root: string, command: string, args: string[]): string {
-  const result = exec.spawnSync(command, args, {
-    cwd: root,
-    stdout: "capture",
-    stderr: "ignore",
-    stdin: "ignore",
-    check: false,
-  });
-  return result.exitCode === 0 ? (result.stdout?.trim() ?? "") : "";
+  return captureTaskCommand(root, command, args);
 }
 
 function contentText(value: unknown): string | undefined {
-  if (typeof value === "string") return string.trimToNull(value) ?? undefined;
+  if (typeof value === "string") return stringUtils.trimToNull(value) ?? undefined;
   if (!Array.isArray(value)) return undefined;
   const text = value
     .flatMap((item) => (object.isRecord(item) && typeof item.text === "string" ? [item.text] : []))
     .join("");
-  return string.trimToNull(text) ?? undefined;
+  return stringUtils.trimToNull(text) ?? undefined;
 }
 
 function eventText(event: Record<string, unknown>): string | undefined {
-  if (typeof event.result === "string") return string.trimToNull(event.result) ?? undefined;
+  if (typeof event.result === "string") return stringUtils.trimToNull(event.result) ?? undefined;
   const item = object.isRecord(event.item) ? event.item : undefined;
   if (item?.type === "agent_message" && typeof item.text === "string") {
-    return string.trimToNull(item.text) ?? undefined;
+    return stringUtils.trimToNull(item.text) ?? undefined;
   }
   const message = object.isRecord(event.message) ? event.message : undefined;
   return contentText(message?.content);
@@ -121,7 +116,7 @@ function eventType(event: Record<string, unknown>): string {
 function eventDetail(event: Record<string, unknown>): string | undefined {
   const item = object.isRecord(event.item) ? event.item : undefined;
   for (const value of [item?.message, event.message, event.error]) {
-    if (typeof value === "string") return string.trimToNull(value) ?? undefined;
+    if (typeof value === "string") return stringUtils.trimToNull(value) ?? undefined;
   }
   return undefined;
 }
@@ -129,7 +124,7 @@ function eventDetail(event: Record<string, unknown>): string | undefined {
 function eventToolName(event: Record<string, unknown>): string | undefined {
   const item = object.isRecord(event.item) ? event.item : undefined;
   for (const value of [event.tool_name, event.toolName, event.name, item?.tool_name, item?.name]) {
-    if (typeof value === "string") return string.trimToNull(value) ?? undefined;
+    if (typeof value === "string") return stringUtils.trimToNull(value) ?? undefined;
   }
   const toolCall = object.isRecord(event.tool_call)
     ? event.tool_call
@@ -185,7 +180,7 @@ async function runProvider(
       (line) => {
         const event = json.parseRecord(line);
         if (!event) {
-          const text = string.trimToNull(line);
+          const text = stringUtils.trimToNull(line);
           if (text) {
             textOutput.push(text);
             logEvent({ type: "text", text });
@@ -198,7 +193,7 @@ async function runProvider(
       },
     ],
     stderr: (line) => {
-      const message = string.trimToNull(line);
+      const message = stringUtils.trimToNull(line);
       if (message) logger.warn("provider-stderr", { provider: provider.name, message });
     },
     stdin: "ignore",
@@ -243,6 +238,7 @@ export async function selectReleaseSummary(
 }
 
 function summaryPrompt(
+  projectName: string,
   version: string,
   fromRef: string | undefined,
   commits: string,
@@ -250,7 +246,7 @@ function summaryPrompt(
   diffStat: string,
 ): string {
   return [
-    `Write a concise user-facing Markdown release summary for dbx-tools ${version}.`,
+    `Write a concise user-facing Markdown release summary for ${projectName} ${version}.`,
     "Use only the supplied Git context. Do not run commands, edit files, speculate,",
     "mention commit hashes, use emojis, or use em/en dashes.",
     "Return no title and no fenced block. Start with one short paragraph, then",
@@ -270,7 +266,12 @@ function summaryPrompt(
 }
 
 /** Deterministic fallback when every configured AI provider is unavailable. */
-function gitSummary(version: string, commits: string, changedFiles: string): string {
+function gitSummary(
+  projectName: string,
+  version: string,
+  commits: string,
+  changedFiles: string,
+): string {
   const subjects = commits
     .split("\n")
     .map((line) => line.trim())
@@ -290,7 +291,7 @@ function gitSummary(version: string, commits: string, changedFiles: string): str
     .slice(0, 12);
   const bullets = subjects.length ? subjects : areas.map((area) => `Updated ${area}`);
   return [
-    `dbx-tools ${version} contains the reviewed changes listed below.`,
+    `${projectName} ${version} contains the reviewed changes listed below.`,
     "",
     "## Changes",
     ...(bullets.length ? bullets.map((item) => `- ${item}`) : ["- Release metadata updated."]),
@@ -310,6 +311,7 @@ export async function generateReleaseSummary(options: {
   readonly providers?: readonly ReleaseSummaryProviderName[];
   readonly runner?: ReleaseSummaryRunner;
 }): Promise<string | undefined> {
+  const projectName = projectUtils.name(options.root);
   const relativeOutput =
     options.outputFile ?? releaseSummaryFile(options.version, options.component);
   const output = join(options.root, relativeOutput);
@@ -347,17 +349,26 @@ export async function generateReleaseSummary(options: {
     ...scopedPaths,
     `:(exclude)${relativeOutput}`,
   ]);
-  const customSummary = string.trimToNull(options.customSummary);
+  const customSummary = stringUtils.trimToNull(options.customSummary);
   const result = customSummary
     ? undefined
     : await selectReleaseSummary(
         options.root,
-        summaryPrompt(options.version, options.fromRef, commits, changedFiles, diffStat),
+        summaryPrompt(
+          projectName,
+          options.version,
+          options.fromRef,
+          commits,
+          changedFiles,
+          diffStat,
+        ),
         options.runner,
         options.providers,
       );
   const summary =
-    customSummary ?? result?.summary ?? gitSummary(options.version, commits, changedFiles);
+    customSummary ??
+    result?.summary ??
+    gitSummary(projectName, options.version, commits, changedFiles);
   const provider = customSummary ? "custom" : (result?.provider ?? "git");
   if (!customSummary && !result) {
     logger.info("AI providers unavailable; using Git release summary");

package/tasks/release-version.ts

@@ -0,0 +1,44 @@
+#!/usr/bin/env -S bun
+/** Validate one stable release version against the canonical workspace policy. */
+import { resolve } from "node:path";
+import { parseArgs } from "node:util";
+import * as projectUtils from "@dbx-tools/core/project-utils";
+import { compareSemver, parseSemver, resolveRemoteVersion } from "../src/workspace-version.ts";
+
+export function assertReleaseVersion(
+  version: string,
+  options: { root?: string; prefixes?: readonly string[]; assertNext?: boolean } = {},
+): void {
+  const parsed = parseSemver(version);
+  if (!parsed) {
+    throw new Error(
+      `release version must be an exact stable x.y.z, got ${JSON.stringify(version)}`,
+    );
+  }
+  if (!options.assertNext) return;
+  const root = resolve(options.root ?? projectUtils.root() ?? process.cwd());
+  const prefixes = options.prefixes?.length ? options.prefixes : ["v"];
+  const current = resolveRemoteVersion(root, prefixes, { fetch: false });
+  const currentParsed = current ? parseSemver(current) : undefined;
+  if (currentParsed && compareSemver(parsed, currentParsed) <= 0) {
+    throw new Error(`release version ${version} must be greater than published ${current}`);
+  }
+}
+
+if (import.meta.main) {
+  const { values } = parseArgs({
+    options: {
+      version: { type: "string" },
+      root: { type: "string" },
+      prefix: { type: "string", multiple: true },
+      "assert-next": { type: "boolean", default: false },
+    },
+    strict: true,
+  });
+  if (!values.version) throw new Error("--version is required");
+  assertReleaseVersion(values.version, {
+    ...(values.root ? { root: values.root } : {}),
+    ...(values.prefix ? { prefixes: values.prefix } : {}),
+    assertNext: values["assert-next"],
+  });
+}