genbumppush 0.0.2 → 0.0.3

package/README.md

@@ -2,23 +2,15 @@
 
 [![CI](https://img.shields.io/github/actions/workflow/status/xcvzmoon/genbumppush/ci.yml?branch=main&color=black)](https://github.com/xcvzmoon/genbumppush/actions/workflows/ci.yml)
 [![Release](https://img.shields.io/github/actions/workflow/status/xcvzmoon/genbumppush/release.yml?color=black)](https://github.com/xcvzmoon/genbumppush/actions/workflows/release.yml)
-[![npm version](https://img.shields.io/npm/v/%40xcvzmoon%2Fgenbumppush?color=black)](https://www.npmjs.com/package/@xcvzmoon/genbumppush)
-[![npm downloads](https://img.shields.io/npm/dm/%40xcvzmoon%2Fgenbumppush?color=black)](https://www.npmjs.com/package/@xcvzmoon/genbumppush)
+[![npm version](https://img.shields.io/npm/v/genbumppush?color=black)](https://www.npmjs.com/package/genbumppush)
+[![npm downloads](https://img.shields.io/npm/dm/genbumppush?color=black)](https://www.npmjs.com/package/genbumppush)
 
 `genbumppush` handles the repetitive parts of releasing a Conventional Commit repository. It picks the next semantic version, updates the files you choose, writes the changelog, commits, tags, and can push the branch and tag together.
 
-It supports Node packages, Nuxt applications, fixed-version monorepos, Tauri applications, and tag-driven publication/deployment. It does not publish packages or create provider releases itself; GitHub Actions or GitLab CI should handle those after the tag is pushed.
-
-## Requirements and installation
-
-- Node.js 20.19+
-- Git
-- Conventional Commits
-- An upstream branch when pushing (unless `requireUpstream: false`)
+It supports Node packages, web applications (React, Vue, Solid, Svelte, Astro, Next, Nuxt, etc.), fixed-version monorepos, Tauri applications, and tag-driven publication/deployment. It does not publish packages or create provider releases itself; GitHub Actions or GitLab CI should handle those after the tag is pushed.
 
 ```bash
-pnpm add -D genbumppush
-# or: npm install --save-dev genbumppush
+npm install --save-dev genbumppush
 ```
 
 ```json
@@ -50,15 +42,15 @@ genbumppush [release] [options]
 | `prerelease` | `1.2.4-beta.0`      |
 
 ```bash
-pnpm release                         # detect from Conventional Commits
-pnpm release patch                   # force a release type
-pnpm release preminor --preid beta  # start a prerelease channel
-pnpm release prerelease --preid beta
-pnpm release --dry-run               # preview without mutation
-pnpm release patch --no-push         # local commit and tag only
-pnpm release patch --yes             # non-interactive
+npm run release                                             # detect from Conventional Commits
+npm run release patch                                       # force a release type
+npm run release preminor --preid beta                       # start a prerelease channel
+npm run release prerelease --preid beta
+npm run release --dry-run                                   # preview without mutation
+npm run release patch --no-push                             # local commit and tag only
+npm run release patch --yes                                 # non-interactive
 genbumppush --cwd ../app --config release.config.ts patch
-genbumppush --retry-gitlab v1.2.4  # retry provider release after a successful Git push
+genbumppush --retry-gitlab v1.2.4                           # retry provider release after a successful Git push
 ```
 
 | Option                 | Meaning                                                  |
@@ -68,6 +60,7 @@ genbumppush --retry-gitlab v1.2.4  # retry provider release after a successful G
 | `--config <path>`      | Explicit C12 config file                                 |
 | `--preid <id>`         | Identifier containing letters, numbers, and hyphens      |
 | `--retry-gitlab <tag>` | Retry GitLab release creation for an existing remote tag |
+| `--retry-github <tag>` | Retry GitHub release creation for an existing remote tag |
 | `--dry-run`            | Preview without changing files, Git, or remotes          |
 | `--no-push`            | Keep commit and tag local                                |
 | `--yes`, `-y`          | Skip confirmation                                        |
@@ -140,6 +133,12 @@ The same object can live under `"genbumppush"` in `package.json`. JavaScript and
 | `git.tagMessage`           | string                    | `v{{version}}`                 | Annotated tag template                 |
 | `hooks.before`             | string or string[]        | unset                          | Commands before file changes           |
 | `hooks.after`              | string or string[]        | unset                          | Commands after tag/push                |
+| `github.enabled`           | boolean                   | `false`                        | Create a GitHub release after push     |
+| `github.host`              | string                    | `github.com`                   | github.com or GHES host                |
+| `github.repo`              | string                    | `GITHUB_REPOSITORY` / remote   | `owner/name`                           |
+| `github.tokenEnv`          | string                    | `GITHUB_TOKEN`                 | Token environment variable             |
+| `github.releaseName`       | string                    | tag                            | Release title template                 |
+| `gitlab.enabled`           | boolean                   | `false`                        | Create a GitLab release after push     |
 
 `{{version}}` is replaced in commit and tag templates. Hooks run through the shell in the repository directory; only use trusted configuration.
 
@@ -205,13 +204,28 @@ A release commit message alone does not trigger tag workflows. The tag must exis
 git push origin main v0.0.1
 ```
 
-For npm trusted publishing, configure the npm package trusted publisher to match the repository/workflow, keep `id-token: write`, and use a current npm. The included workflow disables provenance for private GitHub source repositories because npm rejects private-source provenance bundles. Public repositories can enable provenance after trusted publishing is configured.
+For npm trusted publishing, configure the npm package trusted publisher to match the repository/workflow, keep `id-token: write`, and use a current npm. The included workflow enables provenance for public repositories. Private source repositories should set `NPM_CONFIG_PROVENANCE=false` because npm rejects private-source provenance bundles.
+
+## GitHub and GitLab releases
+
+GitHub Releases are supported as an opt-in provider after the Git branch and tag are pushed atomically. genbumppush uses the exact `git.tagName` string (so custom templates work) and creates or updates the release via the GitHub API (including GHES).
+
+```ts
+export default defineConfig({
+  git: { push: true },
+  github: {
+    enabled: true,
+    // host: 'github.com', // or a GHES host
+    // repo: 'group/project', // or GITHUB_REPOSITORY / package.json repository
+    tokenEnv: 'GITHUB_TOKEN', // also honors GH_TOKEN and CHANGELOGEN_TOKENS_GITHUB
+    releaseName: 'v{{version}}',
+  },
+});
+```
 
-## GitLab CI
+If GitHub release creation fails after the Git push succeeds, fix credentials and run `genbumppush --retry-github <tag>`.
 
-GitLab release creation is supported as an opt-in provider. The Git branch and tag are
-still pushed atomically first; only then does genbumppush call the GitLab Releases API.
-Configure a project path and provide an API token through the environment:
+GitLab release creation remains supported the same way. Configure a project path and provide an API token through the environment:
 
 ```ts
 export default defineConfig({
@@ -251,7 +265,7 @@ Keep artifact publication and GitLab release creation in protected, tag-triggere
 
 | Scenario               | Recommended setup                                  |
 | ---------------------- | -------------------------------------------------- |
-| Local release          | `pnpm release`, confirm interactively              |
+| Local release          | `npm run release`, confirm interactively           |
 | CI release             | `genbumppush --yes` with protected Git credentials |
 | Preview only           | `genbumppush --dry-run --yes`                      |
 | Local commit/tag only  | `genbumppush patch --no-push --yes`                |
@@ -284,7 +298,7 @@ Run `git status --short` and inspect an existing tag with `git show <tag>`. Comm
 
 ### Private-repository provenance failure
 
-npm rejects provenance bundles identifying private GitHub source repositories. Use the included workflow’s `NPM_CONFIG_PROVENANCE=false` behavior, or make the source public and enable provenance after trusted publishing setup.
+npm rejects provenance bundles identifying private GitHub source repositories. Set `NPM_CONFIG_PROVENANCE=false` in the publish workflow, or make the source public and keep provenance enabled.
 
 ### Workflow did not run
 

package/dist/bin.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { n as ReleaseError, t as runRelease } from "./release-cb3ZULZM.mjs";
+import { n as ReleaseError, t as runRelease } from "./release-CVQ5WSKG.mjs";
 import { resolve } from "node:path";
 //#region src/types.ts
 const RELEASE_TYPES = [
@@ -13,7 +13,7 @@ const RELEASE_TYPES = [
 ];
 //#endregion
 //#region src/cli.ts
-const HELP_TEXT = `Usage: genbumppush [release] [options]\n\nGenerate a changelog, bump versions, create an annotated tag, and push atomically.\n\nArguments:\n  release             ${RELEASE_TYPES.join(" | ")}\n\nOptions:\n  --cwd <path>        Repository directory\n  --config <path>     Explicit C12 config file\n  --preid <id>        Prerelease identifier\n  --retry-gitlab <tag> Retry GitLab release creation for a pushed tag\n  --dry-run           Preview without changes\n  --no-push           Keep commit and tag local\n  --yes, -y           Skip confirmation\n  --help, -h          Show help\n`;
+const HELP_TEXT = `Usage: genbumppush [release] [options]\n\nGenerate a changelog, bump versions, create an annotated tag, and push atomically.\n\nArguments:\n  release             ${RELEASE_TYPES.join(" | ")}\n\nOptions:\n  --cwd <path>        Repository directory\n  --config <path>     Explicit C12 config file\n  --preid <id>        Prerelease identifier\n  --retry-gitlab <tag> Retry GitLab release creation for a pushed tag\n  --retry-github <tag> Retry GitHub release creation for a pushed tag\n  --dry-run           Preview without changes\n  --no-push           Keep commit and tag local\n  --yes, -y           Skip confirmation\n  --help, -h          Show help\n`;
 function isType(value) {
 	return RELEASE_TYPES.some((item) => item === value);
 }
@@ -71,6 +71,10 @@ function parseCliOptions(args) {
 				result.gitlabRetryTag = inlineValue ?? next(args, index, "--retry-gitlab");
 				if (inlineValue === void 0) index += 1;
 				break;
+			case "--retry-github":
+				result.githubRetryTag = inlineValue ?? next(args, index, "--retry-github");
+				if (inlineValue === void 0) index += 1;
+				break;
 			default:
 				if (isType(arg) && result.release === void 0) {
 					result.release = arg;
@@ -80,6 +84,8 @@ function parseCliOptions(args) {
 		}
 	}
 	if (result.gitlabRetryTag !== void 0 && result.release !== void 0) throw new ReleaseError("CONFLICTING_ARGUMENTS", "--retry-gitlab cannot be combined with a release type.");
+	if (result.githubRetryTag !== void 0 && result.release !== void 0) throw new ReleaseError("CONFLICTING_ARGUMENTS", "--retry-github cannot be combined with a release type.");
+	if (result.gitlabRetryTag !== void 0 && result.githubRetryTag !== void 0) throw new ReleaseError("CONFLICTING_ARGUMENTS", "--retry-gitlab and --retry-github cannot be combined.");
 	return result;
 }
 //#endregion
@@ -89,8 +95,10 @@ try {
 	if (options.help) console.info(HELP_TEXT);
 	else {
 		const result = await runRelease(options);
-		if (result.gitlabReleaseCreated) console.info(`GitLab release ${result.tag ?? ""} created.`);
+		if (result.githubReleaseCreated) console.info(`GitHub release ${result.tag ?? ""} created.`);
+		else if (result.gitlabReleaseCreated) console.info(`GitLab release ${result.tag ?? ""} created.`);
 		else if (result.releaseType === void 0) console.info("No releasable commits found.");
+		else if (result.dryRun) console.info(`Dry run: would create ${result.tag ?? result.releaseType} from ${result.currentVersion}${result.newVersion !== void 0 ? ` to v${result.newVersion}` : ""}.`);
 		else if (!result.dryRun) console.info(`${result.tag ?? result.releaseType} created${result.pushed ? " and pushed" : ""}.`);
 	}
 } catch (error) {

package/dist/index.d.mts

@@ -22,6 +22,13 @@ type GitLabOptions = {
   tokenEnv?: string;
   releaseName?: string;
 };
+type GitHubOptions = {
+  enabled?: boolean;
+  host?: string;
+  repo?: string;
+  tokenEnv?: string;
+  releaseName?: string;
+};
 type GenBumpPushConfig = {
   release?: ReleaseType;
   preid?: string;
@@ -31,12 +38,14 @@ type GenBumpPushConfig = {
   excludeDependencyCommits?: boolean;
   git?: GitOptions;
   gitlab?: GitLabOptions;
+  github?: GitHubOptions;
   hooks?: HookOptions;
 };
 type CliOptions = {
   cwd: string;
   configFile?: string;
   gitlabRetryTag?: string;
+  githubRetryTag?: string;
   release?: ReleaseType;
   preid?: string;
   dryRun: boolean;
@@ -53,6 +62,7 @@ type ReleaseResult = {
   dryRun: boolean;
   commitCount: number;
   gitlabReleaseCreated?: boolean;
+  githubReleaseCreated?: boolean;
 };
 //#endregion
 //#region src/config.d.ts
@@ -68,4 +78,4 @@ export declare class ReleaseError extends Error {
 //#region src/release.d.ts
 export declare function runRelease(options: CliOptions): Promise<ReleaseResult>;
 //#endregion
-export type { CliOptions, GenBumpPushConfig, GitLabOptions, GitOptions, HookOptions, ReleaseResult, ReleaseType };
+export type { CliOptions, GenBumpPushConfig, GitHubOptions, GitLabOptions, GitOptions, HookOptions, ReleaseResult, ReleaseType };

package/dist/index.mjs

@@ -1,2 +1,2 @@
-import { i as loadReleaseConfig, n as ReleaseError, r as defineConfig, t as runRelease } from "./release-cb3ZULZM.mjs";
+import { i as loadReleaseConfig, n as ReleaseError, r as defineConfig, t as runRelease } from "./release-CVQ5WSKG.mjs";
 export { ReleaseError, defineConfig, loadReleaseConfig, runRelease };

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

@@ -1,5 +1,5 @@
 import { createDefineConfig, loadConfig } from "c12";
-import { determineSemverChange, generateMarkDown, getGitDiff, loadChangelogConfig, parseCommits } from "changelogen";
+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";
@@ -73,7 +73,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 +81,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,6 +101,105 @@ function runHook(command, cwd) {
 	}).status !== 0) throw new ReleaseError("HOOK_FAILED", `Hook failed: ${command}`);
 }
 //#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("/");
+}
+function resolveGitHubToken(tokenEnv) {
+	if (tokenEnv !== void 0) {
+		const token = process.env[tokenEnv];
+		return token !== void 0 && token.length > 0 ? token : void 0;
+	}
+	for (const name of [
+		"GITHUB_TOKEN",
+		"GH_TOKEN",
+		"CHANGELOGEN_TOKENS_GITHUB"
+	]) {
+		const token = process.env[name];
+		if (token !== void 0 && token.length > 0) return token;
+	}
+}
+async function resolveGitHubRepo(cwd, source) {
+	const host = normalizeHost(source.host ?? process.env.GITHUB_API_URL ?? "github.com");
+	const explicit = source.repo ?? process.env.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 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
 function releaseNotes(changelog, tag) {
 	const lines = changelog.split("\n");
@@ -112,12 +213,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 +287,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 +432,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);
@@ -392,6 +633,23 @@ function gitLabContext(config) {
 	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 ${config.tokenEnv ?? "GITHUB_TOKEN"} 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 +665,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()];
@@ -469,6 +737,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 +771,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 +791,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 +856,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 +874,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.3",
   "type": "module",
   "sideEffects": false,
   "license": "MIT",