tegami 0.0.1 → 0.1.0-beta.1

package/dist/plugins/github.js

@@ -0,0 +1,187 @@
+import { t as execFailure } from "../error-DBK-9uBa.js";
+import { n as formatNpmDistTag, r as formatPackageVersion } from "../semver-mWK2Khi2.js";
+import { t as isCI } from "../constants-B9qjNfvr.js";
+import { git } from "./git.js";
+import { x } from "tinyexec";
+import { prerelease } from "semver";
+//#region src/plugins/github.ts
+/** Create GitHub releases for successfully published packages after the whole plan succeeds. */
+function github(options = {}) {
+	async function runGithubRelease(gitTag, title, notes, prerelease) {
+		const args = [
+			"release",
+			"create",
+			gitTag,
+			"--title",
+			title,
+			"--notes",
+			notes
+		];
+		if (options.repo) args.push("--repo", options.repo);
+		if (prerelease) args.push("--prerelease");
+		const result = await x("gh", args);
+		if (result.exitCode !== 0) throw execFailure(`Failed to create GitHub release for ${gitTag}.`, result);
+	}
+	async function createRelease(pkg) {
+		if (!pkg.gitTag) return;
+		const release = await options.onCreateRelease?.(pkg) ?? {};
+		if (release === false) return;
+		await runGithubRelease(pkg.gitTag, release.title ?? defaultTitle(pkg), release.notes ?? defaultNotes(pkg), release.prerelease ?? prerelease(pkg.version) !== null);
+	}
+	async function createGroupedRelease(packages) {
+		const primary = packages[0];
+		if (!primary?.gitTag) return;
+		const release = await options.onCreateGroupedRelease?.(packages) ?? {};
+		if (release === false) return;
+		await runGithubRelease(primary.gitTag, release.title ?? defaultGroupedTitle(packages), release.notes ?? defaultGroupedNotes(packages), release.prerelease ?? packages.some((pkg) => prerelease(pkg.version) !== null));
+	}
+	function resolvePROptions() {
+		const setting = options.cli?.versionPr ?? isCI();
+		if (setting === false) return [false];
+		return [true, typeof setting === "object" ? setting : {}];
+	}
+	function defaultVersionPRBody(draft, context) {
+		const packageLines = [];
+		for (const pkg of context.graph.getPackages()) {
+			const packagePlan = draft.getPackagePlan(pkg.id);
+			if (!packagePlan?.type) continue;
+			const publishTxt = packagePlan.publish ? "" : " (no publish)";
+			const distTagTxt = formatNpmDistTag(packagePlan.npm?.distTag);
+			packageLines.push(`- ${pkg.name}@${cliOriginalPackageVersions.get(pkg.id) ?? pkg.version} → ${pkg.name}@${pkg.version}${distTagTxt}${publishTxt}`);
+		}
+		const changelogLines = draft.getChangelogs().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");
+	}
+	const cliOriginalPackageVersions = /* @__PURE__ */ new Map();
+	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 execFailure("Failed to configure git remote for GitHub Actions.", result);
+			},
+			publishPlanCreated() {
+				for (const pkg of this.graph.getPackages()) cliOriginalPackageVersions.set(pkg.id, pkg.version);
+			},
+			async publishPlanApplied(draft) {
+				const { cwd } = this;
+				const [enabled, config] = resolvePROptions();
+				if (!enabled || !await hasGitChanges(cwd)) return;
+				const { branch = "tegami/version-packages", base = "main" } = config;
+				const basePR = await options.onCreateVersionPullRequest?.(draft);
+				if (basePR === false) return;
+				const pr = {
+					title: basePR?.title ?? "Version Packages",
+					body: basePR?.body ?? defaultVersionPRBody(draft, this)
+				};
+				const gitOptions = { nodeOptions: { cwd } };
+				let result = await x("git", [
+					"checkout",
+					"-B",
+					branch
+				], gitOptions);
+				if (result.exitCode !== 0) throw execFailure("Failed to create the version pull request branch.", result);
+				result = await x("git", ["add", "-A"], gitOptions);
+				if (result.exitCode !== 0) throw execFailure("Failed to stage version changes.", result);
+				result = await x("git", [
+					"commit",
+					"-m",
+					pr.title
+				], gitOptions);
+				if (result.exitCode !== 0) throw execFailure("Failed to commit version changes.", result);
+				result = await x("git", [
+					"push",
+					"--force",
+					"-u",
+					"origin",
+					branch
+				], gitOptions);
+				if (result.exitCode !== 0) throw 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",
+					pr.title,
+					"--body",
+					pr.body,
+					"--head",
+					branch,
+					"--base",
+					base
+				];
+				if (options.repo) args.push("--repo", options.repo);
+				const prResult = await x("gh", args);
+				if (prResult.exitCode !== 0) throw execFailure("Failed to create the version pull request.", prResult);
+			}
+		},
+		async afterPublish(result) {
+			if (result.state !== "created") return;
+			for (const packages of groupPackagesByGitTag(result.packages).values()) if (packages.length > 1) await createGroupedRelease(packages);
+			else await createRelease(packages[0]);
+		}
+	}];
+}
+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 execFailure("Failed to check for an existing version pull request.", result);
+	return result.stdout.trim() !== "[]";
+}
+function groupPackagesByGitTag(packages) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const pkg of packages) {
+		if (!pkg.gitTag) continue;
+		const group = groups.get(pkg.gitTag);
+		if (group) group.push(pkg);
+		else groups.set(pkg.gitTag, [pkg]);
+	}
+	return groups;
+}
+function defaultTitle(pkg) {
+	return formatPackageVersion(pkg.name, pkg.version, pkg.npm?.distTag);
+}
+function defaultGroupedTitle(packages) {
+	const primary = packages[0];
+	const distTag = packages.every((pkg) => pkg.npm?.distTag === primary.npm?.distTag) ? primary.npm?.distTag : void 0;
+	return formatPackageVersion(primary.gitTag.slice(0, primary.gitTag.lastIndexOf("@")), primary.version, distTag);
+}
+function defaultNotes(pkg) {
+	if (pkg.changelogs.length > 0) return pkg.changelogs.map((entry) => [`### ${entry.title}`, entry.content].filter(Boolean).join("\n\n")).join("\n\n");
+	return `Published ${formatPackageVersion(pkg.name, pkg.version, pkg.npm?.distTag)}.`;
+}
+function defaultGroupedNotes(packages) {
+	const changelogs = /* @__PURE__ */ new Map();
+	for (const pkg of packages) for (const entry of pkg.changelogs) changelogs.set(entry.id, entry);
+	const sections = [packages.map((pkg) => `- ${formatPackageVersion(pkg.name, pkg.version, pkg.npm?.distTag)}`).join("\n")];
+	if (changelogs.size > 0) sections.push("", Array.from(changelogs.values()).map((entry) => [`### ${entry.title}`, entry.content].filter(Boolean).join("\n\n")).join("\n\n"));
+	else sections.push("", `Published ${packages[0].gitTag}.`);
+	return sections.join("\n");
+}
+//#endregion
+export { github };

package/dist/providers/cargo.d.ts

@@ -0,0 +1,2 @@
+import { g as cargo, h as CargoRegistryClient, m as CargoPluginOptions, p as CargoPackage } from "../index-Da6P6gSc.js";
+export { CargoPackage, CargoPluginOptions, CargoRegistryClient, cargo };

package/dist/providers/{cargo.mjs → cargo.js}

@@ -1,4 +1,5 @@
-import { n as WorkspacePackage, r as isNodeError } from "../workspace-B5_i21S0.mjs";
+import { r as isNodeError } from "../error-DBK-9uBa.js";
+import { n as WorkspacePackage } from "../graph-CUgwuRW5.js";
 import { readFile, writeFile } from "node:fs/promises";
 import { join, normalize } from "node:path";
 import { x } from "tinyexec";
@@ -11,7 +12,7 @@ const DEP_FIELDS = [
 	"dev-dependencies",
 	"build-dependencies"
 ];
-var CargoPackage = class CargoPackage extends WorkspacePackage {
+var CargoPackage = class extends WorkspacePackage {
 	path;
 	manifest;
 	workspaceManifest;
@@ -23,69 +24,42 @@ var CargoPackage = class CargoPackage extends WorkspacePackage {
 		this.workspaceManifest = workspaceManifest;
 	}
 	get name() {
-		return stringValue(this.packageInfo.name);
+		return this.packageInfo.name;
 	}
 	get version() {
 		return stringValue(this.packageInfo.version) ?? this.workspaceVersion ?? "0.0.0";
 	}
-	get publish() {
-		return this.packageInfo.publish !== false;
-	}
-	setVersion(version) {
-		this.packageInfo.version = version;
-	}
-	async updateDependency(target, version, context) {
-		if (!(target instanceof CargoPackage)) return;
-		const next = semver.parse(version);
-		if (!next) return;
-		for (const table of dependencyTables(this.manifest)) for (const [rawName, rawSpec] of Object.entries(table)) {
-			const spec = tableValue(rawSpec);
-			const packageName = stringValue(spec?.package) ?? rawName;
-			if (packageName !== target.name) continue;
-			if (typeof rawSpec === "string") {
-				table[rawName] = (await this.updateRange(context, {
-					name: packageName,
-					range: rawSpec
-				}, next)).range;
-				continue;
-			}
-			if (spec) {
-				const current = stringValue(spec.version);
-				spec.version = current ? (await this.updateRange(context, {
-					name: packageName,
-					range: current
-				}, next)).range : next.format();
-			}
-		}
+	onPlan(context) {
+		const defaults = super.onPlan(context);
+		defaults.publish ??= this.packageInfo.publish !== false;
+		return defaults;
 	}
 	async write() {
 		await writeFile(join(this.path, "Cargo.toml"), stringify(this.manifest));
 	}
 	get packageInfo() {
-		return tableValue(this.manifest.package) ?? {};
+		this.manifest.package ??= {};
+		return this.manifest.package;
 	}
 	get workspaceVersion() {
 		return stringValue(tableValue(tableValue(this.workspaceManifest?.workspace)?.package)?.version);
 	}
 };
 var CargoRegistryClient = class {
-	graph;
 	id = "cargo";
 	#versionMap = /* @__PURE__ */ new Map();
-	constructor(graph) {
-		this.graph = graph;
-	}
+	constructor(_graph) {}
 	supports(pkg) {
 		return pkg instanceof CargoPackage;
 	}
-	async packageVersionExists(pkg, version) {
-		const cacheKey = `${pkg.id}@${version}`;
+	async isPackagePublished(pkg) {
+		const cacheKey = `${pkg.id}@${pkg.version}`;
 		let info = this.#versionMap.get(cacheKey);
 		if (!info) {
-			info = fetch(`https://crates.io/api/v1/crates/${encodeURIComponent(pkg.name)}/${version}`).then(async (response) => {
+			info = fetch(`https://crates.io/api/v1/crates/${encodeURIComponent(pkg.name)}/${pkg.version}`).then(async (response) => {
 				if (response.status === 200) return true;
 				if (response.status === 404) return false;
-				throw new Error(`Unable to validate ${pkg.name}@${version} against crates.io: ${await response.text()}`);
+				throw new Error(`Unable to validate ${pkg.name}@${pkg.version} against crates.io: ${await response.text()}`);
 			});
 			this.#versionMap.set(cacheKey, info);
 		}
@@ -97,16 +71,46 @@ var CargoRegistryClient = class {
 			throwOnError: true
 		});
 	}
-	async publishPlanStatus(plan) {
-		for (const [id, pkgPlan] of Object.entries(plan.packages)) {
-			const pkg = this.graph.get(id);
-			if (!(pkg instanceof CargoPackage) || !pkgPlan.publish) continue;
-			if (!await this.packageVersionExists(pkg, pkg.version)) return { state: "pending" };
-		}
-		return { state: "success" };
-	}
 };
-function cargo() {
+function cargo({ bumpDep: getBumpDepType = ({ kind }) => {
+	switch (kind) {
+		case "dependencies": return "patch";
+		case "build-dependencies":
+		case "dev-dependencies": return false;
+	}
+} } = {}) {
+	function updateRange(range, next) {
+		if (!semver.validRange(range)) return false;
+		if (new semver.Range(range).test(next)) return false;
+		return next;
+	}
+	function depsPolicy({ graph }) {
+		return {
+			id: "cargo:deps",
+			onUpdate({ pkg, plan }) {
+				for (const other of graph.getPackages()) {
+					if (!(other instanceof CargoPackage)) continue;
+					for (const { table, kind } of dependencyTables(other.manifest)) for (const [rawName, rawSpec] of Object.entries(table)) {
+						const spec = parseSpec(rawSpec);
+						if (!spec) continue;
+						const packageName = spec.package ?? rawName;
+						if (pkg.id !== `cargo:${packageName}`) continue;
+						if (updateRange(spec.version, plan.bumpVersion(pkg)) === false) continue;
+						const bumpType = getBumpDepType({
+							kind,
+							name: packageName,
+							version: spec.version
+						});
+						if (bumpType === false) continue;
+						this.bumpPackage(other, {
+							type: bumpType,
+							reason: `update dependency "${rawName}"`
+						});
+					}
+				}
+			}
+		};
+	}
 	return {
 		name: "cargo",
 		enforce: "pre",
@@ -115,6 +119,33 @@ function cargo() {
 		},
 		createRegistryClient() {
 			return new CargoRegistryClient(this.graph);
+		},
+		initPlan(plan) {
+			plan.addPolicy(depsPolicy(this));
+		},
+		async applyPlan(draft) {
+			const { graph } = this;
+			const writes = [];
+			for (const pkg of graph.getPackages()) {
+				if (!(pkg instanceof CargoPackage)) continue;
+				const plan = draft.getPackagePlan(pkg.id);
+				if (plan) pkg.packageInfo.version = plan.bumpVersion(pkg);
+			}
+			for (const pkg of graph.getPackages()) {
+				if (!(pkg instanceof CargoPackage)) continue;
+				for (const { table } of dependencyTables(pkg.manifest)) for (const [rawName, rawSpec] of Object.entries(table)) {
+					const spec = parseSpec(rawSpec);
+					if (!spec) continue;
+					const packageName = spec.package ?? rawName;
+					const linked = graph.get(`cargo:${packageName}`);
+					if (!linked || !(linked instanceof CargoPackage)) continue;
+					const result = updateRange(spec.version, linked.version);
+					if (result === false) continue;
+					table[rawName] = spec.setVersion(result);
+				}
+				writes.push(pkg.write());
+			}
+			await Promise.all(writes);
 		}
 	};
 }
@@ -159,7 +190,10 @@ function dependencyTables(manifest) {
 	const tables = [];
 	for (const field of DEP_FIELDS) {
 		const table = tableValue(manifest[field]);
-		if (table) tables.push(table);
+		if (table) tables.push({
+			kind: field,
+			table
+		});
 	}
 	const target = tableValue(manifest.target);
 	if (target) for (const targetConfig of Object.values(target)) {
@@ -167,14 +201,38 @@ function dependencyTables(manifest) {
 		if (!targetTable) continue;
 		for (const field of DEP_FIELDS) {
 			const table = tableValue(targetTable[field]);
-			if (table) tables.push(table);
+			if (table) tables.push({
+				kind: field,
+				table
+			});
 		}
 	}
 	return tables;
 }
+function parseSpec(v) {
+	if (typeof v === "string") return {
+		version: v,
+		setVersion(version) {
+			return version;
+		}
+	};
+	if (isTableValue(v)) return {
+		package: stringValue(v.package),
+		version: v.version,
+		setVersion(version) {
+			return {
+				...v,
+				version
+			};
+		}
+	};
+}
 async function readCargoManifest(path) {
 	return parse$1(await readFile(join(path, "Cargo.toml"), "utf8"));
 }
+function isTableValue(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
 function tableValue(value) {
 	if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
 	return value;

package/dist/providers/npm.d.ts

@@ -0,0 +1,2 @@
+import { _ as NpmPackage, b as npm, v as NpmPluginOptions, y as NpmRegistryClient } from "../index-Da6P6gSc.js";
+export { NpmPackage, NpmPluginOptions, NpmRegistryClient, npm };