@savvy-web/silk-effects 0.6.1 → 1.0.1

package/lint/handlers/Yaml.js

@@ -0,0 +1,167 @@
+import { Command } from "../utils/Command.js";
+import { Filter } from "../utils/Filter.js";
+import { getWorkspaceRoot } from "../utils/Workspace.js";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { format, resolveConfig } from "prettier";
+import { lint } from "yaml-lint";
+
+//#region src/lint/handlers/Yaml.ts
+/**
+* Handler for YAML files.
+*
+* Formats with Prettier and validates with yaml-lint, both as bundled dependencies.
+*/
+/**
+* Handler for YAML files.
+*
+* Formats with Prettier and validates with yaml-lint, both as bundled dependencies.
+*
+* @remarks
+* Excludes pnpm-lock.yaml and pnpm-workspace.yaml by default.
+* pnpm-workspace.yaml has its own dedicated handler.
+*
+* Uses Prettier for formatting and yaml-lint for validation.
+* Both are bundled dependencies (no CLI spawning required).
+*
+* @example
+* ```typescript
+* import { Yaml } from '\@savvy-web/lint-staged';
+*
+* export default {
+*   [Yaml.glob]: Yaml.create({
+*     exclude: ['pnpm-lock.yaml', 'pnpm-workspace.yaml', 'generated/'],
+*   }),
+* };
+* ```
+*/
+var Yaml = class Yaml {
+	/**
+	* Glob pattern for matching YAML files.
+	* @defaultValue `'**\/*.{yml,yaml}'`
+	*/
+	static glob = "**/*.{yml,yaml}";
+	/**
+	* Default patterns to exclude from processing.
+	* @defaultValue `['pnpm-lock.yaml', 'pnpm-workspace.yaml', '__test__/fixtures']`
+	*/
+	static defaultExcludes = [
+		"pnpm-lock.yaml",
+		"pnpm-workspace.yaml",
+		"__test__/fixtures"
+	];
+	/**
+	* Pre-configured handler with default options.
+	*/
+	static handler = Yaml.create();
+	/**
+	* Find the yaml-lint config file.
+	*
+	* Paths are anchored to the workspace root (via {@link getWorkspaceRoot}),
+	* falling back to `process.cwd()` when not inside a workspace.
+	*
+	* Searches in order:
+	* 1. `{workspaceRoot}/lib/configs/.yaml-lint.json`
+	* 2. `{workspaceRoot}/.yaml-lint.json`
+	*
+	* @returns The config file path, or undefined if not found
+	*/
+	static findConfig() {
+		const root = getWorkspaceRoot() ?? process.cwd();
+		const libPath = join(root, "lib/configs/.yaml-lint.json");
+		if (existsSync(libPath)) return libPath;
+		const rootPath = join(root, ".yaml-lint.json");
+		if (existsSync(rootPath)) return rootPath;
+	}
+	/**
+	* Load the yaml-lint schema from a config file.
+	*
+	* @param filepath - Path to the yaml-lint config file
+	* @returns The schema string, or undefined if not found
+	*/
+	static loadConfig(filepath) {
+		try {
+			const content = readFileSync(filepath, "utf-8");
+			return JSON.parse(content).schema;
+		} catch {
+			return;
+		}
+	}
+	/**
+	* Check if yaml-lint is available.
+	*
+	* @returns Always `true` since yaml-lint is a bundled dependency
+	*/
+	static isAvailable() {
+		return true;
+	}
+	/**
+	* Format a YAML file in-place using Prettier.
+	*
+	* @param filepath - Path to the YAML file
+	*/
+	static async formatFile(filepath) {
+		writeFileSync(filepath, await format(readFileSync(filepath, "utf-8"), {
+			...await resolveConfig(filepath),
+			filepath,
+			parser: "yaml"
+		}), "utf-8");
+	}
+	/**
+	* Validate a YAML file using yaml-lint.
+	*
+	* @param filepath - Path to the YAML file
+	* @param schema - The YAML schema to validate against
+	* @throws Error if the YAML is invalid
+	*/
+	static async validateFile(filepath, schema) {
+		await lint(readFileSync(filepath, "utf-8"), schema ? { schema } : void 0);
+	}
+	/**
+	* Create a handler that returns a CLI command to format YAML files.
+	*
+	* @remarks
+	* Unlike {@link create}, this does not modify files in the handler function
+	* body. Instead it returns a `savvy-lint fmt yaml` command so lint-staged
+	* can detect the modification and auto-stage it.
+	* Use this in lint-staged array syntax for sequential execution.
+	*
+	* @param options - Configuration options
+	* @returns A lint-staged compatible handler function
+	*/
+	static fmtCommand(options = {}) {
+		const excludes = options.exclude ?? [...Yaml.defaultExcludes];
+		return (filenames) => {
+			const filtered = Filter.exclude(filenames, excludes);
+			if (filtered.length === 0) return [];
+			return `${Command.findSavvyLint()} fmt yaml ${Filter.shellEscape(filtered)}`;
+		};
+	}
+	/**
+	* Create a handler with custom options.
+	*
+	* @param options - Configuration options
+	* @returns A lint-staged compatible handler function
+	*/
+	static create(options = {}) {
+		const excludes = options.exclude ?? [...Yaml.defaultExcludes];
+		const skipFormat = options.skipFormat ?? false;
+		const skipValidate = options.skipValidate ?? false;
+		const configPath = options.config ?? Yaml.findConfig();
+		const schema = configPath ? Yaml.loadConfig(configPath) : void 0;
+		return async (filenames) => {
+			const filtered = Filter.exclude(filenames, excludes);
+			if (filtered.length === 0) return [];
+			if (!skipFormat) for (const filepath of filtered) await Yaml.formatFile(filepath);
+			if (!skipValidate) for (const filepath of filtered) try {
+				await Yaml.validateFile(filepath, schema);
+			} catch (error) {
+				throw new Error(`Invalid YAML in ${filepath}: ${error instanceof Error ? error.message : String(error)}`);
+			}
+			return [];
+		};
+	}
+};
+
+//#endregion
+export { Yaml };

package/lint/index.js

@@ -0,0 +1,52 @@
+import { __exportAll } from "../_virtual/_rolldown/runtime.js";
+import { Handler } from "./Handler.js";
+import { Command } from "./utils/Command.js";
+import { Filter } from "./utils/Filter.js";
+import { getWorkspacePackagePaths, getWorkspacePackages, getWorkspaceRoot, isWorkspacePackagePath, resetWorkspaceCache } from "./utils/Workspace.js";
+import { Biome } from "./handlers/Biome.js";
+import { Markdown } from "./handlers/Markdown.js";
+import { PackageJson } from "./handlers/PackageJson.js";
+import { PnpmWorkspace } from "./handlers/PnpmWorkspace.js";
+import { ShellScripts } from "./handlers/ShellScripts.js";
+import { TypeScript } from "./handlers/TypeScript.js";
+import { Yaml } from "./handlers/Yaml.js";
+import { createConfig } from "./config/createConfig.js";
+import { Preset } from "./config/Preset.js";
+import { DEFAULT_CONFIG_PATH, HUSKY_HOOK_PATH, LegacySavvyLintHygieneDef, MARKDOWNLINT_CONFIG_PATH, POST_CHECKOUT_HOOK_PATH, POST_MERGE_HOOK_PATH, SavvyLintSectionDef, generateManagedContent, savvyLintBlock } from "./cli/sections.js";
+import { MARKDOWNLINT_CONFIG, MARKDOWNLINT_SCHEMA, MARKDOWNLINT_TEMPLATE } from "./cli/templates/markdownlint.gen.js";
+
+//#region src/lint/index.ts
+var lint_exports = /* @__PURE__ */ __exportAll({
+	Biome: () => Biome,
+	Command: () => Command,
+	DEFAULT_CONFIG_PATH: () => DEFAULT_CONFIG_PATH,
+	Filter: () => Filter,
+	HUSKY_HOOK_PATH: () => HUSKY_HOOK_PATH,
+	Handler: () => Handler,
+	LegacySavvyLintHygieneDef: () => LegacySavvyLintHygieneDef,
+	MARKDOWNLINT_CONFIG: () => MARKDOWNLINT_CONFIG,
+	MARKDOWNLINT_CONFIG_PATH: () => MARKDOWNLINT_CONFIG_PATH,
+	MARKDOWNLINT_SCHEMA: () => MARKDOWNLINT_SCHEMA,
+	MARKDOWNLINT_TEMPLATE: () => MARKDOWNLINT_TEMPLATE,
+	Markdown: () => Markdown,
+	POST_CHECKOUT_HOOK_PATH: () => POST_CHECKOUT_HOOK_PATH,
+	POST_MERGE_HOOK_PATH: () => POST_MERGE_HOOK_PATH,
+	PackageJson: () => PackageJson,
+	PnpmWorkspace: () => PnpmWorkspace,
+	Preset: () => Preset,
+	SavvyLintSectionDef: () => SavvyLintSectionDef,
+	ShellScripts: () => ShellScripts,
+	TypeScript: () => TypeScript,
+	Yaml: () => Yaml,
+	createConfig: () => createConfig,
+	generateManagedContent: () => generateManagedContent,
+	getWorkspacePackagePaths: () => getWorkspacePackagePaths,
+	getWorkspacePackages: () => getWorkspacePackages,
+	getWorkspaceRoot: () => getWorkspaceRoot,
+	isWorkspacePackagePath: () => isWorkspacePackagePath,
+	resetWorkspaceCache: () => resetWorkspaceCache,
+	savvyLintBlock: () => savvyLintBlock
+});
+
+//#endregion
+export { lint_exports };

package/lint/utils/Command.js

@@ -0,0 +1,285 @@
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { execSync } from "node:child_process";
+
+//#region src/lint/utils/Command.ts
+/**
+* Utilities for shell command operations.
+*
+* @example
+* ```typescript
+* import { Command } from '@savvy-web/lint-staged';
+*
+* if (Command.isAvailable('yq')) {
+*   // yq is installed globally
+* }
+*
+* // Check for tool available globally OR via package manager
+* const biome = Command.findTool('biome');
+* if (biome.available) {
+*   console.log(`Using: ${biome.command}`); // 'biome' or 'pnpm exec biome'
+* }
+*
+* // Detect package manager from package.json
+* const pm = Command.detectPackageManager();
+* console.log(pm); // 'pnpm', 'npm', 'yarn', or 'bun'
+* ```
+*/
+/** Pattern for valid command/tool names (alphanumeric, hyphens, underscores, \@, /) */
+const VALID_COMMAND_PATTERN = /^[\w@/-]+$/;
+/**
+* Validate that a command name is safe for shell execution.
+* Prevents command injection by ensuring only valid characters are used.
+*
+* @param name - The command or tool name to validate
+* @throws Error if the name contains invalid characters
+*/
+function validateCommandName(name) {
+	if (!VALID_COMMAND_PATTERN.test(name)) throw new Error(`Invalid command name: "${name}". Only alphanumeric characters, hyphens, underscores, @ and / are allowed.`);
+}
+/**
+* Static utility class for shell command operations.
+*/
+var Command = class Command {
+	/** Cached package manager detection result */
+	static cachedPackageManager = null;
+	/** Cached project root path */
+	static cachedRoot = null;
+	/**
+	* Find the project root directory by walking up from `cwd`.
+	*
+	* Searches upward for the nearest directory containing a `package.json`.
+	* Falls back to the provided `cwd` (or `process.cwd()`) when none is found.
+	*
+	* @remarks
+	* This is more reliable than `process.cwd()` in environments like Husky
+	* hooks where the working directory may point to `.husky/` or another
+	* subdirectory.
+	*
+	* @param cwd - Starting directory for the search (defaults to `process.cwd()`)
+	* @returns The resolved project root path
+	*
+	* @example
+	* ```typescript
+	* const root = Command.findRoot();
+	* console.log(root); // '/Users/me/my-project'
+	* ```
+	*/
+	static findRoot(cwd = process.cwd()) {
+		if (Command.cachedRoot !== null) return Command.cachedRoot;
+		let dir = resolve(cwd);
+		while (true) {
+			if (existsSync(join(dir, "package.json"))) {
+				Command.cachedRoot = dir;
+				return dir;
+			}
+			const parent = dirname(dir);
+			if (parent === dir) break;
+			dir = parent;
+		}
+		Command.cachedRoot = cwd;
+		return cwd;
+	}
+	/**
+	* Detect the package manager from the root package.json's `packageManager` field.
+	*
+	* Parses the `packageManager` field (e.g., `pnpm\@9.0.0`) and extracts the manager name.
+	* Falls back to "npm" if no packageManager field is found.
+	*
+	* @param cwd - Directory to search for package.json (defaults to `Command.findRoot()`)
+	* @returns The detected package manager
+	*
+	* @example
+	* ```typescript
+	* const pm = Command.detectPackageManager();
+	* console.log(pm); // 'pnpm', 'npm', 'yarn', or 'bun'
+	* ```
+	*/
+	static detectPackageManager(cwd = Command.findRoot()) {
+		if (Command.cachedPackageManager !== null) return Command.cachedPackageManager;
+		const packageJsonPath = join(cwd, "package.json");
+		if (!existsSync(packageJsonPath)) {
+			Command.cachedPackageManager = "npm";
+			return "npm";
+		}
+		try {
+			const content = readFileSync(packageJsonPath, "utf-8");
+			const pkg = JSON.parse(content);
+			if (pkg.packageManager) {
+				const match = pkg.packageManager.match(/^(npm|pnpm|yarn|bun)@/);
+				if (match) {
+					Command.cachedPackageManager = match[1];
+					return Command.cachedPackageManager;
+				}
+			}
+		} catch {}
+		Command.cachedPackageManager = "npm";
+		return "npm";
+	}
+	/**
+	* Get the exec command prefix for a package manager.
+	*
+	* @param packageManager - The package manager name
+	* @returns Array of command parts to prefix tool execution
+	*
+	* @example
+	* ```typescript
+	* Command.getExecPrefix('pnpm'); // ['pnpm', 'exec']
+	* Command.getExecPrefix('npm');  // ['npx', '--no']
+	* Command.getExecPrefix('yarn'); // ['yarn', 'exec']
+	* Command.getExecPrefix('bun');  // ['bun', 'x', "--no-install"]
+	* ```
+	*/
+	static getExecPrefix(packageManager) {
+		switch (packageManager) {
+			case "pnpm": return ["pnpm", "exec"];
+			case "yarn": return ["yarn", "exec"];
+			case "bun": return [
+				"bun",
+				"x",
+				"--no-install"
+			];
+			default: return ["npx", "--no"];
+		}
+	}
+	/**
+	* Clear the cached package manager and project root detection.
+	* Useful for testing or when package.json changes.
+	*/
+	static clearCache() {
+		Command.cachedPackageManager = null;
+		Command.cachedRoot = null;
+	}
+	/**
+	* Check if a command is available in the system PATH.
+	*
+	* @param command - The command name to check
+	* @returns `true` if the command exists, `false` otherwise
+	*
+	* @example
+	* ```typescript
+	* if (Command.isAvailable('yq')) {
+	*   console.log('yq is installed');
+	* }
+	* ```
+	*/
+	static isAvailable(command) {
+		validateCommandName(command);
+		try {
+			execSync(`command -v ${command}`, { stdio: "ignore" });
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* Find a tool, checking global installation first, then the project's package manager.
+	*
+	* Search order:
+	* 1. Global command (in PATH)
+	* 2. Project's package manager (detected from package.json `packageManager` field)
+	*
+	* @param tool - The tool name to find
+	* @returns Search result with command string if found
+	*
+	* @example
+	* ```typescript
+	* const biome = Command.findTool('biome');
+	* if (biome.available) {
+	*   // biome.command is 'biome', 'pnpm exec biome', 'npx --no biome', etc.
+	*   console.log(`Running: ${biome.command} check`);
+	* }
+	* ```
+	*/
+	static findTool(tool) {
+		validateCommandName(tool);
+		if (Command.isAvailable(tool)) return {
+			available: true,
+			command: tool,
+			source: "global"
+		};
+		const pm = Command.detectPackageManager();
+		const execCmd = [...Command.getExecPrefix(pm), tool].join(" ");
+		try {
+			execSync(`${execCmd} --version`, { stdio: "ignore" });
+			return {
+				available: true,
+				command: execCmd,
+				source: pm
+			};
+		} catch {}
+		return {
+			available: false,
+			command: void 0,
+			source: void 0
+		};
+	}
+	/**
+	* Find a tool or throw an error if not available.
+	*
+	* @param tool - The tool name to find
+	* @param errorMessage - Custom error message (optional)
+	* @returns The command string to use
+	* @throws Error if the tool is not available
+	*
+	* @example
+	* ```typescript
+	* const biomeCmd = Command.requireTool('biome');
+	* // Throws if biome not found, otherwise returns command string
+	* ```
+	*/
+	static requireTool(tool, errorMessage) {
+		const result = Command.findTool(tool);
+		if (!result.available || !result.command) throw new Error(errorMessage ?? `Required tool '${tool}' is not available. Install it globally or add it as a dev dependency.`);
+		return result.command;
+	}
+	/**
+	* Find the `savvy lint` CLI command.
+	*
+	* @remarks
+	* Resolves the unified `savvy` binary via the standard tool search and
+	* appends the `lint` subcommand, falling back to the cli dev build at
+	* `packages/cli/dist/dev/pkg/bin/savvy.js` for dogfooding scenarios where the
+	* bin isn't linked yet.
+	*
+	* @returns The command string to invoke `savvy lint`
+	*/
+	static findSavvyLint() {
+		const result = Command.findTool("savvy");
+		if (result.available && result.command) return `${result.command} lint`;
+		return `node ${Command.findRoot()}/packages/cli/dist/dev/pkg/bin/savvy.js lint`;
+	}
+	/**
+	* Execute a command and return its output.
+	*
+	* @param command - The command to execute
+	* @returns The command output as a string (trimmed)
+	* @throws If the command fails
+	*
+	* @example
+	* ```typescript
+	* const version = Command.exec('node --version');
+	* console.log(version); // 'v20.10.0'
+	* ```
+	*/
+	static exec(command) {
+		return execSync(command, { encoding: "utf-8" }).trim();
+	}
+	/**
+	* Execute a command silently (ignore output).
+	*
+	* @param command - The command to execute
+	* @returns `true` if successful, `false` if failed
+	*/
+	static execSilent(command) {
+		try {
+			execSync(command, { stdio: "ignore" });
+			return true;
+		} catch {
+			return false;
+		}
+	}
+};
+
+//#endregion
+export { Command };

package/lint/utils/Filter.js

@@ -0,0 +1,100 @@
+//#region src/lint/utils/Filter.ts
+/**
+* Utilities for filtering staged file lists.
+*
+* @example
+* ```typescript
+* import { Filter } from '@savvy-web/lint-staged';
+*
+* const handler = (filenames: readonly string[]) => {
+*   const filtered = Filter.exclude(filenames, ['dist/', '__fixtures__']);
+*   return filtered.length > 0 ? `biome check ${Filter.shellEscape(filtered)}` : [];
+* };
+* ```
+*/
+/**
+* Static utility class for filtering file lists.
+*/
+var Filter = class Filter {
+	/**
+	* Exclude files matching any of the given patterns.
+	*
+	* @param filenames - Array of file paths
+	* @param patterns - Patterns to exclude (uses `string.includes()`)
+	* @returns Filtered array of file paths
+	*
+	* @example
+	* ```typescript
+	* const files = ['src/index.ts', 'dist/index.js', '__fixtures__/test.ts'];
+	* const filtered = Filter.exclude(files, ['dist/', '__fixtures__']);
+	* // Result: ['src/index.ts']
+	* ```
+	*/
+	static exclude(filenames, patterns) {
+		if (patterns.length === 0) return [...filenames];
+		return filenames.filter((file) => !patterns.some((pattern) => file.includes(pattern)));
+	}
+	/**
+	* Include only files matching any of the given patterns.
+	*
+	* @param filenames - Array of file paths
+	* @param patterns - Patterns to include (uses `string.includes()`)
+	* @returns Filtered array of file paths
+	*
+	* @example
+	* ```typescript
+	* const files = ['src/index.ts', 'lib/utils.ts', 'test/foo.test.ts'];
+	* const filtered = Filter.include(files, ['src/', 'lib/']);
+	* // Result: ['src/index.ts', 'lib/utils.ts']
+	* ```
+	*/
+	static include(filenames, patterns) {
+		if (patterns.length === 0) return [];
+		return filenames.filter((file) => patterns.some((pattern) => file.includes(pattern)));
+	}
+	/**
+	* Combine exclude and include filters.
+	*
+	* @param filenames - Array of file paths
+	* @param options - Filter options
+	* @returns Filtered array of file paths
+	*
+	* @example
+	* ```typescript
+	* const files = ['src/index.ts', 'src/index.test.ts', 'dist/index.js'];
+	* const filtered = Filter.apply(files, {
+	*   include: ['src/'],
+	*   exclude: ['.test.'],
+	* });
+	* // Result: ['src/index.ts']
+	* ```
+	*/
+	static apply(filenames, options) {
+		let result = [...filenames];
+		if (options.include && options.include.length > 0) result = Filter.include(result, options.include);
+		if (options.exclude && options.exclude.length > 0) result = Filter.exclude(result, options.exclude);
+		return result;
+	}
+	/**
+	* Escape file paths for safe shell command construction.
+	*
+	* Wraps each path in single quotes and escapes any embedded single quotes.
+	* This prevents issues with paths containing spaces or special characters.
+	*
+	* @param filenames - Array of file paths
+	* @returns Space-separated string of shell-escaped paths
+	*
+	* @example
+	* ```typescript
+	* const files = ['/path/to/file.ts', '/path/with spaces/file.ts'];
+	* const escaped = Filter.shellEscape(files);
+	* // Result: "'/path/to/file.ts' '/path/with spaces/file.ts'"
+	* ```
+	*/
+	static shellEscape(filenames) {
+		return filenames.map((f) => `'${f.replace(/'/g, "'\\''")}'`).join(" ");
+	}
+};
+
+//#endregion
+export { Filter };

package/lint/utils/Workspace.js

@@ -0,0 +1,86 @@
+import { dirname } from "node:path";
+import { findWorkspaceRootSync, getWorkspacePackagesSync } from "workspaces-effect";
+
+//#region src/lint/utils/Workspace.ts
+/**
+* Workspace-aware discovery utilities.
+*
+* @remarks
+* Wraps the synchronous APIs from `workspaces-effect` with caching.
+* Workspace layout does not change during a lint-staged run, so
+* results are cached on first access. Use `resetWorkspaceCache()`
+* in tests to clear state between runs.
+*/
+/** Sentinel indicating "not yet resolved". */
+const UNRESOLVED = Symbol("unresolved");
+let cachedRoot = UNRESOLVED;
+let cachedPackages = UNRESOLVED;
+let cachedPaths = UNRESOLVED;
+/**
+* Get the workspace root directory.
+*
+* @returns Absolute path to workspace root, or null if not in a workspace
+*/
+function getWorkspaceRoot() {
+	if (cachedRoot !== UNRESOLVED) return cachedRoot;
+	cachedRoot = findWorkspaceRootSync() ?? null;
+	return cachedRoot;
+}
+/**
+* Get all leaf workspace packages (excludes root).
+*
+* @returns Array of workspace packages, or null if not in a workspace
+*/
+function getWorkspacePackages() {
+	if (cachedPackages !== UNRESOLVED) return cachedPackages;
+	const root = getWorkspaceRoot();
+	if (root === null) {
+		cachedPackages = null;
+		return null;
+	}
+	cachedPackages = (getWorkspacePackagesSync(root) ?? []).filter((pkg) => pkg.path !== root);
+	return cachedPackages;
+}
+/**
+* Get absolute paths of all leaf workspace package directories.
+*
+* @returns Array of absolute paths, empty if not in a workspace
+*/
+function getWorkspacePackagePaths() {
+	if (cachedPaths !== UNRESOLVED) return cachedPaths;
+	cachedPaths = getWorkspacePackages()?.map((pkg) => pkg.path) ?? [];
+	return cachedPaths;
+}
+/**
+* Check if a file path is at a workspace root or leaf workspace root.
+*
+* @remarks
+* Compares the file's parent directory against the workspace root
+* and all leaf workspace roots. Returns true as a permissive
+* fallback when not in a workspace, so single-package repos
+* continue to work.
+*
+* @param filePath - Absolute path to the file
+* @returns true if the file is at a workspace or leaf root
+*/
+function isWorkspacePackagePath(filePath) {
+	const root = getWorkspaceRoot();
+	if (root === null) return true;
+	const dir = dirname(filePath);
+	if (dir === root) return true;
+	return getWorkspacePackagePaths().includes(dir);
+}
+/**
+* Clear all cached workspace data.
+*
+* @remarks
+* Call this in test teardown to ensure clean state between tests.
+*/
+function resetWorkspaceCache() {
+	cachedRoot = UNRESOLVED;
+	cachedPackages = UNRESOLVED;
+	cachedPaths = UNRESOLVED;
+}
+
+//#endregion
+export { getWorkspacePackagePaths, getWorkspacePackages, getWorkspaceRoot, isWorkspacePackagePath, resetWorkspaceCache };