@savvy-web/silk-effects 3.2.2 → 3.2.4

package/README.md

@@ -145,7 +145,7 @@ See [Publishability](./docs/publishability.md) for the adaptive layer and the `C
 
 #### ChangesetConfig
 
-Typed accessor over a workspace root's `.changeset/config.json`, reading through `ChangesetConfigReader` with a per-root cache. Every accessor is total — a missing or unreadable config collapses to `mode: "none"` and empty defaults. Methods: `mode`, `versionPrivate`, `ignorePatterns`, `isIgnored`, `fixed`, plus a static `ChangesetConfig.matches(name, pattern)`.
+Typed accessor over a workspace root's `.changeset/config.json`, reading through `ChangesetConfigReader` with a per-root cache. Every accessor is total — a missing or unreadable config collapses to `mode: "none"` and empty defaults. Methods: `mode`, `versionPrivate`, `ignorePatterns`, `isIgnored`, `fixed` and `refresh` (drops every cached read so a long-lived host observes on-disk config edits made since the last call), plus a static `ChangesetConfig.matches(name, pattern)`.
 
 ```typescript
 import { Effect } from "effect";

package/changesets/services/config-inspector.js

@@ -402,9 +402,14 @@ function makeShape(reader, discovery, fs) {
 		const inspected = yield* inspect(cwd);
 		return paths.map((p) => classifyOne(inspected, p));
 	});
+	const refresh = () => Effect.gen(function* () {
+		cache.clear();
+		yield* discovery.refresh();
+	});
 	return {
 		inspect,
-		classify
+		classify,
+		refresh
 	};
 }
 /**
@@ -474,7 +479,8 @@ const ConfigInspectorLive = Layer.effect(ConfigInspector, Effect.gen(function* (
 function makeConfigInspectorTest(fixed) {
 	return Layer.succeed(ConfigInspector, {
 		inspect: () => Effect.succeed(fixed),
-		classify: (_cwd, paths) => Effect.succeed(paths.map((p) => classifyOne(fixed, p)))
+		classify: (_cwd, paths) => Effect.succeed(paths.map((p) => classifyOne(fixed, p))),
+		refresh: () => Effect.void
 	});
 }
 

package/changesets/services/deps-regen.js

@@ -5,10 +5,10 @@ import { ChangesetConfig, ChangesetConfigLive } from "../../services/ChangesetCo
 import { PublishabilityDetectorAdaptiveLive } from "../../services/SilkPublishability.js";
 import { ConfigInspector, ConfigInspectorLive } from "./config-inspector.js";
 import { computeWorkspaceDependencyDiffs } from "../utils/dep-diff.js";
-import { gitMergeBase } from "../utils/git.js";
+import { gitListChangesetFilesAtRef, gitMergeBase } from "../utils/git.js";
 import { listPublishablePackageNames } from "../utils/publishability.js";
 import { Context, Effect, Layer, Option } from "effect";
-import { join, resolve } from "node:path";
+import { basename, join, resolve } from "node:path";
 import { FileSystem } from "@effect/platform";
 import { PointInTimeWorkspace, PointInTimeWorkspaceLive, PublishabilityDetector, WorkspaceDiscovery, WorkspaceDiscoveryLive, WorkspaceRootLive } from "workspaces-effect";
 
@@ -30,6 +30,15 @@ import { PointInTimeWorkspace, PointInTimeWorkspaceLive, PublishabilityDetector,
 * first, then deleting the stale pure-dependency ones (so an interrupted
 * run loses nothing and is safely re-runnable).
 *
+* A pure dependency changeset is only ever a delete candidate when BOTH:
+* its package is in scope AND actually produced a fresh diff this run
+* (present in {@link RegenPlan.toWrite}), and the file was authored on
+* this branch rather than already committed at the merge-base ref. Either
+* gap silently destroyed a still-relevant release note before this was
+* fixed (#258) — a devDependency-only diff drops all its rows and was
+* never rewritten, and a changeset an earlier, already-merged PR
+* committed was swept away by an unrelated branch's regen run.
+*
 * This is the single source of truth for regen/detect: the CLI commands
 * and MCP tools are thin adapters over this service.
 *
@@ -250,7 +259,8 @@ function makeShape(pit, inspector, discovery, detector, config, fs) {
 	const plan = (options) => Effect.gen(function* () {
 		const resolvedCwd = resolve(options.cwd);
 		const changesetDir = join(resolvedCwd, ".changeset");
-		yield* discovery.refresh();
+		yield* inspector.refresh();
+		yield* config.refresh();
 		let fromRef = options.from;
 		if (!fromRef) {
 			let baseBranch = options.base;
@@ -287,7 +297,10 @@ function makeShape(pit, inspector, discovery, detector, config, fs) {
 		}
 		const existingPure = yield* findPureDependencyChangesets(fs, changesetDir);
 		const skippedMixed = yield* findMixedDependencyChangesets(fs, changesetDir);
-		const toDelete = existingPure.filter((p) => inScopeFor(p.package));
+		const rewrittenPackages = new Set(resolved.map((d) => d.package));
+		const atMergeBase = yield* gitListChangesetFilesAtRef(resolvedCwd, fromRef);
+		const authoredOnBranch = (file) => !atMergeBase.has(basename(file));
+		const toDelete = existingPure.filter((p) => inScopeFor(p.package) && rewrittenPackages.has(p.package) && authoredOnBranch(p.file));
 		const chosenFilenames = /* @__PURE__ */ new Set();
 		const toWrite = [];
 		for (const diff of resolved) {

package/changesets/utils/git.js

@@ -1,5 +1,6 @@
 import { GitError } from "../errors.js";
 import { Effect } from "effect";
+import { basename } from "node:path";
 import { execFileSync } from "node:child_process";
 
 //#region src/changesets/utils/git.ts
@@ -46,6 +47,48 @@ function gitMergeBase(cwd, base) {
 		}
 	});
 }
+/**
+* List the basenames of `.changeset/*.md` files tracked at `ref` (e.g. the
+* merge base), via `git ls-tree -r --name-only`. Used by `DepsRegen.plan()`
+* to protect changesets authored by already-merged PRs from being deleted by
+* an unrelated branch's regen run (#258).
+*
+* @remarks
+* Deliberately tolerant, unlike {@link gitMergeBase}: `cwd` may not be a git
+* repository at all (many `DepsRegen` unit tests pass synthetic refs like
+* `"BEFORE"`/`"AFTER"` against a bare tmpdir), and an unresolvable ref is a
+* plausible caller mistake rather than a fatal condition. Either failure mode
+* resolves to an empty set — "nothing protected" — rather than propagating a
+* {@link GitError}, so a missing/invalid git context degrades the
+* authorship filter to a no-op instead of blocking the whole plan.
+*
+* @internal
+*/
+function gitListChangesetFilesAtRef(cwd, ref) {
+	return Effect.sync(() => {
+		try {
+			const out = execFileSync("git", [
+				"ls-tree",
+				"-r",
+				"--name-only",
+				ref,
+				"--",
+				".changeset"
+			], {
+				cwd,
+				encoding: "utf8",
+				stdio: [
+					"ignore",
+					"pipe",
+					"pipe"
+				]
+			});
+			return new Set(out.split(/\r?\n/).filter((line) => line.trim().length > 0).map((path) => basename(path)));
+		} catch {
+			return /* @__PURE__ */ new Set();
+		}
+	});
+}
 
 //#endregion
-export { gitMergeBase };
+export { gitListChangesetFilesAtRef, gitMergeBase };

package/index.d.ts

@@ -3002,6 +3002,17 @@ interface ConfigInspectorShape {
    *   input path, in the same order
    */
   readonly classify: (cwd: string, paths: ReadonlyArray<string>) => Effect.Effect<ReadonlyArray<Classification>, ConfigurationError>;
+  /**
+   * Drop the cached {@link InspectedConfig} for every previously-inspected
+   * root, and refresh the underlying `WorkspaceDiscovery` snapshot. Callers
+   * that hold this service across multiple logical operations in a single
+   * process (e.g. a long-lived MCP server) must call this before an
+   * operation that needs to observe on-disk edits made since the last
+   * `inspect`/`classify` call — the cache never expires on its own.
+   *
+   * @returns An Effect that clears the cache and succeeds with `void`.
+   */
+  readonly refresh: () => Effect.Effect<void>;
 }
 /**
  * Base class for {@link ConfigInspector}.
@@ -3697,6 +3708,14 @@ declare const ChangesetConfig_base: Context.TagClass<ChangesetConfig, "@savvy-we
   readonly ignorePatterns: (root: string) => Effect.Effect<ReadonlyArray<string>>;
   readonly isIgnored: (name: string, root: string) => Effect.Effect<boolean>;
   readonly fixed: (root: string) => Effect.Effect<ReadonlyArray<ReadonlyArray<string>>>;
+  /**
+   * Drop the cached read for every previously-read root. Callers that hold
+   * this service across multiple logical operations in a single process
+   * (e.g. a long-lived MCP server) must call this before an operation that
+   * needs to observe an on-disk edit made since the last accessor call —
+   * the cache never expires on its own.
+   */
+  readonly refresh: () => Effect.Effect<void>;
 }>;
 /**
  * Accessor service over a workspace root's `.changeset/config.json`.

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@savvy-web/silk-effects",
-	"version": "3.2.2",
+	"version": "3.2.4",
 	"private": false,
 	"description": "Shared Effect library for Silk Suite conventions",
 	"homepage": "https://github.com/savvy-web/systems/tree/main/packages/silk-effects",
@@ -36,7 +36,7 @@
 		"jsonc-effect": "^0.3.1",
 		"mdast-util-heading-range": "^4.0.0",
 		"mdast-util-to-string": "^4.0.0",
-		"prettier": "^3.9.4",
+		"prettier": "^3.9.5",
 		"remark-gfm": "^4.0.1",
 		"remark-parse": "^11.0.0",
 		"remark-stringify": "^11.0.0",

package/services/ChangesetConfig.js

@@ -72,7 +72,8 @@ const ChangesetConfigLive = Layer.effect(ChangesetConfig, Effect.gen(function* (
 		fixed: (root) => read(root).pipe(Effect.map(Option.match({
 			onNone: () => [],
 			onSome: (cfg) => cfg.fixed ?? []
-		})))
+		}))),
+		refresh: () => Effect.sync(() => cache.clear())
 	};
 }));