@serkanalgur/opencodev2-slim 2.0.9 → 2.0.12

package/README.md

@@ -141,6 +141,25 @@ Note: Compression is performed by the AI assistant using the `compress` tool. Th
 
 ## Changelog
 
+### 2.0.12
+
+- Bind panel/nudge to real OpenCode context measurements:
+  - Resolve the active model's real context window from `ctx.model.default().data.limit.context` instead of the hard-coded 200k.
+  - `/panel` now reads live server measurements (`Session.Info.tokens` + `cost`) via `ctx.session.get()` and feeds them to `buildPanelData`, so the headline tokens/percent/cost match what OpenCode's UI reports.
+  - The nudge decision prefers the measured token count over the rough 4-char estimation.
+
+### 2.0.11
+
+- Fix CI publish: add `solid-js`, `@opentui/core`, `@opentui/solid` to `devDependencies`.
+  The workflow runs `npm ci --legacy-peer-deps`, which skips peer deps, so loading
+  `@opencode/plugin/tui` failed with `Cannot find package 'solid-js'`.
+
+### 2.0.10
+
+- Fix `/panel` output showing `User tokens: 0`: user/system messages carry their text
+  on a top-level `text` field (not inside `content`), which `deriveStats` now captures.
+- Add regression tests for CLI panel stats.
+
 ### 2.0.9
 
 - `feat(panel-as-message)`: `/panel` and `slim-panel` now print the context stats as plain

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@serkanalgur/opencodev2-slim",
-  "version": "2.0.9",
+  "version": "2.0.12",
   "description": "Smart context management plugin for OpenCode v2 - semantic compression, cost-aware pruning, adaptive thresholds",
   "keywords": [
     "opencode",
@@ -49,10 +49,13 @@
     "jsonc-parser": "^3.3.1"
   },
   "devDependencies": {
-    "@opencode/plugin": "^2.0.0",
     "@opencode-ai/sdk": "^1.18.29",
+    "@opencode/plugin": "^2.0.0",
+    "@opentui/core": "^0.5.11",
+    "@opentui/solid": "^0.5.11",
     "@types/node": "^22.0.0",
     "prettier": "^3.4.0",
+    "solid-js": "^1.9.12",
     "tsx": "^4.19.0",
     "typescript": "^5.7.0"
   },

package/src/index.ts

@@ -36,20 +36,13 @@ function getConfig(sessionId: string): SlimConfig {
 }
 
 // Resolve the active model's real context limit instead of hard-coding 200k.
+// ctx.model.default() returns { data: ModelInfo | null }, where ModelInfo.limit.context
+// holds the model's context window. Use it directly and only fall back when missing.
 async function resolveModelContextLimit(ctx: any): Promise<number> {
     try {
-        const models: any[] = await ctx.model.list()
-        const selected: { providerID?: string; modelID?: string } | undefined =
+        const selected: { data?: { limit?: { context?: number } } | null } | 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
+        const limit = selected?.data?.limit?.context
         return typeof limit === "number" && limit > 0 ? limit : DEFAULT_MODEL_LIMIT
     } catch {
         return DEFAULT_MODEL_LIMIT
@@ -300,6 +293,31 @@ export default Plugin.define({
                     const state = getState(sessionId, config)
 
                     try {
+                        // Pull the real, server-measured context usage for this session.
+                        let measured: import("./lib/tui").MeasuredContext | undefined
+                        try {
+                            const info = await ctx.session.get({ sessionID: sessionId })
+                            const tokens = info.tokens as any
+                            const tokenCount =
+                                (tokens?.input ?? 0) +
+                                (tokens?.output ?? 0) +
+                                (tokens?.reasoning ?? 0) +
+                                (tokens?.cache?.read ?? 0) +
+                                (tokens?.cache?.write ?? 0)
+                            measured = {
+                                tokens: tokenCount,
+                                cost: typeof info.cost === "number" ? info.cost : 0,
+                                contextLimit:
+                                    state.modelContextLimit || (await resolveModelContextLimit(ctx)),
+                                model: (info.model && (info.model as any).id) || "unknown",
+                            }
+                            // Keep state's headline figure aligned with reality.
+                            state.modelContextLimit = measured.contextLimit
+                            state.currentTokenCount = measured.tokens
+                        } catch {
+                            // Fall through to estimation if session.get fails.
+                        }
+
                         const messages = await ctx.session.context({ sessionID: sessionId })
 
                         if (!messages || messages.length === 0) {
@@ -315,9 +333,12 @@ export default Plugin.define({
                             messageWithParts,
                             state,
                             config,
+                            measured?.model,
+                            measured,
                         )
 
                         const panel = renderPanel(panelData)
+                        saveSessionState(state, config.persistence.directory)
                         return { content: panel }
                     } catch (error) {
                         return {
@@ -367,19 +388,24 @@ export default Plugin.define({
                 }
             }
 
-            // Quick token estimate (sync, ~4 chars per token)
-            let totalTokens = 0
+            // Quick token estimate (sync, ~4 chars per token). On the first pass
+            // (before the panel has written real numbers into state) this is a
+            // fallback; afterwards we prefer the server-measured value.
+            let estimatedTokens = 0
             for (const msg of event.messages) {
                 const content = (msg as any).content
                 if (Array.isArray(content)) {
                     for (const part of content) {
                         if (part.type === "text" && part.text) {
-                            totalTokens += Math.ceil(part.text.length / 4)
+                            estimatedTokens += Math.ceil(part.text.length / 4)
                         }
                     }
                 }
             }
 
+            // Prefer the real measured token count when available; else the estimate.
+            const totalTokens =
+                state.currentTokenCount > 0 ? state.currentTokenCount : estimatedTokens
             state.currentTokenCount = totalTokens
 
             const maxTokens = resolveTokenLimit(

package/src/lib/tui.ts

@@ -50,17 +50,30 @@ export interface PanelData {
 
 // ─── Panel Builder ─────────────────────────────────────────────────────────
 
+export interface MeasuredContext {
+    /** Real context input tokens for this session (Session.Info.tokens.input). */
+    tokens: number
+    /** Real total spend for this session (Session.Info.cost). */
+    cost: number
+    /** Real model context window (Model.Info.limit.context). */
+    contextLimit: number
+    /** Real model id. */
+    model: string
+}
+
 export async function buildPanelData(
     sessionId: string,
     messages: MessageWithParts[],
     state: SessionState,
     config: SlimConfig,
     modelId?: string,
+    measured?: MeasuredContext,
 ): Promise<PanelData> {
-    const modelContextLimit = state.modelContextLimit || 200000
+    // Prefer the real model context window from the server; fall back to state/default.
+    const modelContextLimit = measured?.contextLimit || state.modelContextLimit || 200000
     const maxTokens = resolveTokenLimit(config.compress.maxContextLimit, modelContextLimit)
     
-    // Count tokens
+    // Count tokens (estimation for role breakdown; real total used for usage %).
     let currentTokens = 0
     const tokensByRole = { user: 0, assistant: 0, tools: 0, system: 0 }
     let userMessages = 0
@@ -102,8 +115,15 @@ export async function buildPanelData(
     tokensByRole.tools = Math.max(tokensByRole.tools, 0)
     tokensByRole.system = Math.max(0, currentTokens - tokensByRole.user - tokensByRole.assistant - tokensByRole.tools)
     
-    // Calculate status
-    const usagePercent = (currentTokens / maxTokens) * 100
+    // Prefer the server-measured real token count for the headline usage figure.
+    // Role buckets remain our estimate for breakdown detail.
+    const effectiveTokens = measured?.tokens ?? currentTokens
+    
+    // Usage % shown to the user is relative to the real model context window
+    // (e.g. 220k / 1M = 22%), matching what OpenCode's own UI displays. The
+    // configured maxTokens (a percentage of that same window) drives nudge/compress.
+    const usageBase = measured?.contextLimit ? modelContextLimit : modelContextLimit
+    const usagePercent = (effectiveTokens / modelContextLimit) * 100
     let status: "healthy" | "warning" | "critical" = "healthy"
     if (usagePercent > 90) status = "critical"
     else if (usagePercent > 70) status = "warning"
@@ -121,9 +141,9 @@ export async function buildPanelData(
         ? state.compressionHistory[state.compressionHistory.length - 1]
         : null
     
-    // Cost estimate
+    // Cost: prefer the server-measured real spend; else estimate from tokens.
     const profile = COST_PROFILES[modelId || "default"] || COST_PROFILES.default
-    const estimatedCost = (currentTokens / 1000) * profile.inputPricePer1k
+    const estimatedCost = measured?.cost ?? (currentTokens / 1000) * profile.inputPricePer1k
     const costSaved = (totalTokensSaved / 1000) * profile.inputPricePer1k
     
     // Topic distribution
@@ -155,7 +175,7 @@ export async function buildPanelData(
     return {
         sessionId,
         timestamp: Date.now(),
-        currentTokens,
+        currentTokens: effectiveTokens,
         maxTokens,
         usagePercent,
         status,
@@ -171,7 +191,7 @@ export async function buildPanelData(
         lastCompression,
         estimatedCost,
         costSaved,
-        model: modelId || "unknown",
+        model: measured?.model || modelId || "unknown",
         topics,
         recommendations,
     }

package/src/tui.tsx

@@ -31,7 +31,7 @@ function emptyStats(): PanelStats {
 }
 
 // Derives context-usage stats from the session transcript.
-function deriveStats(messages: readonly unknown[]): PanelStats {
+export function deriveStats(messages: readonly unknown[]): PanelStats {
     const stats = emptyStats()
     for (const raw of messages) {
         const m = raw as {
@@ -55,6 +55,12 @@ function deriveStats(messages: readonly unknown[]): PanelStats {
             text = m.summary || ""
         }
 
+        // User/system messages carry their text on a top-level `text` field
+        // (not inside a `content` array). Capture it too so their tokens count.
+        if (role !== "assistant" && typeof (m as any).text === "string") {
+            text += (m as any).text
+        }
+
         if (Array.isArray(m.content)) {
             for (const part of m.content) {
                 if (part?.type === "text" && typeof part.text === "string") {