openrecall 0.2.2 → 0.4.0

package/src/dcp/hooks.ts

@@ -0,0 +1,224 @@
+import type { SessionState, WithParts } from "./state"
+import type { Logger } from "./logger"
+import type { PluginConfig } from "./config"
+import { syncToolCache } from "./state/tool-cache"
+import { deduplicate, supersedeWrites, purgeErrors } from "./strategies"
+import { prune, insertPruneToolContext } from "./messages"
+import { buildToolIdList, isIgnoredUserMessage } from "./messages/utils"
+import { checkSession } from "./state"
+import { renderSystemPrompt } from "./prompts"
+import { handleStatsCommand } from "./commands/stats"
+import { handleContextCommand } from "./commands/context"
+import { handleHelpCommand } from "./commands/help"
+import { handleSweepCommand } from "./commands/sweep"
+import { handleManualToggleCommand, handleManualTriggerCommand } from "./commands/manual"
+import { ensureSessionInitialized } from "./state/state"
+import { getCurrentParams } from "./strategies/utils"
+
+const INTERNAL_AGENT_SIGNATURES = [
+    "You are a title generator",
+    "You are a helpful AI assistant tasked with summarizing conversations",
+    "Summarize what was done in this conversation",
+]
+
+function applyPendingManualTriggerPrompt(
+    state: SessionState,
+    messages: WithParts[],
+    logger: Logger,
+): void {
+    const pending = state.pendingManualTrigger
+    if (!pending) {
+        return
+    }
+
+    if (!state.sessionId || pending.sessionId !== state.sessionId) {
+        state.pendingManualTrigger = null
+        return
+    }
+
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const msg = messages[i]!
+        if (msg.info.role !== "user" || isIgnoredUserMessage(msg)) {
+            continue
+        }
+
+        for (const part of msg.parts) {
+            if (part.type !== "text" || part.ignored || part.synthetic) {
+                continue
+            }
+
+            part.text = pending.prompt
+            state.pendingManualTrigger = null
+            logger.debug("Applied pending manual trigger prompt", { sessionId: pending.sessionId })
+            return
+        }
+    }
+
+    state.pendingManualTrigger = null
+}
+
+export function createSystemPromptHandler(
+    state: SessionState,
+    logger: Logger,
+    config: PluginConfig,
+) {
+    return async (
+        input: { sessionID?: string; model: { limit: { context: number } } },
+        output: { system: string[] },
+    ) => {
+        if (input.model?.limit?.context) {
+            state.modelContextLimit = input.model.limit.context
+            logger.debug("Cached model context limit", { limit: state.modelContextLimit })
+        }
+
+        if (state.isSubAgent) {
+            return
+        }
+
+        const systemText = output.system.join("\n")
+        if (INTERNAL_AGENT_SIGNATURES.some((sig) => systemText.includes(sig))) {
+            logger.info("Skipping DCP system prompt injection for internal agent")
+            return
+        }
+
+        const flags = {
+            prune: config.tools.prune.permission !== "deny",
+            distill: config.tools.distill.permission !== "deny",
+            compress: config.tools.compress.permission !== "deny",
+            manual: state.manualMode,
+        }
+
+        if (!flags.prune && !flags.distill && !flags.compress) {
+            return
+        }
+
+        output.system.push(renderSystemPrompt(flags))
+    }
+}
+
+export function createChatMessageTransformHandler(
+    client: any,
+    state: SessionState,
+    logger: Logger,
+    config: PluginConfig,
+) {
+    return async (input: {}, output: { messages: WithParts[] }) => {
+        await checkSession(client, state, logger, output.messages, config.manualMode.enabled)
+
+        if (state.isSubAgent) {
+            return
+        }
+
+        syncToolCache(state, config, logger, output.messages)
+        buildToolIdList(state, output.messages, logger)
+
+        deduplicate(state, logger, config, output.messages)
+        supersedeWrites(state, logger, config, output.messages)
+        purgeErrors(state, logger, config, output.messages)
+
+        prune(state, logger, config, output.messages)
+        insertPruneToolContext(state, config, logger, output.messages)
+
+        applyPendingManualTriggerPrompt(state, output.messages, logger)
+
+        if (state.sessionId) {
+            await logger.saveContext(state.sessionId, output.messages)
+        }
+    }
+}
+
+export function createCommandExecuteHandler(
+    client: any,
+    state: SessionState,
+    logger: Logger,
+    config: PluginConfig,
+    workingDirectory: string,
+) {
+    return async (
+        input: { command: string; sessionID: string; arguments: string },
+        output: { parts: any[] },
+    ) => {
+        if (!config.commands.enabled) {
+            return
+        }
+
+        if (input.command === "dcp") {
+            const messagesResponse = await client.session.messages({
+                path: { id: input.sessionID },
+            })
+            const messages = (messagesResponse.data || messagesResponse) as WithParts[]
+
+            await ensureSessionInitialized(
+                client,
+                state,
+                input.sessionID,
+                logger,
+                messages,
+                config.manualMode.enabled,
+            )
+
+            const args = (input.arguments || "").trim().split(/\s+/).filter(Boolean)
+            const subcommand = args[0]?.toLowerCase() || ""
+            const subArgs = args.slice(1)
+
+            const commandCtx = {
+                client,
+                state,
+                config,
+                logger,
+                sessionId: input.sessionID,
+                messages,
+            }
+
+            if (subcommand === "context") {
+                await handleContextCommand(commandCtx)
+                throw new Error("__DCP_CONTEXT_HANDLED__")
+            }
+
+            if (subcommand === "stats") {
+                await handleStatsCommand(commandCtx)
+                throw new Error("__DCP_STATS_HANDLED__")
+            }
+
+            if (subcommand === "sweep") {
+                await handleSweepCommand({
+                    ...commandCtx,
+                    args: subArgs,
+                    workingDirectory,
+                })
+                throw new Error("__DCP_SWEEP_HANDLED__")
+            }
+
+            if (subcommand === "manual") {
+                await handleManualToggleCommand(commandCtx, subArgs[0]?.toLowerCase())
+                throw new Error("__DCP_MANUAL_HANDLED__")
+            }
+
+            if (
+                (subcommand === "prune" || subcommand === "distill" || subcommand === "compress") &&
+                config.tools[subcommand].permission !== "deny"
+            ) {
+                const userFocus = subArgs.join(" ").trim()
+                const prompt = await handleManualTriggerCommand(commandCtx, subcommand, userFocus)
+                if (!prompt) {
+                    throw new Error("__DCP_MANUAL_TRIGGER_BLOCKED__")
+                }
+
+                state.pendingManualTrigger = {
+                    sessionId: input.sessionID,
+                    prompt,
+                }
+                const rawArgs = (input.arguments || "").trim()
+                output.parts.length = 0
+                output.parts.push({
+                    type: "text",
+                    text: rawArgs ? `/dcp ${rawArgs}` : `/dcp ${subcommand}`,
+                })
+                return
+            }
+
+            await handleHelpCommand(commandCtx)
+            throw new Error("__DCP_HELP_HANDLED__")
+        }
+    }
+}

package/src/dcp/index.ts

@@ -0,0 +1,123 @@
+import type { PluginInput, Hooks } from "@opencode-ai/plugin"
+import { getConfig } from "./config"
+import { Logger } from "./logger"
+import { createSessionState } from "./state"
+import { createPruneTool, createDistillTool, createCompressTool } from "./strategies"
+import {
+    createChatMessageTransformHandler,
+    createCommandExecuteHandler,
+    createSystemPromptHandler,
+} from "./hooks"
+import { configureClientAuth, isSecureMode } from "./auth"
+
+export async function createDcpPlugin(ctx: PluginInput): Promise<Partial<Hooks>> {
+    const config = getConfig(ctx)
+
+    if (!config.enabled) {
+        return {}
+    }
+
+    const logger = new Logger(config.debug)
+    const state = createSessionState()
+
+    if (isSecureMode()) {
+        configureClientAuth(ctx.client)
+    }
+
+    logger.info("DCP initialized", {
+        strategies: config.strategies,
+    })
+
+    return {
+        "experimental.chat.system.transform": createSystemPromptHandler(state, logger, config),
+
+        "experimental.chat.messages.transform": createChatMessageTransformHandler(
+            ctx.client,
+            state,
+            logger,
+            config,
+        ) as any,
+        "chat.message": async (
+            input: {
+                sessionID: string
+                agent?: string
+                model?: { providerID: string; modelID: string }
+                messageID?: string
+                variant?: string
+            },
+            _output: any,
+        ) => {
+            state.variant = input.variant
+            logger.debug("Cached variant from chat.message hook", { variant: input.variant })
+        },
+        "command.execute.before": createCommandExecuteHandler(
+            ctx.client,
+            state,
+            logger,
+            config,
+            ctx.directory,
+        ),
+        tool: {
+            ...(config.tools.distill.permission !== "deny" && {
+                distill: createDistillTool({
+                    client: ctx.client,
+                    state,
+                    logger,
+                    config,
+                    workingDirectory: ctx.directory,
+                }),
+            }),
+            ...(config.tools.compress.permission !== "deny" && {
+                compress: createCompressTool({
+                    client: ctx.client,
+                    state,
+                    logger,
+                    config,
+                    workingDirectory: ctx.directory,
+                }),
+            }),
+            ...(config.tools.prune.permission !== "deny" && {
+                prune: createPruneTool({
+                    client: ctx.client,
+                    state,
+                    logger,
+                    config,
+                    workingDirectory: ctx.directory,
+                }),
+            }),
+        },
+        config: async (opencodeConfig: any) => {
+            if (config.commands.enabled) {
+                opencodeConfig.command ??= {}
+                opencodeConfig.command["dcp"] = {
+                    template: "",
+                    description: "Show available DCP commands",
+                }
+            }
+
+            const toolsToAdd: string[] = []
+            if (config.tools.distill.permission !== "deny") toolsToAdd.push("distill")
+            if (config.tools.compress.permission !== "deny") toolsToAdd.push("compress")
+            if (config.tools.prune.permission !== "deny") toolsToAdd.push("prune")
+
+            if (toolsToAdd.length > 0) {
+                const existingPrimaryTools = opencodeConfig.experimental?.primary_tools ?? []
+                opencodeConfig.experimental = {
+                    ...opencodeConfig.experimental,
+                    primary_tools: [...existingPrimaryTools, ...toolsToAdd],
+                }
+                logger.info(
+                    `Added ${toolsToAdd.map((t) => `'${t}'`).join(" and ")} to experimental.primary_tools via config mutation`,
+                )
+            }
+
+            const permission = opencodeConfig.permission ?? {}
+            opencodeConfig.permission = {
+                ...permission,
+                distill: config.tools.distill.permission,
+                compress: config.tools.compress.permission,
+                prune: config.tools.prune.permission,
+            } as typeof permission
+        },
+    }
+}

package/src/dcp/logger.ts

@@ -0,0 +1,211 @@
+import { writeFile, mkdir } from "fs/promises"
+import { join } from "path"
+import { existsSync } from "fs"
+import { homedir } from "os"
+
+export class Logger {
+    private logDir: string
+    public enabled: boolean
+
+    constructor(enabled: boolean) {
+        this.enabled = enabled
+        const configHome = process.env.XDG_CONFIG_HOME || join(homedir(), ".config")
+        this.logDir = 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 dailyLogDir = join(this.logDir, "daily")
+            if (!existsSync(dailyLogDir)) {
+                await mkdir(dailyLogDir, { recursive: true })
+            }
+
+            const logFile = join(dailyLogDir, `${new Date().toISOString().split("T")[0]!}.log`)
+            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, callID on parts)
+     * - 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
+     */
+    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
+                            return { type: "text", text: part.text }
+                        }
+
+                        if (part.type === "reasoning") {
+                            return {
+                                type: "reasoning",
+                                text: part.text,
+                            }
+                        }
+
+                        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
+                            }
+
+                            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)
+            const timestamp = new Date().toISOString().replace(/[:.]/g, "-")
+            const contextFile = join(contextDir, `${timestamp}.json`)
+            await writeFile(contextFile, JSON.stringify(minimized, null, 2))
+        } catch (error) {}
+    }
+}

package/src/dcp/messages/index.ts

@@ -0,0 +1,2 @@
+export { prune } from "./prune"
+export { insertPruneToolContext } from "./inject"