openrecall 0.1.0

package/src/extract.ts

@@ -0,0 +1,142 @@
+import { storeMemory, findDuplicate } from "./memory"
+import { isDbAvailable } from "./db"
+import { getConfig } from "./config"
+
+// Rate limit: max extractions per session
+const sessionExtractionCount = new Map<string, number>()
+const MAX_EXTRACTIONS_PER_SESSION = 20
+
+// Preference patterns
+const PREFERENCE_PATTERNS = [
+  /\b(?:always|never|prefer|don'?t|avoid)\b.*\b(?:use|do|make|write|create|run|call)\b/i,
+  /\b(?:i (?:always|never|prefer to|like to|want to))\b/i,
+  /\buser (?:prefers?|wants?|likes?)\b/i,
+]
+
+// Bug fix patterns — tool output indicating a fix was applied
+const BUG_FIX_PATTERNS = [
+  /\bfixed?\b.*\b(?:by|with|using|adding|removing|changing)\b/i,
+  /\b(?:the )?(?:issue|bug|error|problem) was\b/i,
+  /\bresolved?\b.*\b(?:by|with)\b/i,
+  /\bworkaround\b/i,
+]
+
+// Convention patterns
+const CONVENTION_PATTERNS = [
+  /\b(?:convention|standard|rule|guideline)\b.*\b(?:is|are|should|must)\b/i,
+  /\bproject (?:uses?|follows?|requires?)\b/i,
+]
+
+interface ExtractionCandidate {
+  content: string
+  category: string
+  source: string
+}
+
+/** Extract potential memories from tool execution output */
+export function extractFromToolOutput(
+  toolName: string,
+  args: any,
+  output: string,
+  sessionId: string,
+  projectId: string,
+): void {
+  const config = getConfig()
+  if (!config.autoExtract) return
+  if (!isDbAvailable()) return
+
+  // Don't extract from our own memory tools
+  if (toolName.startsWith("memory_")) return
+
+  // Rate limit
+  const count = sessionExtractionCount.get(sessionId) || 0
+  if (count >= MAX_EXTRACTIONS_PER_SESSION) return
+
+  const candidates: ExtractionCandidate[] = []
+
+  // Check tool output for extractable patterns
+  const outputStr = typeof output === "string" ? output : String(output)
+
+  // Detect preferences from tool output or args
+  for (const pattern of PREFERENCE_PATTERNS) {
+    if (pattern.test(outputStr)) {
+      // Extract the matching sentence
+      const sentences = outputStr.split(/[.!?\n]/).filter((s) => s.trim().length > 10)
+      for (const sentence of sentences) {
+        if (pattern.test(sentence)) {
+          candidates.push({
+            content: sentence.trim(),
+            category: "preference",
+            source: `auto-extracted from ${toolName}`,
+          })
+          break
+        }
+      }
+    }
+  }
+
+  // Detect bug fixes
+  for (const pattern of BUG_FIX_PATTERNS) {
+    if (pattern.test(outputStr)) {
+      const sentences = outputStr.split(/[.!?\n]/).filter((s) => s.trim().length > 15)
+      for (const sentence of sentences) {
+        if (pattern.test(sentence)) {
+          candidates.push({
+            content: sentence.trim(),
+            category: "debugging",
+            source: `auto-extracted from ${toolName}`,
+          })
+          break
+        }
+      }
+    }
+  }
+
+  // Detect conventions
+  for (const pattern of CONVENTION_PATTERNS) {
+    if (pattern.test(outputStr)) {
+      const sentences = outputStr.split(/[.!?\n]/).filter((s) => s.trim().length > 10)
+      for (const sentence of sentences) {
+        if (pattern.test(sentence)) {
+          candidates.push({
+            content: sentence.trim(),
+            category: "convention",
+            source: `auto-extracted from ${toolName}`,
+          })
+          break
+        }
+      }
+    }
+  }
+
+  // Store candidates (dedup will handle duplicates)
+  for (const candidate of candidates) {
+    if (count + candidates.indexOf(candidate) >= MAX_EXTRACTIONS_PER_SESSION) break
+
+    try {
+      // Skip if too short or too long
+      if (candidate.content.length < 15 || candidate.content.length > 500) continue
+
+      storeMemory({
+        content: candidate.content,
+        category: candidate.category,
+        sessionId,
+        projectId,
+        source: candidate.source,
+      })
+
+      sessionExtractionCount.set(
+        sessionId,
+        (sessionExtractionCount.get(sessionId) || 0) + 1,
+      )
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e)
+      console.error(`[OpenRecall] Auto-extraction store failed for "${candidate.content.slice(0, 50)}...":`, msg)
+    }
+  }
+}
+
+/** Clear extraction tracking for a session */
+export function clearSessionExtraction(sessionId: string): void {
+  sessionExtractionCount.delete(sessionId)
+}

package/src/index.ts

@@ -0,0 +1,262 @@
+import type { PluginInput, Hooks } from "@opencode-ai/plugin"
+import { createTools } from "./tools"
+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 { maybeRunMaintenance } from "./maintenance"
+import { extractFromToolOutput, clearSessionExtraction } from "./extract"
+import { incrementCounter, clearCounter, scanProjectFiles, extractFileKnowledge } from "./agent"
+
+// In-memory cache of session metadata for enriching memories
+interface SessionInfo {
+  title?: string
+  directory?: string
+}
+const sessionContext = new Map<string, SessionInfo>()
+
+// Cache recalled memories per session to avoid repeated lookups
+const recalledMemories = new Map<string, string>()
+// Track which sessions have had their first message processed
+const sessionFirstMessage = new Set<string>()
+
+export default async function OpenRecallPlugin(
+  inputRef: PluginInput,
+): Promise<Hooks> {
+  const projectId = inputRef.project.id
+
+  // Store SDK client for hooks and tools to access OpenCode data
+  initClient(inputRef.client)
+
+  return {
+    // Load config from opencode.json plugin options
+    async config(cfg: any) {
+      const pluginConfig = cfg?.plugins?.openrecall as
+        | Partial<OpenRecallConfig>
+        | undefined
+      initConfig(pluginConfig)
+
+      // Initialize database after config is loaded
+      try {
+        getDb()
+        // Run periodic maintenance if needed (every 7 days)
+        maybeRunMaintenance()
+        // Scan key project files on startup to pre-populate memory
+        scanProjectFiles(inputRef.directory, projectId)
+      } catch (e) {
+        console.error(
+          "[OpenRecall] Failed to initialize database. Memory features will be unavailable.",
+          e,
+        )
+      }
+    },
+
+    // Detect first message in a session and auto-recall relevant memories
+    async "chat.message"(input, output) {
+      const sessionId = input.sessionID
+
+      // Increment message counter for agent extraction triggering
+      incrementCounter(sessionId)
+
+      const config = getConfig()
+      if (!config.autoRecall) return
+      if (!isDbAvailable()) return
+
+      if (sessionFirstMessage.has(sessionId)) return
+      sessionFirstMessage.add(sessionId)
+
+      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})`
+          })
+        }
+
+        // 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)
+      }
+    },
+
+    // Track session lifecycle events
+    async event({ event }: { event: any }) {
+      if (!event || typeof event !== "object") return
+      const type = event.type as string | undefined
+      if (!type) return
+
+      if (type === "session.created" || type === "session.updated") {
+        const properties = event.properties as
+          | { id?: string; title?: string; directory?: string }
+          | undefined
+        if (properties?.id) {
+          sessionContext.set(properties.id, {
+            title: properties.title,
+            directory: properties.directory,
+          })
+        }
+      }
+
+      if (type === "session.deleted") {
+        const properties = event.properties as { id?: string } | undefined
+        if (properties?.id) {
+          sessionContext.delete(properties.id)
+          recalledMemories.delete(properties.id)
+          sessionFirstMessage.delete(properties.id)
+          clearSessionExtraction(properties.id)
+          clearCounter(properties.id)
+        }
+      }
+    },
+
+    // Auto-extract memories from tool execution results
+    async "tool.execute.after"(input, output) {
+      const config = getConfig()
+
+      // Pattern-based extraction from tool outputs
+      if (config.autoExtract) {
+        try {
+          extractFromToolOutput(
+            input.tool,
+            input.args,
+            output.output,
+            input.sessionID,
+            projectId,
+          )
+        } catch {
+          // Silent fail
+        }
+      }
+
+      // Track file reads/edits as project knowledge
+      try {
+        extractFileKnowledge(
+          input.tool,
+          input.args,
+          output.output,
+          input.sessionID,
+          projectId,
+        )
+      } catch (e) {
+        const msg = e instanceof Error ? e.message : String(e)
+        console.error("[OpenRecall] extractFileKnowledge error:", msg)
+      }
+    },
+
+    // Expose memory tools to the LLM
+    tool: createTools(projectId),
+
+    // 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).",
+        "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.",
+      ]
+
+      // Add dynamic summary if DB is available
+      if (isDbAvailable()) {
+        try {
+          const stats = getStats()
+          if (stats.total > 0) {
+            const catSummary = Object.entries(stats.byCategory)
+              .map(([cat, count]) => `${count} ${cat}`)
+              .join(", ")
+            lines.push(`[OpenRecall] ${stats.total} memories stored: ${catSummary}.`)
+
+            // Show last few recent memories as brief summaries
+            const recent = listMemories({ projectId, limit: 3 })
+            if (recent.length > 0) {
+              const previews = recent
+                .map((m) => {
+                  const preview = m.content.length > 60
+                    ? m.content.slice(0, 57) + "..."
+                    : m.content
+                  return `"${preview}"`
+                })
+                .join(" | ")
+              lines.push(`Recent: ${previews}`)
+            }
+          }
+        } catch {
+          // Silent fail
+        }
+      }
+
+      output.system.push(lines.join("\n"))
+
+      // Inject auto-recalled memories if available
+      const sessionId = input.sessionID
+      if (sessionId) {
+        const memories = recalledMemories.get(sessionId)
+        if (memories) {
+          output.system.push(memories)
+        }
+      }
+    },
+
+    // During compaction, remind to preserve important context
+    "experimental.session.compacting": async (_input, output) => {
+      output.context.push(
+        "Before compacting, consider using memory_store to save any important " +
+          "findings, decisions, or patterns from this session that should be " +
+          "remembered across future sessions.",
+      )
+    },
+  }
+}
+
+/** Extract text content from a user message output */
+function extractUserText(output: { message: any; parts: any[] }): string {
+  // Try to get text from parts first
+  if (output.parts && Array.isArray(output.parts)) {
+    const texts = output.parts
+      .filter((p: any) => p.type === "text" && p.text)
+      .map((p: any) => p.text)
+    if (texts.length > 0) return texts.join(" ")
+  }
+
+  // Fall back to message content
+  if (output.message) {
+    const msg = output.message as any
+    if (typeof msg.content === "string") return msg.content
+    if (Array.isArray(msg.content)) {
+      return msg.content
+        .filter((c: any) => c.type === "text" && c.text)
+        .map((c: any) => c.text)
+        .join(" ")
+    }
+  }
+
+  return ""
+}

package/src/maintenance.ts

@@ -0,0 +1,134 @@
+import { getDb, isDbAvailable } from "./db"
+import { getConfig } from "./config"
+import { statSync } from "fs"
+
+const CLEANUP_INTERVAL_DAYS = 7
+
+export function getMetadata(key: string): string | null {
+  const db = getDb()
+  const row = db.prepare("SELECT value FROM metadata WHERE key = ?").get(key) as
+    | { value: string }
+    | undefined
+  return row?.value ?? null
+}
+
+export function setMetadata(key: string, value: string): void {
+  const db = getDb()
+  db.prepare(
+    "INSERT OR REPLACE INTO metadata (key, value) VALUES (?, ?)",
+  ).run(key, value)
+}
+
+export function optimizeFts(): void {
+  const db = getDb()
+  db.prepare("INSERT INTO memory_fts(memory_fts) VALUES('optimize')").run()
+}
+
+export function vacuumDb(): void {
+  const db = getDb()
+  db.exec("VACUUM")
+}
+
+export function getDbSize(): number {
+  const config = getConfig()
+  try {
+    return statSync(config.dbPath).size
+  } catch {
+    return 0
+  }
+}
+
+export function purgeOldMemories(olderThanDays: number): number {
+  const db = getDb()
+  const cutoff = Math.floor(Date.now() / 1000) - olderThanDays * 86400
+  const result = db
+    .prepare(
+      "DELETE FROM memory WHERE time_created < ? AND access_count = 0 AND time_last_accessed IS NULL",
+    )
+    .run(cutoff)
+  return result.changes
+}
+
+export function enforceMaxMemories(): number {
+  const config = getConfig()
+  if (config.maxMemories <= 0) return 0
+
+  const db = getDb()
+  const count = (
+    db.prepare("SELECT COUNT(*) as count FROM memory").get() as { count: number }
+  ).count
+
+  if (count <= config.maxMemories) return 0
+
+  const excess = count - config.maxMemories
+  // Delete oldest, least-accessed memories first
+  const result = db
+    .prepare(
+      `DELETE FROM memory WHERE id IN (
+        SELECT id FROM memory
+        ORDER BY access_count ASC, time_created ASC
+        LIMIT ?
+      )`,
+    )
+    .run(excess)
+  return result.changes
+}
+
+export function runMaintenance(): {
+  ftsOptimized: boolean
+  memoriesPurged: number
+  memoriesTrimmed: number
+  dbSizeBytes: number
+} {
+  const result = {
+    ftsOptimized: false,
+    memoriesPurged: 0,
+    memoriesTrimmed: 0,
+    dbSizeBytes: 0,
+  }
+
+  try {
+    optimizeFts()
+    result.ftsOptimized = true
+  } catch (e) {
+    console.error("[OpenRecall] FTS optimization failed:", e)
+  }
+
+  try {
+    result.memoriesTrimmed = enforceMaxMemories()
+  } catch (e) {
+    console.error("[OpenRecall] Max memories enforcement failed:", e)
+  }
+
+  result.dbSizeBytes = getDbSize()
+
+  setMetadata("last_maintenance", String(Math.floor(Date.now() / 1000)))
+
+  return result
+}
+
+export function shouldRunMaintenance(): boolean {
+  if (!isDbAvailable()) return false
+
+  try {
+    const last = getMetadata("last_maintenance")
+    if (!last) return true
+
+    const lastTs = parseInt(last, 10)
+    const now = Math.floor(Date.now() / 1000)
+    const daysSinceLast = (now - lastTs) / 86400
+    return daysSinceLast >= CLEANUP_INTERVAL_DAYS
+  } catch {
+    return false
+  }
+}
+
+export function maybeRunMaintenance(): void {
+  if (shouldRunMaintenance()) {
+    try {
+      runMaintenance()
+    } catch (e) {
+      console.error("[OpenRecall] Auto-maintenance failed:", e)
+    }
+  }
+}