mcp-memory-keeper 0.10.0

package/dist/__tests__/utils/validation.test.js

@@ -0,0 +1,200 @@
+"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 validation_1 = require("../../utils/validation");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+// Mock fs module
+jest.mock('fs');
+describe('Validation Utils', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    describe('validateFilePath', () => {
+        it('should accept valid file paths for write', () => {
+            fs.existsSync.mockReturnValue(true);
+            const result = (0, validation_1.validateFilePath)('/tmp/test.txt', 'write');
+            expect(result).toBe(path.normalize('/tmp/test.txt'));
+        });
+        it('should accept valid file paths for read', () => {
+            fs.existsSync.mockReturnValue(true);
+            const result = (0, validation_1.validateFilePath)('/tmp/test.txt', 'read');
+            expect(result).toBe(path.normalize('/tmp/test.txt'));
+        });
+        it('should reject empty file paths', () => {
+            expect(() => (0, validation_1.validateFilePath)('', 'read')).toThrow(validation_1.ValidationError);
+            expect(() => (0, validation_1.validateFilePath)('', 'read')).toThrow('File path must be a non-empty string');
+        });
+        it('should reject null/undefined file paths', () => {
+            expect(() => (0, validation_1.validateFilePath)(null, 'read')).toThrow(validation_1.ValidationError);
+            expect(() => (0, validation_1.validateFilePath)(undefined, 'read')).toThrow(validation_1.ValidationError);
+        });
+        it('should reject path traversal attempts', () => {
+            expect(() => (0, validation_1.validateFilePath)('../../../etc/passwd', 'read')).toThrow(validation_1.ValidationError);
+            expect(() => (0, validation_1.validateFilePath)('../../../etc/passwd', 'read')).toThrow('Path traversal detected');
+        });
+        it('should reject non-existent files for read', () => {
+            fs.existsSync.mockReturnValue(false);
+            expect(() => (0, validation_1.validateFilePath)('/tmp/nonexistent.txt', 'read')).toThrow(validation_1.ValidationError);
+            expect(() => (0, validation_1.validateFilePath)('/tmp/nonexistent.txt', 'read')).toThrow('File not found');
+        });
+        it('should reject non-existent directories for write', () => {
+            fs.existsSync.mockReturnValue(false);
+            expect(() => (0, validation_1.validateFilePath)('/nonexistent/dir/file.txt', 'write')).toThrow(validation_1.ValidationError);
+            expect(() => (0, validation_1.validateFilePath)('/nonexistent/dir/file.txt', 'write')).toThrow('Directory not found');
+        });
+    });
+    describe('validateSearchQuery', () => {
+        it('should accept valid search queries', () => {
+            expect((0, validation_1.validateSearchQuery)('test query')).toBe('test query');
+            expect((0, validation_1.validateSearchQuery)('  spaces  ')).toBe('spaces');
+        });
+        it('should escape SQL wildcards', () => {
+            expect((0, validation_1.validateSearchQuery)('test%query')).toBe('test\\%query');
+            expect((0, validation_1.validateSearchQuery)('test_query')).toBe('test\\_query');
+        });
+        it('should reject empty queries', () => {
+            expect(() => (0, validation_1.validateSearchQuery)('')).toThrow(validation_1.ValidationError);
+            expect(() => (0, validation_1.validateSearchQuery)('   ')).toThrow('Search query cannot be empty');
+        });
+        it('should reject null/undefined queries', () => {
+            expect(() => (0, validation_1.validateSearchQuery)(null)).toThrow(validation_1.ValidationError);
+            expect(() => (0, validation_1.validateSearchQuery)(undefined)).toThrow(validation_1.ValidationError);
+        });
+        it('should reject queries that are too long', () => {
+            const longQuery = 'a'.repeat(1001);
+            expect(() => (0, validation_1.validateSearchQuery)(longQuery)).toThrow(validation_1.ValidationError);
+            expect(() => (0, validation_1.validateSearchQuery)(longQuery)).toThrow('Search query too long');
+        });
+    });
+    describe('validateSessionName', () => {
+        it('should accept valid session names', () => {
+            expect((0, validation_1.validateSessionName)('My Session')).toBe('My Session');
+            expect((0, validation_1.validateSessionName)('  Trimmed  ')).toBe('Trimmed');
+        });
+        it('should reject empty session names', () => {
+            expect(() => (0, validation_1.validateSessionName)('')).toThrow(validation_1.ValidationError);
+            expect(() => (0, validation_1.validateSessionName)('   ')).toThrow('Session name cannot be empty');
+        });
+        it('should reject null/undefined session names', () => {
+            expect(() => (0, validation_1.validateSessionName)(null)).toThrow(validation_1.ValidationError);
+            expect(() => (0, validation_1.validateSessionName)(undefined)).toThrow(validation_1.ValidationError);
+        });
+        it('should reject session names that are too long', () => {
+            const longName = 'a'.repeat(256);
+            expect(() => (0, validation_1.validateSessionName)(longName)).toThrow(validation_1.ValidationError);
+            expect(() => (0, validation_1.validateSessionName)(longName)).toThrow('Session name too long');
+        });
+    });
+    describe('validateKey', () => {
+        it('should accept valid keys', () => {
+            expect((0, validation_1.validateKey)('my_key')).toBe('my_key');
+            expect((0, validation_1.validateKey)('valid_key_123')).toBe('valid_key_123');
+            expect((0, validation_1.validateKey)('key-with-hyphens')).toBe('key-with-hyphens');
+            expect((0, validation_1.validateKey)('key.with.dots')).toBe('key.with.dots');
+            expect((0, validation_1.validateKey)('path/to/key')).toBe('path/to/key');
+            expect((0, validation_1.validateKey)('namespace:key')).toBe('namespace:key');
+        });
+        it('should reject keys with leading or trailing whitespace', () => {
+            expect(() => (0, validation_1.validateKey)('  trimmed_key  ')).toThrow(validation_1.ValidationError);
+            expect(() => (0, validation_1.validateKey)(' leading_space')).toThrow(validation_1.ValidationError);
+            expect(() => (0, validation_1.validateKey)('trailing_space ')).toThrow(validation_1.ValidationError);
+            expect(() => (0, validation_1.validateKey)('\ttab_key')).toThrow(validation_1.ValidationError);
+        });
+        it('should reject empty keys', () => {
+            expect(() => (0, validation_1.validateKey)('')).toThrow(validation_1.ValidationError);
+            expect(() => (0, validation_1.validateKey)('   ')).toThrow('Key cannot be empty');
+        });
+        it('should reject null/undefined keys', () => {
+            expect(() => (0, validation_1.validateKey)(null)).toThrow(validation_1.ValidationError);
+            expect(() => (0, validation_1.validateKey)(undefined)).toThrow(validation_1.ValidationError);
+        });
+        it('should reject keys that are too long', () => {
+            const longKey = 'k'.repeat(256);
+            expect(() => (0, validation_1.validateKey)(longKey)).toThrow(validation_1.ValidationError);
+            expect(() => (0, validation_1.validateKey)(longKey)).toThrow('Key too long');
+        });
+    });
+    describe('validateValue', () => {
+        it('should accept valid values', () => {
+            expect((0, validation_1.validateValue)('test value')).toBe('test value');
+            expect((0, validation_1.validateValue)('')).toBe(''); // Empty values are allowed
+        });
+        it('should reject non-string values', () => {
+            expect(() => (0, validation_1.validateValue)(123)).toThrow(validation_1.ValidationError);
+            expect(() => (0, validation_1.validateValue)(null)).toThrow('Value must be a string');
+        });
+        it('should reject values that are too large', () => {
+            const largeValue = 'v'.repeat(1000001);
+            expect(() => (0, validation_1.validateValue)(largeValue)).toThrow(validation_1.ValidationError);
+            expect(() => (0, validation_1.validateValue)(largeValue)).toThrow('Value too large');
+        });
+    });
+    describe('validateCategory', () => {
+        it('should accept valid categories', () => {
+            expect((0, validation_1.validateCategory)('task')).toBe('task');
+            expect((0, validation_1.validateCategory)('decision')).toBe('decision');
+            expect((0, validation_1.validateCategory)('progress')).toBe('progress');
+            expect((0, validation_1.validateCategory)('note')).toBe('note');
+            expect((0, validation_1.validateCategory)('error')).toBe('error');
+            expect((0, validation_1.validateCategory)('warning')).toBe('warning');
+            expect((0, validation_1.validateCategory)('git')).toBe('git');
+            expect((0, validation_1.validateCategory)('system')).toBe('system');
+        });
+        it('should return undefined for empty category', () => {
+            expect((0, validation_1.validateCategory)('')).toBeUndefined();
+            expect((0, validation_1.validateCategory)(undefined)).toBeUndefined();
+        });
+        it('should reject invalid categories', () => {
+            expect(() => (0, validation_1.validateCategory)('invalid')).toThrow(validation_1.ValidationError);
+            expect(() => (0, validation_1.validateCategory)('invalid')).toThrow('Invalid category');
+        });
+    });
+    describe('validatePriority', () => {
+        it('should accept valid priorities', () => {
+            expect((0, validation_1.validatePriority)('high')).toBe('high');
+            expect((0, validation_1.validatePriority)('normal')).toBe('normal');
+            expect((0, validation_1.validatePriority)('low')).toBe('low');
+        });
+        it('should default to normal for empty priority', () => {
+            expect((0, validation_1.validatePriority)('')).toBe('normal');
+            expect((0, validation_1.validatePriority)(undefined)).toBe('normal');
+        });
+        it('should reject invalid priorities', () => {
+            expect(() => (0, validation_1.validatePriority)('urgent')).toThrow(validation_1.ValidationError);
+            expect(() => (0, validation_1.validatePriority)('invalid')).toThrow('Invalid priority');
+        });
+    });
+});

package/dist/__tests__/utils/vector-store.test.js

@@ -0,0 +1,231 @@
+"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 vector_store_1 = require("../../utils/vector-store");
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const uuid_1 = require("uuid");
+describe('VectorStore', () => {
+    let dbManager;
+    let vectorStore;
+    let tempDbPath;
+    let db;
+    let testSessionId;
+    beforeEach(() => {
+        tempDbPath = path.join(os.tmpdir(), `test-vector-${Date.now()}.db`);
+        dbManager = new database_1.DatabaseManager({
+            filename: tempDbPath,
+            maxSize: 10 * 1024 * 1024,
+            walMode: true,
+        });
+        db = dbManager.getDatabase();
+        vectorStore = new vector_store_1.VectorStore(db);
+        // Create test session and context items
+        testSessionId = (0, uuid_1.v4)();
+        db.prepare('INSERT INTO sessions (id, name, description) VALUES (?, ?, ?)').run(testSessionId, 'Test Session', 'Testing vector store');
+    });
+    afterEach(() => {
+        dbManager.close();
+        try {
+            fs.unlinkSync(tempDbPath);
+            fs.unlinkSync(`${tempDbPath}-wal`);
+            fs.unlinkSync(`${tempDbPath}-shm`);
+        }
+        catch (_e) {
+            // Ignore
+        }
+    });
+    describe('Embedding creation', () => {
+        it('should create consistent embeddings for the same text', () => {
+            const text = 'This is a test sentence for embedding';
+            const embedding1 = vectorStore.createEmbedding(text);
+            const embedding2 = vectorStore.createEmbedding(text);
+            expect(embedding1).toEqual(embedding2);
+            expect(embedding1.length).toBe(384); // Default dimension
+        });
+        it('should create different embeddings for different text', () => {
+            const embedding1 = vectorStore.createEmbedding('First text');
+            const embedding2 = vectorStore.createEmbedding('Completely different text');
+            expect(embedding1).not.toEqual(embedding2);
+        });
+        it('should normalize embeddings', () => {
+            const embedding = vectorStore.createEmbedding('Test text');
+            const magnitude = Math.sqrt(embedding.reduce((sum, val) => sum + val * val, 0));
+            expect(magnitude).toBeCloseTo(1.0, 5);
+        });
+        it('should handle empty text', () => {
+            const embedding = vectorStore.createEmbedding('');
+            expect(embedding.every(v => v === 0)).toBe(true);
+        });
+    });
+    describe('Document storage', () => {
+        it('should store a document with embedding', async () => {
+            const contentId = (0, uuid_1.v4)();
+            db.prepare('INSERT INTO context_items (id, session_id, key, value) VALUES (?, ?, ?, ?)').run(contentId, testSessionId, 'test_key', 'test value');
+            const docId = await vectorStore.storeDocument(contentId, 'test_key: test value', {
+                category: 'test',
+            });
+            expect(docId).toBeDefined();
+            // Verify in database
+            const stored = db.prepare('SELECT * FROM vector_embeddings WHERE id = ?').get(docId);
+            expect(stored).toBeDefined();
+            expect(stored.content).toBe('test_key: test value');
+            expect(stored.content_id).toBe(contentId);
+            expect(JSON.parse(stored.metadata)).toEqual({ category: 'test' });
+        });
+        it('should handle documents without metadata', async () => {
+            const contentId = (0, uuid_1.v4)();
+            db.prepare('INSERT INTO context_items (id, session_id, key, value) VALUES (?, ?, ?, ?)').run(contentId, testSessionId, 'test_key', 'test value');
+            const docId = await vectorStore.storeDocument(contentId, 'test content');
+            const stored = db.prepare('SELECT * FROM vector_embeddings WHERE id = ?').get(docId);
+            expect(stored.metadata).toBeNull();
+        });
+    });
+    describe('Semantic search', () => {
+        beforeEach(async () => {
+            // Create test context items with embeddings
+            const items = [
+                { key: 'auth_task', value: 'Implement user authentication with JWT tokens' },
+                { key: 'auth_decision', value: 'Use bcrypt for password hashing' },
+                { key: 'db_task', value: 'Set up PostgreSQL database connection' },
+                { key: 'api_task', value: 'Create REST API endpoints for user management' },
+                { key: 'test_task', value: 'Write unit tests for authentication module' },
+            ];
+            for (const item of items) {
+                const itemId = (0, uuid_1.v4)();
+                db.prepare('INSERT INTO context_items (id, session_id, key, value) VALUES (?, ?, ?, ?)').run(itemId, testSessionId, item.key, item.value);
+                await vectorStore.storeDocument(itemId, `${item.key}: ${item.value}`, { key: item.key });
+            }
+        });
+        it('should find relevant documents by semantic similarity', async () => {
+            const results = await vectorStore.search('authentication security', 5, 0.1);
+            expect(results.length).toBeGreaterThan(0);
+            // Authentication-related items should rank higher
+            const topResults = results.slice(0, 2);
+            const authRelated = topResults.filter(r => r.content.toLowerCase().includes('auth') || r.content.toLowerCase().includes('password'));
+            expect(authRelated.length).toBeGreaterThan(0);
+        });
+        it('should respect topK parameter', async () => {
+            const results = await vectorStore.search('task', 3);
+            expect(results.length).toBeLessThanOrEqual(3);
+        });
+        it('should filter by minimum similarity', async () => {
+            const results = await vectorStore.search('completely unrelated query xyz123', 10, 0.8);
+            expect(results.length).toBe(0);
+        });
+        it('should search within a specific session', async () => {
+            // Create another session with different content
+            const otherSessionId = (0, uuid_1.v4)();
+            db.prepare('INSERT INTO sessions (id, name) VALUES (?, ?)').run(otherSessionId, 'Other Session');
+            const itemId = (0, uuid_1.v4)();
+            db.prepare('INSERT INTO context_items (id, session_id, key, value) VALUES (?, ?, ?, ?)').run(itemId, otherSessionId, 'other_key', 'authentication in other session');
+            await vectorStore.storeDocument(itemId, 'other_key: authentication in other session');
+            // Search only in test session
+            const results = await vectorStore.searchInSession(testSessionId, 'authentication', 10, 0.1);
+            const otherSessionResults = results.filter(r => r.content.includes('other_key'));
+            expect(otherSessionResults.length).toBe(0);
+        });
+    });
+    describe('Related documents', () => {
+        let docIds = [];
+        beforeEach(async () => {
+            const items = [
+                { key: 'jwt_info', value: 'JWT tokens expire after 24 hours' },
+                { key: 'jwt_impl', value: 'Implement JWT token generation and validation' },
+                { key: 'session_info', value: 'Session management using Redis' },
+            ];
+            for (const item of items) {
+                const itemId = (0, uuid_1.v4)();
+                db.prepare('INSERT INTO context_items (id, session_id, key, value) VALUES (?, ?, ?, ?)').run(itemId, testSessionId, item.key, item.value);
+                const docId = await vectorStore.storeDocument(itemId, `${item.key}: ${item.value}`);
+                docIds.push(docId);
+            }
+        });
+        it('should find related documents', async () => {
+            const relatedToJwt = await vectorStore.findRelated(docIds[0], 5, 0.1);
+            expect(relatedToJwt.length).toBeGreaterThan(0);
+            // JWT implementation should be related to JWT info
+            const jwtImpl = relatedToJwt.find(r => r.content.includes('jwt_impl'));
+            expect(jwtImpl).toBeDefined();
+        });
+        it('should exclude the source document', async () => {
+            const related = await vectorStore.findRelated(docIds[0], 10, 0.0);
+            const self = related.find(r => r.id === docIds[0]);
+            expect(self).toBeUndefined();
+        });
+    });
+    describe('Session embedding updates', () => {
+        it('should create embeddings for all context items in a session', async () => {
+            // Create context items without embeddings
+            const items = [
+                { id: (0, uuid_1.v4)(), key: 'item1', value: 'First item' },
+                { id: (0, uuid_1.v4)(), key: 'item2', value: 'Second item' },
+                { id: (0, uuid_1.v4)(), key: 'item3', value: 'Third item' },
+            ];
+            for (const item of items) {
+                db.prepare('INSERT INTO context_items (id, session_id, key, value) VALUES (?, ?, ?, ?)').run(item.id, testSessionId, item.key, item.value);
+            }
+            const count = await vectorStore.updateSessionEmbeddings(testSessionId);
+            expect(count).toBe(3);
+            // Verify embeddings were created
+            const embeddings = db
+                .prepare('SELECT COUNT(*) as count FROM vector_embeddings WHERE content_id IN (?, ?, ?)')
+                .get(items[0].id, items[1].id, items[2].id);
+            expect(embeddings.count).toBe(3);
+        });
+        it('should not duplicate embeddings', async () => {
+            const itemId = (0, uuid_1.v4)();
+            db.prepare('INSERT INTO context_items (id, session_id, key, value) VALUES (?, ?, ?, ?)').run(itemId, testSessionId, 'test', 'value');
+            // Create embedding
+            await vectorStore.storeDocument(itemId, 'test: value');
+            // Update should not create duplicate
+            const count = await vectorStore.updateSessionEmbeddings(testSessionId);
+            expect(count).toBe(0);
+        });
+    });
+    describe('Statistics', () => {
+        it('should return document count', async () => {
+            const stats = vectorStore.getStats();
+            expect(stats.totalDocuments).toBe(0);
+            const itemId = (0, uuid_1.v4)();
+            db.prepare('INSERT INTO context_items (id, session_id, key, value) VALUES (?, ?, ?, ?)').run(itemId, testSessionId, 'test', 'value');
+            await vectorStore.storeDocument(itemId, 'test: value');
+            const newStats = vectorStore.getStats();
+            expect(newStats.totalDocuments).toBe(1);
+        });
+    });
+});

package/dist/handlers/contextWatchHandlers.js

@@ -0,0 +1,206 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleContextWatch = handleContextWatch;
+exports.handleContextWatchCreate = handleContextWatchCreate;
+exports.handleContextWatchPoll = handleContextWatchPoll;
+exports.handleContextWatchStop = handleContextWatchStop;
+exports.handleContextWatchList = handleContextWatchList;
+const validation_js_1 = require("../utils/validation.js");
+/**
+ * Validates filter parameters for watchers
+ */
+function validateFilters(filters) {
+    if (filters) {
+        // Validate keys
+        if (filters.keys !== undefined && !Array.isArray(filters.keys)) {
+            throw new validation_js_1.ValidationError('keys filter must be an array');
+        }
+        // Validate channels
+        if (filters.channels !== undefined && !Array.isArray(filters.channels)) {
+            throw new validation_js_1.ValidationError('channels filter must be an array');
+        }
+        // Validate categories
+        if (filters.categories !== undefined && !Array.isArray(filters.categories)) {
+            throw new validation_js_1.ValidationError('categories filter must be an array');
+        }
+        // Validate category values
+        if (filters.categories) {
+            const validCategories = ['task', 'decision', 'progress', 'note', 'error', 'warning'];
+            for (const cat of filters.categories) {
+                if (!validCategories.includes(cat)) {
+                    throw new validation_js_1.ValidationError(`Invalid category: ${cat}`);
+                }
+            }
+        }
+        // Validate priorities
+        if (filters.priorities !== undefined && !Array.isArray(filters.priorities)) {
+            throw new validation_js_1.ValidationError('priorities filter must be an array');
+        }
+        // Validate priority values
+        if (filters.priorities) {
+            const validPriorities = ['high', 'normal', 'low'];
+            for (const priority of filters.priorities) {
+                if (!validPriorities.includes(priority)) {
+                    throw new validation_js_1.ValidationError(`Invalid priority: ${priority}`);
+                }
+            }
+        }
+    }
+}
+/**
+ * context_watch handler - unified handler for all watch operations
+ */
+async function handleContextWatch(args, repositories, currentSessionId) {
+    const { action, watcherId, filters } = args;
+    try {
+        switch (action) {
+            case 'create': {
+                // Validate filters
+                validateFilters(filters);
+                // Create watcher
+                const watcher = repositories.watchers.createWatcher({
+                    sessionId: currentSessionId,
+                    filters: filters || {},
+                    ttl: 1800, // 30 minutes default
+                });
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                watcherId: watcher.id,
+                                created: true,
+                                filters: watcher.filters,
+                                currentSequence: watcher.lastSequence,
+                                expiresIn: '30 minutes',
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'poll': {
+                if (!watcherId) {
+                    throw new validation_js_1.ValidationError('watcherId is required for poll action');
+                }
+                // Poll for changes
+                const result = repositories.watchers.pollChanges(watcherId, 100);
+                if (result.watcherStatus === 'deleted') {
+                    throw new validation_js_1.ValidationError(`Watcher not found: ${watcherId}`);
+                }
+                if (result.watcherStatus === 'expired') {
+                    // Check if it's actually stopped vs expired
+                    const watcher = repositories.watchers.getWatcher(watcherId);
+                    if (watcher && !watcher.isActive) {
+                        throw new validation_js_1.ValidationError(`Watcher is stopped: ${watcherId}`);
+                    }
+                    throw new validation_js_1.ValidationError(`Watcher expired: ${watcherId}`);
+                }
+                // Transform changes to match test expectations
+                const transformedChanges = result.changes.map(change => ({
+                    type: change.operation,
+                    key: change.key,
+                    value: change.operation !== 'DELETE' ? change.newValue : undefined,
+                    category: change.category,
+                    channel: change.channel,
+                    sequence: change.sequenceId,
+                    timestamp: change.createdAt,
+                }));
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                watcherId,
+                                changes: transformedChanges,
+                                hasMore: result.hasMore,
+                                lastSequence: result.lastSequence,
+                                polledAt: new Date().toISOString(),
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'stop': {
+                if (!watcherId) {
+                    throw new validation_js_1.ValidationError('watcherId is required for stop action');
+                }
+                const stopped = repositories.watchers.stopWatcher(watcherId);
+                if (!stopped) {
+                    throw new validation_js_1.ValidationError(`Watcher not found: ${watcherId}`);
+                }
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                watcherId,
+                                stopped: true,
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'list': {
+                const watchers = repositories.watchers.listWatchers(currentSessionId);
+                const watcherList = watchers.map(w => ({
+                    watcherId: w.id,
+                    active: w.isActive,
+                    filters: w.filters,
+                    lastSequence: w.lastSequence,
+                    createdAt: w.createdAt,
+                    expiresAt: w.expiresAt,
+                }));
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                watchers: watcherList,
+                                total: watcherList.length,
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
+            default:
+                throw new validation_js_1.ValidationError(`Unknown action: ${action}`);
+        }
+    }
+    catch (error) {
+        if (error instanceof validation_js_1.ValidationError) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `Error: ${error.message}`,
+                    },
+                ],
+            };
+        }
+        throw error;
+    }
+}
+/**
+ * Context watch create handler
+ */
+async function handleContextWatchCreate(args, repositories, currentSessionId) {
+    return handleContextWatch({ ...args, action: 'create' }, repositories, currentSessionId);
+}
+/**
+ * Context watch poll handler
+ */
+async function handleContextWatchPoll(args, repositories, currentSessionId) {
+    return handleContextWatch({ ...args, action: 'poll' }, repositories, currentSessionId);
+}
+/**
+ * Context watch stop handler
+ */
+async function handleContextWatchStop(args, repositories, currentSessionId) {
+    return handleContextWatch({ ...args, action: 'stop' }, repositories, currentSessionId);
+}
+/**
+ * Context watch list handler
+ */
+async function handleContextWatchList(args, repositories, currentSessionId) {
+    return handleContextWatch({ ...args, action: 'list' }, repositories, currentSessionId);
+}