@synth-coder/memhub 0.1.0

package/test/server/mcp-server.test.ts

@@ -0,0 +1,97 @@
+/**
+ * MCP Server Tests
+ * Tests for the McpServer class
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { McpServer } from '../../src/server/mcp-server.js';
+import {
+  TOOL_DEFINITIONS,
+  SERVER_INFO,
+  ERROR_CODES,
+  MCP_PROTOCOL_VERSION,
+} from '../../src/contracts/mcp.js';
+import { mkdtempSync, rmSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+
+describe('McpServer', () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = mkdtempSync(join(tmpdir(), 'memhub-server-test-'));
+    process.env.MEMHUB_STORAGE_PATH = tempDir;
+  });
+
+  afterEach(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+    delete process.env.MEMHUB_STORAGE_PATH;
+  });
+
+  describe('constructor', () => {
+    it('should create server instance', () => {
+      const server = new McpServer();
+      expect(server).toBeDefined();
+    });
+  });
+
+  describe('TOOL_DEFINITIONS', () => {
+    it('should have 2 tools defined', () => {
+      expect(TOOL_DEFINITIONS).toHaveLength(2);
+    });
+
+    it('should include STM-first tools', () => {
+      const toolNames = TOOL_DEFINITIONS.map(t => t.name);
+      expect(toolNames).toContain('memory_load');
+      expect(toolNames).toContain('memory_update');
+    });
+
+    it('should have descriptions for all tools', () => {
+      for (const tool of TOOL_DEFINITIONS) {
+        expect(tool.description).toBeDefined();
+        expect(tool.description.length).toBeGreaterThan(0);
+      }
+    });
+
+    it('should have input schemas for all tools', () => {
+      for (const tool of TOOL_DEFINITIONS) {
+        expect(tool.inputSchema).toBeDefined();
+        expect(tool.inputSchema.type).toBe('object');
+      }
+    });
+  });
+
+  describe('ServerInfo', () => {
+    it('should have correct server name', () => {
+      expect(SERVER_INFO.name).toBe('memhub');
+    });
+
+    it('should have version', () => {
+      expect(SERVER_INFO.version).toBeDefined();
+      expect(SERVER_INFO.version).toMatch(/^\d+\.\d+\.\d+/);
+    });
+  });
+
+  describe('ErrorCodes', () => {
+    it('should have standard MCP error codes', () => {
+      expect(ERROR_CODES.PARSE_ERROR).toBe(-32700);
+      expect(ERROR_CODES.INVALID_REQUEST).toBe(-32600);
+      expect(ERROR_CODES.METHOD_NOT_FOUND).toBe(-32601);
+      expect(ERROR_CODES.INVALID_PARAMS).toBe(-32602);
+      expect(ERROR_CODES.INTERNAL_ERROR).toBe(-32603);
+    });
+
+    it('should have custom MemHub error codes', () => {
+      expect(ERROR_CODES.NOT_FOUND).toBe(-32001);
+      expect(ERROR_CODES.STORAGE_ERROR).toBe(-32002);
+      expect(ERROR_CODES.VALIDATION_ERROR).toBe(-32003);
+      expect(ERROR_CODES.DUPLICATE_ERROR).toBe(-32004);
+    });
+  });
+
+  describe('Protocol', () => {
+    it('should have correct protocol version', () => {
+      expect(MCP_PROTOCOL_VERSION).toBe('2024-11-05');
+    });
+  });
+});

package/test/services/memory-service-edge.test.ts

@@ -0,0 +1,248 @@
+/**
+ * Memory Service Edge Case Tests
+ * Additional tests for better coverage
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtempSync, rmSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { MemoryService, ServiceError } from '../../src/services/memory-service.js';
+
+describe('MemoryService Edge Cases', () => {
+  let tempDir: string;
+  let memoryService: MemoryService;
+
+  beforeEach(() => {
+    tempDir = mkdtempSync(join(tmpdir(), 'memhub-edge-test-'));
+    memoryService = new MemoryService({ storagePath: tempDir });
+  });
+
+  afterEach(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  describe('create with edge cases', () => {
+    it('should handle empty content', async () => {
+      const result = await memoryService.create({
+        title: 'Empty Content',
+        content: '',
+      });
+      expect(result.memory.content).toBe('');
+    });
+
+    it('should handle very long title', async () => {
+      const longTitle = 'A'.repeat(200);
+      const result = await memoryService.create({
+        title: longTitle,
+        content: 'Content',
+      });
+      expect(result.memory.title).toBe(longTitle);
+    });
+
+    it('should handle special characters in title', async () => {
+      const result = await memoryService.create({
+        title: 'Title with @#$%^&*() special chars!',
+        content: 'Content',
+      });
+      expect(result.memory.title).toBe('Title with @#$%^&*() special chars!');
+    });
+
+    it('should handle many tags', async () => {
+      const tags = Array.from({ length: 20 }, (_, i) => `tag${i}`);
+      const result = await memoryService.create({
+        title: 'Many Tags',
+        content: 'Content',
+        tags,
+      });
+      expect(result.memory.tags).toHaveLength(20);
+    });
+  });
+
+  describe('update edge cases', () => {
+    it('should update only tags', async () => {
+      const created = await memoryService.create({
+        title: 'Title',
+        content: 'Content',
+        tags: ['old'],
+      });
+      const updated = await memoryService.update({
+        id: created.id,
+        tags: ['new1', 'new2'],
+      });
+      expect(updated.memory.tags).toEqual(['new1', 'new2']);
+      expect(updated.memory.title).toBe('Title');
+      expect(updated.memory.content).toBe('Content');
+    });
+
+    it('should update only importance', async () => {
+      const created = await memoryService.create({
+        title: 'Title',
+        content: 'Content',
+        importance: 1,
+      });
+      const updated = await memoryService.update({
+        id: created.id,
+        importance: 5,
+      });
+      expect(updated.memory.importance).toBe(5);
+    });
+
+    it('should update only category', async () => {
+      const created = await memoryService.create({
+        title: 'Title',
+        content: 'Content',
+        category: 'old-category',
+      });
+      const updated = await memoryService.update({
+        id: created.id,
+        category: 'new-category',
+      });
+      expect(updated.memory.category).toBe('new-category');
+    });
+  });
+
+  describe('list with various filters', () => {
+    beforeEach(async () => {
+      // Create test data with various dates
+      const baseDate = new Date('2024-01-15');
+      for (let i = 0; i < 5; i++) {
+        const date = new Date(baseDate);
+        date.setDate(date.getDate() + i);
+        await memoryService.create({
+          title: `Memory ${i}`,
+          content: 'Content',
+          category: i % 2 === 0 ? 'even' : 'odd',
+          tags: [`tag${i}`, 'common'],
+        });
+      }
+    });
+
+    it('should filter by date range', async () => {
+      // The created memories will have current timestamp, so we need to use a wide range
+      const now = new Date();
+      const yesterday = new Date(now);
+      yesterday.setDate(yesterday.getDate() - 1);
+      const tomorrow = new Date(now);
+      tomorrow.setDate(tomorrow.getDate() + 1);
+
+      const result = await memoryService.list({
+        fromDate: yesterday.toISOString(),
+        toDate: tomorrow.toISOString(),
+      });
+      expect(result.memories.length).toBeGreaterThan(0);
+    });
+
+    it('should handle empty result with strict filters', async () => {
+      const result = await memoryService.list({
+        category: 'non-existent',
+      });
+      expect(result.memories).toHaveLength(0);
+      expect(result.total).toBe(0);
+      expect(result.hasMore).toBe(false);
+    });
+
+    it('should sort by importance', async () => {
+      await memoryService.create({
+        title: 'High Importance',
+        content: 'Content',
+        importance: 5,
+      });
+      await memoryService.create({
+        title: 'Low Importance',
+        content: 'Content',
+        importance: 1,
+      });
+
+      const result = await memoryService.list({
+        sortBy: 'importance',
+        sortOrder: 'desc',
+      });
+      expect(result.memories[0].importance).toBe(5);
+    });
+
+    it('should handle pagination across multiple pages', async () => {
+      const page1 = await memoryService.list({ limit: 2, offset: 0 });
+      expect(page1.memories).toHaveLength(2);
+      expect(page1.hasMore).toBe(true);
+
+      const page2 = await memoryService.list({ limit: 2, offset: 2 });
+      expect(page2.memories).toHaveLength(2);
+      expect(page2.hasMore).toBe(true);
+
+      const page3 = await memoryService.list({ limit: 2, offset: 4 });
+      expect(page3.memories.length).toBeGreaterThanOrEqual(1);
+    });
+  });
+
+  describe('search edge cases', () => {
+    beforeEach(async () => {
+      await memoryService.create({
+        title: 'Project Alpha',
+        content: 'This is about the alpha project development.',
+        tags: ['alpha', 'dev'],
+      });
+      await memoryService.create({
+        title: 'Project Beta',
+        content: 'Beta testing is in progress.',
+        tags: ['beta', 'testing'],
+      });
+    });
+
+    it('should search with case insensitivity', async () => {
+      const result = await memoryService.search({ query: 'ALPHA' });
+      expect(result.results.length).toBeGreaterThan(0);
+    });
+
+    it('should handle search with no results', async () => {
+      const result = await memoryService.search({ query: 'xyznonexistent' });
+      expect(result.results).toHaveLength(0);
+      expect(result.total).toBe(0);
+    });
+
+    it('should limit search results', async () => {
+      const result = await memoryService.search({ query: 'project', limit: 1 });
+      expect(result.results.length).toBeLessThanOrEqual(1);
+    });
+
+    it('should search with category filter', async () => {
+      await memoryService.create({
+        title: 'Work Item',
+        content: 'Work content',
+        category: 'work',
+      });
+      const result = await memoryService.search({
+        query: 'work',
+        category: 'work',
+      });
+      expect(result.results.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('getCategories and getTags edge cases', () => {
+    it('should return sorted categories', async () => {
+      await memoryService.create({ title: 'A', content: 'C', category: 'zebra' });
+      await memoryService.create({ title: 'B', content: 'C', category: 'alpha' });
+      await memoryService.create({ title: 'C', content: 'C', category: 'beta' });
+
+      const result = await memoryService.getCategories();
+      expect(result.categories).toEqual(['alpha', 'beta', 'zebra']);
+    });
+
+    it('should return sorted tags', async () => {
+      await memoryService.create({ title: 'A', content: 'C', tags: ['zebra', 'alpha'] });
+      await memoryService.create({ title: 'B', content: 'C', tags: ['beta'] });
+
+      const result = await memoryService.getTags();
+      expect(result.tags).toEqual(['alpha', 'beta', 'zebra']);
+    });
+
+    it('should handle duplicate tags across memories', async () => {
+      await memoryService.create({ title: 'A', content: 'C', tags: ['shared'] });
+      await memoryService.create({ title: 'B', content: 'C', tags: ['shared'] });
+
+      const result = await memoryService.getTags();
+      expect(result.tags).toEqual(['shared']);
+    });
+  });
+});

package/test/services/memory-service.test.ts

@@ -0,0 +1,279 @@
+/**
+ * Memory Service Tests
+ * Tests for the MemoryService class
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtempSync, rmSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { MemoryService, ServiceError } from '../../src/services/memory-service.js';
+import type {
+  CreateMemoryInput,
+  UpdateMemoryInput,
+  ListMemoryInput,
+  SearchMemoryInput,
+} from '../../src/contracts/types.js';
+
+describe('MemoryService', () => {
+  let tempDir: string;
+  let memoryService: MemoryService;
+
+  beforeEach(() => {
+    tempDir = mkdtempSync(join(tmpdir(), 'memhub-test-'));
+    memoryService = new MemoryService({ storagePath: tempDir });
+  });
+
+  afterEach(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  describe('create', () => {
+    it('should create a new memory with generated ID', async () => {
+      const input: CreateMemoryInput = {
+        title: 'Test Memory',
+        content: 'This is a test memory',
+      };
+
+      const result = await memoryService.create(input);
+      expect(result.id).toBeDefined();
+      expect(result.id).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i);
+    });
+
+    it('should create memory file with correct format', async () => {
+      const input: CreateMemoryInput = {
+        title: 'Test Memory',
+        content: 'This is a test memory',
+        tags: ['test', 'memory'],
+        category: 'testing',
+        importance: 4,
+      };
+
+      const result = await memoryService.create(input);
+      const { readFileSync } = await import('fs');
+      const fileContent = readFileSync(result.filePath, 'utf-8');
+      expect(fileContent).toContain('---');
+      expect(fileContent).toContain('id:');
+      expect(fileContent).toContain('# Test Memory');
+    });
+
+    it('should set timestamps on creation', async () => {
+      const input: CreateMemoryInput = {
+        title: 'Test Memory',
+        content: 'Content',
+      };
+
+      const before = new Date().toISOString();
+      const result = await memoryService.create(input);
+      const after = new Date().toISOString();
+      expect(result.memory.createdAt >= before).toBe(true);
+      expect(result.memory.createdAt <= after).toBe(true);
+      expect(result.memory.updatedAt).toBe(result.memory.createdAt);
+    });
+
+    it('should apply default values for optional fields', async () => {
+      const input: CreateMemoryInput = {
+        title: 'Test Memory',
+        content: 'Content',
+      };
+
+      const result = await memoryService.create(input);
+      expect(result.memory.tags).toEqual([]);
+      expect(result.memory.category).toBe('general');
+      expect(result.memory.importance).toBe(3);
+    });
+
+    it('should generate URL-friendly filename from title', async () => {
+      const input: CreateMemoryInput = {
+        title: 'Hello World Test',
+        content: 'Content',
+      };
+
+      const result = await memoryService.create(input);
+      expect(result.filePath).toContain('hello-world-test');
+    });
+  });
+
+  describe('read', () => {
+    it('should read existing memory by ID', async () => {
+      const created = await memoryService.create({ title: 'Test', content: 'Content' });
+      const read = await memoryService.read({ id: created.id });
+      expect(read.memory.id).toBe(created.id);
+      expect(read.memory.title).toBe('Test');
+    });
+
+    it('should throw NOT_FOUND error for non-existent ID', async () => {
+      await expect(
+        memoryService.read({ id: '550e8400-e29b-41d4-a716-446655440000' })
+      ).rejects.toThrow(ServiceError);
+    });
+  });
+
+  describe('update', () => {
+    it('should update memory title', async () => {
+      const created = await memoryService.create({ title: 'Old Title', content: 'Content' });
+      const updated = await memoryService.update({ id: created.id, title: 'New Title' });
+      expect(updated.memory.title).toBe('New Title');
+      expect(updated.memory.content).toBe('Content');
+    });
+
+    it('should update memory content', async () => {
+      const created = await memoryService.create({ title: 'Title', content: 'Old Content' });
+      const updated = await memoryService.update({ id: created.id, content: 'New Content' });
+      expect(updated.memory.content).toBe('New Content');
+    });
+
+    it('should update updatedAt timestamp', async () => {
+      const created = await memoryService.create({ title: 'Title', content: 'Content' });
+      await new Promise(resolve => setTimeout(resolve, 10));
+      const updated = await memoryService.update({ id: created.id, title: 'New Title' });
+      expect(new Date(updated.memory.updatedAt).getTime()).toBeGreaterThan(
+        new Date(created.memory.updatedAt).getTime()
+      );
+    });
+
+    it('should not change createdAt timestamp', async () => {
+      const created = await memoryService.create({ title: 'Title', content: 'Content' });
+      const updated = await memoryService.update({ id: created.id, title: 'New Title' });
+      expect(updated.memory.createdAt).toBe(created.memory.createdAt);
+    });
+
+    it('should throw NOT_FOUND error for non-existent ID', async () => {
+      await expect(
+        memoryService.update({ id: '550e8400-e29b-41d4-a716-446655440000', title: 'New' })
+      ).rejects.toThrow(ServiceError);
+    });
+  });
+
+  describe('delete', () => {
+    it('should delete existing memory', async () => {
+      const created = await memoryService.create({ title: 'To Delete', content: 'Content' });
+      const result = await memoryService.delete({ id: created.id });
+      expect(result.success).toBe(true);
+      await expect(memoryService.read({ id: created.id })).rejects.toThrow(ServiceError);
+    });
+
+    it('should return file path of deleted memory', async () => {
+      const created = await memoryService.create({ title: 'To Delete', content: 'Content' });
+      const result = await memoryService.delete({ id: created.id });
+      expect(result.filePath).toBe(created.filePath);
+    });
+
+    it('should throw NOT_FOUND error for non-existent ID', async () => {
+      await expect(
+        memoryService.delete({ id: '550e8400-e29b-41d4-a716-446655440000' })
+      ).rejects.toThrow(ServiceError);
+    });
+  });
+
+  describe('list', () => {
+    beforeEach(async () => {
+      await memoryService.create({ title: 'Work 1', content: 'Content', category: 'work', tags: ['project'] });
+      await memoryService.create({ title: 'Work 2', content: 'Content', category: 'work', tags: ['meeting'] });
+      await memoryService.create({ title: 'Personal', content: 'Content', category: 'personal' });
+    });
+
+    it('should list all memories', async () => {
+      const result = await memoryService.list({});
+      expect(result.memories).toHaveLength(3);
+      expect(result.total).toBe(3);
+      expect(result.hasMore).toBe(false);
+    });
+
+    it('should filter by category', async () => {
+      const result = await memoryService.list({ category: 'work' });
+      expect(result.memories).toHaveLength(2);
+      expect(result.total).toBe(2);
+    });
+
+    it('should filter by tags', async () => {
+      const result = await memoryService.list({ tags: ['project'] });
+      expect(result.memories).toHaveLength(1);
+      expect(result.memories[0].title).toBe('Work 1');
+    });
+
+    it('should support pagination', async () => {
+      const result = await memoryService.list({ limit: 2, offset: 0 });
+      expect(result.memories).toHaveLength(2);
+      expect(result.hasMore).toBe(true);
+    });
+
+    it('should sort by specified field', async () => {
+      const result = await memoryService.list({ sortBy: 'title', sortOrder: 'asc' });
+      expect(result.memories[0].title).toBe('Personal');
+    });
+  });
+
+  describe('search', () => {
+    beforeEach(async () => {
+      await memoryService.create({
+        title: 'Project Planning',
+        content: 'We need to plan the project timeline and resources.',
+        tags: ['planning'],
+      });
+      await memoryService.create({
+        title: 'Meeting Notes',
+        content: 'Discussed project requirements and timeline.',
+        tags: ['meeting'],
+      });
+    });
+
+    it('should search in title', async () => {
+      const result = await memoryService.search({ query: 'planning' });
+      expect(result.results.length).toBeGreaterThan(0);
+      expect(result.results[0].memory.title).toBe('Project Planning');
+    });
+
+    it('should search in content', async () => {
+      const result = await memoryService.search({ query: 'timeline' });
+      expect(result.results.length).toBeGreaterThan(0);
+    });
+
+    it('should search in tags', async () => {
+      const result = await memoryService.search({ query: 'meeting' });
+      expect(result.results.length).toBeGreaterThan(0);
+    });
+
+    it('should return match snippets', async () => {
+      const result = await memoryService.search({ query: 'project' });
+      expect(result.results[0].matches.length).toBeGreaterThan(0);
+    });
+
+    it('should support multiple keywords', async () => {
+      const result = await memoryService.search({ query: 'project timeline' });
+      expect(result.results.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe('getCategories', () => {
+    it('should return all unique categories', async () => {
+      await memoryService.create({ title: '1', content: 'C', category: 'work' });
+      await memoryService.create({ title: '2', content: 'C', category: 'personal' });
+      await memoryService.create({ title: '3', content: 'C', category: 'work' });
+      const result = await memoryService.getCategories();
+      expect(result.categories).toContain('personal');
+      expect(result.categories).toContain('work');
+    });
+
+    it('should return empty array when no memories exist', async () => {
+      const result = await memoryService.getCategories();
+      expect(result.categories).toEqual([]);
+    });
+  });
+
+  describe('getTags', () => {
+    it('should return all unique tags', async () => {
+      await memoryService.create({ title: '1', content: 'C', tags: ['a', 'b'] });
+      await memoryService.create({ title: '2', content: 'C', tags: ['b', 'c'] });
+      const result = await memoryService.getTags();
+      expect(result.tags).toContain('a');
+      expect(result.tags).toContain('b');
+      expect(result.tags).toContain('c');
+    });
+
+    it('should return empty array when no memories exist', async () => {
+      const result = await memoryService.getTags();
+      expect(result.tags).toEqual([]);
+    });
+  });
+});