openhermes 1.5.6 → 1.12.1

package/lib/ohc/pruner.mjs

@@ -0,0 +1,239 @@
+import { tool } from "@opencode-ai/plugin"
+import { loadConfig } from "./config.mjs"
+import { selectMessagesToReap, totalTokens } from "./reaper.mjs"
+import { loadOhcState, saveOhcState } from "./state.mjs"
+
+function buildNudge(pct, max) {
+  if (pct > 0.95) return `[OHC] Context critically high (${Math.round(pct * 100)}% of ${max.toLocaleString()} token budget). Oldest messages will be pruned immediately if limit exceeded. Use the \`compress\` tool now.`
+  if (pct > 0.85) return `[OHC] Context at ${Math.round(pct * 100)}%. Proactive compression recommended. Run \`compress\` to free space.`
+  if (pct > 0.70) return `[OHC] Context at ${Math.round(pct * 100)}% of budget. Consider using \`compress\` to keep room for new content.`
+  return null
+}
+
+function summarizeRemoved(selected, summary) {
+  const n = selected.length
+  if (summary) return `[Compressed: ${summary} — ${n} message${n === 1 ? "" : "s"} removed]`
+  return `[Auto-pruned: ${n} message${n === 1 ? "" : "s"} removed]`
+}
+
+function createSummaryMessage(text) {
+  return { parts: [{ type: "text", text }], info: { role: "system" } }
+}
+
+async function applyCompress(ctx, sessionId, summary, max, min, targetTokens) {
+  const ss = getOrCreateState(sessionId)
+  ss.prunedIds.clear()
+
+  const res = await ctx.client.session.messages({ path: { id: sessionId } })
+  const msgs = res?.data || res || []
+  if (!Array.isArray(msgs)) return { removed: 0, message: "no messages" }
+
+  const selected = selectMessagesToReap(msgs, max, min, "compress", targetTokens)
+  if (selected.length === 0) return { removed: 0, message: "already within target" }
+
+  for (const r of selected) ss.prunedIds.add(r.id)
+  ss.summary = summarizeRemoved(selected, summary)
+  ss.anchorMessageId = selected[0].id
+  saveOhcState(sessionId, {
+    prunedMessageIds: [...ss.prunedIds],
+    summary: ss.summary,
+    anchorMessageId: ss.anchorMessageId,
+  })
+
+  return { removed: selected.length }
+}
+
+const stateCache = new Map()
+
+function getOrCreateState(sessionId) {
+  if (!sessionId) return null
+  let s = stateCache.get(sessionId)
+  if (!s) {
+    const persisted = loadOhcState(sessionId)
+    s = {
+      prunedIds: new Set(persisted?.prunedMessageIds || []),
+      summary: persisted?.summary || null,
+      anchorMessageId: persisted?.anchorMessageId || null,
+      lastNudgePct: 0,
+    }
+    stateCache.set(sessionId, s)
+  }
+  return s
+}
+
+export const OhcPlugin = async (ctx) => {
+  const config = loadConfig()
+  if (!config.enabled) return {}
+
+  const max = config.max
+  const min = config.min
+  if (max <= min + 10000) return {}
+
+  let systemInjected = false
+
+  return {
+    "experimental.chat.system.transform": async (_input, output) => {
+      if (systemInjected || !output.system?.length) return
+      systemInjected = true
+      output.system[output.system.length - 1] += `\n\n## Context Management (OHC)\n- OHC manages all compression. Set \`compaction.auto: false\` in opencode.json to prevent double pruning.\n- Default soft budget: ${max.toLocaleString()} tokens. Soft floor: ${min.toLocaleString()}.\n- These are advisory — the agent can override by passing \`targetTokens\` to the \`compress\` tool.\n- Call \`compress\` with a summary to free context space. Optionally specify \`targetTokens\` (lower = more aggressive).`
+    },
+
+    "experimental.chat.messages.transform": async (_input, output) => {
+      if (!output?.messages?.length) return
+
+      const sessionId = output.messages.find(m => m.info?.sessionID)?.info?.sessionID
+      if (!sessionId) return
+
+      const ss = getOrCreateState(sessionId)
+      if (!ss) return
+
+      if (ss.prunedIds.size > 0) {
+        const currentIds = new Set(output.messages.map(m => m.info?.id).filter(Boolean))
+        if ([...ss.prunedIds].every(id => !currentIds.has(id))) {
+          ss.prunedIds.clear()
+          ss.summary = null
+          ss.anchorMessageId = null
+          saveOhcState(sessionId, {
+            prunedMessageIds: [],
+            summary: null,
+            anchorMessageId: null,
+          })
+        }
+      }
+
+      const currentTotal = totalTokens(output.messages)
+      if (currentTotal > max) {
+        const selected = selectMessagesToReap(output.messages, max, min)
+        if (selected.length > 0) {
+          for (const r of selected) ss.prunedIds.add(r.id)
+          if (!ss.summary) ss.summary = summarizeRemoved(selected, null)
+          if (!ss.anchorMessageId) ss.anchorMessageId = selected[0].id
+          saveOhcState(sessionId, {
+            prunedMessageIds: [...ss.prunedIds],
+            summary: ss.summary,
+            anchorMessageId: ss.anchorMessageId,
+          })
+        }
+      }
+
+      if (ss.prunedIds.size > 0) {
+        const prunedIds = ss.prunedIds
+        const summary = ss.summary
+        const anchorId = ss.anchorMessageId
+        const result = []
+        let injected = false
+
+        for (const msg of output.messages) {
+          const msgId = msg.info?.id
+
+          if (anchorId && msgId === anchorId && !injected && summary) {
+            result.push(createSummaryMessage(summary))
+            injected = true
+          }
+
+          if (msgId !== undefined && prunedIds.has(msgId)) continue
+
+          result.push(msg)
+        }
+
+        if (!injected && summary && result.length > 1) {
+          result.splice(1, 0, createSummaryMessage(summary))
+        }
+
+        output.messages.length = 0
+        output.messages.push(...result)
+      }
+
+      const afterTotal = totalTokens(output.messages)
+      const pct = afterTotal / max
+      const nudge = buildNudge(pct, max)
+      if (nudge && pct > ss.lastNudgePct + 0.05) {
+        ss.lastNudgePct = pct
+        for (let i = output.messages.length - 1; i >= 0; i--) {
+          const m = output.messages[i]
+          if (m.info?.role === "assistant" && m.parts?.length) {
+            const textPart = m.parts.find(p => p.type === "text")
+            if (textPart) { textPart.text += "\n\n" + nudge; break }
+          }
+        }
+      }
+    },
+
+    "command.execute.before": async (input, output) => {
+      if (input.command !== "ohc") return
+      const sub = (input.arguments || "").trim().toLowerCase()
+      const args = (input.arguments || "").trim()
+
+      if (sub === "status") {
+        let msgs = [], t = 0
+        try {
+          if (ctx?.client?.session?.messages) {
+            const res = await ctx.client.session.messages({ path: { id: input.sessionID } })
+            msgs = res?.data || res || []
+            t = totalTokens(msgs)
+          }
+        } catch {}
+        const ss = getOrCreateState(input.sessionID)
+        const prunedCount = ss?.prunedIds.size || 0
+        const text = `[OHC Status] ${msgs.length} messages visible (${prunedCount} pruned), ~${Math.round(t / 1000)}K / ${max.toLocaleString()} tokens (${Math.round((t / max) * 100)}%). Soft floor: ${min.toLocaleString()}.`
+        await ctx.client.session.prompt({
+          path: { id: input.sessionID },
+          body: { noReply: true, parts: [{ type: "text", text, ignored: true }] },
+        })
+        throw new Error("__OHC_STATUS_HANDLED__")
+      }
+
+      if (sub.startsWith("compress")) {
+        const rest = args.replace(/^compress\s*/i, "").trim()
+        const numMatch = rest.match(/^(\d+)\s*(.*)/)
+        let targetTokens
+        let focus
+        if (numMatch) {
+          targetTokens = parseInt(numMatch[1], 10)
+          focus = numMatch[2].trim() || "Manual compression by user"
+        } else {
+          focus = rest || "Manual compression by user"
+        }
+        try {
+          const result = await applyCompress(ctx, input.sessionID, focus, max, min, targetTokens)
+          output.parts.length = 0
+          output.parts.push({
+            type: "text",
+            text: `[OHC] Compressed: ${result.removed} messages removed. Summary: ${focus}`,
+          })
+        } catch {
+          output.parts.length = 0
+          output.parts.push({ type: "text", text: `/ohc compress ${focus}` })
+        }
+        return
+      }
+
+      const text = "OHC commands: /ohc status — /ohc compress [targetTokens] [focus description]"
+      await ctx.client.session.prompt({
+        path: { id: input.sessionID },
+        body: { noReply: true, parts: [{ type: "text", text, ignored: true }] },
+      })
+      throw new Error("__OHC_HELP_HANDLED__")
+    },
+
+    tool: {
+      compress: tool({
+        description: "Proactively compress old conversation content to free context space. Provide a technical summary of what was removed. Optionally specify targetTokens to control how much to keep (lower = more aggressive).",
+        args: {
+          summary: tool.schema.string().describe("Technical summary of the compressed content. Include what was removed and key decisions preserved."),
+          targetTokens: tool.schema.number().optional().describe("Estimated target after compression (heuristic, not exact). Lower = more aggressive. Default uses soft config floor."),
+        },
+        async execute(args, toolCtx) {
+          const result = await applyCompress(ctx, toolCtx.sessionID, args.summary, max, min, args.targetTokens)
+          toolCtx.metadata({ title: "Compress" })
+          return `Compressed: ${result.removed} messages removed. Summary: "${truncateText(args.summary, 200)}"`
+        },
+      }),
+    },
+  }
+}
+
+function truncateText(s, n) {
+  if (!s || s.length <= n) return s || ""
+  return s.slice(0, n) + "..."
+}

package/lib/ohc/reaper.mjs

@@ -0,0 +1,61 @@
+function partTokens(part) {
+  if (part.type === "text") return Math.ceil((part.text || "").length / 4)
+  if (part.type === "tool") {
+    let t = 0
+    if (part.state?.input) t += JSON.stringify(part.state.input).length / 4
+    if (part.state?.output)
+      t += (typeof part.state.output === "string" ? part.state.output : JSON.stringify(part.state.output ?? "")).length / 4
+    return Math.ceil(t)
+  }
+  return Math.ceil(JSON.stringify(part).length / 4)
+}
+
+function msgTokens(msg) {
+  return (Array.isArray(msg.parts) ? msg.parts : []).reduce((s, p) => s + partTokens(p), 0)
+}
+
+export function totalTokens(messages) {
+  return (Array.isArray(messages) ? messages : []).reduce((s, m) => s + msgTokens(m), 0)
+}
+
+/**
+ * Select oldest messages to remove.
+ * Returns array of { id, msg, tokens } without mutating the input.
+ * Never removes index 0 (system prompt) or the last message (latest turn).
+ *
+ * mode "auto":          remove just enough to bring total under maxLimit
+ * mode "compress":      remove everything down to floor (deep prune)
+ *
+ * targetOverride: when set, replaces floor/minFloor — agent explicit request
+ *   overrides the soft config defaults. Used when user asks "compress to X".
+ */
+export function selectMessagesToReap(messages, maxLimit, minFloor, mode = "auto", targetOverride) {
+  if (!messages?.length || messages.length < 3) return []
+
+  let total = totalTokens(messages)
+  const selected = []
+
+  if (mode === "compress") {
+    const floor = targetOverride ?? minFloor
+    let i = 1
+    while (i < messages.length - 1) {
+      const t = msgTokens(messages[i])
+      if (total - t < floor) break
+      total -= t
+      selected.push({ id: String(messages[i].info?.id ?? i), msg: messages[i], tokens: t })
+      i++
+    }
+  } else {
+    const floor = targetOverride ?? minFloor
+    let i = 1
+    while (i < messages.length - 1 && total > maxLimit) {
+      const t = msgTokens(messages[i])
+      if (total - t < floor) break
+      total -= t
+      selected.push({ id: String(messages[i].info?.id ?? i), msg: messages[i], tokens: t })
+      i++
+    }
+  }
+
+  return selected
+}

package/lib/ohc/state.mjs

@@ -0,0 +1,32 @@
+import fs from "node:fs"
+import path from "node:path"
+import os from "node:os"
+
+const STATE_DIR = path.join(os.homedir(), ".local", "share", "opencode")
+const STATE_FILE = path.join(STATE_DIR, "ohc-state.json")
+
+function readAll() {
+  try {
+    return JSON.parse(fs.readFileSync(STATE_FILE, "utf8"))
+  } catch {
+    return {}
+  }
+}
+
+function writeAll(data) {
+  fs.mkdirSync(STATE_DIR, { recursive: true })
+  fs.writeFileSync(STATE_FILE, JSON.stringify(data, null, 2), "utf8")
+}
+
+export function loadOhcState(sessionId) {
+  if (!sessionId) return null
+  const all = readAll()
+  return all[sessionId] || null
+}
+
+export function saveOhcState(sessionId, data) {
+  if (!sessionId) return
+  const all = readAll()
+  all[sessionId] = { ...data, updatedAt: new Date().toISOString() }
+  writeAll(all)
+}

package/lib/ohc/updater.mjs

@@ -0,0 +1,110 @@
+import fs from "node:fs"
+import path from "node:path"
+import os from "node:os"
+
+const CONFIG_PATH = path.join(os.homedir(), ".config", "opencode", "opencode.json")
+const CACHE_ROOT = path.join(os.homedir(), ".cache", "opencode", "packages")
+
+function detectInstallMethod() {
+  let raw = {}
+  try {
+    raw = JSON.parse(fs.readFileSync(CONFIG_PATH, "utf8"))
+  } catch {
+    return { method: "unknown", entry: null, reason: `cannot read ${CONFIG_PATH}` }
+  }
+
+  const plugins = Array.isArray(raw.plugin) ? raw.plugin : []
+  for (const p of plugins) {
+    const entry = typeof p === "string" ? p : (Array.isArray(p) && typeof p[0] === "string" ? p[0] : "")
+    if (!entry.startsWith("openhermes")) continue
+
+    if (entry.includes("@git+https://") || entry.includes("@git+ssh://")) {
+      const repoUrl = entry.replace(/^openhermes@/, "")
+      return { method: "git", entry, repoUrl }
+    }
+
+    if (entry === "openhermes") {
+      return { method: "npm", entry }
+    }
+
+    return { method: "other", entry, reason: `unrecognized format: ${entry}` }
+  }
+
+  return { method: "unknown", entry: null, reason: "openhermes not found in plugin config" }
+}
+
+function findCacheDirs() {
+  const results = []
+  if (!fs.existsSync(CACHE_ROOT)) return results
+  try {
+    for (const e of fs.readdirSync(CACHE_ROOT)) {
+      const full = path.join(CACHE_ROOT, e)
+      if (e.startsWith("openhermes") && fs.statSync(full).isDirectory()) {
+        results.push({ name: e, path: full })
+      }
+    }
+  } catch {}
+  return results
+}
+
+async function handleUpdateMe(ctx, input, output) {
+  const info = detectInstallMethod()
+
+  if (info.method === "unknown") {
+    output.parts.length = 0
+    output.parts.push({
+      type: "text",
+      text: `[Update-Me] Could not detect installation method.\n${info.reason}\n\nEnsure 'openhermes' is in your opencode.json plugin list:\n  https://github.com/nathwn12/openhermes#setup`,
+    })
+    return
+  }
+
+  const cacheDirs = findCacheDirs()
+
+  if (cacheDirs.length === 0) {
+    output.parts.length = 0
+    output.parts.push({
+      type: "text",
+      text: `[Update-Me] No cached version found. Already at the latest (method: ${info.method}). Restart OpenCode if you suspect a stale install.`,
+    })
+    return
+  }
+
+  const deleted = []
+  const failed = []
+  for (const dir of cacheDirs) {
+    try {
+      fs.rmSync(dir.path, { recursive: true, force: true })
+      deleted.push(dir.name)
+    } catch (e) {
+      failed.push({ name: dir.name, error: e.message })
+    }
+  }
+
+  output.parts.length = 0
+  let msg = `[Update-Me] OpenHermes update (${info.method})\n`
+
+  if (deleted.length > 0) {
+    msg += `\nCleared:\n`
+    for (const d of deleted) msg += `  ✓ ${d}\n`
+  }
+
+  if (failed.length > 0) {
+    msg += `\n⚠ Could not remove (file may be locked):\n`
+    for (const f of failed) msg += `  ✗ ${f.name} — ${f.error}\n`
+    msg += `Try deleting manually:\n  ${CACHE_ROOT}\n`
+  }
+
+  msg += `\nRestart OpenCode to load the latest OpenHermes from ${info.method === "git" ? "git HEAD" : "npm registry"}.`
+
+  output.parts.push({ type: "text", text: msg })
+}
+
+export function UpdaterPlugin(ctx) {
+  return {
+    "command.execute.before": async (input, output) => {
+      if (input.command !== "update-me") return
+      await handleUpdateMe(ctx, input, output)
+    },
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openhermes",
-  "version": "1.5.6",
+  "version": "1.12.1",
   "description": "OpenHermes plugin suite for OpenCode — autonomous checkpointing, native memory tools, subagent routing, slash commands, and skill-candidate detection.",
   "type": "module",
   "license": "MIT",

package/skill-builder.mjs

@@ -1,13 +1,9 @@
 import path from "node:path"
 import fs from "node:fs"
 import os from "node:os"
-import { atomicWriteJson, fingerprintEnvironment, isTruthy, sanitizeRecord } from "./lib/hardening.mjs"
+import { atomicWriteJson, fingerprintEnvironment, readJson, sanitizeRecord } from "./lib/hardening.mjs"
 import { getConfigRoot, getDataRoot, getMemoryRoot } from "./lib/paths.mjs"
 
-function readJson(fp, fallback) {
-  try { return JSON.parse(fs.readFileSync(fp, "utf8")) } catch { return fallback }
-}
-
 function buildEnvironmentFingerprint(root, directory, project) {
   return fingerprintEnvironment({
     cwd: directory,
@@ -94,7 +90,7 @@ export const SkillBuilderPlugin = async ({ project, directory }) => {
             })
             atomicWriteJson(path.join(dir, "index.json"), index)
 
-          } catch (err) {}
+          } catch (err) { process.stderr.write(`[skill-builder] backlog write error: ${err?.message || err}\n`) }
         }
         sessionStats = { toolCalls: 0, subagents: 0, startTime: Date.now() }
       }