@wpelevator/wp-release 0.12.0 → 0.14.0

package/dist/changeset-prompt.js

@@ -0,0 +1,203 @@
+import { createInterface } from 'node:readline';
+import { findPackage } from "./changeset-packages.js";
+import { CHANGESET_BUMPS } from "./changesets.js";
+import { ValidationError } from "./errors.js";
+/**
+ * Ask for the packages, bumps and release note of a changeset, line by line,
+ * so that it works in any terminal and with piped input.
+ */
+export class ChangesetPrompt {
+    terminal;
+    lines;
+    readline;
+    /**
+     * @param terminal Input to read answers from and output for the questions.
+     */
+    constructor(terminal) {
+        this.terminal = terminal;
+    }
+    /**
+     * Ask for the changeset, preselecting the changed packages.
+     *
+     * @param  input Packages, changed packages and an optional release note.
+     * @return Package bumps, empty for no release, and the release note.
+     * @throws {ValidationError} If the input ends before the changeset is complete.
+     */
+    async ask(input) {
+        this.listPackages(input);
+        const names = await this.askUntilValid(this.getPackagesQuestion(input), (answer) => this.parsePackages(answer, input));
+        const packages = {};
+        for (const name of names) {
+            packages[name] = await this.askUntilValid(`Bump for ${name} (patch, minor or major) [patch]: `, (answer) => this.parseBump(answer));
+        }
+        const summary = input.summary ??
+            (names.length
+                ? await this.askUntilValid('Release note: ', (answer) => this.parseSummary(answer))
+                : '');
+        return { packages, summary };
+    }
+    /**
+     * Stop reading the input, so that the process can exit.
+     */
+    close() {
+        this.readline?.close();
+    }
+    /**
+     * Print the numbered packages, marking the changed ones.
+     *
+     * @param input Packages and changed packages.
+     */
+    listPackages(input) {
+        const width = String(input.packages.length).length;
+        const rows = input.packages.map((pkg, index) => {
+            const marker = input.changed.includes(pkg.name) ? '*' : ' ';
+            const label = pkg.name === pkg.path
+                ? pkg.name
+                : `${pkg.name} (${pkg.path})`;
+            return `  ${String(index + 1).padStart(width)} ${marker} ${label}`;
+        });
+        const legend = input.changed.length
+            ? `* changed${input.since ? ` since ${input.since}` : ''} without a changeset`
+            : 'No changed packages without a changeset.';
+        this.terminal.output.write(`Packages:\n${rows.join('\n')}\n${legend}\n`);
+    }
+    /**
+     * Get the package question, with the changed packages as the default.
+     *
+     * @param input Packages and changed packages.
+     * @return Question text.
+     */
+    getPackagesQuestion(input) {
+        const defaults = input.changed.length
+            ? ` [${input.changed.join(', ')}]`
+            : '';
+        return `Packages to release, by number, identifier or path, comma-separated, or "none" for no release${defaults}: `;
+    }
+    /**
+     * Parse the chosen packages.
+     *
+     * @param  answer Comma or space separated numbers, identifiers or paths.
+     * @param  input  Packages and changed packages.
+     * @return Package identifiers, empty for no release.
+     * @throws {ValidationError} For unknown, repeated or missing packages.
+     */
+    parsePackages(answer, input) {
+        const tokens = answer.split(/[\s,]+/).filter(Boolean);
+        let names = input.changed;
+        if (1 === tokens.length && 'none' === tokens[0]) {
+            names = [];
+        }
+        else if (tokens.length) {
+            names = tokens.map((token) => this.parsePackage(token, input.packages));
+        }
+        else if (!names.length) {
+            throw new ValidationError('Choose at least one package, or "none" for no release.');
+        }
+        const repeated = names.find((name, index) => names.indexOf(name) !== index);
+        if (repeated) {
+            throw new ValidationError(`Package "${repeated}" was chosen more than once.`);
+        }
+        return names;
+    }
+    /**
+     * Parse one chosen package.
+     *
+     * @param  token    Package number, identifier or path.
+     * @param  packages Configured packages.
+     * @return Package identifier.
+     * @throws {ValidationError} For an unknown package.
+     */
+    parsePackage(token, packages) {
+        const pkg = /^\d+$/.test(token)
+            ? packages[Number(token) - 1]
+            : findPackage(packages, token);
+        if (!pkg) {
+            throw new ValidationError(`Unknown package "${token}".`);
+        }
+        return pkg.name;
+    }
+    /**
+     * Parse a bump, patch by default.
+     *
+     * @param  answer Bump name.
+     * @return Bump.
+     * @throws {ValidationError} For an unknown bump.
+     */
+    parseBump(answer) {
+        const bump = answer.trim().toLowerCase() || 'patch';
+        if (!CHANGESET_BUMPS.includes(bump)) {
+            throw new ValidationError(`Invalid bump "${bump}"; expected patch, minor or major.`);
+        }
+        return bump;
+    }
+    /**
+     * Parse a release note.
+     *
+     * @param  answer Release note.
+     * @return Trimmed release note.
+     * @throws {ValidationError} For an empty release note.
+     */
+    parseSummary(answer) {
+        const summary = answer.trim();
+        if (!summary) {
+            throw new ValidationError('The release note must not be empty.');
+        }
+        return summary;
+    }
+    /**
+     * Ask a question until the answer parses, printing why it didn't.
+     *
+     * @param question Question text.
+     * @param parse    Parser that throws a ValidationError for invalid answers.
+     * @return Parsed answer.
+     */
+    async askUntilValid(question, parse) {
+        let parsed;
+        while (undefined === parsed) {
+            const answer = await this.readAnswer(question);
+            try {
+                parsed = { answer: parse(answer) };
+            }
+            catch (error) {
+                if (!(error instanceof ValidationError)) {
+                    throw error;
+                }
+                this.terminal.output.write(`${error.message}\n`);
+            }
+        }
+        return parsed.answer;
+    }
+    /**
+     * Write a question and read the next line of the input.
+     *
+     * @param  question Question text.
+     * @return Answer line.
+     * @throws {ValidationError} If the input ended.
+     */
+    async readAnswer(question) {
+        this.terminal.output.write(question);
+        const line = await this.getLines().next();
+        if (line.done) {
+            throw new ValidationError('The input ended before the changeset was complete.');
+        }
+        return line.value;
+    }
+    /**
+     * Get the lines of the input, reading it from the first question on. The
+     * interface stays in line mode, so the terminal echoes and edits the
+     * answers and Ctrl+C ends the process.
+     *
+     * @return Line iterator.
+     */
+    getLines() {
+        if (!this.lines) {
+            this.readline = createInterface({
+                input: this.terminal.input,
+                terminal: false,
+                crlfDelay: Infinity,
+            });
+            this.lines = this.readline[Symbol.asyncIterator]();
+        }
+        return this.lines;
+    }
+}

package/dist/changeset-release.d.ts

@@ -4,13 +4,15 @@ import { ReleaseRepository } from './release-repository.ts';
 export interface ChangesetRepository {
     cwd: string;
     configFile?: string;
+    /** Tag format that replaces the tagFormat of the config. */
+    tagFormat?: string;
 }
 export interface ChangesetReleaseOptions extends ChangesetRepository {
     /** Git runner, spawning git by default. */
     git?: GitRunner;
 }
 export interface ChangesetAddOptions {
-    /** Bump of each package. */
+    /** Bump of each package, by package identifier or path under the configured root. */
     packages: Record<string, ChangesetBump>;
     /** Changelog summary. */
     summary: string;
@@ -20,10 +22,22 @@ export interface ChangesetAddOptions {
 export interface ChangesetVersionOptions {
     dryRun?: boolean;
     date?: string;
-    /** Version only these packages, leaving the other changesets pending. */
+    /** Version only these packages, by identifier or path under the configured root, leaving the other changesets pending. */
     packages?: string[];
     /** Whether the selected sources release their configured dependents; defaults to true. */
     dependents?: boolean;
+    /**
+     * Release pre-releases of the next versions, with this identifier and an
+     * optional number, like rc or rc.1, numbered from the package tags without one.
+     */
+    prerelease?: string;
+    /**
+     * Release snapshots of the next versions, like 1.3.0-pr-251.20261012183000,
+     * with this identifier and the UTC time, for test builds that aren't committed.
+     */
+    snapshot?: string;
+    /** Time of a snapshot, now by default. */
+    snapshotTime?: Date;
 }
 export type ChangesetVersionInput = ChangesetRepository & ChangesetVersionOptions;
 /** Versioned releases, the applied changesets and whether files were changed. */
@@ -38,7 +52,7 @@ export interface ChangesetTagOptions {
     untagged?: boolean;
     push?: boolean;
     since?: string;
-    /** Tag only these packages. */
+    /** Tag only these packages, by identifier or path under the configured root. */
     packages?: string[];
     /** Expected version of the single package in `packages`. */
     version?: string;
@@ -59,10 +73,14 @@ export interface ChangesetTagResult {
     }>;
 }
 export interface ChangesetStatusOptions {
-    /** Base ref to diff against, origin/<baseBranch> by default. */
+    /** Base ref to diff against, <remote>/<baseBranch> by default. */
     since?: string;
+    /** Whether to include uncommitted and untracked files, like before adding a changeset. */
+    uncommitted?: boolean;
 }
 export interface ChangesetStatusResult {
+    /** Base ref that the changed files were compared with, if any. */
+    since?: string;
     changesets: Changeset[];
     releases: PackageRelease[];
     changedPackages: string[];
@@ -81,6 +99,7 @@ export interface ChangesetStatusResult {
 export declare class ChangesetRelease {
     readonly cwd: string;
     readonly configFile: string | undefined;
+    readonly tagFormat: string | undefined;
     readonly repository: ReleaseRepository;
     /**
      * @param options Repository root, config file and git runner.
@@ -118,7 +137,7 @@ export declare class ChangesetRelease {
      */
     version(options?: ChangesetVersionOptions): Promise<VersionChangesetsResult>;
     /**
-     * Create missing release tags, optionally pushing them to the origin
+     * Create missing release tags, optionally pushing them to the configured
      * remote. Each tag comes with the title and notes of its release, for a
      * workflow step to create the GitHub Release.
      *
@@ -135,6 +154,25 @@ export declare class ChangesetRelease {
      * @throws {ValidationError} Without a config.
      */
     getStatus(options?: ChangesetStatusOptions): Promise<ChangesetStatusResult>;
+    /**
+     * Turn the next versions of releases into pre-releases, like 1.3.0-rc.1
+     * for 1.3.0, numbered from the existing tags of each package. Dependents
+     * become pre-releases too, so they bundle the pre-releases of their sources.
+     *
+     * @param  context    Release context.
+     * @param  releases   Releases with their stable next versions.
+     * @param  prerelease Pre-release identifier with an optional number, like rc or rc.1.
+     * @return Releases with their pre-release next versions.
+     * @throws {ValidationError} For an invalid pre-release or an existing version.
+     */
+    private toPrereleases;
+    /**
+     * List the versions of the tags with a prefix.
+     *
+     * @param prefix Tag prefix of a package, like `plugins/alpha/`.
+     * @return Tagged versions.
+     */
+    private listTaggedVersions;
     /**
      * Write the versions, dependency specs and changelogs of the releases and
      * consume the applied changesets, restoring every changed file when a

package/dist/changeset-release.js

@@ -3,15 +3,15 @@ import { getVersionedReleases, prependChangelog } from "./changelog.js";
 import { loadChangesetConfig } from "./changeset-config.js";
 import { applyDependents, assertDependentsSourcesReleased, collectPinDriftWarnings, expandDependentsPlan, findBundledPinChanges, hasChangeset, selectReleasePlan, stripDependentsPlan, updateDependencyDeclaration, } from "./changeset-dependents.js";
 import { consumeChangeset, readChangesets, readChangesetsSince, writeChangeset, } from "./changeset-files.js";
-import { assertKnownPackages, discoverPackages, getChangedPackages, toChangesetPackage, } from "./changeset-packages.js";
+import { discoverPackages, getChangedPackages, resolvePackageNames, toChangesetPackage, } from "./changeset-packages.js";
 import { getChangesetBump, getNextVersion } from "./changesets.js";
 import { ValidationError } from "./errors.js";
 import { FileJournal } from "./file-journal.js";
 import { getPreviousTag, getReleaseNotes, getTagVersion, selectTagPackages, } from "./release-tags.js";
 import { ReleaseRepository } from "./release-repository.js";
-import { formatTag } from "./tag-format.js";
+import { DEFAULT_TAG_FORMAT, formatTag } from "./tag-format.js";
 import { verifyVersionTargets, writeVersion } from "./version-files.js";
-import { isPrerelease } from "./versions.js";
+import { getPrereleaseVersion, getSnapshotVersion, isPrerelease, } from "./versions.js";
 const MISSING_CONFIG = 'No wp-release config found. Add wp-release.config.js or pass --config <path>.';
 /**
  * Changeset releases of a repository: recording changesets, versioning the
@@ -24,6 +24,7 @@ const MISSING_CONFIG = 'No wp-release config found. Add wp-release.config.js or
 export class ChangesetRelease {
     cwd;
     configFile;
+    tagFormat;
     repository;
     /**
      * @param options Repository root, config file and git runner.
@@ -31,6 +32,7 @@ export class ChangesetRelease {
     constructor(options) {
         this.cwd = options.cwd;
         this.configFile = options.configFile;
+        this.tagFormat = options.tagFormat;
         this.repository = new ReleaseRepository({
             cwd: options.cwd,
             runner: options.git,
@@ -67,8 +69,17 @@ export class ChangesetRelease {
     async add(options) {
         const config = await this.requireConfig();
         const packages = await discoverPackages(this.repository, config);
-        assertKnownPackages(packages, Object.keys(options.packages));
-        return writeChangeset(this.getChangesetDirectory(config), options.packages, options.summary, options.name);
+        const entries = Object.entries(options.packages);
+        const names = resolvePackageNames(packages, entries.map(([name]) => name));
+        const resolved = {};
+        entries.forEach(([, bump], index) => {
+            const name = names[index] ?? '';
+            if (Object.hasOwn(resolved, name)) {
+                throw new ValidationError(`Package "${name}" was passed more than once.`);
+            }
+            resolved[name] = bump;
+        });
+        return writeChangeset(this.getChangesetDirectory(config), resolved, options.summary, options.name);
     }
     /**
      * Apply pending package versions and changelogs. A failed run restores
@@ -82,9 +93,12 @@ export class ChangesetRelease {
         const context = await this.requireContext();
         const { config, packages } = context;
         const withDependents = options.dependents ?? true;
+        const selected = options.packages
+            ? resolvePackageNames(packages, options.packages)
+            : undefined;
         let releasePlan = context.plan;
-        if (options.packages) {
-            releasePlan = expandDependentsPlan(await selectReleasePlan(context.plan, packages, options.packages, config, withDependents));
+        if (selected) {
+            releasePlan = expandDependentsPlan(await selectReleasePlan(context.plan, packages, selected, config, withDependents));
         }
         else if (!withDependents) {
             releasePlan = stripDependentsPlan(context.plan);
@@ -96,10 +110,31 @@ export class ChangesetRelease {
         if (withDependents && config.dependents) {
             await assertDependentsSourcesReleased(releasePlan, context.plan, packages, config);
         }
+        if (undefined !== options.prerelease &&
+            undefined !== options.snapshot) {
+            throw new ValidationError('A release cannot be both a pre-release and a snapshot.');
+        }
+        if (undefined !== options.snapshot) {
+            const id = options.snapshot;
+            const time = options.snapshotTime ?? new Date();
+            releasePlan = {
+                ...releasePlan,
+                releases: releasePlan.releases.map((release) => ({
+                    ...release,
+                    nextVersion: getSnapshotVersion(release.nextVersion, id, time),
+                })),
+            };
+        }
+        if (undefined !== options.prerelease) {
+            releasePlan = {
+                ...releasePlan,
+                releases: await this.toPrereleases(context, releasePlan.releases, options.prerelease),
+            };
+        }
         const date = options.date ?? new Date().toISOString().slice(0, 10);
         const releases = await getVersionedReleases(this.repository, config, releasePlan.releases, this.getChangesetDirectory(config));
         if (!options.dryRun) {
-            await this.writeReleases(context, releasePlan, releases, date, options.packages);
+            await this.writeReleases(context, releasePlan, releases, date, selected);
         }
         return {
             changesets: releasePlan.changesets,
@@ -111,7 +146,7 @@ export class ChangesetRelease {
         };
     }
     /**
-     * Create missing release tags, optionally pushing them to the origin
+     * Create missing release tags, optionally pushing them to the configured
      * remote. Each tag comes with the title and notes of its release, for a
      * workflow step to create the GitHub Release.
      *
@@ -124,13 +159,13 @@ export class ChangesetRelease {
             throw new ValidationError('Listing untagged releases cannot be combined with pushing tags.');
         }
         const context = await this.requireContext();
-        const selected = selectTagPackages(context.packages, options.packages ?? [], options.version);
+        const selected = selectTagPackages(context.packages, resolvePackageNames(context.packages, options.packages ?? []), options.version);
         const packages = options.since
             ? (await getChangedPackages(this.repository, selected, options.since)).packages
             : selected;
         const results = [];
         const dryRun = options.dryRun || options.untagged;
-        const tagFormat = context.config.tagFormat ?? '{path}/{version}';
+        const tagFormat = context.config.tagFormat ?? DEFAULT_TAG_FORMAT;
         for (const pkg of packages) {
             const version = await getTagVersion(pkg, options.version);
             if (undefined !== options.version &&
@@ -163,7 +198,7 @@ export class ChangesetRelease {
         // tags when more than three are pushed at once.
         if (options.push && !dryRun) {
             for (const item of results.filter((result) => result.created)) {
-                await this.repository.pushTag(item.tag);
+                await this.repository.pushTag(item.tag, context.config.remote ?? 'origin');
             }
         }
         return {
@@ -183,16 +218,27 @@ export class ChangesetRelease {
         const { config, packages, plan } = await this.requireContext();
         const { changesets, releases } = plan;
         const since = options.since ??
-            (config.baseBranch ? `origin/${config.baseBranch}` : undefined);
+            (config.baseBranch
+                ? `${config.remote ?? 'origin'}/${config.baseBranch}`
+                : undefined);
         const changed = since
-            ? await getChangedPackages(this.repository, packages, since)
+            ? await getChangedPackages(this.repository, packages, since, options.uncommitted)
             : { packages: [], filesByPackage: {} };
         const changedPackages = changed.packages.map((pkg) => pkg.name);
         const changesetsInDiff = since
-            ? await readChangesetsSince(this.repository, this.getChangesetDirectory(config), changesets, since)
+            ? await readChangesetsSince(this.repository, this.getChangesetDirectory(config), changesets, since, options.uncommitted)
             : [];
         const hasEmptyChangeset = changesetsInDiff.some((changeset) => 0 === Object.keys(changeset.packages).length);
-        const bundled = await findBundledPinChanges(changed, changesetsInDiff, packages, config);
+        const bundled = since
+            ? await findBundledPinChanges({
+                changed,
+                changesetsInDiff,
+                packages,
+                config,
+                repository: this.repository,
+                since,
+            })
+            : new Set();
         const missingChangesets = hasEmptyChangeset
             ? []
             : changedPackages.filter((name) => !hasChangeset(changesetsInDiff, name) &&
@@ -203,6 +249,7 @@ export class ChangesetRelease {
             ? await collectPinDriftWarnings(config, packages)
             : [];
         return {
+            ...(since ? { since } : {}),
             changesets,
             releases,
             changedPackages,
@@ -211,6 +258,40 @@ export class ChangesetRelease {
             warnings,
         };
     }
+    /**
+     * Turn the next versions of releases into pre-releases, like 1.3.0-rc.1
+     * for 1.3.0, numbered from the existing tags of each package. Dependents
+     * become pre-releases too, so they bundle the pre-releases of their sources.
+     *
+     * @param  context    Release context.
+     * @param  releases   Releases with their stable next versions.
+     * @param  prerelease Pre-release identifier with an optional number, like rc or rc.1.
+     * @return Releases with their pre-release next versions.
+     * @throws {ValidationError} For an invalid pre-release or an existing version.
+     */
+    async toPrereleases(context, releases, prerelease) {
+        const tagFormat = context.config.tagFormat ?? DEFAULT_TAG_FORMAT;
+        return Promise.all(releases.map(async (release) => {
+            const configured = context.packages.find((pkg) => pkg.name === release.package.name);
+            const versions = configured
+                ? await this.listTaggedVersions(formatTag(tagFormat, configured, ''))
+                : [];
+            return {
+                ...release,
+                nextVersion: getPrereleaseVersion(release.nextVersion, prerelease, versions),
+            };
+        }));
+    }
+    /**
+     * List the versions of the tags with a prefix.
+     *
+     * @param prefix Tag prefix of a package, like `plugins/alpha/`.
+     * @return Tagged versions.
+     */
+    async listTaggedVersions(prefix) {
+        const tags = await this.repository.listTags(prefix);
+        return tags.map((tag) => tag.slice(prefix.length));
+    }
     /**
      * Write the versions, dependency specs and changelogs of the releases and
      * consume the applied changesets, restoring every changed file when a
@@ -287,6 +368,7 @@ export class ChangesetRelease {
         const loaded = await loadChangesetConfig({
             cwd: this.cwd,
             ...(this.configFile ? { configFile: this.configFile } : {}),
+            ...(this.tagFormat ? { tagFormat: this.tagFormat } : {}),
         });
         if (!loaded) {
             return undefined;
@@ -352,6 +434,7 @@ export class ChangesetRelease {
         const loaded = await loadChangesetConfig({
             cwd: this.cwd,
             ...(this.configFile ? { configFile: this.configFile } : {}),
+            ...(this.tagFormat ? { tagFormat: this.tagFormat } : {}),
         });
         if (!loaded) {
             throw new ValidationError(MISSING_CONFIG);

package/dist/changesets.d.ts

@@ -83,11 +83,15 @@ export declare function formatChangelogList(entries: string[]): string;
  */
 export declare function getChangesetBump(changesets: Changeset[], packageName: string): ChangesetBump | undefined;
 /**
- * Calculate the next stable semantic version using literal SemVer bump rules.
+ * Calculate the next stable version using literal SemVer bump rules. Besides
+ * x.y.z, it accepts the x.y and x.y.z.w versions common in WordPress plugins:
+ * the bumped part is raised, the parts after it reset to 0, and the version
+ * keeps its number of parts, so a minor bump of 2.1 is 2.2 and of 1.2.3.4 is
+ * 1.3.0.0. A patch bump of x.y adds the third part, so 2.1 becomes 2.1.1.
  *
  * @param  currentVersion Current package version.
  * @param  bump           Requested bump.
  * @return Next version.
- * @throws {ValidationError} If currentVersion is not a stable x.y.z version.
+ * @throws {ValidationError} If currentVersion is not a stable x.y, x.y.z or x.y.z.w version.
  */
 export declare function getNextVersion(currentVersion: string, bump: ChangesetBump): string;

package/dist/changesets.js

@@ -99,26 +99,32 @@ export function getChangesetBump(changesets, packageName) {
     return bumps.sort((a, b) => BUMP_RANK[b] - BUMP_RANK[a])[0];
 }
 /**
- * Calculate the next stable semantic version using literal SemVer bump rules.
+ * Calculate the next stable version using literal SemVer bump rules. Besides
+ * x.y.z, it accepts the x.y and x.y.z.w versions common in WordPress plugins:
+ * the bumped part is raised, the parts after it reset to 0, and the version
+ * keeps its number of parts, so a minor bump of 2.1 is 2.2 and of 1.2.3.4 is
+ * 1.3.0.0. A patch bump of x.y adds the third part, so 2.1 becomes 2.1.1.
  *
  * @param  currentVersion Current package version.
  * @param  bump           Requested bump.
  * @return Next version.
- * @throws {ValidationError} If currentVersion is not a stable x.y.z version.
+ * @throws {ValidationError} If currentVersion is not a stable x.y, x.y.z or x.y.z.w 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 (!/^(0|[1-9]\d*)(\.(0|[1-9]\d*)){1,3}$/.test(currentVersion)) {
+        throw new ValidationError(`Cannot bump "${currentVersion}": expected a stable version in x.y, x.y.z or x.y.z.w 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}`;
+    const parts = currentVersion.split('.').map(Number);
+    const index = { major: 0, minor: 1, patch: 2 }[bump];
+    const length = Math.max(parts.length, index + 1);
+    return Array.from({ length }, (_, position) => {
+        const part = parts[position] ?? 0;
+        if (position === index) {
+            return part + 1;
+        }
+        return position < index ? part : 0;
+    }).join('.');
 }

package/dist/cli.d.ts

@@ -6,7 +6,13 @@ 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';
+/** Input stream that interactive prompts read from in a terminal. */
+export type InputStream = NodeJS.ReadableStream & {
+    isTTY?: boolean;
+};
 export interface CliIo {
+    /** Input for interactive prompts, used when it and stdout are a terminal. */
+    stdin?: InputStream;
     /** Stream for regular output. */
     stdout?: OutputStream;
     /** Stream for errors. */
@@ -74,7 +80,7 @@ export declare function execute<Name extends keyof CommandResults>(name: Name, a
  * Run the CLI.
  *
  * @param args CLI arguments without the node and script paths.
- * @param io   Output streams and working directory.
+ * @param io   Input and output streams and working directory.
  * @return Exit code.
  */
 export declare function run(args: string[], io?: CliIo): Promise<number>;