tegami 0.1.6 → 0.2.0

package/dist/plugins/git.d.ts

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

package/dist/plugins/git.js

@@ -1,5 +1,4 @@
 import { a as isCI, n as execFailure } from "../error-DNy8R5ue.js";
-import { n as publishError, t as packagePublishError } from "../publish-DkRT0yh6.js";
 import { x } from "tinyexec";
 //#region src/plugins/git.ts
 /**
@@ -10,12 +9,15 @@ import { x } from "tinyexec";
 */
 function git(options = {}) {
 	const { createTags = true, pushTags = isCI() } = options;
-	function resolveGitTag(context, result) {
-		const { graph } = context;
-		const pkg = graph.get(result.id);
-		const group = pkg && graph.getPackageGroup(pkg.id);
-		if (group?.options.syncGitTag) return `${group.name}@${result.version}`;
-		return `${result.name}@${result.version}`;
+	function getPendingTags(plan) {
+		const pendingTags = /* @__PURE__ */ new Set();
+		if ((plan.options.dryRun ?? false) || !createTags) return pendingTags;
+		for (const pkg of plan.packages.values()) {
+			if (pkg.publishResult.type !== "published") continue;
+			const tag = pkg.git?.tag;
+			if (tag) pendingTags.add(tag);
+		}
+		return pendingTags;
 	}
 	return {
 		name: "git",
@@ -36,45 +38,47 @@ function git(options = {}) {
 				if (result.exitCode !== 0) throw execFailure("Failed to configure git user for GitHub Actions.", result);
 			}
 		} },
-		async afterPublishAll(result) {
-			const { cwd, publishOptions: { dryRun = false } } = this;
-			if (dryRun || !createTags || result.state === "skipped") return;
-			const createdTags = [];
-			const pendingTags = /* @__PURE__ */ new Map();
-			for (const pkg of result.packages) {
-				const tag = resolveGitTag(this, pkg);
-				pkg.git = {
-					tag,
-					tagState: "skipped"
-				};
-				if (pkg.state === "success") pendingTags.set(tag, null);
+		initPublishPlan({ plan }) {
+			const { graph } = this;
+			for (const [id, packagePlan] of plan.packages) {
+				const pkg = graph.get(id);
+				const group = pkg && graph.getPackageGroup(pkg.id);
+				let tag;
+				if (group?.options.syncGitTag) tag = `${group.name}@${pkg.version}`;
+				else tag = `${pkg.name}@${pkg.version}`;
+				packagePlan.git = { tag };
+			}
+		},
+		async resolvePlanStatus({ plan }) {
+			const pendingTags = getPendingTags(plan);
+			if (pendingTags.size === 0) return;
+			try {
+				await Promise.all(Array.from(pendingTags, async (tag) => {
+					if (!await gitTagExists(this.cwd, tag)) throw "pending";
+				}));
+			} catch (e) {
+				if (e === "pending") return "pending";
+				throw e;
 			}
-			await Promise.all(Array.from(pendingTags.keys(), async (tag) => {
+		},
+		async afterPublishAll({ plan }) {
+			const { cwd } = this;
+			const createdTags = [];
+			const pendingTags = getPendingTags(plan);
+			if (pendingTags.size === 0) return;
+			await Promise.all(Array.from(pendingTags, async (tag) => {
 				if (await gitTagExists(cwd, tag)) return;
 				const gitOut = await x("git", ["tag", tag], { nodeOptions: { cwd } });
-				if (gitOut.exitCode !== 0) {
-					pendingTags.set(tag, execFailure(`Failed to create Git tag "${tag}" for release`, gitOut));
-					return;
-				}
+				if (gitOut.exitCode !== 0) throw execFailure(`Failed to create Git tag "${tag}" for release`, gitOut);
 				createdTags.push(tag);
-				pendingTags.set(tag, true);
 			}));
-			for (const pkg of result.packages) {
-				if (!pkg.git?.tag) continue;
-				const state = pendingTags.get(pkg.git.tag);
-				if (state === true) pkg.git.tagState = "created";
-				else if (state instanceof Error) {
-					pkg.git.tagState = "failed";
-					packagePublishError(result, pkg, state.message);
-				}
-			}
 			if (pushTags && createdTags.length > 0) {
 				const gitOut = await x("git", [
 					"push",
 					"origin",
 					...createdTags
 				], { nodeOptions: { cwd } });
-				if (gitOut.exitCode !== 0) publishError(result, execFailure(`Failed to push Git tags to origin: ${createdTags.join(", ")}`, gitOut).message);
+				if (gitOut.exitCode !== 0) throw execFailure(`Failed to push Git tags to origin: ${createdTags.join(", ")}`, gitOut);
 			}
 		}
 	};

package/dist/plugins/github.d.ts

@@ -1,4 +1,4 @@
-import { S as PackagePublishResult, T as TegamiContext, c as TegamiPlugin, k as DraftPlan, t as Awaitable } from "../types-DexeJdl7.js";
+import { D as WorkspacePackage, O as Draft, S as PublishPlan, s as TegamiPlugin, t as Awaitable, w as TegamiContext } from "../types-CurHqnWl.js";
 import { GitPluginOptions } from "./git.js";
 
 //#region src/plugins/github.d.ts
@@ -35,6 +35,10 @@ interface VersionPullRequestOptions {
    * @default "main"
    */
   base?: string;
+  /** Override details for "Version Packages" PR. */
+  create?: (this: TegamiContext, opts: {
+    draft: Draft;
+  }) => Awaitable<VersionPullRequest>;
 }
 /** Options for creating GitHub releases after a successful publish. */
 interface GitHubPluginOptions extends GitPluginOptions {
@@ -43,25 +47,34 @@ interface GitHubPluginOptions extends GitPluginOptions {
   /** Optional GitHub token for Git & GitHub operations. */
   token?: string;
   /**
-   * Create GitHub release immediately after successful publish, without waiting for others.
+   * Create GitHub release for published packages.
    *
-   * @default false
+   * @default true
    */
-  eagerRelease?: boolean;
-  /** Override release details for a single package, return `false` to skip. */
-  onCreateRelease?: (this: TegamiContext, result: PackagePublishResult) => Awaitable<GithubRelease | false>;
-  /** Override release details when multiple packages share a git tag, return `false` to skip. */
-  onCreateGroupedRelease?: (this: TegamiContext, packages: PackagePublishResult[]) => Awaitable<GithubRelease | false>;
-  /** Override details for "Version Packages" PR. */
-  onCreateVersionPullRequest?: (this: TegamiContext, publishPlan: DraftPlan) => Awaitable<VersionPullRequest | false>;
-  cli?: {
+  release?: boolean | {
     /**
-     * Open a version pull request after versioning.
-     * Defaults to enabled in CI and disabled locally.
-     * Set to `true` to always create the pull request.
+     * Create GitHub release immediately after successful publish, without waiting for others.
+     *
+     * @default false
      */
-    versionPr?: boolean | VersionPullRequestOptions;
+    eager?: boolean; /** Override release details for a single package. */
+    create?: (this: TegamiContext, opts: {
+      tag: string;
+      pkg: WorkspacePackage;
+      plan: PublishPlan;
+    }) => Awaitable<GithubRelease>; /** Override release details when multiple packages share a git tag. */
+    createGrouped?: (this: TegamiContext, opts: {
+      tag: string;
+      packages: WorkspacePackage[];
+      plan: PublishPlan;
+    }) => Awaitable<GithubRelease>;
   };
+  /**
+   * (CLI only) Open a version pull request after versioning.
+   *
+   * Defaults to enabled in CI and disabled locally.
+   */
+  versionPr?: VersionPullRequestOptions | false;
 }
 /** Create GitHub releases for successfully published packages after the whole plan succeeds. */
 declare function github(options?: GitHubPluginOptions): TegamiPlugin[];

package/dist/plugins/github.js

@@ -1,6 +1,6 @@
 import { i as formatPackageVersion, r as formatNpmDistTag } from "../semver-C4vJ4SK8.js";
 import { a as isCI, n as execFailure } from "../error-DNy8R5ue.js";
-import { n as publishError } from "../publish-DkRT0yh6.js";
+import { a as findOpenPullRequest, l as updatePullRequest, n as createPullRequest, r as createRelease, s as releaseExistsByTag } from "../api-D-jf_8xY.js";
 import { git } from "./git.js";
 import { join, relative } from "node:path";
 import { x } from "tinyexec";
@@ -8,44 +8,27 @@ import { prerelease } from "semver";
 //#region src/plugins/github.ts
 /** Create GitHub releases for successfully published packages after the whole plan succeeds. */
 function github(options = {}) {
-	const { eagerRelease = false, onCreateGroupedRelease, onCreateRelease, onCreateVersionPullRequest, cli: cliOptions = {} } = options;
-	async function createRelease(context, pkg) {
-		if (pkg.state === "failed") return;
-		const release = await onCreateRelease?.call(context, pkg) ?? {};
-		if (release === false) return;
-		return {
-			title: release.title ?? defaultTitle(pkg),
-			notes: release.notes ?? await defaultNotes(context, pkg),
-			prerelease: release.prerelease ?? prerelease(pkg.version) !== null
-		};
-	}
-	async function createGroupedRelease(context, packages) {
-		if (packages.some((member) => member.state === "failed")) return;
-		const release = await onCreateGroupedRelease?.call(context, packages) ?? {};
-		if (release === false) return;
-		return {
-			title: release.title ?? defaultGroupedTitle(packages),
-			notes: release.notes ?? await defaultGroupedNotes(context, packages),
-			prerelease: release.prerelease ?? packages.some((pkg) => prerelease(pkg.version) !== null)
-		};
+	const { release: releaseOptions = true } = options;
+	let renderer;
+	function getRenderer(context) {
+		return renderer ??= createChangelogRenderer(context);
 	}
 	function resolvePROptions() {
-		const setting = cliOptions.versionPr ?? isCI();
-		if (setting === false) return [false];
-		if (setting === true) return [true, {}];
-		if (setting.forceCreate || isCI()) return [true, setting];
+		const config = options.versionPr ?? {};
+		if (config === false) return [false];
+		if (config.forceCreate || isCI()) return [true, config];
 		return [false];
 	}
 	function defaultVersionPRBody(draft, context) {
 		const packageLines = [];
 		for (const pkg of context.graph.getPackages()) {
-			const packagePlan = draft.getPackagePlan(pkg.id);
-			if (!packagePlan) continue;
+			const packageDraft = draft.getPackageDraft(pkg.id);
+			if (!packageDraft) continue;
 			const originalVersion = cliOriginalPackageVersions.get(pkg.id) ?? pkg.version;
 			if (originalVersion === pkg.version) continue;
-			const publishTxt = packagePlan.publish ? "" : " (no publish)";
-			const distTagTxt = formatNpmDistTag(packagePlan.npm?.distTag);
-			packageLines.push(`- ${pkg.name}@${originalVersion} → ${pkg.name}@${pkg.version}${distTagTxt}${publishTxt}`);
+			let line = `- **${pkg.name}**: ${originalVersion} → ${pkg.version}`;
+			line += formatNpmDistTag(packageDraft.npm?.distTag);
+			packageLines.push(line);
 		}
 		const changelogLines = [];
 		for (const entry of draft.getChangelogs()) {
@@ -75,6 +58,74 @@ function github(options = {}) {
 				token: options.token ?? process.env.GITHUB_TOKEN ?? process.env.GH_TOKEN
 			};
 		},
+		async resolvePlanStatus({ plan }) {
+			const { repo, token } = this.github;
+			if (!repo || !token || releaseOptions === false) return;
+			const tags = groupPackagesByTag(this, plan);
+			try {
+				await Promise.all(Array.from(tags.keys(), async (tag) => {
+					if (!await releaseExistsByTag(repo, tag, token)) throw "pending";
+				}));
+			} catch (e) {
+				if (e === "pending") return "pending";
+				throw e;
+			}
+		},
+		async afterPublishAll({ plan }) {
+			const { repo, token } = this.github;
+			if (!repo || !token || releaseOptions === false) return;
+			const { eager = false, create, createGrouped } = releaseOptions === true ? {} : releaseOptions;
+			if (!eager) {
+				for (const pkg of plan.packages.values()) if (pkg.publishResult.type === "failed") return;
+			}
+			await Promise.all(Array.from(groupPackagesByTag(this, plan), async ([tag, packages]) => {
+				let hasFailed = false;
+				let hasPublished = false;
+				for (const member of packages) switch (plan.packages.get(member.id).publishResult.type) {
+					case "published":
+						hasPublished = true;
+						break;
+					case "failed":
+						hasFailed = true;
+						break;
+				}
+				if (hasFailed || !hasPublished) return;
+				if (await releaseExistsByTag(repo, tag, token)) 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),
+						prerelease: overrides.prerelease ?? packages.some((pkg) => prerelease(pkg.version) !== null)
+					};
+				} 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),
+						prerelease: overrides.prerelease ?? prerelease(pkg.version) !== null
+					};
+				}
+				await createRelease(repo, {
+					tag,
+					title: release.title,
+					notes: release.notes,
+					prerelease: release.prerelease,
+					token
+				});
+			}));
+		},
 		cli: {
 			async init() {
 				if (!isCI()) return;
@@ -88,17 +139,16 @@ function github(options = {}) {
 				], { nodeOptions: { cwd: this.cwd } });
 				if (result.exitCode !== 0) throw execFailure("Failed to configure git remote for GitHub Actions.", result);
 			},
-			publishPlanCreated() {
+			draftCreated() {
 				for (const pkg of this.graph.getPackages()) cliOriginalPackageVersions.set(pkg.id, pkg.version);
 			},
-			async publishPlanApplied(draft) {
+			async draftApplied(draft) {
 				const { cwd } = this;
 				const [enabled, config] = resolvePROptions();
-				const repo = this.github?.repo;
 				if (!enabled || !await hasGitChanges(cwd)) return;
+				const repo = this.github?.repo;
 				const { branch = "tegami/version-packages", base = "main" } = config;
-				const basePR = await onCreateVersionPullRequest?.call(this, draft);
-				if (basePR === false) return;
+				const basePR = await config.create?.call(this, { draft });
 				const pr = {
 					title: basePR?.title ?? "Version Packages",
 					body: basePR?.body ?? defaultVersionPRBody(draft, this)
@@ -126,148 +176,98 @@ function github(options = {}) {
 					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 openPr = await findOpenPullRequest(branch, repo);
+				const token = this.github?.token;
+				if (!repo) return;
+				const openPr = await findOpenPullRequest(repo, branch, token);
 				if (openPr !== void 0) {
-					const editArgs = [
-						"pr",
-						"edit",
-						String(openPr),
-						"--title",
-						pr.title,
-						"--body",
-						pr.body
-					];
-					if (repo) editArgs.push("--repo", repo);
-					const editResult = await x("gh", editArgs);
-					if (editResult.exitCode !== 0) throw execFailure("Failed to update the version pull request.", editResult);
+					await updatePullRequest(repo, openPr, {
+						title: pr.title,
+						body: pr.body,
+						token
+					});
 					return;
 				}
-				const args = [
-					"pr",
-					"create",
-					"--title",
-					pr.title,
-					"--body",
-					pr.body,
-					"--head",
-					branch,
-					"--base",
-					base
-				];
-				if (repo) args.push("--repo", repo);
-				const prResult = await x("gh", args);
-				if (prResult.exitCode !== 0) throw execFailure("Failed to create the version pull request.", prResult);
+				await createPullRequest(repo, {
+					title: pr.title,
+					body: pr.body,
+					head: branch,
+					base,
+					token
+				});
 			}
-		},
-		async afterPublishAll(result) {
-			if (result.state === "skipped") return;
-			if (!eagerRelease && result.state === "failed") return;
-			const repo = this.github?.repo;
-			await Promise.all(Array.from(groupPackagesByGitTag(result.packages), async ([tag, packages]) => {
-				const release = packages.length > 1 ? await createGroupedRelease(this, packages) : await createRelease(this, packages[0]);
-				if (!release) return;
-				const viewArgs = [
-					"release",
-					"view",
-					tag
-				];
-				if (repo) viewArgs.push("--repo", repo);
-				if ((await x("gh", viewArgs)).exitCode === 0) return;
-				const args = [
-					"release",
-					"create",
-					tag,
-					"--title",
-					release.title,
-					"--notes",
-					release.notes
-				];
-				if (repo) args.push("--repo", repo);
-				if (release.prerelease) args.push("--prerelease");
-				const ghOut = await x("gh", args);
-				if (ghOut.exitCode !== 0) publishError(result, execFailure(`Failed to create GitHub release for ${tag}.`, ghOut).message);
-			}));
 		}
 	}];
 }
-async function hasGitChanges(cwd) {
-	return (await x("git", ["status", "--porcelain"], { nodeOptions: { cwd } })).stdout.trim().length > 0;
-}
-async function findOpenPullRequest(branch, repo) {
-	const args = [
-		"pr",
-		"list",
-		"--head",
-		branch,
-		"--state",
-		"open",
-		"--json",
-		"number"
-	];
-	if (repo) args.push("--repo", repo);
-	const result = await x("gh", args);
-	if (result.exitCode !== 0) throw execFailure("Failed to check for an existing version pull request.", result);
-	return JSON.parse(result.stdout)[0]?.number;
-}
-function groupPackagesByGitTag(packages) {
+function groupPackagesByTag({ graph }, plan) {
 	const groups = /* @__PURE__ */ new Map();
-	for (const pkg of packages) {
-		if (!pkg.git?.tag) continue;
-		const group = groups.get(pkg.git.tag);
+	for (const [id, packagePlan] of plan.packages) {
+		const pkg = graph.get(id);
+		const tag = packagePlan.git?.tag;
+		if (!tag) continue;
+		const group = groups.get(tag);
 		if (group) group.push(pkg);
-		else groups.set(pkg.git.tag, [pkg]);
+		else groups.set(tag, [pkg]);
 	}
 	return groups;
 }
-function defaultTitle(pkg) {
-	return formatPackageVersion(pkg.name, pkg.version, pkg.npm?.distTag);
-}
-function defaultGroupedTitle(packages) {
-	const primary = packages[0];
-	const distTag = packages.every((pkg) => pkg.npm?.distTag === primary.npm?.distTag) ? primary.npm?.distTag : void 0;
-	const tag = primary.git.tag;
-	return formatPackageVersion(tag.slice(0, tag.lastIndexOf("@")), primary.version, distTag);
-}
-function formatCommitLink(commit, repo) {
-	const short = commit.slice(0, 7);
-	if (!repo) return `\`${short}\``;
-	return `[${short}](https://github.com/${repo}/commit/${commit})`;
-}
-async function resolveChangelogEntryCommit(context, 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;
+async function hasGitChanges(cwd) {
+	return (await x("git", ["status", "--porcelain"], { nodeOptions: { cwd } })).stdout.trim().length > 0;
 }
-async function renderChangelogEntryNotes(context, entry) {
-	const repo = context.github?.repo;
-	const commit = await resolveChangelogEntryCommit(context, entry.filename);
-	const commitSuffix = commit ? ` (${formatCommitLink(commit, repo)})` : "";
-	const lines = [];
-	for (const section of entry.sections) {
-		lines.push(`### ${section.title}${commitSuffix}`, "");
-		if (section.content) lines.push(section.content, "");
+function createChangelogRenderer(context) {
+	const cache = /* @__PURE__ */ new Map();
+	async function resolveFileCommit(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;
+	}
+	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})`;
 	}
-	return lines.join("\n").trim();
+	return async (entry) => {
+		let commitPromise = cache.get(entry.filename);
+		if (!commitPromise) {
+			commitPromise = resolveFileCommit(entry.filename);
+			cache.set(entry.filename, commitPromise);
+		}
+		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, "");
+		}
+		return lines.join("\n").trim();
+	};
 }
-async function defaultNotes(context, pkg) {
-	if (pkg.changelogs.length > 0) return (await Promise.all(pkg.changelogs.map(async (entry) => renderChangelogEntryNotes(context, entry)))).join("\n\n");
-	return `Published ${formatPackageVersion(pkg.name, pkg.version, pkg.npm?.distTag)}.`;
+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(context, packages) {
+async function defaultGroupedNotes(renderer, plan, packages) {
 	const changelogs = /* @__PURE__ */ new Map();
-	for (const pkg of packages) for (const entry of pkg.changelogs) changelogs.set(entry.id, entry);
-	const sections = [packages.map((pkg) => `- ${formatPackageVersion(pkg.name, pkg.version, pkg.npm?.distTag)}`).join("\n")];
+	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()).map((entry) => renderChangelogEntryNotes(context, entry)));
+		const notes = await Promise.all(Array.from(changelogs.values(), renderer));
 		sections.push("", notes.join("\n\n"));
-	} else sections.push("", `Published ${packages[0].git.tag}.`);
+	}
 	return sections.join("\n");
 }
 //#endregion

package/dist/providers/cargo.d.ts

@@ -1,2 +1,2 @@
-import { d as CargoPluginOptions, f as CargoRegistryClient, p as cargo, u as CargoPackage } from "../types-DexeJdl7.js";
-export { CargoPackage, CargoPluginOptions, CargoRegistryClient, cargo };
+import { d as cargo, l as CargoPackage, u as CargoPluginOptions } from "../types-CurHqnWl.js";
+export { CargoPackage, CargoPluginOptions, cargo };