@hiai-gg/hiai-opencode 0.1.6 → 0.1.8

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
-}

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

@@ -1,255 +0,0 @@
-/**
- * Claude Code Plugin Types
- * 
- * Type definitions for Claude Code plugin system compatibility.
- * Based on https://code.claude.com/docs/en/plugins-reference
- */
-
-export type PluginScope = "user" | "project" | "local" | "managed"
-
-/**
- * Plugin installation entry in installed_plugins.json
- */
-export interface PluginInstallation {
-  scope: PluginScope
-  installPath: string
-  version: string
-  installedAt: string
-  lastUpdated: string
-  gitCommitSha?: string
-  isLocal?: boolean
-  /**
-   * Claude Code records this on project/local-scoped installations.
-   * Absolute path (or `~`-prefixed) of the project the plugin was installed for.
-   * Used to filter project/local plugins that do not belong to the current cwd.
-   */
-  projectPath?: string
-}
-
-/**
- * Installed plugins database v1 (legacy)
- * plugins stored as direct objects
- */
-export interface InstalledPluginsDatabaseV1 {
-  version: 1
-  plugins: Record<string, PluginInstallation>
-}
-
-/**
- * Installed plugins database v2
- * plugins stored as arrays keyed by plugin identifier
- */
-export interface InstalledPluginsDatabaseV2 {
-  version: 2
-  plugins: Record<string, PluginInstallation[]>
-}
-
-/**
- * Installed plugins database v3 entry (current Claude Code format)
- * A flat array of plugin entries, each containing name and marketplace fields
- * used to construct the plugin key as "name@marketplace".
- */
-export interface InstalledPluginEntryV3 {
-  name: string
-  marketplace: string
-  scope: PluginScope
-  version: string
-  installPath: string
-  lastUpdated: string
-  gitCommitSha?: string
-  /**
-   * Claude Code records this on project/local-scoped installations.
-   * Absolute path (or `~`-prefixed) of the project the plugin was installed for.
-   */
-  projectPath?: string
-}
-
-/**
- * Installed plugins database structure
- * Located at ~/.claude/plugins/installed_plugins.json
- *
- * Supports three formats:
- * - v1: { version: 1, plugins: Record<string, PluginInstallation> }
- * - v2: { version: 2, plugins: Record<string, PluginInstallation[]> }
- * - v3: InstalledPluginEntryV3[] (flat array, current Claude Code format)
- */
-export type InstalledPluginsDatabase =
-  | InstalledPluginsDatabaseV1
-  | InstalledPluginsDatabaseV2
-  | InstalledPluginEntryV3[]
-
-/**
- * Plugin author information
- */
-export interface PluginAuthor {
-  name?: string
-  email?: string
-  url?: string
-}
-
-/**
- * Plugin manifest (plugin.json)
- * Located at <plugin_root>/.claude-plugin/plugin.json
- */
-export interface PluginManifest {
-  name: string
-  version?: string
-  description?: string
-  author?: PluginAuthor
-  homepage?: string
-  repository?: string
-  license?: string
-  keywords?: string[]
-  
-  // Component paths (can be string or array)
-  commands?: string | string[]
-  agents?: string | string[]
-  skills?: string | string[]
-  hooks?: string | HooksConfig
-  mcpServers?: string | McpServersConfig
-  lspServers?: string | LspServersConfig
-  outputStyles?: string | string[]
-}
-
-/**
- * Hooks configuration
- */
-export type HookEntry =
-  | { type: "command"; command?: string }
-  | { type: "prompt"; prompt?: string }
-  | { type: "agent"; agent?: string }
-  | { type: "http"; url: string; headers?: Record<string, string>; allowedEnvVars?: string[]; timeout?: number }
-
-export interface HookMatcher {
-  matcher?: string
-  hooks: HookEntry[]
-}
-
-export interface HooksConfig {
-  hooks?: {
-    PreToolUse?: HookMatcher[]
-    PostToolUse?: HookMatcher[]
-    PostToolUseFailure?: HookMatcher[]
-    PermissionRequest?: HookMatcher[]
-    UserPromptSubmit?: HookMatcher[]
-    Notification?: HookMatcher[]
-    Stop?: HookMatcher[]
-    SubagentStart?: HookMatcher[]
-    SubagentStop?: HookMatcher[]
-    SessionStart?: HookMatcher[]
-    SessionEnd?: HookMatcher[]
-    PreCompact?: HookMatcher[]
-  }
-}
-
-/**
- * MCP servers configuration in plugin
- */
-export interface PluginMcpServer {
-  command?: string
-  args?: string[]
-  env?: Record<string, string>
-  cwd?: string
-  url?: string
-  type?: "stdio" | "http" | "sse"
-  disabled?: boolean
-}
-
-export interface McpServersConfig {
-  mcpServers?: Record<string, PluginMcpServer>
-}
-
-/**
- * LSP server configuration
- */
-export interface LspServerConfig {
-  command: string
-  args?: string[]
-  extensionToLanguage: Record<string, string>
-  transport?: "stdio" | "socket"
-  env?: Record<string, string>
-  initializationOptions?: Record<string, unknown>
-  settings?: Record<string, unknown>
-  workspaceFolder?: string
-  startupTimeout?: number
-  shutdownTimeout?: number
-  restartOnCrash?: boolean
-  maxRestarts?: number
-  loggingConfig?: {
-    args?: string[]
-    env?: Record<string, string>
-  }
-}
-
-export interface LspServersConfig {
-  [language: string]: LspServerConfig
-}
-
-/**
- * Loaded plugin with all resolved components
- */
-export interface LoadedPlugin {
-  name: string
-  version: string
-  scope: PluginScope
-  installPath: string
-  manifest?: PluginManifest
-  pluginKey: string
-  
-  // Resolved paths for components
-  commandsDir?: string
-  agentsDir?: string
-  skillsDir?: string
-  hooksPath?: string
-  mcpPath?: string
-  lspPath?: string
-}
-
-/**
- * Plugin load result with all components
- */
-export interface PluginLoadResult {
-  plugins: LoadedPlugin[]
-  errors: PluginLoadError[]
-}
-
-export interface PluginLoadError {
-  pluginKey: string
-  installPath: string
-  error: string
-}
-
-/**
- * Claude settings from ~/.claude/settings.json
- */
-export interface ClaudeSettings {
-  enabledPlugins?: Record<string, boolean>
-  // Other settings we don't use
-  [key: string]: unknown
-}
-
-/**
- * Plugin loader options
- */
-export interface PluginLoaderOptions {
-  /**
-   * Override the plugins home directory for testing.
-   * If not provided, uses CLAUDE_PLUGINS_HOME env var or ~/.claude/plugins
-   */
-  pluginsHomeOverride?: string
-
-  /**
-   * Override plugin manifest loading for testing.
-   * Return null to force plugin name derivation from the plugin key.
-   */
-  loadPluginManifestOverride?: (installPath: string) => PluginManifest | null
-
-  /**
-   * Override enabled plugins from hiai-opencode config.
-   * Key format: "pluginName@marketplace" (e.g., "shell-scripting@claude-code-workflows")
-   * Value: true = enabled, false = disabled
-   * 
-   * This takes precedence over ~/.claude/settings.json enabledPlugins
-   */
-  enabledPluginsOverride?: Record<string, boolean>
-}

package/src/features/claude-code-session-state/index.ts

@@ -1 +0,0 @@
-export * from "./state"