claude-recall 0.2.0

package/dist/memory/storage.js

@@ -0,0 +1,274 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryStorage = void 0;
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class MemoryStorage {
+    constructor(dbPath) {
+        this.db = new better_sqlite3_1.default(dbPath);
+        this.initialize();
+    }
+    initialize() {
+        // Check if the database is already initialized
+        try {
+            const tableExists = this.db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='memories'").get();
+            if (tableExists) {
+                // Database is already initialized, skip schema execution
+                return;
+            }
+        }
+        catch (error) {
+            // If checking fails, proceed with initialization
+        }
+        // Initialize the database schema
+        try {
+            const schemaPath = path.join(__dirname, 'schema.sql');
+            const schema = fs.readFileSync(schemaPath, 'utf-8');
+            this.db.exec(schema);
+        }
+        catch (error) {
+            // Log error but don't throw - database might already be initialized
+            console.error('Error initializing database schema:', error);
+            // Verify that the memories table exists
+            const tableExists = this.db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='memories'").get();
+            if (!tableExists) {
+                // Re-throw the error if the table doesn't exist
+                throw new Error(`Failed to initialize database: ${error}`);
+            }
+        }
+    }
+    save(memory) {
+        const stmt = this.db.prepare(`
+      INSERT OR REPLACE INTO memories 
+      (key, value, type, project_id, file_path, timestamp, relevance_score, access_count, 
+       preference_key, is_active, superseded_by, superseded_at, confidence_score)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        stmt.run(memory.key, JSON.stringify(memory.value), memory.type, memory.project_id || null, memory.file_path || null, memory.timestamp || Date.now(), memory.relevance_score || 1.0, memory.access_count || 0, memory.preference_key || null, memory.is_active !== undefined ? (memory.is_active ? 1 : 0) : 1, memory.superseded_by || null, memory.superseded_at || null, memory.confidence_score || null);
+    }
+    retrieve(key) {
+        const stmt = this.db.prepare('SELECT * FROM memories WHERE key = ?');
+        const row = stmt.get(key);
+        if (row) {
+            this.updateAccessCount(key);
+            // Fetch updated row after incrementing access count
+            const updatedRow = stmt.get(key);
+            return this.rowToMemory(updatedRow);
+        }
+        return null;
+    }
+    updateAccessCount(key) {
+        const stmt = this.db.prepare(`
+      UPDATE memories 
+      SET access_count = access_count + 1, 
+          last_accessed = ? 
+      WHERE key = ?
+    `);
+        stmt.run(Date.now(), key);
+    }
+    rowToMemory(row) {
+        return {
+            id: row.id,
+            key: row.key,
+            value: JSON.parse(row.value),
+            type: row.type,
+            project_id: row.project_id,
+            file_path: row.file_path,
+            timestamp: row.timestamp,
+            access_count: row.access_count,
+            last_accessed: row.last_accessed,
+            relevance_score: row.relevance_score,
+            preference_key: row.preference_key,
+            is_active: row.is_active === 1,
+            superseded_by: row.superseded_by,
+            superseded_at: row.superseded_at,
+            confidence_score: row.confidence_score
+        };
+    }
+    searchByContext(context) {
+        let query = 'SELECT * FROM memories WHERE 1=1';
+        const params = [];
+        if (context.project_id) {
+            query += ' AND project_id = ?';
+            params.push(context.project_id);
+        }
+        if (context.file_path) {
+            query += ' AND file_path = ?';
+            params.push(context.file_path);
+        }
+        if (context.type) {
+            query += ' AND type = ?';
+            params.push(context.type);
+        }
+        // Add keyword search in value field
+        if (context.keywords && context.keywords.length > 0) {
+            const keywordConditions = context.keywords.map(() => 'value LIKE ?').join(' OR ');
+            query += ` AND (${keywordConditions})`;
+            // Add parameters for each keyword
+            for (const keyword of context.keywords) {
+                params.push(`%${keyword}%`);
+            }
+        }
+        // Order by type priority and relevance
+        query += ` ORDER BY 
+      CASE type 
+        WHEN 'project-knowledge' THEN 1 
+        WHEN 'preference' THEN 2 
+        WHEN 'tool-use' THEN 3 
+        ELSE 4 
+      END,
+      relevance_score DESC,
+      timestamp DESC`;
+        const stmt = this.db.prepare(query);
+        const rows = stmt.all(...params);
+        return rows.map(row => this.rowToMemory(row));
+    }
+    search(query) {
+        const stmt = this.db.prepare(`
+      SELECT * FROM memories 
+      WHERE key LIKE ? OR value LIKE ?
+      ORDER BY relevance_score DESC
+      LIMIT 20
+    `);
+        const searchPattern = `%${query}%`;
+        const rows = stmt.all(searchPattern, searchPattern);
+        return rows.map(row => this.rowToMemory(row));
+    }
+    getStats() {
+        const totalStmt = this.db.prepare('SELECT COUNT(*) as count FROM memories');
+        const total = totalStmt.get().count;
+        const byTypeStmt = this.db.prepare('SELECT type, COUNT(*) as count FROM memories GROUP BY type');
+        const byTypeRows = byTypeStmt.all();
+        const byType = {};
+        for (const row of byTypeRows) {
+            byType[row.type] = row.count;
+        }
+        return { total, byType };
+    }
+    /**
+     * Update a memory record by key
+     */
+    update(key, updates) {
+        const fields = Object.keys(updates).filter(k => k !== 'key'); // Don't update key
+        const setClause = fields.map(field => `${field} = ?`).join(', ');
+        const values = fields.map(field => {
+            const value = updates[field];
+            if (field === 'value') {
+                return JSON.stringify(value);
+            }
+            else if (field === 'is_active') {
+                return value ? 1 : 0;
+            }
+            else {
+                return value;
+            }
+        });
+        const stmt = this.db.prepare(`UPDATE memories SET ${setClause} WHERE key = ?`);
+        stmt.run(...values, key);
+    }
+    /**
+     * Get preferences by preference key
+     */
+    getByPreferenceKey(preferenceKey, projectId) {
+        let query = 'SELECT * FROM memories WHERE preference_key = ? AND type = ?';
+        const params = [preferenceKey, 'preference'];
+        if (projectId) {
+            query += ' AND project_id = ?';
+            params.push(projectId);
+        }
+        query += ' ORDER BY timestamp DESC';
+        const stmt = this.db.prepare(query);
+        const rows = stmt.all(...params);
+        return rows.map(row => this.rowToMemory(row));
+    }
+    /**
+     * Get preferences by context with active filtering
+     */
+    getPreferencesByContext(context) {
+        let query = 'SELECT * FROM memories WHERE type = ?';
+        const params = ['preference'];
+        if (context.project_id) {
+            query += ' AND project_id = ?';
+            params.push(context.project_id);
+        }
+        if (context.file_path) {
+            query += ' AND file_path = ?';
+            params.push(context.file_path);
+        }
+        // Order by preference key, then by timestamp desc to get latest per key
+        query += ' ORDER BY preference_key, timestamp DESC';
+        const stmt = this.db.prepare(query);
+        const rows = stmt.all(...params);
+        return rows.map(row => this.rowToMemory(row));
+    }
+    /**
+     * Mark a memory as superseded
+     */
+    markSuperseded(key, supersededBy) {
+        const stmt = this.db.prepare(`
+      UPDATE memories 
+      SET is_active = 0, superseded_by = ?, superseded_at = ?
+      WHERE key = ?
+    `);
+        stmt.run(supersededBy, Date.now(), key);
+    }
+    /**
+     * Get active preferences only
+     */
+    getActivePreferences(projectId) {
+        let query = 'SELECT * FROM memories WHERE type = ? AND is_active = 1';
+        const params = ['preference'];
+        if (projectId) {
+            query += ' AND project_id = ?';
+            params.push(projectId);
+        }
+        query += ' ORDER BY preference_key, timestamp DESC';
+        const stmt = this.db.prepare(query);
+        const rows = stmt.all(...params);
+        return rows.map(row => this.rowToMemory(row));
+    }
+    getDatabase() {
+        return this.db;
+    }
+    close() {
+        this.db.close();
+    }
+}
+exports.MemoryStorage = MemoryStorage;

package/dist/services/action-pattern-detector.js

@@ -0,0 +1,251 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActionPatternDetector = void 0;
+const logging_1 = require("./logging");
+/**
+ * ActionPatternDetector - Detects patterns in Claude Code's behavior
+ *
+ * Instead of analyzing user input with API calls, this service detects
+ * patterns in how Claude Code acts, allowing us to learn preferences
+ * from behavior rather than redundant text analysis.
+ */
+class ActionPatternDetector {
+    constructor() {
+        this.logger = logging_1.LoggingService.getInstance();
+        this.actionHistory = [];
+        // Pattern detection thresholds
+        this.PATTERN_THRESHOLD = 2; // How many times before we consider it a pattern
+        this.RECENT_WINDOW = 10; // Number of recent actions to consider
+        this.logger.info('ActionPatternDetector', 'Initialized behavioral pattern detector');
+    }
+    /**
+     * Detect patterns from tool usage
+     */
+    detectToolAction(toolName, toolInput) {
+        const timestamp = Date.now();
+        // Detect file creation patterns
+        if (toolName === 'Write' || toolName === 'MultiEdit') {
+            const filePath = toolInput.file_path || toolInput.filePath;
+            if (filePath) {
+                const action = this.detectFileCreationPattern(filePath, timestamp);
+                if (action) {
+                    this.recordAction(action);
+                    return action;
+                }
+            }
+        }
+        // Detect specific tool preferences (e.g., always using axios for HTTP)
+        if (toolName === 'Write' && toolInput.content) {
+            const toolPreference = this.detectToolPreference(toolInput.content, timestamp);
+            if (toolPreference) {
+                this.recordAction(toolPreference);
+                return toolPreference;
+            }
+        }
+        return null;
+    }
+    /**
+     * Detect patterns from Claude's response content
+     */
+    detectResponsePattern(responseContent) {
+        const timestamp = Date.now();
+        // Detect when Claude mentions preferences
+        const preferenceMentions = [
+            /I'll use (\w+) for (\w+)/gi,
+            /I'm using (\w+) instead of (\w+)/gi,
+            /I'll save (?:the )?(\w+) in ([\w\-\/]+)/gi,
+            /I'll create (?:the )?(\w+) in ([\w\-\/]+)/gi,
+            /Using (\w+) as (?:the )?(\w+)/gi
+        ];
+        for (const pattern of preferenceMentions) {
+            const match = pattern.exec(responseContent);
+            if (match) {
+                const action = {
+                    type: 'preference_mention',
+                    pattern: match[0],
+                    context: {
+                        content: responseContent.substring(Math.max(0, match.index - 50), match.index + match[0].length + 50),
+                        timestamp
+                    },
+                    preference: {
+                        key: this.inferPreferenceKey(match[2] || 'tool'),
+                        value: match[1],
+                        confidence: 0.8,
+                        raw: match[0],
+                        isOverride: false,
+                        overrideSignals: []
+                    }
+                };
+                this.recordAction(action);
+                return action;
+            }
+        }
+        return null;
+    }
+    /**
+     * Get learned patterns based on repeated behavior
+     */
+    getLearnedPatterns() {
+        const preferences = [];
+        const recentActions = this.actionHistory.slice(-this.RECENT_WINDOW);
+        // Group actions by type and pattern
+        const patternGroups = new Map();
+        for (const action of recentActions) {
+            if (action.preference) {
+                const key = `${action.preference.key}:${action.preference.value}`;
+                if (!patternGroups.has(key)) {
+                    patternGroups.set(key, []);
+                }
+                patternGroups.get(key).push(action);
+            }
+        }
+        // Convert repeated patterns to preferences
+        for (const [key, actions] of patternGroups) {
+            if (actions.length >= this.PATTERN_THRESHOLD) {
+                const latestAction = actions[actions.length - 1];
+                if (latestAction.preference) {
+                    preferences.push({
+                        ...latestAction.preference,
+                        confidence: Math.min(0.9, 0.5 + (actions.length * 0.1)), // Increase confidence with repetition
+                        raw: `Behavioral pattern: ${latestAction.preference.raw} (observed ${actions.length} times)`
+                    });
+                }
+            }
+        }
+        return preferences;
+    }
+    detectFileCreationPattern(filePath, timestamp) {
+        const pathParts = filePath.split('/');
+        // Detect test file patterns
+        if (filePath.includes('test') || filePath.includes('spec')) {
+            const testDir = this.findTestDirectory(pathParts);
+            if (testDir) {
+                return {
+                    type: 'file_creation',
+                    pattern: `test_files_in_${testDir}`,
+                    context: { filePath, directory: testDir, timestamp },
+                    preference: {
+                        key: 'test_location',
+                        value: testDir,
+                        confidence: 0.85,
+                        raw: `Tests created in ${testDir}`,
+                        isOverride: false,
+                        overrideSignals: []
+                    }
+                };
+            }
+        }
+        // Detect config file patterns
+        if (pathParts.includes('configs') || pathParts.includes('config')) {
+            const configDir = pathParts.includes('configs') ? 'configs' : 'config';
+            return {
+                type: 'file_creation',
+                pattern: `config_files_in_${configDir}`,
+                context: { filePath, directory: configDir, timestamp },
+                preference: {
+                    key: 'config_location',
+                    value: configDir,
+                    confidence: 0.8,
+                    raw: `Config files saved in ${configDir}`,
+                    isOverride: false,
+                    overrideSignals: []
+                }
+            };
+        }
+        return null;
+    }
+    detectToolPreference(content, timestamp) {
+        // Detect HTTP client preferences
+        if (content.includes('axios') && (content.includes('http') || content.includes('request'))) {
+            return {
+                type: 'tool_preference',
+                pattern: 'axios_for_http',
+                context: { content: content.substring(0, 200), timestamp },
+                preference: {
+                    key: 'http_client',
+                    value: 'axios',
+                    confidence: 0.75,
+                    raw: 'Using axios for HTTP requests',
+                    isOverride: false,
+                    overrideSignals: []
+                }
+            };
+        }
+        // Detect indentation preferences
+        if (content.includes('\t')) {
+            return {
+                type: 'pattern_usage',
+                pattern: 'tabs_indentation',
+                context: { content: 'File uses tab indentation', timestamp },
+                preference: {
+                    key: 'indentation',
+                    value: 'tabs',
+                    confidence: 0.7,
+                    raw: 'Using tabs for indentation',
+                    isOverride: false,
+                    overrideSignals: []
+                }
+            };
+        }
+        else if (content.match(/^  /m)) {
+            return {
+                type: 'pattern_usage',
+                pattern: '2_space_indentation',
+                context: { content: 'File uses 2-space indentation', timestamp },
+                preference: {
+                    key: 'indentation',
+                    value: '2_spaces',
+                    confidence: 0.7,
+                    raw: 'Using 2 spaces for indentation',
+                    isOverride: false,
+                    overrideSignals: []
+                }
+            };
+        }
+        return null;
+    }
+    findTestDirectory(pathParts) {
+        // Look for test-related directories
+        for (let i = 0; i < pathParts.length; i++) {
+            const part = pathParts[i];
+            if (part.includes('test') || part.includes('spec')) {
+                // Check if it's a custom test directory
+                if (part.startsWith('tests-') || part.startsWith('test-')) {
+                    return part;
+                }
+                // Otherwise return the standard test directory
+                return part;
+            }
+        }
+        return null;
+    }
+    inferPreferenceKey(context) {
+        const normalized = context.toLowerCase();
+        if (normalized.includes('indent'))
+            return 'indentation';
+        if (normalized.includes('http') || normalized.includes('request'))
+            return 'http_client';
+        if (normalized.includes('test'))
+            return 'test_framework';
+        if (normalized.includes('build'))
+            return 'build_tool';
+        if (normalized.includes('ui') || normalized.includes('frontend'))
+            return 'ui_framework';
+        if (normalized.includes('database') || normalized.includes('db'))
+            return 'database';
+        return context.toLowerCase().replace(/\s+/g, '_');
+    }
+    recordAction(action) {
+        this.actionHistory.push(action);
+        // Keep history size manageable
+        if (this.actionHistory.length > 100) {
+            this.actionHistory = this.actionHistory.slice(-50);
+        }
+        this.logger.debug('ActionPatternDetector', 'Recorded action', {
+            type: action.type,
+            pattern: action.pattern,
+            preference: action.preference
+        });
+    }
+}
+exports.ActionPatternDetector = ActionPatternDetector;