@tarquinen/opencode-dcp 3.1.12 → 3.1.13

package/lib/strategies/purge-errors.ts

@@ -0,0 +1,88 @@
+import { PluginConfig } from "../config"
+import { Logger } from "../logger"
+import type { SessionState, WithParts } from "../state"
+import {
+    getFilePathsFromParameters,
+    isFilePathProtected,
+    isToolNameProtected,
+} from "../protected-patterns"
+import { getTotalToolTokens } from "../token-utils"
+
+/**
+ * Purge Errors strategy - prunes tool inputs for tools that errored
+ * after they are older than a configurable number of turns.
+ * The error message is preserved, but the (potentially large) inputs
+ * are removed to save context.
+ *
+ * Modifies the session state in place to add pruned tool call IDs.
+ */
+export const purgeErrors = (
+    state: SessionState,
+    logger: Logger,
+    config: PluginConfig,
+    messages: WithParts[],
+): void => {
+    if (state.manualMode && !config.manualMode.automaticStrategies) {
+        return
+    }
+
+    if (!config.strategies.purgeErrors.enabled) {
+        return
+    }
+
+    const allToolIds = state.toolIdList
+    if (allToolIds.length === 0) {
+        return
+    }
+
+    // Filter out IDs already pruned
+    const unprunedIds = allToolIds.filter((id) => !state.prune.tools.has(id))
+
+    if (unprunedIds.length === 0) {
+        return
+    }
+
+    const protectedTools = config.strategies.purgeErrors.protectedTools
+    const turnThreshold = Math.max(1, config.strategies.purgeErrors.turns)
+
+    const newPruneIds: string[] = []
+
+    for (const id of unprunedIds) {
+        const metadata = state.toolParameters.get(id)
+        if (!metadata) {
+            continue
+        }
+
+        // Skip protected tools
+        if (isToolNameProtected(metadata.tool, protectedTools)) {
+            continue
+        }
+
+        const filePaths = getFilePathsFromParameters(metadata.tool, metadata.parameters)
+        if (isFilePathProtected(filePaths, config.protectedFilePatterns)) {
+            continue
+        }
+
+        // Only process error tools
+        if (metadata.status !== "error") {
+            continue
+        }
+
+        // Check if the tool is old enough to prune
+        const turnAge = state.currentTurn - metadata.turn
+        if (turnAge >= turnThreshold) {
+            newPruneIds.push(id)
+        }
+    }
+
+    if (newPruneIds.length > 0) {
+        state.stats.totalPruneTokens += getTotalToolTokens(state, newPruneIds)
+        for (const id of newPruneIds) {
+            const entry = state.toolParameters.get(id)
+            state.prune.tools.set(id, entry?.tokenCount ?? 0)
+        }
+        logger.debug(
+            `Marked ${newPruneIds.length} error tool calls for pruning (older than ${turnThreshold} turns)`,
+        )
+    }
+}

package/lib/subagents/subagent-results.ts

@@ -0,0 +1,74 @@
+import type { WithParts } from "../state"
+
+const SUB_AGENT_RESULT_BLOCK_REGEX = /(<task_result>\s*)([\s\S]*?)(\s*<\/task_result>)/i
+
+export function getSubAgentId(part: any): string | null {
+    const sessionId = part?.state?.metadata?.sessionId
+    if (typeof sessionId !== "string") {
+        return null
+    }
+
+    const value = sessionId.trim()
+    return value.length > 0 ? value : null
+}
+
+export function buildSubagentResultText(messages: WithParts[]): string {
+    const assistantMessages = messages.filter((message) => message.info.role === "assistant")
+    if (assistantMessages.length === 0) {
+        return ""
+    }
+
+    const lastAssistant = assistantMessages[assistantMessages.length - 1]
+    const lastText = getLastTextPart(lastAssistant)
+
+    if (assistantMessages.length < 2) {
+        return lastText
+    }
+
+    const secondToLastAssistant = assistantMessages[assistantMessages.length - 2]
+    if (!assistantMessageHasCompressTool(secondToLastAssistant)) {
+        return lastText
+    }
+
+    const secondToLastText = getLastTextPart(secondToLastAssistant)
+    return [secondToLastText, lastText].filter((text) => text.length > 0).join("\n\n")
+}
+
+export function mergeSubagentResult(output: string, subAgentResultText: string): string {
+    if (!subAgentResultText || typeof output !== "string") {
+        return output
+    }
+
+    return output.replace(
+        SUB_AGENT_RESULT_BLOCK_REGEX,
+        (_match, openTag: string, _body: string, closeTag: string) =>
+            `${openTag}${subAgentResultText}${closeTag}`,
+    )
+}
+
+function getLastTextPart(message: WithParts): string {
+    const parts = Array.isArray(message.parts) ? message.parts : []
+    for (let index = parts.length - 1; index >= 0; index--) {
+        const part = parts[index]
+        if (part.type !== "text" || typeof part.text !== "string") {
+            continue
+        }
+
+        const text = part.text.trim()
+        if (!text) {
+            continue
+        }
+
+        return text
+    }
+
+    return ""
+}
+
+function assistantMessageHasCompressTool(message: WithParts): boolean {
+    const parts = Array.isArray(message.parts) ? message.parts : []
+    return parts.some(
+        (part) =>
+            part.type === "tool" && part.tool === "compress" && part.state?.status === "completed",
+    )
+}

package/lib/token-utils.ts

@@ -0,0 +1,164 @@
+import { SessionState, WithParts } from "./state"
+import { AssistantMessage, UserMessage } from "@opencode-ai/sdk/v2"
+import { Logger } from "./logger"
+import * as _anthropicTokenizer from "@anthropic-ai/tokenizer"
+const anthropicCountTokens = (_anthropicTokenizer.countTokens ??
+    (_anthropicTokenizer as any).default?.countTokens) as typeof _anthropicTokenizer.countTokens
+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: undefined,
+        }
+    }
+    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 = userInfo.model.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/lib/tui/commands.ts

@@ -0,0 +1,31 @@
+import type { DcpCommand, TuiApi } from "./types"
+
+export function registerCommands(api: TuiApi, commands: DcpCommand[]) {
+    const keymap = (api as any).keymap
+    if (keymap?.registerLayer) {
+        keymap.registerLayer({
+            commands: commands.map((command) => ({
+                namespace: "palette",
+                name: command.name,
+                title: command.title,
+                desc: command.description,
+                category: "DCP",
+                slashName: command.slashName,
+                slashAliases: command.slashAliases,
+                run: command.run,
+            })),
+        })
+        return
+    }
+
+    api.command?.register(() =>
+        commands.map((command) => ({
+            title: command.title,
+            value: command.name,
+            description: command.description,
+            category: "DCP",
+            slash: { name: command.slashName, aliases: command.slashAliases },
+            onSelect: command.run,
+        })),
+    )
+}

package/lib/tui/data.ts

@@ -0,0 +1,73 @@
+import { getConfig, type PluginConfig } from "../config"
+import { Logger } from "../logger"
+import { filterMessages } from "../messages/shape"
+import { createSessionState, type SessionState, type WithParts } from "../state"
+import { loadSessionState } from "../state/persistence"
+import { findLastCompactionTimestamp, loadPruneMap, loadPruneMessagesState } from "../state/utils"
+import type { TuiApi } from "./types"
+
+export const logger = new Logger(false)
+
+export function loadConfig(api: TuiApi): PluginConfig {
+    return getConfig({
+        client: api.client,
+        directory: api.state.path.directory,
+        worktree: api.state.path.worktree,
+    } as any)
+}
+
+export function activeSessionID(api: TuiApi): string | undefined {
+    const current = api.route.current
+    if (current.name !== "session") return undefined
+    const sessionID = current.params?.sessionID
+    return typeof sessionID === "string" ? sessionID : undefined
+}
+
+export function sessionMessages(api: TuiApi, sessionID: string): WithParts[] {
+    const messages = api.state.session.messages(sessionID)
+    return filterMessages(
+        messages.map((info) => ({
+            info,
+            parts: api.state.part(info.id),
+        })) as unknown as WithParts[],
+    )
+}
+
+export async function buildSessionState(
+    sessionID: string,
+    messages: WithParts[],
+    config: PluginConfig,
+): Promise<SessionState> {
+    const state = createSessionState()
+    state.sessionId = sessionID
+    state.manualMode = config.manualMode.enabled ? "active" : false
+    state.lastCompaction = findLastCompactionTimestamp(messages)
+
+    const persisted = await loadSessionState(sessionID, logger)
+    if (persisted) {
+        if (typeof persisted.manualMode === "boolean") {
+            state.manualMode = persisted.manualMode ? "active" : false
+        }
+
+        state.prune.tools = loadPruneMap(persisted.prune.tools)
+        state.prune.messages = loadPruneMessagesState(persisted.prune.messages)
+        state.nudges.contextLimitAnchors = new Set(persisted.nudges.contextLimitAnchors || [])
+        state.nudges.turnNudgeAnchors = new Set(persisted.nudges.turnNudgeAnchors || [])
+        state.nudges.iterationNudgeAnchors = new Set(persisted.nudges.iterationNudgeAnchors || [])
+        state.stats = {
+            pruneTokenCounter: persisted.stats?.pruneTokenCounter || 0,
+            totalPruneTokens: persisted.stats?.totalPruneTokens || 0,
+        }
+    }
+
+    return state
+}
+
+export async function loadSessionData(api: TuiApi, config: PluginConfig) {
+    const sessionID = activeSessionID(api)
+    if (!sessionID) return undefined
+
+    const messages = sessionMessages(api, sessionID)
+    const state = await buildSessionState(sessionID, messages, config)
+    return { state, messages }
+}

package/lib/tui/dialogs.tsx

@@ -0,0 +1,235 @@
+/** @jsxImportSource @opentui/solid */
+
+import { compressPermission } from "../compress-permission"
+import { analyzeContextTokens } from "../commands/context"
+import type { PluginConfig } from "../config"
+import type { SessionState, WithParts } from "../state"
+import { formatTokenCount } from "../ui/utils"
+import { TextAttributes } from "@opentui/core"
+import { formatDuration, formatRatio } from "./format"
+import { ActionRow, Card, DcpFrame, Metric, Progress, PromptRow, StatusPill } from "./ui"
+import type { StatsReport, TuiApi } from "./types"
+
+export function StatusDialog(props: {
+    api: TuiApi
+    title: string
+    eyebrow: string
+    message: string
+}) {
+    return (
+        <DcpFrame api={props.api} title={props.title} eyebrow={props.eyebrow}>
+            <box paddingTop={1} paddingBottom={1}>
+                <text fg={props.api.theme.current.textMuted}>{props.message}</text>
+            </box>
+        </DcpFrame>
+    )
+}
+
+export function ContextDialog(props: {
+    api: TuiApi
+    state: SessionState
+    messages: WithParts[]
+    onBack: () => void
+}) {
+    const theme = props.api.theme.current
+    const breakdown = analyzeContextTokens(props.state, props.messages)
+    const total = Math.max(0, breakdown.total)
+    const activePruned = breakdown.prunedToolCount + breakdown.prunedMessageCount
+
+    return (
+        <DcpFrame api={props.api} title="Context" eyebrow="DCP" onBack={props.onBack}>
+            <Card theme={theme} title="Current">
+                <Metric
+                    theme={theme}
+                    label="Total in context"
+                    value={`~${formatTokenCount(total)}`}
+                    hint="tokens"
+                />
+                <Metric
+                    theme={theme}
+                    label="Tools in context"
+                    value={`${breakdown.toolsInContextCount}`}
+                />
+                <Metric theme={theme} label="Active pruned targets" value={`${activePruned}`} />
+                <Metric
+                    theme={theme}
+                    label="Tokens pruned"
+                    value={`~${formatTokenCount(breakdown.prunedTokens)}`}
+                    hint="tokens"
+                />
+            </Card>
+            <Card theme={theme} title="Breakdown">
+                <Progress
+                    theme={theme}
+                    label="System"
+                    value={breakdown.system}
+                    total={total}
+                    color="primary"
+                    detail={`~${formatTokenCount(breakdown.system)} tokens`}
+                />
+                <Progress
+                    theme={theme}
+                    label="User"
+                    value={breakdown.user}
+                    total={total}
+                    color="primary"
+                    detail={`~${formatTokenCount(breakdown.user)} tokens`}
+                />
+                <Progress
+                    theme={theme}
+                    label="Assistant"
+                    value={breakdown.assistant}
+                    total={total}
+                    color="primary"
+                    detail={`~${formatTokenCount(breakdown.assistant)} tokens`}
+                />
+                <Progress
+                    theme={theme}
+                    label={`Tools (${breakdown.toolsInContextCount})`}
+                    value={breakdown.tools}
+                    total={total}
+                    color="primary"
+                    detail={`~${formatTokenCount(breakdown.tools)} tokens`}
+                />
+            </Card>
+        </DcpFrame>
+    )
+}
+
+export function StatsDialog(props: { api: TuiApi; report: StatsReport; onBack: () => void }) {
+    const theme = props.api.theme.current
+    const ratio = formatRatio(props.report.sessionTokens, props.report.sessionSummaryTokens)
+    return (
+        <DcpFrame api={props.api} title="Stats" eyebrow="DCP" onBack={props.onBack}>
+            <Card theme={theme} title="Session">
+                <Metric
+                    theme={theme}
+                    label="Tokens saved"
+                    value={`~${formatTokenCount(props.report.sessionTokens)}`}
+                    hint="tokens"
+                />
+                <Metric
+                    theme={theme}
+                    label="Summary size"
+                    value={`~${formatTokenCount(props.report.sessionSummaryTokens)}`}
+                    hint="tokens"
+                />
+                <Metric theme={theme} label="Compression ratio" value={ratio} />
+                <Metric
+                    theme={theme}
+                    label="Compression time"
+                    value={formatDuration(props.report.sessionDurationMs)}
+                />
+                <Metric theme={theme} label="Tools pruned" value={`${props.report.sessionTools}`} />
+                <Metric
+                    theme={theme}
+                    label="Messages pruned"
+                    value={`${props.report.sessionMessages}`}
+                />
+            </Card>
+            <Card theme={theme} title="All time">
+                <Metric
+                    theme={theme}
+                    label="Tokens saved"
+                    value={`~${formatTokenCount(props.report.allTime.totalTokens)}`}
+                    hint="tokens"
+                />
+                <Metric
+                    theme={theme}
+                    label="Tools pruned"
+                    value={`${props.report.allTime.totalTools}`}
+                />
+                <Metric
+                    theme={theme}
+                    label="Messages pruned"
+                    value={`${props.report.allTime.totalMessages}`}
+                />
+                <Metric
+                    theme={theme}
+                    label="Sessions with DCP history"
+                    value={`${props.report.allTime.sessionCount}`}
+                />
+            </Card>
+        </DcpFrame>
+    )
+}
+
+export function PanelDialog(props: {
+    api: TuiApi
+    state: SessionState
+    config: PluginConfig
+    onContext: () => void
+    onStats: () => void
+    onManual: (enabled: boolean) => void
+}) {
+    const theme = props.api.theme.current
+    const canCompress = compressPermission(props.state, props.config) !== "deny"
+    return (
+        <DcpFrame api={props.api} eyebrow="DCP">
+            <Card theme={theme} title="Views">
+                <box flexDirection="column" gap={1}>
+                    <ActionRow
+                        theme={theme}
+                        title="Context"
+                        detail="Token usage"
+                        onClick={props.onContext}
+                    />
+                    <ActionRow
+                        theme={theme}
+                        title="Stats"
+                        detail="Savings"
+                        onClick={props.onStats}
+                    />
+                </box>
+            </Card>
+            <Card theme={theme} title="Prompt">
+                {canCompress ? (
+                    <PromptRow
+                        theme={theme}
+                        command="/dcp-compress [focus]"
+                        description="Ask the model to compress"
+                        accent="primary"
+                    />
+                ) : (
+                    <text fg={theme.textMuted}>Compression is denied by permissions.</text>
+                )}
+            </Card>
+            <Card theme={theme} title="Session State">
+                <ManualModeToggle api={props.api} state={props.state} onToggle={props.onManual} />
+                <StatusPill
+                    theme={theme}
+                    label="Compression command"
+                    value={canCompress ? "enabled" : "disabled"}
+                    accent={canCompress ? "success" : "warning"}
+                />
+            </Card>
+        </DcpFrame>
+    )
+}
+
+function ManualModeToggle(props: {
+    api: TuiApi
+    state: SessionState
+    onToggle: (enabled: boolean) => void
+}) {
+    const theme = props.api.theme.current
+    const enabled = !!props.state.manualMode
+    const track = enabled ? theme.success : theme.error
+    return (
+        <box flexDirection="row" justifyContent="space-between" paddingLeft={1} paddingRight={1}>
+            <box width={22}>
+                <text fg={theme.primary} attributes={TextAttributes.BOLD}>
+                    Manual mode
+                </text>
+            </box>
+            <box
+                backgroundColor={track}
+                paddingLeft={1}
+                paddingRight={1}
+                onMouseUp={() => props.onToggle(!enabled)}
+            >
+                <text fg={theme.background}>{enabled ? "   ■" : "■   "}</text>
+            </box>
+        </box>
+    )
+}

package/lib/tui/format.ts

@@ -0,0 +1,25 @@
+export function formatDuration(ms: number): string {
+    const safeMs = Math.max(0, Math.round(ms))
+    if (safeMs < 1000) return `${safeMs} ms`
+
+    const totalSeconds = safeMs / 1000
+    if (totalSeconds < 60) return `${totalSeconds.toFixed(1)} s`
+
+    const wholeSeconds = Math.floor(totalSeconds)
+    const hours = Math.floor(wholeSeconds / 3600)
+    const minutes = Math.floor((wholeSeconds % 3600) / 60)
+    const seconds = wholeSeconds % 60
+    if (hours > 0) return `${hours}h ${minutes}m ${seconds}s`
+    return `${minutes}m ${seconds}s`
+}
+
+export function formatRatio(inputTokens: number, outputTokens: number): string {
+    if (inputTokens <= 0) return "0:1"
+    if (outputTokens <= 0) return "∞:1"
+    return `${Math.max(1, Math.round(inputTokens / outputTokens))}:1`
+}
+
+export function pct(value: number, total: number): string {
+    if (total <= 0) return "0.0%"
+    return `${((value / total) * 100).toFixed(1)}%`
+}