openhermes 2.8.0 → 4.0.0

package/lib/ohc/config.mjs

@@ -1,185 +0,0 @@
-import fs from "node:fs"
-import path from "node:path"
-import os from "node:os"
-
-const GLOBAL_DIR = path.join(os.homedir(), ".config", "opencode")
-const GLOBAL_PATH = path.join(GLOBAL_DIR, "ohc.json")
-const GLOBAL_PATH_JSONC = path.join(GLOBAL_DIR, "ohc.jsonc")
-
-const DEFAULTS = {
-  enabled: true,
-  notification: "chat",
-  notificationMode: "detailed",
-  max: 150000,
-  min: 50000,
-  manualMode: { enabled: false, automaticStrategies: true },
-  turnProtection: { enabled: false, turns: 4 },
-  protectedFilePatterns: [],
-  compress: {
-
-    nudgeFrequency: 5,
-    iterationNudgeThreshold: 15,
-    nudgeForce: "soft",
-    protectedTools: ["task", "skill", "todowrite", "todoread"],
-    protectUserMessages: false,
-    summaryBuffer: true,
-  },
-  strategies: {
-    deduplication: { enabled: true, protectedTools: [] },
-    purgeErrors: { enabled: true, turns: 4, protectedTools: [] },
-  },
-}
-
-function findOpencodeDir(startDir) {
-  let current = startDir
-  while (current && current.length > 3) {
-    const candidate = path.join(current, ".opencode")
-    if (fs.existsSync(candidate) && fs.statSync(candidate).isDirectory()) {
-      return candidate
-    }
-    const parent = path.dirname(current)
-    if (parent === current) break
-    current = parent
-  }
-  return null
-}
-
-function loadFile(filePath) {
-  try {
-    const content = fs.readFileSync(filePath, "utf8").trim()
-    if (!content) return null
-    if (filePath.endsWith(".jsonc")) {
-      const stripped = content
-        .replace(/"(?:[^"\\]|\\.)*"|\/\/.*/gm, m => m.startsWith('"') ? m : "")
-        .replace(/\/\*[\s\S]*?\*\//g, "")
-      return JSON.parse(stripped)
-    }
-    return JSON.parse(content)
-  } catch {
-    return null
-  }
-}
-
-function mergeDeep(base, override) {
-  if (!override || typeof override !== "object") return base
-  const result = { ...base }
-  for (const key of Object.keys(override)) {
-    if (override[key] === undefined) continue
-    if (typeof override[key] === "object" && !Array.isArray(override[key]) && override[key] !== null) {
-      result[key] = mergeDeep(base[key] || {}, override[key])
-    } else {
-      result[key] = override[key]
-    }
-  }
-  return result
-}
-
-function mergeArrays(base, override) {
-  if (!override || !Array.isArray(override)) return base
-  return [...new Set([...base, ...override])]
-}
-
-function mergeManualMode(base, override) {
-  if (!override || typeof override !== "object") return base
-  return {
-    enabled: override.enabled ?? base.enabled,
-    automaticStrategies: override.automaticStrategies ?? base.automaticStrategies,
-  }
-}
-
-function mergeTurnProtection(base, override) {
-  if (!override || typeof override !== "object") return base
-  return {
-    enabled: override.enabled ?? base.enabled,
-    turns: override.turns ?? base.turns,
-  }
-}
-
-function mergeCompress(base, override) {
-  if (!override || typeof override !== "object") return base
-  return {
-    nudgeFrequency: override.nudgeFrequency ?? base.nudgeFrequency,
-    iterationNudgeThreshold: override.iterationNudgeThreshold ?? base.iterationNudgeThreshold,
-    nudgeForce: override.nudgeForce ?? base.nudgeForce,
-    protectedTools: mergeArrays(base.protectedTools, override.protectedTools),
-    protectUserMessages: override.protectUserMessages ?? base.protectUserMessages,
-    summaryBuffer: override.summaryBuffer ?? base.summaryBuffer,
-  }
-}
-
-function mergeStrategies(base, override) {
-  if (!override || typeof override !== "object") return base
-  return {
-    deduplication: {
-      enabled: override.deduplication?.enabled ?? base.deduplication.enabled,
-      protectedTools: mergeArrays(base.deduplication.protectedTools, override.deduplication?.protectedTools),
-    },
-    purgeErrors: {
-      enabled: override.purgeErrors?.enabled ?? base.purgeErrors.enabled,
-      turns: override.purgeErrors?.turns ?? base.purgeErrors.turns,
-      protectedTools: mergeArrays(base.purgeErrors.protectedTools, override.purgeErrors?.protectedTools),
-    },
-  }
-}
-
-function mergeLayer(base, data) {
-  if (!data) return base
-  return {
-    enabled: data.enabled ?? base.enabled,
-    notification: data.notification ?? base.notification,
-    notificationMode: data.notificationMode ?? base.notificationMode,
-    max: data.max ?? base.max,
-    min: data.min ?? base.min,
-    manualMode: mergeManualMode(base.manualMode, data.manualMode),
-    turnProtection: mergeTurnProtection(base.turnProtection, data.turnProtection),
-    protectedFilePatterns: mergeArrays(base.protectedFilePatterns, data.protectedFilePatterns),
-    compress: mergeCompress(base.compress, data.compress),
-    strategies: mergeStrategies(base.strategies, data.strategies),
-  }
-}
-
-export function loadConfig(ctx) {
-  let config = { ...DEFAULTS }
-
-  const layers = [
-    { path: fs.existsSync(GLOBAL_PATH_JSONC) ? GLOBAL_PATH_JSONC : (fs.existsSync(GLOBAL_PATH) ? GLOBAL_PATH : null), name: "global" },
-  ]
-
-  const opencodeConfigDir = process.env.OPENCODE_CONFIG_DIR
-  if (opencodeConfigDir) {
-    const cdJsonc = path.join(opencodeConfigDir, "ohc.jsonc")
-    const cdJson = path.join(opencodeConfigDir, "ohc.json")
-    const cdPath = fs.existsSync(cdJsonc) ? cdJsonc : (fs.existsSync(cdJson) ? cdJson : null)
-    if (cdPath) layers.push({ path: cdPath, name: "configDir" })
-  }
-
-  if (ctx?.directory) {
-    const opencodeDir = findOpencodeDir(ctx.directory)
-    if (opencodeDir) {
-      const pjJsonc = path.join(opencodeDir, "ohc.jsonc")
-      const pjJson = path.join(opencodeDir, "ohc.json")
-      const pjPath = fs.existsSync(pjJsonc) ? pjJsonc : (fs.existsSync(pjJson) ? pjJson : null)
-      if (pjPath) layers.push({ path: pjPath, name: "project" })
-    }
-  }
-
-  for (const layer of layers) {
-    if (!layer.path) continue
-    const data = loadFile(layer.path)
-    if (data) config = mergeLayer(config, data)
-  }
-
-  config.max = typeof config.max === "number" && config.max > 0 ? config.max : DEFAULTS.max
-  config.min = typeof config.min === "number" ? Math.max(10000, Math.min(config.min, config.max - 10000)) : DEFAULTS.min
-
-  try { writeDefaults() } catch { /* best-effort */ }
-
-  return config
-}
-
-function writeDefaults() {
-  fs.mkdirSync(GLOBAL_DIR, { recursive: true })
-  if (!fs.existsSync(GLOBAL_PATH) && !fs.existsSync(GLOBAL_PATH_JSONC)) {
-    fs.writeFileSync(GLOBAL_PATH, JSON.stringify(DEFAULTS, null, 2) + "\n", "utf8")
-  }
-}

package/lib/ohc/message-ids.mjs

@@ -1,178 +0,0 @@
-const MESSAGE_REF_REGEX = /^ohc(\d{4})$/
-const BLOCK_REF_REGEX = /^bk([1-9]\d*)$/
-const OHCTAG = "ohc-ref"
-
-export function formatMessageRef(index) {
-  if (!Number.isInteger(index) || index < 1 || index > 9999) {
-    throw new Error(`OHC ref index out of bounds: ${index}`)
-  }
-  return `ohc${index.toString().padStart(4, "0")}`
-}
-
-export function formatBlockRef(blockId) {
-  if (!Number.isInteger(blockId) || blockId < 1) {
-    throw new Error(`Invalid block ID: ${blockId}`)
-  }
-  return `bk${blockId}`
-}
-
-export function parseMessageRef(ref) {
-  const m = (ref || "").trim().toLowerCase().match(MESSAGE_REF_REGEX)
-  if (!m) return null
-  const idx = parseInt(m[1], 10)
-  return Number.isInteger(idx) && idx >= 1 && idx <= 9999 ? idx : null
-}
-
-export function parseBlockRef(ref) {
-  const m = (ref || "").trim().toLowerCase().match(BLOCK_REF_REGEX)
-  if (!m) return null
-  const id = parseInt(m[1], 10)
-  return Number.isInteger(id) ? id : null
-}
-
-export function parseBoundaryId(id) {
-  const norm = (id || "").trim().toLowerCase()
-  const msgIdx = parseMessageRef(norm)
-  if (msgIdx !== null) {
-    return { kind: "message", ref: formatMessageRef(msgIdx), index: msgIdx }
-  }
-  const bkId = parseBlockRef(norm)
-  if (bkId !== null) {
-    return { kind: "compressed-block", ref: formatBlockRef(bkId), blockId: bkId }
-  }
-  return null
-}
-
-function escapeXml(s) {
-  return String(s).replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;")
-}
-
-export function formatOhcTag(ref, attrs) {
-  const serialized = Object.entries(attrs || {})
-    .filter(([, v]) => typeof v === "string" && v.length > 0)
-    .sort(([a], [b]) => a.localeCompare(b))
-    .map(([k, v]) => ` ${k}="${escapeXml(v)}"`)
-    .join("")
-  return `\n<${OHCTAG}${serialized}>${ref}</${OHCTAG}>`
-}
-
-export function isIgnoredUserMessage(message) {
-  if (!message?.info || message.info.role !== "user") return false
-  const parts = Array.isArray(message.parts) ? message.parts : []
-  if (parts.length === 0) return true
-  return parts.every(p => p.ignored)
-}
-
-export function assignMessageRefs(state, messages) {
-  let assigned = 0
-  let skippedFirstUser = false
-
-  for (const msg of messages) {
-    if (isIgnoredUserMessage(msg)) continue
-
-    if (state.isSubAgent && !skippedFirstUser && msg.info.role === "user") {
-      skippedFirstUser = true
-      continue
-    }
-
-    const rawId = msg.info?.id
-    if (typeof rawId !== "string" || !rawId) continue
-
-    const existing = state.messageIds.byRawId.get(rawId)
-    if (existing) {
-      if (state.messageIds.byRef.get(existing) !== rawId) {
-        state.messageIds.byRef.set(existing, rawId)
-      }
-      continue
-    }
-
-    const ref = allocateNextRef(state)
-    state.messageIds.byRawId.set(rawId, ref)
-    state.messageIds.byRef.set(ref, rawId)
-    assigned++
-  }
-
-  return assigned
-}
-
-function allocateNextRef(state) {
-  let candidate = Number.isInteger(state.messageIds.nextRef)
-    ? Math.max(1, state.messageIds.nextRef)
-    : 1
-
-  for (let attempt = 0; attempt < 9999; attempt++) {
-    if (candidate > 9999) candidate = 1
-    const ref = formatMessageRef(candidate)
-    if (!state.messageIds.byRef.has(ref)) {
-      state.messageIds.nextRef = candidate + 1
-      return ref
-    }
-    candidate++
-  }
-
-  state.messageIds.nextRef = 1
-  return formatMessageRef(1)
-}
-
-export function cleanupMessageRefs(state, removedRawIds) {
-  for (const rawId of removedRawIds) {
-    const ref = state.messageIds.byRawId.get(rawId)
-    if (ref) {
-      state.messageIds.byRawId.delete(rawId)
-      state.messageIds.byRef.delete(ref)
-    }
-  }
-}
-
-export function injectMessageIds(state, messages) {
-  for (const msg of messages) {
-    if (isIgnoredUserMessage(msg)) continue
-    const msgRef = state.messageIds.byRawId.get(msg.info?.id)
-    if (!msgRef) continue
-    const tag = formatOhcTag(msgRef)
-
-    if (msg.info.role === "user") {
-      let injected = false
-      for (const part of msg.parts) {
-        if (part.type === "text") {
-          part.text += tag
-          injected = true
-          break
-        }
-      }
-      if (!injected) {
-        msg.parts.push({ type: "text", text: tag })
-      }
-      continue
-    }
-
-    if (msg.info.role !== "assistant") continue
-
-    let hasContent = Array.isArray(msg.parts) && msg.parts.some(p => p.type === "text" || p.type === "tool")
-    if (!hasContent) continue
-
-    let injected = false
-    for (const part of msg.parts) {
-      if (part.type !== "tool" || typeof part.state?.output !== "string") continue
-      part.state.output = (part.state.output || "") + tag
-      injected = true
-      break
-    }
-
-    if (injected) continue
-
-    const lastText = [...msg.parts].reverse().find(p => p.type === "text")
-    if (lastText) {
-      lastText.text += tag
-      continue
-    }
-
-    const firstToolIdx = msg.parts.findIndex(p => p.type === "tool")
-    const synth = { type: "text", text: tag }
-    if (firstToolIdx === -1) {
-      msg.parts.push(synth)
-    } else {
-      msg.parts.splice(firstToolIdx, 0, synth)
-    }
-  }
-}

package/lib/ohc/notify.mjs

@@ -1,135 +0,0 @@
-function formatTokenCount(tokens) {
-  if (tokens >= 1_000_000) return `${(tokens / 1_000_000).toFixed(1)}M`.replace(".0M", "M")
-  if (tokens >= 1000) return `${(tokens / 1000).toFixed(1)}K`.replace(".0K", "K")
-  return String(tokens)
-}
-
-function truncate(str, max) {
-  if (!str) return ""
-  return str.length > max ? str.slice(0, max) + "\u2026" : str
-}
-
-function buildCompressionDetailed(count, savedTotal, blockCount, summary) {
-  const parts = [
-    `${formatTokenCount(savedTotal)} saved \u00b7 ${count} msg${count === 1 ? "" : "s"} removed \u00b7 #${blockCount} block${blockCount === 1 ? "" : "s"}`,
-  ]
-  if (summary) parts.push(truncate(summary, 48))
-  return parts.join("\n")
-}
-
-function buildCompressionMinimal(count, savedTotal, blockCount) {
-  return `${formatTokenCount(savedTotal)} saved \u00b7 ${blockCount} block${blockCount === 1 ? "" : "s"} \u00b7 ${count} msg${count === 1 ? "" : "s"} removed`
-}
-
-function buildMemoryMessage(action, cls, id, summary) {
-  const idPart = id ? truncate(id, 28) : ""
-  return [action, cls, idPart].filter(Boolean).join(" \u00b7 ")
-}
-
-export async function sendCompressNotification(client, sessionId, config, count, summary, tokensRemoved, ss, currentMessageCount) {
-  if (count === 0) return false
-
-  const savedTotal = ss?.totalTokensSaved || 0
-  const blockCount = ss?.blockCount || 0
-
-  const notifType = config.notification ?? "chat"
-  const notifMode = config.notificationMode ?? "detailed"
-
-  if (notifType === "off") return false
-
-  if (notifType === "toast") {
-    const message = notifMode === "minimal"
-      ? buildCompressionMinimal(count, savedTotal, blockCount)
-      : buildCompressionDetailed(count, savedTotal, blockCount, summary)
-    try {
-      await client.tui.showToast({
-        body: {
-          title: "OHC Compression",
-          message,
-          variant: "info",
-          duration: 5000,
-        },
-      })
-    } catch {}
-    return true
-  }
-
-  const message = notifMode === "minimal"
-    ? buildCompressionMinimal(count, savedTotal, blockCount)
-    : buildCompressionDetailed(count, savedTotal, blockCount, summary)
-  try {
-    await client.session.prompt({
-      path: { id: sessionId },
-      body: {
-        noReply: true,
-        parts: [{ type: "text", text: `OHC: ${message}`, ignored: true }],
-      },
-    })
-  } catch {}
-  return true
-}
-
-export async function sendStrategyNotification(client, sessionId, config, strategy, count, detail) {
-  if (count === 0) return false
-  const notifType = config.notification ?? "chat"
-  if (notifType === "off") return false
-
-  const message = detail ? `${strategy} \u2014 ${count} pruned \u00b7 ${truncate(detail, 36)}` : `${strategy} \u2014 ${count} pruned`
-
-  if (notifType === "toast") {
-    try {
-      await client.tui.showToast({
-        body: {
-          title: "OHC Strategy",
-          message,
-          variant: "info",
-          duration: 3000,
-        },
-      })
-    } catch {}
-    return true
-  }
-
-  try {
-    await client.session.prompt({
-      path: { id: sessionId },
-      body: {
-        noReply: true,
-        parts: [{ type: "text", text: `OHC: ${message}`, ignored: true }],
-      },
-    })
-  } catch {}
-  return true
-}
-
-export async function sendMemoryNotification(client, sessionId, config, action, cls, id, summary) {
-  const notifType = config.notification ?? "toast"
-  if (notifType === "off") return false
-
-  const message = buildMemoryMessage(action, cls, id, summary)
-
-  if (notifType === "toast") {
-    try {
-      await client.tui.showToast({
-        body: {
-          title: "OHC Memory",
-          message,
-          variant: "info",
-          duration: 4000,
-        },
-      })
-    } catch {}
-    return true
-  }
-
-  try {
-    await client.session.prompt({
-      path: { id: sessionId },
-      body: {
-        noReply: true,
-        parts: [{ type: "text", text: `OHC: ${message}`, ignored: true }],
-      },
-    })
-  } catch {}
-  return true
-}

package/lib/ohc/protected-patterns.mjs

@@ -1,55 +0,0 @@
-const DEFAULT_PROTECTED_TOOLS = new Set([
-  "task", "skill", "todowrite", "todoread",
-  "compress", "batch", "plan_enter", "plan_exit",
-  "write", "edit", "bash", "webfetch",
-])
-
-export function isToolNameProtected(toolName, extraProtected = []) {
-  if (DEFAULT_PROTECTED_TOOLS.has(toolName)) return true
-  return extraProtected.includes(toolName)
-}
-
-export function getFilePathsFromParameters(tool, params) {
-  if (!params || typeof params !== "object") return []
-  if (params.filePath) return [params.filePath]
-  if (params.file_path) return [params.file_path]
-  if (params.path) return [params.path]
-  if (params.target) return [params.target]
-  if (params.directory) return [params.directory]
-  if (tool === "glob" && params.pattern) return [params.pattern]
-  return []
-}
-
-export function isFilePathProtected(filePaths, protectedPatterns = []) {
-  if (!protectedPatterns?.length) return false
-  if (!filePaths?.length) return false
-  for (const fp of filePaths) {
-    for (const pattern of protectedPatterns) {
-      if (globMatch(fp, pattern)) return true
-    }
-  }
-  return false
-}
-
-function globMatch(filePath, pattern) {
-  const regexStr = pattern
-    .replace(/[.+^${}()|[\]\\]/g, "\\$&")
-    .replace(/\*\*/g, ".*")
-    .replace(/\*/g, "[^/]*")
-    .replace(/\?/g, ".")
-  try {
-    return new RegExp(`^${regexStr}$`, "i").test(filePath)
-  } catch {
-    return filePath.toLowerCase() === pattern.toLowerCase()
-  }
-}
-
-export function getTurnProtectionTags(state) {
-  const config = state.protectedTurns || {}
-  if (!config.enabled || !config.turns) return []
-  const threshold = state.currentTurn - config.turns
-  return [...state.toolIdList].filter(id => {
-    const entry = state.toolParameters.get(id)
-    return entry && entry.turn > threshold
-  })
-}

package/lib/ohc/prune-apply.mjs

@@ -1,134 +0,0 @@
-const PRUNED_OUTPUT_PLACEHOLDER = "[Output removed — information superseded or no longer needed]"
-const PRUNED_ERROR_INPUT_PLACEHOLDER = "[input removed — failed tool call]"
-const PRUNED_QUESTION_INPUT_PLACEHOLDER = "[questions removed — see output for answers]"
-
-export function applyPruneTools(state, messages) {
-  if (!state.prune.tools.size) return 0
-
-  let prunedCount = 0
-
-  for (const msg of messages) {
-    if (!Array.isArray(msg.parts)) continue
-
-    for (const part of msg.parts) {
-      if (part.type !== "tool" || !part.callID) continue
-      if (!state.prune.tools.has(part.callID)) continue
-
-      prunedCount++
-
-      if (part.state?.status === "completed") {
-        if (part.tool === "question") {
-          if (part.state.input?.questions !== undefined) {
-            part.state.input.questions = PRUNED_QUESTION_INPUT_PLACEHOLDER
-          }
-        } else if (part.tool !== "edit" && part.tool !== "write") {
-          part.state = {
-            ...part.state,
-            output: PRUNED_OUTPUT_PLACEHOLDER,
-          }
-        }
-      }
-
-      if (part.state?.status === "error") {
-        const input = part.state.input
-        if (input && typeof input === "object") {
-          for (const key of Object.keys(input)) {
-            if (typeof input[key] === "string") {
-              input[key] = PRUNED_ERROR_INPUT_PLACEHOLDER
-            }
-          }
-        }
-      }
-    }
-  }
-
-  return prunedCount
-}
-
-export function filterCompressedBlocks(state, messages) {
-  const ms = state.prune?.messages
-  if (!ms || !ms.activeBlockIds?.size || !ms.blocksById?.size) return { removed: 0, injected: 0 }
-
-  const coveredMessageIds = new Set()
-  for (const [rawId, entry] of ms.byMessageId) {
-    const hasActive = Array.isArray(entry.activeBlockIds) && entry.activeBlockIds.some(id => ms.activeBlockIds.has(id))
-    if (hasActive) coveredMessageIds.add(rawId)
-  }
-
-  if (!coveredMessageIds.size) return { removed: 0, injected: 0 }
-
-  const activeBlocks = [...ms.activeBlockIds].map(id => ms.blocksById.get(id)).filter(Boolean)
-  const summaryByAnchor = new Map()
-  for (const block of activeBlocks) {
-    if (block.anchorMessageId && !summaryByAnchor.has(block.anchorMessageId)) {
-      summaryByAnchor.set(block.anchorMessageId, block)
-    }
-  }
-
-  let removed = 0
-  let injected = 0
-  const result = []
-  const blocksDeployed = new Set()
-
-  for (const msg of messages) {
-    const mid = msg.info?.id
-
-    if (mid && coveredMessageIds.has(mid)) {
-      if (!blocksDeployed.has(mid)) {
-        blocksDeployed.add(mid)
-        const block = summaryByAnchor.get(mid)
-        if (block) {
-          result.push({
-            parts: [{ type: "text", text: block.summary }],
-            info: { role: "system" },
-          })
-          injected++
-        }
-      }
-      removed++
-      continue
-    }
-
-    result.push(msg)
-  }
-
-  messages.length = 0
-  messages.push(...result)
-
-  return { removed, injected }
-}
-
-export function applyFullToolRemoval(state, messages) {
-  if (!state.prune.tools.size) return 0
-
-  const removed = []
-
-  for (const msg of messages) {
-    if (!Array.isArray(msg.parts)) continue
-
-    const toRemove = []
-    for (const part of msg.parts) {
-      if (part.type !== "tool" || !part.callID) continue
-      if (!state.prune.tools.has(part.callID)) continue
-      if (part.tool !== "edit" && part.tool !== "write") continue
-      toRemove.push(part.callID)
-    }
-
-    if (!toRemove.length) continue
-
-    const before = msg.parts.length
-    msg.parts = msg.parts.filter(p => p.type !== "tool" || !toRemove.includes(p.callID))
-    const after = msg.parts.length
-    if (after === 0 && before > 0) {
-      removed.push(msg.info.id)
-    }
-  }
-
-  if (removed.length) {
-    const result = messages.filter(m => !removed.includes(m.info.id))
-    messages.length = 0
-    messages.push(...result)
-  }
-
-  return removed.length
-}