@synth-coder/memhub 0.2.2 → 0.2.4

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

@@ -37,7 +37,9 @@ describe('MemoryService', () => {
 
       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);
+      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 () => {
@@ -168,8 +170,18 @@ describe('MemoryService', () => {
 
   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: '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' });
     });
 
@@ -276,4 +288,4 @@ describe('MemoryService', () => {
       expect(result.tags).toEqual([]);
     });
   });
-});
+});

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

@@ -220,4 +220,4 @@ describe('frontMatterToMemory', () => {
     expect(result.title).toBe('Title');
     expect(result.content).toBe('Content');
   });
-});
+});

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

@@ -103,9 +103,9 @@ This is the content.
     });
 
     it('should throw error when file not found', async () => {
-      await expect(
-        storage.read('550e8400-e29b-41d4-a716-446655440000')
-      ).rejects.toThrow(StorageError);
+      await expect(storage.read('550e8400-e29b-41d4-a716-446655440000')).rejects.toThrow(
+        StorageError
+      );
     });
 
     it('should parse front matter correctly', async () => {
@@ -157,17 +157,23 @@ importance: 3
     });
 
     it('should throw error when file not found', async () => {
-      await expect(
-        storage.delete('550e8400-e29b-41d4-a716-446655440000')
-      ).rejects.toThrow(StorageError);
+      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');
+      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);
@@ -180,7 +186,10 @@ importance: 3
 
     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.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();
@@ -214,4 +223,4 @@ importance: 3
       expect(filePath).toBeNull();
     });
   });
-});
+});

package/test/storage/vector-index.test.ts

@@ -11,143 +11,139 @@ import type { Memory } from '../../src/contracts/types.js';
 
 /** Build a random 384-dim float vector (avoids loading the real model) */
 function randomVec(dim = 384): number[] {
-    const vec = Array.from({ length: dim }, () => Math.random() * 2 - 1);
-    // L2-normalise so cosine distance is meaningful
-    const norm = Math.sqrt(vec.reduce((s, v) => s + v * v, 0));
-    return vec.map(v => v / norm);
+  const vec = Array.from({ length: dim }, () => Math.random() * 2 - 1);
+  // L2-normalise so cosine distance is meaningful
+  const norm = Math.sqrt(vec.reduce((s, v) => s + v * v, 0));
+  return vec.map(v => v / norm);
 }
 
 function makeMemory(overrides: Partial<Memory> = {}): Memory {
-    return {
-        id: 'test-id-' + Math.random().toString(36).slice(2),
-        createdAt: new Date().toISOString(),
-        updatedAt: new Date().toISOString(),
-        tags: [],
-        category: 'general',
-        importance: 3,
-        title: 'Test Memory',
-        content: 'Test content',
-        ...overrides,
-    };
+  return {
+    id: 'test-id-' + Math.random().toString(36).slice(2),
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+    tags: [],
+    category: 'general',
+    importance: 3,
+    title: 'Test Memory',
+    content: 'Test content',
+    ...overrides,
+  };
 }
 
 describe('VectorIndex', () => {
-    let tempDir: string;
-    let index: VectorIndex;
-
-    beforeEach(() => {
-        tempDir = mkdtempSync(join(tmpdir(), 'memhub-vec-test-'));
-        index = new VectorIndex(tempDir);
-    });
-
-    afterEach(() => {
-        rmSync(tempDir, { recursive: true, force: true });
-    });
-
-    it('should initialize without errors', async () => {
-        await expect(index.initialize()).resolves.not.toThrow();
-    });
-
-    it('should report 0 rows after initialization', async () => {
-        await index.initialize();
-        expect(await index.count()).toBe(0);
-    });
-
-    it('should upsert a memory and increase count', async () => {
-        const memory = makeMemory();
-        const vec = randomVec();
-        await index.upsert(memory, vec);
-        expect(await index.count()).toBe(1);
-    });
-
-    it('should overwrite existing row on upsert (same id)', async () => {
-        const memory = makeMemory({ id: 'fixed-id' });
-        await index.upsert(memory, randomVec());
-        await index.upsert({ ...memory, title: 'Updated' }, randomVec());
-        expect(await index.count()).toBe(1);
-    });
-
-    it('should delete a row by id', async () => {
-        const memory = makeMemory();
-        await index.upsert(memory, randomVec());
-        await index.delete(memory.id);
-        expect(await index.count()).toBe(0);
-    });
-
-    it('should not throw when deleting non-existent id', async () => {
-        await expect(index.delete('non-existent')).resolves.not.toThrow();
-    });
-
-    it('should search and return results', async () => {
-        const vec = randomVec();
-        const memory = makeMemory({ id: 'searchable-id' });
-        await index.upsert(memory, vec);
-
-        // Searching with the same vector should return that memory as top result
-        const results = await index.search(vec, 5);
-        expect(results.length).toBeGreaterThan(0);
-        expect(results[0].id).toBe('searchable-id');
-    });
-
-    it('should return empty results when index is empty', async () => {
-        const results = await index.search(randomVec(), 5);
-        expect(results).toHaveLength(0);
-    });
-
-    it('should respect the limit parameter', async () => {
-        for (let i = 0; i < 5; i++) {
-            await index.upsert(makeMemory(), randomVec());
-        }
-        const results = await index.search(randomVec(), 3);
-        expect(results.length).toBeLessThanOrEqual(3);
-    });
-
-    it('should return _distance field in results', async () => {
-        const vec = randomVec();
-        await index.upsert(makeMemory(), vec);
-        const results = await index.search(vec, 1);
-        expect(results[0]._distance).toBeDefined();
-        expect(typeof results[0]._distance).toBe('number');
-    });
-
-    it('should handle id with single quotes (SQL injection prevention)', async () => {
-        const maliciousId = "test-' OR '1'='1";
-        const memory = makeMemory({ id: maliciousId });
-        await index.upsert(memory, randomVec());
-        expect(await index.count()).toBe(1);
-
-        // Should be able to delete by the same id
-        await index.delete(maliciousId);
-        expect(await index.count()).toBe(0);
-    });
-
-    it('should handle id with special characters', async () => {
-        const specialId = "id-with-'quotes'-and-more";
-        const memory = makeMemory({ id: specialId });
-        await index.upsert(memory, randomVec());
-        expect(await index.count()).toBe(1);
-
-        await index.delete(specialId);
-        expect(await index.count()).toBe(0);
-    });
-
-    // Error scenario tests
-    it('should allow concurrent initialization calls', async () => {
-        // Multiple concurrent init calls should not cause issues
-        const promises = [
-            index.initialize(),
-            index.initialize(),
-            index.initialize(),
-        ];
-        await expect(Promise.all(promises)).resolves.not.toThrow();
-    });
-
-    it('should persist data across instances', async () => {
-        const memory = makeMemory({ id: 'persistent-id' });
-        await index.upsert(memory, randomVec());
-
-        // Create a new instance pointing to the same directory
-        const newIndex = new VectorIndex(tempDir);
-        expect(await newIndex.count()).toBe(1);
-    });
+  let tempDir: string;
+  let index: VectorIndex;
+
+  beforeEach(() => {
+    tempDir = mkdtempSync(join(tmpdir(), 'memhub-vec-test-'));
+    index = new VectorIndex(tempDir);
+  });
+
+  afterEach(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it('should initialize without errors', async () => {
+    await expect(index.initialize()).resolves.not.toThrow();
+  });
+
+  it('should report 0 rows after initialization', async () => {
+    await index.initialize();
+    expect(await index.count()).toBe(0);
+  });
+
+  it('should upsert a memory and increase count', async () => {
+    const memory = makeMemory();
+    const vec = randomVec();
+    await index.upsert(memory, vec);
+    expect(await index.count()).toBe(1);
+  });
+
+  it('should overwrite existing row on upsert (same id)', async () => {
+    const memory = makeMemory({ id: 'fixed-id' });
+    await index.upsert(memory, randomVec());
+    await index.upsert({ ...memory, title: 'Updated' }, randomVec());
+    expect(await index.count()).toBe(1);
+  });
+
+  it('should delete a row by id', async () => {
+    const memory = makeMemory();
+    await index.upsert(memory, randomVec());
+    await index.delete(memory.id);
+    expect(await index.count()).toBe(0);
+  });
+
+  it('should not throw when deleting non-existent id', async () => {
+    await expect(index.delete('non-existent')).resolves.not.toThrow();
+  });
+
+  it('should search and return results', async () => {
+    const vec = randomVec();
+    const memory = makeMemory({ id: 'searchable-id' });
+    await index.upsert(memory, vec);
+
+    // Searching with the same vector should return that memory as top result
+    const results = await index.search(vec, 5);
+    expect(results.length).toBeGreaterThan(0);
+    expect(results[0].id).toBe('searchable-id');
+  });
+
+  it('should return empty results when index is empty', async () => {
+    const results = await index.search(randomVec(), 5);
+    expect(results).toHaveLength(0);
+  });
+
+  it('should respect the limit parameter', async () => {
+    for (let i = 0; i < 5; i++) {
+      await index.upsert(makeMemory(), randomVec());
+    }
+    const results = await index.search(randomVec(), 3);
+    expect(results.length).toBeLessThanOrEqual(3);
+  });
+
+  it('should return _distance field in results', async () => {
+    const vec = randomVec();
+    await index.upsert(makeMemory(), vec);
+    const results = await index.search(vec, 1);
+    expect(results[0]._distance).toBeDefined();
+    expect(typeof results[0]._distance).toBe('number');
+  });
+
+  it('should handle id with single quotes (SQL injection prevention)', async () => {
+    const maliciousId = "test-' OR '1'='1";
+    const memory = makeMemory({ id: maliciousId });
+    await index.upsert(memory, randomVec());
+    expect(await index.count()).toBe(1);
+
+    // Should be able to delete by the same id
+    await index.delete(maliciousId);
+    expect(await index.count()).toBe(0);
+  });
+
+  it('should handle id with special characters', async () => {
+    const specialId = "id-with-'quotes'-and-more";
+    const memory = makeMemory({ id: specialId });
+    await index.upsert(memory, randomVec());
+    expect(await index.count()).toBe(1);
+
+    await index.delete(specialId);
+    expect(await index.count()).toBe(0);
+  });
+
+  // Error scenario tests
+  it('should allow concurrent initialization calls', async () => {
+    // Multiple concurrent init calls should not cause issues
+    const promises = [index.initialize(), index.initialize(), index.initialize()];
+    await expect(Promise.all(promises)).resolves.not.toThrow();
+  });
+
+  it('should persist data across instances', async () => {
+    const memory = makeMemory({ id: 'persistent-id' });
+    await index.upsert(memory, randomVec());
+
+    // Create a new instance pointing to the same directory
+    const newIndex = new VectorIndex(tempDir);
+    expect(await newIndex.count()).toBe(1);
+  });
 });

package/test/utils/slugify.test.ts

@@ -62,7 +62,11 @@ describe('generateUniqueSlug', () => {
   });
 
   it('should increment counter until unique', () => {
-    const result = generateUniqueSlug('hello world', ['hello-world', 'hello-world-1', 'hello-world-2']);
+    const result = generateUniqueSlug('hello world', [
+      'hello-world',
+      'hello-world-1',
+      'hello-world-2',
+    ]);
     expect(result).toBe('hello-world-3');
   });
 });