@hiai-gg/hiai-opencode 0.1.7 → 0.1.9

package/src/features/claude-code-agent-loader/agent-definitions-loader.ts

@@ -1,87 +0,0 @@
-import { existsSync, readFileSync } from "fs"
-import { basename, extname } from "path"
-import { parseFrontmatter } from "../../shared/frontmatter"
-import { log } from "../../shared/logger"
-import { parseToolsConfig } from "../../shared/parse-tools-config"
-import { parseJsonAgentFile } from "./json-agent-loader"
-import { mapClaudeModelToOpenCode } from "./claude-model-mapper"
-import type { AgentScope, AgentFrontmatter, ClaudeCodeAgentConfig, LoadedAgent } from "./types"
-
-export function parseMarkdownAgentFile(filePath: string, scope: AgentScope): LoadedAgent | null {
-  try {
-    if (!existsSync(filePath)) {
-      return null
-    }
-
-    const content = readFileSync(filePath, "utf-8")
-    const { data, body } = parseFrontmatter<AgentFrontmatter>(content)
-
-    const fileName = basename(filePath)
-    const agentName = fileName.replace(/\.md$/i, "")
-    const name = data.name || agentName
-    const originalDescription = data.description || ""
-
-    const formattedDescription = `(${scope}) ${originalDescription}`
-
-    const mappedModelOverride = mapClaudeModelToOpenCode(data.model)
-    const modelString = mappedModelOverride
-      ? `${mappedModelOverride.providerID}/${mappedModelOverride.modelID}`
-      : undefined
-
-    const config: ClaudeCodeAgentConfig = {
-      description: formattedDescription,
-      mode: data.mode || "subagent",
-      prompt: body.trim(),
-      ...(modelString ? { model: modelString } : {}),
-    }
-
-    const toolsConfig = parseToolsConfig(data.tools)
-    if (toolsConfig) {
-      config.tools = toolsConfig
-    }
-
-    return {
-      name,
-      path: filePath,
-      config,
-      scope,
-    }
-  } catch {
-    return null
-  }
-}
-
-export function loadAgentDefinitions(
-  paths: string[],
-  scope: AgentScope
-): Record<string, ClaudeCodeAgentConfig> {
-  const result: Record<string, ClaudeCodeAgentConfig> = Object.create(null)
-
-  for (const filePath of paths) {
-    if (!existsSync(filePath)) {
-      log(`[agent-definitions-loader] File not found, skipping: ${filePath}`)
-      continue
-    }
-
-    const ext = extname(filePath).toLowerCase()
-    let agent: LoadedAgent | null = null
-
-    if (ext === ".md") {
-      agent = parseMarkdownAgentFile(filePath, scope)
-    } else if (ext === ".json" || ext === ".jsonc") {
-      agent = parseJsonAgentFile(filePath, scope)
-    } else {
-      log(`[agent-definitions-loader] Unsupported file extension: ${ext} for ${filePath}`)
-      continue
-    }
-
-    if (!agent) {
-      log(`[agent-definitions-loader] Failed to parse agent file: ${filePath}`)
-      continue
-    }
-
-    result[agent.name] = agent.config
-  }
-
-  return result
-}

package/src/features/claude-code-agent-loader/claude-model-mapper.ts

@@ -1,53 +0,0 @@
-import { normalizeModelFormat } from "../../shared/model-format-normalizer"
-import { normalizeModelID } from "../../shared/model-normalization"
-
-const ANTHROPIC_PREFIX = "anthropic/"
-
-let CLAUDE_CODE_ALIAS_MAP = new Map<string, string>();
-
-/**
- * Initializes Claude model aliases from the provided configuration.
- */
-export function initializeClaudeAliases(aliases?: Record<string, string>) {
-  if (aliases) {
-    CLAUDE_CODE_ALIAS_MAP = new Map(Object.entries(aliases));
-  }
-}
-
-function mapClaudeModelString(model: string | undefined): string | undefined {
-  if (!model) return undefined
-
-  const trimmed = model.trim()
-  if (trimmed.length === 0) return undefined
-
-  if (trimmed === "inherit") return undefined
-
-  const aliasResult = CLAUDE_CODE_ALIAS_MAP.get(trimmed.toLowerCase())
-  if (aliasResult) return aliasResult
-
-  if (trimmed.includes("/")) {
-    const [providerID, ...modelParts] = trimmed.split("/")
-    const modelID = modelParts.join("/")
-
-    if (providerID.length === 0 || modelID.length === 0) return trimmed
-
-    return modelID.startsWith("claude-")
-      ? `${providerID}/${normalizeModelID(modelID)}`
-      : trimmed
-  }
-
-  const normalized = normalizeModelID(trimmed)
-
-  if (normalized.startsWith("claude-")) {
-    return `${ANTHROPIC_PREFIX}${normalized}`
-  }
-
-  return undefined
-}
-
-export function mapClaudeModelToOpenCode(
-  model: string | undefined
-): { providerID: string; modelID: string } | undefined {
-  const mappedModel = mapClaudeModelString(model)
-  return mappedModel ? normalizeModelFormat(mappedModel) : undefined
-}

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

@@ -1,5 +0,0 @@
-export * from "./types"
-export * from "./loader"
-export * from "./agent-definitions-loader"
-export * from "./opencode-config-agents-reader"
-export * from "./json-agent-loader"

package/src/features/claude-code-agent-loader/json-agent-loader.ts

@@ -1,53 +0,0 @@
-import { existsSync, readFileSync } from "fs"
-import { parseJsoncSafe } from "../../shared/jsonc-parser"
-import { parseToolsConfig } from "../../shared/parse-tools-config"
-import { mapClaudeModelToOpenCode } from "./claude-model-mapper"
-import type { AgentScope, AgentJsonDefinition, ClaudeCodeAgentConfig, LoadedAgent } from "./types"
-
-export function parseJsonAgentFile(filePath: string, scope: AgentScope): LoadedAgent | null {
-  try {
-    if (!existsSync(filePath)) {
-      return null
-    }
-
-    const content = readFileSync(filePath, "utf-8")
-    const { data } = parseJsoncSafe<AgentJsonDefinition>(content)
-
-    if (!data) {
-      return null
-    }
-
-    if (!data.name || !data.prompt) {
-      return null
-    }
-
-    const originalDescription = data.description ?? ""
-    const formattedDescription = `(${scope}) ${originalDescription}`
-
-    const mappedModelOverride = mapClaudeModelToOpenCode(data.model)
-    const modelString = mappedModelOverride
-      ? `${mappedModelOverride.providerID}/${mappedModelOverride.modelID}`
-      : undefined
-
-    const config: ClaudeCodeAgentConfig = {
-      description: formattedDescription,
-      mode: data.mode ?? "subagent",
-      prompt: data.prompt.trim(),
-      ...(modelString ? { model: modelString } : {}),
-    }
-
-    const toolsConfig = parseToolsConfig(data.tools)
-    if (toolsConfig) {
-      config.tools = toolsConfig
-    }
-
-    return {
-      name: data.name,
-      path: filePath,
-      config,
-      scope,
-    }
-  } catch {
-    return null
-  }
-}

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

@@ -1,86 +0,0 @@
-import { existsSync, readdirSync } from "fs"
-import { join } from "path"
-import { isMarkdownFile } from "../../shared/file-utils"
-import { getClaudeConfigDir } from "../../shared"
-import { getAgentsConfigDir } from "../../shared/agents-config-dir"
-import type { AgentScope, ClaudeCodeAgentConfig, LoadedAgent } from "./types"
-import { getOpenCodeConfigDir } from "../../shared/opencode-config-dir"
-import { parseMarkdownAgentFile } from "./agent-definitions-loader"
-
-function loadAgentsFromDir(agentsDir: string, scope: AgentScope): LoadedAgent[] {
-  if (!existsSync(agentsDir)) {
-    return []
-  }
-
-  const entries = readdirSync(agentsDir, { withFileTypes: true })
-  const agents: LoadedAgent[] = []
-
-  for (const entry of entries) {
-    if (!isMarkdownFile(entry)) continue
-
-    const agentPath = join(agentsDir, entry.name)
-    const agent = parseMarkdownAgentFile(agentPath, scope)
-
-    if (agent) {
-      agents.push(agent)
-    }
-  }
-
-  return agents
-}
-
-export function loadUserAgents(): Record<string, ClaudeCodeAgentConfig> {
-  const userAgentsDir = join(getClaudeConfigDir(), "agents")
-  const agents = loadAgentsFromDir(userAgentsDir, "user")
-
-  const result: Record<string, ClaudeCodeAgentConfig> = Object.create(null)
-  for (const agent of agents) {
-    result[agent.name] = agent.config
-  }
-  return result
-}
-
-export function loadProjectAgents(directory?: string): Record<string, ClaudeCodeAgentConfig> {
-  const projectAgentsDir = join(directory ?? process.cwd(), ".claude", "agents")
-  const agents = loadAgentsFromDir(projectAgentsDir, "project")
-
-  const result: Record<string, ClaudeCodeAgentConfig> = Object.create(null)
-  for (const agent of agents) {
-    result[agent.name] = agent.config
-  }
-  return result
-}
-
-export function loadOpencodeGlobalAgents(): Record<string, ClaudeCodeAgentConfig> {
-  const configDir = getOpenCodeConfigDir({ binary: "opencode" })
-  const opencodeAgentsDir = join(configDir, "agents")
-  const agents = loadAgentsFromDir(opencodeAgentsDir, "opencode")
-
-  const result: Record<string, ClaudeCodeAgentConfig> = Object.create(null)
-  for (const agent of agents) {
-    result[agent.name] = agent.config
-  }
-  return result
-}
-
-export function loadOpencodeProjectAgents(directory?: string): Record<string, ClaudeCodeAgentConfig> {
-  const opencodeProjectDir = join(directory ?? process.cwd(), ".opencode", "agents")
-  const agents = loadAgentsFromDir(opencodeProjectDir, "opencode-project")
-
-  const result: Record<string, ClaudeCodeAgentConfig> = Object.create(null)
-  for (const agent of agents) {
-    result[agent.name] = agent.config
-  }
-  return result
-}
-
-export function loadGlobalAgents(): Record<string, ClaudeCodeAgentConfig> {
-  const agentsDir = join(getAgentsConfigDir(), "agents")
-  const agents = loadAgentsFromDir(agentsDir, "user")
-
-  const result: Record<string, ClaudeCodeAgentConfig> = Object.create(null)
-  for (const agent of agents) {
-    result[agent.name] = agent.config
-  }
-  return result
-}

package/src/features/claude-code-agent-loader/opencode-config-agents-reader.ts

@@ -1,125 +0,0 @@
-import * as fs from "node:fs"
-import * as path from "node:path"
-
-import { getOpenCodeConfigDir } from "../../shared/opencode-config-dir"
-import { parseJsoncSafe } from "../../shared/jsonc-parser"
-import { parseToolsConfig } from "../../shared/parse-tools-config"
-import { resolveAgentDefinitionPaths } from "../../shared/resolve-agent-definition-paths"
-import { loadAgentDefinitions } from "./agent-definitions-loader"
-import { mapClaudeModelToOpenCode } from "./claude-model-mapper"
-import type { ClaudeCodeAgentConfig } from "./types"
-
-interface OpencodeConfigWithAgents {
-  agents?: Record<string, unknown>
-  agent?: Record<string, unknown>
-  agent_definitions?: string | string[]
-}
-
-function getConfigPaths(directory: string): string[] {
-  const globalConfigDir = getOpenCodeConfigDir({ binary: "opencode" })
-  const paths = [
-    path.join(directory, ".opencode", "opencode.json"),
-    path.join(directory, ".opencode", "opencode.jsonc"),
-    path.join(globalConfigDir, "opencode.json"),
-    path.join(globalConfigDir, "opencode.jsonc"),
-  ]
-
-  return paths
-}
-
-function convertInlineAgent(agentData: unknown): ClaudeCodeAgentConfig | null {
-  if (!agentData || typeof agentData !== "object") {
-    return null
-  }
-
-  const agent = agentData as Record<string, unknown>
-
-  const description = agent.description ? `(opencode-config) ${String(agent.description)}` : "(opencode-config) "
-
-  const mappedModel = mapClaudeModelToOpenCode(
-    agent.model ? String(agent.model) : undefined
-  )
-  const modelString = mappedModel
-    ? `${mappedModel.providerID}/${mappedModel.modelID}`
-    : undefined
-
-  const VALID_MODES = ["subagent", "primary", "all"] as const
-  const rawMode = typeof agent.mode === "string" ? agent.mode : undefined
-  const mode = rawMode && (VALID_MODES as readonly string[]).includes(rawMode)
-    ? (rawMode as "subagent" | "primary" | "all")
-    : "subagent"
-
-  const config: ClaudeCodeAgentConfig = {
-    description,
-    mode,
-    prompt: agent.prompt ? String(agent.prompt) : "",
-    ...(modelString ? { model: modelString } : {}),
-  }
-
-  const toolsConfig = parseToolsConfig(agent.tools)
-  if (toolsConfig) {
-    config.tools = toolsConfig
-  }
-
-  return config
-}
-
-export function readOpencodeConfigAgents(directory: string): Record<string, ClaudeCodeAgentConfig> {
-  const result: Record<string, ClaudeCodeAgentConfig> = Object.create(null)
-
-  for (const configPath of getConfigPaths(directory)) {
-    try {
-      if (!fs.existsSync(configPath)) continue
-
-      const content = fs.readFileSync(configPath, "utf-8")
-      const parseResult = parseJsoncSafe<OpencodeConfigWithAgents>(content)
-
-      if (!parseResult.data) continue
-
-      const configDir = path.dirname(configPath)
-
-      const agentsToLoad = parseResult.data.agents || parseResult.data.agent
-
-      if (agentsToLoad && typeof agentsToLoad === "object") {
-        for (const [agentName, agentData] of Object.entries(agentsToLoad)) {
-          if (Object.hasOwn(result, agentName)) continue
-          const converted = convertInlineAgent(agentData)
-          if (converted) {
-            result[agentName] = converted
-          }
-        }
-      }
-
-      if (parseResult.data.agent_definitions) {
-        const definitionPaths = extractDefinitionPaths(parseResult.data.agent_definitions)
-        const resolvedPaths = resolveAgentDefinitionPaths(definitionPaths, configDir, directory)
-
-        const definitionAgents = loadAgentDefinitions(resolvedPaths, "opencode-config")
-
-        for (const [name, config] of Object.entries(definitionAgents)) {
-          if (!Object.hasOwn(result, name)) {
-            result[name] = config
-          }
-        }
-      }
-    } catch {
-      continue
-    }
-  }
-
-  return result
-}
-
-function extractDefinitionPaths(definitionPaths: unknown): string[] {
-  if (typeof definitionPaths === "string") {
-    return [definitionPaths]
-  }
-
-  if (Array.isArray(definitionPaths)) {
-    return definitionPaths
-      .filter((p) => typeof p === "string")
-      .map((p) => p as string)
-  }
-
-  return []
-}

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

@@ -1,31 +0,0 @@
-import type { AgentConfig } from "@opencode-ai/sdk"
-
-export type AgentScope = "user" | "project" | "opencode" | "opencode-project" | "definition-file" | "opencode-config"
-
-export type ClaudeCodeAgentConfig = Omit<AgentConfig, "model"> & {
-  model?: string | { providerID: string; modelID: string }
-}
-
-export interface AgentFrontmatter {
-  name?: string
-  description?: string
-  model?: string
-  tools?: string
-  mode?: "subagent" | "primary" | "all"
-}
-
-export interface AgentJsonDefinition {
-  name: string
-  description?: string
-  model?: string
-  tools?: string | string[]
-  mode?: "subagent" | "primary" | "all"
-  prompt: string
-}
-
-export interface LoadedAgent {
-  name: string
-  path: string
-  config: ClaudeCodeAgentConfig
-  scope: AgentScope
-}

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

@@ -1,2 +0,0 @@
-export * from "./types"
-export * from "./loader"

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

@@ -1,169 +0,0 @@
-import { promises as fs, type Dirent } from "fs"
-import { join, basename } from "path"
-import { parseFrontmatter } from "../../shared/frontmatter"
-import { sanitizeModelField } from "../../shared/model-sanitizer"
-import { isMarkdownFile } from "../../shared/file-utils"
-import {
-  findProjectOpencodeCommandDirs,
-  getClaudeConfigDir,
-  getOpenCodeCommandDirs,
-} from "../../shared"
-import { log } from "../../shared/logger"
-import type { CommandScope, CommandDefinition, CommandFrontmatter, LoadedCommand } from "./types"
-
-async function loadCommandsFromDir(
-  commandsDir: string,
-  scope: CommandScope,
-  visited: Set<string> = new Set(),
-  prefix: string = ""
-): Promise<LoadedCommand[]> {
-  try {
-    await fs.access(commandsDir)
-  } catch {
-    return []
-  }
-
-  let realPath: string
-  try {
-    realPath = await fs.realpath(commandsDir)
-  } catch (error) {
-    log(`Failed to resolve command directory: ${commandsDir}`, error)
-    return []
-  }
-
-  if (visited.has(realPath)) {
-    return []
-  }
-  visited.add(realPath)
-
-  let entries: Dirent[]
-  try {
-    entries = await fs.readdir(commandsDir, { withFileTypes: true })
-  } catch (error) {
-    log(`Failed to read command directory: ${commandsDir}`, error)
-    return []
-  }
-
-  const commands: LoadedCommand[] = []
-
-  for (const entry of entries) {
-    if (entry.isDirectory()) {
-      if (entry.name.startsWith(".")) continue
-      const subDirPath = join(commandsDir, entry.name)
-      const subPrefix = prefix ? `${prefix}/${entry.name}` : entry.name
-      const subCommands = await loadCommandsFromDir(subDirPath, scope, visited, subPrefix)
-      commands.push(...subCommands)
-      continue
-    }
-
-    if (!isMarkdownFile(entry)) continue
-
-    const commandPath = join(commandsDir, entry.name)
-    const baseCommandName = basename(entry.name, ".md")
-    const commandName = prefix ? `${prefix}/${baseCommandName}` : baseCommandName
-
-    try {
-      const content = await fs.readFile(commandPath, "utf-8")
-      const { data, body } = parseFrontmatter<CommandFrontmatter>(content)
-
-      const wrappedTemplate = `<command-instruction>
-${body.trim()}
-</command-instruction>
-
-<user-request>
-$ARGUMENTS
-</user-request>`
-
-      const formattedDescription = `(${scope}) ${data.description || ""}`
-
-      const isOpencodeSource = scope === "opencode" || scope === "opencode-project"
-      const definition: CommandDefinition = {
-        name: commandName,
-        description: formattedDescription,
-        template: wrappedTemplate,
-        agent: data.agent,
-        model: sanitizeModelField(data.model, isOpencodeSource ? "opencode" : "claude-code"),
-        subtask: data.subtask,
-        argumentHint: data["argument-hint"],
-        handoffs: data.handoffs,
-      }
-
-      commands.push({
-        name: commandName,
-        path: commandPath,
-        definition,
-        scope,
-      })
-    } catch (error) {
-      log(`Failed to parse command: ${commandPath}`, error)
-      continue
-    }
-  }
-
-  return commands
-}
-
-function deduplicateLoadedCommandsByName(commands: LoadedCommand[]): LoadedCommand[] {
-  const seen = new Set<string>()
-  const deduplicatedCommands: LoadedCommand[] = []
-
-  for (const command of commands) {
-    if (seen.has(command.name)) {
-      continue
-    }
-
-    seen.add(command.name)
-    deduplicatedCommands.push(command)
-  }
-
-  return deduplicatedCommands
-}
-
-function commandsToRecord(commands: LoadedCommand[]): Record<string, CommandDefinition> {
-  const result: Record<string, CommandDefinition> = {}
-  for (const cmd of deduplicateLoadedCommandsByName(commands)) {
-    const { name: _name, argumentHint: _argumentHint, ...openCodeCompatible } = cmd.definition
-    result[cmd.name] = openCodeCompatible as CommandDefinition
-  }
-  return result
-}
-
-export async function loadUserCommands(): Promise<Record<string, CommandDefinition>> {
-  const userCommandsDir = join(getClaudeConfigDir(), "commands")
-  const commands = await loadCommandsFromDir(userCommandsDir, "user")
-  return commandsToRecord(commands)
-}
-
-export async function loadProjectCommands(directory?: string): Promise<Record<string, CommandDefinition>> {
-  const projectCommandsDir = join(directory ?? process.cwd(), ".claude", "commands")
-  const commands = await loadCommandsFromDir(projectCommandsDir, "project")
-  return commandsToRecord(commands)
-}
-
-export async function loadOpencodeGlobalCommands(): Promise<Record<string, CommandDefinition>> {
-  const opencodeCommandDirs = getOpenCodeCommandDirs({ binary: "opencode" })
-  const allCommands = await Promise.all(
-    opencodeCommandDirs.map((commandsDir) => loadCommandsFromDir(commandsDir, "opencode")),
-  )
-  return commandsToRecord(allCommands.flat())
-}
-
-export async function loadOpencodeProjectCommands(directory?: string): Promise<Record<string, CommandDefinition>> {
-  const opencodeProjectDirs = findProjectOpencodeCommandDirs(directory ?? process.cwd())
-  const allCommands = await Promise.all(
-    opencodeProjectDirs.map((commandsDir) =>
-      loadCommandsFromDir(commandsDir, "opencode-project"),
-    ),
-  )
-  return commandsToRecord(allCommands.flat())
-}
-
-export async function loadAllCommands(directory?: string): Promise<Record<string, CommandDefinition>> {
-  const [user, project, global, projectOpencode] = await Promise.all([
-    loadUserCommands(),
-    loadProjectCommands(directory),
-    loadOpencodeGlobalCommands(),
-    loadOpencodeProjectCommands(directory),
-  ])
-  return { ...projectOpencode, ...global, ...project, ...user }
-}

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

@@ -1,46 +0,0 @@
-export type CommandScope = "user" | "project" | "opencode" | "opencode-project"
-
-/**
- * Handoff definition for command workflows.
- * Based on speckit's handoff pattern for multi-agent orchestration.
- * @see https://github.com/github/spec-kit
- */
-export interface HandoffDefinition {
-  /** Human-readable label for the handoff action */
-  label: string
-  /** Target agent/command identifier (e.g., "speckit.tasks") */
-  agent: string
-  /** Pre-filled prompt text for the handoff */
-  prompt: string
-  /** If true, automatically executes after command completion; if false, shows as suggestion */
-  send?: boolean
-}
-
-export interface CommandDefinition {
-  name: string
-  description?: string
-  template: string
-  agent?: string
-  model?: string
-  subtask?: boolean
-  argumentHint?: string
-  /** Handoff definitions for workflow transitions */
-  handoffs?: HandoffDefinition[]
-}
-
-export interface CommandFrontmatter {
-  description?: string
-  "argument-hint"?: string
-  agent?: string
-  model?: string
-  subtask?: boolean
-  /** Handoff definitions for workflow transitions */
-  handoffs?: HandoffDefinition[]
-}
-
-export interface LoadedCommand {
-  name: string
-  path: string
-  definition: CommandDefinition
-  scope: CommandScope
-}