@tarquinen/opencode-dcp 3.2.3-beta0 → 3.2.4-beta0

package/lib/compress/types.ts

@@ -0,0 +1,108 @@
+import type { PluginConfig } from "../config"
+import type { Logger } from "../logger"
+import type { PromptStore } from "../prompts/store"
+import type { CompressionBlock, CompressionMode, SessionState, WithParts } from "../state"
+
+export interface ToolContext {
+    client: any
+    state: SessionState
+    logger: Logger
+    config: PluginConfig
+    prompts: PromptStore
+}
+
+export interface CompressRangeEntry {
+    startId: string
+    endId: string
+    summary: string
+}
+
+export interface CompressRangeToolArgs {
+    topic: string
+    content: CompressRangeEntry[]
+}
+
+export interface CompressMessageEntry {
+    messageId: string
+    topic: string
+    summary: string
+}
+
+export interface CompressMessageToolArgs {
+    topic: string
+    content: CompressMessageEntry[]
+}
+
+export interface BoundaryReference {
+    kind: "message" | "compressed-block"
+    rawIndex: number
+    messageId?: string
+    blockId?: number
+    anchorMessageId?: string
+}
+
+export interface SearchContext {
+    rawMessages: WithParts[]
+    rawMessagesById: Map<string, WithParts>
+    rawIndexById: Map<string, number>
+    summaryByBlockId: Map<number, CompressionBlock>
+}
+
+export interface SelectionResolution {
+    startReference: BoundaryReference
+    endReference: BoundaryReference
+    messageIds: string[]
+    messageTokenById: Map<string, number>
+    toolIds: string[]
+    requiredBlockIds: number[]
+}
+
+export interface ResolvedMessageCompression {
+    entry: CompressMessageEntry
+    selection: SelectionResolution
+    anchorMessageId: string
+}
+
+export interface ResolvedRangeCompression {
+    index: number
+    entry: CompressRangeEntry
+    selection: SelectionResolution
+    anchorMessageId: string
+}
+
+export interface ResolvedMessageCompressionsResult {
+    plans: ResolvedMessageCompression[]
+    skippedIssues: string[]
+    skippedCount: number
+}
+
+export interface ParsedBlockPlaceholder {
+    raw: string
+    blockId: number
+    startIndex: number
+    endIndex: number
+}
+
+export interface InjectedSummaryResult {
+    expandedSummary: string
+    consumedBlockIds: number[]
+}
+
+export interface AppliedCompressionResult {
+    compressedTokens: number
+    messageIds: string[]
+    newlyCompressedMessageIds: string[]
+    newlyCompressedToolIds: string[]
+}
+
+export interface CompressionStateInput {
+    topic: string
+    batchTopic: string
+    startId: string
+    endId: string
+    mode: CompressionMode
+    runId: number
+    compressMessageId: string
+    compressCallId?: string
+    summaryTokens: number
+}

package/lib/config.ts

@@ -642,7 +642,7 @@ function scheduleConfigWarning(
         if (!notify) return
         try {
             notify(title, message)
-        } catch { }
+        } catch {}
     }, 7000)
 }
 
@@ -766,8 +766,8 @@ function getConfigPaths(directory?: string): {
     const global = existsSync(GLOBAL_CONFIG_PATH_JSONC)
         ? GLOBAL_CONFIG_PATH_JSONC
         : existsSync(GLOBAL_CONFIG_PATH_JSON)
-            ? GLOBAL_CONFIG_PATH_JSON
-            : null
+          ? GLOBAL_CONFIG_PATH_JSON
+          : null
 
     let configDir: string | null = null
     const opencodeConfigDir = process.env.OPENCODE_CONFIG_DIR
@@ -777,8 +777,8 @@ function getConfigPaths(directory?: string): {
         configDir = existsSync(configJsonc)
             ? configJsonc
             : existsSync(configJson)
-                ? configJson
-                : null
+              ? configJson
+              : null
     }
 
     let project: string | null = null
@@ -790,8 +790,8 @@ function getConfigPaths(directory?: string): {
             project = existsSync(projectJsonc)
                 ? projectJsonc
                 : existsSync(projectJson)
-                    ? projectJson
-                    : null
+                  ? projectJson
+                  : null
         }
     }
 

package/lib/message-ids.ts

@@ -0,0 +1,172 @@
+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 MESSAGE_ID_TAG_NAME = "dcp-message-id"
+
+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): string {
+    if (
+        !Number.isInteger(index) ||
+        index < MESSAGE_REF_MIN_INDEX ||
+        index > MESSAGE_REF_MAX_INDEX
+    ) {
+        throw new Error(
+            `Message ID index out of bounds: ${index}. Supported range is 0-${MESSAGE_REF_MAX_INDEX}.`,
+        )
+    }
+    return `m${index.toString().padStart(MESSAGE_REF_WIDTH, "0")}`
+}
+
+export function formatBlockRef(blockId: number): string {
+    if (!Number.isInteger(blockId) || blockId < 1) {
+        throw new Error(`Invalid block ID: ${blockId}`)
+    }
+    return `b${blockId}`
+}
+
+export function parseMessageRef(ref: string): number | null {
+    const normalized = ref.trim().toLowerCase()
+    const match = normalized.match(MESSAGE_REF_REGEX)
+    if (!match) {
+        return null
+    }
+    const index = Number.parseInt(match[1], 10)
+    if (!Number.isInteger(index)) {
+        return null
+    }
+    if (index < MESSAGE_REF_MIN_INDEX || index > MESSAGE_REF_MAX_INDEX) {
+        return null
+    }
+    return index
+}
+
+export function parseBlockRef(ref: string): number | null {
+    const normalized = ref.trim().toLowerCase()
+    const match = normalized.match(BLOCK_REF_REGEX)
+    if (!match) {
+        return null
+    }
+    const id = Number.parseInt(match[1], 10)
+    return Number.isInteger(id) ? id : null
+}
+
+export function parseBoundaryId(id: string): ParsedBoundaryId | null {
+    const normalized = id.trim().toLowerCase()
+    const messageIndex = parseMessageRef(normalized)
+    if (messageIndex !== null) {
+        return {
+            kind: "message",
+            ref: formatMessageRef(messageIndex),
+            index: messageIndex,
+        }
+    }
+
+    const blockId = parseBlockRef(normalized)
+    if (blockId !== null) {
+        return {
+            kind: "compressed-block",
+            ref: formatBlockRef(blockId),
+            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>,
+): string {
+    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
+
+    while (candidate <= MESSAGE_REF_MAX_INDEX) {
+        const ref = formatMessageRef(candidate)
+        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(MESSAGE_REF_MAX_INDEX)} aliases in this session.`,
+    )
+}

package/package.json

@@ -1,7 +1,7 @@
 {
     "$schema": "https://json.schemastore.org/package.json",
     "name": "@tarquinen/opencode-dcp",
-    "version": "3.2.3-beta0",
+    "version": "3.2.4-beta0",
     "type": "module",
     "description": "OpenCode plugin that optimizes token usage by pruning obsolete tool outputs from conversation context",
     "main": "./dist/index.js",
@@ -74,9 +74,11 @@
     "files": [
         "dist/",
         "lib/analysis/",
+        "lib/compress/",
         "lib/state/",
         "lib/config.ts",
         "lib/logger.ts",
+        "lib/message-ids.ts",
         "lib/messages/query.ts",
         "lib/token-utils.ts",
         "tui/data/",