@shivaedev/changesets 0.0.0 → 0.1.1

package/src/cli.ts

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+import process from "node:process";
+import { NodeFileSystem, NodeRuntime } from "@effect/platform-node";
+import { Console, Effect } from "effect";
+import { applyRelease } from "#applyRelease.ts";
+import { checkRepository } from "#check.ts";
+import { ChangesetError } from "#error.ts";
+import { planRelease, summarizePlan } from "#planner.ts";
+import { loadConfig } from "#workspace.ts";
+
+const program = Effect.gen(function* () {
+	const [command, argument, ...extra] = process.argv.slice(2);
+	if (
+		!["plan", "apply", "check"].includes(command ?? "")
+		|| extra.length > 0
+		|| (argument !== undefined && command !== "check" && !(command === "plan" && argument === "--json"))
+	) {
+		return yield* new ChangesetError({ message: "Use changesets plan [--json], changesets apply, or changesets check [base-ref]." });
+	}
+	const root = process.cwd();
+	const config = yield* loadConfig(root);
+	if (command === "check") {
+		yield* checkRepository(root, config, argument);
+		yield* Console.log("Changesets and release notes are valid.");
+	} else {
+		const plan = yield* command === "apply" ? applyRelease(root, config) : planRelease(root, config);
+		yield* Console.log(argument === "--json" ? JSON.stringify(plan, null, 2) : summarizePlan(plan));
+	}
+});
+NodeRuntime.runMain(
+	program.pipe(
+		Effect.tapError((error) => Console.error(error.message)),
+		Effect.provide(NodeFileSystem.layer),
+	),
+	{ disableErrorReporting: true },
+);

package/src/collectChangelog.ts

@@ -0,0 +1,27 @@
+import { requireThat } from "#error.ts";
+import type { Release, ReleasePlan } from "#model.ts";
+import { parseChangeset } from "#parser.ts";
+import { renderEntries } from "#sections.ts";
+
+export function collectChangelog(previous: string, release: Release, plan: ReleasePlan, date: string): string {
+	const timestamp = Date.parse(`${date}T00:00:00Z`);
+	requireThat(
+		/^\d{4}-\d{2}-\d{2}$/u.test(date) && Number.isFinite(timestamp) && new Date(timestamp).toISOString().slice(0, 10) === date,
+		"Use a valid UTC YYYY-MM-DD release date in .changeset/release.json; rerun changesets apply.",
+	);
+	requireThat(
+		previous.startsWith("# Changelog\n") && !/^## Unreleased\s*$/mu.test(previous),
+		`${release.name}: use a '# Changelog' title and move Unreleased notes into .changeset/*.md.`,
+	);
+	requireThat(
+		!new RegExp(`^## ${release.to.replaceAll(".", "\\.")}(?: - |$)`, "mu").test(previous),
+		`${release.name}: version ${release.to} already has notes; restore the package version and rerun changesets apply.`,
+	);
+	const entries = plan.changesets.flatMap((source) => {
+		const changeset = parseChangeset(source);
+		return Object.hasOwn(changeset.packages, release.name) ? changeset.entries : [];
+	});
+	const dependencyNotes = entries.length === 0 ? [{ section: "Changed" as const, text: "- Release with updated workspace dependencies." }] : [];
+	const history = previous.slice("# Changelog\n".length).trimStart();
+	return `# Changelog\n\n## ${release.to} - ${date}\n\n${renderEntries([...entries, ...dependencyNotes])}${history === "" ? "" : `\n${history}`}`;
+}

package/src/config.ts

@@ -0,0 +1,16 @@
+import type { Effect, FileSystem, PlatformError } from "effect";
+import type { ChangesetError } from "#error.ts";
+import type { ReleasePlan } from "#model.ts";
+
+export interface HookContext {
+	readonly plan: ReleasePlan;
+	readonly root: string;
+}
+export type ReleaseHook = (context: HookContext) => Effect.Effect<void, ChangesetError | PlatformError.PlatformError, FileSystem.FileSystem>;
+export interface ChangesetConfig {
+	readonly hooks?: readonly ReleaseHook[];
+	readonly packages?: readonly string[];
+}
+export function defineConfig(config: ChangesetConfig): ChangesetConfig {
+	return config;
+}

package/src/error.ts

@@ -0,0 +1,20 @@
+import { Data, Effect } from "effect";
+
+export class ChangesetError extends Data.TaggedError("ChangesetError")<{
+	readonly message: string;
+	readonly cause?: unknown;
+}> {}
+
+export function attempt<A>(evaluate: () => A) {
+	return Effect.try({
+		catch: (cause) =>
+			cause instanceof ChangesetError ? cause : new ChangesetError({ cause, message: cause instanceof Error ? cause.message : String(cause) }),
+		try: evaluate,
+	});
+}
+
+export function requireThat(condition: boolean, message: string): void {
+	if (!condition) {
+		throw new ChangesetError({ message });
+	}
+}

package/src/model.ts

@@ -0,0 +1,38 @@
+import { Schema } from "effect";
+export const Bump = Schema.Literals(["patch", "minor", "major"]);
+export type Bump = typeof Bump.Type;
+export const Source = Schema.Struct({ name: Schema.String, text: Schema.String });
+export type Source = typeof Source.Type;
+const Versions = Schema.Record(Schema.String, Schema.String);
+export const PackageManifest = Schema.Struct({
+	dependencies: Schema.optional(Versions),
+	name: Schema.String,
+	optionalDependencies: Schema.optional(Versions),
+	peerDependencies: Schema.optional(Versions),
+	private: Schema.optional(Schema.Boolean),
+	version: Schema.String,
+});
+export type PackageManifest = typeof PackageManifest.Type;
+export interface WorkspacePackage {
+	readonly changelog: string;
+	readonly directory: string;
+	readonly json: Readonly<Record<string, unknown>>;
+	readonly manifest: PackageManifest;
+}
+export const Release = Schema.Struct({
+	bump: Bump,
+	directory: Schema.String,
+	from: Schema.String,
+	name: Schema.String,
+	to: Schema.String,
+});
+export type Release = typeof Release.Type;
+export const ReleasePlan = Schema.Struct({ changesets: Schema.Array(Source), releases: Schema.Array(Release) });
+export type ReleasePlan = typeof ReleasePlan.Type;
+export const ReleaseManifest = Schema.Struct({ date: Schema.String, plan: ReleasePlan });
+export type ReleaseManifest = typeof ReleaseManifest.Type;
+export interface Workspace {
+	readonly changesets: readonly Source[];
+	readonly packages: readonly WorkspacePackage[];
+	readonly release: ReleaseManifest | undefined;
+}

package/src/parser.ts

@@ -0,0 +1,33 @@
+import { Schema } from "effect";
+import { requireThat } from "#error.ts";
+import { Bump, type Source } from "#model.ts";
+import { type Entry, parseBody } from "#sections.ts";
+export interface Changeset extends Source {
+	readonly entries: readonly Entry[];
+	readonly packages: Readonly<Record<string, Bump>>;
+}
+function scalar(value: string): string {
+	if (value.startsWith('"')) {
+		return Schema.decodeUnknownSync(Schema.fromJsonString(Schema.String))(value);
+	}
+	return value.startsWith("'") && value.endsWith("'") ? value.slice(1, -1).replaceAll("''", "'") : value;
+}
+export function parseChangeset(source: Source): Changeset {
+	const match = /^---\n(?<header>[\s\S]*?)\n---\n(?<body>[\s\S]*)$/u.exec(source.text.replaceAll("\r\n", "\n"));
+	requireThat(match !== null, `${source.name}: add YAML frontmatter between --- lines, mapping package names to patch, minor or major.`);
+	const packages: Record<string, Bump> = {};
+	for (const line of (match?.groups?.header ?? "").split("\n")) {
+		if (line.trim() === "" || line.trimStart().startsWith("#")) {
+			continue;
+		}
+		const mapping = /^\s*(?<name>"(?:[^"\\]|\\.)*"|'(?:[^']|'')*'|[^\s:'"{}[\],#]+)\s*:\s*(?<bump>"[^"]*"|'[^']*'|[^\s#]+)\s*(?:#.*)?$/u.exec(line);
+		requireThat(mapping !== null, `${source.name}: use one YAML package: bump mapping per line, for example '"@scope/pkg": minor'.`);
+		const name = scalar(mapping?.groups?.name ?? "");
+		const bump = scalar(mapping?.groups?.bump ?? "");
+		requireThat(name !== "" && !Object.hasOwn(packages, name), `${source.name}: name each package once in frontmatter.`);
+		requireThat(Schema.is(Bump)(bump), `${source.name}: ${name} needs an explicit patch, minor or major bump.`);
+		packages[name] = Schema.decodeUnknownSync(Bump)(bump);
+	}
+	requireThat(Object.keys(packages).length > 0, `${source.name}: name at least one package and its explicit bump in frontmatter.`);
+	return { ...source, entries: parseBody(source.name, match?.groups?.body ?? ""), packages };
+}

package/src/planner.ts

@@ -0,0 +1,73 @@
+import { Effect } from "effect";
+import type { ChangesetConfig } from "#config.ts";
+import { attempt, requireThat } from "#error.ts";
+import type { Bump, PackageManifest, ReleasePlan, Source, WorkspacePackage } from "#model.ts";
+import { parseChangeset } from "#parser.ts";
+import { readWorkspace } from "#workspace.ts";
+
+const rank = { major: 2, minor: 1, patch: 0 };
+export function publishedDependencies(manifest: PackageManifest): readonly string[] {
+	return Object.keys({ ...manifest.dependencies, ...manifest.optionalDependencies, ...manifest.peerDependencies });
+}
+function nextVersion(name: string, version: string, bump: Bump): string {
+	const match = /^(?<major>0|[1-9]\d*)\.(?<minor>0|[1-9]\d*)\.(?<patch>0|[1-9]\d*)$/u.exec(version);
+	requireThat(match !== null, `${name}: use a stable major.minor.patch version before planning a release; found ${version}.`);
+	const major = Number(match?.groups?.major);
+	const minor = Number(match?.groups?.minor);
+	const patch = Number(match?.groups?.patch);
+	requireThat(major !== 0 || bump !== "major", `${name}: major is not allowed on a 0.x package; use minor for breaking changes.`);
+	if (bump === "major") {
+		return `${major + 1}.0.0`;
+	}
+	return bump === "minor" ? `${major}.${minor + 1}.0` : `${major}.${minor}.${patch + 1}`;
+}
+function requestedBumps(packages: readonly WorkspacePackage[], sources: readonly Source[]): Map<string, Bump> {
+	const bumps = new Map<string, Bump>();
+	for (const source of sources) {
+		for (const [name, bump] of Object.entries(parseChangeset(source).packages)) {
+			const pkg = packages.find((candidate) => candidate.manifest.name === name);
+			requireThat(pkg !== undefined, `${source.name}: unknown package ${name}; fix the name or include its directory in config.packages.`);
+			requireThat(!pkg?.manifest.private, `${source.name}: ${name} is private; remove it from release frontmatter.`);
+			if (pkg !== undefined) {
+				nextVersion(name, pkg.manifest.version, bump);
+			}
+			const previous = bumps.get(name);
+			if (previous === undefined || rank[bump] > rank[previous]) {
+				bumps.set(name, bump);
+			}
+		}
+	}
+	return bumps;
+}
+export function computePlan(packages: readonly WorkspacePackage[], sources: readonly Source[]): ReleasePlan {
+	const bumps = requestedBumps(packages, sources);
+	let changed = true;
+	while (changed) {
+		changed = false;
+		for (const { manifest } of packages) {
+			if (!(manifest.private || bumps.has(manifest.name)) && publishedDependencies(manifest).some((name) => bumps.has(name))) {
+				bumps.set(manifest.name, "patch");
+				changed = true;
+			}
+		}
+	}
+	const releases = [...bumps]
+		.sort(([left], [right]) => left.localeCompare(right))
+		.map(([name, bump]) => {
+			const pkg = packages.find((candidate) => candidate.manifest.name === name);
+			if (pkg === undefined) {
+				throw new Error(`Package ${name} disappeared while planning.`);
+			}
+			return { bump, directory: pkg.directory, from: pkg.manifest.version, name, to: nextVersion(name, pkg.manifest.version, bump) };
+		});
+	return { changesets: [...sources].sort((left, right) => left.name.localeCompare(right.name)), releases };
+}
+export function summarizePlan(plan: ReleasePlan): string {
+	return plan.releases.length === 0
+		? "No pending releases."
+		: plan.releases.map((release) => `${release.name}: ${release.from} -> ${release.to} (${release.bump})`).join("\n");
+}
+export const planRelease = Effect.fn("Changesets.planRelease")(function* (root: string, config: ChangesetConfig = {}) {
+	const workspace = yield* readWorkspace(root, config);
+	return yield* attempt(() => computePlan(workspace.packages, workspace.changesets));
+});

package/src/readHistory.ts

@@ -0,0 +1,41 @@
+import { execFileSync, spawnSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { posix } from "node:path";
+import { Effect, Schema } from "effect";
+import type { ChangesetConfig } from "#config.ts";
+import { attempt, ChangesetError } from "#error.ts";
+import { ReleaseManifest } from "#model.ts";
+import { decodePackage, isChangeset, packagePatterns } from "#workspace.ts";
+
+function git(root: string, args: readonly string[]): string {
+	return execFileSync("git", ["-C", root, ...args], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
+}
+export const readHistory = Effect.fn("Changesets.readHistory")(function* (root: string, config: ChangesetConfig, reference?: string) {
+	const base = yield* attempt(() => {
+		const mergeHead = git(root, ["rev-parse", "--path-format=absolute", "--git-path", "MERGE_HEAD"]).trim();
+		const heads = ["HEAD", ...(existsSync(mergeHead) ? readFileSync(mergeHead, "utf8").trim().split("\n") : [])];
+		for (const candidate of reference === undefined ? ["origin/main", "main"] : [reference]) {
+			const result = spawnSync("git", ["-C", root, "merge-base", candidate, ...heads], { encoding: "utf8" });
+			if (result.status === 0) {
+				return result.stdout.trim();
+			}
+		}
+		throw new ChangesetError({
+			message: `Cannot resolve changeset base ${reference ?? "origin/main or main"}; run git fetch origin main or pass an existing base-ref with full history.`,
+		});
+	});
+	return yield* attempt(() => {
+		const paths = git(root, ["ls-tree", "-r", "--name-only", base]).trim().split("\n");
+		function read(path: string, fallback: string) {
+			return paths.includes(path) ? git(root, ["show", `${base}:${path}`]) : fallback;
+		}
+		const packages = paths
+			.filter((path) => path.endsWith("/package.json") && packagePatterns(config).some((pattern) => posix.matchesGlob(posix.dirname(path), pattern)))
+			.map((path) => decodePackage(posix.dirname(path), read(path, ""), read(`${posix.dirname(path)}/CHANGELOG.md`, "# Changelog\n")));
+		const changesets = paths
+			.filter((path) => path.startsWith(".changeset/") && isChangeset(path.slice(".changeset/".length)))
+			.map((path) => ({ name: path.slice(".changeset/".length), text: read(path, "") }));
+		const text = read(".changeset/release.json", "");
+		return { changesets, packages, release: text === "" ? undefined : Schema.decodeUnknownSync(Schema.fromJsonString(ReleaseManifest))(text) };
+	});
+});

package/src/sections.ts

@@ -0,0 +1,40 @@
+import { requireThat } from "#error.ts";
+
+export const sections = ["Added", "Changed", "Fixed", "Breaking"] as const;
+export type Section = (typeof sections)[number];
+export interface Entry {
+	readonly section: Section;
+	readonly text: string;
+}
+
+export function parseBody(name: string, body: string): readonly Entry[] {
+	const entries: Entry[] = [];
+	let section: Section | undefined;
+	for (const line of body.split("\n")) {
+		if (line.startsWith("### ")) {
+			section = sections.find((value) => line === `### ${value}`);
+			requireThat(section !== undefined, `${name}: use ### Added, ### Changed, ### Fixed or ### Breaking.`);
+		} else if (line.startsWith("- ") && section !== undefined) {
+			requireThat(line.slice(2).trim() !== "", `${name}: write text after '- '.`);
+			entries.push({ section, text: line });
+		} else if (line.trim() !== "") {
+			const previous = entries.at(-1);
+			if (previous === undefined || previous.section !== section || !/^\s+\S/u.test(line)) {
+				requireThat(false, `${name}: start each entry with '- ' under a ### section heading.`);
+			} else {
+				entries[entries.length - 1] = { ...previous, text: `${previous.text}\n${line}` };
+			}
+		}
+	}
+	requireThat(entries.length > 0, `${name}: add at least one release-note entry under a ### section heading.`);
+	return entries;
+}
+
+export function renderEntries(entries: readonly Entry[]): string {
+	return sections
+		.flatMap((section) => {
+			const selected = entries.filter((entry) => entry.section === section);
+			return selected.length === 0 ? [] : [`### ${section}\n\n${selected.map((entry) => entry.text).join("\n")}\n`];
+		})
+		.join("\n");
+}

package/src/workspace.ts

@@ -0,0 +1,109 @@
+import { join } from "node:path";
+import { pathToFileURL } from "node:url";
+import { Effect, FileSystem, Schema } from "effect";
+import type { ChangesetConfig } from "#config.ts";
+import { attempt, ChangesetError, requireThat } from "#error.ts";
+import { PackageManifest, ReleaseManifest, type Source, type WorkspacePackage } from "#model.ts";
+export function packagePatterns(config: ChangesetConfig): readonly string[] {
+	return config.packages ?? ["packages/*", "examples/*"];
+}
+const Json = Schema.Record(Schema.String, Schema.Unknown);
+export function decodePackage(directory: string, text: string, changelog: string): WorkspacePackage {
+	return {
+		changelog,
+		directory,
+		json: Schema.decodeUnknownSync(Schema.fromJsonString(Json))(text),
+		manifest: Schema.decodeUnknownSync(Schema.fromJsonString(PackageManifest))(text),
+	};
+}
+export const readOptional = Effect.fn("Changesets.readOptional")(function* (path: string, fallback: string) {
+	const fs = yield* FileSystem.FileSystem;
+	return (yield* fs.exists(path)) ? yield* fs.readFileString(path) : fallback;
+});
+export const loadConfig = Effect.fn("Changesets.loadConfig")(function* (root: string) {
+	const fs = yield* FileSystem.FileSystem;
+	const path = join(root, ".changeset/changesets.config.ts");
+	if (!(yield* fs.exists(path))) {
+		return {} satisfies ChangesetConfig;
+	}
+	const module: {
+		default: ChangesetConfig;
+	} = yield* Effect.tryPromise({
+		catch: (cause) =>
+			new ChangesetError({
+				cause,
+				message: ".changeset/changesets.config.ts: export default defineConfig({ packages, hooks }); hooks must be typed Effect functions.",
+			}),
+		try: () => import(pathToFileURL(path).href),
+	});
+	yield* attempt(() => {
+		requireThat(
+			typeof module.default === "object" && module.default !== null,
+			".changeset/changesets.config.ts: export a config object with defineConfig.",
+		);
+		requireThat(
+			module.default.hooks === undefined || (Array.isArray(module.default.hooks) && module.default.hooks.every((hook) => typeof hook === "function")),
+			".changeset/changesets.config.ts: hooks must be Effect functions, not shell strings.",
+		);
+		requireThat(
+			module.default.packages === undefined
+				|| (Array.isArray(module.default.packages) && module.default.packages.every((pattern) => typeof pattern === "string")),
+			".changeset/changesets.config.ts: packages must be directory paths or parent/* patterns.",
+		);
+	});
+	return module.default;
+});
+const directories = Effect.fn("Changesets.directories")(function* (root: string, pattern: string) {
+	const fs = yield* FileSystem.FileSystem;
+	yield* attempt(() =>
+		requireThat(
+			/^(?:[\w.-]+\/)*[\w.*-]+$/u.test(pattern) && !pattern.split("/").includes("..") && (!pattern.includes("*") || pattern.endsWith("/*")),
+			`Invalid package pattern ${pattern}; use a relative directory or parent/*. `,
+		),
+	);
+	if (!pattern.endsWith("/*")) {
+		return [pattern];
+	}
+	const parent = pattern.slice(0, -2);
+	return (yield* fs.exists(join(root, parent))) ? (yield* fs.readDirectory(join(root, parent))).map((name) => `${parent}/${name}`) : [];
+});
+export const readChangesets = Effect.fn("Changesets.readChangesets")(function* (root: string) {
+	const fs = yield* FileSystem.FileSystem;
+	const directory = join(root, ".changeset");
+	const names = (yield* fs.exists(directory)) ? yield* fs.readDirectory(directory) : [];
+	return yield* Effect.forEach(names.filter(isChangeset).sort(), (name) =>
+		Effect.map(fs.readFileString(join(directory, name)), (text): Source => ({ name, text })),
+	);
+});
+export function isChangeset(name: string): boolean {
+	return name !== "README.md" && /^[^/\\]+\.md$/u.test(name);
+}
+export const readWorkspace = Effect.fn("Changesets.readWorkspace")(function* (root: string, config: ChangesetConfig) {
+	const fs = yield* FileSystem.FileSystem;
+	const paths = [...new Set((yield* Effect.forEach(packagePatterns(config), (pattern) => directories(root, pattern))).flat())].sort();
+	const packages: WorkspacePackage[] = [];
+	for (const directory of paths) {
+		if (yield* fs.exists(join(root, directory, "package.json"))) {
+			const text = yield* fs.readFileString(join(root, directory, "package.json"));
+			const changelog = yield* readOptional(join(root, directory, "CHANGELOG.md"), "# Changelog\n");
+			packages.push(yield* attempt(() => decodePackage(directory, text, changelog)));
+		}
+	}
+	yield* attempt(() =>
+		requireThat(
+			new Set(packages.map((pkg) => pkg.manifest.name)).size === packages.length,
+			"Workspace package names must be unique; fix package.json names.",
+		),
+	);
+	const releaseText = yield* readOptional(join(root, ".changeset/release.json"), "");
+	const release =
+		releaseText === ""
+			? undefined
+			: yield* attempt(() => Schema.decodeUnknownSync(Schema.fromJsonString(ReleaseManifest))(releaseText)).pipe(
+					Effect.mapError(
+						(cause) =>
+							new ChangesetError({ cause, message: ".changeset/release.json is invalid; restore the manifest generated by changesets apply." }),
+					),
+				);
+	return { changesets: yield* readChangesets(root), packages, release };
+});