memory-journal-mcp 4.4.2 → 5.0.0

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

@@ -0,0 +1,106 @@
+/**
+ * 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 { SqliteAdapter } from '../../src/database/SqliteAdapter.js'
+import { execQuery, getPrompts, getPrompt } from '../../src/handlers/prompts/index.js'
+
+describe('Prompt Handlers - Coverage', () => {
+    let db: SqliteAdapter
+    const testDbPath = './test-prompts-cov.db'
+
+    beforeAll(async () => {
+        db = new SqliteAdapter(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('Unknown 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

@@ -87,5 +87,45 @@ describe('Prompt Handlers', () => {
         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)
+        })
     })
 })

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

@@ -0,0 +1,181 @@
+/**
+ * Resource Handler Coverage Tests — Targeted Gap Closure
+ *
+ * Tests for remaining uncovered lines in:
+ * - handlers/resources/index.ts: getBaseUri non-memory URL, template match + ResourceResult
+ * - handlers/resources/templates.ts: invalid params for template resources
+ * - handlers/resources/core.ts: CI status branches, scheduler section
+ */
+
+import { describe, it, expect, beforeAll, afterAll } from 'vitest'
+import { readResource } from '../../src/handlers/resources/index.js'
+import { SqliteAdapter } from '../../src/database/SqliteAdapter.js'
+
+describe('Resource Handler Coverage', () => {
+    let db: SqliteAdapter
+    const testDbPath = './test-resource-coverage.db'
+
+    beforeAll(async () => {
+        db = new SqliteAdapter(testDbPath)
+        await db.initialize()
+
+        // Create entries with project/issue/PR links for template tests
+        db.createEntry({
+            content: 'Resource coverage test entry',
+            tags: ['resource-test'],
+            projectNumber: 42,
+            issueNumber: 7,
+            prNumber: 3,
+        })
+    })
+
+    afterAll(() => {
+        db.close()
+        try {
+            const fs = require('node:fs')
+            if (fs.existsSync(testDbPath)) fs.unlinkSync(testDbPath)
+        } catch {
+            // cleanup
+        }
+    })
+
+    // ========================================================================
+    // handlers/resources/index.ts — getBaseUri, template matching
+    // ========================================================================
+
+    describe('readResource - base URI parsing', () => {
+        it('should handle memory:// URIs with query parameters', async () => {
+            const result = await readResource('memory://recent?limit=5&format=brief', db)
+            expect(result.data).toBeDefined()
+        })
+
+        it('should throw for unknown resource URI', async () => {
+            await expect(readResource('memory://nonexistent-resource-xyz', db)).rejects.toThrow(
+                'Unknown resource'
+            )
+        })
+
+        it('should throw for non-memory URI schemes', async () => {
+            await expect(readResource('https://example.com/unknown', db)).rejects.toThrow(
+                'Unknown resource'
+            )
+        })
+    })
+
+    // ========================================================================
+    // handlers/resources/templates.ts — invalid template params (lines 33, 67, 100)
+    // ========================================================================
+
+    describe('template resources — invalid params', () => {
+        it('should return error for invalid project timeline number', async () => {
+            const result = await readResource('memory://projects/abc/timeline', db)
+            expect(result.data).toHaveProperty('error')
+        })
+
+        it('should return entries for valid project timeline', async () => {
+            const result = await readResource('memory://projects/42/timeline', db)
+            const data = result.data as { projectNumber: number; entries: unknown[] }
+            expect(data.projectNumber).toBe(42)
+            expect(data.entries).toBeDefined()
+        })
+
+        it('should return error for invalid issue entries number', async () => {
+            const result = await readResource('memory://issues/abc/entries', db)
+            expect(result.data).toHaveProperty('error')
+        })
+
+        it('should return entries for valid issue entries', async () => {
+            const result = await readResource('memory://issues/7/entries', db)
+            const data = result.data as { issueNumber: number; entries: unknown[] }
+            expect(data.issueNumber).toBe(7)
+        })
+
+        it('should return error for invalid PR entries number', async () => {
+            const result = await readResource('memory://prs/abc/entries', db)
+            expect(result.data).toHaveProperty('error')
+        })
+
+        it('should return entries for valid PR entries', async () => {
+            const result = await readResource('memory://prs/3/entries', db)
+            const data = result.data as { prNumber: number; entries: unknown[] }
+            expect(data.prNumber).toBe(3)
+        })
+
+        it('should return error for invalid PR timeline number', async () => {
+            const result = await readResource('memory://prs/abc/timeline', db)
+            expect(result.data).toHaveProperty('error')
+        })
+
+        it('should return timeline without GitHub for valid PR', async () => {
+            const result = await readResource('memory://prs/3/timeline', db)
+            const data = result.data as {
+                prNumber: number
+                prMetadata: null
+                timelineNote: string
+            }
+            expect(data.prNumber).toBe(3)
+            expect(data.prMetadata).toBeNull()
+            expect(data.timelineNote).toContain('unavailable')
+        })
+
+        it('should return error for invalid kanban project number', async () => {
+            const result = await readResource('memory://kanban/abc', db)
+            expect(result.data).toHaveProperty('error')
+        })
+
+        it('should return error for kanban without github', async () => {
+            const result = await readResource('memory://kanban/1', db)
+            const data = result.data as { error: string }
+            expect(data.error).toContain('not available')
+        })
+
+        it('should return error for invalid kanban diagram number', async () => {
+            const result = await readResource('memory://kanban/abc/diagram', db)
+            expect(result.data).toHaveProperty('error')
+        })
+
+        it('should return mermaid fallback for diagram without github', async () => {
+            const result = await readResource('memory://kanban/1/diagram', db)
+            const data = result.data as { format: string; diagram: string }
+            expect(data.format).toBe('mermaid')
+            expect(data.diagram).toContain('not available')
+        })
+    })
+
+    // Note: health endpoint is served by HttpTransport, not as a memory:// resource.
+
+    // ========================================================================
+    // handlers/resources/core.ts — instructions resource
+    // ========================================================================
+
+    describe('core resources — instructions', () => {
+        it('should return instructions text', async () => {
+            const result = await readResource('memory://instructions', db)
+            expect(result.data).toBeDefined()
+            expect(typeof result.data).toBe('string')
+        })
+    })
+
+    // ========================================================================
+    // handlers/resources/core.ts — briefing resource
+    // ========================================================================
+
+    describe('core resources — briefing', () => {
+        it('should return briefing data', async () => {
+            const result = await readResource('memory://briefing', db)
+            expect(result.data).toBeDefined()
+        })
+    })
+
+    // ========================================================================
+    // handlers/resources/core.ts — recent with entry_type filter
+    // ========================================================================
+
+    describe('core resources — recent with filters', () => {
+        it('should return recent entries with query params', async () => {
+            const result = await readResource('memory://recent?limit=3', db)
+            const data = result.data as { entries: unknown[] }
+            expect(data.entries).toBeDefined()
+        })
+    })
+})

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

@@ -76,7 +76,6 @@ describe('Resource Handlers', () => {
             expect(uris).toContain('memory://recent')
             expect(uris).toContain('memory://significant')
             expect(uris).toContain('memory://tags')
-            expect(uris).toContain('memory://team/recent')
         })
 
         it('should include template resources', () => {
@@ -122,7 +121,7 @@ describe('Resource Handlers', () => {
             const result = await readResource('memory://instructions', db, undefined, null)
 
             const text = result.data as string
-            expect(text).toContain('Active Tools (39)')
+            expect(text).toContain('Active Tools (42)')
         })
 
         it('should read memory://recent', async () => {
@@ -203,13 +202,6 @@ describe('Resource Handlers', () => {
             expect(data.timestamp).toBeDefined()
         })
 
-        it('should read memory://team/recent', async () => {
-            const result = await readResource('memory://team/recent', db)
-
-            const data = result.data as { entries: unknown[]; count: number }
-            expect(data.entries).toBeDefined()
-        })
-
         it('should read memory://graph/recent', async () => {
             const result = await readResource('memory://graph/recent', db)
 
@@ -335,5 +327,37 @@ describe('Resource Handlers', () => {
             const data = result.data as { prNumber: number }
             expect(data.prNumber).toBe(15)
         })
+
+        it('should handle resource URI with query parameters', async () => {
+            // Query params should be stripped for matching but the full URI is passed to the handler
+            const result = await readResource('memory://recent?limit=5', db)
+            const data = result.data as { entries: unknown[]; count: number }
+            expect(data.entries).toBeDefined()
+        })
+
+        it('should handle resource URI with hash fragment', async () => {
+            const result = await readResource('memory://recent#section', db)
+            const data = result.data as { entries: unknown[]; count: number }
+            expect(data.entries).toBeDefined()
+        })
+
+        it('should handle template URI with query parameters', async () => {
+            const result = await readResource('memory://projects/42/timeline?sort=asc', db)
+            const data = result.data as { projectNumber: number }
+            expect(data.projectNumber).toBe(42)
+        })
+
+        it('should return no-github diagram for kanban without integration', async () => {
+            const result = await readResource(
+                'memory://kanban/1/diagram',
+                db,
+                undefined,
+                undefined,
+                null // no github
+            )
+            const data = result.data as { format: string; diagram: string; message: string }
+            expect(data.format).toBe('mermaid')
+            expect(data.diagram).toContain('GitHub integration not available')
+        })
     })
 })

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

@@ -0,0 +1,272 @@
+/**
+ * Search Tool Handler Coverage Tests
+ *
+ * Tests for search tool uncovered code paths:
+ * - search_entries with teamDb (cross-database merge)
+ * - search_by_date_range with teamDb
+ * - search_entries with GitHub filters
+ * - search_entries with no query and no filters (recent entries path)
+ * - search_by_date_range with entry_type filter
+ * - mergeAndDedup helper (dedup, sort, limit)
+ */
+
+import { describe, it, expect, beforeAll, afterAll } from 'vitest'
+import { callTool } from '../../src/handlers/tools/index.js'
+import { SqliteAdapter } from '../../src/database/SqliteAdapter.js'
+
+describe('Search Tool Handlers - Coverage', () => {
+    let db: SqliteAdapter
+    let teamDb: SqliteAdapter
+    const testDbPath = './test-search-cov.db'
+    const teamDbPath = './test-search-team-cov.db'
+
+    beforeAll(async () => {
+        db = new SqliteAdapter(testDbPath)
+        await db.initialize()
+        teamDb = new SqliteAdapter(teamDbPath)
+        await teamDb.initialize()
+
+        // Seed personal entries
+        db.createEntry({
+            content: 'Personal alpha entry',
+            entryType: 'personal_reflection',
+            tags: ['alpha'],
+            projectNumber: 42,
+            issueNumber: 7,
+            prNumber: 10,
+        })
+        db.createEntry({
+            content: 'Personal beta entry',
+            entryType: 'project_decision',
+            tags: ['beta'],
+            isPersonal: true,
+        })
+
+        // Seed team entries
+        teamDb.createEntry({
+            content: 'Team gamma entry',
+            entryType: 'personal_reflection',
+            tags: ['gamma'],
+            projectNumber: 42,
+        })
+        teamDb.createEntry({
+            content: 'Team delta entry',
+            entryType: 'project_decision',
+            tags: ['delta'],
+        })
+        // Duplicate content to test dedup
+        teamDb.createEntry({
+            content: 'Personal alpha entry',
+            entryType: 'personal_reflection',
+            tags: ['dup'],
+        })
+    })
+
+    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
+        }
+    })
+
+    // ========================================================================
+    // search_entries — cross-database merge
+    // ========================================================================
+
+    describe('search_entries with teamDb', () => {
+        it('should merge personal and team results', async () => {
+            const result = (await callTool(
+                'search_entries',
+                { query: 'entry', limit: 10 },
+                db,
+                undefined,
+                undefined,
+                undefined,
+                undefined,
+                teamDb
+            )) as { entries: unknown[]; count: number }
+
+            // Should have entries from both DBs (deduped)
+            expect(result.count).toBeGreaterThan(0)
+            expect(result.entries.length).toBe(result.count)
+        })
+
+        it('should deduplicate entries with same content', async () => {
+            const result = (await callTool(
+                'search_entries',
+                { query: 'alpha', limit: 50 },
+                db,
+                undefined,
+                undefined,
+                undefined,
+                undefined,
+                teamDb
+            )) as { entries: { content: string }[]; count: number }
+
+            // "Personal alpha entry" exists in both DBs — should be deduped
+            const alphaEntries = result.entries.filter((e) =>
+                e.content.includes('Personal alpha entry')
+            )
+            expect(alphaEntries.length).toBe(1)
+        })
+
+        it('should merge recent entries (no query, no filters)', async () => {
+            const result = (await callTool(
+                'search_entries',
+                { limit: 10 },
+                db,
+                undefined,
+                undefined,
+                undefined,
+                undefined,
+                teamDb
+            )) as { entries: unknown[]; count: number }
+
+            expect(result.count).toBeGreaterThan(0)
+        })
+    })
+
+    // ========================================================================
+    // search_entries — GitHub filters
+    // ========================================================================
+
+    describe('search_entries with filters', () => {
+        it('should filter by project_number', async () => {
+            const result = (await callTool(
+                'search_entries',
+                { project_number: 42, limit: 10 },
+                db
+            )) as { entries: unknown[]; count: number }
+
+            expect(result.count).toBeGreaterThan(0)
+        })
+
+        it('should filter by issue_number', async () => {
+            const result = (await callTool(
+                'search_entries',
+                { issue_number: 7, limit: 10 },
+                db
+            )) as { entries: unknown[]; count: number }
+
+            expect(result.count).toBeGreaterThan(0)
+        })
+
+        it('should filter by pr_number', async () => {
+            const result = (await callTool('search_entries', { pr_number: 10, limit: 10 }, db)) as {
+                entries: unknown[]
+                count: number
+            }
+
+            expect(result.count).toBeGreaterThan(0)
+        })
+
+        it('should filter by is_personal', async () => {
+            const result = (await callTool(
+                'search_entries',
+                { is_personal: true, limit: 10 },
+                db
+            )) as { entries: unknown[]; count: number }
+
+            expect(result.count).toBeGreaterThan(0)
+        })
+
+        it('should handle combined filters with teamDb', async () => {
+            const result = (await callTool(
+                'search_entries',
+                { project_number: 42, limit: 10 },
+                db,
+                undefined,
+                undefined,
+                undefined,
+                undefined,
+                teamDb
+            )) as { entries: unknown[]; count: number }
+
+            expect(result.count).toBeGreaterThan(0)
+        })
+    })
+
+    // ========================================================================
+    // search_by_date_range — cross-database merge
+    // ========================================================================
+
+    describe('search_by_date_range with teamDb', () => {
+        it('should merge personal and team results by date', async () => {
+            const today = new Date().toISOString().split('T')[0]!
+            const result = (await callTool(
+                'search_by_date_range',
+                { start_date: today, end_date: today },
+                db,
+                undefined,
+                undefined,
+                undefined,
+                undefined,
+                teamDb
+            )) as { entries: unknown[]; count: number }
+
+            expect(result.count).toBeGreaterThan(0)
+        })
+
+        it('should apply entry_type filter', async () => {
+            const today = new Date().toISOString().split('T')[0]!
+            const result = (await callTool(
+                'search_by_date_range',
+                {
+                    start_date: today,
+                    end_date: today,
+                    entry_type: 'project_decision',
+                },
+                db
+            )) as { entries: unknown[]; count: number }
+
+            expect(result.count).toBeGreaterThan(0)
+        })
+
+        it('should apply tags filter', async () => {
+            const today = new Date().toISOString().split('T')[0]!
+            const result = (await callTool(
+                'search_by_date_range',
+                {
+                    start_date: today,
+                    end_date: today,
+                    tags: ['alpha'],
+                },
+                db
+            )) as { entries: unknown[]; count: number }
+
+            expect(result.count).toBeGreaterThan(0)
+        })
+
+        it('should return Zod error for invalid date format', async () => {
+            const result = (await callTool(
+                'search_by_date_range',
+                { start_date: 'not-a-date', end_date: 'invalid' },
+                db
+            )) as { error: string }
+
+            expect(result.error).toBeDefined()
+        })
+    })
+
+    // ========================================================================
+    // search_entries — Zod error handling
+    // ========================================================================
+
+    describe('search_entries error handling', () => {
+        it('should return error for invalid pr_status enum', async () => {
+            const result = (await callTool(
+                'search_entries',
+                { pr_status: 'invalid_status', limit: 5 },
+                db
+            )) as { error: string }
+
+            expect(result.error).toBeDefined()
+        })
+    })
+})