tegami 1.0.0-beta.3 → 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,6 +1,4 @@
-import { p as PublishPlan, t as Awaitable, w as Draft } from "../types-BHT_9k9p.js";
-import { n as Tegami } from "../index-syNgzQTi.js";
-import { Command } from "commander";
+import { O as Draft, _ as PublishPlan, t as Awaitable, u as Tegami } from "../types-C1rEqeM4.js";
 
 //#region src/cli/index.d.ts
 interface TegamiCLIOptions {
@@ -8,6 +6,10 @@ interface TegamiCLIOptions {
   version?: () => Awaitable<Draft>;
   publish?: () => Awaitable<PublishPlan>;
 }
-declare function createCli(tegami: Tegami, options?: TegamiCLIOptions): Command;
+interface TegamiCLI {
+  parseAsync(argv?: string[]): Promise<void>;
+}
+declare function createCli(tegami: Tegami, options?: TegamiCLIOptions): TegamiCLI;
+declare function runCli(tegami: Tegami, options?: TegamiCLIOptions): Promise<void>;
 //#endregion
-export { TegamiCLIOptions, createCli };
+export { TegamiCLI, TegamiCLIOptions, createCli, runCli };