@serkanalgur/opencodev2-slim 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 serkanalgur
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,146 @@
+# opencodev2-slim
+
+[![npm version](https://img.shields.io/npm/v/@serkanalgur/opencodev2-slim.svg)](https://www.npmjs.com/package/@serkanalgur/opencodev2-slim)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+Smart context management plugin for OpenCode v2. Optimizes token usage through semantic compression, cost-aware pruning, and adaptive thresholds.
+
+> **Note:** This plugin requires OpenCode v2 (1.18.29+). For v1 compatibility, use [@serkanalgur/opencode-slim](https://github.com/serkanalgur/opencode-slim).
+
+## Features
+
+- **TUI Panel** - Rich context usage visualization with status indicators
+- **Enhanced Compress** - Auto/range/topic modes for flexible compression
+- **Semantic Compression** - Groups related tool calls and compresses them intelligently
+- **Cost-Aware Pruning** - Considers token pricing when deciding what to compress
+- **Adaptive Thresholds** - Learns from compression history to optimize timing
+- **Session Persistence** - Saves state across restarts
+- **Deduplication** - Removes repeated tool calls automatically
+- **Error Purging** - Cleans up failed tool call outputs after configurable turns
+- **Topic Extraction** - Identifies and tracks conversation topics
+- **Smart Recommendations** - Provides actionable suggestions for context optimization
+
+## Installation
+
+```bash
+opencode plugin @serkanalgur/opencodev2-slim@latest --global
+```
+
+This installs the plugin globally. The TUI features (panel, slash commands) are automatically loaded when OpenCode starts.
+
+### Manual Installation
+
+If the CLI command doesn't work, add to your `~/.config/opencode/opencode.json`:
+
+```json
+{
+  "plugins": ["@serkanalgur/opencodev2-slim"]
+}
+```
+
+## Usage
+
+### Slash Commands
+
+After installation, these slash commands are available in the TUI:
+
+- `/panel` — Opens the rich TUI panel with context usage, stats, and help
+- `/compress` — Shows instructions for using the compress tool
+
+### TUI Panel
+
+The panel provides a real-time overview of your context usage, including:
+- Token usage vs model limit with visual progress bar
+- Message breakdown by role (user/assistant/tools)
+- Compression history and savings
+- Cost estimation based on your model
+- Smart recommendations for optimization
+
+### Compress Tool
+
+The enhanced compress tool supports multiple modes:
+
+```typescript
+// Auto mode (default) - intelligently selects what to compress
+compress({ focus: "old exploration" })
+
+// Range mode - compress specific message range
+compress({ focus: "completed tasks", mode: "range", start: 0, end: 50 })
+
+// Topic mode - compress messages matching a topic
+compress({ focus: "database work", mode: "topic", topic: "database" })
+```
+
+## Configuration
+
+Create `~/.config/opencode/slim.jsonc`:
+
+```jsonc
+{
+    "enabled": true,
+    "compress": {
+        "enabled": true,
+        "permission": "allow",
+        "maxContextLimit": "80%",
+        "minContextLimit": "40%",
+        "nudgeFrequency": 5,
+        "protectUserMessages": false,
+        "protectedTools": ["task", "skill", "todowrite", "todoread"]
+    },
+    "strategies": {
+        "deduplication": {
+            "enabled": true,
+            "protectedTools": []
+        },
+        "purgeErrors": {
+            "enabled": true,
+            "turns": 4,
+            "protectedTools": []
+        }
+    },
+    "adaptive": {
+        "enabled": true,
+        "learningRate": 0.1,
+        "minCompressionRatio": 0.3
+    },
+    "costAware": {
+        "enabled": true,
+        "cacheBoostFactor": 0.5
+    },
+    "persistence": {
+        "enabled": true,
+        "directory": "~/.config/opencode/slim"
+    }
+}
+```
+
+## How It Works
+
+### Semantic Compression
+
+Unlike simple text truncation, slim analyzes the semantic content of messages and groups related tool calls together. This preserves context while removing redundancy.
+
+### Cost-Aware Pruning
+
+Slim considers the cost of tokens when deciding what to compress. It prioritizes compressing expensive operations (like large file reads) while preserving cheap but important context.
+
+### Adaptive Thresholds
+
+The plugin learns from your compression patterns and adjusts thresholds over time. If you tend to need more context, it will compress less aggressively. If you're efficient, it will compress more.
+
+### Session Persistence
+
+State is saved to disk, so compression history and learning persist across restarts.
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `/panel` | Open the Slim TUI panel with context usage, stats, and help |
+| `/compress` | Show instructions for using the compress tool |
+
+Note: Compression is performed by the AI assistant using the `compress` tool. The slash command provides guidance on usage.
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,80 @@
+{
+  "name": "@serkanalgur/opencodev2-slim",
+  "version": "1.0.0",
+  "description": "Smart context management plugin for OpenCode v2 - semantic compression, cost-aware pruning, adaptive thresholds",
+  "keywords": [
+    "opencode",
+    "opencode-plugin",
+    "context",
+    "compression",
+    "pruning",
+    "tokens",
+    "semantic"
+  ],
+  "homepage": "https://github.com/serkanalgur/opencodev2-slim#readme",
+  "bugs": {
+    "url": "https://github.com/serkanalgur/opencodev2-slim/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/serkanalgur/opencodev2-slim.git"
+  },
+  "license": "MIT",
+  "author": "serkanalgur",
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts",
+    "./tui": "./src/tui.tsx"
+  },
+  "main": "index.js",
+  "directories": {
+    "test": "tests"
+  },
+  "files": [
+    "src/",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "test": "node --import tsx --test tests/*.ts",
+    "format": "prettier --write .",
+    "format:check": "prettier --check ."
+  },
+  "dependencies": {
+    "@anthropic-ai/tokenizer": "^0.0.4",
+    "jsonc-parser": "^3.3.1"
+  },
+  "devDependencies": {
+    "@opencode-ai/plugin": "^1.18.29",
+    "@opentui/core": "^0.4.5",
+    "@opentui/keymap": "^0.4.5",
+    "@opentui/solid": "^0.4.5",
+    "@types/node": "^22.0.0",
+    "prettier": "^3.4.0",
+    "solid-js": "1.9.12",
+    "tsx": "^4.19.0",
+    "typescript": "^5.7.0"
+  },
+  "peerDependencies": {
+    "@opencode-ai/plugin": ">=1.18.29",
+    "@opentui/core": ">=0.4.5",
+    "@opentui/keymap": ">=0.4.5",
+    "@opentui/solid": ">=0.4.5",
+    "solid-js": ">=1.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@opentui/core": {
+      "optional": true
+    },
+    "@opentui/keymap": {
+      "optional": true
+    },
+    "@opentui/solid": {
+      "optional": true
+    },
+    "solid-js": {
+      "optional": true
+    }
+  }
+}

package/src/index.ts

@@ -0,0 +1,407 @@
+import type { Plugin } from "@opencode-ai/plugin"
+import { tool } from "@opencode-ai/plugin"
+import { z } from "zod"
+import { loadConfig, createDefaultConfig, resolveTokenLimit } from "./lib/config"
+import {
+    loadSessionState,
+    saveSessionState,
+    addCompressionRecord,
+} from "./lib/state"
+import { countTokens, shouldCompress, getMessageText, getToolResultContent } from "./lib/compress"
+import { pruneMessages } from "./lib/strategies"
+import { getSystemPrompt, getCompressToolDescription, getNudgeMessage } from "./lib/prompts"
+import { buildPanelData, renderPanel } from "./lib/tui"
+import type { SlimConfig, SessionState, MessageWithParts } from "./lib/types"
+
+// ─── State Management ───────────────────────────────────────────────────────
+
+const sessionStates = new Map<string, SessionState>()
+const sessionConfigs = new Map<string, SlimConfig>()
+
+function getState(sessionId: string, config: SlimConfig): SessionState {
+    if (!sessionStates.has(sessionId)) {
+        const state = loadSessionState(sessionId, config.persistence.directory)
+        sessionStates.set(sessionId, state)
+    }
+    return sessionStates.get(sessionId)!
+}
+
+function getConfig(sessionId: string): SlimConfig {
+    return sessionConfigs.get(sessionId) || loadConfig()
+}
+
+// ─── Plugin Entry ───────────────────────────────────────────────────────────
+
+const server: Plugin = async (ctx) => {
+    // Load and create default config if needed
+    createDefaultConfig()
+    const globalConfig = loadConfig()
+
+    // ─── Compress Tool ─────────────────────────────────────────────────────
+    const compressTool = tool({
+        description: getCompressToolDescription(),
+        args: {
+            focus: z
+                .string()
+                .describe("What to compress (e.g., 'old exploration', 'completed tasks')"),
+            mode: z
+                .enum(["auto", "range", "topic"])
+                .default("auto")
+                .describe("Compression mode"),
+            start: z.number().optional().describe("Start message index (for range mode)"),
+            end: z.number().optional().describe("End message index (for range mode)"),
+            topic: z.string().optional().describe("Topic to compress (for topic mode)"),
+            keepRecent: z.number().default(5).describe("Number of recent messages to always keep"),
+        },
+        async execute(args, context) {
+            const config = getConfig(context.sessionID)
+            const state = getState(context.sessionID, config)
+
+            try {
+                const response = await ctx.client.session.messages({
+                    path: { id: context.sessionID },
+                })
+
+                if (!response.data || response.error) {
+                    return "Failed to fetch messages"
+                }
+
+                const messageList = response.data
+                const messageWithParts: MessageWithParts[] = messageList.map((m) => ({
+                    info: m.info,
+                    parts: m.parts,
+                }))
+
+                // Determine what to compress
+                let targetIndices: number[] = []
+                let inputTokens = 0
+
+                if (args.mode === "range" && args.start !== undefined && args.end !== undefined) {
+                    // Range mode: compress specific range
+                    const start = Math.max(0, args.start)
+                    const end = Math.min(messageWithParts.length, args.end)
+                    for (let i = start; i < end; i++) {
+                        targetIndices.push(i)
+                        const text =
+                            getMessageText(messageWithParts[i]) +
+                            getToolResultContent(messageWithParts[i])
+                        inputTokens += await countTokens(text)
+                    }
+                } else if (args.mode === "topic" && args.topic) {
+                    // Topic mode: compress messages matching topic
+                    const topicLower = args.topic.toLowerCase()
+                    for (let i = 0; i < messageWithParts.length - args.keepRecent; i++) {
+                        const msg = messageWithParts[i]
+                        const text = getMessageText(msg) + getToolResultContent(msg)
+                        if (text.toLowerCase().includes(topicLower)) {
+                            targetIndices.push(i)
+                            inputTokens += await countTokens(text)
+                        }
+                    }
+                } else {
+                    // Auto mode: smart selection
+                    const keepRecent = args.keepRecent
+                    for (let i = 0; i < messageWithParts.length - keepRecent; i++) {
+                        const msg = messageWithParts[i]
+                        const text = getMessageText(msg) + getToolResultContent(msg)
+                        const tokens = await countTokens(text)
+
+                        // Skip if too small to compress
+                        if (tokens < 100) continue
+
+                        targetIndices.push(i)
+                        inputTokens += tokens
+                    }
+                }
+
+                if (targetIndices.length === 0) {
+                    return "Nothing to compress - context is already efficient"
+                }
+
+                // Build summary
+                const targetMessages = targetIndices.map((i) => messageWithParts[i])
+                const summary = buildCompressionSummary(targetMessages, args.focus)
+
+                // Count output tokens
+                const outputTokens = await countTokens(summary)
+                const ratio = inputTokens > 0 ? 1 - outputTokens / inputTokens : 0
+
+                // Record compression
+                addCompressionRecord(
+                    state,
+                    {
+                        timestamp: Date.now(),
+                        inputTokens,
+                        outputTokens,
+                        ratio,
+                        messageCount: targetMessages.length,
+                        success: true,
+                    },
+                    config.adaptive.learningRate,
+                )
+
+                saveSessionState(state, config.persistence.directory)
+
+                return {
+                    title: `Compressed ${targetMessages.length} messages`,
+                    output: summary,
+                    metadata: {
+                        inputTokens,
+                        outputTokens,
+                        ratio: Math.round(ratio * 100) + "%",
+                        mode: args.mode,
+                        focus: args.focus,
+                    },
+                }
+            } catch (error) {
+                return `Error compressing: ${error instanceof Error ? error.message : "Unknown error"}`
+            }
+        },
+    })
+
+    // ─── Panel Tool ────────────────────────────────────────────────────────
+    const panelTool = tool({
+        description: `Display a rich context usage panel showing:
+- Current token usage vs model limit
+- Message breakdown (user/assistant/tools)
+- Token distribution by role
+- Compression history and savings
+- Cost estimate
+- Topic distribution
+- Smart recommendations`,
+        args: {},
+        async execute(_args, context) {
+            const config = getConfig(context.sessionID)
+            const state = getState(context.sessionID, config)
+
+            try {
+                const response = await ctx.client.session.messages({
+                    path: { id: context.sessionID },
+                })
+
+                if (!response.data || response.error) {
+                    return "Failed to fetch messages"
+                }
+
+                const messageList = response.data
+                const messageWithParts: MessageWithParts[] = messageList.map((m) => ({
+                    info: m.info,
+                    parts: m.parts,
+                }))
+
+                // Get model ID from context if available
+                const modelId = (context as any).model?.id || "unknown"
+
+                // Build panel data
+                const panelData = await buildPanelData(
+                    context.sessionID,
+                    messageWithParts,
+                    state,
+                    config,
+                    modelId,
+                )
+
+                // Render panel
+                const panel = renderPanel(panelData)
+
+                return {
+                    title: "Context Panel",
+                    output: panel,
+                    metadata: {
+                        usagePercent: panelData.usagePercent,
+                        status: panelData.status,
+                        currentTokens: panelData.currentTokens,
+                        maxTokens: panelData.maxTokens,
+                    },
+                }
+            } catch (error) {
+                return `Error generating panel: ${error instanceof Error ? error.message : "Unknown error"}`
+            }
+        },
+    })
+
+    // ─── Return Hooks ──────────────────────────────────────────────────────
+    return {
+        config: async (opencodeConfig) => {
+            // Add tool permissions
+            if (!opencodeConfig.permission) {
+                opencodeConfig.permission = {} as any
+            }
+            ;(opencodeConfig.permission as any).compress = globalConfig.compress.permission
+            ;(opencodeConfig.permission as any).panel = "allow"
+        },
+
+        tool: {
+            compress: compressTool,
+            panel: panelTool,
+        },
+
+        "experimental.chat.system.transform": async (input, output) => {
+            const config = getConfig(input.sessionID || "")
+            if (!config.enabled || !config.compress.enabled) {
+                return
+            }
+
+            const state = getState(input.sessionID || "", config)
+
+            // Track model context limit
+            if (input.model?.limit?.context) {
+                state.modelContextLimit = input.model.limit.context
+            }
+
+            // Add system prompt
+            const systemPrompt = getSystemPrompt()
+            if (output.system.length > 0) {
+                output.system[output.system.length - 1] += "\n\n" + systemPrompt
+            } else {
+                output.system.push(systemPrompt)
+            }
+        },
+
+        "experimental.chat.messages.transform": async (input, output) => {
+            const config = getConfig("")
+            if (!config.enabled) {
+                return
+            }
+
+            // Get session ID from first message if available
+            const sessionId = output.messages[0]?.info.sessionID || ""
+            const state = getState(sessionId, config)
+
+            // Apply pruning strategies
+            const prunedMessages = pruneMessages(
+                output.messages as any,
+                config,
+                output.messages.length,
+            )
+
+            // Replace messages
+            output.messages.length = 0
+            output.messages.push(...(prunedMessages as any))
+
+            // Check if compression nudge is needed
+            let totalTokens = 0
+            for (const msg of output.messages) {
+                const text = getMessageText(msg as any) + getToolResultContent(msg as any)
+                totalTokens += await countTokens(text)
+            }
+
+            state.currentTokenCount = totalTokens
+
+            const maxTokens = resolveTokenLimit(
+                config.compress.maxContextLimit,
+                state.modelContextLimit,
+            )
+            const minTokens = resolveTokenLimit(
+                config.compress.minContextLimit,
+                state.modelContextLimit,
+            )
+
+            const shouldComp = shouldCompress(
+                totalTokens,
+                maxTokens,
+                minTokens,
+                state.lastCompressionTime,
+                config.compress.nudgeFrequency,
+                output.messages.length,
+            )
+
+            if (shouldComp.compress && !state.manualMode) {
+                // Inject nudge as a system message
+                const nudgeMessage = getNudgeMessage(
+                    shouldComp.reason,
+                    totalTokens,
+                    maxTokens,
+                )
+                output.messages.push({
+                    info: {
+                        role: "assistant",
+                        sessionID: sessionId,
+                    } as any,
+                    parts: [{ type: "text", text: nudgeMessage }],
+                } as any)
+            }
+
+            saveSessionState(state, config.persistence.directory)
+        },
+
+        event: async (input) => {
+            const event = input.event
+            if (event.type === "session.created") {
+                const sessionId = (event as any).properties?.sessionID || ""
+                const config = getConfig(sessionId)
+                sessionConfigs.set(sessionId, config)
+                getState(sessionId, config)
+            }
+        },
+
+        dispose: async () => {
+            // Save all states on dispose
+            for (const [sessionId, state] of sessionStates.entries()) {
+                const config = getConfig(sessionId)
+                saveSessionState(state, config.persistence.directory)
+            }
+        },
+    }
+}
+
+// ─── Helpers ────────────────────────────────────────────────────────────────
+
+function buildCompressionSummary(messages: MessageWithParts[], focus: string): string {
+    const lines: string[] = []
+    lines.push(`## Compression Summary`)
+    lines.push(`Focus: ${focus}`)
+    lines.push(`Messages compressed: ${messages.length}`)
+    lines.push("")
+
+    // Extract key information
+    const toolCalls: string[] = []
+    const errors: string[] = []
+    const decisions: string[] = []
+
+    for (const msg of messages) {
+        for (const part of msg.parts) {
+            if (part.type === "tool") {
+                const toolPart = part as any
+                toolCalls.push(
+                    `${toolPart.tool}: ${JSON.stringify(toolPart.state?.input || {}).slice(0, 100)}`,
+                )
+                if (toolPart.state?.status === "error") {
+                    errors.push(toolPart.state.error?.slice(0, 200) || "Unknown error")
+                }
+            }
+            if (part.type === "text") {
+                const text = (part as any).text
+                if (
+                    text.includes("decided") ||
+                    text.includes("chose") ||
+                    text.includes("implemented")
+                ) {
+                    decisions.push(text.slice(0, 200))
+                }
+            }
+        }
+    }
+
+    if (toolCalls.length > 0) {
+        lines.push("### Tool Calls")
+        toolCalls.slice(0, 10).forEach((tc) => lines.push(`- ${tc}`))
+        lines.push("")
+    }
+
+    if (errors.length > 0) {
+        lines.push("### Errors Encountered")
+        errors.slice(0, 5).forEach((e) => lines.push(`- ${e}`))
+        lines.push("")
+    }
+
+    if (decisions.length > 0) {
+        lines.push("### Key Decisions")
+        decisions.slice(0, 5).forEach((d) => lines.push(`- ${d}`))
+        lines.push("")
+    }
+
+    return lines.join("\n")
+}
+
+export default { id: "opencodev2-slim", server }