@toolkit-cli/toolkode 1.3.8 → 1.3.9

package/src/skill/index.ts

@@ -1,284 +0,0 @@
-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

@@ -1,305 +0,0 @@
-/**
- * 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 },
-  ]
-}