openrecall 0.2.2 → 0.4.0

package/src/dcp/shared-utils.ts

@@ -0,0 +1,26 @@
+import type { SessionState, WithParts } from "./state"
+import { isIgnoredUserMessage } from "./messages/utils"
+
+export const isMessageCompacted = (state: SessionState, msg: WithParts): boolean => {
+    if (msg.info.time.created < state.lastCompaction) {
+        return true
+    }
+    if (state.prune.messages.has(msg.info.id)) {
+        return true
+    }
+    return false
+}
+
+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
+}

package/src/dcp/state/index.ts

@@ -0,0 +1,3 @@
+export * from "./persistence"
+export * from "./types"
+export * from "./state"

package/src/dcp/state/persistence.ts

@@ -0,0 +1,196 @@
+/**
+ * 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 { SessionState, SessionStats, CompressSummary } from "./types"
+import type { Logger } from "../logger"
+
+/** Prune state as stored on disk */
+export interface PersistedPrune {
+    // New format: tool/message IDs with token counts
+    tools?: Record<string, number>
+    messages?: Record<string, number>
+    // Legacy format: plain ID arrays (backward compatibility)
+    toolIds?: string[]
+    messageIds?: string[]
+}
+
+export interface PersistedSessionState {
+    sessionName?: string
+    prune: PersistedPrune
+    compressSummaries: CompressSummary[]
+    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`)
+}
+
+export async function saveSessionState(
+    sessionState: SessionState,
+    logger: Logger,
+    sessionName?: string,
+): Promise<void> {
+    try {
+        if (!sessionState.sessionId) {
+            return
+        }
+
+        await ensureStorageDir()
+
+        const state: PersistedSessionState = {
+            sessionName: sessionName,
+            prune: {
+                tools: Object.fromEntries(sessionState.prune.tools),
+                messages: Object.fromEntries(sessionState.prune.messages),
+            },
+            compressSummaries: sessionState.compressSummaries,
+            stats: sessionState.stats,
+            lastUpdated: new Date().toISOString(),
+        }
+
+        const filePath = getSessionFilePath(sessionState.sessionId)
+        const content = JSON.stringify(state, null, 2)
+        await fs.writeFile(filePath, content, "utf-8")
+
+        logger.info("Saved session state to disk", {
+            sessionId: sessionState.sessionId,
+            totalTokensSaved: state.stats.totalPruneTokens,
+        })
+    } 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 hasNewFormat = state?.prune?.tools && typeof state.prune.tools === "object"
+        const hasLegacyFormat = Array.isArray(state?.prune?.toolIds)
+        if (!state || !state.prune || (!hasNewFormat && !hasLegacyFormat) || !state.stats) {
+            logger.warn("Invalid session state file, ignoring", {
+                sessionId: sessionId,
+            })
+            return null
+        }
+
+        if (Array.isArray(state.compressSummaries)) {
+            const validSummaries = state.compressSummaries.filter(
+                (s): s is CompressSummary =>
+                    s !== null &&
+                    typeof s === "object" &&
+                    typeof s.anchorMessageId === "string" &&
+                    typeof s.summary === "string",
+            )
+            if (validSummaries.length !== state.compressSummaries.length) {
+                logger.warn("Filtered out malformed compressSummaries entries", {
+                    sessionId: sessionId,
+                    original: state.compressSummaries.length,
+                    valid: validSummaries.length,
+                })
+            }
+            state.compressSummaries = validSummaries
+        } else {
+            state.compressSummaries = []
+        }
+
+        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
+                        : (state.prune.toolIds?.length ?? 0)
+                    result.totalMessages += state.prune.messages
+                        ? Object.keys(state.prune.messages).length
+                        : (state.prune.messageIds?.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/src/dcp/state/state.ts

@@ -0,0 +1,143 @@
+import type { SessionState, ToolParameterEntry, WithParts } from "./types"
+import type { Logger } from "../logger"
+import { loadSessionState } from "./persistence"
+import {
+    isSubAgentSession,
+    findLastCompactionTimestamp,
+    countTurns,
+    resetOnCompaction,
+    loadPruneMap,
+} from "./utils"
+import { getLastUserMessage } from "../shared-utils"
+
+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,
+        })
+    }
+
+    state.currentTurn = countTurns(state, messages)
+}
+
+export function createSessionState(): SessionState {
+    return {
+        sessionId: null,
+        isSubAgent: false,
+        manualMode: false,
+        pendingManualTrigger: null,
+        prune: {
+            tools: new Map<string, number>(),
+            messages: new Map<string, number>(),
+        },
+        compressSummaries: [],
+        stats: {
+            pruneTokenCounter: 0,
+            totalPruneTokens: 0,
+        },
+        toolParameters: new Map<string, ToolParameterEntry>(),
+        toolIdList: [],
+        nudgeCounter: 0,
+        lastToolPrune: false,
+        lastCompaction: 0,
+        currentTurn: 0,
+        variant: undefined,
+        modelContextLimit: undefined,
+    }
+}
+
+export function resetSessionState(state: SessionState): void {
+    state.sessionId = null
+    state.isSubAgent = false
+    state.manualMode = false
+    state.pendingManualTrigger = null
+    state.prune = {
+        tools: new Map<string, number>(),
+        messages: new Map<string, number>(),
+    }
+    state.compressSummaries = []
+    state.stats = {
+        pruneTokenCounter: 0,
+        totalPruneTokens: 0,
+    }
+    state.toolParameters.clear()
+    state.toolIdList = []
+    state.nudgeCounter = 0
+    state.lastToolPrune = false
+    state.lastCompaction = 0
+    state.currentTurn = 0
+    state.variant = undefined
+    state.modelContextLimit = undefined
+}
+
+export async function ensureSessionInitialized(
+    client: any,
+    state: SessionState,
+    sessionId: string,
+    logger: Logger,
+    messages: WithParts[],
+    manualModeDefault: boolean,
+): Promise<void> {
+    if (state.sessionId === sessionId) {
+        return
+    }
+
+    // logger.info("session ID = " + sessionId)
+    // logger.info("Initializing session state", { sessionId: sessionId })
+
+    resetSessionState(state)
+    state.manualMode = manualModeDefault
+    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)
+
+    const persisted = await loadSessionState(sessionId, logger)
+    if (persisted === null) {
+        return
+    }
+
+    state.prune.tools = loadPruneMap(persisted.prune.tools, persisted.prune.toolIds)
+    state.prune.messages = loadPruneMap(persisted.prune.messages, persisted.prune.messageIds)
+    state.compressSummaries = persisted.compressSummaries || []
+    state.stats = {
+        pruneTokenCounter: persisted.stats?.pruneTokenCounter || 0,
+        totalPruneTokens: persisted.stats?.totalPruneTokens || 0,
+    }
+}

package/src/dcp/state/tool-cache.ts

@@ -0,0 +1,112 @@
+import type { SessionState, ToolStatus, WithParts } from "./index"
+import type { Logger } from "../logger"
+import type { PluginConfig } from "../config"
+import { isMessageCompacted } from "../shared-utils"
+import { countToolTokens } from "../strategies/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")
+
+        state.nudgeCounter = 0
+        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 (part.tool === "distill" || part.tool === "compress" || part.tool === "prune") {
+                    state.nudgeCounter = 0
+                    state.lastToolPrune = true
+                } else {
+                    state.lastToolPrune = false
+                    const allProtectedTools = config.tools.settings.protectedTools
+                    if (!allProtectedTools.includes(part.tool) && !isProtectedByTurn) {
+                        state.nudgeCounter++
+                    }
+                }
+
+                if (state.toolParameters.has(part.callID)) {
+                    continue
+                }
+
+                if (isProtectedByTurn) {
+                    continue
+                }
+
+                const allProtectedTools = config.tools.settings.protectedTools
+                const isProtectedTool = allProtectedTools.includes(part.tool)
+                const tokenCount = isProtectedTool ? undefined : countToolTokens(part)
+
+                state.toolParameters.set(part.callID, {
+                    tool: part.tool,
+                    parameters: part.state?.input ?? {},
+                    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}, nudgeCounter: ${state.nudgeCounter}`,
+        )
+        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)
+    }
+}

package/src/dcp/state/types.ts

@@ -0,0 +1,55 @@
+import type { Message, Part } from "@opencode-ai/sdk/v2"
+
+export interface WithParts {
+    info: Message
+    parts: Part[]
+}
+
+export type ToolStatus = "pending" | "running" | "completed" | "error"
+
+export interface ToolParameterEntry {
+    tool: string
+    parameters: any
+    status?: ToolStatus
+    error?: string
+    turn: number
+    tokenCount?: number
+}
+
+export interface SessionStats {
+    pruneTokenCounter: number
+    totalPruneTokens: number
+}
+
+export interface CompressSummary {
+    anchorMessageId: string
+    summary: string
+}
+
+export interface Prune {
+    tools: Map<string, number>
+    messages: Map<string, number>
+}
+
+export interface PendingManualTrigger {
+    sessionId: string
+    prompt: string
+}
+
+export interface SessionState {
+    sessionId: string | null
+    isSubAgent: boolean
+    manualMode: boolean
+    pendingManualTrigger: PendingManualTrigger | null
+    prune: Prune
+    compressSummaries: CompressSummary[]
+    stats: SessionStats
+    toolParameters: Map<string, ToolParameterEntry>
+    toolIdList: string[]
+    nudgeCounter: number
+    lastToolPrune: boolean
+    lastCompaction: number
+    currentTurn: number
+    variant: string | undefined
+    modelContextLimit: number | undefined
+}

package/src/dcp/state/utils.ts

@@ -0,0 +1,55 @@
+import type { SessionState, WithParts } from "./types"
+import { isMessageCompacted } from "../shared-utils"
+
+export async function isSubAgentSession(client: any, sessionID: string): Promise<boolean> {
+    try {
+        const result = await client.session.get({ path: { id: sessionID } })
+        return !!result.data?.parentID
+    } catch (error: any) {
+        return false
+    }
+}
+
+export function findLastCompactionTimestamp(messages: WithParts[]): number {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const msg = messages[i]!
+        if (msg.info.role === "assistant" && msg.info.summary === true) {
+            return msg.info.time.created
+        }
+    }
+    return 0
+}
+
+export function countTurns(state: SessionState, messages: WithParts[]): number {
+    let turnCount = 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") {
+                turnCount++
+            }
+        }
+    }
+    return turnCount
+}
+
+export function loadPruneMap(
+    obj?: Record<string, number>,
+    legacyArr?: string[],
+): Map<string, number> {
+    if (obj) return new Map(Object.entries(obj))
+    if (legacyArr) return new Map(legacyArr.map((id) => [id, 0]))
+    return new Map()
+}
+
+export function resetOnCompaction(state: SessionState): void {
+    state.toolParameters.clear()
+    state.prune.tools = new Map<string, number>()
+    state.prune.messages = new Map<string, number>()
+    state.compressSummaries = []
+    state.nudgeCounter = 0
+    state.lastToolPrune = false
+}