@tarquinen/opencode-dcp 3.2.0-beta0 → 3.2.2-beta0

package/lib/token-utils.ts

@@ -0,0 +1,162 @@
+import { SessionState, WithParts } from "./state"
+import { AssistantMessage, UserMessage } from "@opencode-ai/sdk/v2"
+import { Logger } from "./logger"
+import { countTokens as anthropicCountTokens } from "@anthropic-ai/tokenizer"
+import { getLastUserMessage } from "./messages/query"
+
+export function getCurrentTokenUsage(state: SessionState, messages: WithParts[]): number {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const msg = messages[i]
+        if (msg.info.role !== "assistant") {
+            continue
+        }
+
+        const assistantInfo = msg.info as AssistantMessage
+        if ((assistantInfo.tokens?.output || 0) <= 0) {
+            continue
+        }
+
+        if (
+            state.lastCompaction > 0 &&
+            (msg.info.time.created < state.lastCompaction ||
+                (msg.info.summary === true && msg.info.time.created === state.lastCompaction))
+        ) {
+            return 0
+        }
+
+        const input = assistantInfo.tokens?.input || 0
+        const output = assistantInfo.tokens?.output || 0
+        const reasoning = assistantInfo.tokens?.reasoning || 0
+        const cacheRead = assistantInfo.tokens?.cache?.read || 0
+        const cacheWrite = assistantInfo.tokens?.cache?.write || 0
+        return input + output + reasoning + cacheRead + cacheWrite
+    }
+
+    return 0
+}
+
+export function getCurrentParams(
+    state: SessionState,
+    messages: WithParts[],
+    logger: Logger,
+): {
+    providerId: string | undefined
+    modelId: string | undefined
+    agent: string | undefined
+    variant: string | undefined
+} {
+    const userMsg = getLastUserMessage(messages)
+    if (!userMsg) {
+        logger.debug("No user message found when determining current params")
+        return {
+            providerId: undefined,
+            modelId: undefined,
+            agent: undefined,
+            variant: state.variant,
+        }
+    }
+    const userInfo = userMsg.info as UserMessage
+    const agent: string = userInfo.agent
+    const providerId: string | undefined = userInfo.model.providerID
+    const modelId: string | undefined = userInfo.model.modelID
+    const variant: string | undefined = state.variant ?? userInfo.variant
+
+    return { providerId, modelId, agent, variant }
+}
+
+export function countTokens(text: string): number {
+    if (!text) return 0
+    try {
+        return anthropicCountTokens(text)
+    } catch {
+        return Math.round(text.length / 4)
+    }
+}
+
+export function estimateTokensBatch(texts: string[]): number {
+    if (texts.length === 0) return 0
+    return countTokens(texts.join(" "))
+}
+
+export const COMPACTED_TOOL_OUTPUT_PLACEHOLDER = "[Old tool result content cleared]"
+
+function stringifyToolContent(value: unknown): string {
+    return typeof value === "string" ? value : JSON.stringify(value)
+}
+
+export function extractCompletedToolOutput(part: any): string | undefined {
+    if (
+        part?.type !== "tool" ||
+        part.state?.status !== "completed" ||
+        part.state?.output === undefined
+    ) {
+        return undefined
+    }
+
+    if (part.state?.time?.compacted) {
+        return COMPACTED_TOOL_OUTPUT_PLACEHOLDER
+    }
+
+    return stringifyToolContent(part.state.output)
+}
+
+export function extractToolContent(part: any): string[] {
+    const contents: string[] = []
+
+    if (part?.type !== "tool") {
+        return contents
+    }
+
+    if (part.state?.input !== undefined) {
+        contents.push(stringifyToolContent(part.state.input))
+    }
+
+    const completedOutput = extractCompletedToolOutput(part)
+    if (completedOutput !== undefined) {
+        contents.push(completedOutput)
+    } else if (part.state?.status === "error" && part.state?.error) {
+        contents.push(stringifyToolContent(part.state.error))
+    }
+
+    return contents
+}
+
+export function countToolTokens(part: any): number {
+    const contents = extractToolContent(part)
+    return estimateTokensBatch(contents)
+}
+
+export function getTotalToolTokens(state: SessionState, toolIds: string[]): number {
+    let total = 0
+    for (const id of toolIds) {
+        const entry = state.toolParameters.get(id)
+        total += entry?.tokenCount ?? 0
+    }
+    return total
+}
+
+export function countMessageTextTokens(msg: WithParts): number {
+    const texts: string[] = []
+    const parts = Array.isArray(msg.parts) ? msg.parts : []
+    for (const part of parts) {
+        if (part.type === "text") {
+            texts.push(part.text)
+        }
+    }
+    if (texts.length === 0) return 0
+    return estimateTokensBatch(texts)
+}
+
+export function countAllMessageTokens(msg: WithParts): number {
+    const parts = Array.isArray(msg.parts) ? msg.parts : []
+    const texts: string[] = []
+    for (const part of parts) {
+        if (part.type === "text") {
+            texts.push(part.text)
+        } else {
+            texts.push(...extractToolContent(part))
+        }
+    }
+    if (texts.length === 0) return 0
+    return estimateTokensBatch(texts)
+}

package/package.json

@@ -1,7 +1,7 @@
 {
     "$schema": "https://json.schemastore.org/package.json",
     "name": "@tarquinen/opencode-dcp",
-    "version": "3.2.0-beta0",
+    "version": "3.2.2-beta0",
     "type": "module",
     "description": "OpenCode plugin that optimizes token usage by pruning obsolete tool outputs from conversation context",
     "main": "./dist/index.js",
@@ -13,7 +13,7 @@
         },
         "./tui": {
             "types": "./dist/tui/index.d.ts",
-            "import": "./dist/tui/index.js"
+            "import": "./tui/index.tsx"
         }
     },
     "oc-plugin": [
@@ -52,41 +52,38 @@
     "author": "tarquinen",
     "license": "AGPL-3.0-or-later",
     "peerDependencies": {
-        "@opencode-ai/plugin": ">=1.2.0",
-        "@opentui/core": ">=0.1.87",
-        "@opentui/solid": ">=0.0.0-20260307",
-        "solid-js": ">=1.9.9 <2"
-    },
-    "peerDependenciesMeta": {
-        "@opentui/core": {
-            "optional": true
-        },
-        "@opentui/solid": {
-            "optional": true
-        },
-        "solid-js": {
-            "optional": true
-        }
+        "@opencode-ai/plugin": ">=1.2.0"
     },
     "dependencies": {
         "@anthropic-ai/tokenizer": "^0.0.4",
         "@opencode-ai/sdk": "^1.3.2",
+        "@opentui/core": "0.0.0-20260307-536c401b",
+        "@opentui/solid": "0.0.0-20260307-536c401b",
         "fuzzball": "^2.2.3",
         "jsonc-parser": "^3.3.1",
+        "solid-js": "1.9.9",
         "zod": "^4.3.6"
     },
     "devDependencies": {
         "@opencode-ai/plugin": "^1.3.2",
-        "@opentui/core": "0.0.0-20260307-536c401b",
-        "@opentui/solid": "0.0.0-20260307-536c401b",
         "@types/node": "^25.5.0",
         "prettier": "^3.8.1",
-        "solid-js": "1.9.9",
         "tsx": "^4.21.0",
         "typescript": "^6.0.2"
     },
     "files": [
         "dist/",
+        "lib/analysis/",
+        "lib/state/",
+        "lib/config.ts",
+        "lib/logger.ts",
+        "lib/messages/query.ts",
+        "lib/token-utils.ts",
+        "tui/data/",
+        "tui/routes/",
+        "tui/shared/",
+        "tui/slots/",
+        "tui/index.tsx",
         "README.md",
         "LICENSE"
     ]

package/tui/data/context.ts

@@ -0,0 +1,177 @@
+import { Logger } from "../../lib/logger"
+import {
+    createSessionState,
+    loadSessionState,
+    type SessionState,
+    type WithParts,
+} from "../../lib/state"
+import {
+    findLastCompactionTimestamp,
+    getActiveSummaryTokenUsage,
+    loadPruneMap,
+    loadPruneMessagesState,
+} from "../../lib/state/utils"
+import { loadAllSessionStats } from "../../lib/state/persistence"
+import { analyzeTokens, emptyBreakdown } from "../../lib/analysis/tokens"
+import type { DcpContextSnapshot, DcpTuiClient } from "../shared/types"
+
+const snapshotCache = new Map<string, DcpContextSnapshot>()
+const inflightSnapshots = new Map<string, Promise<DcpContextSnapshot>>()
+const CACHE_TTL_MS = 5000
+
+export const createPlaceholderContextSnapshot = (
+    sessionID?: string,
+    notes: string[] = [],
+): DcpContextSnapshot => ({
+    sessionID,
+    breakdown: emptyBreakdown(),
+    activeSummaryTokens: 0,
+    persisted: {
+        available: false,
+        activeBlockCount: 0,
+        activeBlocks: [],
+    },
+    messageStatuses: [],
+    allTimeStats: { totalTokensSaved: 0, sessionCount: 0 },
+    notes,
+    loadedAt: Date.now(),
+})
+
+function cleanBlockSummary(raw: string): string {
+    return raw
+        .replace(/^\s*\[Compressed conversation section\]\s*/i, "")
+        .replace(/(?:\r?\n)*<dcp-message-id>b\d+<\/dcp-message-id>\s*$/i, "")
+        .trim()
+}
+
+const buildState = async (
+    sessionID: string,
+    messages: WithParts[],
+    logger: Logger,
+): Promise<{ state: SessionState; persisted: Awaited<ReturnType<typeof loadSessionState>> }> => {
+    const state = createSessionState()
+    const persisted = await loadSessionState(sessionID, logger)
+
+    state.sessionId = sessionID
+    state.lastCompaction = findLastCompactionTimestamp(messages)
+    state.stats.pruneTokenCounter = 0
+    state.stats.totalPruneTokens = persisted?.stats?.totalPruneTokens || 0
+    state.prune.tools = loadPruneMap(persisted?.prune?.tools)
+    state.prune.messages = loadPruneMessagesState(persisted?.prune?.messages)
+
+    return {
+        state,
+        persisted,
+    }
+}
+
+const loadContextSnapshot = async (
+    client: DcpTuiClient,
+    logger: Logger,
+    sessionID?: string,
+): Promise<DcpContextSnapshot> => {
+    if (!sessionID) {
+        return createPlaceholderContextSnapshot(undefined, ["No active session."])
+    }
+
+    const messagesResult = await client.session.messages({ sessionID })
+    const rawMessages =
+        messagesResult && typeof messagesResult === "object" && "data" in messagesResult
+            ? messagesResult.data
+            : messagesResult
+    const messages = Array.isArray(rawMessages) ? (rawMessages as WithParts[]) : ([] as WithParts[])
+
+    const { state, persisted } = await buildState(sessionID, messages, logger)
+    const [{ breakdown, messageStatuses }, aggregated] = await Promise.all([
+        Promise.resolve(analyzeTokens(state, messages)),
+        loadAllSessionStats(logger),
+    ])
+
+    const allBlocks = Array.from(state.prune.messages.activeBlockIds)
+        .map((blockID) => state.prune.messages.blocksById.get(blockID))
+        .filter((block): block is NonNullable<typeof block> => !!block && !!block.topic)
+        .map((block) => ({ topic: block.topic, summary: cleanBlockSummary(block.summary) }))
+
+    const notes: string[] = []
+    if (persisted) {
+        notes.push("Using live session messages plus persisted DCP state.")
+    } else {
+        notes.push("No saved DCP state found for this session yet.")
+    }
+    if (messages.length === 0) {
+        notes.push("This session does not have any messages yet.")
+    }
+
+    return {
+        sessionID,
+        breakdown,
+        activeSummaryTokens: getActiveSummaryTokenUsage(state),
+        persisted: {
+            available: !!persisted,
+            activeBlockCount: state.prune.messages.activeBlockIds.size,
+            activeBlocks: allBlocks,
+            lastUpdated: persisted?.lastUpdated,
+        },
+        messageStatuses,
+        allTimeStats: {
+            totalTokensSaved: aggregated.totalTokens,
+            sessionCount: aggregated.sessionCount,
+        },
+        notes,
+        loadedAt: Date.now(),
+    }
+}
+
+export const peekContextSnapshot = (sessionID?: string): DcpContextSnapshot | undefined => {
+    if (!sessionID) return undefined
+    return snapshotCache.get(sessionID)
+}
+
+export const invalidateContextSnapshot = (sessionID?: string) => {
+    if (!sessionID) {
+        snapshotCache.clear()
+        inflightSnapshots.clear()
+        return
+    }
+    snapshotCache.delete(sessionID)
+    inflightSnapshots.delete(sessionID)
+}
+
+export const loadContextSnapshotCached = async (
+    client: DcpTuiClient,
+    logger: Logger,
+    sessionID?: string,
+): Promise<DcpContextSnapshot> => {
+    if (!sessionID) {
+        return createPlaceholderContextSnapshot(undefined, ["No active session."])
+    }
+
+    const cached = snapshotCache.get(sessionID)
+    if (cached && Date.now() - cached.loadedAt < CACHE_TTL_MS) {
+        return cached
+    }
+
+    const inflight = inflightSnapshots.get(sessionID)
+    if (inflight) {
+        return inflight
+    }
+
+    const request = loadContextSnapshot(client, logger, sessionID)
+        .then((snapshot) => {
+            snapshotCache.set(sessionID, snapshot)
+            return snapshot
+        })
+        .catch((error) => {
+            logger.error("Failed to load TUI context snapshot", {
+                sessionID,
+                error: error instanceof Error ? error.message : String(error),
+            })
+            throw error
+        })
+        .finally(() => {
+            inflightSnapshots.delete(sessionID)
+        })
+
+    inflightSnapshots.set(sessionID, request)
+    return request
+}

package/tui/index.tsx

@@ -0,0 +1,34 @@
+/** @jsxImportSource @opentui/solid */
+import type { TuiPlugin } from "@opencode-ai/plugin/tui"
+import { getConfigForDirectory } from "../lib/config"
+import { Logger } from "../lib/logger"
+import { createSidebarContentSlot } from "./slots/sidebar-content"
+import { createSummaryRoute } from "./routes/summary"
+import { NAMES } from "./shared/names"
+
+const tui: TuiPlugin = async (api) => {
+    const config = getConfigForDirectory(api.state.path.directory, (title, message) => {
+        api.ui.toast({
+            title,
+            message,
+            variant: "warning",
+            duration: 7000,
+        })
+    })
+    if (!config.enabled) return
+
+    const logger = new Logger(config.tui.debug, "tui")
+
+    api.route.register([createSummaryRoute(api)])
+
+    if (config.tui.sidebar) {
+        api.slots.register(createSidebarContentSlot(api, NAMES, logger))
+    }
+}
+
+const id = "opencode-dynamic-context-pruning"
+
+export default {
+    id,
+    tui,
+}

package/tui/routes/summary.tsx

@@ -0,0 +1,175 @@
+/** @jsxImportSource @opentui/solid */
+import { createMemo, createSignal, For, Show } from "solid-js"
+import { useKeyboard } from "@opentui/solid"
+import type { TuiPluginApi } from "@opencode-ai/plugin/tui"
+import { getPalette, type DcpPalette } from "../shared/theme"
+import { LABEL, NAMES } from "../shared/names"
+
+const SINGLE_BORDER = { type: "single" } as any
+
+interface SummaryRouteParams {
+    topic?: string
+    summary?: string
+    sessionID?: string
+}
+
+interface CollapsibleSection {
+    label: string
+    content: string
+}
+
+interface ParsedSummary {
+    body: string
+    sections: CollapsibleSection[]
+}
+
+// These patterns must stay in sync with the exact headings produced by
+// lib/compress (compactSummary output). If compression wording changes,
+// update these patterns accordingly.
+const SECTION_HEADINGS: { pattern: RegExp; label: string }[] = [
+    {
+        pattern: /\n*The following user messages were sent in this conversation verbatim:/,
+        label: "Protected User Messages",
+    },
+    {
+        pattern: /\n*The following protected tools were used in this conversation as well:/,
+        label: "Protected Tools",
+    },
+    {
+        pattern:
+            /\n*The following previously compressed summaries were also part of this conversation section:/,
+        label: "Included Compressed Summaries",
+    },
+]
+
+function parseSummary(raw: string): ParsedSummary {
+    if (!raw) return { body: "", sections: [] }
+
+    const matches: { index: number; length: number; label: string }[] = []
+    for (const heading of SECTION_HEADINGS) {
+        const match = raw.match(heading.pattern)
+        if (match && match.index !== undefined) {
+            matches.push({ index: match.index, length: match[0].length, label: heading.label })
+        }
+    }
+
+    if (matches.length === 0) {
+        return { body: raw, sections: [] }
+    }
+
+    matches.sort((a, b) => a.index - b.index)
+
+    const body = raw.slice(0, matches[0].index).trimEnd()
+    const sections: CollapsibleSection[] = []
+
+    for (let i = 0; i < matches.length; i++) {
+        const start = matches[i].index + matches[i].length
+        const end = i + 1 < matches.length ? matches[i + 1].index : raw.length
+        const content = raw.slice(start, end).trim()
+        if (content) {
+            sections.push({ label: matches[i].label, content })
+        }
+    }
+
+    return { body, sections }
+}
+
+function CollapsibleSectionRow(props: { section: CollapsibleSection; palette: DcpPalette }) {
+    const [expanded, setExpanded] = createSignal(false)
+
+    return (
+        <box flexDirection="column" width="100%" marginTop={1}>
+            <box flexDirection="row" width="100%" height={1}>
+                <box
+                    backgroundColor={props.palette.base}
+                    height={1}
+                    onMouseUp={() => setExpanded(!expanded())}
+                >
+                    <text fg={props.palette.accent}>{expanded() ? " ▼ " : " ▶ "}</text>
+                </box>
+                <box height={1} paddingLeft={1}>
+                    <text fg={props.palette.muted} onMouseUp={() => setExpanded(!expanded())}>
+                        {props.section.label}
+                    </text>
+                </box>
+            </box>
+            <Show when={expanded()}>
+                <box width="100%" marginTop={1} paddingLeft={2} flexDirection="column">
+                    <text fg={props.palette.text}>{props.section.content}</text>
+                </box>
+            </Show>
+        </box>
+    )
+}
+
+function SummaryScreen(props: { api: TuiPluginApi; params: SummaryRouteParams }) {
+    const palette = createMemo(() => getPalette(props.api.theme.current as Record<string, unknown>))
+    const parsed = createMemo(() => parseSummary(props.params.summary || ""))
+
+    const keys = props.api.keybind.create({ close: "escape" })
+
+    useKeyboard((evt: any) => {
+        if (props.api.route.current.name !== NAMES.routes.summary) return
+        if (props.api.ui.dialog.open) return
+        const matched = keys.match("close", evt)
+        if (!matched) return
+        evt.preventDefault()
+        evt.stopPropagation()
+        const sessionID = props.params.sessionID
+        if (sessionID) {
+            props.api.route.navigate("session", { sessionID })
+        } else {
+            props.api.route.navigate("home")
+        }
+    })
+
+    return (
+        <box
+            flexDirection="column"
+            width="100%"
+            height="100%"
+            padding={1}
+            backgroundColor={palette().surface}
+        >
+            <box flexDirection="row" gap={1} alignItems="center">
+                <box paddingLeft={1} paddingRight={1} backgroundColor={palette().accent}>
+                    <text fg={palette().panel}>
+                        <b>{LABEL}</b>
+                    </text>
+                </box>
+                <text fg={palette().accent}>
+                    <b>{props.params.topic || "Compression Summary"}</b>
+                </text>
+            </box>
+
+            <box
+                flexGrow={1}
+                width="100%"
+                marginTop={1}
+                border={SINGLE_BORDER}
+                borderColor={palette().border}
+                padding={1}
+                flexDirection="column"
+            >
+                <text fg={palette().text}>{parsed().body || "(no summary available)"}</text>
+
+                <For each={parsed().sections}>
+                    {(section) => <CollapsibleSectionRow section={section} palette={palette()} />}
+                </For>
+            </box>
+
+            <box marginTop={1}>
+                <text {...({ dim: true } as any)} fg={palette().muted}>
+                    Press Escape to return
+                </text>
+            </box>
+        </box>
+    )
+}
+
+export const createSummaryRoute = (api: TuiPluginApi) => ({
+    name: NAMES.routes.summary,
+    render: (input: { params?: Record<string, unknown> }) => (
+        <SummaryScreen api={api} params={(input.params ?? {}) as SummaryRouteParams} />
+    ),
+})

package/tui/shared/names.ts

@@ -0,0 +1,9 @@
+export const LABEL = "DCP"
+
+export const NAMES = {
+    routes: {
+        summary: "dcp.summary",
+    },
+} as const
+
+export type DcpRouteNames = typeof NAMES

package/tui/shared/theme.ts

@@ -0,0 +1,58 @@
+import type { RGBA } from "@opentui/core"
+
+export type DcpColor = RGBA | string
+
+export interface DcpPalette {
+    panel: DcpColor
+    base: DcpColor
+    surface: DcpColor
+    border: DcpColor
+    text: DcpColor
+    muted: DcpColor
+    accent: DcpColor
+    success: DcpColor
+    warning: DcpColor
+}
+
+export type DcpTone = "text" | "muted" | "accent" | "success" | "warning"
+
+const defaults = {
+    panel: "#111111",
+    base: "#1d1d1d",
+    surface: "#171717",
+    border: "#4a4a4a",
+    text: "#f0f0f0",
+    muted: "#a5a5a5",
+    accent: "#5f87ff",
+    success: "#67b95f",
+    warning: "#d7a94b",
+}
+
+export const getPalette = (theme: Record<string, unknown>): DcpPalette => {
+    const get = (name: string, fallback: string): DcpColor => {
+        const value = theme[name]
+        if (typeof value === "string") return value
+        if (value && typeof value === "object") return value as RGBA
+        return fallback
+    }
+
+    return {
+        panel: get("backgroundPanel", defaults.panel),
+        base: get("backgroundElement", defaults.base),
+        surface: get("background", defaults.surface),
+        border: get("border", defaults.border),
+        text: get("text", defaults.text),
+        muted: get("textMuted", defaults.muted),
+        accent: get("primary", defaults.accent),
+        success: get("success", defaults.success),
+        warning: get("warning", defaults.warning),
+    }
+}
+
+export const toneColor = (palette: DcpPalette, tone: DcpTone = "text") => {
+    if (tone === "accent") return palette.accent
+    if (tone === "success") return palette.success
+    if (tone === "warning") return palette.warning
+    if (tone === "muted") return palette.muted
+    return palette.text
+}