@hiai-gg/hiai-opencode 0.1.7 → 0.1.8

package/src/features/claude-code-plugin-loader/discovery.ts

@@ -1,251 +0,0 @@
-import { existsSync, readFileSync } from "fs"
-import { homedir } from "os"
-import { basename, join } from "path"
-import { fileURLToPath } from "url"
-import { log } from "../../shared/logger"
-import { shouldLoadPluginForCwd } from "./scope-filter"
-import type {
-  InstalledPluginsDatabase,
-  InstalledPluginEntryV3,
-  PluginInstallation,
-  PluginManifest,
-  LoadedPlugin,
-  PluginLoadResult,
-  PluginLoadError,
-  PluginScope,
-  ClaudeSettings,
-  PluginLoaderOptions,
-} from "./types"
-
-function getPluginsBaseDir(): string {
-  if (process.env.CLAUDE_PLUGINS_HOME) {
-    return process.env.CLAUDE_PLUGINS_HOME
-  }
-  return join(homedir(), ".claude", "plugins")
-}
-
-function getInstalledPluginsPath(pluginsBaseDir?: string): string {
-  return join(pluginsBaseDir ?? getPluginsBaseDir(), "installed_plugins.json")
-}
-
-function loadInstalledPlugins(pluginsBaseDir?: string): InstalledPluginsDatabase | null {
-  const dbPath = getInstalledPluginsPath(pluginsBaseDir)
-  if (!existsSync(dbPath)) {
-    return null
-  }
-
-  try {
-    const content = readFileSync(dbPath, "utf-8")
-    return JSON.parse(content) as InstalledPluginsDatabase
-  } catch (error) {
-    log("Failed to load installed plugins database", error)
-    return null
-  }
-}
-
-function getClaudeSettingsPath(): string {
-  if (process.env.CLAUDE_SETTINGS_PATH) {
-    return process.env.CLAUDE_SETTINGS_PATH
-  }
-  return join(homedir(), ".claude", "settings.json")
-}
-
-function loadClaudeSettings(): ClaudeSettings | null {
-  const settingsPath = getClaudeSettingsPath()
-  if (!existsSync(settingsPath)) {
-    return null
-  }
-
-  try {
-    const content = readFileSync(settingsPath, "utf-8")
-    return JSON.parse(content) as ClaudeSettings
-  } catch (error) {
-    log("Failed to load Claude settings", error)
-    return null
-  }
-}
-
-export function loadPluginManifest(installPath: string): PluginManifest | null {
-  const manifestPath = join(installPath, ".claude-plugin", "plugin.json")
-  if (!existsSync(manifestPath)) {
-    return null
-  }
-
-  try {
-    const content = readFileSync(manifestPath, "utf-8")
-    return JSON.parse(content) as PluginManifest
-  } catch (error) {
-    log(`Failed to load plugin manifest from ${manifestPath}`, error)
-    return null
-  }
-}
-
-function derivePluginNameFromKey(pluginKey: string): string {
-  const keyWithoutSource = pluginKey.startsWith("npm:") ? pluginKey.slice(4) : pluginKey
-
-  let versionSeparator: number
-  if (keyWithoutSource.startsWith("@")) {
-    const scopeEnd = keyWithoutSource.indexOf("/")
-    versionSeparator = scopeEnd > 0 ? keyWithoutSource.indexOf("@", scopeEnd) : -1
-  } else {
-    versionSeparator = keyWithoutSource.lastIndexOf("@")
-  }
-  const keyWithoutVersion = versionSeparator > 0 ? keyWithoutSource.slice(0, versionSeparator) : keyWithoutSource
-
-  if (keyWithoutVersion.startsWith("file://")) {
-    try {
-      return basename(fileURLToPath(keyWithoutVersion))
-    } catch {
-      return basename(keyWithoutVersion)
-    }
-  }
-
-  if (keyWithoutVersion.startsWith("@") && keyWithoutVersion.includes("/")) {
-    return keyWithoutVersion
-  }
-
-  if (keyWithoutVersion.includes("/") || keyWithoutVersion.includes("\\")) {
-    return basename(keyWithoutVersion)
-  }
-
-  return keyWithoutVersion
-}
-
-function isPluginEnabled(
-  pluginKey: string,
-  settingsEnabledPlugins: Record<string, boolean> | undefined,
-  overrideEnabledPlugins: Record<string, boolean> | undefined,
-): boolean {
-  if (overrideEnabledPlugins && pluginKey in overrideEnabledPlugins) {
-    return overrideEnabledPlugins[pluginKey]
-  }
-  if (settingsEnabledPlugins && pluginKey in settingsEnabledPlugins) {
-    return settingsEnabledPlugins[pluginKey]
-  }
-  return true
-}
-
-function v3EntryToInstallation(entry: InstalledPluginEntryV3): PluginInstallation {
-  return {
-    scope: entry.scope,
-    installPath: entry.installPath,
-    version: entry.version,
-    installedAt: entry.lastUpdated,
-    lastUpdated: entry.lastUpdated,
-    gitCommitSha: entry.gitCommitSha,
-    projectPath: entry.projectPath,
-  }
-}
-
-function isValidV3Entry(entry: unknown): entry is InstalledPluginEntryV3 {
-  return (
-    entry != null &&
-    typeof entry === "object" &&
-    typeof (entry as Record<string, unknown>).name === "string" &&
-    typeof (entry as Record<string, unknown>).marketplace === "string" &&
-    typeof (entry as Record<string, unknown>).installPath === "string"
-  )
-}
-
-function extractPluginEntries(
-  db: InstalledPluginsDatabase,
-): Array<[string, PluginInstallation | undefined]> {
-  if (Array.isArray(db)) {
-    return db
-      .filter(isValidV3Entry)
-      .map((entry) => [
-        `${entry.name}@${entry.marketplace}`,
-        v3EntryToInstallation(entry),
-      ])
-  }
-  if (db.version === 1) {
-    return Object.entries(db.plugins).map(([key, installation]) => [key, installation])
-  }
-  return Object.entries(db.plugins).map(([key, installations]) => [key, installations[0]])
-}
-
-export function discoverInstalledPlugins(options?: PluginLoaderOptions): PluginLoadResult {
-  // Allow overriding the plugins base directory for testing
-  const pluginsBaseDir = options?.pluginsHomeOverride ?? getPluginsBaseDir()
-  const db = loadInstalledPlugins(pluginsBaseDir)
-  const settings = loadClaudeSettings()
-  const plugins: LoadedPlugin[] = []
-  const errors: PluginLoadError[] = []
-
-  if (!db || (!Array.isArray(db) && !db.plugins)) {
-    return { plugins, errors }
-  }
-
-  const settingsEnabledPlugins = settings?.enabledPlugins
-  const overrideEnabledPlugins = options?.enabledPluginsOverride
-  const pluginManifestLoader = options?.loadPluginManifestOverride ?? loadPluginManifest
-  const cwd = process.cwd()
-
-  for (const [pluginKey, installation] of extractPluginEntries(db)) {
-    if (!installation) continue
-
-    if (!isPluginEnabled(pluginKey, settingsEnabledPlugins, overrideEnabledPlugins)) {
-      log(`Plugin disabled: ${pluginKey}`)
-      continue
-    }
-
-    if (!shouldLoadPluginForCwd(installation, cwd)) {
-      log(`Skipping ${installation.scope}-scoped plugin outside current cwd: ${pluginKey}`, {
-        projectPath: installation.projectPath,
-        cwd,
-      })
-      continue
-    }
-
-    const { installPath, scope, version } = installation
-
-    if (!existsSync(installPath)) {
-      errors.push({
-        pluginKey,
-        installPath,
-        error: "Plugin installation path does not exist",
-      })
-      continue
-    }
-
-    const manifest = pluginManifestLoader(installPath)
-    const pluginName = manifest?.name || derivePluginNameFromKey(pluginKey)
-
-    const loadedPlugin: LoadedPlugin = {
-      name: pluginName,
-      version: version || manifest?.version || "unknown",
-      scope: scope as PluginScope,
-      installPath,
-      pluginKey,
-      manifest: manifest ?? undefined,
-    }
-
-    if (existsSync(join(installPath, "commands"))) {
-      loadedPlugin.commandsDir = join(installPath, "commands")
-    }
-    if (existsSync(join(installPath, "agents"))) {
-      loadedPlugin.agentsDir = join(installPath, "agents")
-    }
-    if (existsSync(join(installPath, "skills"))) {
-      loadedPlugin.skillsDir = join(installPath, "skills")
-    }
-
-    const hooksPath = join(installPath, "hooks", "hooks.json")
-    if (existsSync(hooksPath)) {
-      loadedPlugin.hooksPath = hooksPath
-    }
-
-    const mcpPath = join(installPath, ".mcp.json")
-    if (existsSync(mcpPath)) {
-      loadedPlugin.mcpPath = mcpPath
-    }
-
-    plugins.push(loadedPlugin)
-    log(`Discovered plugin: ${pluginName}@${version} (${scope})`, {
-      installPath,
-      hasManifest: !!manifest,
-    })
-  }
-
-  return { plugins, errors }
-}

package/src/features/claude-code-plugin-loader/hook-loader.ts

@@ -1,26 +0,0 @@
-import { existsSync, readFileSync } from "fs"
-import { log } from "../../shared/logger"
-import type { HooksConfig, LoadedPlugin } from "./types"
-import { resolvePluginPaths } from "./plugin-path-resolver"
-
-export function loadPluginHooksConfigs(plugins: LoadedPlugin[]): HooksConfig[] {
-  const configs: HooksConfig[] = []
-
-  for (const plugin of plugins) {
-    if (!plugin.hooksPath || !existsSync(plugin.hooksPath)) continue
-
-    try {
-      const content = readFileSync(plugin.hooksPath, "utf-8")
-      let config = JSON.parse(content) as HooksConfig
-
-      config = resolvePluginPaths(config, plugin.installPath)
-
-      configs.push(config)
-      log(`Loaded plugin hooks config from ${plugin.name}`, { path: plugin.hooksPath })
-    } catch (error) {
-      log(`Failed to load plugin hooks config: ${plugin.hooksPath}`, error)
-    }
-  }
-
-  return configs
-}

package/src/features/claude-code-plugin-loader/index.ts

@@ -1,10 +0,0 @@
-export * from "./types"
-export * from "./loader"
-export * from "./discovery"
-export * from "./plugin-path-resolver"
-export * from "./command-loader"
-export * from "./skill-loader"
-export * from "./agent-loader"
-export * from "./mcp-server-loader"
-export * from "./hook-loader"
-export type { PluginLoaderOptions, ClaudeSettings } from "./types"

package/src/features/claude-code-plugin-loader/loader.ts

@@ -1,134 +0,0 @@
-import { log } from "../../shared/logger"
-import type { CommandDefinition } from "../claude-code-command-loader/types"
-import type { McpServerConfig } from "../claude-code-mcp-loader/types"
-import type { ClaudeCodeAgentConfig } from "../claude-code-agent-loader/types"
-import type { HooksConfig, LoadedPlugin, PluginLoadError, PluginLoaderOptions } from "./types"
-import { discoverInstalledPlugins } from "./discovery"
-import { loadPluginCommands } from "./command-loader"
-import { loadPluginSkillsAsCommands } from "./skill-loader"
-import { loadPluginAgents } from "./agent-loader"
-import { loadPluginMcpServers } from "./mcp-server-loader"
-import { loadPluginHooksConfigs } from "./hook-loader"
-
-export { discoverInstalledPlugins } from "./discovery"
-export { loadPluginCommands } from "./command-loader"
-export { loadPluginSkillsAsCommands } from "./skill-loader"
-export { loadPluginAgents } from "./agent-loader"
-export { loadPluginMcpServers } from "./mcp-server-loader"
-export { loadPluginHooksConfigs } from "./hook-loader"
-
-export interface PluginComponentsResult {
-  commands: Record<string, CommandDefinition>
-  skills: Record<string, CommandDefinition>
-  agents: Record<string, ClaudeCodeAgentConfig>
-  mcpServers: Record<string, McpServerConfig>
-  hooksConfigs: HooksConfig[]
-  plugins: LoadedPlugin[]
-  errors: PluginLoadError[]
-}
-
-export interface PluginComponentLoadDeps {
-  discoverInstalledPlugins: typeof discoverInstalledPlugins
-  loadPluginCommands: typeof loadPluginCommands
-  loadPluginSkillsAsCommands: typeof loadPluginSkillsAsCommands
-  loadPluginAgents: typeof loadPluginAgents
-  loadPluginMcpServers: typeof loadPluginMcpServers
-  loadPluginHooksConfigs: typeof loadPluginHooksConfigs
-}
-
-const cachedPluginComponentsByKey = new Map<string, PluginComponentsResult>()
-
-const defaultPluginComponentLoadDeps: PluginComponentLoadDeps = {
-  discoverInstalledPlugins,
-  loadPluginCommands,
-  loadPluginSkillsAsCommands,
-  loadPluginAgents,
-  loadPluginMcpServers,
-  loadPluginHooksConfigs,
-}
-
-function clonePluginComponentsResult(
-  result: PluginComponentsResult,
-): PluginComponentsResult {
-  return structuredClone(result)
-}
-
-function isClaudeCodePluginsDisabled(): boolean {
-  const disableFlag = process.env.OPENCODE_DISABLE_CLAUDE_CODE
-  const disablePluginsFlag = process.env.OPENCODE_DISABLE_CLAUDE_CODE_PLUGINS
-  return disableFlag === "true" || disableFlag === "1" || disablePluginsFlag === "true" || disablePluginsFlag === "1"
-}
-
-function getPluginComponentsCacheKey(options?: PluginLoaderOptions): string {
-  const overrideEntries = Object.entries(options?.enabledPluginsOverride ?? {})
-    .sort(([leftKey], [rightKey]) => leftKey.localeCompare(rightKey))
-
-  return JSON.stringify({
-    enabledPluginsOverride: overrideEntries,
-  })
-}
-
-export function clearPluginComponentsCache(): void {
-  cachedPluginComponentsByKey.clear()
-}
-
-async function loadAllPluginComponentsInternal(
-  options?: PluginLoaderOptions,
-  deps: PluginComponentLoadDeps = defaultPluginComponentLoadDeps,
-): Promise<PluginComponentsResult> {
-  if (isClaudeCodePluginsDisabled()) {
-    log("Claude Code plugin loading disabled via OPENCODE_DISABLE_CLAUDE_CODE env var")
-    return {
-      commands: {},
-      skills: {},
-      agents: {},
-      mcpServers: {},
-      hooksConfigs: [],
-      plugins: [],
-      errors: [],
-    }
-  }
-
-  const cacheKey = getPluginComponentsCacheKey(options)
-  const cachedPluginComponents = cachedPluginComponentsByKey.get(cacheKey)
-  if (cachedPluginComponents) {
-    return clonePluginComponentsResult(cachedPluginComponents)
-  }
-
-  const { plugins, errors } = deps.discoverInstalledPlugins(options)
-
-  const [commands, skills, agents, mcpServers, hooksConfigs] = await Promise.all([
-    Promise.resolve(deps.loadPluginCommands(plugins)),
-    Promise.resolve(deps.loadPluginSkillsAsCommands(plugins)),
-    Promise.resolve(deps.loadPluginAgents(plugins)),
-    deps.loadPluginMcpServers(plugins),
-    Promise.resolve(deps.loadPluginHooksConfigs(plugins)),
-  ])
-
-  log(`Loaded ${plugins.length} plugins with ${Object.keys(commands).length} commands, ${Object.keys(skills).length} skills, ${Object.keys(agents).length} agents, ${Object.keys(mcpServers).length} MCP servers`)
-
-  const result = {
-    commands,
-    skills,
-    agents,
-    mcpServers,
-    hooksConfigs,
-    plugins,
-    errors,
-  }
-
-  cachedPluginComponentsByKey.set(cacheKey, clonePluginComponentsResult(result))
-
-  return clonePluginComponentsResult(result)
-}
-
-export async function loadAllPluginComponents(options?: PluginLoaderOptions): Promise<PluginComponentsResult> {
-  return loadAllPluginComponentsInternal(options)
-}
-
-export async function loadAllPluginComponentsWithDeps(
-  options: PluginLoaderOptions | undefined,
-  deps: PluginComponentLoadDeps,
-): Promise<PluginComponentsResult> {
-  return loadAllPluginComponentsInternal(options, deps)
-}

package/src/features/claude-code-plugin-loader/mcp-server-loader.ts

@@ -1,59 +0,0 @@
-import { existsSync } from "fs"
-import type { McpServerConfig } from "../claude-code-mcp-loader/types"
-import { expandEnvVarsInObject } from "../claude-code-mcp-loader/env-expander"
-import { shouldLoadMcpServer } from "../claude-code-mcp-loader/scope-filter"
-import { transformMcpServer } from "../claude-code-mcp-loader/transformer"
-import type { ClaudeCodeMcpConfig } from "../claude-code-mcp-loader/types"
-import { log } from "../../shared/logger"
-import type { LoadedPlugin } from "./types"
-import { resolvePluginPaths } from "./plugin-path-resolver"
-
-export async function loadPluginMcpServers(
-  plugins: LoadedPlugin[],
-): Promise<Record<string, McpServerConfig>> {
-  const servers: Record<string, McpServerConfig> = {}
-  const cwd = process.cwd()
-
-  for (const plugin of plugins) {
-    if (!plugin.mcpPath || !existsSync(plugin.mcpPath)) continue
-
-    try {
-      const content = await Bun.file(plugin.mcpPath).text()
-      let config = JSON.parse(content) as ClaudeCodeMcpConfig
-
-      config = resolvePluginPaths(config, plugin.installPath)
-      config = expandEnvVarsInObject(config)
-
-      if (!config.mcpServers) continue
-
-      for (const [name, serverConfig] of Object.entries(config.mcpServers)) {
-        if (!shouldLoadMcpServer(serverConfig, cwd)) {
-          log(`Skipping local plugin MCP server "${name}" outside current cwd`, {
-            path: plugin.mcpPath,
-            projectPath: serverConfig.projectPath,
-            cwd,
-          })
-          continue
-        }
-
-        if (serverConfig.disabled) {
-          log(`Skipping disabled MCP server "${name}" from plugin ${plugin.name}`)
-          continue
-        }
-
-        try {
-          const transformed = transformMcpServer(name, serverConfig)
-          const namespacedName = `${plugin.name}:${name}`
-          servers[namespacedName] = transformed
-          log(`Loaded plugin MCP server: ${namespacedName}`, { path: plugin.mcpPath })
-        } catch (error) {
-          log(`Failed to transform plugin MCP server "${name}"`, error)
-        }
-      }
-    } catch (error) {
-      log(`Failed to load plugin MCP config: ${plugin.mcpPath}`, error)
-    }
-  }
-
-  return servers
-}

package/src/features/claude-code-plugin-loader/plugin-path-resolver.ts

@@ -1,23 +0,0 @@
-const CLAUDE_PLUGIN_ROOT_VAR = "${CLAUDE_PLUGIN_ROOT}"
-
-export function resolvePluginPath(path: string, pluginRoot: string): string {
-  return path.replace(CLAUDE_PLUGIN_ROOT_VAR, pluginRoot)
-}
-
-export function resolvePluginPaths<T>(obj: T, pluginRoot: string): T {
-  if (obj == null) return obj
-  if (typeof obj === "string") {
-    return resolvePluginPath(obj, pluginRoot) as T
-  }
-  if (Array.isArray(obj)) {
-    return obj.map((item) => resolvePluginPaths(item, pluginRoot)) as T
-  }
-  if (typeof obj === "object") {
-    const result: Record<string, unknown> = {}
-    for (const [key, value] of Object.entries(obj)) {
-      result[key] = resolvePluginPaths(value, pluginRoot)
-    }
-    return result as T
-  }
-  return obj
-}

package/src/features/claude-code-plugin-loader/scope-filter.ts

@@ -1,29 +0,0 @@
-import { homedir } from "os"
-import { join } from "path"
-import { containsPath } from "../../shared/contains-path"
-import type { PluginInstallation } from "./types"
-
-function expandTilde(inputPath: string): string {
-  if (inputPath === "~") {
-    return homedir()
-  }
-  if (inputPath.startsWith("~/") || inputPath.startsWith("~\\")) {
-    return join(homedir(), inputPath.slice(2))
-  }
-  return inputPath
-}
-
-export function shouldLoadPluginForCwd(
-  installation: Pick<PluginInstallation, "scope" | "projectPath">,
-  cwd: string = process.cwd(),
-): boolean {
-  if (installation.scope !== "project" && installation.scope !== "local") {
-    return true
-  }
-
-  if (!installation.projectPath) {
-    return false
-  }
-
-  return containsPath(expandTilde(installation.projectPath), cwd)
-}

package/src/features/claude-code-plugin-loader/skill-loader.ts

@@ -1,62 +0,0 @@
-import { existsSync, readdirSync, readFileSync } from "fs"
-import { join } from "path"
-import { parseFrontmatter } from "../../shared/frontmatter"
-import { resolveSymlink } from "../../shared/file-utils"
-import { sanitizeModelField } from "../../shared/model-sanitizer"
-import { resolveSkillPathReferences } from "../../shared/skill-path-resolver"
-import { log } from "../../shared/logger"
-import type { CommandDefinition } from "../claude-code-command-loader/types"
-import type { SkillMetadata } from "../opencode-skill-loader/types"
-import type { LoadedPlugin } from "./types"
-
-export function loadPluginSkillsAsCommands(
-  plugins: LoadedPlugin[],
-): Record<string, CommandDefinition> {
-  const skills: Record<string, CommandDefinition> = {}
-
-  for (const plugin of plugins) {
-    if (!plugin.skillsDir || !existsSync(plugin.skillsDir)) continue
-
-    const entries = readdirSync(plugin.skillsDir, { withFileTypes: true })
-
-    for (const entry of entries) {
-      if (entry.name.startsWith(".")) continue
-
-      const skillPath = join(plugin.skillsDir, entry.name)
-      if (!entry.isDirectory() && !entry.isSymbolicLink()) continue
-
-      const resolvedPath = resolveSymlink(skillPath)
-      const skillMdPath = join(resolvedPath, "SKILL.md")
-      if (!existsSync(skillMdPath)) continue
-
-      try {
-        const content = readFileSync(skillMdPath, "utf-8")
-        const { data, body } = parseFrontmatter<SkillMetadata>(content)
-
-        const skillName = data.name || entry.name
-        const namespacedName = `${plugin.name}:${skillName}`
-        const originalDescription = data.description || ""
-        const formattedDescription = `(plugin: ${plugin.name} - Skill) ${originalDescription}`
-
-        const resolvedBody = resolveSkillPathReferences(body.trim(), resolvedPath)
-        const wrappedTemplate = `<skill-instruction>\nBase directory for this skill: ${resolvedPath}/\nFile references (@path) in this skill are relative to this directory.\n\n${resolvedBody}\n</skill-instruction>\n\n<user-request>\n$ARGUMENTS\n</user-request>`
-
-        const definition = {
-          name: namespacedName,
-          description: formattedDescription,
-          template: wrappedTemplate,
-          model: sanitizeModelField(data.model),
-        }
-
-        const { name: _name, ...openCodeCompatible } = definition
-        skills[namespacedName] = openCodeCompatible as CommandDefinition
-
-        log(`Loaded plugin skill: ${namespacedName}`, { path: resolvedPath })
-      } catch (error) {
-        log(`Failed to load plugin skill: ${skillPath}`, error)
-      }
-    }
-  }
-
-  return skills
-}