@royalcat/opencode-dcp-rc 0.0.0-stage → 4.0.1

package/lib/subagents/subagent-results.ts

@@ -0,0 +1,75 @@
+import type { WithParts } from "../state"
+
+const SUB_AGENT_RESULT_BLOCK_REGEX =
+    /(<(?:task_result|subagent\b[^>]*)>\s*)([\s\S]*?)(\s*<\/(?:task_result|subagent)>)/i
+
+export function getSubAgentId(part: any): string | null {
+    const sessionId = part?.state?.metadata?.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/dialogs.tsx

@@ -0,0 +1,261 @@
+/** @jsxImportSource @opentui/solid */
+
+import type { analyzeContextTokens } from "../commands/context"
+import { formatTokenCount } from "../ui/utils"
+import { formatDuration, formatRatio } from "./format"
+import { ActionRow, Card, DcpFrame, Metric, Progress, PromptRow, StatusPill } from "./ui"
+import type { StatsReport, ViewApi } from "./types"
+
+export function StatusDialog(props: {
+    api: ViewApi
+    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: ViewApi
+    breakdown: ReturnType<typeof analyzeContextTokens>
+    onBack: () => void
+}) {
+    const theme = props.api.theme.current
+    const breakdown = props.breakdown
+    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: ViewApi; 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}`}
+                />
+                <Metric
+                    theme={theme}
+                    label="Summary requests"
+                    value={`${props.report.sessionCompressionUsage.calls}`}
+                    hint={`${props.report.sessionCompressionUsage.providerCalls} provider · ${props.report.sessionCompressionUsage.estimatedCalls} estimated`}
+                />
+                <Metric
+                    theme={theme}
+                    label="Request in|out"
+                    value={`~${formatTokenCount(props.report.sessionCompressionUsage.inputTokens)} | ~${formatTokenCount(props.report.sessionCompressionUsage.outputTokens)}`}
+                    hint="tokens"
+                />
+                <Metric
+                    theme={theme}
+                    label="Request cache r|w"
+                    value={`~${formatTokenCount(props.report.sessionCompressionUsage.cacheReadTokens)} | ~${formatTokenCount(props.report.sessionCompressionUsage.cacheWriteTokens)}`}
+                    hint={`reasoning ~${formatTokenCount(props.report.sessionCompressionUsage.reasoningTokens)}`}
+                />
+            </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}`}
+                />
+                <Metric
+                    theme={theme}
+                    label="Summary requests"
+                    value={`${props.report.allTime.compressionUsage.calls}`}
+                    hint={`~${formatTokenCount(props.report.allTime.compressionUsage.inputTokens)} in · ~${formatTokenCount(props.report.allTime.compressionUsage.outputTokens)} out`}
+                />
+            </Card>
+        </DcpFrame>
+    )
+}
+
+export function PanelDialog(props: {
+    api: ViewApi
+    manualMode: boolean
+    canCompress: boolean
+    blockedReason?: string
+    onContext: () => void
+    onStats: () => void
+    onManual: (enabled: boolean) => void
+}) {
+    const theme = props.api.theme.current
+    const canCompress = props.canCompress
+    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}>
+                        {props.blockedReason ?? "Compression is denied by permissions."}
+                    </text>
+                )}
+            </Card>
+            <Card theme={theme} title="Session State">
+                <ManualModeToggle
+                    api={props.api}
+                    enabled={props.manualMode}
+                    onToggle={props.onManual}
+                />
+                <StatusPill
+                    theme={theme}
+                    label="Compression command"
+                    value={canCompress ? "enabled" : "disabled"}
+                    accent={canCompress ? "success" : "warning"}
+                />
+            </Card>
+        </DcpFrame>
+    )
+}
+
+function ManualModeToggle(props: {
+    api: ViewApi
+    enabled: boolean
+    onToggle: (enabled: boolean) => void
+}) {
+    const theme = props.api.theme.current
+    const enabled = props.enabled
+    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}>
+                    <b>Manual mode</b>
+                </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)}%`
+}

package/lib/tui/types.ts

@@ -0,0 +1,25 @@
+import type { TuiPluginModule } from "@opencode-ai/plugin/tui"
+import type { buildStatsReport } from "../commands/stats"
+
+export type TuiApi = Parameters<NonNullable<TuiPluginModule["tui"]>>[0]
+export type Theme = Pick<
+    TuiApi["theme"]["current"],
+    | "primary"
+    | "accent"
+    | "text"
+    | "textMuted"
+    | "background"
+    | "backgroundElement"
+    | "borderSubtle"
+    | "selectedListItemText"
+    | "success"
+    | "warning"
+    | "error"
+>
+export type ThemeColor = keyof Theme
+export type ViewApi = {
+    theme: { readonly current: Theme }
+    renderer: Pick<TuiApi["renderer"], "height" | "on" | "off">
+    ui: { dialog: { clear(): void } }
+}
+export type StatsReport = Awaited<ReturnType<typeof buildStatsReport>>