tegami 1.1.2 → 1.1.3

package/dist/plugins/gitlab.js

@@ -3,7 +3,7 @@ import { t as changelogFilename } from "../generate-Bg86OJP4.js";
 import { a as cached, n as execFailure, o as isCI, s as joinPath } from "../error-BhMYq9iW.js";
 import { o as readChangelogEntries, t as createDraft } from "../draft-CzUiQasJ.js";
 import { git } from "./git.js";
-import { n as createVersionRequestBody, r as hasGitChanges, t as commitVersionBranchChanges } from "../version-request-oxy16TJ1.js";
+import { t as onVersionRequest } from "../version-request-DlLpLLK3.js";
 import { readFile, writeFile } from "node:fs/promises";
 import { basename, join, relative, resolve } from "node:path";
 import { x } from "tinyexec";
@@ -309,7 +309,39 @@ function gitlab(options = {}) {
 	function getRenderer(context) {
 		return renderer ??= createChangelogRenderer(context);
 	}
-	const cliOriginalPackageVersions = /* @__PURE__ */ new Map();
+	const versionRequests = onVersionRequest({
+		name: "gitlab",
+		summary: "Merge this MR to publish the versioned packages.",
+		options: options.versionMr,
+		enabled(context) {
+			const { repo, token } = context.gitlab ?? {};
+			return Boolean(repo && token);
+		},
+		find(context, { head, base }) {
+			return findOpenMergeRequest(context.gitlab.repo, {
+				head,
+				base,
+				...gitLabApiOptions(context.gitlab)
+			});
+		},
+		create(context, request) {
+			return createMergeRequest(context.gitlab.repo, {
+				title: request.title,
+				body: request.body,
+				head: request.head,
+				base: request.base,
+				...gitLabApiOptions(context.gitlab)
+			});
+		},
+		update(context, number, request) {
+			return updateMergeRequest(context.gitlab.repo, number, {
+				title: request.title,
+				body: request.body,
+				base: request.base,
+				...gitLabApiOptions(context.gitlab)
+			});
+		}
+	});
 	return [git(options), {
 		name: "gitlab",
 		init() {
@@ -321,6 +353,7 @@ function gitlab(options = {}) {
 			};
 		},
 		async resolvePlanStatus({ plan }) {
+			if (versionRequests.resolvePlanStatus() === "pending") return "pending";
 			const { repo, token } = this.gitlab;
 			if (!repo || !token || releaseOptions === false) return;
 			const requiredTags = /* @__PURE__ */ new Set();
@@ -394,42 +427,16 @@ function gitlab(options = {}) {
 			if (result.exitCode !== 0) throw execFailure("Failed to configure git remote for GitLab CI.", result);
 		},
 		initCliDraft() {
-			for (const pkg of this.graph.getPackages()) cliOriginalPackageVersions.set(pkg.id, pkg.version);
+			versionRequests.initCliDraft.call(this);
 		},
-		async applyCliDraft(draft) {
-			const config = options.versionMr ?? {};
-			if (config === false || !(config.forceCreate || isCI()) || !await hasGitChanges(this.cwd)) return;
-			const repo = this.gitlab?.repo;
-			const { branch = "tegami/version-packages", base = "main" } = config;
-			const baseMR = await config.create?.call(this, { draft });
-			const mr = {
-				title: baseMR?.title ?? "Version Packages",
-				body: baseMR?.body ?? createVersionRequestBody(draft, this, cliOriginalPackageVersions, "Merge this MR to publish the versioned packages.")
-			};
-			await commitVersionBranchChanges(this.cwd, branch, mr.title);
-			const api = gitLabApiOptions(this.gitlab);
-			if (!repo) return;
-			const openMr = await findOpenMergeRequest(repo, {
-				head: branch,
-				base,
-				...api
-			});
-			if (openMr !== void 0) {
-				await updateMergeRequest(repo, openMr, {
-					title: mr.title,
-					body: mr.body,
-					base,
-					...api
-				});
-				return;
-			}
-			await createMergeRequest(repo, {
-				title: mr.title,
-				body: mr.body,
-				head: branch,
-				base,
-				...api
-			});
+		applyCliDraft(draft) {
+			return versionRequests.applyCliDraft.call(this, draft);
+		},
+		initPublishPlan(opts) {
+			versionRequests.initPublishPlan.call(this, opts);
+		},
+		beforePublishAll(opts) {
+			return versionRequests.beforePublishAll.call(this, opts);
 		}
 	}];
 }

package/dist/plugins/go.d.ts

@@ -1,4 +1,4 @@
-import { A as WorkspacePackage, P as BumpType, s as TegamiPlugin } from "../types-B50RK1rR.js";
+import { A as WorkspacePackage, P as BumpType, s as TegamiPlugin } from "../types-DEyZ2r-2.js";
 
 //#region src/plugins/go.d.ts
 interface GoModFile {

package/dist/providers/npm.d.ts

@@ -1,2 +1,2 @@
-import { C as NpmPackage, S as NpmGraph, l as NpmPluginOptions, u as npm, x as DependencySpec } from "../types-B50RK1rR.js";
+import { C as NpmPackage, S as NpmGraph, l as NpmPluginOptions, u as npm, x as DependencySpec } from "../types-DEyZ2r-2.js";
 export { type DependencySpec, type NpmGraph, NpmPackage, NpmPluginOptions, npm };

package/dist/providers/npm.js

@@ -1,2 +1,2 @@
-import { n as NpmPackage, t as npm } from "../npm-DoPhFKji.js";
+import { n as NpmPackage, t as npm } from "../npm-CaBYeOeV.js";
 export { NpmPackage, npm };

package/dist/{types-B50RK1rR.d.ts → types-DEyZ2r-2.d.ts}

@@ -582,6 +582,18 @@ interface PackagePublishPlan {
 interface PublishOptions {
   /** Validate the publish plan without publishing packages, creating tags, or running release plugins. */
   dryRun?: boolean;
+  /**
+   * Publish only the given packages and their dependencies.
+   *
+   * Each entry can be a package id, package name, or `group:name`.
+   */
+  packages?: string[];
+  /**
+   * The max amount of concurrent publishes (unstable, can change in anytime).
+   *
+   * @default 5
+   */
+  unstable_maxChunk?: number;
 }
 type PackagePublishResult = {
   type: "published" | "skipped";
@@ -628,9 +640,9 @@ interface Tegami {
    *
    * Prefer `publish()` over this if you are publishing packages, it will also check the publish status.
    */
-  publishStatus(): Promise<"pending" | "success" | "idle">;
+  publishStatus(options?: PublishOptions): Promise<"pending" | "success" | "idle">;
   /** Remove the publish lock file after publishing has finished successfully. */
-  cleanup(): Promise<{
+  cleanup(options?: PublishOptions): Promise<{
     state: "removed";
   } | {
     state: "skipped";
@@ -647,13 +659,17 @@ interface Tegami {
 declare function tegami<const Groups extends string = string>(options?: TegamiOptions<Groups>): Tegami;
 //#endregion
 //#region src/cli/core.d.ts
-interface TegamiCliCommand<Values extends Record<string, boolean | string | undefined>, Positionals extends Record<string, string | undefined>> {
-  option<const Name extends string, const T extends "string" | "boolean">(name: Name, opts: {
+type ArgValue = boolean | string | string[] | boolean[];
+type PositionalValue = string | string[];
+interface TegamiCliCommand<Values extends Record<string, ArgValue | undefined>, Positionals extends Record<string, PositionalValue | undefined>> {
+  option<const Name extends string, const T extends "string" | "boolean", const Multiple extends boolean = false>(name: Name, opts: {
     type: T;
     short?: string;
     description?: string;
-  }): TegamiCliCommand<Values & { [k in Name]?: T extends "string" ? string : boolean }, Positionals>;
+    multiple?: Multiple;
+  }): TegamiCliCommand<Values & { [k in Name]?: Multiple extends true ? T extends "string" ? string[] : boolean[] : T extends "string" ? string : boolean }, Positionals>;
   positional<const Name extends string, const Required extends boolean = true>(name: Name, required?: Required): TegamiCliCommand<Values, Positionals & { [K in Name]: Required extends true ? string : string | undefined }>;
+  positionals<const Name extends string>(name: Name): TegamiCliCommand<Values, Positionals & { [K in Name]: string[] }>;
   action(fn: (options: {
     context: TegamiContext;
     values: Values;
@@ -839,6 +855,10 @@ interface TegamiPlugin {
   resolvePlanStatus?(this: TegamiContext, opts: {
     plan: PublishPlan;
   }): Awaitable<"success" | "pending" | undefined | void | Awaitable<"success" | "pending" | undefined>[]>;
+  /** Called after preflights, before Tegami starts publishing the packages of a plan. */
+  beforePublishAll?(this: TegamiContext, opts: {
+    plan: PublishPlan;
+  }): Awaitable<void>;
   /** Called before a package will be published, return `false` to prevent from publishing. */
   willPublish?(this: TegamiContext, opts: {
     pkg: WorkspacePackage;
@@ -861,17 +881,23 @@ type Awaitable<T> = T | Promise<T>;
 type RequireFields<Obj, K extends keyof Obj> = Obj & { [R in K]-?: NonNullable<Obj[R]> };
 interface PublishPreflight {
   /**
-   * Whether the package should be published, the state **must not** be changed across different runs.
+   * Whether the package should be published, the state **must only depend on local inputs** (e.g. local `package.json` or `publish-lock.yaml`).
    *
    * To note if the package is already published, hook `resolvePlanStatus` on plugins, or skip at publish-time.
    */
   shouldPublish: boolean;
   /**
-   * Package ids that must be published before this one, this will automatically disallow circular dependency.
+   * Package ids that **must be** published before this one, this disallows circular dependency.
    *
-   * It is okay to add unpublished packages to `wait`, they will be ignored.
+   * It is okay to add unpublished packages, they will be ignored.
    */
   wait?: string[];
+  /**
+   * Package ids that **are preferred** to publish before this one, this allows circular dependency.
+   *
+   * It is okay to add unpublished packages, they will be ignored.
+   */
+  optionalWait?: string[];
 }
 //#endregion
 export { WorkspacePackage as A, NpmPackage as C, cargo as D, CargoPluginOptions as E, DraftPolicy as M, PackageDraft as N, PackageGraph as O, BumpType as P, NpmGraph as S, CargoPackage as T, PublishOptions as _, PublishPreflight as a, TegamiContext as b, TegamiPluginOption as c, GenerateChangelogOptions as d, Tegami as f, PackagePublishResult as g, PackagePublishPlan as h, PackageOptions as i, Draft as j, PackageGroup as k, NpmPluginOptions as l, PublishLock as m, GroupOptions as n, TegamiOptions as o, tegami as p, LogGenerator as r, TegamiPlugin as s, Awaitable as t, npm as u, PublishPlan as v, CargoGraph as w, DependencySpec as x, CommitChangelog as y };

package/dist/version-request-DlLpLLK3.js

@@ -0,0 +1,445 @@
+import { r as formatNpmDistTag } from "./semver-EKJ8yK5U.js";
+import { n as execFailure, o as isCI } from "./error-BhMYq9iW.js";
+import { t as _accessExpressionAsString } from "./_accessExpressionAsString-QhbUZzwv.js";
+import { n as _validateReport, t as _createStandardSchema } from "./_createStandardSchema-BGQyz-uA.js";
+import { i as parsePublishLock } from "./draft-CzUiQasJ.js";
+import { readFile, writeFile } from "node:fs/promises";
+import { x } from "tinyexec";
+//#region src/utils/version-request.ts
+const validatePublishGroupStore = (() => {
+	const _io0 = (input) => Array.isArray(input.active) && input.active.every((elem) => "object" === typeof elem && null !== elem && _io1(elem)) && Array.isArray(input.pending) && input.pending.every((elem) => "object" === typeof elem && null !== elem && _io1(elem)) && "object" === typeof input.versions && null !== input.versions && false === Array.isArray(input.versions) && _io2(input.versions);
+	const _io1 = (input) => "string" === typeof input.title && "string" === typeof input.branch && Array.isArray(input.packages) && input.packages.every((elem) => "string" === typeof elem);
+	const _io2 = (input) => Object.keys(input).every((key) => {
+		const value = input[key];
+		if (void 0 === value) return true;
+		return "string" === typeof value;
+	});
+	const _vo0 = (input, _path, _exceptionable = true) => [
+		(Array.isArray(input.active) || _report(_exceptionable, {
+			path: _path + ".active",
+			expected: "Array<PublishGroup>",
+			value: input.active
+		})) && input.active.map((elem, _index4) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+			path: _path + ".active[" + _index4 + "]",
+			expected: "PublishGroup",
+			value: elem
+		})) && _vo1(elem, _path + ".active[" + _index4 + "]", _exceptionable) || _report(_exceptionable, {
+			path: _path + ".active[" + _index4 + "]",
+			expected: "PublishGroup",
+			value: elem
+		})).every((flag) => flag) || _report(_exceptionable, {
+			path: _path + ".active",
+			expected: "Array<PublishGroup>",
+			value: input.active
+		}),
+		(Array.isArray(input.pending) || _report(_exceptionable, {
+			path: _path + ".pending",
+			expected: "Array<PublishGroup>",
+			value: input.pending
+		})) && input.pending.map((elem, _index5) => ("object" === typeof elem && null !== elem || _report(_exceptionable, {
+			path: _path + ".pending[" + _index5 + "]",
+			expected: "PublishGroup",
+			value: elem
+		})) && _vo1(elem, _path + ".pending[" + _index5 + "]", _exceptionable) || _report(_exceptionable, {
+			path: _path + ".pending[" + _index5 + "]",
+			expected: "PublishGroup",
+			value: elem
+		})).every((flag) => flag) || _report(_exceptionable, {
+			path: _path + ".pending",
+			expected: "Array<PublishGroup>",
+			value: input.pending
+		}),
+		("object" === typeof input.versions && null !== input.versions && false === Array.isArray(input.versions) || _report(_exceptionable, {
+			path: _path + ".versions",
+			expected: "Record<string, string>",
+			value: input.versions
+		})) && _vo2(input.versions, _path + ".versions", _exceptionable) || _report(_exceptionable, {
+			path: _path + ".versions",
+			expected: "Record<string, string>",
+			value: input.versions
+		})
+	].every((flag) => flag);
+	const _vo1 = (input, _path, _exceptionable = true) => [
+		"string" === typeof input.title || _report(_exceptionable, {
+			path: _path + ".title",
+			expected: "string",
+			value: input.title
+		}),
+		"string" === typeof input.branch || _report(_exceptionable, {
+			path: _path + ".branch",
+			expected: "string",
+			value: input.branch
+		}),
+		(Array.isArray(input.packages) || _report(_exceptionable, {
+			path: _path + ".packages",
+			expected: "Array<string>",
+			value: input.packages
+		})) && input.packages.map((elem, _index6) => "string" === typeof elem || _report(_exceptionable, {
+			path: _path + ".packages[" + _index6 + "]",
+			expected: "string",
+			value: elem
+		})).every((flag) => flag) || _report(_exceptionable, {
+			path: _path + ".packages",
+			expected: "Array<string>",
+			value: input.packages
+		})
+	].every((flag) => flag);
+	const _vo2 = (input, _path, _exceptionable = true) => [false === _exceptionable || Object.keys(input).map((key) => {
+		const value = input[key];
+		if (void 0 === value) return true;
+		return "string" === typeof value || _report(_exceptionable, {
+			path: _path + _accessExpressionAsString(key),
+			expected: "string",
+			value
+		});
+	}).every((flag) => flag)].every((flag) => flag);
+	const __is = (input) => "object" === typeof input && null !== input && _io0(input);
+	let errors;
+	let _report;
+	return _createStandardSchema((input) => {
+		if (false === __is(input)) {
+			errors = [];
+			_report = _validateReport(errors);
+			((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || _report(true, {
+				path: _path + "",
+				expected: "PublishGroupStore",
+				value: input
+			})) && _vo0(input, _path + "", true) || _report(true, {
+				path: _path + "",
+				expected: "PublishGroupStore",
+				value: input
+			}))(input, "$input", true);
+			const success = 0 === errors.length;
+			return success ? {
+				success,
+				data: input
+			} : {
+				success,
+				errors,
+				data: input
+			};
+		}
+		return {
+			success: true,
+			data: input
+		};
+	});
+})();
+function onVersionRequest(provider) {
+	const namespace = `${provider.name}:publish-group`;
+	/** package id -> version before applying the CLI draft */
+	const snapshots = /* @__PURE__ */ new Map();
+	/** publish group state restored from the lock, publish-time only */
+	let store;
+	function resolveConfig() {
+		if (provider.options === false) return;
+		const { forceCreate = false, branch = "tegami/version-packages", base = "main", groups, create } = provider.options ?? {};
+		return {
+			forceCreate,
+			branch,
+			base,
+			groups,
+			create
+		};
+	}
+	async function createDraftRequest(context, config, draft, versions, group) {
+		const custom = await config.create?.call(context, {
+			draft,
+			publishGroup: group?.packages
+		});
+		return {
+			title: custom?.title ?? group?.title ?? "Version Packages",
+			body: custom?.body ?? renderRequestBody(draftRequestItems(context, draft, versions, group), provider.summary)
+		};
+	}
+	async function upsertRequest(context, request) {
+		const handle = await provider.find(context, {
+			head: request.head,
+			base: request.base
+		});
+		if (handle !== void 0) await provider.update(context, handle, request);
+		else await provider.create(context, request);
+	}
+	return {
+		/** snapshot package versions, hook into `initCliDraft` */
+		initCliDraft() {
+			for (const pkg of this.graph.getPackages()) snapshots.set(pkg.id, pkg.version);
+		},
+		/** commit & push version branches, then upsert their requests, hook into `applyCliDraft` */
+		async applyCliDraft(draft) {
+			const config = resolveConfig();
+			if (!config || !provider.enabled(this)) return;
+			if (!(config.forceCreate || isCI()) || !await hasGitChanges(this.cwd)) return;
+			/** package id -> version before the bump */
+			const versions = {};
+			for (const id of draft.getPackageDrafts().keys()) {
+				const pkg = this.graph.get(id);
+				const original = snapshots.get(id);
+				if (!pkg?.version || !original || original === pkg.version) continue;
+				versions[id] = original;
+			}
+			const groups = resolvePublishGroups(this, config.branch, config.groups, versions);
+			if (groups.length === 0) {
+				const request = await createDraftRequest(this, config, draft, versions);
+				await createVersionCommit(this.cwd, request.title);
+				await pushBranch(this.cwd, config.branch);
+				await upsertRequest(this, {
+					...request,
+					head: config.branch,
+					base: config.base
+				});
+				return;
+			}
+			const requests = [];
+			for (const group of groups) {
+				const request = await createDraftRequest(this, config, draft, versions, group);
+				group.title = request.title;
+				requests.push(request);
+			}
+			await createVersionCommit(this.cwd, "Version Packages");
+			const versionCommit = await run(this.cwd, ["rev-parse", "HEAD"], "Failed to resolve the version commit.");
+			if (!versionCommit) throw new Error("Failed to resolve the version commit.");
+			/** lock content of the version commit, without publish groups */
+			const lockContent = await readFile(this.lockPath, "utf8");
+			for (let i = 0; i < groups.length; i++) {
+				const group = groups[i];
+				const request = requests[i];
+				if (i > 0) await run(this.cwd, [
+					"checkout",
+					"--detach",
+					versionCommit
+				], "Failed to check out the version commit.");
+				const lock = parsePublishLock(lockContent);
+				lock.write(namespace, {
+					active: [group],
+					pending: groups.filter((other) => other !== group),
+					versions
+				});
+				await writeFile(this.lockPath, lock.serialize());
+				await commitChanges(this.cwd, request.title);
+				await pushBranch(this.cwd, group.branch);
+				await upsertRequest(this, {
+					...request,
+					head: group.branch,
+					base: config.base
+				});
+			}
+		},
+		/** restore publish groups from the lock into the plan, hook into `initPublishPlan` */
+		initPublishPlan({ lock, plan }) {
+			store = void 0;
+			let data;
+			const entries = [];
+			while ((data = lock.read(namespace)) !== void 0) {
+				const validated = validatePublishGroupStore(data);
+				if (validated.success) entries.push(validated.data);
+			}
+			if (entries.length === 0) return;
+			const merged = {
+				active: [],
+				pending: [],
+				versions: {}
+			};
+			const seen = /* @__PURE__ */ new Set();
+			for (const entry of entries) {
+				Object.assign(merged.versions, entry.versions);
+				for (const group of entry.active) {
+					if (seen.has(group.branch)) continue;
+					seen.add(group.branch);
+					merged.active.push(group);
+				}
+			}
+			for (const entry of entries) for (const group of entry.pending) {
+				if (seen.has(group.branch)) continue;
+				seen.add(group.branch);
+				merged.pending.push(group);
+			}
+			store = merged;
+			const packages = new Set(plan.options.packages);
+			for (const group of merged.active) for (const name of group.packages) packages.add(name);
+			if (packages.size > 0) plan.options = {
+				...plan.options,
+				packages: Array.from(packages)
+			};
+		},
+		/** report `pending` while publish groups are waiting for their request, hook into `resolvePlanStatus` */
+		resolvePlanStatus() {
+			if (store && store.pending.length > 0) return "pending";
+		},
+		/** re-sync the version requests of pending publish groups, hook into `beforePublishAll` */
+		async beforePublishAll({ plan }) {
+			if (!store || store.pending.length === 0 || plan.options.dryRun) return;
+			const config = resolveConfig();
+			if (!config || !provider.enabled(this)) return;
+			const head = await run(this.cwd, ["rev-parse", "HEAD"], "Failed to resolve the current commit.");
+			const ref = await run(this.cwd, [
+				"rev-parse",
+				"--abbrev-ref",
+				"HEAD"
+			], "Failed to resolve the current branch.");
+			const lockContent = await readFile(this.lockPath, "utf8");
+			try {
+				for (const group of store.pending) {
+					const lock = parsePublishLock(lockContent);
+					while (lock.read(namespace) !== void 0);
+					lock.write(namespace, {
+						active: [...store.active, group],
+						pending: store.pending.filter((other) => other !== group),
+						versions: store.versions
+					});
+					await run(this.cwd, [
+						"checkout",
+						"--detach",
+						head
+					], "Failed to check out the current commit.");
+					await writeFile(this.lockPath, lock.serialize());
+					await commitChanges(this.cwd, group.title);
+					await pushBranch(this.cwd, group.branch);
+					await upsertRequest(this, {
+						title: group.title,
+						body: renderRequestBody(planRequestItems(this, plan, store.versions, group), provider.summary),
+						head: group.branch,
+						base: config.base
+					});
+				}
+			} finally {
+				await run(this.cwd, ["checkout", ref === "HEAD" ? head : ref], "Failed to restore the original checkout.");
+			}
+		}
+	};
+}
+function resolvePublishGroups(context, branch, groups, versions) {
+	if (!groups?.length) return [];
+	const out = [];
+	const matched = /* @__PURE__ */ new Set();
+	for (const entry of groups) {
+		const members = Array.isArray(entry) ? entry : [entry];
+		let hasMatched = false;
+		for (const name of members) for (const pkg of context.graph.getByName(name)) if (pkg.id in versions && !matched.has(pkg.id)) {
+			hasMatched = true;
+			matched.add(pkg.id);
+		}
+		if (!hasMatched) continue;
+		const slug = members.map(branchSlug).filter(Boolean).join("-") || "group";
+		out.push({
+			title: `Release ${members.join(", ")}`,
+			branch: `${branch}/${slug}`,
+			packages: members
+		});
+	}
+	const unlisted = Object.keys(versions).filter((id) => !matched.has(id));
+	if (unlisted.length > 0) out.push({
+		title: "Release unlisted packages",
+		branch: `${branch}/unlisted`,
+		packages: unlisted
+	});
+	return out;
+}
+function branchSlug(name) {
+	return name.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function resolveMembers(context, group) {
+	const ids = /* @__PURE__ */ new Set();
+	for (const name of group.packages) for (const pkg of context.graph.getByName(name)) ids.add(pkg.id);
+	return ids;
+}
+function draftRequestItems(context, draft, versions, group) {
+	const members = group ? resolveMembers(context, group) : void 0;
+	const items = [];
+	for (const [id, packageDraft] of draft.getPackageDrafts()) {
+		if (members && !members.has(id)) continue;
+		const pkg = context.graph.get(id);
+		if (!pkg) continue;
+		items.push({
+			pkg,
+			from: versions[id],
+			changelogs: packageDraft.changelogs ?? [],
+			distTag: packageDraft.npm?.distTag
+		});
+	}
+	return items;
+}
+function planRequestItems(context, plan, versions, group) {
+	const items = [];
+	for (const id of resolveMembers(context, group)) {
+		const pkg = context.graph.get(id);
+		const packagePlan = plan.packages.get(id);
+		if (!pkg || !packagePlan) continue;
+		items.push({
+			pkg,
+			from: versions[id],
+			changelogs: packagePlan.changelogs,
+			distTag: packagePlan.npm?.distTag
+		});
+	}
+	return items;
+}
+function renderRequestBody(items, summary) {
+	const packageLines = [];
+	const changesets = /* @__PURE__ */ new Map();
+	for (const { pkg, from, changelogs, distTag } of items) {
+		for (const entry of changelogs) {
+			const list = changesets.get(entry);
+			if (list) list.push(pkg);
+			else changesets.set(entry, [pkg]);
+		}
+		if (!from || from === pkg.version) continue;
+		packageLines.push(`| \`${pkg.name}\` | \`${from}\` | \`${pkg.version}\`${formatNpmDistTag(distTag)} |`);
+	}
+	const changelogLines = [];
+	for (const [entry, linkedPackages] of changesets) {
+		changelogLines.push(`### ${entry.subject ?? `\`${entry.filename}\``}`, "");
+		changelogLines.push("<details>", `<summary>Show Bumped Packages (${linkedPackages.length})</summary>`, "", ...linkedPackages.map((pkg) => `- \`${pkg.id}\``), "", "</details>", "");
+		for (const section of entry.sections) {
+			changelogLines.push(`#### ${section.title}`, "");
+			if (section.content) changelogLines.push(section.content);
+		}
+	}
+	const sections = [
+		"## Summary",
+		"",
+		summary,
+		""
+	];
+	if (packageLines.length > 0) sections.push("| Package | From | To |", "| --- | --- | --- |", ...packageLines);
+	if (changelogLines.length > 0) sections.push("", "## Changelogs", ...changelogLines);
+	sections.push("");
+	return sections.join("\n");
+}
+async function run(cwd, args, message) {
+	const result = await x("git", args, { nodeOptions: { cwd } });
+	if (result.exitCode !== 0) throw execFailure(message, result);
+	return result.stdout.trim();
+}
+async function hasGitChanges(cwd) {
+	return (await run(cwd, ["status", "--porcelain"], "Failed to check git status.")).length > 0;
+}
+async function commitChanges(cwd, title) {
+	await run(cwd, ["add", "-A"], "Failed to stage version changes.");
+	await run(cwd, [
+		"commit",
+		"-m",
+		title
+	], "Failed to commit version changes.");
+}
+/** commit the working tree changes onto a detached HEAD */
+async function createVersionCommit(cwd, title) {
+	await run(cwd, ["checkout", "--detach"], "Failed to detach HEAD for version branches.");
+	await commitChanges(cwd, title);
+}
+async function pushBranch(cwd, branch) {
+	await run(cwd, [
+		"checkout",
+		"-B",
+		branch
+	], "Failed to create the version branch.");
+	await run(cwd, [
+		"push",
+		"--force",
+		"-u",
+		"origin",
+		branch
+	], "Failed to push the version branch to origin. Ensure `origin` is configured and you have push access.");
+}
+//#endregion
+export { onVersionRequest as t };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "tegami",
-  "version": "1.1.2",
-  "description": "Utility for package versioning & publish",
+  "version": "1.1.3",
+  "description": "A tool to manage changelogs, versioning, and publishing in monorepo",
   "license": "MIT",
   "author": "Fuma Nama",
   "repository": {