openrecall 0.2.2 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openrecall",
-  "version": "0.2.2",
+  "version": "0.3.0",
   "description": "Cross-session memory plugin for OpenCode with full-text search, tagging, and auto-recall",
   "module": "src/index.ts",
   "main": "src/index.ts",

package/src/agent.ts

@@ -1,4 +1,4 @@
-import { storeMemory, searchByTag, getTagsForMemory } from "./memory"
+import { storeMemory, searchByTag, getTagsForMemory, deleteMemory, updateMemory, setTags } from "./memory"
 import { isDbAvailable } from "./db"
 import * as fs from "fs"
 import * as path from "path"
@@ -57,6 +57,92 @@ function buildFingerprintTags(filePath: string, directory?: string): string[] {
   return tags
 }
 
+/**
+ * Remove all existing memories tagged with a specific filepath.
+ */
+function purgeFileMemories(absPath: string, projectId: string): number {
+  const tag = `filepath:${absPath}`.toLowerCase()
+  const existing = searchByTag(tag, { projectId, limit: 50 })
+  for (const m of existing) {
+    deleteMemory(m.id)
+  }
+  return existing.length
+}
+
+/**
+ * Check if a file already has a fresh memory. Returns true if fresh (skip store).
+ * If stale, purges old memories so caller can store fresh ones.
+ */
+function isFileFreshInMemory(absPath: string, projectId: string, directory?: string): boolean {
+  const tag = `filepath:${absPath}`.toLowerCase()
+  const existing = searchByTag(tag, { projectId, limit: 1 })
+  if (existing.length === 0) return false
+
+  const memory = existing[0]!
+  const memoryTags = getTagsForMemory(memory.id)
+
+  let storedGitHash: string | undefined
+  let storedMtime: number | undefined
+  for (const t of memoryTags) {
+    if (t.startsWith("git:")) storedGitHash = t.slice(4)
+    if (t.startsWith("mtime:")) storedMtime = parseFloat(t.slice(6))
+  }
+
+  const current = getFileFingerprint(absPath, directory)
+
+  // Compare git hash first
+  if (current.gitHash && storedGitHash && current.gitHash === storedGitHash) {
+    return true // fresh
+  }
+
+  // Fall back to mtime
+  if (!current.gitHash && storedMtime !== undefined && current.mtime > 0) {
+    if (Math.abs(current.mtime - storedMtime) < 1000) return true // fresh
+  }
+
+  // Stale — purge old memories for this file
+  purgeFileMemories(absPath, projectId)
+  return false
+}
+
+/**
+ * Upsert a single file memory: update existing or create new.
+ * For read-tool tracking where we want exactly one memory per file.
+ */
+function upsertFileMemory(
+  content: string,
+  projectId: string,
+  filePath: string,
+  tags: string[],
+  source: string,
+  sessionId?: string,
+): void {
+  const absPath = path.resolve(filePath)
+  const tag = `filepath:${absPath}`.toLowerCase()
+  const existing = searchByTag(tag, { projectId, limit: 1 })
+
+  if (existing.length > 0) {
+    const memory = existing[0]!
+    updateMemory(memory.id, { content, source })
+    // Refresh fingerprint tags
+    const fpTags = buildFingerprintTags(filePath)
+    const nonFpTags = getTagsForMemory(memory.id).filter(
+      (t) => !t.startsWith("git:") && !t.startsWith("mtime:"),
+    )
+    setTags(memory.id, [...nonFpTags, ...fpTags])
+  } else {
+    storeMemory({
+      content,
+      category: "discovery",
+      projectId,
+      sessionId,
+      source,
+      tags,
+      force: true,
+    })
+  }
+}
+
 /**
  * Check if a stored file memory is still fresh by comparing fingerprints.
  * Returns { fresh, memory, storedContent } or null if no memory found.
@@ -159,11 +245,14 @@ export function scanProjectFiles(directory: string, projectId: string): void {
       // Skip large files (> 50KB)
       if (stat.size > 50 * 1024) continue
 
-      // Use mtime as cache key to avoid re-scanning unchanged files
+      // Skip if already scanned this process lifetime
       const cacheKey = `${fullPath}:${stat.mtimeMs}`
       if (scannedFiles.has(cacheKey)) continue
       scannedFiles.add(cacheKey)
 
+      // Skip if memory already has fresh content for this file
+      if (isFileFreshInMemory(fullPath, projectId, directory)) continue
+
       const content = fs.readFileSync(fullPath, "utf-8")
       if (!content.trim()) continue
 
@@ -224,7 +313,6 @@ function storePackageJsonMemory(content: string, projectId: string, filePath: st
         projectId,
         source: `file-scan: ${filePath}`,
         tags: ["project-config", "package.json", ...fpTags],
-        force: true,
       })
     }
   } catch {
@@ -254,7 +342,6 @@ function storeFileChunks(content: string, projectId: string, filePath: string, d
         projectId,
         source: `file-scan: ${filePath} (section ${i + 1})`,
         tags: ["file-content", path.basename(filePath).toLowerCase(), ...fpTags],
-        force: true,
       })
       stored++
     } catch {
@@ -329,15 +416,14 @@ export function extractFileKnowledge(
       const basename = path.basename(filePath)
       const fpTags = buildFingerprintTags(filePath)
 
-      storeMemory({
-        content: `File ${basename}: ${preview}`,
-        category: "discovery",
+      upsertFileMemory(
+        `File ${basename}: ${preview}`,
         projectId,
+        filePath,
+        ["file-content", basename.toLowerCase(), ...fpTags],
+        `tool-read: ${filePath}`,
         sessionId,
-        source: `tool-read: ${filePath}`,
-        tags: ["file-content", basename.toLowerCase(), ...fpTags],
-        force: true,
-      })
+      )
     } else if (toolName === "edit" || toolName === "write") {
       // Store what was edited/written
       const basename = path.basename(filePath)

package/src/index.ts

@@ -4,7 +4,7 @@ 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"
@@ -184,10 +184,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
@@ -231,6 +229,30 @@ export default async function OpenRecallPlugin(
       }
     },
 
+    // Auto-distill the LLM's final response text into memory
+    "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
     "experimental.session.compacting": async (_input, output) => {
       output.context.push(