onbuzz 3.4.0 → 3.6.2

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

@@ -0,0 +1,123 @@
+import { jest, describe, test, expect, beforeEach } from '@jest/globals';
+
+const fsMock = {
+  readFile: jest.fn(),
+  writeFile: jest.fn().mockResolvedValue(undefined),
+  mkdir: jest.fn().mockResolvedValue(undefined),
+  rename: jest.fn().mockResolvedValue(undefined),
+  unlink: jest.fn().mockResolvedValue(undefined),
+  stat: jest.fn()
+};
+
+jest.unstable_mockModule('fs', () => ({
+  promises: fsMock
+}));
+
+jest.unstable_mockModule('../../utilities/userDataDir.js', () => ({
+  getUserDataPaths: jest.fn().mockReturnValue({
+    runtime: '/tmp/test-runtime',
+    config: '/tmp/test-config'
+  })
+}));
+
+const { PortRegistry, getPortRegistry } = await import('../portRegistry.js');
+
+describe('PortRegistry', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    // Return empty registry by default (ENOENT simulates first run)
+    fsMock.readFile.mockRejectedValue(Object.assign(new Error('ENOENT'), { code: 'ENOENT' }));
+  });
+
+  test('constructor creates instance', () => {
+    const registry = new PortRegistry();
+    expect(registry).toBeInstanceOf(PortRegistry);
+    expect(registry._initialized).toBe(false);
+  });
+
+  test('getPortRegistry returns singleton (same instance)', () => {
+    // Note: singleton is module-scoped, so both calls return the same instance
+    const a = getPortRegistry();
+    const b = getPortRegistry();
+    expect(a).toBe(b);
+    expect(a).toBeInstanceOf(PortRegistry);
+  });
+
+  test('registerService stores service info with port', async () => {
+    const registry = new PortRegistry();
+    const result = await registry.registerService('backend', { port: 3000 });
+
+    expect(result).toBeDefined();
+    expect(result.port).toBe(3000);
+    expect(result.host).toBe('localhost');
+    expect(result.protocol).toBe('http');
+    expect(fsMock.writeFile).toHaveBeenCalled();
+  });
+
+  test('getService returns registered service', async () => {
+    const registry = new PortRegistry();
+
+    // First register
+    await registry.registerService('api', { port: 8080 });
+
+    // Mock readFile to return the saved data
+    const savedData = JSON.stringify({
+      version: 1,
+      lastUpdated: new Date().toISOString(),
+      services: {
+        api: { port: 8080, host: 'localhost', protocol: 'http', pid: process.pid, startedAt: new Date().toISOString(), metadata: {} }
+      }
+    });
+    fsMock.readFile.mockResolvedValue(savedData);
+
+    const service = await registry.getService('api');
+    expect(service).toBeDefined();
+    expect(service.port).toBe(8080);
+  });
+
+  test('getService returns null for unknown name', async () => {
+    const registry = new PortRegistry();
+    const service = await registry.getService('nonexistent');
+    expect(service).toBeNull();
+  });
+
+  test('unregisterService removes service', async () => {
+    const registry = new PortRegistry();
+
+    // Mock a registry with a service
+    const savedData = JSON.stringify({
+      version: 1,
+      lastUpdated: new Date().toISOString(),
+      services: {
+        myservice: { port: 4000, host: 'localhost', protocol: 'http', pid: process.pid, startedAt: new Date().toISOString(), metadata: {} }
+      }
+    });
+    fsMock.readFile.mockResolvedValue(savedData);
+
+    const result = await registry.unregisterService('myservice');
+    expect(result).toBe(true);
+  });
+
+  test('getServiceUrl builds URL from protocol/host/port', async () => {
+    const registry = new PortRegistry();
+
+    const savedData = JSON.stringify({
+      version: 1,
+      lastUpdated: new Date().toISOString(),
+      services: {
+        web: { port: 443, host: 'example.com', protocol: 'https', pid: process.pid, startedAt: new Date().toISOString(), metadata: {} }
+      }
+    });
+    fsMock.readFile.mockResolvedValue(savedData);
+
+    const url = await registry.getServiceUrl('web');
+    expect(url).toBe('https://example.com:443');
+  });
+
+  test('isProcessRunning returns boolean (test with current process.pid)', () => {
+    const registry = new PortRegistry();
+    const running = registry.isProcessRunning(process.pid);
+    expect(typeof running).toBe('boolean');
+    expect(running).toBe(true);
+  });
+});

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

@@ -0,0 +1,34 @@
+import { jest, describe, test, expect, beforeEach } from '@jest/globals';
+import ProjectDetector, { getProjectDetector, PROJECT_TYPES } from '../projectDetector.js';
+
+describe('ProjectDetector', () => {
+  test('constructor creates instance', () => {
+    const detector = new ProjectDetector();
+    expect(detector).toBeInstanceOf(ProjectDetector);
+  });
+
+  test('getProjectDetector returns a ProjectDetector instance (singleton)', () => {
+    const detector1 = getProjectDetector();
+    const detector2 = getProjectDetector();
+    expect(detector1).toBeInstanceOf(ProjectDetector);
+    expect(detector1).toBe(detector2);
+  });
+
+  test('PROJECT_TYPES has expected values', () => {
+    expect(PROJECT_TYPES.REACT_CRA).toBe('react-cra');
+    expect(PROJECT_TYPES.NEXTJS).toBe('nextjs');
+    expect(PROJECT_TYPES.STATIC_HTML).toBe('static-html');
+    expect(PROJECT_TYPES.UNKNOWN).toBe('unknown');
+    expect(PROJECT_TYPES.ANGULAR).toBe('angular');
+    expect(PROJECT_TYPES.VUE_VITE).toBe('vue-vite');
+  });
+
+  test('detect returns object with projectType property', async () => {
+    const detector = new ProjectDetector();
+    const result = await detector.detect(process.cwd());
+    expect(result).toHaveProperty('projectType');
+    expect(result).toHaveProperty('projectDir');
+    expect(result).toHaveProperty('entryPoints');
+    expect(typeof result.projectType).toBe('string');
+  });
+});

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

@@ -0,0 +1,242 @@
+import { jest, describe, test, expect, beforeEach, afterEach } from '@jest/globals';
+import { createMockLogger } from '../../__test-utils__/mockFactories.js';
+
+const { PromptService, getPromptService } = await import('../promptService.js');
+
+describe('PromptService', () => {
+  let service;
+  let logger;
+
+  beforeEach(() => {
+    jest.useFakeTimers();
+    logger = createMockLogger();
+    service = new PromptService(logger);
+  });
+
+  afterEach(() => {
+    // Don't call clearAll() — it rejects pending promises which crashes Node
+    // Instead just clear internal state directly
+    if (service.pendingRequests) service.pendingRequests.clear();
+    if (service.requestHistory) service.requestHistory.length = 0;
+    jest.useRealTimers();
+  });
+
+  test('constructor initializes with empty state', () => {
+    expect(service.pendingRequests.size).toBe(0);
+    expect(service.requestHistory).toEqual([]);
+  });
+
+  test('_generateRequestId returns unique IDs', () => {
+    const id1 = service._generateRequestId();
+    const id2 = service._generateRequestId();
+    expect(id1).toMatch(/^prompt-/);
+    expect(id1).not.toBe(id2);
+  });
+
+  test('createPromptRequest creates a pending request with promise', () => {
+    const { requestInfo, promise } = service.createPromptRequest('agent-1', {
+      message: 'Choose an option',
+      questions: [{ message: 'Pick one', options: ['A', 'B'] }]
+    });
+
+    expect(requestInfo.agentId).toBe('agent-1');
+    expect(requestInfo.questions).toHaveLength(1);
+    expect(requestInfo.message).toBe('Choose an option');
+    expect(promise).toBeInstanceOf(Promise);
+    expect(service.pendingRequests.size).toBe(1);
+  });
+
+  test('createPromptRequest normalizes questions with defaults', () => {
+    const { requestInfo } = service.createPromptRequest('agent-1', {
+      questions: [{ question: 'What color?', options: ['red', 'blue'] }]
+    });
+
+    const q = requestInfo.questions[0];
+    expect(q.id).toBe('q1');
+    expect(q.message).toBe('What color?');
+    expect(q.options[0].label).toBe('red');
+    expect(q.allowFreeText).toBe(true);
+    expect(q.required).toBe(true);
+    expect(q.multiSelect).toBe(false);
+  });
+
+  test('createPromptRequest normalizes option objects', () => {
+    const { requestInfo } = service.createPromptRequest('agent-1', {
+      questions: [{
+        message: 'Q',
+        options: [{ id: 'o1', label: 'Option 1', description: 'Desc' }]
+      }]
+    });
+
+    const opt = requestInfo.questions[0].options[0];
+    expect(opt.id).toBe('o1');
+    expect(opt.label).toBe('Option 1');
+    expect(opt.description).toBe('Desc');
+  });
+
+  test('createPromptRequest wraps single prompt as questions array', () => {
+    const { requestInfo } = service.createPromptRequest('agent-1', {
+      message: 'Pick an option'
+    });
+    expect(requestInfo.questions).toHaveLength(1);
+    expect(requestInfo.questions[0].message).toBe('Pick an option');
+  });
+
+  test('submitResponse resolves the promise and removes from pending', async () => {
+    const { requestInfo, promise } = service.createPromptRequest('agent-1', {
+      questions: [{ message: 'Q' }]
+    });
+
+    const response = { answers: [{ questionId: 'q1', freeText: 'My answer' }] };
+    const result = service.submitResponse(requestInfo.requestId, response);
+
+    expect(result.success).toBe(true);
+    expect(service.pendingRequests.size).toBe(0);
+
+    const resolved = await promise;
+    expect(resolved.success).toBe(true);
+    expect(resolved.response).toBe(response);
+  });
+
+  test('submitResponse returns error for unknown request', () => {
+    const result = service.submitResponse('unknown-id', {});
+    expect(result.success).toBe(false);
+    expect(result.error).toContain('not found');
+  });
+
+  test('cancelRequest rejects the promise', async () => {
+    const { requestInfo, promise } = service.createPromptRequest('agent-1', {
+      questions: [{ message: 'Q' }]
+    });
+
+    const result = service.cancelRequest(requestInfo.requestId, 'test cancel');
+    expect(result.success).toBe(true);
+
+    await expect(promise).rejects.toThrow('cancelled');
+  });
+
+  test('cancelRequest returns error for unknown request', () => {
+    const result = service.cancelRequest('unknown-id');
+    expect(result.success).toBe(false);
+  });
+
+  test('timeout rejects the promise', async () => {
+    const { requestInfo, promise } = service.createPromptRequest('agent-1', {
+      questions: [{ message: 'Q' }]
+    }, { timeout: 1000 });
+
+    jest.advanceTimersByTime(1500);
+
+    await expect(promise).rejects.toThrow('timed out');
+    expect(service.pendingRequests.size).toBe(0);
+  });
+
+  test('timeout is no-op for already resolved request', () => {
+    const { requestInfo } = service.createPromptRequest('agent-1', {
+      questions: [{ message: 'Q' }]
+    });
+    service.submitResponse(requestInfo.requestId, { answers: [] });
+
+    // Timeout handler should not throw
+    service._handleTimeout(requestInfo.requestId);
+  });
+
+  test('_addToHistory trims when exceeding max size', () => {
+    service.maxHistorySize = 3;
+    for (let i = 0; i < 5; i++) {
+      service._addToHistory({ id: i });
+    }
+    expect(service.requestHistory).toHaveLength(3);
+    expect(service.requestHistory[0].id).toBe(2);
+  });
+
+  test('getPendingRequest returns info or null', () => {
+    const { requestInfo } = service.createPromptRequest('agent-1', {
+      questions: [{ message: 'Q' }]
+    });
+    expect(service.getPendingRequest(requestInfo.requestId)).toBeTruthy();
+    expect(service.getPendingRequest('unknown')).toBeNull();
+  });
+
+  test('getPendingRequestsForAgent returns requests for agent', () => {
+    service.createPromptRequest('agent-1', { questions: [{ message: 'Q1' }] });
+    service.createPromptRequest('agent-1', { questions: [{ message: 'Q2' }] });
+    service.createPromptRequest('agent-2', { questions: [{ message: 'Q3' }] });
+
+    const results = service.getPendingRequestsForAgent('agent-1');
+    expect(results).toHaveLength(2);
+  });
+
+  test('hasPendingPrompts returns true/false', () => {
+    expect(service.hasPendingPrompts('agent-1')).toBe(false);
+    service.createPromptRequest('agent-1', { questions: [{ message: 'Q' }] });
+    expect(service.hasPendingPrompts('agent-1')).toBe(true);
+    expect(service.hasPendingPrompts('agent-2')).toBe(false);
+  });
+
+  test('getHistory returns last N records', () => {
+    for (let i = 0; i < 10; i++) {
+      service._addToHistory({ id: i });
+    }
+    const recent = service.getHistory(3);
+    expect(recent).toHaveLength(3);
+    expect(recent[0].id).toBe(7);
+  });
+
+  test('clearAll rejects all pending and clears', async () => {
+    const { promise: p1 } = service.createPromptRequest('agent-1', { questions: [{ message: 'Q' }] });
+    const { promise: p2 } = service.createPromptRequest('agent-2', { questions: [{ message: 'Q' }] });
+
+    service.clearAll();
+
+    await expect(p1).rejects.toThrow('shutdown');
+    await expect(p2).rejects.toThrow('shutdown');
+    expect(service.pendingRequests.size).toBe(0);
+  });
+
+  test('formatResponseAsMessage formats answers', () => {
+    const requestInfo = {
+      message: 'Please answer:',
+      questions: [
+        { id: 'q1', message: 'Color?', options: [{ id: 'o1', label: 'Red' }] }
+      ]
+    };
+    const response = {
+      answers: [
+        { questionId: 'q1', selectedOptions: ['o1'], freeText: 'I like red', webSearchRequested: true }
+      ]
+    };
+
+    const msg = service.formatResponseAsMessage(requestInfo, response);
+    expect(msg).toContain('**Context:** Please answer:');
+    expect(msg).toContain('**Q: Color?**');
+    expect(msg).toContain('Red');
+    expect(msg).toContain('"I like red"');
+    expect(msg).toContain('Web search');
+  });
+
+  test('formatResponseAsMessage handles missing question match', () => {
+    const requestInfo = { questions: [] };
+    const response = {
+      answers: [{ questionId: 'q99', selectedOptions: [] }]
+    };
+    const msg = service.formatResponseAsMessage(requestInfo, response);
+    expect(msg).toContain('Question q99');
+  });
+
+  test('formatResponseAsMessage handles no message context', () => {
+    const requestInfo = { questions: [{ id: 'q1', message: 'Q' }] };
+    const response = { answers: [] };
+    const msg = service.formatResponseAsMessage(requestInfo, response);
+    expect(msg).not.toContain('Context');
+  });
+});
+
+describe('getPromptService singleton', () => {
+  test('returns same instance on multiple calls', () => {
+    // Note: the singleton is already created from the module,
+    // but we can verify function exists and returns a PromptService
+    const s = getPromptService();
+    expect(s).toBeInstanceOf(PromptService);
+  });
+});

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

@@ -0,0 +1,97 @@
+import { jest, describe, test, expect, beforeEach, afterEach } from '@jest/globals';
+
+// Mock logger since qualityInspector imports { logger } which doesn't exist as named export
+jest.unstable_mockModule('../../utilities/logger.js', () => ({
+  logger: { info: jest.fn(), warn: jest.fn(), error: jest.fn(), debug: jest.fn() },
+  Logger: jest.fn(),
+  createLogger: jest.fn()
+}));
+
+const { QualityInspector } = await import('../qualityInspector.js');
+
+describe('QualityInspector', () => {
+  let inspector;
+  let mockOrchestrator;
+
+  beforeEach(() => {
+    mockOrchestrator = {
+      sendMessage: jest.fn().mockResolvedValue(undefined),
+      sendSystemMessage: jest.fn().mockResolvedValue(undefined),
+      pauseAgent: jest.fn().mockResolvedValue(undefined)
+    };
+    inspector = new QualityInspector(mockOrchestrator);
+  });
+
+  afterEach(() => {
+    inspector.stop();
+  });
+
+  test('constructor creates instance', () => {
+    expect(inspector).toBeDefined();
+    expect(inspector.isRunning).toBe(false);
+  });
+
+  test('start begins monitoring', () => {
+    inspector.start();
+    expect(inspector.isRunning).toBe(true);
+  });
+
+  test('stop stops monitoring', () => {
+    inspector.start();
+    expect(inspector.isRunning).toBe(true);
+    inspector.stop();
+    expect(inspector.isRunning).toBe(false);
+  });
+
+  test('recordActivity stores activity for agent', () => {
+    inspector.start();
+    inspector.recordActivity('agent-1', { type: 'command', content: 'ls' });
+
+    const data = inspector.monitoringData.get('agent-1');
+    expect(data).toBeDefined();
+    expect(data.activityHistory.length).toBe(1);
+    expect(data.messageCount).toBe(1);
+  });
+
+  test('recordActivity does nothing when not running', () => {
+    inspector.recordActivity('agent-1', { type: 'command', content: 'ls' });
+    expect(inspector.monitoringData.has('agent-1')).toBe(false);
+  });
+
+  test('getMetrics returns metrics object', () => {
+    const metrics = inspector.getMetrics();
+    expect(metrics).toHaveProperty('totalInterventions');
+    expect(metrics).toHaveProperty('isRunning');
+    expect(typeof metrics.agentsMonitored).toBe('number');
+  });
+
+  test('generateOptimizationSuggestion returns string for slow_response', () => {
+    const suggestion = inspector.generateOptimizationSuggestion({ type: 'slow_response' });
+    expect(typeof suggestion).toBe('string');
+    expect(suggestion.length).toBeGreaterThan(0);
+  });
+
+  test('recordActivity caps history at 100', () => {
+    inspector.start();
+    for (let i = 0; i < 120; i++) {
+      inspector.recordActivity('agent-1', { type: 'command', content: `cmd-${i}` });
+    }
+    const data = inspector.monitoringData.get('agent-1');
+    expect(data.activityHistory.length).toBeLessThanOrEqual(100);
+    expect(data.messageCount).toBe(120);
+  });
+
+  test('getAgentReport returns null for unmonitored agent', () => {
+    const report = inspector.getAgentReport('nonexistent');
+    expect(report).toBeNull();
+  });
+
+  test('getAgentReport returns report for monitored agent', () => {
+    inspector.start();
+    inspector.recordActivity('agent-1', { type: 'command', content: 'ls' });
+    const report = inspector.getAgentReport('agent-1');
+    expect(report).not.toBeNull();
+    expect(report.agentId).toBe('agent-1');
+    expect(report.messageCount).toBe(1);
+  });
+});