@savvy-web/silk-effects 0.1.0

package/versioning.d.ts

@@ -0,0 +1,234 @@
+import { Context } from 'effect';
+import { Effect } from 'effect';
+import { FileSystem } from '@effect/platform';
+import { Layer } from 'effect';
+import { Schema } from 'effect';
+import { VoidIfEmpty } from 'effect/Types';
+import { YieldableError } from 'effect/Cause';
+
+/**
+ * Standard changesets configuration matching the `@changesets/types` upstream spec.
+ *
+ * @remarks
+ * Represents the parsed `.changeset/config.json` file. All fields are optional
+ * to allow partial configs. Use {@link SilkChangesetConfig} when the Silk changelog
+ * adapter is detected.
+ *
+ * @since 0.1.0
+ */
+export declare const ChangesetConfig: Schema.Struct<{
+    changelog: Schema.optional<Schema.Union<[typeof Schema.String, Schema.Array$<typeof Schema.Unknown>]>>;
+    commit: Schema.optional<typeof Schema.Boolean>;
+    fixed: Schema.optional<Schema.Array$<Schema.Array$<typeof Schema.String>>>;
+    linked: Schema.optional<Schema.Array$<Schema.Array$<typeof Schema.String>>>;
+    access: Schema.optional<Schema.Literal<["public", "restricted"]>>;
+    baseBranch: Schema.optional<typeof Schema.String>;
+    updateInternalDependencies: Schema.optional<Schema.Literal<["patch", "minor", "major"]>>;
+    ignore: Schema.optional<Schema.Array$<typeof Schema.String>>;
+}>;
+
+/** @since 0.1.0 */
+export declare type ChangesetConfig = typeof ChangesetConfig.Type;
+
+/**
+ * Raised when the `.changeset/config.json` file cannot be read or decoded.
+ *
+ * @remarks
+ * Returned by {@link ChangesetConfigReader.read} when the file is missing,
+ * contains invalid JSON, or fails Effect Schema validation.
+ *
+ * @since 0.1.0
+ */
+export declare class ChangesetConfigError extends ChangesetConfigError_base<{
+    readonly path: string;
+    readonly reason: string;
+}> {
+    get message(): string;
+}
+
+declare const ChangesetConfigError_base: new <A extends Record<string, any> = {}>(args: VoidIfEmpty<    { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => YieldableError & {
+    readonly _tag: "ChangesetConfigError";
+} & Readonly<A>;
+
+/**
+ * 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 SilkChangesetConfig} or the
+ * standard {@link ChangesetConfig} 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
+ */
+export declare class ChangesetConfigReader extends ChangesetConfigReader_base {
+}
+
+declare const ChangesetConfigReader_base: Context.TagClass<ChangesetConfigReader, "@savvy-web/silk-effects/ChangesetConfigReader", {
+    /**
+     * Read and decode `.changeset/config.json` from the given workspace root.
+     *
+     * @param root - Absolute path to the workspace root containing the `.changeset/` directory.
+     * @returns An `Effect` that succeeds with the decoded config or fails with {@link ChangesetConfigError}.
+     *
+     * @since 0.1.0
+     */
+    readonly read: (root: string) => Effect.Effect<ChangesetConfig | SilkChangesetConfig, ChangesetConfigError>;
+}>;
+
+/**
+ * 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
+ */
+export declare const ChangesetConfigReaderLive: Layer.Layer<ChangesetConfigReader, never, FileSystem.FileSystem>;
+
+/**
+ * Extended changeset config for repos using the `@savvy-web/changesets` changelog adapter.
+ *
+ * @remarks
+ * Extends {@link ChangesetConfig} 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
+ */
+export declare const SilkChangesetConfig: Schema.extend<Schema.Struct<{
+    changelog: Schema.optional<Schema.Union<[typeof Schema.String, Schema.Array$<typeof Schema.Unknown>]>>;
+    commit: Schema.optional<typeof Schema.Boolean>;
+    fixed: Schema.optional<Schema.Array$<Schema.Array$<typeof Schema.String>>>;
+    linked: Schema.optional<Schema.Array$<Schema.Array$<typeof Schema.String>>>;
+    access: Schema.optional<Schema.Literal<["public", "restricted"]>>;
+    baseBranch: Schema.optional<typeof Schema.String>;
+    updateInternalDependencies: Schema.optional<Schema.Literal<["patch", "minor", "major"]>>;
+    ignore: Schema.optional<Schema.Array$<typeof Schema.String>>;
+}>, Schema.Struct<{
+    _isSilk: Schema.optionalWith<typeof Schema.Boolean, {
+        default: () => true;
+    }>;
+}>>;
+
+/** @since 0.1.0 */
+export declare type SilkChangesetConfig = typeof SilkChangesetConfig.Type;
+
+/**
+ * Raised when the versioning strategy cannot be determined from the workspace state.
+ *
+ * @remarks
+ * Returned by {@link VersioningStrategy.detect} when an unexpected condition
+ * prevents strategy classification.
+ *
+ * @since 0.1.0
+ */
+export declare class VersioningDetectionError extends VersioningDetectionError_base<{
+    readonly reason: string;
+}> {
+    get message(): string;
+}
+
+declare const VersioningDetectionError_base: new <A extends Record<string, any> = {}>(args: VoidIfEmpty<    { readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => YieldableError & {
+    readonly _tag: "VersioningDetectionError";
+} & Readonly<A>;
+
+/**
+ * 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(NodeContext.layer),
+ *   )
+ * );
+ * ```
+ *
+ * @since 0.1.0
+ */
+export declare class VersioningStrategy extends VersioningStrategy_base {
+}
+
+declare const VersioningStrategy_base: Context.TagClass<VersioningStrategy, "@savvy-web/silk-effects/VersioningStrategy", {
+    /**
+     * Classify the versioning strategy for a list of publishable package names.
+     *
+     * @param publishablePackages - Package names (e.g. `"@my-org/pkg"`) that will be published.
+     * @param root - Workspace root directory to read changeset config from.
+     * @returns An `Effect` resolving to a {@link VersioningStrategyResult}, or failing with
+     *   {@link VersioningDetectionError} on unexpected errors.
+     *
+     * @since 0.1.0
+     */
+    readonly detect: (publishablePackages: ReadonlyArray<string>, root: string) => Effect.Effect<VersioningStrategyResult, VersioningDetectionError>;
+}>;
+
+/**
+ * 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
+ */
+export declare const VersioningStrategyLive: Layer.Layer<VersioningStrategy, never, ChangesetConfigReader>;
+
+/**
+ * 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
+ */
+export declare const VersioningStrategyResult: Schema.Struct<{
+    type: Schema.Literal<["single", "fixed-group", "independent"]>;
+    fixedGroups: Schema.Array$<Schema.Array$<typeof Schema.String>>;
+    publishablePackages: Schema.Array$<typeof Schema.String>;
+}>;
+
+/** @since 0.1.0 */
+export declare type VersioningStrategyResult = typeof VersioningStrategyResult.Type;
+
+/**
+ * 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
+ */
+export declare const VersioningStrategyType: Schema.Literal<["single", "fixed-group", "independent"]>;
+
+/** @since 0.1.0 */
+export declare type VersioningStrategyType = typeof VersioningStrategyType.Type;
+
+export { }

package/versioning.js

@@ -0,0 +1,115 @@
+import { FileSystem } from "@effect/platform";
+import { Context, Data, Effect, Layer, Schema } from "effect";
+class ChangesetConfigError extends Data.TaggedError("ChangesetConfigError") {
+    get message() {
+        return `Failed to read changeset config at ${this.path}: ${this.reason}`;
+    }
+}
+class VersioningDetectionError extends Data.TaggedError("VersioningDetectionError") {
+    get message() {
+        return `Failed to detect versioning strategy: ${this.reason}`;
+    }
+}
+const ChangesetConfig = Schema.Struct({
+    changelog: Schema.optional(Schema.Union(Schema.String, Schema.Array(Schema.Unknown))),
+    commit: Schema.optional(Schema.Boolean),
+    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))
+});
+const SilkChangesetConfig = Schema.extend(ChangesetConfig, Schema.Struct({
+    _isSilk: Schema.optionalWith(Schema.Boolean, {
+        default: ()=>true
+    })
+}));
+const VersioningStrategyType = Schema.Literal("single", "fixed-group", "independent");
+Schema.Struct({
+    type: VersioningStrategyType,
+    fixedGroups: Schema.Array(Schema.Array(Schema.String)),
+    publishablePackages: Schema.Array(Schema.String)
+});
+const SILK_CHANGELOG_MARKER = "@savvy-web/changesets";
+function isSilkChangelog(changelog) {
+    if ("string" == typeof changelog) return changelog.includes(SILK_CHANGELOG_MARKER);
+    if (Array.isArray(changelog) && changelog.length > 0) return "string" == typeof changelog[0] && changelog[0].includes(SILK_CHANGELOG_MARKER);
+    return false;
+}
+class ChangesetConfigReader extends Context.Tag("@savvy-web/silk-effects/ChangesetConfigReader")() {
+}
+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*() {
+            const exists = yield* fs.exists(configPath).pipe(Effect.mapError((cause)=>new ChangesetConfigError({
+                    path: configPath,
+                    reason: String(cause)
+                })));
+            if (!exists) return yield* Effect.fail(new ChangesetConfigError({
+                path: configPath,
+                reason: "File not found"
+            }));
+            const raw = yield* fs.readFileString(configPath).pipe(Effect.mapError((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)}`
+                    })
+            });
+            const rawConfig = parsed;
+            if (isSilkChangelog(rawConfig.changelog)) return yield* Schema.decodeUnknown(SilkChangesetConfig)(parsed).pipe(Effect.mapError((cause)=>new ChangesetConfigError({
+                    path: configPath,
+                    reason: `Schema decode failed: ${String(cause)}`
+                })));
+            return yield* Schema.decodeUnknown(ChangesetConfig)(parsed).pipe(Effect.mapError((cause)=>new ChangesetConfigError({
+                    path: configPath,
+                    reason: `Schema decode failed: ${String(cause)}`
+                })));
+        });
+    };
+    return {
+        read
+    };
+}));
+class VersioningStrategy extends Context.Tag("@savvy-web/silk-effects/VersioningStrategy")() {
+}
+const VersioningStrategyLive = Layer.effect(VersioningStrategy, Effect.gen(function*() {
+    const configReader = yield* ChangesetConfigReader;
+    const detect = (publishablePackages, root)=>Effect.gen(function*() {
+            const config = yield* configReader.read(root).pipe(Effect.orElseSucceed(()=>({
+                    fixed: [],
+                    linked: []
+                })));
+            const fixed = config.fixed ?? [];
+            const packages = [
+                ...publishablePackages
+            ];
+            if (packages.length <= 1) return {
+                type: "single",
+                fixedGroups: fixed,
+                publishablePackages: packages
+            };
+            const containingGroup = fixed.find((group)=>packages.every((pkg)=>group.includes(pkg)));
+            if (void 0 !== containingGroup) return {
+                type: "fixed-group",
+                fixedGroups: fixed,
+                publishablePackages: packages
+            };
+            return {
+                type: "independent",
+                fixedGroups: fixed,
+                publishablePackages: packages
+            };
+        });
+    return {
+        detect
+    };
+}));
+export { ChangesetConfigError, ChangesetConfigReader, ChangesetConfigReaderLive, VersioningDetectionError, VersioningStrategy, VersioningStrategyLive };