onbuzz 3.6.1 → 3.6.2

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

@@ -0,0 +1,204 @@
+import { jest, describe, test, expect, beforeEach } from '@jest/globals';
+import { createMockLogger, createMockConfig } from '../../__test-utils__/mockFactories.js';
+
+// Mock TagParser before importing HelpTool
+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: HelpTool } = await import('../helpTool.js');
+
+describe('HelpTool', () => {
+  let tool;
+  let logger;
+  let config;
+
+  beforeEach(() => {
+    logger = createMockLogger();
+    config = createMockConfig();
+    tool = new HelpTool(config, logger);
+  });
+
+  describe('constructor', () => {
+    test('should set correct id and metadata', () => {
+      expect(tool.id).toBe('help');
+      expect(tool.name).toBe('Help Tool');
+      expect(tool.version).toBe('1.0.0');
+      expect(tool.requiresProject).toBe(false);
+      expect(tool.isAsync).toBe(false);
+      expect(tool.toolsRegistry).toBeNull();
+    });
+  });
+
+  describe('getDescription', () => {
+    test('should return non-empty description string', () => {
+      const desc = tool.getDescription();
+      expect(typeof desc).toBe('string');
+      expect(desc.length).toBeGreaterThan(0);
+      expect(desc).toContain('Help Tool');
+      expect(desc).toContain('toolId');
+    });
+  });
+
+  describe('setToolsRegistry', () => {
+    test('should set the registry reference', () => {
+      const mockRegistry = { getTool: jest.fn() };
+      tool.setToolsRegistry(mockRegistry);
+      expect(tool.toolsRegistry).toBe(mockRegistry);
+    });
+  });
+
+  describe('getSupportedActions', () => {
+    test('should return expected actions', () => {
+      const actions = tool.getSupportedActions();
+      expect(actions).toContain('get-description');
+      expect(actions).toContain('list-tools');
+    });
+  });
+
+  describe('parseParameters', () => {
+    test('should parse tool name from tags', () => {
+      const result = tool.parseParameters('<tool>filesystem</tool>');
+      expect(result.tool).toBe('filesystem');
+      expect(result.list).toBe(false);
+    });
+
+    test('should parse list=true from tags', () => {
+      const result = tool.parseParameters('<list>true</list>');
+      expect(result.list).toBe(true);
+      expect(result.tool).toBeNull();
+    });
+
+    test('should return defaults when no tags found', () => {
+      const result = tool.parseParameters('some random content');
+      expect(result.tool).toBeNull();
+      expect(result.list).toBe(false);
+    });
+  });
+
+  describe('execute', () => {
+    test('should return error when toolsRegistry is not set', async () => {
+      const result = await tool.execute({});
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('not properly initialized');
+    });
+
+    test('should return error when no tool specified and list is false', async () => {
+      tool.setToolsRegistry({ getTool: jest.fn(), listTools: jest.fn() });
+      const result = await tool.execute({ tool: null, list: false });
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('No tool specified');
+    });
+
+    test('should list tools when list=true', async () => {
+      const mockRegistry = {
+        getTool: jest.fn().mockReturnValue({ isEnabled: true }),
+        listTools: jest.fn().mockReturnValue(['filesystem', 'terminal']),
+        toolSummaries: new Map([
+          ['filesystem', 'File operations'],
+          ['terminal', 'Run commands']
+        ])
+      };
+      tool.setToolsRegistry(mockRegistry);
+
+      const result = await tool.execute({ list: true });
+      expect(result.success).toBe(true);
+      expect(result.action).toBe('list-tools');
+      expect(result.tools).toHaveLength(2);
+      expect(result.output).toContain('filesystem');
+      expect(result.output).toContain('terminal');
+    });
+
+    test('should list tools with disabled indicator', async () => {
+      const mockRegistry = {
+        getTool: jest.fn().mockReturnValue({ isEnabled: false }),
+        listTools: jest.fn().mockReturnValue(['web']),
+        toolSummaries: new Map([['web', 'Web browsing']])
+      };
+      tool.setToolsRegistry(mockRegistry);
+
+      const result = await tool.execute({ list: true });
+      expect(result.output).toContain('(disabled)');
+    });
+
+    test('should get tool description for valid tool', async () => {
+      const mockTool = {
+        getDescription: jest.fn().mockReturnValue('Full description of filesystem'),
+        getCapabilities: jest.fn().mockReturnValue({
+          supportedActions: ['read', 'write'],
+          async: false,
+          requiresProject: true
+        })
+      };
+      const mockRegistry = {
+        getTool: jest.fn().mockReturnValue(mockTool),
+        listTools: jest.fn().mockReturnValue(['filesystem'])
+      };
+      tool.setToolsRegistry(mockRegistry);
+
+      const result = await tool.execute({ tool: 'filesystem' });
+      expect(result.success).toBe(true);
+      expect(result.action).toBe('get-description');
+      expect(result.toolId).toBe('filesystem');
+      expect(result.output).toContain('FILESYSTEM TOOL');
+      expect(result.output).toContain('read, write');
+    });
+
+    test('should return error for unknown tool', async () => {
+      const mockRegistry = {
+        getTool: jest.fn().mockReturnValue(null),
+        listTools: jest.fn().mockReturnValue(['filesystem', 'terminal'])
+      };
+      tool.setToolsRegistry(mockRegistry);
+
+      const result = await tool.execute({ tool: 'nonexistent' });
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('Tool not found');
+      expect(result.output).toContain('nonexistent');
+      expect(result.output).toContain('filesystem, terminal');
+    });
+
+    test('should handle nested parameters format', async () => {
+      const mockTool = {
+        getDescription: jest.fn().mockReturnValue('desc'),
+        getCapabilities: jest.fn().mockReturnValue({
+          supportedActions: ['execute'],
+          async: false,
+          requiresProject: false
+        })
+      };
+      const mockRegistry = {
+        getTool: jest.fn().mockReturnValue(mockTool),
+        listTools: jest.fn()
+      };
+      tool.setToolsRegistry(mockRegistry);
+
+      const result = await tool.execute({ parameters: { tool: 'terminal' } });
+      expect(result.success).toBe(true);
+      expect(mockRegistry.getTool).toHaveBeenCalledWith('terminal');
+    });
+
+    test('should handle nested list parameter', async () => {
+      const mockRegistry = {
+        getTool: jest.fn().mockReturnValue({ isEnabled: true }),
+        listTools: jest.fn().mockReturnValue([]),
+        toolSummaries: new Map()
+      };
+      tool.setToolsRegistry(mockRegistry);
+
+      const result = await tool.execute({ parameters: { list: true } });
+      expect(result.success).toBe(true);
+      expect(result.action).toBe('list-tools');
+    });
+  });
+});

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
+      }));
+    });
+  });
+});