@synth-coder/memhub 0.2.3 → 0.2.4

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

@@ -1,153 +1,149 @@
-/**
- * VectorIndex Tests
- */
-
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { mkdtempSync, rmSync } from 'fs';
-import { tmpdir } from 'os';
-import { join } from 'path';
-import { VectorIndex } from '../../src/storage/vector-index.js';
-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);
-}
-
-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,
-    };
-}
-
-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);
-    });
-});
+/**
+ * VectorIndex Tests
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtempSync, rmSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { VectorIndex } from '../../src/storage/vector-index.js';
+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);
+}
+
+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,
+  };
+}
+
+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);
+  });
+});

package/test/utils/slugify-edge.test.ts

@@ -1,94 +1,94 @@
-/**
- * Slugify Edge Case Tests
- * Additional tests for better coverage
- */
-
-import { describe, it, expect } from 'vitest';
-import { slugify, generateUniqueSlug } from '../../src/utils/slugify.js';
-
-describe('slugify edge cases', () => {
-  it('should handle whitespace-only string', () => {
-    expect(slugify('   ')).toBe('untitled');
-  });
-
-  it('should handle multiple consecutive spaces', () => {
-    expect(slugify('hello    world')).toBe('hello-world');
-  });
-
-  it('should handle string with only special characters', () => {
-    expect(slugify('!@#$%^&*()')).toBe('untitled');
-  });
-
-  it('should handle mixed alphanumeric with special chars', () => {
-    expect(slugify('hello123!@#world456')).toBe('hello123world456');
-  });
-
-  it('should handle string starting with numbers', () => {
-    expect(slugify('123hello')).toBe('123hello');
-  });
-
-  it('should handle very short string', () => {
-    expect(slugify('a')).toBe('a');
-  });
-
-  it('should handle string at exactly max length', () => {
-    const input = 'a'.repeat(100);
-    expect(slugify(input)).toBe(input);
-  });
-
-  it('should handle string just over max length', () => {
-    const input = 'a'.repeat(101);
-    expect(slugify(input).length).toBeLessThanOrEqual(100);
-  });
-
-  it('should handle string with hyphens at boundaries', () => {
-    expect(slugify('-hello-world-')).toBe('hello-world');
-  });
-
-  it('should handle string with multiple consecutive hyphens after cleaning', () => {
-    expect(slugify('hello---world')).toBe('hello-world');
-  });
-
-  it('should handle null-like empty string', () => {
-    expect(slugify('')).toBe('untitled');
-  });
-
-  it('should preserve numbers in slug', () => {
-    expect(slugify('version 2.0 release')).toBe('version-20-release');
-  });
-});
-
-describe('generateUniqueSlug edge cases', () => {
-  it('should handle empty existing slugs array', () => {
-    const result = generateUniqueSlug('test', []);
-    expect(result).toBe('test');
-  });
-
-  it('should handle when base slug plus counter would exceed limit', () => {
-    const longBase = 'a'.repeat(98);
-    const existing = [longBase];
-    const result = generateUniqueSlug(longBase, existing);
-    expect(result.length).toBeLessThanOrEqual(100);
-    expect(result).toMatch(/^a+-\d+$/);
-  });
-
-  it('should handle multiple conflicts', () => {
-    const existing = ['test', 'test-1', 'test-2', 'test-3'];
-    const result = generateUniqueSlug('test', existing);
-    expect(result).toBe('test-4');
-  });
-
-  it('should handle slug that looks like a numbered conflict', () => {
-    const existing = ['test-1'];
-    // 'test' is not in existing, so it should return 'test'
-    const result = generateUniqueSlug('test', existing);
-    expect(result).toBe('test');
-  });
-
-  it('should handle case sensitivity', () => {
-    const existing = ['Test'];
-    const result = generateUniqueSlug('test', existing);
-    // Should not conflict because 'test' !== 'Test'
-    expect(result).toBe('test');
-  });
-});
+/**
+ * Slugify Edge Case Tests
+ * Additional tests for better coverage
+ */
+
+import { describe, it, expect } from 'vitest';
+import { slugify, generateUniqueSlug } from '../../src/utils/slugify.js';
+
+describe('slugify edge cases', () => {
+  it('should handle whitespace-only string', () => {
+    expect(slugify('   ')).toBe('untitled');
+  });
+
+  it('should handle multiple consecutive spaces', () => {
+    expect(slugify('hello    world')).toBe('hello-world');
+  });
+
+  it('should handle string with only special characters', () => {
+    expect(slugify('!@#$%^&*()')).toBe('untitled');
+  });
+
+  it('should handle mixed alphanumeric with special chars', () => {
+    expect(slugify('hello123!@#world456')).toBe('hello123world456');
+  });
+
+  it('should handle string starting with numbers', () => {
+    expect(slugify('123hello')).toBe('123hello');
+  });
+
+  it('should handle very short string', () => {
+    expect(slugify('a')).toBe('a');
+  });
+
+  it('should handle string at exactly max length', () => {
+    const input = 'a'.repeat(100);
+    expect(slugify(input)).toBe(input);
+  });
+
+  it('should handle string just over max length', () => {
+    const input = 'a'.repeat(101);
+    expect(slugify(input).length).toBeLessThanOrEqual(100);
+  });
+
+  it('should handle string with hyphens at boundaries', () => {
+    expect(slugify('-hello-world-')).toBe('hello-world');
+  });
+
+  it('should handle string with multiple consecutive hyphens after cleaning', () => {
+    expect(slugify('hello---world')).toBe('hello-world');
+  });
+
+  it('should handle null-like empty string', () => {
+    expect(slugify('')).toBe('untitled');
+  });
+
+  it('should preserve numbers in slug', () => {
+    expect(slugify('version 2.0 release')).toBe('version-20-release');
+  });
+});
+
+describe('generateUniqueSlug edge cases', () => {
+  it('should handle empty existing slugs array', () => {
+    const result = generateUniqueSlug('test', []);
+    expect(result).toBe('test');
+  });
+
+  it('should handle when base slug plus counter would exceed limit', () => {
+    const longBase = 'a'.repeat(98);
+    const existing = [longBase];
+    const result = generateUniqueSlug(longBase, existing);
+    expect(result.length).toBeLessThanOrEqual(100);
+    expect(result).toMatch(/^a+-\d+$/);
+  });
+
+  it('should handle multiple conflicts', () => {
+    const existing = ['test', 'test-1', 'test-2', 'test-3'];
+    const result = generateUniqueSlug('test', existing);
+    expect(result).toBe('test-4');
+  });
+
+  it('should handle slug that looks like a numbered conflict', () => {
+    const existing = ['test-1'];
+    // 'test' is not in existing, so it should return 'test'
+    const result = generateUniqueSlug('test', existing);
+    expect(result).toBe('test');
+  });
+
+  it('should handle case sensitivity', () => {
+    const existing = ['Test'];
+    const result = generateUniqueSlug('test', existing);
+    // Should not conflict because 'test' !== 'Test'
+    expect(result).toBe('test');
+  });
+});

package/test/utils/slugify.test.ts

@@ -1,68 +1,72 @@
-/**
- * Slugify Utility Tests
- * Tests for the slug generation utility
- */
-
-import { describe, it, expect } from 'vitest';
-import { slugify, generateUniqueSlug } from '../../src/utils/slugify.js';
-
-describe('slugify', () => {
-  it('should convert to lowercase', () => {
-    expect(slugify('HELLO')).toBe('hello');
-  });
-
-  it('should replace spaces with hyphens', () => {
-    expect(slugify('hello world')).toBe('hello-world');
-  });
-
-  it('should remove special characters', () => {
-    expect(slugify('hello!@#world')).toBe('helloworld');
-  });
-
-  it('should collapse multiple hyphens', () => {
-    expect(slugify('hello---world')).toBe('hello-world');
-  });
-
-  it('should trim leading/trailing hyphens', () => {
-    expect(slugify('-hello-world-')).toBe('hello-world');
-  });
-
-  it('should handle empty string', () => {
-    expect(slugify('')).toBe('untitled');
-  });
-
-  it('should handle strings that become empty after cleaning', () => {
-    expect(slugify('!@#$%')).toBe('untitled');
-  });
-
-  it('should truncate to max length', () => {
-    const long = 'a'.repeat(200);
-    const result = slugify(long);
-    expect(result.length).toBeLessThanOrEqual(100);
-  });
-
-  it('should handle Chinese characters', () => {
-    expect(slugify('你好世界')).toMatch(/^[a-z0-9-]*$/);
-  });
-
-  it('should handle mixed content', () => {
-    expect(slugify('Hello 世界! World')).toMatch(/^[a-z0-9-]+$/);
-  });
-});
-
-describe('generateUniqueSlug', () => {
-  it('should return same slug when no conflicts', () => {
-    const result = generateUniqueSlug('hello world', []);
-    expect(result).toBe('hello-world');
-  });
-
-  it('should append counter when slug exists', () => {
-    const result = generateUniqueSlug('hello world', ['hello-world']);
-    expect(result).toBe('hello-world-1');
-  });
-
-  it('should increment counter until unique', () => {
-    const result = generateUniqueSlug('hello world', ['hello-world', 'hello-world-1', 'hello-world-2']);
-    expect(result).toBe('hello-world-3');
-  });
-});
+/**
+ * Slugify Utility Tests
+ * Tests for the slug generation utility
+ */
+
+import { describe, it, expect } from 'vitest';
+import { slugify, generateUniqueSlug } from '../../src/utils/slugify.js';
+
+describe('slugify', () => {
+  it('should convert to lowercase', () => {
+    expect(slugify('HELLO')).toBe('hello');
+  });
+
+  it('should replace spaces with hyphens', () => {
+    expect(slugify('hello world')).toBe('hello-world');
+  });
+
+  it('should remove special characters', () => {
+    expect(slugify('hello!@#world')).toBe('helloworld');
+  });
+
+  it('should collapse multiple hyphens', () => {
+    expect(slugify('hello---world')).toBe('hello-world');
+  });
+
+  it('should trim leading/trailing hyphens', () => {
+    expect(slugify('-hello-world-')).toBe('hello-world');
+  });
+
+  it('should handle empty string', () => {
+    expect(slugify('')).toBe('untitled');
+  });
+
+  it('should handle strings that become empty after cleaning', () => {
+    expect(slugify('!@#$%')).toBe('untitled');
+  });
+
+  it('should truncate to max length', () => {
+    const long = 'a'.repeat(200);
+    const result = slugify(long);
+    expect(result.length).toBeLessThanOrEqual(100);
+  });
+
+  it('should handle Chinese characters', () => {
+    expect(slugify('你好世界')).toMatch(/^[a-z0-9-]*$/);
+  });
+
+  it('should handle mixed content', () => {
+    expect(slugify('Hello 世界! World')).toMatch(/^[a-z0-9-]+$/);
+  });
+});
+
+describe('generateUniqueSlug', () => {
+  it('should return same slug when no conflicts', () => {
+    const result = generateUniqueSlug('hello world', []);
+    expect(result).toBe('hello-world');
+  });
+
+  it('should append counter when slug exists', () => {
+    const result = generateUniqueSlug('hello world', ['hello-world']);
+    expect(result).toBe('hello-world-1');
+  });
+
+  it('should increment counter until unique', () => {
+    const result = generateUniqueSlug('hello world', [
+      'hello-world',
+      'hello-world-1',
+      'hello-world-2',
+    ]);
+    expect(result).toBe('hello-world-3');
+  });
+});