tegami 0.1.1 → 0.1.4

package/dist/checks-Cwz-Ezkq.js

@@ -0,0 +1,277 @@
+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 { 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.
+* @see https://www.conventionalcommits.org/en/v1.0.0/
+*/
+const CONVENTIONAL_COMMIT_HEADER = /^(?<type>\w+)(?:\((?<scope>[^)]*)\))?(?<breaking>!)?: (?<title>.+)$/;
+const BREAKING_CHANGE_FOOTER = /^BREAKING[ -]CHANGE:/m;
+/** Parse conventional commits and resolve scopes against the workspace graph. */
+function createConventionalCommitParser(graph) {
+	const byShortName = /* @__PURE__ */ new Map();
+	for (const pkg of graph.getPackages()) {
+		const slash = pkg.name.lastIndexOf("/");
+		const short = slash >= 0 ? pkg.name.slice(slash + 1) : pkg.name;
+		const names = byShortName.get(short);
+		if (names) names.push(pkg.name);
+		else byShortName.set(short, [pkg.name]);
+	}
+	function resolvePackages(scope) {
+		if (!scope) return [];
+		const packages = /* @__PURE__ */ new Set();
+		for (const item of scope.split(",")) {
+			const name = item.trim();
+			if (!name) continue;
+			const direct = graph.getByName(name);
+			if (direct.length > 0) {
+				for (const pkg of direct) packages.add(pkg.name);
+				continue;
+			}
+			const byShort = byShortName.get(name);
+			if (byShort) {
+				for (const pkgName of byShort) packages.add(pkgName);
+				continue;
+			}
+			packages.add(name);
+		}
+		return Array.from(packages);
+	}
+	return function parseConventionalCommit(subject, body = "") {
+		const match = CONVENTIONAL_COMMIT_HEADER.exec(subject.trim());
+		if (!match?.groups) return;
+		const { type, scope, breaking, title } = match.groups;
+		if (!type || !title) return;
+		const trimmedTitle = title.trim();
+		if (!trimmedTitle) return;
+		const trimmedScope = scope?.trim();
+		return {
+			type: type.toLowerCase(),
+			packages: resolvePackages(trimmedScope || void 0),
+			breaking: Boolean(breaking) || BREAKING_CHANGE_FOOTER.test(body),
+			title: trimmedTitle
+		};
+	};
+}
+/** Map releasable conventional commit types to semver bumps (semantic-release defaults). */
+function conventionalCommitToBump(type, breaking) {
+	if (breaking) return "major";
+	switch (type) {
+		case "feat": return "minor";
+		case "fix":
+		case "perf":
+		case "revert": return "patch";
+		default: return;
+	}
+}
+//#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;
+	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 changelogs = Array.from(groups, ([key, changes], index) => {
+		const packageNames = key ? key.split("\0") : [];
+		let bumpType = "patch";
+		for (const change of changes) bumpType = maxBump(change.type, bumpType);
+		const packageBumpMap = Object.fromEntries(packageNames.map((name) => [name, bumpType]));
+		const packages = generateReplays(context.graph, packageBumpMap);
+		const content = renderChangelog({ packages }, changes.map((change) => {
+			const heading = "#".repeat(bumpDepth(change.type));
+			if (!change.body) return `${heading} ${change.title}`;
+			return `${heading} ${change.title}\n\n${change.body}`;
+		}).join("\n\n"));
+		return {
+			filename: changelogFilename(index),
+			content,
+			packages,
+			changes
+		};
+	});
+	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;
+}
+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 execFailure(`Unable to read git commits from ${from ?? "start"} to ${to}`, result);
+	const parseCommit = createConventionalCommitParser(context.graph);
+	const changes = [];
+	for (const record of result.stdout.split("")) {
+		const [hash, subject, body = ""] = record.replace(/^\n+|\n+$/g, "").split("");
+		if (!hash || !subject) continue;
+		const parsed = parseCommit(subject, body);
+		if (!parsed) continue;
+		const bump = conventionalCommitToBump(parsed.type, parsed.breaking);
+		if (!bump) continue;
+		changes.push({
+			hash,
+			subject,
+			body: body.trim(),
+			packages: parsed.packages,
+			type: bump,
+			title: parsed.title.charAt(0).toUpperCase() + parsed.title.slice(1)
+		});
+	}
+	return changes;
+}
+async function latestTag(cwd) {
+	const result = await x("git", [
+		"describe",
+		"--tags",
+		"--abbrev=0"
+	], { nodeOptions: { cwd } });
+	if (result.exitCode !== 0) return;
+	return result.stdout.trim() || void 0;
+}
+function generateReplays(graph, base) {
+	const packages = { ...base };
+	for (const [ref, type] of Object.entries(base)) {
+		const resolved = graph.getByName(ref);
+		for (const pkg of resolved) {
+			const plan = pkg.initPlan();
+			pkg.configurePlan(plan, graph.getPackageGroup(pkg.id));
+			const prerelease = semver.prerelease(pkg.version)?.[0];
+			const targetPrerelease = plan.prerelease;
+			if (targetPrerelease && !prerelease || targetPrerelease && prerelease && targetPrerelease === prerelease) packages[pkg.id] = {
+				type,
+				replay: [`exit prerelease: ${pkg.name}`]
+			};
+		}
+	}
+	return packages;
+}
+function changelogFilename(disambiguator = 0) {
+	const date = /* @__PURE__ */ new Date();
+	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 };

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-Diwnh8Tn.js";
+import { k as DraftPlan, t as Awaitable, v as Tegami, w as PublishResult } from "../types-BXk2fMqa.js";
 import { Command } from "commander";
 
 //#region src/cli/index.d.ts