tegami 0.1.6 → 0.2.0

package/dist/api-D-jf_8xY.js

@@ -0,0 +1,116 @@
+//#region src/plugins/github/api.ts
+function parseGitHubRepo(repo) {
+	const [owner, name] = repo.split("/", 2);
+	if (!owner || !name) throw new Error(`Invalid GitHub repository: ${repo}`);
+	return {
+		owner,
+		repo: name
+	};
+}
+async function githubRequest(path, token, init = {}) {
+	const headers = new Headers(init.headers);
+	headers.set("Accept", "application/vnd.github+json");
+	headers.set("X-GitHub-Api-Version", "2022-11-28");
+	if (token) headers.set("Authorization", `Bearer ${token}`);
+	return fetch(`https://api.github.com${path}`, {
+		...init,
+		headers
+	});
+}
+async function releaseExistsByTag(repo, tag, token) {
+	const { owner, repo: name } = parseGitHubRepo(repo);
+	const response = await githubRequest(`/repos/${owner}/${name}/releases/tags/${encodeURIComponent(tag)}`, token, { method: "HEAD" });
+	if (response.status === 404) return false;
+	if (!response.ok) throw new Error(`Failed to get GitHub release for ${tag}.`);
+	return true;
+}
+async function createRelease(repo, options) {
+	const { owner, repo: name } = parseGitHubRepo(repo);
+	if (!(await githubRequest(`/repos/${owner}/${name}/releases`, options.token, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({
+			tag_name: options.tag,
+			name: options.title,
+			body: options.notes,
+			prerelease: options.prerelease ?? false
+		})
+	})).ok) throw new Error(`Failed to create GitHub release for ${options.tag}.`);
+}
+async function findOpenPullRequest(repo, headBranch, token) {
+	const { owner, repo: name } = parseGitHubRepo(repo);
+	const response = await githubRequest(`/repos/${owner}/${name}/pulls?${new URLSearchParams({
+		head: `${owner}:${headBranch}`,
+		state: "open"
+	})}`, token);
+	if (!response.ok) throw new Error("Failed to check for an existing version pull request.");
+	return (await response.json())[0]?.number;
+}
+async function updatePullRequest(repo, number, options) {
+	const { owner, repo: name } = parseGitHubRepo(repo);
+	if (!(await githubRequest(`/repos/${owner}/${name}/pulls/${number}`, options.token, {
+		method: "PATCH",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({
+			title: options.title,
+			body: options.body
+		})
+	})).ok) throw new Error("Failed to update the version pull request.");
+}
+async function createPullRequest(repo, options) {
+	const { owner, repo: name } = parseGitHubRepo(repo);
+	if (!(await githubRequest(`/repos/${owner}/${name}/pulls`, options.token, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({
+			title: options.title,
+			body: options.body,
+			head: options.head,
+			base: options.base
+		})
+	})).ok) throw new Error("Failed to create the version pull request.");
+}
+async function getPullRequest(repo, number, token) {
+	const { owner, repo: name } = parseGitHubRepo(repo);
+	const response = await githubRequest(`/repos/${owner}/${name}/pulls/${number}`, token);
+	if (!response.ok) throw new Error(`Failed to resolve pull request #${number}.`);
+	const data = await response.json();
+	return {
+		headRefName: data.head.ref,
+		baseRefOid: data.base.sha,
+		headRefOid: data.head.sha,
+		headRepository: data.head.repo
+	};
+}
+async function findIssueCommentByPrefix(repo, issueNumber, prefix, token) {
+	const { owner, repo: name } = parseGitHubRepo(repo);
+	let page = 1;
+	while (true) {
+		const response = await githubRequest(`/repos/${owner}/${name}/issues/${issueNumber}/comments?per_page=100&page=${page}`, token);
+		if (!response.ok) throw new Error("Failed to list pull 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 updateIssueComment(repo, commentId, body, token) {
+	const { owner, repo: name } = parseGitHubRepo(repo);
+	if (!(await githubRequest(`/repos/${owner}/${name}/issues/comments/${commentId}`, token, {
+		method: "PATCH",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({ body })
+	})).ok) throw new Error("Failed to update pull request comment.");
+}
+async function createIssueComment(repo, issueNumber, body, token) {
+	const { owner, repo: name } = parseGitHubRepo(repo);
+	if (!(await githubRequest(`/repos/${owner}/${name}/issues/${issueNumber}/comments`, token, {
+		method: "POST",
+		headers: { "Content-Type": "application/json" },
+		body: JSON.stringify({ body })
+	})).ok) throw new Error("Failed to create pull request comment.");
+}
+//#endregion
+export { findOpenPullRequest as a, updateIssueComment as c, findIssueCommentByPrefix as i, updatePullRequest as l, createPullRequest as n, getPullRequest as o, createRelease as r, releaseExistsByTag as s, createIssueComment as t };

package/dist/cli/index.d.ts

@@ -1,11 +1,11 @@
-import { k as DraftPlan, t as Awaitable, v as Tegami, w as PublishResult } from "../types-DexeJdl7.js";
+import { O as Draft, S as PublishPlan, g as Tegami, t as Awaitable } from "../types-CurHqnWl.js";
 import { Command } from "commander";
 
 //#region src/cli/index.d.ts
 interface TegamiCLIOptions {
-  /** create a custom draft plan, it must not be applied */
-  version?: () => Awaitable<DraftPlan>;
-  publish?: () => Awaitable<PublishResult>;
+  /** create a custom draft, it must not be applied */
+  version?: () => Awaitable<Draft>;
+  publish?: () => Awaitable<PublishPlan>;
 }
 declare function createCli(tegami: Tegami, options?: TegamiCLIOptions): Command;
 //#endregion

package/dist/cli/index.js

@@ -1,15 +1,14 @@
 import { r as formatNpmDistTag } from "../semver-C4vJ4SK8.js";
-import { r as generateReplays, t as changelogFilename } from "../generate-B3bcuKLY.js";
+import { a as renderChangelog, n as generateFromCommits, r as generateReplays, t as changelogFilename } from "../generate-BMlrn-2e.js";
 import { a as isCI, n as execFailure, r as handlePluginError, t as CancelledError } from "../error-DNy8R5ue.js";
-import { o as renderChangelog, t as assertPublishPlanFinished } from "../checks-azjuIFt7.js";
-import { mkdir, mkdtemp, readFile, rm, writeFile } from "node:fs/promises";
+import { c as updateIssueComment, i as findIssueCommentByPrefix, o as getPullRequest, t as createIssueComment } from "../api-D-jf_8xY.js";
+import { mkdir, readFile, writeFile } from "node:fs/promises";
 import path, { basename, isAbsolute, join, normalize, relative } from "node:path";
 import { x } from "tinyexec";
-import z$1 from "zod";
+import z from "zod";
 import { resolveCommand } from "package-manager-detector";
 import { autocompleteMultiselect, confirm, intro, isCancel, multiline, note, outro, select, spinner } from "@clack/prompts";
 import { Command, InvalidArgumentError } from "commander";
-import { tmpdir } from "node:os";
 //#region src/utils/git-changes.ts
 async function getChangedPackages(graph, cwd) {
 	return resolveChangedPackages(graph, await getChangedFilePaths(cwd), cwd);
@@ -49,7 +48,7 @@ async function addGitOutput(files, cwd, args) {
 //#region src/cli/changelog.ts
 async function runChangelogTui(tegami) {
 	const context = await tegami._internal.context();
-	await assertPublishPlanFinished(context);
+	if (await tegami.publishStatus() === "pending") throw new Error(`Publish lock at ${context.lockPath} is still pending. Publish it before applying a new draft.`);
 	intro("Create changelogs");
 	let selectedPackages = [];
 	if (!isCI()) selectedPackages = await promptPackageSelection(context.graph, context.cwd);
@@ -65,7 +64,7 @@ async function runChangelogTui(tegami) {
 				return;
 			}
 		}
-		await persistChangelogs(context, (await tegami.generateChangelog({ write: false })).map(({ filename, content, packages }) => ({
+		await persistChangelogs(context, (await generateFromCommits(context)).map(({ filename, content, packages }) => ({
 			filename,
 			content,
 			packages
@@ -124,6 +123,7 @@ async function promptPackageSelection(graph, cwd) {
 		return useShortname.get(pkg.name) ? pkg.name : pkg.id;
 	};
 	const changedPackages = new Set(await getChangedPackages(graph, cwd));
+	const initialValues = /* @__PURE__ */ new Set();
 	const selectOptions = [];
 	const groups = [];
 	for (const group of graph.getGroups()) {
@@ -132,23 +132,27 @@ async function promptPackageSelection(graph, cwd) {
 	}
 	groups.sort((a, b) => (a[1] ? 0 : 1) - (b[1] ? 0 : 1));
 	for (const [group, changed] of groups) {
-		const members = group.packages.map(getPackageLabel).join(", ");
+		if (changed) initialValues.add(`group:${group.name}`);
 		selectOptions.push({
-			label: `(Group) ${group.name}`,
+			label: `(Group) ${group.name}` + (changed ? "*" : ""),
 			value: `group:${group.name}`,
-			hint: changed ? `changed · ${members}` : members
+			hint: group.packages.map(getPackageLabel).join(", ")
 		});
 	}
 	const packages = graph.getPackages().toSorted((a, b) => (changedPackages.has(a) ? 0 : 1) - (changedPackages.has(b) ? 0 : 1));
-	for (const pkg of packages) selectOptions.push({
-		label: getPackageLabel(pkg),
-		value: pkg.id,
-		hint: changedPackages.has(pkg) ? "changed" : void 0
-	});
+	for (const pkg of packages) {
+		const changed = changedPackages.has(pkg);
+		if (changed) initialValues.add(pkg.id);
+		selectOptions.push({
+			label: getPackageLabel(pkg) + (changed ? "*" : ""),
+			value: pkg.id
+		});
+	}
 	const selected = await autocompleteMultiselect({
 		message: "Select packages (leave empty to auto-generate from commits)",
 		required: false,
-		options: selectOptions
+		options: selectOptions,
+		initialValues: Array.from(initialValues)
 	});
 	if (isCancel(selected)) throw new CancelledError();
 	return selected;
@@ -223,7 +227,7 @@ async function initAgent(context, options = {}) {
 }
 function renderAgentsMd(context) {
 	const changelogDir = path.relative(context.cwd, context.changelogDir) || "project root";
-	const planPath = path.relative(context.cwd, context.planPath) || "project root";
+	const lockPath = path.relative(context.cwd, context.lockPath) || "project root";
 	return [
 		"# Release workflow",
 		"",
@@ -261,7 +265,7 @@ function renderAgentsMd(context) {
 		"- Include YAML frontmatter with `packages`",
 		"- Include at least one `#`, `##`, or `###` heading in the body",
 		"- Write user-facing release notes under each heading",
-		`- Do not edit \`${planPath}\` or package \`CHANGELOG.md\` files directly`,
+		`- Do not edit the publish lock file (\`${lockPath}\`) or package \`CHANGELOG.md\` files directly`,
 		""
 	].join("\n");
 }
@@ -286,24 +290,20 @@ async function buildPrPreview(context, draft, options = {}) {
 	];
 	const pendingPackages = [];
 	for (const pkg of context.graph.getPackages()) {
-		const plan = draft.getPackagePlan(pkg.id);
+		const plan = draft.getPackageDraft(pkg.id);
 		if (!plan || plan.bumpVersion(pkg) === pkg.version) continue;
 		pendingPackages.push({
 			name: pkg.name,
 			type: plan.type ?? "—",
 			from: pkg.version,
 			to: plan.bumpVersion(pkg),
-			distTag: plan.npm?.distTag,
-			publish: plan.publish ?? false
+			distTag: plan.npm?.distTag
 		});
 	}
 	const prChangelogs = draft.getChangelogs().filter((entry) => prChangelogFiles.has(entry.filename));
 	if (pendingPackages.length > 0) {
 		lines.push("#### Release preview", "", "| Package | Bump | Version |", "| --- | --- | --- |");
-		for (const { name, type, from, to, distTag, publish } of pendingPackages) {
-			const publishNote = publish ? "" : " (no publish)";
-			lines.push(`| \`${name}\` | ${type} | \`${from}\` → \`${to}\`${formatNpmDistTag(distTag)}${publishNote} |`);
-		}
+		for (const { name, type, from, to, distTag } of pendingPackages) lines.push(`| \`${name}\` | ${type} | \`${from}\` → \`${to}\`${formatNpmDistTag(distTag)} |`);
 		lines.push("");
 	}
 	if (prChangelogs.length > 0) {
@@ -330,52 +330,18 @@ async function postPrComment(body) {
 		return;
 	}
 	const markedBody = `${COMMENT_MARKER}\n${body}`;
-	const listResult = await x("gh", [
-		"api",
-		`repos/${repo}/issues/${pr.number}/comments`,
-		"--paginate",
-		"--jq",
-		`[.[] | select(.body | startswith("${COMMENT_MARKER}")) | .id][0] // empty`
-	]);
-	if (listResult.exitCode !== 0) throw execFailure("Failed to list pull request comments.", listResult);
-	const existingId = listResult.stdout.trim();
+	const token = process.env.GITHUB_TOKEN ?? process.env.GH_TOKEN;
+	const existingId = await findIssueCommentByPrefix(repo, pr.number, COMMENT_MARKER, token);
 	if (existingId) {
-		const dir = await mkdtemp(join(tmpdir(), "tegami-pr-comment-"));
-		const inputPath = join(dir, "body.json");
-		try {
-			await writeFile(inputPath, JSON.stringify({ body: markedBody }));
-			const updateResult = await x("gh", [
-				"api",
-				"-X",
-				"PATCH",
-				`repos/${repo}/issues/comments/${existingId}`,
-				"--input",
-				inputPath
-			]);
-			if (updateResult.exitCode !== 0) throw execFailure("Failed to update pull request comment.", updateResult);
-		} finally {
-			await rm(dir, {
-				recursive: true,
-				force: true
-			});
-		}
+		await updateIssueComment(repo, existingId, markedBody, token);
 		return;
 	}
-	const createResult = await x("gh", [
-		"pr",
-		"comment",
-		String(pr.number),
-		"--body",
-		markedBody,
-		"--repo",
-		repo
-	]);
-	if (createResult.exitCode !== 0) throw execFailure("Failed to create pull request comment.", createResult);
+	await createIssueComment(repo, pr.number, markedBody, token);
 }
-const eventSchema = z$1.looseObject({ workflow_run: z$1.looseObject({
-	event: z$1.literal("pull_request", { error: "The preview workflow was not triggered by a pull request." }),
-	conclusion: z$1.literal("success", { error: "The preview workflow did not complete successfully." }),
-	pull_requests: z$1.array(z$1.looseObject({ number: z$1.int() }), { error: "The preview workflow is not associated with a pull request." }).min(1)
+const eventSchema = z.looseObject({ workflow_run: z.looseObject({
+	event: z.literal("pull_request", { error: "The preview workflow was not triggered by a pull request." }),
+	conclusion: z.literal("success", { error: "The preview workflow did not complete successfully." }),
+	pull_requests: z.array(z.looseObject({ number: z.int() }), { error: "The preview workflow is not associated with a pull request." }).min(1)
 }, { error: "A workflow_run event is required." }) });
 async function readPullRequestFromWorkflowRunEvent() {
 	const eventPath = process.env.GITHUB_EVENT_PATH;
@@ -395,7 +361,7 @@ async function readPullRequestFromWorkflowRunEvent() {
 	const { error, data } = eventSchema.safeParse(raw);
 	if (error) return {
 		found: false,
-		reason: z$1.prettifyError(error)
+		reason: z.prettifyError(error)
 	};
 	return {
 		found: true,
@@ -405,9 +371,18 @@ async function readPullRequestFromWorkflowRunEvent() {
 async function resolvePullRequest(context, options) {
 	const repo = context.github?.repo ?? process.env.GITHUB_REPOSITORY;
 	if (!repo) throw new Error("GITHUB_REPOSITORY is required.");
+	const token = context.github?.token ?? process.env.GITHUB_TOKEN ?? process.env.GH_TOKEN;
+	if (!repo) throw new Error("GITHUB_TOKEN is required.");
 	if (options.number !== void 0) {
 		if (!Number.isInteger(options.number) || options.number <= 0) throw new Error("--number must be a positive integer.");
-		return readPullRequestFromGh(repo, options.number);
+		const data = await getPullRequest(repo, options.number, token);
+		return {
+			repo,
+			headRepo: data.headRepository ? `${data.headRepository.owner.login}/${data.headRepository.name}` : repo,
+			headRef: data.headRefName,
+			baseSha: data.baseRefOid,
+			headSha: data.headRefOid
+		};
 	}
 	const event = await readPullRequestEvent();
 	if (event) return {
@@ -416,26 +391,6 @@ async function resolvePullRequest(context, options) {
 	};
 	throw new Error("A pull request event or --number is required.");
 }
-async function readPullRequestFromGh(repo, number) {
-	const result = await x("gh", [
-		"pr",
-		"view",
-		String(number),
-		"--repo",
-		repo,
-		"--json",
-		"headRefName,baseRefOid,headRefOid,headRepository"
-	]);
-	if (result.exitCode !== 0) throw execFailure(`Failed to resolve pull request #${number}.`, result);
-	const data = JSON.parse(result.stdout);
-	return {
-		repo,
-		headRepo: data.headRepository ? `${data.headRepository.owner.login}/${data.headRepository.name}` : repo,
-		headRef: data.headRefName,
-		baseSha: data.baseRefOid,
-		headSha: data.headRefOid
-	};
-}
 async function readPullRequestEvent() {
 	const eventPath = process.env.GITHUB_EVENT_PATH;
 	if (!eventPath) return;
@@ -481,13 +436,17 @@ function createChangelogUrl(context, repo, branch, filename) {
 function createCli(tegami, options = {}) {
 	const program = new Command();
 	program.name("tegami").description("create changelogs").action(() => runAction(tegami, () => runChangelogTui(tegami)));
-	program.command("version").description("draft and apply a publish plan").action(() => runAction(tegami, async () => {
+	program.command("version").description("draft version changes and write the publish lock").action(() => runAction(tegami, async () => {
 		await versionPackages(tegami, { cli: options });
 	}));
 	program.command("ci").description("version and publish packages").action(() => runAction(tegami, async () => {
 		if (await versionPackages(tegami, { cli: options })) return;
 		await publishPackages(tegami, { cli: options });
 	}));
+	program.command("check-publish").description("exit with code 1 if no publishing needed, otherwise 0").action(() => runAction(tegami, async () => {
+		const status = await tegami.publishStatus();
+		process.exit(status === "pending" ? 0 : 1);
+	}));
 	const programPr = program.command("pr");
 	programPr.command("preview").description("(should be executed in a GitHub action) show a pull request release preview and changelog guidance").option("--artifact <path>", "write preview markdown to a file").option("--number <number>", "pull request number", (value) => {
 		const number = Number(value);
@@ -522,13 +481,13 @@ function createCli(tegami, options = {}) {
 			process.exit(1);
 		}
 	});
-	program.command("publish").description("publish packages from the applied publish plan").option("--dry-run", "validate the publish plan without publishing packages").action((commandOptions) => runAction(tegami, async () => {
+	program.command("publish").description("publish packages from the publish lock").option("--dry-run", "validate the publish lock without publishing packages").action((commandOptions) => runAction(tegami, async () => {
 		await publishPackages(tegami, {
 			...commandOptions,
 			cli: options
 		});
 	}));
-	program.command("cleanup").description("remove the publish plan after all packages have been published").action(() => runAction(tegami, () => runCleanup(tegami)));
+	program.command("cleanup").description("remove the publish lock after all packages have been published").action(() => runAction(tegami, () => runCleanup(tegami)));
 	program.command("init-agent").description("write AGENTS.md with changelog instructions for AI agents").option("-o, --output <path>", "output path", "AGENTS.md").action((commandOptions) => runAction(tegami, () => runInitAgent(tegami, commandOptions)));
 	return program;
 }
@@ -537,60 +496,69 @@ async function versionPackages(tegami, options) {
 	const { version: customVersion } = options.cli;
 	const context = await tegami._internal.context();
 	const draft = customVersion ? await customVersion() : await tegami.draft();
-	if (!draft.canApply()) throw new Error(`The draft plan from custom "version" hook must not be applied`);
-	for (const plugin of context.plugins) await handlePluginError(plugin, "cli.publishPlanCreated", () => plugin.cli?.publishPlanCreated?.call(context, draft));
+	if (!draft.canApply()) throw new Error(`The draft from custom "version" hook must not be applied`);
+	for (const plugin of context.plugins) await handlePluginError(plugin, "cli.draftCreated", () => plugin.cli?.draftCreated?.call(context, draft));
 	if (!draft.hasPending()) {
 		note("No pending version changes matched workspace packages.", "Nothing to version");
 		outro("No versions changed.");
 		return false;
 	}
-	const planEntries = [];
+	if (await tegami.publishStatus() === "pending") throw new Error(`Publish lock at ${context.lockPath} is still pending. Publish it before applying a new draft.`);
+	const lines = [];
 	for (const pkg of context.graph.getPackages()) {
-		const plan = draft.getPackagePlan(pkg.id);
+		const plan = draft.getPackageDraft(pkg.id);
 		if (!plan || plan.bumpVersion(pkg) === pkg.version) continue;
-		planEntries.push(`${pkg.id}: ${pkg.version} → ${plan.bumpVersion(pkg)} (${plan.changelogs?.length ?? 0} changelogs)`);
-		if (plan.bumpReasons) for (const reason of plan.bumpReasons) planEntries.push(`  - ${reason}`);
+		lines.push(`${pkg.id}: ${pkg.version} → ${plan.bumpVersion(pkg)} (${plan.changelogs?.length ?? 0} changelogs)`);
+		if (plan.bumpReasons) for (const reason of plan.bumpReasons) lines.push(`  - ${reason}`);
 	}
-	note(planEntries.join("\n"), "Release plan");
+	note(lines.join("\n"), "Release plan");
 	const s = spinner();
 	s.start("Updating package versions");
 	try {
-		await draft.applyPlan();
+		await draft.apply();
 	} catch (error) {
-		s.stop("Failed to apply publish plan");
+		s.stop("Failed to apply draft");
 		throw error;
 	}
 	s.stop("Package versions updated");
-	for (const plugin of context.plugins) await handlePluginError(plugin, "cli.publishPlanApplied", () => plugin.cli?.publishPlanApplied?.call(context, draft));
-	outro("Publish plan applied.");
+	for (const plugin of context.plugins) await handlePluginError(plugin, "cli.draftApplied", () => plugin.cli?.draftApplied?.call(context, draft));
+	outro("Publish lock written.");
 	return true;
 }
 async function publishPackages(tegami, options) {
 	const dryRun = options.dryRun ?? false;
+	const context = await tegami._internal.context();
 	const { publish: customPublish } = options.cli;
 	intro(dryRun ? "Publish packages (dry run)" : "Publish packages");
 	const s = spinner();
-	s.start(dryRun ? "Validating publish plan" : "Publishing packages");
-	const result = customPublish ? await customPublish() : await tegami.publish({ dryRun });
-	if (result.state === "skipped") {
-		const { planPath } = await tegami._internal.context();
-		s.stop(dryRun ? "No publish plan to validate" : "Nothing to publish");
-		outro(`No publishable packages were found in ${planPath}.`);
+	s.start(dryRun ? "Validating publish lock" : "Publishing packages");
+	const plan = customPublish ? await customPublish() : await tegami.publish({ dryRun });
+	if (plan === "skipped") {
+		s.stop(dryRun ? "No publish lock to validate" : "Nothing to publish");
+		outro(`No publishable packages were found in ${context.lockPath}.`);
 		return false;
 	}
-	s.stop(dryRun ? "Publish plan validated" : "Publish complete");
-	note(result.packages.map((pkg) => {
-		const tag = pkg.npm?.distTag ? ` (${pkg.npm.distTag})` : "";
-		const suffix = pkg.state === "failed" && pkg.error ? `: ${pkg.error}` : "";
-		return `${pkg.state === "success" ? "success" : "failed"} ${pkg.name}@${pkg.version}${tag}${suffix}`;
-	}).join("\n"), dryRun ? "Publish dry run" : "Publish result");
-	if (result.state === "failed") {
+	s.stop(dryRun ? "Publish lock validated" : "Publish complete");
+	const lines = [];
+	let hasFailed = false;
+	for (const [id, packagePlan] of plan.packages) {
+		if (!packagePlan.updated) continue;
+		const result = packagePlan.publishResult;
+		const pkg = context.graph.get(id);
+		if (result.type === "failed") hasFailed = true;
+		let message = `${result.type} ${pkg.id} - ${pkg.version}`;
+		const distTag = packagePlan.npm?.distTag;
+		if (distTag) message += ` (npm dist-tag: ${distTag})`;
+		if (result.type === "failed" && result.error) message += `: ${result.error}`;
+		lines.push(message);
+	}
+	note(lines.join("\n"), dryRun ? "Publish dry run" : "Publish result");
+	if (hasFailed) {
 		process.exitCode = 1;
-		if (result.error) note(result.error, "Error when publishing");
 		outro("Failed to publish.");
 		return false;
 	}
-	outro(dryRun ? "Publish plan is valid." : "Packages published.");
+	outro(dryRun ? "Publish lock is valid." : "Packages published.");
 	return true;
 }
 async function runInitAgent(tegami, options) {
@@ -604,21 +572,21 @@ async function runInitAgent(tegami, options) {
 	outro("Agents can follow AGENTS.md to write changelogs.");
 }
 async function runCleanup(tegami) {
-	intro("Cleanup publish plan");
+	intro("Cleanup publish lock");
 	const s = spinner();
-	s.start("Checking publish plan status");
+	s.start("Checking publish lock status");
 	const result = await tegami.cleanup();
-	const { planPath } = await tegami._internal.context();
-	s.stop(result.state === "removed" ? "Publish plan removed" : "Publish plan kept");
+	const { lockPath } = await tegami._internal.context();
+	s.stop(result.state === "removed" ? "Publish lock removed" : "Publish lock kept");
 	if (result.state === "removed") {
-		outro(`Removed ${planPath}.`);
+		outro(`Removed ${lockPath}.`);
 		return;
 	}
-	if (result.reason === "missing") {
-		outro(`No publish plan found at ${planPath}.`);
+	if (result.reason === "no-plan") {
+		outro(`No publish lock found at ${lockPath}.`);
 		return;
 	}
-	outro(`Publish plan at ${planPath} is still pending. Publish it before cleanup.`);
+	outro(`Publish lock at ${lockPath} is still pending. Publish it before cleanup.`);
 }
 async function runAction(tegami, action) {
 	try {

package/dist/{generate-B3bcuKLY.js → generate-BMlrn-2e.js}

@@ -1,10 +1,10 @@
 import { a as maxBump, t as bumpDepth } from "./semver-C4vJ4SK8.js";
 import { n as execFailure } from "./error-DNy8R5ue.js";
-import { o as renderChangelog } from "./checks-azjuIFt7.js";
-import { mkdir, writeFile } from "node:fs/promises";
-import { join } from "node:path";
+import { t as bumpTypeSchema } from "./schemas-B7N6EE2k.js";
 import { x } from "tinyexec";
 import * as semver from "semver";
+import z from "zod";
+import { dump } from "js-yaml";
 //#region src/utils/conventional-commit.ts
 /**
 * Conventional commit header per conventionalcommits.org and semantic-release defaults.
@@ -70,10 +70,33 @@ function conventionalCommitToBump(type, breaking) {
 	}
 }
 //#endregion
+//#region src/changelog/shared.ts
+const changelogPackageConfigSchema = z.object({
+	type: bumpTypeSchema.optional(),
+	replay: z.array(z.string().min(1)).optional()
+});
+const changelogFrontmatterSchema = z.object({
+	subject: z.string().optional(),
+	packages: z.union([z.array(z.string()), z.record(z.string(), z.union([
+		bumpTypeSchema,
+		z.null(),
+		changelogPackageConfigSchema
+	]))]).optional()
+});
+function renderChangelog(frontmatter, body) {
+	return [
+		"---",
+		dump(frontmatter).trim(),
+		"---",
+		"",
+		body.trim(),
+		""
+	].join("\n");
+}
+//#endregion
 //#region src/changelog/generate.ts
-async function generateChangelog(context, options = {}) {
-	const write = options.write ?? true;
-	const commits = await readConventionalCommits(context, options);
+async function generateFromCommits(context, { from, to } = {}) {
+	const commits = await readConventionalCommits(context, from, to);
 	const groups = /* @__PURE__ */ new Map();
 	for (const commit of commits) {
 		const key = commit.packages.join("\0");
@@ -81,7 +104,7 @@ async function generateChangelog(context, options = {}) {
 		if (group) group.push(commit);
 		else groups.set(key, [commit]);
 	}
-	const changelogs = Array.from(groups, ([key, changes], index) => {
+	return Array.from(groups, ([key, changes], index) => {
 		const packageNames = key ? key.split("\0") : [];
 		let bumpType = "patch";
 		for (const change of changes) bumpType = maxBump(change.type, bumpType);
@@ -99,15 +122,10 @@ async function generateChangelog(context, options = {}) {
 			changes
 		};
 	});
-	if (write && changelogs.length > 0) {
-		await mkdir(context.changelogDir, { recursive: true });
-		await Promise.all(changelogs.map((entry) => writeFile(join(context.changelogDir, entry.filename), entry.content)));
-	}
-	return changelogs;
 }
-async function readConventionalCommits(context, options) {
-	const to = options.to ?? "HEAD";
-	const from = options.from ?? await latestTag(context.cwd);
+async function readConventionalCommits(context, from, to) {
+	from ??= await latestTag(context.cwd);
+	to ??= "HEAD";
 	const args = [
 		"log",
 		"--no-merges",
@@ -151,8 +169,8 @@ function generateReplays(graph, base) {
 	for (const [ref, type] of Object.entries(base)) {
 		const resolved = graph.getByName(ref);
 		for (const pkg of resolved) {
-			const plan = pkg.initPlan();
-			pkg.configurePlan(plan, graph.getPackageGroup(pkg.id));
+			const plan = pkg.initDraft();
+			pkg.configureDraft(plan, graph.getPackageGroup(pkg.id));
 			const prerelease = semver.prerelease(pkg.version)?.[0];
 			const targetPrerelease = plan.prerelease;
 			if (targetPrerelease && !prerelease || targetPrerelease && prerelease && targetPrerelease === prerelease) packages[pkg.id] = {
@@ -168,4 +186,4 @@ function changelogFilename(disambiguator = 0) {
 	return `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, "0")}-${String(date.getDate()).padStart(2, "0")}-${(Date.now() + disambiguator).toString(36)}.md`;
 }
 //#endregion
-export { generateChangelog as n, generateReplays as r, changelogFilename as t };
+export { renderChangelog as a, changelogFrontmatterSchema as i, generateFromCommits as n, generateReplays as r, changelogFilename as t };

package/dist/generators/simple.d.ts

@@ -1,4 +1,4 @@
-import { r as LogGenerator } from "../types-DexeJdl7.js";
+import { r as LogGenerator } from "../types-CurHqnWl.js";
 
 //#region src/generators/simple.d.ts
 declare function simpleGenerator(): LogGenerator;

package/dist/generators/simple.js

@@ -1,9 +1,9 @@
 import { i as formatPackageVersion } from "../semver-C4vJ4SK8.js";
 //#region src/generators/simple.ts
 function simpleGenerator() {
-	return { generate({ changelogs, version, packageName, plan }) {
-		const lines = [`## ${formatPackageVersion(packageName, version, plan.npm?.distTag)}`, ""];
-		for (const entry of changelogs) {
+	return { generate({ pkg, packageDraft }) {
+		const lines = [`## ${formatPackageVersion(pkg.name, pkg.version, packageDraft.npm?.distTag)}`, ""];
+		for (const entry of packageDraft.changelogs ?? []) {
 			let sectionDepth = 4;
 			if (entry.subject) lines.push(`### ${entry.subject}`, "");
 			else sectionDepth--;