openrecall 0.2.2 → 0.4.0

package/src/dcp/ui/notification.ts

@@ -0,0 +1,273 @@
+import type { Logger } from "../logger"
+import type { SessionState } from "../state"
+import {
+    countDistillationTokens,
+    formatExtracted,
+    formatPrunedItemsList,
+    formatStatsHeader,
+    formatTokenCount,
+    formatProgressBar,
+} from "./utils"
+import type { ToolParameterEntry } from "../state"
+import type { PluginConfig } from "../config"
+
+export type PruneReason = "completion" | "noise" | "extraction"
+export const PRUNE_REASON_LABELS: Record<PruneReason, string> = {
+    completion: "Task Complete",
+    noise: "Noise Removal",
+    extraction: "Extraction",
+}
+
+function buildMinimalMessage(
+    state: SessionState,
+    reason: PruneReason | undefined,
+    distillation: string[] | undefined,
+    showDistillation: boolean,
+): string {
+    const extractedTokens = countDistillationTokens(distillation)
+    const extractedSuffix =
+        extractedTokens > 0 ? ` (distilled ${formatTokenCount(extractedTokens)})` : ""
+    const reasonSuffix = reason && extractedTokens === 0 ? ` — ${PRUNE_REASON_LABELS[reason]}` : ""
+    let message =
+        formatStatsHeader(state.stats.totalPruneTokens, state.stats.pruneTokenCounter) +
+        reasonSuffix +
+        extractedSuffix
+
+    return message + formatExtracted(showDistillation ? distillation : undefined)
+}
+
+function buildDetailedMessage(
+    state: SessionState,
+    reason: PruneReason | undefined,
+    pruneToolIds: string[],
+    toolMetadata: Map<string, ToolParameterEntry>,
+    workingDirectory: string,
+    distillation: string[] | undefined,
+    showDistillation: boolean,
+): string {
+    let message = formatStatsHeader(state.stats.totalPruneTokens, state.stats.pruneTokenCounter)
+
+    if (pruneToolIds.length > 0) {
+        const pruneTokenCounterStr = `~${formatTokenCount(state.stats.pruneTokenCounter)}`
+        const extractedTokens = countDistillationTokens(distillation)
+        const extractedSuffix =
+            extractedTokens > 0 ? `, distilled ${formatTokenCount(extractedTokens)}` : ""
+        const reasonLabel =
+            reason && extractedTokens === 0 ? ` — ${PRUNE_REASON_LABELS[reason]}` : ""
+        message += `\n\n▣ Pruning (${pruneTokenCounterStr}${extractedSuffix})${reasonLabel}`
+
+        const itemLines = formatPrunedItemsList(pruneToolIds, toolMetadata, workingDirectory)
+        message += "\n" + itemLines.join("\n")
+    }
+
+    return (message + formatExtracted(showDistillation ? distillation : undefined)).trim()
+}
+
+const TOAST_BODY_MAX_LINES = 12
+const TOAST_SUMMARY_MAX_CHARS = 600
+
+function truncateToastBody(body: string, maxLines: number = TOAST_BODY_MAX_LINES): string {
+    const lines = body.split("\n")
+    if (lines.length <= maxLines) {
+        return body
+    }
+    const kept = lines.slice(0, maxLines - 1)
+    const remaining = lines.length - maxLines + 1
+    return kept.join("\n") + `\n... and ${remaining} more`
+}
+
+function truncateToastSummary(summary: string, maxChars: number = TOAST_SUMMARY_MAX_CHARS): string {
+    if (summary.length <= maxChars) {
+        return summary
+    }
+    return summary.slice(0, maxChars - 3) + "..."
+}
+
+function truncateExtractedSection(
+    message: string,
+    maxChars: number = TOAST_SUMMARY_MAX_CHARS,
+): string {
+    const marker = "\n\n▣ Extracted"
+    const index = message.indexOf(marker)
+    if (index === -1) {
+        return message
+    }
+    const extracted = message.slice(index)
+    if (extracted.length <= maxChars) {
+        return message
+    }
+    return message.slice(0, index) + truncateToastSummary(extracted, maxChars)
+}
+
+export async function sendUnifiedNotification(
+    client: any,
+    logger: Logger,
+    config: PluginConfig,
+    state: SessionState,
+    sessionId: string,
+    pruneToolIds: string[],
+    toolMetadata: Map<string, ToolParameterEntry>,
+    reason: PruneReason | undefined,
+    params: any,
+    workingDirectory: string,
+    distillation?: string[],
+): Promise<boolean> {
+    const hasPruned = pruneToolIds.length > 0
+    if (!hasPruned) {
+        return false
+    }
+
+    if (config.pruneNotification === "off") {
+        return false
+    }
+
+    const showDistillation = config.tools.distill.showDistillation
+
+    const message =
+        config.pruneNotification === "minimal"
+            ? buildMinimalMessage(state, reason, distillation, showDistillation)
+            : buildDetailedMessage(
+                  state,
+                  reason,
+                  pruneToolIds,
+                  toolMetadata,
+                  workingDirectory,
+                  distillation,
+                  showDistillation,
+              )
+
+    if (config.pruneNotificationType === "toast") {
+        let toastMessage = truncateExtractedSection(message)
+        toastMessage =
+            config.pruneNotification === "minimal" ? toastMessage : truncateToastBody(toastMessage)
+
+        await client.tui.showToast({
+            body: {
+                title: "DCP: Prune Notification",
+                message: toastMessage,
+                variant: "info",
+                duration: 5000,
+            },
+        })
+        return true
+    }
+
+    await sendIgnoredMessage(client, sessionId, message, params, logger)
+    return true
+}
+
+export async function sendCompressNotification(
+    client: any,
+    logger: Logger,
+    config: PluginConfig,
+    state: SessionState,
+    sessionId: string,
+    toolIds: string[],
+    messageIds: string[],
+    topic: string,
+    summary: string,
+    startResult: any,
+    endResult: any,
+    totalMessages: number,
+    params: any,
+): Promise<boolean> {
+    if (config.pruneNotification === "off") {
+        return false
+    }
+
+    let message: string
+
+    if (config.pruneNotification === "minimal") {
+        message = formatStatsHeader(state.stats.totalPruneTokens, state.stats.pruneTokenCounter)
+    } else {
+        message = formatStatsHeader(state.stats.totalPruneTokens, state.stats.pruneTokenCounter)
+
+        const pruneTokenCounterStr = `~${formatTokenCount(state.stats.pruneTokenCounter)}`
+        const progressBar = formatProgressBar(
+            totalMessages,
+            startResult.messageIndex,
+            endResult.messageIndex,
+            25,
+        )
+        message += `\n\n▣ Compressing (${pruneTokenCounterStr}) ${progressBar}`
+        message += `\n→ Topic: ${topic}`
+        message += `\n→ Items: ${messageIds.length} messages`
+        if (toolIds.length > 0) {
+            message += ` and ${toolIds.length} tools condensed`
+        } else {
+            message += ` condensed`
+        }
+        if (config.tools.compress.showCompression) {
+            message += `\n→ Compression: ${summary}`
+        }
+    }
+
+    if (config.pruneNotificationType === "toast") {
+        let toastMessage = message
+        if (config.tools.compress.showCompression) {
+            const truncatedSummary = truncateToastSummary(summary)
+            if (truncatedSummary !== summary) {
+                toastMessage = toastMessage.replace(
+                    `\n→ Compression: ${summary}`,
+                    `\n→ Compression: ${truncatedSummary}`,
+                )
+            }
+        }
+        toastMessage =
+            config.pruneNotification === "minimal" ? toastMessage : truncateToastBody(toastMessage)
+
+        await client.tui.showToast({
+            body: {
+                title: "DCP: Compress Notification",
+                message: toastMessage,
+                variant: "info",
+                duration: 5000,
+            },
+        })
+        return true
+    }
+
+    await sendIgnoredMessage(client, sessionId, message, params, logger)
+    return true
+}
+
+export async function sendIgnoredMessage(
+    client: any,
+    sessionID: string,
+    text: string,
+    params: any,
+    logger: Logger,
+): Promise<void> {
+    const agent = params.agent || undefined
+    const variant = params.variant || undefined
+    const model =
+        params.providerId && params.modelId
+            ? {
+                  providerID: params.providerId,
+                  modelID: params.modelId,
+              }
+            : undefined
+
+    try {
+        await client.session.prompt({
+            path: {
+                id: sessionID,
+            },
+            body: {
+                noReply: true,
+                agent: agent,
+                model: model,
+                variant: variant,
+                parts: [
+                    {
+                        type: "text",
+                        text: text,
+                        ignored: true,
+                    },
+                ],
+            },
+        })
+    } catch (error: any) {
+        logger.error("Failed to send notification", { error: error.message })
+    }
+}

package/src/dcp/ui/utils.ts

@@ -0,0 +1,133 @@
+import type { ToolParameterEntry } from "../state"
+import { extractParameterKey } from "../messages/utils"
+import { countTokens } from "../strategies/utils"
+
+export function countDistillationTokens(distillation?: string[]): number {
+    if (!distillation || distillation.length === 0) return 0
+    return countTokens(distillation.join("\n"))
+}
+
+export function formatExtracted(distillation?: string[]): string {
+    if (!distillation || distillation.length === 0) {
+        return ""
+    }
+    let result = `\n\n▣ Extracted`
+    for (const finding of distillation) {
+        result += `\n───\n${finding}`
+    }
+    return result
+}
+
+export function formatStatsHeader(totalTokensSaved: number, pruneTokenCounter: number): string {
+    const totalTokensSavedStr = `~${formatTokenCount(totalTokensSaved + pruneTokenCounter)}`
+    return [`▣ DCP | ${totalTokensSavedStr} saved total`].join("\n")
+}
+
+export function formatTokenCount(tokens: number): string {
+    if (tokens >= 1000) {
+        return `${(tokens / 1000).toFixed(1)}K`.replace(".0K", "K") + " tokens"
+    }
+    return tokens.toString() + " tokens"
+}
+
+export function truncate(str: string, maxLen: number = 60): string {
+    if (str.length <= maxLen) return str
+    return str.slice(0, maxLen - 3) + "..."
+}
+
+export function formatProgressBar(
+    total: number,
+    start: number,
+    end: number,
+    width: number = 20,
+): string {
+    if (total <= 0) return `│${" ".repeat(width)}│`
+
+    const startIdx = Math.floor((start / total) * width)
+    const endIdx = Math.min(width - 1, Math.floor((end / total) * width))
+
+    let bar = ""
+    for (let i = 0; i < width; i++) {
+        if (i >= startIdx && i <= endIdx) {
+            bar += "░"
+        } else {
+            bar += "█"
+        }
+    }
+
+    return `│${bar}│`
+}
+
+export function shortenPath(input: string, workingDirectory?: string): string {
+    const inPathMatch = input.match(/^(.+) in (.+)$/)
+    if (inPathMatch) {
+        const prefix = inPathMatch[1]!
+        const pathPart = inPathMatch[2]!
+        const shortenedPath = shortenSinglePath(pathPart, workingDirectory)
+        return `${prefix} in ${shortenedPath}`
+    }
+
+    return shortenSinglePath(input, workingDirectory)
+}
+
+function shortenSinglePath(path: string, workingDirectory?: string): string {
+    if (workingDirectory) {
+        if (path.startsWith(workingDirectory + "/")) {
+            return path.slice(workingDirectory.length + 1)
+        }
+        if (path === workingDirectory) {
+            return "."
+        }
+    }
+
+    return path
+}
+
+export function formatPrunedItemsList(
+    pruneToolIds: string[],
+    toolMetadata: Map<string, ToolParameterEntry>,
+    workingDirectory?: string,
+): string[] {
+    const lines: string[] = []
+
+    for (const id of pruneToolIds) {
+        const metadata = toolMetadata.get(id)
+
+        if (metadata) {
+            const paramKey = extractParameterKey(metadata.tool, metadata.parameters)
+            if (paramKey) {
+                // Use 60 char limit to match notification style
+                const displayKey = truncate(shortenPath(paramKey, workingDirectory), 60)
+                lines.push(`→ ${metadata.tool}: ${displayKey}`)
+            } else {
+                lines.push(`→ ${metadata.tool}`)
+            }
+        }
+    }
+
+    const knownCount = pruneToolIds.filter((id) => toolMetadata.has(id)).length
+    const unknownCount = pruneToolIds.length - knownCount
+
+    if (unknownCount > 0) {
+        lines.push(`→ (${unknownCount} tool${unknownCount > 1 ? "s" : ""} with unknown metadata)`)
+    }
+
+    return lines
+}
+
+export function formatPruningResultForTool(
+    prunedIds: string[],
+    toolMetadata: Map<string, ToolParameterEntry>,
+    workingDirectory?: string,
+): string {
+    const lines: string[] = []
+    lines.push(`Context pruning complete. Pruned ${prunedIds.length} tool outputs.`)
+    lines.push("")
+
+    if (prunedIds.length > 0) {
+        lines.push(`Semantically pruned (${prunedIds.length}):`)
+        lines.push(...formatPrunedItemsList(prunedIds, toolMetadata, workingDirectory))
+    }
+
+    return lines.join("\n").trim()
+}

package/src/index.ts

@@ -4,10 +4,11 @@ import { getDb } from "./db"
 import { isDbAvailable } from "./db"
 import { initConfig, getConfig, type OpenRecallConfig } from "./config"
 import { initClient } from "./client"
-import { searchMemories, listMemories, getStats, sanitizeQuery } from "./memory"
+import { storeMemory, searchMemories, listMemories, getStats, sanitizeQuery } from "./memory"
 import { maybeRunMaintenance } from "./maintenance"
 import { extractFromToolOutput, clearSessionExtraction } from "./extract"
 import { incrementCounter, clearCounter, scanProjectFiles, extractFileKnowledge } from "./agent"
+import { createDcpPlugin } from "./dcp"
 
 // In-memory cache of session metadata for enriching memories
 interface SessionInfo {
@@ -29,9 +30,13 @@ export default async function OpenRecallPlugin(
   // Store SDK client for hooks and tools to access OpenCode data
   initClient(inputRef.client)
 
+  // Initialize DCP plugin
+  const dcpHooks = await createDcpPlugin(inputRef)
+
   return {
     // Load config from opencode.json plugin options
     async config(cfg: any) {
+      // OpenRecall config
       const pluginConfig = cfg?.plugins?.openrecall as
         | Partial<OpenRecallConfig>
         | undefined
@@ -50,6 +55,11 @@ export default async function OpenRecallPlugin(
           e,
         )
       }
+
+      // DCP config (registers commands, primary_tools, permissions)
+      if (dcpHooks.config) {
+        await dcpHooks.config(cfg)
+      }
     },
 
     // Detect first message in a session and auto-recall relevant memories
@@ -60,55 +70,60 @@ export default async function OpenRecallPlugin(
       incrementCounter(sessionId)
 
       const config = getConfig()
-      if (!config.autoRecall) return
-      if (!isDbAvailable()) return
+      if (config.autoRecall && isDbAvailable()) {
+        if (!sessionFirstMessage.has(sessionId)) {
+          sessionFirstMessage.add(sessionId)
 
-      if (sessionFirstMessage.has(sessionId)) return
-      sessionFirstMessage.add(sessionId)
+          try {
+            // Extract text from the user's first message
+            const userText = extractUserText(output)
+            if (userText) {
+              // Search for relevant memories using the first message as query
+              const sanitized = sanitizeQuery(userText)
+              let recalled: string[] = []
 
-      try {
-        // Extract text from the user's first message
-        const userText = extractUserText(output)
-        if (!userText) return
-
-        // Search for relevant memories using the first message as query
-        const sanitized = sanitizeQuery(userText)
-        let recalled: string[] = []
+              if (sanitized.trim()) {
+                const results = searchMemories({
+                  query: sanitized,
+                  projectId,
+                  limit: config.searchLimit,
+                })
+                recalled = results.map((r) => {
+                  const time = new Date(r.memory.time_created * 1000).toISOString()
+                  return `[${r.memory.category.toUpperCase()}] ${r.memory.content} (${time})`
+                })
+              }
 
-        if (sanitized.trim()) {
-          const results = searchMemories({
-            query: sanitized,
-            projectId,
-            limit: config.searchLimit,
-          })
-          recalled = results.map((r) => {
-            const time = new Date(r.memory.time_created * 1000).toISOString()
-            return `[${r.memory.category.toUpperCase()}] ${r.memory.content} (${time})`
-          })
-        }
+              // Fall back to recent memories if no search matches
+              if (recalled.length === 0) {
+                const recent = listMemories({ projectId, limit: 5 })
+                recalled = recent.map((m) => {
+                  const time = new Date(m.time_created * 1000).toISOString()
+                  return `[${m.category.toUpperCase()}] ${m.content} (${time})`
+                })
+              }
 
-        // Fall back to recent memories if no search matches
-        if (recalled.length === 0) {
-          const recent = listMemories({ projectId, limit: 5 })
-          recalled = recent.map((m) => {
-            const time = new Date(m.time_created * 1000).toISOString()
-            return `[${m.category.toUpperCase()}] ${m.content} (${time})`
-          })
+              if (recalled.length > 0) {
+                recalledMemories.set(
+                  sessionId,
+                  "Relevant memories from previous sessions:\n" +
+                    recalled.map((r, i) => `${i + 1}. ${r}`).join("\n"),
+                )
+              }
+            }
+          } catch (e) {
+            console.error("[OpenRecall] Auto-recall failed:", e)
+          }
         }
+      }
 
-        if (recalled.length > 0) {
-          recalledMemories.set(
-            sessionId,
-            "Relevant memories from previous sessions:\n" +
-              recalled.map((r, i) => `${i + 1}. ${r}`).join("\n"),
-          )
-        }
-      } catch (e) {
-        console.error("[OpenRecall] Auto-recall failed:", e)
+      // DCP: cache variant from chat messages
+      if (dcpHooks["chat.message"]) {
+        await dcpHooks["chat.message"](input, output)
       }
     },
 
-    // Track session lifecycle events
+    // Track session lifecycle events (OpenRecall only)
     async event({ event }: { event: any }) {
       if (!event || typeof event !== "object") return
       const type = event.type as string | undefined
@@ -138,7 +153,7 @@ export default async function OpenRecallPlugin(
       }
     },
 
-    // Auto-extract memories from tool execution results
+    // Auto-extract memories from tool execution results (OpenRecall only)
     async "tool.execute.after"(input, output) {
       const config = getConfig()
 
@@ -172,11 +187,15 @@ export default async function OpenRecallPlugin(
       }
     },
 
-    // Expose memory tools to the LLM
-    tool: createTools(projectId),
+    // Expose both OpenRecall memory tools and DCP tools
+    tool: {
+      ...createTools(projectId),
+      ...(dcpHooks.tool || {}),
+    },
 
-    // Inject memory context into the system prompt
+    // Inject both memory context and DCP system prompt
     "experimental.chat.system.transform": async (input, output) => {
+      // OpenRecall: inject memory context
       const lines: string[] = [
         "IMPORTANT: You have persistent cross-session memory tools (memory_store, memory_search, memory_list, memory_update, memory_delete, memory_tag, memory_link, memory_refresh, memory_stats, memory_export, memory_import, memory_cleanup, memory_file_check).",
         "MANDATORY FILE ACCESS RULE: You MUST call memory_file_check(file_path) BEFORE every file read. " +
@@ -184,10 +203,8 @@ export default async function OpenRecallPlugin(
           "Only call read/Read if memory_file_check returns \"No memory found\" or \"File has been modified\". " +
           "Calling read on a file after memory_file_check already returned its content is FORBIDDEN — it wastes tokens and time. " +
           "This rule applies to ALL files, every time, with no exceptions.",
-        "MANDATORY SAVE RULE: Before giving your final response to the user, call memory_store to save a concise summary of your key findings, conclusions, or answers. " +
-          "This ensures the knowledge is persisted for future sessions. Do this EVERY time you research, explore, or analyze something — not just when the user explicitly asks you to remember.",
         "When the user asks you to remember, save, store, or note something, you MUST call memory_store immediately.",
-        "Use memory_store to save important findings, decisions, user preferences, and patterns.",
+        "Use memory_store to save important findings, decisions, user preferences, and patterns. Your final responses are automatically distilled into memory.",
       ]
 
       // Add dynamic summary if DB is available
@@ -229,9 +246,41 @@ export default async function OpenRecallPlugin(
           output.system.push(memories)
         }
       }
+
+      // DCP: inject system prompt
+      if (dcpHooks["experimental.chat.system.transform"]) {
+        await dcpHooks["experimental.chat.system.transform"](input, output)
+      }
+    },
+
+    // DCP: message pruning pipeline (DCP only)
+    "experimental.chat.messages.transform": dcpHooks["experimental.chat.messages.transform"] as any,
+
+    // Auto-distill the LLM's final response text into memory (OpenRecall only)
+    "experimental.text.complete": async (input, output) => {
+      if (!isDbAvailable()) return
+      const text = output.text
+      if (!text || text.length < 80) return
+
+      try {
+        // Take a concise summary: first 400 chars of the response
+        const summary = text.length > 400
+          ? text.slice(0, 397) + "..."
+          : text
+        storeMemory({
+          content: summary,
+          category: "discovery",
+          projectId,
+          sessionId: input.sessionID,
+          source: "auto-distill: assistant response",
+          tags: ["auto-distill", "assistant-response"],
+        })
+      } catch {
+        // Silent fail — never block the response
+      }
     },
 
-    // During compaction, remind to preserve important context
+    // During compaction, remind to preserve important context (OpenRecall only)
     "experimental.session.compacting": async (_input, output) => {
       output.context.push(
         "Before compacting, consider using memory_store to save any important " +
@@ -239,6 +288,9 @@ export default async function OpenRecallPlugin(
           "remembered across future sessions.",
       )
     },
+
+    // DCP: command handler (DCP only)
+    "command.execute.before": dcpHooks["command.execute.before"] as any,
   }
 }