@hiai-gg/hiai-opencode 0.1.7 → 0.1.9

package/src/tools/skill/tools.ts

@@ -1,196 +0,0 @@
-import { dirname } from "node:path"
-import { tool, type ToolDefinition } from "@opencode-ai/plugin"
-import type { ToolContext } from "@opencode-ai/plugin/tool"
-import { TOOL_DESCRIPTION_PREFIX } from "./constants"
-import type { SkillArgs, SkillLoadOptions } from "./types"
-import type { LoadedSkill } from "../../features/opencode-skill-loader"
-import { getAllSkills, clearSkillCache } from "../../features/opencode-skill-loader/skill-content"
-import { injectGitMasterConfig } from "../../features/opencode-skill-loader/skill-content"
-import { discoverCommandsSync } from "../slashcommand/command-discovery"
-import type { CommandInfo } from "../slashcommand/types"
-import { formatLoadedCommand } from "../slashcommand/command-output-formatter"
-import { formatCombinedDescription } from "./description-formatter"
-import { formatMcpCapabilities } from "./mcp-capability-formatter"
-import {
-  findPartialMatches,
-  matchCommandByName,
-  matchSkillByName,
-} from "./skill-matcher"
-import { extractSkillBody } from "./skill-body"
-import {
-  isPromiseLike,
-  loadedSkillToInfo,
-  mergeNativeSkillInfos,
-  mergeNativeSkills,
-} from "./native-skills"
-
-export function createSkillTool(options: SkillLoadOptions = {}): ToolDefinition {
-  let cachedDescription: string | null = null
-
-  const getSkills = async (): Promise<LoadedSkill[]> => {
-    clearSkillCache()
-    const discovered = await getAllSkills({
-      disabledSkills: options?.disabledSkills,
-      browserProvider: options?.browserProvider,
-    })
-    const allSkills = !options.skills
-      ? discovered
-      : [
-          ...discovered,
-          ...options.skills.filter(
-            (skill) => !new Set(discovered.map((discoveredSkill) => discoveredSkill.name)).has(skill.name)
-          ),
-        ]
-
-    if (options.nativeSkills) {
-      try {
-        const nativeAll = await options.nativeSkills.all()
-        mergeNativeSkills(allSkills, nativeAll)
-      } catch {
-      }
-    }
-
-    return allSkills
-  }
-
-  const getCommands = (): CommandInfo[] => {
-    return discoverCommandsSync(undefined, {
-      pluginsEnabled: options.pluginsEnabled,
-      enabledPluginsOverride: options.enabledPluginsOverride,
-    })
-  }
-
-  const buildDescription = async (force = false): Promise<string> => {
-    if (!force && cachedDescription) return cachedDescription
-    const skills = await getSkills()
-    const commands = getCommands()
-    const skillInfos = skills.map(loadedSkillToInfo)
-    cachedDescription = formatCombinedDescription(skillInfos, commands)
-    return cachedDescription
-  }
-
-  if (options.skills !== undefined) {
-    const skillInfos = options.skills.map(loadedSkillToInfo)
-    const commandsForDescription = options.commands ?? []
-    let needsAsyncRefresh = false
-
-    if (options.nativeSkills) {
-      try {
-        const nativeAll = options.nativeSkills.all()
-        if (isPromiseLike(nativeAll)) {
-          needsAsyncRefresh = true
-        } else {
-          mergeNativeSkillInfos(skillInfos, nativeAll)
-        }
-      } catch {
-      }
-    }
-
-    cachedDescription = formatCombinedDescription(skillInfos, commandsForDescription)
-    if (needsAsyncRefresh) {
-      void buildDescription(true)
-    }
-  } else if (options.commands !== undefined) {
-    cachedDescription = formatCombinedDescription([], options.commands)
-  } else {
-    void buildDescription()
-  }
-
-  return tool({
-    get description() {
-      if (cachedDescription === null) {
-        void buildDescription()
-      }
-      return cachedDescription ?? TOOL_DESCRIPTION_PREFIX
-    },
-    args: {
-      name: tool.schema.string().describe("The skill or command name (e.g., 'review-work' or 'publish'). Use without leading slash for commands."),
-      user_message: tool.schema
-        .string()
-        .optional()
-        .describe("Optional arguments or context for command invocation. Example: name='publish', user_message='patch'"),
-    },
-    async execute(args: SkillArgs, ctx?: ToolContext) {
-      const skills = await getSkills()
-      const commands = getCommands()
-      cachedDescription = formatCombinedDescription(skills.map(loadedSkillToInfo), commands)
-
-      const requestedName = args.name.replace(/^\//, "")
-      const matchedSkill = matchSkillByName(skills, requestedName)
-
-      if (matchedSkill) {
-        await ctx?.ask({
-          permission: "skill",
-          patterns: [matchedSkill.name],
-          always: [matchedSkill.name],
-          metadata: {
-            skill: matchedSkill.name,
-          },
-        })
-
-        if (matchedSkill.definition.agent && (!ctx?.agent || matchedSkill.definition.agent !== ctx.agent)) {
-          throw new Error(`Skill "${matchedSkill.name}" is restricted to agent "${matchedSkill.definition.agent}"`)
-        }
-
-        let body = await extractSkillBody(matchedSkill)
-
-        if (matchedSkill.name === "git-master") {
-          body = injectGitMasterConfig(body, options.gitMasterConfig)
-        }
-
-        const dir = matchedSkill.path ? dirname(matchedSkill.path) : matchedSkill.resolvedPath || process.cwd()
-
-        const output = [
-          `## Skill: ${matchedSkill.name}`,
-          "",
-          `**Base directory**: ${dir}`,
-          "",
-          body,
-        ]
-
-        if (options.mcpManager && matchedSkill.mcpConfig) {
-          const sessionID = ctx?.sessionID || options.getSessionID?.()
-
-          if (!sessionID) {
-            return output.join("\n")
-          }
-
-          const mcpInfo = await formatMcpCapabilities(
-            matchedSkill,
-            options.mcpManager,
-            sessionID
-          )
-          if (mcpInfo) {
-            output.push(mcpInfo)
-          }
-        }
-
-        return output.join("\n")
-      }
-
-      const matchedCommand = matchCommandByName(commands, requestedName)
-
-      if (matchedCommand) {
-        return await formatLoadedCommand(matchedCommand, args.user_message)
-      }
-
-      const partialMatches = findPartialMatches(skills, commands, requestedName)
-
-      if (partialMatches.length > 0) {
-        throw new Error(
-          `Skill or command "${args.name}" not found. Did you mean: ${partialMatches.join(", ")}?`
-        )
-      }
-
-      const available = [
-        ...skills.map((skill) => skill.name),
-        ...commands.map((command) => `/${command.name}`),
-      ].join(", ")
-      throw new Error(
-        `Skill or command "${args.name}" not found. Available: ${available || "none"}`
-      )
-    },
-  })
-}
-
-export const skill: ToolDefinition = createSkillTool()

package/src/tools/skill/types.ts

@@ -1,48 +0,0 @@
-import type { SkillScope, LoadedSkill } from "../../features/opencode-skill-loader/types"
-import type { SkillMcpManager } from "../../features/skill-mcp-manager"
-import type { BrowserAutomationProvider, GitMasterConfig } from "../../config/schema"
-import type { CommandInfo } from "../slashcommand/types"
-
-export interface SkillArgs {
-  name: string
-  user_message?: string
-}
-
-export interface SkillInfo {
-  name: string
-  description: string
-  location?: string
-  scope: SkillScope
-  license?: string
-  compatibility?: string
-  metadata?: Record<string, string>
-  allowedTools?: string[]
-}
-
-export interface SkillLoadOptions {
-  /** When true, only load from OpenCode paths (.opencode/skills/, ~/.config/opencode/skills/) */
-  opencodeOnly?: boolean
-  /** Pre-merged skills to use instead of discovering */
-  skills?: LoadedSkill[]
-  /** Pre-discovered commands to use instead of discovering */
-  commands?: CommandInfo[]
-  /** MCP manager for querying skill-embedded MCP servers */
-  mcpManager?: SkillMcpManager
-  /** Session ID getter for MCP client identification */
-  getSessionID?: () => string | undefined
-  /** Git master configuration for watermark/co-author settings */
-  gitMasterConfig?: GitMasterConfig
-  disabledSkills?: Set<string>
-  /** Browser automation provider for provider-gated skill filtering */
-  browserProvider?: BrowserAutomationProvider
-  /** Include Claude marketplace plugin commands in discovery (default: true) */
-  pluginsEnabled?: boolean
-  /** Override plugin enablement from Claude settings by plugin key */
-  enabledPluginsOverride?: Record<string, boolean>
-  /** Native skill accessor from PluginInput for discovering skills registered via config.skills.paths */
-  nativeSkills?: {
-    all(): { name: string; description: string; location: string; content: string }[] | Promise<{ name: string; description: string; location: string; content: string }[]>
-    get(name: string): { name: string; description: string; location: string; content: string } | undefined | Promise<{ name: string; description: string; location: string; content: string } | undefined>
-    dirs(): string[] | Promise<string[]>
-  }
-}

package/src/tools/skill-mcp/constants.ts

@@ -1,9 +0,0 @@
-export const SKILL_MCP_TOOL_NAME = "skill_mcp"
-
-export const SKILL_MCP_DESCRIPTION = `Invoke MCP server operations from skill-embedded MCPs or enabled hiai-opencode builtin MCPs. Requires mcp_name plus exactly one of: tool_name, resource_name, or prompt_name.`
-
-export const BUILTIN_MCP_TOOL_HINTS: Record<string, string[]> = {
-  context7: ["context7_resolve-library-id", "context7_query-docs"],
-  websearch: ["websearch_web_search_exa"],
-  grep_app: ["grep_app_searchGitHub"],
-}

package/src/tools/skill-mcp/index.ts

@@ -1,3 +0,0 @@
-export * from "./constants"
-export * from "./types"
-export { createSkillMcpTool } from "./tools"

package/src/tools/skill-mcp/tools.test.ts

@@ -1,44 +0,0 @@
-import { expect, test } from "bun:test"
-import type { ToolContext } from "@opencode-ai/plugin/tool"
-
-import { createSkillMcpTool } from "./tools"
-
-test("skill_mcp falls back to enabled builtin MCP when skill MCP is absent", async () => {
-  let callCaptured: { serverName: string; toolName: string } | null = null
-
-  const toolDef = createSkillMcpTool({
-    manager: {
-      async callTool(info, _context, toolName) {
-        callCaptured = { serverName: info.serverName, toolName }
-        return { ok: true }
-      },
-      async readResource() {
-        return { ok: true }
-      },
-      async getPrompt() {
-        return { ok: true }
-      },
-    } as any,
-    getLoadedSkills: () => [],
-    getSessionID: () => "session-test",
-    builtinMcp: {
-      firecrawl: {
-        enabled: true,
-        type: "local",
-        command: ["node", "firecrawl.mjs"],
-      },
-    },
-  })
-
-  const result = await toolDef.execute(
-    {
-      mcp_name: "firecrawl",
-      tool_name: "firecrawl_search",
-      arguments: { query: "test" },
-    } as any,
-    { sessionID: "session-test" } as ToolContext,
-  )
-
-  expect(callCaptured).toEqual({ serverName: "firecrawl", toolName: "firecrawl_search" })
-  expect(result).toContain("\"ok\": true")
-})

package/src/tools/skill-mcp/tools.ts

@@ -1,242 +0,0 @@
-import { tool, type ToolDefinition } from "@opencode-ai/plugin"
-import type { ToolContext } from "@opencode-ai/plugin/tool"
-import { BUILTIN_MCP_TOOL_HINTS, SKILL_MCP_DESCRIPTION } from "./constants"
-import type { McpServerConfig } from "../../config/types"
-import type { SkillMcpArgs } from "./types"
-import type { SkillMcpManager, SkillMcpClientInfo, SkillMcpServerContext } from "../../features/skill-mcp-manager"
-import type { ClaudeCodeMcpServer } from "../../features/claude-code-mcp-loader/types"
-import type { LoadedSkill } from "../../features/opencode-skill-loader/types"
-
-interface SkillMcpToolOptions {
-  manager: SkillMcpManager
-  getLoadedSkills: () => LoadedSkill[]
-  getSessionID?: () => string | undefined
-  builtinMcp?: Record<string, McpServerConfig>
-}
-
-type OperationType = { type: "tool" | "resource" | "prompt"; name: string }
-
-function validateOperationParams(args: SkillMcpArgs): OperationType {
-  const operations: OperationType[] = []
-  if (args.tool_name) operations.push({ type: "tool", name: args.tool_name })
-  if (args.resource_name) operations.push({ type: "resource", name: args.resource_name })
-  if (args.prompt_name) operations.push({ type: "prompt", name: args.prompt_name })
-
-  if (operations.length === 0) {
-    throw new Error(
-      `Missing operation. Exactly one of tool_name, resource_name, or prompt_name must be specified.\n\n` +
-        `Examples:\n` +
-        `  skill_mcp(mcp_name="sqlite", tool_name="query", arguments='{"sql": "SELECT * FROM users"}')\n` +
-        `  skill_mcp(mcp_name="memory", resource_name="memory://notes")\n` +
-        `  skill_mcp(mcp_name="helper", prompt_name="summarize", arguments='{"text": "..."}')`,
-    )
-  }
-
-  if (operations.length > 1) {
-    const provided = [
-      args.tool_name && `tool_name="${args.tool_name}"`,
-      args.resource_name && `resource_name="${args.resource_name}"`,
-      args.prompt_name && `prompt_name="${args.prompt_name}"`,
-    ]
-      .filter(Boolean)
-      .join(", ")
-
-    throw new Error(
-      `Multiple operations specified. Exactly one of tool_name, resource_name, or prompt_name must be provided.\n\n` +
-        `Received: ${provided}\n\n` +
-        `Use separate calls for each operation.`,
-    )
-  }
-
-  return operations[0]
-}
-
-function findMcpServer(
-  mcpName: string,
-  skills: LoadedSkill[],
-): { skill: LoadedSkill; config: NonNullable<LoadedSkill["mcpConfig"]>[string] } | null {
-  for (const skill of skills) {
-    if (skill.mcpConfig && mcpName in skill.mcpConfig) {
-      return { skill, config: skill.mcpConfig[mcpName] }
-    }
-  }
-  return null
-}
-
-function convertBuiltinMcpConfig(config: McpServerConfig): ClaudeCodeMcpServer | null {
-  if (config.enabled === false) return null
-
-  if (config.type === "remote") {
-    return {
-      type: "http",
-      url: config.url,
-      headers: config.headers,
-    }
-  }
-
-  const [command, ...args] = config.command ?? []
-  if (!command) return null
-
-  return {
-    type: "stdio",
-    command,
-    args,
-    env: config.environment,
-  }
-}
-
-function formatAvailableMcps(skills: LoadedSkill[]): string {
-  const mcps: string[] = []
-  for (const skill of skills) {
-    if (skill.mcpConfig) {
-      for (const serverName of Object.keys(skill.mcpConfig)) {
-        mcps.push(`  - "${serverName}" from skill "${skill.name}"`)
-      }
-    }
-  }
-  return mcps.length > 0 ? mcps.join("\n") : "  (none found)"
-}
-
-function formatAvailableBuiltinMcps(builtinMcp: Record<string, McpServerConfig> | undefined): string {
-  const names = Object.entries(builtinMcp ?? {})
-    .filter(([, config]) => config.enabled !== false)
-    .map(([name]) => `  - "${name}" from hiai-opencode config`)
-
-  return names.length > 0 ? names.join("\n") : "  (none found)"
-}
-
-function formatBuiltinMcpHint(mcpName: string): string | null {
-  const nativeTools = BUILTIN_MCP_TOOL_HINTS[mcpName]
-  if (!nativeTools) return null
-  return (
-    `"${mcpName}" is a builtin MCP, not a skill MCP.\n` +
-    `Use the native tools directly:\n` +
-    nativeTools.map((toolName) => `  - ${toolName}`).join("\n")
-  )
-}
-
-function parseArguments(argsJson: string | Record<string, unknown> | undefined): Record<string, unknown> {
-  if (!argsJson) return {}
-  if (typeof argsJson === "object" && argsJson !== null) {
-    return argsJson
-  }
-  try {
-    // Strip outer single quotes if present (common in LLM output)
-    const jsonStr = argsJson.startsWith("'") && argsJson.endsWith("'") ? argsJson.slice(1, -1) : argsJson
-
-    const parsed = JSON.parse(jsonStr)
-    if (typeof parsed !== "object" || parsed === null) {
-      throw new Error("Arguments must be a JSON object")
-    }
-    return parsed as Record<string, unknown>
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error)
-    throw new Error(
-      `Invalid arguments JSON: ${errorMessage}\n\n` +
-        `Expected a valid JSON object, e.g.: '{"key": "value"}'\n` +
-        `Received: ${argsJson}`,
-    )
-  }
-}
-
-export function applyGrepFilter(output: string, pattern: string | undefined): string {
-  if (!pattern) return output
-  try {
-    const regex = new RegExp(pattern, "i")
-    const lines = output.split("\n")
-    const filtered = lines.filter((line) => regex.test(line))
-    return filtered.length > 0 ? filtered.join("\n") : `[grep] No lines matched pattern: ${pattern}`
-  } catch {
-    return output
-  }
-}
-
-export function createSkillMcpTool(options: SkillMcpToolOptions): ToolDefinition {
-  const { manager, getLoadedSkills, getSessionID, builtinMcp } = options
-
-  return tool({
-    description: SKILL_MCP_DESCRIPTION,
-    args: {
-      mcp_name: tool.schema.string().describe("Name of the MCP server from skill config"),
-      tool_name: tool.schema.string().optional().describe("MCP tool to call"),
-      resource_name: tool.schema.string().optional().describe("MCP resource URI to read"),
-      prompt_name: tool.schema.string().optional().describe("MCP prompt to get"),
-      arguments: tool.schema
-        .union([tool.schema.string(), tool.schema.object({})])
-        .optional()
-        .describe("JSON string or object of arguments"),
-      grep: tool.schema
-        .string()
-        .optional()
-        .describe("Regex pattern to filter output lines (only matching lines returned)"),
-    },
-    async execute(args: SkillMcpArgs, toolContext: ToolContext) {
-      const operation = validateOperationParams(args)
-      const skills = getLoadedSkills()
-      const found = findMcpServer(args.mcp_name, skills)
-      const builtinConfig = builtinMcp?.[args.mcp_name]
-      const convertedBuiltinConfig = builtinConfig ? convertBuiltinMcpConfig(builtinConfig) : null
-
-      if (!found && !convertedBuiltinConfig) {
-        const builtinHint = formatBuiltinMcpHint(args.mcp_name)
-        if (builtinHint) {
-          throw new Error(builtinHint)
-        }
-
-        throw new Error(
-          `MCP server "${args.mcp_name}" not found.\n\n` +
-            `Available MCP servers in loaded skills:\n` +
-            formatAvailableMcps(skills) +
-            `\n\n` +
-            `Available MCP servers in hiai-opencode config:\n` +
-            formatAvailableBuiltinMcps(builtinMcp) +
-            `\n\n` +
-            `Hint: Load the skill first for skill-embedded MCPs. Builtin hiai-opencode MCPs can be called directly when enabled in hiai-opencode.json.`,
-        )
-      }
-
-      const sessionID = toolContext.sessionID || getSessionID?.()
-      if (!sessionID) {
-        throw new Error("No active session available for skill MCP call.")
-      }
-
-      const info: SkillMcpClientInfo = {
-        serverName: args.mcp_name,
-        skillName: found?.skill.name ?? "hiai-opencode",
-        sessionID,
-        scope: found?.skill.scope ?? "user",
-      }
-
-      const context: SkillMcpServerContext = {
-        config: found?.config ?? convertedBuiltinConfig!,
-        skillName: found?.skill.name ?? "hiai-opencode",
-      }
-
-      const parsedArgs = parseArguments(args.arguments)
-
-      let output: string
-      switch (operation.type) {
-        case "tool": {
-          const result = await manager.callTool(info, context, operation.name, parsedArgs)
-          output = JSON.stringify(result, null, 2)
-          break
-        }
-        case "resource": {
-          const result = await manager.readResource(info, context, operation.name)
-          output = JSON.stringify(result, null, 2)
-          break
-        }
-        case "prompt": {
-          const stringArgs: Record<string, string> = {}
-          for (const [key, value] of Object.entries(parsedArgs)) {
-            stringArgs[key] = String(value)
-          }
-          const result = await manager.getPrompt(info, context, operation.name, stringArgs)
-          output = JSON.stringify(result, null, 2)
-          break
-        }
-      }
-      return applyGrepFilter(output, args.grep)
-    },
-  })
-}

package/src/tools/skill-mcp/types.ts

@@ -1,8 +0,0 @@
-export interface SkillMcpArgs {
-  mcp_name: string
-  tool_name?: string
-  resource_name?: string
-  prompt_name?: string
-  arguments?: string | Record<string, unknown>
-  grep?: string
-}