claude-recall 0.2.19 → 0.3.1

package/README.md

@@ -1,8 +1,6 @@
 # Claude Recall
 
-An MCP server that gives Claude persistent memory across conversations, with automatic capture and retrieval of relevant context.
-
-## The Story
+An MCP server that gives Claude persistent memory across conversations.
 
 Every time you start a new conversation with Claude, you're starting from scratch. Claude doesn't remember your preferences, your project context, or the decisions you've made together. Until now.
 
@@ -20,37 +18,56 @@ Every time you start a new conversation with Claude, you're starting from scratc
 - **Categorized storage** - Organizes memories by type (preferences, project knowledge, corrections)
 - **Priority-based** - More important or frequently used memories are prioritized
 
-### 🔒 Privacy First
+### ⚡ Advanced Features (v0.3.0+)
+- **MCP Resources & Prompts** - Expose memories as subscribable resources and prompt templates
+- **Automatic preference detection** - Detects when you express preferences and suggests analysis
+- **Proactive memory injection** - Relevant memories automatically injected before tool execution
+- **Context-aware tool descriptions** - Tools show relevant preferences in their descriptions
+- **Duplicate detection** - Recognizes when you ask the same question multiple times
+- **Memory usage tracking** - Learns which memories are useful and adjusts relevance scores
+
+### 🔒 Privacy & Security First
 - **100% Local** - All memories stored locally in SQLite (~/.claude-recall/)
 - **No cloud sync** - Your data never leaves your machine
 - **You own your data** - Export, view, or delete memories at any time
 - **Zero telemetry** - No data collection or phone-home behavior
+- **Security Audited** - Reviewed by Claude Code using `/security-review` command: No exposed secrets, SQL injection protection, 0 npm vulnerabilities
 
 ## Quick Start
 
-### 1. Install via npm
+### Option 1: Local Project Installation (Recommended)
+For automatic CLAUDE.md integration in your project:
 ```bash
-npm install -g claude-recall@latest
+cd your-project
+npm install claude-recall
 ```
+This automatically adds Claude Recall instructions to your project's CLAUDE.md file.
 
-### 2. Verify Installation
+### Option 2: Global Installation
+For CLI access from anywhere:
 ```bash
-claude-recall --version  # Should show 0.2.19 or higher
+npm install -g claude-recall@latest
 ```
 
-### 3. Start Using Claude
-That's it! Claude Recall works automatically in the background. Your memories are captured and retrieved seamlessly.
+**Note:** You can have both installations. For global installations, manually add this to your `~/.claude/CLAUDE.md`:
+```markdown
+## Claude Recall Integration
+- IMPORTANT: Always search memories before creating new files or making decisions
+- Use `mcp__claude-recall__search_memory` to check for stored preferences and project knowledge
+- Memories include: coding preferences, file locations, project patterns, and team conventions
+```
+
+After installation, verify with: `claude-recall --version` (or `npx claude-recall --version` for local installs)
 
 ## How It Works
 
-### Automatic Mode (Default)
 When you chat with Claude, the system:
-1. **Captures** your preferences and important information automatically
-2. **Stores** them in a local SQLite database
+1. **Captures** your preferences and important information
+2. **Stores** them locally in SQLite (`~/.claude-recall/claude-recall.db`)
 3. **Retrieves** relevant memories when you start new conversations
 4. **Injects** context so Claude remembers your preferences
 
-### Example Workflow
+### Example
 ```
 You: "I prefer TypeScript with strict mode for all my projects"
 [Claude Recall automatically stores this preference]
@@ -103,19 +120,12 @@ claude-recall import memories.json
 
 # Clear memories (use with caution)
 claude-recall clear --type preferences  # Clear only preferences
-claude-recall clear --all               # Clear everything
+claude-recall clear --force               # Clear everything
 
 # Test memory capture (for debugging)
 claude-recall capture user-prompt '{"content":"your message here"}'
 ```
 
-## Privacy & Storage
-
-- **Local storage only** - All memories stored in `~/.claude-recall/claude-recall.db`
-- **No cloud sync** - Your data never leaves your machine
-- **User control** - View, export, or delete memories at any time
-- **Gitignored by default** - Memory database excluded from version control
-
 ## Memory Management
 
 Claude Recall automatically manages memory to prevent unlimited database growth, with user notifications:
@@ -164,12 +174,12 @@ export CLAUDE_RECALL_RETAIN_TOOL_USE=2000      # Keep more tool usage history
 ## Troubleshooting
 
 ### Memories not being retrieved?
-1. Check if claude-recall is installed: `claude-recall --version`
-2. Verify memories exist: `claude-recall stats`
-3. Search manually to test: `claude-recall search "your topic"`
+1. Verify memories exist: `claude-recall stats`
+2. Search manually to test: `claude-recall search "your topic"`
 
 ### Installation shows old version?
-Clear npm cache and reinstall:
+
+#### For global installation (CLI usage):
 ```bash
 npm cache clean --force
 npm uninstall -g claude-recall
@@ -177,33 +187,27 @@ npm install -g claude-recall@latest
 claude-recall --version
 ```
 
+#### For local installation (CLAUDE.md integration):
+```bash
+npm cache clean --force
+npm uninstall claude-recall
+npm install claude-recall@latest
+npx claude-recall --version
+```
+
 ### Performance issues?
 - Check database size: `ls -lh ~/.claude-recall/claude-recall.db`
 - Clear old memories: `claude-recall clear --days 30`
 - The system uses SQLite with optimized indexes for fast retrieval
 
-### Diagnostic Commands for Support
-If you need help, run these commands and share the output:
+### Need Help?
+Run this diagnostic script and share the output:
 ```bash
-# Check Installation
 claude-recall --version
-which claude-recall
-npm list -g claude-recall
-
-# Check Database
-ls -la ~/.claude-recall/
-ls -lh ~/.claude-recall/claude-recall.db
-
-# Check System Status
 claude-recall stats
-
-# Test Basic Functionality
-claude-recall search "test"
-
-# Environment Info
+ls -lh ~/.claude-recall/claude-recall.db
 node --version
 npm --version
-echo "OS: $(uname -s)"
 ```
 
 ## Best Practices
@@ -213,20 +217,6 @@ echo "OS: $(uname -s)"
 3. **Review periodically** - Use `claude-recall stats` to see what's being remembered
 4. **Export important memories** - Backup critical preferences with `claude-recall export`
 
-## Contributing
-
-We welcome contributions! Claude Recall is designed to be hackable:
-
-- **Small Codebase**: Intentionally kept under 3000 lines
-- **Clean Architecture**: Easy to understand and modify
-- **Well Tested**: Comprehensive test coverage
-
-## Support
-
-For issues or questions:
-- GitHub: https://github.com/raoulbia-ai/claude-recall
-- npm: https://www.npmjs.com/package/claude-recall
-
 ## Acknowledgements
 
 This project makes extensive use of the excellent work from:
@@ -236,12 +226,12 @@ This project makes extensive use of the excellent work from:
 
 MIT - Use it, modify it, make it yours.
 
-## The Future
+## Disclaimer
 
-Claude Recall is part of a larger vision where AI assistants truly understand and remember their users. By building on open protocols and local-first principles, we're creating a future where your AI tools work together seamlessly, with memory and context that persists across sessions, projects, and time.
+This software is provided "as-is", without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose, and noninfringement. In no event shall the authors or copyright holders be liable for any claim, damages or other liability, whether in an action of contract, tort or otherwise, arising from, out of or in connection with the software or the use or other dealings in the software.
 
-Start building with memory. Start building with Claude Recall.
+This project is provided for free to the community. While every effort has been made to ensure quality and security (including automated security reviews), users should review and test the code according to their own requirements before use in production environments.
 
 ---
 
-Built with ❤️ by a developer who was tired of repeating himself to Claude.
+Built with ❤️ by a developer who was tired of repeating himself to Claude.

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

@@ -39,6 +39,7 @@ const config_1 = require("../services/config");
 const logging_1 = require("../services/logging");
 const commander_1 = require("commander");
 const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
 const pattern_service_1 = require("../services/pattern-service");
 const migrate_1 = require("./commands/migrate");
 const server_1 = require("../mcp/server");
@@ -255,12 +256,22 @@ class ClaudeRecallCLI {
         return str.substring(0, maxLength) + '...';
     }
 }
+// Get version from package.json
+function getVersion() {
+    try {
+        const packageJson = JSON.parse(fs.readFileSync(path.join(__dirname, '../../package.json'), 'utf-8'));
+        return packageJson.version;
+    }
+    catch (error) {
+        return '0.3.0'; // Fallback
+    }
+}
 // Setup CLI commands
 async function main() {
     program
         .name('claude-recall')
         .description('Memory-enhanced Claude Code via MCP')
-        .version('0.2.19')
+        .version(getVersion())
         .option('--verbose', 'Enable verbose logging')
         .option('--config <path>', 'Path to custom config file');
     // MCP command

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

@@ -38,6 +38,8 @@ 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 keyword_extractor_1 = require("../services/keyword-extractor");
+const memory_usage_tracker_1 = require("../services/memory-usage-tracker");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 class MemoryCaptureMiddleware {
@@ -48,6 +50,8 @@ class MemoryCaptureMiddleware {
         this.actionDetector = new action_pattern_detector_1.ActionPatternDetector();
         this.memoryService = memory_1.MemoryService.getInstance();
         this.logger = logging_1.LoggingService.getInstance();
+        this.keywordExtractor = keyword_extractor_1.KeywordExtractor.getInstance();
+        this.usageTracker = memory_usage_tracker_1.MemoryUsageTracker.getInstance();
         this.loadConfig();
     }
     loadConfig() {
@@ -310,5 +314,137 @@ class MemoryCaptureMiddleware {
         this.loadConfig();
         this.logger.info('MemoryCaptureMiddleware', 'Configuration reloaded');
     }
+    /**
+     * Phase 3B: Proactively retrieve and inject relevant memories
+     * Call this BEFORE executing tool to inject memory context
+     */
+    async enhanceRequestWithMemories(request) {
+        try {
+            // Only enhance tool calls
+            if (request.method !== 'tools/call') {
+                return request;
+            }
+            // Don't enhance memory-related tools to avoid loops
+            if (request.params?.name?.includes('memory')) {
+                return request;
+            }
+            // Extract keywords from tool arguments
+            const toolArgs = request.params?.arguments || {};
+            const searchQuery = this.keywordExtractor.extractAsQuery(toolArgs);
+            if (!searchQuery) {
+                return request; // No keywords found
+            }
+            // Search for relevant memories
+            const memories = this.memoryService.search(searchQuery);
+            // Filter to top 3 most relevant
+            const topMemories = memories.slice(0, 3);
+            if (topMemories.length === 0) {
+                return request; // No relevant memories
+            }
+            // Format memories as context
+            const memoryContext = this.formatMemoriesForContext(topMemories);
+            // Inject into request
+            // Store in a special field that tools can access
+            if (!request.params) {
+                request.params = {};
+            }
+            request.params._memoryContext = memoryContext;
+            request.params._injectedMemories = topMemories.map(m => ({
+                key: m.key,
+                type: m.type,
+                confidence: this.extractConfidence(m)
+            }));
+            // Phase 3C: Track memory injections
+            const sessionId = request.params?.sessionId || 'unknown';
+            for (const memory of topMemories) {
+                this.usageTracker.recordInjection(memory.key, request.params.name, sessionId);
+            }
+            this.logger.info('MemoryCaptureMiddleware', 'Injected memories into request', {
+                toolName: request.params.name,
+                memoryCount: topMemories.length,
+                keywords: searchQuery
+            });
+            return request;
+        }
+        catch (error) {
+            this.logger.error('MemoryCaptureMiddleware', 'Failed to enhance request', error);
+            return request; // Return original on error
+        }
+    }
+    /**
+     * Format memories as readable context string
+     */
+    formatMemoriesForContext(memories) {
+        const lines = ['📝 Relevant Memories:'];
+        for (const memory of memories) {
+            const formatted = this.formatSingleMemoryForContext(memory);
+            if (formatted) {
+                lines.push(`- ${formatted}`);
+            }
+        }
+        return lines.join('\n');
+    }
+    /**
+     * Format a single memory for context injection
+     */
+    formatSingleMemoryForContext(memory) {
+        try {
+            const value = memory.value;
+            // Handle different value formats
+            if (typeof value === 'string') {
+                return value;
+            }
+            if (typeof value === 'object' && value !== null) {
+                // Extract meaningful information
+                if (value.preference)
+                    return value.preference;
+                if (value.value) {
+                    const val = value.value;
+                    if (typeof val === 'string')
+                        return val;
+                    if (typeof val === 'object' && val.framework) {
+                        return `Use ${val.framework}`;
+                    }
+                }
+                if (value.content)
+                    return value.content;
+                if (value.message)
+                    return value.message;
+                if (value.raw)
+                    return value.raw;
+                // Fallback: extract key info from memory key
+                return this.extractKeyInfo(memory.key, value);
+            }
+            return null;
+        }
+        catch (error) {
+            return null;
+        }
+    }
+    /**
+     * Extract key information from memory
+     */
+    extractKeyInfo(key, value) {
+        const cleanKey = key
+            .replace(/auto_|pref_/g, '')
+            .replace(/_\d+$/g, '')
+            .replace(/_/g, ' ');
+        if (value.framework)
+            return `${cleanKey}: ${value.framework}`;
+        if (value.location)
+            return `${cleanKey}: ${value.location}`;
+        if (value.style)
+            return `${cleanKey}: ${value.style}`;
+        return cleanKey;
+    }
+    /**
+     * Extract confidence from memory value
+     */
+    extractConfidence(memory) {
+        if (typeof memory.value === 'object' && memory.value !== null) {
+            return memory.value.confidence || 0.5;
+        }
+        return 0.5;
+    }
 }
 exports.MemoryCaptureMiddleware = MemoryCaptureMiddleware;