micode 0.7.0 → 0.7.1

package/src/hooks/preemptive-compaction.ts

@@ -0,0 +1,183 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+
+// Model context limits (tokens)
+const MODEL_CONTEXT_LIMITS: Record<string, number> = {
+  // Anthropic
+  "claude-opus": 200_000,
+  "claude-sonnet": 200_000,
+  "claude-haiku": 200_000,
+  "claude-3": 200_000,
+  "claude-4": 200_000,
+  // OpenAI
+  "gpt-4o": 128_000,
+  "gpt-4-turbo": 128_000,
+  "gpt-4": 128_000,
+  "gpt-5": 200_000,
+  o1: 200_000,
+  o3: 200_000,
+  // Google
+  gemini: 1_000_000,
+};
+
+const DEFAULT_CONTEXT_LIMIT = 200_000;
+const DEFAULT_THRESHOLD = 0.6; // 60% of context window
+const MIN_TOKENS_FOR_COMPACTION = 50_000;
+const COMPACTION_COOLDOWN_MS = 60_000; // 60 seconds
+
+function getContextLimit(modelID: string): number {
+  const modelLower = modelID.toLowerCase();
+  for (const [pattern, limit] of Object.entries(MODEL_CONTEXT_LIMITS)) {
+    if (modelLower.includes(pattern)) {
+      return limit;
+    }
+  }
+  return DEFAULT_CONTEXT_LIMIT;
+}
+
+interface CompactionState {
+  lastCompactionTime: Map<string, number>;
+  compactionInProgress: Set<string>;
+}
+
+export function createPreemptiveCompactionHook(ctx: PluginInput) {
+  const state: CompactionState = {
+    lastCompactionTime: new Map(),
+    compactionInProgress: new Set(),
+  };
+
+  async function checkAndCompact(sessionID: string, providerID?: string, modelID?: string): Promise<void> {
+    // Skip if compaction in progress
+    if (state.compactionInProgress.has(sessionID)) return;
+
+    // Respect cooldown
+    const lastTime = state.lastCompactionTime.get(sessionID) || 0;
+    if (Date.now() - lastTime < COMPACTION_COOLDOWN_MS) return;
+
+    try {
+      // Get session messages to calculate token usage
+      const resp = await ctx.client.session.messages({
+        path: { id: sessionID },
+        query: { directory: ctx.directory },
+      });
+
+      const messages = (resp as { data?: unknown[] }).data;
+      if (!Array.isArray(messages) || messages.length === 0) return;
+
+      // Find last assistant message with token info
+      const lastAssistant = [...messages].reverse().find((m) => {
+        const msg = m as Record<string, unknown>;
+        const info = msg.info as Record<string, unknown> | undefined;
+        return info?.role === "assistant";
+      }) as Record<string, unknown> | undefined;
+
+      if (!lastAssistant) return;
+
+      const info = lastAssistant.info as Record<string, unknown> | undefined;
+      const usage = info?.usage as Record<string, unknown> | undefined;
+
+      // Calculate token usage
+      const inputTokens = (usage?.inputTokens as number) || 0;
+      const cacheRead = (usage?.cacheReadInputTokens as number) || 0;
+      const totalUsed = inputTokens + cacheRead;
+
+      if (totalUsed < MIN_TOKENS_FOR_COMPACTION) return;
+
+      // Get model context limit
+      const model = modelID || (info?.modelID as string) || "";
+      const contextLimit = getContextLimit(model);
+      const usageRatio = totalUsed / contextLimit;
+
+      if (usageRatio < DEFAULT_THRESHOLD) return;
+
+      // Skip if last message was already a summary
+      const lastUserMsg = [...messages].reverse().find((m) => {
+        const msg = m as Record<string, unknown>;
+        const msgInfo = msg.info as Record<string, unknown> | undefined;
+        return msgInfo?.role === "user";
+      }) as Record<string, unknown> | undefined;
+
+      if (lastUserMsg) {
+        const parts = lastUserMsg.parts as Array<{ type: string; text?: string }> | undefined;
+        const text = parts?.find((p) => p.type === "text")?.text || "";
+        if (text.includes("summarized") || text.includes("compacted")) return;
+      }
+
+      // Trigger compaction
+      state.compactionInProgress.add(sessionID);
+      state.lastCompactionTime.set(sessionID, Date.now());
+
+      await ctx.client.tui
+        .showToast({
+          body: {
+            title: "Context Window",
+            message: `${Math.round(usageRatio * 100)}% used - auto-compacting...`,
+            variant: "warning",
+            duration: 3000,
+          },
+        })
+        .catch(() => {});
+
+      const provider = providerID || (info?.providerID as string);
+      const modelToUse = modelID || (info?.modelID as string);
+
+      if (provider && modelToUse) {
+        await ctx.client.session.summarize({
+          path: { id: sessionID },
+          body: { providerID: provider, modelID: modelToUse },
+          query: { directory: ctx.directory },
+        });
+
+        await ctx.client.tui
+          .showToast({
+            body: {
+              title: "Compacted",
+              message: "Session summarized successfully",
+              variant: "success",
+              duration: 3000,
+            },
+          })
+          .catch(() => {});
+      }
+    } catch (_e) {
+      // Silent failure - don't interrupt user flow
+    } finally {
+      state.compactionInProgress.delete(sessionID);
+    }
+  }
+
+  return {
+    event: async ({ event }: { event: { type: string; properties?: unknown } }) => {
+      const props = event.properties as Record<string, unknown> | undefined;
+
+      // Cleanup on session delete
+      if (event.type === "session.deleted") {
+        const sessionInfo = props?.info as { id?: string } | undefined;
+        if (sessionInfo?.id) {
+          state.lastCompactionTime.delete(sessionInfo.id);
+          state.compactionInProgress.delete(sessionInfo.id);
+        }
+        return;
+      }
+
+      // Check on message update (assistant finished)
+      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") {
+          const providerID = info.providerID as string | undefined;
+          const modelID = info.modelID as string | undefined;
+          await checkAndCompact(sessionID, providerID, modelID);
+        }
+      }
+
+      // Check when session goes idle
+      if (event.type === "session.idle") {
+        const sessionID = props?.sessionID as string | undefined;
+        if (sessionID) {
+          await checkAndCompact(sessionID);
+        }
+      }
+    },
+  };
+}

package/src/hooks/session-recovery.ts

@@ -0,0 +1,258 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+
+// Error patterns we can recover from
+const RECOVERABLE_ERRORS = {
+  TOOL_RESULT_MISSING: "tool_result block(s) missing",
+  THINKING_BLOCK_ORDER: "thinking blocks must be at the start",
+  THINKING_DISABLED: "thinking is not enabled",
+  EMPTY_CONTENT: "content cannot be empty",
+  INVALID_TOOL_RESULT: "tool_result must follow tool_use",
+} as const;
+
+type RecoverableErrorType = keyof typeof RECOVERABLE_ERRORS;
+
+interface RecoveryState {
+  processingErrors: Set<string>;
+  recoveryAttempts: Map<string, number>;
+}
+
+const MAX_RECOVERY_ATTEMPTS = 3;
+
+function extractErrorInfo(error: unknown): { message: string; messageIndex?: number } | null {
+  if (!error) return null;
+
+  let errorStr: string;
+  if (typeof error === "string") {
+    errorStr = error;
+  } else if (error instanceof Error) {
+    errorStr = error.message;
+  } else {
+    errorStr = JSON.stringify(error);
+  }
+
+  const errorLower = errorStr.toLowerCase();
+
+  // Extract message index if present (e.g., "messages.5" or "message 5")
+  const indexMatch = errorStr.match(/messages?[.\s](\d+)/i);
+  const messageIndex = indexMatch ? parseInt(indexMatch[1], 10) : undefined;
+
+  return { message: errorLower, messageIndex };
+}
+
+function identifyErrorType(errorMessage: string): RecoverableErrorType | null {
+  for (const [type, pattern] of Object.entries(RECOVERABLE_ERRORS)) {
+    if (errorMessage.includes(pattern.toLowerCase())) {
+      return type as RecoverableErrorType;
+    }
+  }
+  return null;
+}
+
+export function createSessionRecoveryHook(ctx: PluginInput) {
+  const state: RecoveryState = {
+    processingErrors: new Set(),
+    recoveryAttempts: new Map(),
+  };
+
+  async function getSessionMessages(sessionID: string): Promise<unknown[]> {
+    try {
+      const resp = await ctx.client.session.messages({
+        path: { id: sessionID },
+        query: { directory: ctx.directory },
+      });
+      return (resp as { data?: unknown[] }).data || [];
+    } catch {
+      return [];
+    }
+  }
+
+  async function abortSession(sessionID: string): Promise<void> {
+    try {
+      await ctx.client.session.abort({
+        path: { id: sessionID },
+        query: { directory: ctx.directory },
+      });
+    } catch {
+      // Ignore abort errors
+    }
+  }
+
+  async function resumeSession(
+    sessionID: string,
+    providerID?: string,
+    modelID?: string,
+    agent?: string,
+  ): Promise<void> {
+    try {
+      // Find last user message to resume from
+      const messages = await getSessionMessages(sessionID);
+      const lastUserMsg = [...messages].reverse().find((m) => {
+        const msg = m as Record<string, unknown>;
+        const info = msg.info as Record<string, unknown> | undefined;
+        return info?.role === "user";
+      });
+
+      if (!lastUserMsg) return;
+
+      const parts = (lastUserMsg as Record<string, unknown>).parts as Array<{
+        type: string;
+        text?: string;
+      }>;
+      const text = parts?.find((p) => p.type === "text")?.text;
+
+      if (!text) return;
+
+      // Resume with continue prompt
+      await ctx.client.session.prompt({
+        path: { id: sessionID },
+        body: {
+          parts: [{ type: "text", text: "Continue from where you left off." }],
+          ...(providerID && modelID ? { providerID, modelID } : {}),
+          ...(agent ? { agent } : {}),
+        },
+        query: { directory: ctx.directory },
+      });
+    } catch {
+      // Resume failed - user will need to manually continue
+    }
+  }
+
+  async function attemptRecovery(
+    sessionID: string,
+    errorType: RecoverableErrorType,
+    providerID?: string,
+    modelID?: string,
+    agent?: string,
+  ): Promise<boolean> {
+    const recoveryKey = `${sessionID}:${errorType}`;
+
+    // Check recovery attempts
+    const attempts = state.recoveryAttempts.get(recoveryKey) || 0;
+    if (attempts >= MAX_RECOVERY_ATTEMPTS) {
+      await ctx.client.tui
+        .showToast({
+          body: {
+            title: "Recovery Failed",
+            message: `Max attempts reached for ${errorType}. Manual intervention needed.`,
+            variant: "error",
+            duration: 5000,
+          },
+        })
+        .catch(() => {});
+      return false;
+    }
+
+    state.recoveryAttempts.set(recoveryKey, attempts + 1);
+
+    await ctx.client.tui
+      .showToast({
+        body: {
+          title: "Session Recovery",
+          message: `Recovering from ${errorType.toLowerCase().replace(/_/g, " ")}...`,
+          variant: "warning",
+          duration: 3000,
+        },
+      })
+      .catch(() => {});
+
+    // Abort current session to stop the error state
+    await abortSession(sessionID);
+
+    // Wait a moment for abort to complete
+    await new Promise((resolve) => setTimeout(resolve, 500));
+
+    // Attempt resume
+    await resumeSession(sessionID, providerID, modelID, agent);
+
+    await ctx.client.tui
+      .showToast({
+        body: {
+          title: "Recovery Complete",
+          message: "Session resumed. Continuing...",
+          variant: "success",
+          duration: 3000,
+        },
+      })
+      .catch(() => {});
+
+    return true;
+  }
+
+  return {
+    event: async ({ event }: { event: { type: string; properties?: unknown } }) => {
+      const props = event.properties as Record<string, unknown> | undefined;
+
+      // Cleanup on session delete
+      if (event.type === "session.deleted") {
+        const sessionInfo = props?.info as { id?: string } | undefined;
+        if (sessionInfo?.id) {
+          // Clean up all recovery attempts for this session
+          for (const key of state.recoveryAttempts.keys()) {
+            if (key.startsWith(sessionInfo.id)) {
+              state.recoveryAttempts.delete(key);
+            }
+          }
+          for (const key of state.processingErrors) {
+            if (key.startsWith(sessionInfo.id)) {
+              state.processingErrors.delete(key);
+            }
+          }
+        }
+        return;
+      }
+
+      // Handle session errors
+      if (event.type === "session.error") {
+        const sessionID = props?.sessionID as string | undefined;
+        const error = props?.error;
+
+        if (!sessionID || !error) return;
+
+        const errorInfo = extractErrorInfo(error);
+        if (!errorInfo) return;
+
+        const errorType = identifyErrorType(errorInfo.message);
+        if (!errorType) return;
+
+        // Prevent duplicate processing
+        const errorKey = `${sessionID}:${errorType}:${Date.now()}`;
+        if (state.processingErrors.has(errorKey)) return;
+        state.processingErrors.add(errorKey);
+
+        // Clear old error keys after 10 seconds
+        setTimeout(() => state.processingErrors.delete(errorKey), 10000);
+
+        // Attempt recovery
+        await attemptRecovery(sessionID, errorType);
+      }
+
+      // Handle message errors
+      if (event.type === "message.updated") {
+        const info = props?.info as Record<string, unknown> | undefined;
+        const sessionID = info?.sessionID as string | undefined;
+        const error = info?.error;
+
+        if (!sessionID || !error) return;
+
+        const errorInfo = extractErrorInfo(error);
+        if (!errorInfo) return;
+
+        const errorType = identifyErrorType(errorInfo.message);
+        if (!errorType) return;
+
+        // Prevent duplicate processing
+        const errorKey = `${sessionID}:${errorType}:${Date.now()}`;
+        if (state.processingErrors.has(errorKey)) return;
+        state.processingErrors.add(errorKey);
+
+        setTimeout(() => state.processingErrors.delete(errorKey), 10000);
+
+        const providerID = info.providerID as string | undefined;
+        const modelID = info.modelID as string | undefined;
+        const agent = info.agent as string | undefined;
+
+        await attemptRecovery(sessionID, errorType, providerID, modelID, agent);
+      }
+    },
+  };
+}

package/src/hooks/token-aware-truncation.ts

@@ -0,0 +1,189 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+
+// Tools that benefit from truncation
+const TRUNCATABLE_TOOLS = ["grep", "Grep", "glob", "Glob", "ast_grep_search"];
+
+// Token estimation (conservative: 4 chars = 1 token)
+const CHARS_PER_TOKEN = 4;
+const DEFAULT_CONTEXT_LIMIT = 200_000;
+const DEFAULT_MAX_OUTPUT_TOKENS = 50_000;
+const SAFETY_MARGIN = 0.5; // Keep 50% headroom
+const PRESERVE_HEADER_LINES = 3;
+
+function estimateTokens(text: string): number {
+  return Math.ceil(text.length / CHARS_PER_TOKEN);
+}
+
+function truncateToTokenLimit(
+  output: string,
+  maxTokens: number,
+  preserveLines: number = PRESERVE_HEADER_LINES,
+): string {
+  const currentTokens = estimateTokens(output);
+
+  if (currentTokens <= maxTokens) {
+    return output;
+  }
+
+  const lines = output.split("\n");
+
+  // Preserve header lines
+  const headerLines = lines.slice(0, preserveLines);
+  const remainingLines = lines.slice(preserveLines);
+
+  // Calculate available tokens for content
+  const headerTokens = estimateTokens(headerLines.join("\n"));
+  const truncationMsgTokens = 50; // Reserve for truncation message
+  const availableTokens = maxTokens - headerTokens - truncationMsgTokens;
+
+  if (availableTokens <= 0) {
+    return `${headerLines.join("\n")}\n\n[Output truncated - context window limit reached]`;
+  }
+
+  // Accumulate lines until we hit the limit
+  const resultLines: string[] = [];
+  let usedTokens = 0;
+  let truncatedCount = 0;
+
+  for (const line of remainingLines) {
+    const lineTokens = estimateTokens(line);
+    if (usedTokens + lineTokens > availableTokens) {
+      truncatedCount = remainingLines.length - resultLines.length;
+      break;
+    }
+    resultLines.push(line);
+    usedTokens += lineTokens;
+  }
+
+  if (truncatedCount === 0) {
+    return output;
+  }
+
+  return [
+    ...headerLines,
+    ...resultLines,
+    "",
+    `[${truncatedCount} more lines truncated due to context window limit]`,
+  ].join("\n");
+}
+
+interface TruncationState {
+  sessionTokenUsage: Map<string, { used: number; limit: number }>;
+}
+
+export function createTokenAwareTruncationHook(ctx: PluginInput) {
+  const state: TruncationState = {
+    sessionTokenUsage: new Map(),
+  };
+
+  async function updateTokenUsage(sessionID: string): Promise<{ used: number; limit: number }> {
+    try {
+      const resp = await ctx.client.session.messages({
+        path: { id: sessionID },
+        query: { directory: ctx.directory },
+      });
+
+      const messages = (resp as { data?: unknown[] }).data;
+      if (!Array.isArray(messages) || messages.length === 0) {
+        return { used: 0, limit: DEFAULT_CONTEXT_LIMIT };
+      }
+
+      // Find last assistant message with usage info
+      const lastAssistant = [...messages].reverse().find((m) => {
+        const msg = m as Record<string, unknown>;
+        const info = msg.info as Record<string, unknown> | undefined;
+        return info?.role === "assistant";
+      }) as Record<string, unknown> | undefined;
+
+      if (!lastAssistant) {
+        return { used: 0, limit: DEFAULT_CONTEXT_LIMIT };
+      }
+
+      const info = lastAssistant.info as Record<string, unknown> | undefined;
+      const usage = info?.usage as Record<string, unknown> | undefined;
+
+      const inputTokens = (usage?.inputTokens as number) || 0;
+      const cacheRead = (usage?.cacheReadInputTokens as number) || 0;
+      const used = inputTokens + cacheRead;
+
+      // Get model limit (simplified - use default for now)
+      const limit = DEFAULT_CONTEXT_LIMIT;
+
+      const result = { used, limit };
+      state.sessionTokenUsage.set(sessionID, result);
+      return result;
+    } catch {
+      return state.sessionTokenUsage.get(sessionID) || { used: 0, limit: DEFAULT_CONTEXT_LIMIT };
+    }
+  }
+
+  function calculateMaxOutputTokens(used: number, limit: number): number {
+    const remaining = limit - used;
+    const available = Math.floor(remaining * SAFETY_MARGIN);
+
+    if (available <= 0) {
+      return 0;
+    }
+
+    return Math.min(available, DEFAULT_MAX_OUTPUT_TOKENS);
+  }
+
+  return {
+    // Update token usage when assistant messages are received
+    event: 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) {
+          state.sessionTokenUsage.delete(sessionInfo.id);
+        }
+        return;
+      }
+
+      // Update usage on message updates
+      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") {
+          await updateTokenUsage(sessionID);
+        }
+      }
+    },
+
+    // Truncate tool output
+    "tool.execute.after": async (input: { name: string; sessionID: string }, output: { output?: string }) => {
+      // Only truncate specific tools
+      if (!TRUNCATABLE_TOOLS.includes(input.name)) {
+        return;
+      }
+
+      if (!output.output || typeof output.output !== "string") {
+        return;
+      }
+
+      try {
+        // Get current token usage
+        const { used, limit } = await updateTokenUsage(input.sessionID);
+        const maxTokens = calculateMaxOutputTokens(used, limit);
+
+        if (maxTokens <= 0) {
+          output.output = "[Output suppressed - context window exhausted. Consider compacting.]";
+          return;
+        }
+
+        // Truncate if needed
+        const currentTokens = estimateTokens(output.output);
+        if (currentTokens > maxTokens) {
+          output.output = truncateToTokenLimit(output.output, maxTokens);
+        }
+      } catch {
+        // On error, apply static truncation as fallback
+        const currentTokens = estimateTokens(output.output);
+        if (currentTokens > DEFAULT_MAX_OUTPUT_TOKENS) {
+          output.output = truncateToTokenLimit(output.output, DEFAULT_MAX_OUTPUT_TOKENS);
+        }
+      }
+    },
+  };
+}