@sleepy-ai/cli 0.1.5 → 0.1.7

package/src/skill/compose/bundle.macro.ts

@@ -1,30 +0,0 @@
-import fs from "fs"
-import path from "path"
-
-function walkDir(base: string, rel: string, out: Record<string, string>) {
-  const fullPath = rel ? path.join(base, rel) : base
-  for (const entry of fs.readdirSync(fullPath, { withFileTypes: true })) {
-    const relPath = rel ? `${rel}/${entry.name}` : entry.name
-    if (entry.isDirectory()) {
-      walkDir(base, relPath, out)
-    } else {
-      out[relPath] = fs.readFileSync(path.join(fullPath, entry.name), "utf8")
-    }
-  }
-}
-
-export function loadComposeBundle(): Record<string, Record<string, string>> {
-  const dir = path.resolve(import.meta.dir, ".bundle")
-  const result: Record<string, Record<string, string>> = {}
-
-  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
-    if (!entry.isDirectory()) continue
-    const files: Record<string, string> = {}
-    walkDir(path.join(dir, entry.name), "", files)
-    if (Object.keys(files).length > 0) {
-      result[entry.name] = files
-    }
-  }
-
-  return result
-}

package/src/skill/compose/extract.ts

@@ -1,85 +0,0 @@
-import path from "path"
-import { pathToFileURL } from "url"
-import { Effect } from "effect"
-import matter from "gray-matter"
-import { AppFileSystem } from "@sleepy-ai/shared/filesystem"
-import { Path as GlobalPath } from "@/global"
-import { InstallationLocal, InstallationVersion } from "@/installation/version"
-import { Log } from "@/util"
-import { loadComposeBundle } from "./bundle.macro" with { type: "macro" }
-import { loadComposeBundle as loadComposeBundleDev } from "./bundle.macro"
-import { fallbackSanitization } from "@/config/markdown"
-
-/// Bun macros only resolve in the static import graph of an entry point.
-/// In dynamic import() chains (e.g. plugin tests), the macro is unavailable —
-/// fall back to a normal runtime import of the same function.
-/// `typeof loadComposeBundle` is always "undefined" even after macro expansion
-/// (Bun replaces the call site, not the binding), so use try/catch instead.
-function safeLoadComposeBundle() {
-  try {
-    return loadComposeBundle()
-  } catch(e) {
-    if (e instanceof ReferenceError) {
-      return loadComposeBundleDev()
-    }
-    throw e
-  }
-}
-const COMPOSE_BUNDLE = safeLoadComposeBundle()
-
-const log = Log.create({ service: "skill.compose" })
-
-export const extractComposeBundle = Effect.fn("Skill.extractComposeBundle")(function* (
-  fsys: AppFileSystem.Interface,
-) {
-  const root = path.join(GlobalPath.data, "compose", InstallationVersion)
-  const marker = path.join(root, ".extracted")
-
-  if (!InstallationLocal && (yield* fsys.existsSafe(marker))) return root
-
-  for (const [skillName, files] of Object.entries(COMPOSE_BUNDLE)) {
-    const skillDir = path.join(root, "skills", skillName)
-    for (const [relPath, content] of Object.entries(files)) {
-      yield* fsys.writeWithDirs(path.join(skillDir, relPath), content)
-    }
-  }
-  yield* fsys.writeWithDirs(marker, InstallationVersion)
-  log.info("extracted compose skills", { root })
-  return root
-})
-
-function parseSkillMeta(content: string) {
-  try {
-    return matter(content)
-  } catch {
-    try {
-      return matter(fallbackSanitization(content))
-    } catch {
-      return undefined
-    }
-  }
-}
-
-export function composeSkillsBlock(): string {
-  const root = path.join(GlobalPath.data, "compose", InstallationVersion)
-  const entries: string[] = []
-
-  for (const [skillName, files] of Object.entries(COMPOSE_BUNDLE)) {
-    const skillMd = files["SKILL.md"]
-    if (!skillMd) continue
-    const parsed = parseSkillMeta(skillMd)
-    if (!parsed?.data?.name || !parsed?.data?.description) continue
-
-    const location = pathToFileURL(path.join(root, "skills", skillName, "SKILL.md")).href
-    entries.push(
-      `  <skill>`,
-      `    <name>${parsed.data.name}</name>`,
-      `    <description>${parsed.data.description}</description>`,
-      `    <location>${location}</location>`,
-      `  </skill>`,
-    )
-  }
-
-  if (entries.length === 0) return ""
-  return ["<compose_skills>", ...entries, "</compose_skills>"].join("\n")
-}

package/src/skill/discovery.ts

@@ -1,114 +0,0 @@
-import { Effect, Layer, Schema, Context } from "effect"
-import path from "path"
-import { FetchHttpClient, HttpClient, HttpClientRequest, HttpClientResponse } from "effect/unstable/http"
-import { withTransientReadRetry } from "@/util/effect-http-client"
-import { AppFileSystem } from "@sleepy-ai/shared/filesystem"
-import { Global } from "../global"
-import { Log } from "../util"
-
-const skillConcurrency = 4
-const fileConcurrency = 8
-
-class IndexSkill extends Schema.Class<IndexSkill>("IndexSkill")({
-  name: Schema.String,
-  files: Schema.Array(Schema.String),
-}) {}
-
-class Index extends Schema.Class<Index>("Index")({
-  skills: Schema.Array(IndexSkill),
-}) {}
-
-export interface Interface {
-  readonly pull: (url: string) => Effect.Effect<string[]>
-}
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/SkillDiscovery") {}
-
-export const layer: Layer.Layer<Service, never, AppFileSystem.Service | HttpClient.HttpClient> =
-  Layer.effect(
-    Service,
-    Effect.gen(function* () {
-      const log = Log.create({ service: "skill-discovery" })
-      const fs = yield* AppFileSystem.Service
-      const http = HttpClient.filterStatusOk(withTransientReadRetry(yield* HttpClient.HttpClient))
-      const cache = path.join(Global.Path.cache, "skills")
-
-      const download = Effect.fn("Discovery.download")(function* (url: string, dest: string) {
-        if (yield* fs.exists(dest).pipe(Effect.orDie)) return true
-
-        return yield* HttpClientRequest.get(url).pipe(
-          http.execute,
-          Effect.flatMap((res) => res.arrayBuffer),
-          Effect.flatMap((body) => fs.writeWithDirs(dest, new Uint8Array(body))),
-          Effect.as(true),
-          Effect.catch((err) =>
-            Effect.sync(() => {
-              log.error("failed to download", { url, err })
-              return false
-            }),
-          ),
-        )
-      })
-
-      const pull = Effect.fn("Discovery.pull")(function* (url: string) {
-        const base = url.endsWith("/") ? url : `${url}/`
-        const index = new URL("index.json", base).href
-        const host = base.slice(0, -1)
-
-        log.info("fetching index", { url: index })
-
-        const data = yield* HttpClientRequest.get(index).pipe(
-          HttpClientRequest.acceptJson,
-          http.execute,
-          Effect.flatMap(HttpClientResponse.schemaBodyJson(Index)),
-          Effect.catch((err) =>
-            Effect.sync(() => {
-              log.error("failed to fetch index", { url: index, err })
-              return null
-            }),
-          ),
-        )
-
-        if (!data) return []
-
-        const list = data.skills.filter((skill) => {
-          if (!skill.files.includes("SKILL.md")) {
-            log.warn("skill entry missing SKILL.md", { url: index, skill: skill.name })
-            return false
-          }
-          return true
-        })
-
-        const dirs = yield* Effect.forEach(
-          list,
-          (skill) =>
-            Effect.gen(function* () {
-              const root = path.join(cache, skill.name)
-
-              yield* Effect.forEach(
-                skill.files,
-                (file) => download(new URL(file, `${host}/${skill.name}/`).href, path.join(root, file)),
-                {
-                  concurrency: fileConcurrency,
-                },
-              )
-
-              const md = path.join(root, "SKILL.md")
-              return (yield* fs.exists(md).pipe(Effect.orDie)) ? root : null
-            }),
-          { concurrency: skillConcurrency },
-        )
-
-        return dirs.filter((dir): dir is string => dir !== null)
-      })
-
-      return Service.of({ pull })
-    }),
-  )
-
-export const defaultLayer: Layer.Layer<Service> = layer.pipe(
-  Layer.provide(FetchHttpClient.layer),
-  Layer.provide(AppFileSystem.defaultLayer),
-)
-
-export * as Discovery from "./discovery"

package/src/skill/index.ts

@@ -1,328 +0,0 @@
-import os from "os"
-import path from "path"
-import { pathToFileURL } from "url"
-import z from "zod"
-import { Effect, Layer, Context } from "effect"
-import { NamedError } from "@sleepy-ai/shared/util/error"
-import type { Agent } from "@/agent/agent"
-import { Bus } from "@/bus"
-import { InstanceState } from "@/effect"
-import { Flag } from "@/flag/flag"
-import { Global } from "@/global"
-import { Permission } from "@/permission"
-import { AppFileSystem } from "@sleepy-ai/shared/filesystem"
-import { Config } from "../config"
-import { ConfigMarkdown } from "../config"
-import { Glob } from "@sleepy-ai/shared/util/glob"
-import { Log } from "../util"
-import { Discovery } from "./discovery"
-import { extractComposeBundle } from "./compose/extract"
-import { extractBuiltinBundle } from "./builtin/extract"
-
-const log = Log.create({ service: "skill" })
-const EXTERNAL_DIRS = [".claude", ".agents", ".codex", ".opencode"]
-const EXTERNAL_SKILL_PATTERN = "skills/**/SKILL.md"
-const SLEEPYCODE_SKILL_PATTERN = "{skill,skills}/**/SKILL.md"
-const SKILL_PATTERN = "**/SKILL.md"
-
-export const Info = z.object({
-  name: z.string(),
-  description: z.string(),
-  location: z.string(),
-  content: z.string(),
-  hidden: z.boolean().optional(),
-})
-export type Info = z.infer<typeof Info>
-
-export const InvalidError = NamedError.create(
-  "SkillInvalidError",
-  z.object({
-    path: z.string(),
-    message: z.string().optional(),
-    issues: z.custom<z.core.$ZodIssue[]>().optional(),
-  }),
-)
-
-export const NameMismatchError = NamedError.create(
-  "SkillNameMismatchError",
-  z.object({
-    path: z.string(),
-    expected: z.string(),
-    actual: z.string(),
-  }),
-)
-
-type State = {
-  skills: Record<string, Info>
-  dirs: Set<string>
-}
-
-type DiscoveryState = {
-  matches: string[]
-  dirs: string[]
-}
-
-type ScanState = {
-  matches: Set<string>
-  dirs: Set<string>
-}
-
-export interface Interface {
-  readonly get: (name: string) => Effect.Effect<Info | undefined>
-  readonly all: () => Effect.Effect<Info[]>
-  readonly dirs: () => Effect.Effect<string[]>
-  readonly available: (agent?: Agent.Info) => Effect.Effect<Info[]>
-  readonly reload: () => Effect.Effect<void>
-}
-
-const add = Effect.fnUntraced(function* (state: State, match: string, bus: Bus.Interface) {
-  const md = yield* Effect.tryPromise({
-    try: () => ConfigMarkdown.parse(match),
-    catch: (err) => err,
-  }).pipe(
-    Effect.catch(
-      Effect.fnUntraced(function* (err) {
-        const message = ConfigMarkdown.FrontmatterError.isInstance(err)
-          ? err.data.message
-          : `Failed to parse skill ${match}`
-        const { Session } = yield* Effect.promise(() => import("@/session"))
-        yield* bus.publish(Session.Event.Error, { error: new NamedError.Unknown({ message }).toObject() })
-        log.error("failed to load skill", { skill: match, err })
-        return undefined
-      }),
-    ),
-  )
-
-  if (!md) return
-
-  const parsed = Info.pick({ name: true, description: true, hidden: true }).safeParse(md.data)
-  if (!parsed.success) return
-
-  if (state.skills[parsed.data.name]) {
-    log.warn("duplicate skill name", {
-      name: parsed.data.name,
-      existing: state.skills[parsed.data.name].location,
-      duplicate: match,
-    })
-  }
-
-  state.dirs.add(path.dirname(match))
-  state.skills[parsed.data.name] = {
-    name: parsed.data.name,
-    description: parsed.data.description,
-    location: match,
-    content: md.content,
-    hidden: parsed.data.hidden,
-  }
-})
-
-const scan = Effect.fnUntraced(function* (
-  state: ScanState,
-  root: string,
-  pattern: string,
-  opts?: { dot?: boolean; scope?: string },
-) {
-  const matches = yield* Effect.tryPromise({
-    try: () =>
-      Glob.scan(pattern, {
-        cwd: root,
-        absolute: true,
-        include: "file",
-        symlink: true,
-        dot: opts?.dot,
-      }),
-    catch: (error) => error,
-  }).pipe(
-    Effect.catch((error) => {
-      if (!opts?.scope) return Effect.die(error)
-      log.error(`failed to scan ${opts.scope} skills`, { dir: root, error })
-      return Effect.succeed([] as string[])
-    }),
-  )
-
-  for (const match of matches) {
-    state.matches.add(match)
-    state.dirs.add(path.dirname(match))
-  }
-})
-
-const discoverSkills = Effect.fnUntraced(function* (
-  config: Config.Interface,
-  discovery: Discovery.Interface,
-  fsys: AppFileSystem.Interface,
-  directory: string,
-  worktree: string,
-) {
-  const state: ScanState = { matches: new Set(), dirs: new Set() }
-
-  // Extract builtin skills to disk first (user skills with same name override)
-  if (!Flag.SLEEPYCODE_DISABLE_BUILTIN_SKILLS) {
-    const builtinSkillRoot = yield* extractBuiltinBundle(fsys).pipe(
-      Effect.catch(() => Effect.succeed(undefined)),
-    )
-    if (builtinSkillRoot && (yield* fsys.isDir(builtinSkillRoot))) {
-      yield* scan(state, builtinSkillRoot, SKILL_PATTERN, { scope: "builtin" })
-    }
-  }
-
-  // Extract compose skills to disk (user skills with same name override)
-  if (!Flag.SLEEPYCODE_DISABLE_COMPOSE_SKILLS) {
-    const composeSkillRoot = yield* extractComposeBundle(fsys).pipe(
-      Effect.catch(() => Effect.succeed(undefined)),
-    )
-    if (composeSkillRoot && (yield* fsys.isDir(composeSkillRoot))) {
-      yield* scan(state, composeSkillRoot, SKILL_PATTERN, { scope: "compose" })
-    }
-  }
-
-  if (!Flag.SLEEPYCODE_DISABLE_EXTERNAL_SKILLS) {
-    const externalDirs = EXTERNAL_DIRS.filter((dir) => {
-      if (dir === ".claude" && Flag.SLEEPYCODE_DISABLE_CLAUDE_CODE_SKILLS) return false
-      if (dir === ".codex" && Flag.SLEEPYCODE_DISABLE_CODEX_SKILLS) return false
-      if (dir === ".opencode" && Flag.SLEEPYCODE_DISABLE_OPENCODE_SKILLS) return false
-      return true
-    })
-
-    for (const dir of externalDirs) {
-      const root = path.join(Global.Path.home, dir)
-      if (!(yield* fsys.isDir(root))) continue
-      yield* scan(state, root, EXTERNAL_SKILL_PATTERN, { dot: true, scope: "global" })
-    }
-
-    const upDirs = yield* fsys
-      .up({ targets: externalDirs, start: directory, stop: worktree })
-      .pipe(Effect.catch(() => Effect.succeed([] as string[])))
-
-    for (const root of upDirs) {
-      yield* scan(state, root, EXTERNAL_SKILL_PATTERN, { dot: true, scope: "project" })
-    }
-  }
-
-  const configDirs = yield* config.directories()
-  for (const dir of configDirs) {
-    yield* scan(state, dir, SLEEPYCODE_SKILL_PATTERN)
-  }
-
-  const cfg = yield* config.get()
-  for (const item of cfg.skills?.paths ?? []) {
-    const expanded = item.startsWith("~/") ? path.join(os.homedir(), item.slice(2)) : item
-    const dir = path.isAbsolute(expanded) ? expanded : path.join(directory, expanded)
-    if (!(yield* fsys.isDir(dir))) {
-      log.warn("skill path not found", { path: dir })
-      continue
-    }
-
-    yield* scan(state, dir, SKILL_PATTERN)
-  }
-
-  for (const url of cfg.skills?.urls ?? []) {
-    const pulledDirs = yield* discovery.pull(url)
-    for (const dir of pulledDirs) {
-      yield* scan(state, dir, SKILL_PATTERN)
-    }
-  }
-
-  return {
-    matches: Array.from(state.matches),
-    dirs: Array.from(state.dirs),
-  }
-})
-
-const loadSkills = Effect.fnUntraced(function* (state: State, discovered: DiscoveryState, bus: Bus.Interface) {
-  yield* Effect.forEach(discovered.matches, (match) => add(state, match, bus), {
-    concurrency: "unbounded",
-    discard: true,
-  })
-
-  log.info("init", { count: Object.keys(state.skills).length })
-})
-
-export class Service extends Context.Service<Service, Interface>()("@opencode/Skill") {}
-
-export const layer = Layer.effect(
-  Service,
-  Effect.gen(function* () {
-    const discovery = yield* Discovery.Service
-    const config = yield* Config.Service
-    const bus = yield* Bus.Service
-    const fsys = yield* AppFileSystem.Service
-    const discovered = yield* InstanceState.make(
-      Effect.fn("Skill.discovery")(function* (ctx) {
-        return yield* discoverSkills(config, discovery, fsys, ctx.directory, ctx.worktree)
-      }),
-    )
-    const state = yield* InstanceState.make(
-      Effect.fn("Skill.state")(function* (ctx) {
-        const s: State = { skills: {}, dirs: new Set() }
-        yield* loadSkills(s, yield* InstanceState.get(discovered), bus)
-        return s
-      }),
-    )
-
-    const get = Effect.fn("Skill.get")(function* (name: string) {
-      const s = yield* InstanceState.get(state)
-      return s.skills[name]
-    })
-
-    const all = Effect.fn("Skill.all")(function* () {
-      const s = yield* InstanceState.get(state)
-      return Object.values(s.skills)
-    })
-
-    const dirs = Effect.fn("Skill.dirs")(function* () {
-      return (yield* InstanceState.get(discovered)).dirs
-    })
-
-    const available = Effect.fn("Skill.available")(function* (agent?: Agent.Info) {
-      const s = yield* InstanceState.get(state)
-      let list: Info[] = Object.values(s.skills)
-        .filter((sk) => !sk.hidden)
-
-      list = list.toSorted((a, b) => a.name.localeCompare(b.name))
-      if (!agent) return list
-      return list.filter((skill) => Permission.evaluate("skill", skill.name, agent.permission).action !== "deny")
-    })
-
-    const reload = Effect.fn("Skill.reload")(function* () {
-      yield* InstanceState.invalidate(discovered)
-      yield* InstanceState.invalidate(state)
-    })
-
-    return Service.of({ get, all, dirs, available, reload })
-  }),
-)
-
-export const defaultLayer = layer.pipe(
-  Layer.provide(Discovery.defaultLayer),
-  Layer.provide(Config.defaultLayer),
-  Layer.provide(Bus.layer),
-  Layer.provide(AppFileSystem.defaultLayer),
-)
-
-export function fmt(list: Info[], opts: { verbose: boolean }) {
-  if (list.length === 0) return "No skills are currently available."
-  if (opts.verbose) {
-    return [
-      "<available_skills>",
-      ...list
-        .sort((a, b) => a.name.localeCompare(b.name))
-        .flatMap((skill) => [
-          "  <skill>",
-          `    <name>${skill.name}</name>`,
-          `    <description>${skill.description}</description>`,
-          `    <location>${pathToFileURL(skill.location).href}</location>`,
-          "  </skill>",
-        ]),
-      "</available_skills>",
-    ].join("\n")
-  }
-
-  return [
-    "## Available Skills",
-    ...list
-      .toSorted((a, b) => a.name.localeCompare(b.name))
-      .map((skill) => `- **${skill.name}**: ${skill.description}`),
-  ].join("\n")
-}
-
-export * as Skill from "."