adaptive-memory-multi-model-router 2.14.45 → 2.14.47

package/test-council/1-structure-tests.test.ts

@@ -1,353 +0,0 @@
-/**
- * Structure Tests - Code Structure & Export Coverage
- * 
- * Tests that verify all exported functions, classes, and types work correctly.
- * This file provides comprehensive coverage of the public API surface.
- */
-
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-
-// Import all exports from the main module
-const {
-  // Routing engine
-  routeQuery,
-  routeBatch,
-  recommendForTask,
-  extractQueryFeatures,
-  MODEL_PROFILES,
-  updateModelProfile,
-  getProviderHealth,
-  
-  // Retry handling
-  ProviderRetryHandler,
-  createRetryHandler,
-  getDefaultRetryHandler,
-  DEFAULT_RETRY_CONFIG,
-  DEFAULT_PROVIDER_CONFIG,
-  PROVIDER_CONTEXT_LIMITS,
-  
-  // Providers
-  DEFAULT_PROVIDERS,
-  getAvailableProviders,
-  registerProvider,
-  deregisterProvider,
-  updateProvider,
-  healthCheck,
-  checkAllProviders,
-  findCheapestAvailableProvider,
-  findFastestAvailableProvider,
-  loadConfig,
-  saveConfig,
-  
-  // Cost tracking
-  CostTracker,
-  BudgetEnforcer,
-  BudgetExceededError,
-  createBudgetEnforcer,
-  
-  // Memory
-  MemoryTree,
-  
-  // Utilities
-  countTokens,
-  estimateTokens,
-  
-  // Cache
-  SemanticCache,
-  
-  // Security
-  GuardrailEngine,
-  
-  // Analytics
-  CostAnalytics,
-  
-  // Observability
-  Tracer,
-  getTracer,
-  createTracer,
-  MetricsCollector,
-  getMetrics,
-  createMetricsCollector,
-  observabilityMiddleware,
-  observabilityPlugin,
-  budgetAlertMiddleware,
-  
-  // Ensemble
-  EnsembleOrchestrator,
-  
-  // Factory
-  createA3MRouter,
-} = require('../dist/index.js');
-
-// ============================================================
-// STRUCTURE TESTS
-// ============================================================
-
-describe('1. Structure - Routing Engine Exports', () => {
-  
-  describe('routeQuery', () => {
-    it('is a function', () => {
-      expect(typeof routeQuery).toBe('function');
-    });
-    
-    it('returns object with primary_model', () => {
-      const result = routeQuery('test query');
-      expect(result).toHaveProperty('primary_model');
-    });
-    
-    it('returns object with fallback_models array', () => {
-      const result = routeQuery('test query');
-      expect(result).toHaveProperty('fallback_models');
-      expect(Array.isArray(result.fallback_models)).toBe(true);
-    });
-    
-    it('returns object with estimated_cost number', () => {
-      const result = routeQuery('test query');
-      expect(result).toHaveProperty('estimated_cost');
-      expect(typeof result.estimated_cost).toBe('number');
-    });
-    
-    it('returns object with confidence number', () => {
-      const result = routeQuery('test query');
-      expect(result).toHaveProperty('confidence');
-      expect(typeof result.confidence).toBe('number');
-    });
-  });
-  
-  describe('routeBatch', () => {
-    it('is a function', () => {
-      expect(typeof routeBatch).toBe('function');
-    });
-    
-    it('returns array of same length as input', () => {
-      const queries = ['a', 'b', 'c'];
-      const results = routeBatch(queries);
-      expect(results.length).toBe(queries.length);
-    });
-  });
-  
-  describe('recommendForTask', () => {
-    it('is a function', () => {
-      expect(typeof recommendForTask).toBe('function');
-    });
-    
-    it('returns object with primary field', () => {
-      const result = recommendForTask('coding');
-      expect(result).toHaveProperty('primary');
-    });
-  });
-  
-  describe('extractQueryFeatures', () => {
-    it('is a function', () => {
-      expect(typeof extractQueryFeatures).toBe('function');
-    });
-    
-    it('returns object', () => {
-      const features = extractQueryFeatures('test');
-      expect(typeof features).toBe('object');
-    });
-  });
-  
-  describe('MODEL_PROFILES', () => {
-    it('is an object', () => {
-      expect(typeof MODEL_PROFILES).toBe('object');
-    });
-    
-    it('has at least one model', () => {
-      expect(Object.keys(MODEL_PROFILES).length).toBeGreaterThan(0);
-    });
-  });
-});
-
-describe('2. Structure - Provider Configuration Exports', () => {
-  
-  describe('DEFAULT_PROVIDERS', () => {
-    it('is an object', () => {
-      expect(typeof DEFAULT_PROVIDERS).toBe('object');
-    });
-  });
-  
-  describe('getAvailableProviders', () => {
-    it('is a function', () => {
-      expect(typeof getAvailableProviders).toBe('function');
-    });
-    
-    it('returns an object', () => {
-      const providers = getAvailableProviders();
-      expect(typeof providers).toBe('object');
-    });
-  });
-  
-  describe('registerProvider', () => {
-    it('is a function', () => {
-      expect(typeof registerProvider).toBe('function');
-    });
-  });
-  
-  describe('deregisterProvider', () => {
-    it('is a function', () => {
-      expect(typeof deregisterProvider).toBe('function');
-    });
-  });
-  
-  describe('updateProvider', () => {
-    it('is a function', () => {
-      expect(typeof updateProvider).toBe('function');
-    });
-  });
-  
-  describe('healthCheck', () => {
-    it('is a function', () => {
-      expect(typeof healthCheck).toBe('function');
-    });
-  });
-});
-
-describe('3. Structure - Retry Handler Exports', () => {
-  
-  describe('ProviderRetryHandler', () => {
-    it('is a class', () => {
-      expect(typeof ProviderRetryHandler).toBe('function');
-    });
-    
-    it('can be instantiated', () => {
-      const handler = new ProviderRetryHandler();
-      expect(handler).toBeInstanceOf(ProviderRetryHandler);
-    });
-    
-    it('has getConfig method', () => {
-      const handler = new ProviderRetryHandler();
-      expect(typeof handler.getConfig).toBe('function');
-    });
-    
-    it('has isRetryableError method', () => {
-      const handler = new ProviderRetryHandler();
-      expect(typeof handler.isRetryableError).toBe('function');
-    });
-  });
-  
-  describe('createRetryHandler', () => {
-    it('is a function', () => {
-      expect(typeof createRetryHandler).toBe('function');
-    });
-  });
-  
-  describe('DEFAULT_RETRY_CONFIG', () => {
-    it('is an object', () => {
-      expect(typeof DEFAULT_RETRY_CONFIG).toBe('object');
-    });
-  });
-  
-  describe('PROVIDER_CONTEXT_LIMITS', () => {
-    it('is an object', () => {
-      expect(typeof PROVIDER_CONTEXT_LIMITS).toBe('object');
-    });
-  });
-});
-
-describe('4. Structure - Cost Tracking Exports', () => {
-  
-  describe('CostTracker', () => {
-    it('is a class', () => {
-      expect(typeof CostTracker).toBe('function');
-    });
-    
-    it('can be instantiated', () => {
-      const tracker = new CostTracker();
-      expect(tracker).toBeTruthy();
-    });
-  });
-  
-  describe('BudgetEnforcer', () => {
-    it('is a class', () => {
-      expect(typeof BudgetEnforcer).toBe('function');
-    });
-  });
-  
-  describe('BudgetExceededError', () => {
-    it('is an Error class', () => {
-      expect(typeof BudgetExceededError).toBe('function');
-      const error = new BudgetExceededError('test');
-      expect(error).toBeInstanceOf(Error);
-    });
-  });
-});
-
-describe('5. Structure - Memory Exports', () => {
-  
-  describe('MemoryTree', () => {
-    it('is a class', () => {
-      expect(typeof MemoryTree).toBe('function');
-    });
-    
-    it('can be instantiated', () => {
-      const memory = new MemoryTree({ maxSize: 100 });
-      expect(memory).toBeTruthy();
-    });
-    
-    it('has add method', () => {
-      const memory = new MemoryTree({ maxSize: 100 });
-      expect(typeof memory.add).toBe('function');
-    });
-    
-    it('has search method', () => {
-      const memory = new MemoryTree({ maxSize: 100 });
-      expect(typeof memory.search).toBe('function');
-    });
-    
-    it('has getStats method', () => {
-      const memory = new MemoryTree({ maxSize: 100 });
-      expect(typeof memory.getStats).toBe('function');
-    });
-  });
-});
-
-describe('6. Structure - Utility Exports', () => {
-  
-  describe('countTokens', () => {
-    it('is a function', () => {
-      expect(typeof countTokens).toBe('function');
-    });
-    
-    it('returns positive number for non-empty string', () => {
-      const tokens = countTokens('hello world');
-      expect(typeof tokens).toBe('number');
-      expect(tokens).toBeGreaterThan(0);
-    });
-  });
-  
-  describe('estimateTokens', () => {
-    it('is a function', () => {
-      expect(typeof estimateTokens).toBe('function');
-    });
-  });
-});
-
-describe('7. Structure - Factory Exports', () => {
-  
-  describe('createA3MRouter', () => {
-    it('is a function', () => {
-      expect(typeof createA3MRouter).toBe('function');
-    });
-    
-    it('returns an object', () => {
-      const router = createA3MRouter({});
-      expect(typeof router).toBe('object');
-    });
-    
-    it('returns object with route function', () => {
-      const router = createA3MRouter({});
-      expect(typeof router.route).toBe('function');
-    });
-    
-    it('returns object with costTracker', () => {
-      const router = createA3MRouter({});
-      expect(router.costTracker).toBeTruthy();
-    });
-    
-    it('returns object with memoryTree', () => {
-      const router = createA3MRouter({});
-      expect(router.memoryTree).toBeTruthy();
-    });
-  });
-});

package/test-council/2-edge-case-tests.test.ts

@@ -1,361 +0,0 @@
-/**
- * Edge Case Tests - Failure Modes, Boundaries, and Error Paths
- * 
- * Comprehensive tests for edge cases, error conditions, and boundary values.
- */
-
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-
-// Import modules
-const {
-  routeQuery,
-  routeBatch,
-  extractQueryFeatures,
-  countTokens,
-  MemoryTree,
-  ProviderRetryHandler,
-  CostTracker,
-  createA3MRouter,
-} = require('../dist/index.js');
-
-// ============================================================
-// EDGE CASE TESTS - EMPTY AND NULL INPUTS
-// ============================================================
-
-describe('1. Edge Cases - Empty and Null Inputs', () => {
-  
-  describe('routeQuery with empty/null inputs', () => {
-    it('handles empty string', () => {
-      const result = routeQuery('');
-      expect(result.primary_model).toBeTruthy();
-    });
-    
-    it('handles whitespace-only string', () => {
-      const result = routeQuery('   \n\t  ');
-      expect(result.primary_model).toBeTruthy();
-    });
-  });
-  
-  describe('routeBatch with empty inputs', () => {
-    it('handles empty array', () => {
-      const results = routeBatch([]);
-      expect(Array.isArray(results)).toBe(true);
-      expect(results.length).toBe(0);
-    });
-    
-    it('handles array with empty strings', () => {
-      const results = routeBatch(['', '', '']);
-      expect(results.length).toBe(3);
-    });
-  });
-  
-  describe('countTokens with empty inputs', () => {
-    it('handles empty string', () => {
-      const tokens = countTokens('');
-      expect(typeof tokens).toBe('number');
-      expect(tokens).toBeGreaterThanOrEqual(0);
-    });
-  });
-});
-
-// ============================================================
-// EDGE CASE TESTS - BOUNDARY VALUES
-// ============================================================
-
-describe('2. Edge Cases - Boundary Values', () => {
-  
-  describe('routeQuery with extreme lengths', () => {
-    it('handles single character', () => {
-      const result = routeQuery('x');
-      expect(result.primary_model).toBeTruthy();
-    });
-    
-    it('handles very long query', () => {
-      const longQuery = 'a'.repeat(10000);
-      const result = routeQuery(longQuery);
-      expect(result.primary_model).toBeTruthy();
-    });
-  });
-  
-  describe('MemoryTree with boundary sizes', () => {
-    it('handles maxSize of 0', () => {
-      const memory = new MemoryTree({ maxSize: 0 });
-      memory.add('test', { tags: [] });
-      expect(memory.getStats()).toBeTruthy();
-    });
-    
-    it('handles maxSize of 1', () => {
-      const memory = new MemoryTree({ maxSize: 1 });
-      memory.add('test1', { tags: [] });
-      memory.add('test2', { tags: [] });
-      expect(memory.getStats()).toBeTruthy();
-    });
-  });
-});
-
-// ============================================================
-// EDGE CASE TESTS - ERROR HANDLING
-// ============================================================
-
-describe('3. Edge Cases - Error Handling', () => {
-  
-  describe('ProviderRetryHandler errors', () => {
-    let handler: ProviderRetryHandler;
-    
-    beforeEach(() => {
-      handler = new ProviderRetryHandler();
-    });
-    
-    it('isRetryableError returns false for null', () => {
-      expect(handler.isRetryableError(null)).toBe(false);
-    });
-    
-    it('isRetryableError returns false for undefined', () => {
-      expect(handler.isRetryableError(undefined)).toBe(false);
-    });
-    
-    it('isRetryableError returns false for 400 error', () => {
-      expect(handler.isRetryableError({ status: 400 })).toBe(false);
-    });
-    
-    it('isRetryableError returns true for 429 rate limit', () => {
-      expect(handler.isRetryableError({ status: 429 })).toBe(true);
-    });
-    
-    it('isRetryableError returns true for 500 server error', () => {
-      expect(handler.isRetryableError({ status: 500 })).toBe(true);
-    });
-    
-    it('isRetryableError returns true for ECONNRESET', () => {
-      expect(handler.isRetryableError({ code: 'ECONNRESET' })).toBe(true);
-    });
-    
-    it('isRetryableError returns true for ETIMEDOUT', () => {
-      expect(handler.isRetryableError({ code: 'ETIMEDOUT' })).toBe(true);
-    });
-    
-    it('isRateLimitError detects 429 in status', () => {
-      expect(handler.isRateLimitError({ status: 429 })).toBe(true);
-    });
-    
-    it('isRateLimitError returns false for 200', () => {
-      expect(handler.isRateLimitError({ status: 200 })).toBe(false);
-    });
-  });
-  
-  describe('Retry backoff calculations', () => {
-    let handler: ProviderRetryHandler;
-    
-    beforeEach(() => {
-      handler = new ProviderRetryHandler();
-    });
-    
-    it('calculateBackoffDelay returns positive number', () => {
-      const config = {
-        maxRetries: 3,
-        initialDelayMs: 1000,
-        maxDelayMs: 30000,
-        backoffMultiplier: 2,
-        retryableErrors: ['ECONNRESET'],
-      };
-      const delay = handler.calculateBackoffDelay(0, config);
-      expect(delay).toBeGreaterThan(0);
-    });
-    
-    it('calculateBackoffDelay caps at maxDelayMs', () => {
-      const config = {
-        maxRetries: 10,
-        initialDelayMs: 1000,
-        maxDelayMs: 5000,
-        backoffMultiplier: 2,
-        retryableErrors: ['ECONNRESET'],
-      };
-      const delay = handler.calculateBackoffDelay(100, config);
-      expect(delay).toBeLessThanOrEqual(5000);
-    });
-  });
-});
-
-// ============================================================
-// EDGE CASE TESTS - TIMEOUT AND CONCURRENCY
-// ============================================================
-
-describe('4. Edge Cases - Timeout and Concurrency', () => {
-  
-  describe('executeWithRetry timeout behavior', () => {
-    let handler: ProviderRetryHandler;
-    
-    beforeEach(() => {
-      handler = new ProviderRetryHandler();
-    });
-    
-    it('succeeds on first attempt', async () => {
-      const fn = vi.fn().mockResolvedValue('success');
-      const result = await handler.executeWithRetry('groq', fn);
-      expect(result).toBe('success');
-      expect(fn).toHaveBeenCalledTimes(1);
-    });
-    
-    it('retries on transient errors', async () => {
-      const fn = vi.fn()
-        .mockRejectedValueOnce({ code: 'ECONNRESET' })
-        .mockResolvedValue('success');
-      
-      const result = await handler.executeWithRetry('groq', fn);
-      expect(result).toBe('success');
-      expect(fn).toHaveBeenCalledTimes(2);
-    });
-    
-    it('fails after exhausting retries', async () => {
-      const fn = vi.fn().mockRejectedValue({ code: 'ECONNRESET' });
-      
-      await expect(
-        handler.executeWithRetry('groq', fn)
-      ).rejects.toThrow();
-    });
-    
-    it('does not retry non-retryable errors', async () => {
-      const fn = vi.fn().mockRejectedValue({ status: 401 });
-      
-      await expect(
-        handler.executeWithRetry('groq', fn)
-      ).rejects.toThrow();
-      expect(fn).toHaveBeenCalledTimes(1);
-    });
-  });
-  
-  describe('MemoryTree concurrent access', () => {
-    it('handles concurrent add operations', async () => {
-      const memory = new MemoryTree({ maxSize: 1000 });
-      
-      await Promise.all(
-        Array(50).fill(null).map((_, i) => 
-          memory.add(`entry ${i}`)
-        )
-      );
-      
-      const results = memory.search('entry');
-      expect(Array.isArray(results)).toBe(true);
-    });
-  });
-});
-
-// ============================================================
-// EDGE CASE TESTS - SPECIAL INPUTS
-// ============================================================
-
-describe('5. Edge Cases - Special Input Types', () => {
-  
-  describe('Unicode handling', () => {
-    it('handles Japanese text', () => {
-      const result = routeQuery('こんにちは世界');
-      expect(result.primary_model).toBeTruthy();
-    });
-    
-    it('handles Chinese text', () => {
-      const result = routeQuery('你好世界');
-      expect(result.primary_model).toBeTruthy();
-    });
-    
-    it('handles emoji', () => {
-      const result = routeQuery('Hello 👋🌍🎉');
-      expect(result.primary_model).toBeTruthy();
-    });
-  });
-  
-  describe('Code snippet handling', () => {
-    it('handles JavaScript code', () => {
-      const result = routeQuery('function test() { return 42; }');
-      expect(result.primary_model).toBeTruthy();
-    });
-    
-    it('handles SQL code', () => {
-      const result = routeQuery('SELECT * FROM users WHERE id = 1');
-      expect(result.primary_model).toBeTruthy();
-    });
-  });
-  
-  describe('Translation detection', () => {
-    it('detects translation queries', () => {
-      const features = extractQueryFeatures('Translate hello to French');
-      expect(features.is_translation).toBe(true);
-    });
-  });
-});
-
-// ============================================================
-// EDGE CASE TESTS - STATE MANAGEMENT
-// ============================================================
-
-describe('6. Edge Cases - State Management', () => {
-  
-  describe('MemoryTree state', () => {
-    it('persists state across operations', async () => {
-      const memory = new MemoryTree({ maxSize: 100 });
-      
-      await memory.add('stateful entry');
-      const results1 = memory.search('stateful');
-      expect(Array.isArray(results1)).toBe(true);
-      
-      const results2 = memory.search('stateful');
-      expect(results2.length).toBe(results1.length);
-    });
-    
-    it('getStats returns accurate stats', async () => {
-      const memory = new MemoryTree({ maxSize: 100 });
-      
-      await memory.add('entry 1');
-      await memory.add('entry 2');
-      
-      const stats = memory.getStats();
-      expect(stats.totalChunks).toBeGreaterThan(0);
-    });
-  });
-  
-  describe('Retry handler state', () => {
-    let handler: ProviderRetryHandler;
-    
-    beforeEach(() => {
-      handler = new ProviderRetryHandler();
-    });
-    
-    it('getStats starts at zero', () => {
-      const stats = handler.getStats('groq');
-      expect(stats.totalRequests).toBe(0);
-    });
-    
-    it('resetStats clears stats', () => {
-      handler.resetStats();
-      const allStats = handler.getAllStats();
-      for (const stats of Object.values(allStats)) {
-        expect(stats.totalRequests).toBe(0);
-      }
-    });
-  });
-});
-
-// ============================================================
-// EDGE CASE TESTS - LARGE BATCH PROCESSING
-// ============================================================
-
-describe('7. Edge Cases - Memory and Resource Limits', () => {
-  
-  describe('Large batch processing', () => {
-    it('handles 1000-item batch', () => {
-      const queries = Array(1000).fill('test query');
-      const results = routeBatch(queries);
-      expect(results.length).toBe(1000);
-    });
-  });
-  
-  describe('Rapid successive calls', () => {
-    it('handles 100 rapid calls', async () => {
-      const promises = Array(100).fill(null).map(() => 
-        Promise.resolve(routeQuery('test'))
-      );
-      
-      const results = await Promise.all(promises);
-      expect(results.length).toBe(100);
-    });
-  });
-});