opencode-repos 0.3.0 → 0.3.1

package/oh-my-opencode/src/hooks/anthropic-context-window-limit-recovery/executor.ts

@@ -1,485 +0,0 @@
-import type {
-  AutoCompactState,
-  RetryState,
-  TruncateState,
-} from "./types";
-import type { ExperimentalConfig } from "../../config";
-import { RETRY_CONFIG, TRUNCATE_CONFIG } from "./types";
-
-import {
-  findLargestToolResult,
-  truncateToolResult,
-  truncateUntilTargetTokens,
-} from "./storage";
-import {
-  findEmptyMessages,
-  findEmptyMessageByIndex,
-  injectTextPart,
-  replaceEmptyTextParts,
-} from "../session-recovery/storage";
-import { log } from "../../shared/logger";
-
-const PLACEHOLDER_TEXT = "[user interrupted]";
-
-type Client = {
-  session: {
-    messages: (opts: {
-      path: { id: string };
-      query?: { directory?: string };
-    }) => Promise<unknown>;
-    summarize: (opts: {
-      path: { id: string };
-      body: { providerID: string; modelID: string };
-      query: { directory: string };
-    }) => Promise<unknown>;
-    revert: (opts: {
-      path: { id: string };
-      body: { messageID: string; partID?: string };
-      query: { directory: string };
-    }) => Promise<unknown>;
-    prompt_async: (opts: {
-      path: { id: string };
-      body: { parts: Array<{ type: string; text: string }> };
-      query: { directory: string };
-    }) => Promise<unknown>;
-  };
-  tui: {
-    showToast: (opts: {
-      body: {
-        title: string;
-        message: string;
-        variant: string;
-        duration: number;
-      };
-    }) => Promise<unknown>;
-  };
-};
-
-function getOrCreateRetryState(
-  autoCompactState: AutoCompactState,
-  sessionID: string,
-): RetryState {
-  let state = autoCompactState.retryStateBySession.get(sessionID);
-  if (!state) {
-    state = { attempt: 0, lastAttemptTime: 0 };
-    autoCompactState.retryStateBySession.set(sessionID, state);
-  }
-  return state;
-}
-
-
-
-function getOrCreateTruncateState(
-  autoCompactState: AutoCompactState,
-  sessionID: string,
-): TruncateState {
-  let state = autoCompactState.truncateStateBySession.get(sessionID);
-  if (!state) {
-    state = { truncateAttempt: 0 };
-    autoCompactState.truncateStateBySession.set(sessionID, state);
-  }
-  return state;
-}
-
-
-
-function sanitizeEmptyMessagesBeforeSummarize(sessionID: string): number {
-  const emptyMessageIds = findEmptyMessages(sessionID);
-  if (emptyMessageIds.length === 0) {
-    return 0;
-  }
-
-  let fixedCount = 0;
-  for (const messageID of emptyMessageIds) {
-    const replaced = replaceEmptyTextParts(messageID, PLACEHOLDER_TEXT);
-    if (replaced) {
-      fixedCount++;
-    } else {
-      const injected = injectTextPart(sessionID, messageID, PLACEHOLDER_TEXT);
-      if (injected) {
-        fixedCount++;
-      }
-    }
-  }
-
-  if (fixedCount > 0) {
-    log("[auto-compact] pre-summarize sanitization fixed empty messages", {
-      sessionID,
-      fixedCount,
-      totalEmpty: emptyMessageIds.length,
-    });
-  }
-
-  return fixedCount;
-}
-
-function formatBytes(bytes: number): string {
-  if (bytes < 1024) return `${bytes}B`;
-  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`;
-  return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
-}
-
-export async function getLastAssistant(
-  sessionID: string,
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  client: any,
-  directory: string,
-): Promise<Record<string, unknown> | null> {
-  try {
-    const resp = await (client as Client).session.messages({
-      path: { id: sessionID },
-      query: { directory },
-    });
-
-    const data = (resp as { data?: unknown[] }).data;
-    if (!Array.isArray(data)) return null;
-
-    const reversed = [...data].reverse();
-    const last = reversed.find((m) => {
-      const msg = m as Record<string, unknown>;
-      const info = msg.info as Record<string, unknown> | undefined;
-      return info?.role === "assistant";
-    });
-    if (!last) return null;
-    return (last as { info?: Record<string, unknown> }).info ?? null;
-  } catch {
-    return null;
-  }
-}
-
-
-
-function clearSessionState(
-  autoCompactState: AutoCompactState,
-  sessionID: string,
-): void {
-  autoCompactState.pendingCompact.delete(sessionID);
-  autoCompactState.errorDataBySession.delete(sessionID);
-  autoCompactState.retryStateBySession.delete(sessionID);
-  autoCompactState.truncateStateBySession.delete(sessionID);
-  autoCompactState.emptyContentAttemptBySession.delete(sessionID);
-  autoCompactState.compactionInProgress.delete(sessionID);
-}
-
-function getOrCreateEmptyContentAttempt(
-  autoCompactState: AutoCompactState,
-  sessionID: string,
-): number {
-  return autoCompactState.emptyContentAttemptBySession.get(sessionID) ?? 0;
-}
-
-async function fixEmptyMessages(
-  sessionID: string,
-  autoCompactState: AutoCompactState,
-  client: Client,
-  messageIndex?: number,
-): Promise<boolean> {
-  const attempt = getOrCreateEmptyContentAttempt(autoCompactState, sessionID);
-  autoCompactState.emptyContentAttemptBySession.set(sessionID, attempt + 1);
-
-  let fixed = false;
-  const fixedMessageIds: string[] = [];
-
-  if (messageIndex !== undefined) {
-    const targetMessageId = findEmptyMessageByIndex(sessionID, messageIndex);
-    if (targetMessageId) {
-      const replaced = replaceEmptyTextParts(
-        targetMessageId,
-        "[user interrupted]",
-      );
-      if (replaced) {
-        fixed = true;
-        fixedMessageIds.push(targetMessageId);
-      } else {
-        const injected = injectTextPart(
-          sessionID,
-          targetMessageId,
-          "[user interrupted]",
-        );
-        if (injected) {
-          fixed = true;
-          fixedMessageIds.push(targetMessageId);
-        }
-      }
-    }
-  }
-
-  if (!fixed) {
-    const emptyMessageIds = findEmptyMessages(sessionID);
-    if (emptyMessageIds.length === 0) {
-      await client.tui
-        .showToast({
-          body: {
-            title: "Empty Content Error",
-            message: "No empty messages found in storage. Cannot auto-recover.",
-            variant: "error",
-            duration: 5000,
-          },
-        })
-        .catch(() => {});
-      return false;
-    }
-
-    for (const messageID of emptyMessageIds) {
-      const replaced = replaceEmptyTextParts(messageID, "[user interrupted]");
-      if (replaced) {
-        fixed = true;
-        fixedMessageIds.push(messageID);
-      } else {
-        const injected = injectTextPart(
-          sessionID,
-          messageID,
-          "[user interrupted]",
-        );
-        if (injected) {
-          fixed = true;
-          fixedMessageIds.push(messageID);
-        }
-      }
-    }
-  }
-
-  if (fixed) {
-    await client.tui
-      .showToast({
-        body: {
-          title: "Session Recovery",
-          message: `Fixed ${fixedMessageIds.length} empty message(s). Retrying...`,
-          variant: "warning",
-          duration: 3000,
-        },
-      })
-      .catch(() => {});
-  }
-
-  return fixed;
-}
-
-export async function executeCompact(
-  sessionID: string,
-  msg: Record<string, unknown>,
-  autoCompactState: AutoCompactState,
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  client: any,
-  directory: string,
-  experimental?: ExperimentalConfig,
-): Promise<void> {
-  if (autoCompactState.compactionInProgress.has(sessionID)) {
-    await (client as Client).tui
-      .showToast({
-        body: {
-          title: "Compact In Progress",
-          message:
-            "Recovery already running. Please wait or start new session if stuck.",
-          variant: "warning",
-          duration: 5000,
-        },
-      })
-      .catch(() => {});
-    return;
-  }
-  autoCompactState.compactionInProgress.add(sessionID);
-
-  try {
-    const errorData = autoCompactState.errorDataBySession.get(sessionID);
-    const truncateState = getOrCreateTruncateState(autoCompactState, sessionID);
-
-    const isOverLimit =
-      errorData?.currentTokens &&
-      errorData?.maxTokens &&
-      errorData.currentTokens > errorData.maxTokens;
-
-    // Aggressive Truncation - always try when over limit
-    if (
-      isOverLimit &&
-      truncateState.truncateAttempt < TRUNCATE_CONFIG.maxTruncateAttempts
-    ) {
-      log("[auto-compact] PHASE 2: aggressive truncation triggered", {
-        currentTokens: errorData.currentTokens,
-        maxTokens: errorData.maxTokens,
-        targetRatio: TRUNCATE_CONFIG.targetTokenRatio,
-      });
-
-      const aggressiveResult = truncateUntilTargetTokens(
-        sessionID,
-        errorData.currentTokens,
-        errorData.maxTokens,
-        TRUNCATE_CONFIG.targetTokenRatio,
-        TRUNCATE_CONFIG.charsPerToken,
-      );
-
-      if (aggressiveResult.truncatedCount > 0) {
-        truncateState.truncateAttempt += aggressiveResult.truncatedCount;
-
-        const toolNames = aggressiveResult.truncatedTools
-          .map((t) => t.toolName)
-          .join(", ");
-        const statusMsg = aggressiveResult.sufficient
-          ? `Truncated ${aggressiveResult.truncatedCount} outputs (${formatBytes(aggressiveResult.totalBytesRemoved)})`
-          : `Truncated ${aggressiveResult.truncatedCount} outputs (${formatBytes(aggressiveResult.totalBytesRemoved)}) - continuing to summarize...`;
-
-        await (client as Client).tui
-          .showToast({
-            body: {
-              title: aggressiveResult.sufficient
-                ? "Truncation Complete"
-                : "Partial Truncation",
-              message: `${statusMsg}: ${toolNames}`,
-              variant: aggressiveResult.sufficient ? "success" : "warning",
-              duration: 4000,
-            },
-          })
-          .catch(() => {});
-
-        log("[auto-compact] aggressive truncation completed", aggressiveResult);
-
-        // Only return early if truncation was sufficient to get under token limit
-        // Otherwise fall through to PHASE 3 (Summarize)
-        if (aggressiveResult.sufficient) {
-          clearSessionState(autoCompactState, sessionID);
-          setTimeout(async () => {
-            try {
-              await (client as Client).session.prompt_async({
-                path: { id: sessionID },
-                body: { auto: true } as never,
-                query: { directory },
-              });
-            } catch {}
-          }, 500);
-          return;
-        }
-        // Truncation was insufficient - fall through to Summarize
-        log("[auto-compact] truncation insufficient, falling through to summarize", {
-          sessionID,
-          truncatedCount: aggressiveResult.truncatedCount,
-          sufficient: aggressiveResult.sufficient,
-        });
-      }
-    }
-
-    // PHASE 3: Summarize - fallback when truncation insufficient or no tool outputs
-    const retryState = getOrCreateRetryState(autoCompactState, sessionID);
-
-    if (errorData?.errorType?.includes("non-empty content")) {
-      const attempt = getOrCreateEmptyContentAttempt(
-        autoCompactState,
-        sessionID,
-      );
-      if (attempt < 3) {
-        const fixed = await fixEmptyMessages(
-          sessionID,
-          autoCompactState,
-          client as Client,
-          errorData.messageIndex,
-        );
-        if (fixed) {
-          setTimeout(() => {
-            executeCompact(
-              sessionID,
-              msg,
-              autoCompactState,
-              client,
-              directory,
-              experimental,
-            );
-          }, 500);
-          return;
-        }
-      } else {
-        await (client as Client).tui
-          .showToast({
-            body: {
-              title: "Recovery Failed",
-              message:
-                "Max recovery attempts (3) reached for empty content error. Please start a new session.",
-              variant: "error",
-              duration: 10000,
-            },
-          })
-          .catch(() => {});
-        return;
-      }
-    }
-
-    if (Date.now() - retryState.lastAttemptTime > 300000) {
-      retryState.attempt = 0;
-      autoCompactState.truncateStateBySession.delete(sessionID);
-    }
-
-    if (retryState.attempt < RETRY_CONFIG.maxAttempts) {
-      retryState.attempt++;
-      retryState.lastAttemptTime = Date.now();
-
-      const providerID = msg.providerID as string | undefined;
-      const modelID = msg.modelID as string | undefined;
-
-      if (providerID && modelID) {
-        try {
-          sanitizeEmptyMessagesBeforeSummarize(sessionID);
-
-          await (client as Client).tui
-            .showToast({
-              body: {
-                title: "Auto Compact",
-                message: `Summarizing session (attempt ${retryState.attempt}/${RETRY_CONFIG.maxAttempts})...`,
-                variant: "warning",
-                duration: 3000,
-              },
-            })
-            .catch(() => {});
-
-          const summarizeBody = { providerID, modelID, auto: true }
-          await (client as Client).session.summarize({
-            path: { id: sessionID },
-            body: summarizeBody as never,
-            query: { directory },
-          });
-          return;
-        } catch {
-          const delay =
-            RETRY_CONFIG.initialDelayMs *
-            Math.pow(RETRY_CONFIG.backoffFactor, retryState.attempt - 1);
-          const cappedDelay = Math.min(delay, RETRY_CONFIG.maxDelayMs);
-
-          setTimeout(() => {
-            executeCompact(
-              sessionID,
-              msg,
-              autoCompactState,
-              client,
-              directory,
-              experimental,
-            );
-          }, cappedDelay);
-          return;
-        }
-      } else {
-        await (client as Client).tui
-          .showToast({
-            body: {
-              title: "Summarize Skipped",
-              message: "Missing providerID or modelID.",
-              variant: "warning",
-              duration: 3000,
-            },
-          })
-          .catch(() => {});
-      }
-    }
-
-    clearSessionState(autoCompactState, sessionID);
-
-    await (client as Client).tui
-      .showToast({
-        body: {
-          title: "Auto Compact Failed",
-          message: "All recovery attempts failed. Please start a new session.",
-          variant: "error",
-          duration: 5000,
-        },
-      })
-      .catch(() => {});
-  } finally {
-    autoCompactState.compactionInProgress.delete(sessionID);
-  }
-}

package/oh-my-opencode/src/hooks/anthropic-context-window-limit-recovery/index.ts

@@ -1,151 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin"
-import type { AutoCompactState, ParsedTokenLimitError } from "./types"
-import type { ExperimentalConfig } from "../../config"
-import { parseAnthropicTokenLimitError } from "./parser"
-import { executeCompact, getLastAssistant } from "./executor"
-import { log } from "../../shared/logger"
-
-export interface AnthropicContextWindowLimitRecoveryOptions {
-  experimental?: ExperimentalConfig
-}
-
-function createRecoveryState(): AutoCompactState {
-  return {
-    pendingCompact: new Set<string>(),
-    errorDataBySession: new Map<string, ParsedTokenLimitError>(),
-    retryStateBySession: new Map(),
-    truncateStateBySession: new Map(),
-    emptyContentAttemptBySession: new Map(),
-    compactionInProgress: new Set<string>(),
-  }
-}
-
-export function createAnthropicContextWindowLimitRecoveryHook(ctx: PluginInput, options?: AnthropicContextWindowLimitRecoveryOptions) {
-  const autoCompactState = createRecoveryState()
-  const experimental = options?.experimental
-
-  const eventHandler = async ({ event }: { event: { type: string; properties?: unknown } }) => {
-    const props = event.properties as Record<string, unknown> | undefined
-
-    if (event.type === "session.deleted") {
-      const sessionInfo = props?.info as { id?: string } | undefined
-      if (sessionInfo?.id) {
-        autoCompactState.pendingCompact.delete(sessionInfo.id)
-        autoCompactState.errorDataBySession.delete(sessionInfo.id)
-        autoCompactState.retryStateBySession.delete(sessionInfo.id)
-        autoCompactState.truncateStateBySession.delete(sessionInfo.id)
-        autoCompactState.emptyContentAttemptBySession.delete(sessionInfo.id)
-        autoCompactState.compactionInProgress.delete(sessionInfo.id)
-      }
-      return
-    }
-
-    if (event.type === "session.error") {
-      const sessionID = props?.sessionID as string | undefined
-      log("[auto-compact] session.error received", { sessionID, error: props?.error })
-      if (!sessionID) return
-
-      const parsed = parseAnthropicTokenLimitError(props?.error)
-      log("[auto-compact] parsed result", { parsed, hasError: !!props?.error })
-      if (parsed) {
-        autoCompactState.pendingCompact.add(sessionID)
-        autoCompactState.errorDataBySession.set(sessionID, parsed)
-
-        if (autoCompactState.compactionInProgress.has(sessionID)) {
-          return
-        }
-
-        const lastAssistant = await getLastAssistant(sessionID, ctx.client, ctx.directory)
-        const providerID = parsed.providerID ?? (lastAssistant?.providerID as string | undefined)
-        const modelID = parsed.modelID ?? (lastAssistant?.modelID as string | undefined)
-
-        await ctx.client.tui
-          .showToast({
-            body: {
-              title: "Context Limit Hit",
-              message: "Truncating large tool outputs and recovering...",
-              variant: "warning" as const,
-              duration: 3000,
-            },
-          })
-          .catch(() => {})
-
-        setTimeout(() => {
-          executeCompact(
-            sessionID,
-            { providerID, modelID },
-            autoCompactState,
-            ctx.client,
-            ctx.directory,
-            experimental
-          )
-        }, 300)
-      }
-      return
-    }
-
-    if (event.type === "message.updated") {
-      const info = props?.info as Record<string, unknown> | undefined
-      const sessionID = info?.sessionID as string | undefined
-
-      if (sessionID && info?.role === "assistant" && info.error) {
-        log("[auto-compact] message.updated with error", { sessionID, error: info.error })
-        const parsed = parseAnthropicTokenLimitError(info.error)
-        log("[auto-compact] message.updated parsed result", { parsed })
-        if (parsed) {
-          parsed.providerID = info.providerID as string | undefined
-          parsed.modelID = info.modelID as string | undefined
-          autoCompactState.pendingCompact.add(sessionID)
-          autoCompactState.errorDataBySession.set(sessionID, parsed)
-        }
-      }
-      return
-    }
-
-    if (event.type === "session.idle") {
-      const sessionID = props?.sessionID as string | undefined
-      if (!sessionID) return
-
-      if (!autoCompactState.pendingCompact.has(sessionID)) return
-
-      const errorData = autoCompactState.errorDataBySession.get(sessionID)
-      const lastAssistant = await getLastAssistant(sessionID, ctx.client, ctx.directory)
-
-      if (lastAssistant?.summary === true) {
-        autoCompactState.pendingCompact.delete(sessionID)
-        return
-      }
-
-      const providerID = errorData?.providerID ?? (lastAssistant?.providerID as string | undefined)
-      const modelID = errorData?.modelID ?? (lastAssistant?.modelID as string | undefined)
-
-      await ctx.client.tui
-        .showToast({
-          body: {
-            title: "Auto Compact",
-            message: "Token limit exceeded. Attempting recovery...",
-            variant: "warning" as const,
-            duration: 3000,
-          },
-        })
-        .catch(() => {})
-
-      await executeCompact(
-        sessionID,
-        { providerID, modelID },
-        autoCompactState,
-        ctx.client,
-        ctx.directory,
-        experimental
-      )
-    }
-  }
-
-  return {
-    event: eventHandler,
-  }
-}
-
-export type { AutoCompactState, ParsedTokenLimitError, TruncateState } from "./types"
-export { parseAnthropicTokenLimitError } from "./parser"
-export { executeCompact, getLastAssistant } from "./executor"