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

package/lib/v2/messages.ts

@@ -0,0 +1,252 @@
+import type { Message, ContentPart, ToolResultPart } from "@opencode/ai/schema/messages"
+import type { Plugin } from "@opencode/plugin"
+import type { WithParts } from "../state"
+
+type History = Awaited<ReturnType<Plugin.Context["session"]["context"]>>
+type Session = Awaited<ReturnType<Plugin.Context["session"]["get"]>>
+type Part = WithParts["parts"][number]
+
+const emptyUsage = { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } }
+
+function info(id: string, role: string, session: Session, entry?: History[number]) {
+    const model = entry?.type === "assistant" ? entry.model : session.model
+    return {
+        id,
+        role,
+        sessionID: session.id,
+        time: { created: entry?.time.created ?? 0 },
+        agent: entry?.type === "assistant" ? entry.agent : session.agent,
+        model: { providerID: model?.providerID, modelID: model?.id, variant: model?.variant },
+        providerID: model?.providerID,
+        modelID: model?.id,
+        tokens: entry?.type === "assistant" ? (entry.tokens ?? emptyUsage) : emptyUsage,
+        summary: entry?.type === "compaction" && entry.status === "completed",
+    } as unknown as WithParts["info"]
+}
+
+// Bookkeeping projections are never sent to a provider. Native messages remain
+// authoritative for reasoning, media, checkpoints, and provider metadata.
+export function history(entries: History, session: Session): WithParts[] {
+    return entries.flatMap((entry): WithParts[] => {
+        const base = { sessionID: session.id, messageID: entry.id }
+        if (entry.type === "assistant") {
+            const parts = entry.content.map((part, index) => {
+                if (part.type !== "tool")
+                    return { ...base, id: `${entry.id}:${index}`, type: part.type, text: part.text }
+                const state = part.state
+                return {
+                    ...base,
+                    id: part.id,
+                    type: "tool",
+                    callID: part.id,
+                    tool: part.name,
+                    state: {
+                        ...state,
+                        input: structuredClone(state.input),
+                        ...(state.status === "completed" ? { output: output(state.content) } : {}),
+                    },
+                }
+            })
+            return [
+                {
+                    info: info(entry.id, "assistant", session, entry),
+                    parts: [{ ...base, id: `${entry.id}:step`, type: "step-start" }, ...parts],
+                } as WithParts,
+            ]
+        }
+        let text: string | undefined
+        if (entry.type === "user")
+            text = [
+                ...(entry.skills ?? []).flatMap((skill) =>
+                    skill.text === undefined ? [] : [skill.text],
+                ),
+                entry.text,
+            ].join("\n\n")
+        if (entry.type === "synthetic" || entry.type === "skill") text = entry.text
+        if (entry.type === "location-switched")
+            text = `The working directory has been changed to ${entry.location.directory}.`
+        if (entry.type === "shell" && entry.metadata?.background !== true)
+            text = `The following shell command was executed by the user:\n\nCommand:\n${entry.command}\n\nOutput:\n${entry.output?.output ?? ""}`
+        if (text !== undefined) {
+            return [
+                {
+                    info: info(entry.id, "user", session, entry),
+                    parts: [{ ...base, id: `${entry.id}:text`, type: "text", text }],
+                } as WithParts,
+            ]
+        }
+        if (entry.type === "compaction" && entry.status === "completed") {
+            return [{ info: info(entry.id, "assistant", session, entry), parts: [] } as WithParts]
+        }
+        return []
+    })
+}
+
+function output(content: ReadonlyArray<{ type: string; text?: string }>): unknown {
+    return content.length === 1 && content[0]?.type === "text"
+        ? content[0].text
+        : structuredClone(content)
+}
+
+export function project(native: Message[], entries: History, session: Session) {
+    const byID = new Map(entries.map((entry) => [entry.id, entry]))
+    const results = new Map<string, ToolResultPart>()
+    const owners = new Map<string, string>()
+    const links = new Map<ContentPart, Part>()
+    const originals = new Map<string, WithParts>()
+    const messages: WithParts[] = []
+    for (const message of native)
+        for (const part of message.content) {
+            if (part.type === "tool-result") results.set(part.id, part)
+            if (part.type === "tool-call" && message.id) owners.set(part.id, message.id)
+        }
+    for (const message of native) {
+        if (!message.id || !["user", "assistant"].includes(message.role)) continue
+        const entry = byID.get(message.id)
+        if (!entry || entry.type === "compaction") continue
+        const base = { sessionID: session.id, messageID: message.id }
+        const parts: Part[] = []
+        if (message.role === "assistant")
+            parts.push({ ...base, id: `${message.id}:step`, type: "step-start" })
+        for (const [index, part] of message.content.entries()) {
+            let projected: Part | undefined
+            if (part.type === "text")
+                projected = { ...base, id: `${message.id}:${index}`, type: "text", text: part.text }
+            if (part.type === "media") {
+                // Tolerate both media shapes: older hosts expose mediaType/data
+                // directly, newer ones nest them under `media`.
+                const media: any = (part as any).media
+                const legacy: any = part as any
+                const mime = media?.mediaType ?? legacy.mediaType ?? ""
+                const source = media?.source
+                const url =
+                    typeof legacy.data === "string"
+                        ? legacy.data
+                        : typeof source?.data === "string"
+                          ? source.data
+                          : typeof source?.url === "string"
+                            ? source.url
+                            : ""
+                projected = {
+                    ...base,
+                    id: `${message.id}:${index}`,
+                    type: "file",
+                    mime,
+                    url,
+                }
+            }
+            if (part.type === "tool-call") {
+                const result = results.get(part.id)
+                const entry = byID.get(message.id)
+                const durable =
+                    entry?.type === "assistant"
+                        ? entry.content.find((item) => item.type === "tool" && item.id === part.id)
+                        : undefined
+                projected = {
+                    ...base,
+                    id: part.id,
+                    type: "tool",
+                    callID: part.id,
+                    tool: part.name,
+                    state: {
+                        status: !result
+                            ? "running"
+                            : result.result.type === "error"
+                              ? "error"
+                              : "completed",
+                        input: structuredClone(part.input),
+                        ...(result?.result.type === "error"
+                            ? { error: result.result.value }
+                            : {
+                                  output: structuredClone(
+                                      result?.result.type === "text"
+                                          ? result.result.value
+                                          : result?.result,
+                                  ),
+                              }),
+                        metadata:
+                            durable?.type === "tool" && "metadata" in durable.state
+                                ? durable.state.metadata
+                                : {},
+                    },
+                } as Part
+                if (result) links.set(result, projected)
+            }
+            if (projected) {
+                parts.push(projected)
+                links.set(part, projected)
+            }
+        }
+        const projected = {
+            info: info(message.id, message.role, session, byID.get(message.id)),
+            parts,
+        } as WithParts
+        messages.push(projected)
+        originals.set(message.id, projected)
+    }
+
+    function restore(): Message[] {
+        const retained = new Set(messages.map((message) => message.info.id))
+        const linked = new Set(links.values())
+        const output: Message[] = []
+        let next = 0
+        const synthetic = () => {
+            while (next < messages.length && !originals.has(messages[next]!.info.id)) {
+                const message = messages[next++]!
+                output.push({
+                    id: message.info.id,
+                    role: "user",
+                    content: message.parts
+                        .filter((part) => part.type === "text")
+                        .map((part) => ({ type: "text", text: part.text })),
+                })
+            }
+        }
+        for (const message of native) {
+            const projected = message.id ? originals.get(message.id) : undefined
+            if (projected) {
+                synthetic()
+                if (!retained.has(message.id!)) continue
+                next++
+            }
+            const content: ContentPart[] = []
+            const added =
+                projected?.parts.flatMap((part) =>
+                    part.type === "text" && !linked.has(part)
+                        ? [{ type: "text" as const, text: part.text }]
+                        : [],
+                ) ?? []
+            for (const part of message.content) {
+                if (part.type === "tool-call") content.push(...added.splice(0))
+                if (
+                    part.type === "tool-result" &&
+                    originals.has(owners.get(part.id)!) &&
+                    !retained.has(owners.get(part.id)!)
+                )
+                    continue
+                const edit = links.get(part)
+                if (part.type === "text" && edit?.type === "text")
+                    content.push({ ...part, text: edit.text })
+                else if (part.type === "tool-call" && edit?.type === "tool")
+                    content.push({ ...part, input: edit.state.input })
+                else if (
+                    part.type === "tool-result" &&
+                    edit?.type === "tool" &&
+                    edit.state.status === "completed" &&
+                    typeof edit.state.output === "string" &&
+                    edit.state.output !== part.result.value
+                ) {
+                    content.push({ ...part, result: { type: "text", value: edit.state.output } })
+                } else content.push(part)
+            }
+            content.push(...added)
+            if (content.length || message.content.length === 0) output.push({ ...message, content })
+        }
+        synthetic()
+        return output
+    }
+    // A native checkpoint can replace every user message. Summary construction
+    // still needs session/agent/model fields, without projecting that checkpoint.
+    const summaryBase: WithParts = { info: info("msg_dcp_base", "user", session), parts: [] }
+    return { messages, restore, summaryBase }
+}

package/lib/v2/rpc.ts

@@ -0,0 +1,60 @@
+import { tool } from "@opencode-ai/plugin"
+
+const z = tool.schema
+const session = z.object({ sessionID: z.string() })
+const compressionUsage = z.object({
+    calls: z.number(),
+    providerCalls: z.number(),
+    estimatedCalls: z.number(),
+    inputTokens: z.number(),
+    outputTokens: z.number(),
+    cacheReadTokens: z.number(),
+    cacheWriteTokens: z.number(),
+    reasoningTokens: z.number(),
+})
+const stats = z.object({
+    sessionTokens: z.number(),
+    sessionSummaryTokens: z.number(),
+    sessionDurationMs: z.number(),
+    sessionTools: z.number(),
+    sessionMessages: z.number(),
+    sessionCompressionUsage: compressionUsage,
+    allTime: z.object({
+        totalTokens: z.number(),
+        totalTools: z.number(),
+        totalMessages: z.number(),
+        sessionCount: z.number(),
+        compressionUsage,
+    }),
+})
+const context = z.object({
+    system: z.number(),
+    user: z.number(),
+    assistant: z.number(),
+    tools: z.number(),
+    toolCount: z.number(),
+    toolsInContextCount: z.number(),
+    prunedTokens: z.number(),
+    prunedToolCount: z.number(),
+    prunedMessageCount: z.number(),
+    total: z.number(),
+})
+
+export const rpc = {
+    id: "dcp-rc",
+    methods: {
+        status: { input: z.object({}), output: z.object({ enabled: z.boolean() }) },
+        snapshot: {
+            input: session,
+            output: z.object({
+                manualMode: z.boolean(),
+                canCompress: z.boolean(),
+                blockedReason: z.string().optional(),
+                context,
+                stats,
+            }),
+        },
+        manual: { input: session.extend({ enabled: z.boolean() }), output: z.object({}) },
+    },
+    events: {},
+} as const

package/lib/v2/theme.ts

@@ -0,0 +1,67 @@
+import type { Theme } from "../tui/types"
+
+type Color = Theme["text"]
+type Feedback = "success" | "warning" | "error"
+type Action = "primary" | "secondary"
+
+type CurrentTheme = {
+    surface(name: "dialog"): {
+        text: {
+            base: Color
+            muted: Color
+            action: Record<Action, { base: Color }>
+            feedback: Record<Feedback, { base: Color }>
+        }
+        background: { base: Color; raised: { base: Color } }
+        border: { base: Color }
+    }
+}
+
+type EarlierTheme = {
+    contextual: {
+        overlay: {
+            text: {
+                default: Color
+                subdued: Color
+                action: Record<Action, { default: Color }>
+                feedback: Record<Feedback, { default: Color }>
+            }
+            background: { default: Color; surface: { offset: Color } }
+            border: { default: Color }
+        }
+    }
+}
+
+export function panelTheme(source: CurrentTheme | EarlierTheme): Theme {
+    if ("surface" in source) {
+        const theme = source.surface("dialog")
+        return {
+            primary: theme.text.action.primary.base,
+            accent: theme.text.action.secondary.base,
+            text: theme.text.base,
+            textMuted: theme.text.muted,
+            background: theme.background.base,
+            backgroundElement: theme.background.raised.base,
+            borderSubtle: theme.border.base,
+            selectedListItemText: theme.background.base,
+            success: theme.text.feedback.success.base,
+            warning: theme.text.feedback.warning.base,
+            error: theme.text.feedback.error.base,
+        }
+    }
+
+    const theme = source.contextual.overlay
+    return {
+        primary: theme.text.action.primary.default,
+        accent: theme.text.action.secondary.default,
+        text: theme.text.default,
+        textMuted: theme.text.subdued,
+        background: theme.background.default,
+        backgroundElement: theme.background.surface.offset,
+        borderSubtle: theme.border.default,
+        selectedListItemText: theme.background.default,
+        success: theme.text.feedback.success.default,
+        warning: theme.text.feedback.warning.default,
+        error: theme.text.feedback.error.default,
+    }
+}

package/lib/v2/tui.tsx

@@ -0,0 +1,115 @@
+/** @jsxImportSource @opentui/solid */
+import type { Plugin } from "@opencode/plugin/tui"
+import { ContextDialog, PanelDialog, StatsDialog, StatusDialog } from "../tui/dialogs"
+import type { ViewApi } from "../tui/types"
+import { rpc } from "./rpc"
+import { panelTheme } from "./theme"
+
+export async function setup(ctx: Plugin.Context) {
+    const client = ctx.client.rpc(rpc)
+    const options = () => ({ location: ctx.location ?? ctx.data.location.default() })
+    if (!(await client.status({}, options())).enabled) return
+    const api: ViewApi = {
+        renderer: ctx.renderer,
+        theme: {
+            get current() {
+                return panelTheme(ctx.theme)
+            },
+        },
+        ui: { dialog: { clear: () => ctx.ui.dialog.clear() } },
+    }
+    function show(render: Parameters<typeof ctx.ui.dialog.show>[0]) {
+        ctx.ui.dialog.set({ size: "xlarge" })
+        ctx.ui.dialog.show(render)
+    }
+    async function open(page: "panel" | "context" | "stats" = "panel") {
+        const route = ctx.ui.router.current()
+        if (route.type !== "session") {
+            show(() => (
+                <StatusDialog
+                    api={api}
+                    title="DCP"
+                    eyebrow="No session"
+                    message="Open a session first."
+                />
+            ))
+            return
+        }
+        const sessionID = route.sessionID
+        try {
+            const data = await client.snapshot({ sessionID }, options())
+            const back = () => {
+                void open()
+            }
+            if (page === "context")
+                show(() => <ContextDialog api={api} breakdown={data.context} onBack={back} />)
+            else if (page === "stats")
+                show(() => <StatsDialog api={api} report={data.stats} onBack={back} />)
+            else
+                show(() => (
+                    <PanelDialog
+                        api={api}
+                        manualMode={data.manualMode}
+                        canCompress={data.canCompress}
+                        blockedReason={data.blockedReason}
+                        onContext={() => {
+                            void open("context")
+                        }}
+                        onStats={() => {
+                            void open("stats")
+                        }}
+                        onManual={(enabled) => {
+                            void client
+                                .manual({ sessionID, enabled }, options())
+                                .then(back)
+                                .catch(error)
+                        }}
+                    />
+                ))
+        } catch (cause) {
+            error(cause)
+        }
+    }
+    function error(cause: unknown) {
+        const message =
+            cause instanceof Error
+                ? cause.message
+                : typeof cause === "object" && cause && "message" in cause
+                  ? String(cause.message)
+                  : String(cause)
+        show(() => <StatusDialog api={api} title="DCP" eyebrow="DCP Error" message={message} />)
+    }
+    ctx.ui.slot({
+        append: "app",
+        render() {
+            ctx.keymap.layer(() => ({
+                mode: "global",
+                commands: [
+                    {
+                        id: "dcp.panel",
+                        title: "DCP",
+                        description: "Open DCP panel",
+                        group: "DCP",
+                        palette: true,
+                        slash: { name: "dcp", arguments: true },
+                        run: async (input) => {
+                            if (!input?.trim()) return open()
+                            const route = ctx.ui.router.current()
+                            if (route.type !== "session") return open()
+                            try {
+                                await ctx.client.session.command({
+                                    sessionID: route.sessionID,
+                                    name: "dcp",
+                                    text: input,
+                                })
+                            } catch (cause) {
+                                error(cause)
+                            }
+                        },
+                    },
+                ],
+            }))
+            return null
+        },
+    })
+}