@synth-coder/memhub 0.2.2 → 0.2.3

package/test/frontmatter-parser-more.test.ts

@@ -1,94 +1,94 @@
-/**
- * Additional FrontMatter Parser Tests
- * For better branch coverage
- */
-
-import { describe, it, expect } from 'vitest';
-import {
-  parseFrontMatter,
-  stringifyFrontMatter,
-  FrontMatterError,
-} from '../src/storage/frontmatter-parser.js';
-import type { MemoryFrontMatter } from '../src/contracts/types.js';
-
-describe('parseFrontMatter additional branches', () => {
-  it('should throw for invalid front matter format', () => {
-    // Missing closing ---
-    const markdown = '---\nid: "test"\n# Title\n\nContent';
-    expect(() => parseFrontMatter(markdown)).toThrow(FrontMatterError);
-  });
-
-  it('should parse with Windows line endings', () => {
-    const markdown = `---\r\nid: "550e8400-e29b-41d4-a716-446655440000"\r\ncreated_at: "2024-03-15T10:30:00Z"\r\nupdated_at: "2024-03-15T10:30:00Z"\r\ntags: []\r\ncategory: "general"\r\nimportance: 3\r\n---\r\n\r\n# Title\r\n\r\nContent`;
-
-    const result = parseFrontMatter(markdown);
-    expect(result.frontMatter.id).toBe('550e8400-e29b-41d4-a716-446655440000');
-    expect(result.title).toBe('Title');
-  });
-
-  it('should handle front matter with extra whitespace', () => {
-    const markdown = `---
-  id: "550e8400-e29b-41d4-a716-446655440000"
-  created_at: "2024-03-15T10:30:00Z"
-  updated_at: "2024-03-15T10:30:00Z"
-  tags: []
-  category: "general"
-  importance: 3
----
-
-# Title
-
-Content`;
-
-    const result = parseFrontMatter(markdown);
-    expect(result.frontMatter.id).toBe('550e8400-e29b-41d4-a716-446655440000');
-  });
-});
-
-describe('stringifyFrontMatter additional branches', () => {
-  const baseFrontMatter: MemoryFrontMatter = {
-    id: '550e8400-e29b-41d4-a716-446655440000',
-    created_at: '2024-03-15T10:30:00Z',
-    updated_at: '2024-03-15T10:30:00Z',
-    tags: [],
-    category: 'general',
-    importance: 3,
-  };
-
-  it('should handle empty title', () => {
-    const result = stringifyFrontMatter(baseFrontMatter, '', 'Content');
-    expect(result).toContain('---');
-    expect(result).toContain('Content');
-  });
-
-  it('should handle empty content', () => {
-    const result = stringifyFrontMatter(baseFrontMatter, 'Title', '');
-    expect(result).toContain('# Title');
-  });
-
-  it('should handle both empty title and content', () => {
-    const result = stringifyFrontMatter(baseFrontMatter, '', '');
-    expect(result).toContain('---');
-    expect(result).toContain('id:');
-  });
-
-  it('should handle single tag', () => {
-    const fm = { ...baseFrontMatter, tags: ['single'] };
-    const result = stringifyFrontMatter(fm, 'Title', 'Content');
-    expect(result).toContain('single');
-  });
-
-  it('should handle many tags', () => {
-    const fm = { ...baseFrontMatter, tags: ['a', 'b', 'c', 'd', 'e'] };
-    const result = stringifyFrontMatter(fm, 'Title', 'Content');
-    expect(result).toContain('a');
-    expect(result).toContain('e');
-  });
-
-  it('should end with single newline', () => {
-    const result = stringifyFrontMatter(baseFrontMatter, 'Title', 'Content');
-    const lines = result.split('\n');
-    expect(lines[lines.length - 1]).toBe('');
-    expect(lines[lines.length - 2]).not.toBe('');
-  });
-});
+/**
+ * Additional FrontMatter Parser Tests
+ * For better branch coverage
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  parseFrontMatter,
+  stringifyFrontMatter,
+  FrontMatterError,
+} from '../src/storage/frontmatter-parser.js';
+import type { MemoryFrontMatter } from '../src/contracts/types.js';
+
+describe('parseFrontMatter additional branches', () => {
+  it('should throw for invalid front matter format', () => {
+    // Missing closing ---
+    const markdown = '---\nid: "test"\n# Title\n\nContent';
+    expect(() => parseFrontMatter(markdown)).toThrow(FrontMatterError);
+  });
+
+  it('should parse with Windows line endings', () => {
+    const markdown = `---\r\nid: "550e8400-e29b-41d4-a716-446655440000"\r\ncreated_at: "2024-03-15T10:30:00Z"\r\nupdated_at: "2024-03-15T10:30:00Z"\r\ntags: []\r\ncategory: "general"\r\nimportance: 3\r\n---\r\n\r\n# Title\r\n\r\nContent`;
+
+    const result = parseFrontMatter(markdown);
+    expect(result.frontMatter.id).toBe('550e8400-e29b-41d4-a716-446655440000');
+    expect(result.title).toBe('Title');
+  });
+
+  it('should handle front matter with extra whitespace', () => {
+    const markdown = `---
+  id: "550e8400-e29b-41d4-a716-446655440000"
+  created_at: "2024-03-15T10:30:00Z"
+  updated_at: "2024-03-15T10:30:00Z"
+  tags: []
+  category: "general"
+  importance: 3
+---
+
+# Title
+
+Content`;
+
+    const result = parseFrontMatter(markdown);
+    expect(result.frontMatter.id).toBe('550e8400-e29b-41d4-a716-446655440000');
+  });
+});
+
+describe('stringifyFrontMatter additional branches', () => {
+  const baseFrontMatter: MemoryFrontMatter = {
+    id: '550e8400-e29b-41d4-a716-446655440000',
+    created_at: '2024-03-15T10:30:00Z',
+    updated_at: '2024-03-15T10:30:00Z',
+    tags: [],
+    category: 'general',
+    importance: 3,
+  };
+
+  it('should handle empty title', () => {
+    const result = stringifyFrontMatter(baseFrontMatter, '', 'Content');
+    expect(result).toContain('---');
+    expect(result).toContain('Content');
+  });
+
+  it('should handle empty content', () => {
+    const result = stringifyFrontMatter(baseFrontMatter, 'Title', '');
+    expect(result).toContain('# Title');
+  });
+
+  it('should handle both empty title and content', () => {
+    const result = stringifyFrontMatter(baseFrontMatter, '', '');
+    expect(result).toContain('---');
+    expect(result).toContain('id:');
+  });
+
+  it('should handle single tag', () => {
+    const fm = { ...baseFrontMatter, tags: ['single'] };
+    const result = stringifyFrontMatter(fm, 'Title', 'Content');
+    expect(result).toContain('single');
+  });
+
+  it('should handle many tags', () => {
+    const fm = { ...baseFrontMatter, tags: ['a', 'b', 'c', 'd', 'e'] };
+    const result = stringifyFrontMatter(fm, 'Title', 'Content');
+    expect(result).toContain('a');
+    expect(result).toContain('e');
+  });
+
+  it('should end with single newline', () => {
+    const result = stringifyFrontMatter(baseFrontMatter, 'Title', 'Content');
+    const lines = result.split('\n');
+    expect(lines[lines.length - 1]).toBe('');
+    expect(lines[lines.length - 2]).not.toBe('');
+  });
+});

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

@@ -1,169 +1,210 @@
-/**
- * MCP Server Tests
- * Tests for the MCP Server using @modelcontextprotocol/sdk
- */
-
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { mkdtempSync, rmSync } from 'fs';
-import { tmpdir } from 'os';
-import { join } from 'path';
-import { createMcpServer } from '../../src/server/mcp-server.js';
-import { Server } from '@modelcontextprotocol/sdk/server/index.js';
-import {
-  TOOL_DEFINITIONS,
-  SERVER_INFO,
-  ERROR_CODES,
-  MCP_PROTOCOL_VERSION,
-} from '../../src/contracts/mcp.js';
-import { MemoryService } from '../../src/services/memory-service.js';
-import { MemoryLoadInputSchema, MemoryUpdateInputV2Schema } from '../../src/contracts/schemas.js';
-
-describe('McpServer (SDK)', () => {
-  let tempDir: string;
-  let server: Server;
-  let memoryService: MemoryService;
-
-  beforeEach(() => {
-    tempDir = mkdtempSync(join(tmpdir(), 'memhub-server-test-'));
-    process.env.MEMHUB_STORAGE_PATH = tempDir;
-    process.env.MEMHUB_VECTOR_SEARCH = 'false';
-    server = createMcpServer();
-    memoryService = new MemoryService({ storagePath: tempDir, vectorSearch: false });
-  });
-
-  afterEach(() => {
-    rmSync(tempDir, { recursive: true, force: true });
-    delete process.env.MEMHUB_STORAGE_PATH;
-    delete process.env.MEMHUB_VECTOR_SEARCH;
-  });
-
-  describe('createMcpServer', () => {
-    it('should create server instance', () => {
-      expect(server).toBeDefined();
-      expect(server).toBeInstanceOf(Server);
-    });
-  });
-
-  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');
-    });
-  });
-
-  describe('Tool Integration Tests', () => {
-    it('should handle memory_update via MemoryService', async () => {
-      const input = MemoryUpdateInputV2Schema.parse({
-        sessionId: '550e8400-e29b-41d4-a716-446655440000',
-        entryType: 'decision',
-        title: 'Test decision',
-        content: 'This is a test decision',
-        tags: ['test'],
-        category: 'general',
-      });
-
-      const result = await memoryService.memoryUpdate(input);
-
-      expect(result).toHaveProperty('id');
-      expect(result).toHaveProperty('sessionId');
-      expect(result.sessionId).toBe('550e8400-e29b-41d4-a716-446655440000');
-      expect(result.created).toBe(true);
-    });
-
-    it('should handle memory_load via MemoryService', async () => {
-      // First create a memory
-      const updateInput = MemoryUpdateInputV2Schema.parse({
-        sessionId: '550e8400-e29b-41d4-a716-446655440001',
-        entryType: 'preference',
-        title: 'Test preference',
-        content: 'I prefer chocolate ice cream',
-        tags: ['food', 'preference'],
-        category: 'personal',
-      });
-
-      const updateResult = await memoryService.memoryUpdate(updateInput);
-
-      // Then load it
-      const loadInput = MemoryLoadInputSchema.parse({
-        id: updateResult.id,
-      });
-
-      const loadResult = await memoryService.memoryLoad(loadInput);
-
-      expect(loadResult).toHaveProperty('items');
-      expect(loadResult.items.length).toBeGreaterThan(0);
-      expect(loadResult.items[0].title).toBe('Test preference');
-    });
-
-    it('should return error for invalid tool arguments', () => {
-      expect(() => {
-        MemoryUpdateInputV2Schema.parse({ title: '' }); // content is required
-      }).toThrow();
-    });
-
-    it('should validate memory_load input schema', () => {
-      const validInput = MemoryLoadInputSchema.parse({
-        query: 'test query',
-        limit: 10,
-        category: 'general',
-      });
-
-      expect(validInput.query).toBe('test query');
-      expect(validInput.limit).toBe(10);
-      expect(validInput.category).toBe('general');
-    });
-  });
-});
+/**
+ * MCP Server Tests
+ * Tests for the MCP Server using @modelcontextprotocol/sdk
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtempSync, rmSync } from 'fs';
+import { tmpdir, homedir } from 'os';
+import { join, resolve } from 'path';
+import { createMcpServer, resolveStoragePath } from '../../src/server/mcp-server.js';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import {
+  TOOL_DEFINITIONS,
+  SERVER_INFO,
+  ERROR_CODES,
+  MCP_PROTOCOL_VERSION,
+} from '../../src/contracts/mcp.js';
+import { MemoryService } from '../../src/services/memory-service.js';
+import { MemoryLoadInputSchema, MemoryUpdateInputV2Schema } from '../../src/contracts/schemas.js';
+
+describe('McpServer (SDK)', () => {
+  let tempDir: string;
+  let server: Server;
+  let memoryService: MemoryService;
+
+  beforeEach(() => {
+    tempDir = mkdtempSync(join(tmpdir(), 'memhub-server-test-'));
+    process.env.MEMHUB_STORAGE_PATH = tempDir;
+    process.env.MEMHUB_VECTOR_SEARCH = 'false';
+    server = createMcpServer();
+    memoryService = new MemoryService({ storagePath: tempDir, vectorSearch: false });
+  });
+
+  afterEach(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+    delete process.env.MEMHUB_STORAGE_PATH;
+    delete process.env.MEMHUB_VECTOR_SEARCH;
+  });
+
+  describe('createMcpServer', () => {
+    it('should create server instance', () => {
+      expect(server).toBeDefined();
+      expect(server).toBeInstanceOf(Server);
+    });
+  });
+
+  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');
+    });
+  });
+
+  describe('Tool Integration Tests', () => {
+    it('should handle memory_update via MemoryService', async () => {
+      const input = MemoryUpdateInputV2Schema.parse({
+        sessionId: '550e8400-e29b-41d4-a716-446655440000',
+        entryType: 'decision',
+        title: 'Test decision',
+        content: 'This is a test decision',
+        tags: ['test'],
+        category: 'general',
+      });
+
+      const result = await memoryService.memoryUpdate(input);
+
+      expect(result).toHaveProperty('id');
+      expect(result).toHaveProperty('sessionId');
+      expect(result.sessionId).toBe('550e8400-e29b-41d4-a716-446655440000');
+      expect(result.created).toBe(true);
+    });
+
+    it('should handle memory_load via MemoryService', async () => {
+      // First create a memory
+      const updateInput = MemoryUpdateInputV2Schema.parse({
+        sessionId: '550e8400-e29b-41d4-a716-446655440001',
+        entryType: 'preference',
+        title: 'Test preference',
+        content: 'I prefer chocolate ice cream',
+        tags: ['food', 'preference'],
+        category: 'personal',
+      });
+
+      const updateResult = await memoryService.memoryUpdate(updateInput);
+
+      // Then load it
+      const loadInput = MemoryLoadInputSchema.parse({
+        id: updateResult.id,
+      });
+
+      const loadResult = await memoryService.memoryLoad(loadInput);
+
+      expect(loadResult).toHaveProperty('items');
+      expect(loadResult.items.length).toBeGreaterThan(0);
+      expect(loadResult.items[0].title).toBe('Test preference');
+    });
+
+    it('should return error for invalid tool arguments', () => {
+      expect(() => {
+        MemoryUpdateInputV2Schema.parse({ title: '' }); // content is required
+      }).toThrow();
+    });
+
+    it('should validate memory_load input schema', () => {
+      const validInput = MemoryLoadInputSchema.parse({
+        query: 'test query',
+        limit: 10,
+        category: 'general',
+      });
+
+      expect(validInput.query).toBe('test query');
+      expect(validInput.limit).toBe(10);
+      expect(validInput.category).toBe('general');
+    });
+  });
+
+  describe('resolveStoragePath', () => {
+    const originalEnv = process.env.MEMHUB_STORAGE_PATH;
+    const originalCwd = process.cwd.bind(process);
+
+    afterEach(() => {
+      if (originalEnv === undefined) {
+        delete process.env.MEMHUB_STORAGE_PATH;
+      } else {
+        process.env.MEMHUB_STORAGE_PATH = originalEnv;
+      }
+      process.cwd = originalCwd;
+    });
+
+    it('should return ~/.memhub by default', () => {
+      delete process.env.MEMHUB_STORAGE_PATH;
+      const expectedPath = join(homedir(), '.memhub');
+      expect(resolveStoragePath()).toBe(expectedPath);
+    });
+
+    it('should use absolute path from MEMHUB_STORAGE_PATH', () => {
+      const absolutePath = process.platform === 'win32' ? 'C:\\custom\\path' : '/custom/path';
+      process.env.MEMHUB_STORAGE_PATH = absolutePath;
+      expect(resolveStoragePath()).toBe(absolutePath);
+    });
+
+    it('should resolve relative path from cwd', () => {
+      const cwd = process.platform === 'win32' ? 'C:\\project' : '/project';
+      process.cwd = () => cwd;
+      process.env.MEMHUB_STORAGE_PATH = '.memhub';
+      expect(resolveStoragePath()).toBe(resolve(cwd, '.memhub'));
+    });
+
+    it('should resolve .memhub relative path', () => {
+      const cwd = process.platform === 'win32' ? 'C:\\myproject' : '/myproject';
+      process.cwd = () => cwd;
+      process.env.MEMHUB_STORAGE_PATH = '.memhub';
+      const expected = process.platform === 'win32' ? 'C:\\myproject\\.memhub' : '/myproject/.memhub';
+      expect(resolveStoragePath()).toBe(expected);
+    });
+  });
+});