@hiai-gg/hiai-opencode 0.1.7 → 0.1.9

package/src/hooks/bash-file-read-guard.ts

@@ -1,44 +0,0 @@
-import type { Hooks } from "@opencode-ai/plugin"
-
-import { log } from "../shared"
-
-const WARNING_MESSAGE = "Prefer the Read tool over `cat`/`head`/`tail` for reading file contents. The Read tool provides line numbers and hash anchors for precise editing."
-
-const FILE_READ_PATTERNS = [
-  /^\s*cat\s+(?!-)[^\s|&;]+\s*$/,
-  /^\s*head\s+(-n\s+\d+\s+)?(?!-)[^\s|&;]+\s*$/,
-  /^\s*tail\s+(-n\s+\d+\s+)?(?!-)[^\s|&;]+\s*$/,
-]
-
-function isSimpleFileReadCommand(command: string): boolean {
-  return FILE_READ_PATTERNS.some((pattern) => pattern.test(command))
-}
-
-export function createBashFileReadGuardHook(): Hooks {
-  return {
-    "tool.execute.before": async (
-      input: { tool: string; sessionID: string; callID: string },
-      output: { args: Record<string, unknown>; message?: string },
-    ): Promise<void> => {
-      if (input.tool.toLowerCase() !== "bash") {
-        return
-      }
-
-      const command = output.args.command
-      if (typeof command !== "string") {
-        return
-      }
-
-      if (!isSimpleFileReadCommand(command)) {
-        return
-      }
-
-      output.message = WARNING_MESSAGE
-
-      log("[bash-file-read-guard] warned on bash file read command", {
-        sessionID: input.sessionID,
-        command,
-      })
-    },
-  }
-}

package/src/hooks/category-skill-reminder/formatter.ts

@@ -1,37 +0,0 @@
-import type { AvailableSkill } from "../../agents/dynamic-agent-prompt-builder"
-
-function formatSkillNames(skills: AvailableSkill[], limit: number): string {
-  if (skills.length === 0) return "(none)"
-  const shown = skills.slice(0, limit).map((s) => s.name)
-  const remaining = skills.length - shown.length
-  const suffix = remaining > 0 ? ` (+${remaining} more)` : ""
-  return shown.join(", ") + suffix
-}
-
-export function buildReminderMessage(availableSkills: AvailableSkill[]): string {
-  const builtinSkills = availableSkills.filter((s) => s.location === "plugin")
-  const customSkills = availableSkills.filter((s) => s.location !== "plugin")
-
-  const builtinText = formatSkillNames(builtinSkills, 8)
-  const customText = formatSkillNames(customSkills, 8)
-
-  const exampleSkillName = customSkills[0]?.name ?? builtinSkills[0]?.name
-  const loadSkills = exampleSkillName ? `["${exampleSkillName}"]` : "[]"
-
-  const lines = [
-    "",
-    "[Category+Skill Reminder]",
-    "",
-    `**Built-in**: ${builtinText}`,
-    `**⚡ YOUR SKILLS (PRIORITY)**: ${customText}`,
-    "",
-    "> User-installed skills OVERRIDE built-in defaults. ALWAYS prefer YOUR SKILLS when domain matches.",
-    "",
-    "```typescript",
-    `task(category=\"visual-engineering\", load_skills=${loadSkills}, run_in_background=true)`,
-    "```",
-    "",
-  ]
-
-  return lines.join("\n")
-}

package/src/hooks/category-skill-reminder/hook.ts

@@ -1,142 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin"
-import type { AvailableSkill } from "../../agents/dynamic-agent-prompt-builder"
-import { getSessionAgent } from "../../features/claude-code-session-state"
-import { log } from "../../shared"
-import { getAgentConfigKey } from "../../shared/agent-display-names"
-import { buildReminderMessage } from "./formatter"
-
-/**
- * Target agents that should receive category+skill reminders.
- * These are orchestrator agents that delegate work to specialized agents.
- */
-const TARGET_AGENTS = new Set([
-  "bob",
-  "sub",
-  "guard",
-])
-
-/**
- * Tools that indicate the agent is doing work that could potentially be delegated.
- * When these tools are used, we remind the agent about the category+skill system.
- */
-const DELEGATABLE_WORK_TOOLS = new Set([
-  "edit",
-  "write",
-  "bash",
-  "read",
-  "grep",
-  "glob",
-])
-
-/**
- * Tools that indicate the agent is already using delegation properly.
- */
-const DELEGATION_TOOLS = new Set([
-   "task",
-   "call_omo_agent",
-])
-
-interface ToolExecuteInput {
-  tool: string
-  sessionID: string
-  callID: string
-  agent?: string
-}
-
-interface ToolExecuteOutput {
-  title: string
-  output: string
-  metadata: unknown
-}
-
-interface SessionState {
-  delegationUsed: boolean
-  reminderShown: boolean
-  toolCallCount: number
-}
-
-export function createCategorySkillReminderHook(
-  _ctx: PluginInput,
-  availableSkills: AvailableSkill[] = []
-) {
-  const sessionStates = new Map<string, SessionState>()
-  const reminderMessage = buildReminderMessage(availableSkills)
-
-  function getOrCreateState(sessionID: string): SessionState {
-    if (!sessionStates.has(sessionID)) {
-      sessionStates.set(sessionID, {
-        delegationUsed: false,
-        reminderShown: false,
-        toolCallCount: 0,
-      })
-    }
-    return sessionStates.get(sessionID)!
-  }
-
-  function isTargetAgent(sessionID: string, inputAgent?: string): boolean {
-    const agent = getSessionAgent(sessionID) ?? inputAgent
-    if (!agent) return false
-    const agentKey = getAgentConfigKey(agent)
-    return (
-      TARGET_AGENTS.has(agentKey) ||
-      agentKey.includes("bob") ||
-      agentKey.includes("guard")
-    )
-  }
-
-  const toolExecuteAfter = async (input: ToolExecuteInput, output: ToolExecuteOutput) => {
-    const { tool, sessionID } = input
-    const toolLower = tool.toLowerCase()
-
-    if (!isTargetAgent(sessionID, input.agent)) {
-      return
-    }
-
-    const state = getOrCreateState(sessionID)
-
-    if (DELEGATION_TOOLS.has(toolLower)) {
-      state.delegationUsed = true
-      log("[category-skill-reminder] Delegation tool used", { sessionID, tool })
-      return
-    }
-
-    if (!DELEGATABLE_WORK_TOOLS.has(toolLower)) {
-      return
-    }
-
-    state.toolCallCount++
-
-    if (state.toolCallCount >= 3 && !state.delegationUsed && !state.reminderShown) {
-      output.output += reminderMessage
-      state.reminderShown = true
-      log("[category-skill-reminder] Reminder injected", {
-        sessionID,
-        toolCallCount: state.toolCallCount,
-      })
-    }
-  }
-
-  const eventHandler = async ({ event }: { event: { type: string; properties?: unknown } }) => {
-    const props = event.properties as Record<string, unknown> | undefined
-
-    if (event.type === "session.deleted") {
-      const sessionInfo = props?.info as { id?: string } | undefined
-      if (sessionInfo?.id) {
-        sessionStates.delete(sessionInfo.id)
-      }
-    }
-
-    if (event.type === "session.compacted") {
-      const sessionID = (props?.sessionID ??
-        (props?.info as { id?: string } | undefined)?.id) as string | undefined
-      if (sessionID) {
-        sessionStates.delete(sessionID)
-      }
-    }
-  }
-
-  return {
-    "tool.execute.after": toolExecuteAfter,
-    event: eventHandler,
-  }
-}

package/src/hooks/category-skill-reminder/index.ts

@@ -1 +0,0 @@
-export { createCategorySkillReminderHook } from "./hook"

package/src/hooks/claude-code-hooks/AGENTS.md

@@ -1,41 +0,0 @@
-# src/hooks/claude-code-hooks/ — Claude Code Compatibility
-
-**Generated:** 2026-04-11
-
-## OVERVIEW
-
-~2110 LOC across 19 files. Provides Claude Code settings.json compatibility layer. Parses CC permission rules and maps CC hooks (PreToolUse, PostToolUse) to OpenCode hooks.
-
-## WHAT IT DOES
-
-1. Parses Claude Code `settings.json` permission format
-2. Maps CC hook types to OpenCode event types
-3. Enforces CC permission rules (allow/deny per tool)
-4. Supports CC `.claude/settings.json` and `.claude/settings.local.json`
-
-## CC → OPENCODE HOOK MAPPING
-
-| CC Hook | OpenCode Event |
-|---------|---------------|
-| PreToolUse | tool.execute.before |
-| PostToolUse | tool.execute.after |
-| Notification | event (session.idle) |
-| Stop | event (session.idle) |
-
-## PERMISSION SYSTEM
-
-CC permissions format:
-```json
-{
-  "permissions": {
-    "allow": ["Edit", "Write"],
-    "deny": ["Bash(rm:*)"]
-  }
-}
-```
-
-Translated to OpenCode tool restrictions via permission-compat in shared/.
-
-## FILES
-
-Key files: `settings-loader.ts` (parse CC settings), `hook-mapper.ts` (CC→OC mapping), `permission-handler.ts` (rule enforcement), `types.ts` (CC type definitions).

package/src/hooks/claude-code-hooks/claude-code-hooks-hook.ts

@@ -1,28 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin"
-import type { PluginConfig } from "./types"
-import type { ContextCollector } from "../../features/context-injector"
-import { createChatMessageHandler } from "./handlers/chat-message-handler"
-import { createPreCompactHandler } from "./handlers/pre-compact-handler"
-import {
-  createSessionEventHandler,
-  disposeSessionEventHandler,
-} from "./handlers/session-event-handler"
-import { createToolExecuteAfterHandler } from "./handlers/tool-execute-after-handler"
-import { createToolExecuteBeforeHandler } from "./handlers/tool-execute-before-handler"
-
-export function createClaudeCodeHooksHook(
-  ctx: PluginInput,
-  config: PluginConfig = {},
-  contextCollector?: ContextCollector
-) {
-  return {
-    "experimental.session.compacting": createPreCompactHandler(ctx, config),
-    "chat.message": createChatMessageHandler(ctx, config, contextCollector),
-    "tool.execute.before": createToolExecuteBeforeHandler(ctx, config),
-    "tool.execute.after": createToolExecuteAfterHandler(ctx, config),
-    event: createSessionEventHandler(ctx, config, contextCollector),
-    dispose: (): void => {
-      disposeSessionEventHandler(contextCollector)
-    },
-  }
-}

package/src/hooks/claude-code-hooks/config-loader.ts

@@ -1,151 +0,0 @@
-import { existsSync } from "fs"
-import { join } from "path"
-import type { ClaudeHookEvent } from "./types"
-import { log } from "../../shared/logger"
-import { getOpenCodeConfigDir } from "../../shared"
-
-const CONFIG_CACHE_TTL_MS = 30_000
-
-export interface DisabledHooksConfig {
-  Stop?: string[]
-  PreToolUse?: string[]
-  PostToolUse?: string[]
-  UserPromptSubmit?: string[]
-  PreCompact?: string[]
-}
-
-export interface PluginExtendedConfig {
-  disabledHooks?: DisabledHooksConfig
-}
-
-interface PluginExtendedConfigCacheEntry {
-  value: PluginExtendedConfig
-  cachedAt: number
-}
-
-const configCache = new Map<string, PluginExtendedConfigCacheEntry>()
-
-function getUserConfigPath(): string {
-  return join(getOpenCodeConfigDir({ binary: "opencode" }), "opencode-cc-plugin.json")
-}
-
-function getProjectConfigPath(): string {
-  return join(process.cwd(), ".opencode", "opencode-cc-plugin.json")
-}
-
-function getCacheKey(): string {
-  return `${process.cwd()}::${getUserConfigPath()}`
-}
-
-function getCachedConfig(cacheKey: string): PluginExtendedConfig | undefined {
-  const cachedEntry = configCache.get(cacheKey)
-  if (!cachedEntry) {
-    return undefined
-  }
-
-  if (Date.now() - cachedEntry.cachedAt >= CONFIG_CACHE_TTL_MS) {
-    configCache.delete(cacheKey)
-    return undefined
-  }
-
-  return cachedEntry.value
-}
-
-export function clearPluginExtendedConfigCache(): void {
-  configCache.clear()
-}
-
-async function loadConfigFromPath(path: string): Promise<PluginExtendedConfig | null> {
-  if (!existsSync(path)) {
-    return null
-  }
-
-  try {
-    const content = await Bun.file(path).text()
-    return JSON.parse(content) as PluginExtendedConfig
-  } catch (error) {
-    log("Failed to load config", { path, error })
-    return null
-  }
-}
-
-function mergeDisabledHooks(
-  base: DisabledHooksConfig | undefined,
-  override: DisabledHooksConfig | undefined
-): DisabledHooksConfig {
-  if (!override) return base ?? {}
-  if (!base) return override
-
-  return {
-    Stop: override.Stop ?? base.Stop,
-    PreToolUse: override.PreToolUse ?? base.PreToolUse,
-    PostToolUse: override.PostToolUse ?? base.PostToolUse,
-    UserPromptSubmit: override.UserPromptSubmit ?? base.UserPromptSubmit,
-    PreCompact: override.PreCompact ?? base.PreCompact,
-  }
-}
-
-export async function loadPluginExtendedConfig(): Promise<PluginExtendedConfig> {
-  const cacheKey = getCacheKey()
-  const cachedConfig = getCachedConfig(cacheKey)
-  if (cachedConfig) {
-    return cachedConfig
-  }
-
-  const userConfig = await loadConfigFromPath(getUserConfigPath())
-  const projectConfig = await loadConfigFromPath(getProjectConfigPath())
-
-  const merged: PluginExtendedConfig = {
-    disabledHooks: mergeDisabledHooks(
-      userConfig?.disabledHooks,
-      projectConfig?.disabledHooks
-    ),
-  }
-
-  if (userConfig || projectConfig) {
-    log("Plugin extended config loaded", {
-      userConfigExists: userConfig !== null,
-      projectConfigExists: projectConfig !== null,
-      mergedDisabledHooks: merged.disabledHooks,
-    })
-  }
-
-  configCache.set(cacheKey, {
-    value: merged,
-    cachedAt: Date.now(),
-  })
-
-  return merged
-}
-
-const regexCache = new Map<string, RegExp>()
-
-function getRegex(pattern: string): RegExp {
-  let regex = regexCache.get(pattern)
-  if (!regex) {
-    try {
-      regex = new RegExp(pattern)
-      regexCache.set(pattern, regex)
-    } catch {
-      regex = new RegExp(pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"))
-      regexCache.set(pattern, regex)
-    }
-  }
-  return regex
-}
-
-export function isHookCommandDisabled(
-  eventType: ClaudeHookEvent,
-  command: string,
-  config: PluginExtendedConfig | null
-): boolean {
-  if (!config?.disabledHooks) return false
-
-  const patterns = config.disabledHooks[eventType]
-  if (!patterns || patterns.length === 0) return false
-
-  return patterns.some((pattern) => {
-    const regex = getRegex(pattern)
-    return regex.test(command)
-  })
-}

package/src/hooks/claude-code-hooks/config.ts

@@ -1,147 +0,0 @@
-import { join } from "path"
-import { existsSync } from "fs"
-import { getClaudeConfigDir } from "../../shared"
-import type { ClaudeHooksConfig, HookMatcher, HookAction } from "./types"
-
-const CONFIG_CACHE_TTL_MS = 30_000
-
-interface ClaudeHooksConfigCacheEntry {
-  value: ClaudeHooksConfig | null
-  cachedAt: number
-}
-
-const configCache = new Map<string, ClaudeHooksConfigCacheEntry>()
-
-interface RawHookMatcher {
-  matcher?: string
-  pattern?: string
-  hooks: HookAction[]
-}
-
-interface RawClaudeHooksConfig {
-  PreToolUse?: RawHookMatcher[]
-  PostToolUse?: RawHookMatcher[]
-  UserPromptSubmit?: RawHookMatcher[]
-  Stop?: RawHookMatcher[]
-  PreCompact?: RawHookMatcher[]
-}
-
-function normalizeHookMatcher(raw: RawHookMatcher): HookMatcher {
-  return {
-    matcher: raw.matcher ?? raw.pattern ?? "*",
-    hooks: Array.isArray(raw.hooks) ? raw.hooks : [],
-  }
-}
-
-function normalizeHooksConfig(raw: RawClaudeHooksConfig): ClaudeHooksConfig {
-  const result: ClaudeHooksConfig = {}
-  const eventTypes: (keyof RawClaudeHooksConfig)[] = [
-    "PreToolUse",
-    "PostToolUse",
-    "UserPromptSubmit",
-    "Stop",
-    "PreCompact",
-  ]
-
-  for (const eventType of eventTypes) {
-    if (raw[eventType]) {
-      result[eventType] = raw[eventType].map(normalizeHookMatcher)
-    }
-  }
-
-  return result
-}
-
-export function getClaudeSettingsPaths(customPath?: string): string[] {
-  const claudeConfigDir = getClaudeConfigDir()
-  const paths = [
-    join(claudeConfigDir, "settings.json"),
-    join(process.cwd(), ".claude", "settings.json"),
-    join(process.cwd(), ".claude", "settings.local.json"),
-  ]
-
-  if (customPath && existsSync(customPath)) {
-    paths.unshift(customPath)
-  }
-
-  // Deduplicate paths to prevent loading the same file multiple times
-  // (e.g., when cwd is the home directory)
-  return [...new Set(paths)]
-}
-
-function getCacheKey(customSettingsPath?: string): string {
-  return `${process.cwd()}::${customSettingsPath ?? ""}`
-}
-
-function getCachedConfig(cacheKey: string): ClaudeHooksConfig | null | undefined {
-  const cachedEntry = configCache.get(cacheKey)
-  if (!cachedEntry) {
-    return undefined
-  }
-
-  if (Date.now() - cachedEntry.cachedAt >= CONFIG_CACHE_TTL_MS) {
-    configCache.delete(cacheKey)
-    return undefined
-  }
-
-  return cachedEntry.value
-}
-
-export function clearClaudeHooksConfigCache(): void {
-  configCache.clear()
-}
-
-function mergeHooksConfig(
-  base: ClaudeHooksConfig,
-  override: ClaudeHooksConfig
-): ClaudeHooksConfig {
-  const result: ClaudeHooksConfig = { ...base }
-  const eventTypes: (keyof ClaudeHooksConfig)[] = [
-    "PreToolUse",
-    "PostToolUse",
-    "UserPromptSubmit",
-    "Stop",
-    "PreCompact",
-  ]
-  for (const eventType of eventTypes) {
-    if (override[eventType]) {
-      result[eventType] = [...(base[eventType] || []), ...override[eventType]]
-    }
-  }
-  return result
-}
-
-export async function loadClaudeHooksConfig(
-  customSettingsPath?: string
-): Promise<ClaudeHooksConfig | null> {
-  const cacheKey = getCacheKey(customSettingsPath)
-  const cachedConfig = getCachedConfig(cacheKey)
-  if (cachedConfig !== undefined) {
-    return cachedConfig
-  }
-
-  const paths = getClaudeSettingsPaths(customSettingsPath)
-  let mergedConfig: ClaudeHooksConfig = {}
-
-  for (const settingsPath of paths) {
-    if (existsSync(settingsPath)) {
-      try {
-        const content = await Bun.file(settingsPath).text()
-        const settings = JSON.parse(content) as { hooks?: RawClaudeHooksConfig }
-        if (settings.hooks) {
-          const normalizedHooks = normalizeHooksConfig(settings.hooks)
-          mergedConfig = mergeHooksConfig(mergedConfig, normalizedHooks)
-        }
-      } catch {
-        continue
-      }
-    }
-  }
-
-  const resolvedConfig = Object.keys(mergedConfig).length > 0 ? mergedConfig : null
-  configCache.set(cacheKey, {
-    value: resolvedConfig,
-    cachedAt: Date.now(),
-  })
-  return resolvedConfig
-}

package/src/hooks/claude-code-hooks/dispatch-hook.ts

@@ -1,27 +0,0 @@
-import type { HookAction } from "./types"
-import type { CommandResult } from "../../shared/command-executor/execute-hook-command"
-import { executeHookCommand } from "../../shared"
-import { executeHttpHook } from "./execute-http-hook"
-import { DEFAULT_CONFIG } from "./plugin-config"
-
-export function getHookIdentifier(hook: HookAction): string {
-  if (hook.type === "http") return hook.url
-  return hook.command.split("/").pop() || hook.command
-}
-
-export async function dispatchHook(
-  hook: HookAction,
-  stdinJson: string,
-  cwd: string
-): Promise<CommandResult> {
-  if (hook.type === "http") {
-    return executeHttpHook(hook, stdinJson)
-  }
-
-  return executeHookCommand(
-    hook.command,
-    stdinJson,
-    cwd,
-    { forceZsh: DEFAULT_CONFIG.forceZsh, zshPath: DEFAULT_CONFIG.zshPath }
-  )
-}