memory-journal-mcp 6.1.2 → 6.2.1

package/tests/handlers/handler-error-branches.test.ts

@@ -1,346 +0,0 @@
-/**
- * Handler Error Branches Coverage Tests
- *
- * Tests for remaining uncovered branches in:
- * - search.ts: FTS fallback for invalid queries, semantic_search error handling
- * - relationships.ts: depth parameter traversal branches
- * - export.ts: markdown format branch
- * - index.ts: callTool with progress context, unknown tool error
- * - admin.ts: get_vector_index_stats without vector manager
- */
-
-import { describe, it, expect, beforeAll, afterAll, vi } from 'vitest'
-import { callTool, getTools } from '../../src/handlers/tools/index.js'
-import { DatabaseAdapter } from '../../src/database/sqlite-adapter/index.js'
-import type { VectorSearchManager } from '../../src/vector/vector-search-manager.js'
-
-function createMockVector(overrides: Partial<Record<string, unknown>> = {}): VectorSearchManager {
-    const defaults = {
-        isInitialized: vi.fn().mockReturnValue(true),
-        initialize: vi.fn().mockResolvedValue(undefined),
-        search: vi.fn().mockResolvedValue([]),
-        addEntry: vi.fn().mockResolvedValue(true),
-        removeEntry: vi.fn().mockResolvedValue(true),
-        rebuildIndex: vi.fn().mockResolvedValue(5),
-        getStats: vi.fn().mockReturnValue({
-            itemCount: 10,
-            modelName: 'Xenova/all-MiniLM-L6-v2',
-            dimensions: 384,
-        }),
-        generateEmbedding: vi.fn().mockResolvedValue(new Array(384).fill(0)),
-    }
-    return { ...defaults, ...overrides } as unknown as VectorSearchManager
-}
-
-describe('Handler Error Branches', () => {
-    let db: DatabaseAdapter
-    const testDbPath = './test-handler-branches.db'
-
-    beforeAll(async () => {
-        db = new DatabaseAdapter(testDbPath)
-        await db.initialize()
-
-        // Seed some test data
-        db.createEntry({ content: 'Branch test entry one', tags: ['branch-test'] })
-        db.createEntry({ content: 'Branch test entry two', tags: ['branch-test', 'second'] })
-        db.createEntry({ content: 'Export markdown test entry', tags: ['export-test'] })
-    })
-
-    afterAll(() => {
-        db.close()
-        try {
-            const fs = require('node:fs')
-            if (fs.existsSync(testDbPath)) fs.unlinkSync(testDbPath)
-        } catch {
-            // cleanup
-        }
-    })
-
-    // ========================================================================
-    // search.ts — FTS fallback for invalid/unbalanced queries
-    // ========================================================================
-
-    describe('search_entries — FTS fallback', () => {
-        it('should fall back to LIKE when query has unbalanced quotes', async () => {
-            const result = (await callTool('search_entries', { query: '"unbalanced' }, db)) as {
-                entries: unknown[]
-                count: number
-            }
-
-            // Should not throw, should return results (possibly empty)
-            expect(result.entries).toBeDefined()
-            expect(Array.isArray(result.entries)).toBe(true)
-        })
-
-        it('should handle empty query gracefully', async () => {
-            const result = (await callTool('search_entries', { query: '' }, db)) as {
-                entries: unknown[]
-            }
-
-            expect(result.entries).toBeDefined()
-        })
-    })
-
-    // ========================================================================
-    // search.ts — semantic_search error when vector manager throws
-    // ========================================================================
-
-    describe('semantic_search — error handling', () => {
-        it('should return error when vector manager search throws', async () => {
-            const badVector = createMockVector({
-                search: vi.fn().mockRejectedValue(new Error('Embedding model failed')),
-            })
-
-            const result = (await callTool(
-                'semantic_search',
-                { query: 'test search' },
-                db,
-                badVector
-            )) as { error?: string; entries?: unknown[] }
-
-            expect(result.error).toBeDefined()
-        })
-
-        it('should return hint when no results found and hint_on_empty is true', async () => {
-            const emptyVector = createMockVector({
-                search: vi.fn().mockResolvedValue([]),
-            })
-
-            const result = (await callTool(
-                'semantic_search',
-                { query: 'extremely_unlikely_term_xyz', hint_on_empty: true },
-                db,
-                emptyVector
-            )) as { entries: unknown[]; hint?: string }
-
-            expect(result.entries).toHaveLength(0)
-        })
-
-        it('should not return hint when hint_on_empty is false', async () => {
-            const emptyVector = createMockVector({
-                search: vi.fn().mockResolvedValue([]),
-            })
-
-            const result = (await callTool(
-                'semantic_search',
-                { query: 'xyz_no_result', hint_on_empty: false },
-                db,
-                emptyVector
-            )) as { entries: unknown[]; hint?: string }
-
-            expect(result.entries).toHaveLength(0)
-            expect(result.hint).toBeUndefined()
-        })
-    })
-
-    // ========================================================================
-    // relationships.ts — depth parameter traversal
-    // ========================================================================
-
-    describe('visualize_relationships — depth variations', () => {
-        it('should accept depth=1', async () => {
-            const e1 = db.createEntry({ content: 'Depth test A' })
-            const e2 = db.createEntry({ content: 'Depth test B' })
-
-            await callTool(
-                'link_entries',
-                { from_entry_id: e1.id, to_entry_id: e2.id, relationship_type: 'references' },
-                db
-            )
-
-            const result = (await callTool(
-                'visualize_relationships',
-                { entry_id: e1.id, depth: 1 },
-                db
-            )) as { entry_count: number; mermaid: string | null }
-
-            expect(result.entry_count).toBeGreaterThanOrEqual(1)
-        })
-
-        it('should accept depth=3', async () => {
-            const result = (await callTool(
-                'visualize_relationships',
-                { depth: 3, limit: 5 },
-                db
-            )) as { entry_count: number }
-
-            expect(result.entry_count).toBeGreaterThanOrEqual(0)
-        })
-    })
-
-    // ========================================================================
-    // export.ts — markdown format branch
-    // ========================================================================
-
-    describe('export_entries — markdown format', () => {
-        it('should export entries in markdown format', async () => {
-            const result = (await callTool(
-                'export_entries',
-                { format: 'markdown', limit: 5 },
-                db
-            )) as { format: string; content: string }
-
-            expect(result.format).toBe('markdown')
-            expect(typeof result.content).toBe('string')
-        })
-
-        it('should export with entry_types filter', async () => {
-            const result = (await callTool(
-                'export_entries',
-                { format: 'json', entry_types: ['personal_reflection'], limit: 10 },
-                db
-            )) as { format: string; entries: unknown[] }
-
-            expect(result.format).toBe('json')
-        })
-
-        it('should export with tags filter', async () => {
-            const result = (await callTool(
-                'export_entries',
-                { format: 'json', tags: ['export-test'], limit: 10 },
-                db
-            )) as { format: string; entries: unknown[] }
-
-            expect(result.format).toBe('json')
-        })
-    })
-
-    // ========================================================================
-    // index.ts — callTool with progress context
-    // ========================================================================
-
-    describe('callTool — progress context path', () => {
-        it('should handle progress context and rebuild fresh tool definitions', async () => {
-            const mockProgress = {
-                progressToken: 'test-token',
-                sendProgress: vi.fn(),
-            }
-
-            // test_simple is a trivial tool that always works
-            const result = (await callTool(
-                'test_simple',
-                { message: 'Progress test' },
-                db,
-                undefined,
-                undefined,
-                undefined,
-                mockProgress
-            )) as { message: string }
-
-            expect(result.message).toContain('Progress test')
-        })
-    })
-
-    // ========================================================================
-    // index.ts — unknown tool error
-    // ========================================================================
-
-    describe('callTool — unknown tool', () => {
-        it('should reject with Error for unknown tool name', async () => {
-            await expect(callTool('nonexistent_tool_xyz', {}, db)).rejects.toThrow(
-                'Unknown tool: nonexistent_tool_xyz'
-            )
-        })
-    })
-
-    // ========================================================================
-    // index.ts — getTools with tool filter
-    // ========================================================================
-
-    describe('getTools — icon mapping', () => {
-        it('should return icons for all known tool groups', () => {
-            const tools = getTools(db, null)
-
-            // Every registered tool should have icons (since all groups are in the iconMap)
-            for (const tool of tools) {
-                expect(tool.icons).toBeDefined()
-            }
-        })
-    })
-
-    // ========================================================================
-    // admin.ts — get_vector_index_stats without vector manager
-    // ========================================================================
-
-    describe('get_vector_index_stats — no vector manager', () => {
-        it('should return error when vector manager is not available', async () => {
-            const result = (await callTool('get_vector_index_stats', {}, db)) as { error: string }
-
-            expect(result.error).toContain('not available')
-        })
-    })
-
-    // ========================================================================
-    // admin.ts — get_vector_index_stats with vector manager
-    // ========================================================================
-
-    describe('get_vector_index_stats — with vector manager', () => {
-        it('should return stats from vector manager', async () => {
-            const vectorManager = createMockVector()
-
-            const result = (await callTool('get_vector_index_stats', {}, db, vectorManager)) as {
-                success: boolean
-                available: boolean
-                itemCount: number
-                modelName: string
-            }
-
-            expect(result.success).toBe(true)
-            expect(result.available).toBe(true)
-            expect(result.itemCount).toBe(10)
-            expect(result.modelName).toBe('Xenova/all-MiniLM-L6-v2')
-        })
-    })
-
-    // ========================================================================
-    // search.ts — search_by_date_range with all optional filters
-    // ========================================================================
-
-    describe('search_by_date_range — full filter coverage', () => {
-        it('should filter by tags', async () => {
-            const today = new Date().toISOString().split('T')[0]!
-            const result = (await callTool(
-                'search_by_date_range',
-                {
-                    start_date: '2020-01-01',
-                    end_date: today,
-                    tags: ['branch-test'],
-                },
-                db
-            )) as { entries: unknown[]; count: number }
-
-            expect(result.entries).toBeDefined()
-            expect(result.count).toBeGreaterThan(0)
-        })
-
-        it('should filter by entry_type', async () => {
-            const today = new Date().toISOString().split('T')[0]!
-            const result = (await callTool(
-                'search_by_date_range',
-                {
-                    start_date: '2020-01-01',
-                    end_date: today,
-                    entry_type: 'personal_reflection',
-                },
-                db
-            )) as { entries: unknown[] }
-
-            expect(result.entries).toBeDefined()
-        })
-
-        it('should filter by is_personal', async () => {
-            const today = new Date().toISOString().split('T')[0]!
-            const result = (await callTool(
-                'search_by_date_range',
-                {
-                    start_date: '2020-01-01',
-                    end_date: today,
-                    is_personal: true,
-                },
-                db
-            )) as { entries: unknown[] }
-
-            expect(result.entries).toBeDefined()
-        })
-    })
-})

package/tests/handlers/help-resource.test.ts

@@ -1,92 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll } from 'vitest'
-import { getHelpResourceDefinitions } from '../../src/handlers/resources/help.js'
-import { DatabaseAdapter } from '../../src/database/sqlite-adapter/index.js'
-import type { ResourceContext } from '../../src/handlers/resources/shared.js'
-import * as fs from 'fs'
-
-describe('Help Resource Handlers', () => {
-    let db: DatabaseAdapter
-
-    beforeAll(async () => {
-        const dbPath = './test-help-resource.db'
-        if (fs.existsSync(dbPath)) fs.unlinkSync(dbPath)
-        db = new DatabaseAdapter(dbPath)
-        await db.initialize()
-    })
-
-    afterAll(() => {
-        db.close()
-        const dbPath = './test-help-resource.db'
-        if (fs.existsSync(dbPath)) fs.unlinkSync(dbPath)
-    })
-
-    const getContext = (): ResourceContext => ({ db })
-
-    it('should generate memory://help listing all groups', async () => {
-        const defs = getHelpResourceDefinitions()
-        const rootHelp = defs.find((d) => d.uri === 'memory://help')
-        expect(rootHelp).toBeDefined()
-
-        const result = (await rootHelp!.handler('memory://help', getContext())) as any
-        expect(result.data.totalGroups).toBeGreaterThan(0)
-        expect(result.data.groups.some((g: any) => g.name === 'core')).toBe(true)
-        expect(result.data.groups.some((g: any) => g.name === 'search')).toBe(true)
-    })
-
-    it('should generate memory://help/{group} for a valid group', async () => {
-        const defs = getHelpResourceDefinitions()
-        const groupHelp = defs.find((d) => d.uri === 'memory://help/{group}')
-        expect(groupHelp).toBeDefined()
-
-        const result = (await groupHelp!.handler('memory://help/core', getContext())) as any
-        expect(result.data.group).toBe('core')
-        expect(result.data.tools.length).toBeGreaterThan(0)
-        expect(result.data.tools.some((t: any) => t.name === 'create_entry')).toBe(true)
-
-        // Check that parameters are extracted with correct types and required flags
-        const createEntry = result.data.tools.find((t: any) => t.name === 'create_entry')
-        expect(createEntry.parameters).toBeDefined()
-
-        // content is z.string() — required
-        const contentParam = createEntry.parameters.find((p: any) => p.name === 'content')
-        expect(contentParam).toBeDefined()
-        expect(contentParam.type).toBe('string')
-        expect(contentParam.required).toBe(true)
-
-        // tags is z.array(z.string()).optional() — not required
-        const tagsParam = createEntry.parameters.find((p: any) => p.name === 'tags')
-        expect(tagsParam).toBeDefined()
-        expect(tagsParam.type).toBe('array')
-        expect(tagsParam.required).toBe(false)
-    })
-
-    it('should return error for invalid group in memory://help/{group}', async () => {
-        const defs = getHelpResourceDefinitions()
-        const groupHelp = defs.find((d) => d.uri === 'memory://help/{group}')
-
-        const result = (await groupHelp!.handler(
-            'memory://help/invalid_group_name',
-            getContext()
-        )) as any
-        expect(result.data.error).toContain('not found')
-        expect(result.data.availableGroups).toBeDefined()
-    })
-
-    it('should return error for malformed URI in memory://help/{group}', async () => {
-        const defs = getHelpResourceDefinitions()
-        const groupHelp = defs.find((d) => d.uri === 'memory://help/{group}')
-
-        const result = (await groupHelp!.handler('memory://help/', getContext())) as any
-        expect(result.data.error).toContain('Invalid group')
-    })
-
-    it('should generate memory://help/gotchas', async () => {
-        const defs = getHelpResourceDefinitions()
-        const gotchasHelp = defs.find((d) => d.uri === 'memory://help/gotchas')
-        expect(gotchasHelp).toBeDefined()
-
-        const result = (await gotchasHelp!.handler('memory://help/gotchas', getContext())) as any
-        expect(result.data).toContain('# memory-journal-mcp — Field Notes &')
-        expect(gotchasHelp!.mimeType).toBe('text/markdown')
-    })
-})

package/tests/handlers/prompt-handler-coverage.test.ts

@@ -1,108 +0,0 @@
-/**
- * Prompt Handler Coverage Tests
- *
- * Tests for handlers/prompts/index.ts uncovered paths:
- * - execQuery with empty result set
- * - execQuery with multi-row results
- * - getPrompt with unknown name (throws)
- * - getPrompts listing
- */
-
-import { describe, it, expect, beforeAll, afterAll } from 'vitest'
-import { DatabaseAdapter } from '../../src/database/sqlite-adapter/index.js'
-import { execQuery, getPrompts, getPrompt } from '../../src/handlers/prompts/index.js'
-
-describe('Prompt Handlers - Coverage', () => {
-    let db: DatabaseAdapter
-    const testDbPath = './test-prompts-cov.db'
-
-    beforeAll(async () => {
-        db = new DatabaseAdapter(testDbPath)
-        await db.initialize()
-        // Seed entries for query tests
-        db.createEntry({ content: 'Prompt test entry 1', tags: ['prompt-test'] })
-        db.createEntry({ content: 'Prompt test entry 2', tags: ['prompt-test'] })
-    })
-
-    afterAll(() => {
-        db.close()
-        try {
-            const fs = require('node:fs')
-            if (fs.existsSync(testDbPath)) fs.unlinkSync(testDbPath)
-        } catch {
-            // Ignore cleanup errors
-        }
-    })
-
-    // ========================================================================
-    // execQuery
-    // ========================================================================
-
-    describe('execQuery', () => {
-        it('should return rows for a valid query', () => {
-            const rows = execQuery(db, 'SELECT id, content FROM memory_journal LIMIT 2')
-            expect(rows.length).toBe(2)
-            expect(rows[0]).toHaveProperty('id')
-            expect(rows[0]).toHaveProperty('content')
-        })
-
-        it('should return empty array for no-match query', () => {
-            const rows = execQuery(
-                db,
-                "SELECT id FROM memory_journal WHERE content = 'nonexistent_xyz_12345'"
-            )
-            expect(rows).toEqual([])
-        })
-
-        it('should handle parameterized queries', () => {
-            const rows = execQuery(
-                db,
-                'SELECT id, content FROM memory_journal WHERE content LIKE ?',
-                ['%Prompt test%']
-            )
-            expect(rows.length).toBe(2)
-        })
-
-        it('should return empty array for query that returns no columns', () => {
-            const rows = execQuery(db, 'SELECT id FROM memory_journal WHERE id = -1')
-            expect(rows).toEqual([])
-        })
-    })
-
-    // ========================================================================
-    // getPrompts
-    // ========================================================================
-
-    describe('getPrompts', () => {
-        it('should return all prompt definitions', () => {
-            const prompts = getPrompts()
-            expect(prompts.length).toBeGreaterThan(0)
-
-            for (const p of prompts) {
-                const prompt = p as { name: string; description: string }
-                expect(typeof prompt.name).toBe('string')
-                expect(typeof prompt.description).toBe('string')
-            }
-        })
-    })
-
-    // ========================================================================
-    // getPrompt
-    // ========================================================================
-
-    describe('getPrompt', () => {
-        it('should throw for unknown prompt name', () => {
-            expect(() => getPrompt('nonexistent_prompt', {}, db)).toThrow(
-                'Prompt not found: nonexistent_prompt'
-            )
-        })
-
-        it('should return messages for a valid prompt', () => {
-            const prompts = getPrompts()
-            const firstName = (prompts[0] as { name: string }).name
-            const result = getPrompt(firstName, {}, db)
-            expect(result.messages).toBeDefined()
-            expect(result.messages.length).toBeGreaterThan(0)
-        })
-    })
-})

package/tests/handlers/prompt-handlers.test.ts

@@ -1,131 +0,0 @@
-/**
- * Prompt Handler Tests
- *
- * Tests the prompt listing and execution handlers.
- */
-
-import { describe, it, expect, beforeAll, afterAll } from 'vitest'
-import { getPrompts, getPrompt } from '../../src/handlers/prompts/index.js'
-import { DatabaseAdapter } from '../../src/database/sqlite-adapter/index.js'
-
-describe('Prompt Handlers', () => {
-    let db: DatabaseAdapter
-    const testDbPath = './test-prompts.db'
-
-    beforeAll(async () => {
-        db = new DatabaseAdapter(testDbPath)
-        await db.initialize()
-        // Seed some data for prompts that read from the DB
-        db.createEntry({ content: 'Test entry for prompts', tags: ['test-tag'] })
-    })
-
-    afterAll(() => {
-        db.close()
-        try {
-            const fs = require('node:fs')
-            if (fs.existsSync(testDbPath)) {
-                fs.unlinkSync(testDbPath)
-            }
-        } catch {
-            // Ignore cleanup errors
-        }
-    })
-
-    // ========================================================================
-    // getPrompts
-    // ========================================================================
-
-    describe('getPrompts', () => {
-        it('should return an array of prompt definitions', () => {
-            const prompts = getPrompts()
-            expect(Array.isArray(prompts)).toBe(true)
-            expect(prompts.length).toBeGreaterThan(0)
-        })
-
-        it('should have name and description on each prompt', () => {
-            const prompts = getPrompts()
-            for (const prompt of prompts) {
-                const p = prompt as { name: string; description: string }
-                expect(typeof p.name).toBe('string')
-                expect(p.name.length).toBeGreaterThan(0)
-                expect(typeof p.description).toBe('string')
-            }
-        })
-
-        it('should include known prompt names', () => {
-            const prompts = getPrompts()
-            const names = prompts.map((p) => (p as { name: string }).name)
-
-            // At least some expected prompts should be present
-            expect(names.length).toBeGreaterThan(5)
-        })
-    })
-
-    // ========================================================================
-    // getPrompt
-    // ========================================================================
-
-    describe('getPrompt', () => {
-        it('should return messages for each known prompt', () => {
-            const prompts = getPrompts()
-            const names = prompts.map((p) => (p as { name: string }).name)
-
-            for (const name of names) {
-                const result = getPrompt(name, {}, db)
-                expect(result.messages).toBeDefined()
-                expect(Array.isArray(result.messages)).toBe(true)
-                expect(result.messages.length).toBeGreaterThan(0)
-
-                // Each message should have role and content
-                for (const msg of result.messages) {
-                    expect(msg.role).toBeDefined()
-                    expect(msg.content).toBeDefined()
-                }
-            }
-        })
-
-        it('should throw for unknown prompt name', () => {
-            expect(() => getPrompt('nonexistent_prompt_xyz', {}, db)).toThrow()
-        })
-
-        it('should return messages for analyze-period with date arguments', () => {
-            const today = new Date().toISOString().split('T')[0]!
-            const result = getPrompt('analyze-period', { start_date: today, end_date: today }, db)
-
-            expect(result.messages).toBeDefined()
-            expect(result.messages.length).toBeGreaterThan(0)
-            const text = (result.messages[0]?.content as { text: string }).text
-            expect(text).toContain(today)
-        })
-
-        it('should return messages for find-related with query argument', () => {
-            const result = getPrompt('find-related', { query: 'test' }, db)
-
-            expect(result.messages).toBeDefined()
-            expect(result.messages.length).toBeGreaterThan(0)
-            const text = (result.messages[0]?.content as { text: string }).text
-            expect(text).toContain('test')
-        })
-
-        it('should return messages for get-context-bundle prompt', () => {
-            const result = getPrompt('get-context-bundle', {}, db)
-
-            expect(result.messages).toBeDefined()
-            expect(result.messages.length).toBeGreaterThan(0)
-        })
-
-        it('should return messages for goal-tracker prompt', () => {
-            const result = getPrompt('goal-tracker', {}, db)
-
-            expect(result.messages).toBeDefined()
-            expect(result.messages.length).toBeGreaterThan(0)
-        })
-
-        it('should return messages for prepare-retro with days argument', () => {
-            const result = getPrompt('prepare-retro', { days: '14' }, db)
-
-            expect(result.messages).toBeDefined()
-            expect(result.messages.length).toBeGreaterThan(0)
-        })
-    })
-})