tegami 0.1.4 → 0.1.6

package/dist/checks-azjuIFt7.js

@@ -0,0 +1,109 @@
+import { r as handlePluginError } from "./error-DNy8R5ue.js";
+import { n as jsonCodec, t as bumpTypeSchema } from "./schemas-CurBAaW5.js";
+import z$1 from "zod";
+import { dump } from "js-yaml";
+import { readFile } from "fs/promises";
+//#region src/changelog/shared.ts
+const changelogPackageConfigSchema = z$1.object({
+	type: bumpTypeSchema.optional(),
+	replay: z$1.array(z$1.string().min(1)).optional()
+});
+const changelogFrontmatterSchema = z$1.object({
+	subject: z$1.string().optional(),
+	packages: z$1.union([z$1.array(z$1.string()), z$1.record(z$1.string(), z$1.union([
+		bumpTypeSchema,
+		z$1.null(),
+		changelogPackageConfigSchema
+	]))]).optional()
+});
+function renderChangelog(frontmatter, body) {
+	return [
+		"---",
+		dump(frontmatter).trim(),
+		"---",
+		"",
+		body.trim(),
+		""
+	].join("\n");
+}
+//#endregion
+//#region src/plans/store.ts
+const packagePlanStoreSchema = z$1.object({
+	type: bumpTypeSchema.optional(),
+	changelogIds: z$1.array(z$1.string()).optional(),
+	bumpReasons: z$1.array(z$1.string()).optional(),
+	npm: z$1.object({ distTag: z$1.string().optional() }).optional(),
+	publish: z$1.boolean()
+});
+/** the persisted plan data for actual publishing */
+const planStoreSchema = jsonCodec(z$1.object({
+	id: z$1.string(),
+	createdAt: z$1.iso.datetime(),
+	version: z$1.literal("0.0.0").default("0.0.0"),
+	/** release note entries */
+	changelogs: z$1.record(z$1.string(), z$1.object({
+		filename: z$1.string(),
+		content: z$1.string()
+	})),
+	/** package id -> package info */
+	packages: z$1.record(z$1.string(), packagePlanStoreSchema)
+}));
+function createPlanStore(draft, context) {
+	const store = {
+		version: "0.0.0",
+		id: `tegami-${Date.now().toString(36)}`,
+		createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+		changelogs: {},
+		packages: {}
+	};
+	for (const entry of draft.getChangelogs()) store.changelogs[entry.id] = {
+		filename: entry.filename,
+		content: entry.getRawContent()
+	};
+	for (const pkg of context.graph.getPackages()) {
+		const plan = draft.getPackagePlan(pkg.id);
+		if (plan) store.packages[pkg.id] = {
+			publish: plan.publish ?? false,
+			type: plan.type,
+			npm: plan.npm,
+			changelogIds: plan.changelogs?.map((entry) => entry.id),
+			bumpReasons: plan.bumpReasons ? Array.from(plan.bumpReasons) : void 0
+		};
+	}
+	return planStoreSchema.encode(store);
+}
+async function readPlanStore(context) {
+	try {
+		return planStoreSchema.decode(await readFile(context.planPath, "utf8"));
+	} catch {}
+}
+//#endregion
+//#region src/plans/checks.ts
+async function publishPlanStatus(store, context) {
+	async function defaultStatus() {
+		try {
+			await Promise.all(Object.entries(store.packages).map(async ([id, plan]) => {
+				const pkg = context.graph.get(id);
+				if (!pkg || !plan.publish) return;
+				if (!await context.getRegistryClient(pkg).isPackagePublished(pkg)) throw "pending";
+			}));
+			return { state: "success" };
+		} catch (err) {
+			if (err === "pending") return { state: "pending" };
+			throw err;
+		}
+	}
+	let status = await defaultStatus();
+	for (const plugin of context.plugins) {
+		const resolved = await handlePluginError(plugin, "resolvePlanStatus", () => plugin.resolvePlanStatus?.call(context, status, { plan: store }));
+		if (resolved) status = resolved;
+	}
+	return status;
+}
+async function assertPublishPlanFinished(context) {
+	const store = await readPlanStore(context);
+	if (!store) return;
+	if ((await publishPlanStatus(store, context)).state === "pending") throw new Error(`Publish plan already exists at ${context.planPath} and is pending. Publish it before applying a new plan.`);
+}
+//#endregion
+export { changelogFrontmatterSchema as a, readPlanStore as i, publishPlanStatus as n, renderChangelog as o, createPlanStore as r, assertPublishPlanFinished as t };

package/dist/cli/index.d.ts

@@ -1,4 +1,4 @@
-import { k as DraftPlan, t as Awaitable, v as Tegami, w as PublishResult } from "../types-BXk2fMqa.js";
+import { k as DraftPlan, t as Awaitable, v as Tegami, w as PublishResult } from "../types-DexeJdl7.js";
 import { Command } from "commander";
 
 //#region src/cli/index.d.ts

package/dist/cli/index.js

@@ -1,9 +1,11 @@
 import { r as formatNpmDistTag } from "../semver-C4vJ4SK8.js";
-import { a as changelogFilename, l as renderChangelog, s as generateReplays, t as assertPublishPlanFinished } from "../checks-Cwz-Ezkq.js";
+import { r as generateReplays, t as changelogFilename } from "../generate-B3bcuKLY.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 path, { basename, isAbsolute, join, normalize, relative } from "node:path";
 import { x } from "tinyexec";
+import z$1 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";
@@ -318,12 +320,19 @@ async function buildPrPreview(context, draft, options = {}) {
 }
 async function postPrComment(body) {
 	const repo = process.env.GITHUB_REPOSITORY;
-	if (!repo) throw new Error("GITHUB_REPOSITORY is required.");
-	const number = await readPullRequestNumberFromWorkflowRunEvent();
+	if (!repo) {
+		outro("GITHUB_REPOSITORY is required.");
+		return;
+	}
+	const pr = await readPullRequestFromWorkflowRunEvent();
+	if (!pr.found) {
+		outro(pr.reason);
+		return;
+	}
 	const markedBody = `${COMMENT_MARKER}\n${body}`;
 	const listResult = await x("gh", [
 		"api",
-		`repos/${repo}/issues/${number}/comments`,
+		`repos/${repo}/issues/${pr.number}/comments`,
 		"--paginate",
 		"--jq",
 		`[.[] | select(.body | startswith("${COMMENT_MARKER}")) | .id][0] // empty`
@@ -355,7 +364,7 @@ async function postPrComment(body) {
 	const createResult = await x("gh", [
 		"pr",
 		"comment",
-		String(number),
+		String(pr.number),
 		"--body",
 		markedBody,
 		"--repo",
@@ -363,22 +372,35 @@ async function postPrComment(body) {
 	]);
 	if (createResult.exitCode !== 0) throw execFailure("Failed to create pull request comment.", createResult);
 }
-async function readPullRequestNumberFromWorkflowRunEvent() {
+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)
+}, { error: "A workflow_run event is required." }) });
+async function readPullRequestFromWorkflowRunEvent() {
 	const eventPath = process.env.GITHUB_EVENT_PATH;
-	if (!eventPath) throw new Error("GITHUB_EVENT_PATH is required.");
-	let event;
+	if (!eventPath) return {
+		found: false,
+		reason: "GITHUB_EVENT_PATH is required."
+	};
+	let raw;
 	try {
-		event = JSON.parse(await readFile(eventPath, "utf8"));
+		raw = JSON.parse(await readFile(eventPath, "utf8"));
 	} catch {
-		throw new Error("Failed to read workflow_run event.");
+		return {
+			found: false,
+			reason: "Failed to read workflow_run event."
+		};
 	}
-	const workflowRun = event.workflow_run;
-	if (!workflowRun) throw new Error("A workflow_run event is required.");
-	if (workflowRun.event !== "pull_request") throw new Error("The preview workflow was not triggered by a pull request.");
-	if (workflowRun.conclusion !== "success") throw new Error("The preview workflow did not complete successfully.");
-	const number = workflowRun.pull_requests?.[0]?.number;
-	if (!Number.isInteger(number) || !number || number <= 0) throw new Error("The preview workflow is not associated with a pull request.");
-	return number;
+	const { error, data } = eventSchema.safeParse(raw);
+	if (error) return {
+		found: false,
+		reason: z$1.prettifyError(error)
+	};
+	return {
+		found: true,
+		number: data.workflow_run.pull_requests[0].number
+	};
 }
 async function resolvePullRequest(context, options) {
 	const repo = context.github?.repo ?? process.env.GITHUB_REPOSITORY;
@@ -564,7 +586,8 @@ async function publishPackages(tegami, options) {
 	}).join("\n"), dryRun ? "Publish dry run" : "Publish result");
 	if (result.state === "failed") {
 		process.exitCode = 1;
-		outro("Some packages failed to publish.");
+		if (result.error) note(result.error, "Error when publishing");
+		outro("Failed to publish.");
 		return false;
 	}
 	outro(dryRun ? "Publish plan is valid." : "Packages published.");

package/dist/{checks-Cwz-Ezkq.js → generate-B3bcuKLY.js}

@@ -1,13 +1,10 @@
 import { a as maxBump, t as bumpDepth } from "./semver-C4vJ4SK8.js";
-import { n as execFailure, r as handlePluginError } from "./error-DNy8R5ue.js";
-import { n as jsonCodec, t as bumpTypeSchema } from "./schemas-CurBAaW5.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 { x } from "tinyexec";
 import * as semver from "semver";
-import z$1 from "zod";
-import { dump } from "js-yaml";
-import { readFile as readFile$1 } from "fs/promises";
 //#region src/utils/conventional-commit.ts
 /**
 * Conventional commit header per conventionalcommits.org and semantic-release defaults.
@@ -73,30 +70,6 @@ function conventionalCommitToBump(type, breaking) {
 	}
 }
 //#endregion
-//#region src/changelog/shared.ts
-const changelogPackageConfigSchema = z$1.object({
-	type: bumpTypeSchema.optional(),
-	replay: z$1.array(z$1.string().min(1)).optional()
-});
-const changelogFrontmatterSchema = z$1.object({
-	subject: z$1.string().optional(),
-	packages: z$1.union([z$1.array(z$1.string()), z$1.record(z$1.string(), z$1.union([
-		bumpTypeSchema,
-		z$1.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;
@@ -195,83 +168,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
-//#region src/plans/store.ts
-const packagePlanStoreSchema = z$1.object({
-	type: bumpTypeSchema.optional(),
-	changelogIds: z$1.array(z$1.string()).optional(),
-	bumpReasons: z$1.array(z$1.string()).optional(),
-	npm: z$1.object({ distTag: z$1.string().optional() }).optional(),
-	publish: z$1.boolean()
-});
-/** the persisted plan data for actual publishing */
-const planStoreSchema = jsonCodec(z$1.object({
-	id: z$1.string(),
-	createdAt: z$1.iso.datetime(),
-	version: z$1.literal("0.0.0").default("0.0.0"),
-	/** release note entries */
-	changelogs: z$1.record(z$1.string(), z$1.object({
-		filename: z$1.string(),
-		content: z$1.string()
-	})),
-	/** package id -> package info */
-	packages: z$1.record(z$1.string(), packagePlanStoreSchema)
-}));
-function createPlanStore(draft, context) {
-	const store = {
-		version: "0.0.0",
-		id: `tegami-${Date.now().toString(36)}`,
-		createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-		changelogs: {},
-		packages: {}
-	};
-	for (const entry of draft.getChangelogs()) store.changelogs[entry.id] = {
-		filename: entry.filename,
-		content: entry.getRawContent()
-	};
-	for (const pkg of context.graph.getPackages()) {
-		const plan = draft.getPackagePlan(pkg.id);
-		if (plan) store.packages[pkg.id] = {
-			publish: plan.publish ?? false,
-			type: plan.type,
-			npm: plan.npm,
-			changelogIds: plan.changelogs?.map((entry) => entry.id),
-			bumpReasons: plan.bumpReasons ? Array.from(plan.bumpReasons) : void 0
-		};
-	}
-	return planStoreSchema.encode(store);
-}
-async function readPlanStore(context) {
-	try {
-		return planStoreSchema.decode(await readFile$1(context.planPath, "utf8"));
-	} catch {}
-}
-//#endregion
-//#region src/plans/checks.ts
-async function publishPlanStatus(store, context) {
-	async function defaultStatus() {
-		try {
-			await Promise.all(Object.entries(store.packages).map(async ([id, plan]) => {
-				const pkg = context.graph.get(id);
-				if (!pkg || !plan.publish) return;
-				if (!await context.getRegistryClient(pkg).isPackagePublished(pkg)) throw "pending";
-			}));
-			return { state: "success" };
-		} catch (err) {
-			if (err === "pending") return { state: "pending" };
-			throw err;
-		}
-	}
-	let status = await defaultStatus();
-	for (const plugin of context.plugins) {
-		const resolved = await handlePluginError(plugin, "resolvePlanStatus", () => plugin.resolvePlanStatus?.call(context, status, { plan: store }));
-		if (resolved) status = resolved;
-	}
-	return status;
-}
-async function assertPublishPlanFinished(context) {
-	const store = await readPlanStore(context);
-	if (!store) return;
-	if ((await publishPlanStatus(store, context)).state === "pending") throw new Error(`Publish plan already exists at ${context.planPath} and is pending. Publish it before applying a new plan.`);
-}
-//#endregion
-export { changelogFilename as a, changelogFrontmatterSchema as c, readPlanStore as i, renderChangelog as l, publishPlanStatus as n, generateChangelog as o, createPlanStore as r, generateReplays as s, assertPublishPlanFinished as t };
+export { generateChangelog as n, generateReplays as r, changelogFilename as t };

package/dist/generators/simple.d.ts

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

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-import { A as PackagePlan, C as PublishOptions, D as PackageGroup, E as PackageGraph, O as WorkspacePackage, S as PackagePublishResult, a as PublishPreflight, b as GenerateChangelogOptions, c as TegamiPlugin, i as PackageOptions, k as DraftPlan, l as TegamiPluginOption, n as GroupOptions, o as RegistryClient, r as LogGenerator, s as TegamiOptions, v as Tegami, w as PublishResult, x as GeneratedChangelog, y as tegami } from "./types-BXk2fMqa.js";
+import { A as PackagePlan, C as PublishOptions, D as PackageGroup, E as PackageGraph, O as WorkspacePackage, S as PackagePublishResult, a as PublishPreflight, b as GenerateChangelogOptions, c as TegamiPlugin, i as PackageOptions, k as DraftPlan, l as TegamiPluginOption, n as GroupOptions, o as RegistryClient, r as LogGenerator, s as TegamiOptions, v as Tegami, w as PublishResult, x as GeneratedChangelog, y as tegami } from "./types-DexeJdl7.js";
 export { type DraftPlan, type GenerateChangelogOptions, type GeneratedChangelog, type GroupOptions, type LogGenerator, type PackageGraph, type PackageGroup, type PackageOptions, type PackagePlan, type PackagePublishResult, type PublishOptions, type PublishPreflight, type PublishResult, type RegistryClient, Tegami, type TegamiOptions, type TegamiPlugin, type TegamiPluginOption, type WorkspacePackage, tegami };

package/dist/index.js

@@ -1,16 +1,15 @@
 import { a as maxBump } from "./semver-C4vJ4SK8.js";
-import { c as changelogFrontmatterSchema, i as readPlanStore, n as publishPlanStatus, o as generateChangelog, r as createPlanStore, t as assertPublishPlanFinished } from "./checks-Cwz-Ezkq.js";
+import { n as generateChangelog } from "./generate-B3bcuKLY.js";
 import { r as handlePluginError } from "./error-DNy8R5ue.js";
+import { i as readPlanStore, n as publishPlanStatus, r as createPlanStore, t as assertPublishPlanFinished } from "./checks-azjuIFt7.js";
 import { t as PackageGraph } from "./graph-DLKPUXSD.js";
 import { cargo } from "./providers/cargo.js";
 import { npm } from "./providers/npm.js";
 import { simpleGenerator } from "./generators/simple.js";
-import { mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
-import path, { basename, dirname, join } from "node:path";
+import { a as readChangelogEntries, i as parseReplayCondition, r as publishFromPlan } from "./publish-DkRT0yh6.js";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import path, { dirname, join } from "node:path";
 import * as semver from "semver";
-import { dump, load } from "js-yaml";
-import { fromMarkdown } from "mdast-util-from-markdown";
-import { toMarkdown } from "mdast-util-to-markdown";
 //#region src/context.ts
 async function createTegamiContext(options = {}) {
 	const cwd = options.cwd ? path.resolve(options.cwd) : process.cwd();
@@ -75,141 +74,6 @@ function resolvePlugins(plugins = []) {
 	return plugins.flat(Infinity).sort((a, b) => PLUGIN_ORDER[a.enforce ?? "default"] - PLUGIN_ORDER[b.enforce ?? "default"]);
 }
 //#endregion
-//#region src/utils/frontmatter.ts
-/**
-* Inspired by https://github.com/jonschlinkert/gray-matter
-*/
-const regex = /^---\r?\n(.+?)\r?\n---\r?\n?/s;
-/**
-* parse frontmatter, it supports only yaml format
-*/
-function frontmatter(input) {
-	const output = {
-		matter: "",
-		data: {},
-		content: input
-	};
-	const match = regex.exec(input);
-	if (!match) return output;
-	output.matter = match[0];
-	output.content = input.slice(match[0].length);
-	output.data = load(match[1]) ?? {};
-	return output;
-}
-//#endregion
-//#region src/changelog/parse.ts
-async function getChangelogFiles(context) {
-	return (await readdir(context.changelogDir).catch(() => [])).filter((file) => file.endsWith(".md"));
-}
-async function readChangelogEntries(context) {
-	const dir = context.changelogDir;
-	const files = await getChangelogFiles(context);
-	return (await Promise.all(files.map(async (file) => {
-		const filePath = join(dir, file);
-		const content = await readFile(filePath, "utf8");
-		return parseChangelogFile(basename(filePath), content);
-	}))).filter((v) => v !== void 0);
-}
-/** Parse one changelog markdown file into release entries. */
-function parseChangelogFile(filename, content) {
-	const parsed = frontmatter(content);
-	const { success, data } = changelogFrontmatterSchema.safeParse(parsed.data);
-	if (!success || !data.packages) return;
-	const tree = fromMarkdown(parsed.content);
-	let headingBump;
-	const packages = /* @__PURE__ */ new Map();
-	const sections = [];
-	for (const section of getHeadingSections(tree)) {
-		const sectionBumpType = headingToBump(section.heading.depth);
-		if (sectionBumpType) headingBump = headingBump ? maxBump(headingBump, sectionBumpType) : sectionBumpType;
-		sections.push({
-			depth: section.heading.depth,
-			title: sectionToMarkdown(section.heading.children),
-			content: sectionToMarkdown(section.children)
-		});
-	}
-	if (sections.length === 0) return;
-	if (Array.isArray(data.packages)) {
-		if (!headingBump) return;
-		for (const pkg of data.packages) packages.set(pkg, { type: headingBump });
-	} else for (const [k, v] of Object.entries(data.packages)) {
-		let config;
-		if (typeof v === "string") config = { type: v };
-		else if (v === null) config = { type: headingBump };
-		else config = v;
-		if (config.type || config.replay?.length) packages.set(k, config);
-	}
-	if (packages.size === 0) return;
-	const entry = {
-		id: filename,
-		filename,
-		subject: data.subject,
-		packages,
-		sections,
-		_raw_body: parsed.content,
-		getRawContent() {
-			return [
-				"---",
-				dump({
-					subject: this.subject,
-					packages: Object.fromEntries(this.packages.entries())
-				}).trim(),
-				"---",
-				"",
-				entry._raw_body.trim(),
-				""
-			].join("\n");
-		}
-	};
-	return entry;
-}
-function parseReplayCondition(condition) {
-	if (condition.startsWith("exit prerelease:")) return {
-		type: "on-exit-prerelease",
-		name: condition.slice(16).trimStart()
-	};
-	const idx = condition.lastIndexOf("@");
-	if (idx <= 0) return null;
-	return {
-		type: "on-version",
-		name: condition.slice(0, idx),
-		version: condition.slice(idx + 1)
-	};
-}
-function getHeadingSections(tree) {
-	const sections = [];
-	let current;
-	for (const child of tree.children) {
-		if (child.type === "heading") {
-			current = {
-				heading: child,
-				children: []
-			};
-			sections.push(current);
-			continue;
-		}
-		current?.children.push(child);
-	}
-	return sections;
-}
-function sectionToMarkdown(children) {
-	if (children.length === 0) return "";
-	return toMarkdown({
-		type: "root",
-		children
-	}, {
-		bullet: "-",
-		fence: "`"
-	}).trim();
-}
-function headingToBump(depth) {
-	switch (depth) {
-		case 1: return "major";
-		case 2: return "minor";
-		case 3: return "patch";
-	}
-}
-//#endregion
 //#region src/plans/policy.ts
 function groupPolicy({ graph }) {
 	return {
@@ -427,136 +291,6 @@ function attachChangelog(plan, entry) {
 	plan.changelogs.push(entry);
 }
 //#endregion
-//#region src/publish.ts
-async function resolvePublishTargets(context, store) {
-	const targets = [];
-	const preflightPromises = [];
-	for (const [id, plan] of Object.entries(store.packages)) {
-		if (!plan.publish) continue;
-		const pkg = context.graph.get(id);
-		if (!pkg) continue;
-		targets.push(pkg.id);
-		preflightPromises.push(context.getRegistryClient(pkg).publishPreflight?.(pkg, {
-			store,
-			packageStore: plan
-		}));
-	}
-	const preflights = await Promise.all(preflightPromises);
-	const children = /* @__PURE__ */ new Map();
-	for (let i = 0; i < targets.length; i++) {
-		const id = targets[i];
-		children.set(id, preflights[i]?.wait);
-	}
-	const ordered = [];
-	function scan(id, stack = /* @__PURE__ */ new Set()) {
-		if (stack.has(id)) throw new Error(`circular reference of deps: ${[...stack, id].join(" -> ")}`);
-		if (ordered.includes(id)) return;
-		const deps = children.get(id);
-		if (deps) {
-			stack.add(id);
-			for (const dep of deps) scan(dep, stack);
-			stack.delete(id);
-		}
-		ordered.push(id);
-	}
-	for (const id of targets) scan(id);
-	return ordered;
-}
-async function publishFromPlan(context, store, options) {
-	const { dryRun = false } = options;
-	const packages = [];
-	if ((await publishPlanStatus(store, context)).state !== "pending") return { state: "skipped" };
-	const orderedIds = await resolvePublishTargets(context, store);
-	const parsedChangelogs = /* @__PURE__ */ new Map();
-	for (const [id, entry] of Object.entries(store.changelogs)) {
-		const parsed = parseChangelogFile(entry.filename, entry.content);
-		if (!parsed) continue;
-		parsedChangelogs.set(id, parsed);
-	}
-	for (const id of orderedIds) {
-		const plan = store.packages[id];
-		const pkg = context.graph.get(id);
-		const registryClient = context.getRegistryClient(pkg);
-		const changelogs = [];
-		for (const id of plan.changelogIds ?? []) {
-			const entry = parsedChangelogs.get(id);
-			if (entry) changelogs.push(entry);
-		}
-		if (!dryRun) {
-			if (await registryClient.isPackagePublished(pkg)) {
-				packages.push({
-					id: pkg.id,
-					name: pkg.name,
-					version: pkg.version,
-					npm: plan.npm,
-					state: "success",
-					changelogs
-				});
-				continue;
-			}
-		} else {
-			packages.push({
-				id: pkg.id,
-				name: pkg.name,
-				version: pkg.version,
-				npm: plan.npm,
-				state: "success",
-				changelogs
-			});
-			continue;
-		}
-		try {
-			let result;
-			for (const plugin of context.plugins) {
-				const next = await handlePluginError(plugin, "willPublish", () => plugin.willPublish?.call(context, { pkg }));
-				if (next !== void 0) {
-					result = next;
-					break;
-				}
-			}
-			if (result === void 0) {
-				await registryClient.publish(pkg, {
-					packageStore: plan,
-					store
-				});
-				result = {
-					id: pkg.id,
-					name: pkg.name,
-					version: pkg.version,
-					npm: plan.npm,
-					state: "success",
-					changelogs
-				};
-			}
-			if (result === false) continue;
-			for (const plugin of context.plugins) {
-				const next = await handlePluginError(plugin, "afterPublish", () => plugin.afterPublish?.call(context, {
-					pkg,
-					result
-				}));
-				if (next) result = next;
-			}
-			packages.push(result);
-		} catch (error) {
-			packages.push({
-				id: pkg.id,
-				name: pkg.name,
-				version: pkg.version,
-				npm: plan.npm,
-				changelogs,
-				state: "failed",
-				error: error instanceof Error ? error.message : String(error)
-			});
-		}
-	}
-	if (packages.length === 0) return { state: "skipped" };
-	return {
-		state: packages.some((pkg) => pkg.state === "failed") ? "failed" : "created",
-		packages,
-		_rawPlan: store
-	};
-}
-//#endregion
 //#region src/index.ts
 /** Create a Tegami project handle. */
 function tegami(options = {}) {

package/dist/plugins/git.d.ts

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

package/dist/plugins/git.js

@@ -1,4 +1,5 @@
 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
 /**
@@ -37,37 +38,44 @@ function git(options = {}) {
 		} },
 		async afterPublishAll(result) {
 			const { cwd, publishOptions: { dryRun = false } } = this;
-			if (dryRun || !createTags || result.state === "skipped") return result;
-			const pendingTags = /* @__PURE__ */ new Set();
+			if (dryRun || !createTags || result.state === "skipped") return;
+			const createdTags = [];
+			const pendingTags = /* @__PURE__ */ new Map();
 			for (const pkg of result.packages) {
-				if (pkg.state !== "success") continue;
-				pkg.gitTag = resolveGitTag(this, pkg);
-				pendingTags.add(pkg.gitTag);
+				const tag = resolveGitTag(this, pkg);
+				pkg.git = {
+					tag,
+					tagState: "skipped"
+				};
+				if (pkg.state === "success") pendingTags.set(tag, null);
 			}
-			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);
-				}));
-				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);
+			await Promise.all(Array.from(pendingTags.keys(), 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;
 				}
-			} catch (error) {
-				return {
-					...result,
-					state: "failed",
-					error: error instanceof Error ? error.message : String(error)
-				};
+				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);
 			}
-			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 { S as PackagePublishResult, T as TegamiContext, c as TegamiPlugin, k as DraftPlan, t as Awaitable } from "../types-DexeJdl7.js";
 import { GitPluginOptions } from "./git.js";
 
 //#region src/plugins/github.d.ts

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 { n as publishError } from "../publish-DkRT0yh6.js";
 import { git } from "./git.js";
 import { join, relative } from "node:path";
 import { x } from "tinyexec";
@@ -8,34 +9,25 @@ import { prerelease } from "semver";
 /** 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;
+		if (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);
+		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) {
-		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);
+		return {
+			title: release.title ?? defaultGroupedTitle(packages),
+			notes: release.notes ?? await defaultGroupedNotes(context, packages),
+			prerelease: release.prerelease ?? packages.some((pkg) => prerelease(pkg.version) !== null)
+		};
 	}
 	function resolvePROptions() {
 		const setting = cliOptions.versionPr ?? isCI();
@@ -168,10 +160,33 @@ function github(options = {}) {
 			}
 		},
 		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]);
+			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);
+			}));
 		}
 	}];
 }
@@ -197,10 +212,10 @@ async function findOpenPullRequest(branch, repo) {
 function groupPackagesByGitTag(packages) {
 	const groups = /* @__PURE__ */ new Map();
 	for (const pkg of packages) {
-		if (!pkg.gitTag) continue;
-		const group = groups.get(pkg.gitTag);
+		if (!pkg.git?.tag) continue;
+		const group = groups.get(pkg.git.tag);
 		if (group) group.push(pkg);
-		else groups.set(pkg.gitTag, [pkg]);
+		else groups.set(pkg.git.tag, [pkg]);
 	}
 	return groups;
 }
@@ -210,7 +225,8 @@ function defaultTitle(pkg) {
 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);
+	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);
@@ -251,7 +267,7 @@ async function defaultGroupedNotes(context, packages) {
 	if (changelogs.size > 0) {
 		const notes = await Promise.all(Array.from(changelogs.values()).map((entry) => renderChangelogEntryNotes(context, entry)));
 		sections.push("", notes.join("\n\n"));
-	} else sections.push("", `Published ${packages[0].gitTag}.`);
+	} 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-BXk2fMqa.js";
+import { d as CargoPluginOptions, f as CargoRegistryClient, p as cargo, u as CargoPackage } from "../types-DexeJdl7.js";
 export { CargoPackage, CargoPluginOptions, CargoRegistryClient, cargo };

package/dist/providers/npm.d.ts

@@ -1,2 +1,2 @@
-import { _ as npm, g as NpmRegistryClient, h as NpmPluginOptions, m as NpmPackage } from "../types-BXk2fMqa.js";
+import { _ as npm, g as NpmRegistryClient, h as NpmPluginOptions, m as NpmPackage } from "../types-DexeJdl7.js";
 export { NpmPackage, NpmPluginOptions, NpmRegistryClient, npm };

package/dist/providers/npm.js

@@ -81,15 +81,15 @@ var NpmRegistryClient = class {
 	async publish(pkg, { packageStore }) {
 		const distTag = packageStore.npm?.distTag;
 		if (this.client === "bun") {
-			const tarball = "pkg.tgz";
+			const tarballPath = path.resolve(pkg.path, "pkg.tgz");
 			const packResult = await x("bun", [
 				"pm",
 				"pack",
 				"--filename",
-				tarball
+				tarballPath
 			], { nodeOptions: { cwd: pkg.path } });
 			if (packResult.exitCode !== 0) throw execFailure(`Failed to pack ${pkg.name}@${pkg.version}.`, packResult);
-			const publishArgs = ["publish", tarball];
+			const publishArgs = ["publish", tarballPath];
 			if (distTag) publishArgs.push("--tag", distTag);
 			const publishResult = await x("npm", publishArgs, { nodeOptions: { cwd: pkg.path } });
 			if (publishResult.exitCode !== 0) throw execFailure(`Failed to publish ${pkg.name}@${pkg.version}${distTag ? ` with dist-tag "${distTag}"` : ""}.`, publishResult);

package/dist/publish-DkRT0yh6.js

@@ -0,0 +1,282 @@
+import { a as maxBump } from "./semver-C4vJ4SK8.js";
+import { r as handlePluginError } from "./error-DNy8R5ue.js";
+import { a as changelogFrontmatterSchema, n as publishPlanStatus } from "./checks-azjuIFt7.js";
+import { readFile, readdir } from "node:fs/promises";
+import { basename, join } from "node:path";
+import { dump, load } from "js-yaml";
+import { fromMarkdown } from "mdast-util-from-markdown";
+import { toMarkdown } from "mdast-util-to-markdown";
+//#region src/utils/frontmatter.ts
+/**
+* Inspired by https://github.com/jonschlinkert/gray-matter
+*/
+const regex = /^---\r?\n(.+?)\r?\n---\r?\n?/s;
+/**
+* parse frontmatter, it supports only yaml format
+*/
+function frontmatter(input) {
+	const output = {
+		matter: "",
+		data: {},
+		content: input
+	};
+	const match = regex.exec(input);
+	if (!match) return output;
+	output.matter = match[0];
+	output.content = input.slice(match[0].length);
+	output.data = load(match[1]) ?? {};
+	return output;
+}
+//#endregion
+//#region src/changelog/parse.ts
+async function getChangelogFiles(context) {
+	return (await readdir(context.changelogDir).catch(() => [])).filter((file) => file.endsWith(".md"));
+}
+async function readChangelogEntries(context) {
+	const dir = context.changelogDir;
+	const files = await getChangelogFiles(context);
+	return (await Promise.all(files.map(async (file) => {
+		const filePath = join(dir, file);
+		const content = await readFile(filePath, "utf8");
+		return parseChangelogFile(basename(filePath), content);
+	}))).filter((v) => v !== void 0);
+}
+/** Parse one changelog markdown file into release entries. */
+function parseChangelogFile(filename, content) {
+	const parsed = frontmatter(content);
+	const { success, data } = changelogFrontmatterSchema.safeParse(parsed.data);
+	if (!success || !data.packages) return;
+	const tree = fromMarkdown(parsed.content);
+	let headingBump;
+	const packages = /* @__PURE__ */ new Map();
+	const sections = [];
+	for (const section of getHeadingSections(tree)) {
+		const sectionBumpType = headingToBump(section.heading.depth);
+		if (sectionBumpType) headingBump = headingBump ? maxBump(headingBump, sectionBumpType) : sectionBumpType;
+		sections.push({
+			depth: section.heading.depth,
+			title: sectionToMarkdown(section.heading.children),
+			content: sectionToMarkdown(section.children)
+		});
+	}
+	if (sections.length === 0) return;
+	if (Array.isArray(data.packages)) {
+		if (!headingBump) return;
+		for (const pkg of data.packages) packages.set(pkg, { type: headingBump });
+	} else for (const [k, v] of Object.entries(data.packages)) {
+		let config;
+		if (typeof v === "string") config = { type: v };
+		else if (v === null) config = { type: headingBump };
+		else config = v;
+		if (config.type || config.replay?.length) packages.set(k, config);
+	}
+	if (packages.size === 0) return;
+	const entry = {
+		id: filename,
+		filename,
+		subject: data.subject,
+		packages,
+		sections,
+		_raw_body: parsed.content,
+		getRawContent() {
+			return [
+				"---",
+				dump({
+					subject: this.subject,
+					packages: Object.fromEntries(this.packages.entries())
+				}).trim(),
+				"---",
+				"",
+				entry._raw_body.trim(),
+				""
+			].join("\n");
+		}
+	};
+	return entry;
+}
+function parseReplayCondition(condition) {
+	if (condition.startsWith("exit prerelease:")) return {
+		type: "on-exit-prerelease",
+		name: condition.slice(16).trimStart()
+	};
+	const idx = condition.lastIndexOf("@");
+	if (idx <= 0) return null;
+	return {
+		type: "on-version",
+		name: condition.slice(0, idx),
+		version: condition.slice(idx + 1)
+	};
+}
+function getHeadingSections(tree) {
+	const sections = [];
+	let current;
+	for (const child of tree.children) {
+		if (child.type === "heading") {
+			current = {
+				heading: child,
+				children: []
+			};
+			sections.push(current);
+			continue;
+		}
+		current?.children.push(child);
+	}
+	return sections;
+}
+function sectionToMarkdown(children) {
+	if (children.length === 0) return "";
+	return toMarkdown({
+		type: "root",
+		children
+	}, {
+		bullet: "-",
+		fence: "`"
+	}).trim();
+}
+function headingToBump(depth) {
+	switch (depth) {
+		case 1: return "major";
+		case 2: return "minor";
+		case 3: return "patch";
+	}
+}
+//#endregion
+//#region src/publish.ts
+async function resolvePublishTargets(context, store) {
+	const targets = [];
+	const preflightPromises = [];
+	for (const [id, plan] of Object.entries(store.packages)) {
+		if (!plan.publish) continue;
+		const pkg = context.graph.get(id);
+		if (!pkg) continue;
+		targets.push(pkg.id);
+		preflightPromises.push(context.getRegistryClient(pkg).publishPreflight?.(pkg, {
+			store,
+			packageStore: plan
+		}));
+	}
+	const preflights = await Promise.all(preflightPromises);
+	const children = /* @__PURE__ */ new Map();
+	for (let i = 0; i < targets.length; i++) {
+		const id = targets[i];
+		children.set(id, preflights[i]?.wait);
+	}
+	const ordered = [];
+	function scan(id, stack = /* @__PURE__ */ new Set()) {
+		if (stack.has(id)) throw new Error(`circular reference of deps: ${[...stack, id].join(" -> ")}`);
+		if (ordered.includes(id)) return;
+		const deps = children.get(id);
+		if (deps) {
+			stack.add(id);
+			for (const dep of deps) scan(dep, stack);
+			stack.delete(id);
+		}
+		ordered.push(id);
+	}
+	for (const id of targets) scan(id);
+	return ordered;
+}
+async function publishFromPlan(context, store, options) {
+	const { dryRun = false } = options;
+	const packages = [];
+	if ((await publishPlanStatus(store, context)).state !== "pending") return { state: "skipped" };
+	const orderedIds = await resolvePublishTargets(context, store);
+	const parsedChangelogs = /* @__PURE__ */ new Map();
+	for (const [id, entry] of Object.entries(store.changelogs)) {
+		const parsed = parseChangelogFile(entry.filename, entry.content);
+		if (!parsed) continue;
+		parsedChangelogs.set(id, parsed);
+	}
+	for (const id of orderedIds) {
+		const plan = store.packages[id];
+		const pkg = context.graph.get(id);
+		const registryClient = context.getRegistryClient(pkg);
+		const changelogs = [];
+		for (const id of plan.changelogIds ?? []) {
+			const entry = parsedChangelogs.get(id);
+			if (entry) changelogs.push(entry);
+		}
+		if (dryRun) {
+			packages.push({
+				id: pkg.id,
+				name: pkg.name,
+				version: pkg.version,
+				npm: plan.npm,
+				state: "success",
+				changelogs
+			});
+			continue;
+		}
+		if (await registryClient.isPackagePublished(pkg)) {
+			packages.push({
+				id: pkg.id,
+				name: pkg.name,
+				version: pkg.version,
+				npm: plan.npm,
+				state: "success",
+				changelogs
+			});
+			continue;
+		}
+		try {
+			let result;
+			for (const plugin of context.plugins) {
+				const next = await handlePluginError(plugin, "willPublish", () => plugin.willPublish?.call(context, { pkg }));
+				if (next !== void 0) {
+					result = next;
+					break;
+				}
+			}
+			if (result === void 0) {
+				await registryClient.publish(pkg, {
+					packageStore: plan,
+					store
+				});
+				result = {
+					id: pkg.id,
+					name: pkg.name,
+					version: pkg.version,
+					npm: plan.npm,
+					state: "success",
+					changelogs
+				};
+			}
+			if (result === false) continue;
+			for (const plugin of context.plugins) {
+				const next = await handlePluginError(plugin, "afterPublish", () => plugin.afterPublish?.call(context, {
+					pkg,
+					result
+				}));
+				if (next) result = next;
+			}
+			packages.push(result);
+		} catch (error) {
+			packages.push({
+				id: pkg.id,
+				name: pkg.name,
+				version: pkg.version,
+				npm: plan.npm,
+				changelogs,
+				state: "failed",
+				error: error instanceof Error ? error.message : String(error)
+			});
+		}
+	}
+	if (packages.length === 0) return { state: "skipped" };
+	return {
+		state: packages.some((pkg) => pkg.state === "failed") ? "failed" : "created",
+		packages,
+		_rawPlan: store
+	};
+}
+function publishError(result, error) {
+	result.state = "failed";
+	if (result.state === "failed" && error) result.error = result.error ? `${result.error}\n${error}` : error;
+}
+function packagePublishError(result, packageResult, error) {
+	result.state = "failed";
+	packageResult.state = "failed";
+	if (packageResult.state === "failed" && error) packageResult.error = packageResult.error ? `${packageResult.error}\n${error}` : error;
+}
+//#endregion
+export { readChangelogEntries as a, parseReplayCondition as i, publishError as n, publishFromPlan as r, packagePublishError as t };

package/dist/{types-BXk2fMqa.d.ts → types-DexeJdl7.d.ts}

@@ -228,8 +228,11 @@ type PackagePublishResult = ({
   version: string;
   npm?: {
     distTag?: string;
-  }; /** added by the `git` plugin */
-  gitTag?: string;
+  };
+  git?: {
+    /** will be defined even if publishing fails */tag: string;
+    tagState: "created" | "skipped" | "failed";
+  };
   changelogs: ChangelogEntry[];
 };
 //#endregion

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tegami",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "Utility for package versioning & publish",
   "license": "MIT",
   "author": "Fuma Nama",