tegami 0.1.6 → 0.2.0

package/dist/index.js

@@ -1,45 +1,33 @@
 import { a as maxBump } from "./semver-C4vJ4SK8.js";
-import { n as generateChangelog } from "./generate-B3bcuKLY.js";
+import { i as changelogFrontmatterSchema, n as generateFromCommits } from "./generate-BMlrn-2e.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 { t as PackageGraph } from "./graph-DrzluXw8.js";
 import { cargo } from "./providers/cargo.js";
 import { npm } from "./providers/npm.js";
 import { simpleGenerator } from "./generators/simple.js";
-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 fs, { mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
+import path, { basename, dirname, join } from "node:path";
 import * as semver from "semver";
+import z from "zod";
+import { dump, load, visit } 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();
 	const changelogDir = path.resolve(cwd, options.changelogDir ?? ".tegami");
 	const graph = new PackageGraph();
-	const registryClients = /* @__PURE__ */ new Map();
 	const ctx = {
 		cwd,
 		changelogDir,
-		planPath: options.planPath ? path.resolve(cwd, options.planPath) : path.join(changelogDir, "publish-plan"),
+		lockPath: options.lockPath ? path.resolve(cwd, options.lockPath) : path.join(changelogDir, "publish-lock.yaml"),
 		options,
 		plugins: resolvePlugins([
 			npm(options.npm),
 			cargo(options.cargo),
 			...options.plugins ?? []
 		]),
-		graph,
-		getRegistryClient(pkgOrId) {
-			let client;
-			if (typeof pkgOrId === "string") client = registryClients.get(pkgOrId);
-			else for (const item of registryClients.values()) if (item.supports && item.supports(pkgOrId)) {
-				client = item;
-				break;
-			}
-			if (!client) {
-				const id = typeof pkgOrId === "string" ? pkgOrId : pkgOrId.manager;
-				throw new Error(`No registry client is available for ${id}.`);
-			}
-			return client;
-		}
+		graph
 	};
 	for (const plugin of ctx.plugins) await handlePluginError(plugin, "init", () => plugin.init?.call(ctx));
 	for (const plugin of ctx.plugins) await handlePluginError(plugin, "resolve", () => plugin.resolve?.call(ctx));
@@ -58,11 +46,6 @@ async function createTegamiContext(options = {}) {
 		pkg.setPackageOptions(packageOptions);
 		if (packageOptions.group) graph.addGroupMember(packageOptions.group, pkg.id);
 	}
-	for (const plugin of ctx.plugins) {
-		const clients = await handlePluginError(plugin, "createRegistryClient", () => plugin.createRegistryClient?.call(ctx));
-		if (!clients) continue;
-		for (const client of Array.isArray(clients) ? clients : [clients]) registryClients.set(client.id, client);
-	}
 	return ctx;
 }
 const PLUGIN_ORDER = {
@@ -74,18 +57,203 @@ 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/lock.ts
+function inlineMultilineScalars(documents) {
+	visit(documents, (node) => {
+		if (node.kind !== "scalar" || !node.value.includes("\n")) return;
+		node.style.doubleQuoted = true;
+		node.style.literal = false;
+		node.style.folded = false;
+		node.style.singleQuoted = false;
+	});
+}
+const lockDumpOptions = {
+	sortKeys: true,
+	lineWidth: -1,
+	transform: inlineMultilineScalars
+};
+/**
+* the data structure of `publish-lock.yaml` file.
+*/
+var PublishLock = class {
+	data;
+	constructor(data = /* @__PURE__ */ new Map()) {
+		this.data = data;
+	}
+	/** write data to namespace, note that the `data` must be serializable in yaml */
+	write(namespace, data) {
+		let arr = this.data.get(namespace);
+		if (!arr) {
+			arr = [];
+			this.data.set(namespace, arr);
+		}
+		arr.push(data);
+	}
+	read(namespace) {
+		return this.data.get(namespace)?.shift();
+	}
+	size(namespace) {
+		return this.data.get(namespace)?.length ?? 0;
+	}
+	serialize() {
+		let res = dump(Object.fromEntries(this.data.entries()), lockDumpOptions);
+		if (!res.endsWith("\n")) res += "\n";
+		return res;
+	}
+};
+const baseSchema = z.record(z.string(), z.array(z.unknown()));
+function parsePublishLock(content) {
+	const data = baseSchema.parse(load(content));
+	return new PublishLock(new Map(Object.entries(data)));
+}
+//#endregion
 //#region src/plans/policy.ts
 function groupPolicy({ graph }) {
 	return {
 		id: "group",
-		onUpdate({ pkg, plan }) {
-			if (!plan.type) return;
+		onUpdate({ pkg, packageDraft }) {
+			if (!packageDraft.type) return;
 			const group = graph.getPackageGroup(pkg.id);
 			if (!group || !group.options.syncBump) return;
 			for (const member of group.packages) {
 				if (member === pkg) continue;
 				this.bumpPackage(member, {
-					type: plan.type,
+					type: packageDraft.type,
 					reason: `sync "${group.name}" group package versions`
 				});
 			}
@@ -94,57 +262,70 @@ function groupPolicy({ graph }) {
 }
 //#endregion
 //#region src/plans/draft.ts
-var DraftPlan = class {
+const changelogStoreSchema = z.object({
+	v: z.literal("0.0.0"),
+	filename: z.string(),
+	content: z.string()
+});
+const packageStoreSchema = z.object({
+	id: z.string(),
+	updated: z.boolean(),
+	changelogIds: z.array(z.string()).optional()
+});
+/** a draft describes all operations to perform before the actual publishing, such as version bumps. */
+var Draft = class {
 	context;
 	#applied = false;
+	/** package id -> draft */
 	packages = /* @__PURE__ */ new Map();
+	/** id -> changelog */
 	changelogs = /* @__PURE__ */ new Map();
 	policies = [];
 	constructor(context) {
 		this.context = context;
 		this.policies.push(groupPolicy(context));
 	}
-	getPackagePlans() {
+	getPackageDrafts() {
 		return this.packages;
 	}
-	getPackagePlan(id) {
+	getPackageDraft(id) {
 		return this.packages.get(id);
 	}
 	bumpPackage(pkg, { type, reason }) {
-		return this.dispatchPackage(pkg, (plan) => {
-			plan.type = plan.type ? maxBump(plan.type, type) : type;
+		return this.dispatchPackage(pkg, (draft) => {
+			draft.type = draft.type ? maxBump(draft.type, type) : type;
 			if (reason) {
-				plan.bumpReasons ??= /* @__PURE__ */ new Set();
-				plan.bumpReasons.add(reason);
+				draft.bumpReasons ??= /* @__PURE__ */ new Set();
+				draft.bumpReasons.add(reason);
 			}
 		});
 	}
 	dispatchPackage(pkg, dispatch, onUpdate) {
-		const plan = this.getOrInitPackage(pkg);
-		const prevVersion = plan.bumpVersion(pkg);
-		dispatch(plan);
-		if (prevVersion !== plan.bumpVersion(pkg)) {
-			onUpdate?.(plan);
+		const packageDraft = this.getOrInitPackage(pkg);
+		const prevVersion = packageDraft.bumpVersion(pkg);
+		dispatch(packageDraft);
+		if (prevVersion !== packageDraft.bumpVersion(pkg)) {
+			onUpdate?.(packageDraft);
 			for (const policy of this.policies) policy.onUpdate?.call(this, {
-				plan,
+				packageDraft,
 				pkg
 			});
 		}
-		return plan;
+		return packageDraft;
 	}
 	getOrInitPackage(pkg) {
 		const existing = this.packages.get(pkg.id);
 		if (existing) return existing;
-		this.packages.set(pkg.id, pkg.initPlan());
-		return this.dispatchPackage(pkg, (plan) => pkg.configurePlan(plan, this.context.graph.getPackageGroup(pkg.id)), (plan) => {
-			(plan.bumpReasons ??= /* @__PURE__ */ new Set()).add("align with script-level configs");
+		this.packages.set(pkg.id, pkg.initDraft());
+		return this.dispatchPackage(pkg, (draft) => pkg.configureDraft(draft, this.context.graph.getPackageGroup(pkg.id)), (draft) => {
+			(draft.bumpReasons ??= /* @__PURE__ */ new Set()).add("align with script-level configs");
 		});
 	}
 	hasPending() {
 		const { graph } = this.context;
-		for (const [id, plan] of this.packages) {
+		for (const [id, draft] of this.packages) {
 			const pkg = graph.get(id);
-			if (pkg && plan.bumpVersion(pkg) !== pkg.version) return true;
+			if (pkg && draft.bumpVersion(pkg) !== pkg.version) return true;
 		}
 		return false;
 	}
@@ -167,30 +348,53 @@ var DraftPlan = class {
 	deleteChangelog(id) {
 		return this.changelogs.delete(id);
 	}
-	/** Apply the publish plan: update package versions, write the plan file, and consume changelog files. */
-	async applyPlan() {
-		if (this.#applied) throw new Error("This draft has already applied a publish plan.");
-		await assertPublishPlanFinished(this.context);
+	/** Apply version bumps, lock file, and changelog files. */
+	async apply() {
+		if (this.#applied) throw new Error("This draft has already been applied.");
 		const { graph } = this.context;
 		this.#applied = true;
 		const snapshots = /* @__PURE__ */ new Map();
 		for (const pkg of graph.getPackages()) snapshots.set(pkg.id, { version: pkg.version });
-		for (const plugin of this.context.plugins) await handlePluginError(plugin, "applyPlan", () => plugin.applyPlan?.call(this.context, this));
+		for (const plugin of this.context.plugins) await handlePluginError(plugin, "applyDraft", () => plugin.applyDraft?.call(this.context, this));
 		const updatedChangelogs = this.applyReplays(snapshots);
 		const writes = [];
-		for (const [id, packagePlan] of this.packages) {
+		for (const [id, packageDraft] of this.packages) {
 			const pkg = graph.get(id);
 			if (!pkg) continue;
-			writes.push(this.appendChangelog(pkg, packagePlan));
+			writes.push(this.appendChangelog(pkg, packageDraft));
 		}
 		for (const entry of this.changelogs.values()) {
 			const updated = updatedChangelogs.get(entry.id);
 			const filePath = path.join(this.context.changelogDir, entry.filename);
-			writes.push(updated ? writeFile(filePath, updated.getRawContent()) : rm(filePath, { force: true }));
+			if (updated) writes.push(mkdir(this.context.changelogDir, { recursive: true }).then(() => writeFile(filePath, updated.getRawContent())));
+			else if (!entry.virtual) writes.push(rm(filePath, { force: true }));
 		}
+		writes.push(this.writeLockFile(snapshots));
 		await Promise.all(writes);
-		await mkdir(dirname(this.context.planPath), { recursive: true });
-		await writeFile(this.context.planPath, createPlanStore(this, this.context));
+	}
+	/** write persistent data to publish lock */
+	async writeLockFile(snapshots) {
+		const lock = new PublishLock();
+		for (const entry of this.getChangelogs()) lock.write("core:changelogs", {
+			v: "0.0.0",
+			filename: entry.filename,
+			content: entry.getRawContent()
+		});
+		for (const pkg of this.context.graph.getPackages()) {
+			const draft = this.getPackageDraft(pkg.id);
+			const snapshot = snapshots.get(pkg.id);
+			lock.write("core:packages", {
+				id: pkg.id,
+				updated: draft !== void 0 && (snapshot === void 0 || snapshot.version !== pkg.version),
+				changelogIds: draft?.changelogs?.map((entry) => entry.id)
+			});
+		}
+		for (const plugin of this.context.plugins) await handlePluginError(plugin, "initPublishLock", () => plugin.initPublishLock?.call(this.context, {
+			lock,
+			draft: this
+		}));
+		await mkdir(dirname(this.context.lockPath), { recursive: true });
+		await writeFile(this.context.lockPath, lock.serialize());
 	}
 	addPolicy(policy) {
 		this.policies.push(policy);
@@ -242,53 +446,191 @@ var DraftPlan = class {
 		}
 		return updated;
 	}
-	async appendChangelog(pkg, plan) {
-		if (!plan.changelogs || plan.changelogs.length === 0) return;
+	async appendChangelog(pkg, draft) {
+		if (!draft.changelogs || draft.changelogs.length === 0) return;
 		const { generator = simpleGenerator() } = this.context.options;
 		const generated = await generator.generate.call(this.context, {
-			packageId: pkg.id,
-			packageName: pkg.name,
-			version: pkg.version,
-			plan,
-			changelogs: plan.changelogs,
-			unstable_draft: this
+			pkg,
+			packageDraft: draft,
+			draft: this
 		});
 		const path = join(pkg.path, "CHANGELOG.md");
 		const existing = await readFile(path, "utf8").catch(() => "");
 		await writeFile(path, `${generated.trim()}\n\n${existing}`.trimEnd() + "\n");
 	}
-	/** {@link applyPlan} but for `await using` syntax */
+	/** {@link apply} but for `await using` syntax */
 	async [Symbol.asyncDispose]() {
-		return this.applyPlan();
+		return this.apply();
 	}
 };
-async function cleanupPublishPlan(context) {
-	const store = await readPlanStore(context);
-	if (!store) return {
-		state: "skipped",
-		reason: "missing"
-	};
-	if ((await publishPlanStatus(store, context)).state !== "success") return {
-		state: "skipped",
-		reason: "pending"
-	};
-	await rm(context.planPath, { force: true });
-	return { state: "removed" };
-}
-async function createDraftPlan(changelogs, context) {
-	let draft = new DraftPlan(context);
+async function createDraft(changelogs, context) {
+	let draft = new Draft(context);
 	for (const plugin of context.plugins) {
-		const result = await handlePluginError(plugin, "initPlan", () => plugin.initPlan?.call(context, draft));
+		const result = await handlePluginError(plugin, "initDraft", () => plugin.initDraft?.call(context, draft));
 		if (result) draft = result;
 	}
 	for (const pkg of context.graph.getPackages()) draft.getOrInitPackage(pkg);
 	for (const entry of changelogs) draft.addChangelog(entry);
 	return draft;
 }
-function attachChangelog(plan, entry) {
-	if (plan.changelogs?.some((item) => item.id === entry.id)) return;
-	plan.changelogs ??= [];
-	plan.changelogs.push(entry);
+function attachChangelog(draft, entry) {
+	if (draft.changelogs?.some((item) => item.id === entry.id)) return;
+	draft.changelogs ??= [];
+	draft.changelogs.push(entry);
+}
+//#endregion
+//#region src/plans/publish.ts
+async function initPublishPlan(context, options) {
+	let lock;
+	try {
+		lock = parsePublishLock(await fs.readFile(context.lockPath, "utf8"));
+	} catch {
+		return;
+	}
+	let data;
+	const packages = /* @__PURE__ */ new Map();
+	const changelogs = /* @__PURE__ */ new Map();
+	while (data = lock.read("core:changelogs")) {
+		const entry = changelogStoreSchema.safeParse(data).data;
+		if (!entry) continue;
+		const parsed = parseChangelogFile(entry.filename, entry.content);
+		if (!parsed) continue;
+		changelogs.set(parsed.id, parsed);
+	}
+	while (data = lock.read("core:packages")) {
+		const parsed = packageStoreSchema.safeParse(data).data;
+		if (!parsed) continue;
+		if (!context.graph.get(parsed.id)) continue;
+		const pkgChangelogs = [];
+		for (const id of parsed.changelogIds ?? []) {
+			const entry = changelogs.get(id);
+			if (entry) pkgChangelogs.push(entry);
+		}
+		packages.set(parsed.id, {
+			changelogs: pkgChangelogs,
+			updated: parsed.updated
+		});
+	}
+	const plan = {
+		options,
+		changelogs,
+		packages
+	};
+	for (const plugin of context.plugins) await handlePluginError(plugin, "initPublishPlan", () => plugin.initPublishPlan?.call(context, {
+		lock,
+		plan
+	}));
+	return plan;
+}
+function resolvePublishTargets(plan) {
+	const ordered = [];
+	function scan(id, stack = /* @__PURE__ */ new Set()) {
+		const preflight = plan.packages.get(id)?.preflight;
+		if (!preflight || preflight.publish === false) return;
+		if (stack.has(id)) throw new Error(`circular reference of deps: ${[...stack, id].join(" -> ")}`);
+		if (ordered.includes(id)) return;
+		if (preflight.wait) {
+			stack.add(id);
+			for (const dep of preflight.wait) scan(dep, stack);
+			stack.delete(id);
+		}
+		ordered.push(id);
+	}
+	for (const id of plan.packages.keys()) scan(id);
+	return ordered;
+}
+async function runPublishPlan(context, plan) {
+	const { dryRun = false } = plan.options;
+	const onPublishResult = async (pkg, publishResult) => {
+		const packagePlan = plan.packages.get(pkg.id);
+		if (!packagePlan) return;
+		packagePlan.publishResult = publishResult;
+		for (const plugin of context.plugins) await handlePluginError(plugin, "afterPublish", () => plugin.afterPublish?.call(context, {
+			pkg,
+			plan
+		}));
+	};
+	for (const id of resolvePublishTargets(plan)) {
+		const pkg = context.graph.get(id);
+		if (dryRun) {
+			await onPublishResult(pkg, { type: "published" });
+			continue;
+		}
+		let isSkipped = false;
+		for (const plugin of context.plugins) if (await handlePluginError(plugin, "willPublish", () => plugin.willPublish?.call(context, { pkg })) === false) {
+			isSkipped = true;
+			break;
+		}
+		if (isSkipped) {
+			await onPublishResult(pkg, { type: "skipped" });
+			continue;
+		}
+		let published = false;
+		for (const plugin of context.plugins) {
+			const publishResult = await handlePluginError(plugin, "publish", () => plugin.publish?.call(context, {
+				pkg,
+				plan
+			}));
+			if (publishResult) {
+				published = true;
+				await onPublishResult(pkg, publishResult);
+				break;
+			}
+		}
+		if (!published) await onPublishResult(pkg, {
+			type: "failed",
+			error: `There is no plugin to publish package "${pkg.id}", please make sure the package has a supported provider plugin.`
+		});
+	}
+	await Promise.all(Array.from(plan.packages, async ([id, packagePlan]) => {
+		const pkg = context.graph.get(id);
+		if (!packagePlan.publishResult) await onPublishResult(pkg, { type: "skipped" });
+	}));
+	for (const plugin of context.plugins) await handlePluginError(plugin, "afterPublishAll", () => plugin.afterPublishAll?.call(context, { plan }));
+}
+async function runPreflights(context, plan) {
+	const promises = [];
+	const runPreflight = async (pkg) => {
+		const out = {};
+		for (const plugin of context.plugins) {
+			const res = await handlePluginError(plugin, "publishPreflight", () => plugin.publishPreflight?.call(context, {
+				pkg,
+				plan
+			}));
+			if (res?.publish !== void 0) out.publish = res.publish;
+			if (res?.wait) {
+				out.wait ??= [];
+				out.wait.push(...res.wait);
+			}
+		}
+		return out;
+	};
+	for (const [id, packagePlan] of plan.packages) {
+		const pkg = context.graph.get(id);
+		if (!packagePlan.updated) {
+			packagePlan.preflight = { publish: false };
+			continue;
+		}
+		promises.push(runPreflight(pkg).then((preflight) => {
+			packagePlan.preflight = preflight;
+		}));
+	}
+	await Promise.all(promises);
+}
+async function publishPlanStatus(plan, context) {
+	for (const pkg of plan.packages.values()) {
+		if (!pkg.preflight) throw new Error("Should perform preflight before checking plan status.");
+		if (pkg.preflight.publish ?? true) return "pending";
+	}
+	try {
+		await Promise.all(context.plugins.map(async (plugin) => {
+			if (await handlePluginError(plugin, "resolvePlanStatus", () => plugin.resolvePlanStatus?.call(context, { plan })) === "pending") throw "pending";
+		}));
+		return "success";
+	} catch (e) {
+		if (e === "pending") return "pending";
+		throw e;
+	}
 }
 //#endregion
 //#region src/index.ts
@@ -299,8 +641,15 @@ function tegami(options = {}) {
 		return createTegamiContext(options);
 	}
 	return {
-		async generateChangelog(createOptions = {}) {
-			return generateChangelog(await $context, createOptions);
+		async generateChangelog(generateOptions = {}) {
+			const { write = true } = generateOptions;
+			const context = await $context;
+			const changelogs = await generateFromCommits(context, generateOptions);
+			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;
 		},
 		_internal: {
 			options,
@@ -313,25 +662,49 @@ function tegami(options = {}) {
 		},
 		async draft() {
 			const context = await $context;
-			return createDraftPlan(await readChangelogEntries(context), context);
+			const changelogs = await readChangelogEntries(context);
+			if (context.options.conventionalCommits) {
+				const generated = await generateFromCommits(context);
+				for (const entry of generated) {
+					const parsed = parseChangelogFile(entry.filename, entry.content);
+					if (!parsed) continue;
+					parsed.virtual = true;
+					changelogs.push(parsed);
+				}
+			}
+			return createDraft(changelogs, context);
+		},
+		async publishStatus() {
+			const context = await $context;
+			const plan = await initPublishPlan(context, {});
+			if (!plan) return "idle";
+			await runPreflights(context, plan);
+			return publishPlanStatus(plan, context);
 		},
 		async publish(publishOptions = {}) {
 			const context = await $context;
-			const parsed = await readPlanStore(context);
-			if (!parsed) return { state: "skipped" };
-			let result = await publishFromPlan(context, parsed, publishOptions);
-			const publishCtx = {
-				...context,
-				publishOptions
-			};
-			for (const plugin of context.plugins) {
-				const next = await handlePluginError(plugin, "afterPublishAll", () => plugin.afterPublishAll?.call(publishCtx, result));
-				if (next) result = next;
-			}
-			return result;
+			const plan = await initPublishPlan(context, publishOptions);
+			if (!plan) return "skipped";
+			await runPreflights(context, plan);
+			if (await publishPlanStatus(plan, context) === "success") return "skipped";
+			await runPublishPlan(context, plan);
+			if (Array.from(plan.packages.values()).every((pkg) => pkg.publishResult.type === "skipped")) return "skipped";
+			return plan;
 		},
 		async cleanup() {
-			return cleanupPublishPlan(await $context);
+			const context = await $context;
+			const plan = await initPublishPlan(context, {});
+			if (!plan) return {
+				state: "skipped",
+				reason: "no-plan"
+			};
+			await runPreflights(context, plan);
+			if (await publishPlanStatus(plan, context) !== "success") return {
+				state: "skipped",
+				reason: "pending"
+			};
+			await rm(context.lockPath, { force: true });
+			return { state: "removed" };
 		}
 	};
 }