create-byan-agent 2.1.0 → 2.1.1

package/__tests__/dashboard.test.js

@@ -1,444 +0,0 @@
-/**
- * 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

@@ -1,245 +0,0 @@
-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
-    });
-  });
-});