tegami 0.0.0

package/dist/npm-BSE_dtB3.mjs

@@ -0,0 +1,280 @@
+import { n as WorkspacePackage, r as isNodeError } from "./workspace-B5_i21S0.mjs";
+import { readFile, writeFile } from "node:fs/promises";
+import { join, normalize } from "node:path";
+import { x } from "tinyexec";
+import * as semver from "semver";
+import { glob } from "tinyglobby";
+import { load } from "js-yaml";
+import { z } from "zod";
+import { detect } from "package-manager-detector";
+//#region src/schemas.ts
+const changelogFrontmatterSchema = z.object({
+	subject: z.string().optional(),
+	packages: z.array(z.string()).default([])
+});
+const stringRecordSchema = z.record(z.string(), z.string());
+const jsonCodec = (schema) => z.codec(z.string(), schema, {
+	decode: (jsonString, ctx) => {
+		try {
+			return JSON.parse(jsonString);
+		} catch (err) {
+			ctx.issues.push({
+				code: "invalid_format",
+				format: "json",
+				input: jsonString,
+				message: err.message
+			});
+			return z.NEVER;
+		}
+	},
+	encode: (value) => JSON.stringify(value)
+});
+const workspacePatternsSchema = z.union([z.array(z.string()), z.looseObject({ packages: z.array(z.string()).optional() }).transform((workspaces) => workspaces.packages ?? ["."])]).pipe(z.array(z.string()));
+const packageManifestSchema = z.looseObject({
+	name: z.string().optional(),
+	version: z.string().optional(),
+	private: z.boolean().optional(),
+	publishConfig: z.looseObject({
+		access: z.enum(["public", "restricted"]).optional(),
+		registry: z.string().optional(),
+		tag: z.string().optional()
+	}).optional(),
+	workspaces: workspacePatternsSchema.optional(),
+	dependencies: stringRecordSchema.optional(),
+	devDependencies: stringRecordSchema.optional(),
+	peerDependencies: stringRecordSchema.optional(),
+	optionalDependencies: stringRecordSchema.optional()
+});
+/** the persisted plan data for actual publishing */
+const planStoreSchema = jsonCodec(z.object({
+	id: z.string(),
+	createdAt: z.iso.datetime(),
+	/** release note entries */
+	changelogs: z.record(z.string(), z.object({
+		filename: z.string(),
+		subject: z.string().optional(),
+		packages: z.array(z.string()),
+		type: z.enum([
+			"major",
+			"minor",
+			"patch"
+		]),
+		title: z.string(),
+		content: z.string()
+	})),
+	/** package id -> package info */
+	packages: z.record(z.string(), z.object({
+		type: z.enum([
+			"major",
+			"minor",
+			"patch"
+		]),
+		changelogIds: z.codec(z.array(z.string()), z.set(z.string()), {
+			encode: (v) => Array.from(v),
+			decode: (v) => new Set(v)
+		}),
+		distTag: z.string().optional(),
+		publish: z.boolean()
+	}))
+}));
+//#endregion
+//#region src/providers/npm.ts
+const DEP_FIELDS = [
+	"dependencies",
+	"devDependencies",
+	"peerDependencies",
+	"optionalDependencies"
+];
+var NpmPackage = class NpmPackage extends WorkspacePackage {
+	path;
+	manifest;
+	manager = "npm";
+	constructor(path, manifest) {
+		super();
+		this.path = path;
+		this.manifest = manifest;
+	}
+	get name() {
+		return this.manifest.name;
+	}
+	get version() {
+		return this.manifest.version ?? "0.0.0";
+	}
+	get publish() {
+		return this.manifest.private !== true;
+	}
+	get distTag() {
+		return this.manifest.publishConfig?.tag;
+	}
+	setVersion(version) {
+		this.manifest.version = version;
+	}
+	async updateDependency(target, version, context) {
+		if (!(target instanceof NpmPackage)) return;
+		const next = semver.parse(version);
+		if (!next) return;
+		for (const field of DEP_FIELDS) {
+			const dependencies = this.manifest[field];
+			if (!dependencies) continue;
+			for (const [rawName, rawRange] of Object.entries(dependencies)) {
+				const spec = parseNpmDependency(rawName, rawRange);
+				if (!spec || spec.name !== target.name) continue;
+				dependencies[rawName] = formatNpmDependency(await this.updateRange(context, spec, next));
+			}
+		}
+	}
+	async write() {
+		await writeFile(join(this.path, "package.json"), `${JSON.stringify(this.manifest, null, 2)}\n`);
+	}
+};
+var NpmRegistryClient = class {
+	cwd;
+	npmClient;
+	graph;
+	id = "npm";
+	#versionMap = /* @__PURE__ */ new Map();
+	#resolvedClient;
+	constructor(cwd, npmClient = void 0, graph) {
+		this.cwd = cwd;
+		this.npmClient = npmClient;
+		this.graph = graph;
+	}
+	supports(pkg) {
+		return pkg instanceof NpmPackage;
+	}
+	async packageVersionExists(pkg, version) {
+		const cacheKey = `${pkg.id}@${version}`;
+		let info = this.#versionMap.get(cacheKey);
+		if (!info) {
+			const run = async () => {
+				if (!(pkg instanceof NpmPackage)) return false;
+				const registry = pkg.manifest.publishConfig?.registry;
+				const args = [
+					"view",
+					`${pkg.name}@${version}`,
+					"version",
+					"--json"
+				];
+				if (registry) args.push("--registry", registry);
+				const result = await x(await this.resolveClient(), args, { nodeOptions: { cwd: this.cwd } });
+				if (result.exitCode === 0) return true;
+				const output = commandOutput(result);
+				if (isMissingRegistryEntry(output)) return false;
+				throw new Error(`Unable to validate ${pkg.name}@${version} against the npm registry${registry ? ` "${registry}"` : ""}: ${output.trim() || `command exited with code ${result.exitCode}`}`);
+			};
+			info = run();
+			this.#versionMap.set(cacheKey, info);
+		}
+		return info;
+	}
+	async publish(pkg, options = {}) {
+		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
+		});
+	}
+	async publishPlanStatus(plan) {
+		for (const [name, pkgPlan] of Object.entries(plan.packages)) {
+			const pkg = this.graph.get(name);
+			if (!(pkg instanceof NpmPackage) || !pkgPlan.publish) continue;
+			if (!await this.packageVersionExists(pkg, pkg.version)) return { state: "pending" };
+		}
+		return { state: "success" };
+	}
+	resolveClient() {
+		if (!this.#resolvedClient) this.#resolvedClient = this.npmClient ?? detect({ cwd: this.cwd }).then((result) => {
+			if (result?.name === "pnpm") return "pnpm";
+			return "npm";
+		});
+		return this.#resolvedClient;
+	}
+};
+function commandOutput(result) {
+	return [result.stdout, result.stderr].filter(Boolean).join("\n");
+}
+function isMissingRegistryEntry(output) {
+	const normalized = output.toLowerCase();
+	return normalized.includes("e404") || normalized.includes("404") || normalized.includes("no match") || normalized.includes("no matching version") || normalized.includes("not found");
+}
+function parseNpmDependency(rawName, rawRange) {
+	if (rawRange.startsWith("workspace:")) return {
+		name: rawName,
+		range: rawRange.slice(10),
+		protocol: "workspace"
+	};
+	if (rawRange.startsWith("npm:")) {
+		const spec = rawRange.slice(4);
+		const separator = spec.lastIndexOf("@");
+		if (separator <= 0) return void 0;
+		return {
+			name: spec.slice(0, separator),
+			range: spec.slice(separator + 1),
+			protocol: "npm"
+		};
+	}
+	return {
+		name: rawName,
+		range: rawRange
+	};
+}
+function formatNpmDependency(spec) {
+	const npmSpec = spec;
+	if (npmSpec.protocol === "workspace") return `workspace:${spec.range}`;
+	if (npmSpec.protocol === "npm") return `npm:${spec.name}@${spec.range}`;
+	return spec.range;
+}
+function npm(client) {
+	return {
+		name: "npm",
+		enforce: "pre",
+		async resolve() {
+			await discoverNpmPackages(this.cwd, (pkg) => this.graph.add(pkg));
+		},
+		createRegistryClient() {
+			return new NpmRegistryClient(this.cwd, client, this.graph);
+		}
+	};
+}
+async function discoverNpmPackages(cwd, add) {
+	const candidatePaths = await expandWorkspacePatterns(cwd, await readWorkspacePatterns(cwd));
+	const rootManifestPromise = readManifest(cwd).catch(() => void 0);
+	const manifests = await Promise.all(candidatePaths.map((path) => readManifest(path).then((manifest) => ({
+		path,
+		manifest
+	})).catch(() => void 0)));
+	const rootManifest = await rootManifestPromise;
+	if (rootManifest?.name && rootManifest.version && rootManifest.private !== true) add(new NpmPackage(cwd, rootManifest));
+	for (const entry of manifests) {
+		if (!entry?.manifest.name || !entry.manifest.version) continue;
+		add(new NpmPackage(entry.path, entry.manifest));
+	}
+}
+async function readWorkspacePatterns(cwd) {
+	const pnpmPatterns = await readFile(join(cwd, "pnpm-workspace.yaml"), "utf8").then((content) => workspacePatternsSchema.parse(load(content) ?? {})).catch((error) => {
+		if (isNodeError(error) && error.code === "ENOENT") return void 0;
+		throw error;
+	});
+	if (pnpmPatterns) return pnpmPatterns;
+	return (await readManifest(cwd).catch(() => void 0))?.workspaces ?? ["."];
+}
+async function expandWorkspacePatterns(cwd, patterns) {
+	const paths = patterns.includes(".") ? [cwd] : [];
+	const globPatterns = patterns.filter((pattern) => pattern !== ".");
+	if (globPatterns.length > 0) paths.push(...await glob(globPatterns, {
+		absolute: true,
+		cwd,
+		ignore: ["**/node_modules/**"],
+		onlyDirectories: true,
+		onlyFiles: false
+	}));
+	return paths.map(normalize);
+}
+async function readManifest(packagePath) {
+	const content = await readFile(join(packagePath, "package.json"), "utf8");
+	return packageManifestSchema.parse(JSON.parse(content));
+}
+//#endregion
+export { planStoreSchema as a, changelogFrontmatterSchema as i, NpmRegistryClient as n, npm as r, NpmPackage as t };

package/dist/plugins/git.d.mts

@@ -0,0 +1,19 @@
+import { o as TegamiPlugin } from "../types-DdIMewK9.mjs";
+
+//#region src/plugins/git.d.ts
+interface GitPluginOptions {
+  /** Set to false to skip creating git tags after all packages publish successfully. */
+  createTags?: boolean;
+}
+/**
+ * Basic Git integrations:
+ * - auto tags.
+ *
+ * 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 };

package/dist/plugins/git.mjs

@@ -0,0 +1,56 @@
+import { x } from "tinyexec";
+//#region src/plugins/git.ts
+/**
+* Basic Git integrations:
+* - auto tags.
+*
+* Note: you do not need this with `github` plugin enabled.
+*/
+function git(options = {}) {
+	const { createTags = true } = options;
+	return {
+		name: "git",
+		enforce: "pre",
+		async afterPublish(result) {
+			const { graph, publishOptions: { dryRun = false } } = this;
+			if (dryRun || !createTags || result.state === "failed") return result;
+			for (const pkg of result.packages) try {
+				const gitTag = `${pkg.name}@${pkg.version}`;
+				await createGitTag(graph.get(pkg.id).path, gitTag);
+				pkg.gitTag = gitTag;
+			} catch (error) {
+				return {
+					...result,
+					state: "failed",
+					packages: result.packages.map((pkgResult) => {
+						if (pkgResult.id === pkg.id) return {
+							...pkgResult,
+							state: "failed",
+							error: error instanceof Error ? error.message : String(error)
+						};
+						return pkgResult;
+					})
+				};
+			}
+			return result;
+		}
+	};
+}
+/** create a Git tag, ignored if already exists */
+async function createGitTag(cwd, tag) {
+	if (await gitTagExists(cwd, tag)) return;
+	await x("git", ["tag", tag], {
+		nodeOptions: { cwd },
+		throwOnError: true
+	});
+}
+async function gitTagExists(cwd, tag) {
+	return (await x("git", [
+		"rev-parse",
+		"-q",
+		"--verify",
+		`refs/tags/${tag}`
+	], { nodeOptions: { cwd } })).exitCode === 0;
+}
+//#endregion
+export { createGitTag, git, gitTagExists };

package/dist/plugins/github.d.mts

@@ -0,0 +1,23 @@
+import { f as PackagePublishResult, o as TegamiPlugin, t as Awaitable } from "../types-DdIMewK9.mjs";
+import { GitPluginOptions } from "./git.mjs";
+
+//#region src/plugins/github.d.ts
+interface GithubRelease {
+  /** Release title */
+  title?: string;
+  /** Release notes */
+  notes?: string;
+  /** Whether to mark release as prerelease */
+  prerelease?: boolean;
+}
+/** 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>;
+}
+/** Create GitHub releases for successfully published packages after the whole plan succeeds. */
+declare function github(options?: GitHubPluginOptions): TegamiPlugin[];
+//#endregion
+export { GitHubPluginOptions, github };

package/dist/plugins/github.mjs

@@ -0,0 +1,41 @@
+import { git } from "./git.mjs";
+import { x } from "tinyexec";
+//#region src/plugins/github.ts
+/** Create GitHub releases for successfully published packages after the whole plan succeeds. */
+function github(options = {}) {
+	async function createGithubRelease(pkg) {
+		if (!pkg.gitTag) return;
+		const release = await options.onCreateRelease?.(pkg) ?? {};
+		if (release === false) return;
+		const args = [
+			"release",
+			"create",
+			pkg.gitTag,
+			"--title",
+			release.title ?? `${pkg.name}@${pkg.version}`,
+			"--notes",
+			release.notes ?? defaultNotes(pkg)
+		];
+		if (options.repo) args.push("--repo", options.repo);
+		if (release.prerelease) args.push("--prerelease");
+		await x("gh", args, { throwOnError: true });
+	}
+	return [git(options), {
+		name: "github",
+		async afterPublish(result) {
+			if (result.state !== "success") return;
+			await Promise.all(result.packages.map(createGithubRelease));
+		}
+	}];
+}
+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");
+	return [
+		`Published ${pkg.name}@${pkg.version}.`,
+		"",
+		`npm dist-tag: ${pkg.distTag}`
+	].join("\n");
+}
+//#endregion
+export { github };

package/dist/providers/cargo.d.mts

@@ -0,0 +1,32 @@
+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 { TomlTable } from "smol-toml";
+
+//#region src/providers/cargo.d.ts
+declare class CargoPackage extends WorkspacePackage {
+  readonly path: string;
+  readonly manifest: TomlTable;
+  private readonly workspaceManifest?;
+  readonly manager = "cargo";
+  constructor(path: string, manifest: TomlTable, workspaceManifest?: TomlTable | undefined);
+  get name(): string;
+  get version(): string;
+  get publish(): boolean;
+  setVersion(version: string): void;
+  updateDependency(target: WorkspacePackage, version: string, context: TegamiContext): Promise<void>;
+  write(): Promise<void>;
+  private get packageInfo();
+  private get workspaceVersion();
+}
+declare class CargoRegistryClient implements RegistryClient {
+  #private;
+  private readonly graph;
+  readonly id = "cargo";
+  constructor(graph: PackageGraph);
+  supports(pkg: WorkspacePackage): boolean;
+  packageVersionExists(pkg: WorkspacePackage, version: string): Promise<boolean>;
+  publish(pkg: WorkspacePackage): Promise<void>;
+  publishPlanStatus(plan: PlanStore): Promise<PublishPlanStatus>;
+}
+declare function cargo(): TegamiPlugin;
+//#endregion
+export { CargoPackage, CargoRegistryClient, cargo };

package/dist/providers/cargo.mjs

@@ -0,0 +1,186 @@
+import { n as WorkspacePackage, r as isNodeError } from "../workspace-B5_i21S0.mjs";
+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 { glob } from "tinyglobby";
+//#region src/providers/cargo.ts
+const DEP_FIELDS = [
+	"dependencies",
+	"dev-dependencies",
+	"build-dependencies"
+];
+var CargoPackage = class CargoPackage extends WorkspacePackage {
+	path;
+	manifest;
+	workspaceManifest;
+	manager = "cargo";
+	constructor(path, manifest, workspaceManifest) {
+		super();
+		this.path = path;
+		this.manifest = manifest;
+		this.workspaceManifest = workspaceManifest;
+	}
+	get name() {
+		return stringValue(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();
+			}
+		}
+	}
+	async write() {
+		await writeFile(join(this.path, "Cargo.toml"), stringify(this.manifest));
+	}
+	get packageInfo() {
+		return tableValue(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;
+	}
+	supports(pkg) {
+		return pkg instanceof CargoPackage;
+	}
+	async packageVersionExists(pkg, version) {
+		const cacheKey = `${pkg.id}@${version}`;
+		let info = this.#versionMap.get(cacheKey);
+		if (!info) {
+			info = fetch(`https://crates.io/api/v1/crates/${encodeURIComponent(pkg.name)}/${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()}`);
+			});
+			this.#versionMap.set(cacheKey, info);
+		}
+		return info;
+	}
+	async publish(pkg) {
+		await x("cargo", ["publish"], {
+			nodeOptions: { cwd: pkg.path },
+			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() {
+	return {
+		name: "cargo",
+		enforce: "pre",
+		async resolve() {
+			await discoverCargoPackages(this.cwd, (pkg) => this.graph.add(pkg));
+		},
+		createRegistryClient() {
+			return new CargoRegistryClient(this.graph);
+		}
+	};
+}
+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, root, add);
+	const workspace = tableValue(root.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, root, add);
+}
+function addCargoPackage(path, manifest, workspaceManifest, add) {
+	const packageInfo = tableValue(manifest.package);
+	const workspacePackage = tableValue(workspaceManifest.workspace)?.package;
+	if (!packageInfo?.name) return;
+	if (!packageInfo.version && !tableValue(workspacePackage)?.version) return;
+	add(new CargoPackage(path, manifest, 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) {
+	const tables = [];
+	for (const field of DEP_FIELDS) {
+		const table = tableValue(manifest[field]);
+		if (table) tables.push(table);
+	}
+	const target = tableValue(manifest.target);
+	if (target) for (const targetConfig of Object.values(target)) {
+		const targetTable = tableValue(targetConfig);
+		if (!targetTable) continue;
+		for (const field of DEP_FIELDS) {
+			const table = tableValue(targetTable[field]);
+			if (table) tables.push(table);
+		}
+	}
+	return tables;
+}
+async function readCargoManifest(path) {
+	return parse(await readFile(join(path, "Cargo.toml"), "utf8"));
+}
+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
+export { CargoPackage, CargoRegistryClient, cargo };

package/dist/providers/npm.d.mts

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

package/dist/providers/npm.mjs

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