memory-journal-mcp 6.1.2 → 6.2.1

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

@@ -1,301 +0,0 @@
-/**
- * Team Tool Handler Tests
- *
- * Tests the team tool group: team_create_entry, team_get_recent, team_search,
- * and the share_with_team shorthand on create_entry.
- */
-
-import { describe, it, expect, beforeAll, afterAll } from 'vitest'
-import { callTool } from '../../src/handlers/tools/index.js'
-import { DatabaseAdapter } from '../../src/database/sqlite-adapter/index.js'
-
-describe('Team Tool Handlers', () => {
-    let personalDb: DatabaseAdapter
-    let teamDb: DatabaseAdapter
-    const personalDbPath = './test-team-tools-personal.db'
-    const teamDbPath = './test-team-tools-team.db'
-
-    beforeAll(async () => {
-        personalDb = new DatabaseAdapter(personalDbPath)
-        await personalDb.initialize()
-
-        teamDb = new DatabaseAdapter(teamDbPath)
-        await teamDb.initialize()
-        teamDb.applyTeamSchema()
-    })
-
-    afterAll(() => {
-        personalDb.close()
-        teamDb.close()
-        try {
-            const fs = require('node:fs')
-            if (fs.existsSync(personalDbPath)) fs.unlinkSync(personalDbPath)
-            if (fs.existsSync(teamDbPath)) fs.unlinkSync(teamDbPath)
-        } catch {
-            // Ignore cleanup errors
-        }
-    })
-
-    // ========================================================================
-    // team_create_entry
-    // ========================================================================
-
-    describe('team_create_entry', () => {
-        it('should create team entry with auto-detected author', async () => {
-            const result = (await callTool(
-                'team_create_entry',
-                { content: 'Team entry alpha' },
-                personalDb,
-                undefined,
-                undefined,
-                undefined,
-                undefined,
-                teamDb
-            )) as { success: boolean; entry: { content: string }; author: string }
-
-            expect(result.success).toBe(true)
-            expect(result.entry.content).toBe('Team entry alpha')
-            expect(result.author).toBeDefined()
-            expect(typeof result.author).toBe('string')
-        })
-
-        it('should use explicit author when provided', async () => {
-            const result = (await callTool(
-                'team_create_entry',
-                { content: 'Entry by Alice', author: 'Alice' },
-                personalDb,
-                undefined,
-                undefined,
-                undefined,
-                undefined,
-                teamDb
-            )) as { success: boolean; author: string }
-
-            expect(result.success).toBe(true)
-            expect(result.author).toBe('Alice')
-        })
-
-        it('should support tags and entry_type', async () => {
-            const result = (await callTool(
-                'team_create_entry',
-                {
-                    content: 'Tagged team entry',
-                    entry_type: 'project_decision',
-                    tags: ['team-tag-1', 'team-tag-2'],
-                },
-                personalDb,
-                undefined,
-                undefined,
-                undefined,
-                undefined,
-                teamDb
-            )) as { success: boolean; entry: { entryType: string; tags: string[] } }
-
-            expect(result.success).toBe(true)
-            expect(result.entry.entryType).toBe('project_decision')
-            expect(result.entry.tags).toContain('team-tag-1')
-        })
-
-        it('should return error when team DB not configured', async () => {
-            const result = (await callTool(
-                'team_create_entry',
-                { content: 'Should fail' },
-                personalDb
-                // No teamDb passed
-            )) as { success: boolean; error: string }
-
-            expect(result.success).toBe(false)
-            expect(result.error).toContain('Team database not configured')
-        })
-    })
-
-    // ========================================================================
-    // team_get_recent
-    // ========================================================================
-
-    describe('team_get_recent', () => {
-        it('should return recent team entries with author', async () => {
-            const result = (await callTool(
-                'team_get_recent',
-                { limit: 5 },
-                personalDb,
-                undefined,
-                undefined,
-                undefined,
-                undefined,
-                teamDb
-            )) as { entries: { content: string; author: string | null }[]; count: number }
-
-            expect(result.count).toBeGreaterThan(0)
-            // Entries should have author field
-            for (const entry of result.entries) {
-                expect('author' in entry).toBe(true)
-            }
-        })
-
-        it('should respect limit', async () => {
-            const result = (await callTool(
-                'team_get_recent',
-                { limit: 1 },
-                personalDb,
-                undefined,
-                undefined,
-                undefined,
-                undefined,
-                teamDb
-            )) as { entries: unknown[]; count: number }
-
-            expect(result.count).toBeLessThanOrEqual(1)
-        })
-
-        it('should return error when team DB not configured', async () => {
-            const result = (await callTool('team_get_recent', {}, personalDb)) as {
-                success: boolean
-                error: string
-            }
-
-            expect(result.success).toBe(false)
-            expect(result.error).toContain('Team database not configured')
-        })
-    })
-
-    // ========================================================================
-    // team_search
-    // ========================================================================
-
-    describe('team_search', () => {
-        it('should search team entries by query', async () => {
-            await callTool(
-                'team_create_entry',
-                { content: 'Searchable team xyz987' },
-                personalDb,
-                undefined,
-                undefined,
-                undefined,
-                undefined,
-                teamDb
-            )
-
-            const result = (await callTool(
-                'team_search',
-                { query: 'xyz987' },
-                personalDb,
-                undefined,
-                undefined,
-                undefined,
-                undefined,
-                teamDb
-            )) as { entries: unknown[]; count: number }
-
-            expect(result.count).toBeGreaterThan(0)
-        })
-
-        it('should search by tags', async () => {
-            await callTool(
-                'team_create_entry',
-                { content: 'Tag-searchable entry', tags: ['unique-search-tag'] },
-                personalDb,
-                undefined,
-                undefined,
-                undefined,
-                undefined,
-                teamDb
-            )
-
-            const result = (await callTool(
-                'team_search',
-                { tags: ['unique-search-tag'] },
-                personalDb,
-                undefined,
-                undefined,
-                undefined,
-                undefined,
-                teamDb
-            )) as { entries: unknown[]; count: number }
-
-            expect(result.count).toBeGreaterThan(0)
-        })
-
-        it('should return error when team DB not configured', async () => {
-            const result = (await callTool('team_search', { query: 'test' }, personalDb)) as {
-                success: boolean
-                error: string
-            }
-
-            expect(result.success).toBe(false)
-            expect(result.error).toContain('Team database not configured')
-        })
-    })
-
-    // ========================================================================
-    // share_with_team (on create_entry)
-    // ========================================================================
-
-    describe('create_entry - share_with_team', () => {
-        it('should share entry to team DB when share_with_team is true', async () => {
-            const result = (await callTool(
-                'create_entry',
-                { content: 'Shared to team abc123', share_with_team: true },
-                personalDb,
-                undefined,
-                undefined,
-                undefined,
-                undefined,
-                teamDb
-            )) as {
-                success: boolean
-                entry: { content: string }
-                sharedWithTeam?: boolean
-                author?: string
-            }
-
-            expect(result.success).toBe(true)
-            expect(result.sharedWithTeam).toBe(true)
-            expect(result.author).toBeDefined()
-
-            // Verify the entry exists in team DB
-            const teamResults = (await callTool(
-                'team_search',
-                { query: 'abc123' },
-                personalDb,
-                undefined,
-                undefined,
-                undefined,
-                undefined,
-                teamDb
-            )) as { entries: unknown[]; count: number }
-
-            expect(teamResults.count).toBeGreaterThan(0)
-        })
-
-        it('should not include sharedWithTeam when share_with_team is false', async () => {
-            const result = (await callTool(
-                'create_entry',
-                { content: 'Not shared to team', share_with_team: false },
-                personalDb,
-                undefined,
-                undefined,
-                undefined,
-                undefined,
-                teamDb
-            )) as { success: boolean; sharedWithTeam?: boolean }
-
-            expect(result.success).toBe(true)
-            expect(result.sharedWithTeam).toBeUndefined()
-        })
-
-        it('should still save personal entry even without team DB', async () => {
-            const result = (await callTool(
-                'create_entry',
-                { content: 'Personal only entry', share_with_team: true },
-                personalDb
-                // No teamDb — share_with_team is silently ignored
-            )) as { success: boolean; entry: { content: string }; sharedWithTeam?: boolean }
-
-            expect(result.success).toBe(true)
-            expect(result.entry.content).toBe('Personal only entry')
-            // share_with_team is just silently skipped (no team DB)
-            expect(result.sharedWithTeam).toBeUndefined()
-        })
-    })
-})

package/tests/handlers/team-vector.test.ts

@@ -1,213 +0,0 @@
-/**
- * Team Vector Tool Handler Tests
- *
- * Tests the team vector tool group: team_semantic_search, team_get_vector_index_stats, team_rebuild_vector_index, team_add_to_vector_index
- */
-
-import { describe, it, expect, beforeAll, afterAll } from 'vitest'
-import { callTool } from '../../src/handlers/tools/index.js'
-import { DatabaseAdapter } from '../../src/database/sqlite-adapter/index.js'
-import { VectorSearchManager } from '../../src/vector/vector-search-manager.js'
-
-describe('Team Vector Tool Handlers', () => {
-    let personalDb: DatabaseAdapter
-    let teamDb: DatabaseAdapter
-    let vectorManager: VectorSearchManager
-    const personalDbPath = './test-team-vector-personal.db'
-    const teamDbPath = './test-team-vector-team.db'
-
-    beforeAll(async () => {
-        try {
-            const fs = require('node:fs')
-            if (fs.existsSync(personalDbPath)) fs.unlinkSync(personalDbPath)
-            if (fs.existsSync(teamDbPath)) fs.unlinkSync(teamDbPath)
-        } catch {}
-
-        personalDb = new DatabaseAdapter(personalDbPath)
-        await personalDb.initialize()
-
-        teamDb = new DatabaseAdapter(teamDbPath)
-        await teamDb.initialize()
-        teamDb.applyTeamSchema()
-
-        // Mock vector manager
-        vectorManager = {
-            search: async (query: string, limit: number, threshold: number) => {
-                if (query === 'empty') return []
-                return [{ entryId: 1, score: 0.8 }]
-            },
-            getStats: () => ({ itemCount: 10, modelName: 'test-model', dimensions: 384 }),
-            rebuildIndex: async () => ({ indexed: 10, failed: 0 }),
-            addEntry: async (id: number) => ({
-                success: id !== 999,
-                error: id === 999 ? 'Failed' : undefined,
-            }),
-            initialize: async () => {},
-            deleteEntry: async () => {},
-            close: async () => {},
-        } as unknown as VectorSearchManager
-
-        // Create the entry that the mock returns
-        await callTool(
-            'team_create_entry',
-            { content: 'Vector matched' },
-            personalDb,
-            undefined,
-            undefined,
-            undefined,
-            undefined,
-            teamDb
-        )
-    })
-
-    afterAll(() => {
-        personalDb.close()
-        teamDb.close()
-        try {
-            const fs = require('node:fs')
-            if (fs.existsSync(personalDbPath)) fs.unlinkSync(personalDbPath)
-            if (fs.existsSync(teamDbPath)) fs.unlinkSync(teamDbPath)
-        } catch {
-            // Ignore cleanup errors
-        }
-    })
-
-    // Helper to get tools
-    const callTeamTool = async (name: string, args: any) =>
-        callTool(
-            name,
-            args,
-            personalDb,
-            undefined,
-            undefined,
-            undefined,
-            undefined,
-            teamDb,
-            vectorManager
-        )
-
-    describe('team_semantic_search', () => {
-        it('should return semantic search results', async () => {
-            const result = (await callTeamTool('team_semantic_search', { query: 'test' })) as any
-
-            expect(result.query).toBe('test')
-            expect(result.count).toBeGreaterThan(0)
-            expect(result.entries[0].similarity).toBe(0.8)
-            expect(result.entries[0].content).toContain('Vector matched')
-        })
-
-        it('should handle hints on empty results', async () => {
-            const result = (await callTeamTool('team_semantic_search', { query: 'empty' })) as any
-
-            expect(result.count).toBe(0)
-            expect(result.hint).toContain('No entries matched')
-        })
-
-        it('should require vector manager', async () => {
-            const result = (await callTool(
-                'team_semantic_search',
-                { query: 'test' },
-                personalDb,
-                undefined,
-                undefined,
-                undefined,
-                undefined,
-                teamDb
-            )) as any
-            expect(result.success).toBe(false)
-            expect(result.error).toContain('Team vector search not available')
-        })
-
-        it('should require team DB', async () => {
-            const result = (await callTool(
-                'team_semantic_search',
-                { query: 'test' },
-                personalDb
-            )) as any
-            expect(result.error).toContain('Team database not configured')
-        })
-    })
-
-    describe('team_get_vector_index_stats', () => {
-        it('should return vector stats', async () => {
-            const result = (await callTeamTool('team_get_vector_index_stats', {})) as any
-
-            expect(result.available).toBe(true)
-            expect(result.itemCount).toBe(10)
-        })
-
-        it('should require vector manager', async () => {
-            const result = (await callTool(
-                'team_get_vector_index_stats',
-                {},
-                personalDb,
-                undefined,
-                undefined,
-                undefined,
-                undefined,
-                teamDb
-            )) as any
-            expect(result.available).toBe(false)
-            expect(result.error).toContain('Team vector search not available')
-        })
-    })
-
-    describe('team_rebuild_vector_index', () => {
-        it('should rebuild index', async () => {
-            const result = (await callTeamTool('team_rebuild_vector_index', {})) as any
-
-            expect(result.success).toBe(true)
-            expect(result.entriesIndexed).toBe(10)
-        })
-
-        it('should require vector manager', async () => {
-            const result = (await callTool(
-                'team_rebuild_vector_index',
-                {},
-                personalDb,
-                undefined,
-                undefined,
-                undefined,
-                undefined,
-                teamDb
-            )) as any
-            expect(result.success).toBe(false)
-            expect(result.error).toContain('Team vector search not available')
-        })
-    })
-
-    describe('team_add_to_vector_index', () => {
-        it('should add entry to index', async () => {
-            const result = (await callTeamTool('team_add_to_vector_index', { entry_id: 1 })) as any
-
-            expect(result.success).toBe(true)
-            expect(result.entryId).toBe(1)
-        })
-
-        it('should handle failure', async () => {
-            // we mocked entry 999 to fail returning an error, but it first checks DB.
-            // Let's create entry 999 manually. Wait, sqlite auto-increments. Let's just create a new entry and check.
-            const result = (await callTeamTool('team_add_to_vector_index', {
-                entry_id: 9999,
-            })) as any
-
-            expect(result.success).toBe(false)
-            expect(result.error).toContain('not found') // DB lookup fails first
-        })
-
-        it('should require vector manager', async () => {
-            const result = (await callTool(
-                'team_add_to_vector_index',
-                { entry_id: 1 },
-                personalDb,
-                undefined,
-                undefined,
-                undefined,
-                undefined,
-                teamDb
-            )) as any
-            expect(result.success).toBe(false)
-            expect(result.error).toContain('Team vector search not available')
-        })
-    })
-})