rubino-agent 0.3.0

data/lib/rubino/tools/webfetch_tool.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+
+module Rubino
+  module Tools
+    # Tool for fetching web page content and converting to text/markdown.
+    class WebFetchTool < Base
+      MAX_BODY_SIZE = 100_000
+      TIMEOUT = 30
+
+      def name
+        "webfetch"
+      end
+
+      # Gated by `tools.web` (shared with websearch), not `tools.webfetch`.
+      def config_key
+        "web"
+      end
+
+      def description
+        "Fetch content from a URL and return it as text. " \
+          "Useful for reading documentation, API references, and web pages."
+      end
+
+      def input_schema
+        {
+          type: "object",
+          properties: {
+            url: {
+              type: "string",
+              description: "The URL to fetch content from"
+            },
+            format: {
+              type: "string",
+              enum: %w[text html],
+              description: "Output format: 'text' (default, strips HTML) or 'html' (raw)"
+            }
+          },
+          required: %w[url]
+        }
+      end
+
+      def risk_level
+        :low
+      end
+
+      def call(arguments)
+        url = arguments["url"] || arguments[:url]
+        format = arguments["format"] || arguments[:format] || "text"
+
+        fetch_url(url, format: format)
+      end
+
+      private
+
+      def fetch_url(url, format:, redirects: 5)
+        return "Error: Too many redirects" if redirects <= 0
+
+        uri = URI.parse(url)
+        uri = URI.parse("https://#{url}") unless uri.scheme
+
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = (uri.scheme == "https")
+        http.open_timeout = TIMEOUT
+        http.read_timeout = TIMEOUT
+
+        request = Net::HTTP::Get.new(uri.request_uri)
+        request["User-Agent"] = "Rubino/#{Rubino::VERSION}"
+        request["Accept"] = "text/html,text/plain,application/json"
+
+        response = http.request(request)
+
+        case response
+        when Net::HTTPRedirection
+          fetch_url(response["location"], format: format, redirects: redirects - 1)
+        when Net::HTTPSuccess
+          content_type = response["content-type"].to_s
+          return binary_refusal(url, content_type) if binary_content_type?(content_type)
+
+          # Force UTF-8 + scrub so gsub! in strip_html doesn't trip
+          # "source sequence is illegal/malformed utf-8" when the upstream
+          # response is labelled text/* but contains stray non-UTF-8 bytes
+          # (which is the common case for misencoded HTML / CRLF logs).
+          body = response.body.to_s.dup.force_encoding("UTF-8").scrub("?")
+          if body.bytesize > MAX_BODY_SIZE
+            body = body.byteslice(0,
+                                  MAX_BODY_SIZE).to_s.force_encoding("UTF-8").scrub("?")
+          end
+
+          if format == "html"
+            body
+          else
+            strip_html(body)
+          end
+        else
+          "Error: HTTP #{response.code} - #{response.message}"
+        end
+      rescue StandardError => e
+        "Error fetching URL: #{e.message}"
+      end
+
+      BINARY_TYPE_PATTERNS = [
+        %r{\Aapplication/(pdf|zip|x-tar|x-gzip|x-bzip2|x-7z-compressed|x-rar|octet-stream|x-msdownload|vnd\.openxmlformats|vnd\.ms-)},
+        %r{\Aimage/}, %r{\Aaudio/}, %r{\Avideo/},
+        %r{\Afont/}
+      ].freeze
+
+      def binary_content_type?(content_type)
+        type = content_type.to_s.split(";").first.to_s.strip.downcase
+        BINARY_TYPE_PATTERNS.any? { |re| type.match?(re) }
+      end
+
+      def binary_refusal(url, content_type)
+        "Error: refusing to fetch binary content as text " \
+          "(URL=#{url}, Content-Type=#{content_type.split(";").first.to_s.strip}). " \
+          "Use a dedicated tool (e.g. read_file after downloading, attach_file, " \
+          "or an image-aware model) for binary assets."
+      end
+
+      def strip_html(html)
+        # Basic HTML to text conversion
+        text = html.dup
+
+        # Remove script and style blocks
+        text.gsub!(%r{<script[^>]*>.*?</script>}mi, "")
+        text.gsub!(%r{<style[^>]*>.*?</style>}mi, "")
+
+        # Convert common elements
+        text.gsub!(%r{<br\s*/?>}i, "\n")
+        text.gsub!(%r{</(p|div|h[1-6]|li|tr)>}i, "\n")
+        text.gsub!(/<(h[1-6])[^>]*>/i, "\n## ")
+        text.gsub!(/<li[^>]*>/i, "- ")
+
+        # Remove remaining tags
+        text.gsub!(/<[^>]+>/, "")
+
+        # Decode common entities
+        text.gsub!("&amp;", "&")
+        text.gsub!("&lt;", "<")
+        text.gsub!("&gt;", ">")
+        text.gsub!("&quot;", '"')
+        text.gsub!("&#39;", "'")
+        text.gsub!("&nbsp;", " ")
+
+        # Clean up whitespace
+        text.gsub!(/\n{3,}/, "\n\n")
+        text.strip
+      end
+    end
+  end
+end

data/lib/rubino/tools/websearch_tool.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+require "json"
+
+module Rubino
+  module Tools
+    # Tool for performing web searches via external search APIs.
+    # Supports Tavily, SearXNG, and a fallback DuckDuckGo scraper.
+    class WebSearchTool < Base
+      def name
+        "websearch"
+      end
+
+      # Gated by `tools.web` (shared with webfetch), not `tools.websearch`.
+      def config_key
+        "web"
+      end
+
+      def description
+        "Search the web for information. Returns relevant results with titles, " \
+          "URLs, and snippets. Useful for finding documentation, researching " \
+          "dependencies, and answering questions about external topics."
+      end
+
+      def input_schema
+        {
+          type: "object",
+          properties: {
+            query: {
+              type: "string",
+              description: "The search query"
+            },
+            max_results: {
+              type: "integer",
+              description: "Maximum number of results (default: 5)"
+            }
+          },
+          required: %w[query]
+        }
+      end
+
+      def risk_level
+        :low
+      end
+
+      def call(arguments)
+        query = arguments["query"] || arguments[:query]
+        max_results = arguments["max_results"] || arguments[:max_results] || 5
+
+        if ENV["TAVILY_API_KEY"]
+          search_tavily(query, max_results)
+        elsif ENV["SEARXNG_URL"]
+          search_searxng(query, max_results)
+        else
+          search_ddg(query, max_results)
+        end
+      rescue StandardError => e
+        "Search error: #{e.message}"
+      end
+
+      private
+
+      # Tavily API (preferred - high quality results)
+      def search_tavily(query, max_results)
+        uri = URI("https://api.tavily.com/search")
+        body = {
+          api_key: ENV.fetch("TAVILY_API_KEY", nil),
+          query: query,
+          max_results: max_results,
+          include_answer: true,
+          search_depth: "basic"
+        }
+
+        response = post_json(uri, body)
+        data = JSON.parse(response)
+
+        results = []
+        results << "**Answer:** #{data["answer"]}\n" if data["answer"]
+
+        (data["results"] || []).each do |r|
+          results << format_result(r["title"], r["url"], r["content"])
+        end
+
+        results.empty? ? "No results found for: #{query}" : results.join("\n\n")
+      end
+
+      # SearXNG (self-hosted, privacy-focused)
+      def search_searxng(query, max_results)
+        base_url = ENV["SEARXNG_URL"].chomp("/")
+        uri = URI("#{base_url}/search")
+        uri.query = URI.encode_www_form(
+          q: query,
+          format: "json",
+          pageno: 1
+        )
+
+        response = get_json(uri)
+        data = JSON.parse(response)
+
+        results = (data["results"] || []).first(max_results).map do |r|
+          format_result(r["title"], r["url"], r["content"])
+        end
+
+        results.empty? ? "No results found for: #{query}" : results.join("\n\n")
+      end
+
+      # DuckDuckGo HTML scraper (fallback, no API key needed)
+      def search_ddg(query, max_results)
+        uri = URI("https://html.duckduckgo.com/html/")
+        body = URI.encode_www_form(q: query)
+
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true
+        request = Net::HTTP::Post.new(uri.path)
+        request["User-Agent"] = "Rubino/#{Rubino::VERSION}"
+        request.body = body
+
+        response = http.request(request)
+        parse_ddg_html(response.body, max_results)
+      end
+
+      def parse_ddg_html(html, max_results)
+        results = []
+
+        # Extract result blocks
+        html.scan(%r{<a rel="nofollow" class="result__a" href="([^"]+)"[^>]*>(.+?)</a>.*?<a class="result__snippet"[^>]*>(.+?)</a>}m) do |url, title, snippet|
+          clean_title = title.gsub(/<[^>]+>/, "").strip
+          clean_snippet = snippet.gsub(/<[^>]+>/, "").strip
+          clean_url = url.strip
+
+          # DuckDuckGo wraps URLs in redirects
+          if clean_url.include?("uddg=")
+            clean_url = begin
+              URI.decode_www_form_component(clean_url.match(/uddg=([^&]+)/)[1])
+            rescue StandardError
+              clean_url
+            end
+          end
+
+          results << format_result(clean_title, clean_url, clean_snippet)
+          break if results.size >= max_results
+        end
+
+        results.empty? ? "No results found (DDG fallback)" : results.join("\n\n")
+      end
+
+      def format_result(title, url, snippet)
+        "**#{title}**\n#{url}\n#{snippet}"
+      end
+
+      def post_json(uri, body)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl      = (uri.scheme == "https")
+        http.open_timeout = 10
+        http.read_timeout = 15
+
+        request = Net::HTTP::Post.new(uri.request_uri)
+        request["Content-Type"] = "application/json"
+        request.body = JSON.generate(body)
+
+        http.request(request).body
+      end
+
+      def get_json(uri)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl      = (uri.scheme == "https")
+        http.open_timeout = 10
+        http.read_timeout = 15
+
+        request = Net::HTTP::Get.new(uri.request_uri)
+        request["Accept"] = "application/json"
+
+        http.request(request).body
+      end
+    end
+  end
+end

data/lib/rubino/tools/write_tool.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Rubino
+  module Tools
+    # Writes content to a file, creating parent directories if needed.
+    # Overwrites existing files (the LLM is expected to Read first when in
+    # doubt). Kept intentionally narrow — no append mode, no partial writes;
+    # those belong in `edit` / `multi_edit`.
+    class WriteTool < Base
+      def name
+        "write"
+      end
+
+      def description
+        "Write content to a file, overwriting any existing content. " \
+          "Creates parent directories if they do not exist. " \
+          "Use `edit` or `multi_edit` to modify an existing file in place."
+      end
+
+      def input_schema
+        {
+          type: "object",
+          properties: {
+            file_path: { type: "string", description: "Absolute or relative file path" },
+            content: { type: "string", description: "Full file content to write" }
+          },
+          required: %w[file_path content]
+        }
+      end
+
+      def risk_level
+        :medium
+      end
+
+      def call(arguments)
+        file_path = arguments["file_path"] || arguments[:file_path]
+        content   = arguments["content"]   || arguments[:content] || ""
+
+        return "Error: file_path is required" if file_path.nil? || file_path.to_s.empty?
+
+        expanded = File.expand_path(file_path)
+        return workspace_violation_message(file_path) unless within_workspace?(expanded)
+
+        FileUtils.mkdir_p(File.dirname(expanded))
+
+        existed = File.exist?(expanded)
+        File.write(expanded, content)
+
+        verb  = existed ? "overwrote" : "created"
+        bytes = content.to_s.bytesize
+        lines = content.to_s.lines.size
+        { output: "#{verb} #{file_path} (#{bytes} bytes)",
+          metrics: "#{lines} line#{"s" if lines != 1} · #{bytes}B" }
+      rescue StandardError => e
+        "Error writing #{file_path}: #{e.message}"
+      end
+    end
+  end
+end

data/lib/rubino/trust.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+
+module Rubino
+  # Proportionate folder-trust, modelled on VS Code Workspace Trust and Claude
+  # Code's directory-trust dialog — but DELIBERATELY lighter, because rubino
+  # auto-RUNS no code from a project directory (config is HOME-only, there are
+  # no folder-open hooks, custom slash commands are user-triggered, and the
+  # arbitrary-Ruby tool loader can no longer load from cwd — see #44).
+  #
+  # What the gate protects: the ONE thing rubino auto-loads from a directory is
+  # *text into the system prompt* — its AGENTS.md / CLAUDE.md / .rubino.md /
+  # .cursorrules project-context files and its .rubino/skills catalogue. A
+  # hostile repo can use those to STEER the agent (prompt injection) the moment
+  # you start there. So, like VS Code's Restricted Mode, an untrusted directory
+  # still works — it just runs WITHOUT that directory's project context and
+  # skills until you vouch for it.
+  #
+  # What it does NOT do: there is no feature-disabling Restricted Mode (no
+  # auto-executed code to disable) and no per-tool gating — that would be
+  # ceremony without payoff given rubino's actual exposure.
+  #
+  # The decision is remembered in trusted_dirs.json under RUBINO_HOME so a
+  # trusted directory is never re-prompted (mirrors trustedDirectories).
+  module Trust
+    FILENAME = "trusted_dirs.json"
+
+    class << self
+      # True when +dir+ has been remembered as trusted. Compares on canonical
+      # (realpath) form so a symlinked/relative path matches its stored entry.
+      def trusted?(dir)
+        real = canonical(dir)
+        return false unless real
+
+        load_dirs.any? { |d| canonical(d) == real }
+      end
+
+      # Remembers +dir+ as trusted (idempotent). Stores the canonical path so
+      # later lookups match regardless of how the dir is later referenced.
+      def remember(dir)
+        real = canonical(dir)
+        return unless real
+
+        dirs = load_dirs
+        return if dirs.any? { |d| canonical(d) == real }
+
+        save_dirs(dirs + [real])
+      end
+
+      # The remembered list, canonicalised (for display / tests).
+      def trusted_dirs
+        load_dirs
+      end
+
+      def store_path
+        File.join(Rubino.home_path, FILENAME)
+      end
+
+      private
+
+      def load_dirs
+        return [] unless File.exist?(store_path)
+
+        data = JSON.parse(File.read(store_path))
+        data.is_a?(Array) ? data.map(&:to_s) : []
+      rescue StandardError
+        []
+      end
+
+      def save_dirs(dirs)
+        FileUtils.mkdir_p(File.dirname(store_path))
+        File.write(store_path, JSON.pretty_generate(dirs.uniq))
+      rescue StandardError
+        nil
+      end
+
+      def canonical(path)
+        return nil if path.nil? || path.to_s.empty?
+
+        File.realpath(File.expand_path(path.to_s))
+      rescue StandardError
+        nil
+      end
+    end
+  end
+end