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

package/lib/hooks.ts

@@ -0,0 +1,205 @@
+import type { SessionState, WithParts } from "./state"
+import type { Logger } from "./logger"
+import type { PluginConfig } from "./config"
+import { renderSystemPrompt, type PromptStore } from "./prompts"
+import { buildProtectedToolsExtension } from "./prompts/extensions/system"
+import { filterMessages } from "./messages/shape"
+import {
+    handleContextCommand,
+    handleDecompressCommand,
+    handleHelpCommand,
+    handleManualToggleCommand,
+    handleManualTriggerCommand,
+    handleRecompressCommand,
+    handleStatsCommand,
+    handleSweepCommand,
+} from "./commands"
+import { compressPermission } from "./compress-permission"
+import { ensureSessionInitialized } from "./state"
+
+const INTERNAL_AGENT_SIGNATURES = [
+    "You are a title generator",
+    "You are a helpful AI assistant tasked with summarizing conversations",
+    "You are an anchored context summarization assistant for coding sessions",
+    "Summarize what was done in this conversation",
+]
+
+function isInternalAgentCall(systemPrompts: string[]): boolean {
+    const primaryPrompt = systemPrompts[0]
+    if (typeof primaryPrompt !== "string" || primaryPrompt.length === 0) {
+        return false
+    }
+
+    return INTERNAL_AGENT_SIGNATURES.some((signature) => primaryPrompt.includes(signature))
+}
+
+export function createSystemPromptHandler(
+    state: SessionState,
+    logger: Logger,
+    config: PluginConfig,
+    prompts: PromptStore,
+) {
+    return async (
+        input: { sessionID?: string; model: { limit: { context: number } } },
+        output: { system: string[] },
+    ) => {
+        if (input.model?.limit?.context) {
+            state.modelContextLimit = input.model.limit.context
+            logger.debug("Cached model context limit", { limit: state.modelContextLimit })
+        }
+
+        if (state.isSubAgent && !config.experimental.allowSubAgents) {
+            return
+        }
+
+        if (isInternalAgentCall(output.system)) {
+            logger.info("Skipping DCP system prompt injection for internal agent")
+            return
+        }
+
+        const effectivePermission =
+            input.sessionID && state.sessionId === input.sessionID
+                ? compressPermission(state, config)
+                : config.compress.permission
+
+        if (effectivePermission === "deny") {
+            return
+        }
+
+        prompts.reload()
+        const runtimePrompts = prompts.getRuntimePrompts()
+        const newPrompt = renderSystemPrompt(
+            runtimePrompts,
+            buildProtectedToolsExtension(config.compress.protectedTools),
+            !!state.manualMode,
+            state.isSubAgent && config.experimental.allowSubAgents,
+        )
+        if (output.system.length > 0) {
+            output.system[output.system.length - 1] += "\n\n" + newPrompt
+        } else {
+            output.system.push(newPrompt)
+        }
+    }
+}
+
+export function createCommandExecuteHandler(
+    client: any,
+    state: SessionState,
+    logger: Logger,
+    config: PluginConfig,
+    workingDirectory: string,
+) {
+    return async (
+        input: { command: string; sessionID: string; arguments: string },
+        output: { parts: any[] },
+    ) => {
+        if (!config.commands.enabled) {
+            return
+        }
+
+        if (input.command === "dcp" || input.command === "dcp-compress") {
+            const messagesResponse = await client.session.messages({
+                path: { id: input.sessionID },
+            })
+            const messages: WithParts[] = filterMessages(messagesResponse.data || messagesResponse)
+
+            await ensureSessionInitialized(
+                client,
+                state,
+                input.sessionID,
+                logger,
+                messages,
+                config.manualMode.enabled,
+            )
+
+            const effectivePermission = compressPermission(state, config)
+            if (effectivePermission === "deny") {
+                return
+            }
+
+            const args = (input.arguments || "").trim().split(/\s+/).filter(Boolean)
+            const isCompressCommand = input.command === "dcp-compress"
+            const subcommand = isCompressCommand ? "compress" : args[0]?.toLowerCase() || ""
+            const subArgs = isCompressCommand ? args : args.slice(1)
+
+            const commandCtx = {
+                client,
+                state,
+                config,
+                logger,
+                sessionId: input.sessionID,
+                messages,
+            }
+
+            if (subcommand === "context") {
+                await handleContextCommand(commandCtx)
+                return
+            }
+
+            if (subcommand === "stats") {
+                await handleStatsCommand(commandCtx)
+                return
+            }
+
+            if (subcommand === "sweep") {
+                await handleSweepCommand({
+                    ...commandCtx,
+                    args: subArgs,
+                    workingDirectory,
+                })
+                return
+            }
+
+            if (subcommand === "manual") {
+                await handleManualToggleCommand(commandCtx, subArgs[0]?.toLowerCase())
+                return
+            }
+
+            if (subcommand === "compress") {
+                const userFocus = subArgs.join(" ").trim()
+                const prompt = await handleManualTriggerCommand(commandCtx, "compress", userFocus)
+                if (!prompt) {
+                    throw new Error("__DCP_MANUAL_TRIGGER_BLOCKED__")
+                }
+
+                state.manualMode = "compress-pending"
+                state.pendingManualTrigger = {
+                    sessionId: input.sessionID,
+                    prompt,
+                }
+                const rawArgs = (input.arguments || "").trim()
+                output.parts.length = 0
+                output.parts.push({
+                    type: "text",
+                    text: isCompressCommand
+                        ? rawArgs
+                            ? `/dcp-compress ${rawArgs}`
+                            : "/dcp-compress"
+                        : rawArgs
+                          ? `/dcp ${rawArgs}`
+                          : `/dcp ${subcommand}`,
+                })
+                return
+            }
+
+            if (subcommand === "decompress") {
+                await handleDecompressCommand({
+                    ...commandCtx,
+                    args: subArgs,
+                })
+                return
+            }
+
+            if (subcommand === "recompress") {
+                await handleRecompressCommand({
+                    ...commandCtx,
+                    args: subArgs,
+                })
+                return
+            }
+
+            await handleHelpCommand(commandCtx)
+            return
+        }
+    }
+}

package/lib/logger.ts

@@ -0,0 +1,226 @@
+import { writeFile, mkdir } from "fs/promises"
+import { join } from "path"
+import { existsSync } from "fs"
+import { homedir } from "os"
+
+export class Logger {
+    private logDir: string
+    public enabled: boolean
+
+    constructor(enabled: boolean) {
+        this.enabled = enabled
+        const configHome = process.env.XDG_CONFIG_HOME || join(homedir(), ".config")
+        this.logDir = join(configHome, "opencode", "logs", "dcp")
+    }
+
+    private async ensureLogDir() {
+        if (!existsSync(this.logDir)) {
+            await mkdir(this.logDir, { recursive: true })
+        }
+    }
+
+    private formatData(data?: any): string {
+        if (!data) return ""
+
+        const parts: string[] = []
+        for (const [key, value] of Object.entries(data)) {
+            if (value === undefined || value === null) continue
+
+            // Format arrays compactly
+            if (Array.isArray(value)) {
+                if (value.length === 0) continue
+                parts.push(
+                    `${key}=[${value.slice(0, 3).join(",")}${value.length > 3 ? `...+${value.length - 3}` : ""}]`,
+                )
+            } else if (typeof value === "object") {
+                const str = JSON.stringify(value)
+                if (str.length < 50) {
+                    parts.push(`${key}=${str}`)
+                }
+            } else {
+                parts.push(`${key}=${value}`)
+            }
+        }
+        return parts.join(" ")
+    }
+
+    private getCallerFile(skipFrames: number = 3): string {
+        const originalPrepareStackTrace = Error.prepareStackTrace
+        try {
+            const err = new Error()
+            Error.prepareStackTrace = (_, stack) => stack
+            const stack = err.stack as unknown as NodeJS.CallSite[]
+            Error.prepareStackTrace = originalPrepareStackTrace
+
+            // Skip specified number of frames to get to actual caller
+            for (let i = skipFrames; i < stack.length; i++) {
+                const filename = stack[i]?.getFileName()
+                if (filename && !filename.includes("/logger.")) {
+                    // Extract just the filename without path and extension
+                    const match = filename.match(/([^/\\]+)\.[tj]s$/)
+                    return match ? match[1] : filename
+                }
+            }
+            return "unknown"
+        } catch {
+            return "unknown"
+        }
+    }
+
+    private async write(level: string, component: string, message: string, data?: any) {
+        if (!this.enabled) return
+
+        try {
+            await this.ensureLogDir()
+
+            const timestamp = new Date().toISOString()
+            const dataStr = this.formatData(data)
+
+            const logLine = `${timestamp} ${level.padEnd(5)} ${component}: ${message}${dataStr ? " | " + dataStr : ""}\n`
+
+            const dailyLogDir = join(this.logDir, "daily")
+            if (!existsSync(dailyLogDir)) {
+                await mkdir(dailyLogDir, { recursive: true })
+            }
+
+            const logFile = join(dailyLogDir, `${new Date().toISOString().split("T")[0]}.log`)
+            await writeFile(logFile, logLine, { flag: "a" })
+        } catch (error) {}
+    }
+
+    info(message: string, data?: any) {
+        const component = this.getCallerFile(2)
+        return this.write("INFO", component, message, data)
+    }
+
+    debug(message: string, data?: any) {
+        const component = this.getCallerFile(2)
+        return this.write("DEBUG", component, message, data)
+    }
+
+    warn(message: string, data?: any) {
+        const component = this.getCallerFile(2)
+        return this.write("WARN", component, message, data)
+    }
+
+    error(message: string, data?: any) {
+        const component = this.getCallerFile(2)
+        return this.write("ERROR", component, message, data)
+    }
+
+    /**
+     * Strips unnecessary metadata from messages for cleaner debug logs.
+     *
+     * Removed:
+     * - All IDs (id, sessionID, messageID, parentID)
+     * - summary, path, cost, model, agent, mode, finish, providerID, modelID
+     * - step-start and step-finish parts entirely
+     * - snapshot fields
+     * - ignored text parts
+     *
+     * Kept:
+     * - role, time (created only), tokens (input, output, reasoning, cache)
+     * - text, reasoning, tool parts with content
+     * - tool calls with: tool, callID, input, output, metadata
+     */
+    private minimizeForDebug(messages: any[]): any[] {
+        return messages.map((msg) => {
+            const minimized: any = {
+                role: msg.info?.role,
+            }
+
+            if (msg.info?.time?.created) {
+                minimized.time = msg.info.time.created
+            }
+
+            if (msg.info?.tokens) {
+                minimized.tokens = {
+                    input: msg.info.tokens.input,
+                    output: msg.info.tokens.output,
+                    reasoning: msg.info.tokens.reasoning,
+                    cache: msg.info.tokens.cache,
+                }
+            }
+
+            if (msg.parts) {
+                minimized.parts = msg.parts
+                    .map((part: any) => {
+                        if (part.type === "step-start" || part.type === "step-finish") {
+                            return null
+                        }
+
+                        if (part.type === "text") {
+                            if (part.ignored) return null
+                            const textPart: any = { type: "text", text: part.text }
+                            if (part.metadata) textPart.metadata = part.metadata
+                            return textPart
+                        }
+
+                        if (part.type === "reasoning") {
+                            const reasoningPart: any = { type: "reasoning", text: part.text }
+                            if (part.metadata) reasoningPart.metadata = part.metadata
+                            return reasoningPart
+                        }
+
+                        if (part.type === "tool") {
+                            const toolPart: any = {
+                                type: "tool",
+                                tool: part.tool,
+                                callID: part.callID,
+                            }
+
+                            if (part.state?.status) {
+                                toolPart.status = part.state.status
+                            }
+                            if (part.state?.input) {
+                                toolPart.input = part.state.input
+                            }
+                            if (part.state?.output) {
+                                toolPart.output = part.state.output
+                            }
+                            if (part.state?.error) {
+                                toolPart.error = part.state.error
+                            }
+                            if (part.metadata) {
+                                toolPart.metadata = part.metadata
+                            }
+                            if (part.state?.metadata) {
+                                toolPart.metadata = {
+                                    ...(toolPart.metadata || {}),
+                                    ...part.state.metadata,
+                                }
+                            }
+                            if (part.state?.title) {
+                                toolPart.title = part.state.title
+                            }
+
+                            return toolPart
+                        }
+
+                        return null
+                    })
+                    .filter(Boolean)
+            }
+
+            return minimized
+        })
+    }
+
+    async saveContext(sessionId: string, messages: any[]) {
+        if (!this.enabled) return
+
+        try {
+            const contextDir = join(this.logDir, "context", sessionId)
+            if (!existsSync(contextDir)) {
+                await mkdir(contextDir, { recursive: true })
+            }
+
+            const minimized = this.minimizeForDebug(messages).filter(
+                (msg) => msg.parts && msg.parts.length > 0,
+            )
+            const timestamp = new Date().toISOString().replace(/[:.]/g, "-")
+            const contextFile = join(contextDir, `${timestamp}.json`)
+            await writeFile(contextFile, JSON.stringify(minimized, null, 2))
+        } catch (error) {}
+    }
+}

package/lib/message-ids.ts

@@ -0,0 +1,181 @@
+import type { SessionState, WithParts } from "./state"
+import { isIgnoredUserMessage } from "./messages/query"
+
+const MESSAGE_REF_REGEX = /^m(\d{4})$/
+const BLOCK_REF_REGEX = /^b([1-9]\d*)$/
+const COMPACT_MESSAGE_REGEX = /^@([1-9]\d*)@$/
+const COMPACT_BLOCK_REGEX = /^@b([1-9]\d*)@$/
+const MESSAGE_ID_TAG_NAME = "dcp-message-id"
+
+export type IdFormat = "xml" | "compact"
+
+const MESSAGE_REF_WIDTH = 4
+const MESSAGE_REF_MIN_INDEX = 1
+export const MESSAGE_REF_MAX_INDEX = 9999
+
+export type ParsedBoundaryId =
+    | {
+          kind: "message"
+          ref: string
+          index: number
+      }
+    | {
+          kind: "compressed-block"
+          ref: string
+          blockId: number
+      }
+
+export function formatMessageRef(index: number, format: IdFormat = "xml"): string {
+    const max = format === "compact" ? Number.MAX_SAFE_INTEGER : MESSAGE_REF_MAX_INDEX
+    if (!Number.isSafeInteger(index) || index < MESSAGE_REF_MIN_INDEX || index > max) {
+        throw new Error(`Message ID index out of bounds: ${index}. Supported range is 1-${max}.`)
+    }
+    return format === "compact"
+        ? `@${index}@`
+        : `m${index.toString().padStart(MESSAGE_REF_WIDTH, "0")}`
+}
+
+export function formatBlockRef(blockId: number, format: IdFormat = "xml"): string {
+    if (!Number.isInteger(blockId) || blockId < 1) {
+        throw new Error(`Invalid block ID: ${blockId}`)
+    }
+    return format === "compact" ? `@b${blockId}@` : `b${blockId}`
+}
+
+export function parseMessageRef(ref: string, format: IdFormat = "xml"): number | null {
+    const normalized = ref.trim().toLowerCase()
+    const match = normalized.match(format === "compact" ? COMPACT_MESSAGE_REGEX : MESSAGE_REF_REGEX)
+    if (!match) {
+        return null
+    }
+    const index = Number.parseInt(match[1], 10)
+    if (!Number.isSafeInteger(index)) {
+        return null
+    }
+    const max = format === "compact" ? Number.MAX_SAFE_INTEGER : MESSAGE_REF_MAX_INDEX
+    if (index < MESSAGE_REF_MIN_INDEX || index > max) {
+        return null
+    }
+    return index
+}
+
+export function parseBlockRef(ref: string, format: IdFormat = "xml"): number | null {
+    const normalized = ref.trim().toLowerCase()
+    const match = normalized.match(format === "compact" ? COMPACT_BLOCK_REGEX : BLOCK_REF_REGEX)
+    if (!match) {
+        return null
+    }
+    const id = Number.parseInt(match[1], 10)
+    return Number.isSafeInteger(id) ? id : null
+}
+
+export function parseBoundaryId(id: string, format: IdFormat = "xml"): ParsedBoundaryId | null {
+    const normalized = id.trim().toLowerCase()
+    const messageIndex = parseMessageRef(normalized, format)
+    if (messageIndex !== null) {
+        return {
+            kind: "message",
+            ref: formatMessageRef(messageIndex, format),
+            index: messageIndex,
+        }
+    }
+
+    const blockId = parseBlockRef(normalized, format)
+    if (blockId !== null) {
+        return {
+            kind: "compressed-block",
+            ref: formatBlockRef(blockId, format),
+            blockId,
+        }
+    }
+
+    return null
+}
+
+function escapeXmlAttribute(value: string): string {
+    return value
+        .replace(/&/g, "&amp;")
+        .replace(/"/g, "&quot;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+}
+
+export function formatMessageIdTag(
+    ref: string,
+    attributes?: Record<string, string | undefined>,
+    format: IdFormat = "xml",
+): string {
+    if (format === "compact") {
+        if (ref === "BLOCKED") return "\n@blocked@"
+        const priority = attributes?.priority
+        return `\n${ref}${priority ? ` [${priority}]` : ""}`
+    }
+    const serializedAttributes = Object.entries(attributes || {})
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([name, value]) => {
+            if (name.trim().length === 0 || typeof value !== "string" || value.length === 0) {
+                return ""
+            }
+
+            return ` ${name}="${escapeXmlAttribute(value)}"`
+        })
+        .join("")
+
+    return `\n<${MESSAGE_ID_TAG_NAME}${serializedAttributes}>${ref}</${MESSAGE_ID_TAG_NAME}>`
+}
+
+export function assignMessageRefs(state: SessionState, messages: WithParts[]): number {
+    let assigned = 0
+    let skippedSubAgentPrompt = false
+
+    for (const message of messages) {
+        if (isIgnoredUserMessage(message)) {
+            continue
+        }
+
+        if (state.isSubAgent && !skippedSubAgentPrompt && message.info.role === "user") {
+            skippedSubAgentPrompt = true
+            continue
+        }
+
+        const rawMessageId = message.info.id
+        if (typeof rawMessageId !== "string" || rawMessageId.length === 0) {
+            continue
+        }
+
+        const existingRef = state.messageIds.byRawId.get(rawMessageId)
+        if (existingRef) {
+            if (state.messageIds.byRef.get(existingRef) !== rawMessageId) {
+                state.messageIds.byRef.set(existingRef, rawMessageId)
+            }
+            continue
+        }
+
+        const ref = allocateNextMessageRef(state)
+        state.messageIds.byRawId.set(rawMessageId, ref)
+        state.messageIds.byRef.set(ref, rawMessageId)
+        assigned++
+    }
+
+    return assigned
+}
+
+function allocateNextMessageRef(state: SessionState): string {
+    let candidate = Number.isInteger(state.messageIds.nextRef)
+        ? Math.max(MESSAGE_REF_MIN_INDEX, state.messageIds.nextRef)
+        : MESSAGE_REF_MIN_INDEX
+
+    const max = state.idFormat === "compact" ? Number.MAX_SAFE_INTEGER : MESSAGE_REF_MAX_INDEX
+    while (candidate <= max) {
+        const ref = formatMessageRef(candidate, state.idFormat)
+        if (!state.messageIds.byRef.has(ref)) {
+            state.messageIds.nextRef = candidate + 1
+            return ref
+        }
+        candidate++
+    }
+
+    throw new Error(
+        `Message ID alias capacity exceeded. Cannot allocate more than ${formatMessageRef(max, state.idFormat)} aliases in this session.`,
+    )
+}

package/lib/messages/index.ts

@@ -0,0 +1,7 @@
+export { prune } from "./prune"
+export { syncCompressionBlocks } from "./sync"
+export { injectCompressNudges } from "./inject/inject"
+export { injectMessageIds } from "./inject/inject"
+export { injectExtendedSubAgentResults } from "./inject/subagent-results"
+export { stripStaleMetadata } from "./reasoning-strip"
+export { buildToolIdList, stripHallucinations, stripHallucinationsFromString } from "./utils"