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

package/lib/messages/utils.ts

@@ -0,0 +1,190 @@
+import { createHash } from "node:crypto"
+import type { SessionState, WithParts } from "../state"
+import { isMessageCompacted } from "../state/utils"
+import type { UserMessage } from "@opencode-ai/sdk/v2"
+import type { IdFormat } from "../message-ids"
+
+const SUMMARY_ID_HASH_LENGTH = 16
+const DCP_PAIRED_TAG_REGEX = /<dcp[^>]*>[\s\S]*?<\/dcp[^>]*>/gi
+const DCP_UNPAIRED_TAG_REGEX = /<\/?dcp[^>]*>/gi
+const INJECTED_MESSAGE_ID_SUFFIX_REGEX = /(?<=\n)<dcp-message-id[^>]*>m\d+<\/dcp-message-id>\s*$/
+const HALLUCINATED_PARAMETER_SUFFIX_REGEX = /(?<=\n)m\d+<\/parameter>\s*$/
+const COMPACT_TAG_REGEX = /@(?:[1-9]\d*|b[1-9]\d*|blocked)@(?:[ \t]+\[(?:low|medium|high)\])?/gi
+
+const generateStableId = (prefix: string, seed: string): string => {
+    const hash = createHash("sha256").update(seed).digest("hex").slice(0, SUMMARY_ID_HASH_LENGTH)
+    return `${prefix}_${hash}`
+}
+
+export const createSyntheticUserMessage = (
+    baseMessage: WithParts,
+    content: string,
+    stableSeed?: string,
+): WithParts => {
+    const userInfo = baseMessage.info as UserMessage
+    const now = Date.now()
+    const deterministicSeed = stableSeed?.trim() || userInfo.id
+    const messageId = generateStableId("msg_dcp_summary", deterministicSeed)
+    const partId = generateStableId("prt_dcp_summary", deterministicSeed)
+
+    return {
+        info: {
+            id: messageId,
+            sessionID: userInfo.sessionID,
+            role: "user" as const,
+            agent: userInfo.agent,
+            model: userInfo.model,
+            time: { created: now },
+        },
+        parts: [
+            {
+                id: partId,
+                sessionID: userInfo.sessionID,
+                messageID: messageId,
+                type: "text" as const,
+                text: content,
+            },
+        ],
+    }
+}
+
+export const createSyntheticTextPart = (
+    baseMessage: WithParts,
+    content: string,
+    stableSeed?: string,
+) => {
+    const userInfo = baseMessage.info as UserMessage
+    const deterministicSeed = stableSeed?.trim() || userInfo.id
+    const partId = generateStableId("prt_dcp_text", deterministicSeed)
+
+    return {
+        id: partId,
+        sessionID: userInfo.sessionID,
+        messageID: userInfo.id,
+        type: "text" as const,
+        text: content,
+    }
+}
+
+type MessagePart = WithParts["parts"][number]
+type ToolPart = Extract<MessagePart, { type: "tool" }>
+type TextPart = Extract<MessagePart, { type: "text" }>
+
+export const appendToLastTextPart = (message: WithParts, injection: string): boolean => {
+    const textPart = findLastTextPart(message)
+    if (!textPart) {
+        return false
+    }
+
+    return appendToTextPart(textPart, injection)
+}
+
+const findLastTextPart = (message: WithParts): TextPart | null => {
+    for (let i = message.parts.length - 1; i >= 0; i--) {
+        const part = message.parts[i]
+        if (part.type === "text") {
+            return part
+        }
+    }
+
+    return null
+}
+
+export const appendToTextPart = (part: TextPart, injection: string): boolean => {
+    if (typeof part.text !== "string") {
+        return false
+    }
+
+    const normalizedInjection = injection.replace(/^\n+/, "")
+    if (!normalizedInjection.trim()) {
+        return false
+    }
+    if (part.text.includes(normalizedInjection)) {
+        return true
+    }
+
+    const baseText = part.text.replace(/\n*$/, "")
+    part.text = baseText.length > 0 ? `${baseText}\n\n${normalizedInjection}` : normalizedInjection
+    return true
+}
+
+export const appendToAllToolParts = (message: WithParts, tag: string): boolean => {
+    let injected = false
+    for (const part of message.parts) {
+        if (part.type === "tool") {
+            injected = appendToToolPart(part, tag) || injected
+        }
+    }
+    return injected
+}
+
+export const appendToToolPart = (part: ToolPart, tag: string): boolean => {
+    if (part.state?.status !== "completed" || typeof part.state.output !== "string") {
+        return false
+    }
+    if (part.state.output.includes(tag)) {
+        return true
+    }
+
+    part.state.output = `${part.state.output}${tag}`
+    return true
+}
+
+export const hasContent = (message: WithParts): boolean => {
+    return message.parts.some(
+        (part) =>
+            (part.type === "text" &&
+                typeof part.text === "string" &&
+                part.text.trim().length > 0) ||
+            (part.type === "tool" &&
+                part.state?.status === "completed" &&
+                typeof part.state.output === "string"),
+    )
+}
+
+export function buildToolIdList(state: SessionState, messages: WithParts[]): string[] {
+    const toolIds: string[] = []
+    for (const msg of messages) {
+        if (isMessageCompacted(state, msg)) {
+            continue
+        }
+        const parts = Array.isArray(msg.parts) ? msg.parts : []
+        if (parts.length > 0) {
+            for (const part of parts) {
+                if (part.type === "tool" && part.callID && part.tool) {
+                    toolIds.push(part.callID)
+                }
+            }
+        }
+    }
+    state.toolIdList = toolIds
+    return toolIds
+}
+
+export const stripHallucinationsFromString = (text: string, format: IdFormat = "xml"): string => {
+    if (format === "compact") text = text.replace(COMPACT_TAG_REGEX, "")
+    const withoutKnownSuffixes = text
+        .replace(INJECTED_MESSAGE_ID_SUFFIX_REGEX, "")
+        .replace(HALLUCINATED_PARAMETER_SUFFIX_REGEX, "")
+    return withoutKnownSuffixes
+        .replace(DCP_PAIRED_TAG_REGEX, "")
+        .replace(DCP_UNPAIRED_TAG_REGEX, "")
+}
+
+export const stripHallucinations = (messages: WithParts[], format: IdFormat = "xml"): void => {
+    for (const message of messages) {
+        for (const part of message.parts) {
+            if (part.type === "text" && typeof part.text === "string") {
+                part.text = stripHallucinationsFromString(part.text, format)
+            }
+
+            if (
+                part.type === "tool" &&
+                part.state?.status === "completed" &&
+                typeof part.state.output === "string"
+            ) {
+                part.state.output = stripHallucinationsFromString(part.state.output, format)
+            }
+        }
+    }
+}

package/lib/prompts/compress-rc.ts

@@ -0,0 +1,25 @@
+import type { IdFormat } from "../message-ids"
+
+export function rcPrompt(format: IdFormat = "xml"): string {
+    const single = format === "compact" ? "`@4@`" : "`m0004`"
+    const block = format === "compact" ? "`@b2@`" : "`b2`"
+    const range = format === "compact" ? "`@4@-@8@`" : "`m0004-m0008`"
+    return `Compress stale conversation messages into technical summaries.
+
+Pass \`ids\`: an ordered list of injected message IDs, block IDs, or inclusive
+ranges. Each list item becomes one summary, so preserve the summary boundaries
+you want. For example, {"ids": [${range}, ${single}]} creates one summary for
+the range and one for the single message.
+
+Use only IDs visible in the conversation. A compressed block (${block}) can be
+used as a boundary: including it merges its summary into the new one and retires
+the old block. Prefer one broad, comprehensive selection of stale or resolved
+messages over several small calls. Do not compress messages whose exact code,
+errors, or file contents may still be needed in the immediate next steps; do not
+compress work that is still active.
+
+The summaries are generated automatically during this tool call and replace the
+selected messages in your next request.`
+}
+
+export const COMPRESS_RC = rcPrompt()

package/lib/prompts/context-limit-nudge.ts

@@ -0,0 +1,18 @@
+export const CONTEXT_LIMIT_NUDGE = `<dcp-system-reminder>
+CRITICAL WARNING: MAX CONTEXT LIMIT REACHED
+
+You are at or beyond the configured max context threshold. This is an emergency context-recovery moment.
+
+You MUST use the \`compress\` tool now. Do not continue normal exploration until compression is handled.
+
+If you are in the middle of a critical atomic operation, finish that atomic step first, then compress immediately.
+
+SELECTION PROCESS
+Start from older, resolved history and capture as much stale context as safely possible in one pass.
+Avoid the newest active working messages unless it is clearly closed.
+
+SUMMARY REQUIREMENTS
+Your summary MUST cover all essential details from the selected messages so work can continue.
+If the compressed range includes user messages, preserve user intent exactly. Prefer direct quotes for short user messages to avoid semantic drift.
+</dcp-system-reminder>
+`

package/lib/prompts/extensions/nudge.ts

@@ -0,0 +1,34 @@
+import type { SessionState } from "../../state"
+import { formatBlockRef } from "../../message-ids"
+
+export function buildCompressedBlockGuidance(state: SessionState): string {
+    const refs = Array.from(state.prune.messages.activeBlockIds)
+        .filter((id) => Number.isInteger(id) && id > 0)
+        .sort((a, b) => a - b)
+        .map((id) => formatBlockRef(id, state.idFormat))
+    const blockCount = refs.length
+    const blockList = blockCount > 0 ? refs.join(", ") : "none"
+
+    return [
+        "Compressed block context:",
+        `- Active compressed blocks in this session: ${blockCount} (${blockList})`,
+        "- Compressed blocks can be used as selection boundaries: include a block ID (or a range spanning it) to merge its summary into a new summary and retire the old block.",
+    ].join("\n")
+}
+
+export function appendGuidanceToDcpTag(nudgeText: string, guidance: string): string {
+    if (!guidance.trim()) {
+        return nudgeText
+    }
+
+    const closeTag = "</dcp-system-reminder>"
+    const closeTagIndex = nudgeText.lastIndexOf(closeTag)
+
+    if (closeTagIndex === -1) {
+        return nudgeText
+    }
+
+    const beforeClose = nudgeText.slice(0, closeTagIndex).trimEnd()
+    const afterClose = nudgeText.slice(closeTagIndex)
+    return `${beforeClose}\n\n${guidance}\n${afterClose}`
+}

package/lib/prompts/extensions/system.ts

@@ -0,0 +1,32 @@
+export const MANUAL_MODE_SYSTEM_EXTENSION = `<dcp-system-reminder>
+Manual mode is enabled. Do NOT use compress unless the user has explicitly triggered it through a manual marker.
+
+Only use the compress tool after seeing \`<compress triggered manually>\` in the current user instruction context.
+
+Issue exactly ONE compress tool per manual trigger. Do NOT launch multiple compress tools in parallel. Each trigger grants a single compression; after it completes, wait for the next trigger.
+
+After completing a manually triggered context-management action, STOP IMMEDIATELY. Do NOT continue with any task execution. End your response right after the tool use completes and wait for the next user input.
+</dcp-system-reminder>
+`
+
+export const SUBAGENT_SYSTEM_EXTENSION = `<dcp-system-reminder>
+You are operating in a subagent environment.
+
+The initial subagent instruction is imperative and must be followed exactly.
+It is the only user message intentionally not assigned a message ID, and therefore is not eligible for compression.
+All subsequent messages in the session will have IDs.
+</dcp-system-reminder>
+`
+
+export function buildProtectedToolsExtension(protectedTools: string[]): string {
+    if (protectedTools.length === 0) {
+        return ""
+    }
+
+    const toolList = protectedTools.map((t) => `\`${t}\``).join(", ")
+    return `<dcp-system-reminder>
+The following tools are environment-managed: ${toolList}.
+Their outputs are automatically preserved during compression.
+Do not include their content in compress tool summaries — the environment retains it independently.
+</dcp-system-reminder>`
+}

package/lib/prompts/extensions/tool.ts

@@ -0,0 +1,21 @@
+// These format schemas are kept separate from the editable compress prompts
+// so they cannot be modified via custom prompt overrides. The schemas must
+// match the tool's input validation and are not safe to change independently.
+
+import type { IdFormat } from "../../message-ids"
+
+export function rcFormat(format: IdFormat = "xml"): string {
+    const single = format === "compact" ? "@4@" : "m0004"
+    const block = format === "compact" ? "@b2@" : "b2"
+    const range = format === "compact" ? "@4@-@8@" : "m0004-m0008"
+    return `
+THE FORMAT OF COMPRESS
+
+\`\`\`
+{
+  ids: string[]   // Injected message IDs, block IDs, or inclusive ranges; each item becomes one summary
+}
+\`\`\`
+
+Examples: \`{"ids": ["${range}", "${single}"]}\` creates one summary for the range and a separate summary for the single message. \`{"ids": ["${block}"]}\` merges an existing compressed block into a new summary.`
+}

package/lib/prompts/index.ts

@@ -0,0 +1,29 @@
+import type { RuntimePrompts } from "./store"
+export type { PromptStore, RuntimePrompts } from "./store"
+
+export function renderSystemPrompt(
+    prompts: RuntimePrompts,
+    protectedToolsExtension?: string,
+    manual?: boolean,
+    subagent?: boolean,
+): string {
+    const extensions: string[] = []
+
+    if (protectedToolsExtension) {
+        extensions.push(protectedToolsExtension.trim())
+    }
+
+    if (manual) {
+        extensions.push(prompts.manualExtension.trim())
+    }
+
+    if (subagent) {
+        extensions.push(prompts.subagentExtension.trim())
+    }
+
+    return [prompts.system.trim(), ...extensions]
+        .filter(Boolean)
+        .join("\n\n")
+        .replace(/\n([ \t]*\n)+/g, "\n\n")
+        .trim()
+}

package/lib/prompts/iteration-nudge.ts

@@ -0,0 +1,6 @@
+export const ITERATION_NUDGE = `<dcp-system-reminder>
+You've been iterating for a while after the last user message.
+
+If there is a closed portion that is unlikely to be referenced immediately (for example, finished research before implementation), use the compress tool on it now.
+</dcp-system-reminder>
+`