openhermes 1.13.1 → 2.5.0

package/lib/ohc/config.mjs

@@ -2,29 +2,185 @@ import fs from "node:fs"
 import path from "node:path"
 import os from "node:os"
 
-const CONFIG_PATH = path.join(os.homedir(), ".config", "opencode", "ohc.json")
+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, max: 200000, min: 50000 }
+const DEFAULTS = {
+  enabled: true,
+  notification: "chat",
+  notificationMode: "detailed",
+  max: 150000,
+  min: 50000,
+  manualMode: { enabled: false, automaticStrategies: true },
+  turnProtection: { enabled: false, turns: 4 },
+  protectedFilePatterns: [],
+  compress: {
+    maxContextLimit: 150000,
+    minContextLimit: 50000,
+    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 writeDefaults() {
-  try {
-    fs.mkdirSync(path.dirname(CONFIG_PATH), { recursive: true })
-    fs.writeFileSync(CONFIG_PATH, JSON.stringify(DEFAULTS, null, 2) + "\n", "utf8")
-  } catch {}
+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
 }
 
-export function loadConfig() {
-  let raw = {}
+function loadFile(filePath) {
   try {
-    raw = JSON.parse(fs.readFileSync(CONFIG_PATH, "utf8"))
+    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 {
-    writeDefaults()
-    return { ...DEFAULTS }
+    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 {
+    maxContextLimit: override.maxContextLimit ?? base.maxContextLimit,
+    minContextLimit: override.minContextLimit ?? base.minContextLimit,
+    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: raw.enabled !== false,
-    max: typeof raw.max === "number" && raw.max > 0 ? raw.max : DEFAULTS.max,
-    min: typeof raw.min === "number" ? Math.max(10000, raw.min) : DEFAULTS.min,
+    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
+
+  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

@@ -0,0 +1,168 @@
+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 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

@@ -0,0 +1,150 @@
+function formatTokenCount(tokens) {
+  if (tokens >= 1000) return `${(tokens / 1000).toFixed(1)}K`.replace(".0K", "K")
+  return String(tokens)
+}
+
+function buildProgressBar(prunedCount, visibleCount, width) {
+  width = width || 30
+  const total = prunedCount + visibleCount
+  if (total === 0) return `\u2502${"\u2591".repeat(width)}\u2502  0% active`
+  const activeRatio = visibleCount / total
+  const activeW = Math.round(activeRatio * width)
+  const prunedW = width - activeW
+  const bar = "\u2588".repeat(Math.min(activeW, width)) + "\u2591".repeat(Math.min(prunedW, width))
+  return `\u2502${bar.slice(0, width)}\u2502  ${Math.round(activeRatio * 100)}% active`
+}
+
+function buildMinimal(count, tokensRemoved, savedTotal, blockCount) {
+  const label = "Compression"
+  return `\u25A3 OHC | ~${formatTokenCount(savedTotal)} saved total \u2014 ${label}`
+}
+
+function buildDetailed(count, tokensRemoved, savedTotal, blockCount, prunedCount, visibleCount, summary) {
+  const label = "Compression"
+  let msg = `\u25A3 OHC | ~${formatTokenCount(savedTotal)} saved total`
+  if (prunedCount + visibleCount > 0) {
+    msg += `\n\n${buildProgressBar(prunedCount, visibleCount)}`
+  }
+  msg += `\n\n\u25A3 ${label} #${blockCount}`
+  msg += `\n\u2192 ${count} message${count === 1 ? "" : "s"} removed`
+  if (summary) msg += `\n\u2192 Summary: ${summary}`
+  return msg
+}
+
+function buildStrategyNotification(strategy, count, detail) {
+  return `\u25A3 OHC | ${strategy}: ${count} pruned${detail ? ` (${detail})` : ""}`
+}
+
+export async function sendCompressNotification(client, sessionId, config, count, summary, tokensRemoved, savedTotal, blockCount, prunedCount, visibleCount) {
+  if (count === 0) return false
+
+  const notifType = config.notification ?? "toast"
+  const notifMode = config.notificationMode ?? "minimal"
+
+  if (notifType === "off") return false
+
+  if (notifType === "toast") {
+    const message = notifMode === "minimal"
+      ? buildMinimal(count, tokensRemoved, savedTotal, blockCount)
+      : buildDetailed(count, tokensRemoved, savedTotal, blockCount, prunedCount, visibleCount, summary)
+    try {
+      await client.tui.showToast({
+        body: {
+          title: "OHC: Compression",
+          message,
+          variant: "info",
+          duration: 5000,
+        },
+      })
+    } catch {}
+    return true
+  }
+
+  try {
+    await client.session.prompt({
+      path: { id: sessionId },
+      body: {
+        noReply: true,
+        parts: [{ type: "text", text: buildDetailed(count, tokensRemoved, savedTotal, blockCount, prunedCount, visibleCount, summary), ignored: true }],
+      },
+    })
+  } catch {}
+  return true
+}
+
+export async function sendStrategyNotification(client, sessionId, config, strategy, count, detail) {
+  if (count === 0) return false
+  const notifType = config.notification ?? "toast"
+  if (notifType === "off") return false
+
+  const message = buildStrategyNotification(strategy, count, detail)
+
+  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: message, ignored: true }],
+      },
+    })
+  } catch {}
+  return true
+}
+
+export async function sendMemoryNotification(client, sessionId, config, action, cls, id, summary) {
+  const notifType = config.notification ?? "toast"
+  const notifMode = config.notificationMode ?? "minimal"
+
+  if (notifType === "off") return false
+
+  const buildHeader = (action, summary) => `[Memory] ${summary}`
+  const buildDetailed = (action, cls, id, summary) => {
+    let msg = `\u25A3 Memory ${action}`
+    if (cls) msg += `\n\u2192 Class: ${cls}`
+    if (id) msg += `\n\u2192 ID: ${id}`
+    if (summary) msg += `\n\u2192 ${summary}`
+    return msg
+  }
+
+  if (notifType === "toast") {
+    const message = notifMode === "minimal"
+      ? buildHeader(action, summary)
+      : buildDetailed(action, cls, id, summary)
+    try {
+      await client.tui.showToast({
+        body: {
+          title: "Memory",
+          message,
+          variant: "info",
+          duration: 4000,
+        },
+      })
+    } catch {}
+    return true
+  }
+
+  try {
+    await client.session.prompt({
+      path: { id: sessionId },
+      body: {
+        noReply: true,
+        parts: [{ type: "text", text: buildDetailed(action, cls, id, summary), ignored: true }],
+      },
+    })
+  } catch {}
+  return true
+}

package/lib/ohc/protected-patterns.mjs

@@ -0,0 +1,54 @@
+const DEFAULT_PROTECTED_TOOLS = new Set([
+  "task", "skill", "todowrite", "todoread",
+  "compress", "batch", "plan_enter", "plan_exit",
+  "write", "edit",
+])
+
+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, ".")
+  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
+  })
+}