mcp-memory-keeper 0.10.0

package/dist/repositories/FileRepository.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileRepository = void 0;
+const BaseRepository_js_1 = require("./BaseRepository.js");
+class FileRepository extends BaseRepository_js_1.BaseRepository {
+    cache(sessionId, input) {
+        const id = this.generateId();
+        const size = this.calculateSize(input.content);
+        const timestamp = this.getCurrentTimestamp();
+        const stmt = this.db.prepare(`
+      INSERT OR REPLACE INTO file_cache 
+      (id, session_id, file_path, content, hash, size, last_read, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        stmt.run(id, sessionId, input.file_path, input.content, input.hash || null, size, timestamp, timestamp);
+        return this.getById(id);
+    }
+    getById(id) {
+        const stmt = this.db.prepare('SELECT * FROM file_cache WHERE id = ?');
+        return stmt.get(id);
+    }
+    getBySessionId(sessionId) {
+        const stmt = this.db.prepare(`
+      SELECT * FROM file_cache 
+      WHERE session_id = ? 
+      ORDER BY last_read DESC
+    `);
+        return stmt.all(sessionId);
+    }
+    getByFilePath(sessionId, filePath) {
+        const stmt = this.db.prepare(`
+      SELECT * FROM file_cache 
+      WHERE session_id = ? AND file_path = ?
+    `);
+        return stmt.get(sessionId, filePath);
+    }
+    hasChanged(sessionId, filePath, currentContent) {
+        const cached = this.getByFilePath(sessionId, filePath);
+        if (!cached) {
+            return true; // No cached version, so it's "changed"
+        }
+        return cached.content !== currentContent;
+    }
+    updateContent(sessionId, filePath, content, hash) {
+        const size = this.calculateSize(content);
+        const timestamp = this.getCurrentTimestamp();
+        const stmt = this.db.prepare(`
+      UPDATE file_cache 
+      SET content = ?, hash = ?, size = ?, last_read = ?, updated_at = ?
+      WHERE session_id = ? AND file_path = ?
+    `);
+        stmt.run(content, hash || null, size, timestamp, timestamp, sessionId, filePath);
+    }
+    delete(id) {
+        const stmt = this.db.prepare('DELETE FROM file_cache WHERE id = ?');
+        stmt.run(id);
+    }
+    deleteBySessionId(sessionId) {
+        const stmt = this.db.prepare('DELETE FROM file_cache WHERE session_id = ?');
+        stmt.run(sessionId);
+    }
+    deleteByFilePath(sessionId, filePath) {
+        const stmt = this.db.prepare('DELETE FROM file_cache WHERE session_id = ? AND file_path = ?');
+        stmt.run(sessionId, filePath);
+    }
+    copyBetweenSessions(fromSessionId, toSessionId) {
+        const stmt = this.db.prepare(`
+      INSERT INTO file_cache (id, session_id, file_path, content, hash, size, last_read, updated_at)
+      SELECT ?, ?, file_path, content, hash, size, last_read, ?
+      FROM file_cache
+      WHERE session_id = ?
+    `);
+        const files = this.getBySessionId(fromSessionId);
+        let copied = 0;
+        for (const _file of files) {
+            stmt.run(this.generateId(), toSessionId, this.getCurrentTimestamp(), fromSessionId);
+            copied++;
+        }
+        return copied;
+    }
+    getStatsBySession(sessionId) {
+        const stmt = this.db.prepare(`
+      SELECT COUNT(*) as count, SUM(size) as totalSize 
+      FROM file_cache 
+      WHERE session_id = ?
+    `);
+        const result = stmt.get(sessionId);
+        return {
+            count: result.count || 0,
+            totalSize: result.totalSize || 0,
+        };
+    }
+    cleanup(olderThanDays) {
+        const cutoffDate = new Date();
+        cutoffDate.setDate(cutoffDate.getDate() - olderThanDays);
+        const stmt = this.db.prepare(`
+      DELETE FROM file_cache 
+      WHERE last_read < ?
+    `);
+        const result = stmt.run(cutoffDate.toISOString());
+        return result.changes;
+    }
+}
+exports.FileRepository = FileRepository;

package/dist/repositories/RepositoryManager.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RepositoryManager = void 0;
+const SessionRepository_js_1 = require("./SessionRepository.js");
+const ContextRepository_js_1 = require("./ContextRepository.js");
+const FileRepository_js_1 = require("./FileRepository.js");
+const CheckpointRepository_js_1 = require("./CheckpointRepository.js");
+const WatcherRepository_js_1 = require("./WatcherRepository.js");
+class RepositoryManager {
+    dbManager;
+    sessions;
+    contexts;
+    files;
+    checkpoints;
+    watchers;
+    constructor(dbManager) {
+        this.dbManager = dbManager;
+        // Initialize all repositories
+        this.sessions = new SessionRepository_js_1.SessionRepository(dbManager);
+        this.contexts = new ContextRepository_js_1.ContextRepository(dbManager);
+        this.files = new FileRepository_js_1.FileRepository(dbManager);
+        this.checkpoints = new CheckpointRepository_js_1.CheckpointRepository(dbManager);
+        this.watchers = new WatcherRepository_js_1.WatcherRepository(dbManager);
+    }
+    /**
+     * Get the underlying database manager
+     */
+    getDatabaseManager() {
+        return this.dbManager;
+    }
+    /**
+     * Close all database connections
+     */
+    close() {
+        this.dbManager.close();
+    }
+    /**
+     * Get session statistics across all repositories
+     */
+    getSessionStats(sessionId) {
+        const contextStats = this.contexts.getStatsBySession(sessionId);
+        const fileStats = this.files.getStatsBySession(sessionId);
+        const checkpointStats = this.checkpoints.getStatsBySession(sessionId);
+        return {
+            session: this.sessions.getById(sessionId),
+            contexts: contextStats,
+            files: fileStats,
+            checkpoints: checkpointStats,
+            totalSize: contextStats.totalSize + fileStats.totalSize,
+        };
+    }
+    /**
+     * Clean up old data across all repositories
+     */
+    cleanup(olderThanDays) {
+        const filesDeleted = this.files.cleanup(olderThanDays);
+        return {
+            filesDeleted,
+        };
+    }
+}
+exports.RepositoryManager = RepositoryManager;

package/dist/repositories/SessionRepository.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionRepository = void 0;
+const BaseRepository_js_1 = require("./BaseRepository.js");
+class SessionRepository extends BaseRepository_js_1.BaseRepository {
+    create(input) {
+        const id = this.generateId();
+        const timestamp = this.getCurrentTimestamp();
+        const stmt = this.db.prepare(`
+      INSERT INTO sessions (id, name, description, branch, working_directory, parent_id, default_channel, created_at, updated_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        stmt.run(id, input.name || `Session ${timestamp}`, input.description || '', input.branch || null, input.working_directory || null, input.parent_id || null, input.defaultChannel || 'general', timestamp, timestamp);
+        return this.getById(id);
+    }
+    getById(id) {
+        const stmt = this.db.prepare('SELECT * FROM sessions WHERE id = ?');
+        return stmt.get(id);
+    }
+    getAll(limit = 50) {
+        const stmt = this.db.prepare('SELECT * FROM sessions ORDER BY created_at DESC LIMIT ?');
+        return stmt.all(limit);
+    }
+    getLatest() {
+        const stmt = this.db.prepare('SELECT * FROM sessions ORDER BY created_at DESC LIMIT 1');
+        return stmt.get();
+    }
+    update(id, updates) {
+        const setClause = Object.keys(updates)
+            .filter(key => key !== 'id' && key !== 'created_at')
+            .map(key => `${key} = ?`)
+            .join(', ');
+        if (setClause) {
+            const values = Object.keys(updates)
+                .filter(key => key !== 'id' && key !== 'created_at')
+                .map(key => updates[key]);
+            const stmt = this.db.prepare(`
+        UPDATE sessions 
+        SET ${setClause}, updated_at = CURRENT_TIMESTAMP 
+        WHERE id = ?
+      `);
+            stmt.run(...values, id);
+        }
+    }
+    delete(id) {
+        const stmt = this.db.prepare('DELETE FROM sessions WHERE id = ?');
+        stmt.run(id);
+    }
+    findByBranch(branch) {
+        const stmt = this.db.prepare('SELECT * FROM sessions WHERE branch = ? ORDER BY created_at DESC');
+        return stmt.all(branch);
+    }
+    findByWorkingDirectory(workingDirectory) {
+        const stmt = this.db.prepare('SELECT * FROM sessions WHERE working_directory = ? ORDER BY created_at DESC');
+        return stmt.all(workingDirectory);
+    }
+    getChildren(parentId) {
+        const stmt = this.db.prepare('SELECT * FROM sessions WHERE parent_id = ? ORDER BY created_at DESC');
+        return stmt.all(parentId);
+    }
+    getRecent(limit = 10) {
+        const stmt = this.db.prepare('SELECT * FROM sessions ORDER BY created_at DESC LIMIT ?');
+        return stmt.all(limit);
+    }
+}
+exports.SessionRepository = SessionRepository;

package/dist/repositories/WatcherRepository.js

@@ -0,0 +1,252 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WatcherRepository = void 0;
+const uuid_1 = require("uuid");
+const timestamps_1 = require("../utils/timestamps");
+class WatcherRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    createWatcher(params) {
+        const id = `watch_${(0, uuid_1.v4)().substring(0, 8)}`;
+        const now = new Date();
+        const ttlSeconds = params.ttl || 3600; // Default 1 hour
+        const expiresAt = new Date(now.getTime() + ttlSeconds * 1000);
+        // Get current max sequence number
+        const maxSeqQuery = params.sessionId
+            ? 'SELECT MAX(sequence_id) as max_seq FROM context_changes WHERE session_id = ?'
+            : 'SELECT MAX(sequence_id) as max_seq FROM context_changes';
+        const maxSeqResult = params.sessionId
+            ? this.db.getDatabase().prepare(maxSeqQuery).get(params.sessionId)
+            : this.db.getDatabase().prepare(maxSeqQuery).get();
+        const currentSequence = maxSeqResult?.max_seq || 0;
+        const stmt = this.db.getDatabase().prepare(`
+      INSERT INTO context_watchers (
+        id, session_id, filter_keys, filter_categories, filter_channels, filter_priorities,
+        last_sequence, created_at, expires_at, is_active
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        stmt.run(id, params.sessionId || null, JSON.stringify(params.filters?.keys || []), JSON.stringify(params.filters?.categories || []), JSON.stringify(params.filters?.channels || []), JSON.stringify(params.filters?.priorities || []), currentSequence, (0, timestamps_1.ensureSQLiteFormat)(now.toISOString()), (0, timestamps_1.ensureSQLiteFormat)(expiresAt.toISOString()), 1);
+        return {
+            id,
+            sessionId: params.sessionId,
+            filters: params.filters || {},
+            lastSequence: currentSequence,
+            createdAt: (0, timestamps_1.ensureSQLiteFormat)(now.toISOString()),
+            expiresAt: (0, timestamps_1.ensureSQLiteFormat)(expiresAt.toISOString()),
+            isActive: true,
+        };
+    }
+    getWatcher(watcherId) {
+        const watcher = this.db
+            .getDatabase()
+            .prepare(`
+      SELECT * FROM context_watchers WHERE id = ?
+    `)
+            .get(watcherId);
+        if (!watcher) {
+            return null;
+        }
+        return this.mapWatcherFromDb(watcher);
+    }
+    pollChanges(watcherId, limit = 100) {
+        const watcher = this.getWatcher(watcherId);
+        if (!watcher) {
+            return {
+                changes: [],
+                lastSequence: 0,
+                hasMore: false,
+                watcherStatus: 'deleted',
+            };
+        }
+        // Check if stopped
+        if (!watcher.isActive) {
+            return {
+                changes: [],
+                lastSequence: watcher.lastSequence,
+                hasMore: false,
+                watcherStatus: 'expired', // This is what the handler expects for stopped watchers
+            };
+        }
+        // Check if expired
+        const now = new Date();
+        const expiresAt = new Date(watcher.expiresAt);
+        if (now > expiresAt) {
+            // Mark as inactive if expired
+            this.db
+                .getDatabase()
+                .prepare('UPDATE context_watchers SET is_active = 0 WHERE id = ?')
+                .run(watcherId);
+            return {
+                changes: [],
+                lastSequence: watcher.lastSequence,
+                hasMore: false,
+                watcherStatus: 'expired',
+            };
+        }
+        // Build query for changes
+        let query = `
+      SELECT * FROM context_changes 
+      WHERE sequence_id > ?
+    `;
+        const params = [watcher.lastSequence];
+        // Apply session filter
+        if (watcher.sessionId) {
+            query += ' AND session_id = ?';
+            params.push(watcher.sessionId);
+        }
+        // Apply filters
+        const filterConditions = [];
+        // Key filters with wildcard support
+        if (watcher.filters.keys && watcher.filters.keys.length > 0) {
+            const keyConditions = watcher.filters.keys
+                .map((pattern) => {
+                const sqlPattern = pattern.replace(/\*/g, '%').replace(/\?/g, '_');
+                params.push(sqlPattern);
+                return 'key LIKE ?';
+            })
+                .join(' OR ');
+            filterConditions.push(`(${keyConditions})`);
+        }
+        // Category filters
+        if (watcher.filters.categories && watcher.filters.categories.length > 0) {
+            const placeholders = watcher.filters.categories.map(() => '?').join(',');
+            filterConditions.push(`category IN (${placeholders})`);
+            params.push(...watcher.filters.categories);
+        }
+        // Channel filters
+        if (watcher.filters.channels && watcher.filters.channels.length > 0) {
+            const placeholders = watcher.filters.channels.map(() => '?').join(',');
+            filterConditions.push(`channel IN (${placeholders})`);
+            params.push(...watcher.filters.channels);
+        }
+        // Priority filters
+        if (watcher.filters.priorities && watcher.filters.priorities.length > 0) {
+            const placeholders = watcher.filters.priorities.map(() => '?').join(',');
+            filterConditions.push(`priority IN (${placeholders})`);
+            params.push(...watcher.filters.priorities);
+        }
+        if (filterConditions.length > 0) {
+            query += ' AND (' + filterConditions.join(' AND ') + ')';
+        }
+        // Add privacy filter if watching across sessions
+        if (!watcher.sessionId) {
+            query += ` AND EXISTS (
+        SELECT 1 FROM context_items ci 
+        WHERE ci.id = context_changes.item_id 
+        AND ci.is_private = 0
+      )`;
+        }
+        query += ' ORDER BY sequence_id ASC LIMIT ?';
+        params.push(limit + 1); // Get one extra to check hasMore
+        const changes = this.db
+            .getDatabase()
+            .prepare(query)
+            .all(...params);
+        const hasMore = changes.length > limit;
+        if (hasMore) {
+            changes.pop(); // Remove the extra one
+        }
+        let maxSequence = watcher.lastSequence;
+        const mappedChanges = changes.map(change => {
+            maxSequence = Math.max(maxSequence, change.sequence_id);
+            return this.mapChangeFromDb(change);
+        });
+        // Update watcher's last sequence and extend expiration
+        // Always update on poll to extend expiration
+        const newExpiry = new Date(Date.now() + 30 * 60 * 1000); // Extend by 30 minutes
+        this.db
+            .getDatabase()
+            .prepare(`
+        UPDATE context_watchers 
+        SET last_sequence = ?, last_poll_at = ?, expires_at = ?
+        WHERE id = ?
+      `)
+            .run(maxSequence, (0, timestamps_1.ensureSQLiteFormat)(new Date().toISOString()), (0, timestamps_1.ensureSQLiteFormat)(newExpiry.toISOString()), watcherId);
+        return {
+            changes: mappedChanges,
+            lastSequence: maxSequence,
+            hasMore,
+            watcherStatus: 'active',
+        };
+    }
+    stopWatcher(watcherId) {
+        const result = this.db
+            .getDatabase()
+            .prepare(`
+      UPDATE context_watchers SET is_active = 0 WHERE id = ?
+    `)
+            .run(watcherId);
+        return result.changes > 0;
+    }
+    listWatchers(sessionId, includeExpired = false) {
+        let query = 'SELECT * FROM context_watchers';
+        const conditions = [];
+        const params = [];
+        if (sessionId) {
+            conditions.push('session_id = ?');
+            params.push(sessionId);
+        }
+        if (!includeExpired) {
+            conditions.push('is_active = 1');
+        }
+        if (conditions.length > 0) {
+            query += ' WHERE ' + conditions.join(' AND ');
+        }
+        query += ' ORDER BY created_at DESC';
+        const watchers = this.db
+            .getDatabase()
+            .prepare(query)
+            .all(...params);
+        return watchers.map(w => this.mapWatcherFromDb(w));
+    }
+    cleanupExpiredWatchers() {
+        const result = this.db
+            .getDatabase()
+            .prepare(`
+      DELETE FROM context_watchers 
+      WHERE expires_at < datetime('now') AND is_active = 1
+    `)
+            .run();
+        return result.changes;
+    }
+    mapWatcherFromDb(row) {
+        return {
+            id: row.id,
+            sessionId: row.session_id || undefined,
+            filters: {
+                keys: JSON.parse(row.filter_keys || '[]'),
+                categories: JSON.parse(row.filter_categories || '[]'),
+                channels: JSON.parse(row.filter_channels || '[]'),
+                priorities: JSON.parse(row.filter_priorities || '[]'),
+            },
+            lastSequence: row.last_sequence,
+            createdAt: row.created_at,
+            lastPollAt: row.last_poll_at || undefined,
+            expiresAt: row.expires_at,
+            metadata: row.metadata ? JSON.parse(row.metadata) : undefined,
+            isActive: row.is_active === 1,
+        };
+    }
+    mapChangeFromDb(row) {
+        return {
+            sequenceId: row.sequence_id,
+            sessionId: row.session_id,
+            itemId: row.item_id,
+            key: row.key,
+            operation: row.operation,
+            oldValue: row.old_value || undefined,
+            newValue: row.new_value || undefined,
+            oldMetadata: row.old_metadata || undefined,
+            newMetadata: row.new_metadata || undefined,
+            category: row.category || undefined,
+            priority: row.priority || undefined,
+            channel: row.channel || undefined,
+            sizeDelta: row.size_delta || 0,
+            createdAt: row.created_at,
+            createdBy: row.created_by || undefined,
+        };
+    }
+}
+exports.WatcherRepository = WatcherRepository;

package/dist/repositories/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RepositoryManager = exports.CheckpointRepository = exports.FileRepository = exports.ContextRepository = exports.SessionRepository = exports.BaseRepository = void 0;
+var BaseRepository_js_1 = require("./BaseRepository.js");
+Object.defineProperty(exports, "BaseRepository", { enumerable: true, get: function () { return BaseRepository_js_1.BaseRepository; } });
+var SessionRepository_js_1 = require("./SessionRepository.js");
+Object.defineProperty(exports, "SessionRepository", { enumerable: true, get: function () { return SessionRepository_js_1.SessionRepository; } });
+var ContextRepository_js_1 = require("./ContextRepository.js");
+Object.defineProperty(exports, "ContextRepository", { enumerable: true, get: function () { return ContextRepository_js_1.ContextRepository; } });
+var FileRepository_js_1 = require("./FileRepository.js");
+Object.defineProperty(exports, "FileRepository", { enumerable: true, get: function () { return FileRepository_js_1.FileRepository; } });
+var CheckpointRepository_js_1 = require("./CheckpointRepository.js");
+Object.defineProperty(exports, "CheckpointRepository", { enumerable: true, get: function () { return CheckpointRepository_js_1.CheckpointRepository; } });
+var RepositoryManager_js_1 = require("./RepositoryManager.js");
+Object.defineProperty(exports, "RepositoryManager", { enumerable: true, get: function () { return RepositoryManager_js_1.RepositoryManager; } });