genbumppush 0.0.2 → 0.0.4

package/dist/{release-cb3ZULZM.mjs → release-gwyqzR0C.mjs}

@@ -1,12 +1,43 @@
-import { createDefineConfig, loadConfig } from "c12";
-import { determineSemverChange, generateMarkDown, getGitDiff, loadChangelogConfig, parseCommits } from "changelogen";
+import { createDefineConfig, loadConfig, setupDotenv } from "c12";
+import { determineSemverChange, generateMarkDown, getGitDiff, loadChangelogConfig, parseCommits, resolveRepoConfig } from "changelogen";
 import { existsSync, readFileSync } from "node:fs";
 import { readFile, readdir, realpath, unlink, writeFile } from "node:fs/promises";
 import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
 import { createInterface } from "node:readline/promises";
 import { execFileSync, spawnSync } from "node:child_process";
 //#region src/config.ts
+/**
+* Identity helper that types a release config for your editor.
+*
+* It does not change the object at runtime — it only enables autocomplete
+* and catches typos inside `defineConfig({ … })`.
+*
+* @typeParam Config - Config object shape; defaults to {@link GenBumpPushConfig}.
+* @returns The same object you passed in.
+*
+* @example `genbumppush.config.ts`
+* ```ts
+* import { defineConfig } from 'genbumppush';
+*
+* export default defineConfig({
+*   preid: 'beta',
+*   files: ['package.json'],
+*   git: {
+*     commitMessage: 'chore(release): v{{version}}',
+*   },
+*   hooks: {
+*     before: ['npm run check', 'npm test'],
+*   },
+* });
+* ```
+*/
 const defineConfig = createDefineConfig();
+/**
+* Built-in defaults used when neither the CLI, a config file, nor
+* `package.json` sets a field.
+*
+* Useful if you want to document or assert what an empty config resolves to.
+*/
 const defaults = {
 	changelog: "CHANGELOG.md",
 	excludeDependencyCommits: true,
@@ -22,7 +53,45 @@ const defaults = {
 		tagMessage: "v{{version}}"
 	}
 };
+/**
+* Load the effective release config for a repository.
+*
+* Resolution order (later wins):
+* 1. {@link defaults}
+* 2. `"genbumppush"` key in that directory’s `package.json`
+* 3. C12 config file (`genbumppush.config.ts` / `.js`, or `configFile` when given)
+* 4. `overrides` you pass here (CLI flags in the binary go through this)
+*
+* Also loads `.env` from `cwd` into `process.env` without overwriting
+* variables that are already set. Secrets still belong in the environment —
+* not in config files.
+*
+* @param cwd - Repository root to load config from.
+* @param configFile - Optional explicit path to a C12 config file.
+* @param overrides - Highest-priority values (for example CLI flags).
+* @returns The fully merged config object.
+* @throws May reject if the config file throws or cannot be loaded.
+*
+* @example Read what a repo already configured
+* ```ts
+* import { loadReleaseConfig } from 'genbumppush';
+*
+* const config = await loadReleaseConfig(process.cwd());
+* console.log(config.git?.remote ?? 'origin');
+* ```
+*
+* @example Force a dry-run-style push disable from a script
+* ```ts
+* import { loadReleaseConfig } from 'genbumppush';
+*
+* const config = await loadReleaseConfig(process.cwd(), undefined, {
+*   git: { push: false },
+* });
+* // config.git.push === false even if the file enabled push
+* ```
+*/
 async function loadReleaseConfig(cwd, configFile, overrides) {
+	await setupDotenv({ cwd });
 	return (await loadConfig({
 		name: "genbumppush",
 		cwd,
@@ -36,8 +105,42 @@ async function loadReleaseConfig(cwd, configFile, overrides) {
 }
 //#endregion
 //#region src/error.ts
+/**
+* Error thrown by genbumppush for expected release failures.
+*
+* Unlike a generic `Error`, every {@link ReleaseError} carries a stable
+* {@link ReleaseError.code} so scripts and the CLI can branch on the reason
+* (`DIRTY_WORKTREE`, `TAG_EXISTS`, `CANCELLED`, …) without parsing messages.
+*
+* @example Branch on the failure reason
+* ```ts
+* import { runRelease, ReleaseError } from 'genbumppush';
+*
+* try {
+*   await runRelease({ cwd: process.cwd(), dryRun: false, yes: true, help: false });
+* } catch (error) {
+*   if (error instanceof ReleaseError && error.code === 'CANCELLED') {
+*     process.exit(0);
+*   }
+*   throw error;
+* }
+* ```
+*
+* @example Print code and message the same way the CLI does
+* ```ts
+* if (error instanceof ReleaseError) {
+*   console.error(`[${error.code}] ${error.message}`);
+* }
+* ```
+*/
 var ReleaseError = class extends Error {
+	/** Machine-readable reason, for example `'DIRTY_WORKTREE'` or `'TAG_EXISTS'`. */
 	code;
+	/**
+	* @param code - Stable machine-readable reason.
+	* @param message - Human-readable explanation shown to the user.
+	* @param options - Optional `cause` when wrapping an underlying error.
+	*/
 	constructor(code, message, options) {
 		super(message, options);
 		this.name = "ReleaseError";
@@ -73,7 +176,7 @@ function tagExists(cwd, tag) {
 	}).status === 0;
 }
 function isGitRepository(cwd) {
-	return spawnSync("git", ["rev-parse", "--is-inside-work-tree"], {
+	const result = spawnSync("git", ["rev-parse", "--is-inside-work-tree"], {
 		cwd,
 		encoding: "utf8",
 		stdio: [
@@ -81,7 +184,9 @@ function isGitRepository(cwd) {
 			"pipe",
 			"ignore"
 		]
-	}).stdout.trim() === "true";
+	});
+	if (result.error || result.status !== 0 || typeof result.stdout !== "string") return false;
+	return result.stdout.trim() === "true";
 }
 function remoteTagExists(cwd, remote, tag) {
 	return git([
@@ -99,7 +204,139 @@ function runHook(command, cwd) {
 	}).status !== 0) throw new ReleaseError("HOOK_FAILED", `Hook failed: ${command}`);
 }
 //#endregion
+//#region src/env.ts
+const ENV = {
+	GITHUB_TOKEN: "GENBUMPPUSH_GITHUB_TOKEN",
+	GITHUB_HOST: "GENBUMPPUSH_GITHUB_HOST",
+	GITHUB_REPOSITORY: "GENBUMPPUSH_GITHUB_REPOSITORY",
+	GITLAB_TOKEN: "GENBUMPPUSH_GITLAB_TOKEN",
+	GITLAB_HOST: "GENBUMPPUSH_GITLAB_HOST",
+	GITLAB_PROJECT: "GENBUMPPUSH_GITLAB_PROJECT"
+};
+function readEnv(name) {
+	const value = process.env[name];
+	return value !== void 0 && value.length > 0 ? value : void 0;
+}
+function readEnvFirst(...names) {
+	for (const name of names) {
+		const value = readEnv(name);
+		if (value !== void 0) return value;
+	}
+}
+//#endregion
+//#region src/github.ts
+function normalizeHost(host) {
+	return host.replace(/^https?:\/\//, "").replace(/\/$/, "");
+}
+function apiBase(host) {
+	const normalized = normalizeHost(host);
+	if (normalized === "github.com" || normalized === "api.github.com") return "https://api.github.com";
+	return `https://${normalized}/api/v3`;
+}
+function encodeRepoPath(repo) {
+	return repo.split("/").map((segment) => encodeURIComponent(segment)).join("/");
+}
+const GITHUB_TOKEN_FALLBACKS = [
+	ENV.GITHUB_TOKEN,
+	"GITHUB_TOKEN",
+	"GH_TOKEN",
+	"CHANGELOGEN_TOKENS_GITHUB"
+];
+function githubTokenEnvLabel(tokenEnv) {
+	return tokenEnv ?? `${ENV.GITHUB_TOKEN} (or GITHUB_TOKEN, GH_TOKEN, CHANGELOGEN_TOKENS_GITHUB)`;
+}
+function resolveGitHubToken(tokenEnv) {
+	if (tokenEnv !== void 0) return readEnv(tokenEnv);
+	return readEnvFirst(...GITHUB_TOKEN_FALLBACKS);
+}
+async function resolveGitHubRepo(cwd, source) {
+	const host = normalizeHost(source.host ?? readEnv(ENV.GITHUB_HOST) ?? readEnv("GITHUB_API_URL") ?? "github.com");
+	const explicit = source.repo ?? readEnvFirst(ENV.GITHUB_REPOSITORY, "GITHUB_REPOSITORY");
+	if (explicit !== void 0 && explicit.length > 0) return {
+		host,
+		repo: explicit
+	};
+	const resolved = await resolveRepoConfig(cwd);
+	if (resolved?.provider === "github" && resolved.repo) return {
+		host: normalizeHost(resolved.domain ?? host),
+		repo: resolved.repo
+	};
+	throw new ReleaseError("GITHUB_RELEASE_FAILED", `Set github.repo or ${ENV.GITHUB_REPOSITORY} (or GITHUB_REPOSITORY) to create a GitHub release.`);
+}
+async function githubFetch(options, path, init) {
+	const url = `${apiBase(options.host)}/repos/${encodeRepoPath(options.repo)}${path}`;
+	const headers = new Headers({
+		Accept: "application/vnd.github+json",
+		"X-GitHub-Api-Version": "2022-11-28",
+		Authorization: `Bearer ${options.token}`,
+		"Content-Type": "application/json"
+	});
+	if (init?.headers) new Headers(init.headers).forEach((value, key) => {
+		headers.set(key, value);
+	});
+	let response;
+	try {
+		response = await fetch(url, {
+			method: init?.method,
+			body: init?.body,
+			headers,
+			signal: init?.signal ?? AbortSignal.timeout(3e4)
+		});
+	} catch (error) {
+		throw new ReleaseError("GITHUB_RELEASE_FAILED", "Could not send the GitHub release request.", { cause: error });
+	}
+	return response;
+}
+function parseReleaseId(body) {
+	if (typeof body !== "object" || body === null || !("id" in body)) return void 0;
+	const id = body.id;
+	return typeof id === "number" ? id : void 0;
+}
+/**
+* Create or update a GitHub (or GHES) release for an existing tag.
+* Uses the exact tag string so custom genbumppush tag templates stay valid.
+*/
+async function createGitHubRelease(options) {
+	const existing = await githubFetch(options, `/releases/tags/${encodeURIComponent(options.tag)}`, { method: "GET" });
+	let existingId;
+	if (existing.ok) existingId = parseReleaseId(await existing.json().catch(() => ({})));
+	else if (existing.status !== 404) {
+		const text = await existing.text().catch(() => "");
+		throw new ReleaseError("GITHUB_RELEASE_FAILED", `GitHub release lookup failed with ${existing.status}: ${text || existing.statusText}`);
+	}
+	const payload = JSON.stringify({
+		tag_name: options.tag,
+		name: options.name,
+		body: options.description
+	});
+	const response = existingId === void 0 ? await githubFetch(options, "/releases", {
+		method: "POST",
+		body: payload
+	}) : await githubFetch(options, `/releases/${existingId}`, {
+		method: "PATCH",
+		body: payload
+	});
+	if (!response.ok) {
+		const text = await response.text().catch(() => "");
+		throw new ReleaseError("GITHUB_RELEASE_FAILED", `GitHub release creation failed with ${response.status}: ${text || response.statusText}`);
+	}
+}
+//#endregion
 //#region src/gitlab.ts
+const GITLAB_TOKEN_FALLBACKS = [ENV.GITLAB_TOKEN, "GITLAB_TOKEN"];
+function gitLabTokenEnvLabel(tokenEnv) {
+	return tokenEnv ?? `${ENV.GITLAB_TOKEN} (or GITLAB_TOKEN)`;
+}
+function resolveGitLabToken(tokenEnv) {
+	if (tokenEnv !== void 0) return readEnv(tokenEnv);
+	return readEnvFirst(...GITLAB_TOKEN_FALLBACKS);
+}
+function resolveGitLabHost(host) {
+	return host ?? readEnv(ENV.GITLAB_HOST) ?? readEnv("GITLAB_HOST") ?? "https://gitlab.com";
+}
+function resolveGitLabProject(project) {
+	return project ?? readEnvFirst(ENV.GITLAB_PROJECT, "GITLAB_PROJECT");
+}
 function releaseNotes(changelog, tag) {
 	const lines = changelog.split("\n");
 	const heading = `## ${tag}`;
@@ -112,12 +349,14 @@ function releaseNotes(changelog, tag) {
 	}
 	return notes.join("\n").trim() || "See CHANGELOG.md for release notes.";
 }
+const PROVIDER_FETCH_TIMEOUT_MS = 3e4;
 async function createGitLabRelease(options) {
 	const url = `${options.host.replace(/\/$/, "")}/api/v4/projects/${encodeURIComponent(options.project)}/releases`;
 	let response;
 	try {
 		response = await fetch(url, {
 			method: "POST",
+			signal: AbortSignal.timeout(PROVIDER_FETCH_TIMEOUT_MS),
 			headers: {
 				Authorization: `Bearer ${options.token}`,
 				"Content-Type": "application/json"
@@ -184,11 +423,139 @@ async function findManifests(directory) {
 function assertCurrent(path, actual, expected) {
 	if (actual !== expected) throw new ReleaseError("VERSION_MISMATCH", `${path} has version ${actual}; expected ${expected}.`);
 }
+function parseJsonString(raw) {
+	try {
+		const parsed = JSON.parse(raw);
+		return isString$1(parsed) ? parsed : void 0;
+	} catch {
+		return;
+	}
+}
+function readJsonString(content, start) {
+	let index = start + 1;
+	let escape = false;
+	while (index < content.length) {
+		const char = content[index];
+		if (char === void 0) break;
+		if (escape) escape = false;
+		else if (char === "\\") escape = true;
+		else if (char === "\"") {
+			index += 1;
+			return {
+				end: index,
+				raw: content.slice(start, index)
+			};
+		}
+		index += 1;
+	}
+	return {
+		end: content.length,
+		raw: content.slice(start)
+	};
+}
+function objectKeyPath(stack, propertyKey) {
+	const path = [];
+	for (const frame of stack) if (frame.kind === "object" && frame.introKey !== void 0) path.push(frame.introKey);
+	path.push(propertyKey);
+	return path;
+}
+/**
+* Locate a JSON string property by object-key path without reformatting the file.
+* Nested keys with the same name are never selected.
+*/
+function findJsonStringProperty(content, keyPath) {
+	if (keyPath.length === 0) return void 0;
+	const stack = [];
+	let index = 0;
+	let pendingKey;
+	let afterColon = false;
+	const skipWhitespace = () => {
+		while (index < content.length && /\s/.test(content[index] ?? "")) index += 1;
+	};
+	while (index < content.length) {
+		skipWhitespace();
+		const char = content[index];
+		if (char === void 0) break;
+		if (char === "{") {
+			stack.push({
+				kind: "object",
+				introKey: pendingKey
+			});
+			pendingKey = void 0;
+			afterColon = false;
+			index += 1;
+			continue;
+		}
+		if (char === "}") {
+			stack.pop();
+			pendingKey = void 0;
+			afterColon = false;
+			index += 1;
+			continue;
+		}
+		if (char === "[") {
+			stack.push({ kind: "array" });
+			pendingKey = void 0;
+			afterColon = false;
+			index += 1;
+			continue;
+		}
+		if (char === "]") {
+			stack.pop();
+			pendingKey = void 0;
+			afterColon = false;
+			index += 1;
+			continue;
+		}
+		if (char === ",") {
+			pendingKey = void 0;
+			afterColon = false;
+			index += 1;
+			continue;
+		}
+		if (char === ":") {
+			afterColon = true;
+			index += 1;
+			continue;
+		}
+		if (char === "\"") {
+			const { end, raw } = readJsonString(content, index);
+			index = end;
+			const decoded = parseJsonString(raw);
+			if (decoded === void 0) continue;
+			if (stack.at(-1)?.kind === "object" && !afterColon) {
+				pendingKey = decoded;
+				continue;
+			}
+			if (afterColon && pendingKey !== void 0) {
+				const path = objectKeyPath(stack, pendingKey);
+				if (path.length === keyPath.length && path.every((segment, i) => segment === keyPath[i])) return {
+					value: decoded,
+					valueStart: end - raw.length + 1,
+					valueEnd: end - 1
+				};
+				pendingKey = void 0;
+				afterColon = false;
+			}
+			continue;
+		}
+		if (afterColon) {
+			pendingKey = void 0;
+			afterColon = false;
+		}
+		index += 1;
+	}
+}
+function replaceJsonStringProperty(content, span, value) {
+	return `${content.slice(0, span.valueStart)}${JSON.stringify(value).slice(1, -1)}${content.slice(span.valueEnd)}`;
+}
 function replaceJsonVersion(content, path, current, version) {
 	const parsed = JSON.parse(content);
 	if (!isObject$1(parsed) || !("version" in parsed) || !isString$1(parsed.version)) throw new ReleaseError("MISSING_VERSION", `${path} has no top-level version string.`);
 	assertCurrent(path, parsed.version, current);
-	const updated = content.replace(/("version"\s*:\s*")[^"]*(")/, `$1${version}$2`);
+	const span = findJsonStringProperty(content, ["version"]);
+	if (span === void 0) throw new ReleaseError("MISSING_VERSION", `${path} has no top-level version string.`);
+	const updated = replaceJsonStringProperty(content, span, version);
 	if (updated === content) throw new ReleaseError("VERSION_UNCHANGED", `${path} was not updated.`);
 	return updated;
 }
@@ -201,10 +568,20 @@ function replacePackageLockVersion(content, path, current, version) {
 	const rootVersion = data.packages?.[""]?.version;
 	if (rootVersion !== void 0 && !isString$1(rootVersion)) throw new ReleaseError("INVALID_LOCKFILE", `${path} has an invalid root package version.`);
 	if (isString$1(rootVersion)) assertCurrent(path, rootVersion, current);
-	data.version = version;
-	if (data.packages?.[""] !== void 0) data.packages[""].version = version;
-	const indent = /^\s+"/.exec(content)?.[0].length ?? 2;
-	return `${JSON.stringify(data, null, indent)}\n`;
+	const rootSpan = findJsonStringProperty(content, ["version"]);
+	if (rootSpan === void 0) throw new ReleaseError("MISSING_VERSION", `${path} has no root version.`);
+	let updated = replaceJsonStringProperty(content, rootSpan, version);
+	if (isString$1(rootVersion)) {
+		const packagesSpan = findJsonStringProperty(updated, [
+			"packages",
+			"",
+			"version"
+		]);
+		if (packagesSpan === void 0) throw new ReleaseError("MISSING_VERSION", `${path} has no packages[""].version string to update.`);
+		updated = replaceJsonStringProperty(updated, packagesSpan, version);
+	}
+	if (updated === content) throw new ReleaseError("VERSION_UNCHANGED", `${path} was not updated.`);
+	return updated;
 }
 function cargoSection(content) {
 	const start = content.search(/^\[package\]\s*$/m);
@@ -379,19 +756,35 @@ function isString(value) {
 }
 function gitLabContext(config) {
 	if (config?.enabled !== true) throw new ReleaseError("GITLAB_RELEASE_FAILED", "Enable gitlab before creating a release.");
-	const tokenEnv = config.tokenEnv ?? "GITLAB_TOKEN";
-	const token = process.env[tokenEnv];
-	const project = config.project ?? process.env.GITLAB_PROJECT;
-	if (token === void 0 || token.length === 0) throw new ReleaseError("GITLAB_RELEASE_FAILED", `Set ${tokenEnv} to create a GitLab release.`);
-	if (project === void 0 || project.length === 0) throw new ReleaseError("GITLAB_RELEASE_FAILED", "Set gitlab.project or GITLAB_PROJECT to create a GitLab release.");
+	const token = resolveGitLabToken(config.tokenEnv);
+	const project = resolveGitLabProject(config.project);
+	if (token === void 0) throw new ReleaseError("GITLAB_RELEASE_FAILED", `Set ${gitLabTokenEnvLabel(config.tokenEnv)} to create a GitLab release.`);
+	if (project === void 0) throw new ReleaseError("GITLAB_RELEASE_FAILED", "Set gitlab.project or GENBUMPPUSH_GITLAB_PROJECT (or GITLAB_PROJECT) to create a GitLab release.");
 	const context = {
-		host: config.host ?? process.env.GITLAB_HOST ?? "https://gitlab.com",
+		host: resolveGitLabHost(config.host),
 		project,
 		token
 	};
 	if (config.releaseName !== void 0) context.releaseName = config.releaseName;
 	return context;
 }
+function resolveGitHubContext(config, cwd) {
+	if (config?.enabled !== true) throw new ReleaseError("GITHUB_RELEASE_FAILED", "Enable github before creating a release.");
+	const token = resolveGitHubToken(config.tokenEnv);
+	if (token === void 0) throw new ReleaseError("GITHUB_RELEASE_FAILED", `Set ${githubTokenEnvLabel(config.tokenEnv)} to create a GitHub release.`);
+	return resolveGitHubRepo(cwd, {
+		host: config.host,
+		repo: config.repo
+	}).then(({ host, repo }) => {
+		const context = {
+			host,
+			repo,
+			token
+		};
+		if (config.releaseName !== void 0) context.releaseName = config.releaseName;
+		return context;
+	});
+}
 async function changelogText(cwd, config) {
 	if (config.changelog === false) return "";
 	const path = await resolveRepositoryPath(cwd, config.changelog === true ? "CHANGELOG.md" : config.changelog ?? "CHANGELOG.md");
@@ -407,6 +800,16 @@ async function publishGitLab(context, cwd, config, tag, version) {
 		description: releaseNotes(await changelogText(cwd, config), tag)
 	});
 }
+async function publishGitHub(context, cwd, config, tag, version) {
+	await createGitHubRelease({
+		host: context.host,
+		repo: context.repo,
+		token: context.token,
+		tag,
+		name: context.releaseName?.replaceAll("{{version}}", version) ?? tag,
+		description: releaseNotes(await changelogText(cwd, config), tag)
+	});
+}
 function filter(commits, config, exclude) {
 	return commits.filter((commit) => {
 		const type = config.types[commit.type.toLowerCase()];
@@ -446,6 +849,82 @@ function packageVersion(cwd) {
 	if (!isObject(data) || !("version" in data) || !isString(data.version)) throw new ReleaseError("INVALID_PACKAGE", "package.json must contain a version string.");
 	return data.version;
 }
+/**
+* Run a full release (or a dry run / provider retry) for one repository.
+*
+* Typical flow:
+* 1. Load config and `.env`
+* 2. Verify the worktree is a clean Git repo on a branch
+* 3. Detect (or force) a release type from Conventional Commits
+* 4. Confirm, run `before` hooks, update version files and the changelog
+* 5. Commit, tag, and atomically push branch + tag
+* 6. Optionally create a GitHub/GitLab release, then run `after` hooks
+*
+* Version-file or commit failures restore files and the index. A failed tag
+* or network push can leave the release commit locally so you can inspect
+* and retry — see the returned {@link ReleaseResult} and any thrown
+* {@link ReleaseError}.
+*
+* Prefer the `genbumppush` CLI for day-to-day use. Call this directly when
+* embedding releases in a Node script or CI job that already builds
+* {@link CliOptions}.
+*
+* @param options - Parsed CLI options. `cwd`, `dryRun`, `yes`, and `help` are required;
+*   the rest override config when set.
+* @returns A summary of what happened. Never mutates when `dryRun` is `true`.
+* @throws {@link ReleaseError} for expected failures (dirty worktree, existing tag,
+*   cancelled confirmation, Git/provider errors). Unexpected errors may also throw.
+*
+* @example Dry run in the current directory
+* ```ts
+* import { runRelease } from 'genbumppush';
+*
+* const result = await runRelease({
+*   cwd: process.cwd(),
+*   dryRun: true,
+*   yes: true,
+*   help: false,
+* });
+*
+* console.log(result);
+* // {
+* //   currentVersion: '1.2.3',
+* //   newVersion: '1.3.0',
+* //   releaseType: 'minor',
+* //   tag: 'v1.3.0',
+* //   pushed: false,
+* //   dryRun: true,
+* //   commitCount: 4
+* // }
+* ```
+*
+* @example Non-interactive patch release that stays local
+* ```ts
+* import { runRelease } from 'genbumppush';
+*
+* await runRelease({
+*   cwd: process.cwd(),
+*   dryRun: false,
+*   yes: true,
+*   help: false,
+*   release: 'patch',
+*   push: false,
+* });
+* ```
+*
+* @example Retry only the GitLab release after Git already succeeded
+* ```ts
+* import { runRelease } from 'genbumppush';
+*
+* await runRelease({
+*   cwd: process.cwd(),
+*   dryRun: false,
+*   yes: true,
+*   help: false,
+*   gitlabRetryTag: 'v1.3.0',
+* });
+* ```
+*/
 async function runRelease(options) {
 	const overrides = {};
 	if (options.release !== void 0) overrides.release = options.release;
@@ -469,6 +948,20 @@ async function runRelease(options) {
 			gitlabReleaseCreated: true
 		};
 	}
+	if (options.githubRetryTag !== void 0) {
+		const context = await resolveGitHubContext(config.github, cwd);
+		const remote = config.git?.remote ?? "origin";
+		if (!remoteTagExists(cwd, remote, options.githubRetryTag)) throw new ReleaseError("GITHUB_RELEASE_FAILED", `Tag ${options.githubRetryTag} does not exist on ${remote}.`);
+		await publishGitHub(context, cwd, config, options.githubRetryTag, currentVersion);
+		return {
+			currentVersion,
+			tag: options.githubRetryTag,
+			pushed: true,
+			dryRun: false,
+			commitCount: 0,
+			githubReleaseCreated: true
+		};
+	}
 	if (config.git?.requireClean !== false && git(["status", "--porcelain"], cwd) !== "") throw new ReleaseError("DIRTY_WORKTREE", "Commit or stash all changes before releasing.");
 	const branch = git(["branch", "--show-current"], cwd);
 	if (branch === "") throw new ReleaseError("DETACHED_HEAD", "Releases require a checked-out branch.");
@@ -489,11 +982,16 @@ async function runRelease(options) {
 	};
 	const releaseType = detected;
 	console.info(`Release: v${currentVersion} → ${releaseType} (${commits.length} commits)`);
+	const plannedVersion = bumpVersion(currentVersion, releaseType, config.preid);
+	const plannedTag = render(config.git?.tagName ?? "v{{version}}", plannedVersion);
 	if (options.dryRun) {
+		console.info(`Dry run: v${currentVersion} → v${plannedVersion} (${plannedTag})`);
 		console.info(await generateMarkDown(commits, changelog));
 		return {
 			currentVersion,
+			newVersion: plannedVersion,
 			releaseType,
+			tag: plannedTag,
 			pushed: false,
 			dryRun: true,
 			commitCount: commits.length
@@ -504,13 +1002,17 @@ async function runRelease(options) {
 		if (!push) throw new ReleaseError("GITLAB_RELEASE_FAILED", "GitLab release creation requires git.push to be enabled.");
 		gitlab = gitLabContext(config.gitlab);
 	}
+	let github;
+	if (config.github?.enabled === true) {
+		if (!push) throw new ReleaseError("GITHUB_RELEASE_FAILED", "GitHub release creation requires git.push to be enabled.");
+		github = await resolveGitHubContext(config.github, cwd);
+	}
 	if (!options.yes && !await confirm(`Create a ${releaseType} release?`)) throw new ReleaseError("CANCELLED", "Release cancelled.");
-	const plannedVersion = bumpVersion(currentVersion, releaseType, config.preid);
-	const tag = render(config.git?.tagName ?? "v{{version}}", plannedVersion);
+	const version = plannedVersion;
+	const tag = plannedTag;
 	const remote = config.git?.remote ?? "origin";
 	if (tagExists(cwd, tag) || push && remoteTagExists(cwd, remote, tag)) throw new ReleaseError("TAG_EXISTS", `Tag ${tag} already exists.`);
 	for (const command of list(config.hooks?.before)) runHook(command, cwd);
-	const version = plannedVersion;
 	const changes = await planVersionChanges(cwd, currentVersion, version, config);
 	const changed = changes.map((change) => change.path);
 	let changelogSnapshot;
@@ -565,6 +1067,13 @@ async function runRelease(options) {
 	} catch (error) {
 		throw new ReleaseError("RELEASE_PUBLISHED_GITLAB_FAILED", `Git release ${tag} was pushed, but GitLab release creation failed. Retry with: genbumppush --retry-gitlab ${tag}`, { cause: error });
 	}
+	let githubReleaseCreated = false;
+	if (github !== void 0) try {
+		await publishGitHub(github, cwd, config, tag, version);
+		githubReleaseCreated = true;
+	} catch (error) {
+		throw new ReleaseError("RELEASE_PUBLISHED_GITHUB_FAILED", `Git release ${tag} was pushed, but GitHub release creation failed. Retry with: genbumppush --retry-github ${tag}`, { cause: error });
+	}
 	for (const command of list(config.hooks?.after)) runHook(command, cwd);
 	const result = {
 		currentVersion,
@@ -576,6 +1085,7 @@ async function runRelease(options) {
 		commitCount: commits.length
 	};
 	if (gitlabReleaseCreated) result.gitlabReleaseCreated = true;
+	if (githubReleaseCreated) result.githubReleaseCreated = true;
 	return result;
 }
 //#endregion

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "genbumppush",
   "description": "Generate changelog, bump version, then push",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "type": "module",
   "sideEffects": false,
   "license": "MIT",