claude-mem-lite 2.24.2 → 2.25.0

package/.claude-plugin/marketplace.json

@@ -10,7 +10,7 @@
   "plugins": [
     {
       "name": "claude-mem-lite",
-      "version": "2.24.2",
+      "version": "2.25.0",
       "source": "./",
       "description": "Lightweight persistent memory system for Claude Code — FTS5 search, episode batching, error-triggered recall"
     }

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mem-lite",
-  "version": "2.24.2",
+  "version": "2.25.0",
   "description": "Lightweight persistent memory system for Claude Code — FTS5 search, episode batching, error-triggered recall",
   "author": {
     "name": "sdsrss"

package/hook-episode.mjs

@@ -133,7 +133,6 @@ export function createEpisode(sessionId, project) {
     files: [],
     entries: [],
     filesRead: [],
-    fileHistoryShown: [],
   };
 }
 

package/hook.mjs

@@ -28,7 +28,7 @@ import {
   spawnBackground,
 } from './hook-shared.mjs';
 import { handleLLMEpisode, handleLLMSummary, saveObservation, buildImmediateObservation } from './hook-llm.mjs';
-import { searchRelevantMemories, recallForFile } from './hook-memory.mjs';
+import { searchRelevantMemories } from './hook-memory.mjs';
 import { buildAndSaveHandoff, detectContinuationIntent, renderHandoffInjection, extractUnfinishedSummary } from './hook-handoff.mjs';
 import { checkForUpdate } from './hook-update.mjs';
 import { SKIP_TOOLS, SKIP_PREFIXES } from './skip-tools.mjs';
@@ -225,28 +225,7 @@ async function handlePostToolUse() {
     episode.lastAt = Date.now();
     addFileToEpisode(episode, files);
 
-    // Proactive file history: show past observations for files being edited
-    // Uses recallForFile for importance>=2 with lesson context
-    if (EDIT_TOOLS.has(tool_name) && files.length > 0) {
-      const d = getDb();
-      if (d) {
-        for (const f of files) {
-          if (episode.fileHistoryShown?.includes(f)) continue;
-          try {
-            const recalled = recallForFile(d, f, project);
-            if (recalled.length > 0) {
-              const hints = recalled.map(r => {
-                const lesson = r.lesson_learned ? ` | ${r.lesson_learned}` : '';
-                return `  #${r.id} [${r.type}] ${truncate(r.title, 60)}${lesson}`;
-              }).join('\n');
-              process.stdout.write(`[claude-mem-lite] History for ${basename(f)}:\n${hints}\n`);
-            }
-          } catch (e) { debugCatch(e, 'fileHistory'); }
-          if (!episode.fileHistoryShown) episode.fileHistoryShown = [];
-          episode.fileHistoryShown.push(f);
-        }
-      }
-    }
+    // File history injection moved to PreToolUse hook (scripts/pre-tool-recall.js)
 
     writeEpisode(episode);
 
@@ -650,23 +629,50 @@ async function handleSessionStart() {
     const summaryLines = buildSummaryLines(latestSummary);
 
     // Key context: top high-importance observations for CLAUDE.md persistence
+    // Split into "File Lessons" (actionable, has lesson + file) and "Key Context" (informational)
     const keyObs = db.prepare(`
-      SELECT id, type, title, lesson_learned FROM observations
-      WHERE project = ? AND COALESCE(compressed_into, 0) = 0
-        AND COALESCE(importance, 1) >= 2
-      ORDER BY created_at_epoch DESC LIMIT 5
+      SELECT o.id, o.type, o.title, o.lesson_learned, o.files_modified FROM observations o
+      WHERE o.project = ? AND COALESCE(o.compressed_into, 0) = 0
+        AND o.superseded_at IS NULL
+        AND COALESCE(o.importance, 1) >= 2
+      ORDER BY o.created_at_epoch DESC LIMIT 10
     `).all(project);
+
     if (keyObs.length > 0) {
-      summaryLines.push('### Key Context');
+      const fileLessons = [];
+      const keyContext = [];
+
       for (const o of keyObs) {
-        // Strip raw JSON output from degraded Bash-style titles
         const clean = (o.title || '(untitled)')
           .replace(/ → (?:ERROR: )?\{".*$/, '')
           .replace(/ → (?:ERROR: )?\{[^}]*\.{3}$/, '');
-        const lesson = o.lesson_learned ? ` — ${truncate(o.lesson_learned, 60)}` : '';
-        summaryLines.push(`- [${o.type || 'discovery'}] ${truncate(clean, 80)} (#${o.id})${lesson}`);
+        const hasLesson = o.lesson_learned && o.lesson_learned.trim();
+        const hasFiles = o.files_modified && o.files_modified !== '[]';
+
+        if (hasLesson && hasFiles) {
+          try {
+            const files = JSON.parse(o.files_modified);
+            const fname = basename(Array.isArray(files) && files.length > 0 ? files[0] : '');
+            if (fname) {
+              fileLessons.push(`- ${fname}: ${truncate(o.lesson_learned, 100)} (#${o.id})`);
+              continue;
+            }
+          } catch {}
+        }
+        const lesson = hasLesson ? ` — ${truncate(o.lesson_learned, 60)}` : '';
+        keyContext.push(`- [${o.type || 'discovery'}] ${truncate(clean, 80)} (#${o.id})${lesson}`);
+      }
+
+      if (fileLessons.length > 0) {
+        summaryLines.push('### File Lessons');
+        summaryLines.push(...fileLessons.slice(0, 5));
+        summaryLines.push('');
+      }
+      if (keyContext.length > 0) {
+        summaryLines.push('### Key Context');
+        summaryLines.push(...keyContext.slice(0, 5));
+        summaryLines.push('');
       }
-      summaryLines.push('');
     } else if (!latestSummary) {
       // Fallback: no summary AND no key observations — show recent activity
       const recentObs = (observations.length >= 3 ? observations : fallbackObs).slice(0, 3);

package/hooks/hooks.json

@@ -18,6 +18,18 @@
         ]
       }
     ],
+    "PreToolUse": [
+      {
+        "matcher": "Edit|Write|NotebookEdit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "node \"${CLAUDE_PLUGIN_ROOT}/scripts/pre-tool-recall.js\"",
+            "timeout": 3
+          }
+        ]
+      }
+    ],
     "PostToolUse": [
       {
         "matcher": "*",

package/install.mjs

@@ -452,20 +452,25 @@ async function install() {
     ]
   };
 
+  const memPreToolUse = {
+    matcher: 'Edit|Write|NotebookEdit',
+    hooks: [
+      {
+        type: 'command',
+        command: `node "${join(SCRIPTS_PATH, 'pre-tool-recall.js')}"`,
+        timeout: 3
+      }
+    ]
+  };
+
   // Filter out existing mem hooks, then append fresh ones
-  for (const [event, config] of [['PostToolUse', memPostToolUse], ['SessionStart', memSessionStart], ['Stop', memStop], ['UserPromptSubmit', memUserPrompt]]) {
+  for (const [event, config] of [['PreToolUse', memPreToolUse], ['PostToolUse', memPostToolUse], ['SessionStart', memSessionStart], ['Stop', memStop], ['UserPromptSubmit', memUserPrompt]]) {
     const existing = Array.isArray(settings.hooks[event]) ? settings.hooks[event].filter(cfg => !isMemHook(cfg)) : [];
     settings.hooks[event] = [...existing, config];
   }
 
-  // Clean up stale PreToolUse hook from previous versions
-  if (Array.isArray(settings.hooks.PreToolUse)) {
-    settings.hooks.PreToolUse = settings.hooks.PreToolUse.filter(cfg => !isMemHook(cfg));
-    if (settings.hooks.PreToolUse.length === 0) delete settings.hooks.PreToolUse;
-  }
-
   writeSettings(settings);
-  ok('Hooks configured (PostToolUse, SessionStart, Stop, UserPromptSubmit)');
+  ok('Hooks configured (PreToolUse, PostToolUse, SessionStart, Stop, UserPromptSubmit)');
 
   // 5. Migrate from old ~/.claude-mem/ if needed
   if (existsSync(join(OLD_DATA_DIR, 'claude-mem.db')) && !existsSync(DB_PATH) && !existsSync(join(DATA_DIR, 'claude-mem.db'))) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-mem-lite",
-  "version": "2.24.2",
+  "version": "2.25.0",
   "description": "Lightweight persistent memory system for Claude Code",
   "type": "module",
   "engines": {
@@ -72,6 +72,7 @@
     "scripts/setup.sh",
     "scripts/post-tool-use.sh",
     "scripts/user-prompt-search.js",
+    "scripts/pre-tool-recall.js",
     "scripts/prompt-search-utils.mjs",
     ".mcp.json",
     ".claude-plugin/plugin.json",

package/scripts/pre-tool-recall.js

@@ -0,0 +1,126 @@
+#!/usr/bin/env node
+// claude-mem-lite: PreToolUse file recall — injects lessons before Edit/Write
+// Lightweight standalone (~30ms): only imports better-sqlite3, fs, path, os
+// Safety: readonly DB, exit 0 always, 3s timeout
+
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { basename, join } from 'path';
+import { homedir } from 'os';
+
+const DB_PATH = join(homedir(), '.claude-mem-lite', 'claude-mem-lite.db');
+const RUNTIME_DIR = join(homedir(), '.claude-mem-lite', 'runtime');
+const COOLDOWN_PATH = join(RUNTIME_DIR, 'pre-recall-cooldown.json');
+const COOLDOWN_MS = 5 * 60 * 1000; // 5 minutes
+const STALE_MS = 10 * 60 * 1000;   // 10 minutes cleanup threshold
+
+// ─── Helpers ────────────────────────────────────────────────────────────────
+
+function inferProject() {
+  const dir = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+  const base = basename(dir);
+  const parent = basename(join(dir, '..'));
+  let project = (parent && parent !== '.' && parent !== '/')
+    ? `${parent}--${base}` : base;
+  project = project.replace(/[^a-zA-Z0-9_.-]/g, '-') || 'unknown';
+  return project;
+}
+
+function readCooldown() {
+  try { return JSON.parse(readFileSync(COOLDOWN_PATH, 'utf8')); } catch { return {}; }
+}
+
+function writeCooldown(data) {
+  try {
+    mkdirSync(RUNTIME_DIR, { recursive: true });
+    // Clean stale entries
+    const now = Date.now();
+    const cleaned = {};
+    for (const [k, v] of Object.entries(data)) {
+      if (now - v < STALE_MS) cleaned[k] = v;
+    }
+    writeFileSync(COOLDOWN_PATH, JSON.stringify(cleaned));
+  } catch { /* silent */ }
+}
+
+// ─── Main ───────────────────────────────────────────────────────────────────
+
+try {
+  // Skip if recursive hook
+  if (process.env.CLAUDE_MEM_HOOK_RUNNING) process.exit(0);
+
+  // Skip if DB doesn't exist
+  if (!existsSync(DB_PATH)) process.exit(0);
+
+  // Read stdin
+  let input = '';
+  for await (const chunk of process.stdin) input += chunk;
+
+  // Parse event
+  let filePath;
+  try {
+    const event = JSON.parse(input);
+    filePath = event.tool_input?.file_path;
+  } catch { process.exit(0); }
+
+  if (!filePath) process.exit(0);
+
+  // Cooldown check (full path as key)
+  const cooldown = readCooldown();
+  const now = Date.now();
+  if (cooldown[filePath] && (now - cooldown[filePath]) < COOLDOWN_MS) {
+    process.exit(0);
+  }
+
+  // Open DB readonly
+  const Database = (await import('better-sqlite3')).default;
+  let db;
+  try {
+    db = new Database(DB_PATH, { readonly: true });
+    db.pragma('busy_timeout = 1000');
+  } catch { process.exit(0); }
+
+  try {
+    const project = inferProject();
+    const fname = basename(filePath);
+    // Escape LIKE wildcards
+    const escaped = fname.replace(/%/g, '\\%').replace(/_/g, '\\_');
+    const likePattern = `%${escaped}`;
+    // 60-day lookback to avoid surfacing ancient observations
+    const cutoff = Date.now() - 60 * 86400000;
+
+    const rows = db.prepare(`
+      SELECT DISTINCT o.id, o.type, o.title, o.lesson_learned
+      FROM observations o
+      JOIN observation_files of2 ON of2.obs_id = o.id
+      WHERE o.project = ?
+        AND o.importance >= 2
+        AND o.lesson_learned IS NOT NULL
+        AND o.lesson_learned != ''
+        AND COALESCE(o.compressed_into, 0) = 0
+        AND o.superseded_at IS NULL
+        AND o.created_at_epoch > ?
+        AND (of2.filename = ? OR of2.filename LIKE ? ESCAPE '\\')
+      ORDER BY o.created_at_epoch DESC
+      LIMIT 2
+    `).all(project, cutoff, filePath, likePattern);
+
+    if (rows.length > 0) {
+      console.log(`[mem] Lessons for ${fname}:`);
+      for (const r of rows) {
+        const lesson = r.lesson_learned.length > 120
+          ? r.lesson_learned.slice(0, 117) + '...'
+          : r.lesson_learned;
+        console.log(`  #${r.id} [${r.type}] ${lesson}`);
+      }
+      // Update cooldown
+      cooldown[filePath] = now;
+      writeCooldown(cooldown);
+    }
+  } catch {
+    // Silent failure — never block editing
+  } finally {
+    try { db.close(); } catch {}
+  }
+} catch {
+  // Top-level catch — exit 0 no matter what
+}