openrecall 0.2.2 → 0.4.0

package/src/dcp/tools/distill.ts

@@ -0,0 +1,60 @@
+import { tool } from "@opencode-ai/plugin"
+import type { PruneToolContext } from "./types"
+import { executePruneOperation } from "./prune-shared"
+import type { PruneReason } from "../ui/notification"
+import { loadPrompt } from "../prompts"
+
+const DISTILL_TOOL_DESCRIPTION = loadPrompt("distill-tool-spec")
+
+export function createDistillTool(ctx: PruneToolContext): ReturnType<typeof tool> {
+    return tool({
+        description: DISTILL_TOOL_DESCRIPTION,
+        args: {
+            targets: tool.schema
+                .array(
+                    tool.schema.object({
+                        id: tool.schema
+                            .string()
+                            .describe("Numeric ID from the <prunable-tools> list"),
+                        distillation: tool.schema
+                            .string()
+                            .describe("Complete technical distillation for this tool output"),
+                    }),
+                )
+                .describe("Tool outputs to distill, each pairing an ID with its distillation"),
+        },
+        async execute(args, toolCtx) {
+            if (!args.targets || !Array.isArray(args.targets) || args.targets.length === 0) {
+                ctx.logger.debug("Distill tool called without targets: " + JSON.stringify(args))
+                throw new Error("Missing targets. Provide at least one { id, distillation } entry.")
+            }
+
+            for (const target of args.targets) {
+                if (!target.id || typeof target.id !== "string" || target.id.trim() === "") {
+                    ctx.logger.debug("Distill target missing id: " + JSON.stringify(target))
+                    throw new Error(
+                        "Each target must have an id (numeric string from <prunable-tools>).",
+                    )
+                }
+                if (!target.distillation || typeof target.distillation !== "string") {
+                    ctx.logger.debug(
+                        "Distill target missing distillation: " + JSON.stringify(target),
+                    )
+                    throw new Error("Each target must have a distillation string.")
+                }
+            }
+
+            const ids = args.targets.map((t) => t.id)
+            const distillations = args.targets.map((t) => t.distillation)
+
+            return executePruneOperation(
+                ctx,
+                toolCtx,
+                ids,
+                "extraction" as PruneReason,
+                "Distill",
+                distillations,
+            )
+        },
+    })
+}

package/src/dcp/tools/index.ts

@@ -0,0 +1,4 @@
+export type { PruneToolContext } from "./types"
+export { createPruneTool } from "./prune"
+export { createDistillTool } from "./distill"
+export { createCompressTool } from "./compress"

package/src/dcp/tools/prune-shared.ts

@@ -0,0 +1,174 @@
+import type { SessionState, ToolParameterEntry, WithParts } from "../state"
+import type { PluginConfig } from "../config"
+import type { Logger } from "../logger"
+import type { PruneToolContext } from "./types"
+import { syncToolCache } from "../state/tool-cache"
+import type { PruneReason } from "../ui/notification"
+import { sendUnifiedNotification } from "../ui/notification"
+import { formatPruningResultForTool } from "../ui/utils"
+import { ensureSessionInitialized } from "../state"
+import { saveSessionState } from "../state/persistence"
+import { getTotalToolTokens, getCurrentParams } from "../strategies/utils"
+import { getFilePathsFromParameters, isProtected } from "../protected-file-patterns"
+import { buildToolIdList } from "../messages/utils"
+
+// Shared logic for executing prune operations.
+export async function executePruneOperation(
+    ctx: PruneToolContext,
+    toolCtx: { sessionID: string },
+    ids: string[],
+    reason: PruneReason,
+    toolName: string,
+    distillation?: string[],
+): Promise<string> {
+    const { client, state, logger, config, workingDirectory } = ctx
+    const sessionId = toolCtx.sessionID
+
+    logger.info(`${toolName} tool invoked`)
+    logger.info(JSON.stringify(reason ? { ids, reason } : { ids }))
+
+    if (!ids || ids.length === 0) {
+        logger.debug(`${toolName} tool called but ids is empty or undefined`)
+        throw new Error(
+            `No IDs provided. Check the <prunable-tools> list for available IDs to ${toolName.toLowerCase()}.`,
+        )
+    }
+
+    const numericToolIds: number[] = ids
+        .map((id) => parseInt(id, 10))
+        .filter((n): n is number => !isNaN(n))
+
+    if (numericToolIds.length === 0) {
+        logger.debug(`No numeric tool IDs provided for ${toolName}: ` + JSON.stringify(ids))
+        throw new Error("No numeric IDs provided. Format: ids: [id1, id2, ...]")
+    }
+
+    // Fetch messages to calculate tokens and find current agent
+    const messagesResponse = await client.session.messages({
+        path: { id: sessionId },
+    })
+    const messages: WithParts[] = messagesResponse.data || messagesResponse
+
+    // These 3 are probably not needed as they should always be set in the message
+    // transform handler, but in case something causes state to reset, this is a safety net
+    await ensureSessionInitialized(
+        ctx.client,
+        state,
+        sessionId,
+        logger,
+        messages,
+        config.manualMode.enabled,
+    )
+    syncToolCache(state, config, logger, messages)
+    buildToolIdList(state, messages, logger)
+
+    const currentParams = getCurrentParams(state, messages, logger)
+
+    const toolIdList = state.toolIdList
+
+    const validNumericIds: number[] = []
+    const skippedIds: string[] = []
+
+    // Validate and filter IDs
+    for (const index of numericToolIds) {
+        // Validate that index is within bounds
+        if (index < 0 || index >= toolIdList.length) {
+            logger.debug(`Rejecting prune request - index out of bounds: ${index}`)
+            skippedIds.push(index.toString())
+            continue
+        }
+
+        const id = toolIdList[index]!
+        const metadata = state.toolParameters.get(id)
+
+        // Validate that all IDs exist in cache and aren't protected
+        // (rejects hallucinated IDs and turn-protected tools not shown in <prunable-tools>)
+        if (!metadata) {
+            logger.debug(
+                "Rejecting prune request - ID not in cache (turn-protected or hallucinated)",
+                { index, id },
+            )
+            skippedIds.push(index.toString())
+            continue
+        }
+
+        const allProtectedTools = config.tools.settings.protectedTools
+        if (allProtectedTools.includes(metadata.tool)) {
+            logger.debug("Rejecting prune request - protected tool", {
+                index,
+                id,
+                tool: metadata.tool,
+            })
+            skippedIds.push(index.toString())
+            continue
+        }
+
+        const filePaths = getFilePathsFromParameters(metadata.tool, metadata.parameters)
+        if (isProtected(filePaths, config.protectedFilePatterns)) {
+            logger.debug("Rejecting prune request - protected file path", {
+                index,
+                id,
+                tool: metadata.tool,
+                filePaths,
+            })
+            skippedIds.push(index.toString())
+            continue
+        }
+
+        validNumericIds.push(index)
+    }
+
+    if (validNumericIds.length === 0) {
+        const errorMsg =
+            skippedIds.length > 0
+                ? `Invalid IDs provided: [${skippedIds.join(", ")}]. Only use numeric IDs from the <prunable-tools> list.`
+                : `No valid IDs provided to ${toolName.toLowerCase()}.`
+        throw new Error(errorMsg)
+    }
+
+    const pruneToolIds: string[] = validNumericIds.map((index) => toolIdList[index]!)
+    for (const id of pruneToolIds) {
+        const entry = state.toolParameters.get(id)
+        state.prune.tools.set(id, entry?.tokenCount ?? 0)
+    }
+
+    const toolMetadata = new Map<string, ToolParameterEntry>()
+    for (const id of pruneToolIds) {
+        const toolParameters = state.toolParameters.get(id)
+        if (toolParameters) {
+            toolMetadata.set(id, toolParameters)
+        } else {
+            logger.debug("No metadata found for ID", { id })
+        }
+    }
+
+    state.stats.pruneTokenCounter += getTotalToolTokens(state, pruneToolIds)
+
+    await sendUnifiedNotification(
+        client,
+        logger,
+        config,
+        state,
+        sessionId,
+        pruneToolIds,
+        toolMetadata,
+        reason,
+        currentParams,
+        workingDirectory,
+        distillation,
+    )
+
+    state.stats.totalPruneTokens += state.stats.pruneTokenCounter
+    state.stats.pruneTokenCounter = 0
+    state.nudgeCounter = 0
+
+    saveSessionState(state, logger).catch((err) =>
+        logger.error("Failed to persist state", { error: err.message }),
+    )
+
+    let result = formatPruningResultForTool(pruneToolIds, toolMetadata, workingDirectory)
+    if (skippedIds.length > 0) {
+        result += `\n\nNote: ${skippedIds.length} IDs were skipped (invalid, protected, or missing metadata): ${skippedIds.join(", ")}`
+    }
+    return result
+}

package/src/dcp/tools/prune.ts

@@ -0,0 +1,36 @@
+import { tool } from "@opencode-ai/plugin"
+import type { PruneToolContext } from "./types"
+import { executePruneOperation } from "./prune-shared"
+import type { PruneReason } from "../ui/notification"
+import { loadPrompt } from "../prompts"
+
+const PRUNE_TOOL_DESCRIPTION = loadPrompt("prune-tool-spec")
+
+export function createPruneTool(ctx: PruneToolContext): ReturnType<typeof tool> {
+    return tool({
+        description: PRUNE_TOOL_DESCRIPTION,
+        args: {
+            ids: tool.schema
+                .array(tool.schema.string())
+                .describe("Numeric IDs as strings from the <prunable-tools> list to prune"),
+        },
+        async execute(args, toolCtx) {
+            if (!args.ids || !Array.isArray(args.ids) || args.ids.length === 0) {
+                ctx.logger.debug("Prune tool called without ids: " + JSON.stringify(args))
+                throw new Error("Missing ids. You must provide at least one ID to prune.")
+            }
+
+            if (!args.ids.every((id) => typeof id === "string" && id.trim() !== "")) {
+                ctx.logger.debug("Prune tool called with invalid ids: " + JSON.stringify(args))
+                throw new Error(
+                    'Invalid ids. All IDs must be numeric strings (e.g., "1", "23") from the <prunable-tools> list.',
+                )
+            }
+
+            const numericIds = args.ids
+            const reason = "noise"
+
+            return executePruneOperation(ctx, toolCtx, numericIds, reason, "Prune")
+        },
+    })
+}

package/src/dcp/tools/types.ts

@@ -0,0 +1,11 @@
+import type { SessionState } from "../state"
+import type { PluginConfig } from "../config"
+import type { Logger } from "../logger"
+
+export interface PruneToolContext {
+    client: any
+    state: SessionState
+    logger: Logger
+    config: PluginConfig
+    workingDirectory: string
+}

package/src/dcp/tools/utils.ts

@@ -0,0 +1,244 @@
+import { partial_ratio } from "fuzzball"
+import type { WithParts } from "../state"
+import type { Logger } from "../logger"
+import { isIgnoredUserMessage } from "../messages/utils"
+
+export interface FuzzyConfig {
+    minScore: number
+    minGap: number
+}
+
+export const DEFAULT_FUZZY_CONFIG: FuzzyConfig = {
+    minScore: 95,
+    minGap: 15,
+}
+
+interface MatchResult {
+    messageId: string
+    messageIndex: number
+    score: number
+    matchType: "exact" | "fuzzy"
+}
+
+function extractMessageContent(msg: WithParts): string {
+    const parts = Array.isArray(msg.parts) ? msg.parts : []
+    let content = ""
+
+    for (const part of parts) {
+        const p = part as Record<string, unknown>
+        if ((part as any).ignored) {
+            continue
+        }
+
+        switch (part.type) {
+            case "text":
+            case "reasoning":
+                if (typeof p.text === "string") {
+                    content += " " + p.text
+                }
+                break
+
+            case "tool": {
+                const state = p.state as Record<string, unknown> | undefined
+                if (!state) break
+
+                // Include tool output (completed or error)
+                if (state.status === "completed" && typeof state.output === "string") {
+                    content += " " + state.output
+                } else if (state.status === "error" && typeof state.error === "string") {
+                    content += " " + state.error
+                }
+
+                // Include tool input
+                if (state.input) {
+                    content +=
+                        " " +
+                        (typeof state.input === "string"
+                            ? state.input
+                            : JSON.stringify(state.input))
+                }
+                break
+            }
+
+            case "compaction":
+                if (typeof p.summary === "string") {
+                    content += " " + p.summary
+                }
+                break
+
+            case "subtask":
+                if (typeof p.summary === "string") {
+                    content += " " + p.summary
+                }
+                if (typeof p.result === "string") {
+                    content += " " + p.result
+                }
+                break
+        }
+    }
+
+    return content
+}
+
+function findExactMatches(messages: WithParts[], searchString: string): MatchResult[] {
+    const matches: MatchResult[] = []
+
+    for (let i = 0; i < messages.length; i++) {
+        const msg = messages[i]!
+        if (isIgnoredUserMessage(msg)) {
+            continue
+        }
+        const content = extractMessageContent(msg)
+        if (content.includes(searchString)) {
+            matches.push({
+                messageId: msg.info.id,
+                messageIndex: i,
+                score: 100,
+                matchType: "exact",
+            })
+        }
+    }
+
+    return matches
+}
+
+function findFuzzyMatches(
+    messages: WithParts[],
+    searchString: string,
+    minScore: number,
+): MatchResult[] {
+    const matches: MatchResult[] = []
+
+    for (let i = 0; i < messages.length; i++) {
+        const msg = messages[i]!
+        if (isIgnoredUserMessage(msg)) {
+            continue
+        }
+        const content = extractMessageContent(msg)
+        const score = partial_ratio(searchString, content)
+        if (score >= minScore) {
+            matches.push({
+                messageId: msg.info.id,
+                messageIndex: i,
+                score,
+                matchType: "fuzzy",
+            })
+        }
+    }
+
+    return matches
+}
+
+export function findStringInMessages(
+    messages: WithParts[],
+    searchString: string,
+    logger: Logger,
+    stringType: "startString" | "endString",
+    fuzzyConfig: FuzzyConfig = DEFAULT_FUZZY_CONFIG,
+): { messageId: string; messageIndex: number } {
+    const searchableMessages = messages.length > 1 ? messages.slice(0, -1) : messages
+    const lastMessage = messages.length > 0 ? messages[messages.length - 1] : undefined
+
+    const exactMatches = findExactMatches(searchableMessages, searchString)
+
+    if (exactMatches.length === 1) {
+        return { messageId: exactMatches[0]!.messageId, messageIndex: exactMatches[0]!.messageIndex }
+    }
+
+    if (exactMatches.length > 1) {
+        throw new Error(
+            `Found multiple matches for ${stringType}. ` +
+                `Provide more surrounding context to uniquely identify the intended match.`,
+        )
+    }
+
+    const fuzzyMatches = findFuzzyMatches(searchableMessages, searchString, fuzzyConfig.minScore)
+
+    if (fuzzyMatches.length === 0) {
+        if (lastMessage && !isIgnoredUserMessage(lastMessage)) {
+            const lastMsgContent = extractMessageContent(lastMessage)
+            const lastMsgIndex = messages.length - 1
+            if (lastMsgContent.includes(searchString)) {
+                // logger.info(
+                //     `${stringType} found in last message (last resort) at index ${lastMsgIndex}`,
+                // )
+                return {
+                    messageId: lastMessage.info.id,
+                    messageIndex: lastMsgIndex,
+                }
+            }
+        }
+
+        throw new Error(
+            `${stringType} not found in conversation. ` +
+                `Make sure the string exists and is spelled exactly as it appears.`,
+        )
+    }
+
+    fuzzyMatches.sort((a, b) => b.score - a.score)
+
+    const best = fuzzyMatches[0]!
+    const secondBest = fuzzyMatches[1]
+
+    // Log fuzzy match candidates
+    // logger.info(
+    //     `Fuzzy match for ${stringType}: best=${best.score}% (msg ${best.messageIndex})` +
+    //     (secondBest
+    //         ? `, secondBest=${secondBest.score}% (msg ${secondBest.messageIndex})`
+    //         : ""),
+    // )
+
+    // Check confidence gap - best must be significantly better than second best
+    if (secondBest && best.score - secondBest.score < fuzzyConfig.minGap) {
+        throw new Error(
+            `Found multiple matches for ${stringType}. ` +
+                `Provide more unique surrounding context to disambiguate.`,
+        )
+    }
+
+    logger.info(
+        `Fuzzy matched ${stringType} with ${best.score}% confidence at message index ${best.messageIndex}`,
+    )
+
+    return { messageId: best.messageId, messageIndex: best.messageIndex }
+}
+
+export function collectToolIdsInRange(
+    messages: WithParts[],
+    startIndex: number,
+    endIndex: number,
+): string[] {
+    const toolIds: string[] = []
+
+    for (let i = startIndex; i <= endIndex; i++) {
+        const msg = messages[i]!
+        const parts = Array.isArray(msg.parts) ? msg.parts : []
+
+        for (const part of parts) {
+            if (part.type === "tool" && part.callID) {
+                if (!toolIds.includes(part.callID)) {
+                    toolIds.push(part.callID)
+                }
+            }
+        }
+    }
+
+    return toolIds
+}
+
+export function collectMessageIdsInRange(
+    messages: WithParts[],
+    startIndex: number,
+    endIndex: number,
+): string[] {
+    const messageIds: string[] = []
+
+    for (let i = startIndex; i <= endIndex; i++) {
+        const msgId = messages[i]!.info.id
+        if (!messageIds.includes(msgId)) {
+            messageIds.push(msgId)
+        }
+    }
+
+    return messageIds
+}