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

package/dist/plugins/gitlab.js

@@ -0,0 +1,554 @@
+import { i as formatPackageVersion, r as formatNpmDistTag } from "../semver-EKJ8yK5U.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 { 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 { resolveCommand } from "package-manager-detector";
+import { note, outro } from "@clack/prompts";
+//#region src/plugins/gitlab/api.ts
+function parseGitLabRepo(repo) {
+	const projectPath = repo.replace(/^\/+|\/+$/g, "");
+	if (!projectPath || !projectPath.includes("/")) throw new Error(`Invalid GitLab repository: ${repo}`);
+	return {
+		projectPath,
+		encodedProjectPath: encodeURIComponent(projectPath)
+	};
+}
+function gitlabApiUrl(apiUrl = "https://gitlab.com/api/v4") {
+	return apiUrl.replace(/\/+$/, "");
+}
+function gitlabWebUrl(webUrl = "https://gitlab.com") {
+	return webUrl.replace(/\/+$/, "");
+}
+async function gitlabRequest(options, path, init = {}) {
+	const headers = new Headers(init.headers);
+	headers.set("Accept", "application/json");
+	if (options.token) headers.set(options.token.type === "job-token" ? "JOB-TOKEN" : "PRIVATE-TOKEN", options.token.value);
+	return fetch(`${gitlabApiUrl(options.apiUrl)}${path}`, {
+		...init,
+		headers
+	});
+}
+async function releaseExistsByTag(repo, tag, options = {}) {
+	const { encodedProjectPath } = parseGitLabRepo(repo);
+	const response = await gitlabRequest(options, `/projects/${encodedProjectPath}/releases/${encodeURIComponent(tag)}`, { method: "HEAD" });
+	if (response.status === 404) return false;
+	if (!response.ok) throw new Error(`Failed to get GitLab release for ${tag}.`);
+	return true;
+}
+async function createRelease(repo, options) {
+	const { encodedProjectPath } = parseGitLabRepo(repo);
+	if (!(await gitlabRequest(options, `/projects/${encodedProjectPath}/releases`, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({
+			tag_name: options.tag,
+			name: options.title,
+			description: options.notes
+		})
+	})).ok) throw new Error(`Failed to create GitLab release for ${options.tag}.`);
+}
+async function findOpenMergeRequest(repo, options) {
+	const { encodedProjectPath } = parseGitLabRepo(repo);
+	const params = new URLSearchParams({
+		source_branch: options.head,
+		state: "opened"
+	});
+	if (options.base) params.set("target_branch", options.base);
+	const response = await gitlabRequest(options, `/projects/${encodedProjectPath}/merge_requests?${params}`);
+	if (!response.ok) throw new Error("Failed to check for an existing version merge request.");
+	return (await response.json())[0]?.iid;
+}
+async function updateMergeRequest(repo, number, options) {
+	const { encodedProjectPath } = parseGitLabRepo(repo);
+	if (!(await gitlabRequest(options, `/projects/${encodedProjectPath}/merge_requests/${number}`, {
+		method: "PUT",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({
+			title: options.title,
+			description: options.body,
+			target_branch: options.base
+		})
+	})).ok) throw new Error("Failed to update the version merge request.");
+}
+async function createMergeRequest(repo, options) {
+	const { encodedProjectPath } = parseGitLabRepo(repo);
+	if (!(await gitlabRequest(options, `/projects/${encodedProjectPath}/merge_requests`, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({
+			title: options.title,
+			description: options.body,
+			source_branch: options.head,
+			target_branch: options.base
+		})
+	})).ok) throw new Error("Failed to create the version merge request.");
+}
+async function getMergeRequest(repo, number, options = {}) {
+	const { encodedProjectPath } = parseGitLabRepo(repo);
+	const response = await gitlabRequest(options, `/projects/${encodedProjectPath}/merge_requests/${number}`);
+	if (!response.ok) throw new Error(`Failed to resolve merge request !${number}.`);
+	const data = await response.json();
+	let sourceProjectPath;
+	if (data.source_project_id !== void 0) {
+		const projectResponse = await gitlabRequest(options, `/projects/${data.source_project_id}`);
+		if (projectResponse.ok) sourceProjectPath = (await projectResponse.json()).path_with_namespace;
+	}
+	return {
+		sourceBranch: data.source_branch,
+		sourceProjectPath,
+		baseSha: data.diff_refs?.base_sha ?? "",
+		headSha: data.diff_refs?.head_sha ?? data.sha ?? ""
+	};
+}
+async function listMergeRequestsForCommit(repo, commitSha, options = {}) {
+	const { encodedProjectPath } = parseGitLabRepo(repo);
+	const response = await gitlabRequest(options, `/projects/${encodedProjectPath}/repository/commits/${commitSha}/merge_requests`);
+	if (!response.ok) throw new Error(`Failed to list merge requests for commit ${commitSha.slice(0, 7)}.`);
+	return (await response.json()).map((mergeRequest) => ({
+		number: mergeRequest.iid,
+		title: mergeRequest.title,
+		user: mergeRequest.author ? { login: mergeRequest.author.username } : void 0
+	}));
+}
+async function findMergeRequestCommentByPrefix(repo, mergeRequestNumber, prefix, options = {}) {
+	const { encodedProjectPath } = parseGitLabRepo(repo);
+	let page = 1;
+	while (true) {
+		const response = await gitlabRequest(options, `/projects/${encodedProjectPath}/merge_requests/${mergeRequestNumber}/notes?per_page=100&page=${page}`);
+		if (!response.ok) throw new Error("Failed to list merge 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 updateMergeRequestComment(repo, mergeRequestNumber, commentId, body, options = {}) {
+	const { encodedProjectPath } = parseGitLabRepo(repo);
+	if (!(await gitlabRequest(options, `/projects/${encodedProjectPath}/merge_requests/${mergeRequestNumber}/notes/${commentId}`, {
+		method: "PUT",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({ body })
+	})).ok) throw new Error("Failed to update merge request comment.");
+}
+async function createMergeRequestComment(repo, mergeRequestNumber, body, options = {}) {
+	const { encodedProjectPath } = parseGitLabRepo(repo);
+	if (!(await gitlabRequest(options, `/projects/${encodedProjectPath}/merge_requests/${mergeRequestNumber}/notes`, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({ body })
+	})).ok) throw new Error("Failed to create merge request comment.");
+}
+//#endregion
+//#region src/plugins/gitlab/cli.ts
+const COMMENT_MARKER = "<!-- tegami -->";
+function registerMrCli(cli) {
+	cli.command("mr preview", { description: "show a merge request release preview and changelog guidance" }).option("artifact", {
+		type: "string",
+		description: "write preview markdown to a file"
+	}).option("number", {
+		type: "string",
+		description: "merge request iid"
+	}).action(async ({ context, values }) => {
+		const number = values.number ? parsePositiveInt(values.number, "--number") : void 0;
+		const artifact = values.artifact;
+		const body = await buildMrPreview(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("mr comment", { description: "post the merge request release preview as a comment" }).positional("artifact").option("number", {
+		type: "string",
+		description: "merge request iid"
+	}).action(async ({ context, values, positionals }) => {
+		await postMrComment(context, await readFile(positionals.artifact, "utf8"), { number: values.number ? parsePositiveInt(values.number, "--number") : void 0 });
+		outro("Merge request comment updated.");
+	});
+}
+async function buildMrPreview(context, draft, options = {}) {
+	const mergeRequest = await resolveMergeRequest(context, options);
+	const tegamiCommandRaw = resolveCommand(context.npm?.client ?? "npm", "run", ["tegami"]);
+	const tegamiCommand = [tegamiCommandRaw.command, ...tegamiCommandRaw.args].join(" ");
+	const changelogFiles = await listMergeRequestChangelogFiles(context, mergeRequest.baseSha, mergeRequest.headSha);
+	const createLink = createChangelogUrl(context, mergeRequest.headRepo, mergeRequest.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 MR", "", "| 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 MR has no pending changelog files. If your changes require a release, add a changelog before merging.", "");
+	else if (changelogFiles.size === 0) lines.push("This MR 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 postMrComment(context, body, options = {}) {
+	const { repo } = context.gitlab ?? {};
+	if (!repo) {
+		outro("GITLAB_REPOSITORY or CI_PROJECT_PATH is required.");
+		return;
+	}
+	const number = options.number ?? (process.env.CI_MERGE_REQUEST_IID ? parsePositiveInt(process.env.CI_MERGE_REQUEST_IID, "CI_MERGE_REQUEST_IID") : void 0);
+	if (!number) {
+		outro("CI_MERGE_REQUEST_IID or --number is required.");
+		return;
+	}
+	const api = {
+		apiUrl: context.gitlab?.apiUrl,
+		token: context.gitlab?.token
+	};
+	const markedBody = `${COMMENT_MARKER}\n${body}`;
+	const existingId = await findMergeRequestCommentByPrefix(repo, number, COMMENT_MARKER, api);
+	if (existingId) {
+		await updateMergeRequestComment(repo, number, existingId, markedBody, api);
+		return;
+	}
+	await createMergeRequestComment(repo, number, markedBody, api);
+}
+async function resolveMergeRequest(context, options) {
+	const { repo } = context.gitlab ?? {};
+	if (!repo) throw new Error("GITLAB_REPOSITORY or CI_PROJECT_PATH is required.");
+	const api = {
+		apiUrl: context.gitlab?.apiUrl,
+		token: context.gitlab?.token
+	};
+	if (options.number !== void 0) {
+		const data = await getMergeRequest(repo, options.number, api);
+		if (!data.baseSha || !data.headSha) throw new Error(`Merge request !${options.number} does not include diff refs.`);
+		return {
+			headRepo: data.sourceProjectPath ?? repo,
+			headRef: data.sourceBranch,
+			baseSha: data.baseSha,
+			headSha: data.headSha
+		};
+	}
+	const headRef = process.env.CI_MERGE_REQUEST_SOURCE_BRANCH_NAME;
+	const baseSha = process.env.CI_MERGE_REQUEST_DIFF_BASE_SHA;
+	const headSha = process.env.CI_COMMIT_SHA;
+	if (headRef && baseSha && headSha) return {
+		headRepo: process.env.CI_MERGE_REQUEST_SOURCE_PROJECT_PATH ?? repo,
+		headRef,
+		baseSha,
+		headSha
+	};
+	throw new Error("A merge request event or --number is required.");
+}
+async function listMergeRequestChangelogFiles(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 merge 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("\\", "/");
+	const branchPath = branch.split("/").map(encodeURIComponent).join("/");
+	const params = new URLSearchParams({ file_name: filePath });
+	return `${gitlabWebUrl(context.gitlab?.webUrl)}/${repo}/-/new/${branchPath}?${params}`;
+}
+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/gitlab.ts
+/** Create GitLab releases for successfully published packages after the whole plan succeeds. */
+function gitlab(options = {}) {
+	const { release: releaseOptions = true } = options;
+	let renderer;
+	function getRenderer(context) {
+		return renderer ??= createChangelogRenderer(context);
+	}
+	const cliOriginalPackageVersions = /* @__PURE__ */ new Map();
+	return [git(options), {
+		name: "gitlab",
+		init() {
+			this.gitlab = {
+				repo: options.repo ?? process.env.GITLAB_REPOSITORY ?? process.env.CI_PROJECT_PATH,
+				token: resolveGitLabToken(options.token),
+				apiUrl: options.apiUrl ?? process.env.GITLAB_API_URL ?? process.env.CI_API_V4_URL,
+				webUrl: options.webUrl ?? process.env.GITLAB_SERVER_URL ?? process.env.CI_SERVER_URL
+			};
+		},
+		async resolvePlanStatus({ plan }) {
+			const { repo, token } = this.gitlab;
+			if (!repo || !token || releaseOptions === false) return;
+			const requiredTags = /* @__PURE__ */ new Set();
+			const api = gitLabApiOptions(this.gitlab);
+			for (const pkg of plan.packages.values()) if (pkg.preflight.shouldPublish && pkg.git?.tag) requiredTags.add(pkg.git.tag);
+			return Array.from(requiredTags, async (tag) => {
+				if (!await releaseExistsByTag(repo, tag, api)) return "pending";
+			});
+		},
+		async afterPublishAll({ plan }) {
+			const { repo, token } = this.gitlab;
+			if (!repo || !token || releaseOptions === false) return;
+			const api = gitLabApiOptions(this.gitlab);
+			const { eager = false, create, createGrouped } = releaseOptions === true ? {} : releaseOptions;
+			const groups = /* @__PURE__ */ new Map();
+			for (const [id, { preflight, publishResult, git }] of plan.packages) {
+				if (!eager && publishResult.type === "failed") return;
+				const tag = git?.tag;
+				if (!tag || !preflight.shouldPublish) continue;
+				const pkg = this.graph.get(id);
+				const group = groups.get(tag);
+				if (group) group.push(pkg);
+				else groups.set(tag, [pkg]);
+			}
+			await Promise.all(Array.from(groups, async ([tag, packages]) => {
+				for (const member of packages) if (plan.packages.get(member.id).publishResult.type === "failed") return;
+				if (await releaseExistsByTag(repo, tag, api)) return;
+				let release;
+				if (packages.length > 1) {
+					const overrides = await createGrouped?.call(this, {
+						tag,
+						packages,
+						plan
+					}) ?? {};
+					release = {
+						title: overrides.title ?? tag,
+						notes: overrides.notes ?? await defaultGroupedNotes(getRenderer(this), plan, packages)
+					};
+				} else {
+					const pkg = packages[0];
+					const overrides = await create?.call(this, {
+						tag,
+						pkg,
+						plan
+					}) ?? {};
+					const packagePlan = plan.packages.get(pkg.id);
+					release = {
+						title: overrides.title ?? formatPackageVersion(pkg.name, pkg.version, packagePlan?.npm?.distTag),
+						notes: overrides.notes ?? await defaultNotes(getRenderer(this), pkg, packagePlan)
+					};
+				}
+				await createRelease(repo, {
+					tag,
+					title: release.title,
+					notes: release.notes,
+					...api
+				});
+			}));
+		},
+		async initCli(cli) {
+			registerMrCli(cli);
+			if (!isCI()) return;
+			const { repo, token, webUrl } = this.gitlab ?? {};
+			if (!token || !repo) return;
+			const result = await x("git", [
+				"remote",
+				"set-url",
+				"origin",
+				gitlabRemoteUrl(repo, token, webUrl)
+			], { nodeOptions: { cwd: this.cwd } });
+			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);
+		},
+		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
+			});
+		}
+	}];
+}
+function createChangelogRenderer(context) {
+	const { repo, webUrl } = context.gitlab;
+	const api = gitLabApiOptions(context.gitlab);
+	const baseUrl = gitlabWebUrl(webUrl);
+	const resolveFileCommit = cached((filename) => filename, async (filename) => {
+		const result = await x("git", [
+			"log",
+			"--diff-filter=A",
+			"-1",
+			"--format=%H",
+			"--",
+			relative(context.cwd, join(context.changelogDir, filename))
+		], { nodeOptions: { cwd: context.cwd } });
+		if (result.exitCode !== 0) return;
+		return result.stdout.trim() || void 0;
+	});
+	const resolveEntryMeta = cached((entry) => entry.id, async (entry) => {
+		const commit = await resolveFileCommit(entry.filename);
+		if (!commit || !repo) return {
+			commit,
+			mergeRequests: []
+		};
+		return {
+			commit,
+			mergeRequests: await listMergeRequestsForCommit(repo, commit, api).catch(() => [])
+		};
+	});
+	function formatEntryDetails(meta) {
+		if (meta.mergeRequests.length === 0) return;
+		const lines = [];
+		for (const mr of meta.mergeRequests) {
+			let line = repo ? `- [!${mr.number} ${mr.title}](${baseUrl}/${repo}/-/merge_requests/${mr.number})` : `- #${mr.number} ${mr.title}`;
+			if (mr.user) line += ` by @${mr.user.login}`;
+			lines.push(line);
+		}
+		return [
+			"<details>",
+			"<summary>Merge request & contributors</summary>",
+			"",
+			...lines,
+			"",
+			"</details>"
+		].join("\n");
+	}
+	return async (entry) => {
+		const meta = await resolveEntryMeta(entry);
+		let commitSuffix = "";
+		if (meta.commit) {
+			const short = meta.commit.slice(0, 7);
+			const link = repo ? `[${short}](${baseUrl}/${repo}/-/commit/${meta.commit})` : `\`${short}\``;
+			commitSuffix += ` (${link})`;
+		}
+		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();
+	};
+}
+async function defaultNotes(renderer, pkg, packagePlan) {
+	if (packagePlan && packagePlan.changelogs.length > 0) return (await Promise.all(packagePlan.changelogs.map(renderer))).join("\n\n");
+	return `Published ${formatPackageVersion(pkg.name, pkg.version, packagePlan?.npm?.distTag)}.`;
+}
+async function defaultGroupedNotes(renderer, plan, packages) {
+	const changelogs = /* @__PURE__ */ new Map();
+	for (const pkg of packages) {
+		const packagePlan = plan.packages.get(pkg.id);
+		if (!packagePlan) continue;
+		for (const entry of packagePlan.changelogs) changelogs.set(entry.id, entry);
+	}
+	const sections = [packages.map((pkg) => {
+		const packagePlan = plan.packages.get(pkg.id);
+		return `- ${formatPackageVersion(pkg.name, pkg.version, packagePlan?.npm?.distTag)}`;
+	}).join("\n")];
+	if (changelogs.size > 0) {
+		const notes = await Promise.all(Array.from(changelogs.values(), renderer));
+		sections.push("", notes.join("\n\n"));
+	}
+	return sections.join("\n");
+}
+function gitLabApiOptions(gitlab) {
+	const options = {};
+	if (gitlab?.apiUrl) options.apiUrl = gitlab.apiUrl;
+	if (gitlab?.token) options.token = gitlab.token;
+	return options;
+}
+function resolveGitLabToken(optionToken) {
+	if (optionToken) return {
+		value: optionToken,
+		type: "private-token"
+	};
+	if (process.env.GITLAB_TOKEN) return {
+		value: process.env.GITLAB_TOKEN,
+		type: "private-token"
+	};
+	if (process.env.GL_TOKEN) return {
+		value: process.env.GL_TOKEN,
+		type: "private-token"
+	};
+	if (process.env.CI_JOB_TOKEN) return {
+		value: process.env.CI_JOB_TOKEN,
+		type: "job-token"
+	};
+}
+function gitlabRemoteUrl(repo, token, webUrl) {
+	const username = token.type === "job-token" ? "gitlab-ci-token" : "oauth2";
+	return `${gitlabWebUrl(webUrl).replace(/^https?:\/\//, `https://${username}:${token.value}@`)}/${repo}.git`;
+}
+//#endregion
+export { gitlab };

package/dist/plugins/go.d.ts

@@ -1,4 +1,4 @@
-import { C as WorkspacePackage, O as BumpType, s as TegamiPlugin } from "../types-DKeF_CDv.js";
+import { D as WorkspacePackage, j as BumpType, s as TegamiPlugin } from "../types-DKZsadC8.js";
 
 //#region src/plugins/go.d.ts
 interface GoModFile {

package/dist/plugins/go.js

@@ -1,4 +1,4 @@
-import { i as isNodeError, n as execFailure } from "../error-D3dwQnwR.js";
+import { i as isNodeError, n as execFailure } from "../error-We7chQVJ.js";
 import { n as WorkspacePackage } from "../graph-gThXu8Cz.js";
 import { relative, resolve } from "node:path";
 import { x } from "tinyexec";
@@ -135,6 +135,7 @@ function go({ updateLockFile = true, bumpDep: getBumpDepType } = {}) {
 		},
 		async publishPreflight({ pkg }) {
 			if (!(pkg instanceof GoPackage)) return;
+			const shouldPublish = pkg.getPackageOptions().go?.publish ?? this.graph.getPackageGroup(pkg.id)?.options?.go?.publish ?? true;
 			const wait = [];
 			for (const [moduleName] of pkg.mod.requires) {
 				const linked = this.graph.get(`go:${moduleName}`);
@@ -147,7 +148,7 @@ function go({ updateLockFile = true, bumpDep: getBumpDepType } = {}) {
 				wait.push(linked.id);
 			}
 			return {
-				shouldPublish: true,
+				shouldPublish,
 				wait
 			};
 		},
@@ -163,7 +164,7 @@ function go({ updateLockFile = true, bumpDep: getBumpDepType } = {}) {
 			if (!(pkg instanceof GoPackage)) return;
 			return { type: await isModulePublished(pkg.name, pkg.version) ? "skipped" : "published" };
 		},
-		cli: { async draftApplied() {
+		async applyCliDraft() {
 			if (!active || !updateLockFile) return;
 			if (await listGoWorkUsePaths(this.cwd)) {
 				const result = await x("go", ["work", "sync"], { nodeOptions: { cwd: this.cwd } });
@@ -175,7 +176,7 @@ function go({ updateLockFile = true, bumpDep: getBumpDepType } = {}) {
 				const result = await x("go", ["mod", "tidy"], { nodeOptions: { cwd: pkg.path } });
 				if (result.exitCode !== 0) throw execFailure(`Failed to run \`go mod tidy\` in ${pkg.path}.`, result);
 			}));
-		} }
+		}
 	};
 }
 function depsPolicy({ graph }, getBumpDepType = () => "patch") {

package/dist/providers/cargo.d.ts

@@ -1,2 +1,2 @@
-import { g as cargo, h as CargoPluginOptions, m as CargoPackage } from "../types-DKeF_CDv.js";
+import { b as cargo, v as CargoPackage, y as CargoPluginOptions } from "../types-DKZsadC8.js";
 export { CargoPackage, CargoPluginOptions, cargo };

package/dist/providers/cargo.js

@@ -1,4 +1,4 @@
-import { i as isNodeError, n as execFailure } from "../error-D3dwQnwR.js";
+import { i as isNodeError, n as execFailure } from "../error-We7chQVJ.js";
 import { n as WorkspacePackage } from "../graph-gThXu8Cz.js";
 import { readFile, writeFile } from "node:fs/promises";
 import { join, normalize } from "node:path";
@@ -129,11 +129,11 @@ function cargo({ updateLockFile = true, bumpDep: getBumpDepType } = {}) {
 			}
 			await Promise.all(writes);
 		},
-		cli: { async draftApplied() {
+		async applyCliDraft() {
 			if (!active || !updateLockFile) return;
 			const result = await x("cargo", ["update", "--workspace"], { nodeOptions: { cwd: this.cwd } });
 			if (result.exitCode !== 0) throw execFailure("Failed to update Cargo lock file", result);
-		} }
+		}
 	};
 }
 function depsPolicy({ graph }, getBumpDepType = ({ kind }) => {

package/dist/providers/npm.d.ts

@@ -1,2 +1,2 @@
-import { _ as NpmPackage, v as NpmPluginOptions, y as npm } from "../types-DKeF_CDv.js";
+import { C as npm, S as NpmPluginOptions, x as NpmPackage } from "../types-DKZsadC8.js";
 export { NpmPackage, NpmPluginOptions, npm };

package/dist/providers/npm.js

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