@hanzo/dev 2.1.1 → 3.0.2

package/tests/browser-integration.test.ts

@@ -1,242 +0,0 @@
-import { describe, test, expect, beforeEach, afterEach, jest } from '@jest/globals';
-import { ConfigurableAgentLoop, LLMProvider } from '../src/lib/agent-loop';
-import WebSocket from 'ws';
-import * as http from 'http';
-
-// Mock WebSocket
-jest.mock('ws');
-
-describe('Browser Integration', () => {
-  let agentLoop: ConfigurableAgentLoop;
-  let mockWebSocketServer: http.Server;
-  let mockWebSocket: any;
-
-  beforeEach(() => {
-    // Mock WebSocket connection
-    mockWebSocket = {
-      on: jest.fn(),
-      close: jest.fn(),
-      send: jest.fn()
-    };
-
-    (WebSocket as jest.MockedClass<typeof WebSocket>).mockImplementation(() => mockWebSocket);
-
-    // Create agent loop with browser enabled
-    const provider: LLMProvider = {
-      name: 'Test Provider',
-      type: 'local',
-      model: 'test-model',
-      supportsTools: true,
-      supportsStreaming: false
-    };
-
-    agentLoop = new ConfigurableAgentLoop({
-      provider,
-      maxIterations: 10,
-      enableMCP: false,
-      enableBrowser: true,
-      enableSwarm: false,
-      streamOutput: false,
-      confirmActions: false
-    });
-  });
-
-  afterEach(() => {
-    jest.clearAllMocks();
-    if (mockWebSocketServer) {
-      mockWebSocketServer.close();
-    }
-  });
-
-  describe('browser tool registration', () => {
-    test('should detect and connect to browser extension', async () => {
-      // Simulate successful WebSocket connection
-      mockWebSocket.on.mockImplementation((event: string, handler: Function) => {
-        if (event === 'open') {
-          setTimeout(() => handler(), 10);
-        }
-      });
-
-      // Mock checkBrowserExtension to return true
-      (agentLoop as any).checkBrowserExtension = jest.fn().mockResolvedValue(true);
-
-      await agentLoop.initialize();
-
-      // Verify browser tools were registered
-      const tools = (agentLoop as any).functionCalling.getAvailableTools();
-      const browserTools = tools.filter((t: any) => t.name.startsWith('browser_'));
-      
-      expect(browserTools).toHaveLength(4);
-      expect(browserTools.map((t: any) => t.name)).toContain('browser_navigate');
-      expect(browserTools.map((t: any) => t.name)).toContain('browser_click');
-      expect(browserTools.map((t: any) => t.name)).toContain('browser_screenshot');
-      expect(browserTools.map((t: any) => t.name)).toContain('browser_fill');
-    });
-
-    test('should fall back to Hanzo Browser if extension not available', async () => {
-      // Mock extension check to fail
-      (agentLoop as any).checkBrowserExtension = jest.fn().mockResolvedValue(false);
-      
-      // Mock browser check to succeed
-      global.fetch = jest.fn().mockResolvedValue({ ok: true });
-      
-      await agentLoop.initialize();
-
-      // Verify browser tools were still registered
-      const tools = (agentLoop as any).functionCalling.getAvailableTools();
-      const browserTools = tools.filter((t: any) => t.name.startsWith('browser_'));
-      
-      expect(browserTools).toHaveLength(4);
-    });
-  });
-
-  describe('browser actions', () => {
-    test('should navigate to URL', async () => {
-      const result = await (agentLoop as any).browserNavigate('https://example.com');
-      
-      expect(result).toEqual({
-        success: true,
-        url: 'https://example.com'
-      });
-    });
-
-    test('should click element', async () => {
-      const result = await (agentLoop as any).browserClick('#submit-button');
-      
-      expect(result).toEqual({
-        success: true,
-        selector: '#submit-button'
-      });
-    });
-
-    test('should take screenshot', async () => {
-      const result = await (agentLoop as any).browserScreenshot(true);
-      
-      expect(result).toEqual({
-        success: true,
-        screenshot: 'base64_image_data'
-      });
-    });
-
-    test('should fill form field', async () => {
-      const result = await (agentLoop as any).browserFill('#email', 'test@example.com');
-      
-      expect(result).toEqual({
-        success: true,
-        selector: '#email',
-        value: 'test@example.com'
-      });
-    });
-  });
-
-  describe('browser action execution via LLM', () => {
-    test('should execute browser navigation through agent loop', async () => {
-      // Mock LLM to return browser navigation tool call
-      (agentLoop as any).callLLM = jest.fn().mockResolvedValue({
-        role: 'assistant',
-        content: 'I will navigate to the website.',
-        toolCalls: [{
-          id: 'call_1',
-          name: 'browser_navigate',
-          arguments: { url: 'https://example.com' }
-        }]
-      });
-
-      // Mock tool execution
-      (agentLoop as any).functionCalling.callFunctions = jest.fn()
-        .mockResolvedValue([{ success: true, url: 'https://example.com' }]);
-
-      await agentLoop.initialize();
-      await agentLoop.execute('Navigate to example.com');
-
-      // Verify tool was called
-      expect((agentLoop as any).functionCalling.callFunctions).toHaveBeenCalledWith([{
-        id: 'call_1',
-        name: 'browser_navigate',
-        arguments: { url: 'https://example.com' }
-      }]);
-    });
-
-    test('should handle browser action errors', async () => {
-      // Mock LLM to return browser action
-      (agentLoop as any).callLLM = jest.fn().mockResolvedValue({
-        role: 'assistant',
-        content: 'I will click the button.',
-        toolCalls: [{
-          id: 'call_2',
-          name: 'browser_click',
-          arguments: { selector: '#missing-button' }
-        }]
-      });
-
-      // Mock tool execution to fail
-      (agentLoop as any).functionCalling.callFunctions = jest.fn()
-        .mockRejectedValue(new Error('Element not found'));
-
-      await agentLoop.initialize();
-
-      // Execute should handle the error gracefully
-      await expect(agentLoop.execute('Click the submit button')).resolves.not.toThrow();
-    });
-  });
-
-  describe('browser-based evaluation scenarios', () => {
-    test('should handle multi-step browser automation', async () => {
-      const responses = [
-        {
-          role: 'assistant',
-          content: 'I will navigate to the login page.',
-          toolCalls: [{
-            id: 'nav_1',
-            name: 'browser_navigate',
-            arguments: { url: 'https://example.com/login' }
-          }]
-        },
-        {
-          role: 'assistant',
-          content: 'I will fill in the login form.',
-          toolCalls: [
-            {
-              id: 'fill_1',
-              name: 'browser_fill',
-              arguments: { selector: '#username', value: 'testuser' }
-            },
-            {
-              id: 'fill_2',
-              name: 'browser_fill',
-              arguments: { selector: '#password', value: 'testpass' }
-            }
-          ]
-        },
-        {
-          role: 'assistant',
-          content: 'I will submit the form.',
-          toolCalls: [{
-            id: 'click_1',
-            name: 'browser_click',
-            arguments: { selector: '#submit' }
-          }]
-        },
-        {
-          role: 'assistant',
-          content: 'Login completed successfully.',
-          toolCalls: []
-        }
-      ];
-
-      let callCount = 0;
-      (agentLoop as any).callLLM = jest.fn().mockImplementation(() => {
-        return Promise.resolve(responses[callCount++]);
-      });
-
-      (agentLoop as any).functionCalling.callFunctions = jest.fn()
-        .mockResolvedValue([{ success: true }]);
-
-      await agentLoop.initialize();
-      await agentLoop.execute('Login to the website with username "testuser"');
-
-      // Verify all browser actions were executed
-      expect((agentLoop as any).functionCalling.callFunctions).toHaveBeenCalledTimes(3);
-    });
-  });
-});

package/tests/code-act-agent.test.ts

@@ -1,305 +0,0 @@
-import { describe, test, expect, beforeEach, jest } from '@jest/globals';
-import { CodeActAgent, AgentState } from '../src/lib/code-act-agent';
-import { FunctionCallingSystem } from '../src/lib/function-calling';
-
-describe('CodeActAgent', () => {
-  let agent: CodeActAgent;
-  let mockFunctionCalling: jest.Mocked<FunctionCallingSystem>;
-
-  beforeEach(() => {
-    // Mock function calling system
-    mockFunctionCalling = {
-      registerTool: jest.fn(),
-      callFunctions: jest.fn(),
-      getAvailableTools: jest.fn().mockReturnValue([
-        { name: 'view_file', description: 'View file contents' },
-        { name: 'str_replace', description: 'Replace string in file' },
-        { name: 'run_command', description: 'Run shell command' }
-      ]),
-      getAllToolSchemas: jest.fn().mockReturnValue([])
-    } as any;
-
-    agent = new CodeActAgent('test-agent', mockFunctionCalling);
-  });
-
-  describe('state management', () => {
-    test('should initialize with correct default state', () => {
-      const state = agent.getState();
-      expect(state.currentTask).toBe('');
-      expect(state.plan).toEqual([]);
-      expect(state.completedSteps).toEqual([]);
-      expect(state.currentStep).toBe(0);
-      expect(state.errors).toEqual([]);
-      expect(state.observations).toEqual([]);
-    });
-
-    test('should update state correctly', () => {
-      const newState: Partial<AgentState> = {
-        currentTask: 'Fix bug in login',
-        plan: ['Locate login file', 'Fix validation', 'Test changes'],
-        currentStep: 1
-      };
-
-      agent.setState(newState);
-      const state = agent.getState();
-      
-      expect(state.currentTask).toBe('Fix bug in login');
-      expect(state.plan).toHaveLength(3);
-      expect(state.currentStep).toBe(1);
-    });
-  });
-
-  describe('planning', () => {
-    test('should generate plan for task', async () => {
-      const task = 'Add user authentication to the API';
-      
-      // Mock LLM response for planning
-      const mockPlan = [
-        'Analyze current API structure',
-        'Install authentication dependencies',
-        'Create auth middleware',
-        'Add login/logout endpoints',
-        'Update existing endpoints with auth checks',
-        'Write tests for authentication'
-      ];
-
-      // The agent should generate a plan based on the task
-      await agent.plan(task);
-      
-      const state = agent.getState();
-      expect(state.currentTask).toBe(task);
-      expect(state.plan.length).toBeGreaterThan(0);
-    });
-
-    test('should handle planning errors gracefully', async () => {
-      const task = 'Invalid task that causes error';
-      
-      // Even with errors, planning should not throw
-      await expect(agent.plan(task)).resolves.not.toThrow();
-      
-      const state = agent.getState();
-      expect(state.currentTask).toBe(task);
-    });
-  });
-
-  describe('task execution', () => {
-    test('should execute single step', async () => {
-      // Set up agent with a plan
-      agent.setState({
-        currentTask: 'Fix typo in README',
-        plan: ['View README.md', 'Fix typo', 'Verify changes'],
-        currentStep: 0
-      });
-
-      // Mock function calling for view_file
-      mockFunctionCalling.callFunctions.mockResolvedValueOnce([{
-        success: true,
-        content: '# README\n\nThis is a typpo in the readme.'
-      }]);
-
-      const result = await agent.executeStep();
-      
-      expect(result.completed).toBe(false);
-      expect(result.action).toBe('View README.md');
-      expect(mockFunctionCalling.callFunctions).toHaveBeenCalled();
-    });
-
-    test('should handle step execution errors', async () => {
-      agent.setState({
-        currentTask: 'Run failing command',
-        plan: ['Execute broken command'],
-        currentStep: 0
-      });
-
-      // Mock function calling to throw error
-      mockFunctionCalling.callFunctions.mockRejectedValueOnce(
-        new Error('Command not found')
-      );
-
-      const result = await agent.executeStep();
-      
-      expect(result.completed).toBe(false);
-      expect(result.error).toBe('Command not found');
-      
-      const state = agent.getState();
-      expect(state.errors).toHaveLength(1);
-      expect(state.errors[0]).toContain('Command not found');
-    });
-
-    test('should mark task as completed when all steps done', async () => {
-      agent.setState({
-        currentTask: 'Simple task',
-        plan: ['Step 1', 'Step 2'],
-        currentStep: 1,
-        completedSteps: ['Step 1']
-      });
-
-      // Mock successful execution
-      mockFunctionCalling.callFunctions.mockResolvedValueOnce([{
-        success: true
-      }]);
-
-      const result = await agent.executeStep();
-      
-      expect(result.completed).toBe(true);
-      expect(result.action).toBe('Step 2');
-      
-      const state = agent.getState();
-      expect(state.completedSteps).toHaveLength(2);
-    });
-  });
-
-  describe('parallel execution', () => {
-    test('should identify parallelizable steps', () => {
-      const plan = [
-        'Download file A',
-        'Download file B', 
-        'Process file A',
-        'Process file B',
-        'Merge results'
-      ];
-
-      const parallel = agent.identifyParallelSteps(plan);
-      
-      // Downloads can be parallel
-      expect(parallel[0]).toEqual([0, 1]);
-      // Processing depends on downloads
-      expect(parallel[1]).toEqual([2]);
-      expect(parallel[2]).toEqual([3]);
-      // Merge depends on processing
-      expect(parallel[3]).toEqual([4]);
-    });
-
-    test('should execute parallel steps concurrently', async () => {
-      agent.setState({
-        currentTask: 'Parallel downloads',
-        plan: ['Download file1.txt', 'Download file2.txt', 'Merge files'],
-        currentStep: 0
-      });
-
-      // Mock both downloads to succeed
-      mockFunctionCalling.callFunctions
-        .mockResolvedValueOnce([{ success: true, file: 'file1.txt' }])
-        .mockResolvedValueOnce([{ success: true, file: 'file2.txt' }]);
-
-      // Execute should handle parallel steps
-      const result1 = await agent.executeStep();
-      expect(result1.action).toContain('Download');
-      
-      // The agent should recognize these can be parallel
-      const state = agent.getState();
-      expect(state.currentStep).toBeLessThanOrEqual(2);
-    });
-  });
-
-  describe('self-correction', () => {
-    test('should retry failed steps with corrections', async () => {
-      agent.setState({
-        currentTask: 'Fix syntax error',
-        plan: ['Edit file with error'],
-        currentStep: 0
-      });
-
-      // First attempt fails
-      mockFunctionCalling.callFunctions.mockResolvedValueOnce([{
-        success: false,
-        error: 'Syntax error in edit'
-      }]);
-
-      // Agent should detect error and retry
-      const result1 = await agent.executeStep();
-      expect(result1.error).toBeDefined();
-
-      // Second attempt with correction succeeds
-      mockFunctionCalling.callFunctions.mockResolvedValueOnce([{
-        success: true
-      }]);
-
-      const result2 = await agent.executeStep();
-      expect(result2.error).toBeUndefined();
-      expect(result2.retryCount).toBeGreaterThan(0);
-    });
-
-    test('should give up after max retries', async () => {
-      agent.setState({
-        currentTask: 'Impossible task',
-        plan: ['Do impossible thing'],
-        currentStep: 0
-      });
-
-      // All attempts fail
-      mockFunctionCalling.callFunctions.mockRejectedValue(
-        new Error('Cannot do impossible thing')
-      );
-
-      let lastResult;
-      for (let i = 0; i < 5; i++) {
-        lastResult = await agent.executeStep();
-      }
-
-      expect(lastResult!.error).toBeDefined();
-      expect(lastResult!.aborted).toBe(true);
-    });
-  });
-
-  describe('observation handling', () => {
-    test('should collect and store observations', async () => {
-      agent.setState({
-        currentTask: 'Analyze codebase',
-        plan: ['List files', 'Read main file'],
-        currentStep: 0
-      });
-
-      // Mock file listing
-      mockFunctionCalling.callFunctions.mockResolvedValueOnce([{
-        success: true,
-        output: 'file1.js\nfile2.js\nindex.js'
-      }]);
-
-      await agent.executeStep();
-      
-      const state = agent.getState();
-      expect(state.observations).toHaveLength(1);
-      expect(state.observations[0]).toContain('file1.js');
-    });
-
-    test('should use observations for context', async () => {
-      // Pre-populate observations
-      agent.setState({
-        currentTask: 'Fix bug',
-        plan: ['Find bug location', 'Fix bug'],
-        currentStep: 1,
-        observations: ['Bug is in auth.js on line 42']
-      });
-
-      // The agent should use the observation context
-      mockFunctionCalling.callFunctions.mockResolvedValueOnce([{
-        success: true,
-        result: 'Fixed bug in auth.js'
-      }]);
-
-      const result = await agent.executeStep();
-      expect(result.completed).toBe(true);
-    });
-  });
-
-  describe('complete task execution', () => {
-    test('should execute entire task from plan to completion', async () => {
-      const task = 'Add logging to application';
-      
-      // Mock successful execution of all steps
-      mockFunctionCalling.callFunctions
-        .mockResolvedValueOnce([{ success: true }]) // Install logger
-        .mockResolvedValueOnce([{ success: true }]) // Create logger config
-        .mockResolvedValueOnce([{ success: true }]) // Add logging statements
-        .mockResolvedValueOnce([{ success: true }]); // Test logging
-
-      await agent.plan(task);
-      const result = await agent.execute(task);
-      
-      expect(result.success).toBe(true);
-      expect(result.completedSteps.length).toBeGreaterThan(0);
-      expect(result.errors).toHaveLength(0);
-    });
-  });
-});