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

package/lib/state/persistence.ts

@@ -0,0 +1,305 @@
+/**
+ * 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
+    manualMode?: boolean
+    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,
+            manualMode: !!sessionState.manualMode,
+            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
+    }
+}
+
+function emptyPersistedState(manualMode: boolean): PersistedSessionState {
+    return {
+        manualMode,
+        prune: {
+            tools: {},
+            messages: {
+                byMessageId: {},
+                blocksById: {},
+                activeBlockIds: [],
+                activeByAnchorMessageId: {},
+                nextBlockId: 1,
+                nextRunId: 1,
+            },
+        },
+        nudges: {
+            contextLimitAnchors: [],
+            turnNudgeAnchors: [],
+            iterationNudgeAnchors: [],
+        },
+        stats: {
+            pruneTokenCounter: 0,
+            totalPruneTokens: 0,
+        },
+        lastUpdated: new Date().toISOString(),
+    }
+}
+
+export async function loadManualModeSetting(
+    sessionId: string,
+    logger: Logger,
+): Promise<boolean | undefined> {
+    const state = await loadSessionState(sessionId, logger)
+    return typeof state?.manualMode === "boolean" ? state.manualMode : undefined
+}
+
+export async function saveManualModeSetting(
+    sessionId: string,
+    manualMode: boolean,
+    logger: Logger,
+): Promise<void> {
+    const existing = await loadSessionState(sessionId, logger)
+    const state = existing ?? emptyPersistedState(manualMode)
+    state.manualMode = manualMode
+    state.lastUpdated = new Date().toISOString()
+    await writePersistedSessionState(sessionId, state, logger)
+}
+
+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
+}

package/lib/state/state.ts

@@ -0,0 +1,210 @@
+import type { SessionState, ToolParameterEntry, WithParts } from "./types"
+import type { Logger } from "../logger"
+import { applyPendingCompressionDurations } from "../compress/timing"
+import { loadManualModeSetting, loadSessionState, saveSessionState } from "./persistence"
+import {
+    isSubAgentSession,
+    findLastCompactionTimestamp,
+    countTurns,
+    resetOnCompaction,
+    createPruneMessagesState,
+    loadPruneMessagesState,
+    loadPruneMap,
+    collectTurnNudgeAnchors,
+} from "./utils"
+import { getLastUserMessage } from "../messages/query"
+import type { IdFormat } from "../message-ids"
+
+export const checkSession = async (
+    client: any,
+    state: SessionState,
+    logger: Logger,
+    messages: WithParts[],
+    manualModeDefault: boolean,
+): Promise<void> => {
+    const lastUserMessage = getLastUserMessage(messages)
+    if (!lastUserMessage) {
+        return
+    }
+
+    const lastSessionId = lastUserMessage.info.sessionID
+
+    if (state.sessionId === null || state.sessionId !== lastSessionId) {
+        logger.info(`Session changed: ${state.sessionId} -> ${lastSessionId}`)
+        try {
+            await ensureSessionInitialized(
+                client,
+                state,
+                lastSessionId,
+                logger,
+                messages,
+                manualModeDefault,
+            )
+        } catch (err: any) {
+            logger.error("Failed to initialize session state", { error: err.message })
+        }
+    }
+
+    const lastCompactionTimestamp = findLastCompactionTimestamp(messages)
+    if (lastCompactionTimestamp > state.lastCompaction) {
+        state.lastCompaction = lastCompactionTimestamp
+        resetOnCompaction(state)
+        logger.info("Detected compaction - reset stale state", {
+            timestamp: lastCompactionTimestamp,
+        })
+
+        saveSessionState(state, logger).catch((error) => {
+            logger.warn("Failed to persist state reset after compaction", {
+                error: error instanceof Error ? error.message : String(error),
+            })
+        })
+    }
+
+    state.currentTurn = countTurns(state, messages)
+    await refreshManualMode(state, lastSessionId, logger, manualModeDefault)
+}
+
+export function createSessionState(idFormat: IdFormat = "xml"): SessionState {
+    return {
+        idFormat,
+        sessionId: null,
+        isSubAgent: false,
+        manualMode: false,
+        compressPermission: undefined,
+        pendingManualTrigger: null,
+        prune: {
+            tools: new Map<string, number>(),
+            messages: createPruneMessagesState(),
+        },
+        nudges: {
+            contextLimitAnchors: new Set<string>(),
+            turnNudgeAnchors: new Set<string>(),
+            iterationNudgeAnchors: new Set<string>(),
+        },
+        stats: {
+            pruneTokenCounter: 0,
+            totalPruneTokens: 0,
+        },
+        compressionTiming: {
+            startsByCallId: new Map<string, number>(),
+            pendingByCallId: new Map(),
+        },
+        toolParameters: new Map<string, ToolParameterEntry>(),
+        subAgentResultCache: new Map<string, string>(),
+        toolIdList: [],
+        messageIds: {
+            byRawId: new Map<string, string>(),
+            byRef: new Map<string, string>(),
+            nextRef: 1,
+        },
+        lastCompaction: 0,
+        currentTurn: 0,
+        modelContextLimit: undefined,
+        systemPromptTokens: undefined,
+    }
+}
+
+export function resetSessionState(state: SessionState): void {
+    state.sessionId = null
+    state.isSubAgent = false
+    state.manualMode = false
+    state.compressPermission = undefined
+    state.pendingManualTrigger = null
+    state.prune = {
+        tools: new Map<string, number>(),
+        messages: createPruneMessagesState(),
+    }
+    state.nudges = {
+        contextLimitAnchors: new Set<string>(),
+        turnNudgeAnchors: new Set<string>(),
+        iterationNudgeAnchors: new Set<string>(),
+    }
+    state.stats = {
+        pruneTokenCounter: 0,
+        totalPruneTokens: 0,
+    }
+    state.toolParameters.clear()
+    state.subAgentResultCache.clear()
+    state.toolIdList = []
+    state.messageIds = {
+        byRawId: new Map<string, string>(),
+        byRef: new Map<string, string>(),
+        nextRef: 1,
+    }
+    state.lastCompaction = 0
+    state.currentTurn = 0
+    state.modelContextLimit = undefined
+    state.systemPromptTokens = undefined
+}
+
+export async function ensureSessionInitialized(
+    client: any,
+    state: SessionState,
+    sessionId: string,
+    logger: Logger,
+    messages: WithParts[],
+    manualModeEnabled: boolean,
+): Promise<void> {
+    if (state.sessionId === sessionId) {
+        return
+    }
+
+    // logger.info("session ID = " + sessionId)
+    // logger.info("Initializing session state", { sessionId: sessionId })
+
+    resetSessionState(state)
+    state.manualMode = manualModeEnabled ? "active" : false
+    state.sessionId = sessionId
+
+    const isSubAgent = await isSubAgentSession(client, sessionId)
+    state.isSubAgent = isSubAgent
+    // logger.info("isSubAgent = " + isSubAgent)
+
+    state.lastCompaction = findLastCompactionTimestamp(messages)
+    state.currentTurn = countTurns(state, messages)
+    state.nudges.turnNudgeAnchors = collectTurnNudgeAnchors(messages)
+
+    const persisted = await loadSessionState(sessionId, logger)
+    if (persisted === null) {
+        return
+    }
+
+    if (typeof persisted.manualMode === "boolean") {
+        state.manualMode = persisted.manualMode ? "active" : false
+    }
+
+    state.prune.tools = loadPruneMap(persisted.prune.tools)
+    state.prune.messages = loadPruneMessagesState(persisted.prune.messages)
+    state.nudges.contextLimitAnchors = new Set<string>(persisted.nudges.contextLimitAnchors || [])
+    state.nudges.turnNudgeAnchors = new Set<string>([
+        ...state.nudges.turnNudgeAnchors,
+        ...(persisted.nudges.turnNudgeAnchors || []),
+    ])
+    state.nudges.iterationNudgeAnchors = new Set<string>(
+        persisted.nudges.iterationNudgeAnchors || [],
+    )
+    state.stats = {
+        pruneTokenCounter: persisted.stats?.pruneTokenCounter || 0,
+        totalPruneTokens: persisted.stats?.totalPruneTokens || 0,
+    }
+
+    const applied = applyPendingCompressionDurations(state)
+    if (applied > 0) {
+        await saveSessionState(state, logger)
+    }
+}
+
+export async function refreshManualMode(
+    state: SessionState,
+    sessionId: string,
+    logger: Logger,
+    manualModeDefault: boolean,
+): Promise<void> {
+    if (state.manualMode === "compress-pending") {
+        return
+    }
+
+    const persisted = await loadManualModeSetting(sessionId, logger)
+    const enabled = persisted ?? manualModeDefault
+    state.manualMode = enabled ? "active" : false
+}

package/lib/state/tool-cache.ts

@@ -0,0 +1,99 @@
+import type { SessionState, ToolStatus, WithParts } from "./index"
+import type { Logger } from "../logger"
+import { PluginConfig } from "../config"
+import { isMessageCompacted } from "./utils"
+import { countToolTokens } from "../token-utils"
+
+const MAX_TOOL_CACHE_SIZE = 1000
+
+/**
+ * Sync tool parameters from session messages.
+ */
+export function syncToolCache(
+    state: SessionState,
+    config: PluginConfig,
+    logger: Logger,
+    messages: WithParts[],
+): void {
+    try {
+        logger.info("Syncing tool parameters from OpenCode messages")
+
+        let turnCounter = 0
+
+        for (const msg of messages) {
+            if (isMessageCompacted(state, msg)) {
+                continue
+            }
+
+            const parts = Array.isArray(msg.parts) ? msg.parts : []
+            for (const part of parts) {
+                if (part.type === "step-start") {
+                    turnCounter++
+                    continue
+                }
+
+                if (part.type !== "tool" || !part.callID) {
+                    continue
+                }
+
+                const turnProtectionEnabled = config.turnProtection.enabled
+                const turnProtectionTurns = config.turnProtection.turns
+                const isProtectedByTurn =
+                    turnProtectionEnabled &&
+                    turnProtectionTurns > 0 &&
+                    state.currentTurn - turnCounter < turnProtectionTurns
+
+                if (state.toolParameters.has(part.callID)) {
+                    continue
+                }
+
+                if (isProtectedByTurn) {
+                    continue
+                }
+
+                const tokenCount = countToolTokens(part)
+
+                state.toolParameters.set(part.callID, {
+                    tool: part.tool,
+                    parameters: part.state?.input ?? {},
+                    metadata: "metadata" in part.state ? part.state.metadata : undefined,
+                    status: part.state.status as ToolStatus | undefined,
+                    error: part.state.status === "error" ? part.state.error : undefined,
+                    turn: turnCounter,
+                    tokenCount,
+                })
+                logger.info(
+                    `Cached tool id: ${part.callID} (turn ${turnCounter}${tokenCount !== undefined ? `, ${tokenCount} tokens` : ""})`,
+                )
+            }
+        }
+
+        logger.info(
+            `Synced cache - size: ${state.toolParameters.size}, currentTurn: ${state.currentTurn}`,
+        )
+        trimToolParametersCache(state)
+    } catch (error) {
+        logger.warn("Failed to sync tool parameters from OpenCode", {
+            error: error instanceof Error ? error.message : String(error),
+        })
+    }
+}
+
+/**
+ * Trim the tool parameters cache to prevent unbounded memory growth.
+ * Uses FIFO eviction - removes oldest entries first.
+ */
+export function trimToolParametersCache(state: SessionState): void {
+    if (state.toolParameters.size <= MAX_TOOL_CACHE_SIZE) {
+        return
+    }
+
+    const keysToRemove = Array.from(state.toolParameters.keys()).slice(
+        0,
+        state.toolParameters.size - MAX_TOOL_CACHE_SIZE,
+    )
+
+    for (const key of keysToRemove) {
+        state.toolParameters.delete(key)
+    }
+}