tegami 0.2.1 → 1.0.0-beta.1

package/dist/cli/index.d.ts

@@ -1,4 +1,5 @@
-import { O as Draft, S as PublishPlan, g as Tegami, t as Awaitable } from "../types-DEaKjB3O.js";
+import { p as PublishPlan, t as Awaitable, w as Draft } from "../types-BbDtPn8I.js";
+import { n as Tegami } from "../index-CH40idD8.js";
 import { Command } from "commander";
 
 //#region src/cli/index.d.ts

package/dist/cli/index.js

@@ -1,9 +1,9 @@
-import { r as formatNpmDistTag } from "../semver-C4vJ4SK8.js";
-import { a as renderChangelog, n as generateFromCommits, r as generateReplays, t as changelogFilename } from "../generate-L7ucD7ic.js";
+import { r as formatNpmDistTag } from "../semver-EKJ8yK5U.js";
+import { i as renderChangelog, n as generateFromCommits, t as changelogFilename } from "../generate-BqkwhjRy.js";
 import { a as isCI, n as execFailure, r as handlePluginError, t as CancelledError } from "../error-DNy8R5ue.js";
 import { c as updateIssueComment, i as findIssueCommentByPrefix, o as getPullRequest, t as createIssueComment } from "../api-D-jf_8xY.js";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
-import path, { basename, isAbsolute, join, normalize, relative } from "node:path";
+import path, { basename, join, relative } from "node:path";
 import { x } from "tinyexec";
 import z from "zod";
 import { resolveCommand } from "package-manager-detector";
@@ -15,35 +15,32 @@ async function getChangedPackages(graph, cwd) {
 }
 async function getChangedFilePaths(cwd) {
 	const files = /* @__PURE__ */ new Set();
-	for (const args of [["diff", "--name-only"], [
+	await Promise.all([["diff", "--name-only"], [
 		"diff",
 		"--cached",
 		"--name-only"
-	]]) await addGitOutput(files, cwd, args);
+	]].map(async (args) => {
+		const result = await x("git", args, { nodeOptions: { cwd } });
+		if (result.exitCode !== 0) return;
+		for (const line of result.stdout.split("\n")) {
+			const trimmed = line.trim();
+			if (trimmed) files.add(trimmed);
+		}
+	}));
 	return Array.from(files);
 }
 function resolveChangedPackages(graph, files, cwd) {
 	const packages = [...graph.getPackages()].sort((a, b) => b.path.length - a.path.length);
 	const matched = /* @__PURE__ */ new Map();
-	for (const file of files) for (const pkg of packages) if (isUnderDir(file, pkg.path, cwd)) {
-		matched.set(pkg.id, pkg);
-		break;
+	for (const file of files) {
+		const fullPath = join(cwd, file);
+		for (const pkg of packages) if (!relative(pkg.path, fullPath).startsWith("..")) {
+			matched.set(pkg.id, pkg);
+			break;
+		}
 	}
 	return [...matched.values()];
 }
-function isUnderDir(file, dir, cwd) {
-	const absolute = join(cwd, file);
-	const rel = relative(normalize(dir), absolute);
-	return rel === "" || !rel.startsWith("..") && !isAbsolute(rel);
-}
-async function addGitOutput(files, cwd, args) {
-	const result = await x("git", args, { nodeOptions: { cwd } });
-	if (result.exitCode !== 0) return;
-	for (const line of result.stdout.split("\n")) {
-		const trimmed = line.trim();
-		if (trimmed) files.add(trimmed);
-	}
-}
 //#endregion
 //#region src/cli/changelog.ts
 async function runChangelogTui(tegami) {
@@ -81,11 +78,10 @@ async function runChangelogTui(tegami) {
 		}
 	});
 	if (isCancel(message)) throw new CancelledError();
-	const packages = generateReplays(context.graph, packageBumpMap);
 	await persistChangelogs(context, [{
 		filename: changelogFilename(),
-		content: renderChangelog({ packages }, `## ${message.trim()}`),
-		packages
+		content: renderChangelog({ packages: packageBumpMap }, `## ${message.trim()}`),
+		packages: packageBumpMap
 	}]);
 }
 async function persistChangelogs(context, entries, emptyMessage = "No changelogs created.") {
@@ -291,12 +287,14 @@ async function buildPrPreview(context, draft, options = {}) {
 	const pendingPackages = [];
 	for (const pkg of context.graph.getPackages()) {
 		const plan = draft.getPackageDraft(pkg.id);
-		if (!plan || plan.bumpVersion(pkg) === pkg.version) continue;
+		if (!plan) continue;
+		const bumped = plan.bumpVersion(pkg);
+		if (!bumped || !pkg.version || bumped === pkg.version) continue;
 		pendingPackages.push({
 			name: pkg.name,
 			type: plan.type ?? "—",
 			from: pkg.version,
-			to: plan.bumpVersion(pkg),
+			to: bumped,
 			distTag: plan.npm?.distTag
 		});
 	}
@@ -307,11 +305,8 @@ async function buildPrPreview(context, draft, options = {}) {
 		lines.push("");
 	}
 	if (prChangelogs.length > 0) {
-		lines.push("#### Changelogs in this PR", "");
-		for (const entry of prChangelogs) {
-			const title = entry.sections[0]?.title ?? entry.filename;
-			lines.push(`- \`${entry.filename}\` — ${title}`);
-		}
+		lines.push("#### Changelogs in this PR", "", "| Changelog | Title |", "| --- | --- |");
+		for (const entry of prChangelogs) for (const section of entry.sections) lines.push(`| \`${entry.filename}\` | ${section.title} |`);
 		lines.push("");
 	} else if (pendingPackages.length === 0) lines.push("#### No changelogs yet", "", "This PR has no pending changelog files. If your changes require a release, add a changelog before merging.", "");
 	else if (prChangelogFiles.size === 0) lines.push("This PR does not add changelog files. Pending changelogs from other branches are included in the preview above.", "");
@@ -511,8 +506,10 @@ async function versionPackages(tegami, options) {
 	const lines = [];
 	for (const pkg of context.graph.getPackages()) {
 		const plan = draft.getPackageDraft(pkg.id);
-		if (!plan || plan.bumpVersion(pkg) === pkg.version) continue;
-		lines.push(`${pkg.id}: ${pkg.version} → ${plan.bumpVersion(pkg)} (${plan.changelogs?.length ?? 0} changelogs)`);
+		if (!plan) continue;
+		const bumped = plan.bumpVersion(pkg);
+		if (!pkg.version || !bumped || bumped === pkg.version) continue;
+		lines.push(`${pkg.id}: ${pkg.version} → ${bumped} (${plan.changelogs?.length ?? 0} changelogs)`);
 		if (plan.bumpReasons) for (const reason of plan.bumpReasons) lines.push(`  - ${reason}`);
 	}
 	note(lines.join("\n"), "Release plan");

package/dist/{generate-L7ucD7ic.js → generate-BqkwhjRy.js}

@@ -1,8 +1,6 @@
-import { a as maxBump, t as bumpDepth } from "./semver-C4vJ4SK8.js";
+import { a as maxBump, t as bumpDepth } from "./semver-EKJ8yK5U.js";
 import { n as execFailure } from "./error-DNy8R5ue.js";
-import { t as bumpTypeSchema } from "./schemas-BdUlXfSu.js";
 import { x } from "tinyexec";
-import * as semver from "semver";
 import z from "zod";
 import { dump } from "js-yaml";
 //#region src/utils/conventional-commit.ts
@@ -71,6 +69,11 @@ function conventionalCommitToBump(type, breaking) {
 }
 //#endregion
 //#region src/changelog/shared.ts
+const bumpTypeSchema = z.enum([
+	"major",
+	"minor",
+	"patch"
+]);
 const changelogPackageConfigSchema = z.object({
 	type: bumpTypeSchema.optional(),
 	replay: z.array(z.string().min(1)).optional()
@@ -109,8 +112,7 @@ async function generateFromCommits(context, { from, to } = {}) {
 		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 content = renderChangelog({ packages: packageBumpMap }, changes.map((change) => {
 			const heading = "#".repeat(bumpDepth(change.type));
 			if (!change.body) return `${heading} ${change.title}`;
 			return `${heading} ${change.title}\n\n${change.body}`;
@@ -118,7 +120,7 @@ async function generateFromCommits(context, { from, to } = {}) {
 		return {
 			filename: changelogFilename(index),
 			content,
-			packages,
+			packages: packageBumpMap,
 			changes
 		};
 	});
@@ -164,26 +166,9 @@ async function latestTag(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.initDraft();
-			pkg.configureDraft(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
-export { renderChangelog as a, changelogFrontmatterSchema as i, generateFromCommits as n, generateReplays as r, changelogFilename as t };
+export { renderChangelog as i, generateFromCommits as n, changelogFrontmatterSchema as r, changelogFilename as t };

package/dist/generators/simple.d.ts

@@ -1,4 +1,4 @@
-import { r as LogGenerator } from "../types-DEaKjB3O.js";
+import { r as LogGenerator } from "../types-BbDtPn8I.js";
 
 //#region src/generators/simple.d.ts
 declare function simpleGenerator(): LogGenerator;

package/dist/generators/simple.js

@@ -1,4 +1,4 @@
-import { i as formatPackageVersion } from "../semver-C4vJ4SK8.js";
+import { i as formatPackageVersion } from "../semver-EKJ8yK5U.js";
 //#region src/generators/simple.ts
 function simpleGenerator() {
 	return { generate({ pkg, packageDraft }) {

package/dist/{graph-DrzluXw8.js → graph-gThXu8Cz.js}

@@ -1,4 +1,4 @@
-import { n as bumpVersion } from "./semver-C4vJ4SK8.js";
+import { n as bumpVersion } from "./semver-EKJ8yK5U.js";
 //#region src/graph.ts
 /** Package discovered in the workspace. */
 var WorkspacePackage = class {
@@ -16,18 +16,14 @@ var WorkspacePackage = class {
 	/** create the initial draft. */
 	initDraft() {
 		return { bumpVersion(pkg) {
+			if (!pkg.version) return;
 			return bumpVersion(pkg.version, this.type, this.prerelease);
 		} };
 	}
 	/** configure an initial draft to match script-level configs. */
 	configureDraft(draft, group) {
-		const groupOptions = group?.options;
-		const { prerelease = groupOptions?.prerelease, npm: { distTag = groupOptions?.npm?.distTag } = {} } = this.opts;
+		const { prerelease = group?.options?.prerelease } = this.opts;
 		if (prerelease !== void 0) draft.prerelease = prerelease;
-		if (distTag) {
-			draft.npm ??= {};
-			draft.npm.distTag = distTag;
-		}
 	}
 };
 /** Dependency graph for discovered workspace packages. */

package/dist/index-CH40idD8.d.ts

@@ -0,0 +1,64 @@
+import { D as ChangelogPackageConfig, O as BumpType, b as TegamiContext, f as PublishOptions, o as TegamiOptions, p as PublishPlan, w as Draft, x as PackageGraph } from "./types-BbDtPn8I.js";
+
+//#region src/changelog/generate.d.ts
+interface GenerateFromCommitsOptions {
+  /** 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 CommitChangelog {
+  filename: string;
+  content: string;
+  packages: Record<string, BumpType | ChangelogPackageConfig>;
+  changes: CommitChange[];
+}
+interface CommitChange {
+  hash: string;
+  subject: string;
+  body: string;
+  packages: string[];
+  type: BumpType;
+  title: string;
+}
+//#endregion
+//#region src/index.d.ts
+interface GenerateChangelogOptions extends GenerateFromCommitsOptions {
+  /**
+   * Write changelog files to disk.
+   *
+   * @default true
+   */
+  write?: boolean;
+}
+interface Tegami {
+  /** Create pending changelog files from git commit history. */
+  generateChangelog(options?: GenerateChangelogOptions): Promise<CommitChangelog[]>;
+  /** Build a draft from pending changelog files. */
+  draft(): Promise<Draft>;
+  /** Publish packages from the publish lock. */
+  publish(options?: PublishOptions): Promise<PublishPlan | "skipped">;
+  /**
+   * Check publish status.
+   *
+   * Prefer `publish()` over this if you are publishing packages, it will also check the publish status.
+   */
+  publishStatus(): Promise<"pending" | "success" | "idle">;
+  /** Remove the publish lock file after publishing has finished successfully. */
+  cleanup(): Promise<{
+    state: "removed";
+  } | {
+    state: "skipped";
+    reason: "no-plan" | "pending";
+  }>;
+  /** Internal APIs, do not use it unless you know what you are doing */
+  _internal: {
+    context(): Promise<TegamiContext>;
+    graph(): Promise<PackageGraph>;
+    options: TegamiOptions;
+  };
+}
+/** Create a Tegami project handle. */
+declare function tegami<const Groups extends string = string>(options?: TegamiOptions<Groups>): Tegami;
+//#endregion
+export { CommitChangelog as i, Tegami as n, tegami as r, GenerateChangelogOptions as t };

package/dist/index.d.ts

@@ -1,2 +1,3 @@
-import { A as PackageDraft, C as CommitChangelog, D as WorkspacePackage, E as PackageGroup, O as Draft, S as PublishPlan, T as PackageGraph, _ as tegami, a as PublishPreflight, b as PackagePublishResult, c as TegamiPluginOption, g as Tegami, h as GenerateChangelogOptions, i as PackageOptions, k as DraftPolicy, n as GroupOptions, o as TegamiOptions, r as LogGenerator, s as TegamiPlugin, v as PublishLock, x as PublishOptions, y as PackagePublishPlan } from "./types-DEaKjB3O.js";
+import { C as WorkspacePackage, E as PackageDraft, S as PackageGroup, T as DraftPolicy, a as PublishPreflight, c as TegamiPluginOption, d as PackagePublishResult, f as PublishOptions, i as PackageOptions, l as PublishLock, n as GroupOptions, o as TegamiOptions, p as PublishPlan, r as LogGenerator, s as TegamiPlugin, u as PackagePublishPlan, w as Draft, x as PackageGraph } from "./types-BbDtPn8I.js";
+import { i as CommitChangelog, n as Tegami, r as tegami, t as GenerateChangelogOptions } from "./index-CH40idD8.js";
 export { type CommitChangelog, type Draft, type DraftPolicy, GenerateChangelogOptions, type GroupOptions, type LogGenerator, type PackageDraft, type PackageGraph, type PackageGroup, type PackageOptions, type PackagePublishPlan, type PackagePublishResult, type PublishLock, type PublishOptions, type PublishPlan, type PublishPreflight, Tegami, type TegamiOptions, type TegamiPlugin, type TegamiPluginOption, type WorkspacePackage, tegami };

package/dist/index.js

@@ -1,13 +1,13 @@
-import { a as maxBump } from "./semver-C4vJ4SK8.js";
-import { i as changelogFrontmatterSchema, n as generateFromCommits } from "./generate-L7ucD7ic.js";
+import { a as maxBump } from "./semver-EKJ8yK5U.js";
+import { n as generateFromCommits, r as changelogFrontmatterSchema } from "./generate-BqkwhjRy.js";
 import { r as handlePluginError } from "./error-DNy8R5ue.js";
-import { t as PackageGraph } from "./graph-DrzluXw8.js";
+import { t as PackageGraph } from "./graph-gThXu8Cz.js";
 import { cargo } from "./providers/cargo.js";
-import { npm } from "./providers/npm.js";
+import { n as npm } from "./npm-DqGyAsdo.js";
 import { simpleGenerator } from "./generators/simple.js";
 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 * as semver$1 from "semver";
 import z from "zod";
 import { dump, load, visit } from "js-yaml";
 import { fromMarkdown } from "mdast-util-from-markdown";
@@ -36,12 +36,18 @@ async function createTegamiContext(options = {}) {
 		return (pkg) => pkg.name === pattern || pkg.id === pattern;
 	});
 	for (const [name, groupOptions] of Object.entries(options.groups ?? {})) graph.registerGroup(name, groupOptions);
+	let getPackageOptions;
+	if (typeof options.packages === "function") getPackageOptions = options.packages;
+	else if (options.packages) {
+		const packages = options.packages;
+		getPackageOptions = (pkg) => packages[pkg.id] ?? packages[pkg.name];
+	}
 	for (const pkg of graph.getPackages()) {
-		if (ignoreMatchers?.length && ignoreMatchers.some((matcher) => matcher(pkg))) {
+		if (ignoreMatchers && ignoreMatchers.some((matcher) => matcher(pkg))) {
 			graph.delete(pkg.id);
 			continue;
 		}
-		const packageOptions = options.packages?.[pkg.id] ?? options.packages?.[pkg.name];
+		const packageOptions = getPackageOptions?.(pkg);
 		if (!packageOptions) continue;
 		pkg.setPackageOptions(packageOptions);
 		if (packageOptions.group) graph.addGroupMember(packageOptions.group, pkg.id);
@@ -329,6 +335,7 @@ var Draft = class {
 		}
 		return false;
 	}
+	/** get all changelogs, note that this includes replay-only changelogs, as long as they are in the `.tegami` folder. */
 	getChangelogs() {
 		return Array.from(this.changelogs.values());
 	}
@@ -375,20 +382,23 @@ var Draft = class {
 	/** 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()
-		});
+		const changelogs = /* @__PURE__ */ new Set();
 		for (const pkg of this.context.graph.getPackages()) {
 			const draft = this.getPackageDraft(pkg.id);
 			const snapshot = snapshots.get(pkg.id);
+			if (!snapshot) continue;
+			for (const entry of draft?.changelogs ?? []) changelogs.add(entry);
 			lock.write("core:packages", {
 				id: pkg.id,
-				updated: draft !== void 0 && (snapshot === void 0 || snapshot.version !== pkg.version),
+				updated: draft !== void 0 && snapshot.version !== pkg.version,
 				changelogIds: draft?.changelogs?.map((entry) => entry.id)
 			});
 		}
+		for (const entry of changelogs) lock.write("core:changelogs", {
+			v: "0.0.0",
+			filename: entry.filename,
+			content: entry.getRawContent()
+		});
 		for (const plugin of this.context.plugins) await handlePluginError(plugin, "initPublishLock", () => plugin.initPublishLock?.call(this.context, {
 			lock,
 			draft: this
@@ -410,10 +420,15 @@ var Draft = class {
 	applyReplays(snapshots) {
 		const updated = /* @__PURE__ */ new Map();
 		const { graph } = this.context;
+		const defaultReplays = (name) => {
+			const replay = [];
+			for (const pkg of graph.getByName(name)) if (this.packages.get(pkg.id)?.prerelease) replay.push(`exit prerelease: ${pkg.id}`);
+			return replay;
+		};
 		const isMatch = (condition) => {
 			if (condition.type === "on-exit-prerelease") return graph.getByName(condition.name).some((pkg) => {
 				const previous = snapshots.get(pkg.id);
-				return previous && semver.inc(previous.version, "release") === pkg.version;
+				return previous?.version && semver$1.inc(previous.version, "release") === pkg.version;
 			});
 			return graph.getByName(condition.name).some((pkg) => pkg.version === condition.version);
 		};
@@ -421,8 +436,10 @@ var Draft = class {
 			const updatedPackages = /* @__PURE__ */ new Map();
 			const matchedNames = /* @__PURE__ */ new Set();
 			for (const [name, config] of entry.packages) {
-				if (!config.replay || config.replay.length === 0) continue;
-				const replay = config.replay.filter((item) => {
+				let replay = config.replay;
+				if (config.type) replay ??= defaultReplays(name);
+				if (!replay || replay.length === 0) continue;
+				replay = replay.filter((item) => {
 					const condition = parseReplayCondition(item);
 					if (condition && isMatch(condition)) {
 						matchedNames.add(name);
@@ -545,47 +562,35 @@ async function runPublishPlan(context, plan) {
 		const packagePlan = plan.packages.get(pkg.id);
 		if (!packagePlan) return;
 		packagePlan.publishResult = publishResult;
+		if (publishResult.type === "skipped") return;
 		for (const plugin of context.plugins) await handlePluginError(plugin, "afterPublish", () => plugin.afterPublish?.call(context, {
 			pkg,
 			plan
 		}));
 	};
-	for (const id of resolvePublishTargets(plan)) {
+	publishLoop: 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) if (await handlePluginError(plugin, "willPublish", () => plugin.willPublish?.call(context, { pkg })) === false) continue publishLoop;
 		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;
+				continue publishLoop;
 			}
 		}
-		if (!published) await onPublishResult(pkg, {
+		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 packagePlan of plan.packages.values()) packagePlan.publishResult ??= { type: "skipped" };
 	for (const plugin of context.plugins) await handlePluginError(plugin, "afterPublishAll", () => plugin.afterPublishAll?.call(context, { plan }));
 }
 async function runPreflights(context, plan) {