@savvy-web/silk-effects 0.6.0 → 1.0.0

package/schemas/VersioningSchemas.js

@@ -0,0 +1,95 @@
+import { Schema } from "effect";
+
+//#region src/schemas/VersioningSchemas.ts
+/**
+* Configuration for how private packages are handled during versioning.
+*
+* @remarks
+* When set to `false`, private packages are completely ignored.
+* When set to an object, `tag` and `version` control whether private packages
+* receive git tags and version bumps respectively.
+*
+* @since 0.2.0
+*/
+const PrivatePackagesConfig = Schema.Union(Schema.Struct({
+	tag: Schema.optional(Schema.Boolean),
+	version: Schema.optional(Schema.Boolean)
+}), Schema.Literal(false));
+/**
+* Snapshot release configuration for changesets.
+*
+* @remarks
+* Controls how snapshot versions are generated.
+* `useCalculatedVersion` prepends the calculated version to the snapshot tag.
+* `prereleaseTemplate` is a custom template string for snapshot version format.
+*
+* @since 0.2.0
+*/
+const SnapshotConfig = Schema.Struct({
+	useCalculatedVersion: Schema.optional(Schema.Boolean),
+	prereleaseTemplate: Schema.optional(Schema.String)
+});
+/**
+* Standard changesets configuration matching the `@changesets/config@3.1.1` spec.
+*
+* @remarks
+* Represents the parsed `.changeset/config.json` file. All fields are optional
+* to allow partial configs. Use {@link SilkChangesetConfigFile} when the Silk changelog
+* adapter is detected.
+*
+* @since 0.1.0
+*/
+const ChangesetConfigFile = Schema.Struct({
+	changelog: Schema.optional(Schema.Union(Schema.String, Schema.Array(Schema.Unknown), Schema.Literal(false))),
+	commit: Schema.optional(Schema.Union(Schema.Boolean, Schema.String, Schema.Array(Schema.Unknown))),
+	fixed: Schema.optional(Schema.Array(Schema.Array(Schema.String))),
+	linked: Schema.optional(Schema.Array(Schema.Array(Schema.String))),
+	access: Schema.optional(Schema.Literal("public", "restricted")),
+	baseBranch: Schema.optional(Schema.String),
+	updateInternalDependencies: Schema.optional(Schema.Literal("patch", "minor", "major")),
+	ignore: Schema.optional(Schema.Array(Schema.String)),
+	privatePackages: Schema.optional(PrivatePackagesConfig),
+	prettier: Schema.optional(Schema.Boolean),
+	changedFilePatterns: Schema.optional(Schema.Array(Schema.String)),
+	bumpVersionsWithWorkspaceProtocolOnly: Schema.optional(Schema.Boolean),
+	snapshot: Schema.optional(SnapshotConfig)
+});
+/**
+* Extended changeset config for repos using the `@savvy-web/changesets` changelog adapter.
+*
+* @remarks
+* Extends {@link ChangesetConfigFile} with a `_isSilk` marker flag that is automatically
+* set to `true`. Detected by {@link ChangesetConfigReader} when the `changelog` field
+* references `@savvy-web/changesets`.
+*
+* @since 0.1.0
+*/
+const SilkChangesetConfigFile = Schema.extend(ChangesetConfigFile, Schema.Struct({ _isSilk: Schema.optionalWith(Schema.Boolean, { default: () => true }) }));
+/**
+* Versioning strategy classification for a workspace.
+*
+* @remarks
+* - `"single"` — one publishable package; a single version tag is used.
+* - `"fixed-group"` — all publishable packages are in the same changesets fixed group.
+* - `"independent"` — multiple publishable packages with independent version bumps.
+*
+* @since 0.1.0
+*/
+const VersioningStrategyType = Schema.Literal("single", "fixed-group", "independent");
+/**
+* Output of the versioning strategy detection, combining the strategy type with group metadata.
+*
+* @remarks
+* Produced by {@link VersioningStrategy.detect} and consumed by {@link TagStrategy.determine}
+* to decide on the appropriate git-tag format.
+*
+* @since 0.1.0
+*/
+const VersioningStrategyResult = Schema.Struct({
+	type: VersioningStrategyType,
+	fixedGroups: Schema.Array(Schema.Array(Schema.String)),
+	publishablePackages: Schema.Array(Schema.String)
+});
+
+//#endregion
+export { ChangesetConfigFile, SilkChangesetConfigFile, VersioningStrategyResult };

package/schemas/WorkspaceAnalysisSchemas.js

@@ -0,0 +1,190 @@
+import { ChangesetConfigFile, SilkChangesetConfigFile, VersioningStrategyResult } from "./VersioningSchemas.js";
+import { TagStrategyType } from "./TagStrategySchemas.js";
+import { Equal, Function, Hash, Option, Pretty, Schema } from "effect";
+import { PublishConfig, PublishTarget } from "workspaces-effect";
+
+//#region src/schemas/WorkspaceAnalysisSchemas.ts
+const PublishProtocol = Schema.Literal("npm", "jsr");
+const PublishTargetShorthand = Schema.Literal("npm", "github", "jsr");
+const PublishTargetObject = Schema.Struct({
+	protocol: Schema.optionalWith(PublishProtocol, { default: () => "npm" }),
+	registry: Schema.optional(Schema.String),
+	directory: Schema.optional(Schema.String),
+	access: Schema.optional(Schema.Literal("public", "restricted")),
+	provenance: Schema.optional(Schema.Boolean),
+	tag: Schema.optional(Schema.String)
+});
+/**
+* Silk-extended publishConfig schema.
+*
+* @remarks
+* Extends the base PublishConfig from workspaces-effect (which covers npm
+* standard fields: access, registry, directory, tag, linkDirectory) with the
+* Silk `targets` extension for multi-registry publishing.
+*
+* @since 0.2.0
+*/
+var SilkPublishConfig = class extends PublishConfig.extend("SilkPublishConfig")({ targets: Schema.optional(Schema.Array(Schema.Union(PublishTargetShorthand, PublishTargetObject))) }) {};
+const KNOWN_REGISTRIES = {
+	npm: "https://registry.npmjs.org/",
+	github: "https://npm.pkg.github.com/",
+	jsr: "https://jsr.io/"
+};
+/**
+* Compare registry URLs ignoring a trailing slash. `SilkPublishability` resolves
+* targets from the bundler's `dist/prod/targets.json` binding, which writes
+* registry endpoints WITHOUT a trailing slash (`https://registry.npmjs.org`),
+* while `KNOWN_REGISTRIES` / `NPM_DEFAULT` use the trailing-slash form. Normalize
+* both sides so `hasTarget`/`targetFor` match regardless of which form a target
+* carries (binding-driven, placeholder, or access-branch fallback).
+*/
+const sameRegistry = (a, b) => a.replace(/\/+$/, "") === b.replace(/\/+$/, "");
+const WorkspaceVersion = Schema.Struct({ current: Schema.String });
+/**
+* A fully analyzed workspace with publish targets, versioning status,
+* and release group membership.
+*
+* @since 0.2.0
+*/
+var AnalyzedWorkspace = class AnalyzedWorkspace extends Schema.TaggedClass()("AnalyzedWorkspace", {
+	name: Schema.String,
+	version: WorkspaceVersion,
+	path: Schema.String,
+	root: Schema.Boolean,
+	publishConfig: Schema.NullOr(SilkPublishConfig),
+	publishable: Schema.Boolean,
+	targets: Schema.Array(PublishTarget),
+	versioned: Schema.Boolean,
+	tagged: Schema.Boolean,
+	released: Schema.Boolean,
+	linked: Schema.Array(Schema.suspend(() => AnalyzedWorkspace)),
+	fixed: Schema.Array(Schema.suspend(() => AnalyzedWorkspace))
+}) {
+	get isRoot() {
+		return this.root;
+	}
+	get isPublishable() {
+		return this.publishable;
+	}
+	get isReleasable() {
+		return this.released;
+	}
+	get isFixed() {
+		return this.fixed.length > 0;
+	}
+	get isLinked() {
+		return this.linked.length > 0;
+	}
+	publishesTo(registry) {
+		return this.targets.some((t) => sameRegistry(t.registry, registry));
+	}
+	hasTarget(shorthand) {
+		const registry = KNOWN_REGISTRIES[shorthand];
+		return registry !== void 0 && this.publishesTo(registry);
+	}
+	targetFor(registry) {
+		const found = this.targets.find((t) => sameRegistry(t.registry, registry));
+		return found ? Option.some(found) : Option.none();
+	}
+	[Equal.symbol](that) {
+		if (!(that instanceof AnalyzedWorkspace)) return false;
+		return this.name === that.name && this.path === that.path;
+	}
+	[Hash.symbol]() {
+		return Hash.cached(this)(Hash.combine(Hash.hash(this.name))(Hash.hash(this.path)));
+	}
+	toString() {
+		return `${this.name}@${this.version.current}`;
+	}
+	toJSON() {
+		return {
+			_tag: "AnalyzedWorkspace",
+			name: this.name,
+			version: this.version,
+			path: this.path,
+			root: this.root,
+			publishable: this.publishable,
+			targets: this.targets,
+			versioned: this.versioned,
+			tagged: this.tagged,
+			released: this.released
+		};
+	}
+	static publishable(workspaces) {
+		return workspaces.filter((w) => w.publishable);
+	}
+	static releasable(workspaces) {
+		return workspaces.filter((w) => w.released);
+	}
+	static findByName;
+	/** Pretty-print an AnalyzedWorkspace instance. */
+	static pretty;
+};
+AnalyzedWorkspace.findByName = Function.dual(2, (workspaces, name) => {
+	const found = workspaces.find((w) => w.name === name);
+	return found ? Option.some(found) : Option.none();
+});
+AnalyzedWorkspace.pretty = Pretty.make(AnalyzedWorkspace);
+const PackageManagerInfo = Schema.Struct({
+	type: Schema.Literal("npm", "pnpm", "yarn", "bun"),
+	version: Schema.optional(Schema.String)
+});
+/**
+* Full workspace analysis result containing all analyzed workspaces
+* and project-level configuration.
+*
+* @since 0.2.0
+*/
+var WorkspaceAnalysis = class WorkspaceAnalysis extends Schema.TaggedClass()("WorkspaceAnalysis", {
+	root: Schema.String,
+	runtime: Schema.Literal("node", "bun"),
+	packageManager: PackageManagerInfo,
+	workspaces: Schema.Array(AnalyzedWorkspace),
+	changesetConfig: Schema.NullOr(Schema.Union(SilkChangesetConfigFile, ChangesetConfigFile)),
+	versioning: Schema.NullOr(VersioningStrategyResult),
+	tagStrategy: Schema.NullOr(TagStrategyType)
+}) {
+	findWorkspace(name) {
+		const found = this.workspaces.find((w) => w.name === name);
+		return found ? Option.some(found) : Option.none();
+	}
+	get rootWorkspace() {
+		const root = this.workspaces.find((w) => w.root);
+		return root ? Option.some(root) : Option.none();
+	}
+	get publishableWorkspaces() {
+		return this.workspaces.filter((w) => w.publishable);
+	}
+	get versionedWorkspaces() {
+		return this.workspaces.filter((w) => w.versioned);
+	}
+	get taggedWorkspaces() {
+		return this.workspaces.filter((w) => w.tagged);
+	}
+	get releasableWorkspaces() {
+		return this.workspaces.filter((w) => w.released);
+	}
+	get isSilk() {
+		if (this.changesetConfig == null) return false;
+		return "_isSilk" in this.changesetConfig && this.changesetConfig._isSilk === true;
+	}
+	get hasChangesets() {
+		return this.changesetConfig != null;
+	}
+	[Equal.symbol](that) {
+		if (!(that instanceof WorkspaceAnalysis)) return false;
+		return this.root === that.root;
+	}
+	[Hash.symbol]() {
+		return Hash.cached(this)(Hash.hash(this.root));
+	}
+	toString() {
+		return `WorkspaceAnalysis(${this.root}, ${this.workspaces.length} workspaces)`;
+	}
+	/** Pretty-print a WorkspaceAnalysis instance. */
+	static pretty;
+};
+WorkspaceAnalysis.pretty = Pretty.make(WorkspaceAnalysis);
+
+//#endregion
+export { AnalyzedWorkspace, SilkPublishConfig, WorkspaceAnalysis };

package/services/BiomeSchemaSync.js

@@ -0,0 +1,133 @@
+import { BiomeSyncError } from "../errors/BiomeSyncError.js";
+import { Context, Effect, Layer } from "effect";
+import { FileSystem } from "@effect/platform";
+import { parse } from "jsonc-effect";
+
+//#region src/services/BiomeSchemaSync.ts
+/**
+* Strip leading semver range operators from a version string.
+*
+* @param version - Raw version string that may include `^`, `~`, `>=`, `<`, `=`, or `v` prefixes.
+* @returns The bare semver string (e.g. `"1.9.3"`).
+*
+* @since 0.1.0
+*/
+function extractSemver(version) {
+	return version.replace(/^[\^~>=<v]+/, "");
+}
+/**
+* Build the expected Biome JSON schema URL for a given version.
+*
+* @param version - Bare semver string (e.g. `"1.9.3"`).
+* @returns The canonical `biomejs.dev` schema URL for that version.
+*
+* @since 0.1.0
+*/
+function buildSchemaUrl(version) {
+	return `https://biomejs.dev/schemas/${version}/schema.json`;
+}
+const BIOME_SCHEMA_HOSTNAME = "biomejs.dev";
+/** Check which biome config files exist in cwd. */
+function findBiomeConfigs(cwd, fs) {
+	const candidates = [`${cwd}/biome.json`, `${cwd}/biome.jsonc`];
+	return Effect.gen(function* () {
+		const results = [];
+		for (const candidate of candidates) if (yield* fs.exists(candidate).pipe(Effect.orElseSucceed(() => false))) results.push(candidate);
+		return results;
+	});
+}
+/**
+* Service that keeps the `$schema` URL in Biome config files in sync with a target version.
+*
+* @remarks
+* Locates `biome.json` and `biome.jsonc` files in the working directory, then compares
+* each file's `$schema` field against the expected `biomejs.dev` URL for the given version.
+* `sync` writes updates in-place; `check` returns the same result without modifying files.
+*
+* @example
+* ```typescript
+* const result = await Effect.runPromise(
+*   Effect.gen(function* () {
+*     const syncer = yield* BiomeSchemaSync;
+*     return yield* syncer.sync("^1.9.3");
+*   }).pipe(
+*     Effect.provide(BiomeSchemaSyncLive),
+*     Effect.provide(NodeContext.layer),
+*   )
+* );
+* ```
+*
+* @since 0.1.0
+*/
+var BiomeSchemaSync = class extends Context.Tag("@savvy-web/silk-effects/BiomeSchemaSync")() {};
+/**
+* Live implementation of {@link BiomeSchemaSync}.
+*
+* @remarks
+* Requires `FileSystem` from `@effect/platform`. Provide `NodeContext.layer` or
+* `BunContext.layer` to satisfy this dependency.
+*
+* @since 0.1.0
+*/
+const BiomeSchemaSyncLive = Layer.effect(BiomeSchemaSync, Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const run = (version, options, write) => Effect.gen(function* () {
+		const cwd = options?.cwd ?? process.cwd();
+		const expectedUrl = buildSchemaUrl(extractSemver(version));
+		const configs = yield* findBiomeConfigs(cwd, fs);
+		const updated = [];
+		const skipped = [];
+		const current = [];
+		for (const configPath of configs) {
+			const raw = yield* fs.readFileString(configPath).pipe(Effect.mapError(
+				/* v8 ignore next 4 -- error path requires a filesystem read failure */
+				(cause) => new BiomeSyncError({
+					path: configPath,
+					reason: String(cause)
+				})
+			));
+			const schema = (yield* parse(raw).pipe(Effect.mapError(
+				/* v8 ignore next 4 -- error path requires a JSONC parse failure */
+				(e) => new BiomeSyncError({
+					path: configPath,
+					reason: `Failed to parse JSONC: ${String(e)}`
+				})
+			))).$schema;
+			if (typeof schema !== "string") {
+				skipped.push(configPath);
+				continue;
+			}
+			if (!schema.includes(BIOME_SCHEMA_HOSTNAME)) {
+				skipped.push(configPath);
+				continue;
+			}
+			if (schema === expectedUrl) {
+				current.push(configPath);
+				continue;
+			}
+			if (write) {
+				const updated_content = raw.replaceAll(schema, expectedUrl);
+				yield* fs.writeFileString(configPath, updated_content).pipe(Effect.mapError(
+					/* v8 ignore next 4 -- error path requires a filesystem write failure */
+					(cause) => new BiomeSyncError({
+						path: configPath,
+						reason: String(cause)
+					})
+				));
+			}
+			updated.push(configPath);
+		}
+		return {
+			updated,
+			skipped,
+			current
+		};
+	});
+	return {
+		sync: (version, options) => run(version, options, true),
+		check: (version, options) => run(version, options, false)
+	};
+}));
+
+//#endregion
+export { BiomeSchemaSync, BiomeSchemaSyncLive, buildSchemaUrl, extractSemver };

package/services/ChangesetConfig.js

@@ -0,0 +1,78 @@
+import { ChangesetConfigReader } from "./ChangesetConfigReader.js";
+import { Context, Effect, Layer, Option } from "effect";
+
+//#region src/services/ChangesetConfig.ts
+/**
+* Accessor service over a workspace root's `.changeset/config.json`.
+*
+* @remarks
+* Reads through {@link ChangesetConfigReader} (FileSystem-based) with a per-root cache.
+* Every accessor is total (error channel `never`): a missing or unreadable config collapses
+* to `mode: "none"` and empty/false defaults.
+*
+* @since 0.4.0
+*/
+var ChangesetConfig = class extends Context.Tag("@savvy-web/silk-effects/ChangesetConfig")() {
+	/**
+	* The one ignore matcher: exact name match, or `@scope/*` wildcard.
+	*
+	* `"@scope/*"` matches `"@scope/anything"` (prefix kept includes the trailing slash),
+	* but not the bare scope `"@scope"`.
+	*/
+	static matches(name, pattern) {
+		if (pattern.endsWith("/*")) {
+			const prefix = pattern.slice(0, -1);
+			return name.startsWith(prefix);
+		}
+		return name === pattern;
+	}
+};
+const isSilk = (cfg) => "_isSilk" in cfg && cfg._isSilk === true;
+/**
+* Live {@link ChangesetConfig} reading via {@link ChangesetConfigReader}, cached per root.
+*
+* @remarks
+* Requires `ChangesetConfigReader` (which requires `FileSystem`). Provide
+* `ChangesetConfigReaderLive` + a platform layer (`NodeContext.layer`).
+*
+* @since 0.4.0
+*/
+const ChangesetConfigLive = Layer.effect(ChangesetConfig, Effect.gen(function* () {
+	const reader = yield* ChangesetConfigReader;
+	const cache = /* @__PURE__ */ new Map();
+	const read = (root) => Effect.gen(function* () {
+		const hit = cache.get(root);
+		if (hit !== void 0) return hit;
+		const result = yield* reader.read(root).pipe(Effect.option);
+		cache.set(root, result);
+		return result;
+	});
+	return {
+		mode: (root) => read(root).pipe(Effect.map(Option.match({
+			onNone: () => "none",
+			onSome: (cfg) => isSilk(cfg) ? "silk" : "vanilla"
+		}))),
+		versionPrivate: (root) => read(root).pipe(Effect.map(Option.match({
+			onNone: () => false,
+			onSome: (cfg) => {
+				const pp = cfg.privatePackages;
+				return pp !== void 0 && pp !== false && pp.version === true;
+			}
+		}))),
+		ignorePatterns: (root) => read(root).pipe(Effect.map(Option.match({
+			onNone: () => [],
+			onSome: (cfg) => cfg.ignore ?? []
+		}))),
+		isIgnored: (name, root) => read(root).pipe(Effect.map(Option.match({
+			onNone: () => false,
+			onSome: (cfg) => (cfg.ignore ?? []).some((p) => ChangesetConfig.matches(name, p))
+		}))),
+		fixed: (root) => read(root).pipe(Effect.map(Option.match({
+			onNone: () => [],
+			onSome: (cfg) => cfg.fixed ?? []
+		})))
+	};
+}));
+
+//#endregion
+export { ChangesetConfig, ChangesetConfigLive };

package/services/ChangesetConfigReader.js

@@ -0,0 +1,106 @@
+import { ChangesetConfigError } from "../errors/ChangesetConfigError.js";
+import { ChangesetConfigFile, SilkChangesetConfigFile } from "../schemas/VersioningSchemas.js";
+import { Context, Effect, Layer, Schema } from "effect";
+import { FileSystem } from "@effect/platform";
+
+//#region src/services/ChangesetConfigReader.ts
+/**
+* Substrings that identify a Silk changelog adapter entry in `.changeset/config.json`.
+*
+* Both the standalone package (`@savvy-web/changesets/changelog`) and the
+* consolidated Silk re-export (`@savvy-web/silk/changesets/changelog`) are Silk
+* adapters. The `/silk/` segment in the consolidated path breaks the original
+* `@savvy-web/changesets` substring, so each form needs its own marker.
+*/
+const SILK_CHANGELOG_MARKERS = ["@savvy-web/changesets", "@savvy-web/silk/changesets"];
+function matchesSilkMarker(value) {
+	return SILK_CHANGELOG_MARKERS.some((marker) => value.includes(marker));
+}
+function isSilkChangelog(changelog) {
+	if (typeof changelog === "string") return matchesSilkMarker(changelog);
+	if (Array.isArray(changelog) && changelog.length > 0) return typeof changelog[0] === "string" && matchesSilkMarker(changelog[0]);
+	return false;
+}
+/**
+* Service that reads and decodes the `.changeset/config.json` for a given workspace root.
+*
+* @remarks
+* Automatically detects whether the config uses the Silk changelog adapter
+* (`@savvy-web/changesets`) and decodes as {@link SilkChangesetConfigFile} or the
+* standard {@link ChangesetConfigFile} accordingly.
+*
+* @example
+* ```typescript
+* const result = await Effect.runPromise(
+*   Effect.gen(function* () {
+*     const reader = yield* ChangesetConfigReader;
+*     return yield* reader.read(process.cwd());
+*   }).pipe(
+*     Effect.provide(ChangesetConfigReaderLive),
+*     Effect.provide(NodeContext.layer),
+*   )
+* );
+* ```
+*
+* @since 0.1.0
+*/
+var ChangesetConfigReader = class extends Context.Tag("@savvy-web/silk-effects/ChangesetConfigReader")() {};
+/**
+* Live implementation of {@link ChangesetConfigReader}.
+*
+* @remarks
+* Requires `FileSystem` from `@effect/platform`. Provide `NodeContext.layer` or
+* `BunContext.layer` to satisfy this dependency.
+*
+* @since 0.1.0
+*/
+const ChangesetConfigReaderLive = Layer.effect(ChangesetConfigReader, Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const read = (root) => {
+		const configPath = `${root}/.changeset/config.json`;
+		return Effect.gen(function* () {
+			if (!(yield* fs.exists(configPath).pipe(Effect.mapError(
+				/* v8 ignore next 4 -- error path requires fs.exists to fail */
+				(cause) => new ChangesetConfigError({
+					path: configPath,
+					reason: String(cause)
+				})
+			)))) return yield* Effect.fail(new ChangesetConfigError({
+				path: configPath,
+				reason: "File not found"
+			}));
+			const raw = yield* fs.readFileString(configPath).pipe(Effect.mapError(
+				/* v8 ignore next 4 -- error path requires fs.readFileString to fail */
+				(cause) => new ChangesetConfigError({
+					path: configPath,
+					reason: String(cause)
+				})
+			));
+			const parsed = yield* Effect.try({
+				try: () => JSON.parse(raw),
+				catch: (cause) => new ChangesetConfigError({
+					path: configPath,
+					reason: `Invalid JSON: ${String(cause)}`
+				})
+			});
+			if (isSilkChangelog(parsed.changelog)) return yield* Schema.decodeUnknown(SilkChangesetConfigFile)(parsed).pipe(Effect.mapError(
+				/* v8 ignore next 4 -- error path requires schema decode failure */
+				(cause) => new ChangesetConfigError({
+					path: configPath,
+					reason: `Schema decode failed: ${String(cause)}`
+				})
+			));
+			return yield* Schema.decodeUnknown(ChangesetConfigFile)(parsed).pipe(Effect.mapError(
+				/* v8 ignore next 4 -- error path requires schema decode failure */
+				(cause) => new ChangesetConfigError({
+					path: configPath,
+					reason: `Schema decode failed: ${String(cause)}`
+				})
+			));
+		});
+	};
+	return { read };
+}));
+
+//#endregion
+export { ChangesetConfigReader, ChangesetConfigReaderLive };

package/services/ConfigDiscovery.js

@@ -0,0 +1,71 @@
+import { Context, Effect, Layer } from "effect";
+import { FileSystem } from "@effect/platform";
+
+//#region src/services/ConfigDiscovery.ts
+/**
+* Service that locates named config files within a workspace using priority-ordered search paths.
+*
+* @remarks
+* Search priority (highest to lowest):
+* 1. `lib/configs/{name}` — shared config provided by a dependency package.
+* 2. `{cwd}/{name}` — local override at the workspace root.
+*
+* Missing files are silently skipped; only files that actually exist are returned.
+*
+* @example
+* ```typescript
+* const result = await Effect.runPromise(
+*   Effect.gen(function* () {
+*     const discovery = yield* ConfigDiscovery;
+*     return yield* discovery.find("biome.json");
+*   }).pipe(
+*     Effect.provide(ConfigDiscoveryLive),
+*     Effect.provide(NodeContext.layer),
+*   )
+* );
+* ```
+*
+* @since 0.1.0
+*/
+var ConfigDiscovery = class extends Context.Tag("@savvy-web/silk-effects/ConfigDiscovery")() {};
+/**
+* Check whether a path exists, treating any PlatformError as "not found".
+*/
+function safeExists(fs, path) {
+	return fs.exists(path).pipe(Effect.orElseSucceed(() => false));
+}
+/**
+* Live implementation of {@link ConfigDiscovery}.
+*
+* @remarks
+* Requires `FileSystem` from `@effect/platform`. Provide `NodeContext.layer` or
+* `BunContext.layer` to satisfy this dependency.
+*
+* @since 0.1.0
+*/
+const ConfigDiscoveryLive = Layer.effect(ConfigDiscovery, Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	const findAll = (name, options) => Effect.gen(function* () {
+		const cwd = options?.cwd ?? process.cwd();
+		const results = [];
+		const libPath = `${cwd}/lib/configs/${name}`;
+		if (yield* safeExists(fs, libPath)) results.push({
+			path: libPath,
+			source: "lib"
+		});
+		const rootPath = `${cwd}/${name}`;
+		if (yield* safeExists(fs, rootPath)) results.push({
+			path: rootPath,
+			source: "root"
+		});
+		return results;
+	});
+	const find = (name, options) => findAll(name, options).pipe(Effect.map((results) => results[0] ?? null));
+	return {
+		find,
+		findAll
+	};
+}));
+
+//#endregion
+export { ConfigDiscovery, ConfigDiscoveryLive };