pocketrb 0.1.0

data/lib/pocketrb/tools/registry.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+module Pocketrb
+  module Tools
+    # Registry for managing available tools
+    class Registry
+      attr_reader :context
+
+      def initialize(context = {})
+        @tools = {}
+        @context = context
+      end
+
+      # Register a tool instance
+      # @param tool [Base] Tool instance
+      def register(tool)
+        raise ArgumentError, "Tool must inherit from Tools::Base" unless tool.is_a?(Base)
+
+        @tools[tool.name] = tool
+        Pocketrb.logger.debug("Registered tool: #{tool.name}")
+      end
+
+      # Register a tool class (will be instantiated with context)
+      # @param klass [Class] Tool class
+      def register_class(klass)
+        tool = klass.new(@context)
+        register(tool)
+      end
+
+      # Unregister a tool
+      # @param name [String] Tool name
+      def unregister(name)
+        @tools.delete(name)
+      end
+
+      # Get a tool by name
+      # @param name [String] Tool name
+      # @return [Base|nil]
+      def get(name)
+        @tools[name]
+      end
+
+      # Check if a tool exists
+      # @param name [String] Tool name
+      # @return [Boolean]
+      def exists?(name)
+        @tools.key?(name)
+      end
+
+      # Get all tool names
+      # @return [Array<String>]
+      def names
+        @tools.keys
+      end
+
+      # Get all available tool definitions (for LLM)
+      # @param filter_unavailable [Boolean] Exclude unavailable tools
+      # @return [Array<Hash>]
+      def definitions(filter_unavailable: true)
+        tools = filter_unavailable ? available_tools : @tools.values
+        tools.map(&:to_definition)
+      end
+
+      # Get Anthropic-format definitions
+      # @return [Array<Hash>]
+      def anthropic_definitions(filter_unavailable: true)
+        tools = filter_unavailable ? available_tools : @tools.values
+        tools.map(&:to_anthropic_definition)
+      end
+
+      # Execute a tool
+      # @param name [String] Tool name
+      # @param arguments [Hash] Tool arguments
+      # @return [String] Result
+      def execute(name, arguments)
+        tool = get(name)
+        raise ToolError, "Unknown tool: #{name}" unless tool
+        raise ToolError, "Tool #{name} is not available" unless tool.available?
+
+        start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+        begin
+          # Convert string keys to symbols and filter to known parameters
+          args = arguments.transform_keys(&:to_sym)
+          args = filter_arguments(tool, args)
+          result = tool.execute(**args)
+
+          duration = ((Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time) * 1000).to_i
+          Pocketrb.logger.debug("Tool #{name} executed in #{duration}ms")
+
+          result
+        rescue StandardError => e
+          Pocketrb.logger.error("Tool #{name} failed: #{e.message}")
+          raise ToolError, "Tool execution failed: #{e.message}"
+        end
+      end
+
+      # Get only available tools
+      # @return [Array<Base>]
+      def available_tools
+        @tools.values.select(&:available?)
+      end
+
+      # Number of registered tools
+      # @return [Integer]
+      def size
+        @tools.size
+      end
+
+      # Clear all tools
+      def clear!
+        @tools.clear
+      end
+
+      # Update context for all tools
+      def update_context(new_context)
+        @context = @context.merge(new_context)
+        @tools.each_value { |tool| tool.instance_variable_set(:@context, @context) }
+      end
+
+      # Register default core tools
+      def register_defaults!
+        [
+          ReadFile,
+          WriteFile,
+          EditFile,
+          ListDir,
+          Exec,
+          Jobs,
+          Cron,
+          WebSearch,
+          WebFetch,
+          Think,
+          Message,
+          SendFile,
+          BrowserAdvanced,
+          Memory
+        ].each { |klass| register_class(klass) }
+      end
+
+      private
+
+      # Filter arguments to only include those defined in tool's parameter schema
+      # This prevents LLM from passing unexpected arguments like 'description'
+      def filter_arguments(tool, args)
+        schema = tool.parameters
+        return args unless schema.is_a?(Hash) && schema[:properties]
+
+        allowed_keys = schema[:properties].keys.map(&:to_sym)
+        filtered = args.slice(*allowed_keys)
+
+        # Log filtered out keys for debugging
+        removed = args.keys - filtered.keys
+        Pocketrb.logger.debug("Filtered out unknown arguments for #{tool.name}: #{removed.join(", ")}") if removed.any?
+
+        filtered
+      end
+    end
+  end
+end

data/lib/pocketrb/tools/send_file.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+module Pocketrb
+  module Tools
+    # Tool for sending files/images to chat channels
+    class SendFile < Base
+      ALLOWED_EXTENSIONS = %w[
+        .jpg .jpeg .png .gif .webp .bmp
+        .pdf .txt .md .json .csv .xml
+        .mp3 .ogg .wav .m4a
+        .mp4 .webm .mov
+        .zip .tar .gz
+      ].freeze
+
+      def name
+        "send_file"
+      end
+
+      def description
+        "Send a file (image, document, audio, video) to the user via chat. Use this to share generated content, screenshots, reports, or any files."
+      end
+
+      def parameters
+        {
+          type: "object",
+          properties: {
+            path: {
+              type: "string",
+              description: "Path to the file to send"
+            },
+            caption: {
+              type: "string",
+              description: "Optional caption/message to send with the file"
+            },
+            channel: {
+              type: "string",
+              description: "Target channel (telegram, whatsapp, cli). Uses default if not specified."
+            },
+            chat_id: {
+              type: "string",
+              description: "Recipient chat ID. Uses default if not specified."
+            }
+          },
+          required: ["path"]
+        }
+      end
+
+      def execute(path:, caption: nil, channel: nil, chat_id: nil)
+        # Resolve path
+        file_path = resolve_path(path)
+        return error("File not found: #{path}") unless File.exist?(file_path)
+        return error("Not a file: #{path}") unless File.file?(file_path)
+
+        # Check file size (Telegram limit is 50MB for bots)
+        size = File.size(file_path)
+        return error("File too large (#{size / 1_000_000}MB). Max 50MB.") if size > 50_000_000
+
+        # Check extension
+        ext = File.extname(file_path).downcase
+        return error("File type not allowed: #{ext}") unless ALLOWED_EXTENSIONS.include?(ext)
+
+        # Use defaults from context
+        channel = (channel || @context[:default_channel])&.to_sym
+        chat_id ||= @context[:default_chat_id]
+
+        return error("No channel specified and no default channel") unless channel
+        return error("No chat_id specified and no default chat_id") unless chat_id
+        return error("Message bus not available") unless bus
+
+        # Create media object
+        media = create_media(file_path)
+
+        # Send message with media
+        outbound = Bus::OutboundMessage.new(
+          channel: channel,
+          chat_id: chat_id,
+          content: caption || "",
+          media: [media]
+        )
+
+        bus.publish_outbound(outbound)
+        Pocketrb.logger.info("File sent to #{channel}:#{chat_id}: #{file_path}")
+
+        success("Sent #{File.basename(file_path)} to #{channel}")
+      end
+
+      def available?
+        !bus.nil?
+      end
+
+      private
+
+      def bus
+        @context[:bus]
+      end
+
+      def resolve_path(path)
+        return path if Pathname.new(path).absolute?
+
+        workspace.join(path).to_s
+      end
+
+      def create_media(path)
+        ext = File.extname(path).downcase
+        mime_type = detect_mime_type(ext)
+        type = detect_type(ext)
+
+        Bus::Media.new(
+          type: type,
+          path: path,
+          mime_type: mime_type,
+          filename: File.basename(path),
+          data: nil # Will be read from path when sending
+        )
+      end
+
+      def detect_type(ext)
+        case ext
+        when ".jpg", ".jpeg", ".png", ".gif", ".webp", ".bmp"
+          :image
+        when ".mp3", ".ogg", ".wav", ".m4a"
+          :audio
+        when ".mp4", ".webm", ".mov"
+          :video
+        else
+          :file
+        end
+      end
+
+      def detect_mime_type(ext)
+        {
+          ".jpg" => "image/jpeg",
+          ".jpeg" => "image/jpeg",
+          ".png" => "image/png",
+          ".gif" => "image/gif",
+          ".webp" => "image/webp",
+          ".bmp" => "image/bmp",
+          ".pdf" => "application/pdf",
+          ".txt" => "text/plain",
+          ".md" => "text/markdown",
+          ".json" => "application/json",
+          ".csv" => "text/csv",
+          ".xml" => "application/xml",
+          ".mp3" => "audio/mpeg",
+          ".ogg" => "audio/ogg",
+          ".wav" => "audio/wav",
+          ".m4a" => "audio/mp4",
+          ".mp4" => "video/mp4",
+          ".webm" => "video/webm",
+          ".mov" => "video/quicktime",
+          ".zip" => "application/zip",
+          ".tar" => "application/x-tar",
+          ".gz" => "application/gzip"
+        }[ext] || "application/octet-stream"
+      end
+    end
+  end
+end

data/lib/pocketrb/tools/think.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Pocketrb
+  module Tools
+    # Internal reasoning tool for complex problem solving
+    class Think < Base
+      def name
+        "think"
+      end
+
+      def description
+        "Use this tool to think through complex problems step by step. The content is not shown to the user but helps you reason through the task. Use it when you need to analyze information, plan an approach, or work through logic."
+      end
+
+      def parameters
+        {
+          type: "object",
+          properties: {
+            thought: {
+              type: "string",
+              description: "Your internal reasoning or analysis"
+            }
+          },
+          required: ["thought"]
+        }
+      end
+
+      def execute(thought:)
+        # The thought is logged but not displayed to the user
+        Pocketrb.logger.debug("Agent thought: #{thought[0..200]}...")
+        "Thought recorded."
+      end
+    end
+  end
+end

data/lib/pocketrb/tools/web_fetch.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "faraday/follow_redirects"
+require "uri"
+
+module Pocketrb
+  module Tools
+    # Fetch and extract content from web pages
+    class WebFetch < Base
+      MAX_CONTENT_SIZE = 500_000 # characters
+      TIMEOUT = 30 # seconds
+
+      def name
+        "web_fetch"
+      end
+
+      def description
+        "Fetch content from a URL. Returns the text content of the page. Use for reading documentation, articles, or other web content."
+      end
+
+      def parameters
+        {
+          type: "object",
+          properties: {
+            url: {
+              type: "string",
+              description: "The URL to fetch"
+            },
+            selector: {
+              type: "string",
+              description: "CSS selector to extract specific content (optional)"
+            }
+          },
+          required: ["url"]
+        }
+      end
+
+      def execute(url:, selector: nil)
+        # Validate URL
+        uri = parse_url(url)
+        return error("Invalid URL: #{url}") unless uri
+
+        response = fetch_url(uri)
+        return error("Failed to fetch URL: #{response[:error]}") if response[:error]
+
+        content = extract_content(response[:body], selector)
+        truncate_content(content)
+      rescue Faraday::Error => e
+        error("Request failed: #{e.message}")
+      rescue StandardError => e
+        error("Error fetching URL: #{e.message}")
+      end
+
+      private
+
+      def parse_url(url)
+        # Add https if no scheme
+        url = "https://#{url}" unless url.match?(%r{^https?://})
+
+        uri = URI.parse(url)
+        return nil unless uri.is_a?(URI::HTTP) || uri.is_a?(URI::HTTPS)
+
+        uri
+      rescue URI::InvalidURIError
+        nil
+      end
+
+      def fetch_url(uri)
+        conn = Faraday.new(url: uri.to_s) do |f|
+          f.options.timeout = TIMEOUT
+          f.options.open_timeout = 10
+          f.headers["User-Agent"] = "Pocketrb/#{Pocketrb::VERSION} (Ruby AI Agent)"
+          f.headers["Accept"] = "text/html,text/plain,application/json"
+          f.response :follow_redirects, limit: 5
+          f.adapter Faraday.default_adapter
+        end
+
+        response = conn.get
+
+        if response.success?
+          { body: response.body, content_type: response.headers["content-type"] }
+        else
+          { error: "HTTP #{response.status}" }
+        end
+      end
+
+      def extract_content(body, selector)
+        content_type = detect_content_type(body)
+
+        case content_type
+        when :html
+          extract_html_content(body, selector)
+        when :json
+          format_json(body)
+        else
+          body
+        end
+      end
+
+      def detect_content_type(body)
+        return :json if body.strip.start_with?("{", "[")
+        return :html if body.include?("<html") || body.include?("<body")
+
+        :text
+      end
+
+      def extract_html_content(html, _selector)
+        # Simple HTML to text conversion
+        # A full implementation would use nokogiri
+        text = html
+               .gsub(%r{<script[^>]*>.*?</script>}mi, "")
+               .gsub(%r{<style[^>]*>.*?</style>}mi, "")
+               .gsub(%r{<head[^>]*>.*?</head>}mi, "")
+               .gsub(%r{<nav[^>]*>.*?</nav>}mi, "")
+               .gsub(%r{<footer[^>]*>.*?</footer>}mi, "")
+               .gsub(/<[^>]+>/, "\n")
+               .gsub("&nbsp;", " ")
+               .gsub("&amp;", "&")
+               .gsub("&lt;", "<")
+               .gsub("&gt;", ">")
+               .gsub("&quot;", '"')
+               .gsub(/&#\d+;/) do |m|
+                 [m[2..].to_i].pack("U")
+        rescue StandardError
+          m
+        end
+               .gsub(/\n{3,}/, "\n\n")
+               .strip
+
+        # Clean up whitespace
+        text.lines.map(&:strip).reject(&:empty?).join("\n")
+      end
+
+      def format_json(body)
+        data = JSON.parse(body)
+        JSON.pretty_generate(data)
+      rescue JSON::ParserError
+        body
+      end
+
+      def truncate_content(content)
+        return content if content.length <= MAX_CONTENT_SIZE
+
+        truncated = content[0...MAX_CONTENT_SIZE]
+        "#{truncated}\n\n... [Content truncated at #{MAX_CONTENT_SIZE} characters]"
+      end
+    end
+  end
+end

data/lib/pocketrb/tools/web_search.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "json"
+
+module Pocketrb
+  module Tools
+    # Search the web using Brave Search API
+    class WebSearch < Base
+      BRAVE_API_URL = "https://api.search.brave.com/res/v1/web/search"
+
+      def name
+        "web_search"
+      end
+
+      def description
+        "Search the web for information. Returns relevant search results with titles, URLs, and descriptions."
+      end
+
+      def parameters
+        {
+          type: "object",
+          properties: {
+            query: {
+              type: "string",
+              description: "The search query"
+            },
+            count: {
+              type: "integer",
+              description: "Number of results to return (default: 5, max: 20)"
+            }
+          },
+          required: ["query"]
+        }
+      end
+
+      def available?
+        api_key && !api_key.empty?
+      end
+
+      def execute(query:, count: 5)
+        return error("Web search requires BRAVE_API_KEY environment variable") unless api_key
+
+        count = [[count, 1].max, 20].min
+
+        response = client.get do |req|
+          req.params["q"] = query
+          req.params["count"] = count
+        end
+
+        return error("Search failed: #{response.status}") unless response.success?
+
+        data = JSON.parse(response.body)
+        format_results(data, query)
+      rescue Faraday::Error => e
+        error("Search request failed: #{e.message}")
+      rescue JSON::ParserError
+        error("Failed to parse search results")
+      end
+
+      private
+
+      def api_key
+        @context[:brave_api_key] || ENV.fetch("BRAVE_API_KEY", nil)
+      end
+
+      def client
+        @client ||= Faraday.new(url: BRAVE_API_URL) do |f|
+          f.headers["Accept"] = "application/json"
+          f.headers["X-Subscription-Token"] = api_key
+          f.adapter Faraday.default_adapter
+        end
+      end
+
+      def format_results(data, query)
+        results = data.dig("web", "results") || []
+
+        return "No results found for: #{query}" if results.empty?
+
+        output = ["Search results for: #{query}\n"]
+
+        results.each_with_index do |result, idx|
+          output << format_result(result, idx + 1)
+        end
+
+        output.join("\n")
+      end
+
+      def format_result(result, index)
+        title = result["title"] || "Untitled"
+        url = result["url"] || ""
+        description = result["description"] || ""
+
+        <<~RESULT
+          #{index}. #{title}
+             URL: #{url}
+             #{description[0..300]}
+        RESULT
+      end
+    end
+  end
+end

data/lib/pocketrb/tools/write_file.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Pocketrb
+  module Tools
+    # Write content to a file
+    class WriteFile < Base
+      MAX_FILE_SIZE = 10 * 1024 * 1024 # 10MB
+
+      def name
+        "write_file"
+      end
+
+      def description
+        "Write content to a file. Creates the file if it doesn't exist, or overwrites if it does. Creates parent directories as needed."
+      end
+
+      def parameters
+        {
+          type: "object",
+          properties: {
+            path: {
+              type: "string",
+              description: "Path to the file to write (relative to workspace or absolute)"
+            },
+            content: {
+              type: "string",
+              description: "Content to write to the file"
+            }
+          },
+          required: %w[path content]
+        }
+      end
+
+      def execute(path:, content:)
+        resolved = resolve_path(path)
+
+        return error("Path is outside workspace: #{path}") unless path_allowed?(path)
+
+        return error("Content exceeds maximum file size (10MB)") if content.bytesize > MAX_FILE_SIZE
+
+        # Create parent directories
+        FileUtils.mkdir_p(resolved.dirname)
+
+        # Write file
+        File.write(resolved, content)
+
+        success("Wrote #{content.lines.count} lines (#{content.bytesize} bytes) to #{path}")
+      rescue Errno::EACCES
+        error("Permission denied: #{path}")
+      rescue Errno::ENOSPC
+        error("No space left on device")
+      end
+    end
+  end
+end

data/lib/pocketrb/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Pocketrb
+  VERSION = "0.1.0"
+end