genbumppush 0.0.1 → 0.0.2

package/README.md

@@ -1,23 +1,311 @@
-# vite-plus-starter
+# genbumppush
 
-A starter for creating a Vite Plus project.
+[![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)
 
-## Development
+`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
 
-- Install dependencies:
+- Node.js 20.19+
+- Git
+- Conventional Commits
+- An upstream branch when pushing (unless `requireUpstream: false`)
 
 ```bash
-vp install
+pnpm add -D genbumppush
+# or: npm install --save-dev genbumppush
+```
+
+```json
+{ "scripts": { "release": "genbumppush" } }
+```
+
+The package exports `defineConfig`, `loadReleaseConfig`, `runRelease`, and release types. The `genbumppush` binary is also available directly.
+
+## Release lifecycle
+
+The command loads C12 configuration, validates the Git worktree, detects the release type, and previews or confirms the release. It then calculates the version, checks local/remote tag collisions, runs `before` hooks, validates every version file, writes versions and the changelog, commits, tags, atomically pushes, and runs `after` hooks.
+
+Version-file and commit-preparation failures restore files and the index. A failed tag or network push leaves the release commit locally for inspection and retry. If no releasable commit exists, it exits successfully without mutation.
+
+## CLI
+
+```text
+genbumppush [release] [options]
 ```
 
-- Run the unit tests:
+| Type         | Result from `1.2.3` |
+| ------------ | ------------------- |
+| `major`      | `2.0.0`             |
+| `minor`      | `1.3.0`             |
+| `patch`      | `1.2.4`             |
+| `premajor`   | `2.0.0-beta.0`      |
+| `preminor`   | `1.3.0-beta.0`      |
+| `prepatch`   | `1.2.4-beta.0`      |
+| `prerelease` | `1.2.4-beta.0`      |
 
 ```bash
-vp test
+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
+genbumppush --cwd ../app --config release.config.ts patch
+genbumppush --retry-gitlab v1.2.4  # retry provider release after a successful Git push
+```
+
+| Option                 | Meaning                                                  |
+| ---------------------- | -------------------------------------------------------- |
+| positional release     | One supported release type                               |
+| `--cwd <path>`         | Repository directory; defaults to the current directory  |
+| `--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 |
+| `--dry-run`            | Preview without changing files, Git, or remotes          |
+| `--no-push`            | Keep commit and tag local                                |
+| `--yes`, `-y`          | Skip confirmation                                        |
+| `--help`, `-h`         | Print help                                               |
+
+Values are resolved in this order: CLI, config file, the `genbumppush` key in `package.json`, then defaults. A CLI flag such as `--no-push` overrides the config file.
+
+## Commit detection
+
+Automatic detection uses `changelogen`:
+
+```text
+feat: add an adapter       -> minor
+fix: handle empty input    -> patch
+feat!: remove old API      -> major
+refactor(api)!: change API -> major
+chore(deps): update vite   -> excluded by default
+```
+
+`BREAKING CHANGE:` footers are supported. Set `release` to force a type. Non-breaking `chore(deps)` commits are excluded by default; set `excludeDependencyCommits: false` to include them.
+
+## Configuration
+
+Create `genbumppush.config.ts`:
+
+```ts
+import { defineConfig } from 'genbumppush';
+
+export default defineConfig({
+  // release: 'patch', // omit for automatic detection
+  preid: 'beta',
+  changelog: 'CHANGELOG.md',
+  excludeDependencyCommits: true,
+  recursive: false,
+  files: ['package.json'],
+  git: {
+    remote: 'origin',
+    push: true,
+    sign: false,
+    requireClean: true,
+    requireUpstream: true,
+    commitMessage: 'chore(release): v{{version}}',
+    tagName: 'v{{version}}',
+    tagMessage: 'v{{version}}',
+  },
+  hooks: {
+    before: ['vp check', 'vp test'],
+    after: 'echo Release complete',
+  },
+});
+```
+
+The same object can live under `"genbumppush"` in `package.json`. JavaScript and TypeScript C12 files are supported; use `--config` for another location.
+
+| Key                        | Type                      | Default                        | Behavior                               |
+| -------------------------- | ------------------------- | ------------------------------ | -------------------------------------- |
+| `release`                  | release type              | detected                       | Force release type                     |
+| `preid`                    | string                    | `beta`                         | Prerelease channel                     |
+| `changelog`                | `false \| true \| string` | `CHANGELOG.md`                 | Disable, default, or custom path       |
+| `excludeDependencyCommits` | boolean                   | `true`                         | Ignore non-breaking dependency commits |
+| `files`                    | string[]                  | `['package.json']`             | Version files                          |
+| `recursive`                | boolean                   | `false`                        | Discover nested manifests              |
+| `git.remote`               | string                    | `origin`                       | Remote for checks and push             |
+| `git.push`                 | boolean                   | `true`                         | Push branch and tag                    |
+| `git.sign`                 | boolean                   | `false`                        | Sign commit and tag                    |
+| `git.requireClean`         | boolean                   | `true`                         | Reject uncommitted changes             |
+| `git.requireUpstream`      | boolean                   | `true`                         | Require upstream before pushing        |
+| `git.commitMessage`        | string                    | `chore(release): v{{version}}` | Commit template                        |
+| `git.tagName`              | string                    | `v{{version}}`                 | Tag template                           |
+| `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                |
+
+`{{version}}` is replaced in commit and tag templates. Hooks run through the shell in the repository directory; only use trusted configuration.
+
+## Version-file adapters
+
+Every configured file is validated before writes begin. Structured files must agree with the root version; mismatches fail without partial updates.
+
+Supported adapters:
+
+- `package.json`: top-level `version`
+- `package-lock.json`: root `version` and `packages['']` version
+- Explicit JSON such as `tauri.conf.json`: top-level `version`
+- `Cargo.toml`: `version` in `[package]`
+- `Cargo.lock`: only the package matching the adjacent Cargo manifest
+
+Other files use exact text replacement: the current version must occur exactly once. This suits a `VERSION` file, but not arbitrary lockfiles. There is no general pnpm-lock.yaml adapter; configure it only when the current version occurs exactly once.
+
+### Fixed-version monorepo
+
+```ts
+export default defineConfig({
+  recursive: true,
+  files: ['package.json', 'package-lock.json'],
+});
 ```
 
-- Build the library:
+Discovery ignores `.git`, `node_modules`, `dist`, `target`, and `.output`. It assumes versioned workspaces share one version; independent-version packages need a separate strategy.
+
+### Tauri
+
+```ts
+export default defineConfig({
+  files: [
+    'package.json',
+    'src-tauri/tauri.conf.json',
+    'src-tauri/Cargo.toml',
+    'src-tauri/Cargo.lock',
+  ],
+});
+```
+
+Cargo dependency versions are not changed. Only the application package and matching lock entry are updated.
+
+## Git safety and recovery
+
+Defaults reject dirty worktrees, detached HEAD, missing upstreams, and existing local or remote tags. Branch and tag are sent with `git push --atomic`.
+
+Use `--no-push` for a local rehearsal. If a push fails after commit/tag creation, inspect `git status`, `git log`, and `git show`, then retry the push or remove local artifacts deliberately. If GitLab release creation fails after the Git push succeeds, fix the provider or credentials and run `genbumppush --retry-gitlab <tag>`.
+
+For deliberate exceptions, set `git.requireClean: false` or `git.requireUpstream: false`. These do not disable tag collision checks or version validation.
+
+## GitHub Actions and npm
+
+The included workflows split CI, release creation, and package publication into separate jobs:
+
+- `ci.yml` runs `vp check`, `vp test`, and `vp pack` on pull requests and main pushes.
+- `release.yml` reacts to `v*` tags and creates a GitHub Release from the changelog section.
+- `publish.yml` reacts to `v*` tags, verifies `v${package.json.version}`, rebuilds, and publishes.
+
+A release commit message alone does not trigger tag workflows. The tag must exist and be pushed:
+
+```bash
+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.
+
+## GitLab CI
+
+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:
+
+```ts
+export default defineConfig({
+  git: { push: true },
+  gitlab: {
+    enabled: true,
+    host: 'https://gitlab.com',
+    project: 'group/project',
+    tokenEnv: 'GITLAB_TOKEN',
+    releaseName: 'v{{version}}',
+  },
+});
+```
+
+`GITLAB_HOST` and `GITLAB_PROJECT` may be used as environment fallbacks. The token
+must be available as the configured `tokenEnv` (default `GITLAB_TOKEN`). GitLab receives
+the matching `CHANGELOG.md` section as the release description. If `git.push` is false,
+the provider is rejected because GitLab cannot create a release for an unpublished tag.
+
+```yaml
+release:
+  image: node:20
+  rules:
+    - if: '$CI_COMMIT_TAG =~ /^v/'
+  script:
+    - npm ci
+    - npx genbumppush --dry-run --yes
+    - npm run build
+  release:
+    tag_name: '$CI_COMMIT_TAG'
+    name: 'Release $CI_COMMIT_TAG'
+```
+
+Keep artifact publication and GitLab release creation in protected, tag-triggered jobs with their own credentials.
+
+## Scenario guide
+
+| Scenario               | Recommended setup                                  |
+| ---------------------- | -------------------------------------------------- |
+| Local release          | `pnpm 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`                |
+| Nuxt or Node package   | Default `package.json` adapter                     |
+| npm lockfile           | Add `package-lock.json` explicitly                 |
+| Fixed-version monorepo | `recursive: true`                                  |
+| Tauri                  | Explicit JSON, Cargo.toml, and Cargo.lock files    |
+| Custom VERSION file    | Add only if the old version occurs once            |
+| GitHub/npm publication | Push `v*`; let workflows publish                   |
+| GitLab release         | Run downstream jobs on `$CI_COMMIT_TAG`            |
+
+## Troubleshooting
+
+### Tag does not match package version
 
 ```bash
+node -p "require('./package.json').version"
+git describe --tags --exact-match HEAD
+```
+
+The publisher requires `v${package.json.version}`. Correct the release commit before creating or pushing a replacement tag.
+
+### Dirty worktree, existing tag, or version mismatch
+
+Run `git status --short` and inspect an existing tag with `git show <tag>`. Commit/stash changes, align every configured manifest with the root version, and never overwrite a published tag as a normal retry.
+
+### `EBADDEVENGINES`
+
+`devEngines.packageManager` is npm metadata. Run with the declared package manager or align the metadata with the manager used by CI; it is separate from release logic.
+
+### 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.
+
+### Workflow did not run
+
+Verify the tag was pushed, matches `v*`, and the workflow exists on the pushed commit:
+
+```bash
+git ls-remote --tags origin
+gh run list --workflow release.yml
+```
+
+## Development
+
+```bash
+vp install
+vp check
+vp test
 vp pack
 ```
+
+The test suite covers CLI parsing, C12 configuration, SemVer edges, JSON/npm/Cargo adapters, recursive workspaces, dry runs, rollback, hooks, tag collisions, detached HEAD, upstream checks, and a real atomic push to a temporary bare Git remote.
+
+## License
+
+MIT

package/dist/bin.d.mts

@@ -0,0 +1 @@
+export {}

package/dist/bin.mjs

@@ -0,0 +1,102 @@
+#!/usr/bin/env node
+import { n as ReleaseError, t as runRelease } from "./release-cb3ZULZM.mjs";
+import { resolve } from "node:path";
+//#region src/types.ts
+const RELEASE_TYPES = [
+	"major",
+	"premajor",
+	"minor",
+	"preminor",
+	"patch",
+	"prepatch",
+	"prerelease"
+];
+//#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`;
+function isType(value) {
+	return RELEASE_TYPES.some((item) => item === value);
+}
+function next(args, index, option) {
+	const value = args[index + 1];
+	if (value === void 0 || value.startsWith("-")) throw new ReleaseError("MISSING_OPTION_VALUE", `${option} requires a value.`);
+	return value;
+}
+function parseCliOptions(args) {
+	const result = {
+		cwd: process.cwd(),
+		dryRun: false,
+		yes: false,
+		help: false
+	};
+	for (let index = 0; index < args.length; index += 1) {
+		const arg = args[index];
+		if (arg === void 0) continue;
+		const equals = arg.indexOf("=");
+		const option = equals < 0 ? arg : arg.slice(0, equals);
+		const inlineValue = equals < 0 ? void 0 : arg.slice(equals + 1);
+		switch (option) {
+			case "--dry-run":
+				result.dryRun = true;
+				break;
+			case "--no-push":
+				result.push = false;
+				break;
+			case "--yes":
+			case "-y":
+				result.yes = true;
+				break;
+			case "--help":
+			case "-h":
+				result.help = true;
+				break;
+			case "--cwd": {
+				const value = inlineValue ?? next(args, index, "--cwd");
+				result.cwd = resolve(value);
+				if (inlineValue === void 0) index += 1;
+				break;
+			}
+			case "--config":
+				result.configFile = inlineValue ?? next(args, index, "--config");
+				if (inlineValue === void 0) index += 1;
+				break;
+			case "--preid": {
+				const value = inlineValue ?? next(args, index, "--preid");
+				if (!/^[0-9A-Za-z-]+$/.test(value)) throw new ReleaseError("INVALID_PREID", "--preid accepts letters, numbers, and hyphens.");
+				result.preid = value;
+				if (inlineValue === void 0) index += 1;
+				break;
+			}
+			case "--retry-gitlab":
+				result.gitlabRetryTag = inlineValue ?? next(args, index, "--retry-gitlab");
+				if (inlineValue === void 0) index += 1;
+				break;
+			default:
+				if (isType(arg) && result.release === void 0) {
+					result.release = arg;
+					break;
+				}
+				throw new ReleaseError("UNKNOWN_ARGUMENT", `Unknown argument: ${arg}`);
+		}
+	}
+	if (result.gitlabRetryTag !== void 0 && result.release !== void 0) throw new ReleaseError("CONFLICTING_ARGUMENTS", "--retry-gitlab cannot be combined with a release type.");
+	return result;
+}
+//#endregion
+//#region src/bin.ts
+try {
+	const options = parseCliOptions(process.argv.slice(2));
+	if (options.help) console.info(HELP_TEXT);
+	else {
+		const result = await runRelease(options);
+		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(`${result.tag ?? result.releaseType} created${result.pushed ? " and pushed" : ""}.`);
+	}
+} catch (error) {
+	if (error instanceof ReleaseError) console.error(`[${error.code}] ${error.message}`);
+	else console.error(error instanceof Error ? error.message : error);
+	process.exitCode = 1;
+}
+//#endregion
+export {};

package/dist/index.d.mts

@@ -1,3 +1,71 @@
-//#region src/index.d.ts
-export declare function fn(): string;
-//#endregion
+//#region src/types.d.ts
+declare const RELEASE_TYPES: readonly ["major", "premajor", "minor", "preminor", "patch", "prepatch", "prerelease"];
+type ReleaseType = (typeof RELEASE_TYPES)[number];
+type GitOptions = {
+  remote?: string;
+  push?: boolean;
+  sign?: boolean;
+  requireClean?: boolean;
+  requireUpstream?: boolean;
+  commitMessage?: string;
+  tagName?: string;
+  tagMessage?: string;
+};
+type HookOptions = {
+  before?: string | string[];
+  after?: string | string[];
+};
+type GitLabOptions = {
+  enabled?: boolean;
+  host?: string;
+  project?: string;
+  tokenEnv?: string;
+  releaseName?: string;
+};
+type GenBumpPushConfig = {
+  release?: ReleaseType;
+  preid?: string;
+  files?: string[];
+  recursive?: boolean;
+  changelog?: boolean | string;
+  excludeDependencyCommits?: boolean;
+  git?: GitOptions;
+  gitlab?: GitLabOptions;
+  hooks?: HookOptions;
+};
+type CliOptions = {
+  cwd: string;
+  configFile?: string;
+  gitlabRetryTag?: string;
+  release?: ReleaseType;
+  preid?: string;
+  dryRun: boolean;
+  push?: boolean;
+  yes: boolean;
+  help: boolean;
+};
+type ReleaseResult = {
+  currentVersion: string;
+  newVersion?: string;
+  releaseType?: ReleaseType;
+  tag?: string;
+  pushed: boolean;
+  dryRun: boolean;
+  commitCount: number;
+  gitlabReleaseCreated?: boolean;
+};
+//#endregion
+//#region src/config.d.ts
+export declare const defineConfig: import("c12").DefineConfig<GenBumpPushConfig, import("c12").ConfigLayerMeta>;
+export declare function loadReleaseConfig(cwd: string, configFile?: string, overrides?: GenBumpPushConfig): Promise<GenBumpPushConfig>;
+//#endregion
+//#region src/error.d.ts
+export declare class ReleaseError extends Error {
+  readonly code: string;
+  constructor(code: string, message: string, options?: ErrorOptions);
+}
+//#endregion
+//#region src/release.d.ts
+export declare function runRelease(options: CliOptions): Promise<ReleaseResult>;
+//#endregion
+export type { CliOptions, GenBumpPushConfig, GitLabOptions, GitOptions, HookOptions, ReleaseResult, ReleaseType };

package/dist/index.mjs

@@ -1,6 +1,2 @@
-//#region src/index.ts
-function fn() {
-	return "Hello, tsdown!";
-}
-//#endregion
-export { fn };
+import { i as loadReleaseConfig, n as ReleaseError, r as defineConfig, t as runRelease } from "./release-cb3ZULZM.mjs";
+export { ReleaseError, defineConfig, loadReleaseConfig, runRelease };

package/dist/release-cb3ZULZM.mjs

@@ -0,0 +1,582 @@
+import { createDefineConfig, loadConfig } from "c12";
+import { determineSemverChange, generateMarkDown, getGitDiff, loadChangelogConfig, parseCommits } 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
+const defineConfig = createDefineConfig();
+const defaults = {
+	changelog: "CHANGELOG.md",
+	excludeDependencyCommits: true,
+	recursive: false,
+	git: {
+		remote: "origin",
+		push: true,
+		sign: false,
+		requireClean: true,
+		requireUpstream: true,
+		commitMessage: "chore(release): v{{version}}",
+		tagName: "v{{version}}",
+		tagMessage: "v{{version}}"
+	}
+};
+async function loadReleaseConfig(cwd, configFile, overrides) {
+	return (await loadConfig({
+		name: "genbumppush",
+		cwd,
+		configFile,
+		packageJson: "genbumppush",
+		defaults,
+		overrides,
+		rcFile: false,
+		globalRc: false
+	})).config;
+}
+//#endregion
+//#region src/error.ts
+var ReleaseError = class extends Error {
+	code;
+	constructor(code, message, options) {
+		super(message, options);
+		this.name = "ReleaseError";
+		this.code = code;
+	}
+};
+//#endregion
+//#region src/git.ts
+function git(args, cwd) {
+	try {
+		return execFileSync("git", args, {
+			cwd,
+			encoding: "utf8",
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		}).trim();
+	} catch (error) {
+		throw new ReleaseError("GIT_COMMAND_FAILED", `git ${args.join(" ")} failed.`, { cause: error });
+	}
+}
+function tagExists(cwd, tag) {
+	return spawnSync("git", [
+		"rev-parse",
+		"--verify",
+		"--quiet",
+		`refs/tags/${tag}`
+	], {
+		cwd,
+		stdio: "ignore"
+	}).status === 0;
+}
+function isGitRepository(cwd) {
+	return spawnSync("git", ["rev-parse", "--is-inside-work-tree"], {
+		cwd,
+		encoding: "utf8",
+		stdio: [
+			"ignore",
+			"pipe",
+			"ignore"
+		]
+	}).stdout.trim() === "true";
+}
+function remoteTagExists(cwd, remote, tag) {
+	return git([
+		"ls-remote",
+		"--tags",
+		remote,
+		`refs/tags/${tag}`
+	], cwd).length > 0;
+}
+function runHook(command, cwd) {
+	if (spawnSync(command, {
+		cwd,
+		shell: true,
+		stdio: "inherit"
+	}).status !== 0) throw new ReleaseError("HOOK_FAILED", `Hook failed: ${command}`);
+}
+//#endregion
+//#region src/gitlab.ts
+function releaseNotes(changelog, tag) {
+	const lines = changelog.split("\n");
+	const heading = `## ${tag}`;
+	const start = lines.findIndex((line) => line === heading || line.startsWith(`${heading} `));
+	if (start < 0) return "See CHANGELOG.md for release notes.";
+	const notes = [];
+	for (const line of lines.slice(start + 1)) {
+		if (line.startsWith("## ")) break;
+		notes.push(line);
+	}
+	return notes.join("\n").trim() || "See CHANGELOG.md for release notes.";
+}
+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",
+			headers: {
+				Authorization: `Bearer ${options.token}`,
+				"Content-Type": "application/json"
+			},
+			body: JSON.stringify({
+				tag_name: options.tag,
+				name: options.name,
+				description: options.description
+			})
+		});
+	} catch (error) {
+		throw new ReleaseError("GITLAB_RELEASE_FAILED", "Could not send the GitLab release request.", { cause: error });
+	}
+	if (!response.ok) {
+		const body = await response.text().catch(() => "");
+		throw new ReleaseError("GITLAB_RELEASE_FAILED", `GitLab release creation failed with ${response.status}: ${body || response.statusText}`);
+	}
+}
+//#endregion
+//#region src/version-files.ts
+const IGNORED_DIRECTORIES = /* @__PURE__ */ new Set([
+	".git",
+	"node_modules",
+	"dist",
+	"target",
+	".output"
+]);
+function isObject$1(value) {
+	return value !== null && Object(value) === value && !Array.isArray(value);
+}
+function isString$1(value) {
+	return Object.prototype.toString.call(value) === "[object String]";
+}
+function isPackageManifest(value) {
+	return isObject$1(value) && (!("version" in value) || value.version === void 0 || isString$1(value.version));
+}
+function isPackageMap(value) {
+	if (!isObject$1(value)) return false;
+	const root = "" in value ? value[""] : void 0;
+	return root === void 0 || isPackageManifest(root);
+}
+function isPackageLock(value) {
+	return isPackageManifest(value) && (!("packages" in value) || value.packages === void 0 || isPackageMap(value.packages));
+}
+function isInside(root, path) {
+	const fromRoot = relative(root, path);
+	return fromRoot === "" || !fromRoot.startsWith("..") && !isAbsolute(fromRoot);
+}
+async function resolveRepositoryPath(cwd, configuredPath) {
+	const root = resolve(cwd);
+	const canonicalRoot = await realpath(root);
+	const path = resolve(root, configuredPath);
+	if (!isInside(root, path)) throw new ReleaseError("PATH_OUTSIDE_REPOSITORY", `${path} is outside the repository.`);
+	if (!isInside(canonicalRoot, existsSync(path) ? await realpath(path) : await realpath(dirname(path)))) throw new ReleaseError("PATH_OUTSIDE_REPOSITORY", `${path} resolves outside the repository.`);
+	return path;
+}
+async function findManifests(directory) {
+	const entries = await readdir(directory, { withFileTypes: true });
+	return (await Promise.all(entries.map(async (entry) => {
+		if (entry.isDirectory() && !IGNORED_DIRECTORIES.has(entry.name)) return findManifests(join(directory, entry.name));
+		return entry.name === "package.json" ? [join(directory, entry.name)] : [];
+	}))).flat();
+}
+function assertCurrent(path, actual, expected) {
+	if (actual !== expected) throw new ReleaseError("VERSION_MISMATCH", `${path} has version ${actual}; expected ${expected}.`);
+}
+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`);
+	if (updated === content) throw new ReleaseError("VERSION_UNCHANGED", `${path} was not updated.`);
+	return updated;
+}
+function replacePackageLockVersion(content, path, current, version) {
+	const parsed = JSON.parse(content);
+	if (!isPackageLock(parsed)) throw new ReleaseError("INVALID_LOCKFILE", `${path} is invalid.`);
+	const data = parsed;
+	if (!isString$1(data.version)) throw new ReleaseError("MISSING_VERSION", `${path} has no root version.`);
+	assertCurrent(path, data.version, current);
+	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`;
+}
+function cargoSection(content) {
+	const start = content.search(/^\[package\]\s*$/m);
+	if (start < 0) throw new ReleaseError("MISSING_CARGO_PACKAGE", "Cargo.toml has no [package] section.");
+	const next = content.slice(start + 1).search(/^\[[^[]/m);
+	return {
+		start,
+		end: next < 0 ? content.length : start + 1 + next
+	};
+}
+function cargoName(content) {
+	const section = cargoSection(content);
+	const match = /^name\s*=\s*"([^"]+)"/m.exec(content.slice(section.start, section.end));
+	if (match?.[1] === void 0) throw new ReleaseError("MISSING_CARGO_NAME", "Cargo.toml has no package name.");
+	return match[1];
+}
+function replaceCargoVersion(content, path, current, version) {
+	const section = cargoSection(content);
+	const body = content.slice(section.start, section.end);
+	const match = /^version\s*=\s*"([^"]*)"/m.exec(body);
+	if (match?.[1] === void 0) throw new ReleaseError("MISSING_CARGO_VERSION", "Cargo.toml has no package version.");
+	assertCurrent(path, match[1], current);
+	const updated = body.replace(/(^version\s*=\s*")[^"]*(")/m, `$1${version}$2`);
+	if (updated === body) throw new ReleaseError("MISSING_CARGO_VERSION", "Cargo.toml has no package version.");
+	return `${content.slice(0, section.start)}${updated}${content.slice(section.end)}`;
+}
+function replaceCargoLockVersion(content, path, name, current, version) {
+	const escaped = name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	const blocks = content.split(/(?=^\[\[package\]\]\s*$)/m);
+	let matches = 0;
+	const updated = blocks.map((block) => {
+		if (!new RegExp(`^name\\s*=\\s*"${escaped}"\\s*$`, "m").test(block)) return block;
+		matches += 1;
+		const match = /^version\s*=\s*"([^"]*)"\s*$/m.exec(block);
+		if (match?.[1] === void 0) throw new ReleaseError("MISSING_CARGO_LOCK_VERSION", `${path} package ${name} has no version.`);
+		assertCurrent(path, match[1], current);
+		return block.replace(/(^version\s*=\s*")[^"]*(")/m, `$1${version}$2`);
+	}).join("");
+	if (matches === 0) throw new ReleaseError("MISSING_CARGO_LOCK_PACKAGE", `Cargo.lock has no package named ${name}.`);
+	if (matches > 1) throw new ReleaseError("AMBIGUOUS_CARGO_LOCK_PACKAGE", `${path} contains package ${name} more than once.`);
+	return updated;
+}
+async function transform(path, current, version) {
+	const content = await readFile(path, "utf8");
+	const name = basename(path);
+	if (name === "package-lock.json") return replacePackageLockVersion(content, path, current, version);
+	if (name === "package.json" || name === "tauri.conf.json" || name.endsWith(".json")) return replaceJsonVersion(content, path, current, version);
+	if (name === "Cargo.toml") return replaceCargoVersion(content, path, current, version);
+	if (name === "Cargo.lock") {
+		const manifestPath = join(dirname(path), "Cargo.toml");
+		if (!existsSync(manifestPath)) throw new ReleaseError("MISSING_CARGO_MANIFEST", `${relative(process.cwd(), manifestPath)} is required.`);
+		return replaceCargoLockVersion(content, path, cargoName(await readFile(manifestPath, "utf8")), current, version);
+	}
+	const occurrences = content.split(current).length - 1;
+	if (occurrences !== 1) throw new ReleaseError("AMBIGUOUS_VERSION", `${path} must contain the current version exactly once; found ${occurrences}.`);
+	return content.replace(current, version);
+}
+async function planVersionChanges(cwd, current, version, config) {
+	const configured = await Promise.all((config.files ?? ["package.json"]).map((path) => resolveRepositoryPath(cwd, path)));
+	const paths = config.recursive === true ? [...configured, ...await findManifests(cwd)] : configured;
+	const unique = [...new Set(paths)];
+	return Promise.all(unique.map(async (path) => {
+		if (!existsSync(path)) throw new ReleaseError("MISSING_VERSION_FILE", `${relative(cwd, path)} does not exist.`);
+		return {
+			path,
+			before: await readFile(path, "utf8"),
+			after: await transform(path, current, version)
+		};
+	}));
+}
+async function applyVersionChanges(changes) {
+	try {
+		await Promise.all(changes.map((change) => writeFile(change.path, change.after)));
+	} catch (error) {
+		await restoreVersionChanges(changes);
+		throw error;
+	}
+}
+async function restoreVersionChanges(changes) {
+	await Promise.all(changes.map((change) => writeFile(change.path, change.before)));
+}
+//#endregion
+//#region src/version.ts
+const VERSION_PATTERN = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
+function parseVersion(value) {
+	const match = VERSION_PATTERN.exec(value);
+	if (match?.[1] === void 0 || match[2] === void 0 || match[3] === void 0) throw new ReleaseError("INVALID_VERSION", `Invalid semantic version: ${value}`);
+	const identifiers = match[4]?.split(".");
+	if (identifiers?.some((identifier) => /^\d+$/.test(identifier) && identifier.length > 1 && identifier.startsWith("0"))) throw new ReleaseError("INVALID_VERSION", `Invalid semantic version: ${value}`);
+	const version = {
+		major: Number(match[1]),
+		minor: Number(match[2]),
+		patch: Number(match[3])
+	};
+	if (identifiers !== void 0) version.prerelease = identifiers;
+	return version;
+}
+function format(version) {
+	const base = `${version.major}.${version.minor}.${version.patch}`;
+	return version.prerelease === void 0 ? base : `${base}-${version.prerelease.join(".")}`;
+}
+function applyPrerelease(version, preid) {
+	if (version.prerelease?.[0] === preid) {
+		const identifiers = [...version.prerelease];
+		const last = identifiers.at(-1);
+		if (last !== void 0 && /^\d+$/.test(last)) identifiers[identifiers.length - 1] = String(Number(last) + 1);
+		else identifiers.push("0");
+		return {
+			...version,
+			prerelease: identifiers
+		};
+	}
+	return {
+		...version,
+		prerelease: [preid, "0"]
+	};
+}
+function bumpVersion(current, release, preid = "beta") {
+	const version = parseVersion(current);
+	if (!/^[0-9A-Za-z-]+$/.test(preid)) throw new ReleaseError("INVALID_PREID", `Invalid prerelease identifier: ${preid}`);
+	const stable = version.prerelease === void 0 ? version : {
+		...version,
+		prerelease: void 0
+	};
+	switch (release) {
+		case "major": return format(version.prerelease !== void 0 && version.minor === 0 && version.patch === 0 ? stable : {
+			major: version.major + 1,
+			minor: 0,
+			patch: 0
+		});
+		case "minor": return format(version.prerelease !== void 0 && version.patch === 0 ? stable : {
+			major: version.major,
+			minor: version.minor + 1,
+			patch: 0
+		});
+		case "patch": return format(version.prerelease === void 0 ? {
+			major: version.major,
+			minor: version.minor,
+			patch: version.patch + 1
+		} : stable);
+		case "premajor": return format(applyPrerelease({
+			major: version.major + 1,
+			minor: 0,
+			patch: 0
+		}, preid));
+		case "preminor": return format(applyPrerelease({
+			major: version.major,
+			minor: version.minor + 1,
+			patch: 0
+		}, preid));
+		case "prepatch": return format(applyPrerelease({
+			major: version.major,
+			minor: version.minor,
+			patch: version.patch + 1
+		}, preid));
+		case "prerelease": return format(applyPrerelease(version.prerelease === void 0 ? {
+			...version,
+			patch: version.patch + 1
+		} : version, preid));
+	}
+	throw new ReleaseError("INVALID_RELEASE_TYPE", "Unsupported release type.");
+}
+//#endregion
+//#region src/release.ts
+const render = (value, version) => value.replaceAll("{{version}}", version);
+const list = (value) => value === void 0 ? [] : Array.isArray(value) ? value : [value];
+function isObject(value) {
+	return value !== null && Object(value) === value && !Array.isArray(value);
+}
+function isString(value) {
+	return Object.prototype.toString.call(value) === "[object String]";
+}
+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 context = {
+		host: config.host ?? process.env.GITLAB_HOST ?? "https://gitlab.com",
+		project,
+		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");
+	return existsSync(path) ? readFile(path, "utf8") : "";
+}
+async function publishGitLab(context, cwd, config, tag, version) {
+	await createGitLabRelease({
+		host: context.host,
+		project: context.project,
+		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()];
+		return type !== void 0 && type !== false && !(exclude && commit.type === "chore" && commit.scope === "deps" && !commit.isBreaking);
+	});
+}
+async function collect(cwd, config) {
+	const changelog = await loadChangelogConfig(cwd);
+	const commits = parseCommits(await getGitDiff(changelog.from, changelog.to, cwd), changelog);
+	for (const commit of commits) commit.type = commit.type.toLowerCase();
+	return {
+		changelog,
+		commits: filter(commits, changelog, config.excludeDependencyCommits !== false)
+	};
+}
+async function confirm(message) {
+	const input = createInterface({
+		input: process.stdin,
+		output: process.stdout
+	});
+	try {
+		return /^y(es)?$/i.test((await input.question(`${message} (y/N) `)).trim());
+	} finally {
+		input.close();
+	}
+}
+async function prepend(path, markdown) {
+	const current = existsSync(path) ? await readFile(path, "utf8") : "# Changelog\n";
+	const match = current.match(/^# .+$/m);
+	const offset = match?.index === void 0 ? 0 : match.index + match[0].length;
+	const prefix = current.slice(0, offset).trimEnd();
+	const suffix = current.slice(offset).trim();
+	await writeFile(path, `${prefix}${prefix ? "\n\n" : ""}${markdown.trim()}${suffix ? `\n\n${suffix}` : ""}\n`);
+}
+function packageVersion(cwd) {
+	const data = JSON.parse(readFileSync(resolve(cwd, "package.json"), "utf8"));
+	if (!isObject(data) || !("version" in data) || !isString(data.version)) throw new ReleaseError("INVALID_PACKAGE", "package.json must contain a version string.");
+	return data.version;
+}
+async function runRelease(options) {
+	const overrides = {};
+	if (options.release !== void 0) overrides.release = options.release;
+	if (options.preid !== void 0) overrides.preid = options.preid;
+	if (options.push !== void 0) overrides.git = { push: options.push };
+	const config = await loadReleaseConfig(options.cwd, options.configFile, overrides);
+	const cwd = options.cwd;
+	if (!isGitRepository(cwd)) throw new ReleaseError("NOT_A_REPOSITORY", `${cwd} is not a Git repository.`);
+	const currentVersion = packageVersion(cwd);
+	if (options.gitlabRetryTag !== void 0) {
+		const context = gitLabContext(config.gitlab);
+		const remote = config.git?.remote ?? "origin";
+		if (!remoteTagExists(cwd, remote, options.gitlabRetryTag)) throw new ReleaseError("GITLAB_RELEASE_FAILED", `Tag ${options.gitlabRetryTag} does not exist on ${remote}.`);
+		await publishGitLab(context, cwd, config, options.gitlabRetryTag, currentVersion);
+		return {
+			currentVersion,
+			tag: options.gitlabRetryTag,
+			pushed: true,
+			dryRun: false,
+			commitCount: 0,
+			gitlabReleaseCreated: 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.");
+	const push = config.git?.push !== false;
+	if (push && config.git?.requireUpstream !== false) git([
+		"rev-parse",
+		"--abbrev-ref",
+		"--symbolic-full-name",
+		"@{upstream}"
+	], cwd);
+	const { changelog, commits } = await collect(cwd, config);
+	const detected = config.release ?? determineSemverChange(commits, changelog);
+	if (detected === null) return {
+		currentVersion,
+		pushed: false,
+		dryRun: options.dryRun,
+		commitCount: 0
+	};
+	const releaseType = detected;
+	console.info(`Release: v${currentVersion} → ${releaseType} (${commits.length} commits)`);
+	if (options.dryRun) {
+		console.info(await generateMarkDown(commits, changelog));
+		return {
+			currentVersion,
+			releaseType,
+			pushed: false,
+			dryRun: true,
+			commitCount: commits.length
+		};
+	}
+	let gitlab;
+	if (config.gitlab?.enabled === true) {
+		if (!push) throw new ReleaseError("GITLAB_RELEASE_FAILED", "GitLab release creation requires git.push to be enabled.");
+		gitlab = gitLabContext(config.gitlab);
+	}
+	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 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;
+	if (config.changelog !== false) {
+		const path = await resolveRepositoryPath(cwd, config.changelog === true ? "CHANGELOG.md" : config.changelog ?? "CHANGELOG.md");
+		const existed = existsSync(path);
+		changelogSnapshot = {
+			path,
+			existed
+		};
+		if (existed) changelogSnapshot.content = await readFile(path, "utf8");
+		changed.push(path);
+	}
+	const indexTree = git(["write-tree"], cwd);
+	try {
+		await applyVersionChanges(changes);
+		if (changelogSnapshot !== void 0) await prepend(changelogSnapshot.path, await generateMarkDown(commits, {
+			...changelog,
+			newVersion: version
+		}));
+		git([
+			"add",
+			"--",
+			...[...new Set(changed)].map((path) => relative(cwd, path))
+		], cwd);
+		const commitArgs = ["commit"];
+		if (config.git?.sign === true) commitArgs.push("-S");
+		commitArgs.push("-m", render(config.git?.commitMessage ?? "chore(release): v{{version}}", version));
+		git(commitArgs, cwd);
+	} catch (error) {
+		await restoreVersionChanges(changes);
+		if (changelogSnapshot?.content !== void 0) await writeFile(changelogSnapshot.path, changelogSnapshot.content);
+		else if (changelogSnapshot !== void 0 && existsSync(changelogSnapshot.path)) await unlink(changelogSnapshot.path);
+		git(["read-tree", indexTree], cwd);
+		throw error;
+	}
+	const tagArgs = ["tag", "-a"];
+	if (config.git?.sign === true) tagArgs.push("-s");
+	tagArgs.push(tag, "-m", render(config.git?.tagMessage ?? "v{{version}}", version));
+	git(tagArgs, cwd);
+	if (push) git([
+		"push",
+		"--atomic",
+		remote,
+		`HEAD:${branch}`,
+		`refs/tags/${tag}`
+	], cwd);
+	let gitlabReleaseCreated = false;
+	if (gitlab !== void 0) try {
+		await publishGitLab(gitlab, cwd, config, tag, version);
+		gitlabReleaseCreated = true;
+	} 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 });
+	}
+	for (const command of list(config.hooks?.after)) runHook(command, cwd);
+	const result = {
+		currentVersion,
+		newVersion: version,
+		releaseType,
+		tag,
+		pushed: push,
+		dryRun: false,
+		commitCount: commits.length
+	};
+	if (gitlabReleaseCreated) result.gitlabReleaseCreated = true;
+	return result;
+}
+//#endregion
+export { loadReleaseConfig as i, ReleaseError as n, defineConfig as r, runRelease as t };

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "genbumppush",
   "description": "Generate changelog, bump version, then push",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "type": "module",
+  "sideEffects": false,
   "license": "MIT",
   "author": "Mon Albert Gamil <mrgamilmonalbert@gmail.com>",
   "homepage": "https://github.com/xcvzmoon/genbumppush#readme",
@@ -18,11 +19,26 @@
   ],
   "exports": {
     ".": "./dist/index.mjs",
+    "./bin": "./dist/bin.mjs",
     "./package.json": "./package.json"
   },
+  "bin": {
+    "genbumppush": "./dist/bin.mjs"
+  },
   "publishConfig": {
     "access": "public"
   },
+  "engines": {
+    "node": ">=20.19.0"
+  },
+  "keywords": [
+    "release",
+    "changelog",
+    "semver",
+    "conventional-commits",
+    "monorepo",
+    "tauri"
+  ],
   "scripts": {
     "build": "vp pack",
     "dev": "vp pack --watch",
@@ -31,9 +47,12 @@
     "prepublishOnly": "vp run build",
     "prepare": "vp config"
   },
+  "dependencies": {
+    "c12": "4.0.0-rc.1",
+    "changelogen": "^0.6.2"
+  },
   "devDependencies": {
     "@types/node": "26.5.0",
-    "bumpp": "^11.1.0",
     "typescript": "^6.0.3",
     "vite": "npm:@voidzero-dev/vite-plus-core@0.3.1",
     "vite-plus": "^0.3.1"