tegami 1.2.3 → 1.2.4

package/dist/plugins/gitlab.d.ts

@@ -1,13 +1,13 @@
-import { j as WorkspacePackage, s as TegamiPlugin, t as Awaitable, x as TegamiContext, y as PublishPlan } from "../types-Kj7Nxbjz.js";
+import { j as WorkspacePackage, s as TegamiPlugin, t as Awaitable, x as TegamiContext, y as PublishPlan } from "../types-BMYzG4dR.js";
 import { GitPluginOptions } from "./git.js";
-import { t as VersionRequestOptions } from "../version-request-C5vtakPE.js";
+import { t as VersionRequestOptions } from "../version-request-BorZZ98V.js";
 
 //#region src/plugins/gitlab.d.ts
 interface GitlabRelease {
   /** Release title */
-  title?: string;
+  title: string;
   /** Release notes */
-  notes?: string;
+  notes: string;
 }
 /** Options for creating GitLab releases after a successful publish. */
 interface GitLabPluginOptions extends GitPluginOptions {
@@ -35,12 +35,12 @@ interface GitLabPluginOptions extends GitPluginOptions {
       tag: string;
       pkg: WorkspacePackage;
       plan: PublishPlan;
-    }) => Awaitable<GitlabRelease>; /** Override release details when multiple packages share a git tag. */
+    }) => Awaitable<Partial<GitlabRelease>>; /** Override release details when multiple packages share a git tag. */
     createGrouped?: (this: TegamiContext, opts: {
       tag: string;
       packages: WorkspacePackage[];
       plan: PublishPlan;
-    }) => Awaitable<GitlabRelease>;
+    }) => Awaitable<Partial<GitlabRelease>>;
   };
   /**
    * (CLI only) Open a version merge request after versioning.

package/dist/plugins/gitlab.js

@@ -1,9 +1,8 @@
-import { a as formatPackageVersion } from "../semver-DrtaCCZK.js";
 import { t as changelogFilename } from "../generate-Cgl2G5ea.js";
 import { c as joinPath, n as execFailure, o as cached, r as fetchFailure, s as isCI } from "../error-CAsrGb6e.js";
-import { a as createDraft, l as readChangelogEntries } from "../publish-BEYIILK5.js";
+import { a as createDraft, l as readChangelogEntries } from "../publish-DAMkayLs.js";
 import { git } from "./git.js";
-import { n as onVersionRequest, t as formatPreview } from "../version-request-C89RO85i.js";
+import { i as versionRequestPlugin, n as formatPreview, r as resolveFileCommit, t as createAutoRelease } from "../version-request-CQ4cJHtP.js";
 import { readFile, writeFile } from "node:fs/promises";
 import { basename, join, relative, resolve } from "node:path";
 import { x } from "tinyexec";
@@ -273,209 +272,120 @@ function parsePositiveInt(value, option) {
 /** 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 versionRequests = onVersionRequest({
-		name: "gitlab",
-		options: options.versionMr,
-		canCreate(context) {
-			const { repo, token } = context.gitlab ?? {};
-			return Boolean(repo && token);
-		},
-		async upsert(context, request, update) {
-			const repo = context.gitlab.repo;
-			const api = gitLabApiOptions(context.gitlab);
-			const openMr = await findOpenMergeRequest(repo, {
-				head: request.head,
-				base: request.base,
-				...api
-			});
-			if (openMr === void 0) await createMergeRequest(repo, {
-				title: request.title,
-				body: request.body,
-				head: request.head,
-				base: request.base,
-				...api
-			});
-			else if (update) await updateMergeRequest(repo, openMr, {
-				title: request.title,
-				body: request.body,
-				base: request.base,
-				...api
-			});
-		}
-	});
-	const plugin = {
-		...versionRequests,
-		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 ?? "https://gitlab.com/api/v4",
-				webUrl: options.webUrl ?? process.env.GITLAB_SERVER_URL ?? process.env.CI_SERVER_URL ?? "https://gitlab.com"
-			};
-		},
-		async resolvePlanStatus({ plan }) {
-			if (versionRequests.resolvePlanStatus.call(this, { plan }) === "pending") return "pending";
-			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)
-					};
+	let autoRelease;
+	return [
+		git(options),
+		{
+			name: "gitlab",
+			init() {
+				const { repo, token, webUrl } = 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 ?? "https://gitlab.com/api/v4",
+					webUrl: options.webUrl ?? process.env.GITLAB_SERVER_URL ?? process.env.CI_SERVER_URL ?? "https://gitlab.com"
+				};
+				if (repo && token && releaseOptions !== false) {
+					const { eager = false, create, createGrouped } = releaseOptions === true ? {} : releaseOptions;
+					const api = gitLabApiOptions(this.gitlab);
+					const resolveEntryMeta = cached((entry) => entry.id, async (entry) => {
+						const commit = await resolveFileCommit(this, entry.filename);
+						if (!commit || !repo) return {
+							commit,
+							mergeRequests: []
+						};
+						return {
+							commit,
+							mergeRequests: await listMergeRequestsForCommit(repo, commit, api).catch(() => [])
+						};
+					});
+					autoRelease = createAutoRelease({
+						eager,
+						override: create,
+						overrideGroup: createGrouped,
+						async formatChangelog(entry) {
+							const meta = await resolveEntryMeta(entry);
+							const commitSuffix = meta.commit ? ` ([${meta.commit.slice(0, 7)}](${joinPath(webUrl, repo, "-/commit", meta.commit)}))` : "";
+							const lines = [];
+							for (const section of entry.sections) {
+								lines.push(`### ${section.title}${commitSuffix}`, "");
+								if (section.content) lines.push(section.content, "");
+							}
+							if (meta.mergeRequests.length > 0) {
+								lines.push("<details>", "<summary>Merge request & contributors</summary>", "");
+								for (const mr of meta.mergeRequests) {
+									let line = `- [!${mr.number} ${mr.title}](${joinPath(webUrl, repo, "-/merge_requests", String(mr.number))})`;
+									if (mr.user) line += ` by @${mr.user.login}`;
+									lines.push(line);
+								}
+								lines.push("", "</details>");
+							}
+							return lines.join("\n").trim();
+						},
+						create({ input, tag }) {
+							return createRelease(repo, {
+								tag,
+								title: input.title,
+								notes: input.notes,
+								...api
+							});
+						},
+						releaseExistsByTag(tag) {
+							return releaseExistsByTag(repo, tag, api);
+						}
+					});
 				}
-				await createRelease(repo, {
-					tag,
-					title: release.title,
-					notes: release.notes,
+			},
+			async resolvePlanStatus({ plan }) {
+				if (await autoRelease?.hasPending.call(this, plan)) return "pending";
+			},
+			async afterPublishAll({ plan }) {
+				await autoRelease?.create.call(this, plan);
+			},
+			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);
+			}
+		},
+		versionRequestPlugin({
+			name: "gitlab",
+			options: options.versionMr,
+			canCreate(context) {
+				const { repo, token } = context.gitlab ?? {};
+				return Boolean(repo && token);
+			},
+			async upsert(context, request, update) {
+				const repo = context.gitlab.repo;
+				const api = gitLabApiOptions(context.gitlab);
+				const openMr = await findOpenMergeRequest(repo, {
+					head: request.head,
+					base: request.base,
 					...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);
-		}
-	};
-	return [git(options), plugin];
-}
-function createChangelogRenderer(context) {
-	const { repo, webUrl } = context.gitlab;
-	const api = gitLabApiOptions(context.gitlab);
-	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}](${joinPath(webUrl, repo, "-/merge_requests", String(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}](${joinPath(webUrl, 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");
+				if (openMr === void 0) await createMergeRequest(repo, {
+					title: request.title,
+					body: request.body,
+					head: request.head,
+					base: request.base,
+					...api
+				});
+				else if (update) await updateMergeRequest(repo, openMr, {
+					title: request.title,
+					body: request.body,
+					base: request.base,
+					...api
+				});
+			}
+		})
+	];
 }
 function gitLabApiOptions(gitlab) {
 	const options = {};

package/dist/plugins/go.d.ts

@@ -1,4 +1,4 @@
-import { F as BumpType, j as WorkspacePackage, s as TegamiPlugin } from "../types-Kj7Nxbjz.js";
+import { F as BumpType, j as WorkspacePackage, s as TegamiPlugin } from "../types-BMYzG4dR.js";
 
 //#region src/plugins/go.d.ts
 interface GoModFile {

package/dist/plugins/go.js

@@ -287,7 +287,6 @@ function go({ updateLockFile = true, bumpDep: getBumpDepType } = {}) {
 	let active = false;
 	return {
 		name: "go",
-		enforce: "post",
 		async resolve() {
 			await discoverGoPackages(this.cwd, (pkg) => this.graph.add(pkg));
 			active = this.graph.getPackages().some((pkg) => pkg instanceof GoPackage);
@@ -320,9 +319,9 @@ function go({ updateLockFile = true, bumpDep: getBumpDepType } = {}) {
 		},
 		initPublishLock({ lock, draft }) {
 			if (!active) return;
-			for (const [id, packageDraft] of draft.getPackageDrafts()) {
+			for (const id of draft.getPackageDrafts().keys()) {
 				const pkg = this.graph.get(id);
-				if (!(pkg instanceof GoPackage) || !packageDraft.type) continue;
+				if (!(pkg instanceof GoPackage)) continue;
 				lock.write("go:packages", {
 					id,
 					version: pkg.version
@@ -331,17 +330,18 @@ function go({ updateLockFile = true, bumpDep: getBumpDepType } = {}) {
 		},
 		initPublishPlan({ lock, plan }) {
 			if (!active) return;
+			const lockVersions = /* @__PURE__ */ new Map();
 			let data;
 			while (data = lock.read("go:packages")) {
-				const validated = validateGoPackageLock(data);
-				if (!validated.success) continue;
-				const parsed = validated.data;
-				const pkg = this.graph.get(parsed.id);
-				if (pkg instanceof GoPackage) pkg.setVersion(parsed.version);
+				const { success, data: parsed } = validateGoPackageLock(data);
+				if (!success) continue;
+				lockVersions.set(parsed.id, parsed.version);
 			}
 			for (const [id, packagePlan] of plan.packages) {
 				const pkg = this.graph.get(id);
 				if (!(pkg instanceof GoPackage)) continue;
+				const version = packagePlan.updated && lockVersions.get(id);
+				if (version) pkg.setVersion(version);
 				packagePlan.git ??= {};
 				packagePlan.git.tag = formatGoTag(this.cwd, pkg.path, pkg.version);
 			}

package/dist/providers/npm.d.ts

@@ -1,2 +1,2 @@
-import { C as NpmGraph, S as DependencySpec, l as NpmPluginOptions, u as npm, w as NpmPackage } from "../types-Kj7Nxbjz.js";
+import { C as NpmGraph, S as DependencySpec, l as NpmPluginOptions, u as npm, w as NpmPackage } from "../types-BMYzG4dR.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-uJA8deYA.js";
+import { n as NpmPackage, t as npm } from "../npm-CyC2Rk11.js";
 export { NpmPackage, npm };

package/dist/{publish-BEYIILK5.js → publish-DAMkayLs.js}

@@ -788,10 +788,12 @@ async function runPreflights(context, plan) {
 async function publishPlanStatus(plan, context) {
 	for (const plugin of context.plugins) {
 		const status = await handlePluginError(plugin, "resolvePlanStatus", () => plugin.resolvePlanStatus?.call(context, { plan }));
-		if (Array.isArray(status) && await somePromise(status, (v) => v === "pending")) return "pending";
-		if (status === "pending") return "pending";
+		if (Array.isArray(status) && await somePromise(status, (v) => v === "pending") || status === "pending") return {
+			status: "pending",
+			reason: `Plugin "${plugin.name}" has pending tasks`
+		};
 	}
-	return "success";
+	return { status: "success" };
 }
 //#endregion
 export { createDraft as a, parseChangelogFile as c, runPublishPlan as i, readChangelogEntries as l, publishPlanStatus as n, PublishLock as o, runPreflights as r, parsePublishLock as s, initPublishPlan as t };

package/dist/{types-Kj7Nxbjz.d.ts → types-BMYzG4dR.d.ts}

@@ -362,9 +362,11 @@ declare class CargoToml<Data extends CargoManifest = CargoManifest> {
   data: Data;
   private dependencies;
   workspace?: CargoToml<RequireFields<CargoManifest, "workspace">>;
+  private readonly originalContent;
   constructor(path: string, content: string, data: Data);
   listDependencies(graph: CargoGraph): ResolvedDependency[];
   patch(path: string, value: unknown): void;
+  write(): Promise<void>;
 }
 interface ResolvedDependency {
   path: [...string[], kind: DepKind, key: string];
@@ -645,11 +647,22 @@ interface Tegami {
   /** Publish packages from the publish lock. */
   publish(options?: PublishOptions): Promise<PublishPlan | "skipped">;
   /**
-   * Check publish status.
-   *
-   * Prefer `publish()` over this if you are publishing packages, it will also check the publish status.
+   * @deprecated use `getPublishStatus()` instead
    */
   publishStatus(options?: PublishOptions): Promise<"pending" | "success" | "idle">;
+  /**
+   * Check publish plan status.
+   *
+   * Prefer `publish()` over this if you are publishing packages, this is check-only and can lead to TOCTOU race.
+   */
+  getPublishStatus(options?: PublishOptions): Promise<{
+    /**
+     * - `pending`: has pending tasks.
+     * - `success`: all tasks finished.
+     * - `none`: there is no existing publish plans. */
+    status: "pending" | "success" | "none";
+    reason?: string;
+  }>;
   /** Remove the publish lock file after publishing has finished successfully. */
   cleanup(options?: PublishOptions): Promise<{
     state: "removed";

package/dist/{version-request-C5vtakPE.d.ts → version-request-BorZZ98V.d.ts}

@@ -1,4 +1,4 @@
-import { M as Draft, h as PublishLock, t as Awaitable, x as TegamiContext, y as PublishPlan } from "./types-Kj7Nxbjz.js";
+import { M as Draft, h as PublishLock, t as Awaitable, x as TegamiContext, y as PublishPlan } from "./types-BMYzG4dR.js";
 
 //#region src/utils/version-request.d.ts
 interface VersionRequestOptions {