create-byan-agent 2.0.1 → 2.1.0

package/__tests__/dashboard.test.js

@@ -0,0 +1,444 @@
+/**
+ * Tests for Dashboard
+ * 
+ * @module __tests__/dashboard
+ */
+
+const { printDashboard, generateSummary } = require('../src/observability/dashboard/dashboard');
+
+describe('Dashboard', () => {
+  describe('printDashboard', () => {
+    test('should return formatted dashboard with header', () => {
+      const output = printDashboard();
+
+      expect(output).toContain('BYAN v2.0 Dashboard');
+      expect(output).toContain('╔═══');
+      expect(output).toContain('╚═══');
+    });
+
+    test('should include status section', () => {
+      const output = printDashboard();
+
+      expect(output).toContain('Status');
+      expect(output).toContain('┌─');
+      expect(output).toContain('└─');
+    });
+
+    test('should display status information', () => {
+      const output = printDashboard({
+        status: {
+          version: '2.0.0',
+          uptime: '3600s',
+        },
+      });
+
+      expect(output).toContain('version');
+      expect(output).toContain('2.0.0');
+      expect(output).toContain('uptime');
+      expect(output).toContain('3600s');
+    });
+
+    test('should show message when no status available', () => {
+      const output = printDashboard({ status: {} });
+
+      expect(output).toContain('No status information available');
+    });
+
+    test('should include metrics section', () => {
+      const output = printDashboard();
+
+      expect(output).toContain('Metrics');
+    });
+
+    test('should display metrics', () => {
+      const output = printDashboard({
+        metrics: {
+          'api.calls': { value: 100, type: 'counter' },
+          'cache.hits': { value: 250, type: 'counter' },
+        },
+      });
+
+      expect(output).toContain('api.calls');
+      expect(output).toContain('100');
+      expect(output).toContain('cache.hits');
+      expect(output).toContain('250');
+    });
+
+    test('should show message when no metrics available', () => {
+      const output = printDashboard({ metrics: {} });
+
+      expect(output).toContain('No metrics available');
+    });
+
+    test('should limit metrics display to 10', () => {
+      const metrics = {};
+      for (let i = 0; i < 15; i++) {
+        metrics[`metric${i}`] = { value: i, type: 'gauge' };
+      }
+
+      const output = printDashboard({ metrics });
+
+      expect(output).toContain('... and 5 more metrics');
+    });
+
+    test('should truncate long metric names', () => {
+      const output = printDashboard({
+        metrics: {
+          'very.long.metric.name.that.exceeds.thirty.characters': {
+            value: 123,
+            type: 'gauge',
+          },
+        },
+      });
+
+      expect(output).toContain('very.long.metric.name.that.');
+      expect(output).toContain('...');
+    });
+
+    test('should include recent logs section', () => {
+      const output = printDashboard();
+
+      expect(output).toContain('Recent Logs');
+    });
+
+    test('should display recent logs', () => {
+      const output = printDashboard({
+        logs: [
+          { level: 'info', message: 'Task started', timestamp: '2025-01-01T00:00:00Z' },
+          { level: 'warn', message: 'Rate limit approaching', timestamp: '2025-01-01T00:00:01Z' },
+          { level: 'error', message: 'Task failed', timestamp: '2025-01-01T00:00:02Z' },
+        ],
+      });
+
+      expect(output).toContain('[INFO]');
+      expect(output).toContain('Task started');
+      expect(output).toContain('[WARN]');
+      expect(output).toContain('Rate limit approaching');
+      expect(output).toContain('[ERROR]');
+      expect(output).toContain('Task failed');
+    });
+
+    test('should show message when no logs available', () => {
+      const output = printDashboard({ logs: [] });
+
+      expect(output).toContain('No recent logs');
+    });
+
+    test('should limit logs to last 5', () => {
+      const logs = Array.from({ length: 10 }, (_, i) => ({
+        level: 'info',
+        message: `Message ${i}`,
+        timestamp: new Date().toISOString(),
+      }));
+
+      const output = printDashboard({ logs });
+
+      // Should only contain last 5
+      expect(output).toContain('Message 5');
+      expect(output).toContain('Message 6');
+      expect(output).toContain('Message 7');
+      expect(output).toContain('Message 8');
+      expect(output).toContain('Message 9');
+      expect(output).not.toContain('Message 0');
+      expect(output).not.toContain('Message 4');
+    });
+
+    test('should truncate long log messages', () => {
+      const output = printDashboard({
+        logs: [
+          {
+            level: 'info',
+            message: 'This is a very long log message that exceeds forty characters and should be truncated',
+            timestamp: '2025-01-01T00:00:00Z',
+          },
+        ],
+      });
+
+      expect(output).toContain('This is a very long log message that');
+      expect(output).toContain('...');
+    });
+
+    test('should include workers section', () => {
+      const output = printDashboard();
+
+      expect(output).toContain('Workers');
+    });
+
+    test('should display workers', () => {
+      const output = printDashboard({
+        workers: [
+          { id: '1', status: 'idle' },
+          { id: '2', status: 'busy' },
+          { id: '3', status: 'idle' },
+        ],
+      });
+
+      expect(output).toContain('Worker 1');
+      expect(output).toContain('idle');
+      expect(output).toContain('Worker 2');
+      expect(output).toContain('busy');
+      expect(output).toContain('Worker 3');
+    });
+
+    test('should show message when no workers available', () => {
+      const output = printDashboard({ workers: [] });
+
+      expect(output).toContain('No active workers');
+    });
+
+    test('should handle worker without status', () => {
+      const output = printDashboard({
+        workers: [{ id: '1' }],
+      });
+
+      expect(output).toContain('Worker 1');
+      expect(output).toContain('unknown');
+    });
+
+    test('should return string type', () => {
+      const output = printDashboard();
+
+      expect(typeof output).toBe('string');
+    });
+
+    test('should handle empty data object', () => {
+      const output = printDashboard({});
+
+      expect(output).toContain('BYAN v2.0 Dashboard');
+      expect(output).toContain('Status');
+      expect(output).toContain('Metrics');
+      expect(output).toContain('Recent Logs');
+      expect(output).toContain('Workers');
+    });
+
+    test('should handle null data', () => {
+      const output = printDashboard(null);
+
+      expect(output).toContain('BYAN v2.0 Dashboard');
+    });
+
+    test('should format large numbers with separators', () => {
+      const output = printDashboard({
+        metrics: {
+          'large.number': { value: 1234567, type: 'counter' },
+        },
+      });
+
+      // Should contain number (locale format may vary - comma, space, or non-breaking space)
+      expect(output).toContain('large.number');
+      expect(output).toMatch(/1[\s,]234[\s,]567/);
+    });
+
+    test('should format decimal numbers', () => {
+      const output = printDashboard({
+        metrics: {
+          'decimal.value': { value: 3.14159, type: 'gauge' },
+        },
+      });
+
+      expect(output).toContain('3.14');
+    });
+
+    test('should format integer numbers without decimals', () => {
+      const output = printDashboard({
+        metrics: {
+          'integer.value': { value: 42, type: 'counter' },
+        },
+      });
+
+      expect(output).toContain('42');
+      expect(output).not.toContain('42.00');
+    });
+
+    test('should use box-drawing characters', () => {
+      const output = printDashboard();
+
+      expect(output).toContain('╔');
+      expect(output).toContain('╚');
+      expect(output).toContain('═');
+      expect(output).toContain('║');
+      expect(output).toContain('┌');
+      expect(output).toContain('└');
+      expect(output).toContain('─');
+      expect(output).toContain('│');
+    });
+  });
+
+  describe('generateSummary', () => {
+    test('should generate summary with header', () => {
+      const summary = generateSummary();
+
+      expect(summary).toContain('BYAN v2.0 Summary');
+      expect(summary).toContain('═══');
+    });
+
+    test('should include metrics summary', () => {
+      const summary = generateSummary({
+        metrics: {
+          total: 10,
+          byType: {
+            counter: 5,
+            gauge: 3,
+            timing: 2,
+          },
+        },
+      });
+
+      expect(summary).toContain('Metrics: 10 total');
+      expect(summary).toContain('counter: 5');
+      expect(summary).toContain('gauge: 3');
+      expect(summary).toContain('timing: 2');
+    });
+
+    test('should include logs summary', () => {
+      const summary = generateSummary({
+        logs: {
+          debug: 10,
+          info: 25,
+          warn: 3,
+          error: 1,
+        },
+      });
+
+      expect(summary).toContain('Logs: 39 total');
+      expect(summary).toContain('debug: 10');
+      expect(summary).toContain('info: 25');
+      expect(summary).toContain('warn: 3');
+      expect(summary).toContain('error: 1');
+    });
+
+    test('should handle empty metrics', () => {
+      const summary = generateSummary({ metrics: {} });
+
+      expect(summary).toContain('BYAN v2.0 Summary');
+    });
+
+    test('should handle empty logs', () => {
+      const summary = generateSummary({ logs: {} });
+
+      expect(summary).toContain('BYAN v2.0 Summary');
+    });
+
+    test('should handle null data', () => {
+      const summary = generateSummary(null);
+
+      expect(summary).toContain('BYAN v2.0 Summary');
+    });
+
+    test('should return string type', () => {
+      const summary = generateSummary();
+
+      expect(typeof summary).toBe('string');
+    });
+
+    test('should handle partial metrics data', () => {
+      const summary = generateSummary({
+        metrics: {
+          total: 5,
+          // byType missing
+        },
+      });
+
+      expect(summary).toContain('Metrics: 5 total');
+    });
+
+    test('should handle partial logs data', () => {
+      const summary = generateSummary({
+        logs: {
+          info: 10,
+          error: 2,
+          // debug and warn missing
+        },
+      });
+
+      expect(summary).toContain('Logs: 12 total');
+      expect(summary).toContain('debug: 0');
+      expect(summary).toContain('info: 10');
+      expect(summary).toContain('warn: 0');
+      expect(summary).toContain('error: 2');
+    });
+  });
+
+  describe('Edge Cases', () => {
+    test('should handle special characters in status values', () => {
+      const output = printDashboard({
+        status: {
+          message: 'Status: OK ✓',
+        },
+      });
+
+      expect(output).toContain('Status: OK ✓');
+    });
+
+    test('should handle special characters in log messages', () => {
+      const output = printDashboard({
+        logs: [
+          {
+            level: 'info',
+            message: 'Task completed ✓ 🚀',
+            timestamp: '2025-01-01T00:00:00Z',
+          },
+        ],
+      });
+
+      expect(output).toContain('Task completed');
+    });
+
+    test('should handle numeric worker IDs', () => {
+      const output = printDashboard({
+        workers: [
+          { id: 1, status: 'idle' },
+          { id: 2, status: 'busy' },
+        ],
+      });
+
+      expect(output).toContain('Worker 1');
+      expect(output).toContain('Worker 2');
+    });
+
+    test('should handle undefined values gracefully', () => {
+      const output = printDashboard({
+        status: { key: undefined },
+        metrics: { 'test.metric': { value: undefined } },
+      });
+
+      expect(output).toBeDefined();
+      expect(typeof output).toBe('string');
+    });
+  });
+
+  describe('Integration', () => {
+    test('should display complete dashboard with all sections', () => {
+      const output = printDashboard({
+        status: {
+          version: '2.0.0',
+          uptime: '3600s',
+        },
+        metrics: {
+          'api.calls': { value: 100, type: 'counter' },
+          'cache.hits': { value: 250, type: 'counter' },
+          'request.duration': { value: 150, type: 'timing' },
+        },
+        logs: [
+          { level: 'info', message: 'System started' },
+          { level: 'warn', message: 'High load detected' },
+        ],
+        workers: [
+          { id: '1', status: 'idle' },
+          { id: '2', status: 'busy' },
+        ],
+      });
+
+      // Verify all sections present
+      expect(output).toContain('BYAN v2.0 Dashboard');
+      expect(output).toContain('Status');
+      expect(output).toContain('version');
+      expect(output).toContain('Metrics');
+      expect(output).toContain('api.calls');
+      expect(output).toContain('Recent Logs');
+      expect(output).toContain('System started');
+      expect(output).toContain('Workers');
+      expect(output).toContain('Worker 1');
+    });
+  });
+});

package/__tests__/dispatcher.test.js

@@ -0,0 +1,245 @@
+const EconomicDispatcher = require('../src/core/dispatcher/dispatcher');
+
+describe('EconomicDispatcher', () => {
+  let dispatcher;
+
+  beforeEach(() => {
+    dispatcher = new EconomicDispatcher();
+  });
+
+  describe('dispatch', () => {
+    describe('Haiku tasks (simple/fast)', () => {
+      test('should route "explore" tasks to haiku', () => {
+        expect(dispatcher.dispatch('explore codebase')).toBe('haiku');
+        expect(dispatcher.dispatch('Explore the architecture')).toBe('haiku');
+      });
+
+      test('should route "simple" tasks to haiku', () => {
+        expect(dispatcher.dispatch('simple search operation')).toBe('haiku');
+        expect(dispatcher.dispatch('This is a simple task')).toBe('haiku');
+      });
+
+      test('should route "quick" tasks to haiku', () => {
+        expect(dispatcher.dispatch('quick check of files')).toBe('haiku');
+        expect(dispatcher.dispatch('QUICK validation needed')).toBe('haiku');
+      });
+
+      test('should route "search" and "find" tasks to haiku', () => {
+        expect(dispatcher.dispatch('search for functions')).toBe('haiku');
+        expect(dispatcher.dispatch('find all occurrences')).toBe('haiku');
+        expect(dispatcher.dispatch('list all files')).toBe('haiku');
+      });
+
+      test('should route "read" and "view" tasks to haiku', () => {
+        expect(dispatcher.dispatch('read the configuration')).toBe('haiku');
+        expect(dispatcher.dispatch('view the logs')).toBe('haiku');
+        expect(dispatcher.dispatch('show me the status')).toBe('haiku');
+      });
+    });
+
+    describe('Sonnet tasks (standard/balanced)', () => {
+      test('should route "implement" tasks to sonnet', () => {
+        expect(dispatcher.dispatch('implement new feature')).toBe('sonnet');
+        expect(dispatcher.dispatch('Implement the API endpoint')).toBe('sonnet');
+      });
+
+      test('should route "code" tasks to sonnet', () => {
+        expect(dispatcher.dispatch('code the solution')).toBe('sonnet');
+        expect(dispatcher.dispatch('write code for authentication')).toBe('sonnet');
+      });
+
+      test('should route "complex" tasks to sonnet', () => {
+        expect(dispatcher.dispatch('complex algorithm needed')).toBe('sonnet');
+        expect(dispatcher.dispatch('handle complex logic')).toBe('sonnet');
+      });
+
+      test('should route "develop" and "create" tasks to sonnet', () => {
+        expect(dispatcher.dispatch('develop new module')).toBe('sonnet');
+        expect(dispatcher.dispatch('create the component')).toBe('sonnet');
+        expect(dispatcher.dispatch('build the service')).toBe('sonnet');
+      });
+
+      test('should route "fix" and "refactor" tasks to sonnet', () => {
+        expect(dispatcher.dispatch('fix the bug in parser')).toBe('sonnet');
+        expect(dispatcher.dispatch('refactor legacy code')).toBe('sonnet');
+        expect(dispatcher.dispatch('optimize the algorithm')).toBe('sonnet');
+      });
+    });
+
+    describe('Opus tasks (critical/complex)', () => {
+      test('should route "architect" tasks to opus', () => {
+        expect(dispatcher.dispatch('architect the system')).toBe('opus');
+        expect(dispatcher.dispatch('Architect microservices design')).toBe('opus');
+        expect(dispatcher.dispatch('architectural review needed')).toBe('opus');
+      });
+
+      test('should route "critical" tasks to opus', () => {
+        expect(dispatcher.dispatch('critical security fix')).toBe('opus');
+        expect(dispatcher.dispatch('mission-critical deployment')).toBe('opus');
+      });
+
+      test('should route "review" and "analyze" tasks to opus', () => {
+        expect(dispatcher.dispatch('review the codebase')).toBe('opus');
+        expect(dispatcher.dispatch('analyze performance bottlenecks')).toBe('opus');
+        expect(dispatcher.dispatch('evaluate the design')).toBe('opus');
+      });
+
+      test('should route "security" and "performance" tasks to opus', () => {
+        expect(dispatcher.dispatch('security audit required')).toBe('opus');
+        expect(dispatcher.dispatch('performance optimization strategy')).toBe('opus');
+        expect(dispatcher.dispatch('scalability assessment')).toBe('opus');
+      });
+
+      test('should route "system-design" tasks to opus', () => {
+        expect(dispatcher.dispatch('system-design for new platform')).toBe('opus');
+        expect(dispatcher.dispatch('production deployment plan')).toBe('opus');
+      });
+    });
+
+    describe('edge cases', () => {
+      test('should throw error for invalid task', () => {
+        expect(() => dispatcher.dispatch('')).toThrow('Task must be a non-empty string');
+        expect(() => dispatcher.dispatch(null)).toThrow('Task must be a non-empty string');
+        expect(() => dispatcher.dispatch(123)).toThrow('Task must be a non-empty string');
+      });
+
+      test('should default to sonnet for unclassified tasks', () => {
+        expect(dispatcher.dispatch('random unknown task')).toBe('sonnet');
+        expect(dispatcher.dispatch('xyz abc def')).toBe('sonnet');
+      });
+
+      test('should be case-insensitive', () => {
+        expect(dispatcher.dispatch('EXPLORE CODEBASE')).toBe('haiku');
+        expect(dispatcher.dispatch('Implement Feature')).toBe('sonnet');
+        expect(dispatcher.dispatch('ARCHITECT System')).toBe('opus');
+      });
+
+      test('should prioritize opus over sonnet when both match', () => {
+        // "review" is opus, "code" is sonnet, but opus should win
+        expect(dispatcher.dispatch('review the code')).toBe('opus');
+        expect(dispatcher.dispatch('analyze the implementation')).toBe('opus');
+      });
+
+      test('should prioritize opus over haiku when both match', () => {
+        // "critical" is opus, "quick" is haiku, but opus should win
+        expect(dispatcher.dispatch('critical quick fix')).toBe('opus');
+      });
+
+      test('should handle long task descriptions', () => {
+        const longTask = 'We need to explore the entire codebase and understand how everything works in detail';
+        expect(dispatcher.dispatch(longTask)).toBe('haiku'); // Contains "explore"
+      });
+    });
+  });
+
+  describe('getModelCost', () => {
+    test('should return correct costs for all models', () => {
+      expect(dispatcher.getModelCost('haiku')).toBe(1);
+      expect(dispatcher.getModelCost('sonnet')).toBe(5);
+      expect(dispatcher.getModelCost('opus')).toBe(15);
+    });
+
+    test('should throw error for unknown model', () => {
+      expect(() => dispatcher.getModelCost('unknown')).toThrow('Unknown model: unknown');
+      expect(() => dispatcher.getModelCost('gpt4')).toThrow('Unknown model: gpt4');
+    });
+  });
+
+  describe('compareCosts', () => {
+    test('should compare model costs correctly', () => {
+      expect(dispatcher.compareCosts('haiku', 'sonnet')).toBe(1 / 5);
+      expect(dispatcher.compareCosts('sonnet', 'haiku')).toBe(5);
+      expect(dispatcher.compareCosts('opus', 'haiku')).toBe(15);
+      expect(dispatcher.compareCosts('haiku', 'haiku')).toBe(1);
+    });
+
+    test('should throw error for invalid models', () => {
+      expect(() => dispatcher.compareCosts('invalid', 'haiku')).toThrow();
+      expect(() => dispatcher.compareCosts('haiku', 'invalid')).toThrow();
+    });
+  });
+
+  describe('getAllModels', () => {
+    test('should return all models with costs', () => {
+      const models = dispatcher.getAllModels();
+      expect(models).toEqual({
+        haiku: 1,
+        sonnet: 5,
+        opus: 15
+      });
+    });
+
+    test('should return a copy, not the original', () => {
+      const models = dispatcher.getAllModels();
+      models.haiku = 999;
+      expect(dispatcher.getModelCost('haiku')).toBe(1); // Original unchanged
+    });
+  });
+
+  describe('estimateSavings', () => {
+    test('should calculate savings when using cheaper model', () => {
+      const result = dispatcher.estimateSavings('explore codebase', 'sonnet');
+      expect(result.recommended).toBe('haiku');
+      expect(result.recommendedCost).toBe(1);
+      expect(result.defaultCost).toBe(5);
+      expect(result.savingsPercent).toBe(80); // (5-1)/5 = 80%
+      expect(result.shouldSwitch).toBe(true);
+    });
+
+    test('should calculate negative savings when using more expensive model', () => {
+      const result = dispatcher.estimateSavings('architect system', 'sonnet');
+      expect(result.recommended).toBe('opus');
+      expect(result.recommendedCost).toBe(15);
+      expect(result.defaultCost).toBe(5);
+      expect(result.savingsPercent).toBe(-200); // (5-15)/5 = -200%
+      expect(result.shouldSwitch).toBe(false);
+    });
+
+    test('should calculate zero savings for same model', () => {
+      const result = dispatcher.estimateSavings('implement feature', 'sonnet');
+      expect(result.recommended).toBe('sonnet');
+      expect(result.recommendedCost).toBe(5);
+      expect(result.defaultCost).toBe(5);
+      expect(result.savingsPercent).toBe(0);
+      expect(result.shouldSwitch).toBe(false);
+    });
+
+    test('should use sonnet as default comparison', () => {
+      const result = dispatcher.estimateSavings('quick check');
+      expect(result.defaultCost).toBe(5); // Sonnet
+    });
+  });
+
+  describe('integration scenarios', () => {
+    test('should handle typical workflow tasks', () => {
+      const tasks = [
+        { task: 'explore the codebase structure', expected: 'haiku' },
+        { task: 'implement user authentication', expected: 'sonnet' },
+        { task: 'review security vulnerabilities', expected: 'opus' },
+        { task: 'find all TODO comments', expected: 'haiku' },
+        { task: 'refactor legacy module', expected: 'sonnet' },
+        { task: 'design scalability strategy', expected: 'opus' }
+      ];
+
+      tasks.forEach(({ task, expected }) => {
+        expect(dispatcher.dispatch(task)).toBe(expected);
+      });
+    });
+
+    test('should calculate cost savings for batch operations', () => {
+      const tasks = [
+        'explore files',
+        'quick search',
+        'simple list'
+      ];
+
+      let totalSavings = 0;
+      tasks.forEach(task => {
+        const result = dispatcher.estimateSavings(task, 'sonnet');
+        totalSavings += result.savingsPercent;
+      });
+
+      expect(totalSavings).toBe(240); // 80% * 3 tasks
+    });
+  });
+});