evil-omo 3.17.4 → 3.17.6

package/dist/hooks/preemptive-compaction-types.d.ts

@@ -0,0 +1,53 @@
+export interface TokenInfo {
+    input: number;
+    output: number;
+    reasoning: number;
+    cache: {
+        read: number;
+        write: number;
+    };
+}
+export interface CachedCompactionState {
+    providerID: string;
+    modelID: string;
+    tokens: TokenInfo;
+}
+export interface PreemptiveCompactionClient {
+    session: {
+        messages: (input: {
+            path: {
+                id: string;
+            };
+            query?: {
+                directory: string;
+            };
+        }) => Promise<unknown>;
+        summarize: (input: {
+            path: {
+                id: string;
+            };
+            body: {
+                providerID: string;
+                modelID: string;
+                auto?: boolean;
+            };
+            query: {
+                directory: string;
+            };
+        }) => Promise<unknown>;
+    };
+    tui: {
+        showToast: (input: {
+            body: {
+                title: string;
+                message: string;
+                variant: "warning";
+                duration: number;
+            };
+        }) => Promise<unknown>;
+    };
+}
+export interface PreemptiveCompactionContext {
+    client: PreemptiveCompactionClient;
+    directory: string;
+}

package/dist/hooks/preemptive-compaction.d.ts

@@ -1,18 +1,7 @@
 import type { OhMyOpenCodeConfig } from "../config";
-import { type ContextLimitModelCacheState } from "../shared/context-limit-resolver";
-type PluginInput = {
-    client: {
-        session: {
-            messages: (...args: any[]) => any;
-            summarize: (...args: any[]) => any;
-        };
-        tui: {
-            showToast: (...args: any[]) => any;
-        };
-    };
-    directory: string;
-};
-export declare function createPreemptiveCompactionHook(ctx: PluginInput, pluginConfig: OhMyOpenCodeConfig, modelCacheState?: ContextLimitModelCacheState): {
+import type { ContextLimitModelCacheState } from "../shared/context-limit-resolver";
+import type { PreemptiveCompactionContext } from "./preemptive-compaction-types";
+export declare function createPreemptiveCompactionHook(ctx: PreemptiveCompactionContext, pluginConfig: OhMyOpenCodeConfig, modelCacheState?: ContextLimitModelCacheState): {
     "tool.execute.after": (input: {
         tool: string;
         sessionID: string;
@@ -29,4 +18,3 @@ export declare function createPreemptiveCompactionHook(ctx: PluginInput, pluginC
         };
     }) => Promise<void>;
 };
-export {};

package/dist/hooks/ralph-loop/ralph-loop-event-handler.d.ts

@@ -1,10 +1,5 @@
 import type { PluginInput } from "@opencode-ai/plugin";
 import type { RalphLoopOptions, RalphLoopState } from "./types";
-type SessionRecovery = {
-    isRecovering: (sessionID: string) => boolean;
-    markRecovering: (sessionID: string) => void;
-    clear: (sessionID: string) => void;
-};
 type LoopStateController = {
     getState: () => RalphLoopState | null;
     clear: () => boolean;
@@ -19,7 +14,7 @@ type RalphLoopEventHandlerOptions = {
     apiTimeoutMs: number;
     getTranscriptPath: (sessionID: string) => string | undefined;
     checkSessionExists?: RalphLoopOptions["checkSessionExists"];
-    sessionRecovery: SessionRecovery;
+    backgroundManager?: RalphLoopOptions["backgroundManager"];
     loopState: LoopStateController;
 };
 export declare function createRalphLoopEventHandler(ctx: PluginInput, options: RalphLoopEventHandlerOptions): ({ event }: {

package/dist/hooks/ralph-loop/session-event-handler.d.ts

@@ -3,10 +3,6 @@ type LoopStateController = {
     getState: () => RalphLoopState | null;
     clear: () => boolean;
 };
-type SessionRecovery = {
-    clear: (sessionID: string) => void;
-    markRecovering: (sessionID: string) => void;
-};
-export declare function handleDeletedLoopSession(props: Record<string, unknown> | undefined, loopState: LoopStateController, sessionRecovery: SessionRecovery): boolean;
-export declare function handleErroredLoopSession(props: Record<string, unknown> | undefined, loopState: LoopStateController, sessionRecovery: SessionRecovery): boolean;
+export declare function handleDeletedLoopSession(props: Record<string, unknown> | undefined, loopState: LoopStateController): boolean;
+export declare function handleErroredLoopSession(props: Record<string, unknown> | undefined, loopState: LoopStateController): boolean;
 export {};

package/dist/hooks/ralph-loop/types.d.ts

@@ -20,4 +20,9 @@ export interface RalphLoopOptions {
     getTranscriptPath?: (sessionId: string) => string;
     apiTimeout?: number;
     checkSessionExists?: (sessionId: string) => Promise<boolean>;
+    backgroundManager?: {
+        getTasksByParentSession: (sessionId: string) => Array<{
+            status: string;
+        }>;
+    };
 }

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

@@ -1,3 +1,4 @@
+import type { RuleScanCache } from "./rule-scan-cache";
 export type SessionInjectedRulesCache = {
     contentHashes: Set<string>;
     realPaths: Set<string>;
@@ -6,3 +7,7 @@ export declare function createSessionCacheStore(): {
     getSessionCache: (sessionID: string) => SessionInjectedRulesCache;
     clearSessionCache: (sessionID: string) => void;
 };
+export declare function createSessionRuleScanCacheStore(): {
+    getSessionRuleScanCache: (sessionID: string) => RuleScanCache;
+    clearSessionRuleScanCache: (sessionID: string) => void;
+};

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

@@ -4,6 +4,7 @@ import type { FindRuleFilesOptions } from "./rule-file-finder";
 import { createContentHash, isDuplicateByContentHash, isDuplicateByRealPath, shouldApplyRule } from "./matcher";
 import { saveInjectedRules } from "./storage";
 import type { SessionInjectedRulesCache } from "./cache";
+import type { RuleScanCache } from "./rule-scan-cache";
 type ToolExecuteOutput = {
     title: string;
     output: string;
@@ -19,6 +20,7 @@ export declare function createRuleInjectionProcessor(deps: {
     workspaceDirectory: string;
     truncator: DynamicTruncator;
     getSessionCache: (sessionID: string) => SessionInjectedRulesCache;
+    getSessionRuleScanCache?: (sessionID: string) => RuleScanCache;
     ruleFinderOptions?: FindRuleFilesOptions;
     readFileSync?: typeof readFileSync;
     statSync?: typeof statSync;

package/dist/hooks/rules-injector/project-root-finder.d.ts

@@ -1,3 +1,4 @@
+export declare function clearProjectRootCache(): void;
 /**
  * Find project root by walking up from startPath.
  * Checks for PROJECT_MARKERS (.git, pyproject.toml, package.json, etc.)

package/dist/hooks/rules-injector/rule-file-finder.d.ts

@@ -1,23 +1,6 @@
+import type { RuleScanCache } from "./rule-scan-cache";
 import type { RuleFileCandidate } from "./types";
 export interface FindRuleFilesOptions {
-    /**
-     * When true, skip loading rules from ~/.claude/rules/.
-     * Use when claude_code integration is disabled to prevent
-     * Claude Code-specific instructions from leaking into non-Claude agents.
-     */
     skipClaudeUserRules?: boolean;
 }
-/**
- * Find all rule files for a given context.
- * Searches from currentFile upward to projectRoot for rule directories,
- * then user-level directory (~/.claude/rules).
- *
- * IMPORTANT: This searches EVERY directory from file to project root.
- * Not just the project root itself.
- *
- * @param projectRoot - Project root path (or null if outside any project)
- * @param homeDir - User home directory
- * @param currentFile - Current file being edited (for distance calculation)
- * @returns Array of rule file candidates sorted by distance
- */
-export declare function findRuleFiles(projectRoot: string | null, homeDir: string, currentFile: string, options?: FindRuleFilesOptions): RuleFileCandidate[];
+export declare function findRuleFiles(projectRoot: string | null, homeDir: string, currentFile: string, options?: FindRuleFilesOptions, cache?: RuleScanCache): RuleFileCandidate[];

package/dist/hooks/rules-injector/rule-scan-cache.d.ts

@@ -0,0 +1,6 @@
+export type RuleScanCache = {
+    get: (key: string) => string[] | undefined;
+    set: (key: string, value: string[]) => void;
+    clear: () => void;
+};
+export declare function createRuleScanCache(): RuleScanCache;

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

@@ -0,0 +1,5 @@
+type EventProperties = Record<string, unknown> | undefined;
+export declare function getSessionID(properties: EventProperties): string | undefined;
+export declare function getEventToolName(properties: EventProperties): string | undefined;
+export declare function getQuestionText(properties: EventProperties): string;
+export {};

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

@@ -0,0 +1,7 @@
+import type { Platform } from "./session-notification-sender";
+export declare function createSessionNotificationInit(): {
+    initialize: () => {
+        platform: Platform;
+        defaultSoundPath: string;
+    };
+};

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

@@ -9,6 +9,7 @@ export interface ContinuationProgressUpdate {
 export interface SessionStateStore {
     getState: (sessionID: string) => SessionState;
     getExistingState: (sessionID: string) => SessionState | undefined;
+    startPruneInterval: () => void;
     recordActivity: (sessionID: string) => void;
     trackContinuationProgress: (sessionID: string, incompleteCount: number, todos?: Todo[], options?: ContinuationProgressOptions) => ContinuationProgressUpdate;
     resetContinuationProgress: (sessionID: string) => void;

package/dist/hooks/write-existing-file-guard/tool-execute-before-handler.d.ts

@@ -10,6 +10,6 @@ export declare function handleWriteExistingFileGuardToolExecuteBefore(params: {
     };
     readPermissionsBySession: Map<string, Set<string>>;
     sessionLastAccess: Map<string, number>;
-    canonicalSessionRoot: string;
+    getCanonicalSessionRoot: () => string;
     maxTrackedSessions: number;
 }): Promise<void>;

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import type { Plugin } from "@opencode-ai/plugin";
-declare const OhMyOpenCodePlugin: Plugin;
-export default OhMyOpenCodePlugin;
+import type { PluginModule } from "@opencode-ai/plugin";
+declare const pluginModule: PluginModule;
+export default pluginModule;
 export type { OhMyOpenCodeConfig, AgentName, AgentOverrideConfig, AgentOverrides, McpName, HookName, BuiltinCommandName, } from "./config";
 export type { ConfigLoadError } from "./shared/config-errors";