@tarquinen/opencode-dcp 3.2.3-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/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"

package/lib/state/persistence.ts

@@ -1,256 +0,0 @@
-/**
- * State persistence module for DCP plugin.
- * Persists pruned tool IDs across sessions so they survive OpenCode restarts.
- * Storage location: ~/.local/share/opencode/storage/plugin/dcp/{sessionId}.json
- */
-
-import * as fs from "fs/promises"
-import { existsSync } from "fs"
-import { homedir } from "os"
-import { join } from "path"
-import type { CompressionBlock, PrunedMessageEntry, SessionState, SessionStats } from "./types"
-import type { Logger } from "../logger"
-import { serializePruneMessagesState } from "./utils"
-
-/** Prune state as stored on disk */
-export interface PersistedPruneMessagesState {
-    byMessageId: Record<string, PrunedMessageEntry>
-    blocksById: Record<string, CompressionBlock>
-    activeBlockIds: number[]
-    activeByAnchorMessageId: Record<string, number>
-    nextBlockId: number
-    nextRunId: number
-}
-
-export interface PersistedPrune {
-    tools?: Record<string, number>
-    messages?: PersistedPruneMessagesState
-}
-
-export interface PersistedNudges {
-    contextLimitAnchors: string[]
-    turnNudgeAnchors?: string[]
-    iterationNudgeAnchors?: string[]
-}
-
-export interface PersistedSessionState {
-    sessionName?: string
-    prune: PersistedPrune
-    nudges: PersistedNudges
-    stats: SessionStats
-    lastUpdated: string
-}
-
-const STORAGE_DIR = join(
-    process.env.XDG_DATA_HOME || join(homedir(), ".local", "share"),
-    "opencode",
-    "storage",
-    "plugin",
-    "dcp",
-)
-
-async function ensureStorageDir(): Promise<void> {
-    if (!existsSync(STORAGE_DIR)) {
-        await fs.mkdir(STORAGE_DIR, { recursive: true })
-    }
-}
-
-function getSessionFilePath(sessionId: string): string {
-    return join(STORAGE_DIR, `${sessionId}.json`)
-}
-
-async function writePersistedSessionState(
-    sessionId: string,
-    state: PersistedSessionState,
-    logger: Logger,
-): Promise<void> {
-    await ensureStorageDir()
-
-    const filePath = getSessionFilePath(sessionId)
-    const content = JSON.stringify(state, null, 2)
-    await fs.writeFile(filePath, content, "utf-8")
-
-    logger.info("Saved session state to disk", {
-        sessionId,
-        totalTokensSaved: state.stats.totalPruneTokens,
-    })
-}
-
-export async function saveSessionState(
-    sessionState: SessionState,
-    logger: Logger,
-    sessionName?: string,
-): Promise<void> {
-    try {
-        if (!sessionState.sessionId) {
-            return
-        }
-
-        const state: PersistedSessionState = {
-            sessionName: sessionName,
-            prune: {
-                tools: Object.fromEntries(sessionState.prune.tools),
-                messages: serializePruneMessagesState(sessionState.prune.messages),
-            },
-            nudges: {
-                contextLimitAnchors: Array.from(sessionState.nudges.contextLimitAnchors),
-                turnNudgeAnchors: Array.from(sessionState.nudges.turnNudgeAnchors),
-                iterationNudgeAnchors: Array.from(sessionState.nudges.iterationNudgeAnchors),
-            },
-            stats: sessionState.stats,
-            lastUpdated: new Date().toISOString(),
-        }
-
-        await writePersistedSessionState(sessionState.sessionId, state, logger)
-    } catch (error: any) {
-        logger.error("Failed to save session state", {
-            sessionId: sessionState.sessionId,
-            error: error?.message,
-        })
-    }
-}
-
-export async function loadSessionState(
-    sessionId: string,
-    logger: Logger,
-): Promise<PersistedSessionState | null> {
-    try {
-        const filePath = getSessionFilePath(sessionId)
-
-        if (!existsSync(filePath)) {
-            return null
-        }
-
-        const content = await fs.readFile(filePath, "utf-8")
-        const state = JSON.parse(content) as PersistedSessionState
-
-        const hasPruneTools = state?.prune?.tools && typeof state.prune.tools === "object"
-        const hasPruneMessages = state?.prune?.messages && typeof state.prune.messages === "object"
-        const hasNudgeFormat = state?.nudges && typeof state.nudges === "object"
-        if (
-            !state ||
-            !state.prune ||
-            !hasPruneTools ||
-            !hasPruneMessages ||
-            !state.stats ||
-            !hasNudgeFormat
-        ) {
-            logger.warn("Invalid session state file, ignoring", {
-                sessionId: sessionId,
-            })
-            return null
-        }
-
-        const rawContextLimitAnchors = Array.isArray(state.nudges.contextLimitAnchors)
-            ? state.nudges.contextLimitAnchors
-            : []
-        const validAnchors = rawContextLimitAnchors.filter(
-            (entry): entry is string => typeof entry === "string",
-        )
-        const dedupedAnchors = [...new Set(validAnchors)]
-        if (validAnchors.length !== rawContextLimitAnchors.length) {
-            logger.warn("Filtered out malformed contextLimitAnchors entries", {
-                sessionId: sessionId,
-                original: rawContextLimitAnchors.length,
-                valid: validAnchors.length,
-            })
-        }
-        state.nudges.contextLimitAnchors = dedupedAnchors
-
-        const rawTurnNudgeAnchors = Array.isArray(state.nudges.turnNudgeAnchors)
-            ? state.nudges.turnNudgeAnchors
-            : []
-        const validSoftAnchors = rawTurnNudgeAnchors.filter(
-            (entry): entry is string => typeof entry === "string",
-        )
-        const dedupedSoftAnchors = [...new Set(validSoftAnchors)]
-        if (validSoftAnchors.length !== rawTurnNudgeAnchors.length) {
-            logger.warn("Filtered out malformed turnNudgeAnchors entries", {
-                sessionId: sessionId,
-                original: rawTurnNudgeAnchors.length,
-                valid: validSoftAnchors.length,
-            })
-        }
-        state.nudges.turnNudgeAnchors = dedupedSoftAnchors
-
-        const rawIterationNudgeAnchors = Array.isArray(state.nudges.iterationNudgeAnchors)
-            ? state.nudges.iterationNudgeAnchors
-            : []
-        const validIterationAnchors = rawIterationNudgeAnchors.filter(
-            (entry): entry is string => typeof entry === "string",
-        )
-        const dedupedIterationAnchors = [...new Set(validIterationAnchors)]
-        if (validIterationAnchors.length !== rawIterationNudgeAnchors.length) {
-            logger.warn("Filtered out malformed iterationNudgeAnchors entries", {
-                sessionId: sessionId,
-                original: rawIterationNudgeAnchors.length,
-                valid: validIterationAnchors.length,
-            })
-        }
-        state.nudges.iterationNudgeAnchors = dedupedIterationAnchors
-
-        logger.info("Loaded session state from disk", {
-            sessionId: sessionId,
-        })
-
-        return state
-    } catch (error: any) {
-        logger.warn("Failed to load session state", {
-            sessionId: sessionId,
-            error: error?.message,
-        })
-        return null
-    }
-}
-
-export interface AggregatedStats {
-    totalTokens: number
-    totalTools: number
-    totalMessages: number
-    sessionCount: number
-}
-
-export async function loadAllSessionStats(logger: Logger): Promise<AggregatedStats> {
-    const result: AggregatedStats = {
-        totalTokens: 0,
-        totalTools: 0,
-        totalMessages: 0,
-        sessionCount: 0,
-    }
-
-    try {
-        if (!existsSync(STORAGE_DIR)) {
-            return result
-        }
-
-        const files = await fs.readdir(STORAGE_DIR)
-        const jsonFiles = files.filter((f) => f.endsWith(".json"))
-
-        for (const file of jsonFiles) {
-            try {
-                const filePath = join(STORAGE_DIR, file)
-                const content = await fs.readFile(filePath, "utf-8")
-                const state = JSON.parse(content) as PersistedSessionState
-
-                if (state?.stats?.totalPruneTokens && state?.prune) {
-                    result.totalTokens += state.stats.totalPruneTokens
-                    result.totalTools += state.prune.tools
-                        ? Object.keys(state.prune.tools).length
-                        : 0
-                    result.totalMessages += state.prune.messages?.byMessageId
-                        ? Object.keys(state.prune.messages.byMessageId).length
-                        : 0
-                    result.sessionCount++
-                }
-            } catch {
-                // Skip invalid files
-            }
-        }
-
-        logger.debug("Loaded all-time stats", result)
-    } catch (error: any) {
-        logger.warn("Failed to load all-time stats", { error: error?.message })
-    }
-
-    return result
-}