tegami 1.0.0-beta.5 → 1.0.2

package/dist/plugins/cargo.js

@@ -0,0 +1,405 @@
+import { n as execFailure } from "../error-BhMYq9iW.js";
+import { n as WorkspacePackage } from "../graph-gThXu8Cz.js";
+import { readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { x } from "tinyexec";
+import * as semver$1 from "semver";
+import z from "zod";
+import { glob } from "tinyglobby";
+import initToml, { edit, parse as parse$1 } from "@rainbowatcher/toml-edit-js";
+//#region src/plugins/cargo/schema.ts
+const baseDepSchema = z.object({
+	package: z.string().optional(),
+	features: z.array(z.string()).optional(),
+	optional: z.boolean().optional(),
+	"default-features": z.boolean().optional()
+});
+/** `{ workspace = true }` — inherit from `[workspace.dependencies]` */
+const workspaceDependencySchema = baseDepSchema.extend({ workspace: z.literal(true) });
+/** `{ path = "../lib" }` — optional `version` for publishing */
+const pathDependencySchema = baseDepSchema.extend({
+	path: z.string(),
+	version: z.string().optional()
+});
+/** `{ git = "…" }` — exactly one of `branch`, `tag`, or `rev` in practice */
+const gitDependencySchema = baseDepSchema.extend({
+	git: z.string(),
+	branch: z.string().optional(),
+	tag: z.string().optional(),
+	rev: z.string().optional(),
+	version: z.string().optional()
+});
+/** `{ version = "1.0" }` — crates.io or `[registries]` */
+const registryDependencySchema = baseDepSchema.extend({
+	version: z.string(),
+	registry: z.string().optional()
+});
+/**
+* @see https://doc.rust-lang.org/cargo/reference/specifying-dependencies.html
+*/
+const cargoDependencySchema = z.union([
+	z.string(),
+	workspaceDependencySchema,
+	pathDependencySchema,
+	gitDependencySchema,
+	registryDependencySchema
+]);
+const cargoInheritSchema = z.looseObject({ workspace: z.literal(true) });
+const cargoWorkspaceSchema = z.looseObject({
+	members: z.array(z.string()).optional(),
+	exclude: z.array(z.string()).optional(),
+	package: z.looseObject({
+		version: z.string().optional(),
+		publish: z.boolean().optional()
+	}).optional(),
+	dependencies: z.record(z.string(), cargoDependencySchema).optional(),
+	"dev-dependencies": z.record(z.string(), cargoDependencySchema).optional(),
+	"build-dependencies": z.record(z.string(), cargoDependencySchema).optional()
+});
+const cargoManifestSchema = z.looseObject({
+	package: z.looseObject({
+		name: z.string(),
+		version: z.string().or(cargoInheritSchema),
+		publish: z.boolean().or(cargoInheritSchema).optional()
+	}).optional(),
+	workspace: cargoWorkspaceSchema.optional(),
+	dependencies: z.record(z.string(), cargoDependencySchema).optional(),
+	"dev-dependencies": z.record(z.string(), cargoDependencySchema).optional(),
+	"build-dependencies": z.record(z.string(), cargoDependencySchema).optional(),
+	target: z.record(z.string(), z.looseObject({
+		dependencies: z.record(z.string(), cargoDependencySchema).optional(),
+		"dev-dependencies": z.record(z.string(), cargoDependencySchema).optional(),
+		"build-dependencies": z.record(z.string(), cargoDependencySchema).optional()
+	})).optional()
+});
+//#endregion
+//#region src/plugins/cargo.ts
+const DEP_FIELDS = [
+	"dependencies",
+	"dev-dependencies",
+	"build-dependencies"
+];
+var CargoPackage = class extends WorkspacePackage {
+	path;
+	file;
+	workspaceFile;
+	manager = "cargo";
+	manifest;
+	constructor(path, file, workspaceFile) {
+		super();
+		this.path = path;
+		this.file = file;
+		this.workspaceFile = workspaceFile;
+		this.manifest = file.data;
+	}
+	get name() {
+		return this.manifest.package.name;
+	}
+	get version() {
+		const packageVersion = this.manifest.package.version;
+		if (typeof packageVersion === "string") return packageVersion;
+		const inherited = this.workspaceFile?.data.workspace.package;
+		if (packageVersion.workspace && inherited?.version) return inherited.version;
+		throw new Error(`Invalid Cargo.toml in "${this.path}".`);
+	}
+	setVersion(version) {
+		const packageInfo = this.manifest.package;
+		if (typeof packageInfo.version === "string") {
+			packageInfo.version = version;
+			patchFile(this.file, "package.version", version);
+			return;
+		}
+		if (packageInfo.version.workspace && this.workspaceFile?.data.workspace.package) {
+			this.workspaceFile.data.workspace.package.version = version;
+			patchFile(this.workspaceFile, "workspace.package.version", version);
+			return;
+		}
+		throw new Error(`Invalid Cargo.toml in "${this.path}".`);
+	}
+};
+function patchFile(file, path, value) {
+	file.content = edit(file.content, path, value);
+}
+function cargo({ updateLockFile = true, bumpDep: getBumpDepType } = {}) {
+	return {
+		name: "cargo",
+		enforce: "pre",
+		async init() {
+			await initToml();
+		},
+		async resolve() {
+			const graph = await resolveCargoGraph(this.cwd);
+			if (graph.packages.size === 0) return;
+			this.cargo = { graph };
+			for (const pkg of graph.packages.values()) this.graph.add(pkg);
+		},
+		initDraft(plan) {
+			if (!this.cargo) return;
+			plan.addPolicy(depsPolicy(this, getBumpDepType));
+		},
+		async publishPreflight({ pkg }) {
+			if (!(pkg instanceof CargoPackage) || !this.cargo) return;
+			let shouldPublish = true;
+			if (typeof pkg.manifest.package.publish === "boolean") shouldPublish = pkg.manifest.package.publish;
+			else if (pkg.manifest.package.publish?.workspace) shouldPublish = pkg.workspaceFile?.data.workspace?.package?.publish ?? shouldPublish;
+			const wait = [];
+			for (const { table, tablePath } of dependencyTables(pkg.manifest)) for (const [rawName, spec] of Object.entries(table)) {
+				const resolved = resolveLinkedDep(pkg.workspaceFile, pkg.file, this.cargo.graph, tablePath, rawName, spec);
+				if (!resolved) continue;
+				wait.push(resolved.linked.id);
+			}
+			return {
+				shouldPublish,
+				wait
+			};
+		},
+		resolvePlanStatus({ plan }) {
+			if (!this.cargo) return;
+			return Array.from(plan.packages, async ([id, { preflight }]) => {
+				if (!preflight.shouldPublish) return;
+				const pkg = this.graph.get(id);
+				if (!(pkg instanceof CargoPackage)) return;
+				if (!await isPackagePublished(pkg.name, pkg.version)) return "pending";
+			});
+		},
+		async publish({ pkg }) {
+			if (!(pkg instanceof CargoPackage)) return;
+			const result = await x("cargo", ["publish"], { nodeOptions: { cwd: pkg.path } });
+			if (result.exitCode !== 0) {
+				if (/already exists|already published/i.test(`${result.stdout}\n${result.stderr}`)) return { type: "skipped" };
+				return {
+					type: "failed",
+					error: execFailure(`Failed to publish ${pkg.name}@${pkg.version}.`, result).message
+				};
+			}
+			return { type: "published" };
+		},
+		async applyDraft(draft) {
+			if (!this.cargo) return;
+			const graph = this.cargo.graph;
+			for (const pkg of graph.packages.values()) {
+				const bumped = draft.getPackageDraft(pkg.id)?.bumpVersion(pkg);
+				if (bumped) pkg.setVersion(bumped);
+			}
+			for (const pkg of graph.packages.values()) for (const { table, tablePath } of dependencyTables(pkg.manifest)) for (const [rawName, spec] of Object.entries(table)) {
+				const resolved = resolveLinkedDep(pkg.workspaceFile, pkg.file, graph, tablePath, rawName, spec);
+				if (!resolved || !resolved.range || !resolved.setRange || semver$1.satisfies(resolved.linked.version, resolved.range)) continue;
+				let updatedRange;
+				if (resolved.range.startsWith("^")) updatedRange = `^${resolved.linked.version}`;
+				else if (resolved.range.startsWith("~")) updatedRange = `~${resolved.linked.version}`;
+				else updatedRange = resolved.linked.version;
+				table[rawName] = resolved.setRange(updatedRange);
+			}
+			await Promise.all(Array.from(graph.files.values(), (file) => writeFile(file.path, file.content + "\n")));
+		},
+		async applyCliDraft() {
+			if (!this.cargo || !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, cargo }, getBumpDepType = ({ kind }) => {
+	switch (kind) {
+		case "dependencies": return "patch";
+		case "build-dependencies":
+		case "dev-dependencies": return false;
+	}
+}) {
+	const cargoGraph = cargo.graph;
+	const dependentMap = /* @__PURE__ */ new Map();
+	for (const pkg of cargoGraph.packages.values()) for (const { table, tablePath } of dependencyTables(pkg.manifest)) for (const [name, spec] of Object.entries(table)) {
+		const resolved = resolveLinkedDep(pkg.workspaceFile, pkg.file, cargoGraph, tablePath, name, spec);
+		if (!resolved) continue;
+		const id = resolved.linked.id;
+		const refs = dependentMap.get(id);
+		const kind = tablePath.at(-1);
+		if (refs) refs.push({
+			dependent: pkg,
+			kind,
+			name,
+			spec,
+			version: resolved.range
+		});
+		else dependentMap.set(id, [{
+			dependent: pkg,
+			kind,
+			name,
+			spec,
+			version: resolved.range
+		}]);
+	}
+	return {
+		id: "cargo:deps",
+		onUpdate({ pkg, packageDraft: plan }) {
+			if (!(pkg instanceof CargoPackage)) return;
+			const deps = dependentMap.get(pkg.id);
+			if (!deps) return;
+			const group = graph.getPackageGroup(pkg.id);
+			const bumped = plan.bumpVersion(pkg);
+			if (!bumped) return;
+			for (const dep of deps) {
+				if (group?.options.syncBump && graph.getPackageGroup(dep.dependent.id) === group) continue;
+				if (dep.version && semver$1.satisfies(bumped, dep.version)) continue;
+				const bumpType = getBumpDepType(dep);
+				if (bumpType === false) continue;
+				this.bumpPackage(dep.dependent, {
+					type: bumpType,
+					reason: `update dependency "${pkg.name}"`
+				});
+			}
+		}
+	};
+}
+async function isPackagePublished(name, version) {
+	const response = await fetch(`https://crates.io/api/v1/crates/${encodeURIComponent(name)}/${version}`);
+	if (response.status === 200) return true;
+	if (response.status === 404) return false;
+	throw new Error(`Unable to validate ${name}@${version} against crates.io: ${await response.text()}`);
+}
+async function buildEntry(dir) {
+	try {
+		const filePath = path.join(dir, "Cargo.toml");
+		const content = await readFile(filePath, "utf8");
+		return {
+			path: filePath,
+			data: cargoManifestSchema.parse(parse$1(content)),
+			content
+		};
+	} catch {
+		return;
+	}
+}
+async function resolveCargoGraph(cwd) {
+	const out = {
+		packages: /* @__PURE__ */ new Map(),
+		files: /* @__PURE__ */ new Map()
+	};
+	const root = await buildEntry(cwd);
+	if (!root) return out;
+	const rootWorkspace = root.data.workspace;
+	out.files.set(root.path, root);
+	if (root.data.package) {
+		const pkg = new CargoPackage(cwd, root, rootWorkspace ? root : void 0);
+		out.packages.set(pkg.name, pkg);
+	}
+	if (!rootWorkspace || !rootWorkspace.members) return out;
+	const dirs = await expandWorkspaceMembers(cwd, rootWorkspace.members, rootWorkspace.exclude);
+	await Promise.all(dirs.map(async (dir) => {
+		const entry = await buildEntry(dir);
+		if (!entry || !entry.data.package) return;
+		const pkg = new CargoPackage(dir, entry, root);
+		out.files.set(entry.path, entry);
+		out.packages.set(pkg.name, pkg);
+	}));
+	return out;
+}
+async function expandWorkspaceMembers(cwd, members, exclude = []) {
+	const patterns = members.filter((member) => member !== ".");
+	if (patterns.length === 0) return [];
+	return (await glob(patterns, {
+		absolute: true,
+		cwd,
+		ignore: ["**/target/**", ...exclude],
+		onlyDirectories: true,
+		onlyFiles: false
+	})).map((item) => {
+		return item.endsWith(path.sep) ? item.slice(0, -1) : item;
+	});
+}
+function dependencyTables(manifest, prefix = []) {
+	const tables = [];
+	for (const field of DEP_FIELDS) {
+		const table = manifest[field];
+		if (!table) continue;
+		tables.push({
+			table,
+			tablePath: [...prefix, field]
+		});
+	}
+	const target = manifest.target;
+	if (target) for (const [targetKey, targetConfig] of Object.entries(target)) for (const field of DEP_FIELDS) {
+		const table = targetConfig[field];
+		if (!table) continue;
+		tables.push({
+			table,
+			tablePath: [
+				...prefix,
+				"target",
+				targetKey,
+				field
+			]
+		});
+	}
+	return tables;
+}
+function resolveLinkedDep(workspaceFile, file, graph, tablePath, rawName, spec) {
+	if (typeof spec === "string") {
+		const linked = graph.packages.get(rawName);
+		if (!linked) return;
+		return {
+			linked,
+			range: spec,
+			setRange(v) {
+				patchFile(file, [...tablePath, rawName].join("."), v);
+				return v;
+			}
+		};
+	}
+	if ("git" in spec) return;
+	if ("workspace" in spec) {
+		const kind = tablePath[tablePath.length - 1];
+		const entry = workspaceFile?.data.workspace?.[kind]?.[rawName];
+		if (!entry) return;
+		const resolved = resolveLinkedDep(void 0, workspaceFile, graph, ["workspace", kind], rawName, entry);
+		if (!resolved || !resolved.setRange) return resolved;
+		return {
+			...resolved,
+			setRange(v) {
+				workspaceFile.data.workspace[kind][rawName] = resolved.setRange(v);
+				return spec;
+			}
+		};
+	}
+	if ("path" in spec) {
+		const pkgPath = path.resolve(path.dirname(file.path), spec.path);
+		for (const pkg of graph.packages.values()) {
+			if (pkg.path !== pkgPath) continue;
+			return {
+				linked: pkg,
+				range: spec.version,
+				setRange(v) {
+					patchFile(file, [
+						...tablePath,
+						rawName,
+						"version"
+					].join("."), v);
+					return {
+						...spec,
+						version: v
+					};
+				}
+			};
+		}
+		return;
+	}
+	const linked = graph.packages.get(spec.package ?? rawName);
+	if (!linked) return;
+	return {
+		linked,
+		range: spec.version,
+		setRange(v) {
+			patchFile(file, [
+				...tablePath,
+				rawName,
+				"version"
+			].join("."), v);
+			return {
+				...spec,
+				version: v
+			};
+		}
+	};
+}
+//#endregion
+export { CargoPackage, cargo };

package/dist/plugins/git.d.ts

@@ -1,4 +1,4 @@
-import { s as TegamiPlugin } from "../types-C1rEqeM4.js";
+import { s as TegamiPlugin } from "../types-DHddSAez.js";
 
 //#region src/plugins/git.d.ts
 interface GitPluginOptions {

package/dist/plugins/git.js

@@ -1,4 +1,4 @@
-import { n as execFailure, o as isCI } from "../error-We7chQVJ.js";
+import { n as execFailure, o as isCI } from "../error-BhMYq9iW.js";
 import { x } from "tinyexec";
 //#region src/plugins/git.ts
 /**

package/dist/plugins/github.d.ts

@@ -1,4 +1,4 @@
-import { D as WorkspacePackage, O as Draft, _ as PublishPlan, s as TegamiPlugin, t as Awaitable, w as TegamiContext } from "../types-C1rEqeM4.js";
+import { O as WorkspacePackage, k as Draft, s as TegamiPlugin, t as Awaitable, x as TegamiContext, y as PublishPlan } from "../types-DHddSAez.js";
 import { GitPluginOptions } from "./git.js";
 
 //#region src/plugins/github.d.ts

package/dist/plugins/github.js

@@ -1,9 +1,9 @@
 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 { t as changelogFilename } from "../generate-Rvz4Lu98.js";
+import { a as cached, n as execFailure, o as isCI } from "../error-BhMYq9iW.js";
+import { n as createDraft, o as readChangelogEntries } from "../draft-BqHcSCeX.js";
 import { git } from "./git.js";
-import { n as createVersionRequestBody, r as hasGitChanges, t as commitVersionBranchChanges } from "../version-request-DKvR3_xb.js";
+import { n as createVersionRequestBody, r as hasGitChanges, t as commitVersionBranchChanges } from "../version-request-oxy16TJ1.js";
 import { readFile, writeFile } from "node:fs/promises";
 import { basename, join, relative, resolve } from "node:path";
 import { x } from "tinyexec";

package/dist/plugins/gitlab.d.ts

@@ -1,4 +1,4 @@
-import { D as WorkspacePackage, O as Draft, _ as PublishPlan, s as TegamiPlugin, t as Awaitable, w as TegamiContext } from "../types-C1rEqeM4.js";
+import { O as WorkspacePackage, k as Draft, s as TegamiPlugin, t as Awaitable, x as TegamiContext, y as PublishPlan } from "../types-DHddSAez.js";
 import { GitPluginOptions } from "./git.js";
 
 //#region src/plugins/gitlab.d.ts

package/dist/plugins/gitlab.js

@@ -1,9 +1,9 @@
 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 { t as changelogFilename } from "../generate-Rvz4Lu98.js";
+import { a as cached, n as execFailure, o as isCI, s as joinPath } from "../error-BhMYq9iW.js";
+import { n as createDraft, o as readChangelogEntries } from "../draft-BqHcSCeX.js";
 import { git } from "./git.js";
-import { n as createVersionRequestBody, r as hasGitChanges, t as commitVersionBranchChanges } from "../version-request-DKvR3_xb.js";
+import { n as createVersionRequestBody, r as hasGitChanges, t as commitVersionBranchChanges } from "../version-request-oxy16TJ1.js";
 import { readFile, writeFile } from "node:fs/promises";
 import { basename, join, relative, resolve } from "node:path";
 import { x } from "tinyexec";
@@ -18,17 +18,11 @@ function parseGitLabRepo(repo) {
 		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}`, {
+	return fetch(joinPath(options.apiUrl ?? "https://gitlab.com/api/v4", path), {
 		...init,
 		headers
 	});
@@ -227,7 +221,7 @@ async function buildMrPreview(context, draft, options = {}) {
 	return lines.join("\n");
 }
 async function postMrComment(context, body, options = {}) {
-	const { repo } = context.gitlab ?? {};
+	const { repo, apiUrl, token } = context.gitlab;
 	if (!repo) {
 		outro("GITLAB_REPOSITORY or CI_PROJECT_PATH is required.");
 		return;
@@ -238,8 +232,8 @@ async function postMrComment(context, body, options = {}) {
 		return;
 	}
 	const api = {
-		apiUrl: context.gitlab?.apiUrl,
-		token: context.gitlab?.token
+		apiUrl,
+		token
 	};
 	const markedBody = `${COMMENT_MARKER}\n${body}`;
 	const existingId = await findMergeRequestCommentByPrefix(repo, number, COMMENT_MARKER, api);
@@ -250,11 +244,11 @@ async function postMrComment(context, body, options = {}) {
 	await createMergeRequestComment(repo, number, markedBody, api);
 }
 async function resolveMergeRequest(context, options) {
-	const { repo } = context.gitlab ?? {};
+	const { repo, apiUrl, token } = 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
+		apiUrl,
+		token
 	};
 	if (options.number !== void 0) {
 		const data = await getMergeRequest(repo, options.number, api);
@@ -299,7 +293,7 @@ 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}`;
+	return joinPath(context.gitlab.webUrl, repo, "-/new", branchPath) + `?${params}`;
 }
 function parsePositiveInt(value, option) {
 	const number = Number(value);
@@ -322,8 +316,8 @@ function gitlab(options = {}) {
 			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
+				apiUrl: options.apiUrl ?? process.env.GITLAB_API_URL ?? process.env.CI_API_V4_URL ?? "https://gitlab.com/api/v4",
+				webUrl: options.webUrl ?? process.env.GITLAB_SERVER_URL ?? process.env.CI_SERVER_URL ?? "https://gitlab.com"
 			};
 		},
 		async resolvePlanStatus({ plan }) {
@@ -389,7 +383,7 @@ function gitlab(options = {}) {
 		async initCli(cli) {
 			registerMrCli(cli);
 			if (!isCI()) return;
-			const { repo, token, webUrl } = this.gitlab ?? {};
+			const { repo, token, webUrl } = this.gitlab;
 			if (!token || !repo) return;
 			const result = await x("git", [
 				"remote",
@@ -442,7 +436,6 @@ function gitlab(options = {}) {
 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",
@@ -470,7 +463,7 @@ function createChangelogRenderer(context) {
 		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}`;
+			let line = repo ? `- [!${mr.number} ${mr.title}](${joinPath(webUrl, repo, "-/merge_requests", String(mr.number))})` : `- #${mr.number} ${mr.title}`;
 			if (mr.user) line += ` by @${mr.user.login}`;
 			lines.push(line);
 		}
@@ -488,7 +481,7 @@ function createChangelogRenderer(context) {
 		let commitSuffix = "";
 		if (meta.commit) {
 			const short = meta.commit.slice(0, 7);
-			const link = repo ? `[${short}](${baseUrl}/${repo}/-/commit/${meta.commit})` : `\`${short}\``;
+			const link = repo ? `[${short}](${joinPath(webUrl, repo, "-/commit", meta.commit)})` : `\`${short}\``;
 			commitSuffix += ` (${link})`;
 		}
 		const lines = [];
@@ -548,7 +541,7 @@ function resolveGitLabToken(optionToken) {
 }
 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`;
+	return joinPath(webUrl.replace(/^https?:\/\//, `https://${username}:${token.value}@`), `${repo}.git`);
 }
 //#endregion
 export { gitlab };

package/dist/plugins/go.d.ts

@@ -1,4 +1,4 @@
-import { D as WorkspacePackage, j as BumpType, s as TegamiPlugin } from "../types-C1rEqeM4.js";
+import { M as BumpType, O as WorkspacePackage, s as TegamiPlugin } from "../types-DHddSAez.js";
 
 //#region src/plugins/go.d.ts
 interface GoModFile {
@@ -24,6 +24,11 @@ declare class GoPackage extends WorkspacePackage {
   setRequire(module: string, version: string): void;
   write(): Promise<void>;
 }
+interface DependentRef {
+  dependent: GoPackage;
+  name: string;
+  version: string;
+}
 interface GoPluginOptions {
   /**
    * Run `go work sync` or `go mod tidy` after versioning.
@@ -31,14 +36,10 @@ interface GoPluginOptions {
    * @default true
    */
   updateLockFile?: boolean;
-  bumpDep?: (opts: {
-    dependent: GoPackage;
-    name: string;
-    version: string;
-  }) => BumpType | false;
+  bumpDep?: (opts: DependentRef) => BumpType | false;
 }
 /**
- * Experimental plugin for Golang, the release flow of Golang is pretty special, there's some exceptions for it:
+ * Plugin for Golang, the release flow of Golang is pretty special, there's some exceptions for it:
  *
  * - Version is stored in lock file, normally, it should prefer to store versions in a file like `package.json` & `Cargo.toml`, but for Golang, there is no such file.
  * - Publishing is handed to Git plugin, because Golang uses Git tag for publishing.