@savvy-web/silk-effects 7.0.1 → 7.1.1

package/changesets/remark/plugins/contributor-footnotes.js

@@ -9,6 +9,12 @@ import { visit } from "unist-util-visit";
 */
 const ATTRIBUTION_PLAIN_RE = /\s*Thanks @(\w[\w-]*)!$/;
 /**
+* Pattern matching `@user` mentions inside an existing Thanks section.
+*
+* @internal
+*/
+const MENTION_RE = /@(\w[\w-]*)/g;
+/**
 * Try to extract a linked attribution from the end of a paragraph's children.
 * Pattern: text "...Thanks " + link "\@user" + text "!"
 *
@@ -40,81 +46,287 @@ function extractLinkedAttribution(children) {
 		removeFrom: children.length - 3
 	};
 }
-const ContributorFootnotesPlugin = () => {
+/**
+* Strip a trailing attribution (linked or plain) from a paragraph, adding
+* the contributor to the map.
+*
+* @param para - The paragraph to inspect and mutate
+* @param contributors - The per-block contributor accumulator
+* @returns `true` when an attribution was found and removed
+*
+* @internal
+*/
+function stripAttribution(para, contributors) {
+	const linked = extractLinkedAttribution(para.children);
+	if (linked) {
+		const key = linked.contributor.username.toLowerCase();
+		if (!contributors.has(key)) contributors.set(key, linked.contributor);
+		const textNode = para.children[linked.removeFrom];
+		textNode.value = textNode.value.replace(/\s*Thanks $/, "");
+		para.children.splice(linked.removeFrom + 1, 2);
+		if (textNode.value === "") para.children.splice(linked.removeFrom, 1);
+		return true;
+	}
+	const last = para.children[para.children.length - 1];
+	if (last?.type === "text") {
+		const textNode = last;
+		const match = textNode.value.match(ATTRIBUTION_PLAIN_RE);
+		if (match) {
+			const username = match[1];
+			const key = username.toLowerCase();
+			if (!contributors.has(key)) contributors.set(key, {
+				username,
+				url: void 0
+			});
+			textNode.value = textNode.value.replace(ATTRIBUTION_PLAIN_RE, "");
+			if (textNode.value === "") para.children.pop();
+			return true;
+		}
+	}
+	return false;
+}
+/**
+* Harvest every `@user` mention (linked or plain) from a node subtree.
+* Used to absorb an existing `### Thanks` section so re-running the plugin
+* is idempotent.
+*
+* @internal
+*/
+function harvestMentions(node, contributors) {
+	visit(node, (child) => {
+		if (child.type === "link") {
+			const link = child;
+			const only = link.children.length === 1 ? link.children[0] : void 0;
+			if (only?.type === "text" && only.value.startsWith("@")) {
+				const username = only.value.slice(1);
+				const key = username.toLowerCase();
+				if (!contributors.has(key)) contributors.set(key, {
+					username,
+					url: link.url
+				});
+				return "skip";
+			}
+		} else if (child.type === "text") for (const match of child.value.matchAll(MENTION_RE)) {
+			const key = match[1].toLowerCase();
+			if (!contributors.has(key)) contributors.set(key, {
+				username: match[1],
+				url: void 0
+			});
+		}
+	});
+}
+/**
+* Build the `Thanks to ... for their contributions!` summary paragraph.
+*
+* @internal
+*/
+function buildSummaryParagraph(contributors) {
+	const sorted = [...contributors.values()].sort((a, b) => a.username.toLowerCase().localeCompare(b.username.toLowerCase()));
+	const phrasingChildren = [];
+	phrasingChildren.push({
+		type: "text",
+		value: "Thanks to "
+	});
+	for (let i = 0; i < sorted.length; i++) {
+		const contrib = sorted[i];
+		if (i > 0 && sorted.length > 2) phrasingChildren.push({
+			type: "text",
+			value: ", "
+		});
+		if (i > 0 && i === sorted.length - 1) phrasingChildren.push({
+			type: "text",
+			value: sorted.length === 2 ? " and " : "and "
+		});
+		if (contrib.url) phrasingChildren.push({
+			type: "link",
+			url: contrib.url,
+			children: [{
+				type: "text",
+				value: `@${contrib.username}`
+			}]
+		});
+		else phrasingChildren.push({
+			type: "text",
+			value: `@${contrib.username}`
+		});
+	}
+	phrasingChildren.push({
+		type: "text",
+		value: " for their contributions!"
+	});
+	return {
+		type: "paragraph",
+		children: phrasingChildren
+	};
+}
+/**
+* Remove list items (recursively) whose content was emptied by attribution
+* stripping — a bullet that held ONLY `Thanks @user!` must not survive as a
+* bare `- ` husk. Runs in both the `thanks: true` and `thanks: false` paths,
+* since stripping is unconditional.
+*
+* @internal
+*/
+function pruneEmptiedListItems(list) {
+	list.children = list.children.filter((item) => {
+		item.children = item.children.filter((child) => {
+			if (child.type === "paragraph") return child.children.length > 0;
+			if (child.type === "list") {
+				const nested = child;
+				pruneEmptiedListItems(nested);
+				return nested.children.length > 0;
+			}
+			return true;
+		});
+		return item.children.length > 0;
+	});
+}
+/**
+* Text form of a paragraph: concatenated text values, with single-text link
+* children flattened to their label. Returns `undefined` when the paragraph
+* holds anything other than text and simple text-labelled links.
+*
+* @internal
+*/
+function flattenToText(para) {
+	let out = "";
+	for (const child of para.children) {
+		if (child.type === "text") {
+			out += child.value;
+			continue;
+		}
+		if (child.type === "link") {
+			const link = child;
+			const only = link.children.length === 1 ? link.children[0] : void 0;
+			if (only?.type === "text") {
+				out += only.value;
+				continue;
+			}
+		}
+		return;
+	}
+	return out;
+}
+/**
+* Pattern matching the plugin's own merged summary paragraph, e.g.
+* `Thanks to @alice, @bob, and @carol for their contributions!`.
+*
+* @internal
+*/
+const MERGED_SUMMARY_RE = /^Thanks to @\w[\w-]*(?:(?:, | and |, and |,and )@\w[\w-]*)* for their contributions!$/;
+/**
+* Whether a paragraph consists ENTIRELY of attribution content the plugin
+* owns: either its own merged `Thanks to ... for their contributions!`
+* summary, or one or more trailing `Thanks @user!` / `Thanks [@user](url)!`
+* attributions with nothing else. Checked against a clone so the real node
+* is never mutated — a paragraph carrying anything beyond pure attribution
+* is not the plugin's to touch.
+*
+* @internal
+*/
+function isPureAttributionParagraph(para) {
+	const text = flattenToText(para);
+	if (text !== void 0 && MERGED_SUMMARY_RE.test(text)) return true;
+	const clone = structuredClone(para);
+	const scratch = /* @__PURE__ */ new Map();
+	while (clone.children.length > 0 && stripAttribution(clone, scratch));
+	return clone.children.length === 0;
+}
+/**
+* Whether a Thanks-section body node is a pure attribution shape the plugin
+* may harvest and remove: an attribution-only paragraph, or a list whose
+* every item holds only attribution-only paragraphs. Anything else
+* (mixed prose+mention, plain-name lists, code blocks, arbitrary prose) is
+* preserved untouched and never mined for mentions.
+*
+* @internal
+*/
+function isPureAttributionNode(node) {
+	if (node.type === "paragraph") return isPureAttributionParagraph(node);
+	if (node.type === "list") {
+		const list = node;
+		return list.children.length > 0 && list.children.every((item) => item.children.length > 0 && item.children.every((child) => child.type === "paragraph" && isPureAttributionParagraph(child)));
+	}
+	return false;
+}
+/**
+* Whether a node is a depth-3 heading whose text is `Thanks`.
+*
+* @internal
+*/
+function isThanksHeading(node) {
+	if (node.type !== "heading" || node.depth !== 3) return false;
+	const heading = node;
+	const only = heading.children.length === 1 ? heading.children[0] : void 0;
+	return only?.type === "text" && only.value.trim().toLowerCase() === "thanks";
+}
+const ContributorFootnotesPlugin = (options) => {
+	const emitThanks = options?.thanks !== false;
 	return (tree) => {
 		const blocks = getVersionBlocks(tree);
 		for (let b = blocks.length - 1; b >= 0; b--) {
 			const block = blocks[b];
 			const contributors = /* @__PURE__ */ new Map();
+			const indicesToRemove = [];
+			let preservedThanksAnchor;
 			for (let i = block.startIndex; i < block.endIndex; i++) {
 				const node = tree.children[i];
-				if (node.type !== "list") continue;
-				visit(node, "paragraph", (para) => {
-					const linked = extractLinkedAttribution(para.children);
-					if (linked) {
-						const key = linked.contributor.username.toLowerCase();
-						if (!contributors.has(key)) contributors.set(key, linked.contributor);
-						const textNode = para.children[linked.removeFrom];
-						textNode.value = textNode.value.replace(/\s*Thanks $/, "");
-						para.children.splice(linked.removeFrom + 1, 2);
-						if (textNode.value === "") para.children.splice(linked.removeFrom, 1);
-						return;
+				if (node.type === "list") {
+					const listNode = node;
+					visit(listNode, "paragraph", (para) => {
+						stripAttribution(para, contributors);
+					});
+					pruneEmptiedListItems(listNode);
+					if (listNode.children.length === 0) indicesToRemove.push(i);
+					continue;
+				}
+				if (node.type === "paragraph") {
+					const para = node;
+					if (stripAttribution(para, contributors) && para.children.length === 0) indicesToRemove.push(i);
+					continue;
+				}
+				if (isThanksHeading(node)) {
+					const headingIndex = i;
+					const harvested = [];
+					let lastPreserved;
+					let j = i + 1;
+					for (; j < block.endIndex; j++) {
+						const contentNode = tree.children[j];
+						if (contentNode.type === "heading" && [2, 3].includes(contentNode.depth)) break;
+						if (contentNode.type === "definition") continue;
+						if (isPureAttributionNode(contentNode)) {
+							harvestMentions(contentNode, contributors);
+							harvested.push(j);
+						} else lastPreserved = contentNode;
 					}
-					const last = para.children[para.children.length - 1];
-					if (last?.type === "text") {
-						const textNode = last;
-						const match = textNode.value.match(ATTRIBUTION_PLAIN_RE);
-						if (match) {
-							const username = match[1];
-							const key = username.toLowerCase();
-							if (!contributors.has(key)) contributors.set(key, {
-								username,
-								url: void 0
-							});
-							textNode.value = textNode.value.replace(ATTRIBUTION_PLAIN_RE, "");
-						}
+					if (lastPreserved === void 0) indicesToRemove.push(headingIndex, ...harvested);
+					else {
+						indicesToRemove.push(...harvested);
+						preservedThanksAnchor ??= lastPreserved;
 					}
-				});
+					i = j - 1;
+				}
 			}
-			if (contributors.size === 0) continue;
-			const sorted = [...contributors.values()].sort((a, b) => a.username.toLowerCase().localeCompare(b.username.toLowerCase()));
-			const phrasingChildren = [];
-			phrasingChildren.push({
-				type: "text",
-				value: "Thanks to "
-			});
-			for (let i = 0; i < sorted.length; i++) {
-				const contrib = sorted[i];
-				if (i > 0 && sorted.length > 2) phrasingChildren.push({
-					type: "text",
-					value: ", "
-				});
-				if (i > 0 && i === sorted.length - 1) phrasingChildren.push({
-					type: "text",
-					value: sorted.length === 2 ? " and " : "and "
-				});
-				if (contrib.url) phrasingChildren.push({
-					type: "link",
-					url: contrib.url,
-					children: [{
-						type: "text",
-						value: `@${contrib.username}`
-					}]
-				});
-				else phrasingChildren.push({
-					type: "text",
-					value: `@${contrib.username}`
-				});
+			const uniqueIndices = [...new Set(indicesToRemove)].sort((a, b) => b - a);
+			for (const idx of uniqueIndices) tree.children.splice(idx, 1);
+			if (!emitThanks || contributors.size === 0) continue;
+			if (preservedThanksAnchor !== void 0) {
+				const anchorIndex = tree.children.indexOf(preservedThanksAnchor);
+				if (anchorIndex !== -1) {
+					tree.children.splice(anchorIndex + 1, 0, buildSummaryParagraph(contributors));
+					continue;
+				}
 			}
-			phrasingChildren.push({
-				type: "text",
-				value: " for their contributions!"
-			});
-			const paragraph = {
-				type: "paragraph",
-				children: phrasingChildren
-			};
-			tree.children.splice(block.endIndex, 0, paragraph);
+			let insertAt = block.endIndex - uniqueIndices.length;
+			while (insertAt > block.startIndex && tree.children[insertAt - 1]?.type === "definition") insertAt--;
+			tree.children.splice(insertAt, 0, {
+				type: "heading",
+				depth: 3,
+				children: [{
+					type: "text",
+					value: "Thanks"
+				}]
+			}, buildSummaryParagraph(contributors));
 		}
 	};
 };

package/changesets/remark/plugins/reorder-sections.js

@@ -8,6 +8,23 @@ import { getBlockSections, getHeadingText, getVersionBlocks } from "../../utils/
 * @internal
 */
 const UNKNOWN_PRIORITY = 999;
+/**
+* Priority for the `Thanks` section emitted by {@link ContributorFootnotesPlugin}.
+* Sorts after everything — including unknown headings — so the contributor
+* credits always close the version block.
+*
+* @internal
+*/
+const THANKS_PRIORITY = 1e3;
+/**
+* Resolve the sort priority for a section heading.
+*
+* @internal
+*/
+function headingPriority(text) {
+	if (text.trim().toLowerCase() === "thanks") return THANKS_PRIORITY;
+	return fromHeading(text)?.priority ?? UNKNOWN_PRIORITY;
+}
 const ReorderSectionsPlugin = () => {
 	return (tree) => {
 		const blocks = getVersionBlocks(tree);
@@ -18,9 +35,7 @@ const ReorderSectionsPlugin = () => {
 			const preamble = [];
 			for (let i = block.startIndex; i < block.endIndex; i++) if (i < sections[0].headingIndex) preamble.push(tree.children[i]);
 			else break;
-			const sorted = [...sections].sort((a, b) => {
-				return (fromHeading(getHeadingText(a.heading))?.priority ?? UNKNOWN_PRIORITY) - (fromHeading(getHeadingText(b.heading))?.priority ?? UNKNOWN_PRIORITY);
-			});
+			const sorted = [...sections].sort((a, b) => headingPriority(getHeadingText(a.heading)) - headingPriority(getHeadingText(b.heading)));
 			if (sorted.every((s, i) => s.headingIndex === sections[i].headingIndex)) continue;
 			const newChildren = [...preamble];
 			for (const section of sorted) newChildren.push(section.heading, ...section.contentNodes);

package/changesets/remark/presets.js

@@ -3,8 +3,8 @@ import { DependencyTableFormatRule } from "./rules/dependency-table-format.js";
 import { HeadingHierarchyRule } from "./rules/heading-hierarchy.js";
 import { RequiredSectionsRule } from "./rules/required-sections.js";
 import { UncategorizedContentRule } from "./rules/uncategorized-content.js";
-import { AggregateDependencyTablesPlugin } from "./plugins/aggregate-dependency-tables.js";
 import { ContributorFootnotesPlugin } from "./plugins/contributor-footnotes.js";
+import { AggregateDependencyTablesPlugin } from "./plugins/aggregate-dependency-tables.js";
 import { DeduplicateItemsPlugin } from "./plugins/deduplicate-items.js";
 import { IssueLinkRefsPlugin } from "./plugins/issue-link-refs.js";
 import { MergeSectionsPlugin } from "./plugins/merge-sections.js";

package/changesets/remark/rules/dependency-table-format.js

@@ -1,5 +1,6 @@
 import { parseDependencyTable } from "../../utils/dependency-table.js";
 import { RULE_DOCS } from "../../constants.js";
+import { scanDependencySection } from "../../utils/dependency-section.js";
 import { toString } from "mdast-util-to-string";
 import { lintRule } from "unified-lint-rule";
 import { visit } from "unist-util-visit";
@@ -12,18 +13,15 @@ const DependencyTableFormatRule = lintRule("remark-lint:changeset-dependency-tab
 		if (node.depth !== 2) return;
 		if (toString(node).toLowerCase() !== "dependencies") return;
 		if (index === void 0) return;
-		const content = [];
-		for (let i = index + 1; i < tree.children.length; i++) {
-			const child = tree.children[i];
-			if (child.type === "heading") break;
-			content.push(child);
-		}
-		const tables = content.filter((n) => n.type === "table");
-		if (tables.length === 0) {
+		const scan = scanDependencySection(tree.children, index + 1, {
+			isHeading: (n) => n.type === "heading",
+			isTable: (n) => n.type === "table"
+		});
+		if (scan.table === void 0) {
 			file.message(`Dependencies section must contain a table, not a list or paragraph. See: ${RULE_DOCS.CSH005}`, node);
 			return;
 		}
-		const table = tables[0];
+		const table = scan.table;
 		try {
 			const rows = parseDependencyTable(table);
 			for (const row of rows) {

package/changesets/schemas/dependency-table.js

@@ -52,8 +52,14 @@ const DependencyActionSchema = Schema.Literals([
 * @remarks
 * Unlike {@link DependencyTypeSchema} (which uses plural npm field names like
 * `"dependencies"`), this schema uses singular forms (`"dependency"`) and adds
-* two additional types: `"workspace"` for monorepo workspace references and
-* `"config"` for configuration toolchain updates (e.g., ESLint, TypeScript).
+* four additional types with no `package.json` dependency-field counterpart:
+* `"workspace"` for monorepo workspace references, `"config"` for
+* configuration toolchain updates (e.g., ESLint, TypeScript), `"runtime"` for
+* language-runtime upgrades (e.g., the Node.js engine itself), and
+* `"packageManager"` for the package manager's own self-upgrade (pnpm, bun,
+* npm). `"runtime"` and `"packageManager"` are release-neutral — like
+* `devDependency` rows they document toolchain movement without implying a
+* consumer-facing version bump.
 *
 * @example
 * ```typescript
@@ -76,7 +82,9 @@ const DependencyTableTypeSchema = Schema.Literals([
 	"peerDependency",
 	"optionalDependency",
 	"workspace",
-	"config"
+	"config",
+	"runtime",
+	"packageManager"
 ]);
 /**
 * The canonical accepted-value pattern for a dependency-table From/To cell:

package/changesets/schemas/options.js

@@ -106,6 +106,14 @@ const ChangesetOptionsSchema = Schema.Struct({
 	/** Custom issue reference prefixes (e.g., `["#", "GH-"]`). */
 	issuePrefixes: Schema.optional(Schema.Array(Schema.String)),
 	/**
+	* Whether to credit contributors with `Thanks \@user!` attributions
+	* (aggregated into a `### Thanks` section by the transform pipeline).
+	* Defaults to `true`; set `false` to strip attribution entirely —
+	* no inline thanks and no Thanks section. PR references are kept
+	* either way.
+	*/
+	thanks: Schema.optional(Schema.Boolean),
+	/**
 	* Per-package release surfaces. Each entry declares `additionalScopes`
 	* (globs outside the workspace dir that belong to the package) and
 	* `versionFiles` (files bumped in lockstep with the package's version).

package/changesets/services/config-inspector.js

@@ -1,9 +1,10 @@
 import { ConfigurationError } from "../errors.js";
 import { ChangesetOptionsSchema } from "../schemas/options.js";
+import { MARKDOWNLINT_CONFIG_PATH } from "../../lint/cli/sections.js";
 import { ChangesetConfigReader } from "../../services/ChangesetConfigReader.js";
 import { SilkPublishability, readTargetsBinding } from "../../services/SilkPublishability.js";
 import { Context, Effect, FileSystem, Layer, Path, Result, Schema } from "effect";
-import { isAbsolute, join, relative, resolve } from "node:path";
+import { isAbsolute, join, relative, resolve, sep } from "node:path";
 import { GlobPattern, GlobPatternOptions } from "@effected/glob";
 import { compileAndExpand } from "@effected/walker";
 import { WorkspaceDiscovery } from "@effected/workspaces";
@@ -78,6 +79,10 @@ const ClassificationReasonSchema = Schema.Union([
 		kind: Schema.Literal("versionFile"),
 		glob: Schema.String
 	}),
+	Schema.Struct({
+		kind: Schema.Literal("unmappedHint"),
+		hint: Schema.String.annotate({ description: "Why this UNMAPPED path is probably not an unattributed change: it matches a config glob whose file no longer materializes (deleted versionFiles / additionalScopes target) or mirrors a known package template. The package stays null — a hint is context, not attribution." })
+	}),
 	Schema.Null
 ]).annotate({ identifier: "ClassificationReason" });
 /** The result of classifying a single path against a resolved config. @public */
@@ -398,7 +403,7 @@ function makeShape(reader, discovery, fs) {
 			throw e;
 		}
 		const decodedOptions = yield* Schema.decodeUnknownEffect(ChangesetOptionsSchema)(normalized).pipe(Effect.mapError((parseError) => configErrorFromParseError(parseError, configPath)));
-		const workspaces = (yield* discovery.listPackages().pipe(Effect.mapError((err) => new ConfigurationError({
+		const workspaces = (yield* discovery.listPackagesIn(projectDir).pipe(Effect.mapError((err) => new ConfigurationError({
 			field: "workspace",
 			reason: `Workspace discovery failed for ${projectDir}: ${err.message}`
 		})))).map((w) => ({
@@ -448,13 +453,43 @@ function makeShape(reader, discovery, fs) {
 		cache.clear();
 		yield* discovery.refresh();
 	});
+	const refreshIn = (directory) => Effect.gen(function* () {
+		const target = resolve(directory);
+		for (const key of [...cache.keys()]) if (target === key || target.startsWith(key + sep)) cache.delete(key);
+		yield* Effect.ignore(discovery.refreshIn(target));
+	});
 	return {
 		inspect,
 		classify,
-		refresh
+		refresh,
+		refreshIn
 	};
 }
 /**
+* Known template-mirror pairs (#290): repo files generated from (or kept in
+* byte-lockstep with) a template a package ships, keyed by projectDir-relative
+* POSIX path. An unmapped diff on one of these is a mirror of an already
+* attributed template change, not an unattributed change needing its own
+* changeset — the hint spares the agent a manual diff. Deliberately a small
+* static table, not a diff-correlation engine.
+*/
+const TEMPLATE_MIRRORS = { [MARKDOWNLINT_CONFIG_PATH]: "mirrors the @savvy-web/silk-effects markdownlint template (src/lint/cli/templates/markdownlint.gen.ts)" };
+/**
+* A machine-readable hint for a path that mapped to NO package (#290): a
+* versionFiles / additionalScopes glob that names the path without a
+* materialized file behind it (the deleted-file shape branch diffs produce),
+* or a known template mirror. Pure — pattern matching only, no filesystem.
+* `null` when nothing explains the path.
+*/
+function unmappedHint(inspected, rel) {
+	for (const s of inspected.packages) for (const vf of s.versionFiles) if (globMatchesRel(vf.glob, rel)) return `versionFiles of "${s.name}" (glob "${vf.glob}")`;
+	for (const s of inspected.packages) {
+		const glob = s.additionalScopes.find((g) => globMatchesRel(g, rel));
+		if (glob !== void 0) return `additionalScopes of "${s.name}" (glob "${glob}")`;
+	}
+	return Object.hasOwn(TEMPLATE_MIRRORS, rel) ? TEMPLATE_MIRRORS[rel] : null;
+}
+/**
 * Classify a single path against an inspected config.
 */
 function classifyOne(inspected, path) {
@@ -504,6 +539,17 @@ function classifyOne(inspected, path) {
 		package: rootScope,
 		reason: "workspace"
 	};
+	if (isInside(inspected.projectDir, abs)) {
+		const hint = unmappedHint(inspected, relative(inspected.projectDir, abs).replaceAll("\\", "/"));
+		if (hint !== null) return {
+			path,
+			package: null,
+			reason: {
+				kind: "unmappedHint",
+				hint
+			}
+		};
+	}
 	return {
 		path,
 		package: null,
@@ -524,7 +570,8 @@ function makeConfigInspectorTest(fixed) {
 	return Layer.succeed(ConfigInspector, {
 		inspect: () => Effect.succeed(fixed),
 		classify: (_cwd, paths) => Effect.succeed(paths.map((p) => classifyOne(fixed, p))),
-		refresh: () => Effect.void
+		refresh: () => Effect.void,
+		refreshIn: () => Effect.void
 	});
 }