tegami 0.0.1 → 0.1.0-beta.1

package/dist/checks-CKBRRjgQ.js

@@ -0,0 +1,100 @@
+import { n as handlePluginError } from "./error-DBK-9uBa.js";
+import { n as jsonCodec } from "./schemas-Cc4h6bq5.js";
+import z$1 from "zod";
+import { readFile } from "fs/promises";
+//#region src/plans/store.ts
+const packagePlanStoreSchema = z$1.object({
+	type: z$1.enum([
+		"major",
+		"minor",
+		"patch"
+	]).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(),
+		subject: z$1.string().optional(),
+		packages: z$1.array(z$1.string()),
+		type: z$1.enum([
+			"major",
+			"minor",
+			"patch"
+		]),
+		title: 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,
+		subject: entry.subject,
+		packages: Array.from(entry.packages),
+		type: entry.type,
+		title: entry.title,
+		content: entry.content
+	};
+	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 { readPlanStore as i, publishPlanStatus as n, createPlanStore as r, assertPublishPlanFinished as t };

package/dist/cli/{index.d.mts → index.d.ts}

@@ -1,9 +1,9 @@
-import { _ as PublishResult, n as Awaitable, y as DraftPlan } from "../context-CC36jtz1.mjs";
-import { t as Tegami } from "../index-DJ7YxxdM.mjs";
+import { C as PublishResult, a as Awaitable, t as Tegami, w as DraftPlan } from "../index-Da6P6gSc.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>;
 }

package/dist/cli/{index.mjs → index.js}

@@ -1,6 +1,8 @@
-import { t as isCI } from "../constants-B9qjNfvr.mjs";
+import { n as handlePluginError } from "../error-DBK-9uBa.js";
+import { t as assertPublishPlanFinished } from "../checks-CKBRRjgQ.js";
+import { t as isCI } from "../constants-B9qjNfvr.js";
 import { mkdir, writeFile } from "node:fs/promises";
-import { join, resolve } from "node:path";
+import { join } from "node:path";
 import { confirm, intro, isCancel, multiselect, note, outro, select, spinner, text } from "@clack/prompts";
 import { Command } from "commander";
 //#region src/cli/index.ts
@@ -11,24 +13,34 @@ var CancelledError = class extends Error {
 };
 function createCli(tegami, options = {}) {
 	const program = new Command();
-	program.name("tegami").description("Create changelogs, version packages, and publish releases.").action((commandOptions) => runAction(tegami, () => createChangelogs(tegami, {
-		...commandOptions,
-		cli: options
-	})));
-	program.command("version").description("create a publish plan and update package versions").action((commandOptions) => runAction(tegami, () => versionPackages(tegami, {
-		...commandOptions,
-		cli: options
-	})));
-	program.command("publish").description("publish packages from the current publish plan").option("--dry-run", "validate the publish plan without publishing packages").action((commandOptions) => runAction(tegami, () => publishPackages(tegami, {
+	program.name("tegami").description("create changelogs").action((commandOptions) => runAction(tegami, () => createChangelogs(tegami, {
 		...commandOptions,
 		cli: options
 	})));
+	program.command("version").description("draft and apply a publish plan").action((commandOptions) => runAction(tegami, async () => {
+		await versionPackages(tegami, {
+			...commandOptions,
+			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("publish").description("publish packages from the applied publish plan").option("--dry-run", "validate the publish plan 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)));
 	return program;
 }
 async function createChangelogs(tegami, _options) {
+	const context = await tegami._internal.context();
+	await assertPublishPlanFinished(context);
 	intro("Create changelogs");
-	const { graph, cwd, changelogDir } = await tegami._internal.context();
-	const packages = graph.getPackages();
+	const packages = context.graph.getPackages();
 	let selectedPackages = [];
 	if (isCI()) selectedPackages = [];
 	else {
@@ -92,11 +104,10 @@ async function createChangelogs(tegami, _options) {
 	});
 	if (isCancel(message)) throw new CancelledError();
 	const filename = changelogFilename();
-	const directory = resolve(cwd, changelogDir);
 	const s = spinner();
 	s.start("Creating changelog");
-	await mkdir(directory, { recursive: true });
-	await writeFile(join(directory, filename), renderManualChangelog(selectedPackages, type, message.trim()));
+	await mkdir(context.changelogDir, { recursive: true });
+	await writeFile(join(context.changelogDir, filename), renderManualChangelog(selectedPackages, type, message.trim()));
 	s.stop("Created changelog file");
 	note(`${filename}\n${selectedPackages.join(", ")}: ${type}`, "Created changelog");
 	outro("Changelog ready.");
@@ -104,36 +115,35 @@ async function createChangelogs(tegami, _options) {
 async function versionPackages(tegami, options) {
 	intro("Version Packages");
 	const { version: customVersion } = options.cli;
+	const context = await tegami._internal.context();
 	const draft = customVersion ? await customVersion() : await tegami.draft();
-	const packageIds = draft.getPackageIds();
-	if (packageIds.length === 0) {
+	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.hasPending()) {
 		note("No pending changelog entries matched workspace packages.", "Nothing to version");
 		outro("No versions changed.");
-		return;
+		return false;
 	}
-	note(packageIds.map((id) => {
-		const plan = draft.getPackage(id);
-		return `${id}: ${plan.type} (${plan.changelogIds.size} changelogs)`;
-	}).join("\n"), "Release plan");
-	if (draft.editable()) {
-		const s = spinner();
-		s.start("Updating package versions");
-		try {
-			await draft.createPublishPlan();
-		} catch (error) {
-			s.stop("Failed to create publish plan");
-			throw error;
-		}
-		s.stop("Package versions updated");
+	const planEntries = [];
+	for (const pkg of context.graph.getPackages()) {
+		const plan = draft.getPackagePlan(pkg.id);
+		if (!plan?.type) continue;
+		planEntries.push(`${pkg.id}: ${plan.type} (${plan.changelogs?.length ?? 0} changelogs)`);
+		if (plan.bumpReasons) for (const reason of plan.bumpReasons) planEntries.push(`  - ${reason}`);
 	}
-	const context = await tegami._internal.context();
-	for (const plugin of context.plugins) try {
-		await plugin.cli?.afterVersion?.call(context, draft);
+	note(planEntries.join("\n"), "Release plan");
+	const s = spinner();
+	s.start("Updating package versions");
+	try {
+		await draft.applyPlan();
 	} catch (error) {
-		const details = error instanceof Error ? error.message : String(error);
-		throw new Error(`Plugin "${plugin.name}" failed during afterVersion:\n${details}`, { cause: error });
+		s.stop("Failed to apply publish plan");
+		throw error;
 	}
-	outro("Publish plan created.");
+	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.");
+	return true;
 }
 async function publishPackages(tegami, options) {
 	const dryRun = options.dryRun ?? false;
@@ -143,22 +153,41 @@ async function publishPackages(tegami, options) {
 	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 ${result.planPath}.`);
-		return;
+		outro(`No publishable packages were found in ${planPath}.`);
+		return false;
 	}
 	s.stop(dryRun ? "Publish plan validated" : "Publish complete");
 	note(result.packages.map((pkg) => {
-		const tag = pkg.distTag ? ` (${pkg.distTag})` : "";
+		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") {
 		process.exitCode = 1;
 		outro("Some packages failed to publish.");
-		return;
+		return false;
 	}
 	outro(dryRun ? "Publish plan is valid." : "Packages published.");
+	return true;
+}
+async function runCleanup(tegami) {
+	intro("Cleanup publish plan");
+	const s = spinner();
+	s.start("Checking publish plan status");
+	const result = await tegami.cleanup();
+	const { planPath } = await tegami._internal.context();
+	s.stop(result.state === "removed" ? "Publish plan removed" : "Publish plan kept");
+	if (result.state === "removed") {
+		outro(`Removed ${planPath}.`);
+		return;
+	}
+	if (result.reason === "missing") {
+		outro(`No publish plan found at ${planPath}.`);
+		return;
+	}
+	outro(`Publish plan at ${planPath} is still pending. Publish it before cleanup.`);
 }
 function renderManualChangelog(packages, type, message) {
 	const heading = "#".repeat(type === "major" ? 1 : type === "minor" ? 2 : 3);
@@ -178,21 +207,15 @@ function changelogFilename() {
 async function runAction(tegami, action) {
 	try {
 		const context = await tegami._internal.context();
-		for (const plugin of context.plugins) try {
-			await plugin.cli?.init?.call(context);
-		} catch (error) {
-			const details = error instanceof Error ? error.message : String(error);
-			throw new Error(`Plugin "${plugin.name}" failed during cli.init:\n${details}`, { cause: error });
-		}
+		for (const plugin of context.plugins) await handlePluginError(plugin, "cli.init", () => plugin.cli?.init?.call(context));
 		await action();
 	} catch (error) {
-		process.exitCode = 1;
-		if (error instanceof CancelledError) {
-			outro(error.message);
-			return;
+		if (error instanceof CancelledError) outro(error.message);
+		else {
+			note(error instanceof Error ? error.message : String(error), "Error");
+			outro("Command failed.");
 		}
-		note(error instanceof Error ? error.message : String(error), "Error");
-		outro("Command failed.");
+		process.exit(1);
 	}
 }
 //#endregion

package/dist/error-DBK-9uBa.js

@@ -0,0 +1,23 @@
+//#region src/utils/error.ts
+function commandOutput(result) {
+	return [result.stdout, result.stderr].filter(Boolean).join("\n").trim();
+}
+function execFailure(context, result) {
+	const lines = [context, `(exit ${result.exitCode})`];
+	const output = commandOutput(result);
+	if (output) lines.push(output);
+	return new Error(lines.join("\n"));
+}
+function isNodeError(error) {
+	return error instanceof Error && "code" in error;
+}
+async function handlePluginError(plugin, hookName, callback) {
+	try {
+		return await callback();
+	} catch (error) {
+		const details = error instanceof Error ? error.message : String(error);
+		throw new Error(`Plugin "${plugin.name}" failed during ${hookName}:\n${details}`, { cause: error });
+	}
+}
+//#endregion
+export { handlePluginError as n, isNodeError as r, execFailure as t };

package/dist/generators/{simple.d.mts → simple.d.ts}

@@ -1,4 +1,4 @@
-import { r as LogGenerator } from "../context-CC36jtz1.mjs";
+import { s as LogGenerator } from "../index-Da6P6gSc.js";
 
 //#region src/generators/simple.d.ts
 declare function simpleGenerator(): LogGenerator;

package/dist/generators/{simple.mjs → simple.js}

@@ -1,9 +1,9 @@
-import { n as formatPackageVersion } from "../semver-FSWx3_34.mjs";
+import { r as formatPackageVersion } from "../semver-mWK2Khi2.js";
 //#region src/generators/simple.ts
 function simpleGenerator() {
-	return { generate({ changelogs, version, packageName, distTag }) {
+	return { generate({ changelogs, version, packageName, plan }) {
 		return [
-			`## ${formatPackageVersion(packageName, version, distTag)}`,
+			`## ${formatPackageVersion(packageName, version, plan.npm?.distTag)}`,
 			"",
 			...changelogs.flatMap((entry) => [
 				`### ${entry.title}`,

package/dist/graph-CUgwuRW5.js

@@ -0,0 +1,107 @@
+import { t as bumpVersion } from "./semver-mWK2Khi2.js";
+//#region src/graph.ts
+/** Package discovered in the workspace. */
+var WorkspacePackage = class {
+	get id() {
+		return `${this.manager}:${this.name}`;
+	}
+	opts = {};
+	/** note: this will only be available after package graph is resolved */
+	getPackageOptions() {
+		return this.opts;
+	}
+	setPackageOptions(options) {
+		this.opts = options;
+	}
+	/** create an empty draft plan. */
+	onPlan(_context) {
+		const { publish, prerelease, npm } = this.opts;
+		return {
+			publish,
+			prerelease,
+			npm: npm ? { distTag: npm.distTag } : void 0,
+			bumpVersion(pkg) {
+				return bumpVersion(pkg.version, this.type, this.prerelease);
+			}
+		};
+	}
+};
+/** Dependency graph for discovered workspace packages. */
+var PackageGraph = class {
+	packages = /* @__PURE__ */ new Map();
+	groups = /* @__PURE__ */ new Map();
+	constructor(packages = []) {
+		for (const pkg of packages) this.add(pkg);
+	}
+	getPackages() {
+		const out = [];
+		for (const pkg of this.packages.values()) out.push(pkg.value);
+		return out;
+	}
+	/** Get a package by exact id. */
+	get(id) {
+		return this.packages.get(id)?.value;
+	}
+	/** Get packages by id, `group:name`, or every package matching a name. */
+	getByName(nameOrId) {
+		const exact = this.packages.get(nameOrId);
+		if (exact) return [exact.value];
+		if (nameOrId.startsWith("group:")) return this.getGroup(nameOrId.slice(6))?.packages ?? [];
+		const out = [];
+		for (const { value } of this.packages.values()) if (value.name === nameOrId) out.push(value);
+		return out;
+	}
+	/** scan package into graph, if the package id already exists, replace the existing one in graph */
+	add(pkg) {
+		this.delete(pkg.id);
+		this.packages.set(pkg.id, { value: pkg });
+	}
+	delete(id) {
+		this.packages.delete(id);
+		for (const group of this.groups.values()) {
+			const index = group.packages.findIndex((pkg) => pkg.id === id);
+			if (index >= 0) group.packages.splice(index, 1);
+		}
+	}
+	getPackageGroup(pkgId) {
+		return this.packages.get(pkgId)?.group;
+	}
+	getGroups() {
+		return Array.from(this.groups.values());
+	}
+	getGroup(name) {
+		return this.groups.get(name);
+	}
+	registerGroup(name, options) {
+		const existing = this.groups.get(name);
+		if (existing) {
+			existing.options = options;
+			return existing;
+		}
+		const group = {
+			name,
+			options,
+			packages: []
+		};
+		this.groups.set(name, group);
+		return group;
+	}
+	addGroupMember(groupId, id) {
+		const group = this.groups.get(groupId);
+		const pkg = this.packages.get(id);
+		if (!group || !pkg || pkg.group) return;
+		pkg.group = group;
+		group.packages.push(pkg.value);
+	}
+	removeGroupMember(group, id) {
+		const entry = this.groups.get(group);
+		if (!entry) return;
+		const index = entry.packages.findIndex((pkg) => pkg.id === id);
+		if (index >= 0) entry.packages.splice(index, 1);
+	}
+	unregisterGroup(name) {
+		this.groups.delete(name);
+	}
+};
+//#endregion
+export { WorkspacePackage as n, PackageGraph as t };