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

package/lib/ui/utils.ts

@@ -0,0 +1,304 @@
+import { SessionState, ToolParameterEntry, WithParts } from "../state"
+import { countTokens } from "../token-utils"
+import { isIgnoredUserMessage } from "../messages/query"
+
+function extractParameterKey(tool: string, parameters: any): string {
+    if (!parameters) return ""
+
+    if (tool === "read" && parameters.filePath) {
+        const offset = parameters.offset
+        const limit = parameters.limit
+        if (offset !== undefined && limit !== undefined) {
+            return `${parameters.filePath} (lines ${offset}-${offset + limit})`
+        }
+        if (offset !== undefined) {
+            return `${parameters.filePath} (lines ${offset}+)`
+        }
+        if (limit !== undefined) {
+            return `${parameters.filePath} (lines 0-${limit})`
+        }
+        return parameters.filePath
+    }
+
+    if ((tool === "write" || tool === "edit" || tool === "multiedit") && parameters.filePath) {
+        return parameters.filePath
+    }
+
+    if (tool === "apply_patch" && typeof parameters.patchText === "string") {
+        const pathRegex = /\*\*\* (?:Add|Delete|Update) File: ([^\n\r]+)/g
+        const paths: string[] = []
+        let match
+        while ((match = pathRegex.exec(parameters.patchText)) !== null) {
+            paths.push(match[1].trim())
+        }
+        if (paths.length > 0) {
+            const uniquePaths = [...new Set(paths)]
+            const count = uniquePaths.length
+            const plural = count > 1 ? "s" : ""
+            if (count === 1) return uniquePaths[0]
+            if (count === 2) return uniquePaths.join(", ")
+            return `${count} file${plural}: ${uniquePaths[0]}, ${uniquePaths[1]}...`
+        }
+        return "patch"
+    }
+
+    if (tool === "list") {
+        return parameters.path || "(current directory)"
+    }
+
+    if (tool === "glob") {
+        if (parameters.pattern) {
+            const pathInfo = parameters.path ? ` in ${parameters.path}` : ""
+            return `"${parameters.pattern}"${pathInfo}`
+        }
+        return "(unknown pattern)"
+    }
+
+    if (tool === "grep") {
+        if (parameters.pattern) {
+            const pathInfo = parameters.path ? ` in ${parameters.path}` : ""
+            return `"${parameters.pattern}"${pathInfo}`
+        }
+        return "(unknown pattern)"
+    }
+
+    if (tool === "bash") {
+        if (parameters.description) return parameters.description
+        if (parameters.command) {
+            return parameters.command.length > 50
+                ? parameters.command.substring(0, 50) + "..."
+                : parameters.command
+        }
+    }
+
+    if (tool === "webfetch" && parameters.url) {
+        return parameters.url
+    }
+    if (tool === "websearch" && parameters.query) {
+        return `"${parameters.query}"`
+    }
+    if (tool === "codesearch" && parameters.query) {
+        return `"${parameters.query}"`
+    }
+
+    if (tool === "todowrite") {
+        return `${parameters.todos?.length || 0} todos`
+    }
+    if (tool === "todoread") {
+        return "read todo list"
+    }
+
+    if (tool === "task" && parameters.description) {
+        return parameters.description
+    }
+    if (tool === "skill" && parameters.name) {
+        return parameters.name
+    }
+
+    if (tool === "lsp") {
+        const op = parameters.operation || "lsp"
+        const path = parameters.filePath || ""
+        const line = parameters.line
+        const char = parameters.character
+        if (path && line !== undefined && char !== undefined) {
+            return `${op} ${path}:${line}:${char}`
+        }
+        if (path) {
+            return `${op} ${path}`
+        }
+        return op
+    }
+
+    if (tool === "question") {
+        const questions = parameters.questions
+        if (Array.isArray(questions) && questions.length > 0) {
+            const headers = questions
+                .map((q: any) => q.header || "")
+                .filter(Boolean)
+                .slice(0, 3)
+
+            const count = questions.length
+            const plural = count > 1 ? "s" : ""
+
+            if (headers.length > 0) {
+                const suffix = count > 3 ? ` (+${count - 3} more)` : ""
+                return `${count} question${plural}: ${headers.join(", ")}${suffix}`
+            }
+            return `${count} question${plural}`
+        }
+        return "question"
+    }
+
+    const paramStr = JSON.stringify(parameters)
+    if (paramStr === "{}" || paramStr === "[]" || paramStr === "null") {
+        return ""
+    }
+
+    return paramStr.substring(0, 50)
+}
+
+export function formatStatsHeader(totalTokensSaved: number, pruneTokenCounter: number): string {
+    const totalTokensSavedStr = `~${formatTokenCount(totalTokensSaved + pruneTokenCounter)}`
+    return [`▣ DCP | ${totalTokensSavedStr} saved total`].join("\n")
+}
+
+export function formatTokenCount(tokens: number, compact?: boolean): string {
+    const suffix = compact ? "" : " tokens"
+    if (tokens >= 1000) {
+        return `${(tokens / 1000).toFixed(1)}K`.replace(".0K", "K") + suffix
+    }
+    return tokens.toString() + suffix
+}
+
+export function truncate(str: string, maxLen: number = 60): string {
+    if (str.length <= maxLen) return str
+    return str.slice(0, maxLen - 3) + "..."
+}
+
+export function formatProgressBar(
+    messageIds: string[],
+    prunedMessages: Map<string, number>,
+    recentMessageIds: string[],
+    width: number = 50,
+): string {
+    const ACTIVE = "█"
+    const PRUNED = "░"
+    const RECENT = "⣿"
+    const recentSet = new Set(recentMessageIds)
+
+    const total = messageIds.length
+    if (total === 0) return `│${PRUNED.repeat(width)}│`
+
+    const bar = new Array(width).fill(ACTIVE)
+
+    for (let m = 0; m < total; m++) {
+        const msgId = messageIds[m]
+        const start = Math.floor((m / total) * width)
+        const end = Math.floor(((m + 1) / total) * width)
+
+        if (recentSet.has(msgId)) {
+            for (let i = start; i < end; i++) {
+                bar[i] = RECENT
+            }
+        } else if (prunedMessages.has(msgId)) {
+            for (let i = start; i < end; i++) {
+                bar[i] = PRUNED
+            }
+        }
+    }
+
+    return `│${bar.join("")}│`
+}
+
+export function cacheSystemPromptTokens(state: SessionState, messages: WithParts[]): void {
+    let firstInputTokens = 0
+    for (const msg of messages) {
+        if (msg.info.role !== "assistant") {
+            continue
+        }
+        const info = msg.info as any
+        const input = info?.tokens?.input || 0
+        const cacheRead = info?.tokens?.cache?.read || 0
+        const cacheWrite = info?.tokens?.cache?.write || 0
+        if (input > 0 || cacheRead > 0 || cacheWrite > 0) {
+            firstInputTokens = input + cacheRead + cacheWrite
+            break
+        }
+    }
+
+    if (firstInputTokens <= 0) {
+        state.systemPromptTokens = undefined
+        return
+    }
+
+    let firstUserText = ""
+    for (const msg of messages) {
+        if (msg.info.role !== "user" || isIgnoredUserMessage(msg)) {
+            continue
+        }
+        const parts = Array.isArray(msg.parts) ? msg.parts : []
+        for (const part of parts) {
+            if (part.type === "text" && !(part as any).ignored) {
+                firstUserText += part.text
+            }
+        }
+        break
+    }
+
+    const estimatedSystemTokens = Math.max(0, firstInputTokens - countTokens(firstUserText))
+    state.systemPromptTokens = estimatedSystemTokens > 0 ? estimatedSystemTokens : undefined
+}
+
+export function shortenPath(input: string, workingDirectory?: string): string {
+    const inPathMatch = input.match(/^(.+) in (.+)$/)
+    if (inPathMatch) {
+        const prefix = inPathMatch[1]
+        const pathPart = inPathMatch[2]
+        const shortenedPath = shortenSinglePath(pathPart, workingDirectory)
+        return `${prefix} in ${shortenedPath}`
+    }
+
+    return shortenSinglePath(input, workingDirectory)
+}
+
+function shortenSinglePath(path: string, workingDirectory?: string): string {
+    if (workingDirectory) {
+        if (path.startsWith(workingDirectory + "/")) {
+            return path.slice(workingDirectory.length + 1)
+        }
+        if (path === workingDirectory) {
+            return "."
+        }
+    }
+
+    return path
+}
+
+export function formatPrunedItemsList(
+    pruneToolIds: string[],
+    toolMetadata: Map<string, ToolParameterEntry>,
+    workingDirectory?: string,
+): string[] {
+    const lines: string[] = []
+
+    for (const id of pruneToolIds) {
+        const metadata = toolMetadata.get(id)
+
+        if (metadata) {
+            const paramKey = extractParameterKey(metadata.tool, metadata.parameters)
+            if (paramKey) {
+                // Use 60 char limit to match notification style
+                const displayKey = truncate(shortenPath(paramKey, workingDirectory), 60)
+                lines.push(`→ ${metadata.tool}: ${displayKey}`)
+            } else {
+                lines.push(`→ ${metadata.tool}`)
+            }
+        }
+    }
+
+    const knownCount = pruneToolIds.filter((id) => toolMetadata.has(id)).length
+    const unknownCount = pruneToolIds.length - knownCount
+
+    if (unknownCount > 0) {
+        lines.push(`→ (${unknownCount} tool${unknownCount > 1 ? "s" : ""} with unknown metadata)`)
+    }
+
+    return lines
+}
+
+export function formatPruningResultForTool(
+    prunedIds: string[],
+    toolMetadata: Map<string, ToolParameterEntry>,
+    workingDirectory?: string,
+): string {
+    const lines: string[] = []
+    lines.push(`Context pruning complete. Pruned ${prunedIds.length} tool outputs.`)
+    lines.push("")
+
+    if (prunedIds.length > 0) {
+        lines.push(`Semantically pruned (${prunedIds.length}):`)
+        lines.push(...formatPrunedItemsList(prunedIds, toolMetadata, workingDirectory))
+    }
+
+    return lines.join("\n").trim()
+}

package/lib/v2/index.ts

@@ -0,0 +1,401 @@
+import type { Plugin } from "@opencode/plugin"
+import { tool, type ToolDefinition } from "@opencode-ai/plugin"
+import { getConfig } from "../config"
+import { Logger } from "../logger"
+import { PromptStore } from "../prompts/store"
+import { createRcCompressTool } from "../compress"
+import { RC_SUMMARY_MARKER } from "../compress/summary"
+import { attachCompressionDuration } from "../compress/state"
+import { createCommandExecuteHandler, createSystemPromptHandler } from "../hooks"
+import {
+    createSessionState,
+    ensureSessionInitialized,
+    checkSession,
+    saveSessionState,
+    syncToolCache,
+    type SessionState,
+} from "../state"
+import { assignMessageRefs } from "../message-ids"
+import { applyPendingManualTrigger } from "../commands/manual"
+import {
+    buildToolIdList,
+    injectCompressNudges,
+    injectMessageIds,
+    injectExtendedSubAgentResults,
+    prune,
+    stripHallucinations,
+    syncCompressionBlocks,
+} from "../messages"
+import { countTokens } from "../token-utils"
+import { matchesGlob } from "../protected-patterns"
+import { history, project } from "./messages"
+import { analyzeContextTokens } from "../commands/context"
+import { buildStatsReport } from "../commands/stats"
+import { rpc } from "./rpc"
+
+// Extension point for future model-invisible V2 reports. Never use synthetic()
+// here: its text would enter the model's context, unlike V1 ignored messages.
+export async function report(logger: Logger, text: string, sessionID?: string) {
+    logger.debug("V2 report (display pending)", { sessionID, text })
+}
+
+export async function setup(ctx: Plugin.Context) {
+    const warnings = {
+        tui: {
+            showToast: async (input: { body: { message: string } }) => {
+                console.warn(`DCP: ${input.body.message}`)
+            },
+        },
+    }
+    const config = getConfig({ directory: ctx.location.directory, client: warnings })
+    if (!config.enabled) {
+        await ctx.rpc.register(
+            { ...rpc, methods: { status: rpc.methods.status } },
+            { status: async () => ({ enabled: false }) },
+        )
+        return
+    }
+    const logger = new Logger(config.debug)
+    const prompts = new PromptStore(
+        logger,
+        ctx.location.directory,
+        config.experimental.customPrompts,
+        "compact",
+    )
+    const sessions = new Map<string, SessionState>()
+    const queues = new Map<string, Promise<unknown>>()
+    const limits = new Map<string, number>()
+    const aliases: Record<string, string> = {
+        task: "subagent",
+        bash: "shell",
+        apply_patch: "patch",
+    }
+    for (const list of [
+        config.compress.protectedTools,
+        config.commands.protectedTools,
+        config.strategies.deduplication.protectedTools,
+        config.strategies.purgeErrors.protectedTools,
+    ]) {
+        for (const name of [...list])
+            if (aliases[name] && !list.includes(aliases[name]!)) list.push(aliases[name]!)
+    }
+
+    function serial<T>(sessionID: string, operation: () => Promise<T>): Promise<T> {
+        const pending = (queues.get(sessionID) ?? Promise.resolve()).catch(() => {}).then(operation)
+        queues.set(sessionID, pending)
+        void pending
+            .finally(() => {
+                if (queues.get(sessionID) === pending) queues.delete(sessionID)
+            })
+            .catch(() => {})
+        return pending
+    }
+
+    const client = {
+        session: {
+            get: async ({ path }: { path: { id: string } }) => ({
+                data: await ctx.session.get({ sessionID: path.id }),
+            }),
+            messages: async ({ path }: { path: { id: string } }) => {
+                const [entries, session] = await Promise.all([
+                    ctx.session.context({ sessionID: path.id }),
+                    ctx.session.get({ sessionID: path.id }),
+                ])
+                return { data: history(entries, session) }
+            },
+            prompt: async (input: {
+                path: { id: string }
+                body: { parts: Array<{ text: string }> }
+            }) =>
+                report(logger, input.body.parts.map((part) => part.text).join("\n"), input.path.id),
+        },
+        tui: {
+            showToast: async (input: { body: { message: string } }) =>
+                report(logger, input.body.message),
+        },
+    }
+
+    async function load(sessionID: string, agentID?: string) {
+        const [session, entries] = await Promise.all([
+            ctx.session.get({ sessionID }),
+            ctx.session.context({ sessionID }),
+        ])
+        const selected =
+            agentID ??
+            session.agent ??
+            entries.findLast((entry) => entry.type === "assistant")?.agent
+        if (!selected) throw new Error("DCP commands require a session with a selected agent")
+        const { data: agent } = await ctx.agent.get({ agentID: selected })
+        let state = sessions.get(sessionID)
+        if (!state) {
+            state = createSessionState("compact")
+            sessions.set(sessionID, state)
+        }
+        const messages = history(entries, session)
+        await ensureSessionInitialized(
+            client,
+            state,
+            sessionID,
+            logger,
+            messages,
+            config.manualMode.enabled,
+        )
+        await checkSession(client, state, logger, messages, config.manualMode.enabled)
+        const rule = [...agent.permissions, ...(session.permissions ?? [])].findLast(
+            (rule) => matchesGlob("compress", rule.action) && matchesGlob("*", rule.resource),
+        )
+        state.compressPermission =
+            config.compress.permission === "deny"
+                ? "deny"
+                : rule?.effect === "deny"
+                  ? "deny"
+                  : config.compress.permission === "ask" || rule?.effect === "ask"
+                    ? "ask"
+                    : "allow"
+        return { state, entries, session, messages }
+    }
+
+    function allowed(state: SessionState) {
+        if (state.isSubAgent && !config.experimental.allowSubAgents)
+            throw new Error("DCP compression is disabled in subagents")
+        if (state.compressPermission === "deny") throw new Error("DCP compression is denied")
+        if (state.compressPermission === "ask")
+            throw new Error(
+                "DCP: compress permission 'ask' is not supported by OpenCode V2's public plugin API yet. Compression was not performed.",
+            )
+    }
+
+    await ctx.model.transform((editor) => {
+        limits.clear()
+        for (const model of editor.list())
+            limits.set(`${model.providerID}/${model.id}`, model.limit.context)
+    })
+    for (const kind of ["context", "compaction"] as const)
+        await ctx.session.hook(kind, (event) =>
+            serial(event.sessionID, async () => {
+                const { state, entries, session, messages } = await load(
+                    event.sessionID,
+                    event.agent,
+                )
+                if (state.isSubAgent && !config.experimental.allowSubAgents) {
+                    delete event.tools.compress
+                    return
+                }
+                if (state.compressPermission === "deny") delete event.tools.compress
+                state.modelContextLimit = limits.get(`${event.model.providerID}/${event.model.id}`)
+                state.systemPromptTokens = countTokens(
+                    event.system.map((part) => part.text).join("\n"),
+                )
+                const view = project(event.messages, entries, {
+                    ...session,
+                    agent: event.agent,
+                    model: event.model,
+                })
+                stripHallucinations(view.messages, state.idFormat)
+                assignMessageRefs(state, view.messages)
+                // Compaction may select only a prefix; block origins can be in the retained tail.
+                syncCompressionBlocks(state, logger, messages)
+                syncToolCache(state, config, logger, view.messages)
+                buildToolIdList(state, view.messages)
+                prune(state, logger, view.messages, view.summaryBase)
+                await injectExtendedSubAgentResults(
+                    client,
+                    state,
+                    logger,
+                    view.messages,
+                    config.experimental.allowSubAgents,
+                )
+                prompts.reload()
+                injectCompressNudges(
+                    state,
+                    config,
+                    logger,
+                    view.messages,
+                    prompts.getRuntimePrompts(),
+                    kind === "context",
+                )
+                injectMessageIds(state, config, view.messages)
+                applyPendingManualTrigger(state, view.messages, logger)
+                event.messages = view.restore()
+                const system = { system: event.system.map((part) => part.text) }
+                await createSystemPromptHandler(
+                    state,
+                    logger,
+                    config,
+                    prompts,
+                )(
+                    {
+                        sessionID: event.sessionID,
+                        model: { limit: { context: state.modelContextLimit ?? 0 } },
+                    },
+                    system,
+                )
+                event.system = system.system.map((text, index) => ({
+                    ...event.system[index],
+                    type: "text",
+                    text,
+                }))
+                await logger.saveContext(event.sessionID, view.messages)
+            }),
+        )
+
+    // Hidden summary generation for rc mode: when our marker is present, drop
+    // the session context and every tool so the transient request contains
+    // only the prompt we built. This keeps the summarization request invisible
+    // and independent of any injected metadata.
+    await ctx.session.hook("generate", (event) => {
+        const own = event.messages.filter(
+            (message) =>
+                Array.isArray(message.content) &&
+                message.content.some(
+                    (part: any) =>
+                        part?.type === "text" &&
+                        typeof part.text === "string" &&
+                        part.text.includes(RC_SUMMARY_MARKER),
+                ),
+        )
+        if (own.length === 0) {
+            return
+        }
+        event.messages = own as typeof event.messages
+        for (const name of Object.keys(event.tools ?? {})) {
+            delete (event.tools as Record<string, unknown>)[name]
+        }
+    })
+
+    if (config.compress.permission !== "deny") {
+        const define = (state: SessionState): ToolDefinition => {
+            const context = {
+                client,
+                state,
+                logger,
+                config,
+                prompts,
+                generate: async (input: { sessionID: string; prompt: string }) => {
+                    const result = await ctx.session.generate(input)
+                    return result?.text ?? ""
+                },
+            }
+            return createRcCompressTool(context)
+        }
+        const definition = define(createSessionState("compact"))
+        await ctx.tool.transform((editor) =>
+            editor.add({
+                name: "compress",
+                description: definition.description,
+                input: tool.schema.object(definition.args),
+                options: { codemode: false, permission: "compress" },
+                execute: (input, context) =>
+                    serial(context.sessionID, async () => {
+                        const { state } = await load(context.sessionID, context.agent)
+                        allowed(state)
+                        const started = Date.now()
+                        const legacy = define(state)
+                        const content = await legacy.execute(input, {
+                            sessionID: context.sessionID,
+                            messageID: context.messageID,
+                            callID: context.id,
+                            agent: context.agent,
+                            directory: ctx.location.directory,
+                            worktree: ctx.location.directory,
+                            abort: new AbortController().signal,
+                            ask: async () => allowed(state),
+                            metadata: ({ title }: { title?: string }) => {
+                                void context.progress({ title })
+                            },
+                        } as Parameters<typeof legacy.execute>[1])
+                        attachCompressionDuration(
+                            state.prune.messages,
+                            context.messageID,
+                            context.id,
+                            Date.now() - started,
+                        )
+                        await saveSessionState(state, logger)
+                        // The rc executor returns the tool result text.
+                        return { content: content as string }
+                    }),
+            }),
+        )
+    }
+    if (config.commands.enabled)
+        await ctx.command.transform((editor) => {
+            for (const name of ["dcp", "dcp-compress"])
+                editor.add({
+                    name,
+                    description: name === "dcp" ? "DCP commands" : "Trigger DCP manual compression",
+                    execute: async (invocation) => {
+                        const prompt = await serial(invocation.sessionID, async () => {
+                            const { state } = await load(invocation.sessionID)
+                            const permission =
+                                state.compressPermission ?? config.compress.permission
+                            if (
+                                name === "dcp-compress" ||
+                                invocation.prompt.text.trim().split(/\s+/)[0] === "compress"
+                            )
+                                allowed(state)
+                            const output = { parts: [] }
+                            await createCommandExecuteHandler(
+                                client,
+                                state,
+                                logger,
+                                config,
+                                ctx.location.directory,
+                            )(
+                                {
+                                    command: name,
+                                    sessionID: invocation.sessionID,
+                                    arguments: invocation.prompt.text,
+                                },
+                                output,
+                            )
+                            state.compressPermission = permission
+                            const pending = state.pendingManualTrigger
+                            if (!pending) return
+                            allowed(state)
+                            state.pendingManualTrigger = null
+                            return pending.prompt
+                        })
+                        if (prompt)
+                            await ctx.session.prompt({
+                                sessionID: invocation.sessionID,
+                                text: prompt,
+                                delivery: invocation.delivery,
+                            })
+                    },
+                })
+        })
+    await ctx.rpc.register(rpc, {
+        status: async () => ({ enabled: config.commands.enabled }),
+        snapshot: ({ sessionID }) =>
+            serial(sessionID, async () => {
+                const { state, messages } = await load(sessionID)
+                syncCompressionBlocks(state, logger, messages)
+                return {
+                    manualMode: !!state.manualMode,
+                    canCompress:
+                        state.compressPermission === "allow" &&
+                        (!state.isSubAgent || config.experimental.allowSubAgents),
+                    ...(state.compressPermission === "ask"
+                        ? {
+                              blockedReason:
+                                  "Permission 'ask' is not supported by the V2 plugin API yet.",
+                          }
+                        : {}),
+                    context: analyzeContextTokens(state, messages),
+                    stats: await buildStatsReport(state, logger),
+                }
+            }),
+        manual: ({ sessionID, enabled }) =>
+            serial(sessionID, async () => {
+                const { state } = await load(sessionID)
+                state.manualMode = enabled ? "active" : false
+                await saveSessionState(state, logger)
+                return {}
+            }),
+    })
+    logger.info("DCP V2 initialized")
+    return () => {
+        sessions.clear()
+        limits.clear()
+    }
+}