@nicerice/openhooks 0.0.1 → 0.0.2

package/index.ts

@@ -1,10 +1,10 @@
-import { loadConfig } from "./src/infrastructure/config.ts"
-import { registerHooks } from "./src/application/hooks.ts"
+import { loadConfig } from "./src/infrastructure/config/load-config.ts"
+import { registerHooks } from "./src/application/hooks/register-hooks.ts"
 
-export const OpenhooksPlugin = async (ctx: { worktree?: string; directory?: string; project?: { root?: string } }) => {
+export function OpenhooksPlugin(ctx: { worktree?: string; directory?: string; project?: { root?: string } }) {
   const root = ctx.worktree || ctx.directory || ctx.project?.root || process.cwd()
   const config = loadConfig(root)
+
   return registerHooks(config)
 }
 
-export default OpenhooksPlugin

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@nicerice/openhooks",
   "description": "[opencode plugin] Hook any command into opencode's tool events.",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "type": "module",
   "main": "./index.ts",
   "exports": {
@@ -19,7 +19,8 @@
     "test": "bun test"
   },
   "devDependencies": {
-    "@types/bun": "latest"
-  },
-  "dependencies": {}
+    "@types/bun": "latest",
+    "@types/node": "^26.1.1",
+    "typescript": "^7.0.2"
+  }
 }

package/src/application/hooks/create-session-handler.ts

@@ -0,0 +1,11 @@
+import type { SessionHookEntry } from "../../domain/types/session-hook-entry.ts"
+import type { EventInput } from "../types/event-input.ts"
+import { resolveLabel } from "./resolve-label.ts"
+import { runActions } from "./run-actions.ts"
+
+export function createSessionHandler(entries: SessionHookEntry[]) {
+  return (input: EventInput) => entries.forEach(e => {
+    if (input.event.type !== e.event && input.event.type !== e.event.replace("session.", "")) return
+    try { runActions(e.actions) } catch {}
+  })
+}

package/src/application/hooks/create-tool-handler.ts

@@ -0,0 +1,21 @@
+import type { EventType } from "../../domain/types/event-types.ts"
+import type { HookEntry } from "../../domain/types/hook-entry.ts"
+import type { ToolInput } from "../types/tool-input.ts"
+import type { ToolOutput } from "../types/tool-output.ts"
+import { matchesTool } from "./matches-tool.ts"
+import { resolveLabel } from "./resolve-label.ts"
+import { runActions } from "./run-actions.ts"
+
+export function createToolHandler(event: string, entries: (HookEntry & { tools?: string[] })[]) {
+  return async (input: ToolInput, output?: ToolOutput) => {
+    for (const entry of entries) {
+      if (!matchesTool(entry, input.tool)) continue
+
+      if (output) {
+        output.title = resolveLabel(entry, event as EventType)
+      }
+
+      runActions(entry.actions, output)
+    }
+  }
+}

package/src/application/hooks/matches-tool.ts

@@ -0,0 +1,7 @@
+import type { HookEntry } from "../../domain/types/hook-entry.ts"
+
+export function matchesTool(entry: HookEntry & { tools?: string[] }, tool: string) {
+  if (!entry.tools) return true
+
+  return entry.tools.includes(tool)
+}

package/src/application/hooks/partition-entries.ts

@@ -0,0 +1,20 @@
+import type { HooksConfig } from "../../domain/types/hooks-config.ts"
+import type { HookEntry } from "../../domain/types/hook-entry.ts"
+import type { SessionHookEntry } from "../../domain/types/session-hook-entry.ts"
+
+export function partitionEntries(config: HooksConfig) {
+  const toolHooks: Record<string, (HookEntry & { tools?: string[] })[]> = {}
+  const sessionHooks: SessionHookEntry[] = []
+
+  for (const entry of config.hooks) {
+    if (entry.event.startsWith("tool.")) {
+      if (!toolHooks[entry.event]) toolHooks[entry.event] = []
+
+      toolHooks[entry.event]!.push(entry as HookEntry & { tools?: string[] })
+    } else if (entry.event.startsWith("session.")) {
+      sessionHooks.push(entry as SessionHookEntry)
+    }
+  }
+
+  return { toolHooks, sessionHooks }
+}

package/src/application/hooks/register-hooks.ts

@@ -0,0 +1,19 @@
+import type { HooksConfig } from "../../domain/types/hooks-config.ts"
+import { partitionEntries } from "./partition-entries.ts"
+import { createToolHandler } from "./create-tool-handler.ts"
+import { createSessionHandler } from "./create-session-handler.ts"
+
+export function registerHooks(config: HooksConfig) {
+  const partitioned = partitionEntries(config)
+  const hooks: Record<string, Function> = {}
+
+  for (const [event, entries] of Object.entries(partitioned.toolHooks)) {
+    hooks[event] = createToolHandler(event, entries)
+  }
+
+  if (partitioned.sessionHooks.length > 0) {
+    hooks.event = createSessionHandler(partitioned.sessionHooks)
+  }
+
+  return hooks
+}

package/src/application/hooks/resolve-label.ts

@@ -0,0 +1,3 @@
+export function resolveLabel(entry: { id?: string }, fallback: string) {
+  return entry.id || fallback
+}

package/src/application/hooks/run-actions.ts

@@ -0,0 +1,10 @@
+import { exec } from "../../infrastructure/executor.ts"
+
+export function runActions(actions: { bash: string }[], label?: { output?: string }) {
+  for (const action of actions) {
+    const result = exec(action.bash)
+    const msg = result.stderr || result.stdout || ""
+    if (label) label.output = msg
+    if (result.exitCode !== 0) throw new Error(msg)
+  }
+}

package/src/application/types/event-input.ts

@@ -0,0 +1,3 @@
+export type EventInput = {
+  event: { type: string; properties?: Record<string, unknown> }
+}

package/src/application/types/tool-input.ts

@@ -0,0 +1,6 @@
+export type ToolInput = {
+  tool: string
+  sessionID: string
+  callID: string
+  args?: Record<string, unknown>
+}

package/src/application/types/tool-output.ts

@@ -0,0 +1,5 @@
+export type ToolOutput = {
+  title?: string
+  output?: string
+  metadata?: Record<string, unknown>
+}

package/src/domain/types/bash-action.ts

@@ -0,0 +1,4 @@
+export type BashAction = {
+  bash: string
+  timeout?: number
+}

package/src/domain/types/event-types.ts

@@ -0,0 +1,9 @@
+export type EventType =
+  | "tool.execute.before"
+  | "tool.execute.after"
+
+export type SessionEventType =
+  | "session.created"
+  | "session.deleted"
+  | "session.idle"
+  | "session.error"

package/src/domain/types/exec-result.ts

@@ -0,0 +1,5 @@
+export type ExecResult = {
+  exitCode: number
+  stdout: string
+  stderr: string
+}

package/src/domain/types/hook-entry.ts

@@ -0,0 +1,9 @@
+import type { EventType } from "./event-types.ts"
+import type { BashAction } from "./bash-action.ts"
+
+export type HookEntry = {
+  id?: string
+  event: EventType
+  tools?: string[]
+  actions: BashAction[]
+}

package/src/domain/types/hooks-config.ts

@@ -0,0 +1,6 @@
+import type { HookEntry } from "./hook-entry.ts"
+import type { SessionHookEntry } from "./session-hook-entry.ts"
+
+export type HooksConfig = {
+  hooks: (HookEntry | SessionHookEntry)[]
+}

package/src/domain/types/session-hook-entry.ts

@@ -0,0 +1,8 @@
+import type { SessionEventType } from "./event-types.ts"
+import type { BashAction } from "./bash-action.ts"
+
+export type SessionHookEntry = {
+  id?: string
+  event: SessionEventType
+  actions: BashAction[]
+}

package/src/infrastructure/config/append-action.ts

@@ -0,0 +1,14 @@
+import type { BashAction } from "../../domain/types/bash-action.ts"
+import { parseBashLine } from "./parse-bash-line.ts"
+
+export function appendAction(current: Record<string, unknown>, line: string) {
+  const parsed = parseBashLine(line)
+
+  if (!parsed) return false
+
+  if (!Array.isArray(current.actions)) current.actions = []
+
+  ;(current.actions as BashAction[]).push(parsed)
+
+  return true
+}

package/src/infrastructure/config/apply-property.ts

@@ -0,0 +1,16 @@
+import { parsePropLine } from "./parse-prop-line.ts"
+import { parseToolsList } from "./parse-tools-list.ts"
+
+export function applyProperty(current: Record<string, unknown>, line: string) {
+  const prop = parsePropLine(line)
+
+  if (!prop) return
+
+  if (prop.key === "tools" && prop.value.startsWith("[")) {
+    current.tools = parseToolsList(prop.value)
+  } else if (prop.key === "actions") {
+    if (!Array.isArray(current.actions)) current.actions = []
+  } else {
+    current[prop.key] = prop.value
+  }
+}

package/src/infrastructure/config/finalize-group.ts

@@ -0,0 +1,3 @@
+export function finalizeGroup(current: Record<string, unknown> | null, hooks: unknown[]) {
+  if (current) hooks.push(current)
+}

package/src/infrastructure/config/load-config.ts

@@ -0,0 +1,12 @@
+import type { HooksConfig } from "../../domain/types/hooks-config.ts"
+import { loadGlobal } from "./load-global.ts"
+import { loadProject } from "./load-project.ts"
+import { mergeHooks } from "./merge-by-id.ts"
+
+export function loadConfig(worktree: string) {
+  const global = loadGlobal()
+  const project = loadProject(worktree)
+  const merged = mergeHooks(global, project)
+
+  return { hooks: merged }
+}

package/src/infrastructure/config/load-global.ts

@@ -0,0 +1,13 @@
+import { existsSync, readFileSync } from "node:fs"
+import type { HookEntry } from "../../domain/types/hook-entry.ts"
+import type { SessionHookEntry } from "../../domain/types/session-hook-entry.ts"
+import { getGlobalPath } from "./paths.ts"
+import { parseYaml } from "./parse-yaml.ts"
+
+export function loadGlobal() {
+  if (!existsSync(getGlobalPath())) return []
+
+  const parsed = parseYaml(readFileSync(getGlobalPath(), "utf-8"))
+
+  return parsed.hooks
+}

package/src/infrastructure/config/load-project.ts

@@ -0,0 +1,13 @@
+import { existsSync, readFileSync } from "node:fs"
+import { join } from "node:path"
+import { parseYaml } from "./parse-yaml.ts"
+
+export function loadProject(worktree: string) {
+  const projectPath = join(worktree, ".opencode/hooks.yaml")
+
+  if (!existsSync(projectPath)) return []
+
+  const parsed = parseYaml(readFileSync(projectPath, "utf-8"))
+
+  return parsed.hooks
+}

package/src/infrastructure/config/merge-by-id.ts

@@ -0,0 +1,7 @@
+import type { HookEntry } from "../../domain/types/hook-entry.ts"
+import type { SessionHookEntry } from "../../domain/types/session-hook-entry.ts"
+
+export function mergeHooks(global: (HookEntry | SessionHookEntry)[], project: (HookEntry | SessionHookEntry)[]) {
+  const ids = new Set(project.map(h => h.id).filter(Boolean))
+  return [...global.filter(h => !ids.has(h.id)), ...project]
+}

package/src/infrastructure/config/parse-bash-line.ts

@@ -0,0 +1,7 @@
+export function parseBashLine(line: string) {
+  const match = line.match(/^\s+- bash:\s*(.*)/)
+
+  if (!match) return null
+
+  return { bash: match[1]!.trim().replace(/^["']|["']$/g, "") }
+}

package/src/infrastructure/config/parse-list-line.ts

@@ -0,0 +1,7 @@
+export function parseListLine(line: string) {
+  const match = line.match(/^  - (\w+):\s*(.*)/)
+
+  if (!match) return null
+
+  return { key: match[1]!, value: match[2]!.trim() }
+}

package/src/infrastructure/config/parse-prop-line.ts

@@ -0,0 +1,7 @@
+export function parsePropLine(line: string) {
+  const match = line.match(/^\s+(\w+):\s*(.*)/)
+
+  if (!match) return null
+
+  return { key: match[1]!, value: match[2]!.trim() }
+}

package/src/infrastructure/config/parse-tools-list.ts

@@ -0,0 +1,3 @@
+export function parseToolsList(val: string) {
+  return val.slice(1, -1).split(",").map(s => s.trim().replace(/['"]/g, ""))
+}

package/src/infrastructure/config/parse-yaml.ts

@@ -0,0 +1,18 @@
+import type { HooksConfig } from "../../domain/types/hooks-config.ts"
+import type { HookEntry } from "../../domain/types/hook-entry.ts"
+import type { SessionHookEntry } from "../../domain/types/session-hook-entry.ts"
+import { processLine } from "./process-line.ts"
+import { finalizeGroup } from "./finalize-group.ts"
+
+export function parseYaml(text: string) {
+  const hooks: (HookEntry | SessionHookEntry)[] = []
+  let current: Record<string, unknown> | null = null
+
+  for (const raw of text.split("\n")) {
+    current = processLine(raw, current, hooks)
+  }
+
+  finalizeGroup(current, hooks)
+
+  return { hooks }
+}

package/src/infrastructure/config/paths.ts

@@ -0,0 +1,6 @@
+import { homedir } from "node:os"
+import { join } from "node:path"
+
+export function getGlobalPath() {
+  return join(homedir(), ".config", "opencode", "hooks.yaml")
+}

package/src/infrastructure/config/process-line.ts

@@ -0,0 +1,26 @@
+import { isSkipLine } from "./skip-line.ts"
+import { parseListLine } from "./parse-list-line.ts"
+import { appendAction } from "./append-action.ts"
+import { applyProperty } from "./apply-property.ts"
+
+export function processLine(raw: string, current: Record<string, unknown> | null, hooks: Record<string, unknown>[]) {
+  const line = raw.trimEnd()
+
+  if (isSkipLine(line)) return current
+
+  const parsed = parseListLine(line)
+
+  if (parsed) {
+    if (current) hooks.push(current)
+
+    return { [parsed.key]: parsed.value }
+  }
+
+  if (!current) return current
+
+  if (appendAction(current, line)) return current
+
+  applyProperty(current, line)
+
+  return current
+}

package/src/infrastructure/config/skip-line.ts

@@ -0,0 +1,3 @@
+export function isSkipLine(line: string) {
+  return line.trim() === "" || line.trimStart().startsWith("#")
+}

package/src/infrastructure/executor.ts

@@ -1,7 +1,7 @@
 import { spawnSync } from "node:child_process"
-import type { ExecResult } from "../domain/types.ts"
+import type { ExecResult } from "../domain/types/exec-result.ts"
 
-export const exec = (command: string, timeoutMs = 60_000): ExecResult => {
+export function exec(command: string, timeoutMs = 60_000) {
   const result = spawnSync(command, {
     stdio: ["ignore", "pipe", "pipe"],
     encoding: "utf-8",

package/src/application/hooks.ts

@@ -1,81 +0,0 @@
-import type { HooksConfig, HookEntry, SessionHookEntry, ExecResult } from "../domain/types.ts"
-import { exec } from "../infrastructure/executor.ts"
-
-type ToolInput = {
-  tool: string
-  sessionID: string
-  callID: string
-  args?: Record<string, unknown>
-}
-
-type ToolOutput = {
-  title?: string
-  output?: string
-  metadata?: Record<string, unknown>
-}
-
-type EventInput = {
-  event: { type: string; properties?: Record<string, unknown> }
-}
-
-const runActions = (actions: { bash: string }[], label: string): void => {
-  for (const action of actions) {
-    const result: ExecResult = exec(action.bash)
-    if (result.exitCode === 0) continue
-    throw new Error(`openhooks: ${label} failed (exit ${result.exitCode})\n${result.stderr || result.stdout}`)
-  }
-}
-
-export const registerHooks = (config: HooksConfig) => {
-  const toolHooks: Record<string, (HookEntry & { tools?: string[] })[]> = {}
-  const sessionHooks: SessionHookEntry[] = []
-
-  for (const entry of config.hooks) {
-    if ("tools" in entry) {
-      if (!toolHooks[entry.event]) toolHooks[entry.event] = []
-      toolHooks[entry.event]!.push(entry as HookEntry & { tools?: string[] })
-    } else if (entry.event.startsWith("session.")) {
-      sessionHooks.push(entry as SessionHookEntry)
-    }
-  }
-
-  const hooks: Record<string, (input: ToolInput | EventInput, output?: ToolOutput) => Promise<void>> = {}
-
-  for (const [event, entries] of Object.entries(toolHooks)) {
-    if (event === "tool.execute.before" || event === "tool.execute.after") {
-      hooks[event] = async (input: ToolInput, output?: ToolOutput) => {
-        const toolInput = input as ToolInput
-
-        for (const entry of entries) {
-          if (entry.tools && !entry.tools.includes(toolInput.tool)) continue
-
-          if (output) {
-            output.title = entry.id || event
-          }
-
-          runActions(entry.actions, entry.id || event)
-        }
-      }
-    }
-  }
-
-  if (sessionHooks.length > 0) {
-    hooks.event = async (input: EventInput) => {
-      const type = input.event.type
-
-      for (const entry of sessionHooks) {
-        const sessionEvent = entry.event.replace("session.", "")
-        if (type !== sessionEvent && type !== entry.event) continue
-
-        try {
-          runActions(entry.actions, entry.id || entry.event)
-        } catch (e) {
-          // ponytail: don't throw for session events, just log
-          console.error(`openhooks: session hook failed: ${e}`)
-        }
-      }
-    }
-  }
-
-  return hooks
-}

package/src/domain/types.ts

@@ -1,37 +0,0 @@
-export type EventType =
-  | "tool.execute.before"
-  | "tool.execute.after"
-
-export type SessionEventType =
-  | "session.created"
-  | "session.deleted"
-  | "session.idle"
-  | "session.error"
-
-export type BashAction = {
-  bash: string
-  timeout?: number
-}
-
-export type HookEntry = {
-  id?: string
-  event: EventType
-  tools?: string[]
-  actions: BashAction[]
-}
-
-export type SessionHookEntry = {
-  id?: string
-  event: SessionEventType
-  actions: BashAction[]
-}
-
-export type HooksConfig = {
-  hooks: (HookEntry | SessionHookEntry)[]
-}
-
-export type ExecResult = {
-  exitCode: number
-  stdout: string
-  stderr: string
-}

package/src/infrastructure/config.ts

@@ -1,73 +0,0 @@
-import { readFileSync, existsSync } from "node:fs"
-import { homedir } from "node:os"
-import { join } from "node:path"
-import type { HooksConfig, HookEntry, SessionHookEntry } from "../domain/types.ts"
-
-const parseYaml = (text: string): HooksConfig => {
-  const hooks: (HookEntry | SessionHookEntry)[] = []
-  let current: Record<string, unknown> | null = null
-  const lines = text.split("\n")
-
-  for (const raw of lines) {
-    const line = raw.trimEnd()
-    if (line.trim() === "" || line.trimStart().startsWith("#")) continue
-
-    const listStart = line.match(/^  - (\w+):\s*(.*)/)
-    if (listStart) {
-      if (current) hooks.push(current as HookEntry | SessionHookEntry)
-      current = { [listStart[1]!]: listStart[2]!.trim() } as Record<string, unknown>
-      continue
-    }
-
-    if (!current) continue
-
-    const propMatch = line.match(/^\s+(\w+):\s*(.*)/)
-    const bashMatch = line.match(/^\s+- bash:\s*(.*)/)
-
-    if (!propMatch && !bashMatch) continue
-
-    if (bashMatch) {
-      if (!current.actions || !Array.isArray(current.actions)) current.actions = []
-      ;(current.actions as { bash: string }[]).push({ bash: bashMatch[1]!.trim().replace(/^["']|["']$/g, "") })
-      continue
-    }
-
-    const key = propMatch![1]!
-    const val = propMatch![2]!.trim()
-
-    if (key === "tools" && val.startsWith("[")) {
-      current.tools = val.slice(1, -1).split(",").map((s) => s.trim().replace(/['"]/g, ""))
-    } else if (key === "actions") {
-      if (!current.actions) current.actions = []
-    } else {
-      current[key] = val
-    }
-  }
-
-  if (current) hooks.push(current as HookEntry | SessionHookEntry)
-
-  return { hooks }
-}
-
-const GLOBAL_PATH = join(homedir(), ".config", "opencode", "hooks.yaml")
-const PROJECT_PATH = ".opencode/hooks.yaml"
-
-export const loadConfig = (worktree: string): HooksConfig => {
-  const allHooks: (HookEntry | SessionHookEntry)[] = []
-
-  if (existsSync(GLOBAL_PATH)) {
-    const global = parseYaml(readFileSync(GLOBAL_PATH, "utf-8"))
-    allHooks.push(...global.hooks)
-  }
-
-  const projectPath = join(worktree, PROJECT_PATH)
-  if (existsSync(projectPath)) {
-    const project = parseYaml(readFileSync(projectPath, "utf-8"))
-    const ids = new Set(project.hooks.map((h) => h.id).filter(Boolean))
-    const filtered = allHooks.filter((h) => !ids.has(h.id))
-    allHooks.length = 0
-    allHooks.push(...filtered, ...project.hooks)
-  }
-
-  return { hooks: allHooks }
-}