@dangao/bun-server 1.12.1 → 2.0.1

package/tests/ai-guard/pii-detector.test.ts

@@ -0,0 +1,41 @@
+import { describe, expect, test } from 'bun:test';
+import { PiiDetector } from '../../src/ai-guard/detectors/pii-detector';
+
+describe('PiiDetector', () => {
+  const detector = new PiiDetector();
+
+  test('should detect email addresses', () => {
+    const result = detector.detect('Contact me at alice@example.com for info.');
+    expect(result.detected).toBe(true);
+    expect(result.types).toContain('email');
+    expect(result.sanitized).toContain('[EMAIL]');
+    expect(result.sanitized).not.toContain('alice@example.com');
+  });
+
+  test('should detect phone numbers', () => {
+    const result = detector.detect('Call me at 555-123-4567');
+    expect(result.detected).toBe(true);
+    expect(result.types).toContain('phone');
+  });
+
+  test('should detect SSNs', () => {
+    const result = detector.detect('My SSN is 123-45-6789');
+    expect(result.detected).toBe(true);
+    expect(result.types).toContain('ssn');
+    expect(result.sanitized).toContain('[SSN]');
+  });
+
+  test('should return original text if no PII found', () => {
+    const text = 'This is a safe message with no personal information.';
+    const result = detector.detect(text);
+    expect(result.detected).toBe(false);
+    expect(result.sanitized).toBe(text);
+  });
+
+  test('should not redact when redact=false', () => {
+    const text = 'Email: test@test.com';
+    const result = detector.detect(text, false);
+    expect(result.detected).toBe(true);
+    expect(result.sanitized).toBe(text);
+  });
+});

package/tests/conversation/conversation-module.test.ts

@@ -0,0 +1,26 @@
+import { describe, expect, test, beforeEach } from 'bun:test';
+import { ConversationModule } from '../../src/conversation/conversation-module';
+import { CONVERSATION_SERVICE_TOKEN } from '../../src/conversation/types';
+import { MODULE_METADATA_KEY } from '../../src/di/module';
+
+describe('ConversationModule', () => {
+  beforeEach(() => {
+    ConversationModule.reset();
+  });
+
+  test('should register providers on forRoot()', () => {
+    ConversationModule.forRoot({ maxMessages: 20 });
+    const metadata = Reflect.getMetadata(MODULE_METADATA_KEY, ConversationModule);
+    expect(metadata).toBeDefined();
+    expect(metadata.exports).toContain(CONVERSATION_SERVICE_TOKEN);
+  });
+
+  test('should use MemoryConversationStore by default', () => {
+    ConversationModule.forRoot();
+    const metadata = Reflect.getMetadata(MODULE_METADATA_KEY, ConversationModule);
+    const optionsProvider = metadata.providers.find(
+      (p: { provide: symbol }) => p.provide === Symbol.for('@dangao/bun-server:conversation:options') || true,
+    );
+    expect(optionsProvider).toBeDefined();
+  });
+});

package/tests/conversation/conversation-service.test.ts

@@ -0,0 +1,64 @@
+import { describe, expect, test } from 'bun:test';
+import { ConversationService } from '../../src/conversation/service';
+import { MemoryConversationStore } from '../../src/conversation/stores/memory-store';
+
+function createService(opts = {}) {
+  const store = new MemoryConversationStore();
+  return new ConversationService({ store, maxMessages: 10, autoTrim: true, ...opts } as never);
+}
+
+describe('ConversationService', () => {
+  test('should create a conversation', async () => {
+    const service = createService();
+    const conv = await service.create({ userId: 'u1' });
+    expect(conv.id).toBeDefined();
+    expect(conv.metadata['userId']).toBe('u1');
+    expect(conv.messages).toHaveLength(0);
+  });
+
+  test('should append messages', async () => {
+    const service = createService();
+    const conv = await service.create();
+    await service.appendMessage(conv.id, { role: 'user', content: 'Hello' });
+    await service.appendMessage(conv.id, { role: 'assistant', content: 'Hi!' });
+
+    const history = await service.getHistory(conv.id);
+    expect(history).toHaveLength(2);
+    expect(history[0]!.content).toBe('Hello');
+    expect(history[1]!.content).toBe('Hi!');
+  });
+
+  test('should auto-trim when maxMessages exceeded', async () => {
+    const service = createService({ maxMessages: 3, autoTrim: true });
+    const conv = await service.create();
+
+    for (let i = 0; i < 5; i++) {
+      await service.appendMessage(conv.id, { role: 'user', content: `Message ${i}` });
+    }
+
+    const history = await service.getHistory(conv.id);
+    expect(history.length).toBeLessThanOrEqual(3);
+  });
+
+  test('should delete a conversation', async () => {
+    const service = createService();
+    const conv = await service.create();
+    const deleted = await service.delete(conv.id);
+    expect(deleted).toBe(true);
+    expect(await service.get(conv.id)).toBeNull();
+  });
+
+  test('should list conversation ids', async () => {
+    const service = createService();
+    await service.create();
+    await service.create();
+    const ids = await service.list();
+    expect(ids.length).toBe(2);
+  });
+
+  test('should return null for missing conversation', async () => {
+    const service = createService();
+    const result = await service.get('non-existent');
+    expect(result).toBeNull();
+  });
+});

package/tests/conversation/memory-store.test.ts

@@ -0,0 +1,68 @@
+import { describe, expect, test } from 'bun:test';
+import { MemoryConversationStore } from '../../src/conversation/stores/memory-store';
+
+describe('MemoryConversationStore', () => {
+  test('should create and retrieve conversation', async () => {
+    const store = new MemoryConversationStore();
+    const conv = await store.create({ tag: 'test' });
+
+    expect(conv.id).toBeDefined();
+    expect(conv.messages).toHaveLength(0);
+
+    const retrieved = await store.get(conv.id);
+    expect(retrieved).not.toBeNull();
+    expect(retrieved!.id).toBe(conv.id);
+  });
+
+  test('should append messages', async () => {
+    const store = new MemoryConversationStore();
+    const conv = await store.create();
+    await store.appendMessage(conv.id, { role: 'user', content: 'Hello' });
+
+    const retrieved = await store.get(conv.id);
+    expect(retrieved!.messages).toHaveLength(1);
+    expect(retrieved!.messages[0]!.content).toBe('Hello');
+  });
+
+  test('should trim old messages', async () => {
+    const store = new MemoryConversationStore();
+    const conv = await store.create();
+
+    for (let i = 0; i < 5; i++) {
+      await store.appendMessage(conv.id, { role: 'user', content: `msg${i}` });
+    }
+
+    await store.trim(conv.id, 3);
+    const retrieved = await store.get(conv.id);
+    expect(retrieved!.messages).toHaveLength(3);
+    // Should keep the most recent
+    expect(retrieved!.messages[0]!.content).toBe('msg2');
+  });
+
+  test('should delete conversation', async () => {
+    const store = new MemoryConversationStore();
+    const conv = await store.create();
+    const deleted = await store.delete(conv.id);
+    expect(deleted).toBe(true);
+    expect(await store.get(conv.id)).toBeNull();
+  });
+
+  test('should list all conversations', async () => {
+    const store = new MemoryConversationStore();
+    await store.create();
+    await store.create();
+    await store.create();
+    const ids = await store.list();
+    expect(ids).toHaveLength(3);
+  });
+
+  test('should return null for missing id', async () => {
+    const store = new MemoryConversationStore();
+    expect(await store.get('missing')).toBeNull();
+  });
+
+  test('should throw on appendMessage to missing conversation', async () => {
+    const store = new MemoryConversationStore();
+    expect(store.appendMessage('missing', { role: 'user', content: 'hi' })).rejects.toThrow();
+  });
+});

package/tests/embedding/embedding-service.test.ts

@@ -0,0 +1,55 @@
+import { describe, expect, test } from 'bun:test';
+import { EmbeddingService } from '../../src/embedding/service';
+
+class MockEmbeddingProvider {
+  readonly name = 'mock';
+  readonly dimensions = 4;
+
+  async embed(text: string): Promise<number[]> {
+    return [text.length / 100, 0.2, 0.3, 0.4];
+  }
+
+  async embedBatch(texts: string[]): Promise<number[][]> {
+    return texts.map((t) => [t.length / 100, 0.2, 0.3, 0.4]);
+  }
+}
+
+function createService(batchSize = 100): EmbeddingService {
+  return new EmbeddingService({
+    provider: { name: 'mock', provider: MockEmbeddingProvider as never, config: {} },
+    batchSize,
+  } as never);
+}
+
+describe('EmbeddingService', () => {
+  test('should embed a single text', async () => {
+    const service = createService();
+    const vec = await service.embed('hello');
+    expect(vec).toHaveLength(4);
+    expect(Array.isArray(vec)).toBe(true);
+  });
+
+  test('should embedBatch multiple texts', async () => {
+    const service = createService();
+    const vecs = await service.embedBatch(['hello', 'world', 'foo']);
+    expect(vecs).toHaveLength(3);
+    expect(vecs[0]).toHaveLength(4);
+  });
+
+  test('should report correct dimensions', () => {
+    const service = createService();
+    expect(service.dimensions).toBe(4);
+  });
+
+  test('should report provider name', () => {
+    const service = createService();
+    expect(service.providerName).toBe('mock');
+  });
+
+  test('should handle batch larger than batchSize', async () => {
+    const service = createService(2);
+    const texts = ['a', 'b', 'c', 'd', 'e'];
+    const vecs = await service.embedBatch(texts);
+    expect(vecs).toHaveLength(5);
+  });
+});

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

@@ -0,0 +1,85 @@
+import { describe, expect, test } from 'bun:test';
+import { McpServer } from '../../src/mcp/server';
+import { McpRegistry } from '../../src/mcp/registry';
+import { McpTool } from '../../src/mcp/decorators';
+import type { McpServerInfo } from '../../src/mcp/types';
+
+const serverInfo: McpServerInfo = { name: 'test-server', version: '1.0.0' };
+
+function createServer(): { server: McpServer; registry: McpRegistry } {
+  const registry = new McpRegistry();
+  const server = new McpServer(registry, serverInfo);
+  return { server, registry };
+}
+
+describe('McpServer', () => {
+  test('should handle initialize request', async () => {
+    const { server } = createServer();
+    const response = await server.handle({ jsonrpc: '2.0', id: 1, method: 'initialize', params: {} });
+
+    expect(response.error).toBeUndefined();
+    expect((response.result as Record<string, unknown>)['protocolVersion']).toBeDefined();
+    expect((response.result as Record<string, unknown>)['serverInfo']).toMatchObject(serverInfo);
+  });
+
+  test('should list tools', async () => {
+    const { server, registry } = createServer();
+
+    class MyTools {
+      @McpTool({ name: 'echo', description: 'Echo input', inputSchema: { type: 'object' } })
+      async echo({ text }: { text: string }) { return text; }
+    }
+    registry.scan(new MyTools());
+
+    const response = await server.handle({ jsonrpc: '2.0', id: 2, method: 'tools/list' });
+    const tools = (response.result as { tools: unknown[] }).tools;
+    expect(tools).toHaveLength(1);
+    expect((tools[0] as Record<string, unknown>)['name']).toBe('echo');
+  });
+
+  test('should call a tool', async () => {
+    const { server, registry } = createServer();
+
+    class EchoTool {
+      @McpTool({ name: 'echo', description: 'Echo', inputSchema: {} })
+      async echo(args: { text: string }) { return `Echo: ${args.text}`; }
+    }
+    registry.scan(new EchoTool());
+
+    const response = await server.handle({
+      jsonrpc: '2.0',
+      id: 3,
+      method: 'tools/call',
+      params: { name: 'echo', arguments: { text: 'Hello' } },
+    });
+
+    expect(response.error).toBeUndefined();
+    const content = (response.result as { content: Array<{ text: string }> }).content;
+    expect(content[0]!.text).toContain('Hello');
+  });
+
+  test('should return error for unknown method', async () => {
+    const { server } = createServer();
+    const response = await server.handle({ jsonrpc: '2.0', id: 4, method: 'unknown/method' });
+    expect(response.error).toBeDefined();
+    expect(response.error!.code).toBe(-32601);
+  });
+
+  test('should return error for unknown tool call', async () => {
+    const { server } = createServer();
+    const response = await server.handle({
+      jsonrpc: '2.0',
+      id: 5,
+      method: 'tools/call',
+      params: { name: 'non-existent', arguments: {} },
+    });
+    expect(response.error).toBeDefined();
+  });
+
+  test('should handle ping', async () => {
+    const { server } = createServer();
+    const response = await server.handle({ jsonrpc: '2.0', id: 6, method: 'ping' });
+    expect(response.error).toBeUndefined();
+    expect(response.result).toEqual({});
+  });
+});

package/tests/prompt/prompt-module.test.ts

@@ -0,0 +1,30 @@
+import { describe, expect, test, beforeEach } from 'bun:test';
+import { PromptModule } from '../../src/prompt/prompt-module';
+import { PROMPT_SERVICE_TOKEN } from '../../src/prompt/types';
+import { MODULE_METADATA_KEY } from '../../src/di/module';
+
+describe('PromptModule', () => {
+  beforeEach(() => {
+    PromptModule.reset();
+  });
+
+  test('should register providers on forRoot()', () => {
+    PromptModule.forRoot();
+    const metadata = Reflect.getMetadata(MODULE_METADATA_KEY, PromptModule);
+    expect(metadata).toBeDefined();
+    expect(metadata.exports).toContain(PROMPT_SERVICE_TOKEN);
+  });
+
+  test('should use InMemoryPromptStore by default', () => {
+    PromptModule.forRoot();
+    const metadata = Reflect.getMetadata(MODULE_METADATA_KEY, PromptModule);
+    expect(metadata.providers.length).toBeGreaterThan(0);
+  });
+
+  test('reset() should clear module metadata', () => {
+    PromptModule.forRoot();
+    PromptModule.reset();
+    const metadata = Reflect.getMetadata(MODULE_METADATA_KEY, PromptModule);
+    expect(metadata).toBeUndefined();
+  });
+});

package/tests/prompt/prompt-service.test.ts

@@ -0,0 +1,74 @@
+import { describe, expect, test } from 'bun:test';
+import { PromptService } from '../../src/prompt/service';
+import { InMemoryPromptStore } from '../../src/prompt/stores/memory-store';
+
+function createService(): PromptService {
+  return new PromptService({ store: new InMemoryPromptStore() } as never);
+}
+
+describe('PromptService', () => {
+  test('should create and retrieve a template', async () => {
+    const service = createService();
+    const created = await service.create({ name: 'greeting', content: 'Hello, {{name}}!' });
+
+    expect(created.id).toBeDefined();
+    expect(created.version).toBe(1);
+    expect(created.variables).toContain('name');
+
+    const fetched = await service.get(created.id);
+    expect(fetched.content).toBe('Hello, {{name}}!');
+  });
+
+  test('should render template with variables', async () => {
+    const service = createService();
+    const template = await service.create({ name: 't', content: 'Hi {{name}}, welcome to {{app}}!' });
+    const rendered = await service.render(template.id, { name: 'Alice', app: 'MyApp' });
+    expect(rendered).toBe('Hi Alice, welcome to MyApp!');
+  });
+
+  test('should leave unresolved variables as-is', async () => {
+    const service = createService();
+    const template = await service.create({ name: 't', content: 'Hello {{name}}, from {{sender}}!' });
+    const rendered = await service.render(template.id, { name: 'Bob' });
+    expect(rendered).toBe('Hello Bob, from {{sender}}!');
+  });
+
+  test('should increment version on update', async () => {
+    const service = createService();
+    const template = await service.create({ name: 't', content: 'v1 {{x}}' });
+    const updated = await service.update(template.id, { content: 'v2 {{x}} {{y}}' });
+    expect(updated.version).toBe(2);
+    expect(updated.variables).toContain('y');
+  });
+
+  test('should retrieve specific version', async () => {
+    const service = createService();
+    const template = await service.create({ name: 't', content: 'v1' });
+    await service.update(template.id, { content: 'v2' });
+
+    const v1 = await service.getVersion(template.id, 1);
+    expect(v1.content).toBe('v1');
+    const v2 = await service.getVersion(template.id, 2);
+    expect(v2.content).toBe('v2');
+  });
+
+  test('should list all templates', async () => {
+    const service = createService();
+    await service.create({ name: 'a', content: 'A' });
+    await service.create({ name: 'b', content: 'B' });
+    const list = await service.list();
+    expect(list).toHaveLength(2);
+  });
+
+  test('should delete template', async () => {
+    const service = createService();
+    const template = await service.create({ name: 'd', content: 'delete me' });
+    await service.delete(template.id);
+    expect(service.get(template.id)).rejects.toThrow();
+  });
+
+  test('should throw 404 for missing template', async () => {
+    const service = createService();
+    expect(service.get('non-existent')).rejects.toThrow('not found');
+  });
+});

package/tests/rag/chunkers.test.ts

@@ -0,0 +1,58 @@
+import { describe, expect, test } from 'bun:test';
+import { TextChunker } from '../../src/rag/chunkers/text-chunker';
+import { MarkdownChunker } from '../../src/rag/chunkers/markdown-chunker';
+
+describe('TextChunker', () => {
+  test('should split text into chunks of specified size', () => {
+    const chunker = new TextChunker(10, 0);
+    const chunks = chunker.chunk('Hello World this is a test string');
+    expect(chunks.length).toBeGreaterThan(1);
+    for (const chunk of chunks) {
+      expect(chunk.content.length).toBeLessThanOrEqual(10);
+    }
+  });
+
+  test('should include overlap between chunks', () => {
+    const chunker = new TextChunker(20, 5);
+    const text = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';
+    const chunks = chunker.chunk(text);
+    expect(chunks.length).toBeGreaterThan(1);
+  });
+
+  test('should return single chunk for short text', () => {
+    const chunker = new TextChunker(512, 50);
+    const chunks = chunker.chunk('Short text');
+    expect(chunks).toHaveLength(1);
+    expect(chunks[0]!.content).toBe('Short text');
+  });
+
+  test('should not return empty chunks', () => {
+    const chunker = new TextChunker(10, 0);
+    const chunks = chunker.chunk('   \n\n  ');
+    expect(chunks).toHaveLength(0);
+  });
+});
+
+describe('MarkdownChunker', () => {
+  test('should split by headings', () => {
+    const chunker = new MarkdownChunker(1000);
+    const markdown = `# Title\n\nIntro text.\n\n## Section 1\n\nContent 1.\n\n## Section 2\n\nContent 2.`;
+    const chunks = chunker.chunk(markdown);
+    expect(chunks.length).toBeGreaterThan(1);
+  });
+
+  test('should handle text without headings', () => {
+    const chunker = new MarkdownChunker(1000);
+    const text = 'Just plain text without any headings.';
+    const chunks = chunker.chunk(text);
+    expect(chunks).toHaveLength(1);
+    expect(chunks[0]!.content).toBe(text);
+  });
+
+  test('should split large sections into paragraphs', () => {
+    const chunker = new MarkdownChunker(50);
+    const markdown = `## Big Section\n\nParagraph one with some content.\n\nParagraph two with more content that makes it too long.`;
+    const chunks = chunker.chunk(markdown);
+    expect(chunks.length).toBeGreaterThan(1);
+  });
+});

package/tests/rag/rag-service.test.ts

@@ -0,0 +1,66 @@
+import { describe, expect, test } from 'bun:test';
+import { RagService } from '../../src/rag/service';
+import { MemoryVectorStore } from '../../src/vector-store/stores/memory-store';
+import { EmbeddingService } from '../../src/embedding/service';
+
+class MockEmbeddingProvider {
+  readonly name = 'mock';
+  readonly dimensions = 4;
+
+  async embed(text: string): Promise<number[]> {
+    const codes = text.split('').slice(0, 4).map((c) => c.charCodeAt(0) / 255);
+    while (codes.length < 4) codes.push(0);
+    return codes;
+  }
+
+  async embedBatch(texts: string[]): Promise<number[][]> {
+    return Promise.all(texts.map((t) => this.embed(t)));
+  }
+}
+
+function createRagService(): RagService {
+  const options = { collection: 'test', chunkSize: 100, chunkOverlap: 10, topK: 3, minScore: 0 };
+  const embeddingService = new EmbeddingService({
+    provider: { name: 'mock', provider: MockEmbeddingProvider as never, config: {} },
+  } as never);
+  const vectorStore = new MemoryVectorStore();
+
+  return new RagService(options as never, embeddingService, vectorStore);
+}
+
+describe('RagService', () => {
+  test('should ingest text and return chunk count', async () => {
+    const service = createRagService();
+    const count = await service.ingest({ type: 'text', content: 'Hello world, this is a test document for RAG.' });
+    expect(count).toBeGreaterThan(0);
+  });
+
+  test('should retrieve context after ingestion', async () => {
+    const service = createRagService();
+    await service.ingest({ type: 'text', content: 'The sky is blue and the grass is green.' });
+    const context = await service.retrieve('sky');
+    expect(context.chunks.length).toBeGreaterThanOrEqual(0);
+    expect(typeof context.formatted).toBe('string');
+  });
+
+  test('should return empty context for empty store', async () => {
+    const service = createRagService();
+    const context = await service.retrieve('anything');
+    expect(context.chunks).toHaveLength(0);
+    expect(context.formatted).toBe('');
+  });
+
+  test('should build context prompt string', async () => {
+    const service = createRagService();
+    await service.ingest({ type: 'text', content: 'Water is H2O.' });
+    const prompt = await service.buildContextPrompt('water');
+    expect(typeof prompt).toBe('string');
+  });
+
+  test('should ingest multiple documents', async () => {
+    const service = createRagService();
+    const count1 = await service.ingest({ type: 'text', content: 'Document one content.' });
+    const count2 = await service.ingest({ type: 'text', content: 'Document two content.' });
+    expect(count1 + count2).toBeGreaterThan(0);
+  });
+});

package/tests/vector-store/memory-vector-store.test.ts

@@ -0,0 +1,84 @@
+import { describe, expect, test } from 'bun:test';
+import { MemoryVectorStore } from '../../src/vector-store/stores/memory-store';
+import { cosineSimilarity } from '../../src/vector-store/types';
+
+describe('MemoryVectorStore', () => {
+  test('should upsert and retrieve a document', async () => {
+    const store = new MemoryVectorStore();
+    await store.upsert({ id: 'doc1', vector: [1, 0, 0], content: 'Test', collection: 'col' });
+    const doc = await store.get('doc1', 'col');
+    expect(doc).not.toBeNull();
+    expect(doc!.content).toBe('Test');
+  });
+
+  test('should return null for missing document', async () => {
+    const store = new MemoryVectorStore();
+    expect(await store.get('missing')).toBeNull();
+  });
+
+  test('should search by cosine similarity', async () => {
+    const store = new MemoryVectorStore();
+    await store.upsert({ id: 'a', vector: [1, 0, 0], content: 'Horizontal', collection: 'test' });
+    await store.upsert({ id: 'b', vector: [0, 1, 0], content: 'Vertical', collection: 'test' });
+    await store.upsert({ id: 'c', vector: [0.9, 0.1, 0], content: 'Mostly horizontal', collection: 'test' });
+
+    const results = await store.search([1, 0, 0], { topK: 2, collection: 'test' });
+    expect(results).toHaveLength(2);
+    // Most similar to [1,0,0] should be doc 'a' first
+    expect(results[0]!.document.id).toBe('a');
+    expect(results[0]!.score).toBeCloseTo(1.0, 2);
+  });
+
+  test('should filter by collection', async () => {
+    const store = new MemoryVectorStore();
+    await store.upsert({ id: '1', vector: [1, 0], content: 'A', collection: 'col1' });
+    await store.upsert({ id: '2', vector: [1, 0], content: 'B', collection: 'col2' });
+
+    const results = await store.search([1, 0], { collection: 'col1' });
+    expect(results).toHaveLength(1);
+    expect(results[0]!.document.content).toBe('A');
+  });
+
+  test('should delete a document', async () => {
+    const store = new MemoryVectorStore();
+    await store.upsert({ id: 'del', vector: [1, 0], content: 'Delete me' });
+    const deleted = await store.delete('del');
+    expect(deleted).toBe(true);
+    expect(await store.get('del')).toBeNull();
+  });
+
+  test('should delete entire collection', async () => {
+    const store = new MemoryVectorStore();
+    await store.upsert({ id: '1', vector: [1, 0], content: 'A', collection: 'purge' });
+    await store.upsert({ id: '2', vector: [0, 1], content: 'B', collection: 'purge' });
+    await store.deleteCollection('purge');
+    expect(await store.count('purge')).toBe(0);
+  });
+
+  test('should count documents', async () => {
+    const store = new MemoryVectorStore();
+    await store.upsert({ id: '1', vector: [1], content: 'A', collection: 'x' });
+    await store.upsert({ id: '2', vector: [2], content: 'B', collection: 'x' });
+    await store.upsert({ id: '3', vector: [3], content: 'C', collection: 'y' });
+    expect(await store.count()).toBe(3);
+    expect(await store.count('x')).toBe(2);
+  });
+});
+
+describe('cosineSimilarity', () => {
+  test('identical vectors have similarity 1.0', () => {
+    expect(cosineSimilarity([1, 0, 0], [1, 0, 0])).toBeCloseTo(1.0);
+  });
+
+  test('orthogonal vectors have similarity 0.0', () => {
+    expect(cosineSimilarity([1, 0], [0, 1])).toBeCloseTo(0.0);
+  });
+
+  test('opposite vectors have similarity -1.0', () => {
+    expect(cosineSimilarity([1, 0], [-1, 0])).toBeCloseTo(-1.0);
+  });
+
+  test('zero vectors return 0', () => {
+    expect(cosineSimilarity([0, 0], [1, 1])).toBe(0);
+  });
+});