memory-journal-mcp 4.3.0 → 4.4.0

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

@@ -0,0 +1,335 @@
+/**
+ * VectorSearchManager Tests
+ *
+ * Tests VectorSearchManager with mocked @xenova/transformers pipeline
+ * and vectra LocalIndex. No real model loading or file I/O needed.
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+
+// ============================================================================
+// Hoisted mock functions (must be declared before vi.mock)
+// ============================================================================
+
+const {
+    mockEmbedderFn,
+    mockIsIndexCreated,
+    mockCreateIndex,
+    mockInsertItem,
+    mockDeleteItem,
+    mockQueryItems,
+    mockListItems,
+    mockGetIndexStats,
+} = vi.hoisted(() => ({
+    mockEmbedderFn: vi.fn(),
+    mockIsIndexCreated: vi.fn(),
+    mockCreateIndex: vi.fn(),
+    mockInsertItem: vi.fn(),
+    mockDeleteItem: vi.fn(),
+    mockQueryItems: vi.fn(),
+    mockListItems: vi.fn(),
+    mockGetIndexStats: vi.fn(),
+}))
+
+// ============================================================================
+// Module mocks
+// ============================================================================
+
+vi.mock('vectra', () => ({
+    LocalIndex: function () {
+        return {
+            isIndexCreated: mockIsIndexCreated,
+            createIndex: mockCreateIndex,
+            insertItem: mockInsertItem,
+            deleteItem: mockDeleteItem,
+            queryItems: mockQueryItems,
+            listItems: mockListItems,
+            getIndexStats: mockGetIndexStats,
+        }
+    },
+}))
+
+vi.mock('@xenova/transformers', () => ({
+    pipeline: vi.fn().mockResolvedValue(mockEmbedderFn),
+}))
+
+vi.mock('node:fs', async (importOriginal) => {
+    const real = (await importOriginal()) as Record<string, unknown>
+    return {
+        ...real,
+        existsSync: vi.fn().mockReturnValue(true),
+        mkdirSync: vi.fn(),
+        rmSync: vi.fn(),
+    }
+})
+
+// Import AFTER mocks are set up
+import { VectorSearchManager } from '../../src/vector/VectorSearchManager.js'
+
+/**
+ * Helper to make the VectorSearchManager think it's initialized
+ */
+async function initManager(vm: VectorSearchManager): Promise<void> {
+    mockIsIndexCreated.mockResolvedValue(true)
+    mockEmbedderFn.mockResolvedValue({ data: new Float32Array(384) })
+    await vm.initialize()
+}
+
+/** Generate a fake embedding vector of length 384 */
+function fakeEmbedding(seed = 0): Float32Array {
+    const arr = new Float32Array(384)
+    for (let i = 0; i < 384; i++) arr[i] = Math.sin(i + seed) * 0.1
+    return arr
+}
+
+describe('VectorSearchManager', () => {
+    let vm: VectorSearchManager
+
+    beforeEach(() => {
+        vi.clearAllMocks()
+        vm = new VectorSearchManager('/tmp/test.db')
+    })
+
+    // ========================================================================
+    // Initialization
+    // ========================================================================
+
+    describe('isInitialized', () => {
+        it('should return false before initialize()', () => {
+            expect(vm.isInitialized()).toBe(false)
+        })
+
+        it('should return true after initialize()', async () => {
+            await initManager(vm)
+            expect(vm.isInitialized()).toBe(true)
+        })
+    })
+
+    describe('initialize', () => {
+        it('should load pipeline and create index if needed', async () => {
+            mockIsIndexCreated.mockResolvedValue(false)
+            mockEmbedderFn.mockResolvedValue({ data: new Float32Array(384) })
+
+            await vm.initialize()
+
+            expect(mockCreateIndex).toHaveBeenCalled()
+            expect(vm.isInitialized()).toBe(true)
+        })
+
+        it('should be idempotent', async () => {
+            await initManager(vm)
+            await vm.initialize()
+            expect(vm.isInitialized()).toBe(true)
+        })
+    })
+
+    // ========================================================================
+    // Generate Embedding
+    // ========================================================================
+
+    describe('generateEmbedding', () => {
+        it('should generate embedding array from text', async () => {
+            await initManager(vm)
+            mockEmbedderFn.mockResolvedValue({ data: fakeEmbedding(42) })
+
+            const embedding = await vm.generateEmbedding('test text')
+            expect(embedding).toHaveLength(384)
+            expect(typeof embedding[0]).toBe('number')
+        })
+
+        it('should throw if not initialized', async () => {
+            await expect(vm.generateEmbedding('test')).rejects.toThrow('not initialized')
+        })
+    })
+
+    // ========================================================================
+    // Add Entry
+    // ========================================================================
+
+    describe('addEntry', () => {
+        it('should upsert entry (delete+insert)', async () => {
+            await initManager(vm)
+            mockEmbedderFn.mockResolvedValue({ data: fakeEmbedding(1) })
+            mockDeleteItem.mockResolvedValue(undefined)
+            mockInsertItem.mockResolvedValue(undefined)
+
+            const result = await vm.addEntry(42, 'Some content')
+            expect(result).toBe(true)
+
+            expect(mockDeleteItem).toHaveBeenCalledWith('42')
+            expect(mockInsertItem).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    id: '42',
+                    metadata: expect.objectContaining({ entryId: 42 }),
+                })
+            )
+        })
+
+        it('should return false on error', async () => {
+            await initManager(vm)
+            mockEmbedderFn.mockRejectedValue(new Error('Embedding failed'))
+
+            const result = await vm.addEntry(99, 'Content')
+            expect(result).toBe(false)
+        })
+    })
+
+    // ========================================================================
+    // Search
+    // ========================================================================
+
+    describe('search', () => {
+        it('should return filtered results above threshold', async () => {
+            await initManager(vm)
+            mockEmbedderFn.mockResolvedValue({ data: fakeEmbedding(0) })
+            mockQueryItems.mockResolvedValue([
+                { score: 0.9, item: { metadata: { entryId: 1 } } },
+                { score: 0.5, item: { metadata: { entryId: 2 } } },
+                { score: 0.1, item: { metadata: { entryId: 3 } } },
+            ])
+
+            const results = await vm.search('query text', 10, 0.3)
+            expect(results).toHaveLength(2)
+            expect(results[0]!.entryId).toBe(1)
+            expect(results[0]!.score).toBe(0.9)
+        })
+
+        it('should limit results to limit param', async () => {
+            await initManager(vm)
+            mockEmbedderFn.mockResolvedValue({ data: fakeEmbedding(0) })
+            mockQueryItems.mockResolvedValue([
+                { score: 0.9, item: { metadata: { entryId: 1 } } },
+                { score: 0.8, item: { metadata: { entryId: 2 } } },
+                { score: 0.7, item: { metadata: { entryId: 3 } } },
+            ])
+
+            const results = await vm.search('query', 2, 0.3)
+            expect(results).toHaveLength(2)
+        })
+
+        it('should return empty on error', async () => {
+            await initManager(vm)
+            mockEmbedderFn.mockRejectedValue(new Error('Embed fail'))
+
+            const results = await vm.search('query')
+            expect(results).toEqual([])
+        })
+    })
+
+    // ========================================================================
+    // Remove Entry
+    // ========================================================================
+
+    describe('removeEntry', () => {
+        it('should delete entry from index', async () => {
+            await initManager(vm)
+            mockDeleteItem.mockResolvedValue(undefined)
+
+            const result = await vm.removeEntry(42)
+            expect(result).toBe(true)
+            expect(mockDeleteItem).toHaveBeenCalledWith('42')
+        })
+
+        it('should return false if index not available', async () => {
+            const result = await vm.removeEntry(42)
+            expect(result).toBe(false)
+        })
+
+        it('should return false on delete error', async () => {
+            await initManager(vm)
+            mockDeleteItem.mockRejectedValue(new Error('Not found'))
+
+            const result = await vm.removeEntry(999)
+            expect(result).toBe(false)
+        })
+    })
+
+    // ========================================================================
+    // Get Stats
+    // ========================================================================
+
+    describe('getStats', () => {
+        it('should return stats from index', async () => {
+            await initManager(vm)
+            mockGetIndexStats.mockResolvedValue({ items: 100 })
+
+            const stats = await vm.getStats()
+            expect(stats.itemCount).toBe(100)
+            expect(stats.modelName).toBe('Xenova/all-MiniLM-L6-v2')
+            expect(stats.dimensions).toBe(384)
+        })
+
+        it('should return zero count when no index', async () => {
+            const stats = await vm.getStats()
+            expect(stats.itemCount).toBe(0)
+        })
+
+        it('should return zero count on error', async () => {
+            await initManager(vm)
+            mockGetIndexStats.mockRejectedValue(new Error('Corrupted'))
+
+            const stats = await vm.getStats()
+            expect(stats.itemCount).toBe(0)
+        })
+    })
+
+    // ========================================================================
+    // Rebuild Index
+    // ========================================================================
+
+    describe('rebuildIndex', () => {
+        it('should rebuild from database entries', async () => {
+            await initManager(vm)
+            mockEmbedderFn.mockResolvedValue({ data: fakeEmbedding(0) })
+            mockListItems.mockResolvedValue([])
+            mockInsertItem.mockResolvedValue(undefined)
+
+            const mockDb = {
+                getActiveEntryCount: vi.fn().mockReturnValue(2),
+                getEntriesPage: vi.fn().mockReturnValue([
+                    { id: 1, content: 'Entry one' },
+                    { id: 2, content: 'Entry two' },
+                ]),
+            }
+
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const indexed = await vm.rebuildIndex(mockDb as any)
+            expect(indexed).toBe(2)
+            expect(mockInsertItem).toHaveBeenCalledTimes(2)
+        })
+
+        it('should handle orphan cleanup', async () => {
+            await initManager(vm)
+            mockEmbedderFn.mockResolvedValue({ data: fakeEmbedding(0) })
+
+            mockListItems
+                .mockResolvedValueOnce([{ id: '999' }])
+                .mockResolvedValueOnce([])
+                .mockResolvedValueOnce([])
+
+            mockDeleteItem.mockResolvedValue(undefined)
+            mockInsertItem.mockResolvedValue(undefined)
+
+            const mockDb = {
+                getActiveEntryCount: vi.fn().mockReturnValue(1),
+                getEntriesPage: vi.fn().mockReturnValue([{ id: 1, content: 'Active entry' }]),
+            }
+
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const indexed = await vm.rebuildIndex(mockDb as any)
+            expect(indexed).toBe(1)
+            expect(mockDeleteItem).toHaveBeenCalledWith('999')
+        })
+
+        it('should return 0 when index not available', async () => {
+            const mockDb = {
+                getActiveEntryCount: vi.fn().mockReturnValue(0),
+                getEntriesPage: vi.fn().mockReturnValue([]),
+            }
+
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const indexed = await vm.rebuildIndex(mockDb as any)
+            expect(indexed).toBe(0)
+        })
+    })
+})

package/tests/vector/vector-search.bench.ts

@@ -0,0 +1,53 @@
+import { bench, beforeAll, afterAll } from 'vitest'
+import { VectorSearchManager } from '../../src/vector/VectorSearchManager.js'
+import { SqliteAdapter } from '../../src/database/SqliteAdapter.js'
+import * as fs from 'node:fs'
+import * as path from 'node:path'
+
+let vm: VectorSearchManager
+let db: SqliteAdapter
+const testDbPath = path.join(process.cwd(), 'benchmark-vector.db')
+const testVectorPath = path.join(process.cwd(), 'benchmark-vector-index')
+
+beforeAll(async () => {
+    db = new SqliteAdapter(testDbPath)
+    await db.initialize()
+
+    vm = new VectorSearchManager(testVectorPath)
+
+    // Mock the embedding generation to skip transformer inference delay
+    vm.generateEmbedding = async () => new Float32Array(384).fill(Math.random())
+
+    await vm.initialize()
+
+    // Setup some data
+    for (let i = 0; i < 100; i++) {
+        const entry = db.createEntry({
+            content: `Vector benchmark entry ${i} content`,
+        })
+        await vm.addEntry(entry.id, entry.content)
+    }
+})
+
+afterAll(() => {
+    db.close()
+    try {
+        if (fs.existsSync(testDbPath)) {
+            fs.unlinkSync(testDbPath)
+        }
+        if (fs.existsSync(testVectorPath)) {
+            fs.rmSync(testVectorPath, { recursive: true, force: true })
+        }
+    } catch {
+        // ignore
+    }
+})
+
+bench('addEntry', async () => {
+    const id = Math.floor(Math.random() * 1000000)
+    await vm.addEntry(id, `New content for adding id ${id}`)
+})
+
+bench('search', async () => {
+    await vm.search('Vector benchmark entry 42', 10, 0.1)
+})

package/vitest.config.ts

@@ -0,0 +1,15 @@
+import { defineConfig } from 'vitest/config'
+
+export default defineConfig({
+    test: {
+        globals: true,
+        environment: 'node',
+        include: ['tests/**/*.test.ts'],
+        coverage: {
+            provider: 'v8',
+            reporter: ['text', 'html'],
+            include: ['src/**/*.ts'],
+            exclude: ['src/cli.ts', 'src/index.ts'],
+        },
+    },
+})