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

package/dist/features/tmux-subagent/action-executor.d.ts

@@ -0,0 +1,22 @@
+import type { TmuxConfig } from "../../config/schema";
+import type { PaneAction, WindowState } from "./types";
+export interface ActionResult {
+    success: boolean;
+    paneId?: string;
+    error?: string;
+}
+export interface ExecuteActionsResult {
+    success: boolean;
+    spawnedPaneId?: string;
+    results: Array<{
+        action: PaneAction;
+        result: ActionResult;
+    }>;
+}
+export interface ExecuteContext {
+    config: TmuxConfig;
+    serverUrl: string;
+    windowState: WindowState;
+}
+export declare function executeAction(action: PaneAction, ctx: ExecuteContext): Promise<ActionResult>;
+export declare function executeActions(actions: PaneAction[], ctx: ExecuteContext): Promise<ExecuteActionsResult>;

package/dist/features/tmux-subagent/decision-engine.d.ts

@@ -0,0 +1,38 @@
+import type { WindowState, PaneAction, SpawnDecision, CapacityConfig, TmuxPaneInfo, SplitDirection } from "./types";
+export interface SessionMapping {
+    sessionId: string;
+    paneId: string;
+    createdAt: Date;
+}
+export interface GridCapacity {
+    cols: number;
+    rows: number;
+    total: number;
+}
+export interface GridSlot {
+    row: number;
+    col: number;
+}
+export interface GridPlan {
+    cols: number;
+    rows: number;
+    slotWidth: number;
+    slotHeight: number;
+}
+export interface SpawnTarget {
+    targetPaneId: string;
+    splitDirection: SplitDirection;
+}
+export declare function getColumnCount(paneCount: number): number;
+export declare function getColumnWidth(agentAreaWidth: number, paneCount: number): number;
+export declare function isSplittableAtCount(agentAreaWidth: number, paneCount: number): boolean;
+export declare function findMinimalEvictions(agentAreaWidth: number, currentCount: number): number | null;
+export declare function canSplitPane(pane: TmuxPaneInfo, direction: SplitDirection): boolean;
+export declare function canSplitPaneAnyDirection(pane: TmuxPaneInfo): boolean;
+export declare function getBestSplitDirection(pane: TmuxPaneInfo): SplitDirection | null;
+export declare function calculateCapacity(windowWidth: number, windowHeight: number): GridCapacity;
+export declare function computeGridPlan(windowWidth: number, windowHeight: number, paneCount: number): GridPlan;
+export declare function mapPaneToSlot(pane: TmuxPaneInfo, plan: GridPlan, mainPaneWidth: number): GridSlot;
+export declare function findSpawnTarget(state: WindowState): SpawnTarget | null;
+export declare function decideSpawnActions(state: WindowState, sessionId: string, description: string, _config: CapacityConfig, sessionMappings: SessionMapping[]): SpawnDecision;
+export declare function decideCloseAction(state: WindowState, sessionId: string, sessionMappings: SessionMapping[]): PaneAction | null;

package/dist/features/tmux-subagent/decision-engine.test.d.ts

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

package/dist/features/tmux-subagent/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./manager";
+export * from "./types";
+export * from "./pane-state-querier";
+export * from "./decision-engine";
+export * from "./action-executor";

package/dist/features/tmux-subagent/manager.d.ts

@@ -0,0 +1,59 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { TmuxConfig } from "../../config/schema";
+interface SessionCreatedEvent {
+    type: string;
+    properties?: {
+        info?: {
+            id?: string;
+            parentID?: string;
+            title?: string;
+        };
+    };
+}
+export interface TmuxUtilDeps {
+    isInsideTmux: () => boolean;
+    getCurrentPaneId: () => string | undefined;
+}
+/**
+ * State-first Tmux Session Manager
+ *
+ * Architecture:
+ * 1. QUERY: Get actual tmux pane state (source of truth)
+ * 2. DECIDE: Pure function determines actions based on state
+ * 3. EXECUTE: Execute actions with verification
+ * 4. UPDATE: Update internal cache only after tmux confirms success
+ *
+ * The internal `sessions` Map is just a cache for sessionId<->paneId mapping.
+ * The REAL source of truth is always queried from tmux.
+ */
+export declare class TmuxSessionManager {
+    private client;
+    private tmuxConfig;
+    private serverUrl;
+    private sourcePaneId;
+    private sessions;
+    private pendingSessions;
+    private pollInterval?;
+    private deps;
+    constructor(ctx: PluginInput, tmuxConfig: TmuxConfig, deps?: TmuxUtilDeps);
+    private isEnabled;
+    private getCapacityConfig;
+    private getSessionMappings;
+    private waitForSessionReady;
+    onSessionCreated(event: SessionCreatedEvent): Promise<void>;
+    onSessionDeleted(event: {
+        sessionID: string;
+    }): Promise<void>;
+    private startPolling;
+    private stopPolling;
+    private pollSessions;
+    private closeSessionById;
+    createEventHandler(): (input: {
+        event: {
+            type: string;
+            properties?: unknown;
+        };
+    }) => Promise<void>;
+    cleanup(): Promise<void>;
+}
+export {};

package/dist/features/tmux-subagent/manager.test.d.ts

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

package/dist/features/tmux-subagent/pane-state-querier.d.ts

@@ -0,0 +1,2 @@
+import type { WindowState } from "./types";
+export declare function queryWindowState(sourcePaneId: string): Promise<WindowState | null>;

package/dist/features/tmux-subagent/types.d.ts

@@ -0,0 +1,53 @@
+export interface TrackedSession {
+    sessionId: string;
+    paneId: string;
+    description: string;
+    createdAt: Date;
+    lastSeenAt: Date;
+    lastMessageCount?: number;
+    stableIdlePolls?: number;
+}
+export declare const MIN_PANE_WIDTH = 52;
+export declare const MIN_PANE_HEIGHT = 11;
+export interface TmuxPaneInfo {
+    paneId: string;
+    width: number;
+    height: number;
+    left: number;
+    top: number;
+    title: string;
+    isActive: boolean;
+}
+export interface WindowState {
+    windowWidth: number;
+    windowHeight: number;
+    mainPane: TmuxPaneInfo | null;
+    agentPanes: TmuxPaneInfo[];
+}
+export type SplitDirection = "-h" | "-v";
+export type PaneAction = {
+    type: "close";
+    paneId: string;
+    sessionId: string;
+} | {
+    type: "spawn";
+    sessionId: string;
+    description: string;
+    targetPaneId: string;
+    splitDirection: SplitDirection;
+} | {
+    type: "replace";
+    paneId: string;
+    oldSessionId: string;
+    newSessionId: string;
+    description: string;
+};
+export interface SpawnDecision {
+    canSpawn: boolean;
+    actions: PaneAction[];
+    reason?: string;
+}
+export interface CapacityConfig {
+    mainPaneMinWidth: number;
+    agentPaneWidth: number;
+}

package/dist/hooks/agent-usage-reminder/constants.d.ts

@@ -0,0 +1,5 @@
+export declare const OPENCODE_STORAGE: string;
+export declare const AGENT_USAGE_REMINDER_STORAGE: string;
+export declare const TARGET_TOOLS: Set<string>;
+export declare const AGENT_TOOLS: Set<string>;
+export declare const REMINDER_MESSAGE = "\n[Agent Usage Reminder]\n\nYou called a search/fetch tool directly without leveraging specialized agents.\n\nRECOMMENDED: Use delegate_task with explore/librarian agents for better results:\n\n```\n// Parallel exploration - fire multiple agents simultaneously\ndelegate_task(agent=\"explore\", prompt=\"Find all files matching pattern X\")\ndelegate_task(agent=\"explore\", prompt=\"Search for implementation of Y\") \ndelegate_task(agent=\"librarian\", prompt=\"Lookup documentation for Z\")\n\n// Then continue your work while they run in background\n// System will notify you when each completes\n```\n\nWHY:\n- Agents can perform deeper, more thorough searches\n- Background tasks run in parallel, saving time\n- Specialized agents have domain expertise\n- Reduces context window usage in main session\n\nALWAYS prefer: Multiple parallel delegate_task calls > Direct tool calls\n";

package/dist/hooks/agent-usage-reminder/index.d.ts

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

package/dist/hooks/agent-usage-reminder/storage.d.ts

@@ -0,0 +1,4 @@
+import type { AgentUsageState } from "./types";
+export declare function loadAgentUsageState(sessionID: string): AgentUsageState | null;
+export declare function saveAgentUsageState(state: AgentUsageState): void;
+export declare function clearAgentUsageState(sessionID: string): void;

package/dist/hooks/agent-usage-reminder/types.d.ts

@@ -0,0 +1,6 @@
+export interface AgentUsageState {
+    sessionID: string;
+    agentUsed: boolean;
+    reminderCount: number;
+    updatedAt: number;
+}

package/dist/hooks/anthropic-context-window-limit-recovery/executor.d.ts

@@ -0,0 +1,4 @@
+import type { AutoCompactState } from "./types";
+import type { ExperimentalConfig } from "../../config";
+export declare function getLastAssistant(sessionID: string, client: any, directory: string): Promise<Record<string, unknown> | null>;
+export declare function executeCompact(sessionID: string, msg: Record<string, unknown>, autoCompactState: AutoCompactState, client: any, directory: string, experimental?: ExperimentalConfig): Promise<void>;

package/dist/hooks/anthropic-context-window-limit-recovery/executor.test.d.ts

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

package/dist/hooks/anthropic-context-window-limit-recovery/index.d.ts

@@ -0,0 +1,16 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { ExperimentalConfig } from "../../config";
+export interface AnthropicContextWindowLimitRecoveryOptions {
+    experimental?: ExperimentalConfig;
+}
+export declare function createAnthropicContextWindowLimitRecoveryHook(ctx: PluginInput, options?: AnthropicContextWindowLimitRecoveryOptions): {
+    event: ({ event }: {
+        event: {
+            type: string;
+            properties?: unknown;
+        };
+    }) => Promise<void>;
+};
+export type { AutoCompactState, ParsedTokenLimitError, TruncateState } from "./types";
+export { parseAnthropicTokenLimitError } from "./parser";
+export { executeCompact, getLastAssistant } from "./executor";

package/dist/hooks/anthropic-context-window-limit-recovery/parser.d.ts

@@ -0,0 +1,2 @@
+import type { ParsedTokenLimitError } from "./types";
+export declare function parseAnthropicTokenLimitError(err: unknown): ParsedTokenLimitError | null;

package/dist/hooks/anthropic-context-window-limit-recovery/pruning-deduplication.d.ts

@@ -0,0 +1,7 @@
+import type { PruningState } from "./pruning-types";
+export interface DeduplicationConfig {
+    enabled: boolean;
+    protectedTools?: string[];
+}
+export declare function createToolSignature(toolName: string, input: unknown): string;
+export declare function executeDeduplication(sessionID: string, state: PruningState, config: DeduplicationConfig, protectedTools: Set<string>): number;

package/dist/hooks/anthropic-context-window-limit-recovery/pruning-deduplication.test.d.ts

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

package/dist/hooks/anthropic-context-window-limit-recovery/pruning-types.d.ts

@@ -0,0 +1,36 @@
+export interface ToolCallSignature {
+    toolName: string;
+    signature: string;
+    callID: string;
+    turn: number;
+}
+export interface FileOperation {
+    callID: string;
+    tool: string;
+    filePath: string;
+    turn: number;
+}
+export interface ErroredToolCall {
+    callID: string;
+    toolName: string;
+    turn: number;
+    errorAge: number;
+}
+export interface PruningResult {
+    itemsPruned: number;
+    totalTokensSaved: number;
+    strategies: {
+        deduplication: number;
+        supersedeWrites: number;
+        purgeErrors: number;
+    };
+}
+export interface PruningState {
+    toolIdsToPrune: Set<string>;
+    currentTurn: number;
+    fileOperations: Map<string, FileOperation[]>;
+    toolSignatures: Map<string, ToolCallSignature[]>;
+    erroredTools: Map<string, ErroredToolCall>;
+}
+export declare const CHARS_PER_TOKEN = 4;
+export declare function estimateTokens(text: string): number;

package/dist/hooks/anthropic-context-window-limit-recovery/storage.d.ts

@@ -0,0 +1,28 @@
+export interface ToolResultInfo {
+    partPath: string;
+    partId: string;
+    messageID: string;
+    toolName: string;
+    outputSize: number;
+}
+export declare function findToolResultsBySize(sessionID: string): ToolResultInfo[];
+export declare function findLargestToolResult(sessionID: string): ToolResultInfo | null;
+export declare function truncateToolResult(partPath: string): {
+    success: boolean;
+    toolName?: string;
+    originalSize?: number;
+};
+export declare function getTotalToolOutputSize(sessionID: string): number;
+export declare function countTruncatedResults(sessionID: string): number;
+export interface AggressiveTruncateResult {
+    success: boolean;
+    sufficient: boolean;
+    truncatedCount: number;
+    totalBytesRemoved: number;
+    targetBytesToRemove: number;
+    truncatedTools: Array<{
+        toolName: string;
+        originalSize: number;
+    }>;
+}
+export declare function truncateUntilTargetTokens(sessionID: string, currentTokens: number, maxTokens: number, targetRatio?: number, charsPerToken?: number): AggressiveTruncateResult;

package/dist/hooks/anthropic-context-window-limit-recovery/storage.test.d.ts

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

package/dist/hooks/anthropic-context-window-limit-recovery/types.d.ts

@@ -0,0 +1,37 @@
+export interface ParsedTokenLimitError {
+    currentTokens: number;
+    maxTokens: number;
+    requestId?: string;
+    errorType: string;
+    providerID?: string;
+    modelID?: string;
+    messageIndex?: number;
+}
+export interface RetryState {
+    attempt: number;
+    lastAttemptTime: number;
+}
+export interface TruncateState {
+    truncateAttempt: number;
+    lastTruncatedPartId?: string;
+}
+export interface AutoCompactState {
+    pendingCompact: Set<string>;
+    errorDataBySession: Map<string, ParsedTokenLimitError>;
+    retryStateBySession: Map<string, RetryState>;
+    truncateStateBySession: Map<string, TruncateState>;
+    emptyContentAttemptBySession: Map<string, number>;
+    compactionInProgress: Set<string>;
+}
+export declare const RETRY_CONFIG: {
+    readonly maxAttempts: 2;
+    readonly initialDelayMs: 2000;
+    readonly backoffFactor: 2;
+    readonly maxDelayMs: 30000;
+};
+export declare const TRUNCATE_CONFIG: {
+    readonly maxTruncateAttempts: 20;
+    readonly minOutputSizeToTruncate: 500;
+    readonly targetTokenRatio: 0.5;
+    readonly charsPerToken: 4;
+};

package/dist/hooks/atlas/index.d.ts

@@ -0,0 +1,35 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { BackgroundManager } from "../../features/background-agent";
+export declare const HOOK_NAME = "atlas";
+interface ToolExecuteAfterInput {
+    tool: string;
+    sessionID?: string;
+    callID?: string;
+}
+interface ToolExecuteAfterOutput {
+    title: string;
+    output: string;
+    metadata: Record<string, unknown>;
+}
+export interface AtlasHookOptions {
+    directory: string;
+    backgroundManager?: BackgroundManager;
+}
+export declare function createAtlasHook(ctx: PluginInput, options?: AtlasHookOptions): {
+    handler: ({ event }: {
+        event: {
+            type: string;
+            properties?: unknown;
+        };
+    }) => Promise<void>;
+    "tool.execute.before": (input: {
+        tool: string;
+        sessionID?: string;
+        callID?: string;
+    }, output: {
+        args: Record<string, unknown>;
+        message?: string;
+    }) => Promise<void>;
+    "tool.execute.after": (input: ToolExecuteAfterInput, output: ToolExecuteAfterOutput) => Promise<void>;
+};
+export {};

package/dist/hooks/atlas/index.test.d.ts

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

package/dist/hooks/auto-slash-command/constants.d.ts

@@ -0,0 +1,5 @@
+export declare const HOOK_NAME: "auto-slash-command";
+export declare const AUTO_SLASH_COMMAND_TAG_OPEN = "<auto-slash-command>";
+export declare const AUTO_SLASH_COMMAND_TAG_CLOSE = "</auto-slash-command>";
+export declare const SLASH_COMMAND_PATTERN: RegExp;
+export declare const EXCLUDED_COMMANDS: Set<string>;

package/dist/hooks/auto-slash-command/detector.d.ts

@@ -0,0 +1,9 @@
+import type { ParsedSlashCommand } from "./types";
+export declare function removeCodeBlocks(text: string): string;
+export declare function parseSlashCommand(text: string): ParsedSlashCommand | null;
+export declare function isExcludedCommand(command: string): boolean;
+export declare function detectSlashCommand(text: string): ParsedSlashCommand | null;
+export declare function extractPromptText(parts: Array<{
+    type: string;
+    text?: string;
+}>): string;

package/dist/hooks/auto-slash-command/detector.test.d.ts

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

package/dist/hooks/auto-slash-command/executor.d.ts

@@ -0,0 +1,11 @@
+import { type LoadedSkill } from "../../features/opencode-skill-loader";
+import type { ParsedSlashCommand } from "./types";
+export interface ExecutorOptions {
+    skills?: LoadedSkill[];
+}
+export interface ExecuteResult {
+    success: boolean;
+    replacementText?: string;
+    error?: string;
+}
+export declare function executeSlashCommand(parsed: ParsedSlashCommand, options?: ExecutorOptions): Promise<ExecuteResult>;

package/dist/hooks/auto-slash-command/index.d.ts

@@ -0,0 +1,12 @@
+import type { AutoSlashCommandHookInput, AutoSlashCommandHookOutput } from "./types";
+import type { LoadedSkill } from "../../features/opencode-skill-loader";
+export * from "./detector";
+export * from "./executor";
+export * from "./constants";
+export * from "./types";
+export interface AutoSlashCommandHookOptions {
+    skills?: LoadedSkill[];
+}
+export declare function createAutoSlashCommandHook(options?: AutoSlashCommandHookOptions): {
+    "chat.message": (input: AutoSlashCommandHookInput, output: AutoSlashCommandHookOutput) => Promise<void>;
+};

package/dist/hooks/auto-slash-command/index.test.d.ts

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

package/dist/hooks/auto-slash-command/types.d.ts

@@ -0,0 +1,27 @@
+export interface AutoSlashCommandHookInput {
+    sessionID: string;
+    agent?: string;
+    model?: {
+        providerID: string;
+        modelID: string;
+    };
+    messageID?: string;
+}
+export interface AutoSlashCommandHookOutput {
+    message: Record<string, unknown>;
+    parts: Array<{
+        type: string;
+        text?: string;
+        [key: string]: unknown;
+    }>;
+}
+export interface ParsedSlashCommand {
+    command: string;
+    args: string;
+    raw: string;
+}
+export interface AutoSlashCommandResult {
+    detected: boolean;
+    parsedCommand?: ParsedSlashCommand;
+    injectedMessage?: string;
+}

package/dist/hooks/auto-update-checker/cache.d.ts

@@ -0,0 +1,3 @@
+export declare function invalidatePackage(packageName?: string): boolean;
+/** @deprecated Use invalidatePackage instead - this nukes ALL plugins */
+export declare function invalidateCache(): boolean;

package/dist/hooks/auto-update-checker/checker.d.ts

@@ -0,0 +1,20 @@
+import type { UpdateCheckResult } from "./types";
+export declare function isLocalDevMode(directory: string): boolean;
+export declare function getLocalDevPath(directory: string): string | null;
+export declare function getLocalDevVersion(directory: string): string | null;
+export interface PluginEntryInfo {
+    entry: string;
+    isPinned: boolean;
+    pinnedVersion: string | null;
+    configPath: string;
+}
+export declare function findPluginEntry(directory: string): PluginEntryInfo | null;
+export declare function getCachedVersion(): string | null;
+/**
+ * Updates a pinned version entry in the config file.
+ * Only replaces within the "plugin" array to avoid unintended edits.
+ * Preserves JSONC comments and formatting via string replacement.
+ */
+export declare function updatePinnedVersion(configPath: string, oldEntry: string, newVersion: string): boolean;
+export declare function getLatestVersion(channel?: string): Promise<string | null>;
+export declare function checkForUpdate(directory: string): Promise<UpdateCheckResult>;

package/dist/hooks/auto-update-checker/checker.test.d.ts

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

package/dist/hooks/auto-update-checker/constants.d.ts

@@ -0,0 +1,10 @@
+export declare const PACKAGE_NAME = "oh-my-parallel-agent-opencode";
+export declare const NPM_REGISTRY_URL = "https://registry.npmjs.org/-/package/oh-my-parallel-agent-opencode/dist-tags";
+export declare const NPM_FETCH_TIMEOUT = 5000;
+export declare const CACHE_DIR: string;
+export declare const VERSION_FILE: string;
+export declare const INSTALLED_PACKAGE_JSON: string;
+export declare function getWindowsAppdataDir(): string | null;
+export declare const USER_CONFIG_DIR: string;
+export declare const USER_OPENCODE_CONFIG: string;
+export declare const USER_OPENCODE_CONFIG_JSONC: string;

package/dist/hooks/auto-update-checker/index.d.ts

@@ -0,0 +1,17 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { AutoUpdateCheckerOptions } from "./types";
+export declare function isPrereleaseVersion(version: string): boolean;
+export declare function isDistTag(version: string): boolean;
+export declare function isPrereleaseOrDistTag(pinnedVersion: string | null): boolean;
+export declare function extractChannel(version: string | null): string;
+export declare function createAutoUpdateCheckerHook(ctx: PluginInput, options?: AutoUpdateCheckerOptions): {
+    event: ({ event }: {
+        event: {
+            type: string;
+            properties?: unknown;
+        };
+    }) => void;
+};
+export type { UpdateCheckResult, AutoUpdateCheckerOptions } from "./types";
+export { checkForUpdate } from "./checker";
+export { invalidatePackage, invalidateCache } from "./cache";

package/dist/hooks/auto-update-checker/index.test.d.ts

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

package/dist/hooks/auto-update-checker/types.d.ts

@@ -0,0 +1,25 @@
+export interface NpmDistTags {
+    latest: string;
+    [key: string]: string;
+}
+export interface OpencodeConfig {
+    plugin?: string[];
+    [key: string]: unknown;
+}
+export interface PackageJson {
+    version: string;
+    name?: string;
+    [key: string]: unknown;
+}
+export interface UpdateCheckResult {
+    needsUpdate: boolean;
+    currentVersion: string | null;
+    latestVersion: string | null;
+    isLocalDev: boolean;
+    isPinned: boolean;
+}
+export interface AutoUpdateCheckerOptions {
+    showStartupToast?: boolean;
+    isSisyphusEnabled?: boolean;
+    autoUpdate?: boolean;
+}

package/dist/hooks/background-notification/index.d.ts

@@ -0,0 +1,18 @@
+import type { BackgroundManager } from "../../features/background-agent";
+interface Event {
+    type: string;
+    properties?: Record<string, unknown>;
+}
+interface EventInput {
+    event: Event;
+}
+/**
+ * Background notification hook - handles event routing to BackgroundManager.
+ *
+ * Notifications are now delivered directly via session.prompt({ noReply })
+ * from the manager, so this hook only needs to handle event routing.
+ */
+export declare function createBackgroundNotificationHook(manager: BackgroundManager): {
+    event: ({ event }: EventInput) => Promise<void>;
+};
+export type { BackgroundNotificationHookConfig } from "./types";

package/dist/hooks/background-notification/types.d.ts

@@ -0,0 +1,4 @@
+import type { BackgroundTask } from "../../features/background-agent";
+export interface BackgroundNotificationHookConfig {
+    formatNotification?: (tasks: BackgroundTask[]) => string;
+}

package/dist/hooks/category-skill-reminder/index.d.ts

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

package/dist/hooks/category-skill-reminder/index.test.d.ts

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