@hiai-gg/hiai-opencode 0.1.7 → 0.1.9

package/src/hooks/claude-code-hooks/post-tool-use.ts

@@ -1,195 +0,0 @@
-import type {
-  PostToolUseInput,
-  PostToolUseOutput,
-  ClaudeHooksConfig,
-} from "./types"
-import { findMatchingHooks, objectToSnakeCase, transformToolName, log } from "../../shared"
-import { dispatchHook, getHookIdentifier } from "./dispatch-hook"
-import { buildTranscriptFromSession, deleteTempTranscript } from "./transcript"
-import { isHookCommandDisabled, type PluginExtendedConfig } from "./config-loader"
-
-export interface PostToolUseClient {
-  session: {
-    messages: (opts: { path: { id: string }; query?: { directory: string } }) => Promise<unknown>
-  }
-}
-
-export interface PostToolUseContext {
-  sessionId: string
-  toolName: string
-  toolInput: Record<string, unknown>
-  toolOutput: Record<string, unknown>
-  cwd: string
-  transcriptPath?: string  // Fallback for append-based transcript
-  toolUseId?: string
-  client?: PostToolUseClient
-  permissionMode?: "default" | "plan" | "acceptEdits" | "bypassPermissions"
-}
-
-export interface PostToolUseResult {
-  block: boolean
-  reason?: string
-  message?: string
-  warnings?: string[]
-  elapsedMs?: number
-  hookName?: string
-  toolName?: string
-  additionalContext?: string
-  continue?: boolean
-  stopReason?: string
-  suppressOutput?: boolean
-  systemMessage?: string
-}
-
-export async function executePostToolUseHooks(
-  ctx: PostToolUseContext,
-  config: ClaudeHooksConfig | null,
-  extendedConfig?: PluginExtendedConfig | null
-): Promise<PostToolUseResult> {
-  if (!config) {
-    return { block: false }
-  }
-
-  const transformedToolName = transformToolName(ctx.toolName)
-  const matchers = findMatchingHooks(config, "PostToolUse", transformedToolName)
-  if (matchers.length === 0) {
-    return { block: false }
-  }
-
-  // PORT FROM DISABLED: Build Claude Code compatible transcript (temp file)
-  let tempTranscriptPath: string | null = null
-
-  try {
-    // Try to build full transcript from API if client available
-    if (ctx.client) {
-      tempTranscriptPath = await buildTranscriptFromSession(
-        ctx.client,
-        ctx.sessionId,
-        ctx.cwd,
-        ctx.toolName,
-        ctx.toolInput
-      )
-    }
-
-    const stdinData: PostToolUseInput = {
-      session_id: ctx.sessionId,
-      // Use temp transcript if available, otherwise fallback to append-based
-      transcript_path: tempTranscriptPath ?? ctx.transcriptPath,
-      cwd: ctx.cwd,
-      permission_mode: ctx.permissionMode ?? "bypassPermissions",
-      hook_event_name: "PostToolUse",
-      tool_name: transformedToolName,
-      tool_input: objectToSnakeCase(ctx.toolInput),
-      tool_response: objectToSnakeCase(ctx.toolOutput),
-      tool_use_id: ctx.toolUseId,
-      hook_source: "opencode-plugin",
-    }
-
-    const messages: string[] = []
-    const warnings: string[] = []
-    let firstHookName: string | undefined
-
-    const startTime = Date.now()
-
-     for (const matcher of matchers) {
-       if (!matcher.hooks || matcher.hooks.length === 0) continue
-       for (const hook of matcher.hooks) {
-         if (hook.type !== "command" && hook.type !== "http") continue
-
-        const hookName = getHookIdentifier(hook)
-        if (isHookCommandDisabled("PostToolUse", hookName, extendedConfig ?? null)) {
-          log("PostToolUse hook command skipped (disabled by config)", { command: hookName, toolName: ctx.toolName })
-          continue
-        }
-
-        if (!firstHookName) firstHookName = hookName
-
-        const result = await dispatchHook(hook, JSON.stringify(stdinData), ctx.cwd)
-
-        if (result.stdout) {
-          messages.push(result.stdout)
-        }
-
-        if (result.exitCode === 2) {
-          if (result.stderr) {
-            warnings.push(`[${hookName}]\n${result.stderr.trim()}`)
-          }
-          continue
-        }
-
-        if (result.exitCode === 0 && result.stdout) {
-          try {
-            const output = JSON.parse(result.stdout || "{}") as PostToolUseOutput
-            if (output.decision === "block") {
-              return {
-                block: true,
-                reason: output.reason || result.stderr,
-                message: messages.join("\n"),
-                warnings: warnings.length > 0 ? warnings : undefined,
-                elapsedMs: Date.now() - startTime,
-                hookName: firstHookName,
-                toolName: transformedToolName,
-                additionalContext: output.hookSpecificOutput?.additionalContext,
-                continue: output.continue,
-                stopReason: output.stopReason,
-                suppressOutput: output.suppressOutput,
-                systemMessage: output.systemMessage,
-              }
-            }
-            if (output.hookSpecificOutput?.additionalContext || output.continue !== undefined || output.systemMessage || output.suppressOutput === true || output.stopReason !== undefined) {
-              return {
-                block: false,
-                message: messages.join("\n"),
-                warnings: warnings.length > 0 ? warnings : undefined,
-                elapsedMs: Date.now() - startTime,
-                hookName: firstHookName,
-                toolName: transformedToolName,
-                additionalContext: output.hookSpecificOutput?.additionalContext,
-                continue: output.continue,
-                stopReason: output.stopReason,
-                suppressOutput: output.suppressOutput,
-                systemMessage: output.systemMessage,
-              }
-            }
-          } catch {
-          }
-        } else if (result.exitCode !== 0 && result.exitCode !== 2) {
-          try {
-            const output = JSON.parse(result.stdout || "{}") as PostToolUseOutput
-            if (output.decision === "block") {
-              return {
-                block: true,
-                reason: output.reason || result.stderr,
-                message: messages.join("\n"),
-                warnings: warnings.length > 0 ? warnings : undefined,
-                elapsedMs: Date.now() - startTime,
-                hookName: firstHookName,
-                toolName: transformedToolName,
-                additionalContext: output.hookSpecificOutput?.additionalContext,
-                continue: output.continue,
-                stopReason: output.stopReason,
-                suppressOutput: output.suppressOutput,
-                systemMessage: output.systemMessage,
-              }
-            }
-          } catch {
-          }
-        }
-      }
-    }
-
-    const elapsedMs = Date.now() - startTime
-
-    return {
-      block: false,
-      message: messages.length > 0 ? messages.join("\n") : undefined,
-      warnings: warnings.length > 0 ? warnings : undefined,
-      elapsedMs,
-      hookName: firstHookName,
-      toolName: transformedToolName,
-    }
-  } finally {
-    // PORT FROM DISABLED: Cleanup temp file to avoid disk accumulation
-    deleteTempTranscript(tempTranscriptPath)
-  }
-}

package/src/hooks/claude-code-hooks/pre-compact.ts

@@ -1,105 +0,0 @@
-import type {
-  PreCompactInput,
-  PreCompactOutput,
-  ClaudeHooksConfig,
-} from "./types"
-import { findMatchingHooks, log } from "../../shared"
-import { dispatchHook, getHookIdentifier } from "./dispatch-hook"
-import { isHookCommandDisabled, type PluginExtendedConfig } from "./config-loader"
-
-export interface PreCompactContext {
-  sessionId: string
-  cwd: string
-}
-
-export interface PreCompactResult {
-  context: string[]
-  elapsedMs?: number
-  hookName?: string
-  continue?: boolean
-  stopReason?: string
-  suppressOutput?: boolean
-  systemMessage?: string
-}
-
-export async function executePreCompactHooks(
-  ctx: PreCompactContext,
-  config: ClaudeHooksConfig | null,
-  extendedConfig?: PluginExtendedConfig | null
-): Promise<PreCompactResult> {
-  if (!config) {
-    return { context: [] }
-  }
-
-  const matchers = findMatchingHooks(config, "PreCompact", "*")
-  if (matchers.length === 0) {
-    return { context: [] }
-  }
-
-  const stdinData: PreCompactInput = {
-    session_id: ctx.sessionId,
-    cwd: ctx.cwd,
-    hook_event_name: "PreCompact",
-    hook_source: "opencode-plugin",
-  }
-
-  const startTime = Date.now()
-  let firstHookName: string | undefined
-  const collectedContext: string[] = []
-
-   for (const matcher of matchers) {
-     if (!matcher.hooks || matcher.hooks.length === 0) continue
-     for (const hook of matcher.hooks) {
-       if (hook.type !== "command" && hook.type !== "http") continue
-
-      const hookName = getHookIdentifier(hook)
-      if (isHookCommandDisabled("PreCompact", hookName, extendedConfig ?? null)) {
-        log("PreCompact hook command skipped (disabled by config)", { command: hookName })
-        continue
-      }
-
-      if (!firstHookName) firstHookName = hookName
-
-      const result = await dispatchHook(hook, JSON.stringify(stdinData), ctx.cwd)
-
-      if (result.exitCode === 2) {
-        log("PreCompact hook blocked", { hookName, stderr: result.stderr })
-        continue
-      }
-
-      if (result.stdout) {
-        try {
-          const output = JSON.parse(result.stdout || "{}") as PreCompactOutput
-
-          if (output.hookSpecificOutput?.additionalContext) {
-            collectedContext.push(...output.hookSpecificOutput.additionalContext)
-          } else if (output.context) {
-            collectedContext.push(...output.context)
-          }
-
-          if (output.continue === false) {
-            return {
-              context: collectedContext,
-              elapsedMs: Date.now() - startTime,
-              hookName: firstHookName,
-              continue: output.continue,
-              stopReason: output.stopReason,
-              suppressOutput: output.suppressOutput,
-              systemMessage: output.systemMessage,
-            }
-          }
-        } catch {
-          if (result.stdout.trim()) {
-            collectedContext.push(result.stdout.trim())
-          }
-        }
-      }
-    }
-  }
-
-  return {
-    context: collectedContext,
-    elapsedMs: Date.now() - startTime,
-    hookName: firstHookName,
-  }
-}

package/src/hooks/claude-code-hooks/pre-tool-use.ts

@@ -1,168 +0,0 @@
-import type {
-  PreToolUseInput,
-  PreToolUseOutput,
-  PermissionDecision,
-  ClaudeHooksConfig,
-} from "./types"
-import { findMatchingHooks, objectToSnakeCase, transformToolName, log } from "../../shared"
-import { dispatchHook, getHookIdentifier } from "./dispatch-hook"
-import { isHookCommandDisabled, type PluginExtendedConfig } from "./config-loader"
-
-export interface PreToolUseContext {
-  sessionId: string
-  toolName: string
-  toolInput: Record<string, unknown>
-  cwd: string
-  transcriptPath?: string
-  toolUseId?: string
-  permissionMode?: "default" | "plan" | "acceptEdits" | "bypassPermissions"
-}
-
-export interface PreToolUseResult {
-  decision: PermissionDecision
-  reason?: string
-  modifiedInput?: Record<string, unknown>
-  elapsedMs?: number
-  hookName?: string
-  toolName?: string
-  inputLines?: string
-  // Common output fields (Claude Code spec)
-  continue?: boolean
-  stopReason?: string
-  suppressOutput?: boolean
-  systemMessage?: string
-}
-
-function buildInputLines(toolInput: Record<string, unknown>): string {
-  return Object.entries(toolInput)
-    .slice(0, 3)
-    .map(([key, val]) => {
-      const valStr = String(val).slice(0, 40)
-      return `  ${key}: ${valStr}${String(val).length > 40 ? "..." : ""}`
-    })
-    .join("\n")
-}
-
-export async function executePreToolUseHooks(
-  ctx: PreToolUseContext,
-  config: ClaudeHooksConfig | null,
-  extendedConfig?: PluginExtendedConfig | null
-): Promise<PreToolUseResult> {
-  if (!config) {
-    return { decision: "allow" }
-  }
-
-  const transformedToolName = transformToolName(ctx.toolName)
-  const matchers = findMatchingHooks(config, "PreToolUse", transformedToolName)
-  if (matchers.length === 0) {
-    return { decision: "allow" }
-  }
-
-  const stdinData: PreToolUseInput = {
-    session_id: ctx.sessionId,
-    transcript_path: ctx.transcriptPath,
-    cwd: ctx.cwd,
-    permission_mode: ctx.permissionMode ?? "bypassPermissions",
-    hook_event_name: "PreToolUse",
-    tool_name: transformedToolName,
-    tool_input: objectToSnakeCase(ctx.toolInput),
-    tool_use_id: ctx.toolUseId,
-    hook_source: "opencode-plugin",
-  }
-
-  const startTime = Date.now()
-  let firstHookName: string | undefined
-  const inputLines = buildInputLines(ctx.toolInput)
-
-   for (const matcher of matchers) {
-     if (!matcher.hooks || matcher.hooks.length === 0) continue
-     for (const hook of matcher.hooks) {
-       if (hook.type !== "command" && hook.type !== "http") continue
-
-      const hookName = getHookIdentifier(hook)
-      if (isHookCommandDisabled("PreToolUse", hookName, extendedConfig ?? null)) {
-        log("PreToolUse hook command skipped (disabled by config)", { command: hookName, toolName: ctx.toolName })
-        continue
-      }
-
-      if (!firstHookName) firstHookName = hookName
-
-      const result = await dispatchHook(hook, JSON.stringify(stdinData), ctx.cwd)
-
-      if (result.exitCode === 2) {
-        return {
-          decision: "deny",
-          reason: result.stderr || result.stdout || "Hook blocked the operation",
-          elapsedMs: Date.now() - startTime,
-          hookName: firstHookName,
-          toolName: transformedToolName,
-          inputLines,
-        }
-      }
-
-      if (result.exitCode === 1) {
-        return {
-          decision: "ask",
-          reason: result.stderr || result.stdout,
-          elapsedMs: Date.now() - startTime,
-          hookName: firstHookName,
-          toolName: transformedToolName,
-          inputLines,
-        }
-      }
-
-      if (result.stdout) {
-        try {
-          const output = JSON.parse(result.stdout || "{}") as PreToolUseOutput
-
-          // Handle deprecated decision/reason fields (Claude Code backward compat)
-          let decision: PermissionDecision | undefined
-          let reason: string | undefined
-          let modifiedInput: Record<string, unknown> | undefined
-
-          if (output.hookSpecificOutput?.permissionDecision) {
-            decision = output.hookSpecificOutput.permissionDecision
-            reason = output.hookSpecificOutput.permissionDecisionReason
-            modifiedInput = output.hookSpecificOutput.updatedInput
-          } else if (output.decision) {
-            // Map deprecated values: approve->allow, block->deny, ask->ask
-            const legacyDecision = output.decision
-            if (legacyDecision === "approve" || legacyDecision === "allow") {
-              decision = "allow"
-            } else if (legacyDecision === "block" || legacyDecision === "deny") {
-              decision = "deny"
-            } else if (legacyDecision === "ask") {
-              decision = "ask"
-            }
-            reason = output.reason
-          }
-
-          // Return if decision is set OR if any common fields are set (fallback to allow)
-          const hasCommonFields = output.continue !== undefined || 
-            output.stopReason !== undefined || 
-            output.suppressOutput !== undefined || 
-            output.systemMessage !== undefined
-
-          if (decision || hasCommonFields) {
-            return {
-              decision: decision ?? "allow",
-              reason,
-              modifiedInput,
-              elapsedMs: Date.now() - startTime,
-              hookName: firstHookName,
-              toolName: transformedToolName,
-              inputLines,
-              continue: output.continue,
-              stopReason: output.stopReason,
-              suppressOutput: output.suppressOutput,
-              systemMessage: output.systemMessage,
-            }
-          }
-        } catch {
-        }
-      }
-    }
-  }
-
-  return { decision: "allow" }
-}

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

@@ -1,17 +0,0 @@
-export const sessionFirstMessageProcessed = new Set<string>()
-
-export const sessionErrorState = new Map<string, { hasError: boolean; errorMessage?: string }>()
-
-export const sessionInterruptState = new Map<string, { interrupted: boolean }>()
-
-export function clearSessionHookState(sessionID: string): void {
-	sessionErrorState.delete(sessionID)
-	sessionInterruptState.delete(sessionID)
-	sessionFirstMessageProcessed.delete(sessionID)
-}
-
-export function clearAllSessionHookState(): void {
-	sessionErrorState.clear()
-	sessionInterruptState.clear()
-	sessionFirstMessageProcessed.clear()
-}

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

@@ -1,118 +0,0 @@
-import type {
-  StopInput,
-  StopOutput,
-  ClaudeHooksConfig,
-} from "./types"
-import { findMatchingHooks, log } from "../../shared"
-import { dispatchHook, getHookIdentifier } from "./dispatch-hook"
-import { getTodoPath } from "./todo"
-import { isHookCommandDisabled, type PluginExtendedConfig } from "./config-loader"
-
-// Module-level state to track stop_hook_active per session
-const stopHookActiveState = new Map<string, boolean>()
-
-export function setStopHookActive(sessionId: string, active: boolean): void {
-  stopHookActiveState.set(sessionId, active)
-}
-
-export function getStopHookActive(sessionId: string): boolean {
-  return stopHookActiveState.get(sessionId) ?? false
-}
-
-export interface StopContext {
-  sessionId: string
-  parentSessionId?: string
-  cwd: string
-  transcriptPath?: string
-  permissionMode?: "default" | "acceptEdits" | "bypassPermissions"
-  stopHookActive?: boolean
-}
-
-export interface StopResult {
-  block: boolean
-  reason?: string
-  stopHookActive?: boolean
-  permissionMode?: "default" | "plan" | "acceptEdits" | "bypassPermissions"
-  injectPrompt?: string
-}
-
-export async function executeStopHooks(
-  ctx: StopContext,
-  config: ClaudeHooksConfig | null,
-  extendedConfig?: PluginExtendedConfig | null
-): Promise<StopResult> {
-  if (ctx.parentSessionId) {
-    return { block: false }
-  }
-
-  if (!config) {
-    return { block: false }
-  }
-
-  const matchers = findMatchingHooks(config, "Stop")
-  if (matchers.length === 0) {
-    return { block: false }
-  }
-
-  const stdinData: StopInput = {
-    session_id: ctx.sessionId,
-    transcript_path: ctx.transcriptPath,
-    cwd: ctx.cwd,
-    permission_mode: ctx.permissionMode ?? "bypassPermissions",
-    hook_event_name: "Stop",
-    stop_hook_active: stopHookActiveState.get(ctx.sessionId) ?? false,
-    todo_path: getTodoPath(ctx.sessionId),
-    hook_source: "opencode-plugin",
-  }
-
-   for (const matcher of matchers) {
-     if (!matcher.hooks || matcher.hooks.length === 0) continue
-     for (const hook of matcher.hooks) {
-       if (hook.type !== "command" && hook.type !== "http") continue
-
-      const hookName = getHookIdentifier(hook)
-      if (isHookCommandDisabled("Stop", hookName, extendedConfig ?? null)) {
-        log("Stop hook command skipped (disabled by config)", { command: hookName })
-        continue
-      }
-
-      const result = await dispatchHook(hook, JSON.stringify(stdinData), ctx.cwd)
-
-      // Check exit code first - exit code 2 means block
-      if (result.exitCode === 2) {
-        const reason = result.stderr || result.stdout || "Blocked by stop hook"
-        return {
-          block: true,
-          reason,
-          injectPrompt: reason,
-        }
-      }
-
-       if (result.stdout) {
-         try {
-           const output = JSON.parse(result.stdout || "{}") as StopOutput
-           if (output.stop_hook_active !== undefined) {
-             stopHookActiveState.set(ctx.sessionId, output.stop_hook_active)
-           }
-           const isBlock = output.decision === "block"
-           // Only return early if the hook explicitly blocks - non-blocking hooks
-           // should not prevent subsequent hooks from executing (matches Claude Code behavior)
-           if (isBlock) {
-             const injectPrompt = output.inject_prompt ?? (output.reason || undefined)
-             return {
-               block: true,
-               reason: output.reason,
-               stopHookActive: output.stop_hook_active,
-               permissionMode: output.permission_mode,
-               injectPrompt,
-             }
-           }
-         } catch {
-           // Ignore JSON parse errors - hook may return non-JSON output
-         }
-       }
-    }
-  }
-
-  return { block: false }
-}

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

@@ -1,76 +0,0 @@
-import { join } from "path"
-import { mkdirSync, writeFileSync, readFileSync, existsSync, unlinkSync } from "fs"
-import { getClaudeConfigDir } from "../../shared"
-import type { TodoFile, TodoItem, ClaudeCodeTodoItem } from "./types"
-
-const TODO_DIR = join(getClaudeConfigDir(), "todos")
-
-export function getTodoPath(sessionId: string): string {
-  return join(TODO_DIR, `${sessionId}-agent-${sessionId}.json`)
-}
-
-function ensureTodoDir(): void {
-  if (!existsSync(TODO_DIR)) {
-    mkdirSync(TODO_DIR, { recursive: true })
-  }
-}
-
-export interface OpenCodeTodo {
-  content: string
-  status: string
-  priority: string
-  id: string
-}
-
-function toClaudeCodeFormat(item: OpenCodeTodo | TodoItem): ClaudeCodeTodoItem {
-  return {
-    content: item.content,
-    status: item.status === "cancelled" ? "completed" : item.status,
-    activeForm: item.content,
-  }
-}
-
-export function loadTodoFile(sessionId: string): TodoFile | null {
-   const path = getTodoPath(sessionId)
-   if (!existsSync(path)) return null
-   try {
-     const content = JSON.parse(readFileSync(path, "utf-8"))
-     if (Array.isArray(content)) {
-       return {
-         session_id: sessionId,
-         items: content.map((item: ClaudeCodeTodoItem, idx: number) => ({
-           id: String(idx),
-           content: item.content,
-           status: item.status as TodoItem["status"],
-           created_at: new Date().toISOString(),
-         })),
-         created_at: new Date().toISOString(),
-         updated_at: new Date().toISOString(),
-       }
-     }
-     return content
-   } catch {
-     return null
-   }
-}
-
-export function saveTodoFile(sessionId: string, file: TodoFile): void {
-   ensureTodoDir()
-   const path = getTodoPath(sessionId)
-   const claudeCodeFormat: ClaudeCodeTodoItem[] = file.items.map(toClaudeCodeFormat)
-   writeFileSync(path, JSON.stringify(claudeCodeFormat, null, 2))
-}
-
-export function saveOpenCodeTodos(sessionId: string, todos: OpenCodeTodo[]): void {
-   ensureTodoDir()
-   const path = getTodoPath(sessionId)
-   const claudeCodeFormat: ClaudeCodeTodoItem[] = todos.map(toClaudeCodeFormat)
-   writeFileSync(path, JSON.stringify(claudeCodeFormat, null, 2))
-}
-
-export function deleteTodoFile(sessionId: string): void {
-   const path = getTodoPath(sessionId)
-   if (existsSync(path)) {
-     unlinkSync(path)
-   }
-}