claude-recall 0.2.2 → 0.2.4

package/README.md

@@ -43,13 +43,37 @@ Launch Claude Code and your memories will be captured automatically. Claude Reca
 
 ## How It Works
 
-Claude Recall uses the Model Context Protocol to integrate directly with Claude Code. When you:
-- Use tools or run commands - it captures the patterns
-- Express preferences - it remembers them
-- Make decisions - it stores the context
-- Start new conversations - it provides relevant memories
+Claude Recall uses the Model Context Protocol to integrate directly with Claude Code. 
 
-All of this happens automatically through MCP, without any manual configuration.
+### Automatic Memory Capture (v0.2.4+)
+
+Claude Recall ensures memories are captured reliably by:
+1. **Instructing Claude via CLAUDE.md** - Installation adds instructions so Claude always calls the MCP tool when you say "remember"
+2. **Automatic pattern detection** - When Claude does use tools, additional patterns are detected
+
+**Memory storage is triggered by:**
+- "remember" / "remember that" / "please remember"
+- "don't forget" / "keep in mind" / "bear in mind"
+- "store in memory" / "save to memory"
+- "note that" / "take note"
+- "for future reference" / "memorize"
+
+**Memory retrieval is triggered by:**
+- "recall" / "what did I tell you about"
+- "what do you remember about"
+- "do you remember"
+
+**Additional patterns detected automatically:**
+- **Preferences**: "I prefer X over Y", "Always use X", "From now on, use Y"
+- **Decisions**: "We decided to...", "Let's go with...", "We'll use..."
+- **Instructions**: "Make sure to...", "Ensure that...", "Files should be in..."
+
+### Manual Memory Storage
+
+You can also explicitly ask Claude to store memories using the MCP tools:
+- Use the `mcp__claude-recall__store_memory` tool
+- Search with `mcp__claude-recall__search`
+- Get stats with `mcp__claude-recall__get_stats`
 
 ## Real-World Example
 
@@ -162,6 +186,18 @@ const memories = await mcp__claude-recall__search({
 })
 ```
 
+### Customizing Memory Patterns
+
+Claude Recall uses configurable patterns for automatic memory capture. You can customize these by setting the `CLAUDE_RECALL_PATTERNS_CONFIG` environment variable to point to your own JSON configuration file.
+
+Default patterns include:
+- **Explicit remember**: Any sentence with "remember" (confidence: 1.0)
+- **Preferences**: "I prefer", "Always use", "From now on" (confidence: 0.85-0.9)
+- **Locations**: "Should be in X directory" (confidence: 0.8)
+- **Instructions**: "Make sure", "Ensure that" (confidence: 0.7)
+
+See `src/config/memory-patterns.json` for the full configuration format.
+
 ## Troubleshooting
 
 ### MCP Server Not Found
@@ -178,6 +214,59 @@ If Claude Code can't find the MCP server:
 2. Check stats: `claude-recall stats`
 3. Ensure MCP tools are being used in Claude Code
 
+### Clearing npm Cache (Version Issues)
+
+If you're seeing an old version after installing `@latest`, clear the npm cache:
+
+```bash
+# Complete cache clear and reinstall
+npm uninstall -g claude-recall
+npm cache clean --force
+npm cache verify
+npm install -g claude-recall@latest
+
+# Verify the installation
+claude-recall --version
+claude-recall mcp test
+```
+
+### Diagnostic Commands for Support
+
+If you need help troubleshooting, run these commands and share the output:
+
+```bash
+"""# 1. Check Installation
+claude-recall --version
+which claude-recall
+npm list -g claude-recall
+
+# 2. Check MCP Configuration
+cat ~/.claude.json | grep -A10 "claude-recall"
+claude-recall mcp test
+
+# 3. Check Database
+ls -la ~/.claude-recall/
+ls -lh ~/.claude-recall/claude-recall.db 2>/dev/null || echo "Database not found"
+
+# 4. Check System Status
+claude-recall status
+claude-recall stats
+
+# 5. Test Basic Functionality
+claude-recall search "test"
+claude-recall stats | grep "Total memories"
+
+# 6. Check for Errors
+ls -la *.log 2>/dev/null || echo "No log files"
+tail -20 info.log 2>/dev/null || echo "No info log"
+
+# 7. Environment Info
+node --version
+npm --version
+echo "OS: $(uname -s)"
+echo "Home: $HOME""""
+```
+
 ## Contributing
 
 We welcome contributions! Claude Recall is designed to be hackable:

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

@@ -251,7 +251,7 @@ async function main() {
     program
         .name('claude-recall')
         .description('Memory-enhanced Claude Code via MCP')
-        .version('0.2.2')
+        .version('0.2.4')
         .option('--verbose', 'Enable verbose logging')
         .option('--config <path>', 'Path to custom config file');
     // MCP command

package/dist/config/memory-patterns.json

@@ -0,0 +1,64 @@
+{
+  "preferencePatterns": [
+    {
+      "pattern": "(?:I prefer|I'd prefer|prefer|preferring)\\s+([\\w\\s]+)\\s+(?:over|instead of|rather than)\\s+([\\w\\s]+)",
+      "type": "preference",
+      "confidence": 0.9,
+      "extractionMode": "comparison"
+    },
+    {
+      "pattern": "(?:always use|always using|we always use)\\s+([\\w\\s\\-\\.]+)",
+      "type": "preference",
+      "confidence": 0.85,
+      "extractionMode": "directive"
+    },
+    {
+      "pattern": "(?:from now on|moving forward|going forward)(?:,)?\\s+(?:use|we'll use|let's use)\\s+([\\w\\s\\-\\.]+)",
+      "type": "decision",
+      "confidence": 0.9,
+      "extractionMode": "future_directive"
+    },
+    {
+      "pattern": "(?:should be|must be|needs to be)\\s+(?:in|at|under)\\s+(?:the)?\\s+([\\w\\/\\-\\.]+)\\s+(?:directory|folder|dir)",
+      "type": "location_preference",
+      "confidence": 0.8,
+      "extractionMode": "location"
+    },
+    {
+      "pattern": "(?:make sure|ensure)\\s+(?:to|that)\\s+([^.!?]+)",
+      "type": "instruction",
+      "confidence": 0.7,
+      "extractionMode": "requirement"
+    },
+    {
+      "pattern": "(?:remember|Remember)\\s+(?:that\\s+)?(.+?)(?:[.!?]|$)",
+      "type": "explicit_memory",
+      "confidence": 1.0,
+      "extractionMode": "direct_capture"
+    }
+  ],
+  "actionPatterns": [
+    {
+      "pattern": "(?:creating|created|adding|added)\\s+(?:a|an|the)?\\s*([\\w\\s]+)\\s+(?:in|at|to)\\s+([\\w\\/\\-\\.]+)",
+      "type": "file_creation",
+      "confidence": 0.75
+    },
+    {
+      "pattern": "(?:using|used|chose|chosen)\\s+([\\w\\s\\-\\.]+)\\s+(?:for|as)\\s+(?:the)?\\s*([\\w\\s]+)",
+      "type": "tool_choice",
+      "confidence": 0.8
+    }
+  ],
+  "contextTriggers": {
+    "highConfidenceWords": ["always", "never", "must", "should", "prefer", "requirement", "important"],
+    "decisionIndicators": ["decided", "choosing", "selected", "going with", "settled on"],
+    "futureTense": ["will", "going to", "from now on", "moving forward", "next time"]
+  },
+  "captureSettings": {
+    "minConfidence": 0.7,
+    "requireExplicitConfirmation": false,
+    "batchProcessingDelay": 1000,
+    "maxMemoriesPerSession": 50,
+    "deduplicationWindow": 3600000
+  }
+}

package/dist/mcp/memory-capture-middleware.js

@@ -0,0 +1,314 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryCaptureMiddleware = void 0;
+const preference_extractor_1 = require("../services/preference-extractor");
+const action_pattern_detector_1 = require("../services/action-pattern-detector");
+const memory_1 = require("../services/memory");
+const logging_1 = require("../services/logging");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class MemoryCaptureMiddleware {
+    constructor() {
+        this.recentCaptures = new Map();
+        this.sessionMemoryCount = new Map();
+        this.preferenceExtractor = new preference_extractor_1.PreferenceExtractor();
+        this.actionDetector = new action_pattern_detector_1.ActionPatternDetector();
+        this.memoryService = memory_1.MemoryService.getInstance();
+        this.logger = logging_1.LoggingService.getInstance();
+        this.loadConfig();
+    }
+    loadConfig() {
+        try {
+            // First try custom config location
+            const customConfigPath = process.env.CLAUDE_RECALL_PATTERNS_CONFIG;
+            const defaultConfigPath = path.join(__dirname, '../../config/memory-patterns.json');
+            const configPath = customConfigPath && fs.existsSync(customConfigPath)
+                ? customConfigPath
+                : defaultConfigPath;
+            if (fs.existsSync(configPath)) {
+                const configContent = fs.readFileSync(configPath, 'utf-8');
+                this.config = JSON.parse(configContent);
+                this.logger.info('MemoryCaptureMiddleware', 'Loaded memory patterns config', { configPath });
+            }
+            else {
+                // Use default config if file doesn't exist
+                this.config = this.getDefaultConfig();
+                this.logger.warn('MemoryCaptureMiddleware', 'Using default config, no config file found');
+            }
+        }
+        catch (error) {
+            this.logger.error('MemoryCaptureMiddleware', 'Failed to load config, using defaults', error);
+            this.config = this.getDefaultConfig();
+        }
+    }
+    getDefaultConfig() {
+        return {
+            preferencePatterns: [
+                {
+                    pattern: "(?:I prefer|prefer)\\s+([\\w\\s]+)\\s+(?:over|instead of)\\s+([\\w\\s]+)",
+                    type: "preference",
+                    confidence: 0.9,
+                    extractionMode: "comparison"
+                }
+            ],
+            actionPatterns: [],
+            contextTriggers: {
+                highConfidenceWords: ["always", "never", "must", "prefer"],
+                decisionIndicators: ["decided", "choosing", "selected"],
+                futureTense: ["will", "going to", "from now on"]
+            },
+            captureSettings: {
+                minConfidence: 0.7,
+                requireExplicitConfirmation: false,
+                batchProcessingDelay: 1000,
+                maxMemoriesPerSession: 50,
+                deduplicationWindow: 3600000
+            }
+        };
+    }
+    /**
+     * Process a request/response pair for automatic memory capture
+     */
+    async processForMemoryCapture(request, response, sessionId) {
+        try {
+            // Don't capture from memory-related tools to avoid loops
+            if (request.method === 'tools/call' &&
+                request.params?.name?.includes('memory')) {
+                return;
+            }
+            // Extract content to analyze
+            const contentToAnalyze = this.extractContent(request, response);
+            if (!contentToAnalyze)
+                return;
+            // Check session memory limit
+            const sessionCount = this.sessionMemoryCount.get(sessionId) || 0;
+            if (sessionCount >= this.config.captureSettings.maxMemoriesPerSession) {
+                this.logger.debug('MemoryCaptureMiddleware', 'Session memory limit reached', { sessionId, count: sessionCount });
+                return;
+            }
+            // Analyze for patterns
+            const detectedMemories = await this.analyzeContent(contentToAnalyze, sessionId);
+            // Store unique memories
+            for (const memory of detectedMemories) {
+                if (this.shouldCapture(memory, sessionId)) {
+                    await this.captureMemory(memory, sessionId);
+                }
+            }
+        }
+        catch (error) {
+            this.logger.error('MemoryCaptureMiddleware', 'Error in memory capture', error);
+        }
+    }
+    extractContent(request, response) {
+        let content = '';
+        // Extract from request
+        if (request.params?.arguments?.content) {
+            content += request.params.arguments.content + '\n';
+        }
+        // Extract from response
+        if (response.result?.content) {
+            if (Array.isArray(response.result.content)) {
+                response.result.content.forEach((item) => {
+                    if (item.text)
+                        content += item.text + '\n';
+                });
+            }
+            else if (typeof response.result.content === 'string') {
+                content += response.result.content + '\n';
+            }
+        }
+        return content.trim() || null;
+    }
+    async analyzeContent(content, sessionId) {
+        const memories = [];
+        // PRIORITY 1: Check for explicit "remember" commands
+        const rememberRegex = /(?:remember|Remember)\s+(?:that\s+)?(.+?)(?:[.!?]|$)/gi;
+        const rememberMatches = content.matchAll(rememberRegex);
+        for (const match of rememberMatches) {
+            const memoryContent = match[1].trim();
+            if (memoryContent) {
+                memories.push({
+                    type: 'explicit_memory',
+                    content: memoryContent,
+                    data: {
+                        raw: memoryContent,
+                        source: 'explicit_remember_command',
+                        confidence: 1.0
+                    },
+                    confidence: 1.0, // Always highest confidence
+                    priority: 1 // Highest priority
+                });
+            }
+        }
+        // PRIORITY 2: Use configured preference patterns
+        for (const pattern of this.config.preferencePatterns) {
+            const regex = new RegExp(pattern.pattern, 'gi');
+            const matches = content.matchAll(regex);
+            for (const match of matches) {
+                // Skip if this was already captured as explicit memory
+                if (match[0].toLowerCase().includes('remember'))
+                    continue;
+                memories.push({
+                    type: pattern.type,
+                    content: match[0],
+                    data: {
+                        pattern: pattern.type,
+                        captured: match.slice(1),
+                        confidence: pattern.confidence,
+                        extractionMode: pattern.extractionMode
+                    },
+                    confidence: pattern.confidence,
+                    priority: 2
+                });
+            }
+        }
+        // PRIORITY 3: Use existing PreferenceExtractor
+        const preferences = this.preferenceExtractor.extractPreferences(content);
+        for (const pref of preferences) {
+            if (pref.confidence >= this.config.captureSettings.minConfidence) {
+                // Skip if already captured as explicit memory
+                if (pref.raw.toLowerCase().includes('remember'))
+                    continue;
+                memories.push({
+                    type: 'preference',
+                    content: pref.raw,
+                    data: {
+                        key: pref.key,
+                        value: pref.value,
+                        confidence: pref.confidence
+                    },
+                    confidence: pref.confidence,
+                    priority: 3
+                });
+            }
+        }
+        // Check for action patterns using configured patterns
+        for (const pattern of this.config.actionPatterns) {
+            const regex = new RegExp(pattern.pattern, 'gi');
+            const matches = content.matchAll(regex);
+            for (const match of matches) {
+                memories.push({
+                    type: pattern.type,
+                    content: match[0],
+                    data: {
+                        pattern: pattern.type,
+                        captured: match.slice(1),
+                        confidence: pattern.confidence
+                    },
+                    confidence: pattern.confidence
+                });
+            }
+        }
+        // Check for high-confidence context triggers
+        const hasHighConfidenceContext = this.config.contextTriggers.highConfidenceWords.some(word => content.toLowerCase().includes(word.toLowerCase()));
+        if (hasHighConfidenceContext) {
+            // Boost confidence for all found patterns
+            memories.forEach(m => m.confidence = Math.min(1.0, m.confidence * 1.1));
+        }
+        return memories;
+    }
+    shouldCapture(memory, sessionId) {
+        // ALWAYS capture explicit "remember" commands
+        if (memory.type === 'explicit_memory' || memory.priority === 1) {
+            return true;
+        }
+        // Check confidence threshold for other types
+        if (memory.confidence < this.config.captureSettings.minConfidence) {
+            return false;
+        }
+        // Check for duplicates within deduplication window
+        const memoryKey = `${memory.type}:${memory.content}`;
+        const lastCapture = this.recentCaptures.get(memoryKey);
+        const now = Date.now();
+        if (lastCapture && (now - lastCapture) < this.config.captureSettings.deduplicationWindow) {
+            return false;
+        }
+        return true;
+    }
+    async captureMemory(memory, sessionId) {
+        try {
+            // Store using MemoryService
+            const stored = this.memoryService.store({
+                key: `auto_${memory.type}_${Date.now()}`,
+                value: memory.data,
+                type: memory.type,
+                context: {
+                    projectId: sessionId,
+                    type: 'auto_capture',
+                    timestamp: Date.now()
+                }
+            });
+            // Update tracking
+            const memoryKey = `${memory.type}:${memory.content}`;
+            this.recentCaptures.set(memoryKey, Date.now());
+            const currentCount = this.sessionMemoryCount.get(sessionId) || 0;
+            this.sessionMemoryCount.set(sessionId, currentCount + 1);
+            this.logger.info('MemoryCaptureMiddleware', 'Auto-captured memory', {
+                type: memory.type,
+                confidence: memory.confidence,
+                sessionId
+            });
+        }
+        catch (error) {
+            this.logger.error('MemoryCaptureMiddleware', 'Failed to capture memory', error);
+        }
+    }
+    /**
+     * Clean up old session data
+     */
+    cleanupSessions() {
+        // Clean up old captures
+        const now = Date.now();
+        const cutoff = now - this.config.captureSettings.deduplicationWindow;
+        for (const [key, timestamp] of this.recentCaptures) {
+            if (timestamp < cutoff) {
+                this.recentCaptures.delete(key);
+            }
+        }
+        // Reset session counts periodically
+        if (this.sessionMemoryCount.size > 100) {
+            this.sessionMemoryCount.clear();
+        }
+    }
+    /**
+     * Reload configuration (useful for hot-reloading)
+     */
+    reloadConfig() {
+        this.loadConfig();
+        this.logger.info('MemoryCaptureMiddleware', 'Configuration reloaded');
+    }
+}
+exports.MemoryCaptureMiddleware = MemoryCaptureMiddleware;

package/dist/mcp/server.js

@@ -7,6 +7,7 @@ const memory_1 = require("../services/memory");
 const logging_1 = require("../services/logging");
 const session_manager_1 = require("./session-manager");
 const rate_limiter_1 = require("./rate-limiter");
+const memory_capture_middleware_1 = require("./memory-capture-middleware");
 class MCPServer {
     constructor() {
         this.tools = new Map();
@@ -21,31 +22,45 @@ class MCPServer {
             maxRequests: 100, // 100 requests per minute
             skipSuccessfulRequests: false
         });
+        this.memoryCaptureMiddleware = new memory_capture_middleware_1.MemoryCaptureMiddleware();
         this.setupRequestHandlers();
         this.registerTools();
     }
     setupRequestHandlers() {
         this.transport.onRequest(async (request) => {
+            let response;
             try {
                 switch (request.method) {
                     case 'initialize':
-                        return this.handleInitialize(request);
+                        response = await this.handleInitialize(request);
+                        break;
                     case 'tools/list':
-                        return this.handleToolsList(request);
+                        response = await this.handleToolsList(request);
+                        break;
                     case 'tools/call':
-                        return this.handleToolCall(request);
+                        response = await this.handleToolCall(request);
+                        break;
                     case 'notifications/initialized':
-                        return this.handleInitialized(request);
+                        response = await this.handleInitialized(request);
+                        break;
                     case 'health/check':
-                        return this.handleHealthCheck(request);
+                        response = await this.handleHealthCheck(request);
+                        break;
                     default:
-                        return this.createErrorResponse(request.id, -32601, `Method not found: ${request.method}`);
+                        response = this.createErrorResponse(request.id, -32601, `Method not found: ${request.method}`);
                 }
             }
             catch (error) {
                 this.logger.logServiceError('MCPServer', 'handleRequest', error, { method: request.method });
-                return this.createErrorResponse(request.id, -32603, 'Internal error', { message: error.message });
+                response = this.createErrorResponse(request.id, -32603, 'Internal error', { message: error.message });
             }
+            // Process for automatic memory capture (non-blocking)
+            if (this.isInitialized && request.method === 'tools/call') {
+                const sessionId = request.params?.arguments?.sessionId || this.generateSessionId();
+                this.memoryCaptureMiddleware.processForMemoryCapture(request, response, sessionId)
+                    .catch(err => this.logger.error('MCPServer', 'Memory capture failed', err));
+            }
+            return response;
         });
     }
     registerTools() {
@@ -257,6 +272,8 @@ class MCPServer {
             this.sessionManager.shutdown();
             // Shutdown rate limiter
             this.rateLimiter.shutdown();
+            // Clean up memory capture middleware
+            this.memoryCaptureMiddleware.cleanupSessions();
             await this.transport.stop();
             this.memoryService.close();
             this.logger.info('MCPServer', 'MCP server stopped');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-recall",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "MCP server for persistent memory in Claude Code conversations",
   "main": "dist/index.js",
   "bin": {
@@ -21,7 +21,7 @@
     "postinstall": "node scripts/postinstall.js || true",
     "test": "jest --passWithNoTests",
     "test:watch": "jest --watch",
-    "build": "tsc && mkdir -p dist/memory && cp src/memory/schema.sql dist/memory/ && chmod +x dist/cli/claude-recall-cli.js",
+    "build": "tsc && mkdir -p dist/memory dist/config && cp src/memory/schema.sql dist/memory/ && cp -r src/config/* dist/config/ 2>/dev/null || true && chmod +x dist/cli/claude-recall-cli.js",
     "build:cli": "tsc && chmod +x dist/cli/claude-recall-cli.js",
     "dev": "ts-node",
     "start": "ts-node src/server.ts",

package/scripts/postinstall.js

@@ -57,6 +57,84 @@ try {
   fs.writeFileSync(claudeConfigPath, JSON.stringify(config, null, 2));
 
   console.log('✅ Successfully configured Claude Recall in ~/.claude.json');
+
+  // Update CLAUDE.md with instructions
+  const claudeMdInstructions = `
+# Claude Recall Memory Instructions
+
+IMPORTANT: When the user uses any of these words or phrases, you MUST call the appropriate claude-recall MCP tool:
+
+## Memory Storage Triggers
+When you see these words/phrases, ALWAYS call \`mcp__claude-recall__store_memory\`:
+- "remember" / "remember that" / "please remember"
+- "store" / "store in memory" / "save to memory"
+- "don't forget" / "do not forget"
+- "keep in mind" / "bear in mind"
+- "note that" / "take note"
+- "for future reference"
+- "memorize"
+
+Example: If user says "Remember that I prefer tabs over spaces", you must call:
+\`\`\`
+mcp__claude-recall__store_memory({
+  content: "User prefers tabs over spaces",
+  metadata: { type: "preference" }
+})
+\`\`\`
+
+## Memory Retrieval Triggers
+When you see these words/phrases, ALWAYS call \`mcp__claude-recall__search\` or \`mcp__claude-recall__retrieve_memory\`:
+- "recall" / "what did I tell you about"
+- "what do you remember about"
+- "retrieve" / "fetch from memory"
+- "what's in your memory about"
+- "what did we discuss about"
+- "do you remember"
+
+## Important
+- ALWAYS acknowledge that you're storing/retrieving the memory
+- Be explicit about what was stored or retrieved
+- These instructions ensure your memory system works reliably
+`;
+
+  // Try to find CLAUDE.md in common locations
+  const claudeMdPaths = [
+    path.join(process.cwd(), 'CLAUDE.md'),
+    path.join(os.homedir(), 'CLAUDE.md'),
+    path.join(process.cwd(), '.claude', 'CLAUDE.md'),
+    path.join(os.homedir(), '.claude', 'CLAUDE.md')
+  ];
+
+  let claudeMdPath = claudeMdPaths.find(p => fs.existsSync(p));
+  
+  // If not found, create it in the current directory
+  if (!claudeMdPath) {
+    claudeMdPath = path.join(process.cwd(), 'CLAUDE.md');
+  }
+
+  try {
+    let existingContent = '';
+    if (fs.existsSync(claudeMdPath)) {
+      existingContent = fs.readFileSync(claudeMdPath, 'utf8');
+      
+      // Check if instructions already exist
+      if (existingContent.includes('Claude Recall Memory Instructions')) {
+        console.log('📝 CLAUDE.md already contains Claude Recall instructions');
+      } else {
+        // Append instructions
+        fs.writeFileSync(claudeMdPath, existingContent + '\n' + claudeMdInstructions);
+        console.log(`📝 Updated ${claudeMdPath} with memory instructions`);
+      }
+    } else {
+      // Create new file
+      fs.writeFileSync(claudeMdPath, claudeMdInstructions);
+      console.log(`📝 Created ${claudeMdPath} with memory instructions`);
+    }
+  } catch (err) {
+    console.log('⚠️  Could not update CLAUDE.md:', err.message);
+    console.log('   Please add the memory instructions manually to your CLAUDE.md file');
+  }
+
   console.log('\n📝 Next steps:');
   console.log('   1. Restart Claude Code if it\'s currently running');
   console.log('   2. Claude Recall will start automatically when you launch Claude Code');