tegami 0.1.5 → 0.2.0

package/dist/plugins/git.d.ts

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

package/dist/plugins/git.js

@@ -9,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",
@@ -35,39 +38,48 @@ 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 result;
-			const pendingTags = /* @__PURE__ */ new Set();
-			for (const pkg of result.packages) {
-				if (pkg.state !== "success") continue;
-				pkg.gitTag = resolveGitTag(this, pkg);
-				pendingTags.add(pkg.gitTag);
+		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 {
-				const createdTags = [];
-				await Promise.all(Array.from(pendingTags).map(async (tag) => {
-					if (await gitTagExists(cwd, tag)) return;
-					const gitOut = await x("git", ["tag", tag], { nodeOptions: { cwd } });
-					if (gitOut.exitCode !== 0) throw execFailure(`Failed to create Git tag "${tag}" for release`, gitOut);
-					createdTags.push(tag);
+				await Promise.all(Array.from(pendingTags, async (tag) => {
+					if (!await gitTagExists(this.cwd, tag)) throw "pending";
 				}));
-				if (pushTags && createdTags.length > 0) {
-					const gitOut = await x("git", [
-						"push",
-						"origin",
-						...createdTags
-					], { nodeOptions: { cwd } });
-					if (gitOut.exitCode !== 0) throw execFailure(`Failed to push Git tags to origin: ${createdTags.join(", ")}`, gitOut);
-				}
-			} catch (error) {
-				return {
-					...result,
-					state: "failed",
-					error: error instanceof Error ? error.message : String(error)
-				};
+			} catch (e) {
+				if (e === "pending") return "pending";
+				throw e;
+			}
+		},
+		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) throw execFailure(`Failed to create Git tag "${tag}" for release`, gitOut);
+				createdTags.push(tag);
+			}));
+			if (pushTags && createdTags.length > 0) {
+				const gitOut = await x("git", [
+					"push",
+					"origin",
+					...createdTags
+				], { nodeOptions: { cwd } });
+				if (gitOut.exitCode !== 0) throw execFailure(`Failed to push Git tags to origin: ${createdTags.join(", ")}`, gitOut);
 			}
-			return result;
 		}
 	};
 }

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-BXk2fMqa.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,5 +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 { 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";
@@ -7,53 +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 runGithubRelease(gitTag, title, notes, prerelease, repo) {
-		const args = [
-			"release",
-			"create",
-			gitTag,
-			"--title",
-			title,
-			"--notes",
-			notes
-		];
-		if (repo) args.push("--repo", repo);
-		if (prerelease) args.push("--prerelease");
-		const result = await x("gh", args);
-		if (result.exitCode !== 0) throw execFailure(`Failed to create GitHub release for ${gitTag}.`, result);
-	}
-	async function createRelease(context, pkg) {
-		if (!pkg.gitTag || pkg.state === "failed") return;
-		const release = await onCreateRelease?.call(context, pkg) ?? {};
-		if (release === false) return;
-		await runGithubRelease(pkg.gitTag, release.title ?? defaultTitle(pkg), release.notes ?? await defaultNotes(context, pkg), release.prerelease ?? prerelease(pkg.version) !== null, context.github?.repo);
-	}
-	async function createGroupedRelease(context, packages) {
-		const primary = packages[0];
-		if (!primary?.gitTag) return;
-		if (packages.some((member) => member.state === "failed")) return;
-		const release = await onCreateGroupedRelease?.call(context, packages) ?? {};
-		if (release === false) return;
-		await runGithubRelease(primary.gitTag, release.title ?? defaultGroupedTitle(packages), release.notes ?? await defaultGroupedNotes(context, packages), release.prerelease ?? packages.some((pkg) => prerelease(pkg.version) !== null), context.github?.repo);
+	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()) {
@@ -83,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;
@@ -96,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)
@@ -134,124 +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 (!eagerRelease && result.state === "failed") return;
-			if (result.state === "skipped") return;
-			for (const packages of groupPackagesByGitTag(result.packages).values()) if (packages.length > 1) await createGroupedRelease(this, packages);
-			else await createRelease(this, packages[0]);
 		}
 	}];
 }
-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.gitTag) continue;
-		const group = groups.get(pkg.gitTag);
+	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.gitTag, [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;
-	return formatPackageVersion(primary.gitTag.slice(0, primary.gitTag.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].gitTag}.`);
+	}
 	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-BXk2fMqa.js";
-export { CargoPackage, CargoPluginOptions, CargoRegistryClient, cargo };
+import { d as cargo, l as CargoPackage, u as CargoPluginOptions } from "../types-CurHqnWl.js";
+export { CargoPackage, CargoPluginOptions, cargo };