memory-journal-mcp 6.1.2 → 6.2.1

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

@@ -1,220 +0,0 @@
-/**
- * Team Analytics Tool Handler Tests
- *
- * Tests the team analytics tool group: team_get_statistics, team_get_cross_project_insights
- */
-
-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 Analytics Tool Handlers', () => {
-    let personalDb: DatabaseAdapter
-    let teamDb: DatabaseAdapter
-    const personalDbPath = './test-team-analytics-personal.db'
-    const teamDbPath = './test-team-analytics-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()
-
-        // Seed data for analytics
-        const seed1 = await callTool(
-            'team_create_entry',
-            {
-                content: 'Project Alpha init',
-                entry_type: 'technical_note',
-                project_number: 101,
-                project_owner: 'org',
-                tags: ['planning', 'alpha'],
-            },
-            personalDb,
-            undefined,
-            undefined,
-            undefined,
-            undefined,
-            teamDb
-        )
-        const seed2 = await callTool(
-            'team_create_entry',
-            {
-                content: 'Project Alpha task 1',
-                entry_type: 'feature_implementation',
-                project_number: 101,
-                project_owner: 'org',
-                tags: ['task'],
-            },
-            personalDb,
-            undefined,
-            undefined,
-            undefined,
-            undefined,
-            teamDb
-        )
-        const seed3 = await callTool(
-            'team_create_entry',
-            {
-                content: 'Project Alpha task 2',
-                entry_type: 'feature_implementation',
-                project_number: 101,
-                project_owner: 'org',
-                tags: ['task'],
-            },
-            personalDb,
-            undefined,
-            undefined,
-            undefined,
-            undefined,
-            teamDb
-        )
-        const seed4 = await callTool(
-            'team_create_entry',
-            {
-                content: 'Project Beta init',
-                entry_type: 'technical_note',
-                project_number: 202,
-                tags: ['beta'],
-            },
-            personalDb,
-            undefined,
-            undefined,
-            undefined,
-            undefined,
-            teamDb
-        )
-        console.error('DEBUG SEEDS', JSON.stringify({ seed1, seed2, seed3, seed4 }, null, 2))
-
-        // Old project for testing inactive threshold
-        const oldEntry = teamDb.createEntry({
-            content: 'Old Project Gamma',
-            entryType: 'technical_note',
-            isPersonal: false,
-            projectNumber: 303,
-        })
-        teamDb.executeRawQuery(
-            `UPDATE memory_journal SET timestamp = datetime('now', '-10 days') WHERE id = ?`,
-            [oldEntry.id]
-        )
-        teamDb.flushSave()
-    })
-
-    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_get_statistics', () => {
-        it('should return team statistics including authors', async () => {
-            const result = (await callTool(
-                'team_get_statistics',
-                {},
-                personalDb,
-                undefined,
-                undefined,
-                undefined,
-                undefined,
-                teamDb
-            )) as any
-
-            expect(result.success).toBe(true)
-            expect(result.totalEntries).toBeGreaterThanOrEqual(4)
-            expect(result.authors).toBeDefined()
-            expect(result.authors.length).toBeGreaterThan(0)
-            expect(result.authors[0].author).toBeDefined()
-            expect(result.authors[0].count).toBeGreaterThan(0)
-        })
-
-        it('should return error if team DB is not configured', async () => {
-            const result = (await callTool('team_get_statistics', {}, personalDb)) as any
-
-            expect(result.success).toBe(false)
-            expect(result.error).toContain('Team database not configured')
-        })
-    })
-
-    describe('team_get_cross_project_insights', () => {
-        it('should return cross-project insights above min_entries', async () => {
-            const result = (await callTool(
-                'team_get_cross_project_insights',
-                { min_entries: 2 },
-                personalDb,
-                undefined,
-                undefined,
-                undefined,
-                undefined,
-                teamDb
-            )) as any
-
-            expect(result.project_count).toBeGreaterThanOrEqual(1)
-            expect(result.projects[0].project_number).toBe(101)
-            expect(result.projects[0].top_tags).toBeDefined()
-            expect(result.projects[0].top_tags.some((t: any) => t.name === 'task')).toBe(true)
-
-            expect(result.time_distribution).toBeDefined()
-            expect(result.time_distribution.length).toBeGreaterThan(0)
-            expect(result.time_distribution[0].percentage).toBeDefined()
-        })
-
-        it('should identify inactive projects', async () => {
-            const result = (await callTool(
-                'team_get_cross_project_insights',
-                { min_entries: 1 },
-                personalDb,
-                undefined,
-                undefined,
-                undefined,
-                undefined,
-                teamDb
-            )) as any
-
-            expect(result.inactive_projects).toBeDefined()
-            // Project 303 should be inactive (10 days old)
-            expect(result.inactive_projects.some((p: any) => p.project_number === 303)).toBe(true)
-        })
-
-        it('should handle date ranges', async () => {
-            const result = (await callTool(
-                'team_get_cross_project_insights',
-                { min_entries: 1, start_date: '2050-01-01', end_date: '2050-12-31' },
-                personalDb,
-                undefined,
-                undefined,
-                undefined,
-                undefined,
-                teamDb
-            )) as any
-
-            expect(result.project_count).toBe(0)
-            expect(result.message).toContain('No projects found')
-            expect(result.projects).toHaveLength(0)
-            expect(result.inactive_projects).toHaveLength(0)
-        })
-
-        it('should return error if team DB is not configured', async () => {
-            const result = (await callTool(
-                'team_get_cross_project_insights',
-                { min_entries: 1 },
-                personalDb
-            )) as any
-
-            expect(result.error).toContain('Team database not configured')
-        })
-    })
-})

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

@@ -1,148 +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 Core Tool Handlers', () => {
-    let personalDb: DatabaseAdapter
-    let teamDb: DatabaseAdapter
-
-    const personalDbPath = './test-team-core-personal.db'
-    const teamDbPath = './test-team-core-team.db'
-    let entry1Id: number
-
-    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: 'Core test 1', tags: ['core-1', 'shared'] },
-            personalDb,
-            undefined,
-            undefined,
-            undefined,
-            undefined,
-            teamDb
-        )) as any
-        entry1Id = r1.entry.id
-        await callTool(
-            'team_create_entry',
-            { content: 'Core test 2', tags: ['shared'] },
-            personalDb,
-            undefined,
-            undefined,
-            undefined,
-            undefined,
-            teamDb
-        )
-    })
-
-    afterAll(() => {
-        personalDb.close()
-        teamDb.close()
-        try {
-            if (fs.existsSync(personalDbPath)) fs.unlinkSync(personalDbPath)
-            if (fs.existsSync(teamDbPath)) fs.unlinkSync(teamDbPath)
-        } catch {}
-    })
-
-    describe('team_get_entry_by_id', () => {
-        it('should get a team entry by id', async () => {
-            const result = (await callTool(
-                'team_get_entry_by_id',
-                { entry_id: entry1Id },
-                personalDb,
-                undefined,
-                undefined,
-                undefined,
-                undefined,
-                teamDb
-            )) as any
-            expect(result.success).toBe(true)
-            expect(result.entry.content).toBe('Core test 1')
-            expect(result.entry.author).toBeDefined()
-        })
-
-        it('should return error if not found', async () => {
-            const result = (await callTool(
-                'team_get_entry_by_id',
-                { entry_id: 9999 },
-                personalDb,
-                undefined,
-                undefined,
-                undefined,
-                undefined,
-                teamDb
-            )) as any
-            expect(result.success).toBe(false)
-            expect(result.error).toContain('not found')
-        })
-
-        it('should return error if no team db', async () => {
-            const result = (await callTool(
-                'team_get_entry_by_id',
-                { entry_id: entry1Id },
-                personalDb
-            )) as any
-            expect(result.success).toBe(false)
-            expect(result.error).toContain('not configured')
-        })
-    })
-
-    describe('team_get_recent', () => {
-        it('should get recent entries', async () => {
-            const result = (await callTool(
-                'team_get_recent',
-                { limit: 10 },
-                personalDb,
-                undefined,
-                undefined,
-                undefined,
-                undefined,
-                teamDb
-            )) as any
-            expect(result.entries).toBeDefined()
-            expect(result.entries.length).toBeGreaterThanOrEqual(2)
-            expect(result.count).toBe(result.entries.length)
-        })
-
-        it('should return error if no team db', async () => {
-            const result = (await callTool('team_get_recent', { limit: 10 }, personalDb)) as any
-            expect(result.success).toBe(false)
-        })
-    })
-
-    describe('team_list_tags', () => {
-        it('should list tags', async () => {
-            const result = (await callTool(
-                'team_list_tags',
-                {},
-                personalDb,
-                undefined,
-                undefined,
-                undefined,
-                undefined,
-                teamDb
-            )) as any
-            expect(result.success).toBe(true)
-            expect(result.tags).toBeDefined()
-            expect(result.tags.some((t: any) => t.name === 'shared')).toBe(true)
-            expect(result.count).toBeDefined()
-        })
-
-        it('should return error if no team db', async () => {
-            const result = (await callTool('team_list_tags', {}, personalDb)) as any
-            expect(result.success).toBe(false)
-        })
-    })
-})

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

@@ -1,198 +0,0 @@
-/**
- * Team Backup and Export Tool Handler Tests
- *
- * Tests the team export/backup tool group: team_export_entries, team_backup, team_list_backups
- */
-
-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 Backup and Export Tool Handlers', () => {
-    let personalDb: DatabaseAdapter
-    let teamDb: DatabaseAdapter
-    const personalDbPath = './test-team-data-personal.db'
-    const teamDbPath = './test-team-data-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()
-
-        // Seed entries for export/backup
-        const r1 = (await callTool(
-            'team_create_entry',
-            { content: 'Export test 1', tags: ['export-1'], entry_type: 'technical_note' },
-            personalDb,
-            undefined,
-            undefined,
-            undefined,
-            undefined,
-            teamDb
-        )) as any
-        const r2 = (await callTool(
-            'team_create_entry',
-            { content: 'Export test 2', entry_type: 'project_decision' },
-            personalDb,
-            undefined,
-            undefined,
-            undefined,
-            undefined,
-            teamDb
-        )) as any
-
-        expect(r1.success).toBe(true)
-        expect(r2.success).toBe(true)
-    })
-
-    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)
-
-            // Clean up team backups directory
-            const backupsDir = teamDb.getBackupsDir()
-            if (fs.existsSync(backupsDir)) {
-                const files = fs.readdirSync(backupsDir)
-                for (const f of files) {
-                    fs.unlinkSync(`${backupsDir}/${f}`)
-                }
-            }
-        } catch {
-            // Ignore cleanup errors
-        }
-    })
-
-    describe('team_export_entries', () => {
-        it('should export team entries in JSON format', async () => {
-            const result = (await callTool(
-                'team_export_entries',
-                { format: 'json' },
-                personalDb,
-                undefined,
-                undefined,
-                undefined,
-                undefined,
-                teamDb
-            )) as any
-
-            expect(result.success).toBe(true)
-            expect(result.format).toBe('json')
-            expect(result.count).toBeGreaterThan(0)
-            const parsed = JSON.parse(result.data)
-            expect(parsed.length).toBeGreaterThan(0)
-            expect(parsed[0].content).toBeDefined()
-        })
-
-        it('should export team entries in Markdown format', async () => {
-            const result = (await callTool(
-                'team_export_entries',
-                { format: 'markdown' },
-                personalDb,
-                undefined,
-                undefined,
-                undefined,
-                undefined,
-                teamDb
-            )) as any
-
-            expect(result.success).toBe(true)
-            expect(result.format).toBe('markdown')
-            expect(result.data).toContain('# Team Journal Export')
-            expect(result.data).toContain('Export test 1')
-        })
-
-        it('should filter export by tags and entry_type', async () => {
-            const result = (await callTool(
-                'team_export_entries',
-                { format: 'json', tags: ['export-1'], entry_type: 'technical_note' },
-                personalDb,
-                undefined,
-                undefined,
-                undefined,
-                undefined,
-                teamDb
-            )) as any
-
-            console.error('DEBUG TEAM DATA EXPORT', JSON.stringify(result, null, 2))
-            expect(result.success).toBe(true)
-            expect(result.count).toBe(1)
-            const parsed = JSON.parse(result.data)
-            expect(parsed[0].tags).toContain('export-1')
-        })
-
-        it('should return error if team DB is not configured', async () => {
-            const result = (await callTool(
-                'team_export_entries',
-                { format: 'json' },
-                personalDb
-            )) as any
-
-            expect(result.success).toBe(false)
-            expect(result.error).toContain('Team database not configured')
-        })
-    })
-
-    describe('team_backup and team_list_backups', () => {
-        it('should return error if team DB is not configured for backup', async () => {
-            const result = (await callTool('team_backup', {}, personalDb)) as any
-
-            expect(result.success).toBe(false)
-            expect(result.error).toContain('Team database not configured')
-        })
-
-        it('should return error if team DB is not configured for list', async () => {
-            const result = (await callTool('team_list_backups', {}, personalDb)) as any
-
-            expect(result.success).toBe(false)
-            expect(result.error).toContain('Team database not configured')
-        })
-
-        it('should create and list team backups', async () => {
-            const backupResult = (await callTool(
-                'team_backup',
-                { name: 'test-team-backup' },
-                personalDb,
-                undefined,
-                undefined,
-                undefined,
-                undefined,
-                teamDb
-            )) as any
-
-            expect(backupResult.success).toBe(true)
-            expect(backupResult.filename).toContain('test-team-backup')
-            expect(backupResult.sizeBytes).toBeGreaterThan(0)
-
-            const listResult = (await callTool(
-                'team_list_backups',
-                {},
-                personalDb,
-                undefined,
-                undefined,
-                undefined,
-                undefined,
-                teamDb
-            )) as any
-
-            expect(listResult.success).toBe(true)
-            expect(listResult.total).toBeGreaterThanOrEqual(1)
-            expect(listResult.backups.some((b: any) => b.filename === backupResult.filename)).toBe(
-                true
-            )
-            expect(listResult.hint).toBeUndefined()
-        })
-    })
-})