onbuzz 3.6.1 → 3.6.3

package/src/tools/__tests__/jobDoneTool.test.js

@@ -0,0 +1,296 @@
+import { jest, describe, test, expect, beforeEach } from '@jest/globals';
+import { createMockLogger } from '../../__test-utils__/mockFactories.js';
+
+// Mock TagParser before importing
+jest.unstable_mockModule('../../utilities/tagParser.js', () => ({
+  default: {
+    extractContent: jest.fn((content, tag) => {
+      const regex = new RegExp(`<${tag}>(.*?)</${tag}>`, 'gs');
+      const matches = [];
+      let match;
+      while ((match = regex.exec(content)) !== null) {
+        matches.push(match[1]);
+      }
+      return matches;
+    })
+  }
+}));
+
+const { default: JobDoneTool } = await import('../jobDoneTool.js');
+
+describe('JobDoneTool', () => {
+  let tool;
+
+  beforeEach(() => {
+    tool = new JobDoneTool();
+  });
+
+  describe('constructor', () => {
+    test('should set correct id and metadata', () => {
+      expect(tool.id).toBe('jobdone');
+      expect(tool.name).toBe('Job Done');
+      expect(tool.version).toBe('1.0.0');
+      expect(tool.requiresProject).toBe(false);
+    });
+  });
+
+  describe('getDescription', () => {
+    test('should return description containing usage info', () => {
+      const desc = tool.getDescription();
+      expect(desc).toContain('Job Done Tool');
+      expect(desc).toContain('complete');
+    });
+  });
+
+  describe('getSchema', () => {
+    test('should return valid schema with actions property', () => {
+      const schema = tool.getSchema();
+      expect(schema.type).toBe('object');
+      expect(schema.properties.actions).toBeDefined();
+      expect(schema.required).toContain('actions');
+    });
+  });
+
+  describe('getCapabilities', () => {
+    test('should return capabilities with schema', () => {
+      const caps = tool.getCapabilities();
+      expect(caps.id).toBe('jobdone');
+      expect(caps.schema).toBeDefined();
+      expect(caps.enabled).toBe(true);
+    });
+  });
+
+  describe('parseParameters', () => {
+    test('should parse structured tags with summary', () => {
+      const result = tool.parseParameters('<summary>Task done</summary><success>true</success>');
+      expect(result.actions[0].summary).toBe('Task done');
+      expect(result.actions[0].success).toBe(true);
+      expect(result.actions[0].action).toBe('complete');
+    });
+
+    test('should parse with success=false', () => {
+      const result = tool.parseParameters('<summary>Failed</summary><success>false</success>');
+      expect(result.actions[0].success).toBe(false);
+    });
+
+    test('should parse details tag', () => {
+      const result = tool.parseParameters('<summary>Done</summary><details>Extra info</details>');
+      expect(result.actions[0].details).toBe('Extra info');
+    });
+
+    test('should fallback to raw content as summary', () => {
+      const result = tool.parseParameters('Simple completion message');
+      expect(result.actions[0].summary).toBe('Simple completion message');
+      expect(result.actions[0].success).toBe(true);
+    });
+
+    test('should default summary to "Task completed" for empty content', () => {
+      const result = tool.parseParameters('');
+      expect(result.actions[0].summary).toBe('Task completed');
+    });
+  });
+
+  describe('setAgentPool', () => {
+    test('should store the agent pool reference', () => {
+      const mockPool = { getAgent: jest.fn() };
+      tool.setAgentPool(mockPool);
+      expect(tool.agentPool).toBe(mockPool);
+    });
+  });
+
+  describe('setWebSocketManager', () => {
+    test('should store the websocket manager', () => {
+      const mockWs = { broadcastToSession: jest.fn() };
+      tool.setWebSocketManager(mockWs);
+      expect(tool.webSocketManager).toBe(mockWs);
+    });
+  });
+
+  describe('setFlowExecutor', () => {
+    test('should store the flow executor', () => {
+      const mockFlow = { notifyAgentCompletion: jest.fn() };
+      tool.setFlowExecutor(mockFlow);
+      expect(tool.flowExecutor).toBe(mockFlow);
+    });
+  });
+
+  describe('execute', () => {
+    test('should reject when actions array is missing', async () => {
+      const result = await tool.execute({}, {});
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('Actions array is required');
+    });
+
+    test('should reject when actions array is empty', async () => {
+      const result = await tool.execute({ actions: [] }, {});
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('Actions array is required');
+    });
+
+    test('should reject invalid action type', async () => {
+      const result = await tool.execute({
+        actions: [{ action: 'invalid', summary: 'test' }]
+      }, {});
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('Invalid action');
+    });
+
+    test('should reject when summary is missing', async () => {
+      const result = await tool.execute({
+        actions: [{ action: 'complete' }]
+      }, {});
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('summary is required');
+    });
+
+    test('should successfully complete with minimal params', async () => {
+      const result = await tool.execute({
+        actions: [{ action: 'complete', summary: 'All done' }]
+      }, {});
+      expect(result.success).toBe(true);
+      expect(result.taskComplete).toBe(true);
+      expect(result.exitAutonomousMode).toBe(true);
+      expect(result.summary).toBe('All done');
+      expect(result.successfulCompletion).toBe(true);
+    });
+
+    test('should complete with success=false', async () => {
+      const result = await tool.execute({
+        actions: [{ action: 'complete', summary: 'Stuck', success: false }]
+      }, {});
+      expect(result.success).toBe(true);
+      expect(result.successfulCompletion).toBe(false);
+      expect(result.output).toContain('with issues');
+    });
+
+    test('should include details in output when provided', async () => {
+      const result = await tool.execute({
+        actions: [{ action: 'complete', summary: 'Done', details: 'Created 3 files' }]
+      }, {});
+      expect(result.details).toBe('Created 3 files');
+      expect(result.output).toContain('Created 3 files');
+    });
+
+    test('should reject when agent has pending tasks and success=true', async () => {
+      const mockAgent = {
+        name: 'test-agent',
+        sessionId: 'sess-1',
+        taskList: {
+          tasks: [
+            { status: 'pending', title: 'Unfinished task' },
+            { status: 'in_progress', title: 'Working task' }
+          ]
+        }
+      };
+      const mockPool = {
+        getAgent: jest.fn().mockResolvedValue(mockAgent),
+        persistAgentState: jest.fn().mockResolvedValue(undefined)
+      };
+      tool.setAgentPool(mockPool);
+
+      const result = await tool.execute(
+        { actions: [{ action: 'complete', summary: 'Done', success: true }] },
+        { agentId: 'agent-1' }
+      );
+      expect(result.success).toBe(false);
+      expect(result.output).toContain('pending task(s)');
+      expect(result.pendingTasks).toBe(2);
+    });
+
+    test('should allow completion with success=false even with pending tasks', async () => {
+      const mockAgent = {
+        name: 'test-agent',
+        sessionId: 'sess-1',
+        taskList: {
+          tasks: [{ status: 'pending', title: 'Stuck task' }]
+        }
+      };
+      const mockPool = {
+        getAgent: jest.fn().mockResolvedValue(mockAgent),
+        persistAgentState: jest.fn().mockResolvedValue(undefined)
+      };
+      tool.setAgentPool(mockPool);
+
+      const result = await tool.execute(
+        { actions: [{ action: 'complete', summary: 'Giving up', success: false }] },
+        { agentId: 'agent-1' }
+      );
+      expect(result.success).toBe(true);
+      expect(result.successfulCompletion).toBe(false);
+    });
+
+    test('should clear agent tasks and persist state on completion', async () => {
+      const mockAgent = {
+        id: 'agent-1',
+        name: 'test-agent',
+        sessionId: 'sess-1',
+        taskList: {
+          tasks: [{ status: 'completed', title: 'Done task' }]
+        }
+      };
+      const mockPool = {
+        getAgent: jest.fn().mockResolvedValue(mockAgent),
+        persistAgentState: jest.fn().mockResolvedValue(undefined)
+      };
+      tool.setAgentPool(mockPool);
+
+      await tool.execute(
+        { actions: [{ action: 'complete', summary: 'All done' }] },
+        { agentId: 'agent-1' }
+      );
+      expect(mockAgent.taskList.tasks).toEqual([]);
+      expect(mockAgent.autonomousWorkComplete).toBe(true);
+      expect(mockPool.persistAgentState).toHaveBeenCalledWith('agent-1');
+    });
+
+    test('should broadcast via websocket when available', async () => {
+      const mockAgent = {
+        id: 'agent-1',
+        name: 'test-agent',
+        sessionId: 'sess-1',
+        mode: 'agent',
+        taskList: { tasks: [] }
+      };
+      const mockPool = {
+        getAgent: jest.fn().mockResolvedValue(mockAgent),
+        persistAgentState: jest.fn().mockResolvedValue(undefined)
+      };
+      const mockWs = { broadcastToSession: jest.fn() };
+      tool.setAgentPool(mockPool);
+      tool.setWebSocketManager(mockWs);
+
+      await tool.execute(
+        { actions: [{ action: 'complete', summary: 'Done' }] },
+        { agentId: 'agent-1' }
+      );
+      expect(mockWs.broadcastToSession).toHaveBeenCalledWith('sess-1', expect.objectContaining({
+        type: 'agent_job_done'
+      }));
+    });
+
+    test('should notify flow executor when set', async () => {
+      const mockAgent = {
+        id: 'agent-1',
+        name: 'test-agent',
+        sessionId: 'sess-1',
+        taskList: { tasks: [] }
+      };
+      const mockPool = {
+        getAgent: jest.fn().mockResolvedValue(mockAgent),
+        persistAgentState: jest.fn().mockResolvedValue(undefined)
+      };
+      const mockFlow = { notifyAgentCompletion: jest.fn() };
+      tool.setAgentPool(mockPool);
+      tool.setFlowExecutor(mockFlow);
+
+      await tool.execute(
+        { actions: [{ action: 'complete', summary: 'Done' }] },
+        { agentId: 'agent-1' }
+      );
+      expect(mockFlow.notifyAgentCompletion).toHaveBeenCalledWith('agent-1', expect.objectContaining({
+        summary: 'Done',
+        success: true
+      }));
+    });
+  });
+});

package/src/tools/__tests__/memoryTool.test.js

@@ -0,0 +1,297 @@
+import { jest, describe, test, expect, beforeEach } from '@jest/globals';
+import { createMockLogger, createMockConfig } from '../../__test-utils__/mockFactories.js';
+
+// Mock constants
+jest.unstable_mockModule('../../utilities/constants.js', () => ({
+  TOOL_STATUS: { PENDING: 'pending', EXECUTING: 'executing', COMPLETED: 'completed', FAILED: 'failed' },
+  OPERATION_STATUS: { NOT_FOUND: 'not_found' },
+  ERROR_TYPES: {},
+  SYSTEM_DEFAULTS: { MAX_TOOL_EXECUTION_TIME: 300000 }
+}));
+
+// Create mock memory service
+const mockMemoryService = {
+  initialize: jest.fn().mockResolvedValue(undefined),
+  addMemory: jest.fn(),
+  updateMemory: jest.fn(),
+  deleteMemory: jest.fn(),
+  listMemories: jest.fn(),
+  readMemory: jest.fn(),
+  searchMemories: jest.fn(),
+  getMemoryStats: jest.fn()
+};
+
+jest.unstable_mockModule('../../services/memoryService.js', () => ({
+  getMemoryService: jest.fn(() => mockMemoryService)
+}));
+
+const { default: MemoryTool } = await import('../memoryTool.js');
+
+describe('MemoryTool', () => {
+  let tool;
+  let logger;
+  const context = { agentId: 'agent-1' };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    logger = createMockLogger();
+    tool = new MemoryTool({}, logger);
+  });
+
+  test('constructor sets metadata correctly', () => {
+    expect(tool.id).toBe('memory');
+    expect(tool.requiresProject).toBe(false);
+    expect(tool.timeout).toBe(30000);
+  });
+
+  test('getDescription contains all actions', () => {
+    const desc = tool.getDescription();
+    expect(desc).toContain('Memory Tool');
+    expect(desc).toContain('add');
+    expect(desc).toContain('update');
+    expect(desc).toContain('delete');
+    expect(desc).toContain('list');
+    expect(desc).toContain('read');
+    expect(desc).toContain('search');
+    expect(desc).toContain('stats');
+  });
+
+  test('getSupportedActions returns all 7 actions', () => {
+    expect(tool.getSupportedActions()).toEqual(
+      ['add', 'update', 'delete', 'list', 'read', 'search', 'stats']
+    );
+  });
+
+  test('getRequiredParameters returns action', () => {
+    expect(tool.getRequiredParameters()).toEqual(['action']);
+  });
+
+  test('getCapabilities includes persistent flag', () => {
+    const caps = tool.getCapabilities();
+    expect(caps.persistent).toBe(true);
+    expect(caps.actions).toEqual(tool.getSupportedActions());
+  });
+
+  test('getParameterSchema has action enum', () => {
+    const schema = tool.getParameterSchema();
+    expect(schema.properties.action.enum).toEqual(tool.getSupportedActions());
+  });
+
+  test('parseParameters returns content as-is', () => {
+    const input = { action: 'add', title: 'test' };
+    expect(tool.parseParameters(input)).toBe(input);
+  });
+
+  test('validateParameterTypes catches invalid action type', () => {
+    const result = tool.validateParameterTypes({ action: 123 });
+    expect(result.valid).toBe(false);
+  });
+
+  test('validateParameterTypes catches invalid level', () => {
+    const result = tool.validateParameterTypes({ level: 'invalid' });
+    expect(result.valid).toBe(false);
+  });
+
+  test('validateParameterTypes accepts valid params', () => {
+    const result = tool.validateParameterTypes({ action: 'add', title: 'test', level: 'titles' });
+    expect(result.valid).toBe(true);
+  });
+
+  test('customValidateParameters rejects unknown action', () => {
+    const result = tool.customValidateParameters({ action: 'unknown' });
+    expect(result.valid).toBe(false);
+  });
+
+  test('customValidateParameters requires title and content for add', () => {
+    const result = tool.customValidateParameters({ action: 'add' });
+    expect(result.valid).toBe(false);
+    expect(result.errors.some(e => e.includes('title'))).toBe(true);
+    expect(result.errors.some(e => e.includes('content'))).toBe(true);
+  });
+
+  test('customValidateParameters requires id for update', () => {
+    const result = tool.customValidateParameters({ action: 'update' });
+    expect(result.valid).toBe(false);
+  });
+
+  test('customValidateParameters requires id for delete', () => {
+    const result = tool.customValidateParameters({ action: 'delete' });
+    expect(result.valid).toBe(false);
+  });
+
+  test('customValidateParameters requires id for read', () => {
+    const result = tool.customValidateParameters({ action: 'read' });
+    expect(result.valid).toBe(false);
+  });
+
+  test('customValidateParameters requires query for search', () => {
+    const result = tool.customValidateParameters({ action: 'search' });
+    expect(result.valid).toBe(false);
+  });
+
+  test('customValidateParameters enforces length limits', () => {
+    const result = tool.customValidateParameters({
+      action: 'add',
+      title: 'a'.repeat(201),
+      content: 'c'.repeat(10001),
+      description: 'd'.repeat(501)
+    });
+    expect(result.valid).toBe(false);
+    expect(result.errors.length).toBe(3);
+  });
+
+  test('execute throws without agentId', async () => {
+    await expect(tool.execute({ action: 'stats' }, {}))
+      .rejects.toThrow('Agent ID is required');
+  });
+
+  test('execute add action creates memory', async () => {
+    mockMemoryService.addMemory.mockResolvedValue({
+      id: 'mem-1', title: 'Test', createdAt: '2025-01-01', expiration: null
+    });
+
+    const result = await tool.execute(
+      { action: 'add', title: 'Test', content: 'content', description: 'desc' },
+      context
+    );
+
+    expect(result.success).toBe(true);
+    expect(result.action).toBe('add');
+    expect(result.memory.id).toBe('mem-1');
+    expect(mockMemoryService.addMemory).toHaveBeenCalledWith('agent-1', expect.objectContaining({ title: 'Test' }));
+  });
+
+  test('execute update action modifies memory', async () => {
+    mockMemoryService.updateMemory.mockResolvedValue({
+      id: 'mem-1', title: 'Updated', updatedAt: '2025-01-02'
+    });
+
+    const result = await tool.execute(
+      { action: 'update', id: 'mem-1', title: 'Updated' },
+      context
+    );
+
+    expect(result.success).toBe(true);
+    expect(result.action).toBe('update');
+  });
+
+  test('execute update returns failure when memory not found', async () => {
+    mockMemoryService.updateMemory.mockResolvedValue(null);
+
+    const result = await tool.execute(
+      { action: 'update', id: 'nonexistent', title: 'x' },
+      context
+    );
+
+    expect(result.success).toBe(false);
+    expect(result.message).toContain('not found');
+  });
+
+  test('execute delete action removes memory', async () => {
+    mockMemoryService.deleteMemory.mockResolvedValue(true);
+
+    const result = await tool.execute({ action: 'delete', id: 'mem-1' }, context);
+
+    expect(result.success).toBe(true);
+    expect(result.action).toBe('delete');
+  });
+
+  test('execute delete returns failure when memory not found', async () => {
+    mockMemoryService.deleteMemory.mockResolvedValue(false);
+
+    const result = await tool.execute({ action: 'delete', id: 'nonexistent' }, context);
+
+    expect(result.success).toBe(false);
+  });
+
+  test('execute list action returns memories', async () => {
+    mockMemoryService.listMemories.mockResolvedValue({
+      count: 2,
+      grouped: { '2025-01-01': [{ id: 'mem-1' }, { id: 'mem-2' }] }
+    });
+
+    const result = await tool.execute({ action: 'list', level: 'titles' }, context);
+
+    expect(result.success).toBe(true);
+    expect(result.totalMemories).toBe(2);
+    expect(result.level).toBe('titles');
+  });
+
+  test('execute list with default level', async () => {
+    mockMemoryService.listMemories.mockResolvedValue({ count: 0, grouped: {} });
+
+    const result = await tool.execute({ action: 'list' }, context);
+
+    expect(result.level).toBe('titles');
+    expect(result.message).toContain('No memories');
+  });
+
+  test('execute read action loads memory', async () => {
+    mockMemoryService.readMemory.mockResolvedValue({
+      id: 'mem-1', title: 'Test', description: 'desc', content: 'full content',
+      createdAt: '2025-01-01', updatedAt: null, expiration: null, accessCount: 3
+    });
+
+    const result = await tool.execute({ action: 'read', id: 'mem-1' }, context);
+
+    expect(result.success).toBe(true);
+    expect(result.memory.content).toBe('full content');
+  });
+
+  test('execute read returns failure when not found', async () => {
+    mockMemoryService.readMemory.mockResolvedValue(null);
+
+    const result = await tool.execute({ action: 'read', id: 'nonexistent' }, context);
+
+    expect(result.success).toBe(false);
+  });
+
+  test('execute search action returns results', async () => {
+    mockMemoryService.searchMemories.mockResolvedValue([
+      { id: 'mem-1', title: 'Match' }
+    ]);
+
+    const result = await tool.execute({ action: 'search', query: 'Match' }, context);
+
+    expect(result.success).toBe(true);
+    expect(result.results.length).toBe(1);
+    expect(result.query).toBe('Match');
+  });
+
+  test('execute search with no results', async () => {
+    mockMemoryService.searchMemories.mockResolvedValue([]);
+
+    const result = await tool.execute({ action: 'search', query: 'nothing' }, context);
+
+    expect(result.success).toBe(true);
+    expect(result.results.length).toBe(0);
+    expect(result.message).toContain('No memories found');
+  });
+
+  test('execute stats action returns statistics', async () => {
+    mockMemoryService.getMemoryStats.mockResolvedValue({
+      totalMemories: 5, totalAccessCount: 20
+    });
+
+    const result = await tool.execute({ action: 'stats' }, context);
+
+    expect(result.success).toBe(true);
+    expect(result.stats.totalMemories).toBe(5);
+    expect(result.message).toContain('5 total memories');
+  });
+
+  test('execute throws on unknown action', async () => {
+    await expect(tool.execute({ action: 'unknown' }, context))
+      .rejects.toThrow('Unknown action');
+  });
+
+  test('execute logs and re-throws service errors', async () => {
+    mockMemoryService.addMemory.mockRejectedValue(new Error('DB error'));
+
+    await expect(
+      tool.execute({ action: 'add', title: 'x', content: 'y' }, context)
+    ).rejects.toThrow('DB error');
+
+    expect(logger.error).toHaveBeenCalled();
+  });
+});