@savvy-web/silk-effects 1.6.0 → 2.0.0

package/changesets/services/release-planner.js

@@ -3,9 +3,8 @@ import { ChangelogTransformer } from "../api/transformer.js";
 import { ConfigInspector } from "./config-inspector.js";
 import { VersionFiles } from "../utils/version-files.js";
 import { Context, Effect, Layer } from "effect";
-import { cpSync, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync } from "node:fs";
 import { isAbsolute, join, relative } from "node:path";
-import { tmpdir } from "node:os";
+import { FileSystem } from "@effect/platform";
 import applyReleasePlan from "@changesets/apply-release-plan";
 import { read } from "@changesets/config";
 import getReleasePlan from "@changesets/get-release-plan";
@@ -37,8 +36,8 @@ const _tag = Context.Tag("ReleasePlanner");
 const ReleasePlannerBase = _tag();
 /** Effect service tag for the release planner. @public */
 var ReleasePlanner = class extends ReleasePlannerBase {};
-/** Build the service shape over a resolved {@link ConfigInspector}. */
-function makeShape(inspector) {
+/** Build the service shape over a resolved {@link ConfigInspector} and {@link FileSystem.FileSystem}. */
+function makeShape(inspector, fs) {
 	const plan = (root) => Effect.tryPromise({
 		try: () => getReleasePlan(root),
 		catch: (e) => new ReleasePlanError({
@@ -46,23 +45,17 @@ function makeShape(inspector) {
 			reason: errMsg(e)
 		})
 	});
-	const preview = (root) => Effect.tryPromise({
-		try: () => previewImpl(root),
-		catch: (e) => new ReleasePlanError({
-			phase: "preview",
-			reason: errMsg(e)
-		})
-	});
-	const apply = (root, options) => applyEffect(root, options?.dryRun ?? false, inspector);
+	const preview = (root) => previewEffect(root, fs);
+	const apply = (root, options) => applyEffect(root, options?.dryRun ?? false, inspector, fs);
 	return {
 		plan,
 		preview,
 		apply
 	};
 }
-/** Production layer. Requires {@link ConfigInspector} (used by `apply`). @public */
+/** Production layer. Requires {@link ConfigInspector} (used by `apply`) and `FileSystem`. @public */
 const ReleasePlannerLive = Layer.effect(ReleasePlanner, Effect.gen(function* () {
-	return makeShape(yield* ConfigInspector);
+	return makeShape(yield* ConfigInspector, yield* FileSystem.FileSystem);
 }));
 /**
 * Test factory — supply fixed results for any subset of methods. Unsupplied
@@ -93,31 +86,52 @@ function extractVersionBlock(changelog, version) {
 	}
 	return lines.slice(start, end).join("\n").trim();
 }
-async function previewImpl(root) {
-	const [plan, packages] = await Promise.all([getReleasePlan(root), buildPackages(root)]);
-	const config = await read(root, packages);
-	const preMode = plan.preState ? plan.preState.mode : null;
-	const changesets = plan.changesets.map((cs) => ({
-		id: cs.id,
-		summary: cs.summary,
-		releases: cs.releases.filter((r) => r.type !== "none").map((r) => ({
-			name: r.name,
-			type: r.type
-		}))
-	}));
-	const releasesToRender = plan.releases.filter((r) => r.type !== "none");
-	if (releasesToRender.length === 0) return {
-		preMode,
-		releases: [],
-		changesets
-	};
-	const tempRoot = mkdtempSync(join(tmpdir(), "silk-preview-"));
-	try {
+/**
+* Render a non-destructive preview by redirecting every write into a
+* scope-managed temp directory (cleaned up automatically when the scope
+* closes) and reading the generated CHANGELOG blocks back.
+*/
+function previewEffect(root, fs) {
+	const program = Effect.gen(function* () {
+		const [plan, packages] = yield* Effect.tryPromise({
+			try: () => Promise.all([getReleasePlan(root), buildPackages(root)]),
+			catch: (e) => new ReleasePlanError({
+				phase: "preview",
+				reason: errMsg(e)
+			})
+		});
+		const config = yield* Effect.tryPromise({
+			try: () => read(root, packages),
+			catch: (e) => new ReleasePlanError({
+				phase: "preview",
+				reason: errMsg(e)
+			})
+		});
+		const preMode = plan.preState ? plan.preState.mode : null;
+		const changesets = plan.changesets.map((cs) => ({
+			id: cs.id,
+			summary: cs.summary,
+			releases: cs.releases.filter((r) => r.type !== "none").map((r) => ({
+				name: r.name,
+				type: r.type
+			}))
+		}));
+		const releasesToRender = plan.releases.filter((r) => r.type !== "none");
+		if (releasesToRender.length === 0) return {
+			preMode,
+			releases: [],
+			changesets
+		};
+		const tempRoot = yield* fs.makeTempDirectoryScoped({ prefix: "silk-preview-" });
 		const mapDir = (dir) => {
 			const rel = relative(packages.root.dir, dir);
-			if (rel.startsWith("..") || isAbsolute(rel)) throw new Error(`Package directory is outside the workspace root: ${dir}`);
-			return join(tempRoot, rel);
+			if (rel.startsWith("..") || isAbsolute(rel)) return Effect.fail(new ReleasePlanError({
+				phase: "preview",
+				reason: `Package directory is outside the workspace root: ${dir}`
+			}));
+			return Effect.succeed(join(tempRoot, rel));
 		};
+		const tempDirs = yield* Effect.forEach(packages.packages, (p) => mapDir(p.dir));
 		const tempPackages = {
 			tool: packages.tool,
 			root: {
@@ -125,26 +139,33 @@ async function previewImpl(root) {
 				dir: tempRoot,
 				packageJson: structuredClone(packages.root.packageJson)
 			},
-			packages: packages.packages.map((p) => ({
+			packages: packages.packages.map((p, i) => ({
 				...p,
-				dir: mapDir(p.dir),
+				dir: tempDirs[i],
 				packageJson: structuredClone(p.packageJson)
 			}))
 		};
-		mkdirSync(join(tempRoot, ".changeset"), { recursive: true });
-		cpSync(join(root, "package.json"), join(tempRoot, "package.json"));
+		yield* fs.makeDirectory(join(tempRoot, ".changeset"), { recursive: true });
+		yield* fs.copyFile(join(root, "package.json"), join(tempRoot, "package.json"));
 		const preJson = join(root, ".changeset", "pre.json");
-		if (existsSync(preJson)) cpSync(preJson, join(tempRoot, ".changeset", "pre.json"));
-		for (const p of packages.packages) {
-			const tDir = mapDir(p.dir);
-			mkdirSync(tDir, { recursive: true });
-			cpSync(join(p.dir, "package.json"), join(tDir, "package.json"));
+		if (yield* fs.exists(preJson)) yield* fs.copyFile(preJson, join(tempRoot, ".changeset", "pre.json"));
+		for (let i = 0; i < packages.packages.length; i++) {
+			const p = packages.packages[i];
+			const tDir = tempDirs[i];
+			yield* fs.makeDirectory(tDir, { recursive: true });
+			yield* fs.copyFile(join(p.dir, "package.json"), join(tDir, "package.json"));
 			const realCl = join(p.dir, "CHANGELOG.md");
-			if (existsSync(realCl)) cpSync(realCl, join(tDir, "CHANGELOG.md"));
+			if (yield* fs.exists(realCl)) yield* fs.copyFile(realCl, join(tDir, "CHANGELOG.md"));
 		}
 		const rootCl = join(packages.root.dir, "CHANGELOG.md");
-		if (existsSync(rootCl)) cpSync(rootCl, join(tempRoot, "CHANGELOG.md"));
-		await applyReleasePlan(plan, tempPackages, config, void 0, root);
+		if (yield* fs.exists(rootCl)) yield* fs.copyFile(rootCl, join(tempRoot, "CHANGELOG.md"));
+		yield* Effect.tryPromise({
+			try: () => applyReleasePlan(plan, tempPackages, config, void 0, root),
+			catch: (e) => new ReleasePlanError({
+				phase: "preview",
+				reason: errMsg(e)
+			})
+		});
 		const dirByName = /* @__PURE__ */ new Map();
 		for (const p of tempPackages.packages) dirByName.set(p.packageJson.name, p.dir);
 		if (tempPackages.root.packageJson.name) dirByName.set(tempPackages.root.packageJson.name, tempRoot);
@@ -153,9 +174,15 @@ async function previewImpl(root) {
 			const dir = dirByName.get(r.name);
 			if (!dir) continue;
 			const clPath = join(dir, "CHANGELOG.md");
-			if (!existsSync(clPath)) continue;
-			ChangelogTransformer.transformFile(clPath);
-			const content = readFileSync(clPath, "utf-8");
+			if (!(yield* fs.exists(clPath))) continue;
+			yield* Effect.try({
+				try: () => ChangelogTransformer.transformFile(clPath),
+				catch: (e) => new ReleasePlanError({
+					phase: "preview",
+					reason: errMsg(e)
+				})
+			});
+			const content = yield* fs.readFileString(clPath);
 			releases.push({
 				name: r.name,
 				type: r.type,
@@ -170,22 +197,17 @@ async function previewImpl(root) {
 			releases,
 			changesets
 		};
-	} finally {
-		rmSync(tempRoot, {
-			recursive: true,
-			force: true
-		});
-	}
+	});
+	return Effect.scoped(program).pipe(Effect.mapError((e) => e instanceof ReleasePlanError ? e : new ReleasePlanError({
+		phase: "preview",
+		reason: errMsg(e)
+	})));
 }
-/** Re-read a package's version from disk (post-bump) to feed versionFiles. */
-function diskVersion(workspaceDir, fallback) {
-	try {
-		return JSON.parse(readFileSync(join(workspaceDir, "package.json"), "utf-8")).version ?? fallback;
-	} catch {
-		return fallback;
-	}
+/** Re-read a package's version from disk (post-bump) to feed versionFiles; unreadable/unparseable falls back. */
+function diskVersion(workspaceDir, fallback, fs) {
+	return fs.readFileString(join(workspaceDir, "package.json")).pipe(Effect.flatMap((raw) => Effect.try(() => JSON.parse(raw).version ?? fallback)), Effect.orElseSucceed(() => fallback));
 }
-function applyEffect(root, dryRun, inspector) {
+function applyEffect(root, dryRun, inspector, fs) {
 	return Effect.gen(function* () {
 		const { plan, packages, config } = yield* Effect.tryPromise({
 			try: async () => {
@@ -222,22 +244,24 @@ function applyEffect(root, dryRun, inspector) {
 		const newVersionByName = new Map(plan.releases.map((r) => [r.name, r.newVersion]));
 		const inspected = yield* inspector.inspect(root).pipe(Effect.catchAll((error) => Effect.logWarning(`Skipping versionFiles update: ${errMsg(error)}`).pipe(Effect.as(null))));
 		let versionFileUpdates = [];
-		if (inspected) versionFileUpdates = yield* Effect.try({
-			try: () => {
-				const scopes = inspected.packages.filter((p) => p.versionFiles.length > 0).map((p) => {
-					const fresh = dryRun ? newVersionByName.get(p.name) ?? p.version : diskVersion(p.workspaceDir, p.version);
-					return fresh !== p.version ? {
-						...p,
-						version: fresh
-					} : p;
-				});
-				return scopes.length > 0 ? VersionFiles.processResolvedVersionFiles(scopes, dryRun) : [];
-			},
-			catch: (e) => new ReleasePlanError({
-				phase: "apply",
-				reason: errMsg(e)
-			})
-		});
+		if (inspected) {
+			const candidates = inspected.packages.filter((p) => p.versionFiles.length > 0);
+			const freshVersions = yield* Effect.forEach(candidates, (p) => dryRun ? Effect.succeed(newVersionByName.get(p.name) ?? p.version) : diskVersion(p.workspaceDir, p.version, fs));
+			const scopes = candidates.map((p, i) => {
+				const fresh = freshVersions[i];
+				return fresh !== p.version ? {
+					...p,
+					version: fresh
+				} : p;
+			});
+			versionFileUpdates = yield* Effect.try({
+				try: () => scopes.length > 0 ? VersionFiles.processResolvedVersionFiles(scopes, dryRun) : [],
+				catch: (e) => new ReleasePlanError({
+					phase: "apply",
+					reason: errMsg(e)
+				})
+			});
+		}
 		return {
 			dryRun,
 			touchedFiles,

package/changesets/utils/dep-diff.js

@@ -1,6 +1,35 @@
 import { sortDependencyRows } from "./dependency-table.js";
+import { Option } from "effect";
 
 //#region src/changesets/utils/dep-diff.ts
+/**
+* Compute per-workspace-package dependency-table rows from two
+* {@link WorkspaceStateSnapshot}s, resolving `catalog:` / `workspace:`
+* specifiers against each side's own catalogs and package versions BEFORE
+* comparing.
+*
+* @remarks
+* Operates on declared dependencies only (the `dependencies` /
+* `devDependencies` / `peerDependencies` / `optionalDependencies` fields
+* of each workspace's `package.json`). Lockfile-only movements
+* (resolved versions changing while declared ranges stay put) are
+* intentionally excluded — those happen on every `pnpm install` and
+* would generate constant noise.
+*
+* Each side carries its own catalogs and package versions, so a specifier
+* is resolved against the snapshot it belongs to: `catalog:silk` resolves
+* to that ref's `silk` catalog entry, `workspace:*` to that ref's target
+* package version. A row is emitted iff the two RESOLVED values differ (or
+* the dependency was added/removed) — a package that merely adopted a
+* `catalog:` specifier without changing the concrete version produces NO
+* row. When a side cannot resolve a specifier (no matching catalog entry,
+* plain range, etc.) it falls back to the raw specifier string.
+*
+* @see {@link DependencyTableRow} for the row schema
+* @see {@link WorkspaceStateSnapshot} for the input shape
+*
+*/
+/** The em-dash sentinel (U+2014) used for added ("from") / removed ("to") cells. */
 const EM_DASH = "—";
 const DEP_TYPE_MAP = [
 	["dependencies", "dependency"],
@@ -8,65 +37,70 @@ const DEP_TYPE_MAP = [
 	["peerDependencies", "peerDependency"],
 	["optionalDependencies", "optionalDependency"]
 ];
-function diffOneRecord(before, after, type) {
-	const rows = [];
-	const seen = /* @__PURE__ */ new Set();
-	for (const [name, beforeVersion] of Object.entries(before)) {
-		seen.add(name);
-		const afterVersion = after[name];
-		if (afterVersion === void 0) rows.push({
-			dependency: name,
-			type,
-			action: "removed",
-			from: beforeVersion,
-			to: EM_DASH
-		});
-		else if (afterVersion !== beforeVersion) rows.push({
-			dependency: name,
-			type,
-			action: "updated",
-			from: beforeVersion,
-			to: afterVersion
-		});
-	}
-	for (const [name, afterVersion] of Object.entries(after)) {
-		if (seen.has(name)) continue;
-		rows.push({
-			dependency: name,
-			type,
-			action: "added",
-			from: EM_DASH,
-			to: afterVersion
-		});
-	}
-	return rows;
-}
 /**
-* Diff two workspace snapshots and return per-package dependency-table rows.
+* Resolve a specifier against the snapshot it belongs to, falling back to
+* the raw specifier string when the snapshot cannot resolve it.
+*/
+const resolveOrRaw = (snapshot, dep, spec) => Option.getOrElse(snapshot.resolve(dep, spec), () => spec);
+/**
+* Diff two workspace snapshots and return per-package dependency-table rows,
+* comparing already-resolved specifier values per side.
 *
-* @param before - Snapshot at the older ref (typically the merge base). Pass
-*   `null` for workspace packages that did not exist at the older ref — every
-*   declared dep is then reported as `"added"`.
+* @param before - Snapshot at the older ref (typically the merge base). A
+*   workspace package absent here reports every declared dep as `"added"`.
 * @param after - Snapshot at the newer ref (typically the working tree).
 * @returns One {@link WorkspaceDependencyDiff} entry per workspace package
-*   that has at least one row. Packages with no changes are omitted.
+*   that has at least one row. Packages with no resolved-value changes are
+*   omitted.
 *
 * @public
 */
-function computeWorkspaceDependencyDiffs(beforeSnapshots, afterSnapshots) {
-	const beforeByName = new Map(beforeSnapshots.map((s) => [s.name, s]));
+function computeWorkspaceDependencyDiffs(before, after) {
 	const result = [];
-	for (const after of afterSnapshots) {
-		const before = beforeByName.get(after.name);
+	for (const afterPkg of after.packages) {
+		const beforePkg = Option.getOrNull(before.package(afterPkg.name));
 		const rows = [];
 		for (const [field, type] of DEP_TYPE_MAP) {
-			const beforeRecord = before?.[field] ?? {};
-			const afterRecord = after[field];
-			rows.push(...diffOneRecord(beforeRecord, afterRecord, type));
+			const beforeRecord = beforePkg?.[field] ?? {};
+			const afterRecord = afterPkg[field];
+			const seen = /* @__PURE__ */ new Set();
+			for (const [name, beforeSpec] of Object.entries(beforeRecord)) {
+				seen.add(name);
+				const from = resolveOrRaw(before, name, beforeSpec);
+				const afterSpec = afterRecord[name];
+				if (afterSpec === void 0) {
+					rows.push({
+						dependency: name,
+						type,
+						action: "removed",
+						from,
+						to: EM_DASH
+					});
+					continue;
+				}
+				const to = resolveOrRaw(after, name, afterSpec);
+				if (from !== to) rows.push({
+					dependency: name,
+					type,
+					action: "updated",
+					from,
+					to
+				});
+			}
+			for (const [name, afterSpec] of Object.entries(afterRecord)) {
+				if (seen.has(name)) continue;
+				rows.push({
+					dependency: name,
+					type,
+					action: "added",
+					from: EM_DASH,
+					to: resolveOrRaw(after, name, afterSpec)
+				});
+			}
 		}
 		if (rows.length > 0) result.push({
-			package: after.name,
-			relativePath: after.relativePath,
+			package: afterPkg.name,
+			relativePath: afterPkg.relativePath,
 			rows: sortDependencyRows(rows)
 		});
 	}

package/changesets/utils/git.js

@@ -0,0 +1,51 @@
+import { GitError } from "../errors.js";
+import { Effect } from "effect";
+import { execFileSync } from "node:child_process";
+
+//#region src/changesets/utils/git.ts
+/**
+* Git helpers for the changesets deps regen/detect orchestration.
+*
+* @remarks
+* `PointInTimeWorkspace` (from `workspaces-effect`) reads both sides of a
+* dependency diff over `CommandExecutor`. The one git operation it does not
+* cover is resolving the default `--from` ref — the merge-base with the base
+* branch — which stays here as a synchronous `execFileSync` shell-out.
+*
+* @internal
+*/
+/**
+* Run `git merge-base <base> HEAD`, returning the SHA. Errors propagate
+* as {@link GitError}.
+*
+* @internal
+*/
+function gitMergeBase(cwd, base) {
+	return Effect.try({
+		try: () => execFileSync("git", [
+			"merge-base",
+			base,
+			"HEAD"
+		], {
+			cwd,
+			encoding: "utf8",
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		}).trim(),
+		catch: (error) => {
+			const stderr = error.stderr;
+			const text = typeof stderr === "string" ? stderr : stderr?.toString() ?? "";
+			return new GitError({
+				command: `git merge-base ${base} HEAD`,
+				cwd,
+				reason: text.trim() || (error.message ?? String(error))
+			});
+		}
+	});
+}
+
+//#endregion
+export { gitMergeBase };

package/changesets/utils/publishability.js

@@ -20,16 +20,28 @@ import { PublishabilityDetector } from "workspaces-effect";
 * Uses the currently-active {@link SilkPublishability} — wire the
 * {@link SilkPublishabilityDetectorLive} layer to get silk semantics.
 *
+* `root` is passed through verbatim to `detector.detect(pkg, root)` for every
+* package — it must be the project root (the directory containing
+* `.changeset/`), NOT the individual package's directory. The vanilla
+* `PublishabilityDetectorLive` and plain `SilkPublishabilityDetectorLive`
+* both ignore this argument, but the ignore/mode-aware
+* `PublishabilityDetectorAdaptiveLive` reads `.changeset/config.json`
+* relative to it, so passing a package subdirectory silently makes every
+* package resolve to "not publishable". Mirrors
+* {@link SilkPublishability.listPublishable}, which takes the same
+* single-root parameter for the same reason.
+*
 * @param packages - The workspace packages to evaluate
+* @param root - Absolute path to the project root containing `.changeset/`
 * @returns An Effect yielding a `Set` of publishable package names
 *
 * @public
 */
-function listPublishablePackageNames(packages) {
+function listPublishablePackageNames(packages, root) {
 	return Effect.gen(function* () {
 		const detector = yield* PublishabilityDetector;
 		const names = /* @__PURE__ */ new Set();
-		for (const pkg of packages) if ((yield* detector.detect(pkg, pkg.path)).length > 0) names.add(pkg.name);
+		for (const pkg of packages) if ((yield* detector.detect(pkg, root)).length > 0) names.add(pkg.name);
 		return names;
 	});
 }