oh-my-parallel-agent-opencode 0.1.0 → 0.2.1

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

@@ -0,0 +1,13 @@
+import type { ClaudeHookEvent } from "./types";
+export interface DisabledHooksConfig {
+    Stop?: string[];
+    PreToolUse?: string[];
+    PostToolUse?: string[];
+    UserPromptSubmit?: string[];
+    PreCompact?: 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,48 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { PluginConfig } from "./types";
+import type { ContextCollector } from "../../features/context-injector";
+export declare function createClaudeCodeHooksHook(ctx: PluginInput, config?: PluginConfig, contextCollector?: ContextCollector): {
+    "experimental.session.compacting": (input: {
+        sessionID: string;
+    }, output: {
+        context: string[];
+    }) => Promise<void>;
+    "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-compact.d.ts

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

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,34 @@
+import type { TranscriptEntry } from "./types";
+export declare function getTranscriptPath(sessionId: string): string;
+export declare function appendTranscriptEntry(sessionId: string, entry: TranscriptEntry): 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,183 @@
+/**
+ * Claude Code Hooks Type Definitions
+ * Maps Claude Code hook concepts to OpenCode plugin events
+ */
+export type ClaudeHookEvent = "PreToolUse" | "PostToolUse" | "UserPromptSubmit" | "Stop" | "PreCompact";
+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[];
+    PreCompact?: 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 interface PreCompactInput {
+    session_id: string;
+    cwd: string;
+    hook_event_name: "PreCompact";
+    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 interface PreCompactOutput extends HookCommonOutput {
+    /** Additional context to inject into compaction prompt */
+    context?: string[];
+    hookSpecificOutput?: {
+        hookEventName: "PreCompact";
+        /** Additional context strings to inject */
+        additionalContext?: 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[];
+    keywordDetectorDisabled?: boolean;
+}

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/comment-checker/cli.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Asynchronously get comment-checker binary path.
+ * Will trigger lazy download if binary not found.
+ */
+export declare function getCommentCheckerPath(): Promise<string | null>;
+/**
+ * Synchronously get comment-checker path (no download).
+ * Returns cached path or searches known locations.
+ */
+export declare function getCommentCheckerPathSync(): string | null;
+/**
+ * Start background initialization.
+ * Call this early to trigger download while other init happens.
+ */
+export declare function startBackgroundInit(): void;
+export interface HookInput {
+    session_id: string;
+    tool_name: string;
+    transcript_path: string;
+    cwd: string;
+    hook_event_name: string;
+    tool_input: {
+        file_path?: string;
+        content?: string;
+        old_string?: string;
+        new_string?: string;
+        edits?: Array<{
+            old_string: string;
+            new_string: string;
+        }>;
+    };
+    tool_response?: unknown;
+}
+export interface CheckResult {
+    hasComments: boolean;
+    message: string;
+}
+/**
+ * Run comment-checker CLI with given input.
+ * @param input Hook input to check
+ * @param cliPath Optional explicit path to CLI binary
+ * @param customPrompt Optional custom prompt to replace default warning message
+ */
+export declare function runCommentChecker(input: HookInput, cliPath?: string, customPrompt?: string): Promise<CheckResult>;
+/**
+ * Check if CLI is available (sync check, no download).
+ */
+export declare function isCliAvailable(): boolean;
+/**
+ * Check if CLI will be available (async, may trigger download).
+ */
+export declare function ensureCliAvailable(): Promise<boolean>;

package/dist/hooks/comment-checker/cli.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/hooks/comment-checker/downloader.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Get the cache directory for oh-my-parallel-agent-opencode binaries.
+ * On Windows: Uses %LOCALAPPDATA% or %APPDATA% (Windows conventions)
+ * On Unix: Follows XDG Base Directory Specification
+ */
+export declare function getCacheDir(): string;
+/**
+ * Get the binary name based on platform.
+ */
+export declare function getBinaryName(): string;
+/**
+ * Get the cached binary path if it exists.
+ */
+export declare function getCachedBinaryPath(): string | null;
+/**
+ * Download the comment-checker binary from GitHub Releases.
+ * Returns the path to the downloaded binary, or null on failure.
+ */
+export declare function downloadCommentChecker(): Promise<string | null>;
+/**
+ * Ensure the comment-checker binary is available.
+ * First checks cache, then downloads if needed.
+ * Returns the binary path or null if unavailable.
+ */
+export declare function ensureCommentCheckerBinary(): Promise<string | null>;

package/dist/hooks/comment-checker/index.d.ts

@@ -0,0 +1,19 @@
+import type { CommentCheckerConfig } from "../../config/schema";
+export declare function createCommentCheckerHooks(config?: CommentCheckerConfig): {
+    "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>;
+};

package/dist/hooks/comment-checker/types.d.ts

@@ -0,0 +1,31 @@
+export type CommentType = "line" | "block" | "docstring";
+export interface CommentInfo {
+    text: string;
+    lineNumber: number;
+    filePath: string;
+    commentType: CommentType;
+    isDocstring: boolean;
+    metadata?: Record<string, string>;
+}
+export interface PendingCall {
+    filePath: string;
+    content?: string;
+    oldString?: string;
+    newString?: string;
+    edits?: Array<{
+        old_string: string;
+        new_string: string;
+    }>;
+    tool: "write" | "edit" | "multiedit";
+    sessionID: string;
+    timestamp: number;
+}
+export interface FileComments {
+    filePath: string;
+    comments: CommentInfo[];
+}
+export interface FilterResult {
+    shouldSkip: boolean;
+    reason?: string;
+}
+export type CommentFilter = (comment: CommentInfo) => FilterResult;

package/dist/hooks/compaction-context-injector/index.d.ts

@@ -0,0 +1,8 @@
+export interface SummarizeContext {
+    sessionID: string;
+    providerID: string;
+    modelID: string;
+    usageRatio: number;
+    directory: string;
+}
+export declare function createCompactionContextInjector(): (ctx: SummarizeContext) => Promise<void>;

package/dist/hooks/compaction-context-injector/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/hooks/context-window-monitor.d.ts

@@ -0,0 +1,18 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+export declare function createContextWindowMonitorHook(ctx: PluginInput): {
+    "tool.execute.after": (input: {
+        tool: string;
+        sessionID: string;
+        callID: string;
+    }, output: {
+        title: string;
+        output: string;
+        metadata: unknown;
+    }) => Promise<void>;
+    event: ({ event }: {
+        event: {
+            type: string;
+            properties?: unknown;
+        };
+    }) => Promise<void>;
+};

package/dist/hooks/delegate-task-retry/index.d.ts

@@ -0,0 +1,24 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+export interface DelegateTaskErrorPattern {
+    pattern: string;
+    errorType: string;
+    fixHint: string;
+}
+export declare const DELEGATE_TASK_ERROR_PATTERNS: DelegateTaskErrorPattern[];
+export interface DetectedError {
+    errorType: string;
+    originalOutput: string;
+}
+export declare function detectDelegateTaskError(output: string): DetectedError | null;
+export declare function buildRetryGuidance(errorInfo: DetectedError): string;
+export declare function createDelegateTaskRetryHook(_ctx: PluginInput): {
+    "tool.execute.after": (input: {
+        tool: string;
+        sessionID: string;
+        callID: string;
+    }, output: {
+        title: string;
+        output: string;
+        metadata: unknown;
+    }) => Promise<void>;
+};

package/dist/hooks/delegate-task-retry/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/hooks/directory-agents-injector/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const OPENCODE_STORAGE: string;
+export declare const AGENTS_INJECTOR_STORAGE: string;
+export declare const AGENTS_FILENAME = "AGENTS.md";

package/dist/hooks/directory-agents-injector/index.d.ts

@@ -0,0 +1,26 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+interface ToolExecuteInput {
+    tool: string;
+    sessionID: string;
+    callID: string;
+}
+interface ToolExecuteOutput {
+    title: string;
+    output: string;
+    metadata: unknown;
+}
+interface ToolExecuteBeforeOutput {
+    args: unknown;
+}
+interface EventInput {
+    event: {
+        type: string;
+        properties?: unknown;
+    };
+}
+export declare function createDirectoryAgentsInjectorHook(ctx: PluginInput): {
+    "tool.execute.before": (input: ToolExecuteInput, output: ToolExecuteBeforeOutput) => Promise<void>;
+    "tool.execute.after": (input: ToolExecuteInput, output: ToolExecuteOutput) => Promise<void>;
+    event: ({ event }: EventInput) => Promise<void>;
+};
+export {};

package/dist/hooks/directory-agents-injector/storage.d.ts

@@ -0,0 +1 @@
+export declare const loadInjectedPaths: (sessionID: string) => Set<string>, saveInjectedPaths: (sessionID: string, paths: Set<string>) => void, clearInjectedPaths: (sessionID: string) => void;