@tarquinen/opencode-dcp 3.2.5-beta0 → 3.2.6-beta0

package/lib/ui/utils.ts

@@ -0,0 +1,287 @@
+import { SessionState, ToolParameterEntry, WithParts } from "../state"
+import { countTokens } from "../token-utils"
+import { isIgnoredUserMessage } from "../messages/query"
+
+function extractParameterKey(tool: string, parameters: any): string {
+    if (!parameters) return ""
+
+    if (tool === "read" && parameters.filePath) {
+        const offset = parameters.offset
+        const limit = parameters.limit
+        if (offset !== undefined && limit !== undefined) {
+            return `${parameters.filePath} (lines ${offset}-${offset + limit})`
+        }
+        if (offset !== undefined) {
+            return `${parameters.filePath} (lines ${offset}+)`
+        }
+        if (limit !== undefined) {
+            return `${parameters.filePath} (lines 0-${limit})`
+        }
+        return parameters.filePath
+    }
+
+    if ((tool === "write" || tool === "edit" || tool === "multiedit") && parameters.filePath) {
+        return parameters.filePath
+    }
+
+    if (tool === "apply_patch" && typeof parameters.patchText === "string") {
+        const pathRegex = /\*\*\* (?:Add|Delete|Update) File: ([^\n\r]+)/g
+        const paths: string[] = []
+        let match
+        while ((match = pathRegex.exec(parameters.patchText)) !== null) {
+            paths.push(match[1].trim())
+        }
+        if (paths.length > 0) {
+            const uniquePaths = [...new Set(paths)]
+            const count = uniquePaths.length
+            const plural = count > 1 ? "s" : ""
+            if (count === 1) return uniquePaths[0]
+            if (count === 2) return uniquePaths.join(", ")
+            return `${count} file${plural}: ${uniquePaths[0]}, ${uniquePaths[1]}...`
+        }
+        return "patch"
+    }
+
+    if (tool === "list") {
+        return parameters.path || "(current directory)"
+    }
+
+    if (tool === "glob") {
+        if (parameters.pattern) {
+            const pathInfo = parameters.path ? ` in ${parameters.path}` : ""
+            return `"${parameters.pattern}"${pathInfo}`
+        }
+        return "(unknown pattern)"
+    }
+
+    if (tool === "grep") {
+        if (parameters.pattern) {
+            const pathInfo = parameters.path ? ` in ${parameters.path}` : ""
+            return `"${parameters.pattern}"${pathInfo}`
+        }
+        return "(unknown pattern)"
+    }
+
+    if (tool === "bash") {
+        if (parameters.description) return parameters.description
+        if (parameters.command) {
+            return parameters.command.length > 50
+                ? parameters.command.substring(0, 50) + "..."
+                : parameters.command
+        }
+    }
+
+    if (tool === "webfetch" && parameters.url) {
+        return parameters.url
+    }
+    if (tool === "websearch" && parameters.query) {
+        return `"${parameters.query}"`
+    }
+    if (tool === "codesearch" && parameters.query) {
+        return `"${parameters.query}"`
+    }
+
+    if (tool === "todowrite") {
+        return `${parameters.todos?.length || 0} todos`
+    }
+    if (tool === "todoread") {
+        return "read todo list"
+    }
+
+    if (tool === "task" && parameters.description) {
+        return parameters.description
+    }
+    if (tool === "skill" && parameters.name) {
+        return parameters.name
+    }
+
+    if (tool === "lsp") {
+        const op = parameters.operation || "lsp"
+        const path = parameters.filePath || ""
+        const line = parameters.line
+        const char = parameters.character
+        if (path && line !== undefined && char !== undefined) {
+            return `${op} ${path}:${line}:${char}`
+        }
+        if (path) {
+            return `${op} ${path}`
+        }
+        return op
+    }
+
+    if (tool === "question") {
+        const questions = parameters.questions
+        if (Array.isArray(questions) && questions.length > 0) {
+            const headers = questions
+                .map((q: any) => q.header || "")
+                .filter(Boolean)
+                .slice(0, 3)
+
+            const count = questions.length
+            const plural = count > 1 ? "s" : ""
+
+            if (headers.length > 0) {
+                const suffix = count > 3 ? ` (+${count - 3} more)` : ""
+                return `${count} question${plural}: ${headers.join(", ")}${suffix}`
+            }
+            return `${count} question${plural}`
+        }
+        return "question"
+    }
+
+    const paramStr = JSON.stringify(parameters)
+    if (paramStr === "{}" || paramStr === "[]" || paramStr === "null") {
+        return ""
+    }
+
+    return paramStr.substring(0, 50)
+}
+
+export function formatStatsHeader(totalTokensSaved: number, pruneTokenCounter: number): string {
+    const totalTokensSavedStr = `~${formatTokenCount(totalTokensSaved + pruneTokenCounter)}`
+    return [`▣ DCP | ${totalTokensSavedStr} saved total`].join("\n")
+}
+
+export function formatTokenCount(tokens: number, compact?: boolean): string {
+    const suffix = compact ? "" : " tokens"
+    if (tokens >= 1000) {
+        return `${(tokens / 1000).toFixed(1)}K`.replace(".0K", "K") + suffix
+    }
+    return tokens.toString() + suffix
+}
+
+export function truncate(str: string, maxLen: number = 60): string {
+    if (str.length <= maxLen) return str
+    return str.slice(0, maxLen - 3) + "..."
+}
+
+export function formatProgressBar(
+    messageIds: string[],
+    prunedMessages: Map<string, number>,
+    recentMessageIds: string[],
+    width: number = 50,
+): string {
+    const ACTIVE = "█"
+    const PRUNED = "░"
+    const RECENT = "⣿"
+    const recentSet = new Set(recentMessageIds)
+
+    const total = messageIds.length
+    if (total === 0) return `│${PRUNED.repeat(width)}│`
+
+    const bar = new Array(width).fill(ACTIVE)
+
+    for (let m = 0; m < total; m++) {
+        const msgId = messageIds[m]
+        const start = Math.floor((m / total) * width)
+        const end = Math.floor(((m + 1) / total) * width)
+
+        if (recentSet.has(msgId)) {
+            for (let i = start; i < end; i++) {
+                bar[i] = RECENT
+            }
+        } else if (prunedMessages.has(msgId)) {
+            for (let i = start; i < end; i++) {
+                bar[i] = PRUNED
+            }
+        }
+    }
+
+    return `│${bar.join("")}│`
+}
+
+export function cacheSystemPromptTokens(state: SessionState, messages: WithParts[]): void {
+    let firstInputTokens = 0
+    for (const msg of messages) {
+        if (msg.info.role !== "assistant") {
+            continue
+        }
+        const info = msg.info as any
+        const input = info?.tokens?.input || 0
+        const cacheRead = info?.tokens?.cache?.read || 0
+        const cacheWrite = info?.tokens?.cache?.write || 0
+        if (input > 0 || cacheRead > 0 || cacheWrite > 0) {
+            firstInputTokens = input + cacheRead + cacheWrite
+            break
+        }
+    }
+
+    if (firstInputTokens <= 0) {
+        state.systemPromptTokens = undefined
+        return
+    }
+
+    let firstUserText = ""
+    for (const msg of messages) {
+        if (msg.info.role !== "user" || isIgnoredUserMessage(msg)) {
+            continue
+        }
+        const parts = Array.isArray(msg.parts) ? msg.parts : []
+        for (const part of parts) {
+            if (part.type === "text" && !(part as any).ignored) {
+                firstUserText += part.text
+            }
+        }
+        break
+    }
+
+    const estimatedSystemTokens = Math.max(0, firstInputTokens - countTokens(firstUserText))
+    state.systemPromptTokens = estimatedSystemTokens > 0 ? estimatedSystemTokens : undefined
+}
+
+export function shortenPath(input: string, workingDirectory?: string): string {
+    const inPathMatch = input.match(/^(.+) in (.+)$/)
+    if (inPathMatch) {
+        const prefix = inPathMatch[1]
+        const pathPart = inPathMatch[2]
+        const shortenedPath = shortenSinglePath(pathPart, workingDirectory)
+        return `${prefix} in ${shortenedPath}`
+    }
+
+    return shortenSinglePath(input, workingDirectory)
+}
+
+function shortenSinglePath(path: string, workingDirectory?: string): string {
+    if (workingDirectory) {
+        if (path.startsWith(workingDirectory + "/")) {
+            return path.slice(workingDirectory.length + 1)
+        }
+        if (path === workingDirectory) {
+            return "."
+        }
+    }
+
+    return path
+}
+
+export function formatPrunedItemsList(
+    pruneToolIds: string[],
+    toolMetadata: Map<string, ToolParameterEntry>,
+    workingDirectory?: string,
+): string[] {
+    const lines: string[] = []
+
+    for (const id of pruneToolIds) {
+        const metadata = toolMetadata.get(id)
+
+        if (metadata) {
+            const paramKey = extractParameterKey(metadata.tool, metadata.parameters)
+            if (paramKey) {
+                // Use 60 char limit to match notification style
+                const displayKey = truncate(shortenPath(paramKey, workingDirectory), 60)
+                lines.push(`→ ${metadata.tool}: ${displayKey}`)
+            } else {
+                lines.push(`→ ${metadata.tool}`)
+            }
+        }
+    }
+
+    const knownCount = pruneToolIds.filter((id) => toolMetadata.has(id)).length
+    const unknownCount = pruneToolIds.length - knownCount
+
+    if (unknownCount > 0) {
+        lines.push(`→ (${unknownCount} tool${unknownCount > 1 ? "s" : ""} with unknown metadata)`)
+    }
+
+    return lines
+}

package/package.json

@@ -1,7 +1,7 @@
 {
     "$schema": "https://json.schemastore.org/package.json",
     "name": "@tarquinen/opencode-dcp",
-    "version": "3.2.5-beta0",
+    "version": "3.2.6-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": [
@@ -22,6 +22,13 @@
     ],
     "files": [
         "dist/",
+        "index.ts",
+        "lib/**/*.ts",
+        "tui/index.tsx",
+        "tui/data/*.ts",
+        "tui/routes/*.tsx",
+        "tui/shared/*.ts",
+        "tui/slots/*.tsx",
         "README.md",
         "LICENSE",
         "dcp.schema.json"

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} />
+    ),
+})