@batonfx/skills 0.4.3 → 0.6.0

package/README.md

@@ -1,5 +1,55 @@
 # `@batonfx/skills`
 
-Filesystem and hosted skill sources for Baton agents.
+Focused composition guide for filesystem and hosted skill sources.
 
-See the [Baton documentation](https://github.com/In-Time-Tec/batonfx#readme) for installation, examples, and API guidance.
+## Install
+
+```sh
+bun add effect @effect/platform-bun @batonfx/core @batonfx/skills
+```
+
+## Imports
+
+```ts
+import { SkillSource } from "@batonfx/core"
+import { SkillLoader } from "@batonfx/skills"
+```
+
+## Layer graph
+
+```text
+BunServices.layer
+└─ provides FileSystem + Path
+   └─ SkillLoader.layer({ roots: [] })
+      └─ provides SkillSource.SkillSource
+```
+
+## Runnable program
+
+Checked source: [`../../examples/package-composition-guides/src/skills.ts`](../../examples/package-composition-guides/src/skills.ts)
+
+```ts
+import { Console, Effect, Layer } from "effect"
+import { BunServices } from "@effect/platform-bun"
+import { SkillSource } from "@batonfx/core"
+import { SkillLoader } from "@batonfx/skills"
+
+const skillLayer = SkillLoader.layer({ roots: [] }).pipe(Layer.provide(BunServices.layer))
+
+const program = SkillSource.SkillSource.use((source) =>
+  source.all.pipe(Effect.flatMap((skills) => Console.log(`discovered ${skills.length} skills`))),
+).pipe(Effect.provide(skillLayer))
+
+await Effect.runPromise(program)
+```
+
+Run `bun examples/package-composition-guides/src/skills.ts`.
+
+## Errors, requirements, and resources
+
+`BunServices.layer` provides the `FileSystem` and `Path` requirements used by `SkillLoader.layer`; the composed program has `R = never`, succeeds with `void`, and retains schema-backed `SkillSourceError` for filesystem, parsing, path, and validation failures. The layer owns platform services; this empty-root run performs no concurrent work and uses no timers, detached fibers, or unbounded buffers.
+
+## More
+
+- Current behavior: [Instructions and skills](../../docs/features/instructions-and-skills.md)
+- Deeper example: [capstone local assistant](../../examples/capstone-local-assistant/)

package/dist/github-catalog.d.ts

@@ -10,9 +10,8 @@ export interface Options extends Limits {
     readonly root?: string;
     readonly manifestName?: string;
     readonly apiBaseUrl?: string;
-    readonly source?: string;
 }
 /** @experimental Build a manifest-backed immutable GitHub catalog source. */
 export declare const make: (options: Options) => SkillSource.Source<HttpClient.HttpClient | Crypto.Crypto>;
 /** @experimental Build a manifest-backed immutable GitHub catalog layer. */
-export declare const layer: (options: Options) => import("effect/Layer").Layer<SkillSource.SkillSource, SkillSource.SkillSourceError, HttpClient.HttpClient | Crypto.Crypto>;
+export declare const layer: (options: Options) => import("effect/Layer").Layer<SkillSource.SkillSource, SkillSource.SkillSourceError, Crypto.Crypto | HttpClient.HttpClient>;

package/dist/github-catalog.js

@@ -9,25 +9,29 @@ const encodedPath = (value) => value
     .join("/");
 /** @experimental Build a manifest-backed immutable GitHub catalog source. */
 export const make = (options) => {
-    const source = options.source ?? `github:${options.owner}/${options.repo}@${options.ref}`;
+    const validationSource = "github-skill-catalog";
     if (!/^[0-9a-fA-F]{40}$|^[0-9a-fA-F]{64}$/.test(options.ref)) {
-        return Effect.fail(new SkillSource.SkillSourceError({ source, message: "GitHub skill catalog ref must be a commit id" }));
+        return Effect.fail(SkillSource.SkillSourceError.make({
+            source: validationSource,
+            message: "GitHub skill catalog ref must be a commit id",
+        }));
     }
     if (!/^[A-Za-z0-9](?:[A-Za-z0-9-]{0,37}[A-Za-z0-9])?$/.test(options.owner) ||
         !/^[A-Za-z0-9](?:[A-Za-z0-9._-]{0,98}[A-Za-z0-9])?$/.test(options.repo)) {
-        return Effect.fail(new SkillSource.SkillSourceError({ source, message: "Invalid GitHub owner or repository" }));
+        return Effect.fail(SkillSource.SkillSourceError.make({ source: validationSource, message: "Invalid GitHub owner or repository" }));
     }
+    const source = `github:${options.owner}/${options.repo}@${options.ref}`;
     return Effect.gen(function* () {
         if ((options.root?.length ?? 0) > 0)
             yield* validateSkillPath(source, options.root ?? "");
         yield* validateSkillPath(source, options.manifestName ?? "skills.json");
-        const apiBase = yield* Effect.fromResult(Url.fromString(options.apiBaseUrl ?? "https://api.github.com")).pipe(Effect.mapError((cause) => new SkillSource.SkillSourceError({ source, message: "Invalid GitHub API base URL", cause })));
+        const apiBase = yield* Effect.fromResult(Url.fromString(options.apiBaseUrl ?? "https://api.github.com")).pipe(Effect.mapError(() => SkillSource.SkillSourceError.make({ source, message: "Invalid GitHub API base URL" })));
         if (apiBase.protocol !== "https:" ||
             apiBase.username.length > 0 ||
             apiBase.password.length > 0 ||
             apiBase.search.length > 0 ||
             apiBase.hash.length > 0) {
-            return yield* Effect.fail(new SkillSource.SkillSourceError({ source, message: "Invalid GitHub API base URL" }));
+            return yield* SkillSource.SkillSourceError.make({ source, message: "Invalid GitHub API base URL" });
         }
         const base = apiBase.toString().replace(/\/$/, "");
         const root = encodedPath(options.root ?? "");
@@ -40,7 +44,7 @@ export const make = (options) => {
             "x-github-api-version": "2022-11-28",
         };
         return yield* makeHostedCatalog({
-            ...options,
+            limits: options,
             source,
             manifestUrl,
             manifestHeaders: headers,

package/dist/hosted-catalog.d.ts

@@ -1,43 +1,6 @@
-import { Crypto, Effect, Layer, Schema } from "effect";
+import { Crypto, Effect } from "effect";
 import { HttpClient } from "effect/unstable/http";
 import { SkillSource } from "@batonfx/core";
-/** @experimental Baton hosted skill manifest entry. */
-export declare const ManifestSkill: Schema.Struct<{
-    readonly name: Schema.String;
-    readonly description: Schema.String;
-    readonly skillPath: Schema.String;
-    readonly sha256: Schema.String;
-    readonly whenToUse: Schema.optionalKey<Schema.String>;
-    readonly allowedTools: Schema.optionalKey<Schema.$Array<Schema.String>>;
-    readonly disableModelInvocation: Schema.optionalKey<Schema.Boolean>;
-    readonly userInvocable: Schema.optionalKey<Schema.Boolean>;
-    readonly contextFork: Schema.optionalKey<Schema.Boolean>;
-    readonly agent: Schema.optionalKey<Schema.String>;
-    readonly model: Schema.optionalKey<Schema.String>;
-    readonly paths: Schema.optionalKey<Schema.$Array<Schema.String>>;
-}>;
-/** @experimental */
-export type ManifestSkill = typeof ManifestSkill.Type;
-/** @experimental Baton hosted skill manifest. */
-export declare const Manifest: Schema.Struct<{
-    readonly version: Schema.Literal<1>;
-    readonly skills: Schema.$Array<Schema.Struct<{
-        readonly name: Schema.String;
-        readonly description: Schema.String;
-        readonly skillPath: Schema.String;
-        readonly sha256: Schema.String;
-        readonly whenToUse: Schema.optionalKey<Schema.String>;
-        readonly allowedTools: Schema.optionalKey<Schema.$Array<Schema.String>>;
-        readonly disableModelInvocation: Schema.optionalKey<Schema.Boolean>;
-        readonly userInvocable: Schema.optionalKey<Schema.Boolean>;
-        readonly contextFork: Schema.optionalKey<Schema.Boolean>;
-        readonly agent: Schema.optionalKey<Schema.String>;
-        readonly model: Schema.optionalKey<Schema.String>;
-        readonly paths: Schema.optionalKey<Schema.$Array<Schema.String>>;
-    }>>;
-}>;
-/** @experimental */
-export type Manifest = typeof Manifest.Type;
 /** @experimental Shared hosted-catalog limits and trusted tools. */
 export interface Limits {
     readonly manifestMaxBytes?: number;
@@ -46,8 +9,8 @@ export interface Limits {
     readonly descriptionCap?: number;
     readonly toolsBySkill?: Readonly<Record<string, ReadonlyArray<SkillSource.Skill["tools"][number]>>>;
 }
-/** @experimental Internal hosted-catalog construction options. */
-export interface MakeOptions extends Limits {
+interface MakeOptions {
+    readonly limits: Limits;
     readonly source: string;
     readonly manifestUrl: string;
     readonly resolveSkillUrl: (skillPath: string) => Effect.Effect<string, SkillSource.SkillSourceError>;
@@ -55,10 +18,15 @@ export interface MakeOptions extends Limits {
     readonly bodyHeaders?: Readonly<Record<string, string>>;
 }
 /** @experimental Validate one safe relative SKILL.md path. */
-export declare const validateSkillPath: (source: string, skillPath: string) => Effect.Effect<string, SkillSource.SkillSourceError>;
+export declare const validateSkillPath: {
+    (skillPath: string): (source: string) => Effect.Effect<string, SkillSource.SkillSourceError>;
+    (source: string, skillPath: string): Effect.Effect<string, SkillSource.SkillSourceError>;
+};
 /** @experimental Resolve a same-origin path beneath a manifest directory. */
-export declare const resolveRelative: (source: string, manifestUrl: string, skillPath: string) => Effect.Effect<string, SkillSource.SkillSourceError>;
+export declare const resolveRelative: {
+    (manifestUrl: string, skillPath: string): (source: string) => Effect.Effect<string, SkillSource.SkillSourceError>;
+    (source: string, manifestUrl: string, skillPath: string): Effect.Effect<string, SkillSource.SkillSourceError>;
+};
 /** @experimental Build a hosted manifest source over Effect HTTP and Crypto services. */
 export declare const make: (options: MakeOptions) => SkillSource.Source<HttpClient.HttpClient | Crypto.Crypto>;
-/** @experimental One-source hosted catalog layer. */
-export declare const layer: (options: MakeOptions) => Layer.Layer<SkillSource.SkillSource, SkillSource.SkillSourceError, HttpClient.HttpClient | Crypto.Crypto>;
+export {};

package/dist/hosted-catalog.js

@@ -1,9 +1,8 @@
-import { Crypto, Effect, Encoding, Layer, Schema, Stream } from "effect";
+import { Crypto, Effect, Encoding, Function, Schema, Stream } from "effect";
 import { HttpClient, HttpClientRequest, HttpClientResponse, Url } from "effect/unstable/http";
 import { SkillSource } from "@batonfx/core";
 import { parseDocument, validateName } from "./skill-document.js";
-/** @experimental Baton hosted skill manifest entry. */
-export const ManifestSkill = Schema.Struct({
+const ManifestSkill = Schema.Struct({
     name: Schema.String,
     description: Schema.String,
     skillPath: Schema.String,
@@ -17,13 +16,12 @@ export const ManifestSkill = Schema.Struct({
     model: Schema.optionalKey(Schema.String),
     paths: Schema.optionalKey(Schema.Array(Schema.String)),
 });
-/** @experimental Baton hosted skill manifest. */
-export const Manifest = Schema.Struct({
+const Manifest = Schema.Struct({
     version: Schema.Literal(1),
     skills: Schema.Array(ManifestSkill),
 });
 const decoder = new TextDecoder("utf-8", { fatal: true });
-const sourceError = (source, message, cause) => new SkillSource.SkillSourceError({ source, message, ...(cause === undefined ? {} : { cause }) });
+const sourceError = (source, message, cause) => SkillSource.SkillSourceError.make({ source, message, ...(cause === undefined ? {} : { cause }) });
 const safeInteger = (source, name, value, minimum) => Number.isSafeInteger(value) && value >= minimum
     ? Effect.succeed(value)
     : Effect.fail(sourceError(source, `${name} must be a safe integer >= ${minimum}`));
@@ -33,7 +31,7 @@ const request = (url, headers) => {
         value = HttpClientRequest.setHeader(value, name, header);
     return value;
 };
-const fetchBytes = (client, source, url, headers, maxBytes) => client.execute(request(url, headers)).pipe(Effect.flatMap(HttpClientResponse.filterStatusOk), Effect.mapError((error) => sourceError(source, "Hosted skill request failed", error)), Effect.flatMap((response) => response.stream.pipe(Stream.mapError((error) => sourceError(source, "Hosted skill request failed", error)), Stream.runFoldEffect(() => ({ size: 0, chunks: [] }), (state, chunk) => {
+const fetchBytes = (client, source, url, headers, maxBytes) => client.execute(request(url, headers)).pipe(Effect.flatMap(HttpClientResponse.filterStatusOk), Effect.mapError(() => sourceError(source, "Hosted skill request failed")), Effect.flatMap((response) => response.stream.pipe(Stream.mapError(() => sourceError(source, "Hosted skill request failed")), Stream.runFoldEffect(() => ({ size: 0, chunks: [] }), (state, chunk) => {
     const size = state.size + chunk.byteLength;
     if (size > maxBytes) {
         return Effect.fail(sourceError(source, `Hosted skill response exceeds ${maxBytes} bytes`));
@@ -67,7 +65,7 @@ const frontmatter = (entry) => ({
 });
 const sameFrontmatter = (left, right) => JSON.stringify(left) === JSON.stringify(right);
 /** @experimental Validate one safe relative SKILL.md path. */
-export const validateSkillPath = (source, skillPath) => {
+export const validateSkillPath = Function.dual(2, (source, skillPath) => {
     const segments = skillPath.split("/");
     return skillPath.length > 0 &&
         !skillPath.startsWith("/") &&
@@ -77,48 +75,48 @@ export const validateSkillPath = (source, skillPath) => {
         !skillPath.includes("#") &&
         segments.every((segment) => segment.length > 0 && segment !== "." && segment !== "..")
         ? Effect.succeed(skillPath)
-        : Effect.fail(sourceError(source, `Unsafe hosted skill path: ${skillPath}`));
-};
+        : Effect.fail(sourceError(source, "Unsafe hosted skill path"));
+});
 /** @experimental Resolve a same-origin path beneath a manifest directory. */
-export const resolveRelative = (source, manifestUrl, skillPath) => Effect.gen(function* () {
+export const resolveRelative = Function.dual(3, (source, manifestUrl, skillPath) => Effect.gen(function* () {
     yield* validateSkillPath(source, skillPath);
-    const manifest = yield* Effect.fromResult(Url.fromString(manifestUrl)).pipe(Effect.mapError((error) => sourceError(source, "Invalid manifest URL", error)));
-    const directory = yield* Effect.fromResult(Url.fromString(".", manifest)).pipe(Effect.mapError((error) => sourceError(source, "Invalid manifest directory URL", error)));
-    const resolved = yield* Effect.fromResult(Url.fromString(skillPath, directory)).pipe(Effect.mapError((error) => sourceError(source, "Invalid hosted skill URL", error)));
+    const manifest = yield* Effect.fromResult(Url.fromString(manifestUrl)).pipe(Effect.mapError(() => sourceError(source, "Invalid manifest URL")));
+    const directory = yield* Effect.fromResult(Url.fromString(".", manifest)).pipe(Effect.mapError(() => sourceError(source, "Invalid manifest directory URL")));
+    const resolved = yield* Effect.fromResult(Url.fromString(skillPath, directory)).pipe(Effect.mapError(() => sourceError(source, "Invalid hosted skill URL")));
     if (resolved.origin !== manifest.origin || !resolved.pathname.startsWith(directory.pathname)) {
-        return yield* Effect.fail(sourceError(source, `Hosted skill path escapes manifest directory: ${skillPath}`));
+        return yield* sourceError(source, "Hosted skill path escapes manifest directory");
     }
     return resolved.toString();
-});
+}));
 /** @experimental Build a hosted manifest source over Effect HTTP and Crypto services. */
 export const make = (options) => Effect.gen(function* () {
     const client = yield* HttpClient.HttpClient;
     const crypto = yield* Crypto.Crypto;
-    const manifestMaxBytes = yield* safeInteger(options.source, "manifestMaxBytes", options.manifestMaxBytes ?? 1024 * 1024, 1);
-    const bodyMaxBytes = yield* safeInteger(options.source, "bodyMaxBytes", options.bodyMaxBytes ?? 1024 * 1024, 1);
-    const maxSkills = yield* safeInteger(options.source, "maxSkills", options.maxSkills ?? 1_000, 1);
-    const descriptionCap = yield* safeInteger(options.source, "descriptionCap", options.descriptionCap ?? SkillSource.DESCRIPTION_CAP, 0);
+    const manifestMaxBytes = yield* safeInteger(options.source, "manifestMaxBytes", options.limits.manifestMaxBytes ?? 1024 * 1024, 1);
+    const bodyMaxBytes = yield* safeInteger(options.source, "bodyMaxBytes", options.limits.bodyMaxBytes ?? 1024 * 1024, 1);
+    const maxSkills = yield* safeInteger(options.source, "maxSkills", options.limits.maxSkills ?? 1_000, 1);
+    const descriptionCap = yield* safeInteger(options.source, "descriptionCap", options.limits.descriptionCap ?? SkillSource.DESCRIPTION_CAP, 0);
     const manifestBytes = yield* fetchBytes(client, options.source, options.manifestUrl, options.manifestHeaders, manifestMaxBytes);
     const manifestText = yield* decodeText(options.source, manifestBytes);
     const manifest = yield* Schema.decodeUnknownEffect(Schema.fromJsonString(Manifest))(manifestText).pipe(Effect.mapError((error) => sourceError(options.source, "Invalid hosted skill manifest", error)));
     if (manifest.skills.length > maxSkills) {
-        return yield* Effect.fail(sourceError(options.source, `Hosted skill manifest exceeds ${maxSkills} skills`));
+        return yield* sourceError(options.source, `Hosted skill manifest exceeds ${maxSkills} skills`);
     }
     const byName = new Map();
     for (const entry of manifest.skills) {
         yield* validateName(options.source, entry.name);
         if (entry.description.length === 0 || entry.description.length > 1_024) {
-            return yield* Effect.fail(sourceError(options.source, "Hosted skill description must contain 1-1024 characters"));
+            return yield* sourceError(options.source, "Hosted skill description must contain 1-1024 characters");
         }
         if (!/^[0-9a-f]{64}$/.test(entry.sha256)) {
-            return yield* Effect.fail(sourceError(options.source, `Invalid SHA-256 for hosted skill ${entry.name}`));
+            return yield* sourceError(options.source, `Invalid SHA-256 for hosted skill ${entry.name}`);
         }
         if (byName.has(entry.name)) {
-            return yield* Effect.fail(sourceError(options.source, `Duplicate hosted skill name: ${entry.name}`));
+            return yield* sourceError(options.source, `Duplicate hosted skill name: ${entry.name}`);
         }
         const pathSegments = entry.skillPath.split("/");
         if (pathSegments.at(-1) !== "SKILL.md" || pathSegments.at(-2) !== entry.name) {
-            return yield* Effect.fail(sourceError(options.source, `Hosted skill path directory must match skill name: ${entry.name}`));
+            return yield* sourceError(options.source, `Hosted skill path directory must match skill name: ${entry.name}`);
         }
         const skillUrl = yield* options.resolveSkillUrl(entry.skillPath);
         const metadata = frontmatter(entry);
@@ -127,8 +125,8 @@ export const make = (options) => Effect.gen(function* () {
             : Effect.fail(sourceError(options.source, `SHA-256 mismatch for hosted skill ${entry.name}`))))), Effect.flatMap((content) => parseDocument(options.source, content, entry.name).pipe(Effect.flatMap((document) => sameFrontmatter(document.frontmatter, metadata)
             ? Effect.succeed(document.body)
             : Effect.fail(sourceError(options.source, `Frontmatter mismatch for hosted skill ${entry.name}`))))));
-        const tools = options.toolsBySkill !== undefined && Object.hasOwn(options.toolsBySkill, entry.name)
-            ? (options.toolsBySkill[entry.name] ?? [])
+        const tools = options.limits.toolsBySkill !== undefined && Object.hasOwn(options.limits.toolsBySkill, entry.name)
+            ? (options.limits.toolsBySkill[entry.name] ?? [])
             : [];
         byName.set(entry.name, {
             frontmatter: metadata,
@@ -143,5 +141,3 @@ export const make = (options) => Effect.gen(function* () {
         get: (name) => Effect.succeed(byName.get(name)),
     };
 });
-/** @experimental One-source hosted catalog layer. */
-export const layer = (options) => Layer.effect(SkillSource.SkillSource, make(options).pipe(Effect.map(SkillSource.SkillSource.of)));

package/dist/http-catalog.d.ts

@@ -5,9 +5,8 @@ import { type Limits } from "./hosted-catalog.js";
 /** @experimental Generic HTTP skill catalog options. */
 export interface Options extends Limits {
     readonly manifestUrl: string;
-    readonly source?: string;
 }
 /** @experimental Build a generic HTTP catalog source. */
 export declare const make: (options: Options) => SkillSource.Source<HttpClient.HttpClient | Crypto.Crypto>;
 /** @experimental Build a generic HTTP catalog layer. */
-export declare const layer: (options: Options) => import("effect/Layer").Layer<SkillSource.SkillSource, SkillSource.SkillSourceError, HttpClient.HttpClient | Crypto.Crypto>;
+export declare const layer: (options: Options) => import("effect/Layer").Layer<SkillSource.SkillSource, SkillSource.SkillSourceError, Crypto.Crypto | HttpClient.HttpClient>;

package/dist/http-catalog.js

@@ -2,18 +2,17 @@ import { Crypto, Effect } from "effect";
 import { HttpClient, Url } from "effect/unstable/http";
 import { SkillSource } from "@batonfx/core";
 import { make as makeHostedCatalog, resolveRelative } from "./hosted-catalog.js";
-const invalidUrl = (cause) => new SkillSource.SkillSourceError({ source: "http-skill-catalog", message: "Invalid manifest URL", cause });
+const invalidUrl = () => SkillSource.SkillSourceError.make({ source: "http-skill-catalog", message: "Invalid manifest URL" });
 /** @experimental Build a generic HTTP catalog source. */
-export const make = (options) => {
-    return Effect.gen(function* () {
-        const parsed = yield* Effect.fromResult(Url.fromString(options.manifestUrl)).pipe(Effect.mapError(invalidUrl));
-        const source = options.source ?? `${parsed.origin}${parsed.pathname}`;
-        return yield* makeHostedCatalog({
-            ...options,
-            source,
-            resolveSkillUrl: (skillPath) => resolveRelative(source, options.manifestUrl, skillPath),
-        });
+export const make = (options) => Effect.gen(function* () {
+    const parsed = yield* Effect.fromResult(Url.fromString(options.manifestUrl)).pipe(Effect.mapError(invalidUrl));
+    const source = `${parsed.origin}${parsed.pathname}`;
+    return yield* makeHostedCatalog({
+        limits: options,
+        source,
+        manifestUrl: options.manifestUrl,
+        resolveSkillUrl: (skillPath) => resolveRelative(source, options.manifestUrl, skillPath),
     });
-};
+});
 /** @experimental Build a generic HTTP catalog layer. */
 export const layer = (options) => SkillSource.layer([make(options)]);

package/dist/index.d.ts

@@ -1,5 +1,4 @@
 export * as GitHubCatalog from "./github-catalog.js";
-export * as HostedCatalog from "./hosted-catalog.js";
 export * as HttpCatalog from "./http-catalog.js";
 export * as InstructionFiles from "./instructions-files.js";
 export * as S3Catalog from "./s3-catalog.js";

package/dist/index.js

@@ -1,5 +1,4 @@
 export * as GitHubCatalog from "./github-catalog.js";
-export * as HostedCatalog from "./hosted-catalog.js";
 export * as HttpCatalog from "./http-catalog.js";
 export * as InstructionFiles from "./instructions-files.js";
 export * as S3Catalog from "./s3-catalog.js";

package/dist/s3-catalog.d.ts

@@ -8,9 +8,8 @@ export interface Options extends Limits {
     readonly region: string;
     readonly prefix?: string;
     readonly manifestName?: string;
-    readonly source?: string;
 }
 /** @experimental Build a manifest-backed S3 catalog source. */
 export declare const make: (options: Options) => SkillSource.Source<HttpClient.HttpClient | Crypto.Crypto>;
 /** @experimental Build a manifest-backed S3 catalog layer. */
-export declare const layer: (options: Options) => import("effect/Layer").Layer<SkillSource.SkillSource, SkillSource.SkillSourceError, HttpClient.HttpClient | Crypto.Crypto>;
+export declare const layer: (options: Options) => import("effect/Layer").Layer<SkillSource.SkillSource, SkillSource.SkillSourceError, Crypto.Crypto | HttpClient.HttpClient>;

package/dist/s3-catalog.js

@@ -9,20 +9,24 @@ const segments = (value) => value
     .join("/");
 /** @experimental Build a manifest-backed S3 catalog source. */
 export const make = (options) => {
-    const source = options.source ?? `s3://${options.bucket}/${options.prefix ?? ""}`;
+    const validationSource = "s3-skill-catalog";
     if (!/^[a-z0-9](?:[a-z0-9-]{1,61})[a-z0-9]$/.test(options.bucket) ||
         !/^[a-z0-9](?:[a-z0-9-]*[a-z0-9])$/.test(options.region)) {
-        return Effect.fail(new SkillSource.SkillSourceError({ source, message: "Invalid S3 bucket or region for hosted skill catalog" }));
+        return Effect.fail(SkillSource.SkillSourceError.make({
+            source: validationSource,
+            message: "Invalid S3 bucket or region for hosted skill catalog",
+        }));
     }
     return Effect.gen(function* () {
         if ((options.prefix?.length ?? 0) > 0)
-            yield* validateSkillPath(source, options.prefix ?? "");
+            yield* validateSkillPath(validationSource, options.prefix ?? "");
+        const source = `s3://${options.bucket}/${options.prefix ?? ""}`;
         yield* validateSkillPath(source, options.manifestName ?? "skills.json");
         const prefix = segments(options.prefix ?? "");
         const manifestName = segments(options.manifestName ?? "skills.json");
         const manifestUrl = `https://${options.bucket}.s3.${options.region}.amazonaws.com/${prefix.length === 0 ? "" : `${prefix}/`}${manifestName}`;
         return yield* makeHostedCatalog({
-            ...options,
+            limits: options,
             source,
             manifestUrl,
             resolveSkillUrl: (skillPath) => resolveRelative(source, manifestUrl, skillPath),

package/dist/skill-document.d.ts

@@ -4,7 +4,19 @@ export interface ParsedDocument {
     readonly frontmatter: SkillSource.Frontmatter;
     readonly body: string;
 }
-export declare const splitDocument: (source: string, content: string) => Effect.Effect<readonly [string, string], SkillSource.SkillSourceError>;
-export declare const validateName: (source: string, name: string) => Effect.Effect<string, SkillSource.SkillSourceError>;
-export declare const parseFrontmatter: (source: string, block: string, directoryName: string) => Effect.Effect<SkillSource.Frontmatter, SkillSource.SkillSourceError>;
-export declare const parseDocument: (source: string, content: string, directoryName: string) => Effect.Effect<ParsedDocument, SkillSource.SkillSourceError>;
+export declare const splitDocument: {
+    (content: string): (source: string) => Effect.Effect<readonly [string, string], SkillSource.SkillSourceError>;
+    (source: string, content: string): Effect.Effect<readonly [string, string], SkillSource.SkillSourceError>;
+};
+export declare const validateName: {
+    (name: string): (source: string) => Effect.Effect<string, SkillSource.SkillSourceError>;
+    (source: string, name: string): Effect.Effect<string, SkillSource.SkillSourceError>;
+};
+export declare const parseFrontmatter: {
+    (block: string, directoryName: string): (source: string) => Effect.Effect<SkillSource.Frontmatter, SkillSource.SkillSourceError>;
+    (source: string, block: string, directoryName: string): Effect.Effect<SkillSource.Frontmatter, SkillSource.SkillSourceError>;
+};
+export declare const parseDocument: {
+    (content: string, directoryName: string): (source: string) => Effect.Effect<ParsedDocument, SkillSource.SkillSourceError>;
+    (source: string, content: string, directoryName: string): Effect.Effect<ParsedDocument, SkillSource.SkillSourceError>;
+};

package/dist/skill-document.js

@@ -1,6 +1,6 @@
-import { Effect } from "effect";
+import { Effect, Function } from "effect";
 import { SkillSource } from "@batonfx/core";
-const sourceError = (source, message, cause) => new SkillSource.SkillSourceError({ source, message, ...(cause === undefined ? {} : { cause }) });
+const sourceError = (source, message, cause) => SkillSource.SkillSourceError.make({ source, message, ...(cause === undefined ? {} : { cause }) });
 const normalizeKey = (key) => key.replace(/[-_]/g, "").toLowerCase();
 const stripQuotes = (value) => {
     const trimmed = value.trim();
@@ -98,32 +98,32 @@ const parseHeader = (source, block) => Effect.sync(() => {
     }
     return parsed;
 }).pipe(Effect.catchCause((cause) => Effect.fail(sourceError(source, "Invalid SKILL.md frontmatter", cause))));
-export const splitDocument = (source, content) => Effect.gen(function* () {
+export const splitDocument = Function.dual(2, (source, content) => Effect.gen(function* () {
     const normalized = content.replace(/^\uFEFF/, "").replace(/\r\n/g, "\n");
     const lines = normalized.split("\n");
     if (lines[0] !== "---") {
-        return yield* Effect.fail(sourceError(source, "Invalid SKILL.md document: missing opening frontmatter fence"));
+        return yield* sourceError(source, "Invalid SKILL.md document: missing opening frontmatter fence");
     }
     const close = lines.findIndex((line, index) => index > 0 && line === "---");
     if (close === -1) {
-        return yield* Effect.fail(sourceError(source, "Invalid SKILL.md document: missing closing frontmatter fence"));
+        return yield* sourceError(source, "Invalid SKILL.md document: missing closing frontmatter fence");
     }
     return [lines.slice(1, close).join("\n"), lines.slice(close + 1).join("\n")];
-});
-export const validateName = (source, name) => /^[a-z0-9](?:[a-z0-9-]{0,62}[a-z0-9])?$/.test(name) && !name.includes("--")
+}));
+export const validateName = Function.dual(2, (source, name) => /^[a-z0-9](?:[a-z0-9-]{0,62}[a-z0-9])?$/.test(name) && !name.includes("--")
     ? Effect.succeed(name)
-    : Effect.fail(sourceError(source, "SKILL.md name must be 1-64 lowercase alphanumeric or single-hyphen-separated characters"));
-export const parseFrontmatter = (source, block, directoryName) => Effect.gen(function* () {
+    : Effect.fail(sourceError(source, "SKILL.md name must be 1-64 lowercase alphanumeric or single-hyphen-separated characters")));
+export const parseFrontmatter = Function.dual(3, (source, block, directoryName) => Effect.gen(function* () {
     const parsed = yield* parseHeader(source, block);
     if (parsed.name === undefined) {
-        return yield* Effect.fail(sourceError(source, "SKILL.md frontmatter requires name"));
+        return yield* sourceError(source, "SKILL.md frontmatter requires name");
     }
     yield* validateName(source, parsed.name);
     if (parsed.name !== directoryName) {
-        return yield* Effect.fail(sourceError(source, `SKILL.md name must match directory ${directoryName}`));
+        return yield* sourceError(source, `SKILL.md name must match directory ${directoryName}`);
     }
     if (parsed.description === undefined || parsed.description.length === 0 || parsed.description.length > 1_024) {
-        return yield* Effect.fail(sourceError(source, "SKILL.md description must contain 1-1024 characters"));
+        return yield* sourceError(source, "SKILL.md description must contain 1-1024 characters");
     }
     return {
         name: parsed.name,
@@ -137,8 +137,8 @@ export const parseFrontmatter = (source, block, directoryName) => Effect.gen(fun
         ...(parsed.model === undefined ? {} : { model: parsed.model }),
         ...(parsed.paths === undefined ? {} : { paths: parsed.paths }),
     };
-});
-export const parseDocument = (source, content, directoryName) => Effect.gen(function* () {
+}));
+export const parseDocument = Function.dual(3, (source, content, directoryName) => Effect.gen(function* () {
     const [header, body] = yield* splitDocument(source, content);
     return { frontmatter: yield* parseFrontmatter(source, header, directoryName), body };
-});
+}));

package/dist/skill-loader.js

@@ -3,7 +3,7 @@ import { SkillSource } from "@batonfx/core";
 import { parseDocument, parseFrontmatter, splitDocument } from "./skill-document.js";
 const DEFAULT_ROOTS = [".agents/skills", ".claude/skills", ".pi/skills"];
 const decoder = new TextDecoder();
-const sourceError = (source, message, cause) => new SkillSource.SkillSourceError({ source, message, ...(cause === undefined ? {} : { cause }) });
+const sourceError = (source, message, cause) => SkillSource.SkillSourceError.make({ source, message, ...(cause === undefined ? {} : { cause }) });
 const mapPlatformError = (source, error) => sourceError(source, error.message, error);
 const readHeader = (fs, source, bytes) => fs.stream(source, { bytesToRead: bytes, chunkSize: bytes }).pipe(Stream.runFold(() => "", (content, chunk) => `${content}${decoder.decode(chunk)}`), Effect.mapError((error) => mapPlatformError(source, error)));
 const loadSkill = (fs, path, file, relativeFile, descriptionCap, frontmatterMaxBytes) => Effect.gen(function* () {

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@batonfx/skills",
-  "version": "0.4.3",
+  "version": "0.6.0",
   "private": false,
   "type": "module",
   "exports": {
@@ -17,13 +17,13 @@
     "typecheck": "bun tsc --noEmit"
   },
   "dependencies": {
-    "@batonfx/core": "0.4.3",
+    "@batonfx/core": "0.6.0",
     "effect": "4.0.0-beta.93"
   },
   "devDependencies": {
     "@effect/vitest": "4.0.0-beta.93",
     "@types/bun": "1.3.13",
-    "typescript": "5.8.2",
+    "typescript": "7.0.2",
     "vitest": "4.0.16"
   },
   "description": "Filesystem and hosted skill sources for Baton agents",