openAgent

1export * as SkillV2 from "./skill"
2 
3import { makeLocationNode } from "./effect/app-node"
4import path from "path"
5import { Context, Effect, Layer, Schema, Types } from "effect"
6import { Skill } from "@opencode-ai/schema/skill"
7import { AgentV2 } from "./agent"
8import { ConfigMarkdown } from "./config/markdown"
9import { FSUtil } from "./fs-util"
10import { PermissionV2 } from "./permission"
11import { AbsolutePath } from "./schema"
12import { SkillDiscovery } from "./skill/discovery"
13import { State } from "./state"
14 
15export const DirectorySource = Skill.DirectorySource
16export type DirectorySource = Skill.DirectorySource
17 
18export const UrlSource = Skill.UrlSource
19export type UrlSource = Skill.UrlSource
20 
21export const EmbeddedSource = Skill.EmbeddedSource
22export type EmbeddedSource = Skill.EmbeddedSource
23 
24export const Source = Skill.Source
25export type Source = typeof Source.Type
26 
27export const Info = Skill.Info
28export type Info = Skill.Info
29 
30export const available = (skills: ReadonlyArray<Info>, agent: AgentV2.Info) =>
31  skills.filter((skill) => PermissionV2.evaluate("skill", skill.name, agent.permissions).effect !== "deny")
32 
33const Frontmatter = Schema.Struct({
34  name: Schema.String.pipe(Schema.optional),
35  description: Schema.String.pipe(Schema.optional),
36  slash: Schema.Boolean.pipe(Schema.optional),
37})
38const decodeFrontmatter = Schema.decodeUnknownOption(Frontmatter)
39 
40export type Data = {
41  sources: Types.DeepMutable<Source>[]
42}
43 
44export type Draft = {
45  source: (source: Source) => void
46  list: () => readonly Source[]
47}
48 
49export interface Interface extends State.Transformable<Draft> {
50  readonly sources: () => Effect.Effect<Source[]>
51  readonly list: () => Effect.Effect<Info[]>
52}
53 
54export class Service extends Context.Service<Service, Interface>()("@opencode/v2/Skill") {}
55 
56const layer = Layer.effect(
57  Service,
58  Effect.gen(function* () {
59    const discovery = yield* SkillDiscovery.Service
60    const fs = yield* FSUtil.Service
61 
62    const state = State.create<Data, Draft>({
63      initial: () => ({ sources: [] }),
64      draft: (draft) => ({
65        source: (source) => {
66          if (draft.sources.some((item) => Source.equals(item, source))) return
67          draft.sources.push(source as Types.DeepMutable<Source>)
68        },
69        list: () => draft.sources as Source[],
70      }),
71    })
72 
73    const load = Effect.fn("SkillV2.load")(function* (source: Source) {
74      const skills: Info[] = []
75      if (source.type === "embedded") return [source.skill]
76      const directories = source.type === "directory" ? [source.path] : yield* discovery.pull(source.url)
77      for (const directory of directories) {
78        const files = yield* fs
79          .glob("{*.md,**/SKILL.md}", { cwd: directory, absolute: true, include: "file", symlink: true, dot: true })
80          .pipe(Effect.catch(() => Effect.succeed([] as string[])))
81        for (const filepath of files.toSorted()) {
82          const content = yield* fs.readFileStringSafe(filepath).pipe(Effect.catch(() => Effect.succeed(undefined)))
83          if (!content) continue
84          const markdown = ConfigMarkdown.parseOption(content)
85          if (!markdown) continue
86          const frontmatter = decodeFrontmatter(markdown.data).valueOrUndefined
87          if (!frontmatter) continue
88          const name =
89            frontmatter.name !== undefined
90              ? frontmatter.name
91              : path.dirname(filepath) === directory
92                ? path.basename(filepath, ".md")
93                : undefined
94          if (!name) continue
95          skills.push({
96            name,
97            description: frontmatter.description,
98            slash: frontmatter.slash,
99            location: AbsolutePath.make(filepath),
100            content: markdown.content,
101          })
102        }
103      }
104      return skills
105    })
106 
107    // QUESTION(Dax): Should local skill sources invalidate on filesystem watch
108    // events, following the reload policy chosen for other context sources?
109    const cache = new Map<string, Info[]>()
110    const list = Effect.fn("SkillV2.list")(function* () {
111      const skills = new Map<string, Info>()
112      for (const source of state.get().sources) {
113        const key = Source.key(source)
114        const loaded = cache.get(key) ?? (yield* load(source))
115        cache.set(key, loaded)
116        for (const skill of loaded) skills.set(skill.name, skill)
117      }
118      return Array.from(skills.values())
119    })
120 
121    return Service.of({
122      transform: state.transform,
123      reload: state.reload,
124      sources: Effect.fn("SkillV2.sources")(function* () {
125        return state.get().sources
126      }),
127      list,
128    })
129  }),
130)
131 
132export const node = makeLocationNode({ service: Service, layer, deps: [SkillDiscovery.node, FSUtil.node] })
133