fix tests, lint

Author: bhouston

package.json

@@ -51,11 +51,12 @@
   "dependencies": {
     "@anthropic-ai/sdk": "^0.36",
     "@playwright/test": "^1.50.1",
+    "@vitest/browser": "^3.0.5",
     "chalk": "^5",
     "dotenv": "^16",
     "eslint-plugin-promise": "^7.2.1",
-    "semver": "^7.7.1",
     "playwright": "^1.50.1",
+    "semver": "^7.7.1",
     "source-map-support": "^0.5",
     "uuid": "^11",
     "yargs": "^17",

pnpm-lock.yaml

@@ -64,7 +64,7 @@ describe('toolAgent', () => {
       type: 'string',
       description: 'The processed result',
     },
-    execute: ({ input }) =>  Promise.resolve( `Processed: ${input}`),
+    execute: ({ input }) => Promise.resolve(`Processed: ${input}`),
   };
 
   const sequenceCompleteTool: Tool = {
@@ -84,7 +84,7 @@ describe('toolAgent', () => {
       type: 'string',
       description: 'The final result',
     },
-    execute: ({ result }) => Promise.resolve( result),
+    execute: ({ result }) => Promise.resolve(result),
   };
 
   it('should execute tool calls', async () => {

src/core/toolAgent.test.ts

@@ -59,26 +59,26 @@ const CONFIG = {
       'For coding tasks:',
       '0. Try to break large tasks into smaller sub-tasks that can be completed and verified sequentially.',
       "   - trying to make lots of changes in one go can make it really hard to identify when something doesn't work",
-      "   - use sub-agents for each sub-task, leaving the main agent in a supervisory role",
-      "   - when possible ensure the project compiles/builds and the tests pass after each sub-task",
-      "   - give the sub-agents the guidance and context necessary be successful",
-      "1. First understand the context by:",
-      "   - Reading README.md, CONTRIBUTING.md, and similar documentation",
-      "   - Checking project configuration files (e.g., package.json)",
-      "   - Understanding coding standards",
-      "2. Ensure changes:",
-      "   - Follow project conventions",
-      "   - Build successfully",
-      "   - Pass all tests",
-      "3. Update documentation as needed",
-      "4. Consider adding documentation if you encountered setup/understanding challenges",
-      "",
-      "Feel free to use Google and Bing via the browser tools to search for information or for ideas when you get stuck.",
-      "",
-      "When you run into issues or unexpected results, take a step back and read the project documentation and configuration files and look at other source files in the project for examples of what works.",
-      "",
-      "Use sub-agents for parallel tasks, providing them with specific context they need rather than having them rediscover it.",
-    ].join("\\n");
+      '   - use sub-agents for each sub-task, leaving the main agent in a supervisory role',
+      '   - when possible ensure the project compiles/builds and the tests pass after each sub-task',
+      '   - give the sub-agents the guidance and context necessary be successful',
+      '1. First understand the context by:',
+      '   - Reading README.md, CONTRIBUTING.md, and similar documentation',
+      '   - Checking project configuration files (e.g., package.json)',
+      '   - Understanding coding standards',
+      '2. Ensure changes:',
+      '   - Follow project conventions',
+      '   - Build successfully',
+      '   - Pass all tests',
+      '3. Update documentation as needed',
+      '4. Consider adding documentation if you encountered setup/understanding challenges',
+      '',
+      'Feel free to use Google and Bing via the browser tools to search for information or for ideas when you get stuck.',
+      '',
+      'When you run into issues or unexpected results, take a step back and read the project documentation and configuration files and look at other source files in the project for examples of what works.',
+      '',
+      'Use sub-agents for parallel tasks, providing them with specific context they need rather than having them rediscover it.',
+    ].join('\\n');
   },
 };
 
@@ -114,7 +114,7 @@ async function executeTools(
   toolCalls: ToolUseContent[],
   tools: Tool[],
   messages: Message[],
-  logger: Logger
+  logger: Logger,
 ): Promise<ToolCallResult> {
   if (toolCalls.length === 0) {
     return { sequenceCompleted: false, toolResults: [] };
@@ -136,7 +136,7 @@ async function executeTools(
         content: toolResult,
         isComplete: call.name === 'sequenceComplete',
       };
-    })
+    }),
   );
 
   const toolResults = results.map(({ type, tool_use_id, content }) => ({
@@ -161,7 +161,7 @@ export const toolAgent = async (
   initialPrompt: string,
   tools: Tool[],
   logger: Logger,
-  config = CONFIG
+  config = CONFIG,
 ): Promise<ToolAgentResult> => {
   logger.verbose('Starting agent execution');
   logger.verbose('Initial prompt:', initialPrompt);
@@ -190,7 +190,7 @@ export const toolAgent = async (
     logger.verbose(
       `Requesting completion ${i + 1} with ${messages.length} messages with ${
         JSON.stringify(messages).length
-      } bytes`
+      } bytes`,
     );
 
     interactions++;
@@ -219,15 +219,15 @@ export const toolAgent = async (
         interactions,
       };
       logger.verbose(
-        `Agent completed with ${result.tokens.input} input tokens, ${result.tokens.output} output tokens in ${result.interactions} interactions`
+        `Agent completed with ${result.tokens.input} input tokens, ${result.tokens.output} output tokens in ${result.interactions} interactions`,
       );
       return result;
     }
 
     totalInputTokens += response.usage.input_tokens;
     totalOutputTokens += response.usage.output_tokens;
     logger.verbose(
-      `  Token usage: ${response.usage.input_tokens} input, ${response.usage.output_tokens} output`
+      `  Token usage: ${response.usage.input_tokens} input, ${response.usage.output_tokens} output`,
     );
 
     const { content, toolCalls } = processResponse(response);
@@ -246,7 +246,7 @@ export const toolAgent = async (
       toolCalls,
       tools,
       messages,
-      logger
+      logger,
     );
 
     if (sequenceCompleted) {
@@ -261,7 +261,7 @@ export const toolAgent = async (
         interactions,
       };
       logger.verbose(
-        `Agent completed with ${result.tokens.input} input tokens, ${result.tokens.output} output tokens in ${result.interactions} interactions`
+        `Agent completed with ${result.tokens.input} input tokens, ${result.tokens.output} output tokens in ${result.interactions} interactions`,
       );
       return result;
     }
@@ -277,7 +277,7 @@ export const toolAgent = async (
     interactions,
   };
   logger.verbose(
-    `Agent completed with ${result.tokens.input} input tokens, ${result.tokens.output} output tokens in ${result.interactions} interactions`
+    `Agent completed with ${result.tokens.input} input tokens, ${result.tokens.output} output tokens in ${result.interactions} interactions`,
   );
   return result;
 };

src/core/toolAgent.ts

@@ -1,5 +1,5 @@
-import { BrowserManager } from "./BrowserManager.js";
-import { PageController } from "./PageController.js";
+import { BrowserManager } from './BrowserManager.js';
+import { PageController } from './PageController.js';
 
 export class BrowserAutomation {
   private static instance: BrowserAutomation;

src/tools/browser/BrowserAutomation.ts

@@ -24,7 +24,8 @@ export class BrowserManager {
       // Create a new context (equivalent to Puppeteer's incognito context)
       const context = await browser.newContext({
         viewport: null,
-        userAgent: 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
+        userAgent:
+          'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
       });
 
       const page = await context.newPage();
@@ -44,7 +45,7 @@ export class BrowserManager {
       throw new BrowserError(
         'Failed to create browser session',
         BrowserErrorCode.LAUNCH_FAILED,
-        error
+        error,
       );
     }
   }
@@ -54,7 +55,7 @@ export class BrowserManager {
     if (!session) {
       throw new BrowserError(
         'Session not found',
-        BrowserErrorCode.SESSION_ERROR
+        BrowserErrorCode.SESSION_ERROR,
       );
     }
 
@@ -67,7 +68,7 @@ export class BrowserManager {
       throw new BrowserError(
         'Failed to close session',
         BrowserErrorCode.SESSION_ERROR,
-        error
+        error,
       );
     }
   }
@@ -91,7 +92,7 @@ export class BrowserManager {
 
   async closeAllSessions(): Promise<void> {
     const closePromises = Array.from(this.sessions.keys()).map((sessionId) =>
-      this.closeSession(sessionId).catch(() => {})
+      this.closeSession(sessionId).catch(() => {}),
     );
     await Promise.all(closePromises);
   }
@@ -101,9 +102,9 @@ export class BrowserManager {
     if (!session) {
       throw new BrowserError(
         'Session not found',
-        BrowserErrorCode.SESSION_ERROR
+        BrowserErrorCode.SESSION_ERROR,
       );
     }
     return session;
   }
-}
+}

src/tools/browser/BrowserManager.ts

@@ -1,17 +1,17 @@
-import { Page } from "@playwright/test";
+import { Page } from '@playwright/test';
 import {
   SelectorType,
   SelectorOptions,
   BrowserError,
   BrowserErrorCode,
-} from "./types.js";
+} from './types.js';
 
 export class PageController {
   constructor(private page: Page) {}
 
   private getSelector(
     selector: string,
-    type: SelectorType = SelectorType.CSS
+    type: SelectorType = SelectorType.CSS,
   ): string {
     switch (type) {
       case SelectorType.XPATH:
@@ -30,30 +30,30 @@ export class PageController {
   private validateSelector(selector: string, type: SelectorType): void {
     if (!selector) {
       throw new BrowserError(
-        "Invalid selector: empty string",
-        BrowserErrorCode.SELECTOR_INVALID
+        'Invalid selector: empty string',
+        BrowserErrorCode.SELECTOR_INVALID,
       );
     }
   }
 
   async waitForSelector(
     selector: string,
-    options: SelectorOptions = {}
+    options: SelectorOptions = {},
   ): Promise<void> {
     this.validateSelector(selector, options.type || SelectorType.CSS);
     try {
       const locator = this.page.locator(
-        this.getSelector(selector, options.type)
+        this.getSelector(selector, options.type),
       );
       await locator.waitFor({
-        state: options.visible ? "visible" : "attached",
+        state: options.visible ? 'visible' : 'attached',
         timeout: options.timeout,
       });
     } catch (error) {
       throw new BrowserError(
         `Failed to find element: ${error}`,
         BrowserErrorCode.ELEMENT_NOT_FOUND,
-        error
+        error,
       );
     }
   }
@@ -62,53 +62,53 @@ export class PageController {
     this.validateSelector(selector, options.type || SelectorType.CSS);
     try {
       const locator = this.page.locator(
-        this.getSelector(selector, options.type)
+        this.getSelector(selector, options.type),
       );
       await locator.click({ timeout: options.timeout });
     } catch (error) {
       throw new BrowserError(
         `Failed to click element: ${error}`,
         BrowserErrorCode.SELECTOR_ERROR,
-        error
+        error,
       );
     }
   }
 
   async type(
     selector: string,
     text: string,
-    options: SelectorOptions = {}
+    options: SelectorOptions = {},
   ): Promise<void> {
     this.validateSelector(selector, options.type || SelectorType.CSS);
     try {
       const locator = this.page.locator(
-        this.getSelector(selector, options.type)
+        this.getSelector(selector, options.type),
       );
       await locator.fill(text, { timeout: options.timeout });
     } catch (error) {
       throw new BrowserError(
         `Failed to type text: ${error}`,
         BrowserErrorCode.SELECTOR_ERROR,
-        error
+        error,
       );
     }
   }
 
   async getText(
     selector: string,
-    options: SelectorOptions = {}
+    options: SelectorOptions = {},
   ): Promise<string> {
     this.validateSelector(selector, options.type || SelectorType.CSS);
     try {
       const locator = this.page.locator(
-        this.getSelector(selector, options.type)
+        this.getSelector(selector, options.type),
       );
-      return (await locator.textContent()) || "";
+      return (await locator.textContent()) || '';
     } catch (error) {
       throw new BrowserError(
         `Failed to get text: ${error}`,
         BrowserErrorCode.SELECTOR_ERROR,
-        error
+        error,
       );
     }
   }