@tarquinen/opencode-dcp 3.1.12 → 3.1.14

package/lib/commands/context.ts

@@ -0,0 +1,305 @@
+/**
+ * DCP Context Command
+ * Shows a visual breakdown of token usage in the current session.
+ *
+ * TOKEN CALCULATION STRATEGY
+ * ==========================
+ * We minimize tokenizer estimation by leveraging API-reported values wherever possible.
+ *
+ * WHAT WE GET FROM THE API (exact):
+ *   - tokens.input    : Input tokens for each assistant response
+ *   - tokens.output   : Output tokens generated (includes text + tool calls)
+ *   - tokens.reasoning: Reasoning tokens used
+ *   - tokens.cache    : Cache read/write tokens
+ *
+ * HOW WE CALCULATE EACH CATEGORY:
+ *
+ *   SYSTEM = firstAssistant.input + cache.read + cache.write - tokenizer(firstUserMessage)
+ *            The first response's total input (input + cache.read + cache.write)
+ *            contains system + first user message. On the first request of a
+ *            session, the system prompt appears in cache.write (cache creation),
+ *            not cache.read.
+ *
+ *   TOOLS  = tokenizer(toolInputs + toolOutputs) - prunedTokens
+ *            We must tokenize tools anyway for pruning decisions.
+ *
+ *   USER   = tokenizer(all user messages)
+ *            User messages are typically small, so estimation is acceptable.
+ *
+ *   ASSISTANT = total - system - user - tools
+ *               Calculated as residual. This absorbs:
+ *               - Assistant text output tokens
+ *               - Reasoning tokens (if persisted by the model)
+ *               - Any estimation errors
+ *
+ *   TOTAL  = input + output + reasoning + cache.read + cache.write
+ *            Matches opencode's UI display.
+ *
+ * WHY ASSISTANT IS THE RESIDUAL:
+ *   If reasoning tokens persist in context (model-dependent), they semantically
+ *   belong with "Assistant" since reasoning IS assistant-generated content.
+ */
+
+import type { Logger } from "../logger"
+import type { SessionState, WithParts } from "../state"
+import { sendIgnoredMessage } from "../ui/notification"
+import { formatTokenCount } from "../ui/utils"
+import { isIgnoredUserMessage } from "../messages/query"
+import { isMessageCompacted } from "../state/utils"
+import { countTokens, extractCompletedToolOutput, getCurrentParams } from "../token-utils"
+import type { AssistantMessage, TextPart, ToolPart } from "@opencode-ai/sdk/v2"
+
+export interface ContextCommandContext {
+    client: any
+    state: SessionState
+    logger: Logger
+    sessionId: string
+    messages: WithParts[]
+}
+
+interface TokenBreakdown {
+    system: number
+    user: number
+    assistant: number
+    tools: number
+    toolCount: number
+    toolsInContextCount: number
+    prunedTokens: number
+    prunedToolCount: number
+    prunedMessageCount: number
+    total: number
+}
+
+export function analyzeContextTokens(state: SessionState, messages: WithParts[]): TokenBreakdown {
+    const breakdown: TokenBreakdown = {
+        system: 0,
+        user: 0,
+        assistant: 0,
+        tools: 0,
+        toolCount: 0,
+        toolsInContextCount: 0,
+        prunedTokens: state.stats.totalPruneTokens,
+        prunedToolCount: 0,
+        prunedMessageCount: 0,
+        total: 0,
+    }
+
+    let firstAssistant: AssistantMessage | undefined
+    for (const msg of messages) {
+        if (msg.info.role === "assistant") {
+            const assistantInfo = msg.info as AssistantMessage
+            if (
+                assistantInfo.tokens?.input > 0 ||
+                assistantInfo.tokens?.cache?.read > 0 ||
+                assistantInfo.tokens?.cache?.write > 0
+            ) {
+                firstAssistant = assistantInfo
+                break
+            }
+        }
+    }
+
+    let lastAssistant: AssistantMessage | undefined
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const msg = messages[i]
+        if (msg.info.role === "assistant") {
+            const assistantInfo = msg.info as AssistantMessage
+            if (assistantInfo.tokens?.output > 0) {
+                lastAssistant = assistantInfo
+                break
+            }
+        }
+    }
+
+    const apiInput = lastAssistant?.tokens?.input || 0
+    const apiOutput = lastAssistant?.tokens?.output || 0
+    const apiReasoning = lastAssistant?.tokens?.reasoning || 0
+    const apiCacheRead = lastAssistant?.tokens?.cache?.read || 0
+    const apiCacheWrite = lastAssistant?.tokens?.cache?.write || 0
+    breakdown.total = apiInput + apiOutput + apiReasoning + apiCacheRead + apiCacheWrite
+
+    const userTextParts: string[] = []
+    const toolInputParts: string[] = []
+    const toolOutputParts: string[] = []
+    let firstUserText = ""
+    let foundFirstUser = false
+    const allToolIds = new Set<string>()
+    const activeToolIds = new Set<string>()
+    const prunedByMessageToolIds = new Set<string>()
+    const allMessageIds = new Set<string>()
+
+    for (const msg of messages) {
+        allMessageIds.add(msg.info.id)
+        const parts = Array.isArray(msg.parts) ? msg.parts : []
+        const isCompacted = isMessageCompacted(state, msg)
+        const pruneEntry = state.prune.messages.byMessageId.get(msg.info.id)
+        const isMessagePruned = !!pruneEntry && pruneEntry.activeBlockIds.length > 0
+        const isIgnoredUser = isIgnoredUserMessage(msg)
+
+        for (const part of parts) {
+            if (part.type === "tool") {
+                const toolPart = part as ToolPart
+                if (toolPart.callID) {
+                    allToolIds.add(toolPart.callID)
+                    if (!isCompacted) {
+                        activeToolIds.add(toolPart.callID)
+                    }
+                    if (isMessagePruned) {
+                        prunedByMessageToolIds.add(toolPart.callID)
+                    }
+                }
+
+                const isPruned = toolPart.callID && state.prune.tools.has(toolPart.callID)
+                if (!isCompacted && !isPruned) {
+                    if (toolPart.state?.input) {
+                        const inputStr =
+                            typeof toolPart.state.input === "string"
+                                ? toolPart.state.input
+                                : JSON.stringify(toolPart.state.input)
+                        toolInputParts.push(inputStr)
+                    }
+
+                    const outputStr = extractCompletedToolOutput(toolPart)
+                    if (outputStr !== undefined) {
+                        toolOutputParts.push(outputStr)
+                    }
+                }
+            } else if (
+                part.type === "text" &&
+                msg.info.role === "user" &&
+                !isCompacted &&
+                !isIgnoredUser
+            ) {
+                const textPart = part as TextPart
+                const text = textPart.text || ""
+                userTextParts.push(text)
+                if (!foundFirstUser) {
+                    firstUserText += text
+                }
+            }
+        }
+
+        if (msg.info.role === "user" && !isIgnoredUser && !foundFirstUser) {
+            foundFirstUser = true
+        }
+    }
+
+    const prunedByToolIds = new Set<string>()
+    for (const id of allToolIds) {
+        if (state.prune.tools.has(id)) {
+            prunedByToolIds.add(id)
+        }
+    }
+
+    const prunedToolIds = new Set<string>([...prunedByToolIds, ...prunedByMessageToolIds])
+    const toolsInContextCount = [...activeToolIds].filter((id) => !prunedByToolIds.has(id)).length
+
+    let prunedMessageCount = 0
+    for (const [id, entry] of state.prune.messages.byMessageId) {
+        if (allMessageIds.has(id) && entry.activeBlockIds.length > 0) {
+            prunedMessageCount++
+        }
+    }
+
+    breakdown.toolCount = allToolIds.size
+    breakdown.toolsInContextCount = toolsInContextCount
+    breakdown.prunedToolCount = prunedToolIds.size
+    breakdown.prunedMessageCount = prunedMessageCount
+
+    const firstUserTokens = countTokens(firstUserText)
+    breakdown.user = countTokens(userTextParts.join("\n"))
+    const toolInputTokens = countTokens(toolInputParts.join("\n"))
+    const toolOutputTokens = countTokens(toolOutputParts.join("\n"))
+
+    if (firstAssistant) {
+        const firstInput =
+            (firstAssistant.tokens?.input || 0) +
+            (firstAssistant.tokens?.cache?.read || 0) +
+            (firstAssistant.tokens?.cache?.write || 0)
+        breakdown.system = Math.max(0, firstInput - firstUserTokens)
+    }
+
+    breakdown.tools = toolInputTokens + toolOutputTokens
+    breakdown.assistant = Math.max(
+        0,
+        breakdown.total - breakdown.system - breakdown.user - breakdown.tools,
+    )
+
+    return breakdown
+}
+
+function createBar(value: number, maxValue: number, width: number, char: string = "█"): string {
+    if (maxValue === 0) return ""
+    const filled = Math.round((value / maxValue) * width)
+    const bar = char.repeat(Math.max(0, filled))
+    return bar
+}
+
+export function formatContextMessage(breakdown: TokenBreakdown): string {
+    const lines: string[] = []
+    const barWidth = 30
+
+    const toolsLabel = `Tools (${breakdown.toolsInContextCount})`
+
+    const categories = [
+        { label: "System", value: breakdown.system, char: "█" },
+        { label: "User", value: breakdown.user, char: "▓" },
+        { label: "Assistant", value: breakdown.assistant, char: "▒" },
+        { label: toolsLabel, value: breakdown.tools, char: "░" },
+    ] as const
+
+    const maxLabelLen = Math.max(...categories.map((c) => c.label.length))
+
+    lines.push("╭───────────────────────────────────────────────────────────╮")
+    lines.push("│                  DCP Context Analysis                     │")
+    lines.push("╰───────────────────────────────────────────────────────────╯")
+    lines.push("")
+    lines.push("Session Context Breakdown:")
+    lines.push("─".repeat(60))
+    lines.push("")
+
+    for (const cat of categories) {
+        const bar = createBar(cat.value, breakdown.total, barWidth, cat.char)
+        const percentage =
+            breakdown.total > 0 ? ((cat.value / breakdown.total) * 100).toFixed(1) : "0.0"
+        const labelWithPct = `${cat.label.padEnd(maxLabelLen)} ${percentage.padStart(5)}% `
+        const valueStr = formatTokenCount(cat.value).padStart(13)
+        lines.push(`${labelWithPct}│${bar.padEnd(barWidth)}│${valueStr}`)
+    }
+
+    lines.push("")
+    lines.push("─".repeat(60))
+    lines.push("")
+
+    lines.push("Summary:")
+
+    if (breakdown.prunedTokens > 0) {
+        const withoutPruning = breakdown.total + breakdown.prunedTokens
+        const pruned = []
+        if (breakdown.prunedToolCount > 0) pruned.push(`${breakdown.prunedToolCount} tools`)
+        if (breakdown.prunedMessageCount > 0)
+            pruned.push(`${breakdown.prunedMessageCount} messages`)
+        lines.push(
+            `  Pruned:          ${pruned.join(", ")} (~${formatTokenCount(breakdown.prunedTokens)})`,
+        )
+        lines.push(`  Current context: ~${formatTokenCount(breakdown.total)}`)
+        lines.push(`  Without DCP:     ~${formatTokenCount(withoutPruning)}`)
+    } else {
+        lines.push(`  Current context: ~${formatTokenCount(breakdown.total)}`)
+    }
+
+    lines.push("")
+
+    return lines.join("\n")
+}
+
+export async function handleContextCommand(ctx: ContextCommandContext): Promise<void> {
+    const { client, state, logger, sessionId, messages } = ctx
+
+    const breakdown = analyzeContextTokens(state, messages)
+
+    const message = formatContextMessage(breakdown)
+
+    const params = getCurrentParams(state, messages, logger)
+    await sendIgnoredMessage(client, sessionId, message, params, logger)
+}

package/lib/commands/decompress.ts

@@ -0,0 +1,275 @@
+import type { Logger } from "../logger"
+import type { CompressionBlock, PruneMessagesState, SessionState, WithParts } from "../state"
+import { syncCompressionBlocks } from "../messages"
+import { parseBlockRef } from "../message-ids"
+import { getCurrentParams } from "../token-utils"
+import { saveSessionState } from "../state/persistence"
+import { sendIgnoredMessage } from "../ui/notification"
+import { formatTokenCount } from "../ui/utils"
+import {
+    getActiveCompressionTargets,
+    resolveCompressionTarget,
+    type CompressionTarget,
+} from "./compression-targets"
+
+export interface DecompressCommandContext {
+    client: any
+    state: SessionState
+    logger: Logger
+    sessionId: string
+    messages: WithParts[]
+    args: string[]
+}
+
+function parseBlockIdArg(arg: string): number | null {
+    const normalized = arg.trim().toLowerCase()
+    const blockRef = parseBlockRef(normalized)
+    if (blockRef !== null) {
+        return blockRef
+    }
+
+    if (!/^[1-9]\d*$/.test(normalized)) {
+        return null
+    }
+
+    const parsed = Number.parseInt(normalized, 10)
+    return Number.isInteger(parsed) && parsed > 0 ? parsed : null
+}
+
+function findActiveParentBlockId(
+    messagesState: PruneMessagesState,
+    block: CompressionBlock,
+): number | null {
+    const queue = [...block.parentBlockIds]
+    const visited = new Set<number>()
+
+    while (queue.length > 0) {
+        const parentBlockId = queue.shift()
+        if (parentBlockId === undefined || visited.has(parentBlockId)) {
+            continue
+        }
+        visited.add(parentBlockId)
+
+        const parent = messagesState.blocksById.get(parentBlockId)
+        if (!parent) {
+            continue
+        }
+
+        if (parent.active) {
+            return parent.blockId
+        }
+
+        for (const ancestorId of parent.parentBlockIds) {
+            if (!visited.has(ancestorId)) {
+                queue.push(ancestorId)
+            }
+        }
+    }
+
+    return null
+}
+
+function findActiveAncestorBlockId(
+    messagesState: PruneMessagesState,
+    target: CompressionTarget,
+): number | null {
+    for (const block of target.blocks) {
+        const activeAncestorBlockId = findActiveParentBlockId(messagesState, block)
+        if (activeAncestorBlockId !== null) {
+            return activeAncestorBlockId
+        }
+    }
+
+    return null
+}
+
+function snapshotActiveMessages(messagesState: PruneMessagesState): Map<string, number> {
+    const activeMessages = new Map<string, number>()
+    for (const [messageId, entry] of messagesState.byMessageId) {
+        if (entry.activeBlockIds.length > 0) {
+            activeMessages.set(messageId, entry.tokenCount)
+        }
+    }
+    return activeMessages
+}
+
+function formatDecompressMessage(
+    target: CompressionTarget,
+    restoredMessageCount: number,
+    restoredTokens: number,
+    reactivatedBlockIds: number[],
+): string {
+    const lines: string[] = []
+
+    lines.push(`Restored compression ${target.displayId}.`)
+    if (target.runId !== target.displayId || target.grouped) {
+        lines.push(`Tool call label: Compression #${target.runId}.`)
+    }
+    if (reactivatedBlockIds.length > 0) {
+        const refs = reactivatedBlockIds.map((id) => String(id)).join(", ")
+        lines.push(`Also restored nested compression(s): ${refs}.`)
+    }
+
+    if (restoredMessageCount > 0) {
+        lines.push(
+            `Restored ${restoredMessageCount} message(s) (~${formatTokenCount(restoredTokens)}).`,
+        )
+    } else {
+        lines.push("No messages were restored.")
+    }
+
+    return lines.join("\n")
+}
+
+function formatAvailableBlocksMessage(availableTargets: CompressionTarget[]): string {
+    const lines: string[] = []
+
+    lines.push("Usage: /dcp decompress <n>")
+    lines.push("")
+
+    if (availableTargets.length === 0) {
+        lines.push("No compressions are available to restore.")
+        return lines.join("\n")
+    }
+
+    lines.push("Available compressions:")
+    const entries = availableTargets.map((target) => {
+        const topic = target.topic.replace(/\s+/g, " ").trim() || "(no topic)"
+        const label = `${target.displayId} (${formatTokenCount(target.compressedTokens)})`
+        const details = target.grouped
+            ? `Compression #${target.runId} - ${target.blocks.length} messages`
+            : `Compression #${target.runId}`
+        return { label, topic: `${details} - ${topic}` }
+    })
+
+    const labelWidth = Math.max(...entries.map((entry) => entry.label.length)) + 4
+    for (const entry of entries) {
+        lines.push(`  ${entry.label.padEnd(labelWidth)}${entry.topic}`)
+    }
+
+    return lines.join("\n")
+}
+
+export async function handleDecompressCommand(ctx: DecompressCommandContext): Promise<void> {
+    const { client, state, logger, sessionId, messages, args } = ctx
+
+    const params = getCurrentParams(state, messages, logger)
+    const targetArg = args[0]
+
+    if (args.length > 1) {
+        await sendIgnoredMessage(
+            client,
+            sessionId,
+            "Invalid arguments. Usage: /dcp decompress <n>",
+            params,
+            logger,
+        )
+        return
+    }
+
+    syncCompressionBlocks(state, logger, messages)
+    const messagesState = state.prune.messages
+
+    if (!targetArg) {
+        const availableTargets = getActiveCompressionTargets(messagesState)
+        const message = formatAvailableBlocksMessage(availableTargets)
+        await sendIgnoredMessage(client, sessionId, message, params, logger)
+        return
+    }
+
+    const targetBlockId = parseBlockIdArg(targetArg)
+    if (targetBlockId === null) {
+        await sendIgnoredMessage(
+            client,
+            sessionId,
+            `Please enter a compression number. Example: /dcp decompress 2`,
+            params,
+            logger,
+        )
+        return
+    }
+
+    const target = resolveCompressionTarget(messagesState, targetBlockId)
+    if (!target) {
+        await sendIgnoredMessage(
+            client,
+            sessionId,
+            `Compression ${targetBlockId} does not exist.`,
+            params,
+            logger,
+        )
+        return
+    }
+
+    const activeBlocks = target.blocks.filter((block) => block.active)
+    if (activeBlocks.length === 0) {
+        const activeAncestorBlockId = findActiveAncestorBlockId(messagesState, target)
+        if (activeAncestorBlockId !== null) {
+            await sendIgnoredMessage(
+                client,
+                sessionId,
+                `Compression ${target.displayId} is inside compression ${activeAncestorBlockId}. Restore compression ${activeAncestorBlockId} first.`,
+                params,
+                logger,
+            )
+            return
+        }
+
+        await sendIgnoredMessage(
+            client,
+            sessionId,
+            `Compression ${target.displayId} is not active.`,
+            params,
+            logger,
+        )
+        return
+    }
+
+    const activeMessagesBefore = snapshotActiveMessages(messagesState)
+    const activeBlockIdsBefore = new Set(messagesState.activeBlockIds)
+    const deactivatedAt = Date.now()
+
+    for (const block of target.blocks) {
+        block.active = false
+        block.deactivatedByUser = true
+        block.deactivatedAt = deactivatedAt
+        block.deactivatedByBlockId = undefined
+    }
+
+    syncCompressionBlocks(state, logger, messages)
+
+    let restoredMessageCount = 0
+    let restoredTokens = 0
+    for (const [messageId, tokenCount] of activeMessagesBefore) {
+        const entry = messagesState.byMessageId.get(messageId)
+        const isActiveNow = entry ? entry.activeBlockIds.length > 0 : false
+        if (!isActiveNow) {
+            restoredMessageCount++
+            restoredTokens += tokenCount
+        }
+    }
+
+    state.stats.totalPruneTokens = Math.max(0, state.stats.totalPruneTokens - restoredTokens)
+
+    const reactivatedBlockIds = Array.from(messagesState.activeBlockIds)
+        .filter((blockId) => !activeBlockIdsBefore.has(blockId))
+        .sort((a, b) => a - b)
+
+    await saveSessionState(state, logger)
+
+    const message = formatDecompressMessage(
+        target,
+        restoredMessageCount,
+        restoredTokens,
+        reactivatedBlockIds,
+    )
+    await sendIgnoredMessage(client, sessionId, message, params, logger)
+
+    logger.info("Decompress command completed", {
+        targetBlockId: target.displayId,
+        targetRunId: target.runId,
+        restoredMessageCount,
+        restoredTokens,
+        reactivatedBlockIds,
+    })
+}

package/lib/commands/help.ts

@@ -0,0 +1,76 @@
+/**
+ * DCP Help command handler.
+ * Shows available DCP commands and their descriptions.
+ */
+
+import type { Logger } from "../logger"
+import type { PluginConfig } from "../config"
+import type { SessionState, WithParts } from "../state"
+import { compressPermission } from "../compress-permission"
+import { sendIgnoredMessage } from "../ui/notification"
+import { getCurrentParams } from "../token-utils"
+
+export interface HelpCommandContext {
+    client: any
+    state: SessionState
+    config: PluginConfig
+    logger: Logger
+    sessionId: string
+    messages: WithParts[]
+}
+
+const TUI_COMMANDS: [string, string][] = [
+    ["DCP Context", "Show token usage breakdown for current session"],
+    ["DCP Stats", "Show DCP pruning statistics"],
+    ["DCP Help", "Show this help in a modal"],
+]
+
+const TOOL_COMMANDS: Record<string, [string, string]> = {
+    compress: ["/dcp-compress [focus]", "Trigger manual compress tool execution"],
+    decompress: ["/dcp decompress <n>", "Restore selected compression"],
+    recompress: ["/dcp recompress <n>", "Re-apply a user-decompressed compression"],
+}
+
+function getVisibleCommands(state: SessionState, config: PluginConfig): [string, string][] {
+    const commands = [...TUI_COMMANDS]
+
+    if (compressPermission(state, config) !== "deny") {
+        commands.push(TOOL_COMMANDS.compress)
+    }
+
+    return commands
+}
+
+export function formatHelpMessage(state: SessionState, config: PluginConfig): string {
+    const commands = getVisibleCommands(state, config)
+    const colWidth = Math.max(...commands.map(([cmd]) => cmd.length)) + 4
+    const lines: string[] = []
+
+    lines.push("╭─────────────────────────────────────────────────────────────────────────╮")
+    lines.push("│                              DCP Commands                               │")
+    lines.push("╰─────────────────────────────────────────────────────────────────────────╯")
+    lines.push("")
+    lines.push(`  ${"Manual mode:".padEnd(colWidth)}${state.manualMode ? "ON" : "OFF"}`)
+    lines.push("")
+    lines.push("  Open the command palette for DCP modal commands.")
+    lines.push("  Use /dcp-compress [focus] when you want DCP to ask the model to run compression.")
+    lines.push("")
+    for (const [cmd, desc] of commands) {
+        lines.push(`  ${cmd.padEnd(colWidth)}${desc}`)
+    }
+    lines.push("")
+
+    return lines.join("\n")
+}
+
+export async function handleHelpCommand(ctx: HelpCommandContext): Promise<void> {
+    const { client, state, logger, sessionId, messages } = ctx
+
+    const { config } = ctx
+    const message = formatHelpMessage(state, config)
+
+    const params = getCurrentParams(state, messages, logger)
+    await sendIgnoredMessage(client, sessionId, message, params, logger)
+
+    logger.info("Help command executed")
+}

package/lib/commands/index.ts

@@ -0,0 +1,11 @@
+export { handleContextCommand } from "./context"
+export { handleDecompressCommand } from "./decompress"
+export { handleHelpCommand } from "./help"
+export {
+    applyPendingManualTrigger,
+    handleManualToggleCommand,
+    handleManualTriggerCommand,
+} from "./manual"
+export { handleRecompressCommand } from "./recompress"
+export { handleStatsCommand } from "./stats"
+export { handleSweepCommand } from "./sweep"