pocketrb 0.1.0

data/lib/pocketrb/tools/base.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module Pocketrb
+  module Tools
+    # Base class for all tools
+    class Base
+      attr_reader :context
+
+      def initialize(context = {})
+        @context = context
+      end
+
+      # Tool name (must be unique)
+      # @return [String]
+      def name
+        raise NotImplementedError, "#{self.class}#name must be implemented"
+      end
+
+      # Human-readable description
+      # @return [String]
+      def description
+        raise NotImplementedError, "#{self.class}#description must be implemented"
+      end
+
+      # JSON Schema for parameters
+      # @return [Hash]
+      def parameters
+        { type: "object", properties: {}, required: [] }
+      end
+
+      # Execute the tool
+      # @param kwargs [Hash] Tool arguments
+      # @return [String] Result
+      def execute(**kwargs)
+        raise NotImplementedError, "#{self.class}#execute must be implemented"
+      end
+
+      # Check if tool is available in current context
+      # @return [Boolean]
+      def available?
+        true
+      end
+
+      # Convert to OpenAI/Anthropic tool definition format
+      # @return [Hash]
+      def to_definition
+        {
+          type: "function",
+          function: {
+            name: name,
+            description: description,
+            parameters: parameters
+          }
+        }
+      end
+
+      # Convert to Anthropic-native tool format
+      # @return [Hash]
+      def to_anthropic_definition
+        {
+          name: name,
+          description: description,
+          input_schema: parameters
+        }
+      end
+
+      protected
+
+      # Helper to build a successful result
+      def success(message)
+        message.to_s
+      end
+
+      # Helper to build an error result
+      def error(message)
+        "Error: #{message}"
+      end
+
+      # Access workspace from context
+      def workspace
+        @context[:workspace]
+      end
+
+      # Access bus from context
+      def bus
+        @context[:bus]
+      end
+
+      # Resolve a path relative to workspace
+      def resolve_path(path)
+        return Pathname.new(path) if Pathname.new(path).absolute?
+
+        workspace ? workspace.join(path) : Pathname.new(path)
+      end
+
+      # Check if path is within workspace (security)
+      def path_allowed?(path)
+        return true unless workspace
+
+        resolved = resolve_path(path).expand_path
+        workspace_expanded = workspace.expand_path
+
+        resolved.to_s.start_with?(workspace_expanded.to_s)
+      end
+
+      # Validate path is allowed and exists
+      def validate_path!(path, must_exist: true)
+        resolved = resolve_path(path)
+
+        raise ToolError, "Path #{path} is outside workspace" unless path_allowed?(path)
+
+        raise ToolError, "Path does not exist: #{path}" if must_exist && !resolved.exist?
+
+        resolved
+      end
+    end
+  end
+end

data/lib/pocketrb/tools/browser.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require "playwright"
+
+module Pocketrb
+  module Tools
+    # Browser automation tool using Playwright
+    class Browser < Base
+      def name
+        "browser"
+      end
+
+      def description
+        "Automate browser interactions using headless Chromium. Can navigate to URLs, extract text content, take screenshots, interact with elements, and execute JavaScript. Use this for web scraping, research, testing, or any task requiring web browsing."
+      end
+
+      def parameters
+        {
+          type: "object",
+          properties: {
+            action: {
+              type: "string",
+              description: "Action to perform",
+              enum: %w[navigate extract_text screenshot click type execute_js]
+            },
+            url: {
+              type: "string",
+              description: "URL to navigate to (required for navigate action)"
+            },
+            selector: {
+              type: "string",
+              description: "CSS selector for element interaction (required for click, type actions)"
+            },
+            text: {
+              type: "string",
+              description: "Text to type (required for type action)"
+            },
+            javascript: {
+              type: "string",
+              description: "JavaScript code to execute (required for execute_js action)"
+            },
+            screenshot_path: {
+              type: "string",
+              description: "Path to save screenshot (optional, defaults to workspace/screenshot.png)"
+            },
+            wait_time: {
+              type: "integer",
+              description: "Milliseconds to wait after navigation (default: 1000)"
+            }
+          },
+          required: ["action"]
+        }
+      end
+
+      def execute(action:, url: nil, selector: nil, text: nil, javascript: nil, screenshot_path: nil, wait_time: 1000,
+                  **_kwargs)
+        case action
+        when "navigate"
+          return error("URL required for navigate action") unless url
+
+          navigate_and_extract(url, wait_time)
+        when "extract_text"
+          extract_text_from_page
+        when "screenshot"
+          take_screenshot(screenshot_path || "screenshot.png")
+        when "click"
+          return error("Selector required for click action") unless selector
+
+          click_element(selector, wait_time)
+        when "type"
+          return error("Selector and text required for type action") unless selector && text
+
+          type_into_element(selector, text, wait_time)
+        when "execute_js"
+          return error("JavaScript required for execute_js action") unless javascript
+
+          execute_javascript(javascript)
+        else
+          error("Unknown action: #{action}")
+        end
+      rescue Playwright::Error => e
+        error("Playwright error: #{e.message}")
+      rescue StandardError => e
+        error("Unexpected error: #{e.message}")
+      end
+
+      private
+
+      def with_browser
+        Playwright.create(playwright_cli_executable_path: "npx playwright") do |playwright|
+          playwright.chromium.launch(headless: true) do |browser|
+            page = browser.new_page
+            @current_page = page
+            yield page
+          end
+        end
+      ensure
+        @current_page = nil
+      end
+
+      def navigate_and_extract(url, wait_time)
+        with_browser do |page|
+          page.goto(url)
+          page.wait_for_timeout(wait_time)
+
+          title = page.title
+          content = page.text_content("body")
+
+          success("Title: #{title}\n\nContent:\n#{content[0..2000]}#{"...(truncated)" if content.length > 2000}")
+        end
+      end
+
+      def extract_text_from_page
+        return error("No page is currently loaded. Use navigate action first.") unless @current_page
+
+        content = @current_page.text_content("body")
+        success(content[0..5000] + (content.length > 5000 ? "...(truncated)" : ""))
+      end
+
+      def take_screenshot(path)
+        with_browser do |page|
+          screenshot_path = resolve_path(path)
+          page.screenshot(path: screenshot_path.to_s)
+          success("Screenshot saved to #{screenshot_path}")
+        end
+      end
+
+      def click_element(selector, wait_time)
+        with_browser do |page|
+          page.click(selector)
+          page.wait_for_timeout(wait_time)
+          success("Clicked element: #{selector}")
+        end
+      end
+
+      def type_into_element(selector, text, wait_time)
+        with_browser do |page|
+          page.fill(selector, text)
+          page.wait_for_timeout(wait_time)
+          success("Typed into element: #{selector}")
+        end
+      end
+
+      def execute_javascript(javascript)
+        with_browser do |page|
+          result = page.evaluate(javascript)
+          success("JavaScript executed. Result: #{result.inspect}")
+        end
+      end
+    end
+  end
+end