genbumppush 0.0.1 → 0.0.3

package/dist/release-CVQ5WSKG.mjs

@@ -0,0 +1,881 @@
+import { createDefineConfig, loadConfig } 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
+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) {
+	const result = spawnSync("git", ["rev-parse", "--is-inside-work-tree"], {
+		cwd,
+		encoding: "utf8",
+		stdio: [
+			"ignore",
+			"pipe",
+			"ignore"
+		]
+	});
+	if (result.error || result.status !== 0 || typeof result.stdout !== "string") return false;
+	return result.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/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");
+	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.";
+}
+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"
+			},
+			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 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 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;
+}
+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);
+	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);
+	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;
+}
+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");
+	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)
+	});
+}
+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()];
+		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 (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.");
+	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)`);
+	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
+		};
+	}
+	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);
+	}
+	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 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 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 });
+	}
+	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,
+		newVersion: version,
+		releaseType,
+		tag,
+		pushed: push,
+		dryRun: false,
+		commitCount: commits.length
+	};
+	if (gitlabReleaseCreated) result.gitlabReleaseCreated = true;
+	if (githubReleaseCreated) result.githubReleaseCreated = true;
+	return result;
+}
+//#endregion
+export { loadReleaseConfig as i, ReleaseError as n, defineConfig as r, runRelease as t };