memory-journal-mcp 4.4.2 → 4.5.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-handlers.test.ts

@@ -335,5 +335,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/tool-handlers.test.ts

@@ -96,7 +96,7 @@ describe('Tool Handlers', () => {
                 'create_entry',
                 {
                     content: 'Full tool entry',
-                    entry_type: 'decision',
+                    entry_type: 'project_decision',
                     tags: ['tool-tag-a', 'tool-tag-b'],
                     is_personal: false,
                     significance_type: 'milestone',
@@ -105,9 +105,20 @@ describe('Tool Handlers', () => {
             )) as { success: boolean; entry: { entryType: string; tags: string[] } }
 
             expect(result.success).toBe(true)
-            expect(result.entry.entryType).toBe('decision')
+            expect(result.entry.entryType).toBe('project_decision')
             expect(result.entry.tags).toContain('tool-tag-a')
         })
+
+        it('should set isPersonal to false when share_with_team is true', async () => {
+            const result = (await callTool(
+                'create_entry',
+                { content: 'Team shared entry', share_with_team: true },
+                db
+            )) as { success: boolean; entry: { isPersonal: boolean } }
+
+            expect(result.success).toBe(true)
+            expect(result.entry.isPersonal).toBe(false)
+        })
     })
 
     describe('callTool - create_entry_minimal', () => {

package/tests/security/sql-injection.test.ts

@@ -10,11 +10,8 @@ import { SqliteAdapter } from '../../src/database/SqliteAdapter.js'
 import {
     validateDateFormatPattern,
     sanitizeSearchQuery,
-    containsSqlInjection,
-    assertNoSqlInjection,
     assertNoPathTraversal,
     InvalidDateFormatError,
-    SqlInjectionError,
     PathTraversalError,
 } from '../../src/utils/security-utils.js'
 
@@ -120,52 +117,6 @@ describe('Security Utilities', () => {
         })
     })
 
-    describe('containsSqlInjection', () => {
-        it('should detect stacked query injection', () => {
-            expect(containsSqlInjection('; DROP TABLE users')).toBe(true)
-            expect(containsSqlInjection("'; DELETE FROM logs --")).toBe(true)
-        })
-
-        it('should detect comment injection', () => {
-            expect(containsSqlInjection('value -- comment')).toBe(true)
-            expect(containsSqlInjection('test /* block */ comment')).toBe(true)
-        })
-
-        it('should detect UNION injection', () => {
-            expect(containsSqlInjection("' UNION SELECT * FROM users")).toBe(true)
-            expect(containsSqlInjection("' UNION ALL SELECT 1")).toBe(true)
-        })
-
-        it('should detect boolean bypass', () => {
-            expect(containsSqlInjection("' OR '1'='1")).toBe(true)
-        })
-
-        it('should detect SQLite-specific attacks', () => {
-            expect(containsSqlInjection("ATTACH DATABASE 'mal.db' AS x")).toBe(true)
-            expect(containsSqlInjection("load_extension('evil.so')")).toBe(true)
-        })
-
-        it('should not flag safe inputs', () => {
-            for (const input of SAFE_INPUTS) {
-                expect(containsSqlInjection(input)).toBe(false)
-            }
-        })
-    })
-
-    describe('assertNoSqlInjection', () => {
-        it('should throw SqlInjectionError for injection attempts', () => {
-            for (const payload of INJECTION_PAYLOADS) {
-                expect(() => assertNoSqlInjection(payload)).toThrow(SqlInjectionError)
-            }
-        })
-
-        it('should not throw for safe inputs', () => {
-            for (const input of SAFE_INPUTS) {
-                expect(() => assertNoSqlInjection(input)).not.toThrow()
-            }
-        })
-    })
-
     describe('assertNoPathTraversal', () => {
         it('should throw for path traversal attempts', () => {
             expect(() => assertNoPathTraversal('../secret')).toThrow(PathTraversalError)
@@ -314,16 +265,14 @@ describe('SqliteAdapter SQL Injection Protection', () => {
     describe('restoreFromFile - Path Traversal Protection', () => {
         it('should reject filenames with path traversal', async () => {
             await expect(db.restoreFromFile('../../../etc/passwd')).rejects.toThrow(
-                'Invalid backup filename: path separators not allowed'
+                PathTraversalError
             )
 
             await expect(db.restoreFromFile('..\\..\\windows\\system32')).rejects.toThrow(
-                'Invalid backup filename: path separators not allowed'
+                PathTraversalError
             )
 
-            await expect(db.restoreFromFile('/etc/passwd')).rejects.toThrow(
-                'Invalid backup filename: path separators not allowed'
-            )
+            await expect(db.restoreFromFile('/etc/passwd')).rejects.toThrow(PathTraversalError)
         })
     })