memory-journal-mcp 6.1.2 → 6.2.1

package/tests/handlers/tool-annotations.test.ts

@@ -1,90 +0,0 @@
-/**
- * Tool Annotations Invariant Test
- *
- * Structural enforcement: verifies every tool has proper annotations
- * with explicit readOnlyHint and openWorldHint, plus a valid title.
- */
-
-import { describe, it, expect } from 'vitest'
-import { getTools } from '../../src/handlers/tools/index.js'
-import { DatabaseAdapterFactory } from '../../src/database/adapter-factory.js'
-import path from 'node:path'
-import os from 'node:os'
-import fs from 'node:fs'
-
-describe('Tool Annotations Invariant', () => {
-    // Create a temporary database for tool registration
-    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'mj-invariant-'))
-    const dbPath = path.join(tmpDir, 'test-invariants.db')
-
-    let tools: ReturnType<typeof getTools>
-
-    // Build the tool list once
-    it('should load all tools', async () => {
-        const db = await DatabaseAdapterFactory.create(dbPath)
-        await db.initialize()
-        tools = getTools(db, null)
-        expect(tools.length).toBeGreaterThan(0)
-        db.close()
-    })
-
-    it('every tool must have annotations', () => {
-        for (const tool of tools) {
-            expect(tool.annotations, `Tool "${tool.name}" is missing annotations`).toBeDefined()
-        }
-    })
-
-    it('every tool must have an explicit readOnlyHint', () => {
-        for (const tool of tools) {
-            expect(
-                tool.annotations?.readOnlyHint,
-                `Tool "${tool.name}" is missing readOnlyHint`
-            ).toBeDefined()
-        }
-    })
-
-    it('every tool must have an explicit openWorldHint', () => {
-        for (const tool of tools) {
-            expect(
-                tool.annotations?.openWorldHint,
-                `Tool "${tool.name}" is missing openWorldHint`
-            ).toBeDefined()
-        }
-    })
-
-    it('every tool must have a non-empty name', () => {
-        for (const tool of tools) {
-            expect(tool.name.length).toBeGreaterThan(0)
-            expect(tool.name.length).toBeLessThanOrEqual(128)
-        }
-    })
-
-    it('tool names must be unique', () => {
-        const names = tools.map((t) => t.name)
-        expect(new Set(names).size).toBe(names.length)
-    })
-
-    it('0 tools should be missing openWorldHint', () => {
-        const missing = tools.filter((t) => t.annotations?.openWorldHint === undefined)
-        expect(
-            missing.length,
-            `Tools missing openWorldHint: ${missing.map((t) => t.name).join(', ')}`
-        ).toBe(0)
-    })
-
-    it('every tool must have a non-empty title', () => {
-        for (const tool of tools) {
-            expect(tool.title, `Tool "${tool.name}" is missing title`).toBeTruthy()
-            expect(tool.title!.length).toBeGreaterThan(0)
-        }
-    })
-
-    // Cleanup
-    it('cleanup', () => {
-        try {
-            fs.rmSync(tmpDir, { recursive: true })
-        } catch {
-            // Best-effort cleanup
-        }
-    })
-})

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

@@ -1,514 +0,0 @@
-/**
- * Tool Handler Coverage Tests
- *
- * Additional tests for uncovered code paths in:
- * - admin.ts (update_entry not found, vectorManager, merge_tags errors)
- * - relationships.ts (duplicate link, invalid type, tag filtering, no entries)
- * - backup.ts (restore_backup, cleanup_backups)
- * - analytics.ts (date ranges, project_breakdown, error branches)
- * - core.ts (create_entry with teamDb sharing, auto-context, Zod errors)
- */
-
-import { describe, it, expect, beforeAll, afterAll, vi } from 'vitest'
-import { callTool } 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().mockResolvedValue({
-            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('Tool Handler Coverage', () => {
-    let db: DatabaseAdapter
-    let teamDb: DatabaseAdapter
-    const testDbPath = './test-tool-cov.db'
-    const teamDbPath = './test-tool-team-cov.db'
-
-    beforeAll(async () => {
-        db = new DatabaseAdapter(testDbPath)
-        await db.initialize()
-        teamDb = new DatabaseAdapter(teamDbPath)
-        await teamDb.initialize()
-    })
-
-    afterAll(() => {
-        db.close()
-        teamDb.close()
-        try {
-            const fs = require('node:fs')
-            for (const p of [testDbPath, teamDbPath]) {
-                if (fs.existsSync(p)) fs.unlinkSync(p)
-            }
-        } catch {
-            // Ignore cleanup errors
-        }
-    })
-
-    // ========================================================================
-    // admin.ts — update_entry
-    // ========================================================================
-
-    describe('update_entry - coverage', () => {
-        it('should return error for nonexistent entry', async () => {
-            const result = (await callTool(
-                'update_entry',
-                { entry_id: 99999, content: 'Updated' },
-                db
-            )) as { success: boolean; error: string }
-
-            expect(result.success).toBe(false)
-            expect(result.error).toContain('not found')
-        })
-
-        it('should re-index when content changes and vectorManager present', async () => {
-            const entry = db.createEntry({ content: 'To be updated with vector' })
-            const vectorManager = createMockVector()
-
-            const result = (await callTool(
-                'update_entry',
-                { entry_id: entry.id, content: 'Updated content with vector' },
-                db,
-                vectorManager
-            )) as { success: boolean; entry: { content: string } }
-
-            expect(result.success).toBe(true)
-            expect(result.entry.content).toBe('Updated content with vector')
-            // vectorManager.addEntry should have been called
-            expect(vectorManager.addEntry).toHaveBeenCalled()
-        })
-
-        it('should handle invalid entry_type with Zod error', async () => {
-            const entry = db.createEntry({ content: 'For invalid type test' })
-            const result = (await callTool(
-                'update_entry',
-                { entry_id: entry.id, entry_type: 'completely_invalid_type' },
-                db
-            )) as { error: string }
-
-            expect(result.error).toBeDefined()
-        })
-    })
-
-    // ========================================================================
-    // admin.ts — delete_entry with vectorManager
-    // ========================================================================
-
-    describe('delete_entry - coverage', () => {
-        it('should remove from vector index on delete', async () => {
-            const entry = db.createEntry({ content: 'Delete with vector' })
-            const vectorManager = createMockVector()
-
-            const result = (await callTool(
-                'delete_entry',
-                { entry_id: entry.id },
-                db,
-                vectorManager
-            )) as { success: boolean }
-
-            expect(result.success).toBe(true)
-            expect(vectorManager.removeEntry).toHaveBeenCalledWith(entry.id)
-        })
-
-        it('should handle permanent delete', async () => {
-            const entry = db.createEntry({ content: 'Permanent delete test' })
-            const result = (await callTool(
-                'delete_entry',
-                { entry_id: entry.id, permanent: true },
-                db
-            )) as { success: boolean; permanent: boolean }
-
-            expect(result.success).toBe(true)
-            expect(result.permanent).toBe(true)
-        })
-    })
-
-    // ========================================================================
-    // admin.ts — merge_tags
-    // ========================================================================
-
-    describe('merge_tags - coverage', () => {
-        it('should return error when source equals target', async () => {
-            const result = (await callTool(
-                'merge_tags',
-                { source_tag: 'same', target_tag: 'same' },
-                db
-            )) as { success: boolean; error: string }
-
-            expect(result.success).toBe(false)
-            expect(result.error).toContain('different')
-        })
-
-        it('should return error for nonexistent source tag', async () => {
-            const result = (await callTool(
-                'merge_tags',
-                { source_tag: 'nonexistent_src_xyz', target_tag: 'nonexistent_tgt_xyz' },
-                db
-            )) as { success: boolean; error: string }
-
-            // mergeTags throws "Tag not found" for nonexistent source
-            expect(result.success).toBe(false)
-            expect(result.error).toContain('Tag not found: nonexistent_src_xyz')
-        })
-    })
-
-    // ========================================================================
-    // relationships.ts — link_entries edge cases
-    // ========================================================================
-
-    describe('link_entries - coverage', () => {
-        it('should return duplicate when relationship already exists', async () => {
-            const e1 = db.createEntry({ content: 'Link source dup' })
-            const e2 = db.createEntry({ content: 'Link target dup' })
-
-            // Create first
-            await callTool(
-                'link_entries',
-                {
-                    from_entry_id: e1.id,
-                    to_entry_id: e2.id,
-                    relationship_type: 'references',
-                },
-                db
-            )
-
-            // Create duplicate
-            const result = (await callTool(
-                'link_entries',
-                {
-                    from_entry_id: e1.id,
-                    to_entry_id: e2.id,
-                    relationship_type: 'references',
-                },
-                db
-            )) as { success: boolean; duplicate: boolean; message: string }
-
-            expect(result.success).toBe(true)
-            expect(result.duplicate).toBe(true)
-            expect(result.message).toContain('already exists')
-        })
-
-        it('should return Zod error for invalid relationship_type', async () => {
-            const result = (await callTool(
-                'link_entries',
-                {
-                    from_entry_id: 1,
-                    to_entry_id: 2,
-                    relationship_type: 'invalid_type_xyz',
-                },
-                db
-            )) as { success: boolean; message?: string; error?: string }
-
-            // Should return an error (Zod or domain)
-            expect(result.success === false || result.error !== undefined).toBe(true)
-        })
-    })
-
-    // ========================================================================
-    // relationships.ts — visualize_relationships edge cases
-    // ========================================================================
-
-    describe('visualize_relationships - coverage', () => {
-        it('should return no entries for nonexistent entry_id', async () => {
-            const result = (await callTool('visualize_relationships', { entry_id: 99999 }, db)) as {
-                entry_count: number
-                mermaid: null
-                message: string
-            }
-
-            expect(result.entry_count).toBe(0)
-            expect(result.mermaid).toBeNull()
-            expect(result.message).toContain('not found')
-        })
-
-        it('should filter by tags', async () => {
-            const e1 = db.createEntry({ content: 'Tag viz entry', tags: ['viz-tag1'] })
-            const e2 = db.createEntry({ content: 'Tag viz entry 2', tags: ['viz-tag1'] })
-            await callTool(
-                'link_entries',
-                {
-                    from_entry_id: e1.id,
-                    to_entry_id: e2.id,
-                    relationship_type: 'references',
-                },
-                db
-            )
-
-            const result = (await callTool(
-                'visualize_relationships',
-                { tags: ['viz-tag1'] },
-                db
-            )) as { entry_count: number; mermaid: string | null }
-
-            expect(result.entry_count).toBeGreaterThan(0)
-        })
-
-        it('should show all relationship entries when no filters', async () => {
-            const result = (await callTool('visualize_relationships', {}, db)) as {
-                entry_count: number
-            }
-
-            // Should return entries that have relationships
-            expect(result.entry_count).toBeGreaterThanOrEqual(0)
-        })
-
-        it('should handle entries with tags but no relationships', async () => {
-            db.createEntry({ content: 'Isolated tag entry', tags: ['isolated-tag-xyz'] })
-
-            const result = (await callTool(
-                'visualize_relationships',
-                { tags: ['isolated-tag-xyz'] },
-                db
-            )) as { entry_count: number; relationship_count: number }
-
-            // Entry is found by tag query, but has 0 relationships
-            expect(result.entry_count).toBeGreaterThanOrEqual(1)
-            expect(result.relationship_count).toBe(0)
-        })
-    })
-
-    // ========================================================================
-    // backup.ts — restore_backup, cleanup_backups
-    // ========================================================================
-
-    describe('restore_backup - coverage', () => {
-        it('should return error for nonexistent backup', async () => {
-            const result = (await callTool(
-                'restore_backup',
-                { filename: 'nonexistent_backup.db' },
-                db
-            )) as { success: boolean; error?: string; message?: string }
-
-            expect(result.success).toBe(false)
-        })
-    })
-
-    describe('cleanup_backups - coverage', () => {
-        it('should clean up old backups', async () => {
-            const result = (await callTool('cleanup_backups', { keep_count: 5 }, db)) as {
-                success: boolean
-                message: string
-            }
-
-            expect(result.success).toBe(true)
-            expect(result.message).toBeDefined()
-        })
-    })
-
-    // ========================================================================
-    // analytics.ts — get_statistics
-    // ========================================================================
-
-    describe('get_statistics - coverage', () => {
-        it('should support group_by month', async () => {
-            const result = (await callTool('get_statistics', { group_by: 'month' }, db)) as {
-                groupBy: string
-            }
-
-            expect(result.groupBy).toBe('month')
-        })
-
-        it('should filter by date range', async () => {
-            const today = new Date().toISOString().split('T')[0]!
-            const allStats = (await callTool('get_statistics', {}, db)) as {
-                totalEntries: number
-            }
-            const filteredStats = (await callTool(
-                'get_statistics',
-                { start_date: today, end_date: today },
-                db
-            )) as { totalEntries: number; dateRange: { startDate: string; endDate: string } }
-
-            // Filtered count should be <= all entries
-            expect(filteredStats.totalEntries).toBeLessThanOrEqual(allStats.totalEntries)
-            expect(filteredStats.totalEntries).toBeGreaterThanOrEqual(0)
-            // dateRange should echo back the applied dates
-            expect(filteredStats.dateRange).toBeDefined()
-            expect(filteredStats.dateRange.startDate).toBe(today)
-            expect(filteredStats.dateRange.endDate).toBe(today)
-        })
-
-        it('should return 0 entries for future date range', async () => {
-            const result = (await callTool(
-                'get_statistics',
-                { start_date: '2099-01-01', end_date: '2099-12-31' },
-                db
-            )) as { totalEntries: number; dateRange: { startDate: string; endDate: string } }
-
-            expect(result.totalEntries).toBe(0)
-            expect(result.dateRange.startDate).toBe('2099-01-01')
-        })
-
-        it('should return project_breakdown when requested', async () => {
-            // Create entry with a known project number
-            db.createEntry({ content: 'Project breakdown test', projectNumber: 777 })
-
-            const result = (await callTool('get_statistics', { project_breakdown: true }, db)) as {
-                totalEntries: number
-                projectBreakdown: { project_number: number; entry_count: number }[]
-            }
-
-            expect(result.totalEntries).toBeGreaterThan(0)
-            expect(result.projectBreakdown).toBeDefined()
-            expect(Array.isArray(result.projectBreakdown)).toBe(true)
-            const proj777 = result.projectBreakdown.find((p) => p.project_number === 777)
-            expect(proj777).toBeDefined()
-            expect(proj777!.entry_count).toBeGreaterThanOrEqual(1)
-        })
-
-        it('should NOT return project_breakdown when not requested', async () => {
-            const result = (await callTool('get_statistics', {}, db)) as {
-                projectBreakdown?: unknown
-            }
-
-            expect(result.projectBreakdown).toBeUndefined()
-        })
-
-        it('should NOT return dateRange when no dates provided', async () => {
-            const result = (await callTool('get_statistics', {}, db)) as {
-                dateRange?: unknown
-            }
-
-            expect(result.dateRange).toBeUndefined()
-        })
-
-        it('should return error for invalid group_by', async () => {
-            const result = (await callTool('get_statistics', { group_by: 'invalid' }, db)) as {
-                error?: string
-            }
-
-            // Should return Zod validation error
-            expect(result.error).toBeDefined()
-        })
-    })
-
-    // ========================================================================
-    // analytics.ts — get_cross_project_insights
-    // ========================================================================
-
-    describe('get_cross_project_insights - coverage', () => {
-        it('should support date range filter', async () => {
-            const today = new Date().toISOString().split('T')[0]!
-            const result = (await callTool(
-                'get_cross_project_insights',
-                {
-                    min_entries: 1,
-                    start_date: today,
-                    end_date: today,
-                },
-                db
-            )) as { project_count: number }
-
-            expect(result.project_count).toBeGreaterThanOrEqual(0)
-        })
-    })
-
-    // ========================================================================
-    // core.ts — create_entry with team sharing
-    // ========================================================================
-
-    describe('create_entry - team sharing coverage', () => {
-        it('should attempt team sharing when share_with_team is true', async () => {
-            const result = (await callTool(
-                'create_entry',
-                {
-                    content: 'Team shared entry test',
-                    share_with_team: true,
-                    is_personal: false,
-                },
-                db,
-                undefined,
-                undefined,
-                undefined,
-                undefined,
-                teamDb
-            )) as { success: boolean; sharedWithTeam?: boolean }
-
-            // Entry is always created in personal DB regardless of team share outcome
-            expect(result.success).toBe(true)
-            // Team share may silently fail (missing author column in test schema)
-            // — the important thing is coverage of the share_with_team code path
-        })
-
-        it('should not share when no teamDb', async () => {
-            const result = (await callTool(
-                'create_entry',
-                {
-                    content: 'No team entry test',
-                    share_with_team: true,
-                },
-                db
-            )) as { success: boolean; sharedWithTeam?: boolean }
-
-            expect(result.success).toBe(true)
-            // No teamDb, so sharedWithTeam shouldn't be present
-            expect(result.sharedWithTeam).toBeUndefined()
-        })
-    })
-
-    // ========================================================================
-    // core.ts — create_entry Zod errors
-    // ========================================================================
-
-    describe('create_entry - Zod errors', () => {
-        it('should return error for invalid entry_type', async () => {
-            const result = (await callTool(
-                'create_entry',
-                { content: 'Test', entry_type: 'invalid_type_xyz' },
-                db
-            )) as { error: string }
-
-            expect(result.error).toBeDefined()
-        })
-
-        it('should return error for invalid significance_type', async () => {
-            const result = (await callTool(
-                'create_entry',
-                { content: 'Test', significance_type: 'invalid_sig' },
-                db
-            )) as { error: string }
-
-            expect(result.error).toBeDefined()
-        })
-
-        it('should return error for empty content', async () => {
-            const result = (await callTool('create_entry', { content: '' }, db)) as {
-                error: string
-            }
-
-            expect(result.error).toBeDefined()
-        })
-    })
-
-    // ========================================================================
-    // core.ts — get_entry_by_id without relationships
-    // ========================================================================
-
-    describe('get_entry_by_id - coverage', () => {
-        it('should return entry without relationships when include_relationships is false', async () => {
-            const entry = db.createEntry({ content: 'No relationships entry' })
-
-            const result = (await callTool(
-                'get_entry_by_id',
-                { entry_id: entry.id, include_relationships: false },
-                db
-            )) as { entry: { id: number }; relationships?: unknown[] }
-
-            expect(result.entry.id).toBe(entry.id)
-            expect(result.relationships).toBeUndefined()
-        })
-    })
-})