@savvy-web/silk-effects 0.2.0 → 0.2.2

package/README.md

@@ -3,18 +3,15 @@
 [![npm version](https://img.shields.io/npm/v/@savvy-web/silk-effects)](https://www.npmjs.com/package/@savvy-web/silk-effects)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
-Shared [Effect](https://effect.website/) library providing Silk Suite conventions for publishability detection, versioning strategy, tag formatting, managed sections, config discovery, and Biome schema synchronization. Platform-agnostic: consumers provide their own runtime layer (Node.js, Bun, etc.).
+Shared [Effect](https://effect.website/) library providing Silk Suite conventions for publishability detection, versioning strategy, tag formatting, managed file sections, config discovery, Biome schema synchronization, and CLI tool resolution. Platform-agnostic -- consumers provide their own runtime layer (`NodeContext`, `BunContext`, etc.).
 
 ## Features
 
-- Resolve publish targets from shorthand strings, URLs, or objects with sensible defaults
-- Detect versioning strategy (single, fixed-group, independent) from changeset config
-- Format git tags consistently based on workspace structure
-- Manage tool-owned sections inside user-editable files without clobbering user content
-- Define reusable section identities with typed content factories (`SectionDefinition`)
+- Resolve publish targets and detect publishability from `package.json` with multi-registry support
+- Manage tool-owned sections in user-editable files without clobbering surrounding content
 - Discover and resolve CLI tools globally or locally with version enforcement and caching
-- Discover config files using a priority-based search convention
-- Keep Biome `$schema` URLs in sync across config files
+- Detect versioning strategy and format git tags from changeset configuration
+- Locate config files and keep Biome schema URLs in sync across workspaces
 
 ## Installation
 
@@ -22,12 +19,34 @@ Shared [Effect](https://effect.website/) library providing Silk Suite convention
 pnpm add @savvy-web/silk-effects effect @effect/platform @effect/platform-node
 ```
 
-`effect` is a peer dependency -- install it alongside the package.
+`effect` is a peer dependency. Install a platform package (`@effect/platform-node`, `@effect/platform-bun`) matching your runtime.
 
 ## Quick Start
 
 All exports come from the package root:
 
+```typescript
+import {
+  TargetResolver, TargetResolverLive,
+  ManagedSection, ManagedSectionLive, SectionDefinition,
+  ToolDiscovery, ToolDiscoveryLive, ToolDefinition,
+} from "@savvy-web/silk-effects";
+```
+
+## Services
+
+The 9 services are grouped by which platform layers they require.
+
+---
+
+### No Platform Layer Required
+
+These services are pure logic -- no filesystem or shell access needed.
+
+#### TargetResolver
+
+Resolve raw publish-target values into fully-normalized `ResolvedTarget` records. Supports shorthands (`"npm"`, `"github"`, `"jsr"`), custom registry URLs, and object configs. Auth strategy (OIDC vs token) is auto-detected from the registry hostname.
+
 ```typescript
 import { Effect } from "effect";
 import { TargetResolver, TargetResolverLive } from "@savvy-web/silk-effects";
@@ -38,26 +57,91 @@ const targets = await Effect.runPromise(
     return yield* resolver.resolve(["npm", "github"]);
   }).pipe(Effect.provide(TargetResolverLive)),
 );
+// => ResolvedTarget[] with registry, auth, provenance, etc.
+```
+
+#### SilkPublishabilityPlugin
+
+Detect whether a package is publishable from its `package.json` and resolve its targets. Delegates to `TargetResolver` internally.
+
+Rules: `private: true` with no `publishConfig` is not publishable. A `publishConfig.targets` array resolves each entry. A bare `publishConfig.registry` resolves a single target. Default falls back to `"npm"`.
+
+```typescript
+import { Effect } from "effect";
+import {
+  SilkPublishabilityPlugin, SilkPublishabilityPluginLive,
+  TargetResolverLive,
+} from "@savvy-web/silk-effects";
+
+const targets = await Effect.runPromise(
+  Effect.gen(function* () {
+    const plugin = yield* SilkPublishabilityPlugin;
+    return yield* plugin.detect(packageJson);
+  }).pipe(
+    Effect.provide(SilkPublishabilityPluginLive),
+    Effect.provide(TargetResolverLive),
+  ),
+);
+```
+
+#### TagStrategy
+
+Determine git-tag naming strategy and format tag strings. Strategy is `"single"` (one publishable package, tags like `1.2.3`) or `"scoped"` (multiple packages, tags like `@scope/pkg@1.2.3`). Tag format follows strict SemVer 2.0.0 with no `v` prefix.
+
+```typescript
+import { Effect } from "effect";
+import { TagStrategy, TagStrategyLive } from "@savvy-web/silk-effects";
+
+const tag = await Effect.runPromise(
+  Effect.gen(function* () {
+    const ts = yield* TagStrategy;
+    const strategy = yield* ts.determine(versioningResult);
+    return yield* ts.formatTag("@savvy-web/silk-effects", "0.2.0", strategy);
+  }).pipe(Effect.provide(TagStrategyLive)),
+);
+// => "@savvy-web/silk-effects@0.2.0"
 ```
 
-Services that access the filesystem require a platform layer:
+---
+
+### FileSystem Layer Required
+
+These services read or write files. Provide a platform layer such as `NodeContext.layer` or `BunContext.layer`.
+
+#### ManagedSection
+
+Manage tool-owned delimited sections inside user-editable files. Sections are bounded by markers like `# --- BEGIN TOOL MANAGED SECTION ---` / `# --- END ... ---`. User content outside the markers is never touched.
+
+**SectionDefinition** is a value object representing section identity (tool name + comment style). It creates `SectionBlock` instances that hold the actual content. Definitions support typed content factories via `generate()` and `generateEffect()`.
+
+**SectionBlock** represents the content between markers. It supports `diff()`, `prepend()`, and `append()` operations and uses normalized content for equality comparison.
+
+Methods: `read`, `write`, `sync`, `check`, `isManaged` -- all support dual API (data-first and data-last) for pipe composition.
 
 ```typescript
 import { Effect } from "effect";
 import { NodeContext } from "@effect/platform-node";
 import {
-  ManagedSection,
-  ManagedSectionLive,
-  SectionDefinition,
+  ManagedSection, ManagedSectionLive, SectionDefinition,
 } from "@savvy-web/silk-effects";
 
-const def = SectionDefinition.make({ toolName: "MY-TOOL" });
+// Define section identity
+const def = SectionDefinition.make({ toolName: "LINT-STAGED" });
+
+// Create a content block from the definition
 const block = def.block("\nnpx lint-staged\n");
 
 await Effect.runPromise(
   Effect.gen(function* () {
     const ms = yield* ManagedSection;
-    yield* ms.sync(".husky/pre-commit", block);
+
+    // Sync: creates the section if missing, updates if changed, no-op if identical
+    const result = yield* ms.sync(".husky/pre-commit", block);
+    // => SyncResult: Created | Updated | Unchanged
+
+    // Check: compare file content against expected block
+    const check = yield* ms.check(".husky/pre-commit", block);
+    // => CheckResult: Found | NotFound
   }).pipe(
     Effect.provide(ManagedSectionLive),
     Effect.provide(NodeContext.layer),
@@ -65,23 +149,153 @@ await Effect.runPromise(
 );
 ```
 
-## Services
+`SectionDefinition` also supports `//` comment style for JavaScript/TypeScript files:
+
+```typescript
+const jsDef = SectionDefinition.make({ toolName: "MY-TOOL", commentStyle: "//" });
+```
+
+Use `ShellSectionDefinition` when the comment style is always `#` and should not be configurable.
+
+#### VersioningStrategy
+
+Classify the versioning strategy from changeset configuration. Outputs `"single"` (0-1 publishable packages), `"fixed-group"` (all packages in one fixed group), or `"independent"` (multiple packages, not in a single group). Falls back gracefully if config is missing.
+
+```typescript
+import { Effect } from "effect";
+import { NodeContext } from "@effect/platform-node";
+import {
+  VersioningStrategy, VersioningStrategyLive,
+  ChangesetConfigReaderLive,
+} from "@savvy-web/silk-effects";
+
+const result = await Effect.runPromise(
+  Effect.gen(function* () {
+    const vs = yield* VersioningStrategy;
+    return yield* vs.detect(publishablePackages, process.cwd());
+  }).pipe(
+    Effect.provide(VersioningStrategyLive),
+    Effect.provide(ChangesetConfigReaderLive),
+    Effect.provide(NodeContext.layer),
+  ),
+);
+// => { strategy: "single" | "fixed-group" | "independent", ... }
+```
+
+#### ChangesetConfigReader
 
-| Service | Platform Layer | Description |
-| ------- | -------------- | ----------- |
-| `TargetResolver` | No | Resolve publish targets from shorthand strings or objects |
-| `SilkPublishabilityPlugin` | No | Detect publishable packages from `package.json` |
-| `TagStrategy` | No | Determine and format git tags by versioning strategy |
-| `VersioningStrategy` | Yes (FileSystem) | Detect versioning strategy from changeset config |
-| `ChangesetConfigReader` | Yes (FileSystem) | Read and parse changeset configuration |
-| `ManagedSection` | Yes (FileSystem) | Read/write/sync/check tool-owned sections in user files |
-| `ConfigDiscovery` | Yes (FileSystem) | Locate config files by priority-based search |
-| `BiomeSchemaSync` | Yes (FileSystem) | Keep Biome `$schema` URLs in sync across config files |
-| `ToolDiscovery` | Yes (CommandExecutor) | Locate CLI tools globally or locally, with caching |
+Read and decode `.changeset/config.json`. Auto-detects whether the project uses `@savvy-web/changesets` (returning `SilkChangesetConfig` with `_isSilk: true`) or standard changesets (returning `ChangesetConfig`).
+
+```typescript
+import { Effect } from "effect";
+import { NodeContext } from "@effect/platform-node";
+import {
+  ChangesetConfigReader, ChangesetConfigReaderLive,
+} from "@savvy-web/silk-effects";
+
+const config = await Effect.runPromise(
+  Effect.gen(function* () {
+    const reader = yield* ChangesetConfigReader;
+    return yield* reader.read(process.cwd());
+  }).pipe(
+    Effect.provide(ChangesetConfigReaderLive),
+    Effect.provide(NodeContext.layer),
+  ),
+);
+```
+
+#### ConfigDiscovery
+
+Locate config files using a priority-based search convention. Checks `lib/configs/{name}` (shared configs) first, then `{cwd}/{name}` (local override).
+
+```typescript
+import { Effect } from "effect";
+import { NodeContext } from "@effect/platform-node";
+import { ConfigDiscovery, ConfigDiscoveryLive } from "@savvy-web/silk-effects";
+
+const result = await Effect.runPromise(
+  Effect.gen(function* () {
+    const cd = yield* ConfigDiscovery;
+    return yield* cd.find("biome.jsonc");
+    // => { path: "/project/biome.jsonc", source: "root" } | null
+  }).pipe(
+    Effect.provide(ConfigDiscoveryLive),
+    Effect.provide(NodeContext.layer),
+  ),
+);
+```
+
+#### BiomeSchemaSync
+
+Keep Biome config `$schema` URLs current. Locates `biome.json` or `biome.jsonc`, compares the `$schema` value against the expected URL for the given version, and optionally updates in place. Strips semver range prefixes.
+
+```typescript
+import { Effect } from "effect";
+import { NodeContext } from "@effect/platform-node";
+import { BiomeSchemaSync, BiomeSchemaSyncLive } from "@savvy-web/silk-effects";
+
+await Effect.runPromise(
+  Effect.gen(function* () {
+    const bss = yield* BiomeSchemaSync;
+    const result = yield* bss.sync("2.0.0");
+    // => { updated: true, skipped: false, current: "2.0.0" }
+  }).pipe(
+    Effect.provide(BiomeSchemaSyncLive),
+    Effect.provide(NodeContext.layer),
+  ),
+);
+```
+
+---
+
+### FileSystem + CommandExecutor Layer Required
+
+#### ToolDiscovery
+
+Locate CLI tools globally (PATH) or locally (via package manager), extract versions, enforce constraints, and cache results.
+
+**ToolDefinition** configures how a tool is resolved: `VersionExtractor` (Flag, Json, or None), `ResolutionPolicy` (Report, PreferLocal, PreferGlobal, RequireMatch), and `SourceRequirement` (Any, OnlyLocal, OnlyGlobal, Both). Equality is based on tool name only.
+
+**ResolvedTool** is the result of resolution. It carries the tool's name, source (`"global"` or `"local"`), version, and package manager. Its `exec()` and `dlx()` methods return a **ToolCommand** -- a wrapper around `@effect/platform` `Command` with instance-method ergonomics (`string()`, `lines()`, `exitCode()`, `stream()`).
+
+```typescript
+import { Effect } from "effect";
+import { NodeContext } from "@effect/platform-node";
+import {
+  ToolDiscovery, ToolDiscoveryLive, ToolDefinition,
+} from "@savvy-web/silk-effects";
+
+const output = await Effect.runPromise(
+  Effect.gen(function* () {
+    const td = yield* ToolDiscovery;
+
+    // Resolve a tool (results are cached by name)
+    const biome = yield* td.resolve(ToolDefinition.make({ name: "biome" }));
+
+    // Check availability without throwing
+    const hasBiome = yield* td.isAvailable(ToolDefinition.make({ name: "biome" }));
+
+    // Execute the resolved tool
+    return yield* biome.exec("check", ".").string();
+  }).pipe(
+    Effect.provide(ToolDiscoveryLive),
+    Effect.provide(NodeContext.layer),
+  ),
+);
+```
+
+Use `require()` to fail with a descriptive error if the tool is not found:
+
+```typescript
+const biome = yield* td.require(
+  ToolDefinition.make({ name: "biome" }),
+  "Biome is required for linting",
+);
+```
 
 ## Documentation
 
-For service API reference, schemas, error types, and advanced usage, see [docs/](./docs/).
+For architecture details, service patterns, and design rationale, see the [design documentation](./.claude/design/silk-effects/architecture.md).
 
 ## License
 

package/index.js

@@ -202,7 +202,7 @@ class SectionBlock extends Schema.TaggedClass()("SectionBlock", {
     get rendered() {
         const begin = `${this.commentStyle} --- BEGIN ${this.toolName.toUpperCase()} MANAGED SECTION ---`;
         const end = `${this.commentStyle} --- END ${this.toolName.toUpperCase()} MANAGED SECTION ---`;
-        return `${begin}${this.content}${end}`;
+        return `${begin}\n${this.content}\n${end}`;
     }
     prepend(lines) {
         return SectionBlock.make({
@@ -560,16 +560,19 @@ function parseContent(content, toolName, commentStyle) {
     const beginIndex = content.indexOf(begin);
     const endIndex = content.indexOf(end);
     if (-1 === beginIndex || -1 === endIndex || endIndex <= beginIndex) return null;
+    let managed = content.slice(beginIndex + begin.length, endIndex);
+    if (managed.startsWith("\n")) managed = managed.slice(1);
+    if (managed.endsWith("\n")) managed = managed.slice(0, -1);
     return {
         before: content.slice(0, beginIndex),
-        managed: content.slice(beginIndex + begin.length, endIndex),
+        managed,
         after: content.slice(endIndex + end.length)
     };
 }
 function assembleContent(before, managed, after, toolName, commentStyle) {
     const begin = beginMarker(toolName, commentStyle);
     const end = endMarker(toolName, commentStyle);
-    return `${before}${begin}${managed}${end}${after}`;
+    return `${before}${begin}\n${managed}\n${end}${after}`;
 }
 class ManagedSection extends Context.Tag("@savvy-web/silk-effects/ManagedSection")() {
 }
@@ -614,12 +617,12 @@ const ManagedSectionLive = Layer.effect(ManagedSection, Effect.gen(function*() {
                     const trimmed = raw.trimEnd();
                     const begin = beginMarker(block.toolName, block.commentStyle);
                     const end = endMarker(block.toolName, block.commentStyle);
-                    fileContent = `${trimmed}\n\n${begin}${block.content}${end}\n`;
+                    fileContent = `${trimmed}\n\n${begin}\n${block.content}\n${end}\n`;
                 }
             } else {
                 const begin = beginMarker(block.toolName, block.commentStyle);
                 const end = endMarker(block.toolName, block.commentStyle);
-                fileContent = `${begin}${block.content}${end}\n`;
+                fileContent = `${begin}\n${block.content}\n${end}\n`;
             }
             yield* fs.writeFileString(path, fileContent).pipe(Effect.mapError((cause)=>new SectionWriteError({
                     path,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@savvy-web/silk-effects",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "private": false,
   "description": "Shared Effect library for Silk Suite conventions",
   "homepage": "https://github.com/savvy-web/systems/tree/main/packages/silk-effects",
@@ -30,7 +30,7 @@
     "@effect/platform": "^0.96.0",
     "jsonc-effect": "^0.2.1",
     "semver-effect": "^0.2.1",
-    "workspaces-effect": "^0.2.0",
+    "workspaces-effect": "^0.3.0",
     "yaml-effect": "^0.2.3"
   },
   "peerDependencies": {