onbuzz 3.6.1 → 3.6.2

package/src/core/__tests__/contextManager.test.js

@@ -0,0 +1,252 @@
+import { jest, describe, test, expect, beforeEach } from '@jest/globals';
+import { createMockLogger, createMockConfig } from '../../__test-utils__/mockFactories.js';
+
+// Mock fs/promises
+const mockStat = jest.fn();
+const mockReadFile = jest.fn();
+const mockReaddir = jest.fn();
+
+jest.unstable_mockModule('fs', () => ({
+  promises: {
+    stat: mockStat,
+    readFile: mockReadFile,
+    readdir: mockReaddir,
+  }
+}));
+
+const { default: ContextManager } = await import('../contextManager.js');
+
+describe('ContextManager', () => {
+  let cm;
+  let logger;
+
+  beforeEach(() => {
+    logger = createMockLogger();
+    cm = new ContextManager(
+      createMockConfig({ context: { maxSize: 10000, maxReferences: 5, cacheExpiry: 3600 } }),
+      logger
+    );
+    jest.clearAllMocks();
+  });
+
+  // --- processMessageWithContext ---
+
+  test('processMessageWithContext returns message unchanged if no contextReferences', async () => {
+    const msg = { content: 'Hello', contextReferences: [] };
+    const result = await cm.processMessageWithContext(msg, '/project');
+    expect(result.content).toBe('Hello');
+  });
+
+  test('processMessageWithContext returns message unchanged if contextReferences is missing', async () => {
+    const msg = { content: 'Hello' };
+    const result = await cm.processMessageWithContext(msg, '/project');
+    expect(result.content).toBe('Hello');
+  });
+
+  test('processMessageWithContext enhances message with file context', async () => {
+    mockStat.mockResolvedValue({ isFile: () => true, mtime: new Date(), size: 100 });
+    mockReadFile.mockResolvedValue('const x = 1;');
+
+    const msg = {
+      content: 'Fix this code',
+      contextReferences: [{ type: 'file', path: 'src/index.js' }]
+    };
+    const result = await cm.processMessageWithContext(msg, '/project');
+
+    expect(result.content).toContain('PROJECT CONTEXT REFERENCES');
+    expect(result.content).toContain('Fix this code');
+    expect(result.originalContent).toBe('Fix this code');
+    expect(result.processedContextReferences.length).toBe(1);
+    expect(result.contextSize).toBeGreaterThan(0);
+  });
+
+  test('processMessageWithContext returns error info on catastrophic failure', async () => {
+    // Force loadContextReferences to throw by making sortReferencesByPriority throw
+    cm.sortReferencesByPriority = () => { throw new Error('sort failure'); };
+
+    const msg = {
+      content: 'Fix this code',
+      contextReferences: [{ type: 'file', path: 'x.js' }]
+    };
+    const result = await cm.processMessageWithContext(msg, '/project');
+    expect(result.contextProcessingError).toBe('sort failure');
+    expect(result.processedContextReferences).toEqual([]);
+  });
+
+  // --- loadSingleReference ---
+
+  test('loadSingleReference reads file content for type=file', async () => {
+    mockStat.mockResolvedValue({ isFile: () => true, mtime: new Date(), size: 50 });
+    mockReadFile.mockResolvedValue('hello world');
+
+    const ref = { type: 'file', path: 'test.txt' };
+    const loaded = await cm.loadSingleReference(ref, '/project');
+
+    expect(loaded.content).toBe('hello world');
+    expect(loaded.exists).toBe(true);
+    expect(loaded.checksum).toBeDefined();
+  });
+
+  test('loadSingleReference handles missing file with File not found error', async () => {
+    mockStat.mockRejectedValue(new Error('ENOENT'));
+
+    const ref = { type: 'file', path: 'missing.js' };
+    await expect(cm.loadSingleReference(ref, '/project')).rejects.toThrow('File not found');
+  });
+
+  test('loadSingleReference applies line range for file references', async () => {
+    mockStat.mockResolvedValue({ isFile: () => true, mtime: new Date(), size: 100 });
+    mockReadFile.mockResolvedValue('line1\nline2\nline3\nline4\nline5');
+
+    const ref = { type: 'file', path: 'test.js', lines: [2, 4] };
+    const loaded = await cm.loadSingleReference(ref, '/project');
+
+    expect(loaded.content).toBe('line2\nline3\nline4');
+  });
+
+  test('loadSingleReference throws for unknown reference type', async () => {
+    const ref = { type: 'unknown', path: 'x' };
+    await expect(cm.loadSingleReference(ref, '/project')).rejects.toThrow('Unknown reference type');
+  });
+
+  test('loadSingleReference loads directory listing for type=directory', async () => {
+    mockStat.mockResolvedValue({ isDirectory: () => true });
+    mockReaddir.mockResolvedValue([
+      { name: 'file.js', isFile: () => true, isDirectory: () => false, isSymbolicLink: () => false },
+      { name: 'subfolder', isFile: () => false, isDirectory: () => true, isSymbolicLink: () => false },
+    ]);
+
+    const ref = { type: 'directory', path: 'src' };
+    const loaded = await cm.loadSingleReference(ref, '/project');
+
+    expect(loaded.exists).toBe(true);
+    expect(loaded.content).toContain('file.js');
+    expect(loaded.content).toContain('subfolder');
+    expect(loaded.fileCount).toBe(1);
+    expect(loaded.directoryCount).toBe(1);
+  });
+
+  test('loadSingleReference loads selection reference without file', async () => {
+    const ref = { type: 'selection', content: 'selected text' };
+    const loaded = await cm.loadSingleReference(ref, '/project');
+    expect(loaded.exists).toBe(true);
+    expect(loaded.validated).toBe(false);
+  });
+
+  test('loadSingleReference loads component reference', async () => {
+    mockReadFile.mockResolvedValue('function myFunc() {\n  return 1;\n}');
+
+    const ref = { type: 'component', file: 'utils.js', name: 'myFunc' };
+    const loaded = await cm.loadSingleReference(ref, '/project');
+    expect(loaded.exists).toBe(true);
+    expect(loaded.content).toContain('myFunc');
+  });
+
+  // --- generateContextPrompt ---
+
+  test('generateContextPrompt returns empty string for no references', () => {
+    expect(cm.generateContextPrompt([])).toBe('');
+  });
+
+  test('generateContextPrompt formats references with code blocks and language', () => {
+    const refs = [{
+      type: 'file',
+      path: 'test.js',
+      content: 'const a = 1;',
+      exists: true
+    }];
+    const prompt = cm.generateContextPrompt(refs);
+    expect(prompt).toContain('FILE: test.js');
+    expect(prompt).toContain('```javascript');
+    expect(prompt).toContain('const a = 1;');
+    expect(prompt).toContain('END CONTEXT REFERENCES');
+  });
+
+  test('generateContextPrompt shows error for failed references', () => {
+    const refs = [{ type: 'file', path: 'bad.js', error: 'File not found', content: '[Error]' }];
+    const prompt = cm.generateContextPrompt(refs);
+    expect(prompt).toContain('Error: File not found');
+  });
+
+  test('generateContextPrompt shows line range metadata', () => {
+    const refs = [{
+      type: 'file', path: 'x.py', content: 'pass', exists: true,
+      lines: [10, 20]
+    }];
+    const prompt = cm.generateContextPrompt(refs);
+    expect(prompt).toContain('Lines 10-20');
+  });
+
+  test('generateContextPrompt shows truncation and change warnings', () => {
+    const refs = [{
+      type: 'file', path: 'x.js', content: 'code', exists: true,
+      truncated: true, hasChanged: true
+    }];
+    const prompt = cm.generateContextPrompt(refs);
+    expect(prompt).toContain('truncated');
+    expect(prompt).toContain('changed');
+  });
+
+  // --- Cache operations ---
+
+  test('addToCache and getFromCache round-trip', () => {
+    const data = { content: 'cached data', loadedAt: new Date().toISOString() };
+    cm.addToCache('key1', data);
+    const cached = cm.getFromCache('key1');
+    expect(cached).toBe(data);
+  });
+
+  test('getFromCache returns null for missing key', () => {
+    expect(cm.getFromCache('nonexistent')).toBeNull();
+  });
+
+  test('shouldRefreshCache returns true when cache is old', () => {
+    const oldRef = { loadedAt: new Date(Date.now() - 7200 * 1000).toISOString() };
+    expect(cm.shouldRefreshCache(oldRef)).toBe(true);
+  });
+
+  test('shouldRefreshCache returns false for fresh cache', () => {
+    const freshRef = { loadedAt: new Date().toISOString() };
+    expect(cm.shouldRefreshCache(freshRef)).toBe(false);
+  });
+
+  // --- generateCacheKey ---
+
+  test('generateCacheKey returns consistent keys for same input', () => {
+    const ref = { type: 'file', path: 'a.js' };
+    const key1 = cm.generateCacheKey(ref, '/project');
+    const key2 = cm.generateCacheKey(ref, '/project');
+    expect(key1).toBe(key2);
+  });
+
+  test('generateCacheKey returns different keys for different paths', () => {
+    const key1 = cm.generateCacheKey({ type: 'file', path: 'a.js' }, '/project');
+    const key2 = cm.generateCacheKey({ type: 'file', path: 'b.js' }, '/project');
+    expect(key1).not.toBe(key2);
+  });
+
+  // --- loadContextReferences ---
+
+  test('loadContextReferences truncates content when exceeding maxContextSize', async () => {
+    cm.maxContextSize = 50;
+    mockStat.mockResolvedValue({ isFile: () => true, mtime: new Date(), size: 200 });
+    mockReadFile.mockResolvedValue('A'.repeat(200));
+
+    const refs = [{ type: 'file', path: 'big.js' }];
+    const loaded = await cm.loadContextReferences(refs, '/project');
+
+    // Content should be shorter than original 200 chars
+    expect(loaded[0].content.length).toBeLessThan(200);
+  });
+
+  test('loadContextReferences pushes error reference when loading fails', async () => {
+    mockStat.mockRejectedValue(new Error('ENOENT'));
+
+    const refs = [{ type: 'file', path: 'missing.js' }];
+    const loaded = await cm.loadContextReferences(refs, '/project');
+
+    expect(loaded.length).toBe(1);
+    expect(loaded[0].error).toBeDefined();
+    expect(loaded[0].exists).toBe(false);
+  });
+});

package/src/core/__tests__/flowExecutor.test.js

@@ -0,0 +1,262 @@
+import { jest, describe, test, expect, beforeEach } from '@jest/globals';
+import { createMockLogger, createMockConfig, createMockStateManager, createMockAgentPool } from '../../__test-utils__/mockFactories.js';
+
+jest.unstable_mockModule('../../utilities/constants.js', () => ({
+  AGENT_MODES: { CHAT: 'chat', AGENT: 'agent' }
+}));
+
+const { default: FlowExecutor } = await import('../flowExecutor.js');
+
+describe('FlowExecutor', () => {
+  let fe;
+  let config, logger, stateManager, agentPool, messageProcessor;
+
+  beforeEach(() => {
+    config = createMockConfig();
+    logger = createMockLogger();
+    stateManager = createMockStateManager();
+    agentPool = createMockAgentPool();
+    messageProcessor = { processMessage: jest.fn().mockResolvedValue(undefined) };
+    fe = new FlowExecutor(config, logger, stateManager, agentPool, messageProcessor);
+  });
+
+  // --- topologicalSort ---
+
+  test('topologicalSort with simple linear DAG returns correct order', () => {
+    const nodes = [
+      { id: 'a', data: {} },
+      { id: 'b', data: {} },
+      { id: 'c', data: {} }
+    ];
+    const edges = [
+      { source: 'a', target: 'b' },
+      { source: 'b', target: 'c' }
+    ];
+    const sorted = fe.topologicalSort(nodes, edges);
+    expect(sorted.length).toBe(3);
+    const ids = sorted.map(n => n.id);
+    expect(ids.indexOf('a')).toBeLessThan(ids.indexOf('b'));
+    expect(ids.indexOf('b')).toBeLessThan(ids.indexOf('c'));
+  });
+
+  test('topologicalSort with diamond DAG respects all edges', () => {
+    const nodes = [
+      { id: 'a' }, { id: 'b' }, { id: 'c' }, { id: 'd' }
+    ];
+    const edges = [
+      { source: 'a', target: 'b' },
+      { source: 'a', target: 'c' },
+      { source: 'b', target: 'd' },
+      { source: 'c', target: 'd' }
+    ];
+    const sorted = fe.topologicalSort(nodes, edges);
+    expect(sorted.length).toBe(4);
+    const ids = sorted.map(n => n.id);
+    expect(ids.indexOf('a')).toBeLessThan(ids.indexOf('b'));
+    expect(ids.indexOf('a')).toBeLessThan(ids.indexOf('c'));
+    expect(ids.indexOf('b')).toBeLessThan(ids.indexOf('d'));
+    expect(ids.indexOf('c')).toBeLessThan(ids.indexOf('d'));
+  });
+
+  test('topologicalSort with single node returns that node', () => {
+    const sorted = fe.topologicalSort([{ id: 'x' }], []);
+    expect(sorted.length).toBe(1);
+    expect(sorted[0].id).toBe('x');
+  });
+
+  test('topologicalSort with cycle logs warning and returns partial result', () => {
+    const nodes = [{ id: 'a' }, { id: 'b' }];
+    const edges = [
+      { source: 'a', target: 'b' },
+      { source: 'b', target: 'a' }
+    ];
+    const sorted = fe.topologicalSort(nodes, edges);
+    // Cycle means sorted.length < nodes.length
+    expect(sorted.length).toBeLessThan(nodes.length);
+    expect(logger.warn).toHaveBeenCalledWith(expect.stringContaining('cycles'));
+  });
+
+  test('topologicalSort with empty/null nodes returns empty array', () => {
+    expect(fe.topologicalSort([], [])).toEqual([]);
+    expect(fe.topologicalSort(null, [])).toEqual([]);
+  });
+
+  // --- executeInputNode ---
+
+  test('executeInputNode passes input through with template', async () => {
+    const node = { id: 'in1', data: { promptTemplate: '{{userInput}}' } };
+    const context = { input: 'Hello world', variables: {} };
+    const result = await fe.executeInputNode(node, context);
+    expect(result.type).toBe('input');
+    expect(result.output).toBe('Hello world');
+    expect(result.raw).toBe('Hello world');
+  });
+
+  test('executeInputNode uses default template when none provided', async () => {
+    const node = { id: 'in1', data: {} };
+    const context = { input: 'Test input', variables: {} };
+    const result = await fe.executeInputNode(node, context);
+    expect(result.output).toBe('Test input');
+  });
+
+  // --- executeOutputNode ---
+
+  test('executeOutputNode collects final output from previous nodes in text format', async () => {
+    const node = { id: 'out1', data: { outputFormat: 'text' } };
+    const flow = { edges: [{ source: 'agent1', target: 'out1' }] };
+    const context = {
+      input: '', variables: {},
+      nodeOutputs: { agent1: { output: 'Agent result here' } }
+    };
+    const result = await fe.executeOutputNode(node, context, flow);
+    expect(result.type).toBe('output');
+    expect(result.format).toBe('text');
+    expect(result.output).toBe('Agent result here');
+  });
+
+  test('executeOutputNode uses json format when specified', async () => {
+    const node = { id: 'out1', data: { outputFormat: 'json' } };
+    const flow = { edges: [{ source: 'a1', target: 'out1' }] };
+    const context = { input: '', variables: {}, nodeOutputs: { a1: { output: 'text data' } } };
+    const result = await fe.executeOutputNode(node, context, flow);
+    expect(result.format).toBe('json');
+    expect(result.output).toHaveProperty('result');
+  });
+
+  // --- setWebSocketManager ---
+
+  test('setWebSocketManager stores the reference', () => {
+    const wsm = { broadcast: jest.fn() };
+    fe.setWebSocketManager(wsm);
+    expect(fe.webSocketManager).toBe(wsm);
+  });
+
+  // --- getActiveExecutions ---
+
+  test('getActiveExecutions returns empty array initially', () => {
+    const active = fe.getActiveExecutions();
+    expect(active).toEqual([]);
+  });
+
+  test('getActiveExecutions returns entries during a running flow', () => {
+    fe.activeExecutions.set('run-1', {
+      flowId: 'flow-1', status: 'running', startedAt: new Date()
+    });
+    const active = fe.getActiveExecutions();
+    expect(active.length).toBe(1);
+    expect(active[0].runId).toBe('run-1');
+    expect(active[0].flowId).toBe('flow-1');
+    expect(active[0].status).toBe('running');
+  });
+
+  // --- stopExecution ---
+
+  test('stopExecution marks execution as stopped and returns true', async () => {
+    fe.activeExecutions.set('run-1', { flowId: 'f1', status: 'running' });
+    fe.completionListeners.set('run-1', {});
+    const result = await fe.stopExecution('run-1');
+    expect(result).toBe(true);
+    expect(fe.activeExecutions.get('run-1').status).toBe('stopped');
+    expect(fe.completionListeners.has('run-1')).toBe(false);
+  });
+
+  test('stopExecution returns false for nonexistent run', async () => {
+    const result = await fe.stopExecution('nonexistent');
+    expect(result).toBe(false);
+  });
+
+  // --- notifyAgentCompletion ---
+
+  test('notifyAgentCompletion resolves waiting listener', () => {
+    let resolved = null;
+    fe.completionListeners.set('run-1-agent-1', {
+      agentId: 'agent-1',
+      runId: 'run-1',
+      resolve: (data) => { resolved = data; }
+    });
+    const found = fe.notifyAgentCompletion('agent-1', { summary: 'Done', success: true });
+    expect(found).toBe(true);
+    expect(resolved).not.toBeNull();
+    expect(resolved.summary).toBe('Done');
+    expect(resolved.completed).toBe(true);
+  });
+
+  test('notifyAgentCompletion returns false when no listener found', () => {
+    const found = fe.notifyAgentCompletion('unknown-agent', {});
+    expect(found).toBe(false);
+  });
+
+  // --- executeFlow ---
+
+  test('executeFlow with input+output nodes completes successfully', async () => {
+    const flowId = 'test-flow';
+    const flow = {
+      id: flowId,
+      name: 'Test Flow',
+      nodes: [
+        { id: 'in', type: 'input', data: {} },
+        { id: 'out', type: 'output', data: {} }
+      ],
+      edges: [{ source: 'in', target: 'out' }],
+      variables: {}
+    };
+
+    stateManager.getFlow = jest.fn().mockResolvedValue(flow);
+    stateManager.createFlowRun = jest.fn().mockResolvedValue({ id: 'run-1' });
+    stateManager.updateFlowRun = jest.fn().mockResolvedValue(undefined);
+    stateManager.getFlowRun = jest.fn().mockResolvedValue({ id: 'run-1', nodeStates: {} });
+
+    const result = await fe.executeFlow(flowId, { userInput: 'Hello' });
+    expect(result.status).toBe('completed');
+    expect(result.runId).toBe('run-1');
+  });
+
+  test('executeFlow throws when flow not found', async () => {
+    stateManager.getFlow = jest.fn().mockResolvedValue(null);
+    stateManager.createFlowRun = jest.fn();
+    await expect(fe.executeFlow('missing-flow', {})).rejects.toThrow('Flow not found');
+  });
+
+  // --- truncateOutput ---
+
+  test('truncateOutput truncates long strings', () => {
+    const longStr = 'x'.repeat(2000);
+    const result = fe.truncateOutput(longStr);
+    expect(result.length).toBeLessThan(2000);
+    expect(result).toContain('truncated');
+  });
+
+  test('truncateOutput returns short strings unchanged', () => {
+    expect(fe.truncateOutput('short')).toBe('short');
+  });
+
+  test('truncateOutput handles large objects', () => {
+    const obj = { data: 'x'.repeat(2000) };
+    const result = fe.truncateOutput(obj);
+    expect(result.truncated).toBe(true);
+    expect(result.preview).toBeDefined();
+  });
+
+  // --- applyTemplate ---
+
+  test('applyTemplate substitutes variables', () => {
+    const result = fe.applyTemplate('Hello {{name}}, you have {{count}} items', { name: 'Alice', count: 5 });
+    expect(result).toBe('Hello Alice, you have 5 items');
+  });
+
+  // --- collectPreviousOutput ---
+
+  test('collectPreviousOutput combines multiple outputs', () => {
+    const nodeOutputs = {
+      n1: { output: 'First' },
+      n2: { output: 'Second' }
+    };
+    const result = fe.collectPreviousOutput(['n1', 'n2'], nodeOutputs);
+    expect(result).toContain('First');
+    expect(result).toContain('Second');
+  });
+
+  test('collectPreviousOutput returns empty string for no outputs', () => {
+    expect(fe.collectPreviousOutput([], {})).toBe('');
+  });
+});