@wpelevator/wp-release 0.6.1 → 0.8.0

package/dist/git-deploy.js

@@ -0,0 +1,420 @@
+import { mkdtemp, rm, stat } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join, resolve } from 'node:path';
+import { ValidationError } from "./errors.js";
+import { loadFileRules, resolveFileSelection, selectFiles, } from "./file-selection.js";
+import { createGitRunner, redactUrls } from "./git.js";
+import { Logger } from "./logger.js";
+import { getGitDeploySummary } from "./summary.js";
+/**
+ * Check a branch or tag name for the common mistakes before it's used in a
+ * refspec. It intentionally covers only the main rules of git
+ * check-ref-format, since git rejects any other invalid name when it pushes.
+ *
+ * @param name Branch or tag name.
+ * @return Whether the name can be used.
+ */
+export function isValidRefName(name) {
+    return (/^[^\s~^:?*[\\]+$/.test(name) &&
+        !/(^[-/.]|\/\.|\.\.|\/\/|@\{|\.lock$|[/.]$)/.test(name));
+}
+/**
+ * Apply the defaults to the Git deploy options and validate them.
+ *
+ * @param  input Git deploy input.
+ * @return Git deploy options.
+ * @throws {ValidationError} For a missing URL or an invalid branch or tag.
+ */
+export function resolveGitDeployOptions(input = {}) {
+    const cwd = resolve(input.cwd ?? process.cwd());
+    const sourceDir = resolve(cwd, input.sourceDir || '.');
+    const names = [
+        ['branch', input.branch],
+        ['tag', input.tag],
+    ].filter(([, name]) => name && !isValidRefName(name));
+    if (!input.gitUrl) {
+        throw new ValidationError('Pass the URL of the repository to deploy to.');
+    }
+    if (names.length) {
+        throw new ValidationError(names
+            .map(([kind, name]) => `Invalid ${kind} "${name}".`)
+            .join('\n'));
+    }
+    return {
+        cwd,
+        sourceDir,
+        gitUrl: input.gitUrl,
+        branch: input.branch || null,
+        tag: input.tag || null,
+        splitPrefix: input.splitPrefix || null,
+        sourceRef: input.sourceRef || 'HEAD',
+        message: input.message || null,
+        dryRun: Boolean(input.dryRun),
+        ...resolveFileSelection({
+            cwd,
+            sourceDir,
+            distignore: input.distignore,
+            exclude: input.exclude,
+        }),
+    };
+}
+/**
+ * Deploy the files of a plugin, theme or package to a Git repository, as a
+ * release commit with exactly the selected files. Its parents are the
+ * previous release in the repository and the source commit, or with
+ * splitPrefix the history of that directory from git subtree split, so the
+ * repository keeps the source history and `git log --first-parent` lists the
+ * releases. Pushes are never forced: a branch only moves forward, a release
+ * without changes isn't pushed again, and an existing tag is never replaced.
+ *
+ * Each step is a separate method so that wrappers can run and report them
+ * one by one; run() does all of them.
+ */
+export class GitDeploy {
+    options;
+    logger;
+    runner;
+    repoRoot = null;
+    /**
+     * @param options Options from resolveGitDeployOptions().
+     * @param logger  Logger for the progress.
+     * @param runner  Git command runner, replaceable in tests.
+     */
+    constructor(options, logger = new Logger(), runner = createGitRunner()) {
+        this.options = options;
+        this.logger = logger;
+        this.runner = runner;
+    }
+    /**
+     * Whether the options ask for any push.
+     *
+     * @return True with a branch or a tag.
+     */
+    hasWrites() {
+        return Boolean(this.options.branch || this.options.tag);
+    }
+    /**
+     * Create the release commit and push it.
+     *
+     * @return Release, previous release and the pushed refs.
+     */
+    async run() {
+        const result = {
+            revision: null,
+            previous: null,
+            created: false,
+            outdated: false,
+            planned: [],
+            pushed: [],
+            files: 0,
+        };
+        if (this.hasWrites()) {
+            this.logger.info(`Deploying ${this.options.sourceDir} to ${redactUrls(this.options.gitUrl)}`);
+            const { tree, files } = await this.createTree();
+            const previous = await this.fetchPrevious();
+            const tagged = this.options.tag
+                ? await this.checkTag(tree)
+                : null;
+            const { revision, created, outdated } = tagged
+                ? { revision: tagged, created: false, outdated: false }
+                : await this.createRelease(tree, previous);
+            const planned = this.getRefsToPush(revision, previous, tagged, outdated);
+            const pushed = await this.push(revision, planned);
+            const deployed = {
+                revision,
+                previous,
+                created,
+                outdated,
+                planned,
+                pushed,
+                files,
+            };
+            this.logger.summary((context) => getGitDeploySummary(context, {
+                ...deployed,
+                gitUrl: this.options.gitUrl,
+                dryRun: this.options.dryRun,
+            }));
+            return deployed;
+        }
+        this.logger.notice('Nothing to deploy. Pass a branch or a tag.');
+        return result;
+    }
+    /**
+     * Write the selected files to the object database of the source
+     * repository and create a tree of them, with a temporary index so that
+     * the working tree and the index of the repository are left alone.
+     *
+     * @return Tree hash and the number of files.
+     * @throws {ValidationError} When no files are selected, or a file name has a line break.
+     */
+    async createTree() {
+        const { sourceDir } = this.options;
+        const rules = await loadFileRules(this.options);
+        const files = await selectFiles(sourceDir, rules);
+        if (!files.length) {
+            throw new ValidationError(`No files to deploy in ${sourceDir}.`);
+        }
+        // The git plumbing below reads one path per line.
+        const unsupported = files.filter((file) => /[\n\r]|^"/.test(file));
+        if (unsupported.length) {
+            throw new ValidationError(`File names with line breaks or a leading quote can't be deployed: ${unsupported
+                .map((file) => JSON.stringify(file))
+                .join(', ')}.`);
+        }
+        const hashes = await this.git({
+            args: ['hash-object', '-w', '--no-filters', '--stdin-paths'],
+            input: files
+                .map((file) => join(sourceDir, file))
+                .join('\n'),
+        });
+        const modes = await Promise.all(files.map(async (file) => 
+        // eslint-disable-next-line no-bitwise
+        (await stat(join(sourceDir, file))).mode & 0o111
+            ? '100755'
+            : '100644'));
+        const shas = hashes.split('\n');
+        const indexDir = await mkdtemp(join(tmpdir(), 'wp-release-git-'));
+        const env = { GIT_INDEX_FILE: join(indexDir, 'index') };
+        try {
+            await this.git({
+                args: ['update-index', '--add', '--index-info'],
+                input: files
+                    .map((file, index) => `${modes[index]} ${shas[index]}\t${file}`)
+                    .join('\n'),
+                env,
+            });
+            const tree = await this.git({ args: ['write-tree'], env });
+            this.logger.debug(`Created tree ${tree} of ${files.length} files.`);
+            return { tree, files: files.length };
+        }
+        finally {
+            await rm(indexDir, { recursive: true, force: true });
+        }
+    }
+    /**
+     * Fetch the previous release: the branch, or for a tag-only deploy the
+     * default branch of the repository.
+     *
+     * @return Commit hash, or null when the repository has no such branch yet.
+     */
+    async fetchPrevious() {
+        const { gitUrl, branch } = this.options;
+        const ref = branch ? `refs/heads/${branch}` : 'HEAD';
+        const remote = await this.git({ args: ['ls-remote', gitUrl, ref] });
+        const found = remote
+            .split('\n')
+            .some((line) => line.endsWith(`\t${ref}`));
+        return found ? this.fetchCommit(ref) : null;
+    }
+    /**
+     * Fetch a ref of the repository.
+     *
+     * @param ref Branch or tag ref, or HEAD.
+     * @return Commit hash, with a tag peeled to its commit.
+     */
+    async fetchCommit(ref) {
+        await this.git({
+            args: ['fetch', '--no-tags', '--quiet', this.options.gitUrl, ref],
+        });
+        return this.git({ args: ['rev-parse', 'FETCH_HEAD^{commit}'] });
+    }
+    /**
+     * Get the release commit. When the files are the same as in the previous
+     * release, that release is reused. When the previous release on the
+     * branch already has newer source history, like when an older build runs
+     * again, the branch isn't moved: only a tag gets a new release commit.
+     *
+     * @param tree     Tree of the released files.
+     * @param previous Previous release, or null for the first one.
+     * @return Release commit, whether it was created and whether the source is outdated.
+     */
+    async createRelease(tree, previous) {
+        const previousTree = previous
+            ? await this.git({
+                args: ['rev-parse', `${previous}^{tree}`],
+            })
+            : null;
+        if (previous && tree === previousTree) {
+            this.logger.notice('The files are the same as in the previous release.');
+            return { revision: previous, created: false, outdated: false };
+        }
+        const source = await this.getSourceHistory();
+        const outdated = this.options.branch && previous
+            ? await this.isOutdated(source, previous)
+            : false;
+        if (outdated) {
+            this.logger.notice(`The release on ${this.options.branch} already has newer source history than ${source}, so the branch isn't moved.`);
+        }
+        if (outdated && previous && !this.options.tag) {
+            return { revision: previous, created: false, outdated };
+        }
+        const parents = [previous, source].filter((parent) => Boolean(parent));
+        const revision = await this.git({
+            args: [
+                'commit-tree',
+                tree,
+                ...parents.flatMap((parent) => ['-p', parent]),
+                '-m',
+                this.options.message ?? (await this.getDefaultMessage()),
+            ],
+        });
+        this.logger.notice(`Created release ${revision}.`);
+        return { revision, created: true, outdated };
+    }
+    /**
+     * Check whether a release was made from newer source history: the source
+     * history of the release, its last parent, already has the source as an
+     * older commit. The same source, a newer one, including a revert, and
+     * unrelated history aren't outdated. With splitPrefix, git subtree split
+     * creates the same commits for the same history, so the split of an older
+     * build is part of the split of a newer one.
+     *
+     * @param source   Source history from getSourceHistory().
+     * @param previous Previous release.
+     * @return Whether the source is older than the source of the release.
+     */
+    async isOutdated(source, previous) {
+        const [, ...parents] = (await this.git({
+            args: ['rev-list', '--parents', '--max-count=1', previous],
+        })).split(' ');
+        const released = parents.at(-1);
+        // Commits of the source history that the released source doesn't have.
+        const unreleased = released && released !== source
+            ? await this.git({
+                args: [
+                    'rev-list',
+                    '--max-count=1',
+                    source,
+                    '--not',
+                    released,
+                ],
+            })
+            : source;
+        return '' === unreleased;
+    }
+    /**
+     * Get the source history parent of a release: the source commit, or the
+     * history of splitPrefix from git subtree split.
+     *
+     * @return Commit hash.
+     */
+    async getSourceHistory() {
+        const { splitPrefix, sourceRef } = this.options;
+        return this.git({
+            args: splitPrefix
+                ? ['subtree', 'split', `--prefix=${splitPrefix}`, sourceRef]
+                : ['rev-parse', `${sourceRef}^{commit}`],
+        });
+    }
+    /**
+     * Check the tag in the repository before anything is pushed. Tags are
+     * never replaced, so a tag with other files is an error. A tag with the
+     * same files is the release, which makes running a tag release again a
+     * no-op, also when the release commit was created on top of an older
+     * branch tip. To release a tag again, delete it in the repository first.
+     *
+     * @param  tree Tree of the released files.
+     * @return Tagged commit when the tag has the same files, null without the tag.
+     * @throws {ValidationError} When the tag has other files.
+     */
+    async checkTag(tree) {
+        const { gitUrl, tag } = this.options;
+        const ref = `refs/tags/${tag}`;
+        const remote = await this.git({
+            args: ['ls-remote', '--tags', gitUrl, ref],
+        });
+        const found = remote
+            .split('\n')
+            .some((line) => line.endsWith(`\t${ref}`));
+        const tagged = found ? await this.fetchCommit(ref) : null;
+        const taggedTree = tagged
+            ? await this.git({ args: ['rev-parse', `${tagged}^{tree}`] })
+            : null;
+        if (tagged && taggedTree !== tree) {
+            throw new ValidationError(`Tag ${tag} already exists in ${redactUrls(gitUrl)} with other files. Tags are never replaced: delete the tag in the repository to release it again.`);
+        }
+        if (tagged) {
+            this.logger.notice(`Tag ${tag} already has these files, nothing to push.`);
+        }
+        return tagged;
+    }
+    /**
+     * Get the refs to push: the branch, when the release moves it and the
+     * source isn't outdated, and the tag, unless it already exists with these
+     * files.
+     *
+     * @param revision Release commit.
+     * @param previous Previous release.
+     * @param tagged   Commit of an existing tag with the same files, from checkTag().
+     * @param outdated Whether the branch has newer source history, from createRelease().
+     * @return Refs like refs/heads/main and refs/tags/1.2.0.
+     */
+    getRefsToPush(revision, previous, tagged = null, outdated = false) {
+        const { branch, tag } = this.options;
+        return [
+            branch && !tagged && !outdated && revision !== previous
+                ? `refs/heads/${branch}`
+                : '',
+            tag && !tagged ? `refs/tags/${tag}` : '',
+        ].filter(Boolean);
+    }
+    /**
+     * Push the release to the refs in one atomic push, never forced, so the
+     * branch only moves forward and a tag that was created in the meantime
+     * is never replaced. A dry run checks the push without writing.
+     *
+     * @param revision Release commit.
+     * @param refs     Refs from getRefsToPush().
+     * @return Pushed refs, empty in a dry run or without refs.
+     */
+    async push(revision, refs) {
+        const { gitUrl, dryRun } = this.options;
+        if (refs.length) {
+            await this.git({
+                args: [
+                    'push',
+                    '--no-verify',
+                    '--atomic',
+                    ...(dryRun ? ['--dry-run'] : []),
+                    gitUrl,
+                    ...refs.map((ref) => `${revision}:${ref}`),
+                ],
+            });
+            this.logger.notice(dryRun
+                ? `Dry run, skipped pushing ${refs.join(', ')}.`
+                : `Pushed ${revision} to ${refs.join(', ')}.`);
+        }
+        else {
+            this.logger.notice('No changes to push.');
+        }
+        return dryRun ? [] : refs;
+    }
+    async getDefaultMessage() {
+        const { tag, branch, sourceRef } = this.options;
+        const source = await this.git({
+            args: ['rev-parse', `${sourceRef}^{commit}`],
+        });
+        return `Release ${tag ?? branch} from ${source}`;
+    }
+    async getRepoRoot() {
+        this.repoRoot =
+            this.repoRoot ??
+                (await this.runner({
+                    args: ['rev-parse', '--show-toplevel'],
+                    cwd: this.options.sourceDir,
+                })).stdout.trim();
+        return this.repoRoot;
+    }
+    /**
+     * Run git in the source repository.
+     *
+     * @param input Command input without the working directory.
+     * @return Trimmed standard output.
+     */
+    async git(input) {
+        const cwd = await this.getRepoRoot();
+        this.logger.debug(redactUrls(`git ${input.args.join(' ')}`));
+        const { stdout } = await this.runner({ ...input, cwd });
+        return stdout.trim();
+    }
+}

package/dist/git.d.ts

@@ -0,0 +1,49 @@
+export interface GitCommandInput {
+    /** Arguments after "git", passed without a shell. */
+    args: string[];
+    /** Working directory of the command. */
+    cwd?: string;
+    /** Text written to the standard input. */
+    input?: string;
+    /** Extra environment variables, like GIT_INDEX_FILE. */
+    env?: Record<string, string>;
+}
+export interface GitCommandOutput {
+    /** Standard output. */
+    stdout: string;
+    /** Standard error. */
+    stderr: string;
+}
+/**
+ * Run a git command. Rejects with a GitError when it exits with an error.
+ */
+export type GitRunner = (input: GitCommandInput) => Promise<GitCommandOutput>;
+/**
+ * Hide the credentials in URLs, like https://token@github.com/owner/repo.git,
+ * so that they never end up in logs or error messages.
+ *
+ * @param text Text with URLs.
+ * @return Text with the user info of URLs replaced by ***.
+ */
+export declare function redactUrls(text: string): string;
+/**
+ * Failed git command.
+ */
+export declare class GitError extends Error {
+    name: string;
+    exitCode: number;
+    stderr: string;
+    /**
+     * @param message Error message.
+     * @param stderr  Standard error of the command.
+     */
+    constructor(message: string, stderr?: string);
+}
+/**
+ * Create a runner that spawns git without a shell, with English messages and
+ * without prompting for credentials.
+ *
+ * @param binary Git binary.
+ * @return Command runner.
+ */
+export declare function createGitRunner(binary?: string): GitRunner;

package/dist/git.js

@@ -0,0 +1,65 @@
+import { spawn } from 'node:child_process';
+/**
+ * Hide the credentials in URLs, like https://token@github.com/owner/repo.git,
+ * so that they never end up in logs or error messages.
+ *
+ * @param text Text with URLs.
+ * @return Text with the user info of URLs replaced by ***.
+ */
+export function redactUrls(text) {
+    return text.replace(/(\w+:\/\/)[^/@\s]+@/g, '$1***@');
+}
+/**
+ * Failed git command.
+ */
+export class GitError extends Error {
+    name = 'GitError';
+    exitCode = 1;
+    stderr;
+    /**
+     * @param message Error message.
+     * @param stderr  Standard error of the command.
+     */
+    constructor(message, stderr = '') {
+        super(redactUrls(message));
+        this.stderr = redactUrls(stderr);
+    }
+}
+/**
+ * Create a runner that spawns git without a shell, with English messages and
+ * without prompting for credentials.
+ *
+ * @param binary Git binary.
+ * @return Command runner.
+ */
+export function createGitRunner(binary = 'git') {
+    return ({ args, cwd, input, env = {} }) => new Promise((resolve, reject) => {
+        const child = spawn(binary, args, {
+            cwd,
+            env: {
+                ...process.env,
+                LC_ALL: 'C',
+                GIT_TERMINAL_PROMPT: '0',
+                ...env,
+            },
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        const output = { stdout: '', stderr: '' };
+        child.stdout.setEncoding('utf8');
+        child.stderr.setEncoding('utf8');
+        child.stdout.on('data', (data) => (output.stdout += data));
+        child.stderr.on('data', (data) => (output.stderr += data));
+        child.on('error', (error) => reject(new GitError(`Can't run ${binary}: ${error.message}. Install git.`)));
+        child.on('close', (code) => {
+            if (0 === code) {
+                resolve(output);
+            }
+            else {
+                reject(new GitError(`git ${args[0]} failed: ${output.stderr.trim()}`, output.stderr));
+            }
+        });
+        // A command can exit before it reads all of its input.
+        child.stdin.on('error', () => undefined);
+        child.stdin.end(input ?? '');
+    });
+}

package/dist/github.d.ts

@@ -0,0 +1,24 @@
+/**
+ * A GitHub pull request of a commit.
+ */
+export interface GitHubPullRequest {
+    number: number;
+    url: string;
+    /** GitHub handle of the pull request author, without the @. */
+    author: string;
+}
+export interface GetGitHubPullRequestInput {
+    /** Directory of the repository, whose GitHub remote `gh` uses. */
+    cwd: string;
+    /** Commit hash. */
+    commit: string;
+}
+/**
+ * Find the pull request that merged a commit, with the authenticated `gh`
+ * command line client.
+ *
+ * @param  input Repository directory and commit.
+ * @return The first pull request of the commit, or undefined without one.
+ * @throws {ValidationError} If `gh` fails, like without authentication.
+ */
+export declare function getGitHubPullRequest(input: GetGitHubPullRequestInput): Promise<GitHubPullRequest | undefined>;

package/dist/github.js

@@ -0,0 +1,30 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { ValidationError } from "./errors.js";
+const execFileAsync = promisify(execFile);
+/**
+ * Find the pull request that merged a commit, with the authenticated `gh`
+ * command line client.
+ *
+ * @param  input Repository directory and commit.
+ * @return The first pull request of the commit, or undefined without one.
+ * @throws {ValidationError} If `gh` fails, like without authentication.
+ */
+export async function getGitHubPullRequest(input) {
+    let stdout;
+    try {
+        ({ stdout } = await execFileAsync('gh', ['api', `repos/{owner}/{repo}/commits/${input.commit}/pulls`], { cwd: input.cwd }));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new ValidationError(`Could not find the pull request of commit ${input.commit}: ${message}`);
+    }
+    const [pullRequest] = JSON.parse(stdout);
+    return pullRequest
+        ? {
+            number: pullRequest.number,
+            url: pullRequest.html_url,
+            author: pullRequest.user?.login ?? '',
+        }
+        : undefined;
+}

package/dist/index.d.ts

@@ -14,12 +14,15 @@ export { ZIP_MTIME, ZIP_FILE_MODE, createZip } from './zip.ts';
 export { isUrl, downloadFile } from './download.ts';
 export { readZipEntries, getZipEntryErrors, extractZip } from './unzip.ts';
 export { GIT_TAG_FORMAT, VersionMismatchError, getGitTagVersion, findConstantValues, findConstantDefinitions, findVersionMismatches, getVersionMismatchProblems, } from './version-check.ts';
-export { CHANGESET_BUMPS, parseChangeset, formatChangeset, getChangesetBump, getNextVersion, } from './changesets.ts';
-export { addChangeset, getChangesetReleasePlan, getChangesetStatus, versionChangesets, tagChangesets, } from './changeset-release.ts';
+export { CHANGESET_BUMPS, parseChangeset, formatChangeset, formatChangelogEntries, formatChangelogList, getChangesetBump, getNextVersion, } from './changesets.ts';
+export { addChangeset, getChangesetPackages, getChangesetReleasePlan, getChangesetStatus, versionChangesets, tagChangesets, } from './changeset-release.ts';
 export { defineConfig, packageJsonVersion, composerJsonVersion, wordpressPluginVersion, wordpressThemeVersion, wordpressStableTag, gitTagVersion, phpConstantVersion, loadChangesetConfig, } from './changeset-config.ts';
 export { Svn, SvnError, createSvnRunner, parseStatus, toSvnPath, } from './svn.ts';
 export { syncDirectory, copyFileIfChanged } from './sync.ts';
 export { ASSET_MIME_TYPES, SvnDeploy } from './svn-deploy.ts';
+export { GitError, createGitRunner, redactUrls } from './git.ts';
+export { GitDeploy, isValidRefName, resolveGitDeployOptions, } from './git-deploy.ts';
+export { getGitDeployInputFromArgs } from './commands/deploy-git.ts';
 export type { CliIo, CommandResults } from './cli.ts';
 export type { ChecksumsResult } from './commands/checksums.ts';
 export type { SignResult } from './commands/sign.ts';
@@ -37,10 +40,14 @@ export type { FindMainPluginFileInput, HeaderValues, PackageMeta, ParseFileHeade
 export type { CreateZipInput } from './zip.ts';
 export type { ExtractZipInput, ZipEntryInfo, ZipEntryType } from './unzip.ts';
 export type { FindVersionMismatchesInput, GitTagInput, VersionCheckResult, VersionMismatch, } from './version-check.ts';
-export type { Changeset, ChangesetBump, ChangesetPackages, ChangesetConfig, ChangesetPackageType, ChangesetPackage, PackageRelease, ChangesetReleasePlan, } from './changesets.ts';
-export type { ChangesetRepository, ChangesetVersionInput, ChangesetTagInput, ChangesetTagResult, } from './changeset-release.ts';
-export type { WpReleaseConfig, ChangesetPackageGroup, PackageVersionConfig, PackageVersionSource, PackageVersionTarget, PackageIdSource, NextVersionInput, PackageJsonVersionOptions, ComposerJsonVersionOptions, WordPressVersionFileOptions, GitTagVersionOptions, PhpConstantVersionOptions, LoadChangesetConfigInput, } from './changeset-config.ts';
+export type { Changeset, ChangesetBump, ChangesetPackages, ChangesetConfig, ChangesetPackageType, ChangesetPackage, PackageRelease, VersionedRelease, ChangesetReleasePlan, } from './changesets.ts';
+export type { ChangesetRepository, ChangesetVersionInput, VersionChangesetsResult, ChangesetTagInput, ChangesetTagResult, } from './changeset-release.ts';
+export type { WpReleaseConfig, ChangesetPackageGroup, PackageVersionConfig, PackageVersionSource, PackageVersionTarget, PackageIdSource, NextVersionInput, ReleaseCommit, ReleaseNotesInput, ChangelogEntryInput, PackageJsonVersionOptions, ComposerJsonVersionOptions, WordPressVersionFileOptions, GitTagVersionOptions, PhpConstantVersionOptions, LoadChangesetConfigInput, } from './changeset-config.ts';
 export type { SvnCheckoutInput, SvnCommandInput, SvnCommandOutput, SvnCommitInput, SvnCopyInput, SvnDepth, SvnOptions, SvnPathsInput, SvnPropsetInput, SvnRunner, SvnStatusEntry, SvnStatusType, SvnUpdateInput, } from './svn.ts';
 export type { SyncDirectoryInput, SyncResult } from './sync.ts';
 export type { SummaryContext } from './summary.ts';
+export { getGitHubPullRequest } from './github.ts';
+export type { GitHubPullRequest, GetGitHubPullRequestInput } from './github.ts';
 export type { CheckoutPath, DeployResult } from './svn-deploy.ts';
+export type { GitCommandInput, GitCommandOutput, GitRunner } from './git.ts';
+export type { GitDeployInput, GitDeployOptions, GitDeployResult, } from './git-deploy.ts';

package/dist/index.js

@@ -14,9 +14,13 @@ export { ZIP_MTIME, ZIP_FILE_MODE, createZip } from "./zip.js";
 export { isUrl, downloadFile } from "./download.js";
 export { readZipEntries, getZipEntryErrors, extractZip } from "./unzip.js";
 export { GIT_TAG_FORMAT, VersionMismatchError, getGitTagVersion, findConstantValues, findConstantDefinitions, findVersionMismatches, getVersionMismatchProblems, } from "./version-check.js";
-export { CHANGESET_BUMPS, parseChangeset, formatChangeset, getChangesetBump, getNextVersion, } from "./changesets.js";
-export { addChangeset, getChangesetReleasePlan, getChangesetStatus, versionChangesets, tagChangesets, } from "./changeset-release.js";
+export { CHANGESET_BUMPS, parseChangeset, formatChangeset, formatChangelogEntries, formatChangelogList, getChangesetBump, getNextVersion, } from "./changesets.js";
+export { addChangeset, getChangesetPackages, getChangesetReleasePlan, getChangesetStatus, versionChangesets, tagChangesets, } from "./changeset-release.js";
 export { defineConfig, packageJsonVersion, composerJsonVersion, wordpressPluginVersion, wordpressThemeVersion, wordpressStableTag, gitTagVersion, phpConstantVersion, loadChangesetConfig, } from "./changeset-config.js";
 export { Svn, SvnError, createSvnRunner, parseStatus, toSvnPath, } from "./svn.js";
 export { syncDirectory, copyFileIfChanged } from "./sync.js";
 export { ASSET_MIME_TYPES, SvnDeploy } from "./svn-deploy.js";
+export { GitError, createGitRunner, redactUrls } from "./git.js";
+export { GitDeploy, isValidRefName, resolveGitDeployOptions, } from "./git-deploy.js";
+export { getGitDeployInputFromArgs } from "./commands/deploy-git.js";
+export { getGitHubPullRequest } from "./github.js";