tegami 0.0.0 → 0.1.0-beta.0

package/dist/{index.mjs → index.js}

@@ -1,11 +1,14 @@
-import { r as isNodeError, t as PackageGraph } from "./workspace-B5_i21S0.mjs";
-import { cargo } from "./providers/cargo.mjs";
-import { a as planStoreSchema, i as changelogFrontmatterSchema, r as npm } from "./npm-BSE_dtB3.mjs";
-import { simpleGenerator } from "./generators/simple.mjs";
+import { n as handlePluginError } from "./error-DBK-9uBa.js";
+import { i as maxBump } from "./semver-mWK2Khi2.js";
+import { t as PackageGraph } from "./graph-CUgwuRW5.js";
+import { cargo } from "./providers/cargo.js";
+import { t as changelogFrontmatterSchema } from "./schemas-Cc4h6bq5.js";
+import { npm } from "./providers/npm.js";
+import { simpleGenerator } from "./generators/simple.js";
+import { i as readPlanStore, n as publishPlanStatus, r as createPlanStore, t as assertPublishPlanFinished } from "./checks-CKBRRjgQ.js";
 import { mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
-import path, { basename, dirname, join, resolve } from "node:path";
+import path, { basename, dirname, join } from "node:path";
 import { x } from "tinyexec";
-import { inc } from "semver";
 import { load } from "js-yaml";
 import { fromMarkdown } from "mdast-util-from-markdown";
 import { toMarkdown } from "mdast-util-to-markdown";
@@ -19,7 +22,7 @@ async function createChangelog(context, options = {}) {
 		if (group) group.push(commit);
 		else groups.set(key, [commit]);
 	}
-	const directory = join(context.cwd, context.changelogDir);
+	const directory = context.changelogDir;
 	await mkdir(directory, { recursive: true });
 	const created = [];
 	const stamp = Date.now().toString(36);
@@ -132,17 +135,18 @@ function commandOutput(result) {
 //#endregion
 //#region src/context.ts
 async function createTegamiContext(options = {}) {
-	const cwd = resolve(options.cwd ?? process.cwd());
+	const cwd = options.cwd ? path.resolve(options.cwd) : process.cwd();
+	const changelogDir = path.resolve(cwd, options.changelogDir ?? ".tegami");
 	const graph = new PackageGraph();
 	const registryClients = /* @__PURE__ */ new Map();
 	const ctx = {
 		cwd,
-		changelogDir: options.changelogDir ?? ".tegami",
-		planPath: resolve(cwd, options.planPath ?? join(".tegami", "publish-plan.json")),
+		changelogDir,
+		planPath: options.planPath ? path.resolve(cwd, options.planPath) : path.join(changelogDir, "publish-plan"),
 		options,
 		plugins: resolvePlugins([
-			npm(options.npmClient),
-			cargo(),
+			npm(options.npm),
+			cargo(options.cargo),
 			...options.plugins ?? []
 		]),
 		graph,
@@ -160,10 +164,25 @@ async function createTegamiContext(options = {}) {
 			return client;
 		}
 	};
-	for (const plugin of ctx.plugins) await plugin.init?.call(ctx);
-	for (const plugin of ctx.plugins) await plugin.resolve?.call(ctx);
+	for (const plugin of ctx.plugins) await handlePluginError(plugin, "init", () => plugin.init?.call(ctx));
+	for (const plugin of ctx.plugins) await handlePluginError(plugin, "resolve", () => plugin.resolve?.call(ctx));
+	const ignoreMatchers = options.ignore?.map((pattern) => {
+		if (pattern instanceof RegExp) return (pkg) => pattern.test(pkg.name) || pattern.test(pkg.id);
+		return (pkg) => pkg.name === pattern || pkg.id === pattern;
+	});
+	for (const [name, groupOptions] of Object.entries(options.groups ?? {})) graph.registerGroup(name, groupOptions);
+	for (const pkg of graph.getPackages()) {
+		if (ignoreMatchers?.length && ignoreMatchers.some((matcher) => matcher(pkg))) {
+			graph.delete(pkg.id);
+			continue;
+		}
+		const packageOptions = options.packages?.[pkg.id] ?? options.packages?.[pkg.name];
+		if (!packageOptions) continue;
+		pkg.setPackageOptions(packageOptions);
+		if (packageOptions.group) graph.addGroupMember(packageOptions.group, pkg.id);
+	}
 	for (const plugin of ctx.plugins) {
-		const clients = await plugin.createRegistryClient?.call(ctx);
+		const clients = await handlePluginError(plugin, "createRegistryClient", () => plugin.createRegistryClient?.call(ctx));
 		if (!clients) continue;
 		for (const client of Array.isArray(clients) ? clients : [clients]) registryClients.set(client.id, client);
 	}
@@ -178,195 +197,165 @@ function resolvePlugins(plugins = []) {
 	return plugins.flat(Infinity).sort((a, b) => PLUGIN_ORDER[a.enforce ?? "default"] - PLUGIN_ORDER[b.enforce ?? "default"]);
 }
 //#endregion
-//#region src/utils/semver.ts
-function maxBump(a, b) {
-	if (a === "major" || b === "major") return "major";
-	if (a === "minor" || b === "minor") return "minor";
-	return "patch";
-}
-function bumpVersion(version, type) {
-	const next = inc(version, type);
-	if (!next) throw new Error(`Invalid semver version: ${version}`);
-	return next;
+//#region src/plans/policy.ts
+function groupPolicy({ graph }) {
+	return {
+		id: "group",
+		onUpdate({ pkg, plan }) {
+			if (!plan.type) return;
+			const group = graph.getPackageGroup(pkg.id);
+			if (!group || !group.options.syncBump) return;
+			for (const member of group.packages) {
+				if (member === pkg) continue;
+				this.bumpPackage(member, {
+					type: plan.type,
+					reason: `sync "${group.name}" group package versions`
+				});
+			}
+		}
+	};
 }
 //#endregion
-//#region src/draft.ts
+//#region src/plans/draft.ts
 var DraftPlan = class {
-	changelogs;
-	packages;
 	context;
-	#created = false;
-	constructor(changelogs, packages, context) {
-		this.changelogs = changelogs;
-		this.packages = packages;
+	#applied = false;
+	packages = /* @__PURE__ */ new Map();
+	changelogs = /* @__PURE__ */ new Map();
+	policies = [];
+	constructor(context) {
 		this.context = context;
+		this.policies.push(groupPolicy(context));
 	}
-	getPackageIds() {
-		return Array.from(this.packages.keys());
+	getPackagePlans() {
+		return this.packages;
 	}
-	getPackage(id) {
+	getPackagePlan(id) {
 		return this.packages.get(id);
 	}
-	setPackage(id, plan = {}) {
-		this.packages.set(id, {
-			...plan,
-			changelogIds: plan.changelogIds ?? /* @__PURE__ */ new Set(),
-			publish: plan.publish ?? true,
-			type: plan.type ?? "patch"
+	bumpPackage(pkg, { type, reason }) {
+		let plan = this.packages.get(pkg.id);
+		if (!plan) {
+			plan = this.initPackagePlan(pkg);
+			this.packages.set(pkg.id, plan);
+		}
+		const prevVersion = plan.bumpVersion(pkg);
+		plan.type = plan.type ? maxBump(plan.type, type) : type;
+		if (reason) {
+			plan.bumpReasons ??= /* @__PURE__ */ new Set();
+			plan.bumpReasons.add(reason);
+		}
+		if (prevVersion !== plan.bumpVersion(pkg)) for (const policy of this.policies) policy.onUpdate?.call(this, {
+			plan,
+			pkg
 		});
+		return plan;
 	}
-	deletePackage(id) {
-		return this.packages.delete(id);
+	hasPending() {
+		const { graph } = this.context;
+		for (const [id, plan] of this.packages) {
+			const pkg = graph.get(id);
+			if (pkg && plan.bumpVersion(pkg) !== pkg.version) return true;
+		}
+		return false;
 	}
-	getChangelogIds() {
-		return Array.from(this.changelogs.keys());
+	getChangelogs() {
+		return Array.from(this.changelogs.values());
 	}
 	getChangelog(id) {
 		return this.changelogs.get(id);
 	}
-	setChangelog(id, entry) {
-		this.changelogs.set(id, entry);
+	addChangelog(entry) {
+		this.changelogs.set(entry.id, entry);
+		const { graph } = this.context;
+		const groupPackages = /* @__PURE__ */ new Set();
+		for (const name of entry.packages) for (const pkg of graph.getByName(name)) groupPackages.add(pkg);
+		for (const pkg of groupPackages) {
+			const plan = this.bumpPackage(pkg, { type: entry.type });
+			plan.changelogs ??= [];
+			plan.changelogs.push(entry);
+		}
 	}
 	deleteChangelog(id) {
 		return this.changelogs.delete(id);
 	}
-	/** Write the publish plan, update package versions, and consume changelog files. */
-	async createPublishPlan() {
-		this.assertEditable();
-		await this.assertPublishPlanFinished();
-		this.#created = true;
-		await this.applyVersionChanges();
-		const plan = {
-			id: `tegami-${Date.now().toString(36)}`,
-			createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-			changelogs: Object.fromEntries(Array.from(this.changelogs, ([id, entry]) => [id, {
-				filename: entry.filename,
-				subject: entry.subject,
-				packages: Array.from(entry.packages),
-				type: entry.type,
-				title: entry.title,
-				content: entry.content
-			}])),
-			packages: Object.fromEntries(this.packages)
-		};
-		await mkdir(dirname(this.context.planPath), { recursive: true });
-		await writeFile(this.context.planPath, planStoreSchema.encode(plan));
-		await this.removeConsumedChangelogs();
-	}
-	async assertPublishPlanFinished() {
-		const content = await readFile(this.context.planPath, "utf8").catch(() => void 0);
-		if (!content) return;
-		const parsed = planStoreSchema.safeDecode(content);
-		if (!parsed.success) return;
-		const status = await publishPlanStatus(this.context, parsed.data);
-		if (status.state === "success") return;
-		const message = `Publish plan already exists at ${this.context.planPath} and is ${status.state}. Publish it before creating a new plan.`;
-		throw new Error(status.error ? `${message}\n${status.error}` : message);
+	initPackagePlan(pkg) {
+		const context = this.context;
+		const plan = pkg.onPlan(context);
+		const group = context.graph.getPackageGroup(pkg.id);
+		if (group) plan.prerelease ??= group.options.prerelease;
+		return plan;
 	}
-	async applyVersionChanges() {
+	/** Apply the publish plan: update package versions, write the plan file, and consume changelog files. */
+	async applyPlan() {
+		if (this.#applied) throw new Error("This draft has already applied a publish plan.");
+		await assertPublishPlanFinished(this.context);
+		this.#applied = true;
+		for (const plugin of this.context.plugins) await handlePluginError(plugin, "applyPlan", () => plugin.applyPlan?.call(this.context, this));
 		const { graph } = this.context;
-		const updatedPackages = /* @__PURE__ */ new Map();
 		const writes = [];
-		for (const [id, plan] of this.packages) {
+		for (const [id, packagePlan] of this.packages) {
 			const pkg = graph.get(id);
 			if (!pkg) continue;
-			updatedPackages.set(id, {
-				plan,
-				version: bumpVersion(pkg.version, plan.type)
-			});
-		}
-		for (const pkg of graph.getPackages()) {
-			const updated = updatedPackages.get(pkg.id);
-			for (const [id, updatedDep] of updatedPackages) {
-				const target = graph.get(id);
-				if (target) await pkg.updateDependency?.(target, updatedDep.version, this.context);
-			}
-			if (updated) {
-				pkg.setVersion?.(updated.version);
-				writes.push(this.appendChangelog(pkg, updated.plan));
-			}
-			const write = pkg.write?.();
-			if (write) writes.push(write);
+			writes.push(this.appendChangelog(pkg, packagePlan));
 		}
+		for (const entry of this.changelogs.values()) writes.push(rm(path.join(this.context.changelogDir, entry.filename), { force: true }));
 		await Promise.all(writes);
+		await mkdir(dirname(this.context.planPath), { recursive: true });
+		await writeFile(this.context.planPath, createPlanStore(this, this.context));
 	}
-	async removeConsumedChangelogs() {
-		const writes = [];
-		for (const entry of this.changelogs.values()) {
-			const file = path.resolve(this.context.cwd, this.context.changelogDir, entry.filename);
-			writes.push(rm(file, { force: true }));
-		}
-		await Promise.all(writes);
+	addPolicy(policy) {
+		this.policies.push(policy);
+	}
+	removePolicy(policy) {
+		const idx = this.policies.indexOf(policy);
+		if (idx !== -1) this.policies.splice(idx, 1);
 	}
-	assertEditable() {
-		if (this.#created) throw new Error("This draft has already created a publish plan.");
+	canApply() {
+		return !this.#applied;
 	}
 	async appendChangelog(pkg, plan) {
-		if (plan.changelogIds.size === 0) return;
+		if (!plan.changelogs || plan.changelogs.length === 0) return;
 		const { generator = simpleGenerator() } = this.context.options;
-		const changelogs = [];
-		for (const id of plan.changelogIds) {
-			const entry = this.changelogs.get(id);
-			if (entry) changelogs.push(entry);
-		}
 		const generated = await generator.generate.call(this.context, {
+			packageId: pkg.id,
 			packageName: pkg.name,
 			version: pkg.version,
-			changelogs
+			npm: plan.npm,
+			plan,
+			changelogs: plan.changelogs,
+			_draft: this
 		});
 		const path = join(pkg.path, "CHANGELOG.md");
 		const existing = await readFile(path, "utf8").catch(() => "");
 		await writeFile(path, `${generated.trim()}\n\n${existing}`.trimEnd() + "\n");
 	}
-	/** {@link createPublishPlan} but for `await using` syntax */
+	/** {@link applyPlan} but for `await using` syntax */
 	async [Symbol.asyncDispose]() {
-		return this.createPublishPlan();
+		return this.applyPlan();
 	}
 };
-async function publishPlanStatus(context, plan) {
-	for (const [id, pkgPlan] of Object.entries(plan.packages)) {
-		const pkg = context.graph.get(id);
-		if (!pkg || !pkgPlan.publish) continue;
-		if (!await context.getRegistryClient(pkg).packageVersionExists(pkg, pkg.version)) return { state: "pending" };
-	}
-	return { state: "success" };
-}
-function createDraftPlan(changelogs, context) {
-	const changelogMap = /* @__PURE__ */ new Map();
-	const byPackage = /* @__PURE__ */ new Map();
-	for (const entry of changelogs) {
-		changelogMap.set(entry.id, entry);
-		for (const requestedPackage of entry.packages) for (const pkg of context.graph.getByName(requestedPackage)) {
-			let entries = byPackage.get(pkg);
-			if (!entries) {
-				entries = [];
-				byPackage.set(pkg, entries);
-			}
-			entries.push(entry);
-		}
-	}
-	const packages = /* @__PURE__ */ new Map();
-	for (const [pkg, entries] of byPackage.entries()) {
-		const plan = createPackagePlan(pkg, entries, context);
-		if (plan) packages.set(pkg.id, plan);
-	}
-	return new DraftPlan(changelogMap, packages, context);
+async function cleanupPublishPlan(context) {
+	const store = await readPlanStore(context);
+	if (!store) return {
+		state: "skipped",
+		reason: "missing"
+	};
+	if ((await publishPlanStatus(store, context)).state !== "success") return {
+		state: "skipped",
+		reason: "pending"
+	};
+	await rm(context.planPath, { force: true });
+	return { state: "removed" };
 }
-function createPackagePlan(pkg, entries, context) {
-	if (entries.length === 0) return null;
-	const packageOptions = context.options.packages?.[pkg.id] ?? context.options.packages?.[pkg.name] ?? {};
-	let type = entries[0].type;
-	const changelogIds = /* @__PURE__ */ new Set();
-	for (const entry of entries) {
-		changelogIds.add(entry.id);
-		type = maxBump(type, entry.type);
+async function createDraftPlan(changelogs, context) {
+	let draft = new DraftPlan(context);
+	for (const plugin of context.plugins) {
+		const result = await handlePluginError(plugin, "initPlan", () => plugin.initPlan?.call(context, draft));
+		if (result) draft = result;
 	}
-	return {
-		type,
-		changelogIds,
-		distTag: packageOptions.distTag ?? pkg.distTag,
-		publish: packageOptions.publish ?? pkg.publish
-	};
+	for (const entry of changelogs) draft.addChangelog(entry);
+	return draft;
 }
 //#endregion
 //#region src/utils/frontmatter.ts
@@ -392,20 +381,16 @@ function frontmatter(input) {
 }
 //#endregion
 //#region src/changelog/parse.ts
-async function readChangelogEntries(cwd, changelogDir) {
-	const directory = resolve(cwd, changelogDir);
-	const files = await readdir(directory).catch((error) => {
-		if (isNodeError(error) && error.code === "ENOENT") return [];
-		throw error;
-	});
-	const entries = [];
-	for (const file of files.sort()) {
-		if (!file.endsWith(".md")) continue;
-		const filePath = join(directory, file);
-		const content = await readFile(filePath, "utf8");
-		entries.push(...parseChangelogFile(filePath, content));
-	}
-	return entries;
+async function getChangelogFiles(context) {
+	return (await readdir(context.changelogDir).catch(() => [])).filter((file) => file.endsWith(".md"));
+}
+async function readChangelogEntries(context) {
+	const dir = context.changelogDir;
+	const files = await getChangelogFiles(context);
+	return (await Promise.all(files.map(async (file) => {
+		const filePath = join(dir, file);
+		return parseChangelogFile(filePath, await readFile(filePath, "utf8"));
+	}))).flat();
 }
 /** Parse one changelog markdown file into release entries. */
 function parseChangelogFile(file, content) {
@@ -470,23 +455,16 @@ function headingToBump(depth) {
 }
 //#endregion
 //#region src/publish.ts
-async function publishFromPlan(context, plan, options) {
-	const packages = await publishStoredPlan(plan, context, options);
-	return {
-		planPath: context.planPath,
-		state: packages.some((pkg) => pkg.state === "failed") ? "failed" : "success",
-		packages,
-		_rawPlan: plan
-	};
-}
-async function publishStoredPlan(store, context, { dryRun = false }) {
-	const results = [];
+async function publishFromPlan(context, store, options) {
+	const { dryRun = false } = options;
+	const packages = [];
+	if ((await publishPlanStatus(store, context)).state !== "pending") return { state: "skipped" };
 	for (const [id, plan] of Object.entries(store.packages)) {
 		if (!plan.publish) continue;
 		const pkg = context.graph.get(id);
 		if (!pkg) continue;
 		const changelogs = [];
-		for (const id of plan.changelogIds) {
+		for (const id of plan.changelogIds ?? []) {
 			const entry = store.changelogs[id];
 			if (entry) changelogs.push({
 				...entry,
@@ -495,12 +473,12 @@ async function publishStoredPlan(store, context, { dryRun = false }) {
 			});
 		}
 		if (!dryRun) {
-			if (await context.getRegistryClient(pkg).packageVersionExists(pkg, pkg.version)) {
-				results.push({
+			if (await context.getRegistryClient(pkg).isPackagePublished(pkg)) {
+				packages.push({
 					id: pkg.id,
 					name: pkg.name,
 					version: pkg.version,
-					distTag: plan.distTag,
+					npm: plan.npm,
 					state: "success",
 					changelogs
 				});
@@ -508,60 +486,77 @@ async function publishStoredPlan(store, context, { dryRun = false }) {
 			}
 		}
 		try {
-			if (!dryRun) await context.getRegistryClient(pkg).publish(pkg, { distTag: plan.distTag });
-			results.push({
+			if (!dryRun) await context.getRegistryClient(pkg).publish(pkg, {
+				packageStore: plan,
+				store
+			});
+			packages.push({
 				id: pkg.id,
 				name: pkg.name,
 				version: pkg.version,
-				distTag: plan.distTag,
+				npm: plan.npm,
 				state: "success",
 				changelogs
 			});
 		} catch (error) {
-			results.push({
+			packages.push({
 				id: pkg.id,
 				name: pkg.name,
 				version: pkg.version,
-				distTag: plan.distTag,
+				npm: plan.npm,
 				changelogs,
 				state: "failed",
 				error: error instanceof Error ? error.message : String(error)
 			});
 		}
 	}
-	return results;
+	if (packages.length === 0) return { state: "skipped" };
+	return {
+		state: packages.some((pkg) => pkg.state === "failed") ? "failed" : "created",
+		packages,
+		_rawPlan: store
+	};
 }
 //#endregion
 //#region src/index.ts
 /** Create a Tegami project handle. */
 function tegami(options = {}) {
+	const $context = init();
+	async function init() {
+		return createTegamiContext(options);
+	}
 	return {
-		async createChangelog(createOptions = {}) {
-			return createChangelog(await createTegamiContext(options), createOptions);
+		async generateChangelog(createOptions = {}) {
+			return createChangelog(await $context, createOptions);
 		},
-		async draft() {
-			const context = await createTegamiContext(options);
-			let plan = createDraftPlan(await readChangelogEntries(context.cwd, context.changelogDir), context);
-			for (const plugin of context.plugins) plan = await plugin.initPlan?.call(context, plan) ?? plan;
-			return plan;
+		_internal: {
+			options,
+			context() {
+				return $context;
+			},
+			async graph() {
+				return (await $context).graph;
+			}
 		},
-		async graph() {
-			return (await createTegamiContext(options)).graph;
+		async draft() {
+			const context = await $context;
+			return createDraftPlan(await readChangelogEntries(context), context);
 		},
 		async publish(publishOptions = {}) {
-			const context = await createTegamiContext(options);
-			const parsed = await readFile(context.planPath, "utf8").then((content) => planStoreSchema.decode(content)).catch((error) => {
-				if (isNodeError(error) && error.code === "ENOENT") return void 0;
-				throw error;
-			});
-			if (parsed === void 0) throw new Error(`No publish plan found at ${context.planPath}.`);
+			const context = await $context;
+			if ((await getChangelogFiles(context)).length > 0) return { state: "skipped" };
+			const parsed = await readPlanStore(context);
+			if (!parsed) return { state: "skipped" };
 			let result = await publishFromPlan(context, parsed, publishOptions);
 			const publishCtx = {
 				...context,
 				publishOptions
 			};
-			for (const plugin of context.plugins) result = await plugin.afterPublish?.call(publishCtx, result) ?? result;
+			for (const plugin of context.plugins) result = await handlePluginError(plugin, "afterPublish", () => plugin.afterPublish?.call(publishCtx, result)) ?? result;
 			return result;
+		},
+		async cleanup() {
+			return cleanupPublishPlan(await $context);
 		}
 	};
 }

package/dist/plugins/{git.d.mts → git.d.ts}

@@ -1,9 +1,11 @@
-import { o as TegamiPlugin } from "../types-DdIMewK9.mjs";
+import { d as TegamiPlugin } from "../index-Bhh2dJZp.js";
 
 //#region src/plugins/git.d.ts
 interface GitPluginOptions {
   /** Set to false to skip creating git tags after all packages publish successfully. */
   createTags?: boolean;
+  /** Push created tags to origin. Defaults to true in CI. */
+  pushTags?: boolean;
 }
 /**
  * Basic Git integrations:
@@ -12,8 +14,5 @@ interface GitPluginOptions {
  * Note: you do not need this with `github` plugin enabled.
  */
 declare function git(options?: GitPluginOptions): TegamiPlugin;
-/** create a Git tag, ignored if already exists */
-declare function createGitTag(cwd: string, tag: string): Promise<void>;
-declare function gitTagExists(cwd: string, tag: string): Promise<boolean>;
 //#endregion
-export { GitPluginOptions, createGitTag, git, gitTagExists };
+export { GitPluginOptions, git };

package/dist/plugins/git.js

@@ -0,0 +1,84 @@
+import { t as execFailure } from "../error-DBK-9uBa.js";
+import { t as isCI } from "../constants-B9qjNfvr.js";
+import { x } from "tinyexec";
+//#region src/plugins/git.ts
+/**
+* Basic Git integrations:
+* - auto tags.
+*
+* Note: you do not need this with `github` plugin enabled.
+*/
+function git(options = {}) {
+	const { createTags = true, pushTags = isCI() } = options;
+	function resolveGitTag(context, result) {
+		const { graph } = context;
+		const pkg = graph.get(result.id);
+		if (!pkg) return `${result.name}@${result.version}`;
+		const group = graph.getPackageGroup(pkg.id);
+		if (group?.options.syncGitTag) return `${group.name}@${result.version}`;
+		return `${result.name}@${result.version}`;
+	}
+	return {
+		name: "git",
+		enforce: "pre",
+		cli: { async init() {
+			if (!isCI()) return;
+			const gitOptions = { nodeOptions: { cwd: this.cwd } };
+			for (const args of [[
+				"config",
+				"user.name",
+				"github-actions[bot]"
+			], [
+				"config",
+				"user.email",
+				"41898282+github-actions[bot]@users.noreply.github.com"
+			]]) {
+				const result = await x("git", [...args], gitOptions);
+				if (result.exitCode !== 0) throw execFailure("Failed to configure git user for GitHub Actions.", result);
+			}
+		} },
+		async afterPublish(result) {
+			const { cwd, publishOptions: { dryRun = false } } = this;
+			if (dryRun || !createTags || result.state !== "created") return result;
+			const pendingTags = /* @__PURE__ */ new Set();
+			for (const pkg of result.packages) {
+				pkg.gitTag = resolveGitTag(this, pkg);
+				pendingTags.add(pkg.gitTag);
+			}
+			try {
+				const createdTags = [];
+				await Promise.all(Array.from(pendingTags).map(async (tag) => {
+					if (await gitTagExists(cwd, tag)) return;
+					const gitOut = await x("git", ["tag", tag], { nodeOptions: { cwd } });
+					if (gitOut.exitCode !== 0) throw execFailure(`Failed to create Git tag "${tag}" for release`, gitOut);
+					createdTags.push(tag);
+				}));
+				if (pushTags && createdTags.length > 0) {
+					const gitOut = await x("git", [
+						"push",
+						"origin",
+						...createdTags
+					], { nodeOptions: { cwd } });
+					if (gitOut.exitCode !== 0) throw execFailure(`Failed to push Git tags to origin: ${createdTags.join(", ")}`, gitOut);
+				}
+			} catch (error) {
+				return {
+					...result,
+					state: "failed",
+					error: error instanceof Error ? error.message : String(error)
+				};
+			}
+			return result;
+		}
+	};
+}
+async function gitTagExists(cwd, tag) {
+	return (await x("git", [
+		"rev-parse",
+		"-q",
+		"--verify",
+		`refs/tags/${tag}`
+	], { nodeOptions: { cwd } })).exitCode === 0;
+}
+//#endregion
+export { git };