opencode-repos 0.3.0 → 0.3.1

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

@@ -1,201 +0,0 @@
-import type { ParsedTokenLimitError } from "./types"
-
-interface AnthropicErrorData {
-  type: "error"
-  error: {
-    type: string
-    message: string
-  }
-  request_id?: string
-}
-
-const TOKEN_LIMIT_PATTERNS = [
-  /(\d+)\s*tokens?\s*>\s*(\d+)\s*maximum/i,
-  /prompt.*?(\d+).*?tokens.*?exceeds.*?(\d+)/i,
-  /(\d+).*?tokens.*?limit.*?(\d+)/i,
-  /context.*?length.*?(\d+).*?maximum.*?(\d+)/i,
-  /max.*?context.*?(\d+).*?but.*?(\d+)/i,
-]
-
-const TOKEN_LIMIT_KEYWORDS = [
-  "prompt is too long",
-  "is too long",
-  "context_length_exceeded",
-  "max_tokens",
-  "token limit",
-  "context length",
-  "too many tokens",
-  "non-empty content",
-]
-
-// Patterns that indicate thinking block structure errors (NOT token limit errors)
-// These should be handled by session-recovery hook, not compaction
-const THINKING_BLOCK_ERROR_PATTERNS = [
-  /thinking.*first block/i,
-  /first block.*thinking/i,
-  /must.*start.*thinking/i,
-  /thinking.*redacted_thinking/i,
-  /expected.*thinking.*found/i,
-  /thinking.*disabled.*cannot.*contain/i,
-]
-
-function isThinkingBlockError(text: string): boolean {
-  return THINKING_BLOCK_ERROR_PATTERNS.some((pattern) => pattern.test(text))
-}
-
-const MESSAGE_INDEX_PATTERN = /messages\.(\d+)/
-
-function extractTokensFromMessage(message: string): { current: number; max: number } | null {
-  for (const pattern of TOKEN_LIMIT_PATTERNS) {
-    const match = message.match(pattern)
-    if (match) {
-      const num1 = parseInt(match[1], 10)
-      const num2 = parseInt(match[2], 10)
-      return num1 > num2 ? { current: num1, max: num2 } : { current: num2, max: num1 }
-    }
-  }
-  return null
-}
-
-function extractMessageIndex(text: string): number | undefined {
-  const match = text.match(MESSAGE_INDEX_PATTERN)
-  if (match) {
-    return parseInt(match[1], 10)
-  }
-  return undefined
-}
-
-function isTokenLimitError(text: string): boolean {
-  if (isThinkingBlockError(text)) {
-    return false
-  }
-  const lower = text.toLowerCase()
-  return TOKEN_LIMIT_KEYWORDS.some((kw) => lower.includes(kw.toLowerCase()))
-}
-
-export function parseAnthropicTokenLimitError(err: unknown): ParsedTokenLimitError | null {
-  if (typeof err === "string") {
-    if (err.toLowerCase().includes("non-empty content")) {
-      return {
-        currentTokens: 0,
-        maxTokens: 0,
-        errorType: "non-empty content",
-        messageIndex: extractMessageIndex(err),
-      }
-    }
-    if (isTokenLimitError(err)) {
-      const tokens = extractTokensFromMessage(err)
-      return {
-        currentTokens: tokens?.current ?? 0,
-        maxTokens: tokens?.max ?? 0,
-        errorType: "token_limit_exceeded_string",
-      }
-    }
-    return null
-  }
-
-  if (!err || typeof err !== "object") return null
-
-  const errObj = err as Record<string, unknown>
-
-  const dataObj = errObj.data as Record<string, unknown> | undefined
-  const responseBody = dataObj?.responseBody
-  const errorMessage = errObj.message as string | undefined
-  const errorData = errObj.error as Record<string, unknown> | undefined
-  const nestedError = errorData?.error as Record<string, unknown> | undefined
-
-  const textSources: string[] = []
-
-  if (typeof responseBody === "string") textSources.push(responseBody)
-  if (typeof errorMessage === "string") textSources.push(errorMessage)
-  if (typeof errorData?.message === "string") textSources.push(errorData.message as string)
-  if (typeof errObj.body === "string") textSources.push(errObj.body as string)
-  if (typeof errObj.details === "string") textSources.push(errObj.details as string)
-  if (typeof errObj.reason === "string") textSources.push(errObj.reason as string)
-  if (typeof errObj.description === "string") textSources.push(errObj.description as string)
-  if (typeof nestedError?.message === "string") textSources.push(nestedError.message as string)
-  if (typeof dataObj?.message === "string") textSources.push(dataObj.message as string)
-  if (typeof dataObj?.error === "string") textSources.push(dataObj.error as string)
-
-  if (textSources.length === 0) {
-    try {
-      const jsonStr = JSON.stringify(errObj)
-      if (isTokenLimitError(jsonStr)) {
-        textSources.push(jsonStr)
-      }
-    } catch {}
-  }
-
-  const combinedText = textSources.join(" ")
-  if (!isTokenLimitError(combinedText)) return null
-
-  if (typeof responseBody === "string") {
-    try {
-      const jsonPatterns = [
-        // Greedy match to last } for nested JSON
-        /data:\s*(\{[\s\S]*\})\s*$/m,
-        /(\{"type"\s*:\s*"error"[\s\S]*\})/,
-        /(\{[\s\S]*"error"[\s\S]*\})/,
-      ]
-
-      for (const pattern of jsonPatterns) {
-        const dataMatch = responseBody.match(pattern)
-        if (dataMatch) {
-          try {
-            const jsonData: AnthropicErrorData = JSON.parse(dataMatch[1])
-            const message = jsonData.error?.message || ""
-            const tokens = extractTokensFromMessage(message)
-
-            if (tokens) {
-              return {
-                currentTokens: tokens.current,
-                maxTokens: tokens.max,
-                requestId: jsonData.request_id,
-                errorType: jsonData.error?.type || "token_limit_exceeded",
-              }
-            }
-          } catch {}
-        }
-      }
-
-      const bedrockJson = JSON.parse(responseBody)
-      if (typeof bedrockJson.message === "string" && isTokenLimitError(bedrockJson.message)) {
-        return {
-          currentTokens: 0,
-          maxTokens: 0,
-          errorType: "bedrock_input_too_long",
-        }
-      }
-    } catch {}
-  }
-
-  for (const text of textSources) {
-    const tokens = extractTokensFromMessage(text)
-    if (tokens) {
-      return {
-        currentTokens: tokens.current,
-        maxTokens: tokens.max,
-        errorType: "token_limit_exceeded",
-      }
-    }
-  }
-
-  if (combinedText.toLowerCase().includes("non-empty content")) {
-    return {
-      currentTokens: 0,
-      maxTokens: 0,
-      errorType: "non-empty content",
-      messageIndex: extractMessageIndex(combinedText),
-    }
-  }
-
-  if (isTokenLimitError(combinedText)) {
-    return {
-      currentTokens: 0,
-      maxTokens: 0,
-      errorType: "token_limit_exceeded_unknown",
-    }
-  }
-
-  return null
-}

package/oh-my-opencode/src/hooks/anthropic-context-window-limit-recovery/pruning-deduplication.test.ts

@@ -1,33 +0,0 @@
-import { describe, test, expect } from "bun:test"
-import { createToolSignature } from "./pruning-deduplication"
-
-describe("createToolSignature", () => {
-  test("creates consistent signature for same input", () => {
-    const input1 = { filePath: "/foo/bar.ts", content: "hello" }
-    const input2 = { content: "hello", filePath: "/foo/bar.ts" }
-    
-    const sig1 = createToolSignature("read", input1)
-    const sig2 = createToolSignature("read", input2)
-    
-    expect(sig1).toBe(sig2)
-  })
-  
-  test("creates different signature for different input", () => {
-    const input1 = { filePath: "/foo/bar.ts" }
-    const input2 = { filePath: "/foo/baz.ts" }
-    
-    const sig1 = createToolSignature("read", input1)
-    const sig2 = createToolSignature("read", input2)
-    
-    expect(sig1).not.toBe(sig2)
-  })
-  
-  test("includes tool name in signature", () => {
-    const input = { filePath: "/foo/bar.ts" }
-    
-    const sig1 = createToolSignature("read", input)
-    const sig2 = createToolSignature("write", input)
-    
-    expect(sig1).not.toBe(sig2)
-  })
-})

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

@@ -1,184 +0,0 @@
-import { existsSync, readdirSync, readFileSync } from "node:fs"
-import { join } from "node:path"
-import type { PruningState, ToolCallSignature } from "./pruning-types"
-import { estimateTokens } from "./pruning-types"
-import { log } from "../../shared/logger"
-import { MESSAGE_STORAGE } from "../../features/hook-message-injector"
-
-export interface DeduplicationConfig {
-  enabled: boolean
-  protectedTools?: string[]
-}
-
-interface ToolPart {
-  type: string
-  callID?: string
-  tool?: string
-  state?: {
-    input?: unknown
-    output?: string
-  }
-}
-
-interface MessagePart {
-  type: string
-  parts?: ToolPart[]
-}
-
-export function createToolSignature(toolName: string, input: unknown): string {
-  const sortedInput = sortObject(input)
-  return `${toolName}::${JSON.stringify(sortedInput)}`
-}
-
-function sortObject(obj: unknown): unknown {
-  if (obj === null || obj === undefined) return obj
-  if (typeof obj !== "object") return obj
-  if (Array.isArray(obj)) return obj.map(sortObject)
-  
-  const sorted: Record<string, unknown> = {}
-  const keys = Object.keys(obj as Record<string, unknown>).sort()
-  for (const key of keys) {
-    sorted[key] = sortObject((obj as Record<string, unknown>)[key])
-  }
-  return sorted
-}
-
-function getMessageDir(sessionID: string): string | null {
-  if (!existsSync(MESSAGE_STORAGE)) return null
-
-  const directPath = join(MESSAGE_STORAGE, sessionID)
-  if (existsSync(directPath)) return directPath
-
-  for (const dir of readdirSync(MESSAGE_STORAGE)) {
-    const sessionPath = join(MESSAGE_STORAGE, dir, sessionID)
-    if (existsSync(sessionPath)) return sessionPath
-  }
-
-  return null
-}
-
-function readMessages(sessionID: string): MessagePart[] {
-  const messageDir = getMessageDir(sessionID)
-  if (!messageDir) return []
-
-  const messages: MessagePart[] = []
-  
-  try {
-    const files = readdirSync(messageDir).filter(f => f.endsWith(".json"))
-    for (const file of files) {
-      const content = readFileSync(join(messageDir, file), "utf-8")
-      const data = JSON.parse(content)
-      if (data.parts) {
-        messages.push(data)
-      }
-    }
-  } catch {
-    return []
-  }
-
-  return messages
-}
-
-export function executeDeduplication(
-  sessionID: string,
-  state: PruningState,
-  config: DeduplicationConfig,
-  protectedTools: Set<string>
-): number {
-  if (!config.enabled) return 0
-
-  const messages = readMessages(sessionID)
-  const signatures = new Map<string, ToolCallSignature[]>()
-  
-  let currentTurn = 0
-  
-  for (const msg of messages) {
-    if (!msg.parts) continue
-    
-    for (const part of msg.parts) {
-      if (part.type === "step-start") {
-        currentTurn++
-        continue
-      }
-      
-      if (part.type !== "tool" || !part.callID || !part.tool) continue
-      
-      if (protectedTools.has(part.tool)) continue
-      
-      if (config.protectedTools?.includes(part.tool)) continue
-      
-      if (state.toolIdsToPrune.has(part.callID)) continue
-      
-      const signature = createToolSignature(part.tool, part.state?.input)
-      
-      if (!signatures.has(signature)) {
-        signatures.set(signature, [])
-      }
-      
-      signatures.get(signature)!.push({
-        toolName: part.tool,
-        signature,
-        callID: part.callID,
-        turn: currentTurn,
-      })
-      
-      if (!state.toolSignatures.has(signature)) {
-        state.toolSignatures.set(signature, [])
-      }
-      state.toolSignatures.get(signature)!.push({
-        toolName: part.tool,
-        signature,
-        callID: part.callID,
-        turn: currentTurn,
-      })
-    }
-  }
-  
-  let prunedCount = 0
-  let tokensSaved = 0
-  
-  for (const [signature, calls] of signatures) {
-    if (calls.length > 1) {
-      const toPrune = calls.slice(0, -1)
-      
-      for (const call of toPrune) {
-        state.toolIdsToPrune.add(call.callID)
-        prunedCount++
-        
-        const output = findToolOutput(messages, call.callID)
-        if (output) {
-          tokensSaved += estimateTokens(output)
-        }
-        
-        log("[pruning-deduplication] pruned duplicate", {
-          tool: call.toolName,
-          callID: call.callID,
-          turn: call.turn,
-          signature: signature.substring(0, 100),
-        })
-      }
-    }
-  }
-  
-  log("[pruning-deduplication] complete", {
-    prunedCount,
-    tokensSaved,
-    uniqueSignatures: signatures.size,
-  })
-  
-  return prunedCount
-}
-
-function findToolOutput(messages: MessagePart[], callID: string): string | null {
-  for (const msg of messages) {
-    if (!msg.parts) continue
-    
-    for (const part of msg.parts) {
-      if (part.type === "tool" && part.callID === callID && part.state?.output) {
-        return part.state.output
-      }
-    }
-  }
-  
-  return null
-}

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

@@ -1,44 +0,0 @@
-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 const CHARS_PER_TOKEN = 4
-
-export function estimateTokens(text: string): number {
-  return Math.ceil(text.length / CHARS_PER_TOKEN)
-}

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

@@ -1,77 +0,0 @@
-import { describe, test, expect, mock, beforeEach } from "bun:test"
-import { truncateUntilTargetTokens } from "./storage"
-import * as storage from "./storage"
-
-// Mock the entire module
-mock.module("./storage", () => {
-  return {
-    ...storage,
-    findToolResultsBySize: mock(() => []),
-    truncateToolResult: mock(() => ({ success: false })),
-  }
-})
-
-describe("truncateUntilTargetTokens", () => {
-  const sessionID = "test-session"
-  
-  beforeEach(() => {
-    // Reset mocks
-    const { findToolResultsBySize, truncateToolResult } = require("./storage")
-    findToolResultsBySize.mockReset()
-    truncateToolResult.mockReset()
-  })
-
-  test("truncates only until target is reached", () => {
-    const { findToolResultsBySize, truncateToolResult } = require("./storage")
-    
-    // #given: Two tool results, each 1000 chars. Target reduction is 500 chars.
-    const results = [
-      { partPath: "path1", partId: "id1", messageID: "m1", toolName: "tool1", outputSize: 1000 },
-      { partPath: "path2", partId: "id2", messageID: "m2", toolName: "tool2", outputSize: 1000 },
-    ]
-    
-    findToolResultsBySize.mockReturnValue(results)
-    truncateToolResult.mockImplementation((path: string) => ({
-      success: true,
-      toolName: path === "path1" ? "tool1" : "tool2",
-      originalSize: 1000
-    }))
-
-    // #when: currentTokens=1000, maxTokens=1000, targetRatio=0.5 (target=500, reduce=500)
-    // charsPerToken=1 for simplicity in test
-    const result = truncateUntilTargetTokens(sessionID, 1000, 1000, 0.5, 1)
-
-    // #then: Should only truncate the first tool
-    expect(result.truncatedCount).toBe(1)
-    expect(truncateToolResult).toHaveBeenCalledTimes(1)
-    expect(truncateToolResult).toHaveBeenCalledWith("path1")
-    expect(result.totalBytesRemoved).toBe(1000)
-    expect(result.sufficient).toBe(true)
-  })
-
-  test("truncates all if target not reached", () => {
-    const { findToolResultsBySize, truncateToolResult } = require("./storage")
-    
-    // #given: Two tool results, each 100 chars. Target reduction is 500 chars.
-    const results = [
-      { partPath: "path1", partId: "id1", messageID: "m1", toolName: "tool1", outputSize: 100 },
-      { partPath: "path2", partId: "id2", messageID: "m2", toolName: "tool2", outputSize: 100 },
-    ]
-    
-    findToolResultsBySize.mockReturnValue(results)
-    truncateToolResult.mockImplementation((path: string) => ({
-      success: true,
-      toolName: path === "path1" ? "tool1" : "tool2",
-      originalSize: 100
-    }))
-
-    // #when: reduce 500 chars
-    const result = truncateUntilTargetTokens(sessionID, 1000, 1000, 0.5, 1)
-
-    // #then: Should truncate both
-    expect(result.truncatedCount).toBe(2)
-    expect(truncateToolResult).toHaveBeenCalledTimes(2)
-    expect(result.totalBytesRemoved).toBe(200)
-    expect(result.sufficient).toBe(false)
-  })
-})