opencode-repos 0.3.0 → 0.3.1

package/oh-my-opencode/src/hooks/claude-code-hooks/pre-compact.ts

@@ -1,109 +0,0 @@
-import type {
-  PreCompactInput,
-  PreCompactOutput,
-  ClaudeHooksConfig,
-} from "./types"
-import { findMatchingHooks, executeHookCommand, log } from "../../shared"
-import { DEFAULT_CONFIG } from "./plugin-config"
-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) {
-    for (const hook of matcher.hooks) {
-      if (hook.type !== "command") continue
-
-      if (isHookCommandDisabled("PreCompact", hook.command, extendedConfig ?? null)) {
-        log("PreCompact hook command skipped (disabled by config)", { command: hook.command })
-        continue
-      }
-
-      const hookName = hook.command.split("/").pop() || hook.command
-      if (!firstHookName) firstHookName = hookName
-
-      const result = await executeHookCommand(
-        hook.command,
-        JSON.stringify(stdinData),
-        ctx.cwd,
-        { forceZsh: DEFAULT_CONFIG.forceZsh, zshPath: DEFAULT_CONFIG.zshPath }
-      )
-
-      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/oh-my-opencode/src/hooks/claude-code-hooks/pre-tool-use.ts

@@ -1,172 +0,0 @@
-import type {
-  PreToolUseInput,
-  PreToolUseOutput,
-  PermissionDecision,
-  ClaudeHooksConfig,
-} from "./types"
-import { findMatchingHooks, executeHookCommand, objectToSnakeCase, transformToolName, log } from "../../shared"
-import { DEFAULT_CONFIG } from "./plugin-config"
-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) {
-    for (const hook of matcher.hooks) {
-      if (hook.type !== "command") continue
-
-      if (isHookCommandDisabled("PreToolUse", hook.command, extendedConfig ?? null)) {
-        log("PreToolUse hook command skipped (disabled by config)", { command: hook.command, toolName: ctx.toolName })
-        continue
-      }
-
-      const hookName = hook.command.split("/").pop() || hook.command
-      if (!firstHookName) firstHookName = hookName
-
-      const result = await executeHookCommand(
-        hook.command,
-        JSON.stringify(stdinData),
-        ctx.cwd,
-        { forceZsh: DEFAULT_CONFIG.forceZsh, zshPath: DEFAULT_CONFIG.zshPath }
-      )
-
-      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/oh-my-opencode/src/hooks/claude-code-hooks/stop.ts

@@ -1,118 +0,0 @@
-import type {
-  StopInput,
-  StopOutput,
-  ClaudeHooksConfig,
-} from "./types"
-import { findMatchingHooks, executeHookCommand, log } from "../../shared"
-import { DEFAULT_CONFIG } from "./plugin-config"
-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) {
-    for (const hook of matcher.hooks) {
-      if (hook.type !== "command") continue
-
-      if (isHookCommandDisabled("Stop", hook.command, extendedConfig ?? null)) {
-        log("Stop hook command skipped (disabled by config)", { command: hook.command })
-        continue
-      }
-
-      const result = await executeHookCommand(
-        hook.command,
-        JSON.stringify(stdinData),
-        ctx.cwd,
-        { forceZsh: DEFAULT_CONFIG.forceZsh, zshPath: DEFAULT_CONFIG.zshPath }
-      )
-
-      // 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"
-           // Determine inject_prompt: prefer explicit value, fallback to reason if blocking
-           const injectPrompt = output.inject_prompt ?? (isBlock && output.reason ? output.reason : undefined)
-           return {
-             block: isBlock,
-             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/oh-my-opencode/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)
-   }
-}

package/oh-my-opencode/src/hooks/claude-code-hooks/tool-input-cache.ts

@@ -1,47 +0,0 @@
-/**
- * Caches tool_input from PreToolUse for PostToolUse
- */
-
-interface CacheEntry {
-  toolInput: Record<string, unknown>
-  timestamp: number
-}
-
-const cache = new Map<string, CacheEntry>()
-
-const CACHE_TTL = 60000 // 1 minute
-
-export function cacheToolInput(
-  sessionId: string,
-  toolName: string,
-  invocationId: string,
-  toolInput: Record<string, unknown>
-): void {
-  const key = `${sessionId}:${toolName}:${invocationId}`
-  cache.set(key, { toolInput, timestamp: Date.now() })
-}
-
-export function getToolInput(
-  sessionId: string,
-  toolName: string,
-  invocationId: string
-): Record<string, unknown> | null {
-  const key = `${sessionId}:${toolName}:${invocationId}`
-  const entry = cache.get(key)
-  if (!entry) return null
-
-   cache.delete(key)
-  if (Date.now() - entry.timestamp > CACHE_TTL) return null
-
-  return entry.toolInput
-}
-
-// Periodic cleanup (every minute)
-setInterval(() => {
-  const now = Date.now()
-  for (const [key, entry] of cache.entries()) {
-    if (now - entry.timestamp > CACHE_TTL) {
-      cache.delete(key)
-    }
-  }
-}, CACHE_TTL)