@synth-coder/memhub 0.1.0

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

@@ -0,0 +1,223 @@
+/**
+ * FrontMatter Parser Tests
+ * Tests for the FrontMatter parser
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  parseFrontMatter,
+  stringifyFrontMatter,
+  memoryToFrontMatter,
+  frontMatterToMemory,
+  FrontMatterError,
+} from '../../src/storage/frontmatter-parser.js';
+import type { Memory, MemoryFrontMatter } from '../../src/contracts/types.js';
+
+describe('parseFrontMatter', () => {
+  it('should parse valid front matter and content', () => {
+    const markdown = `---
+id: "550e8400-e29b-41d4-a716-446655440000"
+created_at: "2024-03-15T10:30:00Z"
+updated_at: "2024-03-15T14:20:00Z"
+tags:
+  - project
+  - meeting
+category: "work"
+importance: 4
+---
+
+# Project Meeting
+
+This is the meeting content.
+
+## Action Items
+
+- Item 1
+- Item 2
+`;
+
+    const result = parseFrontMatter(markdown);
+    expect(result.frontMatter.id).toBe('550e8400-e29b-41d4-a716-446655440000');
+    expect(result.frontMatter.category).toBe('work');
+    expect(result.frontMatter.importance).toBe(4);
+    expect(result.title).toBe('Project Meeting');
+    expect(result.content).toContain('Action Items');
+  });
+
+  it('should parse front matter with empty tags', () => {
+    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
+---
+
+# Empty Tags Test
+
+Content here.
+`;
+
+    const result = parseFrontMatter(markdown);
+    expect(result.frontMatter.tags).toEqual([]);
+  });
+
+  it('should throw error for missing front matter', () => {
+    const markdown = `# No Front Matter
+
+This markdown has no front matter.
+`;
+
+    expect(() => parseFrontMatter(markdown)).toThrow(FrontMatterError);
+    expect(() => parseFrontMatter(markdown)).toThrow('Missing front matter delimiter');
+  });
+
+  it('should throw error for invalid YAML', () => {
+    const markdown = `---
+id: "550e8400-e29b-41d4-a716-446655440000"
+created_at: [invalid yaml
+---
+
+# Title
+
+Content.
+`;
+
+    expect(() => parseFrontMatter(markdown)).toThrow(FrontMatterError);
+  });
+
+  it('should throw error for missing required fields', () => {
+    const markdown = `---
+id: "550e8400-e29b-41d4-a716-446655440000"
+---
+
+# Title
+
+Content.
+`;
+
+    expect(() => parseFrontMatter(markdown)).toThrow(FrontMatterError);
+    expect(() => parseFrontMatter(markdown)).toThrow('Missing required fields');
+  });
+
+  it('should handle multiline content correctly', () => {
+    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
+
+Line 1
+Line 2
+
+Line 3 after blank
+`;
+
+    const result = parseFrontMatter(markdown);
+    expect(result.content).toContain('Line 1');
+    expect(result.content).toContain('Line 3 after blank');
+  });
+});
+
+describe('stringifyFrontMatter', () => {
+  const frontMatter: MemoryFrontMatter = {
+    id: '550e8400-e29b-41d4-a716-446655440000',
+    created_at: '2024-03-15T10:30:00Z',
+    updated_at: '2024-03-15T14:20:00Z',
+    tags: ['project', 'meeting'],
+    category: 'work',
+    importance: 4,
+  };
+
+  it('should stringify front matter and content', () => {
+    const result = stringifyFrontMatter(frontMatter, 'Title', 'Content here');
+    expect(result).toContain('---');
+    expect(result).toContain('id: "550e8400-e29b-41d4-a716-446655440000"');
+    expect(result).toContain('# Title');
+    expect(result).toContain('Content here');
+  });
+
+  it('should format tags as YAML array', () => {
+    const result = stringifyFrontMatter(frontMatter, 'Title', 'Content');
+    expect(result).toContain('tags:');
+    expect(result).toContain('project');
+    expect(result).toContain('meeting');
+  });
+
+  it('should use LF line endings', () => {
+    const result = stringifyFrontMatter(frontMatter, 'Title', 'Content');
+    expect(result).not.toContain('\r\n');
+    expect(result).toContain('\n');
+  });
+
+  it('should add blank line between front matter and content', () => {
+    const result = stringifyFrontMatter(frontMatter, 'Title', 'Content');
+    expect(result).toMatch(/---\n\n# Title/);
+  });
+
+  it('should handle empty tags', () => {
+    const fmWithEmptyTags: MemoryFrontMatter = { ...frontMatter, tags: [] };
+    const result = stringifyFrontMatter(fmWithEmptyTags, 'Title', 'Content');
+    expect(result).toContain('tags: []');
+  });
+
+  it('should handle multiline content', () => {
+    const content = 'Line 1\n\nLine 2\n\nLine 3';
+    const result = stringifyFrontMatter(frontMatter, 'Title', content);
+    expect(result).toContain('Line 1');
+    expect(result).toContain('Line 2');
+    expect(result).toContain('Line 3');
+  });
+});
+
+describe('memoryToFrontMatter', () => {
+  it('should convert Memory to MemoryFrontMatter', () => {
+    const memory: Memory = {
+      id: '550e8400-e29b-41d4-a716-446655440000',
+      createdAt: '2024-03-15T10:30:00Z',
+      updatedAt: '2024-03-15T14:20:00Z',
+      tags: ['test'],
+      category: 'work',
+      importance: 3,
+      title: 'Test',
+      content: 'Content',
+    };
+
+    const result = memoryToFrontMatter(memory);
+    expect(result.id).toBe(memory.id);
+    expect(result.created_at).toBe(memory.createdAt);
+    expect(result.updated_at).toBe(memory.updatedAt);
+    expect(result.tags).toEqual(memory.tags);
+    expect(result.category).toBe(memory.category);
+    expect(result.importance).toBe(memory.importance);
+  });
+});
+
+describe('frontMatterToMemory', () => {
+  it('should convert MemoryFrontMatter to Memory', () => {
+    const fm: MemoryFrontMatter = {
+      id: '550e8400-e29b-41d4-a716-446655440000',
+      created_at: '2024-03-15T10:30:00Z',
+      updated_at: '2024-03-15T14:20:00Z',
+      tags: ['test'],
+      category: 'work',
+      importance: 3,
+    };
+
+    const result = frontMatterToMemory(fm, 'Title', 'Content');
+    expect(result.id).toBe(fm.id);
+    expect(result.createdAt).toBe(fm.created_at);
+    expect(result.updatedAt).toBe(fm.updated_at);
+    expect(result.tags).toEqual(fm.tags);
+    expect(result.category).toBe(fm.category);
+    expect(result.importance).toBe(fm.importance);
+    expect(result.title).toBe('Title');
+    expect(result.content).toBe('Content');
+  });
+});

package/test/storage/markdown-storage.test.ts

@@ -0,0 +1,217 @@
+/**
+ * Markdown Storage Tests
+ * Tests for the MarkdownStorage class
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtempSync, rmSync, existsSync, readFileSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { MarkdownStorage, StorageError } from '../../src/storage/markdown-storage.js';
+import type { Memory } from '../../src/contracts/types.js';
+
+describe('MarkdownStorage', () => {
+  let tempDir: string;
+  let storage: MarkdownStorage;
+
+  beforeEach(() => {
+    tempDir = mkdtempSync(join(tmpdir(), 'memhub-storage-test-'));
+    storage = new MarkdownStorage({ storagePath: tempDir });
+  });
+
+  afterEach(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  describe('write', () => {
+    const sampleMemory: Memory = {
+      id: '550e8400-e29b-41d4-a716-446655440000',
+      createdAt: '2024-03-15T10:30:00Z',
+      updatedAt: '2024-03-15T10:30:00Z',
+      sessionId: '550e8400-e29b-41d4-a716-446655440999',
+      tags: ['test', 'memory'],
+      category: 'testing',
+      importance: 3,
+      title: 'Test Memory',
+      content: 'This is the content of the test memory.',
+    };
+
+    it('should write memory to markdown file', async () => {
+      const result = await storage.write(sampleMemory);
+      expect(existsSync(result)).toBe(true);
+      expect(result).toContain(`${sampleMemory.createdAt.split('T')[0]}`);
+      expect(result).toContain(sampleMemory.sessionId as string);
+    });
+
+    it('should write valid YAML front matter', async () => {
+      const filePath = await storage.write(sampleMemory);
+      const content = readFileSync(filePath, 'utf-8');
+      expect(content).toMatch(/^---\n/);
+      expect(content).toContain('id: "550e8400-e29b-41d4-a716-446655440000"');
+      expect(content).toContain('created_at: "2024-03-15T10:30:00Z"');
+      expect(content).toContain('session_id: "550e8400-e29b-41d4-a716-446655440999"');
+    });
+
+    it('should write markdown body with title', async () => {
+      const filePath = await storage.write(sampleMemory);
+      const content = readFileSync(filePath, 'utf-8');
+      expect(content).toContain('# Test Memory');
+      expect(content).toContain('This is the content');
+    });
+
+    it('should write tags as YAML array', async () => {
+      const filePath = await storage.write(sampleMemory);
+      const content = readFileSync(filePath, 'utf-8');
+      expect(content).toContain('tags:');
+      expect(content).toContain('test');
+      expect(content).toContain('memory');
+    });
+
+    it('should return nested file path', async () => {
+      const result = await storage.write(sampleMemory);
+      expect(result).toContain('test-memory.md');
+      expect(result).toContain('2024-03-15');
+      expect(result).toContain('550e8400-e29b-41d4-a716-446655440999');
+    });
+  });
+
+  describe('read', () => {
+    it('should read memory from markdown file', async () => {
+      // Create a test file first
+      const testContent = `---
+id: "550e8400-e29b-41d4-a716-446655440000"
+created_at: "2024-03-15T10:30:00Z"
+updated_at: "2024-03-15T10:30:00Z"
+tags:
+  - test
+category: "testing"
+importance: 3
+---
+
+# Test Memory
+
+This is the content.
+`;
+      const filePath = join(tempDir, 'test.md');
+      // Use sync write for test setup
+      const { writeFileSync } = await import('fs');
+      writeFileSync(filePath, testContent);
+
+      const memory = await storage.read('550e8400-e29b-41d4-a716-446655440000');
+      expect(memory.id).toBe('550e8400-e29b-41d4-a716-446655440000');
+      expect(memory.title).toBe('Test Memory');
+    });
+
+    it('should throw error when file not found', async () => {
+      await expect(
+        storage.read('550e8400-e29b-41d4-a716-446655440000')
+      ).rejects.toThrow(StorageError);
+    });
+
+    it('should parse front matter correctly', async () => {
+      const testContent = `---
+id: "550e8400-e29b-41d4-a716-446655440000"
+created_at: "2024-03-15T10:30:00Z"
+updated_at: "2024-03-15T14:20:00Z"
+tags:
+  - tag1
+  - tag2
+category: "work"
+importance: 4
+---
+
+# Test Title
+
+Test content.
+`;
+      const { writeFileSync } = await import('fs');
+      writeFileSync(join(tempDir, 'test.md'), testContent);
+
+      const memory = await storage.read('550e8400-e29b-41d4-a716-446655440000');
+      expect(memory.tags).toEqual(['tag1', 'tag2']);
+      expect(memory.category).toBe('work');
+      expect(memory.importance).toBe(4);
+    });
+  });
+
+  describe('delete', () => {
+    it('should delete memory file', async () => {
+      // Create a test file first
+      const testContent = `---
+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
+---
+
+# Test
+`;
+      const filePath = join(tempDir, 'test.md');
+      const { writeFileSync } = await import('fs');
+      writeFileSync(filePath, testContent);
+
+      await storage.delete('550e8400-e29b-41d4-a716-446655440000');
+      expect(existsSync(filePath)).toBe(false);
+    });
+
+    it('should throw error when file not found', async () => {
+      await expect(
+        storage.delete('550e8400-e29b-41d4-a716-446655440000')
+      ).rejects.toThrow(StorageError);
+    });
+  });
+
+  describe('list', () => {
+    it('should list all memory files', async () => {
+      const { writeFileSync } = await import('fs');
+      writeFileSync(join(tempDir, '2024-03-15-a.md'), '---\nid: "a"\ncreated_at: "2024-03-15T10:30:00Z"\nupdated_at: "2024-03-15T10:30:00Z"\ntags: []\ncategory: "general"\nimportance: 3\n---\n\n# A');
+      writeFileSync(join(tempDir, '2024-03-16-b.md'), '---\nid: "b"\ncreated_at: "2024-03-16T10:30:00Z"\nupdated_at: "2024-03-16T10:30:00Z"\ntags: []\ncategory: "general"\nimportance: 3\n---\n\n# B');
+
+      const files = await storage.list();
+      expect(files).toHaveLength(2);
+    });
+
+    it('should return empty array when no files exist', async () => {
+      const files = await storage.list();
+      expect(files).toEqual([]);
+    });
+
+    it('should only include .md files', async () => {
+      const { writeFileSync } = await import('fs');
+      writeFileSync(join(tempDir, 'test.md'), '---\nid: "test"\ncreated_at: "2024-03-15T10:30:00Z"\nupdated_at: "2024-03-15T10:30:00Z"\ntags: []\ncategory: "general"\nimportance: 3\n---\n\n# Test');
+      writeFileSync(join(tempDir, 'test.txt'), 'not markdown');
+
+      const files = await storage.list();
+      expect(files).toHaveLength(1);
+      expect(files[0].filename).toBe('test.md');
+    });
+  });
+
+  describe('findById', () => {
+    it('should find file by memory ID', async () => {
+      const testContent = `---
+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
+---
+
+# Test
+`;
+      const { writeFileSync } = await import('fs');
+      writeFileSync(join(tempDir, 'test.md'), testContent);
+
+      const filePath = await storage.findById('550e8400-e29b-41d4-a716-446655440000');
+      expect(filePath).toContain('test.md');
+    });
+
+    it('should return null when ID not found', async () => {
+      const filePath = await storage.findById('550e8400-e29b-41d4-a716-446655440000');
+      expect(filePath).toBeNull();
+    });
+  });
+});

package/test/storage/storage-edge.test.ts

@@ -0,0 +1,238 @@
+/**
+ * Storage Edge Case Tests
+ * Additional tests for better coverage
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtempSync, rmSync, writeFileSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { MarkdownStorage, StorageError } from '../../src/storage/markdown-storage.js';
+import { FrontMatterError } from '../../src/storage/frontmatter-parser.js';
+
+describe('MarkdownStorage Edge Cases', () => {
+  let tempDir: string;
+  let storage: MarkdownStorage;
+
+  beforeEach(() => {
+    tempDir = mkdtempSync(join(tmpdir(), 'memhub-storage-edge-'));
+    storage = new MarkdownStorage({ storagePath: tempDir });
+  });
+
+  afterEach(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  describe('initialize', () => {
+    it('should create directory if it does not exist', async () => {
+      const newDir = join(tempDir, 'subdir', 'new-storage');
+      const newStorage = new MarkdownStorage({ storagePath: newDir });
+      await newStorage.initialize();
+      // Directory should be created
+      const { existsSync } = await import('fs');
+      expect(existsSync(newDir)).toBe(true);
+    });
+  });
+
+  describe('write edge cases', () => {
+    it('should handle memory with empty title', async () => {
+      const memory = {
+        id: '550e8400-e29b-41d4-a716-446655440000',
+        createdAt: '2024-03-15T10:30:00Z',
+        updatedAt: '2024-03-15T10:30:00Z',
+        tags: [],
+        category: 'test',
+        importance: 3,
+        title: '',
+        content: 'Content with empty title',
+      };
+
+      const filePath = await storage.write(memory);
+      expect(filePath).toContain('untitled');
+    });
+
+    it('should handle memory with special characters in title', async () => {
+      const memory = {
+        id: '550e8400-e29b-41d4-a716-446655440001',
+        createdAt: '2024-03-15T10:30:00Z',
+        updatedAt: '2024-03-15T10:30:00Z',
+        tags: [],
+        category: 'test',
+        importance: 3,
+        title: 'Title with @#$%^&*()',
+        content: 'Content',
+      };
+
+      const filePath = await storage.write(memory);
+      expect(filePath).toBeDefined();
+    });
+
+    it('should handle very long content', async () => {
+      const memory = {
+        id: '550e8400-e29b-41d4-a716-446655440002',
+        createdAt: '2024-03-15T10:30:00Z',
+        updatedAt: '2024-03-15T10:30:00Z',
+        tags: [],
+        category: 'test',
+        importance: 3,
+        title: 'Long Content',
+        content: 'A'.repeat(10000),
+      };
+
+      const filePath = await storage.write(memory);
+      const { readFileSync } = await import('fs');
+      const content = readFileSync(filePath, 'utf-8');
+      expect(content).toContain('A'.repeat(100));
+    });
+  });
+
+  describe('read edge cases', () => {
+    it('should throw error for invalid front matter', async () => {
+      const invalidContent = '---\ninvalid yaml: [\n---\n\n# Title';
+      writeFileSync(join(tempDir, 'invalid.md'), invalidContent);
+
+      await expect(storage.read('any-id')).rejects.toThrow(StorageError);
+    });
+
+    it('should throw error for missing required fields', async () => {
+      const incompleteContent = '---\nid: "test-id"\n---\n\n# Title';
+      writeFileSync(join(tempDir, 'incomplete.md'), incompleteContent);
+
+      await expect(storage.read('test-id')).rejects.toThrow(StorageError);
+    });
+
+    it('should handle file with no H1 title', async () => {
+      const noTitleContent = `---
+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
+---
+
+Just some content without H1.
+`;
+      writeFileSync(join(tempDir, 'no-title.md'), noTitleContent);
+
+      const memory = await storage.read('550e8400-e29b-41d4-a716-446655440000');
+      expect(memory.title).toBe('');
+      expect(memory.content).toContain('Just some content');
+    });
+  });
+
+  describe('list edge cases', () => {
+    it('should skip invalid markdown files', async () => {
+      // Create valid file
+      const validContent = `---
+id: "valid-id"
+created_at: "2024-03-15T10:30:00Z"
+updated_at: "2024-03-15T10:30:00Z"
+tags: []
+category: "general"
+importance: 3
+---
+
+# Valid
+`;
+      writeFileSync(join(tempDir, 'valid.md'), validContent);
+
+      // Create invalid file
+      writeFileSync(join(tempDir, 'invalid.md'), 'Not valid markdown');
+
+      const files = await storage.list();
+      expect(files).toHaveLength(2);
+    });
+
+    it('should handle empty directory', async () => {
+      const files = await storage.list();
+      expect(files).toEqual([]);
+    });
+
+    it('should ignore non-markdown files', async () => {
+      writeFileSync(join(tempDir, 'test.txt'), 'Text file');
+      writeFileSync(join(tempDir, 'test.json'), '{}');
+
+      const files = await storage.list();
+      expect(files).toHaveLength(0);
+    });
+  });
+
+  describe('findById edge cases', () => {
+    it('should return null when no files exist', async () => {
+      const result = await storage.findById('any-id');
+      expect(result).toBeNull();
+    });
+
+    it('should skip files with invalid front matter', async () => {
+      writeFileSync(join(tempDir, 'invalid.md'), 'Invalid content');
+
+      const result = await storage.findById('any-id');
+      expect(result).toBeNull();
+    });
+
+    it('should find correct file among multiple files', async () => {
+      const content1 = `---
+id: "id-1"
+created_at: "2024-03-15T10:30:00Z"
+updated_at: "2024-03-15T10:30:00Z"
+tags: []
+category: "general"
+importance: 3
+---
+
+# File 1
+`;
+      const content2 = `---
+id: "id-2"
+created_at: "2024-03-15T10:30:00Z"
+updated_at: "2024-03-15T10:30:00Z"
+tags: []
+category: "general"
+importance: 3
+---
+
+# File 2
+`;
+      writeFileSync(join(tempDir, 'file1.md'), content1);
+      writeFileSync(join(tempDir, 'file2.md'), content2);
+
+      const result = await storage.findById('id-2');
+      expect(result).toContain('file2.md');
+    });
+  });
+
+  describe('delete edge cases', () => {
+    it('should throw error when trying to delete non-existent memory', async () => {
+      await expect(storage.delete('non-existent-id')).rejects.toThrow(StorageError);
+    });
+  });
+});
+
+describe('FrontMatterError', () => {
+  it('should create error with message', () => {
+    const error = new FrontMatterError('Test error');
+    expect(error.message).toBe('Test error');
+    expect(error.name).toBe('FrontMatterError');
+  });
+
+  it('should create error with cause', () => {
+    const cause = new Error('Original error');
+    const error = new FrontMatterError('Test error', cause);
+    expect(error.cause).toBe(cause);
+  });
+});
+
+describe('StorageError', () => {
+  it('should create error with message', () => {
+    const error = new StorageError('Test error');
+    expect(error.message).toBe('Test error');
+    expect(error.name).toBe('StorageError');
+  });
+
+  it('should create error with cause', () => {
+    const cause = new Error('Original error');
+    const error = new StorageError('Test error', cause);
+    expect(error.cause).toBe(cause);
+  });
+});