openrecall 0.1.0 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openrecall",
-  "version": "0.1.0",
+  "version": "0.2.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 } from "./memory"
+import { storeMemory, searchByTag, getTagsForMemory } from "./memory"
 import { isDbAvailable } from "./db"
 import * as fs from "fs"
 import * as path from "path"
@@ -24,6 +24,91 @@ const MAX_CHUNK = 400
 // Track which files have been scanned this process lifetime
 const scannedFiles = new Set<string>()
 
+/**
+ * Get a file's current git commit hash and mtime for freshness tracking.
+ */
+export function getFileFingerprint(filePath: string, directory?: string): { gitHash?: string; mtime: number } {
+  let mtime = 0
+  try { mtime = fs.statSync(filePath).mtimeMs } catch {}
+
+  let gitHash: string | undefined
+  try {
+    const { execSync } = require("child_process")
+    gitHash = execSync(`git log -1 --format=%H -- "${filePath}"`, {
+      cwd: directory || path.dirname(filePath),
+      encoding: "utf-8",
+      timeout: 3000,
+    }).trim()
+    if (!gitHash) gitHash = undefined
+  } catch {}
+
+  return { gitHash, mtime }
+}
+
+/**
+ * Build fingerprint tags for a file path.
+ */
+function buildFingerprintTags(filePath: string, directory?: string): string[] {
+  const absPath = path.resolve(directory || "", filePath)
+  const fp = getFileFingerprint(absPath, directory)
+  const tags: string[] = [`filepath:${absPath}`]
+  tags.push(`git:${fp.gitHash || ""}`)
+  tags.push(`mtime:${fp.mtime}`)
+  return tags
+}
+
+/**
+ * Check if a stored file memory is still fresh by comparing fingerprints.
+ * Returns { fresh, memory, storedContent } or null if no memory found.
+ */
+export function checkFileFreshness(filePath: string, projectId: string, directory?: string): {
+  fresh: boolean
+  memory: any
+  storedContent: string
+} | null {
+  if (!isDbAvailable()) return null
+
+  const absPath = path.resolve(directory || "", filePath)
+  const tag = `filepath:${absPath}`
+
+  const memories = searchByTag(tag, { projectId, limit: 1 })
+  if (memories.length === 0) return null
+
+  const memory = memories[0]!
+  const memoryTags = getTagsForMemory(memory.id)
+
+  // Extract stored git hash and mtime from tags
+  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 (most reliable)
+  if (current.gitHash && storedGitHash) {
+    return {
+      fresh: current.gitHash === storedGitHash,
+      memory,
+      storedContent: memory.content,
+    }
+  }
+
+  // Fall back to mtime comparison
+  if (storedMtime !== undefined && current.mtime > 0) {
+    return {
+      fresh: Math.abs(current.mtime - storedMtime) < 1000, // 1s tolerance
+      memory,
+      storedContent: memory.content,
+    }
+  }
+
+  // Can't determine freshness — treat as stale
+  return { fresh: false, memory, storedContent: memory.content }
+}
+
 interface ExtractionCounter {
   count: number
   extracting: boolean
@@ -84,13 +169,13 @@ export function scanProjectFiles(directory: string, projectId: string): void {
 
       // For package.json, extract key info
       if (relPath === "package.json") {
-        storePackageJsonMemory(content, projectId, relPath)
+        storePackageJsonMemory(content, projectId, fullPath, directory)
         stored++
         continue
       }
 
       // Store file content in chunks
-      stored += storeFileChunks(content, projectId, relPath)
+      stored += storeFileChunks(content, projectId, fullPath, directory)
     } catch (e) {
       // Silent fail per file — don't break startup
     }
@@ -108,7 +193,7 @@ export function scanProjectFiles(directory: string, projectId: string): void {
   }
 }
 
-function storePackageJsonMemory(content: string, projectId: string, filePath: string): void {
+function storePackageJsonMemory(content: string, projectId: string, filePath: string, directory?: string): void {
   try {
     const pkg = JSON.parse(content)
     const parts: string[] = []
@@ -132,12 +217,14 @@ function storePackageJsonMemory(content: string, projectId: string, filePath: st
 
     const summary = parts.join(" | ")
     if (summary.length > 10) {
+      const fpTags = buildFingerprintTags(filePath, directory)
       storeMemory({
         content: summary.slice(0, MAX_CHUNK),
         category: "discovery",
         projectId,
         source: `file-scan: ${filePath}`,
-        tags: ["project-config", "package.json"],
+        tags: ["project-config", "package.json", ...fpTags],
+        force: true,
       })
     }
   } catch {
@@ -145,11 +232,13 @@ function storePackageJsonMemory(content: string, projectId: string, filePath: st
   }
 }
 
-function storeFileChunks(content: string, projectId: string, filePath: string): number {
+function storeFileChunks(content: string, projectId: string, filePath: string, directory?: string): number {
   // Split by sections (headers in markdown, or double newlines)
   const sections = content.split(/\n#{1,3}\s+|\n\n/).filter((s) => s.trim().length > 20)
   let stored = 0
 
+  const fpTags = buildFingerprintTags(filePath, directory)
+
   // Store up to 5 chunks per file to avoid flooding
   const maxChunks = 5
   for (let i = 0; i < Math.min(sections.length, maxChunks); i++) {
@@ -164,7 +253,8 @@ function storeFileChunks(content: string, projectId: string, filePath: string):
         category: "discovery",
         projectId,
         source: `file-scan: ${filePath} (section ${i + 1})`,
-        tags: ["file-content", path.basename(filePath).toLowerCase()],
+        tags: ["file-content", path.basename(filePath).toLowerCase(), ...fpTags],
+        force: true,
       })
       stored++
     } catch {
@@ -237,6 +327,7 @@ export function extractFileKnowledge(
       // Take the first ~400 chars as a content preview
       const preview = output.slice(0, MAX_CHUNK)
       const basename = path.basename(filePath)
+      const fpTags = buildFingerprintTags(filePath)
 
       storeMemory({
         content: `File ${basename}: ${preview}`,
@@ -244,7 +335,8 @@ export function extractFileKnowledge(
         projectId,
         sessionId,
         source: `tool-read: ${filePath}`,
-        tags: ["file-content", basename.toLowerCase()],
+        tags: ["file-content", basename.toLowerCase(), ...fpTags],
+        force: true,
       })
     } else if (toolName === "edit" || toolName === "write") {
       // Store what was edited/written

package/src/index.ts

@@ -178,9 +178,9 @@ export default async function OpenRecallPlugin(
     // Inject memory context into the system prompt
     "experimental.chat.system.transform": async (input, output) => {
       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).",
+        "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).",
+        "CRITICAL: Before reading any file, call memory_file_check with the file path. If the file is unchanged, use the stored memory content directly — do NOT re-read it. Only read files that memory_file_check reports as modified or not found.",
         "When the user asks you to remember, save, store, or note something, you MUST call memory_store immediately.",
-        "When starting work on a topic, call memory_search first to check for relevant past context.",
         "Use memory_store to save important findings, decisions, user preferences, and patterns.",
       ]
 

package/src/tools.ts

@@ -19,6 +19,7 @@ import {
 } from "./memory"
 import { getConfig } from "./config"
 import { isDbAvailable } from "./db"
+import { checkFileFreshness } from "./agent"
 import {
   runMaintenance,
   purgeOldMemories,
@@ -654,5 +655,35 @@ export function createTools(projectId: string) {
         }, "Failed to import memories")
       },
     }),
+
+    memory_file_check: tool({
+      description:
+        "Check if a file's content is already stored in memory and whether it is still current. " +
+        "Call this BEFORE reading any file. If the file is unchanged, use the returned memory content " +
+        "directly instead of re-reading the file. Only read files that this tool reports as modified or not found.",
+      args: {
+        file_path: tool.schema
+          .string()
+          .describe(
+            "The absolute or relative path of the file to check. " +
+              "This should be the same path you would pass to the read tool.",
+          ),
+      },
+      async execute(args) {
+        return safeExecute(() => {
+          const result = checkFileFreshness(args.file_path, projectId)
+
+          if (!result) {
+            return "No memory found for this file. Read it normally."
+          }
+
+          if (result.fresh) {
+            return `File unchanged since last read. Memory content:\n${result.storedContent}`
+          }
+
+          return "File has been modified since last read. Please re-read it."
+        }, "Failed to check file freshness")
+      },
+    }),
   }
 }