@batonfx/skills 0.4.0 → 0.4.2

package/src/hosted-catalog.ts

@@ -1,270 +0,0 @@
-import { Crypto, Effect, Encoding, Layer, Schema, Stream } from "effect"
-import { HttpClient, HttpClientRequest, HttpClientResponse, Url } from "effect/unstable/http"
-import { SkillSource } from "@batonfx/core"
-import { parseDocument, validateName } from "./skill-document"
-
-/** @experimental Baton hosted skill manifest entry. */
-export const ManifestSkill = Schema.Struct({
-  name: Schema.String,
-  description: Schema.String,
-  skillPath: Schema.String,
-  sha256: Schema.String,
-  whenToUse: Schema.optionalKey(Schema.String),
-  allowedTools: Schema.optionalKey(Schema.Array(Schema.String)),
-  disableModelInvocation: Schema.optionalKey(Schema.Boolean),
-  userInvocable: Schema.optionalKey(Schema.Boolean),
-  contextFork: Schema.optionalKey(Schema.Boolean),
-  agent: Schema.optionalKey(Schema.String),
-  model: Schema.optionalKey(Schema.String),
-  paths: Schema.optionalKey(Schema.Array(Schema.String)),
-})
-
-/** @experimental */
-export type ManifestSkill = typeof ManifestSkill.Type
-
-/** @experimental Baton hosted skill manifest. */
-export const Manifest = Schema.Struct({
-  version: Schema.Literal(1),
-  skills: Schema.Array(ManifestSkill),
-})
-
-/** @experimental */
-export type Manifest = typeof Manifest.Type
-
-/** @experimental Shared hosted-catalog limits and trusted tools. */
-export interface Limits {
-  readonly manifestMaxBytes?: number
-  readonly bodyMaxBytes?: number
-  readonly maxSkills?: number
-  readonly descriptionCap?: number
-  readonly toolsBySkill?: Readonly<Record<string, ReadonlyArray<SkillSource.Skill["tools"][number]>>>
-}
-
-/** @experimental Internal hosted-catalog construction options. */
-export interface MakeOptions extends Limits {
-  readonly source: string
-  readonly manifestUrl: string
-  readonly resolveSkillUrl: (skillPath: string) => Effect.Effect<string, SkillSource.SkillSourceError>
-  readonly manifestHeaders?: Readonly<Record<string, string>>
-  readonly bodyHeaders?: Readonly<Record<string, string>>
-}
-
-const decoder = new TextDecoder("utf-8", { fatal: true })
-
-const sourceError = (source: string, message: string, cause?: unknown): SkillSource.SkillSourceError =>
-  new SkillSource.SkillSourceError({ source, message, ...(cause === undefined ? {} : { cause }) })
-
-const safeInteger = (
-  source: string,
-  name: string,
-  value: number,
-  minimum: number,
-): Effect.Effect<number, SkillSource.SkillSourceError> =>
-  Number.isSafeInteger(value) && value >= minimum
-    ? Effect.succeed(value)
-    : Effect.fail(sourceError(source, `${name} must be a safe integer >= ${minimum}`))
-
-const request = (url: string, headers: Readonly<Record<string, string>> | undefined) => {
-  let value = HttpClientRequest.get(url)
-  for (const [name, header] of Object.entries(headers ?? {})) value = HttpClientRequest.setHeader(value, name, header)
-  return value
-}
-
-const fetchBytes = (
-  client: HttpClient.HttpClient,
-  source: string,
-  url: string,
-  headers: Readonly<Record<string, string>> | undefined,
-  maxBytes: number,
-): Effect.Effect<Uint8Array, SkillSource.SkillSourceError> =>
-  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: [] as Array<Uint8Array> }),
-          (state, chunk) => {
-            const size = state.size + chunk.byteLength
-            if (size > maxBytes) {
-              return Effect.fail(sourceError(source, `Hosted skill response exceeds ${maxBytes} bytes`))
-            }
-            state.chunks.push(chunk)
-            return Effect.succeed({ size, chunks: state.chunks })
-          },
-        ),
-        Effect.map(({ chunks, size }) => {
-          const bytes = new Uint8Array(size)
-          let offset = 0
-          for (const chunk of chunks) {
-            bytes.set(chunk, offset)
-            offset += chunk.byteLength
-          }
-          return bytes
-        }),
-      ),
-    ),
-  )
-
-const decodeText = (source: string, bytes: Uint8Array): Effect.Effect<string, SkillSource.SkillSourceError> =>
-  Effect.try({
-    try: () => decoder.decode(bytes),
-    catch: (cause) => sourceError(source, "Hosted skill response is not valid UTF-8", cause),
-  })
-
-const frontmatter = (entry: ManifestSkill): SkillSource.Frontmatter => ({
-  name: entry.name,
-  description: entry.description,
-  ...(entry.whenToUse === undefined ? {} : { whenToUse: entry.whenToUse }),
-  ...(entry.allowedTools === undefined ? {} : { allowedTools: entry.allowedTools }),
-  ...(entry.disableModelInvocation === undefined ? {} : { disableModelInvocation: entry.disableModelInvocation }),
-  ...(entry.userInvocable === undefined ? {} : { userInvocable: entry.userInvocable }),
-  ...(entry.contextFork === undefined ? {} : { contextFork: entry.contextFork }),
-  ...(entry.agent === undefined ? {} : { agent: entry.agent }),
-  ...(entry.model === undefined ? {} : { model: entry.model }),
-  ...(entry.paths === undefined ? {} : { paths: entry.paths }),
-})
-
-const sameFrontmatter = (left: SkillSource.Frontmatter, right: SkillSource.Frontmatter): boolean =>
-  JSON.stringify(left) === JSON.stringify(right)
-
-/** @experimental Validate one safe relative SKILL.md path. */
-export const validateSkillPath = (
-  source: string,
-  skillPath: string,
-): Effect.Effect<string, SkillSource.SkillSourceError> => {
-  const segments = skillPath.split("/")
-  return skillPath.length > 0 &&
-    !skillPath.startsWith("/") &&
-    !skillPath.includes("\\") &&
-    !skillPath.includes("%") &&
-    !skillPath.includes("?") &&
-    !skillPath.includes("#") &&
-    segments.every((segment) => segment.length > 0 && segment !== "." && segment !== "..")
-    ? Effect.succeed(skillPath)
-    : Effect.fail(sourceError(source, `Unsafe hosted skill path: ${skillPath}`))
-}
-
-/** @experimental Resolve a same-origin path beneath a manifest directory. */
-export const resolveRelative = (
-  source: string,
-  manifestUrl: string,
-  skillPath: string,
-): Effect.Effect<string, SkillSource.SkillSourceError> =>
-  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)),
-    )
-    if (resolved.origin !== manifest.origin || !resolved.pathname.startsWith(directory.pathname)) {
-      return yield* Effect.fail(sourceError(source, `Hosted skill path escapes manifest directory: ${skillPath}`))
-    }
-    return resolved.toString()
-  })
-
-/** @experimental Build a hosted manifest source over Effect HTTP and Crypto services. */
-export const make = (options: MakeOptions): SkillSource.Source<HttpClient.HttpClient | Crypto.Crypto> =>
-  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 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`))
-    }
-    const byName = new Map<string, SkillSource.Skill>()
-    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"),
-        )
-      }
-      if (!/^[0-9a-f]{64}$/.test(entry.sha256)) {
-        return yield* Effect.fail(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}`))
-      }
-      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}`),
-        )
-      }
-      const skillUrl = yield* options.resolveSkillUrl(entry.skillPath)
-      const metadata = frontmatter(entry)
-      const body = fetchBytes(client, options.source, skillUrl, options.bodyHeaders, bodyMaxBytes).pipe(
-        Effect.flatMap((bytes) =>
-          crypto.digest("SHA-256", bytes).pipe(
-            Effect.mapError((error) => sourceError(options.source, `Unable to hash hosted skill ${entry.name}`, error)),
-            Effect.flatMap((actual) =>
-              Encoding.encodeHex(actual) === entry.sha256
-                ? decodeText(options.source, bytes)
-                : 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] ?? [])
-          : []
-      byName.set(entry.name, {
-        frontmatter: metadata,
-        listing: SkillSource.makeListing(metadata, descriptionCap),
-        body,
-        tools,
-      })
-    }
-    const skills = [...byName.values()]
-    return {
-      all: Effect.succeed(skills),
-      get: (name) => Effect.succeed(byName.get(name)),
-    }
-  })
-
-/** @experimental One-source hosted catalog layer. */
-export const layer = (
-  options: MakeOptions,
-): Layer.Layer<SkillSource.SkillSource, SkillSource.SkillSourceError, HttpClient.HttpClient | Crypto.Crypto> =>
-  Layer.effect(SkillSource.SkillSource, make(options).pipe(Effect.map(SkillSource.SkillSource.of)))

package/src/http-catalog.ts

@@ -1,29 +0,0 @@
-import { Crypto, Effect } from "effect"
-import { HttpClient, Url } from "effect/unstable/http"
-import { SkillSource } from "@batonfx/core"
-import { type Limits, make as makeHostedCatalog, resolveRelative } from "./hosted-catalog"
-
-/** @experimental Generic HTTP skill catalog options. */
-export interface Options extends Limits {
-  readonly manifestUrl: string
-  readonly source?: string
-}
-
-const invalidUrl = (cause: unknown) =>
-  new SkillSource.SkillSourceError({ source: "http-skill-catalog", message: "Invalid manifest URL", cause })
-
-/** @experimental Build a generic HTTP catalog source. */
-export const make = (options: Options): SkillSource.Source<HttpClient.HttpClient | Crypto.Crypto> => {
-  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),
-    })
-  })
-}
-
-/** @experimental Build a generic HTTP catalog layer. */
-export const layer = (options: Options) => SkillSource.layer([make(options)])

package/src/index.ts

@@ -1,6 +0,0 @@
-export * as GitHubCatalog from "./github-catalog"
-export * as HostedCatalog from "./hosted-catalog"
-export * as HttpCatalog from "./http-catalog"
-export * as InstructionFiles from "./instructions-files"
-export * as S3Catalog from "./s3-catalog"
-export * as SkillLoader from "./skill-loader"

package/src/instructions-files.ts

@@ -1,63 +0,0 @@
-import { Effect, FileSystem, Path, PlatformError } from "effect"
-
-/** @experimental Loaded instruction-file content. */
-export interface InstructionFile {
-  readonly path: string
-  readonly content: string
-}
-
-/** @experimental Instruction-file discovery options. */
-export interface LoadInstructionFilesOptions {
-  readonly filenames?: ReadonlyArray<string>
-  readonly cwd?: string
-  readonly globalFiles?: ReadonlyArray<string>
-}
-
-const DEFAULT_FILENAMES = ["AGENTS.md", "CLAUDE.md"] as const
-
-const readIfExists = (
-  fs: FileSystem.FileSystem,
-  file: string,
-): Effect.Effect<InstructionFile | undefined, PlatformError.PlatformError> =>
-  Effect.gen(function* () {
-    if (!(yield* fs.exists(file))) return undefined
-    const content = yield* fs.readFileString(file)
-    return { path: file, content }
-  })
-
-const ancestors = (path: Path.Path, cwd: string): ReadonlyArray<string> => {
-  const directories: Array<string> = []
-  let cursor = path.resolve(cwd)
-  while (true) {
-    directories.push(cursor)
-    const parent = path.dirname(cursor)
-    if (parent === cursor) break
-    cursor = parent
-  }
-  return directories.toReversed()
-}
-
-/** @experimental Load AGENTS.md / CLAUDE.md instruction files. */
-export const loadInstructionFiles = (
-  options: LoadInstructionFilesOptions = {},
-): Effect.Effect<ReadonlyArray<InstructionFile>, PlatformError.PlatformError, FileSystem.FileSystem | Path.Path> =>
-  Effect.gen(function* () {
-    const fs = yield* FileSystem.FileSystem
-    const path = yield* Path.Path
-    const filenames = options.filenames ?? DEFAULT_FILENAMES
-    const files: Array<InstructionFile> = []
-    for (const globalFile of options.globalFiles ?? []) {
-      const loaded = yield* readIfExists(fs, globalFile)
-      if (loaded !== undefined) files.push(loaded)
-    }
-    for (const directory of ancestors(path, options.cwd ?? ".")) {
-      for (const filename of filenames) {
-        const loaded = yield* readIfExists(fs, path.join(directory, filename))
-        if (loaded !== undefined) {
-          files.push(loaded)
-          break
-        }
-      }
-    }
-    return files
-  })

package/src/s3-catalog.ts

@@ -1,49 +0,0 @@
-import { Crypto, Effect } from "effect"
-import { HttpClient } from "effect/unstable/http"
-import { SkillSource } from "@batonfx/core"
-import { type Limits, make as makeHostedCatalog, resolveRelative, validateSkillPath } from "./hosted-catalog"
-
-/** @experimental Manifest-backed S3 catalog options. */
-export interface Options extends Limits {
-  readonly bucket: string
-  readonly region: string
-  readonly prefix?: string
-  readonly manifestName?: string
-  readonly source?: string
-}
-
-const segments = (value: string): string =>
-  value
-    .split("/")
-    .filter((segment) => segment.length > 0)
-    .map(encodeURIComponent)
-    .join("/")
-
-/** @experimental Build a manifest-backed S3 catalog source. */
-export const make = (options: Options): SkillSource.Source<HttpClient.HttpClient | Crypto.Crypto> => {
-  const source = options.source ?? `s3://${options.bucket}/${options.prefix ?? ""}`
-  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.gen(function* () {
-    if ((options.prefix?.length ?? 0) > 0) yield* validateSkillPath(source, 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,
-      source,
-      manifestUrl,
-      resolveSkillUrl: (skillPath) => resolveRelative(source, manifestUrl, skillPath),
-    })
-  })
-}
-
-/** @experimental Build a manifest-backed S3 catalog layer. */
-export const layer = (options: Options) => SkillSource.layer([make(options)])

package/src/skill-document.ts

@@ -1,174 +0,0 @@
-import { Effect } from "effect"
-import { SkillSource } from "@batonfx/core"
-
-export interface ParsedDocument {
-  readonly frontmatter: SkillSource.Frontmatter
-  readonly body: string
-}
-
-interface ParsedHeader {
-  name?: string
-  description?: string
-  whenToUse?: string
-  allowedTools?: ReadonlyArray<string>
-  disableModelInvocation?: boolean
-  userInvocable?: boolean
-  contextFork?: boolean
-  agent?: string
-  model?: string
-  paths?: ReadonlyArray<string>
-}
-
-const sourceError = (source: string, message: string, cause?: unknown): SkillSource.SkillSourceError =>
-  new SkillSource.SkillSourceError({ source, message, ...(cause === undefined ? {} : { cause }) })
-
-const normalizeKey = (key: string): string => key.replace(/[-_]/g, "").toLowerCase()
-
-const stripQuotes = (value: string): string => {
-  const trimmed = value.trim()
-  return (trimmed.startsWith('"') && trimmed.endsWith('"')) || (trimmed.startsWith("'") && trimmed.endsWith("'"))
-    ? trimmed.slice(1, -1)
-    : trimmed
-}
-
-const parseInlineArray = (value: string): ReadonlyArray<string> => {
-  const trimmed = value.trim()
-  if (!trimmed.startsWith("[") || !trimmed.endsWith("]")) return []
-  const inner = trimmed.slice(1, -1).trim()
-  return inner.length === 0 ? [] : inner.split(",").map((item) => stripQuotes(item).trim())
-}
-
-const parseBoolean = (value: string): boolean | undefined => {
-  const lowered = value.trim().toLowerCase()
-  if (lowered === "true") return true
-  if (lowered === "false") return false
-  return undefined
-}
-
-const setValue = (target: Partial<ParsedHeader>, key: string, value: string | boolean | ReadonlyArray<string>) => {
-  switch (normalizeKey(key)) {
-    case "name":
-      if (typeof value === "string") target.name = value
-      break
-    case "description":
-      if (typeof value === "string") target.description = value
-      break
-    case "whentouse":
-      if (typeof value === "string") target.whenToUse = value
-      break
-    case "allowedtools":
-      if (typeof value === "string") target.allowedTools = value.split(/\s+/).filter((item) => item.length > 0)
-      else if (Array.isArray(value)) target.allowedTools = value
-      break
-    case "disablemodelinvocation":
-      if (typeof value === "boolean") target.disableModelInvocation = value
-      break
-    case "userinvocable":
-      if (typeof value === "boolean") target.userInvocable = value
-      break
-    case "contextfork":
-      if (typeof value === "boolean") target.contextFork = value
-      break
-    case "agent":
-      if (typeof value === "string") target.agent = value
-      break
-    case "model":
-      if (typeof value === "string") target.model = value
-      break
-    case "paths":
-      if (Array.isArray(value)) target.paths = value
-      break
-  }
-}
-
-const parseHeader = (source: string, block: string): Effect.Effect<ParsedHeader, SkillSource.SkillSourceError> =>
-  Effect.sync(() => {
-    const parsed: Partial<ParsedHeader> = {}
-    const lines = block.split("\n")
-    for (let index = 0; index < lines.length; index += 1) {
-      const line = lines[index]?.trimEnd() ?? ""
-      if (line.trim().length === 0) continue
-      const separator = line.indexOf(":")
-      if (separator === -1) continue
-      const key = line.slice(0, separator).trim()
-      const raw = line.slice(separator + 1).trim()
-      if (raw.length === 0) {
-        const values: Array<string> = []
-        while ((lines[index + 1]?.trimStart().startsWith("- ") ?? false) === true) {
-          index += 1
-          values.push(stripQuotes((lines[index] ?? "").trimStart().slice(2)))
-        }
-        setValue(parsed, key, values)
-      } else if (raw.startsWith("[") && raw.endsWith("]")) {
-        setValue(parsed, key, parseInlineArray(raw))
-      } else {
-        setValue(parsed, key, parseBoolean(raw) ?? stripQuotes(raw))
-      }
-    }
-    return parsed
-  }).pipe(Effect.catchCause((cause) => Effect.fail(sourceError(source, "Invalid SKILL.md frontmatter", cause))))
-
-export const splitDocument = (
-  source: string,
-  content: string,
-): Effect.Effect<readonly [string, string], SkillSource.SkillSourceError> =>
-  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"))
-    }
-    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 [lines.slice(1, close).join("\n"), lines.slice(close + 1).join("\n")] as const
-  })
-
-export const validateName = (source: string, name: string): Effect.Effect<string, SkillSource.SkillSourceError> =>
-  /^[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: string,
-  block: string,
-  directoryName: string,
-): Effect.Effect<SkillSource.Frontmatter, SkillSource.SkillSourceError> =>
-  Effect.gen(function* () {
-    const parsed = yield* parseHeader(source, block)
-    if (parsed.name === undefined) {
-      return yield* Effect.fail(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}`))
-    }
-    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 {
-      name: parsed.name,
-      description: parsed.description,
-      ...(parsed.whenToUse === undefined ? {} : { whenToUse: parsed.whenToUse }),
-      ...(parsed.allowedTools === undefined ? {} : { allowedTools: parsed.allowedTools }),
-      ...(parsed.disableModelInvocation === undefined ? {} : { disableModelInvocation: parsed.disableModelInvocation }),
-      ...(parsed.userInvocable === undefined ? {} : { userInvocable: parsed.userInvocable }),
-      ...(parsed.contextFork === undefined ? {} : { contextFork: parsed.contextFork }),
-      ...(parsed.agent === undefined ? {} : { agent: parsed.agent }),
-      ...(parsed.model === undefined ? {} : { model: parsed.model }),
-      ...(parsed.paths === undefined ? {} : { paths: parsed.paths }),
-    }
-  })
-
-export const parseDocument = (
-  source: string,
-  content: string,
-  directoryName: string,
-): Effect.Effect<ParsedDocument, SkillSource.SkillSourceError> =>
-  Effect.gen(function* () {
-    const [header, body] = yield* splitDocument(source, content)
-    return { frontmatter: yield* parseFrontmatter(source, header, directoryName), body }
-  })