memory-journal-mcp 4.4.2 → 4.5.0

package/tests/server/scheduler.test.ts

@@ -0,0 +1,400 @@
+/**
+ * Tests for Scheduler module
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
+import { Scheduler, type SchedulerOptions } from '../../src/server/Scheduler.js'
+
+// Mock logger
+vi.mock('../../src/utils/logger.js', () => ({
+    logger: {
+        info: vi.fn(),
+        warning: vi.fn(),
+        error: vi.fn(),
+        debug: vi.fn(),
+    },
+}))
+
+/**
+ * Creates a mock SqliteAdapter with the methods used by Scheduler.
+ */
+function createMockDb() {
+    return {
+        exportToFile: vi.fn().mockReturnValue({
+            filename: 'backup_2026-03-01.db',
+            path: '/data/backups/backup_2026-03-01.db',
+            sizeBytes: 4096,
+        }),
+        deleteOldBackups: vi.fn().mockReturnValue({
+            deleted: ['old_backup.db'],
+            kept: 5,
+        }),
+        getRawDb: vi.fn().mockReturnValue({
+            run: vi.fn(),
+        }),
+        flushSave: vi.fn(),
+    }
+}
+
+/**
+ * Creates a mock VectorSearchManager with rebuildIndex.
+ */
+function createMockVectorManager() {
+    return {
+        rebuildIndex: vi.fn().mockResolvedValue(42),
+    }
+}
+
+function defaultOptions(overrides: Partial<SchedulerOptions> = {}): SchedulerOptions {
+    return {
+        backupIntervalMinutes: 0,
+        keepBackups: 5,
+        vacuumIntervalMinutes: 0,
+        rebuildIndexIntervalMinutes: 0,
+        ...overrides,
+    }
+}
+
+describe('Scheduler', () => {
+    beforeEach(() => {
+        vi.useFakeTimers()
+    })
+
+    afterEach(() => {
+        vi.useRealTimers()
+        vi.restoreAllMocks()
+    })
+
+    // ========================================================================
+    // Construction & start/stop
+    // ========================================================================
+
+    describe('start and stop', () => {
+        it('should start with no jobs when all intervals are 0', () => {
+            const db = createMockDb()
+            const scheduler = new Scheduler(defaultOptions(), db as never)
+            scheduler.start()
+
+            const status = scheduler.getStatus()
+            expect(status.active).toBe(true)
+            expect(status.jobs).toHaveLength(0)
+
+            scheduler.stop()
+        })
+
+        it('should create timers for enabled jobs', () => {
+            const db = createMockDb()
+            const vectorManager = createMockVectorManager()
+            const scheduler = new Scheduler(
+                defaultOptions({
+                    backupIntervalMinutes: 60,
+                    vacuumIntervalMinutes: 120,
+                    rebuildIndexIntervalMinutes: 180,
+                }),
+                db as never,
+                vectorManager as never
+            )
+            scheduler.start()
+
+            const status = scheduler.getStatus()
+            expect(status.active).toBe(true)
+            expect(status.jobs).toHaveLength(3)
+            expect(status.jobs.map((j) => j.name)).toEqual(['backup', 'vacuum', 'rebuild-index'])
+
+            scheduler.stop()
+        })
+
+        it('should ignore duplicate start calls', () => {
+            const db = createMockDb()
+            const scheduler = new Scheduler(
+                defaultOptions({ backupIntervalMinutes: 60 }),
+                db as never
+            )
+            scheduler.start()
+            scheduler.start() // duplicate — should be ignored
+
+            const status = scheduler.getStatus()
+            expect(status.jobs).toHaveLength(1) // still just 1
+
+            scheduler.stop()
+        })
+
+        it('should clear all timers on stop', () => {
+            const db = createMockDb()
+            const scheduler = new Scheduler(
+                defaultOptions({ backupIntervalMinutes: 30, vacuumIntervalMinutes: 60 }),
+                db as never
+            )
+            scheduler.start()
+            expect(scheduler.getStatus().jobs).toHaveLength(2)
+
+            scheduler.stop()
+            expect(scheduler.getStatus().active).toBe(false)
+            expect(scheduler.getStatus().jobs).toHaveLength(0)
+        })
+
+        it('should be safe to stop multiple times', () => {
+            const db = createMockDb()
+            const scheduler = new Scheduler(
+                defaultOptions({ backupIntervalMinutes: 30 }),
+                db as never
+            )
+            scheduler.start()
+            scheduler.stop()
+            scheduler.stop() // should not throw
+
+            expect(scheduler.getStatus().active).toBe(false)
+        })
+
+        it('should skip rebuild-index when vectorManager is not provided', () => {
+            const db = createMockDb()
+            const scheduler = new Scheduler(
+                defaultOptions({ rebuildIndexIntervalMinutes: 60 }),
+                db as never
+                // no vectorManager
+            )
+            scheduler.start()
+
+            const status = scheduler.getStatus()
+            expect(status.jobs).toHaveLength(0) // skipped
+
+            scheduler.stop()
+        })
+    })
+
+    // ========================================================================
+    // Job execution
+    // ========================================================================
+
+    describe('backup job', () => {
+        it('should call exportToFile and deleteOldBackups on interval', async () => {
+            const db = createMockDb()
+            const scheduler = new Scheduler(
+                defaultOptions({ backupIntervalMinutes: 1, keepBackups: 3 }),
+                db as never
+            )
+            scheduler.start()
+
+            // Advance by 1 minute
+            await vi.advanceTimersByTimeAsync(60_000)
+
+            expect(db.exportToFile).toHaveBeenCalledOnce()
+            expect(db.deleteOldBackups).toHaveBeenCalledWith(3)
+
+            // Advance another minute
+            await vi.advanceTimersByTimeAsync(60_000)
+
+            expect(db.exportToFile).toHaveBeenCalledTimes(2)
+            expect(db.deleteOldBackups).toHaveBeenCalledTimes(2)
+
+            scheduler.stop()
+        })
+
+        it('should track job status after successful run', async () => {
+            const db = createMockDb()
+            const scheduler = new Scheduler(
+                defaultOptions({ backupIntervalMinutes: 1 }),
+                db as never
+            )
+            scheduler.start()
+
+            await vi.advanceTimersByTimeAsync(60_000)
+
+            const status = scheduler.getStatus()
+            const backupJob = status.jobs.find((j) => j.name === 'backup')
+            expect(backupJob).toBeDefined()
+            expect(backupJob!.lastResult).toBe('success')
+            expect(backupJob!.lastError).toBeNull()
+            expect(backupJob!.runCount).toBe(1)
+            expect(backupJob!.lastRun).toBeTruthy()
+
+            scheduler.stop()
+        })
+
+        it('should track error status when backup fails', async () => {
+            const db = createMockDb()
+            db.exportToFile.mockImplementation(() => {
+                throw new Error('Disk full')
+            })
+
+            const scheduler = new Scheduler(
+                defaultOptions({ backupIntervalMinutes: 1 }),
+                db as never
+            )
+            scheduler.start()
+
+            await vi.advanceTimersByTimeAsync(60_000)
+
+            const status = scheduler.getStatus()
+            const backupJob = status.jobs.find((j) => j.name === 'backup')
+            expect(backupJob!.lastResult).toBe('error')
+            expect(backupJob!.lastError).toBe('Disk full')
+            expect(backupJob!.runCount).toBe(1)
+
+            scheduler.stop()
+        })
+
+        it('should continue running after a failure', async () => {
+            const db = createMockDb()
+            db.exportToFile
+                .mockImplementationOnce(() => {
+                    throw new Error('Disk full')
+                })
+                .mockReturnValue({
+                    filename: 'backup.db',
+                    path: '/data/backups/backup.db',
+                    sizeBytes: 4096,
+                })
+
+            const scheduler = new Scheduler(
+                defaultOptions({ backupIntervalMinutes: 1 }),
+                db as never
+            )
+            scheduler.start()
+
+            // First run — fails
+            await vi.advanceTimersByTimeAsync(60_000)
+            expect(scheduler.getStatus().jobs[0].lastResult).toBe('error')
+
+            // Second run — succeeds
+            await vi.advanceTimersByTimeAsync(60_000)
+            expect(scheduler.getStatus().jobs[0].lastResult).toBe('success')
+            expect(scheduler.getStatus().jobs[0].runCount).toBe(2)
+
+            scheduler.stop()
+        })
+    })
+
+    describe('vacuum job', () => {
+        it('should call PRAGMA optimize and flushSave on interval', async () => {
+            const db = createMockDb()
+            const rawDb = db.getRawDb()
+
+            const scheduler = new Scheduler(
+                defaultOptions({ vacuumIntervalMinutes: 1 }),
+                db as never
+            )
+            scheduler.start()
+
+            await vi.advanceTimersByTimeAsync(60_000)
+
+            expect(rawDb.run).toHaveBeenCalledWith('PRAGMA optimize')
+            expect(db.flushSave).toHaveBeenCalledOnce()
+
+            scheduler.stop()
+        })
+    })
+
+    describe('rebuild-index job', () => {
+        it('should call vectorManager.rebuildIndex on interval', async () => {
+            const db = createMockDb()
+            const vectorManager = createMockVectorManager()
+
+            const scheduler = new Scheduler(
+                defaultOptions({ rebuildIndexIntervalMinutes: 1 }),
+                db as never,
+                vectorManager as never
+            )
+            scheduler.start()
+
+            await vi.advanceTimersByTimeAsync(60_000)
+
+            expect(vectorManager.rebuildIndex).toHaveBeenCalledWith(db)
+
+            const status = scheduler.getStatus()
+            const job = status.jobs.find((j) => j.name === 'rebuild-index')
+            expect(job!.lastResult).toBe('success')
+
+            scheduler.stop()
+        })
+    })
+
+    // ========================================================================
+    // getStatus
+    // ========================================================================
+
+    describe('getStatus', () => {
+        it('should return inactive status before start', () => {
+            const db = createMockDb()
+            const scheduler = new Scheduler(
+                defaultOptions({ backupIntervalMinutes: 60 }),
+                db as never
+            )
+
+            const status = scheduler.getStatus()
+            expect(status.active).toBe(false)
+            expect(status.jobs).toHaveLength(0)
+        })
+
+        it('should include nextRun for jobs that have not run yet', () => {
+            const db = createMockDb()
+            const scheduler = new Scheduler(
+                defaultOptions({ backupIntervalMinutes: 60 }),
+                db as never
+            )
+            scheduler.start()
+
+            const status = scheduler.getStatus()
+            const job = status.jobs[0]
+            expect(job.lastRun).toBeNull()
+            expect(job.nextRun).toBeTruthy()
+
+            scheduler.stop()
+        })
+
+        it('should correctly report interval for each job', () => {
+            const db = createMockDb()
+            const vectorManager = createMockVectorManager()
+            const scheduler = new Scheduler(
+                defaultOptions({
+                    backupIntervalMinutes: 10,
+                    vacuumIntervalMinutes: 20,
+                    rebuildIndexIntervalMinutes: 30,
+                }),
+                db as never,
+                vectorManager as never
+            )
+            scheduler.start()
+
+            const status = scheduler.getStatus()
+            expect(status.jobs[0].intervalMinutes).toBe(10)
+            expect(status.jobs[1].intervalMinutes).toBe(20)
+            expect(status.jobs[2].intervalMinutes).toBe(30)
+
+            scheduler.stop()
+        })
+    })
+
+    // ========================================================================
+    // Error isolation
+    // ========================================================================
+
+    describe('error isolation', () => {
+        it('should not stop other jobs when one fails', async () => {
+            const db = createMockDb()
+            db.exportToFile.mockImplementation(() => {
+                throw new Error('Backup failed')
+            })
+
+            const scheduler = new Scheduler(
+                defaultOptions({
+                    backupIntervalMinutes: 1,
+                    vacuumIntervalMinutes: 1,
+                }),
+                db as never
+            )
+            scheduler.start()
+
+            await vi.advanceTimersByTimeAsync(60_000)
+
+            // Backup failed but vacuum should still have run
+            const status = scheduler.getStatus()
+            const backupJob = status.jobs.find((j) => j.name === 'backup')
+            const vacuumJob = status.jobs.find((j) => j.name === 'vacuum')
+            expect(backupJob!.lastResult).toBe('error')
+            expect(vacuumJob!.lastResult).toBe('success')
+
+            scheduler.stop()
+        })
+    })
+})

package/tests/vector/vector-search-manager.test.ts

@@ -331,5 +331,65 @@ describe('VectorSearchManager', () => {
             const indexed = await vm.rebuildIndex(mockDb as any)
             expect(indexed).toBe(0)
         })
+
+        it('should recover from corrupted index', async () => {
+            await initManager(vm)
+            mockEmbedderFn.mockResolvedValue({ data: fakeEmbedding(0) })
+
+            // First listItems call throws (corrupted index)
+            mockListItems.mockRejectedValueOnce(new Error('Corrupted index'))
+            // After recreation, listItems returns empty
+            mockListItems.mockResolvedValueOnce([])
+            mockInsertItem.mockResolvedValue(undefined)
+
+            const mockDb = {
+                getActiveEntryCount: vi.fn().mockReturnValue(1),
+                getEntriesPage: vi.fn().mockReturnValue([{ id: 1, content: 'Entry' }]),
+            }
+
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const indexed = await vm.rebuildIndex(mockDb as any)
+            expect(indexed).toBe(1)
+        })
+
+        it('should skip entries with embedding failures', async () => {
+            await initManager(vm)
+            // First call succeeds, second fails
+            mockEmbedderFn
+                .mockResolvedValueOnce({ data: fakeEmbedding(1) })
+                .mockRejectedValueOnce(new Error('Embedding failed'))
+            mockListItems.mockResolvedValue([])
+            mockInsertItem.mockResolvedValue(undefined)
+
+            const mockDb = {
+                getActiveEntryCount: vi.fn().mockReturnValue(2),
+                getEntriesPage: vi.fn().mockReturnValue([
+                    { id: 1, content: 'Good entry' },
+                    { id: 2, content: 'Will fail embedding' },
+                ]),
+            }
+
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const indexed = await vm.rebuildIndex(mockDb as any)
+            // Only 1 should be indexed (the other failed)
+            expect(indexed).toBe(1)
+        })
+    })
+
+    // ========================================================================
+    // Initialize Error
+    // ========================================================================
+
+    describe('initialize error', () => {
+        it('should rethrow pipeline errors', async () => {
+            const { pipeline: pipelineMock } = await import('@xenova/transformers')
+            ;(pipelineMock as ReturnType<typeof vi.fn>).mockRejectedValueOnce(
+                new Error('Model not found')
+            )
+
+            const vm2 = new VectorSearchManager('/tmp/test-error.db')
+            await expect(vm2.initialize()).rejects.toThrow('Model not found')
+            expect(vm2.isInitialized()).toBe(false)
+        })
     })
 })

package/.vscode/settings.json

@@ -1,84 +0,0 @@
-{
-    // ═══════════════════════════════════════════════════════════════════════
-    // ESLint Configuration
-    // ═══════════════════════════════════════════════════════════════════════
-    "eslint.enable": true,
-    "eslint.useFlatConfig": true,
-    "eslint.validate": [
-        "javascript",
-        "javascriptreact",
-        "typescript",
-        "typescriptreact",
-        "json",
-        "jsonc",
-        "markdown"
-    ],
-    // Run ESLint on save (provides feedback to agent)
-    "eslint.run": "onSave",
-    // Show severity inline
-    "eslint.rules.customizations": [
-        {
-            "rule": "*",
-            "severity": "warn"
-        }
-    ],
-    // ═══════════════════════════════════════════════════════════════════════
-    // Prettier Configuration
-    // ═══════════════════════════════════════════════════════════════════════
-    "editor.defaultFormatter": "esbenp.prettier-vscode",
-    "editor.formatOnSave": true,
-    "[typescript]": {
-        "editor.defaultFormatter": "esbenp.prettier-vscode"
-    },
-    "[javascript]": {
-        "editor.defaultFormatter": "esbenp.prettier-vscode"
-    },
-    "[json]": {
-        "editor.defaultFormatter": "esbenp.prettier-vscode"
-    },
-    "[jsonc]": {
-        "editor.defaultFormatter": "esbenp.prettier-vscode"
-    },
-    "[markdown]": {
-        "editor.defaultFormatter": "esbenp.prettier-vscode"
-    },
-    "[yaml]": {
-        "editor.defaultFormatter": "esbenp.prettier-vscode"
-    },
-    "[html]": {
-        "editor.defaultFormatter": "esbenp.prettier-vscode"
-    },
-    "[css]": {
-        "editor.defaultFormatter": "esbenp.prettier-vscode"
-    },
-    // ═══════════════════════════════════════════════════════════════════════
-    // Error Lens Configuration
-    // ═══════════════════════════════════════════════════════════════════════
-    "errorLens.enabled": true,
-    "errorLens.enabledDiagnosticLevels": ["error", "warning", "info"],
-    "errorLens.messageEnabled": true,
-    "errorLens.statusBarMessageEnabled": true,
-    "errorLens.gutterIconsEnabled": true,
-    // Delay to avoid flicker during active typing
-    "errorLens.delay": 500,
-    // Exclude noisy hints if needed
-    "errorLens.excludeBySource": [],
-    // ═══════════════════════════════════════════════════════════════════════
-    // TypeScript Configuration (Built-in)
-    // ═══════════════════════════════════════════════════════════════════════
-    "typescript.preferences.importModuleSpecifier": "relative",
-    "typescript.updateImportsOnFileMove.enabled": "always",
-    "typescript.suggest.autoImports": true,
-    "typescript.tsdk": "node_modules/typescript/lib",
-    // ═══════════════════════════════════════════════════════════════════════
-    // Editor Behavior
-    // ═══════════════════════════════════════════════════════════════════════
-    "editor.codeActionsOnSave": {
-        "source.fixAll.eslint": "explicit",
-        "source.organizeImports": "never"
-    },
-    "files.trimTrailingWhitespace": true,
-    "files.insertFinalNewline": true,
-    "files.trimFinalNewlines": true,
-    "files.eol": "\n"
-}