@serkanalgur/opencodev2-slim 1.0.0

package/src/lib/compress.ts

@@ -0,0 +1,117 @@
+import type { MessageWithParts } from "./types"
+
+// ─── Token Counting ─────────────────────────────────────────────────────────
+
+let tokenizer: any = null
+
+async function getTokenizer() {
+    if (!tokenizer) {
+        try {
+            const mod = await import("@anthropic-ai/tokenizer")
+            tokenizer = mod
+        } catch {
+            // Fallback: estimate ~4 chars per token
+            return null
+        }
+    }
+    return tokenizer
+}
+
+export async function countTokens(text: string): Promise<number> {
+    if (!text) return 0
+
+    const tok = await getTokenizer()
+    if (tok && tok.encode) {
+        try {
+            return tok.encode(text).length
+        } catch {
+            // Fallback to estimation
+        }
+    }
+
+    // Rough estimation: ~4 chars per token for English
+    return Math.ceil(text.length / 4)
+}
+
+// ─── Message Text Extraction ────────────────────────────────────────────────
+
+export function getMessageText(msg: MessageWithParts): string {
+    const texts: string[] = []
+
+    for (const part of msg.parts) {
+        if (part.type === "text") {
+            const textPart = part as any
+            if (textPart.text) {
+                texts.push(textPart.text)
+            }
+        }
+    }
+
+    return texts.join("\n")
+}
+
+export function getToolResultContent(msg: MessageWithParts): string {
+    const results: string[] = []
+
+    for (const part of msg.parts) {
+        if (part.type === "tool") {
+            const toolPart = part as any
+            if (toolPart.state?.type === "result" && toolPart.state?.output) {
+                results.push(String(toolPart.state.output).slice(0, 500))
+            }
+        }
+    }
+
+    return results.join("\n")
+}
+
+export function getToolName(msg: MessageWithParts): string | null {
+    for (const part of msg.parts) {
+        if (part.type === "tool") {
+            const toolPart = part as any
+            return toolPart.tool || null
+        }
+    }
+    return null
+}
+
+// ─── Compression Decision ───────────────────────────────────────────────────
+
+export function shouldCompress(
+    currentTokens: number,
+    maxTokens: number,
+    minTokens: number,
+    lastCompressionTime: number,
+    nudgeFrequency: number,
+    messageCount: number,
+): { compress: boolean; reason: string } {
+    const usagePercent = (currentTokens / maxTokens) * 100
+    const timeSinceLastCompression = Date.now() - lastCompressionTime
+    const minutesSinceLast = timeSinceLastCompression / (1000 * 60)
+
+    // Hard limit: must compress
+    if (currentTokens >= maxTokens) {
+        return { compress: true, reason: "Context limit reached" }
+    }
+
+    // Soft limit: recommend compression
+    if (currentTokens >= minTokens) {
+        // Check if enough time has passed since last compression
+        if (minutesSinceLast >= nudgeFrequency) {
+            return {
+                compress: true,
+                reason: `Context at ${usagePercent.toFixed(0)}% (${currentTokens}/${maxTokens} tokens)`,
+            }
+        }
+    }
+
+    // Very high usage: always recommend
+    if (usagePercent > 90) {
+        return {
+            compress: true,
+            reason: `Context critically high at ${usagePercent.toFixed(0)}%`,
+        }
+    }
+
+    return { compress: false, reason: "" }
+}

package/src/lib/config.ts

@@ -0,0 +1,126 @@
+import { readFileSync, existsSync, writeFileSync, mkdirSync } from "fs"
+import { join } from "path"
+import { homedir } from "os"
+import { parse } from "jsonc-parser/lib/esm/main.js"
+import type { SlimConfig } from "./types"
+
+const DEFAULT_CONFIG: SlimConfig = {
+    enabled: true,
+    debug: false,
+    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: join(homedir(), ".config", "opencode", "slim"),
+    },
+}
+
+function deepMerge(base: SlimConfig, override: Partial<SlimConfig>): SlimConfig {
+    return {
+        ...base,
+        ...override,
+        compress: { ...base.compress, ...override.compress },
+        strategies: {
+            deduplication: { ...base.strategies.deduplication, ...override.strategies?.deduplication },
+            purgeErrors: { ...base.strategies.purgeErrors, ...override.strategies?.purgeErrors },
+        },
+        adaptive: { ...base.adaptive, ...override.adaptive },
+        costAware: { ...base.costAware, ...override.costAware },
+        persistence: { ...base.persistence, ...override.persistence },
+    }
+}
+
+export function loadConfig(): SlimConfig {
+    let config = { ...DEFAULT_CONFIG }
+
+    const globalDir = process.env.XDG_CONFIG_HOME
+        ? join(process.env.XDG_CONFIG_HOME, "opencode")
+        : join(homedir(), ".config", "opencode")
+
+    const globalPath = join(globalDir, "slim.jsonc")
+    const globalPathJson = join(globalDir, "slim.json")
+
+    const configPath = existsSync(globalPath)
+        ? globalPath
+        : existsSync(globalPathJson)
+          ? globalPathJson
+          : null
+
+    if (configPath) {
+        try {
+            const content = readFileSync(configPath, "utf-8")
+            const parsed = parse(content)
+            if (parsed) {
+                config = deepMerge(config, parsed)
+            }
+        } catch {
+            // Use defaults
+        }
+    }
+
+    return config
+}
+
+export function createDefaultConfig(): void {
+    const globalDir = process.env.XDG_CONFIG_HOME
+        ? join(process.env.XDG_CONFIG_HOME, "opencode")
+        : join(homedir(), ".config", "opencode")
+
+    const configPath = join(globalDir, "slim.jsonc")
+
+    if (!existsSync(configPath)) {
+        try {
+            mkdirSync(globalDir, { recursive: true })
+            writeFileSync(
+                configPath,
+                `{
+    // Slim Configuration
+    "enabled": true,
+    "compress": {
+        "enabled": true,
+        "permission": "allow",
+        "maxContextLimit": "80%",
+        "minContextLimit": "40%",
+        "nudgeFrequency": 5
+    }
+}`,
+                "utf-8",
+            )
+        } catch {
+            // Ignore errors
+        }
+    }
+}
+
+export function resolveTokenLimit(value: number | string, contextLimit: number): number {
+    if (typeof value === "number") return value
+    const percent = parseFloat(value.replace("%", "")) / 100
+    return Math.floor(contextLimit * percent)
+}

package/src/lib/prompts.ts

@@ -0,0 +1,48 @@
+export function getSystemPrompt(): string {
+    return `
+## Context Management (Slim)
+
+You have access to context management tools. Use them wisely:
+
+### compress tool
+Use \`compress\` to reduce context size when it gets large. It supports:
+- Auto mode: Intelligently selects what to compress
+- Range mode: Compress specific message range
+- Topic mode: Compress messages matching a topic
+
+Example: \`compress({ focus: "old exploration" })\`
+
+### panel tool
+Use \`panel\` to view current context usage and statistics.
+
+### When to compress
+- Context usage > 80%: Consider compressing
+- Context usage > 90%: Compress immediately
+- After completing a major task: Compress related messages
+- Before starting a new task: Clean up old context
+`
+}
+
+export function getCompressToolDescription(): string {
+    return `Compress context to free up tokens. Supports multiple modes:
+
+- Auto mode (default): Intelligently selects what to compress based on age and relevance
+- Range mode: Compress specific message range (start/end indices)
+- Topic mode: Compress messages matching a topic keyword
+
+The compression creates a summary preserving key information while removing redundancy.`
+}
+
+export function getNudgeMessage(reason: string, currentTokens: number, maxTokens: number): string {
+    const percent = Math.round((currentTokens / maxTokens) * 100)
+    return `💡 **Context Optimization Available**
+
+${reason} (${percent}% used)
+
+Consider using the \`compress\` tool to free up context space:
+\`\`\`
+compress({ focus: "describe what to compress" })
+\`\`\`
+
+This will create a summary of older messages, preserving key information while freeing tokens.`
+}

package/src/lib/state.ts

@@ -0,0 +1,122 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs"
+import { join } from "path"
+import type { SessionState, CompressionRecord, ToolCallInfo } from "./types"
+
+const DEFAULT_STATE: SessionState = {
+    sessionId: "",
+    modelContextLimit: 200000,
+    currentTokenCount: 0,
+    compressionCount: 0,
+    lastCompressionTime: 0,
+    manualMode: false,
+    compressPermission: null,
+    compressionHistory: [],
+    averageCompressionRatio: 0,
+    toolCalls: new Map(),
+}
+
+export function loadSessionState(sessionId: string, persistenceDir: string): SessionState {
+    const statePath = join(persistenceDir, `${sessionId}.json`)
+
+    if (existsSync(statePath)) {
+        try {
+            const data = readFileSync(statePath, "utf-8")
+            const parsed = JSON.parse(data)
+            // Convert toolCalls back to Map
+            if (parsed.toolCalls && Array.isArray(parsed.toolCalls)) {
+                parsed.toolCalls = new Map(parsed.toolCalls)
+            }
+            return { ...DEFAULT_STATE, ...parsed, sessionId }
+        } catch {
+            // Use default
+        }
+    }
+
+    return { ...DEFAULT_STATE, sessionId }
+}
+
+export function saveSessionState(state: SessionState, persistenceDir: string): void {
+    try {
+        if (!existsSync(persistenceDir)) {
+            mkdirSync(persistenceDir, { recursive: true })
+        }
+
+        const statePath = join(persistenceDir, `${state.sessionId}.json`)
+        // Convert Map to array for serialization
+        const serializable = {
+            ...state,
+            toolCalls: Array.from(state.toolCalls.entries()),
+        }
+        writeFileSync(statePath, JSON.stringify(serializable, null, 2), "utf-8")
+    } catch {
+        // Ignore errors
+    }
+}
+
+export function addCompressionRecord(
+    state: SessionState,
+    record: CompressionRecord,
+    learningRate: number,
+): void {
+    state.compressionHistory.push(record)
+    state.compressionCount++
+    state.lastCompressionTime = record.timestamp
+
+    // Update average ratio with exponential moving average
+    if (state.compressionHistory.length === 1) {
+        state.averageCompressionRatio = record.ratio
+    } else {
+        state.averageCompressionRatio =
+            state.averageCompressionRatio * (1 - learningRate) + record.ratio * learningRate
+    }
+}
+
+export function trackToolCall(
+    state: SessionState,
+    tool: string,
+    args: unknown,
+    turn: number,
+): string {
+    const id = `${tool}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`
+    state.toolCalls.set(id, {
+        tool,
+        args,
+        timestamp: Date.now(),
+        turn,
+    })
+    return id
+}
+
+export function getDuplicateToolCalls(state: SessionState): string[] {
+    const seen = new Map<string, string[]>()
+    const duplicates: string[] = []
+
+    for (const [id, info] of state.toolCalls.entries()) {
+        const key = `${info.tool}:${JSON.stringify(info.args)}`
+        const existing = seen.get(key) || []
+        existing.push(id)
+        seen.set(key, existing)
+    }
+
+    for (const [, ids] of seen.entries()) {
+        if (ids.length > 1) {
+            // Keep first, mark rest as duplicates
+            duplicates.push(...ids.slice(1))
+        }
+    }
+
+    return duplicates
+}
+
+export function getErroredToolCalls(state: SessionState, turnsThreshold: number): string[] {
+    const errored: string[] = []
+    const currentTurn = Math.max(...Array.from(state.toolCalls.values()).map((t) => t.turn), 0)
+
+    for (const [id, info] of state.toolCalls.entries()) {
+        if (info.error && currentTurn - info.turn >= turnsThreshold) {
+            errored.push(id)
+        }
+    }
+
+    return errored
+}

package/src/lib/strategies.ts

@@ -0,0 +1,49 @@
+import type { MessageWithParts, SlimConfig } from "./types"
+import { getToolName, getToolResultContent, getMessageText } from "./compress"
+import { getDuplicateToolCalls, getErroredToolCalls } from "./state"
+import type { SessionState } from "./types"
+
+export function pruneMessages(
+    messages: MessageWithParts[],
+    config: SlimConfig,
+    _messageCount: number,
+): MessageWithParts[] {
+    let pruned = [...messages]
+
+    // Apply deduplication
+    if (config.strategies.deduplication.enabled) {
+        pruned = applyDeduplication(pruned, config.strategies.deduplication.protectedTools)
+    }
+
+    return pruned
+}
+
+function applyDeduplication(messages: MessageWithParts[], protectedTools: string[]): MessageWithParts[] {
+    const seen = new Map<string, number>()
+    const toRemove = new Set<number>()
+
+    for (let i = 0; i < messages.length; i++) {
+        const msg = messages[i]
+        const toolName = getToolName(msg)
+
+        // Skip protected tools
+        if (toolName && protectedTools.includes(toolName)) {
+            continue
+        }
+
+        // Create a fingerprint of the message
+        const text = getMessageText(msg)
+        const toolContent = getToolResultContent(msg)
+        const fingerprint = `${msg.info.role}:${text.slice(0, 200)}:${toolContent.slice(0, 200)}`
+
+        const existingIndex = seen.get(fingerprint)
+        if (existingIndex !== undefined) {
+            // Mark later duplicate for removal
+            toRemove.add(i)
+        } else {
+            seen.set(fingerprint, i)
+        }
+    }
+
+    return messages.filter((_, i) => !toRemove.has(i))
+}

package/src/lib/tui/data.ts

@@ -0,0 +1,90 @@
+import type { TuiPluginApi } from "@opencode-ai/plugin/tui"
+import type { SlimConfig } from "../types"
+import { readFileSync, existsSync } from "fs"
+import { join } from "path"
+import { homedir } from "os"
+import { parse } from "jsonc-parser/lib/esm/main.js"
+
+const DEFAULT_CONFIG: SlimConfig = {
+    enabled: true,
+    debug: false,
+    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: join(homedir(), ".config", "opencode", "slim"),
+    },
+}
+
+function deepMerge(base: SlimConfig, override: Partial<SlimConfig>): SlimConfig {
+    return {
+        ...base,
+        ...override,
+        compress: { ...base.compress, ...override.compress },
+        strategies: {
+            deduplication: { ...base.strategies.deduplication, ...override.strategies?.deduplication },
+            purgeErrors: { ...base.strategies.purgeErrors, ...override.strategies?.purgeErrors },
+        },
+        adaptive: { ...base.adaptive, ...override.adaptive },
+        costAware: { ...base.costAware, ...override.costAware },
+        persistence: { ...base.persistence, ...override.persistence },
+    }
+}
+
+export function loadConfig(_api: TuiPluginApi): SlimConfig {
+    let config = { ...DEFAULT_CONFIG }
+
+    const globalDir = process.env.XDG_CONFIG_HOME
+        ? join(process.env.XDG_CONFIG_HOME, "opencode")
+        : join(homedir(), ".config", "opencode")
+
+    const globalPath = join(globalDir, "slim.jsonc")
+    const globalPathJson = join(globalDir, "slim.json")
+
+    const configPath = existsSync(globalPath)
+        ? globalPath
+        : existsSync(globalPathJson)
+          ? globalPathJson
+          : null
+
+    if (configPath) {
+        try {
+            const content = readFileSync(configPath, "utf-8")
+            const parsed = parse(content)
+            if (parsed) {
+                config = deepMerge(config, parsed)
+            }
+        } catch {
+            // Use defaults
+        }
+    }
+
+    return config
+}