@wpelevator/wp-release 0.5.0 → 0.6.0

package/README.md

@@ -32,6 +32,10 @@ npx wp-release --help
 | `wp-release verify [<source-dir>] --checksums <file> [options]` | Check a plugin or theme directory, or a ZIP, against a checksums manifest. |
 | `wp-release version-check [<source-dir>] [options]` | Check that the `Version` header, readme `Stable tag`, PHP constants and git tag agree. |
 | `wp-release deploy-svn [<source-dir>] [options]` | Deploy a plugin to the WordPress.org plugin SVN repository. |
+| `wp-release changeset-add [options]` | Record the release impact of a pull request. |
+| `wp-release changeset-status [options]` | List pending releases and check changed packages for changesets. |
+| `wp-release changeset-version [options]` | Apply version bumps and changelog entries. |
+| `wp-release changeset-tag [options]` | Create missing package release tags. |
 
 Run `npx wp-release <command> --help` for the options of each command. Every command reads the plugin or theme directory from the first argument or `--source-dir`, defaulting to the current directory, and prints its result as JSON with `--json`.
 
@@ -64,6 +68,69 @@ Each command also adds a section to the [job summary](https://docs.github.com/en
 
 A failed command adds its error to the summary, or a table of its problems with their files and lines, listing up to 100 and counting the rest. The Markdown of the summaries isn't part of the library API. File paths are relative to `GITHUB_WORKSPACE`, or the current directory without it. Files outside it, like those of an extracted ZIP, get an annotation without a file. Multi-line messages stay one annotation.
 
+Use global `--config <path>` to select a config; relative paths resolve from the current directory. Otherwise, Changesets commands discover `wp-release.config.js`, `.mjs` or `.cjs` there.
+
+### Changesets support (experimental)
+
+Changesets support is experimental. It reads Changesets-style Markdown and loads JavaScript configs with descriptors for npm and Composer manifests, plugin and theme headers, readme Stable tags, PHP constants, and Git tags. Use ESM (`export default`) or CommonJS (`module.exports`); TypeScript configs are not supported. Frontmatter accepts `package-name: patch|minor|major` entries; advanced YAML and prerelease mode are unsupported.
+
+Typical release flow, from a feature pull request to the publish workflows triggered by release tags:
+
+```mermaid
+flowchart TD
+	A["Contributor changes a plugin or package"] --> B{"Does this change need a release?"}
+	B -->|Yes| C["Add a changeset with package, bump, and release note"]
+	B -->|No| D["Add an empty changeset"]
+	C --> E["Open or update the feature pull request"]
+	D --> E
+	E --> F["changeset-status checks changed packages and PR changesets"]
+	F -->|Missing a changeset| G["Add the missing changeset"]
+	G --> E
+	F -->|Pass| H["Merge the feature pull request to main"]
+	H --> I["changeset-version updates configured version files and changelogs"]
+	I --> J{"Are there package releases to review?"}
+	J -->|Yes| K["Workflow opens or updates the Version Packages pull request"]
+	K --> L["Review and merge the Version Packages pull request"]
+	L --> M["changeset-tag creates tags for packages changed by that release"]
+	M --> N["GitHub Releases are created from changelog entries"]
+	N --> O["Tag-triggered publish and split workflows run"]
+	J -->|No| P["No package versions or release tags are created"]
+```
+
+An empty changeset marks a feature PR as no-release. The version workflow consumes it without changing versions, and a release PR containing only its deletion produces no tags.
+
+```js
+import { composerJsonVersion, defineConfig, gitTagVersion, packageJsonVersion, wordpressPluginVersion, wordpressStableTag } from '@wpelevator/wp-release';
+
+export default defineConfig( {
+	baseBranch: 'main',
+	changesets: '.changeset',
+	readmeChangelog: true,
+	changelogInsertAfter: '<!-- changelog -->',
+	root: 'packages',
+	tagFormat: '{path}/{version}',
+	packages: [
+		{ glob: 'js/*', idFrom: 'package.json#name', version: { from: packageJsonVersion(), to: [ packageJsonVersion() ] } },
+		{ glob: 'plugins/*', idFrom: 'package.json#name', version: { from: wordpressPluginVersion(), to: [ wordpressPluginVersion(), wordpressStableTag( { ifPresent: true } ), composerJsonVersion( { ifPresent: true } ) ] } },
+		{ glob: 'php/*', idFrom: 'composer.json#name', version: { from: gitTagVersion( { pattern: '{path}/{version}' } ), to: [] } },
+	],
+} );
+```
+
+`version.from` selects the current version; `version.to` lists release targets. Package globs support `*`, `?` and `**`; `{path}` in tag templates is relative to `root`. Templates also accept `{type}`, `{name}` and `{slug}`, while `tagType` customizes the type label. Use `phpConstantVersion( { file, constant } )` to sync a PHP constant.
+
+The default strategy requires stable `x.y.z` versions. Configure `nextVersion( { package, bump, currentVersion, changesets } )` for other formats; changeset bumps remain `patch`, `minor` or `major`, and prerelease syntax is unsupported.
+
+Without `--since`, `changeset-status` compares against `origin/<baseBranch>`; fetch that ref or pass `--since` when using a fork or different upstream. `loadChangesetConfig()` discovers a conventional config at the repository root, unless `--config <path>` selects one explicitly.
+
+Add release notes in a feature PR with `npx wp-release changeset-add --package @vendor/plugin --bump patch --summary "Fix the checkout validation."`. Repeat package and bump flags for multiple packages, or use `--empty` when no release is needed. In CI, `changeset-status --since origin/main` requires a changeset added by the PR; changesets already on the base do not count, while an empty PR changeset records an explicit no-release decision. Missing-change annotations identify an affected file.
+
+On the release branch, preview with `changeset-version --dry-run`, then run `changeset-version` to update version targets and changelogs. By default, new Markdown entries go before the first version heading; `changelogInsertAfter` sets a literal insertion marker for `CHANGELOG.md` and, with `readmeChangelog`, the plugin readme. Put the marker in both files; a missing marker is an error. Without a marker, plugin readmes use the `== Changelog ==` heading. Failed updates are rolled back for safe retries.
+
+After merging the release PR, `changeset-tag --since <merge-commit>^1 --push` pushes tags only for packages changed by that release. Add `--github-release` to create missing GitHub Releases; it requires `--push`. For initial adoption, preview all missing tags with `changeset-tag --dry-run` (without `--since`), then push if needed. Tag pushes need Git write credentials; GitHub Releases need authenticated `gh`.
+
+For local development, run the TypeScript source with `npm run wp-release -- <command>` (for example, `npm run wp-release -- changeset-status --since origin/main`). GitHub workflows use the same CLI for versioning and tagging. `SUBTREE_DEPLOY_TOKEN` lets them update the Version Packages PR, push tags, and create GitHub Releases.
+
 ### Naming convention
 
 `@wpelevator/wp-release` is the suite of release tools and `wp-release` is its CLI. "Release" is the whole workflow; each command is one operation in it. Commands are flat: a single word or dashed words like `version-check` and `deploy-svn`, without command groups or aliases. Each GitHub Action is named `wp-release-` followed by the command name, so the CLI command and the `uses:` name always match:

package/dist/changeset-config.d.ts

@@ -0,0 +1,189 @@
+import type { Changeset, ChangesetBump, ChangesetPackage } from './changesets.ts';
+export type PackageVersionSource = {
+    kind: 'package-json';
+    file: string;
+    field: 'version';
+} | {
+    kind: 'composer-json';
+    file: string;
+    field: 'version';
+} | {
+    kind: 'wordpress-plugin-header';
+    file?: string;
+} | {
+    kind: 'wordpress-theme-header';
+    file?: string;
+} | {
+    kind: 'wordpress-stable-tag';
+    file?: string;
+    ifPresent?: boolean;
+} | {
+    kind: 'php-constant';
+    file: string;
+    constant: string;
+} | {
+    kind: 'git-tag';
+    pattern?: string;
+};
+export type PackageVersionTarget = {
+    kind: 'package-json';
+    file: string;
+    field: 'version';
+} | {
+    kind: 'composer-json';
+    file: string;
+    field: 'version';
+    ifPresent: boolean;
+} | {
+    kind: 'wordpress-plugin-header';
+    file?: string;
+} | {
+    kind: 'wordpress-theme-header';
+    file?: string;
+} | {
+    kind: 'wordpress-stable-tag';
+    file?: string;
+    ifPresent?: boolean;
+} | {
+    kind: 'php-constant';
+    file: string;
+    constant: string;
+};
+export interface PackageVersionConfig {
+    /** File or tag that provides the package's current version. */
+    from: PackageVersionSource;
+    /** All version locations that should receive the next version. */
+    to: PackageVersionTarget[];
+}
+export type PackageIdSource = 'package.json#name' | 'composer.json#name' | 'path';
+/** One directory pattern that describes packages sharing release behavior. */
+export interface ChangesetPackageGroup {
+    /** Package directories to discover, relative to the configured package root. */
+    glob: string;
+    /** Package paths excluded from this group, relative to root. */
+    exclude?: string[];
+    /** Optional type used by the {type} tag template. */
+    tagType?: string;
+    /** Manifest field used as the changeset name; defaults to `path`. */
+    idFrom?: PackageIdSource;
+    /** Version source and files to update for every discovered package. */
+    version: PackageVersionConfig;
+}
+/** JavaScript configuration for changeset-aware releases. */
+export interface ChangesetConfig {
+    /** Branch receiving ordinary changes. */
+    baseBranch?: string;
+    /** Directory containing Markdown changesets, relative to the repository root. */
+    changesets?: string;
+    /** Package groups to discover and release. */
+    packages: ChangesetPackageGroup[];
+    /** Git tag template supporting {name}, {slug}, {path}, {type} and {version}. */
+    tagFormat?: string;
+    /** Directory against which package paths in tag formats are calculated. */
+    root?: string;
+    /** Whether plugin readme changelogs are updated with CHANGELOG.md. */
+    readmeChangelog?: boolean;
+    /** Insert generated changelog entries after this literal marker. */
+    changelogInsertAfter?: string;
+    /** Calculate a package's next version instead of using stable SemVer bumps. */
+    nextVersion?: (input: NextVersionInput) => string;
+}
+/** Inputs supplied to a custom next-version strategy. */
+export interface NextVersionInput {
+    package: ChangesetPackage;
+    bump: ChangesetBump;
+    currentVersion: string;
+    changesets: Changeset[];
+}
+export type WpReleaseConfig = ChangesetConfig;
+export interface PackageJsonVersionOptions {
+    file?: string;
+}
+export interface ComposerJsonVersionOptions {
+    file?: string;
+    /** Skip this target when the `version` property is absent instead of adding it. */
+    ifPresent?: boolean;
+}
+export interface WordPressVersionFileOptions {
+    file?: string;
+    /** Skip a missing target file instead of failing. */
+    ifPresent?: boolean;
+}
+export interface GitTagVersionOptions {
+    pattern?: string;
+}
+export interface PhpConstantVersionOptions {
+    file: string;
+    constant: string;
+}
+/**
+ * Return a package.json version descriptor for use as a source or target.
+ *
+ * @param options Version manifest path.
+ * @return Package version descriptor.
+ */
+export declare function packageJsonVersion(options?: PackageJsonVersionOptions): PackageVersionSource & PackageVersionTarget;
+/**
+ * Return a Composer version descriptor for use as a source or target.
+ *
+ * @param options Composer manifest path and missing-field behavior.
+ * @return Package version descriptor.
+ */
+export declare function composerJsonVersion(options?: ComposerJsonVersionOptions): PackageVersionSource & PackageVersionTarget;
+/**
+ * Return a WordPress plugin header version descriptor.
+ *
+ * @param options Optional plugin main file path.
+ * @return Package version descriptor.
+ */
+export declare function wordpressPluginVersion(options?: WordPressVersionFileOptions): PackageVersionSource & PackageVersionTarget;
+/**
+ * Return a WordPress theme style.css version descriptor.
+ *
+ * @param options Optional theme stylesheet path.
+ * @return Package version descriptor.
+ */
+export declare function wordpressThemeVersion(options?: WordPressVersionFileOptions): PackageVersionSource & PackageVersionTarget;
+/**
+ * Return a WordPress readme Stable tag version descriptor.
+ *
+ * @param options Optional readme path.
+ * @return Package version descriptor.
+ */
+export declare function wordpressStableTag(options?: WordPressVersionFileOptions): PackageVersionSource & PackageVersionTarget;
+/**
+ * Return a git tag version descriptor for packages without a version file.
+ *
+ * @param options Optional tag pattern.
+ * @return Package version descriptor.
+ */
+export declare function gitTagVersion(options?: GitTagVersionOptions): PackageVersionSource;
+/**
+ * Return a PHP constant descriptor for use as a version source or target.
+ *
+ * @param options PHP file and constant name.
+ * @return Package version descriptor.
+ */
+export declare function phpConstantVersion(options: PhpConstantVersionOptions): PackageVersionSource & PackageVersionTarget;
+/**
+ * Add type checking to a JavaScript wp-release configuration.
+ *
+ * @param config Repository release configuration.
+ * @return The same configuration object.
+ */
+export declare function defineConfig(config: ChangesetConfig): ChangesetConfig;
+export interface LoadChangesetConfigInput {
+    cwd?: string;
+    configFile?: string;
+}
+/**
+ * Load and validate the repository's JavaScript wp-release configuration.
+ *
+ * @param  input Working directory and optional explicit config path.
+ * @return Loaded configuration and its absolute file path, or undefined when absent.
+ * @throws {ValidationError} If the module cannot be loaded or its shape is invalid.
+ */
+export declare function loadChangesetConfig(input?: LoadChangesetConfigInput): Promise<{
+    config: ChangesetConfig;
+    file: string;
+} | undefined>;

package/dist/changeset-config.js

@@ -0,0 +1,273 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { access } from 'node:fs/promises';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { ValidationError } from "./errors.js";
+/**
+ * Return a package.json version descriptor for use as a source or target.
+ *
+ * @param options Version manifest path.
+ * @return Package version descriptor.
+ */
+export function packageJsonVersion(options = {}) {
+    return {
+        kind: 'package-json',
+        file: options.file ?? 'package.json',
+        field: 'version',
+    };
+}
+/**
+ * Return a Composer version descriptor for use as a source or target.
+ *
+ * @param options Composer manifest path and missing-field behavior.
+ * @return Package version descriptor.
+ */
+export function composerJsonVersion(options = {}) {
+    return {
+        kind: 'composer-json',
+        file: options.file ?? 'composer.json',
+        field: 'version',
+        ifPresent: options.ifPresent ?? true,
+    };
+}
+/**
+ * Return a WordPress plugin header version descriptor.
+ *
+ * @param options Optional plugin main file path.
+ * @return Package version descriptor.
+ */
+export function wordpressPluginVersion(options = {}) {
+    return {
+        kind: 'wordpress-plugin-header',
+        ...(options.file ? { file: options.file } : {}),
+    };
+}
+/**
+ * Return a WordPress theme style.css version descriptor.
+ *
+ * @param options Optional theme stylesheet path.
+ * @return Package version descriptor.
+ */
+export function wordpressThemeVersion(options = {}) {
+    return {
+        kind: 'wordpress-theme-header',
+        ...(options.file ? { file: options.file } : {}),
+    };
+}
+/**
+ * Return a WordPress readme Stable tag version descriptor.
+ *
+ * @param options Optional readme path.
+ * @return Package version descriptor.
+ */
+export function wordpressStableTag(options = {}) {
+    return {
+        kind: 'wordpress-stable-tag',
+        ...(options.file ? { file: options.file } : {}),
+        ...(undefined !== options.ifPresent
+            ? { ifPresent: options.ifPresent }
+            : {}),
+    };
+}
+/**
+ * Return a git tag version descriptor for packages without a version file.
+ *
+ * @param options Optional tag pattern.
+ * @return Package version descriptor.
+ */
+export function gitTagVersion(options = {}) {
+    return {
+        kind: 'git-tag',
+        ...(options.pattern ? { pattern: options.pattern } : {}),
+    };
+}
+/**
+ * Return a PHP constant descriptor for use as a version source or target.
+ *
+ * @param options PHP file and constant name.
+ * @return Package version descriptor.
+ */
+export function phpConstantVersion(options) {
+    return { kind: 'php-constant', ...options };
+}
+/**
+ * Add type checking to a JavaScript wp-release configuration.
+ *
+ * @param config Repository release configuration.
+ * @return The same configuration object.
+ */
+export function defineConfig(config) {
+    return config;
+}
+const CONFIG_FILES = [
+    'wp-release.config.js',
+    'wp-release.config.mjs',
+    'wp-release.config.cjs',
+];
+/**
+ * Load and validate the repository's JavaScript wp-release configuration.
+ *
+ * @param  input Working directory and optional explicit config path.
+ * @return Loaded configuration and its absolute file path, or undefined when absent.
+ * @throws {ValidationError} If the module cannot be loaded or its shape is invalid.
+ */
+export async function loadChangesetConfig(input = {}) {
+    const cwd = path.resolve(input.cwd ?? process.cwd());
+    const configFile = input.configFile
+        ? path.resolve(cwd, input.configFile)
+        : await findConfigFile(cwd);
+    if (!configFile) {
+        return undefined;
+    }
+    let loaded;
+    try {
+        loaded = await import(__rewriteRelativeImportExtension(pathToFileURL(configFile).href));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new ValidationError(`Could not load wp-release config ${configFile}: ${message}`);
+    }
+    const config = 'object' === typeof loaded && null !== loaded && 'default' in loaded
+        ? loaded.default
+        : undefined;
+    validateChangesetConfig(config, configFile);
+    return { config, file: configFile };
+}
+async function findConfigFile(cwd) {
+    for (const fileName of CONFIG_FILES) {
+        const candidate = path.join(cwd, fileName);
+        try {
+            await access(candidate);
+            return candidate;
+        }
+        catch {
+            // Try the next conventional filename.
+        }
+    }
+    return undefined;
+}
+/**
+ * Validate the supported config shape before commands consume it.
+ *
+ * @param config     Untrusted default export value.
+ * @param configFile Config file path for error messages.
+ */
+function validateChangesetConfig(config, configFile) {
+    if ('object' !== typeof config ||
+        null === config ||
+        Array.isArray(config)) {
+        throw new ValidationError(`wp-release config ${configFile} must default-export a configuration object.`);
+    }
+    const candidate = config;
+    if (!Array.isArray(candidate.packages)) {
+        throw new ValidationError(`wp-release config ${configFile} must define a packages array.`);
+    }
+    for (const [key, value] of Object.entries({
+        baseBranch: candidate.baseBranch,
+        changesets: candidate.changesets,
+        changelogInsertAfter: candidate.changelogInsertAfter,
+        root: candidate.root,
+    })) {
+        if (undefined !== value && 'string' !== typeof value) {
+            throw new ValidationError(`wp-release config ${configFile}.${key} must be a string.`);
+        }
+    }
+    if ('' === candidate.changelogInsertAfter) {
+        throw new ValidationError(`wp-release config ${configFile}.changelogInsertAfter must not be empty.`);
+    }
+    if (undefined !== candidate.tagFormat &&
+        'string' !== typeof candidate.tagFormat) {
+        throw new ValidationError(`wp-release config ${configFile}.tagFormat must be a string.`);
+    }
+    if (undefined !== candidate.readmeChangelog &&
+        'boolean' !== typeof candidate.readmeChangelog) {
+        throw new ValidationError(`wp-release config ${configFile}.readmeChangelog must be a boolean.`);
+    }
+    if (undefined !== candidate.nextVersion &&
+        'function' !== typeof candidate.nextVersion) {
+        throw new ValidationError(`wp-release config ${configFile}.nextVersion must be a function.`);
+    }
+    candidate.packages.forEach((group, index) => {
+        if ('object' !== typeof group ||
+            null === group ||
+            'object' !== typeof group.version ||
+            null === group.version ||
+            'object' !== typeof group.version.from ||
+            !Array.isArray(group.version.to)) {
+            throw new ValidationError(`wp-release config ${configFile} has an invalid packages[${index}] entry.`);
+        }
+        if (undefined !== group.idFrom &&
+            !['path', 'package.json#name', 'composer.json#name'].includes(group.idFrom)) {
+            throw new ValidationError(`wp-release config ${configFile} packages[${index}].idFrom is not supported.`);
+        }
+        if ('string' !== typeof group.glob || !group.glob.trim()) {
+            throw new ValidationError(`wp-release config ${configFile} packages[${index}].glob must be a non-empty string.`);
+        }
+        if ('string' !== typeof group.tagType &&
+            undefined !== group.tagType) {
+            throw new ValidationError(`wp-release config ${configFile} packages[${index}].tagType must be a string.`);
+        }
+        if (undefined !== group.exclude &&
+            (!Array.isArray(group.exclude) ||
+                group.exclude.some((item) => 'string' !== typeof item))) {
+            throw new ValidationError(`wp-release config ${configFile} packages[${index}].exclude must be an array of strings.`);
+        }
+        validateVersionDescriptor(group.version.from, `${configFile}.packages[${index}].version.from`, false);
+        group.version.to.forEach((target, targetIndex) => validateVersionDescriptor(target, `${configFile}.packages[${index}].version.to[${targetIndex}]`, true));
+    });
+}
+function validateVersionDescriptor(descriptor, location, isTarget) {
+    if ('object' !== typeof descriptor || null === descriptor) {
+        throw new ValidationError(`wp-release config ${location} must be an object.`);
+    }
+    const candidate = descriptor;
+    const sourceKinds = [
+        'package-json',
+        'composer-json',
+        'wordpress-plugin-header',
+        'wordpress-theme-header',
+        'wordpress-stable-tag',
+        'php-constant',
+        'git-tag',
+    ];
+    const targetKinds = sourceKinds.filter((kind) => 'git-tag' !== kind);
+    const kinds = isTarget ? targetKinds : sourceKinds;
+    if ('string' !== typeof candidate.kind ||
+        !kinds.includes(candidate.kind)) {
+        throw new ValidationError(`wp-release config ${location}.kind is not supported.`);
+    }
+    const needsFile = [
+        'package-json',
+        'composer-json',
+        'php-constant',
+    ].includes(candidate.kind);
+    if (needsFile &&
+        ('string' !== typeof candidate.file || !candidate.file.trim())) {
+        throw new ValidationError(`wp-release config ${location}.file must be a non-empty string.`);
+    }
+    if (['package-json', 'composer-json'].includes(candidate.kind) &&
+        'version' !== candidate.field) {
+        throw new ValidationError(`wp-release config ${location}.field must be "version".`);
+    }
+    if ('php-constant' === candidate.kind &&
+        ('string' !== typeof candidate.constant ||
+            !candidate.constant.trim())) {
+        throw new ValidationError(`wp-release config ${location}.constant must be a non-empty string.`);
+    }
+    if ('git-tag' === candidate.kind &&
+        undefined !== candidate.pattern &&
+        'string' !== typeof candidate.pattern) {
+        throw new ValidationError(`wp-release config ${location}.pattern must be a string.`);
+    }
+    if (undefined !== candidate.ifPresent &&
+        'boolean' !== typeof candidate.ifPresent) {
+        throw new ValidationError(`wp-release config ${location}.ifPresent must be a boolean.`);
+    }
+}

package/dist/changeset-release.d.ts

@@ -0,0 +1,74 @@
+import type { Changeset, ChangesetReleasePlan, PackageRelease } from './changesets.ts';
+export interface ChangesetRepository {
+    cwd: string;
+    configFile?: string;
+}
+export interface ChangesetVersionInput extends ChangesetRepository {
+    dryRun?: boolean;
+    date?: string;
+}
+export interface ChangesetTagInput extends ChangesetRepository {
+    dryRun?: boolean;
+    push?: boolean;
+    githubRelease?: boolean;
+    since?: string;
+}
+export interface ChangesetTagResult {
+    tags: Array<{
+        package: string;
+        version: string;
+        tag: string;
+        created: boolean;
+        notes: string;
+    }>;
+}
+/**
+ * Discover configured packages, pending changesets, and their proposed versions.
+ *
+ * @param input Repository root and optional explicit config file.
+ * @return A release plan; `undefined` when no config is present.
+ */
+export declare function getChangesetReleasePlan(input: ChangesetRepository): Promise<ChangesetReleasePlan | undefined>;
+/**
+ * Create a Changesets-compatible Markdown file.
+ *
+ * @param input Repository, packages and summary.
+ * @return Created file path.
+ */
+export declare function addChangeset(input: ChangesetRepository & {
+    packages: Record<string, 'patch' | 'minor' | 'major'>;
+    summary: string;
+    name?: string;
+}): Promise<string>;
+/**
+ * Apply pending package versions and changelogs.
+ *
+ * @param input Repository and versioning options.
+ * @return Planned releases and whether files were changed.
+ */
+export declare function versionChangesets(input: ChangesetVersionInput): Promise<ChangesetReleasePlan & {
+    date: string;
+    changed: boolean;
+}>;
+/**
+ * Create missing release tags, optionally pushing them to the configured remote.
+ *
+ * @param input Repository and tag options.
+ * @return Per-package tags and release notes.
+ */
+export declare function tagChangesets(input: ChangesetTagInput): Promise<ChangesetTagResult>;
+/**
+ * Check whether changed files belong to packages without a changeset.
+ *
+ * @param input Repository and base git ref.
+ * @return Changed packages and missing changeset identifiers.
+ */
+export declare function getChangesetStatus(input: ChangesetRepository & {
+    since?: string;
+}): Promise<{
+    changesets: Changeset[];
+    releases: PackageRelease[];
+    changedPackages: string[];
+    changedPackageFiles: Record<string, string[]>;
+    missingChangesets: string[];
+}>;