oh-my-opencode 0.1.32 → 0.3.0

package/README.ko.md

@@ -15,6 +15,7 @@
       - [내장 AST-Grep Tools](#내장-ast-grep-tools)
       - [Grep](#grep)
       - [내장 MCPs](#내장-mcps)
+    - [Claude Code 호환성](#claude-code-호환성)
     - [기타 편의 기능](#기타-편의-기능)
   - [설정](#설정)
   - [작성자의 노트](#작성자의-노트)
@@ -224,17 +225,72 @@ OpenCode 는 아주 확장가능하고 아주 커스터마이저블합니다.
 }
 ```
 
+### Claude Code 호환성
+
+Oh My OpenCode는 Claude Code 설정과 완벽하게 호환됩니다. Claude Code를 사용하셨다면, 기존 설정을 그대로 사용할 수 있습니다.
+
+#### Hooks 통합
+
+Claude Code의 `settings.json` 훅 시스템을 통해 커스텀 스크립트를 실행합니다. Oh My OpenCode는 다음 위치의 훅을 읽고 실행합니다:
+
+- `~/.claude/settings.json` (사용자)
+- `./.claude/settings.json` (프로젝트)
+- `./.claude/settings.local.json` (로컬, git-ignored)
+
+지원되는 훅 이벤트:
+- **PreToolUse**: 도구 실행 전에 실행. 차단하거나 도구 입력을 수정할 수 있습니다.
+- **PostToolUse**: 도구 실행 후에 실행. 경고나 컨텍스트를 추가할 수 있습니다.
+- **UserPromptSubmit**: 사용자가 프롬프트를 제출할 때 실행. 차단하거나 메시지를 주입할 수 있습니다.
+- **Stop**: 세션이 유휴 상태가 될 때 실행. 후속 프롬프트를 주입할 수 있습니다.
+
+`settings.json` 예시:
+```json
+{
+  "hooks": {
+    "PostToolUse": [
+      {
+        "matcher": "Write|Edit",
+        "hooks": [{ "type": "command", "command": "eslint --fix $FILE" }]
+      }
+    ]
+  }
+}
+```
+
+#### 설정 로더
+
+**Command Loader**: 4개 디렉토리에서 마크다운 기반 슬래시 명령어를 로드합니다:
+- `~/.claude/commands/` (사용자)
+- `./.claude/commands/` (프로젝트)
+- `~/.config/opencode/command/` (opencode 전역)
+- `./.opencode/command/` (opencode 프로젝트)
+
+**Skill Loader**: `SKILL.md`가 있는 디렉토리 기반 스킬을 로드합니다:
+- `~/.claude/skills/` (사용자)
+- `./.claude/skills/` (프로젝트)
+
+**Agent Loader**: 마크다운 파일에서 커스텀 에이전트 정의를 로드합니다:
+- `~/.claude/agents/*.md` (사용자)
+- `./.claude/agents/*.md` (프로젝트)
+
+**MCP Loader**: `.mcp.json` 파일에서 MCP 서버 설정을 로드합니다:
+- `~/.claude/.mcp.json` (사용자)
+- `./.mcp.json` (프로젝트)
+- `./.claude/.mcp.json` (로컬)
+- 환경변수 확장 지원 (`${VAR}` 문법)
+
+#### 데이터 저장소
+
+**Todo 관리**: 세션 todo가 `~/.claude/todos/`에 Claude Code 호환 형식으로 저장됩니다.
+
+**Transcript**: 세션 활동이 `~/.claude/transcripts/`에 JSONL 형식으로 기록되어 재생 및 분석이 가능합니다.
+
+> **`claude-code-*` 네이밍에 대해**: `src/features/claude-code-*/` 아래의 기능들은 Claude Code의 설정 시스템에서 마이그레이션되었습니다. 이 네이밍 규칙은 어떤 기능이 Claude Code에서 유래했는지 명확히 식별합니다.
+
 ### 기타 편의 기능
 
 - **Terminal Title**: 세션 상태에 따라 터미널 타이틀을 자동 업데이트합니다 (유휴 ○, 처리중 ◐, 도구 ⚡, 에러 ✖). tmux를 지원합니다.
-- **Command Loader**: 다음 디렉토리들에서 마크다운 기반의 커스텀 명령어들을 로드합니다:
-  - User scope: `~/.claude/commands/`
-  - Project scope: `./.claude/commands/`
-  - OpenCode global: `~/.config/opencode/command/`
-  - OpenCode project: `./.opencode/command/`
-- **Skill Loader**: 다음 디렉토리들에서 디렉토리 기반의 스킬들을 실행 가능한 명령어로 로드합니다:
-  - User scope: `~/.claude/skills/`
-  - Project scope: `./.claude/skills/`
+- **Session State**: 이벤트 훅과 터미널 타이틀 업데이트에 사용되는 중앙집중식 세션 추적 모듈입니다.
 
 ## 설정
 

package/README.md

@@ -15,6 +15,7 @@ English | [한국어](README.ko.md)
       - [Built-in AST-Grep Tools](#built-in-ast-grep-tools)
       - [Grep](#grep)
       - [Built-in MCPs](#built-in-mcps)
+    - [Claude Code Compatibility](#claude-code-compatibility)
     - [Other Features](#other-features)
   - [Configuration](#configuration)
   - [Author's Note](#authors-note)
@@ -221,29 +222,72 @@ Don't need these? Disable them via `oh-my-opencode.json`:
 }
 ```
 
+### Claude Code Compatibility
+
+Oh My OpenCode provides seamless Claude Code configuration compatibility. If you've been using Claude Code, your existing setup works out of the box.
+
+#### Hooks Integration
+
+Execute custom scripts via Claude Code's `settings.json` hook system. Oh My OpenCode reads and executes hooks defined in:
+
+- `~/.claude/settings.json` (user)
+- `./.claude/settings.json` (project)
+- `./.claude/settings.local.json` (local, git-ignored)
+
+Supported hook events:
+- **PreToolUse**: Runs before tool execution. Can block or modify tool input.
+- **PostToolUse**: Runs after tool execution. Can add warnings or context.
+- **UserPromptSubmit**: Runs when user submits a prompt. Can block or inject messages.
+- **Stop**: Runs when session goes idle. Can inject follow-up prompts.
+
+Example `settings.json`:
+```json
+{
+  "hooks": {
+    "PostToolUse": [
+      {
+        "matcher": "Write|Edit",
+        "hooks": [{ "type": "command", "command": "eslint --fix $FILE" }]
+      }
+    ]
+  }
+}
+```
+
+#### Configuration Loaders
+
+**Command Loader**: Loads markdown-based slash commands from 4 directories:
+- `~/.claude/commands/` (user)
+- `./.claude/commands/` (project)
+- `~/.config/opencode/command/` (opencode global)
+- `./.opencode/command/` (opencode project)
+
+**Skill Loader**: Loads directory-based skills with `SKILL.md`:
+- `~/.claude/skills/` (user)
+- `./.claude/skills/` (project)
+
+**Agent Loader**: Loads custom agent definitions from markdown files:
+- `~/.claude/agents/*.md` (user)
+- `./.claude/agents/*.md` (project)
+
+**MCP Loader**: Loads MCP server configurations from `.mcp.json` files:
+- `~/.claude/.mcp.json` (user)
+- `./.mcp.json` (project)
+- `./.claude/.mcp.json` (local)
+- Supports environment variable expansion (`${VAR}` syntax)
+
+#### Data Storage
+
+**Todo Management**: Session todos are stored in Claude Code compatible format at `~/.claude/todos/`.
+
+**Transcript**: Session activity is logged to `~/.claude/transcripts/` in JSONL format, enabling replay and analysis.
+
+> **Note on `claude-code-*` naming**: Features under `src/features/claude-code-*/` are migrated from Claude Code's configuration system. This naming convention clearly identifies which features originated from Claude Code.
+
 ### Other Features
 
 - **Terminal Title**: Auto-updates terminal title with session status (idle ○, processing ◐, tool ⚡, error ✖). Supports tmux.
-- **Command Loader** (`src/features/claude-code-command-loader/`): Loads markdown-based commands from multiple directories:
-  - User scope: `~/.claude/commands/`
-  - Project scope: `./.claude/commands/`
-  - OpenCode global: `~/.config/opencode/command/`
-  - OpenCode project: `./.opencode/command/`
-- **Skill Loader** (`src/features/claude-code-skill-loader/`): Loads directory-based skills as executable commands:
-  - User scope: `~/.claude/skills/`
-  - Project scope: `./.claude/skills/`
-- **Agent Loader** (`src/features/claude-code-agent-loader/`): Loads agent definitions from markdown files with YAML frontmatter:
-  - User scope: `~/.claude/agents/`
-  - Project scope: `./.claude/agents/`
-  - Format: `*.md` files with frontmatter (name, description, tools)
-- **Session State** (`src/features/claude-code-session-state/`): Centralized session tracking module used by event hooks and terminal title updates.
-- **MCP Loader** (`src/features/claude-code-mcp-loader/`): Loads MCP server configurations from `.mcp.json` files:
-  - User scope: `~/.claude/.mcp.json`
-  - Project scope: `./.mcp.json`
-  - Local scope: `./.claude/.mcp.json`
-  - Supports environment variable expansion (`${VAR}` syntax)
-
-> **Note on `claude-code-*` naming**: Features under `src/features/claude-code-*/` are migrated from Claude Code's configuration system. This naming convention clearly identifies which features originated from Claude Code, such as `claude-code-command-loader`, `claude-code-skill-loader`, `claude-code-agent-loader`, and `claude-code-mcp-loader`.
+- **Session State**: Centralized session tracking module used by event hooks and terminal title updates.
 
 ## Configuration
 

package/dist/features/hook-message-injector/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const OPENCODE_STORAGE: string;
+export declare const MESSAGE_STORAGE: string;
+export declare const PART_STORAGE: string;

package/dist/features/hook-message-injector/index.d.ts

@@ -0,0 +1,2 @@
+export { injectHookMessage } from "./injector";
+export type { MessageMeta, OriginalMessageContext, TextPart } from "./types";

package/dist/features/hook-message-injector/injector.d.ts

@@ -0,0 +1,2 @@
+import type { OriginalMessageContext } from "./types";
+export declare function injectHookMessage(sessionID: string, hookContent: string, originalMessage: OriginalMessageContext): boolean;

package/dist/features/hook-message-injector/types.d.ts

@@ -0,0 +1,43 @@
+export interface MessageMeta {
+    id: string;
+    sessionID: string;
+    role: "user" | "assistant";
+    time: {
+        created: number;
+        completed?: number;
+    };
+    agent?: string;
+    model?: {
+        providerID: string;
+        modelID: string;
+    };
+    path?: {
+        cwd: string;
+        root: string;
+    };
+    tools?: Record<string, boolean>;
+}
+export interface OriginalMessageContext {
+    agent?: string;
+    model?: {
+        providerID?: string;
+        modelID?: string;
+    };
+    path?: {
+        cwd?: string;
+        root?: string;
+    };
+    tools?: Record<string, boolean>;
+}
+export interface TextPart {
+    id: string;
+    type: "text";
+    text: string;
+    synthetic: boolean;
+    time: {
+        start: number;
+        end: number;
+    };
+    messageID: string;
+    sessionID: string;
+}

package/dist/hooks/claude-code-hooks/config-loader.d.ts

@@ -0,0 +1,12 @@
+import type { ClaudeHookEvent } from "./types";
+export interface DisabledHooksConfig {
+    Stop?: string[];
+    PreToolUse?: string[];
+    PostToolUse?: string[];
+    UserPromptSubmit?: string[];
+}
+export interface PluginExtendedConfig {
+    disabledHooks?: DisabledHooksConfig;
+}
+export declare function loadPluginExtendedConfig(): Promise<PluginExtendedConfig>;
+export declare function isHookCommandDisabled(eventType: ClaudeHookEvent, command: string, config: PluginExtendedConfig | null): boolean;

package/dist/hooks/claude-code-hooks/config.d.ts

@@ -0,0 +1,3 @@
+import type { ClaudeHooksConfig } from "./types";
+export declare function getClaudeSettingsPaths(customPath?: string): string[];
+export declare function loadClaudeHooksConfig(customSettingsPath?: string): Promise<ClaudeHooksConfig | null>;

package/dist/hooks/claude-code-hooks/index.d.ts

@@ -0,0 +1,42 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { PluginConfig } from "./types";
+export declare function createClaudeCodeHooksHook(ctx: PluginInput, config?: PluginConfig): {
+    "chat.message": (input: {
+        sessionID: string;
+        agent?: string;
+        model?: {
+            providerID: string;
+            modelID: string;
+        };
+        messageID?: string;
+    }, output: {
+        message: Record<string, unknown>;
+        parts: Array<{
+            type: string;
+            text?: string;
+            [key: string]: unknown;
+        }>;
+    }) => Promise<void>;
+    "tool.execute.before": (input: {
+        tool: string;
+        sessionID: string;
+        callID: string;
+    }, output: {
+        args: Record<string, unknown>;
+    }) => Promise<void>;
+    "tool.execute.after": (input: {
+        tool: string;
+        sessionID: string;
+        callID: string;
+    }, output: {
+        title: string;
+        output: string;
+        metadata: unknown;
+    }) => Promise<void>;
+    event: (input: {
+        event: {
+            type: string;
+            properties?: unknown;
+        };
+    }) => Promise<void>;
+};

package/dist/hooks/claude-code-hooks/plugin-config.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Plugin configuration for Claude Code hooks execution
+ * Contains settings for hook command execution (zsh, etc.)
+ */
+export declare const DEFAULT_CONFIG: {
+    forceZsh: boolean;
+    zshPath: string;
+};

package/dist/hooks/claude-code-hooks/post-tool-use.d.ts

@@ -0,0 +1,40 @@
+import type { ClaudeHooksConfig } from "./types";
+import { 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;
+    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 declare function executePostToolUseHooks(ctx: PostToolUseContext, config: ClaudeHooksConfig | null, extendedConfig?: PluginExtendedConfig | null): Promise<PostToolUseResult>;

package/dist/hooks/claude-code-hooks/pre-tool-use.d.ts

@@ -0,0 +1,25 @@
+import type { PermissionDecision, ClaudeHooksConfig } from "./types";
+import { 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;
+    continue?: boolean;
+    stopReason?: string;
+    suppressOutput?: boolean;
+    systemMessage?: string;
+}
+export declare function executePreToolUseHooks(ctx: PreToolUseContext, config: ClaudeHooksConfig | null, extendedConfig?: PluginExtendedConfig | null): Promise<PreToolUseResult>;

package/dist/hooks/claude-code-hooks/stop.d.ts

@@ -0,0 +1,20 @@
+import type { ClaudeHooksConfig } from "./types";
+import { type PluginExtendedConfig } from "./config-loader";
+export declare function setStopHookActive(sessionId: string, active: boolean): void;
+export declare function getStopHookActive(sessionId: string): boolean;
+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 declare function executeStopHooks(ctx: StopContext, config: ClaudeHooksConfig | null, extendedConfig?: PluginExtendedConfig | null): Promise<StopResult>;

package/dist/hooks/claude-code-hooks/todo.d.ts

@@ -0,0 +1,12 @@
+import type { TodoFile } from "./types";
+export declare function getTodoPath(sessionId: string): string;
+export interface OpenCodeTodo {
+    content: string;
+    status: string;
+    priority: string;
+    id: string;
+}
+export declare function loadTodoFile(sessionId: string): TodoFile | null;
+export declare function saveTodoFile(sessionId: string, file: TodoFile): void;
+export declare function saveOpenCodeTodos(sessionId: string, todos: OpenCodeTodo[]): void;
+export declare function deleteTodoFile(sessionId: string): void;

package/dist/hooks/claude-code-hooks/tool-input-cache.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Caches tool_input from PreToolUse for PostToolUse
+ */
+export declare function cacheToolInput(sessionId: string, toolName: string, invocationId: string, toolInput: Record<string, unknown>): void;
+export declare function getToolInput(sessionId: string, toolName: string, invocationId: string): Record<string, unknown> | null;

package/dist/hooks/claude-code-hooks/transcript.d.ts

@@ -0,0 +1,38 @@
+import type { TranscriptEntry } from "./types";
+export declare function getTranscriptPath(sessionId: string): string;
+export declare function appendTranscriptEntry(sessionId: string, entry: TranscriptEntry): void;
+export declare function recordToolUse(sessionId: string, toolName: string, toolInput: Record<string, unknown>): void;
+export declare function recordToolResult(sessionId: string, toolName: string, toolInput: Record<string, unknown>, toolOutput: Record<string, unknown>): void;
+export declare function recordUserMessage(sessionId: string, content: string): void;
+export declare function recordAssistantMessage(sessionId: string, content: string): void;
+/**
+ * Build Claude Code compatible transcript from session messages
+ *
+ * PORT FROM DISABLED: This calls client.session.messages() API to fetch
+ * the full session history and builds a JSONL file in Claude Code format.
+ *
+ * @param client OpenCode client instance
+ * @param sessionId Session ID
+ * @param directory Working directory
+ * @param currentToolName Current tool being executed (added as last entry)
+ * @param currentToolInput Current tool input
+ * @returns Temp file path (caller must call deleteTempTranscript!)
+ */
+export declare function buildTranscriptFromSession(client: {
+    session: {
+        messages: (opts: {
+            path: {
+                id: string;
+            };
+            query?: {
+                directory: string;
+            };
+        }) => Promise<unknown>;
+    };
+}, sessionId: string, directory: string, currentToolName: string, currentToolInput: Record<string, unknown>): Promise<string | null>;
+/**
+ * Delete temp transcript file (call in finally block)
+ *
+ * PORT FROM DISABLED: Cleanup mechanism to avoid disk accumulation
+ */
+export declare function deleteTempTranscript(path: string | null): void;

package/dist/hooks/claude-code-hooks/types.d.ts

@@ -0,0 +1,166 @@
+/**
+ * Claude Code Hooks Type Definitions
+ * Maps Claude Code hook concepts to OpenCode plugin events
+ */
+export type ClaudeHookEvent = "PreToolUse" | "PostToolUse" | "UserPromptSubmit" | "Stop";
+export interface HookMatcher {
+    matcher: string;
+    hooks: HookCommand[];
+}
+export interface HookCommand {
+    type: "command";
+    command: string;
+}
+export interface ClaudeHooksConfig {
+    PreToolUse?: HookMatcher[];
+    PostToolUse?: HookMatcher[];
+    UserPromptSubmit?: HookMatcher[];
+    Stop?: HookMatcher[];
+}
+export interface PreToolUseInput {
+    session_id: string;
+    transcript_path?: string;
+    cwd: string;
+    permission_mode?: PermissionMode;
+    hook_event_name: "PreToolUse";
+    tool_name: string;
+    tool_input: Record<string, unknown>;
+    tool_use_id?: string;
+    hook_source?: HookSource;
+}
+export interface PostToolUseInput {
+    session_id: string;
+    transcript_path?: string;
+    cwd: string;
+    permission_mode?: PermissionMode;
+    hook_event_name: "PostToolUse";
+    tool_name: string;
+    tool_input: Record<string, unknown>;
+    tool_response: {
+        title?: string;
+        output?: string;
+        [key: string]: unknown;
+    };
+    tool_use_id?: string;
+    hook_source?: HookSource;
+}
+export interface UserPromptSubmitInput {
+    session_id: string;
+    cwd: string;
+    permission_mode?: PermissionMode;
+    hook_event_name: "UserPromptSubmit";
+    prompt: string;
+    session?: {
+        id: string;
+    };
+    hook_source?: HookSource;
+}
+export type PermissionMode = "default" | "plan" | "acceptEdits" | "bypassPermissions";
+export type HookSource = "opencode-plugin";
+export interface StopInput {
+    session_id: string;
+    transcript_path?: string;
+    cwd: string;
+    permission_mode?: PermissionMode;
+    hook_event_name: "Stop";
+    stop_hook_active: boolean;
+    todo_path?: string;
+    hook_source?: HookSource;
+}
+export type PermissionDecision = "allow" | "deny" | "ask";
+/**
+ * Common JSON fields for all hook outputs (Claude Code spec)
+ */
+export interface HookCommonOutput {
+    /** If false, Claude stops entirely */
+    continue?: boolean;
+    /** Message shown to user when continue=false */
+    stopReason?: string;
+    /** Suppress output from transcript */
+    suppressOutput?: boolean;
+    /** Warning/message displayed to user */
+    systemMessage?: string;
+}
+export interface PreToolUseOutput extends HookCommonOutput {
+    /** Deprecated: use hookSpecificOutput.permissionDecision instead */
+    decision?: "allow" | "deny" | "approve" | "block" | "ask";
+    /** Deprecated: use hookSpecificOutput.permissionDecisionReason instead */
+    reason?: string;
+    hookSpecificOutput?: {
+        hookEventName: "PreToolUse";
+        permissionDecision: PermissionDecision;
+        permissionDecisionReason?: string;
+        updatedInput?: Record<string, unknown>;
+    };
+}
+export interface PostToolUseOutput extends HookCommonOutput {
+    decision?: "block";
+    reason?: string;
+    hookSpecificOutput?: {
+        hookEventName: "PostToolUse";
+        /** Additional context to provide to Claude */
+        additionalContext?: string;
+    };
+}
+export interface HookResult {
+    exitCode: number;
+    stdout?: string;
+    stderr?: string;
+}
+export interface TranscriptEntry {
+    type: "tool_use" | "tool_result" | "user" | "assistant";
+    timestamp: string;
+    tool_name?: string;
+    tool_input?: Record<string, unknown>;
+    tool_output?: Record<string, unknown>;
+    content?: string;
+}
+export interface TodoItem {
+    id: string;
+    content: string;
+    status: "pending" | "in_progress" | "completed" | "cancelled";
+    priority?: "low" | "medium" | "high";
+    created_at: string;
+    updated_at?: string;
+}
+export interface ClaudeCodeTodoItem {
+    content: string;
+    status: string;
+    activeForm: string;
+}
+export interface TodoFile {
+    session_id: string;
+    items: TodoItem[];
+    created_at: string;
+    updated_at: string;
+}
+export interface StopOutput {
+    decision?: "block" | "continue";
+    reason?: string;
+    stop_hook_active?: boolean;
+    permission_mode?: PermissionMode;
+    inject_prompt?: string;
+}
+export type ClaudeCodeContent = {
+    type: "text";
+    text: string;
+} | {
+    type: "tool_use";
+    id: string;
+    name: string;
+    input: Record<string, unknown>;
+} | {
+    type: "tool_result";
+    tool_use_id: string;
+    content: string;
+};
+export interface ClaudeCodeMessage {
+    type: "user" | "assistant";
+    message: {
+        role: "user" | "assistant";
+        content: ClaudeCodeContent[];
+    };
+}
+export interface PluginConfig {
+    disabledHooks?: boolean | ClaudeHookEvent[];
+}

package/dist/hooks/claude-code-hooks/user-prompt-submit.d.ts

@@ -0,0 +1,22 @@
+import type { ClaudeHooksConfig } from "./types";
+import { type PluginExtendedConfig } from "./config-loader";
+export interface MessagePart {
+    type: "text" | "tool_use" | "tool_result";
+    text?: string;
+    [key: string]: unknown;
+}
+export interface UserPromptSubmitContext {
+    sessionId: string;
+    parentSessionId?: string;
+    prompt: string;
+    parts: MessagePart[];
+    cwd: string;
+    permissionMode?: "default" | "acceptEdits" | "bypassPermissions";
+}
+export interface UserPromptSubmitResult {
+    block: boolean;
+    reason?: string;
+    modifiedParts: MessagePart[];
+    messages: string[];
+}
+export declare function executeUserPromptSubmitHooks(ctx: UserPromptSubmitContext, config: ClaudeHooksConfig | null, extendedConfig?: PluginExtendedConfig | null): Promise<UserPromptSubmitResult>;

package/dist/hooks/index.d.ts

@@ -8,3 +8,4 @@ export { createDirectoryAgentsInjectorHook } from "./directory-agents-injector";
 export { createEmptyTaskResponseDetectorHook } from "./empty-task-response-detector";
 export { createAnthropicAutoCompactHook } from "./anthropic-auto-compact";
 export { createThinkModeHook } from "./think-mode";
+export { createClaudeCodeHooksHook } from "./claude-code-hooks";