onbuzz 3.4.0 → 3.6.2

package/src/services/__tests__/benchmarkService.test.js

@@ -0,0 +1,184 @@
+import { jest, describe, test, expect, beforeEach, afterEach } from '@jest/globals';
+import { createMockLogger, createMockConfig } from '../../__test-utils__/mockFactories.js';
+
+// We need to mock global fetch and setInterval/setTimeout
+const { default: BenchmarkService } = await import('../benchmarkService.js');
+
+describe('BenchmarkService', () => {
+  let service;
+  let logger;
+  let config;
+  let originalFetch;
+
+  beforeEach(() => {
+    jest.useFakeTimers();
+    logger = createMockLogger();
+    config = { backend: { baseUrl: 'https://test-backend.example.com' } };
+    service = new BenchmarkService(config, logger);
+    originalFetch = global.fetch;
+    global.fetch = jest.fn();
+  });
+
+  afterEach(() => {
+    jest.useRealTimers();
+    global.fetch = originalFetch;
+  });
+
+  test('constructor sets backend URL from config', () => {
+    expect(service.azureBackendUrl).toBe('https://test-backend.example.com');
+  });
+
+  test('constructor uses default URL when config has no backend', () => {
+    const s = new BenchmarkService({}, logger);
+    expect(s.azureBackendUrl).toContain('azurefd.net');
+  });
+
+  test('getBenchmarks returns null and warns when no data', () => {
+    const result = service.getBenchmarks();
+    expect(result).toBeNull();
+    expect(logger.warn).toHaveBeenCalled();
+  });
+
+  test('getBenchmarks returns benchmark text when available', () => {
+    service.benchmarkText = 'some benchmark data';
+    expect(service.getBenchmarks()).toBe('some benchmark data');
+  });
+
+  test('getBenchmarkTable is alias for getBenchmarks', () => {
+    service.benchmarkText = 'table data';
+    expect(service.getBenchmarkTable()).toBe('table data');
+  });
+
+  test('loadBenchmarks skips if already loading', async () => {
+    service.isLoading = true;
+    await service.loadBenchmarks();
+    expect(logger.debug).toHaveBeenCalledWith('Benchmark loading already in progress');
+  });
+
+  test('loadBenchmarks skips if endpoint not available', async () => {
+    service.endpointAvailable = false;
+    await service.loadBenchmarks();
+    expect(global.fetch).not.toHaveBeenCalled();
+  });
+
+  test('loadBenchmarks succeeds with valid response', async () => {
+    global.fetch.mockResolvedValueOnce({
+      ok: true,
+      text: jest.fn().mockResolvedValueOnce('benchmark text data')
+    });
+
+    await service.loadBenchmarks();
+    expect(service.benchmarkText).toBe('benchmark text data');
+    expect(service.lastUpdated).toBeInstanceOf(Date);
+    expect(service.isLoading).toBe(false);
+  });
+
+  test('loadBenchmarks handles 404 by disabling endpoint', async () => {
+    global.fetch.mockResolvedValueOnce({
+      ok: false,
+      status: 404,
+      statusText: 'Not Found'
+    });
+
+    await service.loadBenchmarks();
+    expect(service.endpointAvailable).toBe(false);
+    expect(logger.warn).toHaveBeenCalledWith(expect.stringContaining('404'));
+  });
+
+  test('loadBenchmarks handles non-404 error', async () => {
+    global.fetch.mockResolvedValueOnce({
+      ok: false,
+      status: 500,
+      statusText: 'Internal Server Error'
+    });
+
+    await service.loadBenchmarks();
+    expect(service.endpointAvailable).toBe(true);
+    expect(logger.error).toHaveBeenCalled();
+  });
+
+  test('loadBenchmarks handles empty response', async () => {
+    global.fetch.mockResolvedValueOnce({
+      ok: true,
+      text: jest.fn().mockResolvedValueOnce('')
+    });
+
+    await service.loadBenchmarks();
+    expect(service.benchmarkText).toBeNull();
+    expect(service.isLoading).toBe(false);
+  });
+
+  test('loadBenchmarks handles fetch timeout (AbortError)', async () => {
+    const abortError = new Error('Aborted');
+    abortError.name = 'AbortError';
+    global.fetch.mockRejectedValueOnce(abortError);
+
+    await service.loadBenchmarks();
+    expect(logger.error).toHaveBeenCalled();
+    expect(service.isLoading).toBe(false);
+  });
+
+  test('loadBenchmarks includes auth header when apiKey configured', async () => {
+    service.config = { apiKey: 'test-api-key' };
+    global.fetch.mockResolvedValueOnce({
+      ok: true,
+      text: jest.fn().mockResolvedValueOnce('data')
+    });
+
+    await service.loadBenchmarks();
+    const fetchCall = global.fetch.mock.calls[0];
+    expect(fetchCall[1].headers.Authorization).toBe('Bearer test-api-key');
+  });
+
+  test('needsRefresh returns true when never updated', () => {
+    expect(service.needsRefresh()).toBe(true);
+  });
+
+  test('needsRefresh returns false shortly after update', () => {
+    service.lastUpdated = new Date();
+    expect(service.needsRefresh()).toBe(false);
+  });
+
+  test('initialize loads benchmarks and schedules refresh', async () => {
+    global.fetch.mockResolvedValueOnce({
+      ok: true,
+      text: jest.fn().mockResolvedValueOnce('initial data')
+    });
+
+    await service.initialize();
+    expect(service.benchmarkText).toBe('initial data');
+    expect(logger.info).toHaveBeenCalledWith('Benchmark service initialized');
+  });
+
+  test('initialize handles errors', async () => {
+    global.fetch.mockRejectedValueOnce(new Error('network fail'));
+    await service.initialize();
+    expect(service.benchmarkText).toBeNull();
+    expect(logger.error).toHaveBeenCalled();
+  });
+
+  test('forceRefresh calls loadBenchmarks', async () => {
+    global.fetch.mockResolvedValueOnce({
+      ok: true,
+      text: jest.fn().mockResolvedValueOnce('refreshed')
+    });
+    await service.forceRefresh();
+    expect(service.benchmarkText).toBe('refreshed');
+  });
+
+  test('getStatus returns service status', () => {
+    service.benchmarkText = 'data';
+    service.lastUpdated = new Date('2024-01-01');
+    const status = service.getStatus();
+    expect(status.initialized).toBe(true);
+    expect(status.hasData).toBe(true);
+    expect(status.lastUpdated).toBe('2024-01-01T00:00:00.000Z');
+    expect(status.isLoading).toBe(false);
+  });
+
+  test('getStatus when no data', () => {
+    const status = service.getStatus();
+    expect(status.initialized).toBe(false);
+    expect(status.lastUpdated).toBeNull();
+  });
+});

package/src/services/__tests__/budgetService.test.js

@@ -0,0 +1,211 @@
+import { jest, describe, test, expect, beforeEach } from '@jest/globals';
+import { createMockLogger, createMockConfig } from '../../__test-utils__/mockFactories.js';
+
+// Mock constants to avoid loading the full module
+jest.unstable_mockModule('../../utilities/constants.js', () => ({
+  BUDGET_LIMITS: { DAILY: 10, WEEKLY: 50, MONTHLY: 200 },
+  USAGE_ALERTS: { THRESHOLDS: [50, 75, 90, 100], COOLDOWN_PERIOD: 3600000 }
+}));
+
+const { BudgetService } = await import('../budgetService.js');
+
+describe('BudgetService', () => {
+  let service;
+  let mockLogger;
+  let mockConfig;
+  let mockModelsService;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    mockLogger = createMockLogger();
+    mockConfig = createMockConfig();
+    mockConfig.budgets = { daily: 10, weekly: 50, monthly: 200 };
+
+    mockModelsService = {
+      getModels: jest.fn().mockReturnValue([
+        {
+          name: 'gpt-4',
+          pricing: { input: 0.03, output: 0.06 }
+        },
+        {
+          name: 'claude-3-haiku',
+          pricing: { input: 0.00025, output: 0.00125 }
+        }
+      ])
+    };
+
+    service = new BudgetService(mockConfig, mockLogger, mockModelsService);
+  });
+
+  // ───── Cost Calculation ─────
+
+  describe('calculateCost', () => {
+    test('returns 0 for zero tokens', () => {
+      const cost = service.calculateCost('gpt-4', {
+        prompt_tokens: 0,
+        completion_tokens: 0,
+        total_tokens: 0
+      });
+
+      expect(cost).toBe(0);
+    });
+
+    test('returns positive number for non-zero tokens', () => {
+      const cost = service.calculateCost('gpt-4', {
+        prompt_tokens: 1000,
+        completion_tokens: 500,
+        total_tokens: 1500
+      });
+
+      expect(cost).toBeGreaterThan(0);
+    });
+
+    test('uses model-specific pricing when available', () => {
+      // gpt-4 pricing: input 0.03/1K, output 0.06/1K
+      const cost = service.calculateCost('gpt-4', {
+        prompt_tokens: 1000,
+        completion_tokens: 1000,
+        total_tokens: 2000
+      });
+
+      // Expected: (1000 * 0.03/1000) + (1000 * 0.06/1000) = 0.03 + 0.06 = 0.09
+      expect(cost).toBeCloseTo(0.09, 5);
+    });
+
+    test('uses default pricing (returns 0) for unknown models', () => {
+      const cost = service.calculateCost('unknown-model-xyz', {
+        prompt_tokens: 1000,
+        completion_tokens: 500,
+        total_tokens: 1500
+      });
+
+      // No pricing found -> returns 0
+      expect(cost).toBe(0);
+    });
+  });
+
+  // ───── Usage Tracking ─────
+
+  describe('trackUsage', () => {
+    test('increments daily usage', () => {
+      service.trackUsage('agent-1', 'gpt-4', {
+        prompt_tokens: 100,
+        completion_tokens: 50,
+        total_tokens: 150
+      });
+
+      const dayKey = service.getDayKey(new Date());
+      const dailyUsage = service.usage.daily.get(dayKey);
+
+      expect(dailyUsage).toBeDefined();
+      expect(dailyUsage.tokens).toBe(150);
+      expect(dailyUsage.requests).toBe(1);
+    });
+
+    test('tracks per-agent usage', () => {
+      service.trackUsage('agent-1', 'gpt-4', {
+        prompt_tokens: 100,
+        completion_tokens: 50,
+        total_tokens: 150
+      });
+
+      const dayKey = service.getDayKey(new Date());
+      const dailyUsage = service.usage.daily.get(dayKey);
+
+      expect(dailyUsage.byAgent['agent-1']).toBeDefined();
+      expect(dailyUsage.byAgent['agent-1'].tokens).toBe(150);
+      expect(dailyUsage.byAgent['agent-1'].requests).toBe(1);
+    });
+
+    test('tracks per-model usage', () => {
+      service.trackUsage('agent-1', 'claude-3-haiku', {
+        prompt_tokens: 200,
+        completion_tokens: 100,
+        total_tokens: 300
+      });
+
+      const dayKey = service.getDayKey(new Date());
+      const dailyUsage = service.usage.daily.get(dayKey);
+
+      expect(dailyUsage.byModel['claude-3-haiku']).toBeDefined();
+      expect(dailyUsage.byModel['claude-3-haiku'].tokens).toBe(300);
+    });
+
+    test('multiple calls accumulate correctly', () => {
+      service.trackUsage('agent-1', 'gpt-4', {
+        prompt_tokens: 100, completion_tokens: 50, total_tokens: 150
+      });
+      service.trackUsage('agent-2', 'gpt-4', {
+        prompt_tokens: 200, completion_tokens: 100, total_tokens: 300
+      });
+      service.trackUsage('agent-1', 'gpt-4', {
+        prompt_tokens: 50, completion_tokens: 25, total_tokens: 75
+      });
+
+      expect(service.usage.total.tokens).toBe(525);
+      expect(service.usage.total.requests).toBe(3);
+
+      const dayKey = service.getDayKey(new Date());
+      const dailyUsage = service.usage.daily.get(dayKey);
+      expect(dailyUsage.tokens).toBe(525);
+      expect(dailyUsage.requests).toBe(3);
+
+      // agent-1 should have accumulated across two calls
+      expect(dailyUsage.byAgent['agent-1'].tokens).toBe(225);
+      expect(dailyUsage.byAgent['agent-1'].requests).toBe(2);
+    });
+  });
+
+  // ───── Budget Checking ─────
+
+  describe('budget checking', () => {
+    test('isWithinBudget returns true when under limit', () => {
+      // No usage tracked yet, so well under limit
+      expect(service.isWithinBudget('daily')).toBe(true);
+    });
+
+    test('isWithinBudget returns false when over daily limit', () => {
+      // Force daily usage above the $10 limit
+      const dayKey = service.getDayKey(new Date());
+      service.usage.daily.set(dayKey, {
+        cost: 15,
+        tokens: 100000,
+        requests: 50,
+        byAgent: {},
+        byModel: {}
+      });
+
+      expect(service.isWithinBudget('daily')).toBe(false);
+    });
+
+    test('getRemainingBudget decreases after usage', () => {
+      const before = service.getRemainingBudget();
+      expect(before.daily).toBe(10);
+
+      // Track some usage that has cost
+      service.trackUsage('agent-1', 'gpt-4', {
+        prompt_tokens: 1000,
+        completion_tokens: 1000,
+        total_tokens: 2000
+      });
+
+      const after = service.getRemainingBudget();
+      expect(after.daily).toBeLessThan(before.daily);
+    });
+
+    test('setBudgets with custom values overrides defaults', () => {
+      service.setBudgets({ daily: 25, weekly: 100, monthly: 500 });
+
+      expect(service.budgets.daily).toBe(25);
+      expect(service.budgets.weekly).toBe(100);
+      expect(service.budgets.monthly).toBe(500);
+
+      // Remaining budget should reflect new limits
+      const remaining = service.getRemainingBudget();
+      expect(remaining.daily).toBe(25);
+      expect(remaining.weekly).toBe(100);
+      expect(remaining.monthly).toBe(500);
+    });
+  });
+});

package/src/services/__tests__/contextInjectionService.test.js

@@ -0,0 +1,205 @@
+import { jest, describe, test, expect, beforeEach } from '@jest/globals';
+import { createMockLogger, createMockConfig } from '../../__test-utils__/mockFactories.js';
+
+// Mock FileAttachmentService and serviceRegistry
+jest.unstable_mockModule('../fileAttachmentService.js', () => ({
+  default: jest.fn().mockImplementation(() => ({
+    initialize: jest.fn().mockResolvedValue(undefined),
+    getActiveAttachments: jest.fn().mockResolvedValue([]),
+    getAttachmentContent: jest.fn().mockResolvedValue(null)
+  }))
+}));
+
+jest.unstable_mockModule('../serviceRegistry.js', () => ({
+  default: {
+    getAll: jest.fn(() => ({}))
+  }
+}));
+
+const { default: ContextInjectionService } = await import('../contextInjectionService.js');
+const { default: registry } = await import('../serviceRegistry.js');
+
+describe('ContextInjectionService', () => {
+  let service;
+  let logger;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    logger = createMockLogger();
+    service = new ContextInjectionService({}, logger);
+  });
+
+  test('initialize delegates to attachmentService', async () => {
+    await service.initialize();
+    expect(service.attachmentService.initialize).toHaveBeenCalled();
+  });
+
+  test('buildDynamicContext returns empty string when no attachments', async () => {
+    service.attachmentService.getActiveAttachments.mockResolvedValue([]);
+    const result = await service.buildDynamicContext('agent-1');
+    expect(result).toBe('');
+  });
+
+  test('buildDynamicContext builds content file section', async () => {
+    service.attachmentService.getActiveAttachments.mockResolvedValue([
+      { fileId: 'f1', fileName: 'test.txt', mode: 'content', contentType: 'text', fileType: 'text/plain', size: 1024 }
+    ]);
+    service.attachmentService.getAttachmentContent.mockResolvedValue('file content here');
+
+    const result = await service.buildDynamicContext('agent-1');
+    expect(result).toContain('<attached-files>');
+    expect(result).toContain('</attached-files>');
+    expect(result).toContain('file content here');
+  });
+
+  test('buildDynamicContext builds reference file section', async () => {
+    service.attachmentService.getActiveAttachments.mockResolvedValue([
+      { fileId: 'f2', fileName: 'ref.js', mode: 'reference', fileType: 'text/javascript', size: 2048, originalPath: '/path/to/ref.js', lastModified: '2024-01-01T00:00:00Z' }
+    ]);
+
+    const result = await service.buildDynamicContext('agent-1');
+    expect(result).toContain('<file-references>');
+    expect(result).toContain('</file-references>');
+    expect(result).toContain('ref.js');
+    expect(result).toContain('filesystem tool');
+  });
+
+  test('buildDynamicContext skips content files with null content', async () => {
+    service.attachmentService.getActiveAttachments.mockResolvedValue([
+      { fileId: 'f1', fileName: 'test.txt', mode: 'content', contentType: 'text', fileType: 'text/plain', size: 512 }
+    ]);
+    service.attachmentService.getAttachmentContent.mockResolvedValue(null);
+
+    const result = await service.buildDynamicContext('agent-1');
+    expect(result).toContain('<attached-files>');
+    expect(result).not.toContain('test.txt');
+  });
+
+  test('buildDynamicContext handles errors and returns empty string', async () => {
+    service.attachmentService.getActiveAttachments.mockRejectedValue(new Error('fail'));
+    const result = await service.buildDynamicContext('agent-1');
+    expect(result).toBe('');
+    expect(logger.error).toHaveBeenCalled();
+  });
+
+  test('formatContentFile handles text content type', () => {
+    const result = service.formatContentFile(
+      { fileName: 'test.txt', fileType: 'text/plain', size: 1024, contentType: 'text' },
+      'hello world'
+    );
+    expect(result).toContain('test.txt');
+    expect(result).toContain('hello world');
+    expect(result).toContain('1.00KB');
+  });
+
+  test('formatContentFile handles image content type', () => {
+    const result = service.formatContentFile(
+      { fileName: 'img.png', fileType: 'image/png', size: 2048, contentType: 'image' },
+      'data:image/png;base64,abc'
+    );
+    expect(result).toContain('img.png');
+    expect(result).toContain('base64');
+  });
+
+  test('formatContentFile handles pdf content type', () => {
+    const result = service.formatContentFile(
+      { fileName: 'doc.pdf', fileType: 'application/pdf', size: 4096, contentType: 'pdf' },
+      'extracted text'
+    );
+    expect(result).toContain('doc.pdf');
+    expect(result).toContain('extracted text');
+  });
+
+  test('formatContentFile uses fallback for unknown content type', () => {
+    const result = service.formatContentFile(
+      { fileName: 'data.bin', fileType: 'application/octet-stream', size: 512, contentType: 'binary' },
+      'raw data'
+    );
+    expect(result).toContain('data.bin');
+    expect(result).toContain('raw data');
+  });
+
+  test('formatReferenceFile returns formatted XML tag', () => {
+    const result = service.formatReferenceFile({
+      fileName: 'ref.js',
+      originalPath: '/src/ref.js',
+      size: 2048,
+      fileType: 'text/javascript',
+      lastModified: '2024-06-15T12:00:00Z'
+    });
+    expect(result).toContain('ref.js');
+    expect(result).toContain('/src/ref.js');
+    expect(result).toContain('2024-06-15');
+  });
+
+  test('escapeXml escapes special characters', () => {
+    expect(service.escapeXml('a&b<c>d"e\'f')).toBe('a&amp;b&lt;c&gt;d&quot;e&apos;f');
+    expect(service.escapeXml(null)).toBe('');
+    expect(service.escapeXml('')).toBe('');
+  });
+
+  test('formatBytes handles various sizes', () => {
+    expect(service.formatBytes(0)).toBe('0 Bytes');
+    expect(service.formatBytes(500)).toContain('Bytes');
+    expect(service.formatBytes(1024)).toContain('KB');
+    expect(service.formatBytes(1048576)).toContain('MB');
+  });
+
+  test('estimateTotalTokens sums content tokens and reference overhead', async () => {
+    service.attachmentService.getActiveAttachments.mockResolvedValue([
+      { mode: 'content', tokenEstimate: 100 },
+      { mode: 'content', tokenEstimate: 200 },
+      { mode: 'reference' }
+    ]);
+    const total = await service.estimateTotalTokens('agent-1');
+    expect(total).toBe(320); // 100 + 200 + 20
+  });
+
+  test('estimateTotalTokens handles error', async () => {
+    service.attachmentService.getActiveAttachments.mockRejectedValue(new Error('fail'));
+    const total = await service.estimateTotalTokens('agent-1');
+    expect(total).toBe(0);
+  });
+
+  test('getAttachmentSummary returns summary object', async () => {
+    service.attachmentService.getActiveAttachments.mockResolvedValue([
+      { fileName: 'a.txt', mode: 'content', size: 1024, tokenEstimate: 50 },
+      { fileName: 'b.js', mode: 'reference', size: 2048, tokenEstimate: 0 }
+    ]);
+    const summary = await service.getAttachmentSummary('agent-1');
+    expect(summary.totalActive).toBe(2);
+    expect(summary.contentMode).toBe(1);
+    expect(summary.referenceMode).toBe(1);
+    expect(summary.files).toHaveLength(2);
+  });
+
+  test('getAttachmentSummary handles error with defaults', async () => {
+    service.attachmentService.getActiveAttachments.mockRejectedValue(new Error('fail'));
+    const summary = await service.getAttachmentSummary('agent-1');
+    expect(summary.totalActive).toBe(0);
+    expect(summary.files).toEqual([]);
+  });
+
+  test('buildSystemConstraints returns port constraint string', () => {
+    registry.getAll.mockReturnValue({
+      web: { port: 3000 },
+      api: { port: 8080 }
+    });
+    const result = service.buildSystemConstraints();
+    expect(result).toContain('3000');
+    expect(result).toContain('8080');
+    expect(result).toContain('never kill');
+  });
+
+  test('buildSystemConstraints returns empty when no ports', () => {
+    registry.getAll.mockReturnValue({});
+    const result = service.buildSystemConstraints();
+    expect(result).toBe('');
+  });
+
+  test('buildSystemConstraints handles errors gracefully', () => {
+    registry.getAll.mockImplementation(() => { throw new Error('fail'); });
+    const result = service.buildSystemConstraints();
+    expect(result).toBe('');
+  });
+});