@wpelevator/wp-release 0.5.0 → 0.6.1

package/dist/changesets.d.ts

@@ -0,0 +1,72 @@
+export type { ChangesetConfig } from './changeset-config.ts';
+export declare const CHANGESET_BUMPS: readonly ["patch", "minor", "major"];
+export type ChangesetBump = (typeof CHANGESET_BUMPS)[number];
+export type ChangesetPackages = Record<string, ChangesetBump>;
+/** A parsed Changesets-compatible Markdown file. */
+export interface Changeset {
+    /** File name relative to .changeset/, including the .md extension. */
+    fileName: string;
+    /** Package names and their requested version bumps; empty for a no-release changeset. */
+    packages: ChangesetPackages;
+    /** Customer-facing release note. */
+    summary: string;
+}
+export type ChangesetPackageType = 'plugin' | 'theme' | 'npm' | 'other';
+/** A package discovered from repository configuration and its version files. */
+export interface ChangesetPackage {
+    /** Changeset-facing identifier (package.json name or configured path id). */
+    name: string;
+    /** Absolute package directory. */
+    directory: string;
+    /** Package path relative to the configured root. */
+    path: string;
+    type: ChangesetPackageType;
+    /** Version read from the package's authoritative version source. */
+    currentVersion: string;
+}
+/** One package's proposed release in a release plan. */
+export interface PackageRelease {
+    package: ChangesetPackage;
+    bump: ChangesetBump;
+    currentVersion: string;
+    nextVersion: string;
+    changesets: Changeset[];
+}
+/** Deterministic release plan assembled from pending changesets. */
+export interface ChangesetReleasePlan {
+    changesets: Changeset[];
+    releases: PackageRelease[];
+}
+/**
+ * Parse the supported subset of Changesets' Markdown format.
+ *
+ * @param  contents Markdown contents.
+ * @param  fileName File name relative to .changeset/.
+ * @return Parsed changeset.
+ * @throws {ValidationError} If the frontmatter or package bumps are invalid.
+ */
+export declare function parseChangeset(contents: string, fileName?: string): Changeset;
+/**
+ * Serialize a changeset using the standard Markdown frontmatter format.
+ *
+ * @param changeset Parsed changeset values.
+ * @return Markdown contents with a trailing newline.
+ */
+export declare function formatChangeset(changeset: Omit<Changeset, 'fileName'>): string;
+/**
+ * Return the strongest bump requested for a package across changesets.
+ *
+ * @param changesets  Pending changesets.
+ * @param packageName Package identifier.
+ * @return Highest bump, or undefined when no changeset mentions the package.
+ */
+export declare function getChangesetBump(changesets: Changeset[], packageName: string): ChangesetBump | undefined;
+/**
+ * Calculate the next stable semantic version using literal SemVer bump rules.
+ *
+ * @param  currentVersion Current package version.
+ * @param  bump           Requested bump.
+ * @return Next version.
+ * @throws {ValidationError} If currentVersion is not a stable x.y.z version.
+ */
+export declare function getNextVersion(currentVersion: string, bump: ChangesetBump): string;

package/dist/changesets.js

@@ -0,0 +1,103 @@
+import { ValidationError } from "./errors.js";
+export const CHANGESET_BUMPS = ['patch', 'minor', 'major'];
+const BUMP_RANK = {
+    patch: 0,
+    minor: 1,
+    major: 2,
+};
+/**
+ * Parse the supported subset of Changesets' Markdown format.
+ *
+ * @param  contents Markdown contents.
+ * @param  fileName File name relative to .changeset/.
+ * @return Parsed changeset.
+ * @throws {ValidationError} If the frontmatter or package bumps are invalid.
+ */
+export function parseChangeset(contents, fileName = 'changeset.md') {
+    const lines = contents.replace(/^\uFEFF/, '').split(/\r?\n/);
+    if ('---' !== lines[0]) {
+        throw new ValidationError(`Changeset ${fileName} must start with YAML frontmatter (---).`);
+    }
+    const closingLine = lines.indexOf('---', 1);
+    if (-1 === closingLine) {
+        throw new ValidationError(`Changeset ${fileName} is missing the closing frontmatter delimiter.`);
+    }
+    const packages = {};
+    const frontmatter = lines.slice(1, closingLine);
+    frontmatter.forEach((line, index) => {
+        if (line.trim()) {
+            const match = /^\s*(?:"((?:[^"\\]|\\.)+)"|'([^']+)'|([^:#]+))\s*:\s*(patch|minor|major)\s*$/.exec(line);
+            if (!match) {
+                throw new ValidationError(`Invalid package bump on line ${index + 2} of changeset ${fileName}.`);
+            }
+            const name = (match[1] ?? match[2] ?? match[3] ?? '')
+                .replaceAll('\\"', '"')
+                .trim();
+            if (!name) {
+                throw new ValidationError(`Package name is empty on line ${index + 2} of changeset ${fileName}.`);
+            }
+            if (Object.hasOwn(packages, name)) {
+                throw new ValidationError(`Package "${name}" appears more than once in changeset ${fileName}.`);
+            }
+            packages[name] = match[4];
+        }
+    });
+    return {
+        fileName,
+        packages,
+        summary: lines
+            .slice(closingLine + 1)
+            .join('\n')
+            .trim(),
+    };
+}
+/**
+ * Serialize a changeset using the standard Markdown frontmatter format.
+ *
+ * @param changeset Parsed changeset values.
+ * @return Markdown contents with a trailing newline.
+ */
+export function formatChangeset(changeset) {
+    const entries = Object.entries(changeset.packages).sort((a, b) => a[0].localeCompare(b[0]));
+    const frontmatter = entries
+        .map(([name, bump]) => `${JSON.stringify(name)}: ${bump}`)
+        .join('\n');
+    return `---\n${frontmatter}\n---\n\n${changeset.summary.trim()}\n`;
+}
+/**
+ * Return the strongest bump requested for a package across changesets.
+ *
+ * @param changesets  Pending changesets.
+ * @param packageName Package identifier.
+ * @return Highest bump, or undefined when no changeset mentions the package.
+ */
+export function getChangesetBump(changesets, packageName) {
+    const bumps = changesets
+        .map((changeset) => changeset.packages[packageName])
+        .filter((bump) => Boolean(bump));
+    return bumps.sort((a, b) => BUMP_RANK[b] - BUMP_RANK[a])[0];
+}
+/**
+ * Calculate the next stable semantic version using literal SemVer bump rules.
+ *
+ * @param  currentVersion Current package version.
+ * @param  bump           Requested bump.
+ * @return Next version.
+ * @throws {ValidationError} If currentVersion is not a stable x.y.z version.
+ */
+export function getNextVersion(currentVersion, bump) {
+    if (!CHANGESET_BUMPS.includes(bump)) {
+        throw new ValidationError(`Invalid bump "${bump}"; expected patch, minor or major.`);
+    }
+    const match = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/.exec(currentVersion);
+    if (!match) {
+        throw new ValidationError(`Cannot bump "${currentVersion}": expected a stable semantic version in x.y.z format.`);
+    }
+    if ('major' === bump) {
+        return `${Number(match[1]) + 1}.0.0`;
+    }
+    if ('minor' === bump) {
+        return `${match[1]}.${Number(match[2]) + 1}.0`;
+    }
+    return `${match[1]}.${match[2]}.${Number(match[3]) + 1}`;
+}

package/dist/cli.d.ts

@@ -1,6 +1,7 @@
 import type { ChecksumsResult } from './commands/checksums.ts';
 import type { SignResult } from './commands/sign.ts';
 import type { ZipResult } from './commands/zip.ts';
+import type { ChangesetVersionResult } from './commands/changeset-version.ts';
 import { Logger } from './logger.ts';
 import type { OutputStream } from './logger.ts';
 import type { Command, CommandOutcome } from './commands/command.ts';
@@ -43,23 +44,29 @@ export interface CommandResults {
     zip: ZipResult;
     checksums: ChecksumsResult;
     sign: SignResult;
+    'changeset-add': import('./commands/changeset-add.ts').ChangesetAddResult;
+    'changeset-status': import('./commands/changeset-status.ts').ChangesetStatusResult;
+    'changeset-version': ChangesetVersionResult;
+    'changeset-tag': import('./changeset-release.ts').ChangesetTagResult;
 }
 /**
  * Run a command by name with the given arguments, for wrappers like the
  * GitHub Actions that need the result and the thrown errors instead of an
  * exit code.
  *
- * @param  name           Command name, such as zip.
- * @param  args           Arguments after the command name.
- * @param  context        Working directory and logger.
- * @param  context.cwd    Working directory that relative paths resolve against.
- * @param  context.logger Logger for the command output.
+ * @param  name               Command name, such as zip.
+ * @param  args               Arguments after the command name.
+ * @param  context            Working directory and logger.
+ * @param  context.cwd        Working directory that relative paths resolve against.
+ * @param  context.configFile Explicit config file path, when supplied by a wrapper.
+ * @param  context.logger     Logger for the command output.
  * @return Exit code and result of the command.
  * @throws {Error} If the command is unknown, the arguments are invalid or the command fails.
  */
 export declare function execute<Name extends keyof CommandResults>(name: Name, args: string[], context: {
     cwd: string;
     logger: Logger;
+    configFile?: string;
 }): Promise<CommandOutcome<CommandResults[Name]>>;
 /**
  * Run the CLI.

package/dist/cli.js

@@ -1,3 +1,4 @@
+import { appendFileSync } from 'node:fs';
 import { parseArgs } from 'node:util';
 import zip from "./commands/zip.js";
 import checksums from "./commands/checksums.js";
@@ -10,6 +11,10 @@ import { getBoolean, getString } from "./commands/command.js";
 import { ValidationError } from "./errors.js";
 import { GitHubActionsWriter } from "./github-actions-writer.js";
 import { logError } from "./report.js";
+import changesetAdd from "./commands/changeset-add.js";
+import changesetStatus from "./commands/changeset-status.js";
+import changesetVersion from "./commands/changeset-version.js";
+import changesetTag from "./commands/changeset-tag.js";
 export const EXIT_SUCCESS = 0;
 export const EXIT_FAILURE = 1;
 export const EXIT_INVALID = 2;
@@ -20,6 +25,10 @@ export const commands = [
     verify,
     versionCheck,
     deploySvn,
+    changesetAdd,
+    changesetStatus,
+    changesetVersion,
+    changesetTag,
 ];
 const globalArgs = {
     help: { type: 'boolean', short: 'h' },
@@ -28,6 +37,8 @@ const globalArgs = {
     'log-format': { type: 'string' },
     ci: { type: 'boolean' },
     json: { type: 'boolean' },
+    'github-output': { type: 'boolean' },
+    config: { type: 'string' },
 };
 const globalOptions = `Global options:
   -h, --help               Show help for the command
@@ -37,7 +48,10 @@ const globalOptions = `Global options:
                            annotations and job summaries (default: github
                            when GITHUB_ACTIONS=true, otherwise text)
       --ci                 Same as --log-format github
-      --json               Print the result as JSON`;
+      --json               Print the result as JSON
+      --github-output      Set the result as JSON to the "result" output of
+                           the GitHub Actions step
+      --config <path>      Path to a JavaScript release config file`;
 /**
  * Get the top-level help text listing all commands.
  *
@@ -133,6 +147,21 @@ function createLogWriter(values, streams) {
     }
     return create(streams);
 }
+/**
+ * Get the GitHub Actions step output file for --github-output, checked before
+ * the command runs.
+ *
+ * @param  values Parsed option values.
+ * @return Output file path, or undefined without --github-output.
+ * @throws {ValidationError} For --github-output without GITHUB_OUTPUT.
+ */
+function getGitHubOutputFile(values) {
+    const file = process.env.GITHUB_OUTPUT;
+    if (getBoolean(values, 'github-output') && !file) {
+        throw new ValidationError('--github-output requires the GITHUB_OUTPUT environment variable of GitHub Actions.');
+    }
+    return getBoolean(values, 'github-output') ? file : undefined;
+}
 /**
  * Parse the arguments of a command and run it.
  *
@@ -155,6 +184,11 @@ async function runCommand(command, args, io) {
             options: { ...globalArgs, ...command.options },
             allowPositionals: true,
         });
+        const configFile = getString(values, 'config');
+        if ('' === configFile?.trim()) {
+            throw new ValidationError('--config <path> must not be empty.');
+        }
+        const githubOutputFile = getGitHubOutputFile(values);
         logger = new Logger({
             writer: createLogWriter(values, { stdout, stderr }),
             quiet: getBoolean(values, 'quiet') || getBoolean(values, 'json'),
@@ -164,11 +198,16 @@ async function runCommand(command, args, io) {
             values,
             positionals,
             cwd,
+            ...(configFile ? { configFile } : {}),
             logger,
         });
         if (getBoolean(values, 'json')) {
             stdout.write(JSON.stringify(result, null, '\t') + '\n');
         }
+        if (githubOutputFile) {
+            // Compact JSON has no line breaks, so it fits a single output line.
+            appendFileSync(githubOutputFile, `result=${JSON.stringify(result)}\n`);
+        }
         return exitCode;
     }
     catch (error) {
@@ -181,11 +220,12 @@ async function runCommand(command, args, io) {
  * GitHub Actions that need the result and the thrown errors instead of an
  * exit code.
  *
- * @param  name           Command name, such as zip.
- * @param  args           Arguments after the command name.
- * @param  context        Working directory and logger.
- * @param  context.cwd    Working directory that relative paths resolve against.
- * @param  context.logger Logger for the command output.
+ * @param  name               Command name, such as zip.
+ * @param  args               Arguments after the command name.
+ * @param  context            Working directory and logger.
+ * @param  context.cwd        Working directory that relative paths resolve against.
+ * @param  context.configFile Explicit config file path, when supplied by a wrapper.
+ * @param  context.logger     Logger for the command output.
  * @return Exit code and result of the command.
  * @throws {Error} If the command is unknown, the arguments are invalid or the command fails.
  */
@@ -196,14 +236,19 @@ export async function execute(name, args, context) {
     }
     const { values, positionals } = parseArgs({
         args,
-        options: command.options,
+        options: { ...globalArgs, ...command.options },
         allowPositionals: true,
     });
+    const configFile = getString(values, 'config') ?? context.configFile;
+    if ('' === configFile?.trim()) {
+        throw new ValidationError('--config <path> must not be empty.');
+    }
     // The command table is keyed by name, so the result matches CommandResults.
     return command.run({
         values,
         positionals,
         ...context,
+        ...(configFile ? { configFile } : {}),
     });
 }
 /**

package/dist/commands/changeset-add.d.ts

@@ -0,0 +1,37 @@
+export interface ChangesetAddResult {
+    file: string;
+    packages: Record<string, string>;
+}
+declare const _default: {
+    name: string;
+    usage: string;
+    summary: string;
+    help: string;
+    options: {
+        readonly package: {
+            readonly type: "string";
+            readonly multiple: true;
+        };
+        readonly bump: {
+            readonly type: "string";
+            readonly multiple: true;
+        };
+        readonly summary: {
+            readonly type: "string";
+        };
+        readonly empty: {
+            readonly type: "boolean";
+        };
+        readonly name: {
+            readonly type: "string";
+        };
+    };
+    run({ values, cwd, configFile, logger }: import("./command.ts").CommandContext): Promise<{
+        exitCode: number;
+        result: {
+            file: string;
+            packages: import("../changesets.ts").ChangesetPackages;
+        };
+    }>;
+};
+export default _default;

package/dist/commands/changeset-add.js

@@ -0,0 +1,35 @@
+import { addChangeset } from "../changeset-release.js";
+import { parseChangesetAddArgs, changesetAddArgs } from "./changeset-args.js";
+export default {
+    name: 'changeset-add',
+    usage: 'changeset-add (--empty | --package <name> --bump <bump> ...) [options]',
+    summary: 'Add a package release note for the next release PR.',
+    help: `Options:
+  --package <name>       Package identifier (repeatable)
+  --bump <bump>          patch, minor or major (repeatable, in package order)
+  --summary <text>       Customer-facing release note
+  --empty                Record that this change does not need a release
+  --name <name>          Changeset filename (default: random identifier)
+
+Use --package and --bump pairs for package releases, or --empty for changes
+that should pass the status check without producing a release.`,
+    options: changesetAddArgs,
+    async run({ values, cwd, configFile, logger }) {
+        const input = parseChangesetAddArgs(values);
+        const file = await addChangeset({
+            cwd,
+            ...(configFile ? { configFile } : {}),
+            packages: input.packages,
+            summary: input.summary,
+            ...(input.name ? { name: input.name } : {}),
+        });
+        logger.info(`Created ${file}.`);
+        return {
+            exitCode: 0,
+            result: {
+                file,
+                packages: input.packages,
+            },
+        };
+    },
+};

package/dist/commands/changeset-args.d.ts

@@ -0,0 +1,118 @@
+import type { ChangesetPackages } from '../changesets.ts';
+import type { ParsedValues } from './command.ts';
+/** Parsed input for `changeset-add`. */
+export interface ChangesetAddArgs {
+    packages: ChangesetPackages;
+    summary: string;
+    empty: boolean;
+    name?: string;
+}
+/** Parse-args options for `changeset-add`. */
+export declare const changesetAddArgs: {
+    readonly package: {
+        readonly type: "string";
+        readonly multiple: true;
+    };
+    readonly bump: {
+        readonly type: "string";
+        readonly multiple: true;
+    };
+    readonly summary: {
+        readonly type: "string";
+    };
+    readonly empty: {
+        readonly type: "boolean";
+    };
+    readonly name: {
+        readonly type: "string";
+    };
+};
+/**
+ * Parse and validate the `changeset-add` options.
+ *
+ * @param  values Parsed CLI options.
+ * @return Normalized changeset input.
+ * @throws {ValidationError} If required options are missing or conflicting.
+ */
+export declare function parseChangesetAddArgs(values: ParsedValues): ChangesetAddArgs;
+/** Parse-args options for `changeset-status`. */
+export declare const changesetStatusArgs: {
+    readonly since: {
+        readonly type: "string";
+    };
+};
+/** Parsed input for `changeset-status`. */
+export interface ChangesetStatusArgs {
+    since?: string;
+}
+/**
+ * Parse the `changeset-status` options.
+ *
+ * @param  values Parsed CLI options.
+ * @return Normalized status input.
+ * @throws {ValidationError} If --since is empty.
+ */
+export declare function parseChangesetStatusArgs(values: ParsedValues): ChangesetStatusArgs;
+/** Parse-args options for `changeset-version`. */
+export declare const changesetVersionArgs: {
+    readonly 'dry-run': {
+        readonly type: "boolean";
+    };
+    readonly date: {
+        readonly type: "string";
+    };
+};
+/** Parsed input for `changeset-version`. */
+export interface ChangesetVersionArgs {
+    dryRun: boolean;
+    date?: string;
+}
+/**
+ * Validate and normalize a release date option.
+ *
+ * @param  value Value from --date.
+ * @return A validated ISO date or undefined.
+ * @throws {ValidationError} If the date is not a real YYYY-MM-DD date.
+ */
+export declare function parseChangesetDate(value: string | undefined): string | undefined;
+/**
+ * Parse the `changeset-version` options.
+ *
+ * @param  values Parsed CLI options.
+ * @return Normalized versioning input.
+ * @throws {ValidationError} If --date is invalid.
+ */
+export declare function parseChangesetVersionArgs(values: ParsedValues): ChangesetVersionArgs;
+/** Parse-args options for `changeset-tag`. */
+export declare const changesetTagArgs: {
+    readonly push: {
+        readonly type: "boolean";
+    };
+    readonly 'dry-run': {
+        readonly type: "boolean";
+    };
+    readonly untagged: {
+        readonly type: "boolean";
+    };
+    readonly 'github-release': {
+        readonly type: "boolean";
+    };
+    readonly since: {
+        readonly type: "string";
+    };
+};
+/** Parsed input for `changeset-tag`. */
+export interface ChangesetTagArgs {
+    push: boolean;
+    dryRun: boolean;
+    untagged: boolean;
+    githubRelease: boolean;
+    since?: string;
+}
+/**
+ * Parse the `changeset-tag` options.
+ *
+ * @param values Parsed CLI options.
+ * @return Normalized tag input.
+ */
+export declare function parseChangesetTagArgs(values: ParsedValues): ChangesetTagArgs;

package/dist/commands/changeset-args.js

@@ -0,0 +1,144 @@
+import { ValidationError } from "../errors.js";
+import { CHANGESET_BUMPS } from "../changesets.js";
+import { getBoolean, getString, getStrings } from "./command.js";
+/** Parse-args options for `changeset-add`. */
+export const changesetAddArgs = {
+    package: { type: 'string', multiple: true },
+    bump: { type: 'string', multiple: true },
+    summary: { type: 'string' },
+    empty: { type: 'boolean' },
+    name: { type: 'string' },
+};
+/**
+ * Parse and validate the `changeset-add` options.
+ *
+ * @param  values Parsed CLI options.
+ * @return Normalized changeset input.
+ * @throws {ValidationError} If required options are missing or conflicting.
+ */
+export function parseChangesetAddArgs(values) {
+    const names = getStrings(values, 'package');
+    const bumps = getStrings(values, 'bump');
+    const summary = getString(values, 'summary')?.trim();
+    const empty = getBoolean(values, 'empty');
+    const name = getString(values, 'name');
+    if (empty && (names.length || bumps.length || summary)) {
+        throw new ValidationError('--empty cannot be combined with --package, --bump or --summary.');
+    }
+    if (!empty && (!names.length || names.length !== bumps.length)) {
+        throw new ValidationError('Pass matching repeated --package <name> and --bump <patch|minor|major> options, or use --empty.');
+    }
+    if (!empty && !summary) {
+        throw new ValidationError('--summary <text> is required unless --empty is set.');
+    }
+    if (name && !/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(name)) {
+        throw new ValidationError('--name must contain only letters, numbers, dots, underscores or hyphens.');
+    }
+    const packages = {};
+    names.forEach((packageName, index) => {
+        const bump = bumps[index];
+        if (Object.hasOwn(packages, packageName)) {
+            throw new ValidationError(`Package "${packageName}" was passed more than once.`);
+        }
+        if (!CHANGESET_BUMPS.includes(bump)) {
+            throw new ValidationError(`Invalid bump "${bump}" for package "${packageName}"; expected patch, minor or major.`);
+        }
+        packages[packageName] = bump;
+    });
+    return {
+        packages,
+        summary: summary ?? '',
+        empty,
+        ...(name ? { name } : {}),
+    };
+}
+/** Parse-args options for `changeset-status`. */
+export const changesetStatusArgs = {
+    since: { type: 'string' },
+};
+/**
+ * Parse the `changeset-status` options.
+ *
+ * @param  values Parsed CLI options.
+ * @return Normalized status input.
+ * @throws {ValidationError} If --since is empty.
+ */
+export function parseChangesetStatusArgs(values) {
+    const since = getString(values, 'since');
+    if ('' === since?.trim()) {
+        throw new ValidationError('--since <ref> must not be empty.');
+    }
+    return since ? { since } : {};
+}
+/** Parse-args options for `changeset-version`. */
+export const changesetVersionArgs = {
+    'dry-run': { type: 'boolean' },
+    date: { type: 'string' },
+};
+/**
+ * Validate and normalize a release date option.
+ *
+ * @param  value Value from --date.
+ * @return A validated ISO date or undefined.
+ * @throws {ValidationError} If the date is not a real YYYY-MM-DD date.
+ */
+export function parseChangesetDate(value) {
+    if (undefined === value) {
+        return undefined;
+    }
+    const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(value);
+    const parsed = new Date(`${value}T00:00:00.000Z`);
+    if (!match ||
+        Number.isNaN(parsed.getTime()) ||
+        parsed.toISOString().slice(0, 10) !== value) {
+        throw new ValidationError(`Invalid release date "${value}"; expected a real date in YYYY-MM-DD format.`);
+    }
+    return value;
+}
+/**
+ * Parse the `changeset-version` options.
+ *
+ * @param  values Parsed CLI options.
+ * @return Normalized versioning input.
+ * @throws {ValidationError} If --date is invalid.
+ */
+export function parseChangesetVersionArgs(values) {
+    const date = parseChangesetDate(getString(values, 'date'));
+    return {
+        dryRun: getBoolean(values, 'dry-run'),
+        ...(date ? { date } : {}),
+    };
+}
+/** Parse-args options for `changeset-tag`. */
+export const changesetTagArgs = {
+    push: { type: 'boolean' },
+    'dry-run': { type: 'boolean' },
+    untagged: { type: 'boolean' },
+    'github-release': { type: 'boolean' },
+    since: { type: 'string' },
+};
+/**
+ * Parse the `changeset-tag` options.
+ *
+ * @param values Parsed CLI options.
+ * @return Normalized tag input.
+ */
+export function parseChangesetTagArgs(values) {
+    const args = {
+        push: getBoolean(values, 'push'),
+        dryRun: getBoolean(values, 'dry-run'),
+        untagged: getBoolean(values, 'untagged'),
+        githubRelease: getBoolean(values, 'github-release'),
+        since: getString(values, 'since'),
+    };
+    if ('' === args.since?.trim()) {
+        throw new ValidationError('--since <ref> must not be empty.');
+    }
+    if (args.githubRelease && !args.push) {
+        throw new ValidationError('--github-release requires --push.');
+    }
+    if (args.untagged && args.push) {
+        throw new ValidationError('--untagged cannot be combined with --push.');
+    }
+    return args;
+}