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

package/dist/hooks/rules-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 createRulesInjectorHook(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/rules-injector/matcher.d.ts

@@ -0,0 +1,21 @@
+import type { RuleMetadata } from "./types";
+export interface MatchResult {
+    applies: boolean;
+    reason?: string;
+}
+/**
+ * Check if a rule should apply to the current file based on metadata
+ */
+export declare function shouldApplyRule(metadata: RuleMetadata, currentFilePath: string, projectRoot: string | null): MatchResult;
+/**
+ * Check if realPath already exists in cache (symlink deduplication)
+ */
+export declare function isDuplicateByRealPath(realPath: string, cache: Set<string>): boolean;
+/**
+ * Create SHA-256 hash of content, truncated to 16 chars
+ */
+export declare function createContentHash(content: string): string;
+/**
+ * Check if content hash already exists in cache
+ */
+export declare function isDuplicateByContentHash(hash: string, cache: Set<string>): boolean;

package/dist/hooks/rules-injector/output-path.d.ts

@@ -0,0 +1,5 @@
+export interface ToolExecuteOutputShape {
+    title: string;
+    metadata: unknown;
+}
+export declare function getRuleInjectionFilePath(output: ToolExecuteOutputShape): string | null;

package/dist/hooks/rules-injector/output-path.test.d.ts

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

package/dist/hooks/rules-injector/parser.d.ts

@@ -0,0 +1,18 @@
+import type { RuleMetadata } from "./types";
+export interface RuleFrontmatterResult {
+    metadata: RuleMetadata;
+    body: string;
+}
+/**
+ * Parse YAML frontmatter from rule file content
+ * Supports:
+ * - Single string: globs: "**\/*.py"
+ * - Inline array: globs: ["**\/*.py", "src/**\/*.ts"]
+ * - Multi-line array:
+ *   globs:
+ *     - "**\/*.py"
+ *     - "src/**\/*.ts"
+ * - Comma-separated: globs: "**\/*.py, src/**\/*.ts"
+ * - Claude Code 'paths' field (alias for globs)
+ */
+export declare function parseRuleFrontmatter(content: string): RuleFrontmatterResult;

package/dist/hooks/rules-injector/parser.test.d.ts

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

package/dist/hooks/rules-injector/storage.d.ts

@@ -0,0 +1,9 @@
+export declare function loadInjectedRules(sessionID: string): {
+    contentHashes: Set<string>;
+    realPaths: Set<string>;
+};
+export declare function saveInjectedRules(sessionID: string, data: {
+    contentHashes: Set<string>;
+    realPaths: Set<string>;
+}): void;
+export declare function clearInjectedRules(sessionID: string): void;

package/dist/hooks/rules-injector/types.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Rule file metadata (Claude Code style frontmatter)
+ * Supports both Claude Code format (globs, paths) and GitHub Copilot format (applyTo)
+ * @see https://docs.anthropic.com/en/docs/claude-code/settings#rule-files
+ * @see https://docs.github.com/en/copilot/customizing-copilot/adding-repository-custom-instructions-for-github-copilot
+ */
+export interface RuleMetadata {
+    description?: string;
+    globs?: string | string[];
+    alwaysApply?: boolean;
+}
+/**
+ * Rule information with path context and content
+ */
+export interface RuleInfo {
+    /** Absolute path to the rule file */
+    path: string;
+    /** Path relative to project root */
+    relativePath: string;
+    /** Directory distance from target file (0 = same dir) */
+    distance: number;
+    /** Rule file content (without frontmatter) */
+    content: string;
+    /** SHA-256 hash of content for deduplication */
+    contentHash: string;
+    /** Parsed frontmatter metadata */
+    metadata: RuleMetadata;
+    /** Why this rule matched (e.g., "alwaysApply", "glob: *.ts", "path match") */
+    matchReason: string;
+    /** Real path after symlink resolution (for duplicate detection) */
+    realPath: string;
+}
+/**
+ * Rule file candidate with discovery context
+ */
+export interface RuleFileCandidate {
+    path: string;
+    realPath: string;
+    isGlobal: boolean;
+    distance: number;
+    /** Single-file rules (e.g., .github/copilot-instructions.md) always apply without frontmatter */
+    isSingleFile?: boolean;
+}
+/**
+ * Session storage for injected rules tracking
+ */
+export interface InjectedRulesData {
+    sessionID: string;
+    /** Content hashes of already injected rules */
+    injectedHashes: string[];
+    /** Real paths of already injected rules (for symlink deduplication) */
+    injectedRealPaths: string[];
+    updatedAt: number;
+}

package/dist/hooks/session-notification-utils.d.ts

@@ -0,0 +1,9 @@
+type Platform = "darwin" | "linux" | "win32" | "unsupported";
+export declare const getNotifySendPath: () => Promise<string | null>;
+export declare const getOsascriptPath: () => Promise<string | null>;
+export declare const getPowershellPath: () => Promise<string | null>;
+export declare const getAfplayPath: () => Promise<string | null>;
+export declare const getPaplayPath: () => Promise<string | null>;
+export declare const getAplayPath: () => Promise<string | null>;
+export declare function startBackgroundCheck(platform: Platform): void;
+export {};

package/dist/hooks/session-notification.d.ts

@@ -0,0 +1,20 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+interface SessionNotificationConfig {
+    title?: string;
+    message?: string;
+    playSound?: boolean;
+    soundPath?: string;
+    /** Delay in ms before sending notification to confirm session is still idle (default: 1500) */
+    idleConfirmationDelay?: number;
+    /** Skip notification if there are incomplete todos (default: true) */
+    skipIfIncompleteTodos?: boolean;
+    /** Maximum number of sessions to track before cleanup (default: 100) */
+    maxTrackedSessions?: number;
+}
+export declare function createSessionNotification(ctx: PluginInput, config?: SessionNotificationConfig): ({ event }: {
+    event: {
+        type: string;
+        properties?: unknown;
+    };
+}) => Promise<void>;
+export {};

package/dist/hooks/session-notification.test.d.ts

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

package/dist/hooks/session-recovery/constants.d.ts

@@ -0,0 +1,6 @@
+export declare const OPENCODE_STORAGE: string;
+export declare const MESSAGE_STORAGE: string;
+export declare const PART_STORAGE: string;
+export declare const THINKING_TYPES: Set<string>;
+export declare const META_TYPES: Set<string>;
+export declare const CONTENT_TYPES: Set<string>;

package/dist/hooks/session-recovery/index.d.ts

@@ -0,0 +1,22 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { ExperimentalConfig } from "../../config";
+export interface SessionRecoveryOptions {
+    experimental?: ExperimentalConfig;
+}
+type RecoveryErrorType = "tool_result_missing" | "thinking_block_order" | "thinking_disabled_violation" | null;
+interface MessageInfo {
+    id?: string;
+    role?: string;
+    sessionID?: string;
+    parentID?: string;
+    error?: unknown;
+}
+export declare function detectErrorType(error: unknown): RecoveryErrorType;
+export interface SessionRecoveryHook {
+    handleSessionRecovery: (info: MessageInfo) => Promise<boolean>;
+    isRecoverableError: (error: unknown) => boolean;
+    setOnAbortCallback: (callback: (sessionID: string) => void) => void;
+    setOnRecoveryCompleteCallback: (callback: (sessionID: string) => void) => void;
+}
+export declare function createSessionRecoveryHook(ctx: PluginInput, options?: SessionRecoveryOptions): SessionRecoveryHook;
+export {};

package/dist/hooks/session-recovery/index.test.d.ts

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

package/dist/hooks/session-recovery/storage.d.ts

@@ -0,0 +1,19 @@
+import type { StoredMessageMeta, StoredPart } from "./types";
+export declare function generatePartId(): string;
+export declare function getMessageDir(sessionID: string): string;
+export declare function readMessages(sessionID: string): StoredMessageMeta[];
+export declare function readParts(messageID: string): StoredPart[];
+export declare function hasContent(part: StoredPart): boolean;
+export declare function messageHasContent(messageID: string): boolean;
+export declare function injectTextPart(sessionID: string, messageID: string, text: string): boolean;
+export declare function findEmptyMessages(sessionID: string): string[];
+export declare function findEmptyMessageByIndex(sessionID: string, targetIndex: number): string | null;
+export declare function findFirstEmptyMessage(sessionID: string): string | null;
+export declare function findMessagesWithThinkingBlocks(sessionID: string): string[];
+export declare function findMessagesWithThinkingOnly(sessionID: string): string[];
+export declare function findMessagesWithOrphanThinking(sessionID: string): string[];
+export declare function prependThinkingPart(sessionID: string, messageID: string): boolean;
+export declare function stripThinkingParts(messageID: string): boolean;
+export declare function replaceEmptyTextParts(messageID: string, replacementText: string): boolean;
+export declare function findMessagesWithEmptyTextParts(sessionID: string): string[];
+export declare function findMessageByIndexNeedingThinking(sessionID: string, targetIndex: number): string | null;

package/dist/hooks/session-recovery/types.d.ts

@@ -0,0 +1,90 @@
+export type ThinkingPartType = "thinking" | "redacted_thinking" | "reasoning";
+export type MetaPartType = "step-start" | "step-finish";
+export type ContentPartType = "text" | "tool" | "tool_use" | "tool_result";
+export interface StoredMessageMeta {
+    id: string;
+    sessionID: string;
+    role: "user" | "assistant";
+    parentID?: string;
+    time?: {
+        created: number;
+        completed?: number;
+    };
+    error?: unknown;
+}
+export interface StoredTextPart {
+    id: string;
+    sessionID: string;
+    messageID: string;
+    type: "text";
+    text: string;
+    synthetic?: boolean;
+    ignored?: boolean;
+}
+export interface StoredToolPart {
+    id: string;
+    sessionID: string;
+    messageID: string;
+    type: "tool";
+    callID: string;
+    tool: string;
+    state: {
+        status: "pending" | "running" | "completed" | "error";
+        input: Record<string, unknown>;
+        output?: string;
+        error?: string;
+    };
+}
+export interface StoredReasoningPart {
+    id: string;
+    sessionID: string;
+    messageID: string;
+    type: "reasoning";
+    text: string;
+}
+export interface StoredStepPart {
+    id: string;
+    sessionID: string;
+    messageID: string;
+    type: "step-start" | "step-finish";
+}
+export type StoredPart = StoredTextPart | StoredToolPart | StoredReasoningPart | StoredStepPart | {
+    id: string;
+    sessionID: string;
+    messageID: string;
+    type: string;
+    [key: string]: unknown;
+};
+export interface MessageData {
+    info?: {
+        id?: string;
+        role?: string;
+        sessionID?: string;
+        parentID?: string;
+        error?: unknown;
+        agent?: string;
+        model?: {
+            providerID: string;
+            modelID: string;
+        };
+        system?: string;
+        tools?: Record<string, boolean>;
+    };
+    parts?: Array<{
+        type: string;
+        id?: string;
+        text?: string;
+        thinking?: string;
+        name?: string;
+        input?: Record<string, unknown>;
+        callID?: string;
+    }>;
+}
+export interface ResumeConfig {
+    sessionID: string;
+    agent?: string;
+    model?: {
+        providerID: string;
+        modelID: string;
+    };
+}

package/dist/hooks/sisyphus-junior-notepad/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const HOOK_NAME = "sisyphus-junior-notepad";
+export declare const NOTEPAD_DIRECTIVE = "\n<Work_Context>\n## Notepad Location (for recording learnings)\nNOTEPAD PATH: .sisyphus/notepads/{plan-name}/\n- learnings.md: Record patterns, conventions, successful approaches\n- issues.md: Record problems, blockers, gotchas encountered\n- decisions.md: Record architectural choices and rationales\n- problems.md: Record unresolved issues, technical debt\n\nYou SHOULD append findings to notepad files after completing work.\nIMPORTANT: Always APPEND to notepad files - never overwrite or use Edit tool.\n\n## Plan Location (READ ONLY)\nPLAN PATH: .sisyphus/plans/{plan-name}.md\n\nCRITICAL RULE: NEVER MODIFY THE PLAN FILE\n\nThe plan file (.sisyphus/plans/*.md) is SACRED and READ-ONLY.\n- You may READ the plan to understand tasks\n- You may READ checkbox items to know what to do\n- You MUST NOT edit, modify, or update the plan file\n- You MUST NOT mark checkboxes as complete in the plan\n- Only the Orchestrator manages the plan file\n\nVIOLATION = IMMEDIATE FAILURE. The Orchestrator tracks plan state.\n</Work_Context>\n";

package/dist/hooks/sisyphus-junior-notepad/index.d.ts

@@ -0,0 +1,12 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+export * from "./constants";
+export declare function createSisyphusJuniorNotepadHook(ctx: PluginInput): {
+    "tool.execute.before": (input: {
+        tool: string;
+        sessionID: string;
+        callID: string;
+    }, output: {
+        args: Record<string, unknown>;
+        message?: string;
+    }) => Promise<void>;
+};

package/dist/hooks/start-work/index.d.ts

@@ -0,0 +1,16 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+export declare const HOOK_NAME = "start-work";
+interface StartWorkHookInput {
+    sessionID: string;
+    messageID?: string;
+}
+interface StartWorkHookOutput {
+    parts: Array<{
+        type: string;
+        text?: string;
+    }>;
+}
+export declare function createStartWorkHook(ctx: PluginInput): {
+    "chat.message": (input: StartWorkHookInput, output: StartWorkHookOutput) => Promise<void>;
+};
+export {};

package/dist/hooks/start-work/index.test.d.ts

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

package/dist/hooks/stop-continuation-guard/index.d.ts

@@ -0,0 +1,16 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+export interface StopContinuationGuard {
+    event: (input: {
+        event: {
+            type: string;
+            properties?: unknown;
+        };
+    }) => Promise<void>;
+    "chat.message": (input: {
+        sessionID?: string;
+    }) => Promise<void>;
+    stop: (sessionID: string) => void;
+    isStopped: (sessionID: string) => boolean;
+    clear: (sessionID: string) => void;
+}
+export declare function createStopContinuationGuardHook(_ctx: PluginInput): StopContinuationGuard;

package/dist/hooks/stop-continuation-guard/index.test.d.ts

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

package/dist/hooks/subagent-question-blocker/index.d.ts

@@ -0,0 +1,2 @@
+import type { Hooks } from "@opencode-ai/plugin";
+export declare function createSubagentQuestionBlockerHook(): Hooks;

package/dist/hooks/subagent-question-blocker/index.test.d.ts

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

package/dist/hooks/task-resume-info/index.d.ts

@@ -0,0 +1,11 @@
+export declare function createTaskResumeInfoHook(): {
+    "tool.execute.after": (input: {
+        tool: string;
+        sessionID: string;
+        callID: string;
+    }, output: {
+        title: string;
+        output: string;
+        metadata: unknown;
+    }) => Promise<void>;
+};

package/dist/hooks/think-mode/detector.d.ts

@@ -0,0 +1,5 @@
+export declare function detectThinkKeyword(text: string): boolean;
+export declare function extractPromptText(parts: Array<{
+    type: string;
+    text?: string;
+}>): string;

package/dist/hooks/think-mode/index.d.ts

@@ -0,0 +1,14 @@
+import type { ThinkModeInput } from "./types";
+export * from "./detector";
+export * from "./switcher";
+export * from "./types";
+export declare function clearThinkModeState(sessionID: string): void;
+export declare function createThinkModeHook(): {
+    "chat.params": (output: ThinkModeInput, sessionID: string) => Promise<void>;
+    event: ({ event }: {
+        event: {
+            type: string;
+            properties?: unknown;
+        };
+    }) => Promise<void>;
+};

package/dist/hooks/think-mode/index.test.d.ts

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

package/dist/hooks/think-mode/switcher.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Think Mode Switcher
+ *
+ * This module handles "thinking mode" activation for reasoning-capable models.
+ * When a user includes "think" keywords in their prompt, models are upgraded to
+ * their high-reasoning variants with extended thinking budgets.
+ *
+ * PROVIDER ALIASING:
+ * GitHub Copilot acts as a proxy provider that routes to underlying providers
+ * (Anthropic, Google, OpenAI). We resolve the proxy to the actual provider
+ * based on model name patterns, allowing GitHub Copilot to inherit thinking
+ * configurations without duplication.
+ *
+ * NORMALIZATION:
+ * Model IDs are normalized (dots → hyphens in version numbers) to handle API
+ * inconsistencies defensively while maintaining backwards compatibility.
+ */
+export declare const THINKING_CONFIGS: {
+    readonly anthropic: {
+        readonly thinking: {
+            readonly type: "enabled";
+            readonly budgetTokens: 64000;
+        };
+        readonly maxTokens: 128000;
+    };
+    readonly "amazon-bedrock": {
+        readonly reasoningConfig: {
+            readonly type: "enabled";
+            readonly budgetTokens: 32000;
+        };
+        readonly maxTokens: 64000;
+    };
+    readonly google: {
+        readonly providerOptions: {
+            readonly google: {
+                readonly thinkingConfig: {
+                    readonly thinkingLevel: "HIGH";
+                };
+            };
+        };
+    };
+    readonly "google-vertex": {
+        readonly providerOptions: {
+            readonly "google-vertex": {
+                readonly thinkingConfig: {
+                    readonly thinkingLevel: "HIGH";
+                };
+            };
+        };
+    };
+    readonly openai: {
+        readonly reasoning_effort: "high";
+    };
+    readonly "zai-coding-plan": {
+        readonly providerOptions: {
+            readonly "zai-coding-plan": {
+                readonly extra_body: {
+                    readonly thinking: {
+                        readonly type: "enabled";
+                        readonly clear_thinking: false;
+                    };
+                };
+            };
+        };
+    };
+};
+export declare function getHighVariant(modelID: string): string | null;
+export declare function isAlreadyHighVariant(modelID: string): boolean;
+export declare function getThinkingConfig(providerID: string, modelID: string): Record<string, unknown> | null;

package/dist/hooks/think-mode/switcher.test.d.ts

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

package/dist/hooks/think-mode/types.d.ts

@@ -0,0 +1,21 @@
+export interface ThinkModeState {
+    requested: boolean;
+    modelSwitched: boolean;
+    thinkingConfigInjected: boolean;
+    providerID?: string;
+    modelID?: string;
+}
+export interface ModelRef {
+    providerID: string;
+    modelID: string;
+}
+export interface MessageWithModel {
+    model?: ModelRef;
+}
+export interface ThinkModeInput {
+    parts: Array<{
+        type: string;
+        text?: string;
+    }>;
+    message: MessageWithModel;
+}

package/dist/hooks/thinking-block-validator/index.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Proactive Thinking Block Validator Hook
+ *
+ * Prevents "Expected thinking/redacted_thinking but found tool_use" errors
+ * by validating and fixing message structure BEFORE sending to Anthropic API.
+ *
+ * This hook runs on the "experimental.chat.messages.transform" hook point,
+ * which is called before messages are converted to ModelMessage format and
+ * sent to the API.
+ *
+ * Key differences from session-recovery hook:
+ * - PROACTIVE (prevents error) vs REACTIVE (fixes after error)
+ * - Runs BEFORE API call vs AFTER API error
+ * - User never sees the error vs User sees error then recovery
+ */
+import type { Message, Part } from "@opencode-ai/sdk";
+interface MessageWithParts {
+    info: Message;
+    parts: Part[];
+}
+type MessagesTransformHook = {
+    "experimental.chat.messages.transform"?: (input: Record<string, never>, output: {
+        messages: MessageWithParts[];
+    }) => Promise<void>;
+};
+/**
+ * Validate and fix assistant messages that have tool_use but no thinking block
+ */
+export declare function createThinkingBlockValidatorHook(): MessagesTransformHook;
+export {};

package/dist/hooks/todo-continuation-enforcer.d.ts

@@ -0,0 +1,19 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { BackgroundManager } from "../features/background-agent";
+export interface TodoContinuationEnforcerOptions {
+    backgroundManager?: BackgroundManager;
+    skipAgents?: string[];
+    isContinuationStopped?: (sessionID: string) => boolean;
+}
+export interface TodoContinuationEnforcer {
+    handler: (input: {
+        event: {
+            type: string;
+            properties?: unknown;
+        };
+    }) => Promise<void>;
+    markRecovering: (sessionID: string) => void;
+    markRecoveryComplete: (sessionID: string) => void;
+    cancelAllCountdowns: () => void;
+}
+export declare function createTodoContinuationEnforcer(ctx: PluginInput, options?: TodoContinuationEnforcerOptions): TodoContinuationEnforcer;

package/dist/hooks/todo-continuation-enforcer.test.d.ts

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

package/dist/hooks/tool-output-truncator.d.ts

@@ -0,0 +1,17 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { ExperimentalConfig } from "../config/schema";
+interface ToolOutputTruncatorOptions {
+    experimental?: ExperimentalConfig;
+}
+export declare function createToolOutputTruncatorHook(ctx: PluginInput, options?: ToolOutputTruncatorOptions): {
+    "tool.execute.after": (input: {
+        tool: string;
+        sessionID: string;
+        callID: string;
+    }, output: {
+        title: string;
+        output: string;
+        metadata: unknown;
+    }) => Promise<void>;
+};
+export {};

package/dist/hooks/tool-output-truncator.test.d.ts

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

package/dist/hooks/unstable-agent-babysitter/index.d.ts

@@ -0,0 +1,50 @@
+import type { BackgroundManager } from "../../features/background-agent";
+type BabysittingConfig = {
+    timeout_ms?: number;
+};
+type BabysitterContext = {
+    directory: string;
+    client: {
+        session: {
+            messages: (args: {
+                path: {
+                    id: string;
+                };
+            }) => Promise<{
+                data?: unknown;
+            } | unknown[]>;
+            prompt: (args: {
+                path: {
+                    id: string;
+                };
+                body: {
+                    parts: Array<{
+                        type: "text";
+                        text: string;
+                    }>;
+                    agent?: string;
+                    model?: {
+                        providerID: string;
+                        modelID: string;
+                    };
+                };
+                query?: {
+                    directory?: string;
+                };
+            }) => Promise<unknown>;
+        };
+    };
+};
+type BabysitterOptions = {
+    backgroundManager: Pick<BackgroundManager, "getTasksByParentSession">;
+    config?: BabysittingConfig;
+};
+export declare function createUnstableAgentBabysitterHook(ctx: BabysitterContext, options: BabysitterOptions): {
+    event: ({ event }: {
+        event: {
+            type: string;
+            properties?: unknown;
+        };
+    }) => Promise<void>;
+};
+export {};

package/dist/hooks/unstable-agent-babysitter/index.test.d.ts

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