@savvy-web/silk-effects 1.5.2 → 2.0.0

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;
 	});
 }