oh-my-claudecode-opencode 0.1.0

package/dist/hooks/remember-tag-processor.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Remember Tag Processor Hook
+ *
+ * Processes <remember> tags from Task agent output.
+ * Saves to .omc/notepad.md for compaction-resilient memory.
+ *
+ * Based on oh-my-claude-sisyphus post-tool-use hook.
+ *
+ * Tag formats:
+ * - <remember>content</remember> → Working Memory (auto-pruned after 7 days)
+ * - <remember priority>content</remember> → Priority Context (always loaded)
+ */
+import type { PluginInput } from "@opencode-ai/plugin";
+export interface RememberTagProcessorOptions {
+    /** Only process tags from Task tool output */
+    taskToolOnly?: boolean;
+    /** Tools to process (if not taskToolOnly) */
+    toolNames?: string[];
+}
+/**
+ * Create the Remember Tag Processor hook
+ */
+export declare function createRememberTagProcessor(ctx: PluginInput, options?: RememberTagProcessorOptions): {
+    /**
+     * Process tool output for <remember> tags
+     */
+    "tool.execute.after": (input: {
+        tool: string;
+        sessionID: string;
+        callID: string;
+    }, output: {
+        title: string;
+        output: string;
+        metadata: unknown;
+    }) => Promise<void>;
+};
+/**
+ * Extract and process remember tags from arbitrary content
+ */
+export declare function extractRememberTags(content: string): {
+    priority: string[];
+    working: string[];
+};
+/**
+ * Format remember tags for output
+ */
+export declare function formatRememberTag(content: string, priority?: boolean): string;

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

@@ -0,0 +1,10 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+export declare function createSessionRecoveryHook(ctx: PluginInput): {
+    setOnAbortCallback: (cb: (sessionID: string) => void) => void;
+    setOnRecoveryCompleteCallback: (cb: (sessionID: string) => void) => void;
+    isRecoverableError: (error: unknown) => boolean;
+    handleSessionRecovery: (messageInfo: {
+        sessionID?: string;
+        error?: unknown;
+    }) => Promise<boolean>;
+};

package/dist/hooks/skill-injector.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Skill Injector Hook
+ *
+ * Automatically detects context and injects skill prompts.
+ */
+import type { PluginInput } from "@opencode-ai/plugin";
+export interface SkillInjection {
+    skill: "frontend-ui-ux" | "git-master" | null;
+    prompt: string | null;
+}
+export declare function createSkillInjector(_ctx: PluginInput): {
+    /**
+     * Detect context and return appropriate skill injection
+     */
+    detectAndInject(sessionID: string, messageText: string): SkillInjection;
+};

package/dist/hooks/system-prompt-injector.d.ts

@@ -0,0 +1,24 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { SkillInjection } from "./skill-injector";
+export type ActiveMode = "ultrawork" | "ralph-loop" | "ultrawork-ralph" | null;
+interface ModeState {
+    mode: ActiveMode;
+    sessionID: string;
+    startedAt: number;
+    task?: string;
+}
+export declare function createSystemPromptInjector(_ctx: PluginInput): {
+    setMode: (sessionID: string, mode: ActiveMode, task?: string) => void;
+    getMode: (sessionID: string) => ModeState | undefined;
+    clearMode: (sessionID: string) => void;
+    getSystemPromptForMode: (mode: ActiveMode) => string | null;
+    setSkillInjection: (sessionID: string, injection: SkillInjection) => void;
+    getSkillInjection: (sessionID: string) => SkillInjection | undefined;
+    clearSkillInjection: (sessionID: string) => void;
+    "experimental.chat.system.transform": (input: {
+        sessionID: string;
+    }, output: {
+        system: string[];
+    }) => Promise<void>;
+};
+export {};

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

@@ -0,0 +1,21 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { BackgroundManager } from "../tools/background-manager";
+export interface TodoContinuationEnforcerOptions {
+    backgroundManager?: BackgroundManager;
+    /** Countdown seconds before resuming (default: 2) */
+    countdownSeconds?: number;
+    /** Skip countdown if completion percentage is above this threshold */
+    skipCountdownAbovePercent?: number;
+    /** Vary countdown based on task complexity */
+    adaptiveCountdown?: boolean;
+}
+export declare function createTodoContinuationEnforcer(ctx: PluginInput, options?: TodoContinuationEnforcerOptions): {
+    handler: ({ event }: {
+        event: {
+            type: string;
+            properties?: unknown;
+        };
+    }) => Promise<void>;
+    markRecovering: (sessionID: string) => void;
+    markRecoveryComplete: (sessionID: string) => void;
+};

package/dist/hooks/tui-status.d.ts

@@ -0,0 +1,72 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+export interface TuiStatusOptions {
+    enabled?: boolean;
+    showAgentNotifications?: boolean;
+    showModeChanges?: boolean;
+    toastDuration?: number;
+    trackMetrics?: boolean;
+}
+type ToastVariant = "info" | "success" | "warning" | "error";
+interface ToastOptions {
+    title?: string;
+    message: string;
+    variant: ToastVariant;
+    duration?: number;
+}
+interface AgentStatus {
+    name: string;
+    status: "running" | "completed" | "failed";
+    startTime: number;
+    endTime?: number;
+    task?: string;
+    callID?: string;
+}
+interface AgentMetrics {
+    totalCalls: number;
+    successCount: number;
+    failureCount: number;
+    totalDurationMs: number;
+    avgDurationMs: number;
+    minDurationMs: number;
+    maxDurationMs: number;
+    lastCallTime: number;
+}
+interface SessionMetrics {
+    sessionStartTime: number;
+    totalAgentCalls: number;
+    totalSuccesses: number;
+    totalFailures: number;
+    agentMetrics: Map<string, AgentMetrics>;
+}
+export declare function createTuiStatusHook(ctx: PluginInput, options?: TuiStatusOptions): {
+    showToast: (opts: ToastOptions) => Promise<void>;
+    notifyAgentStarted: (agentName: string, task?: string, callID?: string) => Promise<void>;
+    notifyAgentCompleted: (agentName: string, success?: boolean, callID?: string) => Promise<void>;
+    notifyModeChange: (mode: string, active: boolean) => Promise<void>;
+    notifyPhaseChange: (phase: string, current: number, total: number) => Promise<void>;
+    notifyIteration: (mode: string, current: number, max: number) => Promise<void>;
+    getActiveAgents: () => AgentStatus[];
+    getMetrics: () => {
+        session: Omit<SessionMetrics, "agentMetrics">;
+        agents: Record<string, AgentMetrics>;
+    };
+    getMetricsSummary: () => string;
+    resetMetrics: () => 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: any;
+    }) => Promise<void>;
+};
+export {};

package/dist/hooks/ultraqa-loop.d.ts

@@ -0,0 +1,38 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import { type UltraQAState } from "../state/ultraqa-state";
+export interface UltraQALoopOptions {
+    config?: {
+        enabled?: boolean;
+        maxIterations?: number;
+        buildCommand?: string;
+        testCommand?: string;
+        lintCommand?: string;
+    };
+    onCycleComplete?: (sessionId: string, state: UltraQAState) => void;
+}
+export declare function createUltraQALoopHook(ctx: PluginInput, options?: UltraQALoopOptions): {
+    startUltraQA: (sessionId: string, goal: string) => void;
+    cancelUltraQA: (sessionId: string) => void;
+    updateCycle: (sessionId: string, results: {
+        build?: "pass" | "fail";
+        lint?: "pass" | "fail";
+        test?: "pass" | "fail";
+    }) => void;
+    getState: (sessionId: string) => UltraQAState | undefined;
+    isActive: (sessionId: string) => boolean;
+    getQAPrompt: (state: UltraQAState) => string;
+    "chat.message": (input: {
+        sessionID: string;
+    }, output: {
+        parts: Array<{
+            type: string;
+            text?: string;
+        }>;
+    }) => Promise<void>;
+    event: (input: {
+        event: {
+            type: string;
+            properties?: unknown;
+        };
+    }) => Promise<void>;
+};

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import type { Plugin } from "@opencode-ai/plugin";
+declare const OmoOmcsPlugin: Plugin;
+export default OmoOmcsPlugin;