tegami 1.0.0-beta.2 → 1.0.0-beta.4

package/dist/plugins/github.js

@@ -1,10 +1,316 @@
 import { i as formatPackageVersion, r as formatNpmDistTag } from "../semver-EKJ8yK5U.js";
-import { a as isCI, n as execFailure } from "../error-D3dwQnwR.js";
-import { a as findOpenPullRequest, l as updatePullRequest, n as createPullRequest, r as createRelease, s as releaseExistsByTag } from "../api-D-jf_8xY.js";
+import { t as changelogFilename } from "../generate-BfYdNTFi.js";
+import { a as cached, n as execFailure, o as isCI } from "../error-We7chQVJ.js";
+import { n as createDraft, o as readChangelogEntries } from "../draft-DtFyGxe8.js";
 import { git } from "./git.js";
-import { join, relative } from "node:path";
+import { n as createVersionRequestBody, r as hasGitChanges, t as commitVersionBranchChanges } from "../version-request-cFS0Suzd.js";
+import { readFile, writeFile } from "node:fs/promises";
+import { basename, join, relative, resolve } from "node:path";
 import { x } from "tinyexec";
 import semver from "semver";
+import z from "zod";
+import { resolveCommand } from "package-manager-detector";
+import { note, outro } from "@clack/prompts";
+//#region src/plugins/github/api.ts
+function parseGitHubRepo(repo) {
+	const [owner, name] = repo.split("/", 2);
+	if (!owner || !name) throw new Error(`Invalid GitHub repository: ${repo}`);
+	return {
+		owner,
+		repo: name
+	};
+}
+async function githubRequest(path, token, init = {}) {
+	const headers = new Headers(init.headers);
+	headers.set("Accept", "application/vnd.github+json");
+	headers.set("X-GitHub-Api-Version", "2022-11-28");
+	if (token) headers.set("Authorization", `Bearer ${token}`);
+	return fetch(`https://api.github.com${path}`, {
+		...init,
+		headers
+	});
+}
+async function releaseExistsByTag(repo, tag, token) {
+	const { owner, repo: name } = parseGitHubRepo(repo);
+	const response = await githubRequest(`/repos/${owner}/${name}/releases/tags/${encodeURIComponent(tag)}`, token, { method: "HEAD" });
+	if (response.status === 404) return false;
+	if (!response.ok) throw new Error(`Failed to get GitHub release for ${tag}.`);
+	return true;
+}
+async function createRelease(repo, options) {
+	const { owner, repo: name } = parseGitHubRepo(repo);
+	if (!(await githubRequest(`/repos/${owner}/${name}/releases`, options.token, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({
+			tag_name: options.tag,
+			name: options.title,
+			body: options.notes,
+			prerelease: options.prerelease ?? false
+		})
+	})).ok) throw new Error(`Failed to create GitHub release for ${options.tag}.`);
+}
+async function findOpenPullRequest(repo, headBranch, token) {
+	const { owner, repo: name } = parseGitHubRepo(repo);
+	const response = await githubRequest(`/repos/${owner}/${name}/pulls?${new URLSearchParams({
+		head: `${owner}:${headBranch}`,
+		state: "open"
+	})}`, token);
+	if (!response.ok) throw new Error("Failed to check for an existing version pull request.");
+	return (await response.json())[0]?.number;
+}
+async function updatePullRequest(repo, number, options) {
+	const { owner, repo: name } = parseGitHubRepo(repo);
+	if (!(await githubRequest(`/repos/${owner}/${name}/pulls/${number}`, options.token, {
+		method: "PATCH",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({
+			title: options.title,
+			body: options.body
+		})
+	})).ok) throw new Error("Failed to update the version pull request.");
+}
+async function createPullRequest(repo, options) {
+	const { owner, repo: name } = parseGitHubRepo(repo);
+	if (!(await githubRequest(`/repos/${owner}/${name}/pulls`, options.token, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({
+			title: options.title,
+			body: options.body,
+			head: options.head,
+			base: options.base
+		})
+	})).ok) throw new Error("Failed to create the version pull request.");
+}
+async function listPullRequestsForCommit(repo, commitSha, token) {
+	const { owner, repo: name } = parseGitHubRepo(repo);
+	const response = await githubRequest(`/repos/${owner}/${name}/commits/${commitSha}/pulls`, token);
+	if (!response.ok) throw new Error(`Failed to list pull requests for commit ${commitSha.slice(0, 7)}.`);
+	return await response.json();
+}
+async function getPullRequest(repo, number, token) {
+	const { owner, repo: name } = parseGitHubRepo(repo);
+	const response = await githubRequest(`/repos/${owner}/${name}/pulls/${number}`, token);
+	if (!response.ok) throw new Error(`Failed to resolve pull request #${number}.`);
+	const data = await response.json();
+	return {
+		headRefName: data.head.ref,
+		baseRefOid: data.base.sha,
+		headRefOid: data.head.sha,
+		headRepository: data.head.repo
+	};
+}
+async function findIssueCommentByPrefix(repo, issueNumber, prefix, token) {
+	const { owner, repo: name } = parseGitHubRepo(repo);
+	let page = 1;
+	while (true) {
+		const response = await githubRequest(`/repos/${owner}/${name}/issues/${issueNumber}/comments?per_page=100&page=${page}`, token);
+		if (!response.ok) throw new Error("Failed to list pull request comments.");
+		const batch = await response.json();
+		if (batch.length === 0) break;
+		const comment = batch.find((comment) => comment.body.startsWith(prefix));
+		if (comment) return comment.id;
+		if (batch.length < 100) break;
+		page += 1;
+	}
+}
+async function updateIssueComment(repo, commentId, body, token) {
+	const { owner, repo: name } = parseGitHubRepo(repo);
+	if (!(await githubRequest(`/repos/${owner}/${name}/issues/comments/${commentId}`, token, {
+		method: "PATCH",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({ body })
+	})).ok) throw new Error("Failed to update pull request comment.");
+}
+async function createIssueComment(repo, issueNumber, body, token) {
+	const { owner, repo: name } = parseGitHubRepo(repo);
+	if (!(await githubRequest(`/repos/${owner}/${name}/issues/${issueNumber}/comments`, token, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({ body })
+	})).ok) throw new Error("Failed to create pull request comment.");
+}
+//#endregion
+//#region src/plugins/github/cli.ts
+const COMMENT_MARKER = "<!-- tegami -->";
+function registerPrCli(cli) {
+	cli.command("pr preview", { description: "show a pull request release preview and changelog guidance" }).option("artifact", {
+		type: "string",
+		description: "write preview markdown to a file"
+	}).option("number", {
+		type: "string",
+		description: "pull request number"
+	}).action(async ({ context, values }) => {
+		const number = values.number ? parsePositiveInt(values.number, "--number") : void 0;
+		const artifact = values.artifact;
+		const body = await buildPrPreview(context, await createDraft(await readChangelogEntries(context), context), { number });
+		if (artifact) {
+			const artifactPath = resolve(context.cwd, artifact);
+			await writeFile(artifactPath, body);
+			if (!isCI()) {
+				note(relative(context.cwd, artifactPath) || artifact, "Release preview");
+				outro("Release preview ready.");
+			}
+			return;
+		}
+		if (isCI()) {
+			process.stdout.write(`${body}\n`);
+			return;
+		}
+		note(body, "Release preview");
+		outro("Release preview ready.");
+	});
+	cli.command("pr comment", { description: "post the pull request release preview as a comment" }).positional("artifact").action(async ({ context, positionals }) => {
+		await postPrComment(context, await readFile(positionals.artifact, "utf8"));
+		outro("Pull request comment updated.");
+	});
+}
+async function buildPrPreview(context, draft, options = {}) {
+	const pullRequest = await resolvePullRequest(context, options);
+	const tegamiCommandRaw = resolveCommand(context.npm?.client ?? "npm", "run", ["tegami"]);
+	const tegamiCommand = [tegamiCommandRaw.command, ...tegamiCommandRaw.args].join(" ");
+	const changelogFiles = await listPullRequestChangelogFiles(context, pullRequest.baseSha, pullRequest.headSha);
+	const createLink = createChangelogUrl(context, pullRequest.headRepo, pullRequest.headRef, changelogFilename());
+	const pendingPackages = [];
+	const lines = [
+		"### Tegami",
+		"",
+		`This repository uses [Tegami](https://tegami.fuma-nama.dev) to manage releases. When your changes affect published packages, add a changelog file under \`.tegami/\` before merging.`,
+		"",
+		`[**Create a changelog →**](${createLink}) · [Changelog format](https://tegami.fuma-nama.dev/changelog)`,
+		""
+	];
+	for (const pkg of context.graph.getPackages()) {
+		const plan = draft.getPackageDraft(pkg.id);
+		if (!plan) continue;
+		const bumped = plan.bumpVersion(pkg);
+		if (!bumped || !pkg.version || bumped === pkg.version) continue;
+		pendingPackages.push({
+			name: pkg.name,
+			type: plan.type ?? "—",
+			from: pkg.version,
+			to: bumped,
+			distTag: plan.npm?.distTag
+		});
+	}
+	const requestChangelogs = draft.getChangelogs().filter((entry) => changelogFiles.has(entry.filename));
+	if (pendingPackages.length > 0) {
+		lines.push("#### Release preview", "", "| Package | Bump | Version |", "| --- | --- | --- |");
+		for (const { name, type, from, to, distTag } of pendingPackages) lines.push(`| \`${name}\` | ${type} | \`${from}\` → \`${to}\`${formatNpmDistTag(distTag)} |`);
+		lines.push("");
+	}
+	if (requestChangelogs.length > 0) {
+		lines.push("#### Changelogs in this PR", "", "| Changelog | Title |", "| --- | --- |");
+		for (const entry of requestChangelogs) for (const section of entry.sections) lines.push(`| \`${entry.filename}\` | ${section.title} |`);
+		lines.push("");
+	} else if (pendingPackages.length === 0) lines.push("#### No changelogs yet", "", "This PR has no pending changelog files. If your changes require a release, add a changelog before merging.", "");
+	else if (changelogFiles.size === 0) lines.push("This PR does not add changelog files. Pending changelogs from other branches are included in the preview above.", "");
+	lines.push(`Run \`${tegamiCommand}\` locally to create a changelog interactively.`, "", `<sub>Managed by [Tegami](https://tegami.fuma-nama.dev).</sub>`, "");
+	return lines.join("\n");
+}
+async function postPrComment(context, body) {
+	const { repo, token } = context.github ?? {};
+	if (!repo) {
+		outro("GitHub plugin context is required.");
+		return;
+	}
+	const pr = await readPullRequestFromWorkflowRunEvent();
+	if (!pr.found) {
+		outro(pr.reason);
+		return;
+	}
+	const markedBody = `${COMMENT_MARKER}\n${body}`;
+	const existingId = await findIssueCommentByPrefix(repo, pr.number, COMMENT_MARKER, token);
+	if (existingId) {
+		await updateIssueComment(repo, existingId, markedBody, token);
+		return;
+	}
+	await createIssueComment(repo, pr.number, markedBody, token);
+}
+async function resolvePullRequest(context, options) {
+	const { repo, token } = context.github ?? {};
+	if (!repo) throw new Error("GitHub plugin context is required.");
+	if (options.number !== void 0) {
+		parsePositiveInt(String(options.number), "--number");
+		const data = await getPullRequest(repo, options.number, token);
+		return {
+			headRepo: data.headRepository ? `${data.headRepository.owner.login}/${data.headRepository.name}` : repo,
+			headRef: data.headRefName,
+			baseSha: data.baseRefOid,
+			headSha: data.headRefOid
+		};
+	}
+	const eventPath = process.env.GITHUB_EVENT_PATH;
+	if (eventPath) try {
+		const pullRequest = JSON.parse(await readFile(eventPath, "utf8")).pull_request;
+		if (pullRequest) return {
+			headRepo: pullRequest.head.repo.full_name,
+			headRef: pullRequest.head.ref,
+			baseSha: pullRequest.base.sha,
+			headSha: pullRequest.head.sha
+		};
+	} catch {}
+	throw new Error("A pull request event or --number is required.");
+}
+const workflowRunEventSchema = z.object({ workflow_run: z.object({
+	event: z.literal("pull_request", { error: "The preview workflow was not triggered by a pull request." }),
+	conclusion: z.literal("success", { error: "The preview workflow did not complete successfully." }),
+	pull_requests: z.array(z.object({ number: z.int() }), { error: "The preview workflow is not associated with a pull request." }).min(1)
+}, { error: "A workflow_run event is required." }) });
+async function readPullRequestFromWorkflowRunEvent() {
+	const eventPath = process.env.GITHUB_EVENT_PATH;
+	if (!eventPath) return {
+		found: false,
+		reason: "GITHUB_EVENT_PATH is required."
+	};
+	let raw;
+	try {
+		raw = JSON.parse(await readFile(eventPath, "utf8"));
+	} catch {
+		return {
+			found: false,
+			reason: "Failed to read workflow_run event."
+		};
+	}
+	const { error, data } = workflowRunEventSchema.safeParse(raw);
+	if (error) return {
+		found: false,
+		reason: z.prettifyError(error)
+	};
+	return {
+		found: true,
+		number: data.workflow_run.pull_requests[0].number
+	};
+}
+async function listPullRequestChangelogFiles(context, baseSha, headSha) {
+	const dir = relative(context.cwd, context.changelogDir);
+	const result = await x("git", [
+		"diff",
+		"--name-only",
+		"--diff-filter=ACMRD",
+		`${baseSha}...${headSha}`,
+		"--",
+		`${dir}/`
+	], { nodeOptions: { cwd: context.cwd } });
+	if (result.exitCode !== 0) throw execFailure("Failed to list pull request changelog files.", result);
+	const files = /* @__PURE__ */ new Set();
+	for (const line of result.stdout.split("\n")) {
+		const trimmed = line.trim();
+		if (trimmed.endsWith(".md")) files.add(basename(trimmed));
+	}
+	return files;
+}
+function createChangelogUrl(context, repo, branch, filename) {
+	const filePath = join(relative(context.cwd, context.changelogDir), filename).replaceAll("\\", "/");
+	return `https://github.com/${repo}/new/${branch.split("/").map(encodeURIComponent).join("/")}?${new URLSearchParams({ filename: filePath })}`;
+}
+function parsePositiveInt(value, option) {
+	const number = Number(value);
+	if (!Number.isInteger(number) || number <= 0) throw new Error(`${option} must be a positive integer.`);
+	return number;
+}
+//#endregion
 //#region src/plugins/github.ts
 /** Create GitHub releases for successfully published packages after the whole plan succeeds. */
 function github(options = {}) {
@@ -13,48 +319,7 @@ function github(options = {}) {
 	function getRenderer(context) {
 		return renderer ??= createChangelogRenderer(context);
 	}
-	function resolvePROptions() {
-		const config = options.versionPr ?? {};
-		if (config === false) return [false];
-		if (config.forceCreate || isCI()) return [true, config];
-		return [false];
-	}
-	function defaultVersionPRBody(draft, context) {
-		const packageLines = [];
-		const changesets = /* @__PURE__ */ new Map();
-		for (const [id, packageDraft] of draft.getPackageDrafts()) {
-			const pkg = context.graph.get(id);
-			if (!pkg) continue;
-			for (const entry of packageDraft.changelogs ?? []) {
-				const list = changesets.get(entry);
-				if (list) list.push(pkg);
-				else changesets.set(entry, [pkg]);
-			}
-			const originalVersion = cliOriginalPackageVersions.get(pkg.id);
-			if (!originalVersion || originalVersion === pkg.version) continue;
-			packageLines.push(`| \`${pkg.name}\` | \`${originalVersion}\` | \`${pkg.version}\`${formatNpmDistTag(packageDraft.npm?.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",
-			"",
-			"Merge this PR to publish the versioned packages.",
-			""
-		];
-		if (packageLines.length > 0) sections.push("| Package | From | To |", "| --- | --- | --- |", ...packageLines);
-		if (changelogLines.length > 0) sections.push("", "## Changelogs", ...changelogLines);
-		sections.push("");
-		return sections.join("\n");
-	}
-	const cliOriginalPackageVersions = /* @__PURE__ */ new Map();
+	const cliSnapshots = /* @__PURE__ */ new Map();
 	return [git(options), {
 		name: "github",
 		init() {
@@ -124,84 +389,57 @@ function github(options = {}) {
 				});
 			}));
 		},
-		cli: {
-			async init() {
-				if (!isCI()) return;
-				const { repo, token } = this.github ?? {};
-				if (!token || !repo) return;
-				const result = await x("git", [
-					"remote",
-					"set-url",
-					"origin",
-					`https://x-access-token:${token}@github.com/${repo}.git`
-				], { nodeOptions: { cwd: this.cwd } });
-				if (result.exitCode !== 0) throw execFailure("Failed to configure git remote for GitHub Actions.", result);
-			},
-			draftCreated() {
-				for (const pkg of this.graph.getPackages()) cliOriginalPackageVersions.set(pkg.id, pkg.version);
-			},
-			async draftApplied(draft) {
-				const { cwd } = this;
-				const [enabled, config] = resolvePROptions();
-				if (!enabled || !await hasGitChanges(cwd)) return;
-				const repo = this.github?.repo;
-				const { branch = "tegami/version-packages", base = "main" } = config;
-				const basePR = await config.create?.call(this, { draft });
-				const pr = {
-					title: basePR?.title ?? "Version Packages",
-					body: basePR?.body ?? defaultVersionPRBody(draft, this)
-				};
-				const gitOptions = { nodeOptions: { cwd } };
-				let result = await x("git", [
-					"checkout",
-					"-B",
-					branch
-				], gitOptions);
-				if (result.exitCode !== 0) throw execFailure("Failed to create the version pull request branch.", result);
-				result = await x("git", ["add", "-A"], gitOptions);
-				if (result.exitCode !== 0) throw execFailure("Failed to stage version changes.", result);
-				result = await x("git", [
-					"commit",
-					"-m",
-					pr.title
-				], gitOptions);
-				if (result.exitCode !== 0) throw execFailure("Failed to commit version changes.", result);
-				result = await x("git", [
-					"push",
-					"--force",
-					"-u",
-					"origin",
-					branch
-				], gitOptions);
-				if (result.exitCode !== 0) throw execFailure("Failed to push the version branch to origin. Ensure `origin` is configured and you have push access.", result);
-				const token = this.github?.token;
-				if (!repo) return;
-				const openPr = await findOpenPullRequest(repo, branch, token);
-				if (openPr !== void 0) {
-					await updatePullRequest(repo, openPr, {
-						title: pr.title,
-						body: pr.body,
-						token
-					});
-					return;
-				}
-				await createPullRequest(repo, {
+		async initCli(cli) {
+			registerPrCli(cli);
+			if (!isCI()) return;
+			const { repo, token } = this.github ?? {};
+			if (!token || !repo) return;
+			const result = await x("git", [
+				"remote",
+				"set-url",
+				"origin",
+				`https://x-access-token:${token}@github.com/${repo}.git`
+			], { nodeOptions: { cwd: this.cwd } });
+			if (result.exitCode !== 0) throw execFailure("Failed to configure git remote for GitHub Actions.", result);
+		},
+		initCliDraft() {
+			for (const pkg of this.graph.getPackages()) cliSnapshots.set(pkg.id, pkg.version);
+		},
+		async applyCliDraft(draft) {
+			const config = options.versionPr ?? {};
+			if (config === false || !(config.forceCreate || isCI()) || !await hasGitChanges(this.cwd)) return;
+			const repo = this.github?.repo;
+			const { branch = "tegami/version-packages", base = "main" } = config;
+			const basePR = await config.create?.call(this, { draft });
+			const pr = {
+				title: basePR?.title ?? "Version Packages",
+				body: basePR?.body ?? createVersionRequestBody(draft, this, cliSnapshots, "Merge this PR to publish the versioned packages.")
+			};
+			await commitVersionBranchChanges(this.cwd, branch, pr.title);
+			const token = this.github?.token;
+			if (!repo) return;
+			const openPr = await findOpenPullRequest(repo, branch, token);
+			if (openPr !== void 0) {
+				await updatePullRequest(repo, openPr, {
 					title: pr.title,
 					body: pr.body,
-					head: branch,
-					base,
 					token
 				});
+				return;
 			}
+			await createPullRequest(repo, {
+				title: pr.title,
+				body: pr.body,
+				head: branch,
+				base,
+				token
+			});
 		}
 	}];
 }
-async function hasGitChanges(cwd) {
-	return (await x("git", ["status", "--porcelain"], { nodeOptions: { cwd } })).stdout.trim().length > 0;
-}
 function createChangelogRenderer(context) {
-	const cache = /* @__PURE__ */ new Map();
-	async function resolveFileCommit(filename) {
+	const { repo, token } = context.github;
+	const resolveFileCommit = cached((filename) => filename, async (filename) => {
 		const result = await x("git", [
 			"log",
 			"--diff-filter=A",
@@ -212,26 +450,50 @@ function createChangelogRenderer(context) {
 		], { nodeOptions: { cwd: context.cwd } });
 		if (result.exitCode !== 0) return;
 		return result.stdout.trim() || void 0;
-	}
-	function formatCommitLink(commit) {
-		const short = commit.slice(0, 7);
-		const repo = context.github?.repo;
-		if (!repo) return `\`${short}\``;
-		return `[${short}](https://github.com/${repo}/commit/${commit})`;
+	});
+	const resolveEntryMeta = cached((entry) => entry.id, async (entry) => {
+		const commit = await resolveFileCommit(entry.filename);
+		if (!commit || !repo) return {
+			commit,
+			pullRequests: []
+		};
+		return {
+			commit,
+			pullRequests: await listPullRequestsForCommit(repo, commit, token).catch(() => [])
+		};
+	});
+	function formatEntryDetails(meta) {
+		if (meta.pullRequests.length === 0) return;
+		const lines = [];
+		for (const pr of meta.pullRequests) {
+			let line = repo ? `- [#${pr.number} ${pr.title}](https://github.com/${repo}/pull/${pr.number})` : `- #${pr.number} ${pr.title}`;
+			if (pr.user) line += ` by @${pr.user.login}`;
+			lines.push(line);
+		}
+		return [
+			"<details>",
+			"<summary>Pull request & contributors</summary>",
+			"",
+			...lines,
+			"",
+			"</details>"
+		].join("\n");
 	}
 	return async (entry) => {
-		let commitPromise = cache.get(entry.filename);
-		if (!commitPromise) {
-			commitPromise = resolveFileCommit(entry.filename);
-			cache.set(entry.filename, commitPromise);
+		const meta = await resolveEntryMeta(entry);
+		let commitSuffix = "";
+		if (meta.commit) {
+			const short = meta.commit.slice(0, 7);
+			const link = repo ? `[${short}](https://github.com/${repo}/commit/${meta.commit})` : `\`${short}\``;
+			commitSuffix += ` (${link})`;
 		}
-		const commit = await commitPromise;
-		const commitSuffix = commit ? ` (${formatCommitLink(commit)})` : "";
 		const lines = [];
 		for (const section of entry.sections) {
 			lines.push(`### ${section.title}${commitSuffix}`, "");
 			if (section.content) lines.push(section.content, "");
 		}
+		const details = formatEntryDetails(meta);
+		if (details) lines.push(details);
 		return lines.join("\n").trim();
 	};
 }

package/dist/plugins/gitlab.d.ts

@@ -0,0 +1,84 @@
+import { D as WorkspacePackage, O as Draft, _ as PublishPlan, s as TegamiPlugin, t as Awaitable, w as TegamiContext } from "../types-DKZsadC8.js";
+import { GitPluginOptions } from "./git.js";
+
+//#region src/plugins/gitlab.d.ts
+interface GitlabRelease {
+  /** Release title */
+  title?: string;
+  /** Release notes */
+  notes?: string;
+}
+interface VersionMergeRequest {
+  /** Merge request title. */
+  title?: string;
+  /** Merge request body. */
+  body?: string;
+}
+interface VersionMergeRequestOptions {
+  /**
+   * Create the MR even outside of CI.
+   *
+   * @default false
+   */
+  forceCreate?: boolean;
+  /**
+   * Merge request branch.
+   *
+   * @default "tegami/version-packages"
+   */
+  branch?: string;
+  /**
+   * Merge request base branch.
+   *
+   * @default "main"
+   */
+  base?: string;
+  /** Override details for "Version Packages" MR. */
+  create?: (this: TegamiContext, opts: {
+    draft: Draft;
+  }) => Awaitable<VersionMergeRequest>;
+}
+/** Options for creating GitLab releases after a successful publish. */
+interface GitLabPluginOptions extends GitPluginOptions {
+  /** GitLab repository. */
+  repo?: string;
+  /** Optional GitLab token for Git & GitLab operations. */
+  token?: string;
+  /** GitLab API URL. Defaults to `https://gitlab.com/api/v4`. */
+  apiUrl?: string;
+  /** GitLab web URL. Defaults to `https://gitlab.com`. */
+  webUrl?: string;
+  /**
+   * Create GitLab release for published packages.
+   *
+   * @default true
+   */
+  release?: boolean | {
+    /**
+     * Create GitLab release immediately after successful publish, without waiting for others.
+     *
+     * @default false
+     */
+    eager?: boolean; /** Override release details for a single package. */
+    create?: (this: TegamiContext, opts: {
+      tag: string;
+      pkg: WorkspacePackage;
+      plan: PublishPlan;
+    }) => Awaitable<GitlabRelease>; /** Override release details when multiple packages share a git tag. */
+    createGrouped?: (this: TegamiContext, opts: {
+      tag: string;
+      packages: WorkspacePackage[];
+      plan: PublishPlan;
+    }) => Awaitable<GitlabRelease>;
+  };
+  /**
+   * (CLI only) Open a version merge request after versioning.
+   *
+   * Defaults to enabled in CI and disabled locally.
+   */
+  versionMr?: VersionMergeRequestOptions | false;
+}
+/** Create GitLab releases for successfully published packages after the whole plan succeeds. */
+declare function gitlab(options?: GitLabPluginOptions): TegamiPlugin[];
+//#endregion
+export { GitLabPluginOptions, gitlab };