tegami 0.0.0 → 0.1.0-beta.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Fuma Nama
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

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.ts

@@ -0,0 +1,12 @@
+import { C as PublishResult, a as Awaitable, t as Tegami, w as DraftPlan } from "../index-Bhh2dJZp.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>;
+}
+declare function createCli(tegami: Tegami, options?: TegamiCLIOptions): Command;
+//#endregion
+export { TegamiCLIOptions, createCli };

package/dist/cli/index.js

@@ -0,0 +1,212 @@
+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 } 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
+var CancelledError = class extends Error {
+	constructor() {
+		super("Cancelled.");
+	}
+};
+function createCli(tegami, options = {}) {
+	const program = new Command();
+	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, () => versionPackages(tegami, {
+		...commandOptions,
+		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, () => 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 packages = context.graph.getPackages();
+	let selectedPackages = [];
+	if (isCI()) selectedPackages = [];
+	else {
+		const selected = await multiselect({
+			message: "Select packages (leave empty to auto-generate from commits)",
+			required: false,
+			options: packages.map((pkg) => ({
+				value: pkg.id,
+				label: pkg.id,
+				hint: pkg.version
+			}))
+		});
+		if (isCancel(selected)) throw new CancelledError();
+		selectedPackages = selected;
+	}
+	if (selectedPackages.length === 0) {
+		if (!isCI()) {
+			const confirmed = await confirm({
+				message: "Auto-generate changelog files from commits?",
+				initialValue: true
+			});
+			if (isCancel(confirmed)) throw new CancelledError();
+			if (!confirmed) {
+				outro("No changelogs created.");
+				return;
+			}
+		}
+		const s = spinner();
+		s.start("Reading commits and creating changelogs");
+		const created = await tegami.generateChangelog();
+		s.stop(created.length === 1 ? "Created 1 changelog file" : `Created ${created.length} changelog files`);
+		if (created.length === 0) note("No matching conventional commits were found.", "No changelogs created");
+		else note(created.map((entry) => `${entry.filename} (${entry.changes} changes)`).join("\n"), "Created changelogs");
+		outro("Changelogs ready.");
+		return;
+	}
+	const type = await select({
+		message: "Select release type",
+		options: [
+			{
+				value: "patch",
+				label: "patch"
+			},
+			{
+				value: "minor",
+				label: "minor"
+			},
+			{
+				value: "major",
+				label: "major"
+			}
+		]
+	});
+	if (isCancel(type)) throw new CancelledError();
+	const message = await text({
+		message: "Change message",
+		placeholder: "Add a concise release note",
+		validate(value) {
+			if (!value?.trim()) return "Enter a message.";
+		}
+	});
+	if (isCancel(message)) throw new CancelledError();
+	const filename = changelogFilename();
+	const s = spinner();
+	s.start("Creating changelog");
+	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.");
+}
+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();
+	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;
+	}
+	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}`);
+	}
+	note(planEntries.join("\n"), "Release plan");
+	const s = spinner();
+	s.start("Updating package versions");
+	try {
+		await draft.applyPlan();
+	} catch (error) {
+		s.stop("Failed to apply publish plan");
+		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.");
+}
+async function publishPackages(tegami, options) {
+	const dryRun = options.dryRun ?? false;
+	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}.`);
+		return;
+	}
+	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") {
+		process.exitCode = 1;
+		outro("Some packages failed to publish.");
+		return;
+	}
+	outro(dryRun ? "Publish plan is valid." : "Packages published.");
+}
+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);
+	return [
+		"---",
+		`packages: ${JSON.stringify(packages)}`,
+		"---",
+		"",
+		`${heading} ${message}`,
+		""
+	].join("\n");
+}
+function changelogFilename() {
+	const date = /* @__PURE__ */ new Date();
+	return `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, "0")}-${String(date.getDate()).padStart(2, "0")}-${Date.now().toString(36)}.md`;
+}
+async function runAction(tegami, action) {
+	try {
+		const context = await tegami._internal.context();
+		for (const plugin of context.plugins) await handlePluginError(plugin, "cli.init", () => plugin.cli?.init?.call(context));
+		await action();
+	} catch (error) {
+		if (error instanceof CancelledError) outro(error.message);
+		else {
+			note(error instanceof Error ? error.message : String(error), "Error");
+			outro("Command failed.");
+		}
+		process.exit(1);
+	}
+}
+//#endregion
+export { createCli };

package/dist/constants-B9qjNfvr.js

@@ -0,0 +1,4 @@
+//#region src/utils/constants.ts
+const isCI = () => Boolean(process.env.CI);
+//#endregion
+export { isCI as t };

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 { n as LogGenerator } from "../types-DdIMewK9.mjs";
+import { s as LogGenerator } from "../index-Bhh2dJZp.js";
 
 //#region src/generators/simple.d.ts
 declare function simpleGenerator(): LogGenerator;

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

@@ -1,8 +1,9 @@
+import { r as formatPackageVersion } from "../semver-mWK2Khi2.js";
 //#region src/generators/simple.ts
 function simpleGenerator() {
-	return { generate({ changelogs, version }) {
+	return { generate({ changelogs, version, packageName, plan }) {
 		return [
-			`## ${version}`,
+			`## ${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 };