@savvy-web/silk-effects 0.6.0 → 1.0.0

package/changesets/utils/version-blocks.js

@@ -0,0 +1,108 @@
+import { toString } from "mdast-util-to-string";
+
+//#region src/changesets/utils/version-blocks.ts
+/**
+* Extract all version blocks from a CHANGELOG AST.
+*
+* @remarks
+* Scans `tree.children` linearly for h2-level headings. Each h2 starts
+* a new version block whose content extends to the next h2 or the end
+* of the document. The `endIndex` of each block is adjusted in a second
+* pass to stop at the next block's `headingIndex`.
+*
+* h1 headings (typically the package name) are ignored and do not
+* create version blocks.
+*
+* @param tree - The MDAST root node of a CHANGELOG document
+* @returns Array of version blocks in document order
+*
+* @example
+* ```typescript
+* import { getVersionBlocks } from "../utils/version-blocks.js";
+* import { parseMarkdown } from "../utils/remark-pipeline.js";
+*
+* const tree = parseMarkdown("# my-pkg\n\n## 1.1.0\n\nChanges.\n\n## 1.0.0\n\nInitial.");
+* const blocks = getVersionBlocks(tree);
+* // blocks.length === 2
+* // blocks[0] covers "## 1.1.0" section
+* // blocks[1] covers "## 1.0.0" section
+* ```
+*
+* @internal
+*/
+function getVersionBlocks(tree) {
+	const blocks = [];
+	for (let i = 0; i < tree.children.length; i++) {
+		const node = tree.children[i];
+		if (node.type === "heading" && node.depth === 2) blocks.push({
+			headingIndex: i,
+			startIndex: i + 1,
+			endIndex: tree.children.length
+		});
+	}
+	for (let i = 0; i < blocks.length - 1; i++) blocks[i].endIndex = blocks[i + 1].headingIndex;
+	return blocks;
+}
+/**
+* Extract h3 sections within a version block.
+*
+* @remarks
+* Iterates over the children of the given version block (from
+* `block.startIndex` to `block.endIndex`). Each h3 heading starts
+* a new section, and subsequent non-heading nodes are collected
+* into that section's `contentNodes` array until the next h3 or
+* the end of the block.
+*
+* Nodes before the first h3 within the block (e.g., a version
+* summary paragraph) are not included in any section.
+*
+* @param tree - The MDAST root node of a CHANGELOG document
+* @param block - The version block to extract sections from
+* @returns Array of sections in document order
+*
+* @example
+* ```typescript
+* import { getVersionBlocks, getBlockSections } from "../utils/version-blocks.js";
+* import { parseMarkdown } from "../utils/remark-pipeline.js";
+*
+* const tree = parseMarkdown("## 1.0.0\n\n### Features\n\n- New API\n\n### Bug Fixes\n\n- Fixed crash");
+* const blocks = getVersionBlocks(tree);
+* const sections = getBlockSections(tree, blocks[0]);
+* // sections.length === 2
+* // sections[0].heading text === "Features"
+* ```
+*
+* @internal
+*/
+function getBlockSections(tree, block) {
+	const sections = [];
+	for (let i = block.startIndex; i < block.endIndex; i++) {
+		const node = tree.children[i];
+		if (node.type === "heading" && node.depth === 3) sections.push({
+			heading: node,
+			headingIndex: i,
+			contentNodes: []
+		});
+		else if (sections.length > 0) sections[sections.length - 1].contentNodes.push(node);
+	}
+	return sections;
+}
+/**
+* Get the plain text content of a heading node.
+*
+* @remarks
+* Delegates to `mdast-util-to-string` to extract concatenated text
+* from all inline children of the heading (handling bold, italic,
+* code spans, etc.).
+*
+* @param heading - The MDAST heading node
+* @returns The heading text content as a plain string
+*
+* @internal
+*/
+function getHeadingText(heading) {
+	return toString(heading);
+}
+
+//#endregion
+export { getBlockSections, getHeadingText, getVersionBlocks };

package/changesets/utils/version-files.js

@@ -0,0 +1,336 @@
+import { LegacyVersionFilesSchema } from "../schemas/version-files.js";
+import { jsonPathGet, jsonPathSet } from "./jsonpath.js";
+import { Schema } from "effect";
+import { readFileSync, writeFileSync } from "node:fs";
+import { join, relative, resolve } from "node:path";
+import { globSync } from "tinyglobby";
+
+//#region src/changesets/utils/version-files.ts
+/**
+* Utilities for updating version fields in additional JSON files.
+*
+* @remarks
+* Implements the `versionFiles` feature of `\@savvy-web/changesets`, which
+* allows version numbers to be synchronized across arbitrary JSON files
+* (e.g., `tauri.conf.json`, `manifest.json`) during the changeset version
+* step.
+*
+* The flow is:
+* 1. Extract and validate `versionFiles` from a pre-parsed config
+* 2. Resolve glob patterns to absolute file paths
+* 3. Discover workspace packages to determine the correct version per file
+*    (using longest-prefix matching)
+* 4. Update JSONPath-specified fields in each matched file
+*
+* @see {@link jsonPathGet} and {@link jsonPathSet} for the JSONPath implementation
+*
+* @internal
+*/
+/**
+* Static utility class for version file operations.
+*
+* @remarks
+* Orchestrates the full version file update workflow: reading config,
+* discovering workspace versions, resolving globs, and updating JSON
+* files at specified JSONPath locations. Designed to be called from
+* the CLI `version` command.
+*
+* Version resolution uses longest-prefix matching: for a file at
+* `/repo/packages/ui/tauri.conf.json`, if workspace `packages/ui`
+* has version `2.0.0`, that version is used rather than the root version.
+*
+* @example
+* ```typescript
+* import { VersionFiles } from "../utils/version-files.js";
+*
+* const configs = VersionFiles.extractVersionFiles(parsedConfig);
+* if (configs) {
+*   const updates = VersionFiles.processVersionFiles("/path/to/project", configs);
+*   for (const update of updates) {
+*     console.log(`Updated ${update.filePath} to ${update.version}`);
+*   }
+* }
+* ```
+*
+* @internal
+*/
+var VersionFiles = class VersionFiles {
+	/**
+	* Extract and validate `versionFiles` from a pre-parsed changeset config object.
+	*
+	* @remarks
+	* Accepts a config object (already parsed from `.changeset/config.json`),
+	* extracts the `changelog` tuple's second element (options object), and
+	* validates the `versionFiles` key against `LegacyVersionFilesSchema`. Returns
+	* `undefined` if `changelog` is not a tuple, the `versionFiles` key is
+	* absent, or the array is empty. Schema validation errors are logged as
+	* warnings but do not throw.
+	*
+	* File reading and JSONC parsing are delegated to the caller
+	* (e.g., `ChangesetConfigReader` from `\@savvy-web/silk-effects`).
+	*
+	* @param config - Pre-parsed changeset config object
+	* @returns Parsed config array, or `undefined` if not configured
+	*/
+	static extractVersionFiles(config) {
+		const { changelog } = config;
+		if (!Array.isArray(changelog) || changelog.length < 2) return;
+		const options = changelog[1];
+		if (!options || typeof options !== "object" || !("versionFiles" in options)) return;
+		try {
+			const decoded = Schema.decodeUnknownSync(LegacyVersionFilesSchema)(options.versionFiles);
+			return decoded.length > 0 ? decoded : void 0;
+		} catch (error) {
+			console.warn(`[changesets] Invalid versionFiles configuration: ${error instanceof Error ? error.message : String(error)}`);
+			return;
+		}
+	}
+	/**
+	* Discover all workspace packages and their current versions.
+	*
+	* @remarks
+	* Accepts a pre-resolved list of workspace packages (e.g., from
+	* `WorkspaceDiscovery.listPackages()`). The root package is always
+	* included if not already present in the packages list.
+	* Deduplicates by absolute path and skips entries without a version.
+	*
+	* @param cwd - Project root directory
+	* @param packages - Pre-resolved workspace packages
+	* @returns Array of workspace packages with versions
+	*/
+	static discoverVersions(cwd, packages) {
+		const resolvedCwd = resolve(cwd);
+		const results = [];
+		const seen = /* @__PURE__ */ new Set();
+		for (const pkg of packages) {
+			if (seen.has(pkg.path) || !pkg.version) continue;
+			seen.add(pkg.path);
+			results.push({
+				name: pkg.name,
+				path: pkg.path,
+				version: pkg.version
+			});
+		}
+		if (!seen.has(resolvedCwd)) {
+			const version = readPackageVersion(resolvedCwd);
+			if (version) {
+				let rootName = "root";
+				try {
+					const pkg = JSON.parse(readFileSync(join(resolvedCwd, "package.json"), "utf-8"));
+					if (pkg.name) rootName = pkg.name;
+				} catch {}
+				results.push({
+					name: rootName,
+					path: resolvedCwd,
+					version
+				});
+			}
+		}
+		return results;
+	}
+	/**
+	* Determine which workspace version applies to a given file path
+	* using longest-prefix matching.
+	*
+	* @remarks
+	* For each workspace, checks whether the file is contained within
+	* it (i.e., the relative path does not start with `..`). Among all
+	* matching workspaces, the one with the longest absolute path wins
+	* (most specific match). Falls back to `rootVersion` if no workspace
+	* contains the file.
+	*
+	* @param filePath - Absolute path to the file
+	* @param workspaces - Discovered workspace versions
+	* @param rootVersion - Fallback version from project root
+	* @returns The version string to use
+	*/
+	static resolveVersion(filePath, workspaces, rootVersion) {
+		const resolved = resolve(filePath);
+		let bestMatch;
+		let bestLength = 0;
+		for (const ws of workspaces) if (!relative(ws.path, resolved).startsWith("..") && ws.path.length > bestLength) {
+			bestMatch = ws;
+			bestLength = ws.path.length;
+		}
+		return bestMatch?.version ?? rootVersion;
+	}
+	/**
+	* Resolve glob patterns to absolute file paths.
+	*
+	* @remarks
+	* Uses `tinyglobby` to expand each config's glob pattern relative to
+	* `cwd`. The `node_modules` directory is always ignored. Returns
+	* tuples pairing each resolved absolute path with its originating config.
+	*
+	* @param configs - Version file configurations
+	* @param cwd - Project root directory
+	* @returns Array of `[filePath, config]` tuples
+	*/
+	static resolveGlobs(configs, cwd) {
+		const results = [];
+		const resolvedCwd = resolve(cwd);
+		for (const config of configs) {
+			const matches = globSync(config.glob, {
+				cwd: resolvedCwd,
+				ignore: ["**/node_modules/**"]
+			});
+			for (const match of matches) results.push([join(resolvedCwd, match), config]);
+		}
+		return results;
+	}
+	/**
+	* Detect indentation from file content.
+	*
+	* @remarks
+	* Looks for the first line starting with whitespace followed by a
+	* double-quote (typical JSON property). Defaults to 2 spaces if
+	* no indentation pattern is found.
+	*
+	* @param content - Raw file content
+	* @returns Detected indent string (defaults to 2 spaces)
+	*/
+	static detectIndent(content) {
+		return content.match(/^(\s+)"/m)?.[1] ?? "  ";
+	}
+	/**
+	* Update JSON file at specified JSONPath locations.
+	*
+	* @remarks
+	* Reads the file, detects its indentation style and trailing newline
+	* preference, applies all JSONPath updates via {@link jsonPathSet},
+	* and writes the result back preserving the original formatting.
+	* Returns `undefined` if no JSONPath locations matched (no write occurs).
+	*
+	* @param filePath - Absolute path to the JSON file
+	* @param jsonPaths - JSONPath expressions to update
+	* @param version - New version string
+	* @returns Update result, or `undefined` if no changes were made
+	*/
+	static updateFile(filePath, jsonPaths, version) {
+		const content = readFileSync(filePath, "utf-8");
+		const indent = VersionFiles.detectIndent(content);
+		const trailingNewline = content.endsWith("\n");
+		const obj = JSON.parse(content);
+		const previousValues = jsonPaths.flatMap((jp) => jsonPathGet(obj, jp));
+		let totalUpdated = 0;
+		for (const jp of jsonPaths) totalUpdated += jsonPathSet(obj, jp, version);
+		if (totalUpdated === 0) return;
+		let output = JSON.stringify(obj, null, indent);
+		if (trailingNewline) output += "\n";
+		writeFileSync(filePath, output, "utf-8");
+		return {
+			filePath,
+			jsonPaths,
+			version,
+			previousValues
+		};
+	}
+	/**
+	* Orchestrate the full version file update flow.
+	*
+	* @remarks
+	* Combines {@link VersionFiles.discoverVersions},
+	* {@link VersionFiles.resolveGlobs}, {@link VersionFiles.resolveVersion},
+	* and {@link VersionFiles.updateFile} into a single operation. In dry-run
+	* mode, files are read and JSONPaths are resolved but no writes occur.
+	*
+	* @param cwd - Project root directory
+	* @param configs - Validated version file configurations
+	* @param dryRun - If true, do not write files (default: `false`)
+	* @returns Array of update results
+	* @throws If any file cannot be read or parsed
+	*/
+	static processVersionFiles(cwd, configs, dryRun = false, packages = []) {
+		const workspaces = VersionFiles.discoverVersions(cwd, packages);
+		const rootVersion = workspaces.find((ws) => ws.path === resolve(cwd))?.version ?? "0.0.0";
+		const resolved = VersionFiles.resolveGlobs(configs, cwd);
+		const updates = [];
+		for (const [filePath, config] of resolved) {
+			const jsonPaths = config.paths ?? ["$.version"];
+			const version = config.package ? workspaces.find((ws) => ws.name === config.package)?.version ?? rootVersion : VersionFiles.resolveVersion(filePath, workspaces, rootVersion);
+			try {
+				if (dryRun) {
+					const content = readFileSync(filePath, "utf-8");
+					const obj = JSON.parse(content);
+					const previousValues = jsonPaths.flatMap((jp) => jsonPathGet(obj, jp));
+					if (previousValues.length > 0) updates.push({
+						filePath,
+						jsonPaths,
+						version,
+						previousValues
+					});
+				} else {
+					const result = VersionFiles.updateFile(filePath, jsonPaths, version);
+					if (result) updates.push(result);
+				}
+			} catch (error) {
+				throw new Error(`Failed to update ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
+			}
+		}
+		return updates;
+	}
+	/**
+	* Apply version-file updates from the resolved (post-`ConfigInspector`)
+	* representation. Each {@link ResolvedPackageScope} already names the
+	* owning package and carries its current version plus the materialized
+	* file paths, so no glob expansion or path-prefix workspace resolution
+	* is needed here — the inspector has done that work.
+	*
+	* @remarks
+	* This is the 0.9.0 successor to {@link VersionFiles.processVersionFiles}.
+	* The old method stays in place to handle the deprecated top-level
+	* `versionFiles[]` shape (read by `cli/commands/init.ts` for its
+	* validation pass), and is removed alongside the legacy schema in
+	* 1.0.0.
+	*
+	* @param scopes - Per-package resolved scopes from {@link ConfigInspector.inspect}
+	* @param dryRun - When `true`, do not write files
+	* @returns Array of update results, one per file that actually had a
+	*   matching JSONPath
+	*
+	* @internal
+	*/
+	static processResolvedVersionFiles(scopes, dryRun = false) {
+		const updates = [];
+		for (const scope of scopes) for (const vf of scope.versionFiles) {
+			const jsonPaths = vf.paths.length > 0 ? vf.paths : ["$.version"];
+			for (const filePath of vf.matchedFiles) try {
+				if (dryRun) {
+					const content = readFileSync(filePath, "utf-8");
+					const obj = JSON.parse(content);
+					const previousValues = jsonPaths.flatMap((jp) => jsonPathGet(obj, jp));
+					if (previousValues.length > 0) updates.push({
+						filePath,
+						jsonPaths,
+						version: scope.version,
+						previousValues
+					});
+				} else {
+					const result = VersionFiles.updateFile(filePath, jsonPaths, scope.version);
+					if (result) updates.push(result);
+				}
+			} catch (error) {
+				throw new Error(`Failed to update ${filePath}: ${error instanceof Error ? error.message : String(error)}`);
+			}
+		}
+		return updates;
+	}
+};
+/**
+* Read the `version` field from a `package.json` in the given directory.
+*
+* @param dir - Absolute path to the directory containing `package.json`
+* @returns The version string, or `undefined` if the file is missing or has no `version` field
+*
+* @internal
+*/
+function readPackageVersion(dir) {
+	try {
+		return JSON.parse(readFileSync(join(dir, "package.json"), "utf-8")).version;
+	} catch {
+		return;
+	}
+}
+
+//#endregion
+export { VersionFiles };

package/changesets/utils/worktree-snapshot.js

@@ -0,0 +1,142 @@
+import { GitError } from "../errors.js";
+import { Effect } from "effect";
+import { readFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+import { execFileSync } from "node:child_process";
+
+//#region src/changesets/utils/worktree-snapshot.ts
+/**
+* Shared helpers for `deps detect` and `deps regen` — both need to read
+* workspace package snapshots from the live working tree (the "after"
+* side of a dep diff that isn't pinned to a git ref) and to resolve the
+* merge-base for the default `--from` ref.
+*
+* @remarks
+* `WorkspaceSnapshotReader` covers the git-ref side via `git show`. This
+* module is the working-tree counterpart — staged and unstaged
+* `package.json` edits show up here, matching `analyze-branch`'s
+* coverage of the working tree.
+*
+* @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))
+			});
+		}
+	});
+}
+/**
+* Normalize a pnpm-workspace.yaml glob entry for filesystem expansion.
+*
+* `packages/**` collapses to `packages/*` (retains the wildcard so the
+* caller hits the directory-listing path); `packages/*` and a literal
+* `packages/foo` are passed through unchanged.
+*
+* Returning the literal-path form for `packages/**` (i.e., `"packages"`)
+* would route the caller through the "no wildcards" branch and silently
+* skip every child workspace.
+*
+* @internal
+*/
+function normalizeWorkspaceGlob(glob) {
+	return glob.replace(/\/\*\*$/, "/*");
+}
+/**
+* Read every workspace package's `package.json` from the live working
+* tree, returning {@link WorkspaceSnapshot} entries matching the shape
+* `WorkspaceSnapshotReader.snapshotAt` produces for git refs.
+*
+* @remarks
+* Falls back to root-only when `pnpm-workspace.yaml` is missing or
+* unparseable. Uses `node:fs.readdirSync` for directory expansion
+* (portable across platforms — `execFileSync("ls")` is not).
+*
+* @internal
+*/
+function snapshotFromWorktree(cwd) {
+	const snapshots = [];
+	const dirs = new Set([cwd]);
+	for (const dir of expandWorkspaceDirs(cwd)) dirs.add(dir);
+	for (const dir of dirs) try {
+		const pkgJson = JSON.parse(readFileSync(join(dir, "package.json"), "utf8"));
+		if (!pkgJson.name) continue;
+		const rel = dir === cwd ? "." : dir.slice(cwd.length + 1);
+		snapshots.push({
+			name: pkgJson.name,
+			relativePath: rel,
+			version: pkgJson.version ?? "0.0.0",
+			dependencies: pkgJson.dependencies ?? {},
+			devDependencies: pkgJson.devDependencies ?? {},
+			peerDependencies: pkgJson.peerDependencies ?? {},
+			optionalDependencies: pkgJson.optionalDependencies ?? {}
+		});
+	} catch {}
+	return snapshots;
+}
+function expandWorkspaceDirs(cwd) {
+	let yaml;
+	try {
+		yaml = readFileSync(join(cwd, "pnpm-workspace.yaml"), "utf8");
+	} catch {
+		return [];
+	}
+	const dirs = [];
+	const lines = yaml.split(/\r?\n/);
+	let inPackagesBlock = false;
+	for (const line of lines) {
+		if (/^\s*#/.test(line)) continue;
+		if (/^\s*packages\s*:\s*$/.test(line)) {
+			inPackagesBlock = true;
+			continue;
+		}
+		if (!inPackagesBlock) continue;
+		const m = line.match(/^\s+-\s+["']?(.+?)["']?\s*$/);
+		if (m) {
+			const glob = normalizeWorkspaceGlob(m[1]);
+			if (glob.includes("*") || glob.includes("?")) {
+				const prefix = glob.includes("/") ? glob.slice(0, glob.lastIndexOf("/") + 1) : "";
+				let entries = [];
+				try {
+					entries = readdirSync(join(cwd, prefix || "."));
+				} catch {
+					continue;
+				}
+				const regex = new RegExp(`^${glob.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, "[^/]*").replace(/\?/g, "[^/]")}$`);
+				for (const entry of entries) {
+					const candidate = prefix ? `${prefix}${entry}` : entry;
+					if (regex.test(candidate)) dirs.push(join(cwd, candidate));
+				}
+			} else dirs.push(join(cwd, glob));
+		} else if (line.length > 0 && !line.startsWith(" ") && !line.startsWith("	")) inPackagesBlock = false;
+	}
+	return dirs;
+}
+
+//#endregion
+export { gitMergeBase, snapshotFromWorktree };

package/changesets/vendor/github-info.js

@@ -0,0 +1,55 @@
+import { GitHubApiError } from "../errors.js";
+import { Effect } from "effect";
+import { getInfo } from "@changesets/get-github-info";
+
+//#region src/changesets/vendor/github-info.ts
+/**
+* Effect wrapper around `\@changesets/get-github-info`.
+*
+* @remarks
+* Bridges the `\@changesets/get-github-info` package (which returns
+* promises) into the Effect ecosystem. The {@link getGitHubInfo}
+* function wraps the upstream `getInfo()` call in `Effect.tryPromise`,
+* mapping failures to {@link GitHubApiError}.
+*
+* The {@link GitHubCommitInfo} type is the only item from this module
+* that is part of the public API (re-exported from the package root).
+*
+* @see {@link GitHubService} for the Effect service layer that uses
+*   this function
+*
+* @internal
+*/
+/**
+* Fetch GitHub info for a commit, wrapped in Effect.
+*
+* @remarks
+* Calls the upstream `getInfo()` from `\@changesets/get-github-info`
+* within `Effect.tryPromise`. Any thrown error is caught and mapped
+* to a {@link GitHubApiError} with the operation set to `"getInfo"`.
+*
+* Requires a `GITHUB_TOKEN` environment variable to be set for
+* authenticated API access (the upstream library reads it directly).
+*
+* @param params - The commit hash and repo in `owner/repo` format
+* @returns An Effect that resolves to {@link GitHubCommitInfo} or fails
+*   with {@link GitHubApiError}
+*
+* @internal
+*/
+function getGitHubInfo(params) {
+	return Effect.tryPromise({
+		try: () => getInfo({
+			commit: params.commit,
+			repo: params.repo
+		}),
+		/* v8 ignore next 5 -- error mapping tested via GitHubService test layer */
+		catch: (error) => new GitHubApiError({
+			operation: "getInfo",
+			reason: error instanceof Error ? error.message : String(error)
+		})
+	});
+}
+
+//#endregion
+export { getGitHubInfo };