octo-agent 0.11.2

data/lib/octo/tools/web_search.rb

@@ -0,0 +1,260 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "json"
+require "uri"
+require "cgi"
+require "base64"
+require_relative "../utils/encoding"
+
+module Octo
+  module Tools
+    class WebSearch < Base
+      self.tool_name = "web_search"
+      self.tool_description = "Search the web for current information. Returns search results with titles, URLs, and snippets."
+      self.tool_category = "web"
+      self.tool_parameters = {
+        type: "object",
+        properties: {
+          query: {
+            type: "string",
+            description: "The search query"
+          },
+          max_results: {
+            type: "integer",
+            description: "Maximum number of results to return (default: 10)",
+            default: 10
+          }
+        },
+        required: %w[query]
+      }
+
+      # Ordered list of search providers to try in sequence.
+      # cn.bing.com is accessible in mainland China without VPN.
+      PROVIDERS = %i[duckduckgo bing].freeze
+
+      def execute(query:, max_results: 10, working_dir: nil)
+        if query.nil? || query.strip.empty?
+          return { error: "Query cannot be empty" }
+        end
+
+        last_error = nil
+
+        providers = active_providers
+        providers.each do |provider|
+          begin
+            results = send(:"search_#{provider}", query, max_results)
+            # Consider it a success only if we got real results
+            next if results.empty? || results.first[:url].include?("duckduckgo.com") && results.first[:title] == "Web search results"
+
+            return {
+              query: query,
+              results: results,
+              count: results.length,
+              provider: provider.to_s,
+              error: nil
+            }
+          rescue StandardError => e
+            # DuckDuckGo failed — suppress it for 10 minutes
+            @ddg_unavailable_until = Time.now + 600 if provider == :duckduckgo
+            last_error = e
+            next
+          end
+        end
+
+        # All providers failed
+        {
+          query: query,
+          results: [],
+          count: 0,
+          provider: nil,
+          error: "All search providers failed. Last error: #{last_error&.message}"
+        }
+      end
+
+      # Skip DuckDuckGo if it failed recently (within last 10 minutes)
+      private def active_providers
+        if @ddg_unavailable_until && Time.now < @ddg_unavailable_until
+          PROVIDERS.drop(1)
+        else
+          PROVIDERS
+        end
+      end
+
+      # ── DuckDuckGo ─────────────────────────────────────────────────────────
+
+      private def search_duckduckgo(query, max_results)
+        encoded_query = CGI.escape(query)
+        url = URI("https://html.duckduckgo.com/html/?q=#{encoded_query}")
+        response = http_get(url)
+        return [] unless response.is_a?(Net::HTTPSuccess)
+
+        parse_duckduckgo_html(response.body, max_results)
+      end
+
+      private def parse_duckduckgo_html(html, max_results)
+        results = []
+        html = Octo::Utils::Encoding.to_utf8(html)
+
+        links = html.scan(%r{<a[^>]*class="result__a"[^>]*href="//duckduckgo\.com/l/\?uddg=([^"&]+)[^"]*"[^>]*>(.*?)</a>}m)
+        snippets = html.scan(%r{<a[^>]*class="result__snippet"[^>]*>(.*?)</a>}m)
+
+        links.each_with_index do |link_data, index|
+          break if results.length >= max_results
+
+          url = Octo::Utils::Encoding.to_utf8(CGI.unescape(link_data[0]))
+          title = link_data[1].gsub(/<[^>]+>/, "").strip
+          title = CGI.unescapeHTML(title) if title.include?("&")
+
+          snippet = ""
+          if snippets[index]
+            snippet = snippets[index][0].gsub(/<[^>]+>/, "").strip
+            snippet = CGI.unescapeHTML(snippet) if snippet.include?("&")
+          end
+
+          results << { title: title, url: url, snippet: snippet }
+        end
+
+        results
+      end
+
+      # ── Bing ───────────────────────────────────────────────────────────────
+
+      private def search_bing(query, max_results)
+        encoded_query = CGI.escape(query)
+        # cn.bing.com redirects to www.bing.com for non-China IPs (e.g. GitHub CI);
+        # follow_redirects ensures both environments work with the same code path.
+        url = URI("https://cn.bing.com/search?q=#{encoded_query}&count=#{max_results}")
+        response = http_get(url, accept_language: "zh-CN,zh;q=0.9,en;q=0.8", follow_redirects: 2)
+        return [] unless response.is_a?(Net::HTTPSuccess)
+
+        parse_bing_html(response.body, max_results)
+      end
+
+      private def parse_bing_html(html, max_results)
+        results = []
+        html = Octo::Utils::Encoding.to_utf8(html)
+
+        # Bing result blocks: <li class="b_algo">...</li>
+        blocks = html.scan(%r{<li[^>]*class="b_algo"[^>]*>(.*?)</li>}m)
+
+        blocks.each do |block_arr|
+          break if results.length >= max_results
+          block = block_arr[0]
+
+          # Extract URL and title from <h2><a href="URL">TITLE</a></h2>
+          title_match = block.match(%r{<h2[^>]*>.*?<a[^>]*href="(https?://[^"]+)"[^>]*>(.*?)</a>}m)
+          next unless title_match
+
+          raw_url = CGI.unescapeHTML(title_match[1])
+          url = decode_bing_url(raw_url)
+          title = title_match[2].gsub(/<[^>]+>/, "").strip
+          title = CGI.unescapeHTML(title) if title.include?("&")
+
+          # Extract snippet from <p class="b_lineclamp..."> or <div class="b_caption"><p>
+          snippet = ""
+          snippet_match = block.match(%r{<p[^>]*class="b_lineclamp[^"]*"[^>]*>(.*?)</p>}m) ||
+                          block.match(%r{<div[^>]*class="b_caption"[^>]*>.*?<p[^>]*>(.*?)</p>}m)
+          if snippet_match
+            snippet = snippet_match[1].gsub(/<[^>]+>/, "").strip
+            snippet = CGI.unescapeHTML(snippet) if snippet.include?("&")
+          end
+
+          results << { title: title, url: url, snippet: snippet }
+        end
+
+        results
+      end
+
+      # Decode Bing's redirect URL: bing.com/ck/a?...&u=a1BASE64URL&ntb=1
+      # The "u" param is "a1" prefix + base64-encoded real URL
+      private def decode_bing_url(url)
+        return url unless url.include?("bing.com/ck/")
+
+        u_param = url.match(/[?&]u=([^&]+)/)
+        return url unless u_param
+
+        encoded = u_param[1]
+        # Remove "a1" prefix then base64-decode
+        return url unless encoded.start_with?("a1")
+
+        base64_part = encoded[2..]
+        # Bing uses URL-safe base64 without padding
+        padded = base64_part + "=" * ((4 - base64_part.length % 4) % 4)
+        decoded = Base64.urlsafe_decode64(padded)
+        decoded.force_encoding("UTF-8").valid_encoding? ? decoded : url
+      rescue StandardError
+        url
+      end
+
+      # ── Shared HTTP helper ─────────────────────────────────────────────────
+
+      USER_AGENTS = [
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
+        "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36",
+        "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/122.0.0.0 Safari/537.36",
+        "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36"
+      ].freeze
+
+      # Shared browser-like GET request — no Accept-Encoding to avoid gzip/br
+      # detection tricks used by Bing. Supports redirect following.
+      private def http_get(url, accept_language: "en-US,en;q=0.9", follow_redirects: 0)
+        request = Net::HTTP::Get.new(url)
+        request["User-Agent"] = USER_AGENTS.sample
+        request["Accept"] = "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"
+        request["Accept-Language"] = accept_language
+        # Deliberately omit Accept-Encoding — sending gzip causes Bing to return
+        # a JS-only skeleton (~39KB) instead of the real HTML results (~120KB)
+        request["Sec-Fetch-Dest"] = "document"
+        request["Sec-Fetch-Mode"] = "navigate"
+        request["Sec-Fetch-Site"] = "none"
+        request["Upgrade-Insecure-Requests"] = "1"
+
+        response = Net::HTTP.start(url.hostname, url.port,
+          use_ssl: url.scheme == "https",
+          read_timeout: 8,
+          open_timeout: 5) { |http| http.request(request) }
+
+        # Follow redirects (e.g. cn.bing.com redirects to www.bing.com for non-China IPs)
+        if follow_redirects > 0 && response.is_a?(Net::HTTPRedirection)
+          location = response["location"]
+          redirect_url = location.start_with?("http") ? URI(location) : URI("#{url.scheme}://#{url.hostname}#{location}")
+          return http_get(redirect_url, accept_language: accept_language, follow_redirects: follow_redirects - 1)
+        end
+
+        response
+      end
+
+      # ── Formatting ─────────────────────────────────────────────────────────
+
+      def format_call(args)
+        query = args[:query] || args["query"] || ""
+        display_query = query.length > 40 ? "#{query[0..37]}..." : query
+        "web_search(\"#{display_query}\")"
+      end
+
+      def format_result(result)
+        if result[:error]
+          "[Error] #{result[:error]}"
+        else
+          count = result[:count] || 0
+          provider = result[:provider] ? " via #{result[:provider]}" : ""
+          "[OK] Found #{count} results#{provider}"
+        end
+      end
+
+      def format_result_for_ui(result)
+        return nil if result[:error]
+        {
+          type: "web_search",
+          query: result[:query],
+          results: (result[:results] || []).first(5).map do |r|
+            { title: r[:title], url: r[:url], snippet: r[:snippet] }
+          end,
+          total: result[:count] || 0
+        }
+      end
+    end
+  end
+end

data/lib/octo/tools/write.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Octo
+  module Tools
+    class Write < Base
+      self.tool_name = "write"
+      self.tool_description = "Write content to a file. Creates new files or overwrites existing ones."
+      self.tool_category = "file_system"
+      self.tool_parameters = {
+        type: "object",
+        properties: {
+          path: {
+            type: "string",
+            description: "The path of the file to write (absolute or relative)"
+          },
+          content: {
+            type: "string",
+            description: "The content to write to the file"
+          }
+        },
+        required: %w[path content]
+      }
+
+      def execute(path:, content:, working_dir: nil)
+        # Validate path
+        if path.nil? || path.strip.empty?
+          return { error: "Path cannot be empty" }
+        end
+
+        begin
+          # Expand ~ to home directory, resolve relative paths against working_dir
+          path = expand_path(path, working_dir: working_dir)
+
+          # Ensure parent directory exists
+          dir = File.dirname(path)
+          FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
+
+          # Write content to file
+          File.write(path, content)
+
+          {
+            path: File.expand_path(path),
+            bytes_written: content.bytesize,
+            error: nil
+          }
+        rescue Errno::EACCES => e
+          { error: "Permission denied: #{e.message}" }
+        rescue Errno::ENOSPC => e
+          { error: "No space left on device: #{e.message}" }
+        rescue StandardError => e
+          { error: "Failed to write file: #{e.message}" }
+        end
+      end
+
+      def format_call(args)
+        path = args[:path] || args['path']
+        "Write(#{Utils::PathHelper.safe_basename(path)})"
+      end
+
+      def format_result(result)
+        return result[:error] if result[:error]
+
+        bytes = result[:bytes_written] || result['bytes_written'] || 0
+        "Written #{bytes} bytes"
+      end
+
+      def format_result_for_ui(result)
+        return nil if result[:error]
+        {
+          type: "write",
+          path: result[:path],
+          size_bytes: result[:bytes_written] || 0
+        }
+      end
+    end
+  end
+end

data/lib/octo/ui2/block_font.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative "../block_font"
+
+module Octo
+  module UI2
+    # Alias for backward compatibility — BlockFont now lives at Octo::BlockFont.
+    BlockFont = Octo::BlockFont
+  end
+end

data/lib/octo/ui2/components/base_component.rb

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+
+require "pastel"
+
+module Octo
+  module UI2
+    module Components
+      # BaseComponent provides common functionality for all UI components
+      class BaseComponent
+        def initialize
+          @pastel = Pastel.new
+        end
+
+        # Render component with given data
+        # @param data [Hash] Data to render
+        # @return [String] Rendered output
+        def render(data)
+          raise NotImplementedError, "Subclasses must implement render method"
+        end
+
+        # Class method to render without instantiating
+        # @param data [Hash] Data to render
+        # @return [String] Rendered output
+        def self.render(data)
+          new.render(data)
+        end
+
+        protected
+
+        # Get current theme from ThemeManager
+        # @return [Themes::BaseTheme] Current theme instance
+        def theme
+          UI2::ThemeManager.current_theme
+        end
+
+        # Format symbol with color from theme
+        # @param symbol_key [Symbol] Symbol key (e.g., :user, :assistant)
+        # @return [String] Colored symbol
+        def format_symbol(symbol_key)
+          theme.format_symbol(symbol_key)
+        end
+
+        # Format text with color from theme
+        # @param text [String] Text to format
+        # @param symbol_key [Symbol] Symbol key for color lookup
+        # @return [String] Colored text
+        def format_text(text, symbol_key)
+          theme.format_text(text, symbol_key)
+        end
+
+        # Truncate text to max length
+        # @param text [String] Text to truncate
+        # @param max_length [Integer] Maximum length
+        # @return [String] Truncated text
+        def truncate(text, max_length)
+          return "" if text.nil? || text.empty?
+
+          cleaned = text.strip.gsub(/\s+/, ' ')
+          
+          if cleaned.length > max_length
+            cleaned[0...max_length] + "..."
+          else
+            cleaned
+          end
+        end
+
+        # Wrap text to specified width
+        # @param text [String] Text to wrap
+        # @param width [Integer] Maximum width
+        # @return [Array<String>] Array of wrapped lines
+        def wrap_text(text, width)
+          return [] if text.nil? || text.empty?
+          
+          words = text.split(/\s+/)
+          lines = []
+          current_line = ""
+          
+          words.each do |word|
+            if current_line.empty?
+              current_line = word
+            elsif (current_line.length + word.length + 1) <= width
+              current_line += " #{word}"
+            else
+              lines << current_line
+              current_line = word
+            end
+          end
+          
+          lines << current_line unless current_line.empty?
+          lines
+        end
+
+        # Format timestamp
+        # @param time [Time] Time object
+        # @return [String] Formatted timestamp
+        def format_timestamp(time = Time.now)
+          time.strftime("%H:%M:%S")
+        end
+
+        # Create indented text
+        # @param text [String] Text to indent
+        # @param spaces [Integer] Number of spaces
+        # @return [String] Indented text
+        def indent(text, spaces = 2)
+          prefix = " " * spaces
+          text.split("\n").map { |line| "#{prefix}#{line}" }.join("\n")
+        end
+
+        # Format key-value pair
+        # @param key [String] Key name
+        # @param value [String] Value
+        # @return [String] Formatted key-value
+        def format_key_value(key, value)
+          "#{@pastel.cyan(key)}: #{@pastel.white(value)}"
+        end
+
+        # Create a separator line
+        # @param char [String] Character to use
+        # @param width [Integer] Width of separator
+        # @return [String] Separator line
+        def separator(char = "─", width = 80)
+          @pastel.dim(char * width)
+        end
+
+        # Format list item
+        # @param text [String] Item text
+        # @param bullet [String] Bullet character
+        # @return [String] Formatted list item
+        def format_list_item(text, bullet = "•")
+          "#{@pastel.dim(bullet)} #{@pastel.white(text)}"
+        end
+
+        # Format code block
+        # @param code [String] Code content
+        # @param language [String, nil] Language for syntax highlighting hint
+        # @return [String] Formatted code block
+        def format_code_block(code, language = nil)
+          header = language ? @pastel.dim("```#{language}") : @pastel.dim("```")
+          footer = @pastel.dim("```")
+          content = @pastel.cyan(code)
+          
+          "#{header}\n#{content}\n#{footer}"
+        end
+
+        # Format progress bar
+        # @param current [Integer] Current value
+        # @param total [Integer] Total value
+        # @param width [Integer] Bar width
+        # @return [String] Progress bar
+        def format_progress_bar(current, total, width = 20)
+          return "" if total == 0
+          
+          percentage = (current.to_f / total * 100).round(1)
+          filled = (current.to_f / total * width).round
+          empty = width - filled
+          
+          bar = @pastel.green("█" * filled) + @pastel.dim("░" * empty)
+          "#{bar} #{percentage}%"
+        end
+      end
+    end
+  end
+end