fantasy-cli 1.2.6

data/lib/gsd/tools/web.rb

@@ -0,0 +1,260 @@
+# frozen_string_literal: true
+
+require 'gsd/tools/base'
+require 'gsd/go/bridge'
+require 'net/http'
+require 'json'
+
+module Gsd
+  module Tools
+    # WebSearchTool - Pesquisa na web usando Brave API
+    class WebSearchTool < Base
+      class << self
+        tool_name('web_search')
+        tool_description('Search the web using Brave Search API')
+        tool_input_schema({
+          type: 'object',
+          properties: {
+            query: {
+              type: 'string',
+              description: 'Search query'
+            },
+            count: {
+              type: 'integer',
+              description: 'Number of results (default: 10, max: 20)',
+              default: 10
+            },
+            freshness: {
+              type: 'string',
+              description: 'Results freshness: day, week, month',
+              enum: ['day', 'week', 'month']
+            }
+          },
+          required: ['query']
+        })
+      end
+
+      def execute(args)
+        query = args[:query] || args['query']
+        count = args[:count] || args['count'] || 10
+        freshness = args[:freshness] || args['freshness']
+
+        raise ArgumentError, 'Query is required' unless query
+
+        log_debug("Web search: #{query}")
+
+        # Tenta usar Go bridge primeiro
+        begin
+          params = {
+            'search' => true,
+            'query' => query,
+            'count' => [count, 20].min,
+            'freshness' => freshness
+          }
+
+          result = Gsd::Go::Bridge.call('research', params, cwd: @cwd)
+
+          if result['success']
+            return {
+              success: true,
+              operation: 'search',
+              query: query,
+              data: result['data'],
+              cwd: @cwd
+            }
+          end
+        rescue => e
+          log_debug("Go bridge failed: #{e.message}")
+          # Fallback para implementação Ruby
+        end
+
+        # Implementação Ruby fallback
+        search_with_brave(query, count, freshness)
+      rescue => e
+        error_result(e, 'search')
+      end
+
+      def self.safe?(args); true; end
+      def self.read_only?(args); true; end
+
+      private
+
+      def search_with_brave(query, count, freshness)
+        api_key = ENV['BRAVE_API_KEY']
+
+        unless api_key
+          return {
+            success: false,
+            error: 'missing_api_key',
+            message: 'BRAVE_API_KEY environment variable not set',
+            operation: 'search'
+          }
+        end
+
+        uri = URI('https://api.search.brave.com/res/v1/web/search')
+        uri.query = URI.encode_www_form({
+          q: query,
+          count: [count, 20].min,
+          freshness: freshness
+        })
+
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true
+
+        request = Net::HTTP::Get.new(uri.path_query)
+        request['Accept'] = 'application/json'
+        request['X-Subscription-Token'] = api_key
+
+        response = http.request(request)
+
+        if response.code == '200'
+          data = JSON.parse(response.body)
+          {
+            success: true,
+            operation: 'search',
+            query: query,
+            data: data,
+            cwd: @cwd
+          }
+        else
+          {
+            success: false,
+            error: 'api_error',
+            message: "Brave API error: #{response.code}",
+            operation: 'search'
+          }
+        end
+      end
+
+      def error_result(error, operation)
+        log_debug("Error: #{error.message}")
+        {
+          success: false,
+          error: 'search_error',
+          message: error.message,
+          operation: operation
+        }
+      end
+    end
+
+    # WebFetchTool - Fetch conteúdo de URL
+    class WebFetchTool < Base
+      class << self
+        tool_name('web_fetch')
+        tool_description('Fetch content from a URL')
+        tool_input_schema({
+          type: 'object',
+          properties: {
+            url: {
+              type: 'string',
+              description: 'URL to fetch'
+            },
+            max_length: {
+              type: 'integer',
+              description: 'Maximum content length (default: 50000)',
+              default: 50000
+            }
+          },
+          required: ['url']
+        })
+      end
+
+      def execute(args)
+        url = args[:url] || args['url']
+        max_length = args[:max_length] || args['max_length'] || 50000
+
+        raise ArgumentError, 'URL is required' unless url
+        raise ArgumentError, 'Invalid URL' unless valid_url?(url)
+
+        log_debug("Web fetch: #{url}")
+
+        # Tenta usar Go bridge primeiro
+        begin
+          result = Gsd::Go::Bridge.call('research', {
+            'fetch' => true,
+            'url' => url,
+            'max_length' => max_length
+          }, cwd: @cwd)
+
+          if result['success']
+            return {
+              success: true,
+              operation: 'fetch',
+              url: url,
+              data: result['data'],
+              cwd: @cwd
+            }
+          end
+        rescue => e
+          log_debug("Go bridge failed: #{e.message}")
+          # Fallback para implementação Ruby
+        end
+
+        # Implementação Ruby fallback
+        fetch_url(url, max_length)
+      rescue => e
+        error_result(e, 'fetch')
+      end
+
+      def self.safe?(args); true; end
+      def self.read_only?(args); true; end
+
+      private
+
+      def valid_url?(url)
+        url.start_with?('http://', 'https://')
+      end
+
+      def fetch_url(url, max_length)
+        uri = URI(url)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = (uri.scheme == 'https')
+        http.read_timeout = 10
+
+        request = Net::HTTP::Get.new(uri.path_query)
+        request['User-Agent'] = 'GSD-Tools/1.0'
+
+        response = http.request(request)
+
+        if response.code == '200'
+          content = response.body
+          content = content[0...max_length] if content.length > max_length
+
+          {
+            success: true,
+            operation: 'fetch',
+            url: url,
+            data: {
+              content: content,
+              length: content.length,
+              truncated: response.body.length > max_length,
+              content_type: response['Content-Type']
+            },
+            cwd: @cwd
+          }
+        else
+          {
+            success: false,
+            error: 'fetch_error',
+            message: "HTTP #{response.code}",
+            operation: 'fetch'
+          }
+        end
+      end
+
+      def error_result(error, operation)
+        log_debug("Error: #{error.message}")
+        {
+          success: false,
+          error: 'fetch_error',
+          message: error.message,
+          operation: operation
+        }
+      end
+    end
+  end
+end
+
+# Registra as tools
+Gsd::Tools::Registry.register('web_search', Gsd::Tools::WebSearchTool, category: :web)
+Gsd::Tools::Registry.register('web_fetch', Gsd::Tools::WebFetchTool, category: :web)

data/lib/gsd/tui/app.rb

@@ -0,0 +1,366 @@
+# frozen_string_literal: true
+
+require 'io/console'
+require 'gsd/tui/colors'
+require 'gsd/tui/header'
+require 'gsd/tui/input_box'
+require 'gsd/tui/status_bar'
+require 'gsd/tui/auto_complete'
+require 'gsd/tui/command_palette'
+require 'gsd/tui/spinner'
+
+module Gsd
+  module TUI
+    class App
+      def initialize(theme: :fantasy, header_style: :pixel)
+        @theme = theme
+        @header_style = header_style
+        @running = false
+        @is_windows = RUBY_PLATFORM =~ /mswin|mingw/
+
+        @header = Header.new(style: header_style)
+        @input_box = InputBox.new
+        @status_bar = StatusBar.new
+        @auto_complete = AutoComplete.new
+        @command_palette = CommandPalette.new
+        @spinner = Spinner.new
+
+        @agents = ['Code', 'Kilo Auto Free', 'Kilo Gateway']
+        @selected_agent = 1
+
+        @history = []
+        @history_index = -1
+        @output = []
+        @frame_count = 0
+        @render_count = 0
+      end
+
+      def run
+        @running = true
+
+        setup_console
+
+        trap(:WINCH) { full_render if @running } unless @is_windows
+
+        print Colors::CURSOR_HIDE
+
+        if @is_windows
+          system('cls')
+        else
+          print Colors::CLEAR_SCREEN
+        end
+        print Colors::HOME
+
+        @output << { type: :system, text: 'Welcome to Fantasy CLI v1.2.0!' }
+        @output << { type: :system, text: 'Press Ctrl+P for commands, Ctrl+Q to quit.' }
+
+        full_render
+
+        while @running
+          @frame_count += 1
+          @spinner.next_frame if (@frame_count % 5).zero?
+
+          handle_input
+        end
+
+        cleanup_console
+      end
+
+      def stop
+        @running = false
+      end
+
+      private
+
+      # Setup console for raw input (Windows-safe)
+      def setup_console
+        if @is_windows
+          # Windows: STDIN.getch already works in raw mode
+          # No need for stty
+          begin
+            $stdin.echo = false if $stdin.respond_to?(:echo=)
+          rescue StandardError
+            # Ignore if not supported
+          end
+        else
+          # Unix: use stty
+          begin
+            system('stty raw -echo 2>/dev/null')
+          rescue StandardError
+            # Ignore errors
+          end
+        end
+      end
+
+      # Restore console (Windows-safe)
+      def cleanup_console
+        if @is_windows
+          begin
+            $stdin.echo = true if $stdin.respond_to?(:echo=)
+          rescue StandardError
+            # Ignore
+          end
+        else
+          begin
+            system('stty -raw echo 2>/dev/null')
+          rescue StandardError
+            # Ignore
+          end
+        end
+
+        # Always show cursor and clear screen
+        print Colors::CURSOR_SHOW + Colors::CLEAR_SCREEN + Colors::HOME
+        puts 'Goodbye!'
+      end
+
+      # Full render (clears and redraws everything)
+      def full_render
+        @render_count += 1
+
+        # Move to top (ANSI or cls fallback)
+        if @is_windows
+          # Windows: cls is more reliable than ANSI HOME
+          system('cls')
+        else
+          # Unix: ANSI HOME works
+          print Colors::HOME
+        end
+
+        lines = []
+
+        # Header
+        lines << @header.render
+
+        if @command_palette.visible?
+          lines << @command_palette.render(width: 58)
+        else
+          # Output messages
+          @output.each do |msg|
+            t = Colors.theme
+            case msg[:type]
+            when :user
+              lines << "#{t[:accent]}❯#{Colors::RESET} #{t[:text]}#{msg[:text]}#{Colors::RESET}"
+            when :assistant
+              lines << "#{@spinner.render}#{t[:success]}❮#{Colors::RESET} #{t[:text]}#{msg[:text]}#{Colors::RESET}"
+            when :system
+              lines << "#{t[:warning]}⚡ #{t[:text]}#{msg[:text]}#{Colors::RESET}"
+            end
+          end
+
+          # Fill remaining lines for consistent layout
+          lines_needed = 4 - @output.length
+          lines_needed.times { lines << '' } if lines_needed.positive?
+
+          # Auto-complete
+          lines << if @auto_complete.has_suggestions?
+                     @auto_complete.render(@input_box.text, width: 60)
+                   else
+                     ''
+                   end
+
+          # Input box
+          lines << @input_box.render
+
+          # Agent selector
+          lines << render_agent_selector
+        end
+
+        # Status bar
+        lines << @status_bar.render
+
+        # Join and print
+        output_text = lines.join("\n")
+        print output_text
+
+        # Flush output
+        $stdout.flush
+      end
+
+      def handle_input
+        begin
+          char = $stdin.getch
+        rescue EOFError, IOError
+          return
+        end
+
+        if char.nil?
+          stop
+          return
+        end
+
+        # Debug: Log raw character
+        puts "DEBUG: char=#{char.inspect} ord=#{char.ord}" if ENV['TUI_DEBUG'] == '1'
+
+        # Normalize common Windows keys
+        case char
+        when "\r"      # Windows Enter
+          char = "\n"
+        when "\x08"    # Windows Backspace
+          char = "\x7F"
+        when "\x03"    # Ctrl+C
+          char = "\cC"
+        when "\x10"    # Ctrl+P (16 = 0x10)
+          char = "\cP"
+        when "\x11"    # Ctrl+Q (17 = 0x11)
+          char = "\cQ"
+        end
+
+        if @command_palette.visible?
+          handle_palette_input(char)
+          full_render
+          return
+        end
+
+        case char
+        when "\e"
+          handle_escape_sequence
+          full_render
+        when "\n", "\r"
+          handle_enter
+          full_render
+        when "\x7F", "\b"
+          @input_box.backspace
+          @auto_complete.update(@input_box.text)
+          full_render
+        when "\cC", "\cQ"
+          stop
+        when "\cP"
+          @command_palette.show
+          full_render
+        when "\t"
+          handle_tab
+          full_render
+        else
+          if char.length == 1 && char.match?(/[[:print:]]/) && char.ord >= 32
+            @input_box.add_char(char)
+            @auto_complete.update(@input_box.text)
+            full_render
+          end
+        end
+      end
+
+      def handle_escape_sequence
+        $stdin.getch
+        c2 = $stdin.getch
+
+        case c2
+        when 'A'
+          handle_up_arrow
+          full_render
+        when 'B'
+          handle_down_arrow
+          full_render
+        when 'D'
+          @input_box.move_left
+          full_render
+        when 'C'
+          @input_box.move_right
+          full_render
+        end
+      rescue EOFError, IOError
+        nil
+      end
+
+      def handle_palette_input(char)
+        case char
+        when "\r", "\n"
+          action = @command_palette.execute
+          handle_palette_action(action)
+        when "\x7F", "\b"
+          @command_palette.backspace
+        when "\cP"
+          @command_palette.hide
+        when "\cQ"
+          stop
+        else
+          @command_palette.add_char(char) if char.length == 1 && char.match?(/[[:print:]]/) && char.ord >= 32
+        end
+      end
+
+      def handle_palette_action(action)
+        case action
+        when :quit
+          stop
+        when :theme_fantasy, :theme_kilo, :theme_dark, :theme_light, :theme_nord
+          theme_name = action.to_s.split('_').last.to_sym
+          set_theme(theme_name)
+        else
+          @output << { type: :system, text: "Action: #{action} (WIP)" }
+        end
+        full_render
+      end
+
+      def set_theme(theme_name)
+        @theme = theme_name
+        @output << { type: :system, text: "Theme: #{Colors.theme(theme_name)[:name]}" }
+      end
+
+      def handle_enter
+        text = @input_box.submit
+        return if text.strip.empty?
+
+        @history << text
+        @history_index = @history.length
+        @output << { type: :user, text: text }
+        @auto_complete.clear
+
+        @spinner.start
+
+        @output << { type: :assistant, text: "Received: #{text}" }
+        @output = @output.last(20)
+
+        # Simulate processing delay
+        sleep(0.3)
+        @spinner.stop
+      end
+
+      def handle_up_arrow
+        return if @history.empty?
+
+        @history_index = [@history_index - 1, 0].max
+        @input_box.clear
+        @history[@history_index]&.each_char { |c| @input_box.add_char(c) }
+      end
+
+      def handle_down_arrow
+        return if @history.empty?
+
+        @history_index = [@history_index + 1, @history.length].min
+        @input_box.clear
+        return unless @history_index < @history.length
+
+        @history[@history_index]&.each_char { |c| @input_box.add_char(c) }
+      end
+
+      def handle_tab
+        if @auto_complete.has_suggestions?
+          suggestion = @auto_complete.selected
+          if suggestion
+            @input_box.clear
+            suggestion.each_char { |c| @input_box.add_char(c) }
+          end
+        else
+          @selected_agent = (@selected_agent + 1) % @agents.length
+        end
+      end
+
+      def render_agent_selector
+        t = Colors.theme
+        accent = t[:accent]
+        white = t[:text]
+        dim = t[:dim]
+        reset = Colors::RESET
+
+        parts = @agents.each_with_index.map do |agent, idx|
+          if idx == @selected_agent
+            "#{accent}[#{reset}#{white}#{agent}#{reset}#{accent}]#{reset}"
+          else
+            "#{dim}[#{agent}]#{reset}"
+          end
+        end
+
+        "  #{parts.join(' ')}"
+      end
+    end
+  end
+end

data/lib/gsd/tui/auto_complete.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require 'gsd/tui/colors'
+
+module Gsd
+  module TUI
+    class AutoComplete
+      COMMANDS = %w[
+        help version hello ai state phase roadmap plugins agent buddy tui
+        config list install uninstall search info enable disable
+        spawn send stop output status
+        pull get stats feed play evolve
+        load json update patch get find list next-decimal add
+        get-phase analyze
+      ].freeze
+
+      def initialize
+        @suggestions = []
+        @selected_index = 0
+      end
+
+      def update(text)
+        return [] if text.strip.empty?
+
+        @suggestions = COMMANDS.select { |cmd| cmd.start_with?(text.downcase) }
+        @selected_index = 0
+        @suggestions
+      end
+
+      def next
+        return nil if @suggestions.empty?
+
+        @selected_index = (@selected_index + 1) % @suggestions.length
+        @suggestions[@selected_index]
+      end
+
+      def prev
+        return nil if @suggestions.empty?
+
+        @selected_index = (@selected_index - 1) % @suggestions.length
+        @selected_index = @suggestions.length - 1 if @selected_index.negative?
+        @suggestions[@selected_index]
+      end
+
+      def selected
+        @suggestions[@selected_index]
+      end
+
+      def render(_text, width: 60)
+        return '' if @suggestions.empty?
+
+        t = Colors.theme
+        bg = t[:bg]
+        selected_fg = t[:accent]
+        dim = t[:dim]
+        reset = Colors::RESET
+
+        display = @suggestions.first(3).map.with_index do |sug, i|
+          if i == @selected_index
+            " #{bg}#{selected_fg} #{sug} #{reset}"
+          else
+            " #{dim}#{sug}#{reset}"
+          end
+        end.join('  ')
+
+        display[0...width]
+      end
+
+      def has_suggestions?
+        !@suggestions.empty?
+      end
+
+      def clear
+        @suggestions = []
+        @selected_index = 0
+      end
+    end
+  end
+end