mcp-memory-keeper 0.10.0

package/dist/__tests__/integration/concurrent-access.test.js

@@ -0,0 +1,190 @@
+"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 });
+const globals_1 = require("@jest/globals");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const database_helper_js_1 = require("../../test-helpers/database-helper.js");
+(0, globals_1.describe)('Concurrent Access Tests', () => {
+    let tempDir;
+    let tempDbPath;
+    let dbManager;
+    (0, globals_1.beforeEach)(() => {
+        tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mcp-test-'));
+        tempDbPath = path.join(tempDir, 'test.db');
+        dbManager = database_helper_js_1.TestDatabaseHelper.createTestDatabase();
+    });
+    (0, globals_1.afterEach)(async () => {
+        // Clean up all tracked databases
+        await database_helper_js_1.TestDatabaseHelper.cleanupAll();
+        // Clean up temp directory
+        try {
+            fs.rmSync(tempDir, { recursive: true, force: true });
+        }
+        catch (_error) {
+            console.warn('Error cleaning up temp directory:', _error);
+        }
+        // Clean up any WAL/SHM files
+        database_helper_js_1.TestDatabaseHelper.cleanupDbFiles(tempDbPath);
+    });
+    (0, globals_1.it)('should handle concurrent session writes without corruption', async () => {
+        const db = dbManager.getDatabase();
+        const sessionId = 'test-session';
+        // Create session
+        db.prepare(`
+      INSERT INTO sessions (id, name, description, branch, working_directory)
+      VALUES (?, ?, ?, ?, ?)
+    `).run(sessionId, 'Test Session', 'Test', null, null);
+        // Simulate concurrent writes to same session
+        const promises = [];
+        for (let i = 0; i < 10; i++) {
+            promises.push(new Promise(resolve => {
+                setTimeout(() => {
+                    try {
+                        db.prepare(`
+              INSERT OR REPLACE INTO context_items (id, session_id, key, value, category, priority)
+              VALUES (?, ?, ?, ?, ?, ?)
+            `).run(`item-${i}`, sessionId, `key-${i}`, `value-${i}`, 'test', 'normal');
+                        resolve();
+                    }
+                    catch (_error) {
+                        resolve(); // Still resolve to continue test
+                    }
+                }, Math.random() * 10);
+            }));
+        }
+        await Promise.all(promises);
+        // Verify all items were written
+        const items = db
+            .prepare('SELECT COUNT(*) as count FROM context_items WHERE session_id = ?')
+            .get(sessionId);
+        (0, globals_1.expect)(items.count).toBe(10);
+    });
+    (0, globals_1.it)('should handle concurrent updates to same key', async () => {
+        const db = dbManager.getDatabase();
+        const sessionId = 'test-session';
+        const key = 'shared-key';
+        // Create session
+        db.prepare(`
+      INSERT INTO sessions (id, name, description, branch, working_directory)
+      VALUES (?, ?, ?, ?, ?)
+    `).run(sessionId, 'Test Session', 'Test', null, null);
+        // Initial value
+        db.prepare(`
+      INSERT INTO context_items (id, session_id, key, value, category, priority)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `).run('initial', sessionId, key, 'initial-value', 'test', 'normal');
+        // Concurrent updates
+        const updates = [];
+        for (let i = 0; i < 20; i++) {
+            updates.push(new Promise(resolve => {
+                setTimeout(() => {
+                    try {
+                        db.prepare(`
+              UPDATE context_items 
+              SET value = ?, updated_at = CURRENT_TIMESTAMP
+              WHERE session_id = ? AND key = ?
+            `).run(`value-${i}`, sessionId, key);
+                        resolve();
+                    }
+                    catch (_error) {
+                        resolve();
+                    }
+                }, Math.random() * 10);
+            }));
+        }
+        await Promise.all(updates);
+        // Should have exactly one item with the key
+        const items = db
+            .prepare('SELECT COUNT(*) as count FROM context_items WHERE session_id = ? AND key = ?')
+            .get(sessionId, key);
+        (0, globals_1.expect)(items.count).toBe(1);
+    });
+    (0, globals_1.it)('should handle database locks gracefully', () => {
+        const db = dbManager.getDatabase();
+        // In WAL mode, readers don't block writers and vice versa
+        // So we need to test a different scenario - two writers
+        // Start a write transaction
+        db.prepare('BEGIN IMMEDIATE').run();
+        // Try to start another write transaction (should fail)
+        let errorThrown = false;
+        try {
+            // This should fail because we already have a write transaction
+            db.prepare('BEGIN IMMEDIATE').run();
+        }
+        catch (error) {
+            errorThrown = true;
+            // The exact error code might vary
+            (0, globals_1.expect)(error.message).toMatch(/database is locked|cannot start a transaction/i);
+        }
+        db.prepare('ROLLBACK').run();
+        // If no error was thrown, it might be because SQLite is configured differently
+        // In that case, just verify we can at least do transactions
+        if (!errorThrown) {
+            // Verify basic transaction works
+            db.prepare('BEGIN').run();
+            db.prepare('INSERT INTO sessions (id, name) VALUES (?, ?)').run('test', 'Test');
+            db.prepare('COMMIT').run();
+            const result = db.prepare('SELECT * FROM sessions WHERE id = ?').get('test');
+            (0, globals_1.expect)(result.name).toBe('Test');
+        }
+    });
+    (0, globals_1.it)('should handle WAL mode concurrent reads during write', () => {
+        const db = dbManager.getDatabase();
+        // Verify WAL mode is enabled
+        const journalMode = db.pragma('journal_mode');
+        (0, globals_1.expect)(journalMode[0].journal_mode).toBe('wal');
+        // Create a session
+        const sessionId = 'wal-test';
+        db.prepare(`
+      INSERT INTO sessions (id, name, description, branch, working_directory)
+      VALUES (?, ?, ?, ?, ?)
+    `).run(sessionId, 'WAL Test', 'Test', null, null);
+        // Start a write transaction
+        const writeStmt = db.prepare('BEGIN IMMEDIATE');
+        writeStmt.run();
+        // Insert item in transaction
+        db.prepare(`
+      INSERT INTO context_items (id, session_id, key, value, category, priority)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `).run('item-1', sessionId, 'key-1', 'value-1', 'test', 'normal');
+        // Read should work even with ongoing write transaction (WAL mode benefit)
+        const readResult = db.prepare('SELECT COUNT(*) as count FROM sessions').get();
+        (0, globals_1.expect)(readResult.count).toBeGreaterThan(0);
+        // Commit the transaction
+        db.prepare('COMMIT').run();
+    });
+});

package/dist/__tests__/integration/context-operations.test.js

@@ -0,0 +1,243 @@
+"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 });
+const database_1 = require("../../utils/database");
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const uuid_1 = require("uuid");
+describe('Context Operations Integration Tests', () => {
+    let dbManager;
+    let tempDbPath;
+    let db;
+    let testSessionId;
+    beforeEach(() => {
+        tempDbPath = path.join(os.tmpdir(), `test-context-${Date.now()}.db`);
+        dbManager = new database_1.DatabaseManager({
+            filename: tempDbPath,
+            maxSize: 10 * 1024 * 1024,
+            walMode: true,
+        });
+        db = dbManager.getDatabase();
+        // Create test session
+        testSessionId = (0, uuid_1.v4)();
+        db.prepare('INSERT INTO sessions (id, name) VALUES (?, ?)').run(testSessionId, 'Test Session');
+    });
+    afterEach(() => {
+        dbManager.close();
+        try {
+            fs.unlinkSync(tempDbPath);
+            fs.unlinkSync(`${tempDbPath}-wal`);
+            fs.unlinkSync(`${tempDbPath}-shm`);
+        }
+        catch (_e) {
+            // Ignore
+        }
+    });
+    describe('context_save', () => {
+        it('should save a basic context item', () => {
+            const result = db
+                .prepare('INSERT INTO context_items (id, session_id, key, value) VALUES (?, ?, ?, ?)')
+                .run((0, uuid_1.v4)(), testSessionId, 'test_key', 'test_value');
+            expect(result.changes).toBe(1);
+            const saved = db
+                .prepare('SELECT * FROM context_items WHERE session_id = ? AND key = ?')
+                .get(testSessionId, 'test_key');
+            expect(saved).toBeDefined();
+            expect(saved.key).toBe('test_key');
+            expect(saved.value).toBe('test_value');
+        });
+        it('should save context with category and priority', () => {
+            const id = (0, uuid_1.v4)();
+            db.prepare('INSERT INTO context_items (id, session_id, key, value, category, priority) VALUES (?, ?, ?, ?, ?, ?)').run(id, testSessionId, 'task_item', 'Fix bug in auth', 'task', 'high');
+            const saved = db.prepare('SELECT * FROM context_items WHERE id = ?').get(id);
+            expect(saved.category).toBe('task');
+            expect(saved.priority).toBe('high');
+        });
+        it('should update existing key in same session', () => {
+            // Insert first
+            db.prepare('INSERT INTO context_items (id, session_id, key, value) VALUES (?, ?, ?, ?)').run((0, uuid_1.v4)(), testSessionId, 'update_key', 'original_value');
+            // Update using INSERT OR REPLACE
+            db.prepare('INSERT OR REPLACE INTO context_items (id, session_id, key, value) VALUES (?, ?, ?, ?)').run((0, uuid_1.v4)(), testSessionId, 'update_key', 'updated_value');
+            const items = db
+                .prepare('SELECT * FROM context_items WHERE session_id = ? AND key = ?')
+                .all(testSessionId, 'update_key');
+            expect(items).toHaveLength(1);
+            expect(items[0].value).toBe('updated_value');
+        });
+        it('should handle large values', () => {
+            const largeValue = 'x'.repeat(10000); // 10KB of data
+            const result = db
+                .prepare('INSERT INTO context_items (id, session_id, key, value) VALUES (?, ?, ?, ?)')
+                .run((0, uuid_1.v4)(), testSessionId, 'large_key', largeValue);
+            expect(result.changes).toBe(1);
+            const saved = db
+                .prepare('SELECT * FROM context_items WHERE session_id = ? AND key = ?')
+                .get(testSessionId, 'large_key');
+            expect(saved.value).toBe(largeValue);
+        });
+        it('should handle special characters in values', () => {
+            const specialValue = `Line 1\nLine 2\t"quoted"\n'single'\n\`backtick\``;
+            db.prepare('INSERT INTO context_items (id, session_id, key, value) VALUES (?, ?, ?, ?)').run((0, uuid_1.v4)(), testSessionId, 'special_key', specialValue);
+            const saved = db
+                .prepare('SELECT * FROM context_items WHERE session_id = ? AND key = ?')
+                .get(testSessionId, 'special_key');
+            expect(saved.value).toBe(specialValue);
+        });
+    });
+    describe('context_get', () => {
+        beforeEach(() => {
+            // Add test data
+            const items = [
+                { key: 'item1', value: 'value1', category: 'task', priority: 'high' },
+                { key: 'item2', value: 'value2', category: 'task', priority: 'normal' },
+                { key: 'item3', value: 'value3', category: 'decision', priority: 'high' },
+                { key: 'item4', value: 'value4', category: 'note', priority: 'low' },
+            ];
+            items.forEach(item => {
+                db.prepare('INSERT INTO context_items (id, session_id, key, value, category, priority) VALUES (?, ?, ?, ?, ?, ?)').run((0, uuid_1.v4)(), testSessionId, item.key, item.value, item.category, item.priority);
+            });
+        });
+        it('should get item by key', () => {
+            const item = db
+                .prepare('SELECT * FROM context_items WHERE session_id = ? AND key = ?')
+                .get(testSessionId, 'item1');
+            expect(item).toBeDefined();
+            expect(item.value).toBe('value1');
+            expect(item.category).toBe('task');
+        });
+        it('should get all items for session', () => {
+            const items = db
+                .prepare('SELECT * FROM context_items WHERE session_id = ? ORDER BY key')
+                .all(testSessionId);
+            expect(items).toHaveLength(4);
+            expect(items[0].key).toBe('item1');
+            expect(items[3].key).toBe('item4');
+        });
+        it('should filter by category', () => {
+            const tasks = db
+                .prepare('SELECT * FROM context_items WHERE session_id = ? AND category = ?')
+                .all(testSessionId, 'task');
+            expect(tasks).toHaveLength(2);
+            expect(tasks.every((t) => t.category === 'task')).toBe(true);
+        });
+        it('should filter by priority', () => {
+            const highPriority = db
+                .prepare('SELECT * FROM context_items WHERE session_id = ? AND priority = ?')
+                .all(testSessionId, 'high');
+            expect(highPriority).toHaveLength(2);
+            expect(highPriority.every((t) => t.priority === 'high')).toBe(true);
+        });
+        it('should filter by category and priority', () => {
+            const highTasks = db
+                .prepare('SELECT * FROM context_items WHERE session_id = ? AND category = ? AND priority = ?')
+                .all(testSessionId, 'task', 'high');
+            expect(highTasks).toHaveLength(1);
+            expect(highTasks[0].key).toBe('item1');
+        });
+        it('should return empty array when no matches', () => {
+            const items = db
+                .prepare('SELECT * FROM context_items WHERE session_id = ? AND key = ?')
+                .all(testSessionId, 'nonexistent');
+            expect(items).toHaveLength(0);
+        });
+        it('should get items from specific session', () => {
+            // Create another session
+            const otherSessionId = (0, uuid_1.v4)();
+            db.prepare('INSERT INTO sessions (id, name) VALUES (?, ?)').run(otherSessionId, 'Other Session');
+            db.prepare('INSERT INTO context_items (id, session_id, key, value) VALUES (?, ?, ?, ?)').run((0, uuid_1.v4)(), otherSessionId, 'other_item', 'other_value');
+            // Get from specific session
+            const items = db
+                .prepare('SELECT * FROM context_items WHERE session_id = ?')
+                .all(otherSessionId);
+            expect(items).toHaveLength(1);
+            expect(items[0].key).toBe('other_item');
+        });
+    });
+    describe('context_status', () => {
+        it('should show status with no items', () => {
+            const session = db.prepare('SELECT * FROM sessions WHERE id = ?').get(testSessionId);
+            const itemCount = db
+                .prepare('SELECT COUNT(*) as count FROM context_items WHERE session_id = ?')
+                .get(testSessionId);
+            const fileCount = db
+                .prepare('SELECT COUNT(*) as count FROM file_cache WHERE session_id = ?')
+                .get(testSessionId);
+            expect(session).toBeDefined();
+            expect(itemCount.count).toBe(0);
+            expect(fileCount.count).toBe(0);
+        });
+        it('should show complete status information', () => {
+            // Add some data
+            for (let i = 0; i < 5; i++) {
+                db.prepare('INSERT INTO context_items (id, session_id, key, value, category) VALUES (?, ?, ?, ?, ?)').run((0, uuid_1.v4)(), testSessionId, `key${i}`, `value${i}`, i % 2 === 0 ? 'task' : 'note');
+            }
+            for (let i = 0; i < 3; i++) {
+                db.prepare('INSERT INTO file_cache (id, session_id, file_path, content, hash) VALUES (?, ?, ?, ?, ?)').run((0, uuid_1.v4)(), testSessionId, `/file${i}.txt`, `content${i}`, `hash${i}`);
+            }
+            // Get status
+            const itemCount = db
+                .prepare('SELECT COUNT(*) as count FROM context_items WHERE session_id = ?')
+                .get(testSessionId);
+            const fileCount = db
+                .prepare('SELECT COUNT(*) as count FROM file_cache WHERE session_id = ?')
+                .get(testSessionId);
+            const categoryBreakdown = db
+                .prepare(`SELECT category, COUNT(*) as count 
+         FROM context_items 
+         WHERE session_id = ? 
+         GROUP BY category`)
+                .all(testSessionId);
+            expect(itemCount.count).toBe(5);
+            expect(fileCount.count).toBe(3);
+            expect(categoryBreakdown).toHaveLength(2);
+            expect(categoryBreakdown.find((c) => c.category === 'task')?.count).toBe(3);
+            expect(categoryBreakdown.find((c) => c.category === 'note')?.count).toBe(2);
+        });
+        it('should calculate database size', () => {
+            // Add substantial data
+            const largeContent = 'x'.repeat(1000);
+            for (let i = 0; i < 10; i++) {
+                db.prepare('INSERT INTO context_items (id, session_id, key, value) VALUES (?, ?, ?, ?)').run((0, uuid_1.v4)(), testSessionId, `large${i}`, largeContent);
+            }
+            // Calculate approximate size
+            const items = db
+                .prepare('SELECT LENGTH(value) as size FROM context_items WHERE session_id = ?')
+                .all(testSessionId);
+            const totalSize = items.reduce((sum, item) => sum + item.size, 0);
+            expect(totalSize).toBe(10000); // 10 items × 1000 chars
+        });
+    });
+});