tegami 0.0.0 → 0.0.1

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/cli/index.d.mts

@@ -0,0 +1,12 @@
+import { _ as PublishResult, n as Awaitable, y as DraftPlan } from "../context-CC36jtz1.mjs";
+import { t as Tegami } from "../index-DJ7YxxdM.mjs";
+import { Command } from "commander";
+
+//#region src/cli/index.d.ts
+interface TegamiCLIOptions {
+  version?: () => Awaitable<DraftPlan>;
+  publish?: () => Awaitable<PublishResult>;
+}
+declare function createCli(tegami: Tegami, options?: TegamiCLIOptions): Command;
+//#endregion
+export { TegamiCLIOptions, createCli };

package/dist/cli/index.mjs

@@ -0,0 +1,199 @@
+import { t as isCI } from "../constants-B9qjNfvr.mjs";
+import { mkdir, writeFile } from "node:fs/promises";
+import { join, resolve } 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, 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, {
+		...commandOptions,
+		cli: options
+	})));
+	return program;
+}
+async function createChangelogs(tegami, _options) {
+	intro("Create changelogs");
+	const { graph, cwd, changelogDir } = await tegami._internal.context();
+	const packages = 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 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()));
+	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 draft = customVersion ? await customVersion() : await tegami.draft();
+	const packageIds = draft.getPackageIds();
+	if (packageIds.length === 0) {
+		note("No pending changelog entries matched workspace packages.", "Nothing to version");
+		outro("No versions changed.");
+		return;
+	}
+	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 context = await tegami._internal.context();
+	for (const plugin of context.plugins) try {
+		await plugin.cli?.afterVersion?.call(context, draft);
+	} catch (error) {
+		const details = error instanceof Error ? error.message : String(error);
+		throw new Error(`Plugin "${plugin.name}" failed during afterVersion:\n${details}`, { cause: error });
+	}
+	outro("Publish plan created.");
+}
+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") {
+		s.stop(dryRun ? "No publish plan to validate" : "Nothing to publish");
+		outro(`No publishable packages were found in ${result.planPath}.`);
+		return;
+	}
+	s.stop(dryRun ? "Publish plan validated" : "Publish complete");
+	note(result.packages.map((pkg) => {
+		const tag = pkg.distTag ? ` (${pkg.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.");
+}
+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) 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 });
+		}
+		await action();
+	} catch (error) {
+		process.exitCode = 1;
+		if (error instanceof CancelledError) {
+			outro(error.message);
+			return;
+		}
+		note(error instanceof Error ? error.message : String(error), "Error");
+		outro("Command failed.");
+	}
+}
+//#endregion
+export { createCli };

package/dist/constants-B9qjNfvr.mjs

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

package/dist/{types-DdIMewK9.d.mts → context-CC36jtz1.d.mts}

@@ -2,48 +2,6 @@ import * as semver from "semver";
 import { SemVer } from "semver";
 import { z } from "zod";
 
-//#region src/workspace.d.ts
-/** Package discovered in the workspace. */
-declare abstract class WorkspacePackage {
-  abstract readonly name: string;
-  abstract readonly path: string;
-  abstract readonly manager: string;
-  abstract readonly version: string;
-  abstract readonly publish: boolean;
-  get distTag(): string | undefined;
-  get id(): string;
-  setVersion?(version: string): void;
-  updateDependency?(target: WorkspacePackage, version: string, context: TegamiContext): Awaitable<void>;
-  write?(): Awaitable<void>;
-  protected updateRange(context: TegamiContext, spec: DependencySpec, next: semver.SemVer): Promise<DependencySpec>;
-}
-/** Dependency graph for discovered workspace packages. */
-declare class PackageGraph {
-  private readonly byId;
-  private readonly byName;
-  constructor(packages?: WorkspacePackage[]);
-  getPackages(): WorkspacePackage[];
-  /** Get a package by exact id. */
-  get(id: string): WorkspacePackage | undefined;
-  /** Get packages by id, or every package matching a name. */
-  getByName(nameOrId: string): WorkspacePackage[];
-  /** scan package into graph, if the package id already exists, replace the existing one in graph */
-  add(pkg: WorkspacePackage): void;
-  delete(pkg: WorkspacePackage): void;
-}
-//#endregion
-//#region src/context.d.ts
-interface TegamiContext {
-  cwd: string;
-  changelogDir: string;
-  planPath: string;
-  options: TegamiOptions;
-  plugins: TegamiPlugin[];
-  graph: PackageGraph;
-  /** error if doesn't exist */
-  getRegistryClient(pkgOrId: WorkspacePackage | string): RegistryClient;
-}
-//#endregion
 //#region src/utils/semver.d.ts
 type BumpType = "major" | "minor" | "patch";
 //#endregion
@@ -89,6 +47,7 @@ declare class DraftPlan {
   deleteChangelog(id: string): boolean;
   /** Write the publish plan, update package versions, and consume changelog files. */
   createPublishPlan(): Promise<void>;
+  editable(): boolean;
   private assertPublishPlanFinished;
   private applyVersionChanges;
   private removeConsumedChangelogs;
@@ -157,14 +116,21 @@ interface PublishOptions {
   /** Validate the publish plan without publishing packages, creating tags, or running release plugins. */
   dryRun?: boolean;
 }
-interface PublishResult {
-  /** Path to the publish plan that was executed. */
-  planPath: string;
-  state: "success" | "failed";
-  packages: PackagePublishResult[];
-  /** the persisted plan object. This is not a public API, can be changed without notice */
+type PublishResult = {
+  state: "created";
+  packages: PackagePublishResult[]; /** Path to the publish plan that was executed. */
+  planPath: string; /** the persisted plan object. This is not a public API, can be changed without notice */
   _rawPlan: PlanStore;
-}
+} | {
+  state: "failed";
+  error?: string;
+  packages: PackagePublishResult[]; /** Path to the publish plan that was executed. */
+  planPath: string; /** the persisted plan object. This is not a public API, can be changed without notice */
+  _rawPlan: PlanStore;
+} | {
+  state: "skipped"; /** Path to the publish plan that was executed or missing. */
+  planPath: string;
+};
 type PackagePublishResult = ({
   state: "failed";
   error?: string;
@@ -179,6 +145,36 @@ type PackagePublishResult = ({
   changelogs: ChangelogEntry[];
 };
 //#endregion
+//#region src/workspace.d.ts
+/** Package discovered in the workspace. */
+declare abstract class WorkspacePackage {
+  abstract readonly name: string;
+  abstract readonly path: string;
+  abstract readonly manager: string;
+  abstract readonly version: string;
+  abstract readonly publish: boolean;
+  get distTag(): string | undefined;
+  get id(): string;
+  setVersion?(version: string): void;
+  updateDependency?(target: WorkspacePackage, version: string, context: TegamiContext): Awaitable<void>;
+  write?(): Awaitable<void>;
+  protected updateRange(context: TegamiContext, spec: DependencySpec, next: semver.SemVer): Promise<DependencySpec>;
+}
+/** Dependency graph for discovered workspace packages. */
+declare class PackageGraph {
+  private readonly byId;
+  private readonly byName;
+  constructor(packages?: WorkspacePackage[]);
+  getPackages(): WorkspacePackage[];
+  /** Get a package by exact id. */
+  get(id: string): WorkspacePackage | undefined;
+  /** Get packages by id, or every package matching a name. */
+  getByName(nameOrId: string): WorkspacePackage[];
+  /** scan package into graph, if the package id already exists, replace the existing one in graph */
+  add(pkg: WorkspacePackage): void;
+  delete(pkg: WorkspacePackage): void;
+}
+//#endregion
 //#region src/providers/npm.d.ts
 declare class NpmPackage extends WorkspacePackage {
   readonly path: string;
@@ -219,6 +215,7 @@ interface LogGenerator {
   generate(this: TegamiContext, opts: {
     packageName: string;
     version: string;
+    distTag?: string;
     changelogs: ChangelogEntry[];
   }): string | Promise<string>;
 }
@@ -253,6 +250,11 @@ interface TegamiPlugin {
   afterPublish?(this: TegamiContext & {
     publishOptions: PublishOptions;
   }, result: PublishResult): Awaitable<PublishResult | void | undefined>;
+  /** CLI lifecycle hooks. */
+  cli?: {
+    /** Called once before a CLI command runs. */init?(this: TegamiContext): Awaitable<void>; /** Called after `tegami version` creates a publish plan. */
+    afterVersion?(this: TegamiContext, draft: DraftPlan): Awaitable<void>;
+  };
   /**
    * @param pkg - the package that referenced the dependency
    * @param spec - the referenced dependency & its range
@@ -280,4 +282,16 @@ interface DependencySpec {
   range: string;
 }
 //#endregion
-export { PackageOptions as _, TegamiOptions as a, PackageGraph as b, NpmClient as c, npm as d, PackagePublishResult as f, DraftPlan as g, PlanStore as h, RegistryClient as i, NpmPackage as l, PublishResult as m, LogGenerator as n, TegamiPlugin as o, PublishOptions as p, PublishPlanStatus as r, TegamiPluginOption as s, Awaitable as t, NpmRegistryClient as u, PackagePlan as v, WorkspacePackage as x, TegamiContext as y };
+//#region src/context.d.ts
+interface TegamiContext {
+  cwd: string;
+  changelogDir: string;
+  planPath: string;
+  options: TegamiOptions;
+  plugins: TegamiPlugin[];
+  graph: PackageGraph;
+  /** error if doesn't exist */
+  getRegistryClient(pkgOrId: WorkspacePackage | string): RegistryClient;
+}
+//#endregion
+export { PublishResult as _, RegistryClient as a, PackageOptions as b, TegamiPluginOption as c, NpmRegistryClient as d, npm as f, PublishOptions as g, PackagePublishResult as h, PublishPlanStatus as i, NpmClient as l, WorkspacePackage as m, Awaitable as n, TegamiOptions as o, PackageGraph as p, LogGenerator as r, TegamiPlugin as s, TegamiContext as t, NpmPackage as u, PlanStore as v, PackagePlan as x, DraftPlan as y };

package/dist/exec-hOS852t5.mjs

@@ -0,0 +1,12 @@
+//#region src/utils/exec.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 lines.join("\n");
+}
+//#endregion
+export { execFailure as t };

package/dist/generators/simple.d.mts

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

package/dist/generators/simple.mjs

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

package/dist/index-DJ7YxxdM.d.mts

@@ -0,0 +1,35 @@
+import { _ as PublishResult, g as PublishOptions, o as TegamiOptions, p as PackageGraph, t as TegamiContext, y as DraftPlan } from "./context-CC36jtz1.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. */
+  generateChangelog(options?: CreateChangelogOptions): Promise<CreatedChangelog[]>;
+  /** Build an editable draft from pending changelog files. */
+  draft(): Promise<DraftPlan>;
+  /** Publish the current publish plan. */
+  publish(options?: PublishOptions): Promise<PublishResult>;
+  /** 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(options?: TegamiOptions): Tegami;
+//#endregion
+export { CreatedChangelog as i, tegami as n, CreateChangelogOptions as r, Tegami as t };

package/dist/index.d.mts

@@ -1,31 +1,3 @@
-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
+import { _ as PublishResult, a as RegistryClient, b as PackageOptions, c as TegamiPluginOption, g as PublishOptions, h as PackagePublishResult, m as WorkspacePackage, o as TegamiOptions, p as PackageGraph, r as LogGenerator, s as TegamiPlugin, x as PackagePlan, y as DraftPlan } from "./context-CC36jtz1.mjs";
+import { i as CreatedChangelog, n as tegami, r as CreateChangelogOptions, t as Tegami } from "./index-DJ7YxxdM.mjs";
 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

@@ -1,11 +1,11 @@
 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 { a as planStoreSchema, i as changelogFrontmatterSchema, r as npm } from "./npm-BpFlXy8I.mjs";
+import { i as maxBump, t as bumpVersion } from "./semver-FSWx3_34.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";
@@ -178,18 +178,6 @@ 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;
@@ -253,6 +241,9 @@ var DraftPlan = class {
 		await writeFile(this.context.planPath, planStoreSchema.encode(plan));
 		await this.removeConsumedChangelogs();
 	}
+	editable() {
+		return !this.#created;
+	}
 	async assertPublishPlanFinished() {
 		const content = await readFile(this.context.planPath, "utf8").catch(() => void 0);
 		if (!content) return;
@@ -312,6 +303,7 @@ var DraftPlan = class {
 		const generated = await generator.generate.call(this.context, {
 			packageName: pkg.name,
 			version: pkg.version,
+			distTag: plan.distTag,
 			changelogs
 		});
 		const path = join(pkg.path, "CHANGELOG.md");
@@ -470,17 +462,9 @@ function headingToBump(depth) {
 }
 //#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 = [];
+async function publishFromPlan(context, store, options) {
+	const { dryRun = false } = options;
+	const packages = [];
 	for (const [id, plan] of Object.entries(store.packages)) {
 		if (!plan.publish) continue;
 		const pkg = context.graph.get(id);
@@ -496,7 +480,7 @@ async function publishStoredPlan(store, context, { dryRun = false }) {
 		}
 		if (!dryRun) {
 			if (await context.getRegistryClient(pkg).packageVersionExists(pkg, pkg.version)) {
-				results.push({
+				packages.push({
 					id: pkg.id,
 					name: pkg.name,
 					version: pkg.version,
@@ -509,7 +493,7 @@ async function publishStoredPlan(store, context, { dryRun = false }) {
 		}
 		try {
 			if (!dryRun) await context.getRegistryClient(pkg).publish(pkg, { distTag: plan.distTag });
-			results.push({
+			packages.push({
 				id: pkg.id,
 				name: pkg.name,
 				version: pkg.version,
@@ -518,7 +502,7 @@ async function publishStoredPlan(store, context, { dryRun = false }) {
 				changelogs
 			});
 		} catch (error) {
-			results.push({
+			packages.push({
 				id: pkg.id,
 				name: pkg.name,
 				version: pkg.version,
@@ -529,32 +513,58 @@ async function publishStoredPlan(store, context, { dryRun = false }) {
 			});
 		}
 	}
-	return results;
+	if (packages.length === 0) return {
+		state: "skipped",
+		planPath: context.planPath
+	};
+	return {
+		planPath: context.planPath,
+		state: packages.some((pkg) => pkg.state === "failed") ? "failed" : "created",
+		packages,
+		_rawPlan: store
+	};
 }
 //#endregion
 //#region src/index.ts
 /** Create a Tegami project handle. */
 function tegami(options = {}) {
+	const $context = init();
+	async function init() {
+		return createTegamiContext(options);
+	}
 	return {
-		async createChangelog(createOptions = {}) {
-			return createChangelog(await createTegamiContext(options), createOptions);
+		async generateChangelog(createOptions = {}) {
+			return createChangelog(await $context, createOptions);
+		},
+		_internal: {
+			options,
+			context() {
+				return $context;
+			},
+			async graph() {
+				return (await $context).graph;
+			}
 		},
 		async draft() {
-			const context = await createTegamiContext(options);
+			const context = await $context;
 			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 context = await $context;
+			if ((await readChangelogEntries(context.cwd, context.changelogDir)).length > 0) return {
+				state: "skipped",
+				planPath: context.planPath
+			};
 			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}.`);
+			if (parsed === void 0) return {
+				state: "skipped",
+				planPath: context.planPath
+			};
 			let result = await publishFromPlan(context, parsed, publishOptions);
 			const publishCtx = {
 				...context,

package/dist/{npm-BSE_dtB3.mjs → npm-BpFlXy8I.mjs}

@@ -1,4 +1,5 @@
 import { n as WorkspacePackage, r as isNodeError } from "./workspace-B5_i21S0.mjs";
+import { t as execFailure } from "./exec-hOS852t5.mjs";
 import { readFile, writeFile } from "node:fs/promises";
 import { join, normalize } from "node:path";
 import { x } from "tinyexec";
@@ -168,13 +169,13 @@ var NpmRegistryClient = class {
 		return info;
 	}
 	async publish(pkg, options = {}) {
+		const client = await this.resolveClient();
 		const args = ["publish"];
 		const distTag = options.distTag ?? pkg.distTag;
 		if (distTag) args.push("--tag", distTag);
-		await x(await this.resolveClient(), args, {
-			nodeOptions: { cwd: pkg.path },
-			throwOnError: true
-		});
+		if (client === "pnpm") args.push("--no-git-checks");
+		const result = await x(client, args, { nodeOptions: { cwd: pkg.path } });
+		if (result.exitCode !== 0) throw new Error(execFailure(`Failed to publish ${pkg.name}@${pkg.version}${distTag ? ` with dist-tag "${distTag}"` : ""}.`, result));
 	}
 	async publishPlanStatus(plan) {
 		for (const [name, pkgPlan] of Object.entries(plan.packages)) {

package/dist/plugins/git.d.mts

@@ -1,9 +1,11 @@
-import { o as TegamiPlugin } from "../types-DdIMewK9.mjs";
+import { s as TegamiPlugin } from "../context-CC36jtz1.mjs";
 
 //#region src/plugins/git.d.ts
 interface GitPluginOptions {
   /** Set to false to skip creating git tags after all packages publish successfully. */
   createTags?: boolean;
+  /** Push created tags to origin. Defaults to true in CI. */
+  pushTags?: boolean;
 }
 /**
  * Basic Git integrations:
@@ -12,8 +14,5 @@ interface GitPluginOptions {
  * Note: you do not need this with `github` plugin enabled.
  */
 declare function git(options?: GitPluginOptions): TegamiPlugin;
-/** create a Git tag, ignored if already exists */
-declare function createGitTag(cwd: string, tag: string): Promise<void>;
-declare function gitTagExists(cwd: string, tag: string): Promise<boolean>;
 //#endregion
-export { GitPluginOptions, createGitTag, git, gitTagExists };
+export { GitPluginOptions, git };

package/dist/plugins/git.mjs

@@ -1,3 +1,5 @@
+import { t as execFailure } from "../exec-hOS852t5.mjs";
+import { t as isCI } from "../constants-B9qjNfvr.mjs";
 import { x } from "tinyexec";
 //#region src/plugins/git.ts
 /**
@@ -7,42 +9,72 @@ import { x } from "tinyexec";
 * Note: you do not need this with `github` plugin enabled.
 */
 function git(options = {}) {
-	const { createTags = true } = options;
+	const { createTags = true, pushTags = isCI() } = options;
 	return {
 		name: "git",
 		enforce: "pre",
+		cli: { async init() {
+			if (!isCI()) return;
+			const gitOptions = { nodeOptions: { cwd: this.cwd } };
+			for (const args of [[
+				"config",
+				"user.name",
+				"github-actions[bot]"
+			], [
+				"config",
+				"user.email",
+				"41898282+github-actions[bot]@users.noreply.github.com"
+			]]) {
+				const result = await x("git", [...args], gitOptions);
+				if (result.exitCode !== 0) throw new Error(execFailure("Failed to configure git user for GitHub Actions.", result));
+			}
+		} },
 		async afterPublish(result) {
-			const { graph, publishOptions: { dryRun = false } } = this;
-			if (dryRun || !createTags || result.state === "failed") return result;
+			const { cwd, graph, publishOptions: { dryRun = false } } = this;
+			if (dryRun || !createTags || result.state !== "created") return result;
+			const createdTags = [];
 			for (const pkg of result.packages) try {
 				const gitTag = `${pkg.name}@${pkg.version}`;
-				await createGitTag(graph.get(pkg.id).path, gitTag);
+				const packagePath = graph.get(pkg.id).path;
+				if (await createGitTag(packagePath, gitTag)) createdTags.push(gitTag);
 				pkg.gitTag = gitTag;
 			} catch (error) {
+				const errorMessage = error instanceof Error ? error.message : String(error);
 				return {
 					...result,
 					state: "failed",
+					error: errorMessage,
 					packages: result.packages.map((pkgResult) => {
 						if (pkgResult.id === pkg.id) return {
 							...pkgResult,
 							state: "failed",
-							error: error instanceof Error ? error.message : String(error)
+							error: errorMessage
 						};
 						return pkgResult;
 					})
 				};
 			}
+			if (pushTags && createdTags.length > 0) try {
+				await pushGitTags(cwd, createdTags);
+			} catch (error) {
+				return {
+					...result,
+					state: "failed",
+					error: error instanceof Error ? error.message : String(error)
+				};
+			}
 			return result;
 		}
 	};
 }
 /** create a Git tag, ignored if already exists */
 async function createGitTag(cwd, tag) {
-	if (await gitTagExists(cwd, tag)) return;
+	if (await gitTagExists(cwd, tag)) return false;
 	await x("git", ["tag", tag], {
 		nodeOptions: { cwd },
 		throwOnError: true
 	});
+	return true;
 }
 async function gitTagExists(cwd, tag) {
 	return (await x("git", [
@@ -52,5 +84,16 @@ async function gitTagExists(cwd, tag) {
 		`refs/tags/${tag}`
 	], { nodeOptions: { cwd } })).exitCode === 0;
 }
+async function pushGitTags(cwd, tags) {
+	if (tags.length === 0) return;
+	await x("git", [
+		"push",
+		"origin",
+		...tags
+	], {
+		nodeOptions: { cwd },
+		throwOnError: true
+	});
+}
 //#endregion
-export { createGitTag, git, gitTagExists };
+export { git };

package/dist/plugins/github.d.mts

@@ -1,4 +1,4 @@
-import { f as PackagePublishResult, o as TegamiPlugin, t as Awaitable } from "../types-DdIMewK9.mjs";
+import { h as PackagePublishResult, n as Awaitable, s as TegamiPlugin } from "../context-CC36jtz1.mjs";
 import { GitPluginOptions } from "./git.mjs";
 
 //#region src/plugins/github.d.ts
@@ -10,12 +10,30 @@ interface GithubRelease {
   /** Whether to mark release as prerelease */
   prerelease?: boolean;
 }
+interface VersionPullRequestOptions {
+  /** Pull request branch. */
+  branch?: string;
+  /** Pull request base branch. */
+  base?: string;
+  /** Pull request title. */
+  title?: string;
+  /** Pull request body. */
+  body?: string;
+}
 /** Options for creating GitHub releases after a successful publish. */
 interface GitHubPluginOptions extends GitPluginOptions {
   /** GitHub repository. */
   repo?: string;
   /** override release details, return `false` to skip */
   onCreateRelease?: (result: PackagePublishResult) => Awaitable<GithubRelease | false>;
+  cli?: {
+    /**
+     * Open a version pull request after versioning.
+     * Defaults to enabled in CI and disabled locally.
+     * Set to `true` to always create the pull request.
+     */
+    createVersionPR?: boolean | VersionPullRequestOptions;
+  };
 }
 /** Create GitHub releases for successfully published packages after the whole plan succeeds. */
 declare function github(options?: GitHubPluginOptions): TegamiPlugin[];

package/dist/plugins/github.mjs

@@ -1,3 +1,6 @@
+import { t as execFailure } from "../exec-hOS852t5.mjs";
+import { a as previousVersion, r as formatVersionBump } from "../semver-FSWx3_34.mjs";
+import { t as isCI } from "../constants-B9qjNfvr.mjs";
 import { git } from "./git.mjs";
 import { x } from "tinyexec";
 //#region src/plugins/github.ts
@@ -18,16 +21,118 @@ function github(options = {}) {
 		];
 		if (options.repo) args.push("--repo", options.repo);
 		if (release.prerelease) args.push("--prerelease");
-		await x("gh", args, { throwOnError: true });
+		const result = await x("gh", args);
+		if (result.exitCode !== 0) throw new Error(execFailure(`Failed to create GitHub release for ${pkg.name}@${pkg.version}.`, result));
+	}
+	function resolvePROptions() {
+		const setting = options.cli?.createVersionPR ?? isCI();
+		if (setting === false) return [false];
+		return [true, typeof setting === "object" ? setting : {}];
 	}
 	return [git(options), {
 		name: "github",
+		cli: {
+			async init() {
+				if (!isCI()) return;
+				const token = process.env.GITHUB_TOKEN ?? process.env.GH_TOKEN;
+				const repository = options.repo ?? process.env.GITHUB_REPOSITORY;
+				if (!token || !repository) return;
+				const result = await x("git", [
+					"remote",
+					"set-url",
+					"origin",
+					`https://x-access-token:${token}@github.com/${repository}.git`
+				], { nodeOptions: { cwd: this.cwd } });
+				if (result.exitCode !== 0) throw new Error(execFailure("Failed to configure git remote for GitHub Actions.", result));
+			},
+			async afterVersion(draft) {
+				const { cwd } = this;
+				const [enabled, config] = resolvePROptions();
+				if (!enabled || !await hasGitChanges(cwd)) return;
+				const { branch = "tegami/version-packages", base = "main", title = "Version Packages", body = defaultVersionPRBody(draft, this) } = config;
+				const gitOptions = { nodeOptions: { cwd } };
+				let result = await x("git", [
+					"checkout",
+					"-B",
+					branch
+				], gitOptions);
+				if (result.exitCode !== 0) throw new Error(execFailure("Failed to create the version pull request branch.", result));
+				result = await x("git", ["add", "-A"], gitOptions);
+				if (result.exitCode !== 0) throw new Error(execFailure("Failed to stage version changes.", result));
+				result = await x("git", [
+					"commit",
+					"-m",
+					title
+				], gitOptions);
+				if (result.exitCode !== 0) throw new Error(execFailure("Failed to commit version changes.", result));
+				result = await x("git", [
+					"push",
+					"--force",
+					"-u",
+					"origin",
+					branch
+				], gitOptions);
+				if (result.exitCode !== 0) throw new Error(execFailure("Failed to push the version branch to origin. Ensure `origin` is configured and you have push access.", result));
+				if (await hasOpenPullRequest(branch, options.repo)) return;
+				const args = [
+					"pr",
+					"create",
+					"--title",
+					title,
+					"--body",
+					body,
+					"--head",
+					branch,
+					"--base",
+					base
+				];
+				if (options.repo) args.push("--repo", options.repo);
+				const prResult = await x("gh", args);
+				if (prResult.exitCode !== 0) throw new Error(execFailure("Failed to create the version pull request.", prResult));
+			}
+		},
 		async afterPublish(result) {
-			if (result.state !== "success") return;
+			if (result.state !== "created") return;
 			await Promise.all(result.packages.map(createGithubRelease));
 		}
 	}];
 }
+async function hasGitChanges(cwd) {
+	return (await x("git", ["status", "--porcelain"], { nodeOptions: { cwd } })).stdout.trim().length > 0;
+}
+async function hasOpenPullRequest(branch, repo) {
+	const args = [
+		"pr",
+		"list",
+		"--head",
+		branch,
+		"--state",
+		"open",
+		"--json",
+		"number"
+	];
+	if (repo) args.push("--repo", repo);
+	const result = await x("gh", args);
+	if (result.exitCode !== 0) throw new Error(execFailure("Failed to check for an existing version pull request.", result));
+	return result.stdout.trim() !== "[]";
+}
+function defaultVersionPRBody(draft, context) {
+	const packageLines = [];
+	for (const id of draft.getPackageIds()) {
+		const packagePlan = draft.getPackage(id);
+		if (!packagePlan) continue;
+		const pkg = context.graph.get(id);
+		if (!pkg) continue;
+		const publish = packagePlan.publish ? "" : " (no publish)";
+		const previous = previousVersion(pkg.version, packagePlan.type);
+		packageLines.push(`- ${formatVersionBump(pkg.name, previous, pkg.version, packagePlan.distTag)}${publish}`);
+	}
+	const changelogLines = draft.getChangelogIds().map((id) => draft.getChangelog(id)).filter((entry) => entry !== void 0).map((entry) => `- ${entry.title}`);
+	const sections = ["## Summary", ...packageLines];
+	if (changelogLines.length > 0) sections.push("", "## Changelogs", ...changelogLines);
+	sections.push("", "Merge this PR to publish the versioned packages.");
+	return sections.join("\n");
+}
 function defaultNotes(pkg) {
 	const entries = pkg.changelogs;
 	if (entries.length > 0) return entries.map((entry) => [`### ${entry.title}`, entry.content].filter(Boolean).join("\n\n")).join("\n\n");

package/dist/providers/cargo.d.mts

@@ -1,4 +1,4 @@
-import { b as PackageGraph, h as PlanStore, i as RegistryClient, o as TegamiPlugin, r as PublishPlanStatus, x as WorkspacePackage, y as TegamiContext } from "../types-DdIMewK9.mjs";
+import { a as RegistryClient, i as PublishPlanStatus, m as WorkspacePackage, p as PackageGraph, s as TegamiPlugin, t as TegamiContext, v as PlanStore } from "../context-CC36jtz1.mjs";
 import { TomlTable } from "smol-toml";
 
 //#region src/providers/cargo.d.ts

package/dist/providers/cargo.mjs

@@ -3,7 +3,7 @@ import { readFile, writeFile } from "node:fs/promises";
 import { join, normalize } from "node:path";
 import { x } from "tinyexec";
 import * as semver from "semver";
-import { parse, stringify } from "smol-toml";
+import { parse as parse$1, stringify } from "smol-toml";
 import { glob } from "tinyglobby";
 //#region src/providers/cargo.ts
 const DEP_FIELDS = [
@@ -173,7 +173,7 @@ function dependencyTables(manifest) {
 	return tables;
 }
 async function readCargoManifest(path) {
-	return parse(await readFile(join(path, "Cargo.toml"), "utf8"));
+	return parse$1(await readFile(join(path, "Cargo.toml"), "utf8"));
 }
 function tableValue(value) {
 	if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;

package/dist/providers/npm.d.mts

@@ -1,2 +1,2 @@
-import { c as NpmClient, d as npm, l as NpmPackage, u as NpmRegistryClient } from "../types-DdIMewK9.mjs";
+import { d as NpmRegistryClient, f as npm, l as NpmClient, u as NpmPackage } from "../context-CC36jtz1.mjs";
 export { NpmClient, NpmPackage, NpmRegistryClient, npm };

package/dist/providers/npm.mjs

@@ -1,2 +1,2 @@
-import { n as NpmRegistryClient, r as npm, t as NpmPackage } from "../npm-BSE_dtB3.mjs";
+import { n as NpmRegistryClient, r as npm, t as NpmPackage } from "../npm-BpFlXy8I.mjs";
 export { NpmPackage, NpmRegistryClient, npm };

package/dist/semver-FSWx3_34.mjs

@@ -0,0 +1,35 @@
+import { inc, parse } from "semver";
+//#region src/utils/semver.ts
+function formatPackageVersion(name, version, distTag) {
+	return `${name}@${version}${distTag ? ` (${distTag})` : ""}`;
+}
+function previousVersion(version, type) {
+	const parsed = parse(version);
+	if (!parsed) throw new Error(`Invalid semver version: ${version}`);
+	if (type === "major") {
+		parsed.major = Math.max(0, parsed.major - 1);
+		parsed.minor = 0;
+		parsed.patch = 0;
+	} else if (type === "minor") {
+		parsed.minor = Math.max(0, parsed.minor - 1);
+		parsed.patch = 0;
+	} else parsed.patch = Math.max(0, parsed.patch - 1);
+	parsed.prerelease = [];
+	parsed.build = [];
+	return parsed.format();
+}
+function formatVersionBump(name, from, to, distTag) {
+	return `${name}@${from} → ${name}@${to}${distTag ? ` (${distTag})` : ""}`;
+}
+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
+export { previousVersion as a, maxBump as i, formatPackageVersion as n, formatVersionBump as r, bumpVersion as t };

package/package.json

@@ -1,32 +1,12 @@
 {
   "name": "tegami",
-  "version": "0.0.0",
-  "description": "Utility for package versioning & publish",
-  "license": "MIT",
-  "author": "Fuma Nama",
-  "repository": "github:fuma-nama/tegami",
-  "files": [
-    "dist"
-  ],
-  "type": "module",
-  "exports": {
-    ".": "./dist/index.mjs",
-    "./generators/simple": "./dist/generators/simple.mjs",
-    "./plugins/git": "./dist/plugins/git.mjs",
-    "./plugins/github": "./dist/plugins/github.mjs",
-    "./providers/cargo": "./dist/providers/cargo.mjs",
-    "./providers/npm": "./dist/providers/npm.mjs",
-    "./package.json": "./package.json"
-  },
+  "version": "0.0.1",
   "publishConfig": {
     "access": "public"
   },
-  "scripts": {
-    "types:check": "tsc --noEmit",
-    "build": "tsdown",
-    "dev": "tsdown --watch"
-  },
   "dependencies": {
+    "@clack/prompts": "^1.5.1",
+    "commander": "^15.0.0",
     "js-yaml": "^4.2.0",
     "mdast-util-from-markdown": "^2.0.3",
     "mdast-util-to-markdown": "^2.1.2",
@@ -38,12 +18,38 @@
     "zod": "^4.4.3"
   },
   "devDependencies": {
-    "@repo/typescript-config": "workspace:*",
     "@types/js-yaml": "^4.0.9",
     "@types/mdast": "^4.0.4",
     "@types/node": "^25.5.0",
     "@types/semver": "^7.7.1",
     "tsdown": "^0.22.2",
-    "typescript": "6.0.3"
+    "typescript": "6.0.3",
+    "@repo/typescript-config": "0.0.0"
+  },
+  "description": "Utility for package versioning & publish",
+  "license": "MIT",
+  "author": "Fuma Nama",
+  "repository": {
+    "type": "git",
+    "url": "github:fuma-nama/tegami"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./cli": "./dist/cli/index.mjs",
+    "./generators/simple": "./dist/generators/simple.mjs",
+    "./plugins/git": "./dist/plugins/git.mjs",
+    "./plugins/github": "./dist/plugins/github.mjs",
+    "./providers/cargo": "./dist/providers/cargo.mjs",
+    "./providers/npm": "./dist/providers/npm.mjs",
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "types:check": "tsc --noEmit",
+    "build": "tsdown",
+    "dev": "tsdown --watch"
   }
-}
+}