tegami 0.0.0

package/dist/generators/simple.d.mts

@@ -0,0 +1,6 @@
+import { n as LogGenerator } from "../types-DdIMewK9.mjs";
+
+//#region src/generators/simple.d.ts
+declare function simpleGenerator(): LogGenerator;
+//#endregion
+export { simpleGenerator };

package/dist/generators/simple.mjs

@@ -0,0 +1,17 @@
+//#region src/generators/simple.ts
+function simpleGenerator() {
+	return { generate({ changelogs, version }) {
+		return [
+			`## ${version}`,
+			"",
+			...changelogs.flatMap((entry) => [
+				`### ${entry.title}`,
+				"",
+				entry.content,
+				""
+			])
+		].join("\n").trim();
+	} };
+}
+//#endregion
+export { simpleGenerator };

package/dist/index.d.mts

@@ -0,0 +1,31 @@
+import { _ as PackageOptions, a as TegamiOptions, b as PackageGraph, f as PackagePublishResult, g as DraftPlan, i as RegistryClient, m as PublishResult, n as LogGenerator, o as TegamiPlugin, p as PublishOptions, s as TegamiPluginOption, v as PackagePlan, x as WorkspacePackage } from "./types-DdIMewK9.mjs";
+
+//#region src/changelog/create.d.ts
+interface CreateChangelogOptions {
+  /** Start revision. Defaults to the latest reachable git tag, or all history if none exists. */
+  from?: string;
+  /** End revision. Defaults to HEAD. */
+  to?: string;
+}
+interface CreatedChangelog {
+  filename: string;
+  path: string;
+  packages: string[];
+  changes: number;
+}
+//#endregion
+//#region src/index.d.ts
+interface Tegami {
+  /** Create pending changelog files from git commit history. */
+  createChangelog(options?: CreateChangelogOptions): Promise<CreatedChangelog[]>;
+  /** Build an editable draft from pending changelog files. */
+  draft(): Promise<DraftPlan>;
+  /** Discover workspace packages and their dependency relationships. */
+  graph(): Promise<PackageGraph>;
+  /** Publish the current publish plan. */
+  publish(options?: PublishOptions): Promise<PublishResult>;
+}
+/** Create a Tegami project handle. */
+declare function tegami(options?: TegamiOptions): Tegami;
+//#endregion
+export { type CreateChangelogOptions, type CreatedChangelog, type DraftPlan, type LogGenerator, type PackageGraph, type PackageOptions, type PackagePlan, type PackagePublishResult, type PublishOptions, type PublishResult, type RegistryClient, Tegami, type TegamiOptions, type TegamiPlugin, type TegamiPluginOption, type WorkspacePackage, tegami };

package/dist/index.mjs

@@ -0,0 +1,569 @@
+import { r as isNodeError, t as PackageGraph } from "./workspace-B5_i21S0.mjs";
+import { cargo } from "./providers/cargo.mjs";
+import { a as planStoreSchema, i as changelogFrontmatterSchema, r as npm } from "./npm-BSE_dtB3.mjs";
+import { simpleGenerator } from "./generators/simple.mjs";
+import { mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
+import path, { basename, dirname, join, resolve } from "node:path";
+import { x } from "tinyexec";
+import { inc } from "semver";
+import { load } from "js-yaml";
+import { fromMarkdown } from "mdast-util-from-markdown";
+import { toMarkdown } from "mdast-util-to-markdown";
+//#region src/changelog/create.ts
+async function createChangelog(context, options = {}) {
+	const commits = await readConventionalCommits(context, options);
+	const groups = /* @__PURE__ */ new Map();
+	for (const commit of commits) {
+		const key = commit.packages.join("\0");
+		const group = groups.get(key);
+		if (group) group.push(commit);
+		else groups.set(key, [commit]);
+	}
+	const directory = join(context.cwd, context.changelogDir);
+	await mkdir(directory, { recursive: true });
+	const created = [];
+	const stamp = Date.now().toString(36);
+	for (const [key, changes] of groups) {
+		const packages = key ? key.split("\0") : [];
+		const filename = `changes-${stamp}-${slugify(packages.join("-") || "workspace")}.md`;
+		const path = join(directory, filename);
+		await writeFile(path, renderChangelog(packages, changes));
+		created.push({
+			filename,
+			path,
+			packages,
+			changes: changes.length
+		});
+	}
+	return created;
+}
+async function readConventionalCommits(context, options) {
+	const to = options.to ?? "HEAD";
+	const from = options.from ?? await latestTag(context.cwd);
+	const args = [
+		"log",
+		"--no-merges",
+		"--format=%H%x1f%s%x1f%b%x1e"
+	];
+	if (from) args.push(`${from}..${to}`);
+	else if (to !== "HEAD") args.push(to);
+	const result = await x("git", args, { nodeOptions: { cwd: context.cwd } });
+	if (result.exitCode !== 0) throw new Error(`Unable to read git commits: ${commandOutput(result).trim()}`);
+	const changes = [];
+	for (const record of result.stdout.split("")) {
+		const [hash, subject, body = ""] = record.replace(/^\n+|\n+$/g, "").split("");
+		if (!hash || !subject) continue;
+		const change = parseConventionalCommit(context, hash, subject, body);
+		if (change) changes.push(change);
+	}
+	return changes;
+}
+async function latestTag(cwd) {
+	const result = await x("git", [
+		"describe",
+		"--tags",
+		"--abbrev=0"
+	], { nodeOptions: { cwd } });
+	if (result.exitCode !== 0) return void 0;
+	return result.stdout.trim() || void 0;
+}
+function parseConventionalCommit(context, hash, subject, body) {
+	const match = /^(?<type>[a-zA-Z]+)(?:\((?<scope>[^)]+)\))?(?<breaking>!)?:\s*(?<title>.+)$/.exec(subject);
+	if (!match?.groups) return void 0;
+	const bump = commitTypeToBump(match.groups.type.toLowerCase(), Boolean(match.groups.breaking) || /^BREAKING(?:-| )CHANGE:/m.test(body));
+	if (!bump) return void 0;
+	return {
+		hash,
+		subject,
+		body: body.trim(),
+		packages: resolvePackages(context, match.groups.scope),
+		type: bump,
+		title: titleCase(match.groups.title)
+	};
+}
+function commitTypeToBump(type, breaking) {
+	if (breaking) return "major";
+	if (type === "feat") return "minor";
+	if (type === "fix" || type === "perf") return "patch";
+}
+function resolvePackages(context, scope) {
+	if (!scope) return [];
+	const packages = /* @__PURE__ */ new Set();
+	for (const item of scope.split(",")) {
+		const name = item.trim();
+		if (!name) continue;
+		if (context.graph.getByName(name).length > 0) {
+			packages.add(name);
+			continue;
+		}
+		const byShortName = context.graph.getPackages().filter((pkg) => pkg.name.split("/").at(-1) === name);
+		if (byShortName.length > 0) {
+			for (const pkg of byShortName) packages.add(pkg.name);
+			continue;
+		}
+		packages.add(name);
+	}
+	return Array.from(packages).sort();
+}
+function renderChangelog(packages, changes) {
+	return [
+		"---",
+		`packages: ${JSON.stringify(packages)}`,
+		"---",
+		"",
+		changes.map(renderChange).join("\n\n"),
+		""
+	].join("\n");
+}
+function renderChange(change) {
+	const heading = "#".repeat(change.type === "major" ? 1 : change.type === "minor" ? 2 : 3);
+	if (!change.body) return `${heading} ${change.title}`;
+	return `${heading} ${change.title}\n\n${change.body}`;
+}
+function titleCase(value) {
+	return value.charAt(0).toUpperCase() + value.slice(1);
+}
+function slugify(value) {
+	return value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+function commandOutput(result) {
+	return [result.stdout, result.stderr].filter(Boolean).join("\n");
+}
+//#endregion
+//#region src/context.ts
+async function createTegamiContext(options = {}) {
+	const cwd = resolve(options.cwd ?? process.cwd());
+	const graph = new PackageGraph();
+	const registryClients = /* @__PURE__ */ new Map();
+	const ctx = {
+		cwd,
+		changelogDir: options.changelogDir ?? ".tegami",
+		planPath: resolve(cwd, options.planPath ?? join(".tegami", "publish-plan.json")),
+		options,
+		plugins: resolvePlugins([
+			npm(options.npmClient),
+			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;
+		}
+	};
+	for (const plugin of ctx.plugins) await plugin.init?.call(ctx);
+	for (const plugin of ctx.plugins) await plugin.resolve?.call(ctx);
+	for (const plugin of ctx.plugins) {
+		const clients = await 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 = {
+	pre: 0,
+	default: 1,
+	post: 2
+};
+function resolvePlugins(plugins = []) {
+	return plugins.flat(Infinity).sort((a, b) => PLUGIN_ORDER[a.enforce ?? "default"] - PLUGIN_ORDER[b.enforce ?? "default"]);
+}
+//#endregion
+//#region src/utils/semver.ts
+function maxBump(a, b) {
+	if (a === "major" || b === "major") return "major";
+	if (a === "minor" || b === "minor") return "minor";
+	return "patch";
+}
+function bumpVersion(version, type) {
+	const next = inc(version, type);
+	if (!next) throw new Error(`Invalid semver version: ${version}`);
+	return next;
+}
+//#endregion
+//#region src/draft.ts
+var DraftPlan = class {
+	changelogs;
+	packages;
+	context;
+	#created = false;
+	constructor(changelogs, packages, context) {
+		this.changelogs = changelogs;
+		this.packages = packages;
+		this.context = context;
+	}
+	getPackageIds() {
+		return Array.from(this.packages.keys());
+	}
+	getPackage(id) {
+		return this.packages.get(id);
+	}
+	setPackage(id, plan = {}) {
+		this.packages.set(id, {
+			...plan,
+			changelogIds: plan.changelogIds ?? /* @__PURE__ */ new Set(),
+			publish: plan.publish ?? true,
+			type: plan.type ?? "patch"
+		});
+	}
+	deletePackage(id) {
+		return this.packages.delete(id);
+	}
+	getChangelogIds() {
+		return Array.from(this.changelogs.keys());
+	}
+	getChangelog(id) {
+		return this.changelogs.get(id);
+	}
+	setChangelog(id, entry) {
+		this.changelogs.set(id, entry);
+	}
+	deleteChangelog(id) {
+		return this.changelogs.delete(id);
+	}
+	/** Write the publish plan, update package versions, and consume changelog files. */
+	async createPublishPlan() {
+		this.assertEditable();
+		await this.assertPublishPlanFinished();
+		this.#created = true;
+		await this.applyVersionChanges();
+		const plan = {
+			id: `tegami-${Date.now().toString(36)}`,
+			createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+			changelogs: Object.fromEntries(Array.from(this.changelogs, ([id, entry]) => [id, {
+				filename: entry.filename,
+				subject: entry.subject,
+				packages: Array.from(entry.packages),
+				type: entry.type,
+				title: entry.title,
+				content: entry.content
+			}])),
+			packages: Object.fromEntries(this.packages)
+		};
+		await mkdir(dirname(this.context.planPath), { recursive: true });
+		await writeFile(this.context.planPath, planStoreSchema.encode(plan));
+		await this.removeConsumedChangelogs();
+	}
+	async assertPublishPlanFinished() {
+		const content = await readFile(this.context.planPath, "utf8").catch(() => void 0);
+		if (!content) return;
+		const parsed = planStoreSchema.safeDecode(content);
+		if (!parsed.success) return;
+		const status = await publishPlanStatus(this.context, parsed.data);
+		if (status.state === "success") return;
+		const message = `Publish plan already exists at ${this.context.planPath} and is ${status.state}. Publish it before creating a new plan.`;
+		throw new Error(status.error ? `${message}\n${status.error}` : message);
+	}
+	async applyVersionChanges() {
+		const { graph } = this.context;
+		const updatedPackages = /* @__PURE__ */ new Map();
+		const writes = [];
+		for (const [id, plan] of this.packages) {
+			const pkg = graph.get(id);
+			if (!pkg) continue;
+			updatedPackages.set(id, {
+				plan,
+				version: bumpVersion(pkg.version, plan.type)
+			});
+		}
+		for (const pkg of graph.getPackages()) {
+			const updated = updatedPackages.get(pkg.id);
+			for (const [id, updatedDep] of updatedPackages) {
+				const target = graph.get(id);
+				if (target) await pkg.updateDependency?.(target, updatedDep.version, this.context);
+			}
+			if (updated) {
+				pkg.setVersion?.(updated.version);
+				writes.push(this.appendChangelog(pkg, updated.plan));
+			}
+			const write = pkg.write?.();
+			if (write) writes.push(write);
+		}
+		await Promise.all(writes);
+	}
+	async removeConsumedChangelogs() {
+		const writes = [];
+		for (const entry of this.changelogs.values()) {
+			const file = path.resolve(this.context.cwd, this.context.changelogDir, entry.filename);
+			writes.push(rm(file, { force: true }));
+		}
+		await Promise.all(writes);
+	}
+	assertEditable() {
+		if (this.#created) throw new Error("This draft has already created a publish plan.");
+	}
+	async appendChangelog(pkg, plan) {
+		if (plan.changelogIds.size === 0) return;
+		const { generator = simpleGenerator() } = this.context.options;
+		const changelogs = [];
+		for (const id of plan.changelogIds) {
+			const entry = this.changelogs.get(id);
+			if (entry) changelogs.push(entry);
+		}
+		const generated = await generator.generate.call(this.context, {
+			packageName: pkg.name,
+			version: pkg.version,
+			changelogs
+		});
+		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 createPublishPlan} but for `await using` syntax */
+	async [Symbol.asyncDispose]() {
+		return this.createPublishPlan();
+	}
+};
+async function publishPlanStatus(context, plan) {
+	for (const [id, pkgPlan] of Object.entries(plan.packages)) {
+		const pkg = context.graph.get(id);
+		if (!pkg || !pkgPlan.publish) continue;
+		if (!await context.getRegistryClient(pkg).packageVersionExists(pkg, pkg.version)) return { state: "pending" };
+	}
+	return { state: "success" };
+}
+function createDraftPlan(changelogs, context) {
+	const changelogMap = /* @__PURE__ */ new Map();
+	const byPackage = /* @__PURE__ */ new Map();
+	for (const entry of changelogs) {
+		changelogMap.set(entry.id, entry);
+		for (const requestedPackage of entry.packages) for (const pkg of context.graph.getByName(requestedPackage)) {
+			let entries = byPackage.get(pkg);
+			if (!entries) {
+				entries = [];
+				byPackage.set(pkg, entries);
+			}
+			entries.push(entry);
+		}
+	}
+	const packages = /* @__PURE__ */ new Map();
+	for (const [pkg, entries] of byPackage.entries()) {
+		const plan = createPackagePlan(pkg, entries, context);
+		if (plan) packages.set(pkg.id, plan);
+	}
+	return new DraftPlan(changelogMap, packages, context);
+}
+function createPackagePlan(pkg, entries, context) {
+	if (entries.length === 0) return null;
+	const packageOptions = context.options.packages?.[pkg.id] ?? context.options.packages?.[pkg.name] ?? {};
+	let type = entries[0].type;
+	const changelogIds = /* @__PURE__ */ new Set();
+	for (const entry of entries) {
+		changelogIds.add(entry.id);
+		type = maxBump(type, entry.type);
+	}
+	return {
+		type,
+		changelogIds,
+		distTag: packageOptions.distTag ?? pkg.distTag,
+		publish: packageOptions.publish ?? pkg.publish
+	};
+}
+//#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 readChangelogEntries(cwd, changelogDir) {
+	const directory = resolve(cwd, changelogDir);
+	const files = await readdir(directory).catch((error) => {
+		if (isNodeError(error) && error.code === "ENOENT") return [];
+		throw error;
+	});
+	const entries = [];
+	for (const file of files.sort()) {
+		if (!file.endsWith(".md")) continue;
+		const filePath = join(directory, file);
+		const content = await readFile(filePath, "utf8");
+		entries.push(...parseChangelogFile(filePath, content));
+	}
+	return entries;
+}
+/** Parse one changelog markdown file into release entries. */
+function parseChangelogFile(file, content) {
+	const parsed = frontmatter(content);
+	const data = changelogFrontmatterSchema.parse(parsed.data);
+	const tree = fromMarkdown(parsed.content);
+	const entries = [];
+	for (const section of getHeadingSections(tree)) {
+		const type = headingToBump(section.heading.depth);
+		if (!type) continue;
+		const filename = basename(file);
+		entries.push({
+			id: `${filename}:${entries.length}`,
+			filename,
+			subject: data.subject,
+			packages: new Set(data.packages),
+			type,
+			title: headingText(section.heading),
+			content: sectionToMarkdown(section.children)
+		});
+	}
+	return entries;
+}
+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 headingText(heading) {
+	return heading.children.map((child) => nodeText(child)).join("").trim();
+}
+function nodeText(node) {
+	if ("value" in node && typeof node.value === "string") return node.value;
+	if ("children" in node && Array.isArray(node.children)) return node.children.map((child) => nodeText(child)).join("");
+	return "";
+}
+function sectionToMarkdown(children) {
+	if (children.length === 0) return "";
+	return toMarkdown({
+		type: "root",
+		children
+	}, {
+		bullet: "-",
+		fence: "`"
+	}).trim();
+}
+function headingToBump(depth) {
+	if (depth === 1) return "major";
+	if (depth === 2) return "minor";
+	if (depth === 3) return "patch";
+}
+//#endregion
+//#region src/publish.ts
+async function publishFromPlan(context, plan, options) {
+	const packages = await publishStoredPlan(plan, context, options);
+	return {
+		planPath: context.planPath,
+		state: packages.some((pkg) => pkg.state === "failed") ? "failed" : "success",
+		packages,
+		_rawPlan: plan
+	};
+}
+async function publishStoredPlan(store, context, { dryRun = false }) {
+	const results = [];
+	for (const [id, plan] of Object.entries(store.packages)) {
+		if (!plan.publish) continue;
+		const pkg = context.graph.get(id);
+		if (!pkg) continue;
+		const changelogs = [];
+		for (const id of plan.changelogIds) {
+			const entry = store.changelogs[id];
+			if (entry) changelogs.push({
+				...entry,
+				packages: new Set(entry.packages),
+				id
+			});
+		}
+		if (!dryRun) {
+			if (await context.getRegistryClient(pkg).packageVersionExists(pkg, pkg.version)) {
+				results.push({
+					id: pkg.id,
+					name: pkg.name,
+					version: pkg.version,
+					distTag: plan.distTag,
+					state: "success",
+					changelogs
+				});
+				continue;
+			}
+		}
+		try {
+			if (!dryRun) await context.getRegistryClient(pkg).publish(pkg, { distTag: plan.distTag });
+			results.push({
+				id: pkg.id,
+				name: pkg.name,
+				version: pkg.version,
+				distTag: plan.distTag,
+				state: "success",
+				changelogs
+			});
+		} catch (error) {
+			results.push({
+				id: pkg.id,
+				name: pkg.name,
+				version: pkg.version,
+				distTag: plan.distTag,
+				changelogs,
+				state: "failed",
+				error: error instanceof Error ? error.message : String(error)
+			});
+		}
+	}
+	return results;
+}
+//#endregion
+//#region src/index.ts
+/** Create a Tegami project handle. */
+function tegami(options = {}) {
+	return {
+		async createChangelog(createOptions = {}) {
+			return createChangelog(await createTegamiContext(options), createOptions);
+		},
+		async draft() {
+			const context = await createTegamiContext(options);
+			let plan = createDraftPlan(await readChangelogEntries(context.cwd, context.changelogDir), context);
+			for (const plugin of context.plugins) plan = await plugin.initPlan?.call(context, plan) ?? plan;
+			return plan;
+		},
+		async graph() {
+			return (await createTegamiContext(options)).graph;
+		},
+		async publish(publishOptions = {}) {
+			const context = await createTegamiContext(options);
+			const parsed = await readFile(context.planPath, "utf8").then((content) => planStoreSchema.decode(content)).catch((error) => {
+				if (isNodeError(error) && error.code === "ENOENT") return void 0;
+				throw error;
+			});
+			if (parsed === void 0) throw new Error(`No publish plan found at ${context.planPath}.`);
+			let result = await publishFromPlan(context, parsed, publishOptions);
+			const publishCtx = {
+				...context,
+				publishOptions
+			};
+			for (const plugin of context.plugins) result = await plugin.afterPublish?.call(publishCtx, result) ?? result;
+			return result;
+		}
+	};
+}
+//#endregion
+export { tegami };