memory-journal-mcp 6.1.2 → 6.2.1

package/tests/utils/security-utils.test.ts

@@ -1,82 +0,0 @@
-/**
- * Security Utilities Tests - sanitizeErrorForLogging
- *
- * Covers the token scrubbing function not tested by sql-injection.test.ts.
- */
-
-import { describe, it, expect } from 'vitest'
-import { sanitizeErrorForLogging } from '../../src/utils/security-utils.js'
-
-describe('sanitizeErrorForLogging', () => {
-    it('should redact GitHub classic PATs (ghp_)', () => {
-        const token = 'ghp_' + 'A'.repeat(36)
-        const message = `Request failed: token ${token} is invalid`
-        const result = sanitizeErrorForLogging(message)
-
-        expect(result).not.toContain(token)
-        expect(result).toContain('[REDACTED]')
-        expect(result).toBe('Request failed: token [REDACTED] is invalid')
-    })
-
-    it('should redact GitHub fine-grained PATs (github_pat_)', () => {
-        const token = 'github_pat_' + 'B'.repeat(82)
-        const message = `Auth error with ${token}`
-        const result = sanitizeErrorForLogging(message)
-
-        expect(result).not.toContain(token)
-        expect(result).toContain('[REDACTED]')
-    })
-
-    it('should redact Authorization headers with token', () => {
-        const message =
-            'Failed request with Authorization: token ghp_secret123456789012345678901234567890'
-        const result = sanitizeErrorForLogging(message)
-
-        expect(result).toContain('[REDACTED]')
-        expect(result).not.toContain('ghp_secret')
-    })
-
-    it('should redact Authorization headers with Bearer', () => {
-        const message = 'Error: Authorization: Bearer eyJhbGciOiJIUzI1NiJ9.payload.sig'
-        const result = sanitizeErrorForLogging(message)
-
-        expect(result).toContain('[REDACTED]')
-        expect(result).not.toContain('eyJhbGciOiJIUzI1NiJ9')
-    })
-
-    it('should redact generic Bearer tokens', () => {
-        const message = 'Token expired: Bearer abc123.def456.ghi789+/=='
-        const result = sanitizeErrorForLogging(message)
-
-        expect(result).toContain('[REDACTED]')
-        expect(result).not.toContain('abc123.def456')
-    })
-
-    it('should pass through clean messages unchanged', () => {
-        const message = 'Database connection failed at localhost:5432'
-        expect(sanitizeErrorForLogging(message)).toBe(message)
-    })
-
-    it('should pass through empty string', () => {
-        expect(sanitizeErrorForLogging('')).toBe('')
-    })
-
-    it('should handle multiple tokens in one message', () => {
-        const token1 = 'ghp_' + 'C'.repeat(36)
-        const token2 = 'ghp_' + 'D'.repeat(36)
-        const message = `Token1: ${token1}, Token2: ${token2}`
-        const result = sanitizeErrorForLogging(message)
-
-        expect(result).not.toContain(token1)
-        expect(result).not.toContain(token2)
-        expect(result).toBe('Token1: [REDACTED], Token2: [REDACTED]')
-    })
-
-    it('should be idempotent - calling twice yields same result', () => {
-        const token = 'ghp_' + 'E'.repeat(36)
-        const message = `Error with ${token}`
-        const first = sanitizeErrorForLogging(message)
-        const second = sanitizeErrorForLogging(first)
-        expect(first).toBe(second)
-    })
-})

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

@@ -1,111 +0,0 @@
-/**
- * memory-journal-mcp — Vector Search Manager Branch Coverage Tests
- *
- * Targets uncovered branches: not-initialized auto-init, no-db guard,
- * embedding error during rebuild, insert error during rebuild,
- * and progress reporting.
- */
-
-import { describe, it, expect, vi, beforeEach } from 'vitest'
-
-vi.mock('../../src/utils/logger.js', () => ({
-    logger: { info: vi.fn(), warning: vi.fn(), error: vi.fn(), debug: vi.fn() },
-}))
-
-vi.mock('../../src/utils/progress-utils.js', () => ({
-    sendProgress: vi.fn().mockResolvedValue(undefined),
-}))
-
-import { VectorSearchManager } from '../../src/vector/vector-search-manager.js'
-
-// ============================================================================
-// Tests
-// ============================================================================
-
-describe('VectorSearchManager — branch coverage', () => {
-    beforeEach(() => {
-        vi.clearAllMocks()
-    })
-
-    it('should return false from addEntry when no db after initialize', async () => {
-        const manager = new VectorSearchManager('/nonexistent/path.db')
-
-        // Force skipping real initialization by marking it as initialized
-        // but with no db connection
-        Object.assign(manager, { initialized: true, db: null })
-
-        const result = await manager.addEntry(1, 'test content')
-        expect(result).toEqual({ success: false, error: 'Vector database not available' })
-    })
-
-    it('should return empty results from search when no db after initialize', async () => {
-        const manager = new VectorSearchManager('/nonexistent/path.db')
-        Object.assign(manager, { initialized: true, db: null })
-
-        const result = await manager.search('test query')
-        expect(result).toEqual([])
-    })
-
-    it('should return 0 from rebuildIndex when no db', async () => {
-        const manager = new VectorSearchManager('/nonexistent/path.db')
-        Object.assign(manager, { initialized: true, db: null })
-
-        const mockDbAdapter = {
-            getActiveEntryCount: vi.fn().mockReturnValue(0),
-            getEntriesPage: vi.fn().mockReturnValue([]),
-        }
-
-        const result = await manager.rebuildIndex(mockDbAdapter as never)
-        expect(result).toEqual({ indexed: 0, failed: 0, firstError: null })
-    })
-
-    it('should return stats with zero values when no db', async () => {
-        const manager = new VectorSearchManager('/nonexistent/path.db')
-        Object.assign(manager, { initialized: true, db: null })
-
-        const result = manager.getStats()
-        expect(result.itemCount).toBe(0)
-    })
-
-    it('should auto-initialize when calling addEntry on uninitialized manager', async () => {
-        const manager = new VectorSearchManager('/nonexistent/path.db')
-
-        // Mock initialize to just set initialized flag without connecting
-        const initSpy = vi.spyOn(manager, 'initialize').mockImplementation(async () => {
-            Object.assign(manager, { initialized: true, db: null })
-        })
-
-        const result = await manager.addEntry(1, 'test')
-        expect(initSpy).toHaveBeenCalled()
-        expect(result).toEqual({ success: false, error: 'Vector database not available' }) // no db, so returns structured error
-    })
-
-    it('should auto-initialize when calling search on uninitialized manager', async () => {
-        const manager = new VectorSearchManager('/nonexistent/path.db')
-
-        const initSpy = vi.spyOn(manager, 'initialize').mockImplementation(async () => {
-            Object.assign(manager, { initialized: true, db: null })
-        })
-
-        const result = await manager.search('query')
-        expect(initSpy).toHaveBeenCalled()
-        expect(result).toEqual([])
-    })
-
-    it('should auto-initialize when calling rebuildIndex on uninitialized manager', async () => {
-        const manager = new VectorSearchManager('/nonexistent/path.db')
-
-        const initSpy = vi.spyOn(manager, 'initialize').mockImplementation(async () => {
-            Object.assign(manager, { initialized: true, db: null })
-        })
-
-        const mockDbAdapter = {
-            getActiveEntryCount: vi.fn().mockReturnValue(0),
-            getEntriesPage: vi.fn().mockReturnValue([]),
-        }
-
-        const result = await manager.rebuildIndex(mockDbAdapter as never)
-        expect(initSpy).toHaveBeenCalled()
-        expect(result).toEqual({ indexed: 0, failed: 0, firstError: null })
-    })
-})

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

@@ -1,375 +0,0 @@
-/**
- * VectorSearchManager Tests
- *
- * Tests VectorSearchManager with mocked @huggingface/transformers pipeline
- * and mocked better-sqlite3 database. No real model loading or extension I/O needed.
- */
-
-import { describe, it, expect, vi, beforeEach } from 'vitest'
-
-// ============================================================================
-// Hoisted mock functions (must be declared before vi.mock)
-// ============================================================================
-
-const { mockEmbedderFn, mockPrepare, mockRun, mockAll, mockGet } = vi.hoisted(() => ({
-    mockEmbedderFn: vi.fn(),
-    mockPrepare: vi.fn(),
-    mockRun: vi.fn(),
-    mockAll: vi.fn(),
-    mockGet: vi.fn(),
-}))
-
-// ============================================================================
-// Module mocks
-// ============================================================================
-
-vi.mock('@huggingface/transformers', () => ({
-    pipeline: vi.fn().mockResolvedValue(mockEmbedderFn),
-}))
-
-// Import AFTER mocks are set up
-import { VectorSearchManager } from '../../src/vector/vector-search-manager.js'
-import type { IDatabaseAdapter } from '../../src/database/core/interfaces.js'
-import type { DatabaseAdapter } from '../../src/database/sqlite-adapter/index.js'
-
-/**
- * Creates a mock IDatabaseAdapter whose getRawDb() returns a mock better-sqlite3 Database.
- */
-function createMockDbAdapter() {
-    // Mock the prepare().run() / prepare().all() / prepare().get() chain
-    mockPrepare.mockReturnValue({
-        run: mockRun,
-        all: mockAll,
-        get: mockGet,
-    })
-
-    const mockDb = {
-        prepare: mockPrepare,
-        exec: vi.fn(),
-    }
-
-    const adapter = {
-        getRawDb: vi.fn().mockReturnValue(mockDb),
-        getActiveEntryCount: vi.fn().mockReturnValue(0),
-        getEntriesPage: vi.fn().mockReturnValue([]),
-    } as unknown as IDatabaseAdapter
-
-    return { adapter, mockDb }
-}
-
-/**
- * Helper to make the VectorSearchManager think it's initialized
- */
-async function initManager(vm: VectorSearchManager): Promise<void> {
-    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
-    let adapter: IDatabaseAdapter
-
-    beforeEach(() => {
-        vi.clearAllMocks()
-        const mocks = createMockDbAdapter()
-        adapter = mocks.adapter
-        vm = new VectorSearchManager(adapter)
-    })
-
-    // ========================================================================
-    // 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 get raw database', async () => {
-            mockEmbedderFn.mockResolvedValue({ data: new Float32Array(384) })
-            await vm.initialize()
-
-            expect(adapter.getRawDb).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 insert entry via SQL prepared statement', async () => {
-            await initManager(vm)
-            mockEmbedderFn.mockResolvedValue({ data: fakeEmbedding(1) })
-            mockRun.mockReturnValue(undefined)
-
-            const result = await vm.addEntry(42, 'Some content')
-            expect(result.success).toBe(true)
-
-            // Should prepare DELETE then INSERT statements
-            expect(mockPrepare).toHaveBeenCalledWith(
-                'DELETE FROM vec_embeddings WHERE entry_id = ?'
-            )
-            expect(mockPrepare).toHaveBeenCalledWith(
-                'INSERT INTO vec_embeddings(entry_id, embedding) VALUES (?, ?)'
-            )
-            // Should call run with BigInt entryId for DELETE, and BigInt + Float32Array for INSERT
-            expect(mockRun).toHaveBeenCalledWith(BigInt(42))
-            expect(mockRun).toHaveBeenCalledWith(BigInt(42), expect.any(Float32Array))
-        })
-
-        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.success).toBe(false)
-            expect(result.error).toBeDefined()
-        })
-    })
-
-    // ========================================================================
-    // Search
-    // ========================================================================
-
-    describe('search', () => {
-        it('should return filtered results above threshold', async () => {
-            await initManager(vm)
-            mockEmbedderFn.mockResolvedValue({ data: fakeEmbedding(0) })
-
-            // sqlite-vec returns distance (lower = more similar)
-            // score = 1 / (1 + distance)
-            // distance=0.1 -> score≈0.91, distance=1.0 -> score=0.5, distance=9.0 -> score=0.1
-            mockAll.mockReturnValue([
-                { entry_id: 1, distance: 0.1 },
-                { entry_id: 2, distance: 1.0 },
-                { entry_id: 3, distance: 9.0 },
-            ])
-
-            const results = await vm.search('query text', 10, 0.3)
-            expect(results).toHaveLength(2)
-            expect(results[0]!.entryId).toBe(1)
-            expect(results[0]!.score).toBeCloseTo(1 / 1.1, 2)
-        })
-
-        it('should limit results to limit param', async () => {
-            await initManager(vm)
-            mockEmbedderFn.mockResolvedValue({ data: fakeEmbedding(0) })
-            mockAll.mockReturnValue([
-                { entry_id: 1, distance: 0.1 },
-                { entry_id: 2, distance: 0.2 },
-                { entry_id: 3, distance: 0.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 via SQL', async () => {
-            await initManager(vm)
-            mockRun.mockReturnValue(undefined)
-
-            const result = await vm.removeEntry(42)
-            expect(result).toBe(true)
-            expect(mockPrepare).toHaveBeenCalledWith(
-                'DELETE FROM vec_embeddings WHERE entry_id = ?'
-            )
-            expect(mockRun).toHaveBeenCalledWith(BigInt(42))
-        })
-
-        it('should return false if db not available', async () => {
-            const result = await vm.removeEntry(42)
-            expect(result).toBe(false)
-        })
-
-        it('should return false on delete error', async () => {
-            await initManager(vm)
-            mockRun.mockImplementation(() => {
-                throw new Error('SQL error')
-            })
-
-            const result = await vm.removeEntry(999)
-            expect(result).toBe(false)
-        })
-    })
-
-    // ========================================================================
-    // Get Stats
-    // ========================================================================
-
-    describe('getStats', () => {
-        it('should return count from SQL', async () => {
-            await initManager(vm)
-            mockGet.mockReturnValue({ count: 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 db', async () => {
-            const stats = await vm.getStats()
-            expect(stats.itemCount).toBe(0)
-        })
-
-        it('should return zero count on error', async () => {
-            await initManager(vm)
-            mockGet.mockImplementation(() => {
-                throw new Error('SQL error')
-            })
-
-            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) })
-            mockRun.mockReturnValue(undefined)
-
-            const mockDb = {
-                getActiveEntryCount: vi.fn().mockReturnValue(2),
-                getEntriesPage: vi.fn().mockReturnValue([
-                    { id: 1, content: 'Entry one' },
-                    { id: 2, content: 'Entry two' },
-                ]),
-            }
-
-            const result = await vm.rebuildIndex(mockDb as unknown as DatabaseAdapter)
-            expect(result.indexed).toBe(2)
-            expect(result.failed).toBe(0)
-            expect(result.firstError).toBeNull()
-            // DELETE to clear + 2 INSERTs
-            expect(mockRun).toHaveBeenCalledTimes(3)
-        })
-
-        it('should clear existing embeddings before rebuild', async () => {
-            await initManager(vm)
-            mockEmbedderFn.mockResolvedValue({ data: fakeEmbedding(0) })
-            mockRun.mockReturnValue(undefined)
-
-            const mockDb = {
-                getActiveEntryCount: vi.fn().mockReturnValue(1),
-                getEntriesPage: vi.fn().mockReturnValue([{ id: 1, content: 'Active entry' }]),
-            }
-
-            const result = await vm.rebuildIndex(mockDb as unknown as DatabaseAdapter)
-            expect(result.indexed).toBe(1)
-
-            // First call should be DELETE FROM vec_embeddings
-            expect(mockPrepare).toHaveBeenCalledWith('DELETE FROM vec_embeddings')
-        })
-
-        it('should return 0 when db not available', async () => {
-            const mockDb = {
-                getActiveEntryCount: vi.fn().mockReturnValue(0),
-                getEntriesPage: vi.fn().mockReturnValue([]),
-            }
-
-            const result = await vm.rebuildIndex(mockDb as unknown as DatabaseAdapter)
-            expect(result.indexed).toBe(0)
-            expect(result.failed).toBe(0)
-        })
-
-        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'))
-            mockRun.mockReturnValue(undefined)
-
-            const mockDb = {
-                getActiveEntryCount: vi.fn().mockReturnValue(2),
-                getEntriesPage: vi.fn().mockReturnValue([
-                    { id: 1, content: 'Good entry' },
-                    { id: 2, content: 'Will fail embedding' },
-                ]),
-            }
-
-            const result = await vm.rebuildIndex(mockDb as unknown as DatabaseAdapter)
-            // Only 1 should be indexed (the other failed)
-            expect(result.indexed).toBe(1)
-            expect(result.failed).toBe(1)
-            expect(result.firstError).toBe('Embedding failed')
-        })
-    })
-
-    // ========================================================================
-    // Initialize Error
-    // ========================================================================
-
-    describe('initialize error', () => {
-        it('should rethrow pipeline errors', async () => {
-            const { pipeline: pipelineMock } = await import('@huggingface/transformers')
-            ;(pipelineMock as ReturnType<typeof vi.fn>).mockRejectedValueOnce(
-                new Error('Model not found')
-            )
-
-            const vm2 = new VectorSearchManager(adapter)
-            await expect(vm2.initialize()).rejects.toThrow('Model not found')
-            expect(vm2.isInitialized()).toBe(false)
-        })
-    })
-})

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

@@ -1,48 +0,0 @@
-import { bench, beforeAll, afterAll } from 'vitest'
-import { VectorSearchManager } from '../../src/vector/vector-search-manager.js'
-import { DatabaseAdapter } from '../../src/database/sqlite-adapter/index.js'
-import * as fs from 'node:fs'
-
-let vm: VectorSearchManager
-let db: DatabaseAdapter
-const testDbPath = './benchmark-vector.db'
-
-beforeAll(async () => {
-    db = new DatabaseAdapter(testDbPath)
-    await db.initialize()
-
-    vm = new VectorSearchManager(db)
-
-    // Mock the embedding generation to skip transformer inference delay
-    vm.generateEmbedding = async () => Array.from(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)
-        }
-    } 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/tsconfig.json

@@ -1,42 +0,0 @@
-{
-    "compilerOptions": {
-        "target": "ES2022",
-        "module": "NodeNext",
-        "moduleResolution": "NodeNext",
-        "lib": ["ES2022"],
-        "outDir": "./dist",
-        "rootDir": "./src",
-        "skipLibCheck": true,
-        /* Strict Type-Checking Options */
-        "strict": true,
-        "noImplicitAny": true,
-        "strictNullChecks": true,
-        "strictFunctionTypes": true,
-        "strictBindCallApply": true,
-        "strictPropertyInitialization": true,
-        "noImplicitThis": true,
-        "useUnknownInCatchVariables": true,
-        "alwaysStrict": true,
-        "exactOptionalPropertyTypes": false,
-        /* Additional Checks */
-        "noUnusedLocals": true,
-        "noUnusedParameters": true,
-        "noImplicitReturns": true,
-        "noFallthroughCasesInSwitch": true,
-        "noUncheckedIndexedAccess": true,
-        "noImplicitOverride": true,
-        "noPropertyAccessFromIndexSignature": true,
-        "allowUnusedLabels": false,
-        "allowUnreachableCode": false,
-        "noUncheckedSideEffectImports": true,
-        /* Module Resolution */
-        "forceConsistentCasingInFileNames": true,
-        "resolveJsonModule": true,
-        "esModuleInterop": true,
-        "declaration": true,
-        "declarationMap": true,
-        "sourceMap": false
-    },
-    "include": ["src/**/*"],
-    "exclude": ["node_modules", "dist", "**/*.test.ts", "**/*.spec.ts"]
-}

package/tsup.config.ts

@@ -1,19 +0,0 @@
-import { defineConfig } from 'tsup'
-
-export default defineConfig({
-    entry: {
-        index: 'src/index.ts',
-        cli: 'src/cli.ts',
-        'worker-script': 'src/codemode/worker-script.ts',
-    },
-    format: ['esm'],
-    dts: true,
-    clean: true,
-    treeshake: true,
-    splitting: true,
-    sourcemap: false,
-    minify: false,
-    outDir: 'dist',
-    target: 'es2022',
-    external: ['better-sqlite3', 'sqlite-vec', '@huggingface/transformers'],
-})