oh-my-opencode 0.2.0 → 0.3.1

package/README.ko.md

@@ -15,6 +15,7 @@
       - [내장 AST-Grep Tools](#내장-ast-grep-tools)
       - [Grep](#grep)
       - [내장 MCPs](#내장-mcps)
+    - [Claude Code 호환성](#claude-code-호환성)
     - [기타 편의 기능](#기타-편의-기능)
   - [설정](#설정)
   - [작성자의 노트](#작성자의-노트)
@@ -105,7 +106,19 @@ opencode --version  # 1.0.132 이상이어야 함
 cat ~/.config/opencode/opencode.json  # plugin 배열에 "oh-my-opencode"가 있어야 함
 ```
 
-> **참고**: 모델 인증이 필요하면, `opencode` 실행 후 `/connect` 명령어를 사용하거나, tmux를 통해 `opencode auth login`을 안내하세요.
+### 4단계: 인증정보 설정
+
+plugin 에 oh my opencode 를 추가했다면, tmux 를 사용하여 다음의 내용을 진행주세요.
+
+1. tmux 를 사용하여 셸 열기
+2. opencode auth login > Provider Anthropic > Login method Claude Pro/Max > 사용자에게 oauth 화면에서 인증하라고 안내
+3. 사용자에게 macOS 일 경우 VibeProxy, 아닐 경우 CLIProxyAPI 를 사용하여 OpenAI / Google 인증을 완료하라고 안내
+
+### ⚠️ 주의
+
+**사용자가 명시적으로 요청하지 않는 한, `oh-my-opencode.json` 설정 파일을 생성하거나 수정하지 마세요.**
+
+플러그인은 설정 파일 없이도 기본값으로 완벽하게 동작합니다. 설정 파일은 사용자가 커스터마이징을 원할 때만 필요합니다.
 
 </details>
 
@@ -224,17 +237,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**: 이벤트 훅과 터미널 타이틀 업데이트에 사용되는 중앙집중식 세션 추적 모듈입니다.
 
 ## 설정
 
@@ -270,7 +338,7 @@ Schema 자동 완성이 지원됩니다:
 
 각 에이전트에서 지원하는 옵션: `model`, `temperature`, `top_p`, `prompt`, `tools`, `disable`, `description`, `mode`, `color`, `permission`.
 
-또는 `disabled_agents`로 비활성화할 수 있습니다:
+또는 ~/.config/opencode/oh-my-opencode.json 혹은 .opencode/oh-my-opencode.json 의 `disabled_agents` 를 사용하여 비활성화할 수 있습니다:
 
 ```json
 {
@@ -282,7 +350,9 @@ Schema 자동 완성이 지원됩니다:
 
 ### MCPs
 
-내장된 MCP를 비활성화합니다:
+기본적으로 Context7, Exa MCP 를 지원합니다.
+
+이것이 마음에 들지 않는다면, ~/.config/opencode/oh-my-opencode.json 혹은 .opencode/oh-my-opencode.json 의 `disabled_mcps` 를 사용하여 비활성화할 수 있습니다:
 
 ```json
 {
@@ -290,13 +360,13 @@ Schema 자동 완성이 지원됩니다:
 }
 ```
 
-더 자세한 내용은 [OpenCode MCP Servers](https://opencode.ai/docs/mcp-servers)를 참조하세요.
-
 ### LSP
 
-Oh My OpenCode의 LSP 도구는 오직 **리팩토링(이름 변경, 코드 액션)만을 위한 것**입니다. 분석용 LSP는 OpenCode 자체에서 처리합니다.
+OpenCode 는 분석을 위해 LSP 도구를 제공합니다.
+Oh My OpenCode 에서는 LSP 의 리팩토링(이름 변경, 코드 액션) 도구를 제공합니다.
+OpenCode 에서 지원하는 모든 LSP 구성 및 커스텀 설정 (opencode.json 에 설정 된 것) 을 그대로 지원하고, Oh My OpenCode 만을 위한 추가적인 설정도 아래와 같이 설정 할 수 있습니다.
 
-`lsp` 옵션을 통해 LSP 서버를 설정합니다:
+~/.config/opencode/oh-my-opencode.json 혹은 .opencode/oh-my-opencode.json 의 `lsp` 옵션을 통해 LSP 서버를 추가로 설정 할 수 있습니다:
 
 ```json
 {

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)
@@ -27,11 +28,12 @@ Oh My OpenCode
 oMoMoMoMoMo···
 
 If you work in tech, you likely appreciated [Claude Code](https://www.claude.com/product/claude-code).
-If you are a hacker, you will fucking falling in love with [OpenCode](https://github.com/sst/opencode).
+If you are a hacker, you will fucking fall in love with [OpenCode](https://github.com/sst/opencode).
 
-You don't write code just for a paycheck? You write because you genuinely love it?
-
-To you, OpenCode will feel like the paradigm shift from Windows to Linux. Not you? It's still worth the investment. Give it 10 minutes. Your work and life will improve. I promise.
+Do you remember the first time you switched from Windows to Linux? The excitement of configuring everything just the way you wanted?
+In an era where that romance feels lost, OpenCode will be that project for you.
+If you love coding and computers, OpenCode will feel exactly like that moment you first touched Linux after years of Windows.
+Even if you don't, invest a little time. Boost your skills and productivity by multipliers.
 
 ## TL;DR
 
@@ -41,7 +43,7 @@ To you, OpenCode will feel like the paradigm shift from Windows to Linux. Not yo
     - For OpenAI models, I recommend the [OpenCode-OpenAI-Codex-Auth plugin](https://github.com/numman-ali/opencode-openai-codex-auth).
     - For Gemini and GPT, use [VibeProxy (macOS Only)](https://github.com/automazeio/vibeproxy) or [CLIProxyAPI](https://github.com/router-for-me/CLIProxyAPI).
 - **Truth be told, the rest is optional. Just install it. Once set up, no further learning is required. It simply evolves.**
-- **Paste this document into Claude Code, OpenCode, or Cursor, instruct it to install, and ask for assistance if needed. It works seamlessly.**
+- **Paste this document into Claude Code, OpenCode, or Cursor, instruct it to install, and ask for assistance if needed. It just installs.**
   - If you are an LLM Agent, install the required plugins and dependencies, then run `opencode auth login` via tmux to assist the user with configuration.
 
 ## Installation
@@ -103,7 +105,19 @@ opencode --version  # Should be >= 1.0.132
 cat ~/.config/opencode/opencode.json  # Should contain "oh-my-opencode" in plugin array
 ```
 
-> **Note**: If model authentication is needed, run `opencode` and use `/connect` command, or assist the user with `opencode auth login` via tmux.
+### Step 4: Configure Authentication
+
+Once `oh-my-opencode` is added to the plugin list, use `tmux` to proceed with the following:
+
+1. Open a shell using `tmux`.
+2. Run `opencode auth login` > Select Provider `Anthropic` > Select Login method `Claude Pro/Max` > Instruct the user to authenticate via the OAuth screen.
+3. Recommend the setup: [VibeProxy](https://github.com/automazeio/vibeproxy) for macOS users, or [CLIProxyAPI](https://github.com/router-for-me/CLIProxyAPI) for others.
+
+### ⚠️ Warning
+
+**Do NOT create or modify the `oh-my-opencode.json` configuration file unless the user explicitly requests it.**
+
+The plugin works perfectly with default settings without any configuration file. The configuration file is only needed when the user wants customization.
 
 </details>
 
@@ -114,7 +128,7 @@ OpenCode is limitlessly extensible and customizable. Zero screen flicker.
 You can mix and orchestrate models to your exact specifications.
 It is feature-rich. It is elegant. It handles the terminal without hesitation. It is high-performance.
 
-But here is the catch: the learning curve is steep. There is a lot to master.
+But here is the catch: the learning curve is steep. There is a lot to master. And your time is expensive.
 
 Inspired by [AmpCode](https://ampcode.com) and [Claude Code](https://code.claude.com/docs/en/overview), I have implemented their features here—often with superior execution.
 Because this is OpenCode.
@@ -221,29 +235,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
 
@@ -279,7 +336,7 @@ Override built-in agent settings:
 
 Each agent supports: `model`, `temperature`, `top_p`, `prompt`, `tools`, `disable`, `description`, `mode`, `color`, `permission`.
 
-Or disable agents via `disabled_agents`:
+Or you can disable them using `disabled_agents` in `~/.config/opencode/oh-my-opencode.json` or `.opencode/oh-my-opencode.json`:
 
 ```json
 {
@@ -291,7 +348,9 @@ Available agents: `oracle`, `librarian`, `explore`, `frontend-ui-ux-engineer`, `
 
 ### MCPs
 
-Disable built-in MCPs:
+By default, Context7 and Exa MCP are supported.
+
+If you don't want these, you can disable them using `disabled_mcps` in `~/.config/opencode/oh-my-opencode.json` or `.opencode/oh-my-opencode.json`:
 
 ```json
 {
@@ -299,13 +358,13 @@ Disable built-in MCPs:
 }
 ```
 
-See [OpenCode MCP Servers](https://opencode.ai/docs/mcp-servers) for more.
-
 ### LSP
 
-Oh My OpenCode's LSP tools are for **refactoring only** (rename, code actions). Analysis LSP is handled by OpenCode itself.
+OpenCode provides LSP tools for analysis.
+Oh My OpenCode provides LSP tools for refactoring (rename, code actions).
+It supports all LSP configurations and custom settings supported by OpenCode (those configured in opencode.json), and you can also configure additional settings specifically for Oh My OpenCode as shown below.
 
-Configure LSP servers via `lsp` option:
+You can configure additional LSP servers via the `lsp` option in `~/.config/opencode/oh-my-opencode.json` or `.opencode/oh-my-opencode.json`:
 
 ```json
 {
@@ -345,7 +404,7 @@ If this sounds arrogant and you have a superior solution, send a PR. You are wel
 
 As of now, I have no affiliation with any of the projects or models mentioned here. This plugin is purely based on personal experimentation and preference.
 
-I constructed 99% of this project using OpenCode. I focused on functional verification. This documentation has been personally reviewed and comprehensively rewritten, so you can rely on it with confidence.
+I constructed 99% of this project using OpenCode. I focused on functional verification, and honestly, I don't know how to write proper TypeScript. **But I personally reviewed and comprehensively rewritten this documentation, so you can rely on it with confidence.**
 ## Warnings
 
 - If you are on [1.0.132](https://github.com/sst/opencode/releases/tag/v1.0.132) or lower, OpenCode has a bug that might break config.

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;