tegami 1.0.0-beta.4 → 1.0.0-beta.5

package/dist/cargo-hlZX2akE.js

@@ -0,0 +1,292 @@
+import { n as execFailure } from "./error-We7chQVJ.js";
+import { n as WorkspacePackage } from "./graph-gThXu8Cz.js";
+import { readFile, writeFile } from "node:fs/promises";
+import { join, normalize } from "node:path";
+import { x } from "tinyexec";
+import * as semver$1 from "semver";
+import z from "zod";
+import initToml, { edit, parse as parse$1 } from "@rainbowatcher/toml-edit-js";
+import { glob } from "tinyglobby";
+//#region src/providers/cargo/schema.ts
+const cargoDependencySchema = z.union([z.string(), z.object({
+	version: z.string(),
+	package: z.string().optional(),
+	path: z.string().optional()
+})]);
+const cargoTargetConfigSchema = z.object({
+	dependencies: z.record(z.string(), cargoDependencySchema).optional(),
+	"dev-dependencies": z.record(z.string(), cargoDependencySchema).optional(),
+	"build-dependencies": z.record(z.string(), cargoDependencySchema).optional()
+});
+const cargoPackageSchema = z.object({
+	name: z.string(),
+	version: z.string().optional(),
+	publish: z.boolean().optional()
+});
+const cargoWorkspaceSchema = z.object({
+	members: z.array(z.string()).optional(),
+	exclude: z.array(z.string()).optional(),
+	package: z.object({ version: z.string().optional() }).optional()
+});
+const cargoManifestSchema = z.object({
+	package: cargoPackageSchema,
+	workspace: cargoWorkspaceSchema.optional(),
+	dependencies: z.record(z.string(), cargoDependencySchema).optional(),
+	"dev-dependencies": z.record(z.string(), cargoDependencySchema).optional(),
+	"build-dependencies": z.record(z.string(), cargoDependencySchema).optional(),
+	target: z.record(z.string(), cargoTargetConfigSchema).optional()
+});
+//#endregion
+//#region src/providers/cargo.ts
+const DEP_FIELDS = [
+	"dependencies",
+	"dev-dependencies",
+	"build-dependencies"
+];
+var CargoPackage = class extends WorkspacePackage {
+	path;
+	manifest;
+	content;
+	workspaceManifest;
+	manager = "cargo";
+	constructor(path, manifest, content, workspaceManifest) {
+		super();
+		this.path = path;
+		this.manifest = manifest;
+		this.content = content;
+		this.workspaceManifest = workspaceManifest;
+	}
+	get name() {
+		return this.packageInfo.name;
+	}
+	get version() {
+		return this.packageInfo.version ?? this.workspaceVersion;
+	}
+	setVersion(version) {
+		this.packageInfo.version = version;
+		this.patch("package.version", version);
+	}
+	async write() {
+		await writeFile(join(this.path, "Cargo.toml"), this.content + "\n");
+	}
+	patch(path, value) {
+		this.content = edit(this.content, path, value);
+	}
+	get packageInfo() {
+		return this.manifest.package;
+	}
+	get workspaceVersion() {
+		return this.workspaceManifest?.workspace?.package?.version;
+	}
+};
+function cargo({ updateLockFile = true, bumpDep: getBumpDepType } = {}) {
+	let active = false;
+	return {
+		name: "cargo",
+		enforce: "pre",
+		async init() {
+			await initToml();
+		},
+		async resolve() {
+			await discoverCargoPackages(this.cwd, (pkg) => this.graph.add(pkg));
+			active = this.graph.getPackages().some((pkg) => pkg instanceof CargoPackage);
+		},
+		initDraft(plan) {
+			if (!active) return;
+			plan.addPolicy(depsPolicy(this, getBumpDepType));
+		},
+		async publishPreflight({ pkg }) {
+			if (!(pkg instanceof CargoPackage)) return;
+			const wait = [];
+			for (const { table } of dependencyTables(pkg.manifest, "")) for (const [rawName, dep] of Object.entries(table)) {
+				if (!dep || typeof dep === "string" || !dep.path) continue;
+				const id = `cargo:${dep.package ?? rawName}`;
+				const linked = this.graph.get(id);
+				if (!linked || !(linked instanceof CargoPackage)) continue;
+				wait.push(id);
+			}
+			return {
+				shouldPublish: pkg.version !== void 0 && pkg.packageInfo.publish !== false,
+				wait
+			};
+		},
+		resolvePlanStatus({ plan }) {
+			return Array.from(plan.packages, async ([id, { preflight }]) => {
+				if (!preflight.shouldPublish) return;
+				const pkg = this.graph.get(id);
+				if (!(pkg instanceof CargoPackage) || !pkg.version) return;
+				if (!await isPackagePublished(pkg.name, pkg.version)) return "pending";
+			});
+		},
+		async publish({ pkg }) {
+			if (!(pkg instanceof CargoPackage)) return;
+			const result = await x("cargo", ["publish"], { nodeOptions: { cwd: pkg.path } });
+			if (result.exitCode !== 0) {
+				if (/already exists|already published/i.test(`${result.stdout}\n${result.stderr}`)) return { type: "skipped" };
+				return {
+					type: "failed",
+					error: execFailure(`Failed to publish ${pkg.name}@${pkg.version}.`, result).message
+				};
+			}
+			return { type: "published" };
+		},
+		async applyDraft(draft) {
+			if (!active) return;
+			const { graph } = this;
+			const writes = [];
+			for (const pkg of graph.getPackages()) {
+				if (!(pkg instanceof CargoPackage)) continue;
+				const bumped = draft.getPackageDraft(pkg.id)?.bumpVersion(pkg);
+				if (bumped) pkg.setVersion(bumped);
+			}
+			for (const pkg of graph.getPackages()) {
+				if (!(pkg instanceof CargoPackage)) continue;
+				for (const { table, path: tablePath } of dependencyTables(pkg.manifest, "")) for (const [rawName, rawSpec] of Object.entries(table)) {
+					const spec = parseSpec(rawSpec);
+					if (!spec || !semver$1.validRange(spec.version)) continue;
+					const packageName = spec.package ?? rawName;
+					const linked = graph.get(`cargo:${packageName}`);
+					if (!linked || !(linked instanceof CargoPackage)) continue;
+					if (!linked.version || semver$1.satisfies(linked.version, spec.version)) continue;
+					let updatedRange;
+					if (spec.version.startsWith("^")) updatedRange = `^${linked.version}`;
+					else if (spec.version.startsWith("~")) updatedRange = `~${linked.version}`;
+					else updatedRange = linked.version;
+					table[rawName] = spec.setVersion(updatedRange);
+					pkg.patch(typeof rawSpec === "string" ? `${tablePath}.${rawName}` : `${tablePath}.${rawName}.version`, updatedRange);
+				}
+				writes.push(pkg.write());
+			}
+			await Promise.all(writes);
+		},
+		async applyCliDraft() {
+			if (!active || !updateLockFile) return;
+			const result = await x("cargo", ["update", "--workspace"], { nodeOptions: { cwd: this.cwd } });
+			if (result.exitCode !== 0) throw execFailure("Failed to update Cargo lock file", result);
+		}
+	};
+}
+function depsPolicy({ graph }, getBumpDepType = ({ kind }) => {
+	switch (kind) {
+		case "dependencies": return "patch";
+		case "build-dependencies":
+		case "dev-dependencies": return false;
+	}
+}) {
+	return {
+		id: "cargo:deps",
+		onUpdate({ pkg, packageDraft: plan }) {
+			if (!(pkg instanceof CargoPackage)) return;
+			const group = graph.getPackageGroup(pkg.id);
+			for (const dependent of graph.getPackages()) {
+				if (!(dependent instanceof CargoPackage)) continue;
+				for (const { table, kind } of dependencyTables(dependent.manifest, "")) for (const [rawName, rawSpec] of Object.entries(table)) {
+					const spec = parseSpec(rawSpec);
+					if (!spec || !semver$1.validRange(spec.version)) continue;
+					if (pkg.id !== `cargo:${spec.package ?? rawName}`) continue;
+					if (group?.options.syncBump && graph.getPackageGroup(dependent.id) === group) continue;
+					const bumped = plan.bumpVersion(pkg);
+					if (!bumped || semver$1.satisfies(bumped, spec.version)) continue;
+					const bumpType = getBumpDepType({
+						kind,
+						dependent,
+						name: pkg.name,
+						version: spec.version
+					});
+					if (bumpType === false) continue;
+					this.bumpPackage(dependent, {
+						type: bumpType,
+						reason: `update dependency "${rawName}"`
+					});
+				}
+			}
+		}
+	};
+}
+async function isPackagePublished(name, version) {
+	const response = await fetch(`https://crates.io/api/v1/crates/${encodeURIComponent(name)}/${version}`);
+	if (response.status === 200) return true;
+	if (response.status === 404) return false;
+	throw new Error(`Unable to validate ${name}@${version} against crates.io: ${await response.text()}`);
+}
+async function buildEntry(path) {
+	try {
+		const content = await readFile(join(path, "Cargo.toml"), "utf8");
+		return {
+			manifest: cargoManifestSchema.parse(parse$1(content)),
+			content,
+			path
+		};
+	} catch {
+		return;
+	}
+}
+async function discoverCargoPackages(cwd, add) {
+	const root = await buildEntry(cwd);
+	if (!root) return;
+	if (root.manifest.package?.name) add(new CargoPackage(cwd, root.manifest, root.content, root.manifest));
+	const workspace = root.manifest.workspace;
+	if (!workspace?.members) return;
+	const paths = await expandWorkspaceMembers(cwd, workspace.members, workspace.exclude);
+	const manifests = await Promise.all(paths.map(buildEntry));
+	for (const entry of manifests) if (entry?.manifest.package?.name) add(new CargoPackage(entry.path, entry.manifest, entry.content, root.manifest));
+}
+async function expandWorkspaceMembers(cwd, members, exclude = []) {
+	const paths = members.includes(".") ? [cwd] : [];
+	const patterns = members.filter((member) => member !== ".");
+	if (patterns.length > 0) paths.push(...await glob(patterns, {
+		absolute: true,
+		cwd,
+		ignore: ["**/target/**", ...exclude],
+		onlyDirectories: true,
+		onlyFiles: false
+	}));
+	return paths.map(normalize);
+}
+function dependencyTables(manifest, prefix) {
+	const tables = [];
+	for (const field of DEP_FIELDS) {
+		const table = manifest[field];
+		if (table) {
+			const path = prefix ? `${prefix}.${field}` : field;
+			tables.push({
+				kind: field,
+				table,
+				path
+			});
+		}
+	}
+	const target = manifest.target;
+	if (target) for (const [targetKey, targetConfig] of Object.entries(target)) {
+		const targetPath = prefix ? `${prefix}.target.${targetKey}` : `target.${targetKey}`;
+		for (const field of DEP_FIELDS) {
+			const table = targetConfig[field];
+			if (table) tables.push({
+				kind: field,
+				table,
+				path: `${targetPath}.${field}`
+			});
+		}
+	}
+	return tables;
+}
+function parseSpec(v) {
+	if (typeof v === "string") return {
+		version: v,
+		setVersion(version) {
+			return version;
+		}
+	};
+	return {
+		package: v.package,
+		version: v.version,
+		setVersion(version) {
+			return {
+				...v,
+				version
+			};
+		}
+	};
+}
+//#endregion
+export { cargo as n, CargoPackage as t };

package/dist/cli/index.d.ts

@@ -1,4 +1,4 @@
-import { O as Draft, _ as PublishPlan, t as Awaitable, u as Tegami } from "../types-DKZsadC8.js";
+import { O as Draft, _ as PublishPlan, t as Awaitable, u as Tegami } from "../types-C1rEqeM4.js";
 
 //#region src/cli/index.d.ts
 interface TegamiCLIOptions {

package/dist/cli/index.js

@@ -349,10 +349,10 @@ function parseCommandArgs(command, args) {
 		type: "boolean",
 		short: "h"
 	} };
-	for (const option of command.options) optionConfig[option.name] = {
+	for (const option of command.options) optionConfig[option.name] = option.short ? {
 		type: option.type,
 		short: option.short
-	};
+	} : { type: option.type };
 	const parsed = parseArgs({
 		args,
 		options: optionConfig,
@@ -453,8 +453,14 @@ function registerCoreCommands(cli, tegami, options) {
 	cli.command("", { description: "create changelog files interactively" }).action(async () => {
 		await runChangelogTui(tegami);
 	});
-	cli.command("version", { description: "draft version changes and write the publish lock" }).action(async () => {
-		await versionPackages(tegami, { cli: options });
+	cli.command("version", { description: "draft version changes and write the publish lock" }).option("no-checks", {
+		type: "boolean",
+		description: "skip checking whether the publish lock is still pending"
+	}).action(async ({ values }) => {
+		await versionPackages(tegami, {
+			cli: options,
+			noChecks: values["no-checks"]
+		});
 	});
 	cli.command("ci", { description: "version and publish packages" }).action(async () => {
 		if (await versionPackages(tegami, { cli: options })) return;
@@ -499,7 +505,7 @@ async function versionPackages(tegami, options) {
 		outro("No versions changed.");
 		return false;
 	}
-	if (await tegami.publishStatus() === "pending") {
+	if (!options.noChecks && await tegami.publishStatus() === "pending") {
 		note(`Publish lock at ${context.lockPath} is still pending. Publish it before applying a new draft.`);
 		outro("Cannot apply.");
 		return false;

package/dist/generators/simple.d.ts

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

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-import { A as PackageDraft, D as WorkspacePackage, E as PackageGroup, O as Draft, T as PackageGraph, _ as PublishPlan, a as PublishPreflight, c as TegamiPluginOption, d as tegami, f as CommitChangelog, g as PublishOptions, h as PackagePublishResult, i as PackageOptions, k as DraftPolicy, l as GenerateChangelogOptions, m as PackagePublishPlan, n as GroupOptions, o as TegamiOptions, p as PublishLock, r as LogGenerator, s as TegamiPlugin, u as Tegami } from "./types-DKZsadC8.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 };
+import { A as PackageDraft, D as WorkspacePackage, E as PackageGroup, O as Draft, T as PackageGraph, _ as PublishPlan, a as PublishPreflight, c as TegamiPluginOption, d as tegami, f as CommitChangelog, g as PublishOptions, h as PackagePublishResult, i as PackageOptions, j as BumpType, k as DraftPolicy, l as GenerateChangelogOptions, m as PackagePublishPlan, n as GroupOptions, o as TegamiOptions, p as PublishLock, r as LogGenerator, s as TegamiPlugin, u as Tegami, w as TegamiContext } from "./types-C1rEqeM4.js";
+export { type BumpType, type CommitChangelog, type Draft, type DraftPolicy, GenerateChangelogOptions, type GroupOptions, type LogGenerator, type PackageDraft, PackageGraph, type PackageGroup, type PackageOptions, type PackagePublishPlan, type PackagePublishResult, type PublishLock, type PublishOptions, type PublishPlan, type PublishPreflight, Tegami, type TegamiContext, type TegamiOptions, type TegamiPlugin, type TegamiPluginOption, WorkspacePackage, tegami };

package/dist/index.js

@@ -1,7 +1,7 @@
 import { n as generateFromCommits } from "./generate-BfYdNTFi.js";
 import { r as handlePluginError, s as somePromise } from "./error-We7chQVJ.js";
-import { t as PackageGraph } from "./graph-gThXu8Cz.js";
-import { cargo } from "./providers/cargo.js";
+import { n as WorkspacePackage, t as PackageGraph } from "./graph-gThXu8Cz.js";
+import { n as cargo } from "./cargo-hlZX2akE.js";
 import { n as npm } from "./npm-CMOyacwf.js";
 import { a as parseChangelogFile, i as parsePublishLock, n as createDraft, o as readChangelogEntries, r as packageStoreSchema, t as changelogStoreSchema } from "./draft-DtFyGxe8.js";
 import fs, { mkdir, rm, writeFile } from "node:fs/promises";
@@ -268,4 +268,4 @@ function tegami(options = {}) {
 	};
 }
 //#endregion
-export { tegami };
+export { PackageGraph, WorkspacePackage, tegami };

package/dist/plugins/git.d.ts

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

package/dist/plugins/git.js

@@ -52,7 +52,20 @@ function git(options = {}) {
 		async resolvePlanStatus({ plan }) {
 			const pendingTags = getPendingTags(plan);
 			return Array.from(pendingTags, async (tag) => {
-				if (!await gitTagExists(this.cwd, tag)) return "pending";
+				if ((await x("git", [
+					"rev-parse",
+					"-q",
+					"--verify",
+					`refs/tags/${tag}`
+				], { nodeOptions: { cwd: this.cwd } })).exitCode === 0) return;
+				if ((await x("git", [
+					"ls-remote",
+					"--exit-code",
+					"--tags",
+					"origin",
+					`refs/tags/${tag}`
+				], { nodeOptions: { cwd: this.cwd } })).exitCode === 0) return;
+				return "pending";
 			});
 		},
 		async afterPublishAll({ plan }) {
@@ -74,18 +87,13 @@ function git(options = {}) {
 					"origin",
 					...createdTags
 				], { nodeOptions: { cwd } });
-				if (gitOut.exitCode !== 0) throw execFailure(`Failed to push Git tags to origin: ${createdTags.join(", ")}`, gitOut);
+				if (gitOut.exitCode !== 0) {
+					if (/already exists/i.test(`${gitOut.stdout}\n${gitOut.stderr}`)) return;
+					throw execFailure(`Failed to push Git tags to origin: ${createdTags.join(", ")}`, gitOut);
+				}
 			}
 		}
 	};
 }
-async function gitTagExists(cwd, tag) {
-	return (await x("git", [
-		"rev-parse",
-		"-q",
-		"--verify",
-		`refs/tags/${tag}`
-	], { nodeOptions: { cwd } })).exitCode === 0;
-}
 //#endregion
 export { git };

package/dist/plugins/github.d.ts

@@ -1,4 +1,4 @@
-import { D as WorkspacePackage, O as Draft, _ as PublishPlan, s as TegamiPlugin, t as Awaitable, w as TegamiContext } from "../types-DKZsadC8.js";
+import { D as WorkspacePackage, O as Draft, _ as PublishPlan, s as TegamiPlugin, t as Awaitable, w as TegamiContext } from "../types-C1rEqeM4.js";
 import { GitPluginOptions } from "./git.js";
 
 //#region src/plugins/github.d.ts

package/dist/plugins/github.js

@@ -3,7 +3,7 @@ import { t as changelogFilename } from "../generate-BfYdNTFi.js";
 import { a as cached, n as execFailure, o as isCI } from "../error-We7chQVJ.js";
 import { n as createDraft, o as readChangelogEntries } from "../draft-DtFyGxe8.js";
 import { git } from "./git.js";
-import { n as createVersionRequestBody, r as hasGitChanges, t as commitVersionBranchChanges } from "../version-request-cFS0Suzd.js";
+import { n as createVersionRequestBody, r as hasGitChanges, t as commitVersionBranchChanges } from "../version-request-DKvR3_xb.js";
 import { readFile, writeFile } from "node:fs/promises";
 import { basename, join, relative, resolve } from "node:path";
 import { x } from "tinyexec";

package/dist/plugins/gitlab.d.ts

@@ -1,4 +1,4 @@
-import { D as WorkspacePackage, O as Draft, _ as PublishPlan, s as TegamiPlugin, t as Awaitable, w as TegamiContext } from "../types-DKZsadC8.js";
+import { D as WorkspacePackage, O as Draft, _ as PublishPlan, s as TegamiPlugin, t as Awaitable, w as TegamiContext } from "../types-C1rEqeM4.js";
 import { GitPluginOptions } from "./git.js";
 
 //#region src/plugins/gitlab.d.ts

package/dist/plugins/gitlab.js

@@ -3,7 +3,7 @@ import { t as changelogFilename } from "../generate-BfYdNTFi.js";
 import { a as cached, n as execFailure, o as isCI } from "../error-We7chQVJ.js";
 import { n as createDraft, o as readChangelogEntries } from "../draft-DtFyGxe8.js";
 import { git } from "./git.js";
-import { n as createVersionRequestBody, r as hasGitChanges, t as commitVersionBranchChanges } from "../version-request-cFS0Suzd.js";
+import { n as createVersionRequestBody, r as hasGitChanges, t as commitVersionBranchChanges } from "../version-request-DKvR3_xb.js";
 import { readFile, writeFile } from "node:fs/promises";
 import { basename, join, relative, resolve } from "node:path";
 import { x } from "tinyexec";

package/dist/plugins/go.d.ts

@@ -1,4 +1,4 @@
-import { D as WorkspacePackage, j as BumpType, s as TegamiPlugin } from "../types-DKZsadC8.js";
+import { D as WorkspacePackage, j as BumpType, s as TegamiPlugin } from "../types-C1rEqeM4.js";
 
 //#region src/plugins/go.d.ts
 interface GoModFile {

package/dist/providers/cargo.d.ts

@@ -1,2 +1,2 @@
-import { b as cargo, v as CargoPackage, y as CargoPluginOptions } from "../types-DKZsadC8.js";
+import { b as cargo, v as CargoPackage, y as CargoPluginOptions } from "../types-C1rEqeM4.js";
 export { CargoPackage, CargoPluginOptions, cargo };

package/dist/providers/cargo.js

@@ -1,281 +1,2 @@
-import { i as isNodeError, n as execFailure } from "../error-We7chQVJ.js";
-import { n as WorkspacePackage } from "../graph-gThXu8Cz.js";
-import { readFile, writeFile } from "node:fs/promises";
-import { join, normalize } from "node:path";
-import { x } from "tinyexec";
-import * as semver$1 from "semver";
-import initToml, { edit, parse as parse$1 } from "@rainbowatcher/toml-edit-js";
-import { glob } from "tinyglobby";
-//#region src/providers/cargo.ts
-const DEP_FIELDS = [
-	"dependencies",
-	"dev-dependencies",
-	"build-dependencies"
-];
-var CargoPackage = class extends WorkspacePackage {
-	path;
-	manifest;
-	content;
-	workspaceManifest;
-	manager = "cargo";
-	constructor(path, manifest, content, workspaceManifest) {
-		super();
-		this.path = path;
-		this.manifest = manifest;
-		this.content = content;
-		this.workspaceManifest = workspaceManifest;
-	}
-	get name() {
-		return this.packageInfo.name;
-	}
-	get version() {
-		return stringValue(this.packageInfo.version) ?? this.workspaceVersion;
-	}
-	setVersion(version) {
-		this.packageInfo.version = version;
-		this.patch("package.version", version);
-	}
-	async write() {
-		await writeFile(join(this.path, "Cargo.toml"), this.content + "\n");
-	}
-	patch(path, value) {
-		this.content = edit(this.content, path, value);
-	}
-	get packageInfo() {
-		this.manifest.package ??= {};
-		return this.manifest.package;
-	}
-	get workspaceVersion() {
-		return stringValue(tableValue(tableValue(this.workspaceManifest?.workspace)?.package)?.version);
-	}
-};
-function cargo({ updateLockFile = true, bumpDep: getBumpDepType } = {}) {
-	let active = false;
-	return {
-		name: "cargo",
-		enforce: "pre",
-		async init() {
-			await initToml();
-		},
-		async resolve() {
-			await discoverCargoPackages(this.cwd, (pkg) => this.graph.add(pkg));
-			active = this.graph.getPackages().some((pkg) => pkg instanceof CargoPackage);
-		},
-		initDraft(plan) {
-			if (!active) return;
-			plan.addPolicy(depsPolicy(this, getBumpDepType));
-		},
-		async publishPreflight({ pkg }) {
-			if (!(pkg instanceof CargoPackage)) return;
-			const wait = [];
-			for (const { table } of dependencyTables(pkg.manifest, "")) for (const [rawName, rawSpec] of Object.entries(table)) {
-				if (!isTableValue(rawSpec) || typeof rawSpec.path !== "string") continue;
-				const id = `cargo:${stringValue(rawSpec.package) ?? rawName}`;
-				const linked = this.graph.get(id);
-				if (!linked || !(linked instanceof CargoPackage)) continue;
-				wait.push(id);
-			}
-			return {
-				shouldPublish: pkg.version !== void 0 && pkg.packageInfo.publish !== false,
-				wait
-			};
-		},
-		resolvePlanStatus({ plan }) {
-			return Array.from(plan.packages, async ([id, { preflight }]) => {
-				if (!preflight.shouldPublish) return;
-				const pkg = this.graph.get(id);
-				if (!(pkg instanceof CargoPackage) || !pkg.version) return;
-				if (!await isPackagePublished(pkg.name, pkg.version)) return "pending";
-			});
-		},
-		async publish({ pkg }) {
-			if (!(pkg instanceof CargoPackage)) return;
-			const result = await x("cargo", ["publish"], { nodeOptions: { cwd: pkg.path } });
-			if (result.exitCode !== 0) {
-				if (/already exists|already published/i.test(`${result.stdout}\n${result.stderr}`)) return { type: "skipped" };
-				return {
-					type: "failed",
-					error: execFailure(`Failed to publish ${pkg.name}@${pkg.version}.`, result).message
-				};
-			}
-			return { type: "published" };
-		},
-		async applyDraft(draft) {
-			if (!active) return;
-			const { graph } = this;
-			const writes = [];
-			for (const pkg of graph.getPackages()) {
-				if (!(pkg instanceof CargoPackage)) continue;
-				const bumped = draft.getPackageDraft(pkg.id)?.bumpVersion(pkg);
-				if (bumped) pkg.setVersion(bumped);
-			}
-			for (const pkg of graph.getPackages()) {
-				if (!(pkg instanceof CargoPackage)) continue;
-				for (const { table, path: tablePath } of dependencyTables(pkg.manifest, "")) for (const [rawName, rawSpec] of Object.entries(table)) {
-					const spec = parseSpec(rawSpec);
-					if (!spec || !semver$1.validRange(spec.version)) continue;
-					const packageName = spec.package ?? rawName;
-					const linked = graph.get(`cargo:${packageName}`);
-					if (!linked || !(linked instanceof CargoPackage)) continue;
-					if (!linked.version || semver$1.satisfies(linked.version, spec.version)) continue;
-					let updatedRange;
-					if (spec.version.startsWith("^")) updatedRange = `^${linked.version}`;
-					else if (spec.version.startsWith("~")) updatedRange = `~${linked.version}`;
-					else updatedRange = linked.version;
-					table[rawName] = spec.setVersion(updatedRange);
-					pkg.patch(typeof rawSpec === "string" ? `${tablePath}.${rawName}` : `${tablePath}.${rawName}.version`, updatedRange);
-				}
-				writes.push(pkg.write());
-			}
-			await Promise.all(writes);
-		},
-		async applyCliDraft() {
-			if (!active || !updateLockFile) return;
-			const result = await x("cargo", ["update", "--workspace"], { nodeOptions: { cwd: this.cwd } });
-			if (result.exitCode !== 0) throw execFailure("Failed to update Cargo lock file", result);
-		}
-	};
-}
-function depsPolicy({ graph }, getBumpDepType = ({ kind }) => {
-	switch (kind) {
-		case "dependencies": return "patch";
-		case "build-dependencies":
-		case "dev-dependencies": return false;
-	}
-}) {
-	return {
-		id: "cargo:deps",
-		onUpdate({ pkg, packageDraft: plan }) {
-			if (!(pkg instanceof CargoPackage)) return;
-			const group = graph.getPackageGroup(pkg.id);
-			for (const dependent of graph.getPackages()) {
-				if (!(dependent instanceof CargoPackage)) continue;
-				for (const { table, kind } of dependencyTables(dependent.manifest, "")) for (const [rawName, rawSpec] of Object.entries(table)) {
-					const spec = parseSpec(rawSpec);
-					if (!spec || !semver$1.validRange(spec.version)) continue;
-					if (pkg.id !== `cargo:${spec.package ?? rawName}`) continue;
-					if (group?.options.syncBump && graph.getPackageGroup(dependent.id) === group) continue;
-					const bumped = plan.bumpVersion(pkg);
-					if (!bumped || semver$1.satisfies(bumped, spec.version)) continue;
-					const bumpType = getBumpDepType({
-						kind,
-						dependent,
-						name: pkg.name,
-						version: spec.version
-					});
-					if (bumpType === false) continue;
-					this.bumpPackage(dependent, {
-						type: bumpType,
-						reason: `update dependency "${rawName}"`
-					});
-				}
-			}
-		}
-	};
-}
-async function isPackagePublished(name, version) {
-	const response = await fetch(`https://crates.io/api/v1/crates/${encodeURIComponent(name)}/${version}`);
-	if (response.status === 200) return true;
-	if (response.status === 404) return false;
-	throw new Error(`Unable to validate ${name}@${version} against crates.io: ${await response.text()}`);
-}
-async function discoverCargoPackages(cwd, add) {
-	const root = await readCargoManifest(cwd).catch((error) => {
-		if (isNodeError(error) && error.code === "ENOENT") return void 0;
-		throw error;
-	});
-	if (!root) return;
-	addCargoPackage(cwd, root.manifest, root.content, root.manifest, add);
-	const workspace = tableValue(root.manifest.workspace);
-	const members = workspace?.members;
-	if (!workspace || !Array.isArray(members)) return;
-	const exclude = Array.isArray(workspace.exclude) ? workspace.exclude.filter((member) => typeof member === "string") : [];
-	const paths = await expandWorkspaceMembers(cwd, members.filter((member) => typeof member === "string"), exclude);
-	const manifests = await Promise.all(paths.map((path) => readCargoManifest(path).then((manifest) => ({
-		path,
-		manifest
-	})).catch(() => void 0)));
-	for (const entry of manifests) if (entry) addCargoPackage(entry.path, entry.manifest.manifest, entry.manifest.content, root.manifest, add);
-}
-function addCargoPackage(path, manifest, content, workspaceManifest, add) {
-	if (!tableValue(manifest.package)?.name) return;
-	add(new CargoPackage(path, manifest, content, workspaceManifest));
-}
-async function expandWorkspaceMembers(cwd, members, exclude) {
-	const paths = members.includes(".") ? [cwd] : [];
-	const patterns = members.filter((member) => member !== ".");
-	if (patterns.length > 0) paths.push(...await glob(patterns, {
-		absolute: true,
-		cwd,
-		ignore: ["**/target/**", ...exclude],
-		onlyDirectories: true,
-		onlyFiles: false
-	}));
-	return paths.map(normalize);
-}
-function dependencyTables(manifest, prefix) {
-	const tables = [];
-	for (const field of DEP_FIELDS) {
-		const table = tableValue(manifest[field]);
-		if (table) {
-			const path = prefix ? `${prefix}.${field}` : field;
-			tables.push({
-				kind: field,
-				table,
-				path
-			});
-		}
-	}
-	const target = tableValue(manifest.target);
-	if (target) for (const [targetKey, targetConfig] of Object.entries(target)) {
-		const targetTable = tableValue(targetConfig);
-		if (!targetTable) continue;
-		const targetPath = prefix ? `${prefix}.target.${targetKey}` : `target.${targetKey}`;
-		for (const field of DEP_FIELDS) {
-			const table = tableValue(targetTable[field]);
-			if (table) tables.push({
-				kind: field,
-				table,
-				path: `${targetPath}.${field}`
-			});
-		}
-	}
-	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) {
-	const content = await readFile(join(path, "Cargo.toml"), "utf8");
-	return {
-		manifest: parse$1(content),
-		content
-	};
-}
-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;
-}
-function stringValue(value) {
-	return typeof value === "string" ? value : void 0;
-}
-//#endregion
+import { n as cargo, t as CargoPackage } from "../cargo-hlZX2akE.js";
 export { CargoPackage, cargo };

package/dist/providers/npm.d.ts

@@ -1,2 +1,2 @@
-import { C as npm, S as NpmPluginOptions, x as NpmPackage } from "../types-DKZsadC8.js";
+import { C as npm, S as NpmPluginOptions, x as NpmPackage } from "../types-C1rEqeM4.js";
 export { NpmPackage, NpmPluginOptions, npm };

package/dist/{types-DKZsadC8.d.ts → types-C1rEqeM4.d.ts}

@@ -258,25 +258,74 @@ declare function npm({
   bumpDep: getBumpDepType
 }?: NpmPluginOptions): TegamiPlugin;
 //#endregion
+//#region src/providers/cargo/schema.d.ts
+declare const cargoManifestSchema: z.ZodObject<{
+  package: z.ZodObject<{
+    name: z.ZodString;
+    version: z.ZodOptional<z.ZodString>;
+    publish: z.ZodOptional<z.ZodBoolean>;
+  }, z.core.$strip>;
+  workspace: z.ZodOptional<z.ZodObject<{
+    members: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    package: z.ZodOptional<z.ZodObject<{
+      version: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+  }, z.core.$strip>>;
+  dependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    version: z.ZodString;
+    package: z.ZodOptional<z.ZodString>;
+    path: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>]>>>;
+  "dev-dependencies": z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    version: z.ZodString;
+    package: z.ZodOptional<z.ZodString>;
+    path: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>]>>>;
+  "build-dependencies": z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    version: z.ZodString;
+    package: z.ZodOptional<z.ZodString>;
+    path: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>]>>>;
+  target: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+    dependencies: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+      version: z.ZodString;
+      package: z.ZodOptional<z.ZodString>;
+      path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>>;
+    "dev-dependencies": z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+      version: z.ZodString;
+      package: z.ZodOptional<z.ZodString>;
+      path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>>;
+    "build-dependencies": z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+      version: z.ZodString;
+      package: z.ZodOptional<z.ZodString>;
+      path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>>;
+  }, z.core.$strip>>>;
+}, z.core.$strip>;
+type CargoManifest = z.infer<typeof cargoManifestSchema>;
+//#endregion
 //#region src/providers/cargo.d.ts
-interface TomlTable {
-  [key: string]: TomlValue;
-}
-type TomlValue = string | number | boolean | TomlTable | TomlValue[];
 declare const DEP_FIELDS: readonly ["dependencies", "dev-dependencies", "build-dependencies"];
 declare class CargoPackage extends WorkspacePackage {
   readonly path: string;
-  readonly manifest: TomlTable;
+  readonly manifest: CargoManifest;
   private content;
   private readonly workspaceManifest?;
   readonly manager = "cargo";
-  constructor(path: string, manifest: TomlTable, content: string, workspaceManifest?: TomlTable | undefined);
+  constructor(path: string, manifest: CargoManifest, content: string, workspaceManifest?: CargoManifest | undefined);
   get name(): string;
   get version(): string | undefined;
   setVersion(version: string): void;
   write(): Promise<void>;
   patch(path: string, value: unknown): void;
-  get packageInfo(): TomlTable;
+  get packageInfo(): {
+    name: string;
+    version?: string | undefined;
+    publish?: boolean | undefined;
+  };
   private get workspaceVersion();
 }
 interface CargoPluginOptions {

package/dist/utils/index.d.ts

@@ -0,0 +1,6 @@
+import { Result } from "tinyexec";
+
+//#region src/utils/error.d.ts
+declare function execFailure(context: string, result: Awaited<Result>): Error;
+//#endregion
+export { execFailure };

package/dist/utils/index.js

@@ -0,0 +1,2 @@
+import { n as execFailure } from "../error-We7chQVJ.js";
+export { execFailure };

package/dist/{version-request-cFS0Suzd.js → version-request-DKvR3_xb.js}

@@ -3,7 +3,9 @@ import { n as execFailure } from "./error-We7chQVJ.js";
 import { x } from "tinyexec";
 //#region src/utils/version-request.ts
 async function hasGitChanges(cwd) {
-	return (await x("git", ["status", "--porcelain"], { nodeOptions: { cwd } })).stdout.trim().length > 0;
+	const result = await x("git", ["status", "--porcelain"], { nodeOptions: { cwd } });
+	if (result.exitCode !== 0) throw execFailure("Failed to check git status.", result);
+	return result.stdout.trim().length > 0;
 }
 async function commitVersionBranchChanges(cwd, branch, title) {
 	const gitOptions = { nodeOptions: { cwd } };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tegami",
-  "version": "1.0.0-beta.4",
+  "version": "1.0.0-beta.5",
   "description": "Utility for package versioning & publish",
   "license": "MIT",
   "author": "Fuma Nama",
@@ -22,6 +22,7 @@
     "./plugins/go": "./dist/plugins/go.js",
     "./providers/cargo": "./dist/providers/cargo.js",
     "./providers/npm": "./dist/providers/npm.js",
+    "./utils": "./dist/utils/index.js",
     "./package.json": "./package.json"
   },
   "publishConfig": {
@@ -30,7 +31,7 @@
   "dependencies": {
     "@clack/prompts": "^1.6.0",
     "@rainbowatcher/toml-edit-js": "^0.6.5",
-    "js-yaml": "^5.1.0",
+    "js-yaml": "^5.2.0",
     "package-manager-detector": "^1.6.0",
     "semver": "^7.8.5",
     "tinyexec": "^1.2.4",
@@ -38,7 +39,7 @@
     "zod": "^4.4.3"
   },
   "devDependencies": {
-    "@types/node": "^26.0.0",
+    "@types/node": "^26.0.1",
     "@types/semver": "^7.7.1",
     "tsdown": "^0.22.3",
     "typescript": "6.0.3",