@savvy-web/silk-effects 4.2.6 → 5.0.0

package/services/TagStrategy.js

@@ -1,56 +0,0 @@
-import { TagFormatError } from "../errors/TagFormatError.js";
-import { Context, Effect, Layer } from "effect";
-
-//#region src/services/TagStrategy.ts
-/**
-* Service that determines and applies the git-tag naming strategy for a release.
-*
-* @remarks
-* Consumes a {@link (VersioningStrategyResult:type)} to pick between `"single"` and `"scoped"`
-* tag formats, then formats tag strings accordingly. Independent versioning always
-* produces scoped tags; single and fixed-group versioning produces a single shared tag.
-*
-* @example
-* ```typescript
-* const result = await Effect.runPromise(
-*   Effect.gen(function* () {
-*     const tags = yield* TagStrategy;
-*     const strategyType = yield* tags.determine({ type: "independent", fixedGroups: [], publishablePackages: [] });
-*     return yield* tags.formatTag("@my-org/pkg", "1.2.3", strategyType);
-*   }).pipe(Effect.provide(TagStrategyLive))
-* );
-* // => "@my-org/pkg@1.2.3"
-* ```
-*
-* @since 0.1.0
-* @public
-*/
-var TagStrategy = class extends Context.Service()("@savvy-web/silk-effects/TagStrategy") {};
-/**
-* Live implementation of {@link TagStrategy} with no external dependencies.
-*
-* @remarks
-* All logic is pure: strategy determination and tag formatting involve no I/O.
-*
-* @since 0.1.0
-* @public
-*/
-const TagStrategyLive = Layer.succeed(TagStrategy, {
-	determine: (versioningResult) => {
-		if (versioningResult.type === "independent") return Effect.succeed("scoped");
-		return Effect.succeed("single");
-	},
-	formatTag: (name, version, strategy) => {
-		if (version === "") return Effect.fail(new TagFormatError({
-			name,
-			version,
-			reason: "version cannot be empty"
-		}));
-		if (strategy === "single") return Effect.succeed(version);
-		if (name.startsWith("@")) return Effect.succeed(`${name}@${version}`);
-		return Effect.succeed(`${name}@${version}`);
-	}
-});
-
-//#endregion
-export { TagStrategy, TagStrategyLive };

package/services/ToolDiscovery.js

@@ -1,232 +0,0 @@
-import { ToolNotFoundError } from "../errors/ToolNotFoundError.js";
-import { ToolResolutionError } from "../errors/ToolResolutionError.js";
-import { ResolvedTool } from "../schemas/ResolvedTool.js";
-import { Context, Effect, Layer, Option, Ref } from "effect";
-import { PackageManagerDetector, WorkspaceRoot } from "@effected/workspaces";
-import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
-
-//#region src/services/ToolDiscovery.ts
-/**
-* Service that resolves CLI tools — locating them globally (PATH) or locally
-* (via package manager), extracting versions, enforcing source and version
-* constraints, and caching results.
-*
-* @example
-* ```typescript
-* const result = await Effect.runPromise(
-*   Effect.gen(function* () {
-*     const td = yield* ToolDiscovery;
-*     return yield* td.resolve(
-*       ToolDefinition.make({ name: "biome" })
-*     );
-*   }).pipe(
-*     Effect.provide(ToolDiscoveryLive),
-*     Effect.provide(NodeServices.layer),
-*   )
-* );
-* ```
-*
-* @since 0.2.0
-* @public
-*/
-var ToolDiscovery = class extends Context.Service()("@savvy-web/silk-effects/ToolDiscovery") {};
-/**
-* Build the PM exec prefix for running a local binary.
-*/
-function pmExecArgs(pmType, name) {
-	switch (pmType) {
-		case "pnpm": return [
-			"pnpm",
-			"exec",
-			name
-		];
-		case "npm": return [
-			"npx",
-			"--no",
-			"--",
-			name
-		];
-		case "yarn": return [
-			"yarn",
-			"exec",
-			name
-		];
-		case "bun": return [
-			"bun",
-			"x",
-			"--no-install",
-			name
-		];
-	}
-}
-/**
-* Run a command and return its stdout, or `Option.none()` on failure.
-*/
-function tryString(spawner, cmd) {
-	return spawner.string(cmd).pipe(Effect.map((s) => Option.some(s.trim())), Effect.catch(() => Effect.succeed(Option.none())));
-}
-/**
-* Run a command and return true if it succeeds (exit code 0).
-*/
-function tryExists(spawner, cmd) {
-	return spawner.exitCode(cmd).pipe(Effect.map((code) => code === 0), Effect.catch(() => Effect.succeed(false)));
-}
-/**
-* Extract version from command output using a VersionExtractor.
-*/
-function extractVersion(output, extractor) {
-	if (extractor._tag === "None" || Option.isNone(output)) return Option.none();
-	const raw = output.value;
-	if (extractor._tag === "Flag") {
-		const parsed = extractor.parse ? extractor.parse(raw) : raw.trim();
-		return Option.some(parsed);
-	}
-	try {
-		const obj = JSON.parse(raw);
-		const parts = extractor.path.split(".");
-		let current = obj;
-		for (const part of parts) {
-			if (current == null || typeof current !== "object") return Option.none();
-			current = current[part];
-		}
-		return typeof current === "string" ? Option.some(current) : Option.none();
-	} catch {
-		return Option.none();
-	}
-}
-/**
-* Live implementation of {@link ToolDiscovery}.
-*
-* @remarks
-* Requires `ChildProcessSpawner` from `effect/unstable/process` (provide
-* `NodeServices.layer` at the app edge), plus `PackageManagerDetector`
-* and `WorkspaceRoot` from `@effected/workspaces`.
-*
-* @since 0.2.0
-* @public
-*/
-const ToolDiscoveryLive = Layer.effect(ToolDiscovery, Effect.gen(function* () {
-	const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
-	const wsRoot = yield* WorkspaceRoot;
-	const pmDetector = yield* PackageManagerDetector;
-	const cache = yield* Ref.make(/* @__PURE__ */ new Map());
-	const resolve = (definition) => Effect.gen(function* () {
-		const hit = (yield* Ref.get(cache)).get(definition.name);
-		if (hit) return hit;
-		const root = yield* wsRoot.find(process.cwd()).pipe(Effect.catch(() => Effect.fail(new ToolResolutionError({
-			name: definition.name,
-			reason: "Could not find workspace root"
-		}))));
-		const pmType = (yield* pmDetector.detect(root).pipe(Effect.catch(() => Effect.fail(new ToolResolutionError({
-			name: definition.name,
-			reason: "Could not detect package manager"
-		}))))).name;
-		const globalExists = yield* tryExists(spawner, ChildProcess.make("sh", ["-c", `command -v ${definition.name}`]));
-		let globalVersion = Option.none();
-		if (globalExists && definition.versionExtractor._tag !== "None") {
-			const flag = definition.versionExtractor.flag;
-			globalVersion = extractVersion(yield* tryString(spawner, ChildProcess.make(definition.name, [flag])), definition.versionExtractor);
-		}
-		let localExists = false;
-		let localVersion = Option.none();
-		const [pmBin, ...pmArgs] = pmExecArgs(pmType, definition.name);
-		if (definition.versionExtractor._tag !== "None") {
-			const flag = definition.versionExtractor.flag;
-			const localOutput = yield* tryString(spawner, ChildProcess.make(pmBin, [...pmArgs, flag]));
-			if (Option.isSome(localOutput)) {
-				localExists = true;
-				localVersion = extractVersion(localOutput, definition.versionExtractor);
-			}
-		} else localExists = yield* tryExists(spawner, ChildProcess.make(pmBin, [...pmArgs, "--version"]));
-		if (!globalExists && !localExists) return yield* Effect.fail(new ToolResolutionError({
-			name: definition.name,
-			reason: "Tool not found globally or locally"
-		}));
-		switch (definition.source._tag) {
-			case "OnlyLocal":
-				if (!localExists) return yield* Effect.fail(new ToolResolutionError({
-					name: definition.name,
-					reason: "Tool is required locally but was only found globally"
-				}));
-				break;
-			case "OnlyGlobal":
-				if (!globalExists) return yield* Effect.fail(new ToolResolutionError({
-					name: definition.name,
-					reason: "Tool is required globally but was only found locally"
-				}));
-				break;
-			case "Both":
-				if (!globalExists || !localExists) return yield* Effect.fail(new ToolResolutionError({
-					name: definition.name,
-					reason: "Tool is required both globally and locally but was only found in one location"
-				}));
-				break;
-			case "Any": break;
-		}
-		let mismatch = false;
-		let source = localExists ? "local" : "global";
-		let version = localExists ? localVersion : globalVersion;
-		if (globalExists && localExists && Option.isSome(globalVersion) && Option.isSome(localVersion)) {
-			if (globalVersion.value !== localVersion.value) {
-				mismatch = true;
-				switch (definition.policy._tag) {
-					case "Report":
-						source = "local";
-						version = localVersion;
-						break;
-					case "PreferLocal":
-						source = "local";
-						version = localVersion;
-						break;
-					case "PreferGlobal":
-						source = "global";
-						version = globalVersion;
-						break;
-					case "RequireMatch": return yield* Effect.fail(new ToolResolutionError({
-						name: definition.name,
-						reason: `Version mismatch: global ${globalVersion.value} vs local ${localVersion.value}`
-					}));
-				}
-			}
-		}
-		const resolved = new ResolvedTool({
-			name: definition.name,
-			source,
-			version,
-			globalVersion,
-			localVersion,
-			packageManager: pmType,
-			mismatch
-		});
-		yield* Ref.update(cache, (m) => {
-			const next = new Map(m);
-			next.set(definition.name, resolved);
-			return next;
-		});
-		return resolved;
-	});
-	const require_ = (definition, message) => resolve(definition).pipe(Effect.mapError((err) => new ToolNotFoundError({
-		name: definition.name,
-		reason: message ?? err.reason
-	})));
-	const isAvailable = (definition) => Effect.gen(function* () {
-		if (yield* tryExists(spawner, ChildProcess.make("sh", ["-c", `command -v ${definition.name}`]))) return true;
-		const rootResult = yield* wsRoot.find(process.cwd()).pipe(Effect.option);
-		if (Option.isNone(rootResult)) return false;
-		const pmResult = yield* pmDetector.detect(rootResult.value).pipe(Effect.option);
-		if (Option.isNone(pmResult)) return false;
-		const pmType = pmResult.value.name;
-		const probeFlag = definition.versionExtractor._tag !== "None" ? definition.versionExtractor.flag : "--version";
-		const [pmBin, ...pmArgs] = pmExecArgs(pmType, definition.name);
-		return yield* tryExists(spawner, ChildProcess.make(pmBin, [...pmArgs, probeFlag]));
-	});
-	return {
-		resolve,
-		require: require_,
-		isAvailable,
-		clearCache: Ref.set(cache, /* @__PURE__ */ new Map())
-	};
-}));
-
-//#endregion
-export { ToolDiscovery, ToolDiscoveryLive };

package/services/VersioningStrategy.js

@@ -1,69 +0,0 @@
-import { ChangesetConfigReader } from "./ChangesetConfigReader.js";
-import { Context, Effect, Layer } from "effect";
-
-//#region src/services/VersioningStrategy.ts
-/**
-* Service that classifies the versioning strategy used by a workspace.
-*
-* @remarks
-* Reads the changesets config to inspect `fixed` groups, then determines whether
-* the workspace uses a single-package, fixed-group, or independent versioning strategy.
-* Falls back to safe defaults when the changeset config is unavailable.
-*
-* @example
-* ```typescript
-* const result = await Effect.runPromise(
-*   Effect.gen(function* () {
-*     const strategy = yield* VersioningStrategy;
-*     return yield* strategy.detect(["@my-org/pkg-a", "@my-org/pkg-b"]);
-*   }).pipe(
-*     Effect.provide(VersioningStrategyLive),
-*     Effect.provide(ChangesetConfigReaderLive),
-*     Effect.provide(NodeServices.layer),
-*   )
-* );
-* ```
-*
-* @since 0.1.0
-* @public
-*/
-var VersioningStrategy = class extends Context.Service()("@savvy-web/silk-effects/VersioningStrategy") {};
-/**
-* Live implementation of {@link VersioningStrategy}.
-*
-* @remarks
-* Requires {@link ChangesetConfigReader} to read the workspace changeset configuration.
-* If the config file is absent, an empty `fixed` groups array is assumed.
-*
-* @since 0.1.0
-* @public
-*/
-const VersioningStrategyLive = Layer.effect(VersioningStrategy, Effect.gen(function* () {
-	const configReader = yield* ChangesetConfigReader;
-	const detect = (publishablePackages, root) => Effect.gen(function* () {
-		const fixed = (yield* configReader.read(root).pipe(Effect.orElseSucceed(() => ({
-			fixed: [],
-			linked: []
-		})))).fixed ?? [];
-		const packages = [...publishablePackages];
-		if (packages.length <= 1) return {
-			type: "single",
-			fixedGroups: fixed,
-			publishablePackages: packages
-		};
-		if (fixed.find((group) => packages.every((pkg) => group.includes(pkg))) !== void 0) return {
-			type: "fixed-group",
-			fixedGroups: fixed,
-			publishablePackages: packages
-		};
-		return {
-			type: "independent",
-			fixedGroups: fixed,
-			publishablePackages: packages
-		};
-	});
-	return { detect };
-}));
-
-//#endregion
-export { VersioningStrategy, VersioningStrategyLive };

package/utils/ToolCommand.js

@@ -1,67 +0,0 @@
-import { Effect, Stream } from "effect";
-import { ChildProcess, ChildProcessSpawner } from "effect/unstable/process";
-
-//#region src/utils/ToolCommand.ts
-/**
-* Rebuild a command with patched options.
-*
-* @remarks
-* `ChildProcess.Command` values are pure data, but core only ships setters for
-* `cwd` and `env`. This helper rebuilds a `StandardCommand` with merged
-* options, recursing into both sides of a `PipedCommand` the same way
-* `ChildProcess.setCwd` does.
-*/
-const patchOptions = (command, patch) => {
-	switch (command._tag) {
-		case "StandardCommand": return ChildProcess.make(command.command, command.args, patch(command.options));
-		case "PipedCommand": return ChildProcess.pipeTo(patchOptions(command.left, patch), patchOptions(command.right, patch), command.options);
-	}
-};
-/**
-* Wraps `effect/unstable/process` `ChildProcess.Command` with instance method ergonomics.
-*
-* Use `yield* cmd.string()` instead of resolving the `ChildProcessSpawner` service by hand.
-*
-* @since 0.2.0
-* @public
-*/
-var ToolCommand = class ToolCommand {
-	command;
-	constructor(command) {
-		this.command = command;
-	}
-	string() {
-		return Effect.flatMap(ChildProcessSpawner.ChildProcessSpawner, (spawner) => spawner.string(this.command));
-	}
-	exitCode() {
-		return Effect.flatMap(ChildProcessSpawner.ChildProcessSpawner, (spawner) => spawner.exitCode(this.command));
-	}
-	lines() {
-		return Effect.flatMap(ChildProcessSpawner.ChildProcessSpawner, (spawner) => spawner.lines(this.command));
-	}
-	stream() {
-		return Stream.unwrap(Effect.map(ChildProcessSpawner.ChildProcessSpawner, (spawner) => spawner.streamString(this.command)));
-	}
-	env(environment) {
-		return new ToolCommand(patchOptions(this.command, (options) => ({
-			...options,
-			env: {
-				...options.env,
-				...environment
-			},
-			extendEnv: true
-		})));
-	}
-	workingDirectory(cwd) {
-		return new ToolCommand(ChildProcess.setCwd(this.command, cwd));
-	}
-	stdin(input) {
-		return new ToolCommand(patchOptions(this.command, (options) => ({
-			...options,
-			stdin: Stream.succeed(new TextEncoder().encode(input))
-		})));
-	}
-};
-
-//#endregion
-export { ToolCommand };