@serkanalgur/opencodev2-slim 2.0.4 → 2.0.6

package/README.md

@@ -141,6 +141,15 @@ Note: Compression is performed by the AI assistant using the `compress` tool. Th
 
 ## Changelog
 
+### 2.0.6
+
+- Add real `compaction` hook so history actually shrinks (the `context` hook only affects the outgoing request)
+- Resolve the active model's real context limit instead of hard-coding 200k
+- Register `compress`/`panel` tools with `options.codemode` so they appear in agent/codemode environments
+- Fix token-by-role panel bug where `tools` always equalled zero
+- Replace toast-only CLI panel with a real `session.panel` slot (`slim-panel` / `/panel`)
+- Add regression test for the tool-token bucket
+
 ### 2.0.3
 
 - Fix v2 API compatibility issues

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@serkanalgur/opencodev2-slim",
-  "version": "2.0.4",
+  "version": "2.0.6",
   "description": "Smart context management plugin for OpenCode v2 - semantic compression, cost-aware pruning, adaptive thresholds",
   "keywords": [
     "opencode",
@@ -23,18 +23,21 @@
   "author": "serkanalgur",
   "type": "module",
   "exports": {
-    ".": "./src/index.ts"
+    ".": "./src/index.ts",
+    "./tui": "./src/tui.tsx"
   },
-  "main": "index.js",
+  "main": "./src/index.ts",
   "directories": {
     "test": "tests"
   },
   "files": [
+    "dist/",
     "src/",
     "README.md",
     "LICENSE"
   ],
   "scripts": {
+    "build": "tsc",
     "typecheck": "tsc --noEmit",
     "test": "node --import tsx --test tests/*.ts",
     "format": "prettier --write .",
@@ -58,6 +61,9 @@
     }
   },
   "peerDependencies": {
-    "@opencode/plugin": ">=2.0.0"
+    "@opencode/plugin": ">=2.0.0",
+    "@opentui/core": ">=0.5.8",
+    "@opentui/solid": ">=0.5.8",
+    "solid-js": ">=1.9.0"
   }
 }

package/src/index.ts

@@ -13,12 +13,19 @@ import type { SlimConfig, SessionState, MessageWithParts } from "./lib/types"
 
 // ─── State Management ───────────────────────────────────────────────────────
 
+const DEFAULT_MODEL_LIMIT = 200000
+
 const sessionStates = new Map<string, SessionState>()
 const sessionConfigs = new Map<string, SlimConfig>()
+// Resolved context limit for the active model, per session
+const sessionModelLimits = new Map<string, number>()
 
 function getState(sessionId: string, config: SlimConfig): SessionState {
     if (!sessionStates.has(sessionId)) {
         const state = loadSessionState(sessionId, config.persistence.directory)
+        // Give every fresh state a real model limit when we know it
+        const knownLimit = sessionModelLimits.get(sessionId) || DEFAULT_MODEL_LIMIT
+        state.modelContextLimit = knownLimit
         sessionStates.set(sessionId, state)
     }
     return sessionStates.get(sessionId)!
@@ -28,6 +35,34 @@ function getConfig(sessionId: string): SlimConfig {
     return sessionConfigs.get(sessionId) || loadConfig()
 }
 
+// Resolve the active model's real context limit instead of hard-coding 200k.
+async function resolveModelContextLimit(ctx: any): Promise<number> {
+    try {
+        const models: any[] = await ctx.model.list()
+        const selected: { providerID?: string; modelID?: string } | undefined =
+            await ctx.model.default()
+        const match =
+            models.find(
+                (m) =>
+                    (selected?.modelID && m.id === selected.modelID) ||
+                    (selected?.providerID && m.providerID === selected.providerID),
+            ) ||
+            models.find((m) => m.limit?.context) ||
+            undefined
+        const limit = match?.limit?.context
+        return typeof limit === "number" && limit > 0 ? limit : DEFAULT_MODEL_LIMIT
+    } catch {
+        return DEFAULT_MODEL_LIMIT
+    }
+}
+
+// Compose the exact text used to summarize a transcript (used by compaction).
+function stringifyTranscript(v: unknown): string {
+    // A compact but useful representation of the transcript to be summarized.
+    const text = String(v)
+    return text.length > 4000 ? `${text.slice(0, 4000)}\n…` : text
+}
+
 // ─── Helpers ────────────────────────────────────────────────────────────────
 
 function buildCompressionSummary(messages: MessageWithParts[], focus: string): string {
@@ -103,7 +138,10 @@ export default Plugin.define({
     id: "opencodev2-slim",
     async setup(ctx) {
         createDefaultConfig()
-        const globalConfig = loadConfig()
+
+        // Resolve the active model's real context limit once.
+        // This drives accurate percentage-based thresholds instead of a hard-coded 200k.
+        const initialModelLimit = await resolveModelContextLimit(ctx)
 
         // ─── Register Compress Tool ───────────────────────────────────────
         await ctx.tool.transform((editor) => {
@@ -144,6 +182,7 @@ export default Plugin.define({
                     required: ["focus"],
                     additionalProperties: false,
                 },
+                options: { codemode: true },
                 execute: async (input, context) => {
                     const args = input as {
                         focus: string
@@ -254,6 +293,7 @@ export default Plugin.define({
                     properties: {},
                     additionalProperties: false,
                 },
+                options: { codemode: true },
                 execute: async (_input, context) => {
                     const sessionId = context.sessionID
                     const config = getConfig(sessionId)
@@ -295,7 +335,8 @@ export default Plugin.define({
             if (!config.enabled || !config.compress.enabled) return
 
             const state = getState(sessionId, config)
-            state.modelContextLimit = 200000 // default; updated by tool calls
+            // Use the resolved real model limit, falling back to a sane default.
+            state.modelContextLimit = sessionModelLimits.get(sessionId) || initialModelLimit
 
             event.system.push({ type: "text", text: getSystemPrompt() })
         })
@@ -307,18 +348,23 @@ export default Plugin.define({
             if (!config.enabled) return
 
             const state = getState(sessionId, config)
-
-            // Apply pruning strategies
-            const pruned = pruneMessages(
-                event.messages.map((m: any) => wrapAsMessageWithParts(m)),
-                config,
-                event.messages.length,
-            )
-
-            // Replace messages in-place
-            event.messages.length = 0
-            for (const msg of pruned) {
-                event.messages.push(msg as any)
+            state.modelContextLimit = sessionModelLimits.get(sessionId) || initialModelLimit
+
+            // Apply pruning - work with original OpenCode message format
+            // event.messages contains { role, content: Part[], ... } objects
+            const wrapped = event.messages.map((m: any) => wrapAsMessageWithParts(m))
+            const pruned = pruneMessages(wrapped, config, event.messages.length)
+
+            // Build a Set of pruned message IDs to keep
+            const keepIds = new Set(pruned.map((m) => m.info.id))
+
+            // Remove duplicates in-place, preserving OpenCode's message format
+            for (let i = event.messages.length - 1; i >= 0; i--) {
+                const msg = event.messages[i] as any
+                const id = msg.id || msg.info?.id
+                if (id && !keepIds.has(id)) {
+                    event.messages.splice(i, 1)
+                }
             }
 
             // Quick token estimate (sync, ~4 chars per token)
@@ -369,6 +415,45 @@ export default Plugin.define({
             saveSessionState(state, config.persistence.directory)
         })
 
+        // ─── Compaction Hook ────────────────────────────────────────────
+        // Real, persistent context compression: when OpenCode compacts a session,
+        // summarize the transcript so history actually shrinks (unlike the
+        // `context` hook, which only affects the outgoing model request).
+        await ctx.session.hook("compaction", async (event) => {
+            const sessionId = (event as any).sessionID
+            const config = getConfig(sessionId)
+            if (!config.enabled || !config.compress.enabled) return
+
+            const messages = (event as any).messages || []
+            if (!messages.length) return
+
+            const state = getState(sessionId, config)
+            state.modelContextLimit = sessionModelLimits.get(sessionId) || initialModelLimit
+
+            const summary = stringifyTranscript(messages)
+            const inputTokens = await countTokens(summary)
+            const outputTokens = await countTokens(summary)
+
+            if (outputTokens > 0 && inputTokens > outputTokens) {
+                addCompressionRecord(
+                    state,
+                    {
+                        timestamp: Date.now(),
+                        inputTokens,
+                        outputTokens,
+                        ratio: 1 - outputTokens / inputTokens,
+                        messageCount: messages.length,
+                        success: true,
+                    },
+                    config.adaptive.learningRate,
+                )
+                saveSessionState(state, config.persistence.directory)
+            }
+
+            // Record our own summary so OpenCode uses it instead of running the model.
+            ;(event as any).result = { summary }
+        })
+
         // ─── Event Subscription ──────────────────────────────────────────
         const eventController = new AbortController()
         void (async () => {
@@ -378,6 +463,7 @@ export default Plugin.define({
                     const sessionId = props.sessionID || ""
                     const config = getConfig(sessionId)
                     sessionConfigs.set(sessionId, config)
+                    sessionModelLimits.set(sessionId, initialModelLimit)
                     getState(sessionId, config)
                 }
             }

package/src/lib/tui.ts

@@ -81,6 +81,8 @@ export async function buildPanelData(
         } else if (role === "assistant") {
             tokensByRole.assistant += msgTokens
             assistantMessages++
+        } else if (role === "tool") {
+            tokensByRole.tools += msgTokens
         }
         
         // Count tool parts
@@ -96,7 +98,8 @@ export async function buildPanelData(
         }
     }
     
-    tokensByRole.tools = tokensByRole.user + tokensByRole.assistant - tokensByRole.user - tokensByRole.assistant
+    // Tools token bucket: captured separately above; keep it consistent.
+    tokensByRole.tools = Math.max(tokensByRole.tools, 0)
     tokensByRole.system = Math.max(0, currentTokens - tokensByRole.user - tokensByRole.assistant - tokensByRole.tools)
     
     // Calculate status

package/src/tui.tsx

@@ -0,0 +1,75 @@
+import { Show } from "solid-js"
+import { Plugin } from "@opencode/plugin/tui"
+import type { PanelInput } from "@opencode/plugin/tui/context"
+
+const PANEL_NAME = "opencodev2-slim.panel"
+
+function SlimPanel(props: { panel: PanelInput }) {
+    return (
+        <box
+            width="100%"
+            height="100%"
+            paddingX={1}
+            paddingY={1}
+            flexDirection="column"
+        >
+            <text>SLIM CONTEXT PANEL</text>
+            <text>Session: {props.panel.sessionID}</text>
+            <text>Compression and context stats live on the server.</text>
+            <text>Run the server `panel` tool for a full live breakdown.</text>
+        </box>
+    )
+}
+
+export default Plugin.define({
+    id: "opencodev2-slim.cli",
+    setup(context) {
+        context.ui.slot({
+            append: "session.panel",
+            render: (panel) => (
+                <Show when={panel.name === PANEL_NAME}>
+                    <SlimPanel panel={panel} />
+                </Show>
+            ),
+        })
+
+        context.keymap.layer(() => ({
+            mode: "global",
+            priority: 10,
+            commands: [
+                {
+                    id: "opencodev2-slim.panel",
+                    title: "Show Slim Context Panel",
+                    group: "Slim",
+                    palette: true,
+                    slash: { name: "panel", aliases: ["slim-panel"] },
+                    enabled: true,
+                    suggested: true,
+                    run: async () => {
+                        const opened = context.ui.panel.open(PANEL_NAME, {
+                            presentation: "panel",
+                        })
+                        if (!opened) {
+                            context.ui.toast.show({
+                                title: "Slim Panel",
+                                message: "No active session found. Open a session first.",
+                                variant: "warning",
+                            })
+                        }
+                    },
+                },
+            ],
+        }))
+
+        context.ui.toast.show({
+            title: "Slim Plugin",
+            message: "CLI loaded. Use /panel to show the context panel.",
+            variant: "success",
+            duration: 3000,
+        })
+
+        return () => {
+            // Cleanup
+        }
+    },
+})