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

package/lib/logger.ts

@@ -1,235 +0,0 @@
-import { writeFile, mkdir } from "fs/promises"
-import { join } from "path"
-import { existsSync } from "fs"
-import { homedir } from "os"
-
-export class Logger {
-    private logDir: string
-    private scope?: string
-    public enabled: boolean
-
-    constructor(enabled: boolean, scope?: string) {
-        this.enabled = enabled
-        this.scope = scope?.replace(/[^A-Za-z0-9._-]/g, "_")
-        const configHome = process.env.XDG_CONFIG_HOME || join(homedir(), ".config")
-        this.logDir = this.scope
-            ? join(configHome, "opencode", "logs", "dcp", this.scope)
-            : 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 logFile = this.scope
-                ? join(this.logDir, `${new Date().toISOString().split("T")[0]}.log`)
-                : join(this.logDir, "daily", `${new Date().toISOString().split("T")[0]}.log`)
-
-            if (!this.scope) {
-                const dailyLogDir = join(this.logDir, "daily")
-                if (!existsSync(dailyLogDir)) {
-                    await mkdir(dailyLogDir, { recursive: true })
-                }
-            }
-
-            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

@@ -1,172 +0,0 @@
-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/lib/messages/query.ts

@@ -1,56 +0,0 @@
-import type { PluginConfig } from "../config"
-import type { WithParts } from "../state"
-
-export const getLastUserMessage = (
-    messages: WithParts[],
-    startIndex?: number,
-): WithParts | null => {
-    const start = startIndex ?? messages.length - 1
-    for (let i = start; i >= 0; i--) {
-        const msg = messages[i]
-        if (msg.info.role === "user" && !isIgnoredUserMessage(msg)) {
-            return msg
-        }
-    }
-    return null
-}
-
-export const messageHasCompress = (message: WithParts): boolean => {
-    if (message.info.role !== "assistant") {
-        return false
-    }
-
-    const parts = Array.isArray(message.parts) ? message.parts : []
-    return parts.some(
-        (part) =>
-            part.type === "tool" && part.tool === "compress" && part.state?.status === "completed",
-    )
-}
-
-export const isIgnoredUserMessage = (message: WithParts): boolean => {
-    if (message.info.role !== "user") {
-        return false
-    }
-
-    const parts = Array.isArray(message.parts) ? message.parts : []
-    if (parts.length === 0) {
-        return true
-    }
-
-    for (const part of parts) {
-        if (!(part as any).ignored) {
-            return false
-        }
-    }
-
-    return true
-}
-
-export function isProtectedUserMessage(config: PluginConfig, message: WithParts): boolean {
-    return (
-        config.compress.mode === "message" &&
-        config.compress.protectUserMessages &&
-        message.info.role === "user" &&
-        !isIgnoredUserMessage(message)
-    )
-}

package/lib/state/index.ts

@@ -1,4 +0,0 @@
-export * from "./persistence"
-export * from "./types"
-export * from "./state"
-export * from "./tool-cache"