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

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
+}

package/tui/shared/types.ts

@@ -0,0 +1,38 @@
+import type { TuiPluginApi } from "@opencode-ai/plugin/tui"
+import type {
+    MessageStatus as DcpMessageStatus,
+    TokenBreakdown as DcpContextBreakdown,
+} from "../../lib/analysis/tokens"
+
+export type DcpTuiApi = TuiPluginApi
+export type DcpTuiClient = DcpTuiApi["client"]
+
+export type { DcpMessageStatus }
+
+export interface DcpActiveBlockInfo {
+    topic: string
+    summary: string
+}
+
+export interface DcpPersistedSummary {
+    available: boolean
+    activeBlockCount: number
+    activeBlocks: DcpActiveBlockInfo[]
+    lastUpdated?: string
+}
+
+export interface DcpAllTimeStats {
+    totalTokensSaved: number
+    sessionCount: number
+}
+
+export interface DcpContextSnapshot {
+    sessionID?: string
+    breakdown: DcpContextBreakdown
+    activeSummaryTokens: number
+    persisted: DcpPersistedSummary
+    messageStatuses: DcpMessageStatus[]
+    allTimeStats: DcpAllTimeStats
+    notes: string[]
+    loadedAt: number
+}