tegami 0.1.1 → 0.1.4

package/dist/index.js

@@ -1,167 +1,16 @@
-import { a as changelogFilename, i as readPlanStore, n as publishPlanStatus, r as createPlanStore, t as assertPublishPlanFinished } from "./checks-Bz3Rf2OX.js";
-import { n as handlePluginError, t as execFailure } from "./error-BaOQJtvf.js";
-import { i as maxBump } from "./semver-mWK2Khi2.js";
-import { t as PackageGraph } from "./graph-CUgwuRW5.js";
+import { a as maxBump } from "./semver-C4vJ4SK8.js";
+import { c as changelogFrontmatterSchema, i as readPlanStore, n as publishPlanStatus, o as generateChangelog, r as createPlanStore, t as assertPublishPlanFinished } from "./checks-Cwz-Ezkq.js";
+import { r as handlePluginError } from "./error-DNy8R5ue.js";
+import { t as PackageGraph } from "./graph-DLKPUXSD.js";
 import { cargo } from "./providers/cargo.js";
-import { t as bumpTypeSchema } from "./schemas-CurBAaW5.js";
 import { npm } from "./providers/npm.js";
 import { simpleGenerator } from "./generators/simple.js";
 import { mkdir, readFile, readdir, rm, writeFile } from "node:fs/promises";
 import path, { basename, dirname, join } from "node:path";
-import { x } from "tinyexec";
-import { load } from "js-yaml";
-import z$1 from "zod";
+import * as semver from "semver";
+import { dump, load } from "js-yaml";
 import { fromMarkdown } from "mdast-util-from-markdown";
 import { toMarkdown } from "mdast-util-to-markdown";
-//#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/generate.ts
-async function generateChangelog(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]);
-	}
-	await mkdir(context.changelogDir, { recursive: true });
-	return Promise.all(Array.from(groups, async ([key, changes], index) => {
-		const packages = key ? key.split("\0") : [];
-		const filename = changelogFilename(index);
-		const path = join(context.changelogDir, filename);
-		await writeFile(path, renderChangelog(packages, changes));
-		return {
-			filename,
-			path,
-			packages,
-			changes: changes.length
-		};
-	}));
-}
-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: titleCase(parsed.title)
-		});
-	}
-	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 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);
-}
-//#endregion
 //#region src/context.ts
 async function createTegamiContext(options = {}) {
 	const cwd = options.cwd ? path.resolve(options.cwd) : process.cwd();
@@ -226,6 +75,141 @@ function resolvePlugins(plugins = []) {
 	return plugins.flat(Infinity).sort((a, b) => PLUGIN_ORDER[a.enforce ?? "default"] - PLUGIN_ORDER[b.enforce ?? "default"]);
 }
 //#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 getChangelogFiles(context) {
+	return (await readdir(context.changelogDir).catch(() => [])).filter((file) => file.endsWith(".md"));
+}
+async function readChangelogEntries(context) {
+	const dir = context.changelogDir;
+	const files = await getChangelogFiles(context);
+	return (await Promise.all(files.map(async (file) => {
+		const filePath = join(dir, file);
+		const content = await readFile(filePath, "utf8");
+		return parseChangelogFile(basename(filePath), content);
+	}))).filter((v) => v !== void 0);
+}
+/** Parse one changelog markdown file into release entries. */
+function parseChangelogFile(filename, content) {
+	const parsed = frontmatter(content);
+	const { success, data } = changelogFrontmatterSchema.safeParse(parsed.data);
+	if (!success || !data.packages) return;
+	const tree = fromMarkdown(parsed.content);
+	let headingBump;
+	const packages = /* @__PURE__ */ new Map();
+	const sections = [];
+	for (const section of getHeadingSections(tree)) {
+		const sectionBumpType = headingToBump(section.heading.depth);
+		if (sectionBumpType) headingBump = headingBump ? maxBump(headingBump, sectionBumpType) : sectionBumpType;
+		sections.push({
+			depth: section.heading.depth,
+			title: sectionToMarkdown(section.heading.children),
+			content: sectionToMarkdown(section.children)
+		});
+	}
+	if (sections.length === 0) return;
+	if (Array.isArray(data.packages)) {
+		if (!headingBump) return;
+		for (const pkg of data.packages) packages.set(pkg, { type: headingBump });
+	} else for (const [k, v] of Object.entries(data.packages)) {
+		let config;
+		if (typeof v === "string") config = { type: v };
+		else if (v === null) config = { type: headingBump };
+		else config = v;
+		if (config.type || config.replay?.length) packages.set(k, config);
+	}
+	if (packages.size === 0) return;
+	const entry = {
+		id: filename,
+		filename,
+		subject: data.subject,
+		packages,
+		sections,
+		_raw_body: parsed.content,
+		getRawContent() {
+			return [
+				"---",
+				dump({
+					subject: this.subject,
+					packages: Object.fromEntries(this.packages.entries())
+				}).trim(),
+				"---",
+				"",
+				entry._raw_body.trim(),
+				""
+			].join("\n");
+		}
+	};
+	return entry;
+}
+function parseReplayCondition(condition) {
+	if (condition.startsWith("exit prerelease:")) return {
+		type: "on-exit-prerelease",
+		name: condition.slice(16).trimStart()
+	};
+	const idx = condition.lastIndexOf("@");
+	if (idx <= 0) return null;
+	return {
+		type: "on-version",
+		name: condition.slice(0, idx),
+		version: condition.slice(idx + 1)
+	};
+}
+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 sectionToMarkdown(children) {
+	if (children.length === 0) return "";
+	return toMarkdown({
+		type: "root",
+		children
+	}, {
+		bullet: "-",
+		fence: "`"
+	}).trim();
+}
+function headingToBump(depth) {
+	switch (depth) {
+		case 1: return "major";
+		case 2: return "minor";
+		case 3: return "patch";
+	}
+}
+//#endregion
 //#region src/plans/policy.ts
 function groupPolicy({ graph }) {
 	return {
@@ -263,23 +247,35 @@ var DraftPlan = class {
 		return this.packages.get(id);
 	}
 	bumpPackage(pkg, { type, reason }) {
-		let plan = this.packages.get(pkg.id);
-		if (!plan) {
-			plan = this.initPackagePlan(pkg);
-			this.packages.set(pkg.id, plan);
-		}
+		return this.dispatchPackage(pkg, (plan) => {
+			plan.type = plan.type ? maxBump(plan.type, type) : type;
+			if (reason) {
+				plan.bumpReasons ??= /* @__PURE__ */ new Set();
+				plan.bumpReasons.add(reason);
+			}
+		});
+	}
+	dispatchPackage(pkg, dispatch, onUpdate) {
+		const plan = this.getOrInitPackage(pkg);
 		const prevVersion = plan.bumpVersion(pkg);
-		plan.type = plan.type ? maxBump(plan.type, type) : type;
-		if (reason) {
-			plan.bumpReasons ??= /* @__PURE__ */ new Set();
-			plan.bumpReasons.add(reason);
+		dispatch(plan);
+		if (prevVersion !== plan.bumpVersion(pkg)) {
+			onUpdate?.(plan);
+			for (const policy of this.policies) policy.onUpdate?.call(this, {
+				plan,
+				pkg
+			});
 		}
-		if (prevVersion !== plan.bumpVersion(pkg)) for (const policy of this.policies) policy.onUpdate?.call(this, {
-			plan,
-			pkg
-		});
 		return plan;
 	}
+	getOrInitPackage(pkg) {
+		const existing = this.packages.get(pkg.id);
+		if (existing) return existing;
+		this.packages.set(pkg.id, pkg.initPlan());
+		return this.dispatchPackage(pkg, (plan) => pkg.configurePlan(plan, this.context.graph.getPackageGroup(pkg.id)), (plan) => {
+			(plan.bumpReasons ??= /* @__PURE__ */ new Set()).add("align with script-level configs");
+		});
+	}
 	hasPending() {
 		const { graph } = this.context;
 		for (const [id, plan] of this.packages) {
@@ -298,37 +294,36 @@ var DraftPlan = class {
 		this.changelogs.set(entry.id, entry);
 		const { graph } = this.context;
 		const groupPackages = /* @__PURE__ */ new Map();
-		for (const [name, bumpType] of entry.packages) for (const pkg of graph.getByName(name)) groupPackages.set(pkg, bumpType);
-		for (const [pkg, bumpType] of groupPackages) {
-			const plan = this.bumpPackage(pkg, { type: bumpType });
-			plan.changelogs ??= [];
-			plan.changelogs.push(entry);
+		for (const [name, config] of entry.packages) {
+			if (!config.type) continue;
+			for (const pkg of graph.getByName(name)) groupPackages.set(pkg, config.type);
 		}
+		for (const [pkg, bumpType] of groupPackages) attachChangelog(this.bumpPackage(pkg, { type: bumpType }), entry);
 	}
 	deleteChangelog(id) {
 		return this.changelogs.delete(id);
 	}
-	initPackagePlan(pkg) {
-		const context = this.context;
-		const plan = pkg.onPlan(context);
-		const group = context.graph.getPackageGroup(pkg.id);
-		if (group) plan.prerelease ??= group.options.prerelease;
-		return plan;
-	}
 	/** Apply the publish plan: update package versions, write the plan file, and consume changelog files. */
 	async applyPlan() {
 		if (this.#applied) throw new Error("This draft has already applied a publish plan.");
 		await assertPublishPlanFinished(this.context);
+		const { graph } = this.context;
 		this.#applied = true;
+		const snapshots = /* @__PURE__ */ new Map();
+		for (const pkg of graph.getPackages()) snapshots.set(pkg.id, { version: pkg.version });
 		for (const plugin of this.context.plugins) await handlePluginError(plugin, "applyPlan", () => plugin.applyPlan?.call(this.context, this));
-		const { graph } = this.context;
+		const updatedChangelogs = this.applyReplays(snapshots);
 		const writes = [];
 		for (const [id, packagePlan] of this.packages) {
 			const pkg = graph.get(id);
 			if (!pkg) continue;
 			writes.push(this.appendChangelog(pkg, packagePlan));
 		}
-		for (const entry of this.changelogs.values()) writes.push(rm(path.join(this.context.changelogDir, entry.filename), { force: true }));
+		for (const entry of this.changelogs.values()) {
+			const updated = updatedChangelogs.get(entry.id);
+			const filePath = path.join(this.context.changelogDir, entry.filename);
+			writes.push(updated ? writeFile(filePath, updated.getRawContent()) : rm(filePath, { force: true }));
+		}
 		await Promise.all(writes);
 		await mkdir(dirname(this.context.planPath), { recursive: true });
 		await writeFile(this.context.planPath, createPlanStore(this, this.context));
@@ -343,6 +338,46 @@ var DraftPlan = class {
 	canApply() {
 		return !this.#applied;
 	}
+	/** Attach replaying changelog entries to packages (already bumped), and return the updated changelog entries. */
+	applyReplays(snapshots) {
+		const updated = /* @__PURE__ */ new Map();
+		const { graph } = this.context;
+		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 graph.getByName(condition.name).some((pkg) => pkg.version === condition.version);
+		};
+		for (const entry of this.changelogs.values()) {
+			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) => {
+					const condition = parseReplayCondition(item);
+					if (condition && isMatch(condition)) {
+						matchedNames.add(name);
+						return false;
+					}
+					return true;
+				});
+				if (replay.length === 0) continue;
+				const updatedConfig = {
+					...config,
+					replay
+				};
+				delete updatedConfig.type;
+				updatedPackages.set(name, updatedConfig);
+			}
+			if (updatedPackages.size > 0) updated.set(entry.id, {
+				...entry,
+				packages: updatedPackages
+			});
+			for (const name of matchedNames) for (const pkg of graph.getByName(name)) attachChangelog(this.getOrInitPackage(pkg), entry);
+		}
+		return updated;
+	}
 	async appendChangelog(pkg, plan) {
 		if (!plan.changelogs || plan.changelogs.length === 0) return;
 		const { generator = simpleGenerator() } = this.context.options;
@@ -350,10 +385,9 @@ var DraftPlan = class {
 			packageId: pkg.id,
 			packageName: pkg.name,
 			version: pkg.version,
-			npm: plan.npm,
 			plan,
 			changelogs: plan.changelogs,
-			_draft: this
+			unstable_draft: this
 		});
 		const path = join(pkg.path, "CHANGELOG.md");
 		const existing = await readFile(path, "utf8").catch(() => "");
@@ -383,110 +417,14 @@ async function createDraftPlan(changelogs, context) {
 		const result = await handlePluginError(plugin, "initPlan", () => plugin.initPlan?.call(context, draft));
 		if (result) draft = result;
 	}
+	for (const pkg of context.graph.getPackages()) draft.getOrInitPackage(pkg);
 	for (const entry of changelogs) draft.addChangelog(entry);
 	return draft;
 }
-//#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
-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(), bumpTypeSchema.or(z$1.null()))]).optional()
-});
-async function getChangelogFiles(context) {
-	return (await readdir(context.changelogDir).catch(() => [])).filter((file) => file.endsWith(".md"));
-}
-async function readChangelogEntries(context) {
-	const dir = context.changelogDir;
-	const files = await getChangelogFiles(context);
-	return (await Promise.all(files.map(async (file) => {
-		const filePath = join(dir, file);
-		return parseChangelogFile(filePath, await readFile(filePath, "utf8"));
-	}))).filter((v) => v !== void 0);
-}
-/** Parse one changelog markdown file into release entries. */
-function parseChangelogFile(file, content) {
-	const parsed = frontmatter(content);
-	const data = changelogFrontmatterSchema.parse(parsed.data);
-	if (!data.packages) return;
-	const tree = fromMarkdown(parsed.content);
-	let bumpType;
-	const packages = /* @__PURE__ */ new Map();
-	const sections = [];
-	const filename = basename(file);
-	for (const section of getHeadingSections(tree)) {
-		const sectionBumpType = headingToBump(section.heading.depth);
-		if (sectionBumpType) bumpType = bumpType ? maxBump(bumpType, sectionBumpType) : sectionBumpType;
-		sections.push({
-			depth: section.heading.depth,
-			title: sectionToMarkdown(section.heading.children),
-			content: sectionToMarkdown(section.children)
-		});
-	}
-	if (!bumpType) return;
-	if (Array.isArray(data.packages)) for (const pkg of data.packages) packages.set(pkg, bumpType);
-	else for (const [k, v] of Object.entries(data.packages)) packages.set(k, v ?? bumpType);
-	return {
-		id: filename,
-		filename,
-		subject: data.subject,
-		packages,
-		sections
-	};
-}
-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 sectionToMarkdown(children) {
-	if (children.length === 0) return "";
-	return toMarkdown({
-		type: "root",
-		children
-	}, {
-		bullet: "-",
-		fence: "`"
-	}).trim();
-}
-function headingToBump(depth) {
-	switch (depth) {
-		case 1: return "major";
-		case 2: return "minor";
-		case 3: return "patch";
-	}
+function attachChangelog(plan, entry) {
+	if (plan.changelogs?.some((item) => item.id === entry.id)) return;
+	plan.changelogs ??= [];
+	plan.changelogs.push(entry);
 }
 //#endregion
 //#region src/publish.ts
@@ -529,18 +467,20 @@ async function publishFromPlan(context, store, options) {
 	const packages = [];
 	if ((await publishPlanStatus(store, context)).state !== "pending") return { state: "skipped" };
 	const orderedIds = await resolvePublishTargets(context, store);
+	const parsedChangelogs = /* @__PURE__ */ new Map();
+	for (const [id, entry] of Object.entries(store.changelogs)) {
+		const parsed = parseChangelogFile(entry.filename, entry.content);
+		if (!parsed) continue;
+		parsedChangelogs.set(id, parsed);
+	}
 	for (const id of orderedIds) {
 		const plan = store.packages[id];
 		const pkg = context.graph.get(id);
 		const registryClient = context.getRegistryClient(pkg);
 		const changelogs = [];
 		for (const id of plan.changelogIds ?? []) {
-			const entry = store.changelogs[id];
-			if (entry) changelogs.push({
-				...entry,
-				packages: new Map(Object.entries(entry.packages)),
-				id
-			});
+			const entry = parsedChangelogs.get(id);
+			if (entry) changelogs.push(entry);
 		}
 		if (!dryRun) {
 			if (await registryClient.isPackagePublished(pkg)) {
@@ -643,7 +583,6 @@ function tegami(options = {}) {
 		},
 		async publish(publishOptions = {}) {
 			const context = await $context;
-			if ((await getChangelogFiles(context)).length > 0) return { state: "skipped" };
 			const parsed = await readPlanStore(context);
 			if (!parsed) return { state: "skipped" };
 			let result = await publishFromPlan(context, parsed, publishOptions);

package/dist/plugins/git.d.ts

@@ -1,4 +1,4 @@
-import { c as TegamiPlugin } from "../types-Diwnh8Tn.js";
+import { c as TegamiPlugin } from "../types-BXk2fMqa.js";
 
 //#region src/plugins/git.d.ts
 interface GitPluginOptions {

package/dist/plugins/git.js

@@ -1,5 +1,4 @@
-import { t as execFailure } from "../error-BaOQJtvf.js";
-import { t as isCI } from "../constants-B9qjNfvr.js";
+import { a as isCI, n as execFailure } from "../error-DNy8R5ue.js";
 import { x } from "tinyexec";
 //#region src/plugins/git.ts
 /**
@@ -13,8 +12,7 @@ function git(options = {}) {
 	function resolveGitTag(context, result) {
 		const { graph } = context;
 		const pkg = graph.get(result.id);
-		if (!pkg) return `${result.name}@${result.version}`;
-		const group = graph.getPackageGroup(pkg.id);
+		const group = pkg && graph.getPackageGroup(pkg.id);
 		if (group?.options.syncGitTag) return `${group.name}@${result.version}`;
 		return `${result.name}@${result.version}`;
 	}
@@ -39,9 +37,10 @@ function git(options = {}) {
 		} },
 		async afterPublishAll(result) {
 			const { cwd, publishOptions: { dryRun = false } } = this;
-			if (dryRun || !createTags || result.state !== "created") return result;
+			if (dryRun || !createTags || result.state === "skipped") return result;
 			const pendingTags = /* @__PURE__ */ new Set();
 			for (const pkg of result.packages) {
+				if (pkg.state !== "success") continue;
 				pkg.gitTag = resolveGitTag(this, pkg);
 				pendingTags.add(pkg.gitTag);
 			}

package/dist/plugins/github.d.ts

@@ -1,4 +1,4 @@
-import { S as PackagePublishResult, T as TegamiContext, c as TegamiPlugin, k as DraftPlan, t as Awaitable } from "../types-Diwnh8Tn.js";
+import { S as PackagePublishResult, T as TegamiContext, c as TegamiPlugin, k as DraftPlan, t as Awaitable } from "../types-BXk2fMqa.js";
 import { GitPluginOptions } from "./git.js";
 
 //#region src/plugins/github.d.ts
@@ -42,6 +42,12 @@ interface GitHubPluginOptions extends GitPluginOptions {
   repo?: string;
   /** Optional GitHub token for Git & GitHub operations. */
   token?: string;
+  /**
+   * Create GitHub release immediately after successful publish, without waiting for others.
+   *
+   * @default false
+   */
+  eagerRelease?: boolean;
   /** Override release details for a single package, return `false` to skip. */
   onCreateRelease?: (this: TegamiContext, result: PackagePublishResult) => Awaitable<GithubRelease | false>;
   /** Override release details when multiple packages share a git tag, return `false` to skip. */