@sparkleideas/agentdb-onnx 1.0.1

package/src/tests/integration.test.ts

@@ -0,0 +1,302 @@
+/**
+ * Integration tests for AgentDB + ONNX
+ *
+ * Tests the integration between ONNXEmbeddingService and AgentDB controllers
+ */
+
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { createONNXAgentDB } from '../index.js';
+
+describe('AgentDB + ONNX Integration', () => {
+  let agentdb: Awaited<ReturnType<typeof createONNXAgentDB>>;
+
+  beforeAll(async () => {
+    agentdb = await createONNXAgentDB({
+      dbPath: ':memory:',  // Use in-memory database for tests
+      modelName: 'Xenova/all-MiniLM-L6-v2',
+      useGPU: false,
+      batchSize: 4,
+      cacheSize: 100
+    });
+  });
+
+  afterAll(async () => {
+    await agentdb.close();
+  });
+
+  describe('ReasoningBank', () => {
+    it('should store and retrieve patterns', async () => {
+      const patternId = await agentdb.reasoningBank.storePattern({
+        taskType: 'debugging',
+        approach: 'Binary search through code execution',
+        successRate: 0.92,
+        tags: ['systematic', 'efficient']
+      });
+
+      expect(patternId).toBeGreaterThan(0);
+
+      const pattern = agentdb.reasoningBank.getPattern(patternId);
+      expect(pattern).not.toBeNull();
+      expect(pattern?.taskType).toBe('debugging');
+      expect(pattern?.successRate).toBe(0.92);
+    });
+
+    it('should search for similar patterns with semantic matching', async () => {
+      // Store multiple debugging patterns
+      await agentdb.reasoningBank.storePattern({
+        taskType: 'debugging',
+        approach: 'Check logs first, then reproduce the issue systematically',
+        successRate: 0.88
+      });
+
+      await agentdb.reasoningBank.storePattern({
+        taskType: 'debugging',
+        approach: 'Use debugger breakpoints and step through execution',
+        successRate: 0.85
+      });
+
+      await agentdb.reasoningBank.storePattern({
+        taskType: 'optimization',
+        approach: 'Profile before optimizing to identify bottlenecks',
+        successRate: 0.95
+      });
+
+      // Search for debugging patterns using semantic query
+      const results = await agentdb.reasoningBank.searchPatterns({
+        task: 'how to debug code issues',
+        k: 5,
+        threshold: 0.5
+      });
+
+      expect(results.length).toBeGreaterThan(0);
+      results.forEach(r => {
+        expect(r.similarity).toBeGreaterThanOrEqual(0.5);
+        expect(r.similarity).toBeLessThanOrEqual(1.0);
+      });
+
+      // Most results should be debugging-related (semantic matching)
+      const debuggingResults = results.filter(r => r.taskType === 'debugging');
+      expect(debuggingResults.length).toBeGreaterThan(0);
+    });
+
+    it('should filter by task type', async () => {
+      const results = await agentdb.reasoningBank.searchPatterns({
+        task: 'approach for solving problems',
+        k: 10,
+        filters: { taskType: 'debugging' }
+      });
+
+      results.forEach(r => {
+        expect(r.taskType).toBe('debugging');
+      });
+    });
+
+    it('should use ONNX cache for repeated queries', async () => {
+      const stats1 = agentdb.embedder.getStats();
+
+      // First search - will generate embedding
+      await agentdb.reasoningBank.searchPatterns({
+        task: 'test query for caching',
+        k: 5
+      });
+
+      const stats2 = agentdb.embedder.getStats();
+      const embeddings1 = stats2.totalEmbeddings - stats1.totalEmbeddings;
+
+      // Second search - should use cache
+      await agentdb.reasoningBank.searchPatterns({
+        task: 'test query for caching',
+        k: 5
+      });
+
+      const stats3 = agentdb.embedder.getStats();
+      const embeddings2 = stats3.totalEmbeddings - stats2.totalEmbeddings;
+
+      // Second query should use cache (0 new embeddings)
+      expect(embeddings2).toBe(0);
+      expect(embeddings1).toBeGreaterThan(0);
+    });
+
+    it('should delete patterns', async () => {
+      const id = await agentdb.reasoningBank.storePattern({
+        taskType: 'test',
+        approach: 'temporary pattern',
+        successRate: 0.5
+      });
+
+      // Verify it exists
+      let pattern = agentdb.reasoningBank.getPattern(id);
+      expect(pattern).not.toBeNull();
+
+      // Delete it
+      const deleted = agentdb.reasoningBank.deletePattern(id);
+      expect(deleted).toBe(true);
+
+      // Verify it's gone
+      pattern = agentdb.reasoningBank.getPattern(id);
+      expect(pattern).toBeNull();
+    });
+
+    it('should record outcomes for learning', async () => {
+      const id = await agentdb.reasoningBank.storePattern({
+        taskType: 'testing',
+        approach: 'learning pattern',
+        successRate: 0.5,
+        uses: 0,
+        avgReward: 0
+      });
+
+      // Record successful outcome
+      await agentdb.reasoningBank.recordOutcome(id, true, 0.95);
+
+      // Verify stats updated
+      const pattern = agentdb.reasoningBank.getPattern(id);
+      expect(pattern?.uses).toBe(1);
+      expect(pattern?.avgReward).toBeGreaterThan(0);
+    });
+  });
+
+  describe('ReflexionMemory', () => {
+    it('should store and retrieve episodes', async () => {
+      const episodeId = await agentdb.reflexionMemory.storeEpisode({
+        sessionId: 'test-session-1',
+        task: 'Debug memory leak in server',
+        reward: 0.95,
+        success: true,
+        critique: 'Profiling helped identify the leak quickly'
+      });
+
+      expect(episodeId).toBeGreaterThan(0);
+    });
+
+    it('should retrieve relevant episodes', async () => {
+      // Store multiple episodes
+      await agentdb.reflexionMemory.storeEpisode({
+        sessionId: 'session-2',
+        task: 'Optimize database queries',
+        reward: 0.88,
+        success: true,
+        critique: 'Adding indexes improved performance significantly'
+      });
+
+      await agentdb.reflexionMemory.storeEpisode({
+        sessionId: 'session-2',
+        task: 'Debug connection timeout',
+        reward: 0.65,
+        success: false,
+        critique: 'Should have checked network logs first'
+      });
+
+      await agentdb.reflexionMemory.storeEpisode({
+        sessionId: 'session-2',
+        task: 'Fix API response time',
+        reward: 0.92,
+        success: true,
+        critique: 'Caching strategy worked well'
+      });
+
+      // Retrieve episodes related to performance
+      const results = await agentdb.reflexionMemory.retrieveRelevant({
+        task: 'performance optimization',
+        k: 5
+      });
+
+      expect(results.length).toBeGreaterThan(0);
+      results.forEach(r => {
+        expect(r.similarity).toBeGreaterThan(0);
+      });
+    });
+
+    it('should filter by success', async () => {
+      const successes = await agentdb.reflexionMemory.retrieveRelevant({
+        task: 'debugging approach',
+        k: 10,
+        onlySuccesses: true
+      });
+
+      successes.forEach(r => {
+        expect(r.success).toBe(true);
+      });
+
+      const failures = await agentdb.reflexionMemory.retrieveRelevant({
+        task: 'debugging approach',
+        k: 10,
+        onlyFailures: true
+      });
+
+      failures.forEach(r => {
+        expect(r.success).toBe(false);
+      });
+    });
+
+    it('should get critique summary', async () => {
+      const summary = await agentdb.reflexionMemory.getCritiqueSummary({
+        task: 'debugging',
+        k: 5
+      });
+
+      expect(typeof summary).toBe('string');
+      // Summary should contain critique content if failures exist
+    });
+
+    it('should get success strategies', async () => {
+      const strategies = await agentdb.reflexionMemory.getSuccessStrategies({
+        task: 'optimization',
+        k: 5
+      });
+
+      expect(typeof strategies).toBe('string');
+      // Strategies should contain successful approach descriptions
+    });
+  });
+
+  describe('Performance', () => {
+    it('should have good cache hit rate', async () => {
+      // Clear cache first
+      agentdb.embedder.clearCache();
+
+      // Generate some queries
+      const queries = [
+        'debug memory issue',
+        'optimize performance',
+        'debug memory issue',  // Repeat
+        'fix bug',
+        'optimize performance'   // Repeat
+      ];
+
+      for (const query of queries) {
+        await agentdb.reasoningBank.searchPatterns({
+          task: query,
+          k: 3
+        });
+      }
+
+      const stats = agentdb.embedder.getStats();
+      expect(stats.cache.hitRate).toBeGreaterThan(0.2); // At least 20% hit rate
+    });
+
+    it('should maintain low latency with warmup', async () => {
+      const stats = agentdb.embedder.getStats();
+
+      // After warmup, average latency should be reasonable
+      expect(stats.avgLatency).toBeLessThan(200); // < 200ms average
+      expect(stats.warmupComplete).toBe(true);
+    });
+  });
+
+  describe('Statistics', () => {
+    it('should provide comprehensive stats', async () => {
+      const stats = agentdb.getStats();
+
+      expect(stats).toHaveProperty('embedder');
+      expect(stats).toHaveProperty('database');
+
+      expect(stats.embedder).toHaveProperty('totalEmbeddings');
+      expect(stats.embedder).toHaveProperty('avgLatency');
+      expect(stats.embedder).toHaveProperty('cache');
+
+      expect(stats.embedder.cache).toHaveProperty('hitRate');
+      expect(stats.embedder.cache).toHaveProperty('size');
+    });
+  });
+});

package/src/tests/onnx-embedding.test.ts

@@ -0,0 +1,317 @@
+/**
+ * Comprehensive tests for ONNX Embedding Service
+ */
+
+import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { ONNXEmbeddingService } from '../services/ONNXEmbeddingService.js';
+
+describe('ONNXEmbeddingService', () => {
+  let embedder: ONNXEmbeddingService;
+
+  beforeAll(async () => {
+    embedder = new ONNXEmbeddingService({
+      modelName: 'Xenova/all-MiniLM-L6-v2',
+      useGPU: false, // Use CPU for tests
+      batchSize: 4,
+      cacheSize: 100
+    });
+    await embedder.initialize();
+  });
+
+  afterAll(() => {
+    embedder.clearCache();
+  });
+
+  describe('Initialization', () => {
+    it('should initialize successfully', async () => {
+      const stats = embedder.getStats();
+      expect(stats.initialized).toBe(true);
+      expect(stats.model).toBe('Xenova/all-MiniLM-L6-v2');
+    });
+
+    it('should have correct dimension', () => {
+      const dimension = embedder.getDimension();
+      expect(dimension).toBe(384);
+    });
+  });
+
+  describe('Single Embedding', () => {
+    it('should generate embedding for single text', async () => {
+      const text = 'This is a test sentence';
+      const result = await embedder.embed(text);
+
+      expect(result.embedding).toBeInstanceOf(Float32Array);
+      expect(result.embedding.length).toBe(384);
+      expect(result.latency).toBeGreaterThan(0);
+      expect(result.cached).toBe(false);
+      expect(result.model).toBe('Xenova/all-MiniLM-L6-v2');
+    });
+
+    it('should return cached result for same text', async () => {
+      const text = 'Cached test sentence';
+
+      // First call
+      const result1 = await embedder.embed(text);
+      expect(result1.cached).toBe(false);
+
+      // Second call should be cached
+      const result2 = await embedder.embed(text);
+      expect(result2.cached).toBe(true);
+      expect(result2.latency).toBeLessThan(result1.latency);
+    });
+
+    it('should generate different embeddings for different texts', async () => {
+      const text1 = 'First sentence';
+      const text2 = 'Second sentence';
+
+      const result1 = await embedder.embed(text1);
+      const result2 = await embedder.embed(text2);
+
+      // Embeddings should be different
+      const areDifferent = Array.from(result1.embedding).some(
+        (val, i) => val !== result2.embedding[i]
+      );
+      expect(areDifferent).toBe(true);
+    });
+
+    it('should handle empty text', async () => {
+      const result = await embedder.embed('');
+      expect(result.embedding).toBeInstanceOf(Float32Array);
+      expect(result.embedding.length).toBe(384);
+    });
+
+    it('should handle very long text', async () => {
+      const longText = 'word '.repeat(1000);
+      const result = await embedder.embed(longText);
+      expect(result.embedding).toBeInstanceOf(Float32Array);
+      expect(result.embedding.length).toBe(384);
+    });
+  });
+
+  describe('Batch Embedding', () => {
+    it('should generate embeddings for batch', async () => {
+      const texts = [
+        'First text',
+        'Second text',
+        'Third text',
+        'Fourth text'
+      ];
+
+      const result = await embedder.embedBatch(texts);
+
+      expect(result.embeddings).toHaveLength(4);
+      expect(result.total).toBe(4);
+      expect(result.cached).toBe(0);
+      expect(result.latency).toBeGreaterThan(0);
+
+      result.embeddings.forEach(emb => {
+        expect(emb).toBeInstanceOf(Float32Array);
+        expect(emb.length).toBe(384);
+      });
+    });
+
+    it('should use cache for batch processing', async () => {
+      const texts = ['Cached 1', 'Cached 2', 'Cached 3'];
+
+      // First batch
+      const result1 = await embedder.embedBatch(texts);
+      expect(result1.cached).toBe(0);
+
+      // Second batch (should all be cached)
+      const result2 = await embedder.embedBatch(texts);
+      expect(result2.cached).toBe(3);
+      expect(result2.latency).toBeLessThan(result1.latency);
+    });
+
+    it('should handle large batches', async () => {
+      const texts = Array.from({ length: 50 }, (_, i) => `Batch text ${i}`);
+      const result = await embedder.embedBatch(texts);
+
+      expect(result.embeddings).toHaveLength(50);
+      expect(result.total).toBe(50);
+    });
+
+    it('should handle empty batch', async () => {
+      const result = await embedder.embedBatch([]);
+      expect(result.embeddings).toHaveLength(0);
+      expect(result.total).toBe(0);
+    });
+  });
+
+  describe('Performance', () => {
+    it('should generate embedding quickly', async () => {
+      const startTime = Date.now();
+      await embedder.embed('Performance test');
+      const latency = Date.now() - startTime;
+
+      // Should be under 1 second for first run
+      expect(latency).toBeLessThan(1000);
+    });
+
+    it('should be fast with cache', async () => {
+      const text = 'Cache speed test';
+
+      // Warm up cache
+      await embedder.embed(text);
+
+      // Measure cached access
+      const startTime = Date.now();
+      await embedder.embed(text);
+      const latency = Date.now() - startTime;
+
+      // Cached access should be < 10ms
+      expect(latency).toBeLessThan(10);
+    });
+
+    it('should show performance improvement with warmup', async () => {
+      const newEmbedder = new ONNXEmbeddingService({
+        modelName: 'Xenova/all-MiniLM-L6-v2',
+        useGPU: false
+      });
+      await newEmbedder.initialize();
+
+      // Before warmup
+      const start1 = Date.now();
+      await newEmbedder.embed('Test before warmup');
+      const beforeWarmup = Date.now() - start1;
+
+      // Warmup
+      await newEmbedder.warmup(5);
+
+      // After warmup
+      const start2 = Date.now();
+      await newEmbedder.embed('Test after warmup');
+      const afterWarmup = Date.now() - start2;
+
+      // Warmup should improve performance
+      expect(newEmbedder.getStats().warmupComplete).toBe(true);
+    });
+  });
+
+  describe('Cache Management', () => {
+    it('should respect cache size limit', async () => {
+      const smallCache = new ONNXEmbeddingService({
+        modelName: 'Xenova/all-MiniLM-L6-v2',
+        useGPU: false,
+        cacheSize: 5
+      });
+      await smallCache.initialize();
+
+      // Add 10 items (should evict 5)
+      for (let i = 0; i < 10; i++) {
+        await smallCache.embed(`Cache test ${i}`);
+      }
+
+      const stats = smallCache.getStats();
+      expect(stats.cache.size).toBeLessThanOrEqual(5);
+    });
+
+    it('should clear cache', async () => {
+      await embedder.embed('Test 1');
+      await embedder.embed('Test 2');
+
+      let stats = embedder.getStats();
+      expect(stats.cache.size).toBeGreaterThan(0);
+
+      embedder.clearCache();
+
+      stats = embedder.getStats();
+      expect(stats.cache.size).toBe(0);
+    });
+
+    it('should track cache hit rate', async () => {
+      embedder.clearCache();
+
+      // Generate some embeddings
+      await embedder.embed('Hit rate test 1');
+      await embedder.embed('Hit rate test 2');
+
+      // Access cached items
+      await embedder.embed('Hit rate test 1');
+      await embedder.embed('Hit rate test 2');
+
+      const stats = embedder.getStats();
+      expect(stats.cache.hitRate).toBeGreaterThan(0);
+    });
+  });
+
+  describe('Statistics', () => {
+    it('should track total embeddings', async () => {
+      const initialStats = embedder.getStats();
+      const initialCount = initialStats.totalEmbeddings;
+
+      await embedder.embed('Stats test 1');
+      await embedder.embed('Stats test 2');
+
+      const newStats = embedder.getStats();
+      expect(newStats.totalEmbeddings).toBe(initialCount + 2);
+    });
+
+    it('should track average latency', async () => {
+      const stats = embedder.getStats();
+      expect(stats.avgLatency).toBeGreaterThan(0);
+    });
+
+    it('should track batch sizes', async () => {
+      await embedder.embedBatch(['Batch 1', 'Batch 2', 'Batch 3']);
+      const stats = embedder.getStats();
+      expect(stats.avgBatchSize).toBeGreaterThan(0);
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('should throw error if not initialized', async () => {
+      const uninitialized = new ONNXEmbeddingService({
+        modelName: 'Xenova/all-MiniLM-L6-v2'
+      });
+
+      await expect(uninitialized.embed('Test')).rejects.toThrow('not initialized');
+    });
+  });
+
+  describe('Similarity', () => {
+    it('should generate similar embeddings for similar texts', async () => {
+      const text1 = 'The cat sits on the mat';
+      const text2 = 'A cat is sitting on a mat';
+
+      const result1 = await embedder.embed(text1);
+      const result2 = await embedder.embed(text2);
+
+      // Calculate cosine similarity
+      const similarity = cosineSimilarity(result1.embedding, result2.embedding);
+
+      // Similar texts should have high similarity (>0.7)
+      expect(similarity).toBeGreaterThan(0.7);
+    });
+
+    it('should generate dissimilar embeddings for different texts', async () => {
+      const text1 = 'The weather is sunny today';
+      const text2 = 'Quantum physics is fascinating';
+
+      const result1 = await embedder.embed(text1);
+      const result2 = await embedder.embed(text2);
+
+      const similarity = cosineSimilarity(result1.embedding, result2.embedding);
+
+      // Different texts should have lower similarity (<0.7)
+      expect(similarity).toBeLessThan(0.7);
+    });
+  });
+});
+
+/**
+ * Helper: Calculate cosine similarity
+ */
+function cosineSimilarity(a: Float32Array, b: Float32Array): number {
+  let dotProduct = 0;
+  let normA = 0;
+  let normB = 0;
+
+  for (let i = 0; i < a.length; i++) {
+    dotProduct += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+
+  return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
+}

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ES2022",
+    "lib": ["ES2022"],
+    "moduleResolution": "node",
+    "esModuleInterop": true,
+    "resolveJsonModule": true,
+    "declaration": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "strict": false,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "allowSyntheticDefaultImports": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "**/*.test.ts"]
+}