@toolkit-cli/toolkode 1.3.7

package/src/skill/index.ts

@@ -0,0 +1,284 @@
+import os from "os"
+import path from "path"
+import { pathToFileURL } from "url"
+import z from "zod"
+import { Effect, Layer, ServiceMap } from "effect"
+import { NamedError } from "@toolkit-cli/util/error"
+import type { Agent } from "@/agent/agent"
+import { Bus } from "@/bus"
+import { InstanceState } from "@/effect/instance-state"
+import { makeRuntime } from "@/effect/run-service"
+import { Flag } from "@/flag/flag"
+import { Global } from "@/global"
+import { Permission } from "@/permission"
+import { Filesystem } from "@/util/filesystem"
+import { Config } from "../config/config"
+import { ConfigMarkdown } from "../config/markdown"
+import { Glob } from "../util/glob"
+import { Log } from "../util/log"
+import { Discovery } from "./discovery"
+
+export namespace Skill {
+  const log = Log.create({ service: "skill" })
+  const EXTERNAL_DIRS = [".claude", ".agents"]
+  const EXTERNAL_SKILL_PATTERN = "skills/**/SKILL.md"
+  const OPENCODE_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(),
+  })
+  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>
+  }
+
+  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[]>
+  }
+
+  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 }).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,
+    }
+  })
+
+  const scan = Effect.fnUntraced(function* (
+    state: State,
+    bus: Bus.Interface,
+    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[])
+      }),
+    )
+
+    yield* Effect.forEach(matches, (match) => add(state, match, bus), {
+      concurrency: "unbounded",
+      discard: true,
+    })
+  })
+
+  const loadSkills = Effect.fnUntraced(function* (
+    state: State,
+    config: Config.Interface,
+    discovery: Discovery.Interface,
+    bus: Bus.Interface,
+    directory: string,
+    worktree: string,
+  ) {
+    if (!Flag.OPENCODE_DISABLE_EXTERNAL_SKILLS) {
+      for (const dir of EXTERNAL_DIRS) {
+        const root = path.join(Global.Path.home, dir)
+        const isDir = yield* Effect.promise(() => Filesystem.isDir(root))
+        if (!isDir) continue
+        yield* scan(state, bus, root, EXTERNAL_SKILL_PATTERN, { dot: true, scope: "global" })
+      }
+
+      const upDirs = yield* Effect.promise(async () => {
+        const dirs: string[] = []
+        for await (const root of Filesystem.up({
+          targets: EXTERNAL_DIRS,
+          start: directory,
+          stop: worktree,
+        })) {
+          dirs.push(root)
+        }
+        return dirs
+      })
+
+      for (const root of upDirs) {
+        yield* scan(state, bus, root, EXTERNAL_SKILL_PATTERN, { dot: true, scope: "project" })
+      }
+    }
+
+    const configDirs = yield* config.directories()
+    for (const dir of configDirs) {
+      yield* scan(state, bus, dir, OPENCODE_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)
+      const isDir = yield* Effect.promise(() => Filesystem.isDir(dir))
+      if (!isDir) {
+        log.warn("skill path not found", { path: dir })
+        continue
+      }
+
+      yield* scan(state, bus, dir, SKILL_PATTERN)
+    }
+
+    for (const url of cfg.skills?.urls ?? []) {
+      const pulledDirs = yield* discovery.pull(url)
+      for (const dir of pulledDirs) {
+        state.dirs.add(dir)
+        yield* scan(state, bus, dir, SKILL_PATTERN)
+      }
+    }
+
+    log.info("init", { count: Object.keys(state.skills).length })
+  })
+
+  export class Service extends ServiceMap.Service<Service, Interface>()("@opencode/Skill") {}
+
+  export const layer: Layer.Layer<Service, never, Discovery.Service | Config.Service | Bus.Service> = Layer.effect(
+    Service,
+    Effect.gen(function* () {
+      const discovery = yield* Discovery.Service
+      const config = yield* Config.Service
+      const bus = yield* Bus.Service
+      const state = yield* InstanceState.make(
+        Effect.fn("Skill.state")(function* (ctx) {
+          const s: State = { skills: {}, dirs: new Set() }
+          yield* loadSkills(s, config, discovery, bus, ctx.directory, ctx.worktree)
+          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* () {
+        const s = yield* InstanceState.get(state)
+        return Array.from(s.dirs)
+      })
+
+      const available = Effect.fn("Skill.available")(function* (agent?: Agent.Info) {
+        const s = yield* InstanceState.get(state)
+        const list = Object.values(s.skills).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")
+      })
+
+      return Service.of({ get, all, dirs, available })
+    }),
+  )
+
+  export const defaultLayer: Layer.Layer<Service> = layer.pipe(
+    Layer.provide(Discovery.defaultLayer),
+    Layer.provide(Config.defaultLayer),
+    Layer.provide(Bus.layer),
+  )
+
+  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.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.map((skill) => `- **${skill.name}**: ${skill.description}`)].join("\n")
+  }
+
+  const { runPromise } = makeRuntime(Service, defaultLayer)
+
+  export async function get(name: string) {
+    return runPromise((skill) => skill.get(name))
+  }
+
+  export async function all() {
+    return runPromise((skill) => skill.all())
+  }
+
+  export async function dirs() {
+    return runPromise((skill) => skill.dirs())
+  }
+
+  export async function available(agent?: Agent.Info) {
+    return runPromise((skill) => skill.available(agent))
+  }
+}

package/src/skills-marketplace/index.ts

@@ -0,0 +1,305 @@
+/**
+ * tk_ toolkode — Skills Marketplace Client
+ *
+ * Integration with skills.sh — the open agent skills ecosystem.
+ * Browse, search, and install skills from the 90K+ skill leaderboard
+ * directly in the TUI.
+ *
+ * Skills follow the Agent Skills open standard (agentskills.io).
+ * Installation downloads SKILL.md files from GitHub repos into
+ * .toolkode/skills/ or ~/.claude/skills/.
+ */
+import { Log } from "../util/log"
+import { Global } from "../global"
+import { Filesystem } from "../util/filesystem"
+import path from "path"
+import fs from "fs/promises"
+
+const log = Log.create({ service: "skills-marketplace" })
+
+export namespace SkillsMarketplace {
+  /* ── Types ──────────────────────────────────────────────────── */
+
+  export interface SkillEntry {
+    id: string
+    name: string
+    source: string // owner/repo format
+    description?: string
+    installs: number
+    category?: string
+  }
+
+  export interface SkillDetail {
+    id: string
+    name: string
+    source: string
+    description: string
+    content: string // raw SKILL.md content
+    installs: number
+    files: string[] // supporting files in the skill directory
+  }
+
+  export type SortBy = "installs" | "trending" | "hot" | "recent"
+
+  /* ── API Client ─────────────────────────────────────────────── */
+
+  const SKILLS_SH_URL = "https://skills.sh"
+  const GITHUB_RAW = "https://raw.githubusercontent.com"
+
+  /**
+   * Search skills from skills.sh leaderboard.
+   * Falls back to GitHub search if the API is unavailable.
+   */
+  export async function search(query: string, options?: {
+    sort?: SortBy
+    limit?: number
+  }): Promise<SkillEntry[]> {
+    const limit = options?.limit ?? 20
+
+    try {
+      // Try skills.sh API first
+      const url = `${SKILLS_SH_URL}/api/skills?q=${encodeURIComponent(query)}&sort=${options?.sort ?? "installs"}&limit=${limit}`
+      const res = await fetch(url, { signal: AbortSignal.timeout(10_000) })
+      if (res.ok) {
+        const data = await res.json()
+        return Array.isArray(data) ? data.slice(0, limit) : []
+      }
+    } catch {
+      log.info("skills.sh API unavailable, falling back to GitHub search")
+    }
+
+    // Fallback: search GitHub for SKILL.md files
+    try {
+      const ghUrl = `https://api.github.com/search/code?q=${encodeURIComponent(query + " filename:SKILL.md")}&per_page=${limit}`
+      const res = await fetch(ghUrl, {
+        headers: { Accept: "application/vnd.github.v3+json" },
+        signal: AbortSignal.timeout(10_000),
+      })
+      if (res.ok) {
+        const data = await res.json()
+        return (data.items ?? []).map((item: any) => ({
+          id: item.name,
+          name: path.basename(path.dirname(item.path)),
+          source: item.repository.full_name,
+          installs: 0,
+        }))
+      }
+    } catch {}
+
+    return []
+  }
+
+  /**
+   * Get the leaderboard (top skills by install count).
+   */
+  export async function leaderboard(options?: {
+    sort?: SortBy
+    limit?: number
+    offset?: number
+  }): Promise<SkillEntry[]> {
+    const limit = options?.limit ?? 20
+
+    try {
+      const url = `${SKILLS_SH_URL}/api/skills?sort=${options?.sort ?? "installs"}&limit=${limit}&offset=${options?.offset ?? 0}`
+      const res = await fetch(url, { signal: AbortSignal.timeout(10_000) })
+      if (res.ok) {
+        const data = await res.json()
+        return Array.isArray(data) ? data : []
+      }
+    } catch {
+      log.info("skills.sh leaderboard unavailable")
+    }
+
+    // Fallback: return well-known popular skills
+    return WELL_KNOWN_SKILLS.slice(0, limit)
+  }
+
+  /**
+   * Fetch a skill's SKILL.md content from GitHub.
+   */
+  export async function fetchSkill(source: string, skillName: string): Promise<SkillDetail | null> {
+    // Try common paths for SKILL.md in the repo
+    const paths = [
+      `skills/${skillName}/SKILL.md`,
+      `${skillName}/SKILL.md`,
+      `SKILL.md`,
+    ]
+
+    for (const p of paths) {
+      try {
+        const url = `${GITHUB_RAW}/${source}/main/${p}`
+        const res = await fetch(url, { signal: AbortSignal.timeout(10_000) })
+        if (res.ok) {
+          const content = await res.text()
+          return {
+            id: skillName,
+            name: skillName,
+            source,
+            description: extractDescription(content),
+            content,
+            installs: 0,
+            files: [p],
+          }
+        }
+      } catch {}
+    }
+
+    // Also try HEAD branch
+    for (const p of paths) {
+      try {
+        const url = `${GITHUB_RAW}/${source}/HEAD/${p}`
+        const res = await fetch(url, { signal: AbortSignal.timeout(10_000) })
+        if (res.ok) {
+          const content = await res.text()
+          return {
+            id: skillName,
+            name: skillName,
+            source,
+            description: extractDescription(content),
+            content,
+            installs: 0,
+            files: [p],
+          }
+        }
+      } catch {}
+    }
+
+    return null
+  }
+
+  /* ── Installation ───────────────────────────────────────────── */
+
+  /**
+   * Install a skill from skills.sh / GitHub into the local project or user directory.
+   */
+  export async function install(
+    source: string,
+    skillName: string,
+    scope: "project" | "user" = "project",
+  ): Promise<{ success: boolean; path?: string; error?: string }> {
+    const detail = await fetchSkill(source, skillName)
+    if (!detail) {
+      return { success: false, error: `Skill "${skillName}" not found in ${source}` }
+    }
+
+    // Determine installation directory
+    const baseDir = scope === "user"
+      ? path.join(Global.Path.home, ".claude", "skills", skillName)
+      : path.join(process.cwd(), ".toolkode", "skills", skillName)
+
+    try {
+      await fs.mkdir(baseDir, { recursive: true })
+      const skillPath = path.join(baseDir, "SKILL.md")
+      await Filesystem.write(skillPath, detail.content)
+
+      log.info("skill installed", { name: skillName, source, scope, path: skillPath })
+      return { success: true, path: skillPath }
+    } catch (err) {
+      return { success: false, error: `Failed to write skill: ${err}` }
+    }
+  }
+
+  /**
+   * Install a skill using npx skills CLI (the standard way).
+   */
+  export function installCommand(source: string): string {
+    return `npx skills add ${source}`
+  }
+
+  /**
+   * Uninstall a skill by removing its directory.
+   */
+  export async function uninstall(
+    skillName: string,
+    scope: "project" | "user" = "project",
+  ): Promise<boolean> {
+    const baseDir = scope === "user"
+      ? path.join(Global.Path.home, ".claude", "skills", skillName)
+      : path.join(process.cwd(), ".toolkode", "skills", skillName)
+
+    try {
+      await fs.rm(baseDir, { recursive: true, force: true })
+      log.info("skill uninstalled", { name: skillName, scope })
+      return true
+    } catch {
+      return false
+    }
+  }
+
+  /**
+   * List installed skills (both project and user scope).
+   */
+  export async function listInstalled(): Promise<Array<{
+    name: string
+    scope: "project" | "user"
+    path: string
+  }>> {
+    const results: Array<{ name: string; scope: "project" | "user"; path: string }> = []
+
+    // Check project skills
+    const projectDir = path.join(process.cwd(), ".toolkode", "skills")
+    try {
+      const entries = await fs.readdir(projectDir)
+      for (const entry of entries) {
+        const skillPath = path.join(projectDir, entry, "SKILL.md")
+        if (await Filesystem.exists(skillPath)) {
+          results.push({ name: entry, scope: "project", path: skillPath })
+        }
+      }
+    } catch {}
+
+    // Check user skills
+    const userDir = path.join(Global.Path.home, ".claude", "skills")
+    try {
+      const entries = await fs.readdir(userDir)
+      for (const entry of entries) {
+        const skillPath = path.join(userDir, entry, "SKILL.md")
+        if (await Filesystem.exists(skillPath)) {
+          results.push({ name: entry, scope: "user", path: skillPath })
+        }
+      }
+    } catch {}
+
+    return results
+  }
+
+  /* ── Helpers ────────────────────────────────────────────────── */
+
+  function extractDescription(content: string): string {
+    // Try to extract description from YAML frontmatter
+    const match = content.match(/^---\s*\n([\s\S]*?)\n---/)
+    if (match) {
+      const descMatch = match[1].match(/description:\s*(.+)/)
+      if (descMatch) return descMatch[1].trim().replace(/^['"]|['"]$/g, "")
+    }
+    // Fallback: first non-empty line after frontmatter
+    const lines = content.replace(/^---[\s\S]*?---\s*\n/, "").split("\n")
+    const first = lines.find((l) => l.trim() && !l.startsWith("#"))
+    return first?.trim().slice(0, 200) ?? ""
+  }
+
+  /* ── Well-Known Skills (offline fallback) ───────────────────── */
+
+  const WELL_KNOWN_SKILLS: SkillEntry[] = [
+    { id: "find-skills", name: "find-skills", source: "vercel-labs/skills", installs: 774200 },
+    { id: "vercel-react-best-practices", name: "vercel-react-best-practices", source: "vercel-labs/agent-skills", installs: 261000 },
+    { id: "frontend-design", name: "frontend-design", source: "anthropics/skills", installs: 218200 },
+    { id: "next-js", name: "next-js", source: "vercel-labs/agent-skills", installs: 176000 },
+    { id: "supabase", name: "supabase", source: "supabase-community/agent-skills", installs: 144000 },
+    { id: "tailwind-css", name: "tailwind-css", source: "vercel-labs/agent-skills", installs: 128000 },
+    { id: "typescript-best-practices", name: "typescript-best-practices", source: "anthropics/skills", installs: 115000 },
+    { id: "testing-best-practices", name: "testing-best-practices", source: "anthropics/skills", installs: 98000 },
+    { id: "python-best-practices", name: "python-best-practices", source: "anthropics/skills", installs: 89000 },
+    { id: "docker", name: "docker", source: "docker/agent-skills", installs: 76000 },
+    { id: "security-review", name: "security-review", source: "anthropics/skills", installs: 65000 },
+    { id: "git-workflow", name: "git-workflow", source: "anthropics/skills", installs: 58000 },
+    { id: "api-design", name: "api-design", source: "anthropics/skills", installs: 52000 },
+    { id: "database-optimization", name: "database-optimization", source: "anthropics/skills", installs: 45000 },
+    { id: "cloudflare-workers", name: "cloudflare-workers", source: "cloudflare/agent-skills", installs: 41000 },
+    { id: "rust-best-practices", name: "rust-best-practices", source: "anthropics/skills", installs: 38000 },
+    { id: "go-best-practices", name: "go-best-practices", source: "anthropics/skills", installs: 35000 },
+    { id: "graphql", name: "graphql", source: "graphql/agent-skills", installs: 32000 },
+    { id: "kubernetes", name: "kubernetes", source: "kubernetes/agent-skills", installs: 29000 },
+    { id: "aws-best-practices", name: "aws-best-practices", source: "aws/agent-skills", installs: 27000 },
+  ]
+}