btcp-browser-agent 0.1.0 → 0.1.1

package/packages/cli/src/__tests__/executor.test.ts

@@ -1,275 +0,0 @@
-/**
- * Executor tests
- */
-
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { executeCommand, executeCommandString } from '../executor.js';
-import { parseCommand } from '../parser.js';
-import { CommandNotFoundError, ExecutionError, CLIError } from '../errors.js';
-import type { CommandClient, ParsedCommand } from '../types.js';
-
-/**
- * Create a mock client for testing
- */
-function createMockClient(overrides: Partial<CommandClient> = {}): CommandClient {
-  return {
-    execute: vi.fn().mockResolvedValue({ id: '1', success: true }),
-    navigate: vi.fn().mockResolvedValue({ id: '1', success: true }),
-    back: vi.fn().mockResolvedValue({ id: '1', success: true }),
-    forward: vi.fn().mockResolvedValue({ id: '1', success: true }),
-    reload: vi.fn().mockResolvedValue({ id: '1', success: true }),
-    getUrl: vi.fn().mockResolvedValue('https://example.com'),
-    getTitle: vi.fn().mockResolvedValue('Example Page'),
-    snapshot: vi.fn().mockResolvedValue('- button "Submit" [@ref:1]'),
-    click: vi.fn().mockResolvedValue({ id: '1', success: true }),
-    type: vi.fn().mockResolvedValue({ id: '1', success: true }),
-    fill: vi.fn().mockResolvedValue({ id: '1', success: true }),
-    getText: vi.fn().mockResolvedValue('Hello'),
-    isVisible: vi.fn().mockResolvedValue(true),
-    screenshot: vi.fn().mockResolvedValue('data:image/png;base64,ABC123'),
-    tabNew: vi.fn().mockResolvedValue({ tabId: 123, url: 'about:blank' }),
-    tabClose: vi.fn().mockResolvedValue({ id: '1', success: true }),
-    tabSwitch: vi.fn().mockResolvedValue({ id: '1', success: true }),
-    tabList: vi.fn().mockResolvedValue([
-      { id: 1, url: 'https://example.com', title: 'Example', active: true, index: 0 },
-    ]),
-    ...overrides,
-  };
-}
-
-describe('executeCommand', () => {
-  let client: CommandClient;
-
-  beforeEach(() => {
-    client = createMockClient();
-  });
-
-  describe('command lookup', () => {
-    it('executes valid command', async () => {
-      const command: ParsedCommand = {
-        name: 'snapshot',
-        args: [],
-        flags: {},
-        raw: 'snapshot',
-      };
-      const result = await executeCommand(client, command);
-      expect(result.success).toBe(true);
-      expect(client.snapshot).toHaveBeenCalled();
-    });
-
-    it('throws CommandNotFoundError for unknown command', async () => {
-      const command: ParsedCommand = {
-        name: 'unknowncommand',
-        args: [],
-        flags: {},
-        raw: 'unknowncommand',
-      };
-      await expect(executeCommand(client, command)).rejects.toThrow(CommandNotFoundError);
-    });
-
-    it('includes similar commands in CommandNotFoundError', async () => {
-      const command: ParsedCommand = {
-        name: 'clck',
-        args: [],
-        flags: {},
-        raw: 'clck',
-      };
-      try {
-        await executeCommand(client, command);
-        expect.fail('Should have thrown');
-      } catch (error) {
-        expect(error).toBeInstanceOf(CommandNotFoundError);
-        const cmdError = error as CommandNotFoundError;
-        expect(cmdError.suggestions).toBeDefined();
-        expect(cmdError.suggestions?.some((s) => s.includes('click'))).toBe(true);
-      }
-    });
-  });
-
-  describe('command execution', () => {
-    it('passes args to command handler', async () => {
-      const command: ParsedCommand = {
-        name: 'goto',
-        args: ['https://example.com'],
-        flags: {},
-        raw: 'goto https://example.com',
-      };
-      await executeCommand(client, command);
-      expect(client.navigate).toHaveBeenCalledWith('https://example.com');
-    });
-
-    it('passes flags to command handler', async () => {
-      const command: ParsedCommand = {
-        name: 'reload',
-        args: [],
-        flags: { hard: true },
-        raw: 'reload --hard',
-      };
-      await executeCommand(client, command);
-      expect(client.reload).toHaveBeenCalledWith({ bypassCache: true });
-    });
-
-    it('returns command result', async () => {
-      const command: ParsedCommand = {
-        name: 'url',
-        args: [],
-        flags: {},
-        raw: 'url',
-      };
-      const result = await executeCommand(client, command);
-      expect(result.success).toBe(true);
-      expect(result.data).toBe('https://example.com');
-    });
-  });
-
-  describe('error handling', () => {
-    it('adds contextual suggestion on error result', async () => {
-      client = createMockClient({
-        click: vi.fn().mockResolvedValue({
-          id: '1',
-          success: false,
-          error: 'Element not found',
-        }),
-      });
-      const command: ParsedCommand = {
-        name: 'click',
-        args: ['@ref:5'],
-        flags: {},
-        raw: 'click @ref:5',
-      };
-      const result = await executeCommand(client, command);
-      expect(result.success).toBe(false);
-      expect(result.error).toContain('Element not found');
-      // Should include contextual suggestion
-      expect(result.error).toContain('snapshot');
-    });
-
-    it('re-throws CLIError as-is', async () => {
-      const cliError = new CLIError('Custom CLI error');
-      client = createMockClient({
-        click: vi.fn().mockRejectedValue(cliError),
-      });
-      const command: ParsedCommand = {
-        name: 'click',
-        args: ['@ref:1'],
-        flags: {},
-        raw: 'click @ref:1',
-      };
-      await expect(executeCommand(client, command)).rejects.toBe(cliError);
-    });
-
-    it('wraps unexpected errors in ExecutionError', async () => {
-      const genericError = new Error('Network failure');
-      client = createMockClient({
-        navigate: vi.fn().mockRejectedValue(genericError),
-      });
-      const command: ParsedCommand = {
-        name: 'goto',
-        args: ['https://example.com'],
-        flags: {},
-        raw: 'goto https://example.com',
-      };
-      try {
-        await executeCommand(client, command);
-        expect.fail('Should have thrown');
-      } catch (error) {
-        expect(error).toBeInstanceOf(ExecutionError);
-        const execError = error as ExecutionError;
-        expect(execError.message).toContain('Network failure');
-        expect(execError.command).toBe('goto');
-      }
-    });
-
-    it('includes contextual suggestion in wrapped error', async () => {
-      const genericError = new Error('Failed to navigate');
-      client = createMockClient({
-        navigate: vi.fn().mockRejectedValue(genericError),
-      });
-      const command: ParsedCommand = {
-        name: 'goto',
-        args: ['example.com'],
-        flags: {},
-        raw: 'goto example.com',
-      };
-      try {
-        await executeCommand(client, command);
-        expect.fail('Should have thrown');
-      } catch (error) {
-        expect(error).toBeInstanceOf(ExecutionError);
-        const execError = error as ExecutionError;
-        // Should include suggestion about URL format
-        expect(execError.suggestions).toBeDefined();
-      }
-    });
-  });
-
-  describe('result passthrough', () => {
-    it('returns success result unchanged when no error', async () => {
-      const command: ParsedCommand = {
-        name: 'snapshot',
-        args: [],
-        flags: {},
-        raw: 'snapshot',
-      };
-      const result = await executeCommand(client, command);
-      expect(result.success).toBe(true);
-      expect(result.data).toContain('button');
-    });
-
-    it('returns error result from command handler', async () => {
-      client = createMockClient({
-        click: vi.fn().mockResolvedValue({
-          id: '1',
-          success: false,
-          error: 'Failed',
-        }),
-      });
-      const command: ParsedCommand = {
-        name: 'click',
-        args: ['@ref:1'],
-        flags: {},
-        raw: 'click @ref:1',
-      };
-      const result = await executeCommand(client, command);
-      // Command handler transforms result, doesn't preserve raw data
-      expect(result.success).toBe(false);
-      expect(result.error).toContain('Failed');
-    });
-  });
-});
-
-describe('executeCommandString', () => {
-  let client: CommandClient;
-
-  beforeEach(() => {
-    client = createMockClient();
-  });
-
-  it('parses and executes command string', async () => {
-    const result = await executeCommandString(
-      client,
-      'goto https://example.com',
-      parseCommand
-    );
-    expect(result.success).toBe(true);
-    expect(client.navigate).toHaveBeenCalledWith('https://example.com');
-  });
-
-  it('handles parse errors', async () => {
-    await expect(
-      executeCommandString(client, '', parseCommand)
-    ).rejects.toThrow('Empty command');
-  });
-
-  it('uses custom parser', async () => {
-    const customParser = vi.fn().mockReturnValue({
-      name: 'snapshot',
-      args: [],
-      flags: {},
-      raw: 'custom',
-    });
-    await executeCommandString(client, 'custom', customParser);
-    expect(customParser).toHaveBeenCalledWith('custom');
-    expect(client.snapshot).toHaveBeenCalled();
-  });
-});

package/packages/cli/src/__tests__/formatter.test.ts

@@ -1,260 +0,0 @@
-/**
- * Formatter tests
- */
-
-import { describe, it, expect } from 'vitest';
-import {
-  formatResult,
-  formatData,
-  formatHelp,
-  formatCommandHelp,
-  formatScreenshot,
-  formatErrorWithSuggestions,
-  formatSuccessWithNextSteps,
-} from '../formatter.js';
-
-describe('formatResult', () => {
-  describe('success results', () => {
-    it('formats success with message', () => {
-      const result = formatResult({ success: true, message: 'Navigated to example.com' });
-      expect(result.type).toBe('success');
-      expect(result.content).toBe('✓ Navigated to example.com');
-    });
-
-    it('formats success with data', () => {
-      const result = formatResult({ success: true, data: 'Some data' });
-      expect(result.type).toBe('data');
-      expect(result.content).toBe('Some data');
-    });
-
-    it('formats success without message or data', () => {
-      const result = formatResult({ success: true });
-      expect(result.type).toBe('success');
-      expect(result.content).toBe('✓ Done');
-    });
-
-    it('prefers message over data', () => {
-      const result = formatResult({ success: true, message: 'Done!', data: 'ignored' });
-      expect(result.content).toBe('✓ Done!');
-    });
-  });
-
-  describe('error results', () => {
-    it('formats error with message', () => {
-      const result = formatResult({ success: false, error: 'Something went wrong' });
-      expect(result.type).toBe('error');
-      expect(result.content).toBe('✗ Error: Something went wrong');
-    });
-
-    it('formats error without message', () => {
-      const result = formatResult({ success: false });
-      expect(result.type).toBe('error');
-      expect(result.content).toBe('✗ Error: Unknown error');
-    });
-  });
-});
-
-describe('formatData', () => {
-  describe('primitive types', () => {
-    it('formats null', () => {
-      expect(formatData(null)).toBe('');
-    });
-
-    it('formats undefined', () => {
-      expect(formatData(undefined)).toBe('');
-    });
-
-    it('formats string', () => {
-      expect(formatData('hello')).toBe('hello');
-    });
-
-    it('formats number', () => {
-      expect(formatData(42)).toBe('42');
-    });
-
-    it('formats boolean', () => {
-      expect(formatData(true)).toBe('true');
-      expect(formatData(false)).toBe('false');
-    });
-  });
-
-  describe('arrays', () => {
-    it('formats empty array', () => {
-      expect(formatData([])).toBe('(empty)');
-    });
-
-    it('formats array of primitives', () => {
-      expect(formatData(['a', 'b', 'c'])).toBe('a\nb\nc');
-    });
-
-    it('formats array of numbers', () => {
-      expect(formatData([1, 2, 3])).toBe('1\n2\n3');
-    });
-
-    it('formats array of objects with indices', () => {
-      const result = formatData([{ name: 'a' }, { name: 'b' }]);
-      expect(result).toContain('[0]');
-      expect(result).toContain('[1]');
-    });
-  });
-
-  describe('objects', () => {
-    it('formats empty object', () => {
-      expect(formatData({})).toBe('{}');
-    });
-
-    it('formats simple object', () => {
-      const result = formatData({ name: 'test', value: 42 });
-      expect(result).toContain('name: test');
-      expect(result).toContain('value: 42');
-    });
-
-    // Removed: snapshot now returns string directly, not object with tree field
-  });
-});
-
-describe('formatHelp', () => {
-  it('formats command list', () => {
-    const commands = [
-      { name: 'goto', description: 'Navigate to URL', usage: 'goto <url>' },
-      { name: 'click', description: 'Click element', usage: 'click <selector>' },
-    ];
-    const result = formatHelp(commands);
-    expect(result).toContain('goto');
-    expect(result).toContain('Navigate to URL');
-    expect(result).toContain('click');
-    expect(result).toContain('Click element');
-  });
-
-  it('aligns descriptions', () => {
-    const commands = [
-      { name: 'a', description: 'Short', usage: 'a' },
-      { name: 'longer', description: 'Longer name', usage: 'longer' },
-    ];
-    const result = formatHelp(commands);
-    // Both descriptions should be aligned
-    const lines = result.split('\n');
-    expect(lines.length).toBe(2);
-  });
-});
-
-describe('formatCommandHelp', () => {
-  it('formats command with all fields', () => {
-    const command = {
-      name: 'click',
-      description: 'Click an element',
-      usage: 'click <selector>',
-      examples: ['click @ref:5', 'click #submit'],
-    };
-    const result = formatCommandHelp(command);
-    expect(result).toContain('click');
-    expect(result).toContain('Click an element');
-    expect(result).toContain('click <selector>');
-    expect(result).toContain('click @ref:5');
-    expect(result).toContain('click #submit');
-  });
-
-  it('formats command without examples', () => {
-    const command = {
-      name: 'back',
-      description: 'Go back in history',
-      usage: 'back',
-    };
-    const result = formatCommandHelp(command);
-    expect(result).toContain('back');
-    expect(result).toContain('Go back in history');
-    expect(result).not.toContain('Examples');
-  });
-
-  it('includes selector help for interaction commands', () => {
-    const command = {
-      name: 'click',
-      description: 'Click an element',
-      usage: 'click <selector>',
-    };
-    const result = formatCommandHelp(command);
-    expect(result).toContain('Selectors');
-    expect(result).toContain('@ref:N');
-    expect(result).toContain('#id');
-  });
-
-  it('excludes selector help for non-interaction commands', () => {
-    const command = {
-      name: 'goto',
-      description: 'Navigate to URL',
-      usage: 'goto <url>',
-    };
-    const result = formatCommandHelp(command);
-    expect(result).not.toContain('Selectors');
-  });
-});
-
-describe('formatScreenshot', () => {
-  it('extracts format and size from PNG data URL', () => {
-    // Create a small base64 string (~100 bytes)
-    const base64 = 'A'.repeat(100);
-    const dataUrl = `data:image/png;base64,${base64}`;
-    const result = formatScreenshot(dataUrl);
-    expect(result).toContain('png');
-    expect(result).toContain('KB');
-  });
-
-  it('extracts format and size from JPEG data URL', () => {
-    const base64 = 'A'.repeat(1000);
-    const dataUrl = `data:image/jpeg;base64,${base64}`;
-    const result = formatScreenshot(dataUrl);
-    expect(result).toContain('jpeg');
-    expect(result).toContain('KB');
-  });
-
-  it('handles invalid data URL', () => {
-    const result = formatScreenshot('not-a-data-url');
-    expect(result).toBe('Screenshot captured');
-  });
-});
-
-describe('formatErrorWithSuggestions', () => {
-  it('formats error without suggestions', () => {
-    const result = formatErrorWithSuggestions('Something failed');
-    expect(result).toBe('✗ Error: Something failed');
-  });
-
-  it('formats error with suggestions', () => {
-    const result = formatErrorWithSuggestions('Element not found', [
-      'Run snapshot first',
-      'Check selector syntax',
-    ]);
-    expect(result).toContain('✗ Error: Element not found');
-    expect(result).toContain('Suggestions:');
-    expect(result).toContain('Run snapshot first');
-    expect(result).toContain('Check selector syntax');
-  });
-
-  it('formats error with empty suggestions array', () => {
-    const result = formatErrorWithSuggestions('Error', []);
-    expect(result).toBe('✗ Error: Error');
-  });
-});
-
-describe('formatSuccessWithNextSteps', () => {
-  it('formats success without next steps', () => {
-    const result = formatSuccessWithNextSteps('Operation completed');
-    expect(result).toBe('✓ Operation completed');
-  });
-
-  it('formats success with next steps', () => {
-    const result = formatSuccessWithNextSteps('Navigated successfully', [
-      'snapshot  # See page elements',
-      'click @ref:N  # Interact',
-    ]);
-    expect(result).toContain('✓ Navigated successfully');
-    expect(result).toContain('Next steps:');
-    expect(result).toContain('snapshot');
-    expect(result).toContain('click');
-  });
-
-  it('formats success with empty next steps array', () => {
-    const result = formatSuccessWithNextSteps('Done', []);
-    expect(result).toBe('✓ Done');
-  });
-});