memory-journal-mcp 6.1.2 → 6.2.1

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

@@ -1,271 +0,0 @@
-/**
- * Team Relationship Tool Handler Tests
- *
- * Tests the team relationship tool group: team_link_entries, team_visualize_relationships
- */
-
-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 Relationship Tool Handlers', () => {
-    let personalDb: DatabaseAdapter
-    let teamDb: DatabaseAdapter
-    const personalDbPath = './test-team-relationships-personal.db'
-    const teamDbPath = './test-team-relationships-team.db'
-
-    let e1: number, e2: number, e3: number
-
-    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()
-
-        // Seed entries for linking
-        const res1 = (await callTool(
-            'team_create_entry',
-            { content: 'Node A', tags: ['node-tag'] },
-            personalDb,
-            undefined,
-            undefined,
-            undefined,
-            undefined,
-            teamDb
-        )) as any
-        const res2 = (await callTool(
-            'team_create_entry',
-            { content: 'Node B', tags: ['node-tag'] },
-            personalDb,
-            undefined,
-            undefined,
-            undefined,
-            undefined,
-            teamDb
-        )) as any
-        const res3 = (await callTool(
-            'team_create_entry',
-            { content: 'Node C' },
-            personalDb,
-            undefined,
-            undefined,
-            undefined,
-            undefined,
-            teamDb
-        )) as any
-
-        console.error('DEBUG RELATIONS', JSON.stringify({ res1, res2, res3 }, null, 2))
-
-        expect(res1.success).toBe(true)
-        expect(res2.success).toBe(true)
-
-        e1 = res1.entry.id
-        e2 = res2.entry.id
-        e3 = res3.entry.id
-    })
-
-    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
-        }
-    })
-
-    describe('team_link_entries', () => {
-        it('should link two team entries', async () => {
-            const result = (await callTool(
-                'team_link_entries',
-                {
-                    from_entry_id: e1,
-                    to_entry_id: e2,
-                    relationship_type: 'blocked_by',
-                    description: 'A depends on B',
-                },
-                personalDb,
-                undefined,
-                undefined,
-                undefined,
-                undefined,
-                teamDb
-            )) as any
-
-            expect(result.success).toBe(true)
-            expect(result.relationship.fromEntryId).toBe(e1)
-            expect(result.relationship.toEntryId).toBe(e2)
-            expect(result.relationship.relationshipType).toBe('blocked_by')
-            expect(result.message).toContain('Linked entries')
-            expect(result.duplicate).toBeUndefined()
-        })
-
-        it('should detect duplicate relationships', async () => {
-            const result = (await callTool(
-                'team_link_entries',
-                { from_entry_id: e1, to_entry_id: e2, relationship_type: 'blocked_by' },
-                personalDb,
-                undefined,
-                undefined,
-                undefined,
-                undefined,
-                teamDb
-            )) as any
-
-            expect(result.success).toBe(true)
-            expect(result.duplicate).toBe(true)
-            expect(result.message).toContain('already exists')
-        })
-
-        it('should return error if from_entry_id is not found', async () => {
-            const result = (await callTool(
-                'team_link_entries',
-                { from_entry_id: 999, to_entry_id: e2, relationship_type: 'references' },
-                personalDb,
-                undefined,
-                undefined,
-                undefined,
-                undefined,
-                teamDb
-            )) as any
-
-            expect(result.success).toBe(false)
-            expect(result.error).toContain('Team entry 999 not found')
-        })
-
-        it('should return error if to_entry_id is not found', async () => {
-            const result = (await callTool(
-                'team_link_entries',
-                { from_entry_id: e1, to_entry_id: 999, relationship_type: 'references' },
-                personalDb,
-                undefined,
-                undefined,
-                undefined,
-                undefined,
-                teamDb
-            )) as any
-
-            expect(result.success).toBe(false)
-            expect(result.error).toContain('Team entry 999 not found')
-        })
-
-        it('should return error if team DB is not configured', async () => {
-            const result = (await callTool(
-                'team_link_entries',
-                { from_entry_id: e1, to_entry_id: e2, relationship_type: 'references' },
-                personalDb
-            )) as any
-
-            expect(result.success).toBe(false)
-            expect(result.error).toContain('Team database not configured')
-        })
-    })
-
-    describe('team_visualize_relationships', () => {
-        beforeAll(async () => {
-            await callTool(
-                'team_link_entries',
-                { from_entry_id: e2, to_entry_id: e3, relationship_type: 'caused' },
-                personalDb,
-                undefined,
-                undefined,
-                undefined,
-                undefined,
-                teamDb
-            )
-        })
-
-        it('should visualize relationships from entry ID with depth', async () => {
-            const result = (await callTool(
-                'team_visualize_relationships',
-                { entry_id: e1, depth: 2 },
-                personalDb,
-                undefined,
-                undefined,
-                undefined,
-                undefined,
-                teamDb
-            )) as any
-
-            expect(result.success).toBe(true)
-            expect(result.mermaid).toContain('graph LR')
-            expect(result.mermaid).toContain('blocked_by')
-            expect(result.mermaid).toContain('caused')
-            expect(result.nodeCount).toBe(3) // A, B, C
-            expect(result.edgeCount).toBe(2)
-        })
-
-        it('should visualize relationships by tag', async () => {
-            const result = (await callTool(
-                'team_visualize_relationships',
-                { tag: 'node-tag' },
-                personalDb,
-                undefined,
-                undefined,
-                undefined,
-                undefined,
-                teamDb
-            )) as any
-
-            expect(result.success).toBe(true)
-            expect(result.mermaid).toContain('graph LR')
-            expect(result.mermaid).toContain('blocked_by')
-            // Node C does not have 'node-tag', but A and B do, and A->B.
-            // But A, B have relations to each other.
-            expect(result.nodeCount).toBeGreaterThanOrEqual(2)
-            expect(result.edgeCount).toBeGreaterThanOrEqual(1)
-        })
-
-        it('should visualize recent relationships (default)', async () => {
-            const result = (await callTool(
-                'team_visualize_relationships',
-                {},
-                personalDb,
-                undefined,
-                undefined,
-                undefined,
-                undefined,
-                teamDb
-            )) as any
-
-            expect(result.success).toBe(true)
-            expect(result.mermaid).toContain('graph LR')
-            expect(result.nodeCount).toBeGreaterThan(0)
-        })
-
-        it('should return empty graph if no entries match', async () => {
-            const result = (await callTool(
-                'team_visualize_relationships',
-                { tag: 'nonexistent-tag' },
-                personalDb,
-                undefined,
-                undefined,
-                undefined,
-                undefined,
-                teamDb
-            )) as any
-
-            expect(result.success).toBe(true)
-            expect(result.mermaid).toContain('No entries found')
-            expect(result.nodeCount).toBe(0)
-            expect(result.edgeCount).toBe(0)
-        })
-
-        it('should return error if team DB is not configured', async () => {
-            const result = (await callTool('team_visualize_relationships', {}, personalDb)) as any
-
-            expect(result.success).toBe(false)
-            expect(result.error).toContain('Team database not configured')
-        })
-    })
-})

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

@@ -1,161 +0,0 @@
-/**
- * Team Resource Handler Tests
- *
- * Tests memory://team/recent and memory://team/statistics resources.
- */
-
-import { describe, it, expect, beforeAll, afterAll } from 'vitest'
-import { readResource } from '../../src/handlers/resources/index.js'
-import { DatabaseAdapter } from '../../src/database/sqlite-adapter/index.js'
-
-describe('Team Resource Handlers', () => {
-    let personalDb: DatabaseAdapter
-    let teamDb: DatabaseAdapter
-    const personalDbPath = './test-team-resources-personal.db'
-    const teamDbPath = './test-team-resources-team.db'
-
-    beforeAll(async () => {
-        personalDb = new DatabaseAdapter(personalDbPath)
-        await personalDb.initialize()
-
-        teamDb = new DatabaseAdapter(teamDbPath)
-        await teamDb.initialize()
-        teamDb.applyTeamSchema()
-
-        // Seed team entries with author column
-        const entry1 = teamDb.createEntry({
-            content: 'Team resource test alpha',
-            tags: ['res-team'],
-        })
-        const entry2 = teamDb.createEntry({ content: 'Team resource test beta' })
-
-        // Set author on entries via raw SQL
-        teamDb.executeRawQuery('UPDATE memory_journal SET author = ? WHERE id = ?', [
-            'Alice',
-            entry1.id,
-        ])
-        teamDb.executeRawQuery('UPDATE memory_journal SET author = ? WHERE id = ?', [
-            'Bob',
-            entry2.id,
-        ])
-    })
-
-    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
-        }
-    })
-
-    // ========================================================================
-    // memory://team/recent
-    // ========================================================================
-
-    describe('memory://team/recent', () => {
-        it('should return recent team entries with author field', async () => {
-            const result = await readResource(
-                'memory://team/recent',
-                personalDb,
-                undefined,
-                undefined,
-                undefined,
-                undefined,
-                teamDb
-            )
-
-            const data = result.data as {
-                entries: { content: string; author: string | null }[]
-                count: number
-                source: string
-            }
-            expect(data.count).toBeGreaterThan(0)
-            expect(data.source).toBe('team')
-
-            // Every entry should have author field
-            for (const entry of data.entries) {
-                expect('author' in entry).toBe(true)
-            }
-
-            // At least one should have a non-null author
-            const withAuthor = data.entries.filter((e) => e.author !== null)
-            expect(withAuthor.length).toBeGreaterThan(0)
-        })
-
-        it('should include annotations with lastModified', async () => {
-            const result = await readResource(
-                'memory://team/recent',
-                personalDb,
-                undefined,
-                undefined,
-                undefined,
-                undefined,
-                teamDb
-            )
-
-            expect(result.annotations?.lastModified).toBeDefined()
-        })
-
-        it('should return error structure when team DB not configured', async () => {
-            const result = await readResource(
-                'memory://team/recent',
-                personalDb
-                // No teamDb
-            )
-
-            const data = result.data as { error: string; entries: unknown[]; count: number }
-            expect(data.error).toContain('Team database not configured')
-            expect(data.count).toBe(0)
-        })
-    })
-
-    // ========================================================================
-    // memory://team/statistics
-    // ========================================================================
-
-    describe('memory://team/statistics', () => {
-        it('should return team statistics with author breakdown', async () => {
-            const result = await readResource(
-                'memory://team/statistics',
-                personalDb,
-                undefined,
-                undefined,
-                undefined,
-                undefined,
-                teamDb
-            )
-
-            const data = result.data as {
-                configured: boolean
-                totalEntries: number
-                authors: { author: string; count: number }[]
-                source: string
-            }
-            expect(data.configured).toBe(true)
-            expect(data.totalEntries).toBeGreaterThan(0)
-            expect(data.source).toBe('team')
-
-            // Authors breakdown
-            expect(data.authors.length).toBeGreaterThan(0)
-            const alice = data.authors.find((a) => a.author === 'Alice')
-            expect(alice).toBeDefined()
-            expect(alice!.count).toBeGreaterThan(0)
-        })
-
-        it('should return error structure when team DB not configured', async () => {
-            const result = await readResource(
-                'memory://team/statistics',
-                personalDb
-                // No teamDb
-            )
-
-            const data = result.data as { configured: boolean; error: string }
-            expect(data.configured).toBe(false)
-            expect(data.error).toContain('Team database not configured')
-        })
-    })
-})

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

@@ -1,134 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll } from 'vitest'
-import { DatabaseAdapter } from '../../src/database/sqlite-adapter/index.js'
-import { callTool } from '../../src/handlers/tools/index.js'
-import * as fs from 'fs'
-
-describe('Team Search Tool Handlers', () => {
-    let personalDb: DatabaseAdapter
-    let teamDb: DatabaseAdapter
-
-    const personalDbPath = './test-team-search-personal.db'
-    const teamDbPath = './test-team-search-team.db'
-
-    beforeAll(async () => {
-        try {
-            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()
-
-        const r1 = (await callTool(
-            'team_create_entry',
-            { content: 'Strategic Search test 1', tags: ['strategy', 'shared'] },
-            personalDb,
-            undefined,
-            undefined,
-            undefined,
-            undefined,
-            teamDb
-        )) as any
-        const r2 = (await callTool(
-            'team_create_entry',
-            { content: 'Tactical Search test 2', tags: ['tactics'] },
-            personalDb,
-            undefined,
-            undefined,
-            undefined,
-            undefined,
-            teamDb
-        )) as any
-
-        expect(r1.success).toBe(true)
-        expect(r2.success).toBe(true)
-    })
-
-    afterAll(() => {
-        personalDb.close()
-        teamDb.close()
-        try {
-            if (fs.existsSync(personalDbPath)) fs.unlinkSync(personalDbPath)
-            if (fs.existsSync(teamDbPath)) fs.unlinkSync(teamDbPath)
-        } catch {}
-    })
-
-    describe('team_search', () => {
-        it('should search team entries', async () => {
-            const result = (await callTool(
-                'team_search',
-                { query: 'Strategic' },
-                personalDb,
-                undefined,
-                undefined,
-                undefined,
-                undefined,
-                teamDb
-            )) as any
-            expect(result.entries).toBeDefined()
-            expect(result.entries.length).toBeGreaterThan(0)
-            expect(result.entries[0].content).toContain('Strategic')
-        })
-
-        it('should return error if no team db', async () => {
-            const result = (await callTool('team_search', { query: 'test' }, personalDb)) as any
-            expect(result.success).toBe(false)
-            expect(result.error).toContain('not configured')
-        })
-    })
-
-    describe('team_search_by_date_range', () => {
-        it('should search team entries by date range', async () => {
-            const result = (await callTool(
-                'team_search_by_date_range',
-                {
-                    start_date: '2020-01-01',
-                    end_date: '2030-01-01',
-                    tags: ['shared'],
-                },
-                personalDb,
-                undefined,
-                undefined,
-                undefined,
-                undefined,
-                teamDb
-            )) as any
-
-            expect(result.entries).toBeDefined()
-            expect(result.entries.length).toBe(1)
-            expect(result.entries[0].tags).toContain('shared')
-        })
-
-        it('should return error if inverted date range', async () => {
-            const result = (await callTool(
-                'team_search_by_date_range',
-                {
-                    start_date: '2030-01-01',
-                    end_date: '2020-01-01',
-                },
-                personalDb,
-                undefined,
-                undefined,
-                undefined,
-                undefined,
-                teamDb
-            )) as any
-
-            expect(result.success).toBe(false)
-            expect(result.error).toContain('after end_date')
-        })
-
-        it('should return error if no team db', async () => {
-            const result = (await callTool(
-                'team_search_by_date_range',
-                { start_date: '2020-01-01' },
-                personalDb
-            )) as any
-            expect(result.success).toBe(false)
-        })
-    })
-})