claude-recall 0.9.2 → 0.9.3

package/.claude/hooks/search_enforcer.py

@@ -0,0 +1,148 @@
+#!/usr/bin/env python3
+"""
+Minimal Search Enforcer for Claude Recall v0.9.3+
+
+Ensures memory search is performed before Write/Edit/Bash/Task operations.
+Works alongside native Claude Skills - skill teaches, hook enforces.
+
+State file: ~/.claude-recall/hook-state/{session_id}.json
+Exit codes: 0 = allow, 2 = block
+"""
+import json
+import sys
+import os
+from pathlib import Path
+from datetime import datetime
+
+STATE_DIR = Path.home() / '.claude-recall' / 'hook-state'
+SEARCH_TTL_MS = int(os.environ.get('CLAUDE_RECALL_SEARCH_TTL', 5 * 60 * 1000))  # 5 min default
+ENFORCE_MODE = os.environ.get('CLAUDE_RECALL_ENFORCE_MODE', 'block')  # block, warn, off
+
+# Tools that count as "search performed"
+SEARCH_TOOLS = [
+    'mcp__claude-recall__search',
+    'mcp__claude-recall__mcp__claude-recall__search',
+    'mcp__claude-recall__retrieve_memory',
+    'mcp__claude-recall__mcp__claude-recall__retrieve_memory',
+]
+
+# Tools that require search first
+ENFORCE_TOOLS = ['Write', 'Edit', 'Bash', 'Task']
+
+# Read-only bash commands that don't need memory search
+READ_ONLY_BASH = [
+    'ls', 'cat', 'head', 'tail', 'less', 'more', 'file', 'stat', 'wc',
+    'find', 'locate', 'which', 'whereis', 'type', 'pwd', 'whoami',
+    'git status', 'git log', 'git diff', 'git show', 'git branch',
+    'git remote', 'git fetch', 'git stash list', 'git tag',
+    'npm list', 'npm ls', 'npm view', 'npm outdated', 'npm audit',
+    'npm test', 'npm run test', 'npm run build', 'npm run lint',
+    'pip list', 'pip show', 'pip freeze',
+    'pytest', 'jest', 'cargo test', 'go test', 'tsc --noEmit',
+    'grep', 'rg', 'ag', 'awk', 'sed', 'sort', 'uniq', 'diff',
+    'tree', 'realpath', 'dirname', 'basename', 'date', 'env', 'echo',
+    'ps', 'top', 'df', 'du', 'free', 'uptime', 'hostname',
+]
+
+
+def get_state_file(session_id: str) -> Path:
+    safe_id = "".join(c if c.isalnum() or c in '-_' else '_' for c in session_id) or 'default'
+    return STATE_DIR / f'{safe_id}.json'
+
+
+def load_state(session_id: str) -> dict:
+    STATE_DIR.mkdir(parents=True, exist_ok=True)
+    state_file = get_state_file(session_id)
+    if state_file.exists():
+        try:
+            return json.load(open(state_file))
+        except:
+            pass
+    return {'lastSearchAt': None, 'searchQuery': None}
+
+
+def save_state(session_id: str, state: dict):
+    STATE_DIR.mkdir(parents=True, exist_ok=True)
+    try:
+        json.dump(state, open(get_state_file(session_id), 'w'), indent=2)
+    except:
+        pass
+
+
+def is_search_tool(tool_name: str) -> bool:
+    return any(s in tool_name for s in SEARCH_TOOLS)
+
+
+def is_read_only_bash(command: str) -> bool:
+    if not command:
+        return False
+    cmd = command.strip().lower()
+    # Check direct match or pipe starting with read-only
+    for ro in READ_ONLY_BASH:
+        if cmd.startswith(ro):
+            return True
+    if '|' in cmd:
+        first = cmd.split('|')[0].strip()
+        for ro in READ_ONLY_BASH:
+            if first.startswith(ro):
+                return True
+    return False
+
+
+def main():
+    if ENFORCE_MODE == 'off':
+        sys.exit(0)
+
+    try:
+        data = json.load(sys.stdin)
+    except:
+        sys.exit(0)
+
+    tool_name = data.get('tool_name', '')
+    tool_input = data.get('tool_input', {})
+    session_id = data.get('session_id', '') or 'default'
+
+    # Track search calls
+    if is_search_tool(tool_name):
+        state = load_state(session_id)
+        state['lastSearchAt'] = int(datetime.now().timestamp() * 1000)
+        state['searchQuery'] = tool_input.get('query', '')
+        save_state(session_id, state)
+        sys.exit(0)
+
+    # Only enforce on specific tools
+    if tool_name not in ENFORCE_TOOLS:
+        sys.exit(0)
+
+    # Skip read-only bash
+    if tool_name == 'Bash' and is_read_only_bash(tool_input.get('command', '')):
+        sys.exit(0)
+
+    # Check if search was recent
+    state = load_state(session_id)
+    last_search = state.get('lastSearchAt')
+
+    if last_search:
+        now = int(datetime.now().timestamp() * 1000)
+        if (now - last_search) <= SEARCH_TTL_MS:
+            sys.exit(0)
+
+    # Block or warn
+    msg = f"""
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+🔍 MEMORY SEARCH REQUIRED before {tool_name}
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Run: mcp__claude-recall__search({{"query": "relevant keywords"}})
+
+This ensures you apply user preferences and avoid past mistakes.
+
+To disable: CLAUDE_RECALL_ENFORCE_MODE=off
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+"""
+    print(msg.strip(), file=sys.stderr)
+    sys.exit(0 if ENFORCE_MODE == 'warn' else 2)
+
+
+if __name__ == '__main__':
+    main()

package/dist/cli/claude-recall-cli.js

@@ -565,23 +565,24 @@ async function main() {
             }
         }
     }
-    // Install skills and clean up old hooks (v0.9.0+ uses Skills, not hooks)
-    function installSkillsAndCleanupHooks(force = false) {
+    // Install skills + minimal enforcement hook (v0.9.3+ hybrid approach)
+    function installSkillsAndHook(force = false) {
         const cwd = process.cwd();
         const projectName = path.basename(cwd);
-        console.log('\n📦 Claude Recall v0.9.x Setup\n');
+        console.log('\n📦 Claude Recall v0.9.3+ Setup\n');
         console.log(`📍 Project: ${projectName}`);
         console.log(`📍 Directory: ${cwd}\n`);
         // Find the package directory (where claude-recall is installed)
         const packageDir = path.resolve(__dirname, '../..');
         const packageSkillsDir = path.join(packageDir, '.claude/skills');
+        const packageHooksDir = path.join(packageDir, '.claude/hooks');
         const claudeDir = path.join(cwd, '.claude');
         const hooksDir = path.join(claudeDir, 'hooks');
         const settingsPath = path.join(claudeDir, 'settings.json');
-        // === CLEANUP: Remove old hooks (v0.9.0+ doesn't use hooks) ===
+        // === CLEANUP: Remove OLD hooks (not the new search_enforcer.py) ===
         if (fs.existsSync(hooksDir)) {
             const oldHooks = [
-                'memory_enforcer.py',
+                'memory_enforcer.py', // Old v0.8.x hook
                 'pre_tool_search_enforcer.py',
                 'mcp_tool_tracker.py',
                 'pubnub_pre_tool_hook.py',
@@ -597,49 +598,53 @@ async function main() {
                     removedCount++;
                 }
             }
-            // Remove hooks directory if empty
-            try {
-                const remaining = fs.readdirSync(hooksDir);
-                if (remaining.length === 0) {
-                    fs.rmdirSync(hooksDir);
-                }
-            }
-            catch (e) {
-                // Ignore
-            }
             if (removedCount > 0) {
-                console.log(`🧹 Removed ${removedCount} old hook file(s) from .claude/hooks/`);
+                console.log(`🧹 Removed ${removedCount} old hook file(s)`);
             }
         }
-        // === CLEANUP: Clear hook configuration from settings.json ===
+        // === INSTALL: New minimal search_enforcer.py ===
+        if (!fs.existsSync(hooksDir)) {
+            fs.mkdirSync(hooksDir, { recursive: true });
+        }
+        const hookSource = path.join(packageHooksDir, 'search_enforcer.py');
+        const hookDest = path.join(hooksDir, 'search_enforcer.py');
+        if (fs.existsSync(hookSource)) {
+            fs.copyFileSync(hookSource, hookDest);
+            fs.chmodSync(hookDest, 0o755);
+            console.log('✅ Installed search_enforcer.py to .claude/hooks/');
+        }
+        else {
+            console.log(`⚠️  Hook not found at: ${hookSource}`);
+        }
+        // === CONFIGURE: Update settings.json with new hook ===
         let settings = {};
         if (fs.existsSync(settingsPath)) {
             try {
                 settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
-                const hadHooks = settings.hooks && Object.keys(settings.hooks).length > 0;
-                // Clear hooks - v0.9.0+ uses Skills instead
-                settings.hooks = {};
-                settings.hooksVersion = '2.0.0';
-                fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
-                if (hadHooks) {
-                    console.log('🧹 Cleared old hook configuration from .claude/settings.json');
-                }
             }
             catch (e) {
-                // If settings.json is invalid, create fresh one
-                if (!fs.existsSync(claudeDir)) {
-                    fs.mkdirSync(claudeDir, { recursive: true });
-                }
-                fs.writeFileSync(settingsPath, JSON.stringify({ hooks: {}, hooksVersion: '2.0.0' }, null, 2));
+                settings = {};
             }
         }
-        else {
-            // Create new settings.json without hooks
-            if (!fs.existsSync(claudeDir)) {
-                fs.mkdirSync(claudeDir, { recursive: true });
-            }
-            fs.writeFileSync(settingsPath, JSON.stringify({ hooks: {}, hooksVersion: '2.0.0' }, null, 2));
+        settings.hooksVersion = '3.0.0'; // v3 = hybrid (skill + minimal hook)
+        settings.hooks = {
+            PreToolUse: [
+                {
+                    matcher: "mcp__claude-recall__.*|Write|Edit|Bash|Task",
+                    hooks: [
+                        {
+                            type: "command",
+                            command: `python3 ${hookDest}`
+                        }
+                    ]
+                }
+            ]
+        };
+        if (!fs.existsSync(claudeDir)) {
+            fs.mkdirSync(claudeDir, { recursive: true });
         }
+        fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+        console.log('✅ Configured search enforcement hook');
         // === INSTALL: Copy skills directory ===
         if (fs.existsSync(packageSkillsDir)) {
             const skillsDir = path.join(claudeDir, 'skills');
@@ -650,7 +655,7 @@ async function main() {
             console.log(`⚠️  Skills not found at: ${packageSkillsDir}`);
         }
         console.log('\n✅ Setup complete!\n');
-        console.log('ℹ️  v0.9.0+ uses native Claude Skills instead of hooks.');
+        console.log('ℹ️  v0.9.3+ uses Skills (guidance) + minimal hook (enforcement).');
         console.log('Restart Claude Code to activate.\n');
     }
     // Setup command - shows activation instructions or installs skills
@@ -660,8 +665,8 @@ async function main() {
         .option('--install', 'Install skills and clean up old hooks')
         .action((options) => {
         if (options.install) {
-            // Install skills and clean up old hooks
-            installSkillsAndCleanupHooks();
+            // Install skills and enforcement hook
+            installSkillsAndHook();
         }
         else {
             // Show activation instructions
@@ -692,7 +697,7 @@ async function main() {
         .description('Clean up old hooks and install skills (v0.9.0+ migration)')
         .option('--force', 'Force overwrite existing configuration')
         .action((options) => {
-        installSkillsAndCleanupHooks(options.force || false);
+        installSkillsAndHook(options.force || false);
         process.exit(0);
     });
     // Check hooks function

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-recall",
-  "version": "0.9.2",
+  "version": "0.9.3",
   "description": "Persistent memory for Claude Code with native Skills integration, automatic capture, failure learning, and project scoping via MCP server",
   "main": "dist/index.js",
   "bin": {

package/scripts/postinstall.js

@@ -104,22 +104,22 @@ try {
     console.log('⚠️  Failed to register project (non-fatal):', error.message);
   }
 
-  // Install skills and clean up old hooks (v0.9.0+ uses Skills, not hooks)
+  // Install skills + minimal enforcement hook (v0.9.3+ hybrid approach)
   try {
     const cwd = process.cwd();
     const projectName = path.basename(cwd);
     const packageSkillsDir = path.join(__dirname, '../.claude/skills');
+    const packageHooksDir = path.join(__dirname, '../.claude/hooks');
 
     if (projectName !== 'claude-recall' && !cwd.includes('node_modules/.pnpm') && !cwd.includes('node_modules/claude-recall')) {
       const claudeDir = path.join(cwd, '.claude');
       const hooksDir = path.join(claudeDir, 'hooks');
       const settingsPath = path.join(claudeDir, 'settings.json');
 
-      // === CLEANUP: Remove old hooks (v0.9.0+ doesn't use hooks) ===
+      // === CLEANUP: Remove OLD hooks (not the new search_enforcer.py) ===
       if (fs.existsSync(hooksDir)) {
-        // Remove known hook files from previous versions
         const oldHooks = [
-          'memory_enforcer.py',
+          'memory_enforcer.py',  // Old v0.8.x hook
           'pre_tool_search_enforcer.py',
           'mcp_tool_tracker.py',
           'pubnub_pre_tool_hook.py',
@@ -137,48 +137,56 @@ try {
           }
         }
 
-        // Remove hooks directory if empty
-        try {
-          const remaining = fs.readdirSync(hooksDir);
-          if (remaining.length === 0) {
-            fs.rmdirSync(hooksDir);
-          }
-        } catch (e) {
-          // Ignore
-        }
-
         if (removedCount > 0) {
-          console.log(`🧹 Removed ${removedCount} old hook file(s) from .claude/hooks/`);
+          console.log(`🧹 Removed ${removedCount} old hook file(s)`);
         }
       }
 
-      // === CLEANUP: Clear hook configuration from settings.json ===
-      if (fs.existsSync(settingsPath)) {
-        try {
-          let settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
-          const hadHooks = settings.hooks && Object.keys(settings.hooks).length > 0;
+      // === INSTALL: New minimal search_enforcer.py ===
+      if (!fs.existsSync(hooksDir)) {
+        fs.mkdirSync(hooksDir, { recursive: true });
+      }
 
-          // Clear hooks - v0.9.0+ uses Skills instead
-          settings.hooks = {};
-          settings.hooksVersion = '2.0.0'; // Bump version to indicate skills-based
+      const hookSource = path.join(packageHooksDir, 'search_enforcer.py');
+      const hookDest = path.join(hooksDir, 'search_enforcer.py');
 
-          fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+      if (fs.existsSync(hookSource)) {
+        fs.copyFileSync(hookSource, hookDest);
+        fs.chmodSync(hookDest, 0o755);
+        console.log('✅ Installed search_enforcer.py to .claude/hooks/');
+      }
 
-          if (hadHooks) {
-            console.log('🧹 Cleared old hook configuration from .claude/settings.json');
-          }
+      // === CONFIGURE: Update settings.json with new hook ===
+      let settings = {};
+      if (fs.existsSync(settingsPath)) {
+        try {
+          settings = JSON.parse(fs.readFileSync(settingsPath, 'utf8'));
         } catch (e) {
-          // If settings.json is invalid, create fresh one
-          fs.writeFileSync(settingsPath, JSON.stringify({ hooks: {}, hooksVersion: '2.0.0' }, null, 2));
+          settings = {};
         }
-      } else {
-        // Create new settings.json without hooks
-        if (!fs.existsSync(claudeDir)) {
-          fs.mkdirSync(claudeDir, { recursive: true });
-        }
-        fs.writeFileSync(settingsPath, JSON.stringify({ hooks: {}, hooksVersion: '2.0.0' }, null, 2));
       }
 
+      settings.hooksVersion = '3.0.0';  // v3 = hybrid (skill + minimal hook)
+      settings.hooks = {
+        PreToolUse: [
+          {
+            matcher: "mcp__claude-recall__.*|Write|Edit|Bash|Task",
+            hooks: [
+              {
+                type: "command",
+                command: `python3 ${hookDest}`
+              }
+            ]
+          }
+        ]
+      };
+
+      if (!fs.existsSync(claudeDir)) {
+        fs.mkdirSync(claudeDir, { recursive: true });
+      }
+      fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+      console.log('✅ Configured search enforcement hook');
+
       // === INSTALL: Copy skills directory ===
       if (fs.existsSync(packageSkillsDir)) {
         const skillsDir = path.join(claudeDir, 'skills');
@@ -187,7 +195,7 @@ try {
       }
     }
   } catch (error) {
-    console.log('⚠️  Failed to install skills (non-fatal):', error.message);
+    console.log('⚠️  Failed to install (non-fatal):', error.message);
   }
 
   console.log('\n✅ Installation complete!\n');
@@ -201,7 +209,7 @@ try {
   console.log('');
   console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━');
   console.log('');
-  console.log('ℹ️  v0.9.0+ uses native Claude Skills instead of hooks.');
+  console.log('ℹ️  v0.9.3+ uses Skills (guidance) + minimal hook (enforcement).');
   console.log('💡 Your memories persist across conversations and restarts.\n');
 
 } catch (error) {