fantasy-cli 1.2.6

data/lib/gsd/ai/ui.rb

@@ -0,0 +1,429 @@
+# frozen_string_literal: true
+
+module Gsd
+  module AI
+    # UI Utilities - Utilitários de interface do usuário
+    #
+    # Responsável por:
+    # - Cores e formatação de texto
+    # - Spinners e animações
+    # - Barras de progresso
+    # - Tabelas e formatação
+    module UI
+      # Cores ANSI para terminal
+      module Colors
+        COLORS = {
+          reset: "\e[0m",
+          bold: "\e[1m",
+          italic: "\e[3m",
+          underline: "\e[4m",
+          blink: "\e[5m",
+          reverse: "\e[7m",
+          black: "\e[30m",
+          red: "\e[31m",
+          green: "\e[32m",
+          yellow: "\e[33m",
+          blue: "\e[34m",
+          magenta: "\e[35m",
+          cyan: "\e[36m",
+          white: "\e[37m",
+          gray: "\e[90m",
+          bright_red: "\e[91m",
+          bright_green: "\e[92m",
+          bright_yellow: "\e[93m",
+          bright_blue: "\e[94m",
+          bright_magenta: "\e[95m",
+          bright_cyan: "\e[96m",
+          bright_white: "\e[97m"
+        }.freeze
+
+        # Formata texto com cor
+        #
+        # @param text [String] Texto
+        # @param color [Symbol] Cor
+        # @return [String] Texto colorido
+        def self.colorize(text, color)
+          return text unless supports_color?
+
+          "#{COLORS[color]}#{text}#{COLORS[:reset]}"
+        end
+
+        # Formata texto em negrito
+        #
+        # @param text [String] Texto
+        # @return [String] Texto em negrito
+        def self.bold(text)
+          colorize(text, :bold)
+        end
+
+        # Formata texto em vermelho
+        #
+        # @param text [String] Texto
+        # @return [String] Texto em vermelho
+        def self.red(text)
+          colorize(text, :red)
+        end
+
+        # Formata texto em verde
+        #
+        # @param text [String] Texto
+        # @return [String] Texto em verde
+        def self.green(text)
+          colorize(text, :green)
+        end
+
+        # Formata texto em amarelo
+        #
+        # @param text [String] Texto
+        # @return [String] Texto em amarelo
+        def self.yellow(text)
+          colorize(text, :yellow)
+        end
+
+        # Formata texto em azul
+        #
+        # @param text [String] Texto
+        # @return [String] Texto em azul
+        def self.blue(text)
+          colorize(text, :blue)
+        end
+
+        # Formata texto em cyan
+        #
+        # @param text [String] Texto
+        # @return [String] Texto em cyan
+        def self.cyan(text)
+          colorize(text, :cyan)
+        end
+
+        # Verifica se terminal suporta cores
+        #
+        # @return [Boolean] true se suporta
+        def self.supports_color?
+          return false if ENV['NO_COLOR']
+          return true if ENV['FORCE_COLOR']
+          return true if ENV['TERM'] && ENV['TERM'] != 'dumb'
+
+          $stdout.is_a?(IO) && $stdout.tty?
+        end
+      end
+
+      # Spinner para operações assíncronas
+      class Spinner
+        FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'].freeze
+
+        attr_reader :message, :running
+
+        # Inicializa o spinner
+        #
+        # @param message [String] Mensagem para exibir
+        # @param color [Symbol] Cor do spinner
+        def initialize(message: 'Carregando...', color: :cyan)
+          @message = message
+          @color = color
+          @running = false
+          @frame_index = 0
+          @thread = nil
+        end
+
+        # Inicia o spinner
+        #
+        # @return [void]
+        def start
+          return if @running
+
+          @running = true
+          @frame_index = 0
+
+          @thread = Thread.new do
+            while @running
+              print "\r#{colorize(FRAMES[@frame_index])} #{@message}"
+              $stdout.flush
+              @frame_index = (@frame_index + 1) % FRAMES.length
+              sleep(0.1)
+            end
+          end
+        end
+
+        # Para o spinner
+        #
+        # @param success [Boolean] Sucesso ou erro
+        # @return [void]
+        def stop(success: true)
+          return unless @running
+
+          @running = false
+          @thread&.join
+
+          # Limpa a linha e mostra ícone final
+          icon = success ? '✓' : '✗'
+          color = success ? :green : :red
+          print "\r#{colorize(icon, color)} #{@message}"
+          puts
+          $stdout.flush
+        end
+
+        # Atualiza a mensagem
+        #
+        # @param message [String] Nova mensagem
+        # @return [void]
+        def update(message)
+          @message = message
+        end
+
+        # Executa um bloco com o spinner ativo
+        #
+        # @param message [String] Mensagem inicial
+        # @yield Bloco para executar
+        # @return [void]
+        def self.spin(message = 'Carregando...')
+          spinner = new(message: message)
+          spinner.start
+
+          begin
+            yield
+            spinner.stop(success: true)
+          rescue => e
+            spinner.stop(success: false)
+            raise e
+          end
+        end
+
+        private
+
+        # Coloriza texto
+        #
+        # @param text [String] Texto
+        # @param color [Symbol] Cor
+        # @return [String] Texto colorido
+        def colorize(text, color = @color)
+          Colors.colorize(text, color)
+        end
+      end
+
+      # Barra de progresso
+      class ProgressBar
+        attr_reader :total, :current
+
+        # Inicializa a barra de progresso
+        #
+        # @param total [Integer] Total de itens
+        # @param width [Integer] Largura da barra
+        # @param options [Hash] Opções
+        def initialize(total, options = {})
+          @total = total
+          @current = 0
+          @width = options[:width] || 40
+          @filled_char = options[:filled_char] || '█'
+          @empty_char = options[:empty_char] || '░'
+          @show_percent = options.fetch(:show_percent, true)
+          @show_count = options.fetch(:show_count, true)
+        end
+
+        # Incrementa a barra
+        #
+        # @param count [Integer] Quantidade para incrementar
+        # @return [void]
+        def increment(count = 1)
+          @current += count
+          render
+        end
+
+        # Define o valor atual
+        #
+        # @param value [Integer] Valor atual
+        # @return [void]
+        def set(value)
+          @current = value
+          render
+        end
+
+        # Finaliza a barra
+        #
+        # @return [void]
+        def finish
+          @current = @total
+          render
+          puts
+          $stdout.flush
+        end
+
+        # Renderiza a barra
+        #
+        # @return [void]
+        def render
+          progress = @total > 0 ? @current.to_f / @total : 0
+          filled = (progress * @width).to_i
+          empty = @width - filled
+
+          bar = @filled_char * filled + @empty_char * empty
+
+          parts = []
+          parts << "[#{bar}]"
+
+          if @show_percent
+            parts << "#{(progress * 100).to_i}%"
+          end
+
+          if @show_count
+            parts << "(#{@current}/#{@total})"
+          end
+
+          print "\r#{parts.join(' ')}"
+          $stdout.flush
+        end
+      end
+
+      # Formatador de tabelas
+      class TableFormatter
+        attr_reader :headers, :rows
+
+        # Inicializa o formatador
+        #
+        # @param headers [Array<String>] Cabeçalhos
+        # @param rows [Array<Array<String>>] Linhas
+        def initialize(headers = [], rows = [])
+          @headers = headers
+          @rows = rows
+        end
+
+        # Adiciona uma linha
+        #
+        # @param row [Array<String>] Linha
+        # @return [void]
+        def add_row(row)
+          @rows << row
+        end
+
+        # Renderiza a tabela
+        #
+        # @return [String] Tabela formatada
+        def render
+          return '' if @headers.empty? && @rows.empty?
+
+          # Calcula larguras das colunas
+          all_rows = [@headers] + @rows
+          col_widths = all_rows.transpose.map do |col|
+            col.map { |cell| cell.to_s.length }.max
+          end
+
+          # Formata linhas
+          lines = []
+
+          # Header
+          header_line = @headers.zip(col_widths).map { |h, w| h.to_s.ljust(w) }.join(' │ ')
+          lines << header_line
+
+          # Separator
+          separator = col_widths.map { |w| '─' * w }.join('─┼─')
+          lines << separator
+
+          # Rows
+          @rows.each do |row|
+            row_line = row.zip(col_widths).map { |r, w| r.to_s.ljust(w) }.join(' │ ')
+            lines << row_line
+          end
+
+          lines.join("\n")
+        end
+
+        # Imprime a tabela
+        #
+        # @return [void]
+        def print
+          puts render
+        end
+
+        # Cria e imprime uma tabela rapidamente
+        #
+        # @param headers [Array<String>] Cabeçalhos
+        # @param rows [Array<Array<String>>] Linhas
+        # @return [void]
+        def self.table(headers, rows)
+          formatter = new(headers, rows)
+          formatter.print
+        end
+      end
+
+      # Formatador de output
+      module Formatter
+        # Formata JSON com indentação e cores
+        #
+        # @param data [Object] Dados
+        # @return [String] JSON formatado
+        def self.format_json(data)
+          json = JSON.pretty_generate(data)
+          return json unless Colors.supports_color?
+
+          # Adiciona cores ao JSON
+          json.gsub(/"([^"]+)":/) { |m| Colors.cyan(m) }
+              .gsub(/: "([^"]+)"/) { |m| ": #{Colors.green('"' + $1 + '"')}" }
+              .gsub(/: (\d+)/) { |m| ": #{Colors.yellow($1)}" }
+              .gsub(/: (true|false)/) { |m| ": #{Colors.blue($1)}" }
+        end
+
+        # Formata Markdown para terminal
+        #
+        # @param markdown [String] Markdown
+        # @return [String] Markdown formatado
+        def self.format_markdown(markdown)
+          return markdown unless Colors.supports_color?
+
+          # Headings
+          markdown = markdown.gsub(/^# (.+)$/) { |m| Colors.bold(Colors.blue(m)) }
+          markdown = markdown.gsub(/^## (.+)$/) { |m| Colors.bold(m) }
+          markdown = markdown.gsub(/^### (.+)$/) { |m| Colors.yellow(m) }
+
+          # Code blocks
+          markdown = markdown.gsub(/```(\w*)\n(.*?)```/m) do |m|
+            "\n" + Colors.gray(m) + "\n"
+          end
+
+          # Inline code
+          markdown = markdown.gsub(/`([^`]+)`/) { |m| Colors.gray(m) }
+
+          # Bold
+          markdown = markdown.gsub(/\*\*([^*]+)\*\*/) { |m| Colors.bold($1) }
+
+          # Italic
+          markdown = markdown.gsub(/\*([^*]+)\*/) { |m| Colors.italic($1) }
+
+          markdown
+        end
+
+        # Trunca texto se for muito longo
+        #
+        # @param text [String] Texto
+        # @param max_length [Integer] Comprimento máximo
+        # @return [String] Texto truncado
+        def self.truncate(text, max_length: 100)
+          return text if text.length <= max_length
+
+          text[0..max_length - 3] + '...'
+        end
+
+        # Formata timestamp
+        #
+        # @param time [Time] Tempo
+        # @return [String] Tempo formatado
+        def self.format_time(time)
+          time.strftime('%Y-%m-%d %H:%M:%S')
+        end
+
+        # Formata duração em segundos
+        #
+        # @param seconds [Numeric] Segundos
+        # @return [String] Duração formatada
+        def self.format_duration(seconds)
+          if seconds < 60
+            "#{seconds.to_i}s"
+          elsif seconds < 3600
+            "#{(seconds / 60).to_i}m #{(seconds % 60).to_i}s"
+          else
+            "#{(seconds / 3600).to_i}h #{(seconds % 3600 / 60).to_i}m"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gsd/buddy/cli.rb

@@ -0,0 +1,284 @@
+# frozen_string_literal: true
+
+require 'gsd/buddy/gacha'
+require 'gsd/buddy/stats'
+require 'gsd/buddy/renderer'
+
+module Gsd
+  module Buddy
+    # CLI - Interface de linha de comando para Buddy
+    #
+    # Comandos:
+    #   gsd buddy get
+    #   gsd buddy stats
+    #   gsd buddy feed
+    #   gsd buddy play
+    #   gsd buddy evolve
+    #   gsd buddy list
+    #   gsd buddy pull
+    class CLI
+      attr_reader :buddies, :renderer
+
+      # Inicializa o CLI
+      #
+      # @param args [Array] Argumentos de linha de comando
+      def initialize(args = [])
+        @args = args
+        @buddies = []
+        @renderer = Renderer.new
+        @config_file = File.join(Dir.home, '.gsd', 'buddy.json')
+        load_buddies
+      end
+
+      # Executa o comando
+      #
+      # @return [Integer] Exit code
+      def run
+        command = @args.first
+
+        case command
+        when 'get'
+          cmd_get
+        when 'stats'
+          cmd_stats
+        when 'feed'
+          cmd_feed
+        when 'play'
+          cmd_play
+        when 'evolve'
+          cmd_evolve
+        when 'list'
+          cmd_list
+        when 'pull'
+          cmd_pull
+        when 'help', '--help', '-h', nil
+          print_help
+          0
+        else
+          warn "Unknown command: #{command}"
+          print_help
+          1
+        end
+      rescue => e
+        warn "Error: #{e.message}"
+        1
+      end
+
+      private
+
+      # Comando: get
+      #
+      # @return [Integer] Exit code
+      def cmd_get
+        if @buddies.empty?
+          puts "You don't have any buddies yet!"
+          puts "\nPull your first buddy with:"
+          puts "  gsd buddy pull"
+          return 0
+        end
+
+        buddy = @buddies.first
+        puts @renderer.render(buddy)
+        0
+      end
+
+      # Comando: stats
+      #
+      # @return [Integer] Exit code
+      def cmd_stats
+        if @buddies.empty?
+          puts "No buddies found."
+          return 1
+        end
+
+        @buddies.each do |buddy|
+          puts @renderer.render(buddy)
+          puts "\n" + '=' * 60 + "\n"
+        end
+
+        0
+      end
+
+      # Comando: feed
+      #
+      # @return [Integer] Exit code
+      def cmd_feed
+        if @buddies.empty?
+          puts "No buddies to feed!"
+          return 1
+        end
+
+        @buddies.each do |buddy|
+          buddy.stats.increment_interaction
+          puts "Fed #{buddy.name}! +10 EXP"
+
+          if buddy.stats.check_level_up
+            puts "🎉 #{buddy.name} leveled up to #{buddy.level}!"
+          end
+        end
+
+        save_buddies
+        0
+      end
+
+      # Comando: play
+      #
+      # @return [Integer] Exit code
+      def cmd_play
+        if @buddies.empty?
+          puts "No buddies to play with!"
+          return 1
+        end
+
+        @buddies.each do |buddy|
+          buddy.stats.increment_interaction
+          puts "Played with #{buddy.name}! +10 EXP"
+
+          if buddy.stats.check_level_up
+            puts "🎉 #{buddy.name} leveled up to #{buddy.level}!"
+          end
+        end
+
+        save_buddies
+        0
+      end
+
+      # Comando: evolve
+      #
+      # @return [Integer] Exit code
+      def cmd_evolve
+        if @buddies.empty?
+          puts "No buddies to evolve!"
+          return 1
+        end
+
+        @buddies.each do |buddy|
+          if buddy.stats.can_evolve?(buddy.stats.stage)
+            puts "🎉 #{buddy.name} evolved from #{buddy.stats.stage}!"
+            # Evolution logic would go here
+          else
+            puts "#{buddy.name} cannot evolve yet."
+            puts "  Stage: #{buddy.stats.stage}"
+            puts "  Interactions: #{buddy.stats.interactions}"
+            puts "  Level: #{buddy.level}"
+          end
+        end
+
+        0
+      end
+
+      # Comando: list
+      #
+      # @return [Integer] Exit code
+      def cmd_list
+        if @buddies.empty?
+          puts "No buddies found."
+          return 0
+        end
+
+        puts @renderer.render_list(@buddies)
+        0
+      end
+
+      # Comando: pull
+      #
+      # @return [Integer] Exit code
+      def cmd_pull
+        user_id = get_user_id
+        gacha = Gacha.new(user_id: user_id)
+
+        puts "Pulling buddy..."
+        result = gacha.pull
+
+        puts "\n🎉 New Buddy Obtained! 🎉"
+        puts "=" * 60
+        puts "Species: #{result[:name]}"
+        puts "Rarity: #{result[:rarity]}"
+        puts "ASCII: #{result[:ascii]}"
+        puts "\nBase Stats:"
+        result[:stats].each do |stat, value|
+          puts "  #{stat.to_s.upcase}: #{value}/10"
+        end
+        puts "=" * 60
+
+        # Add buddy to collection
+        # In a real implementation, this would create a Buddy object
+        puts "\nBuddy added to your collection!"
+
+        0
+      end
+
+      # Obtém user ID
+      #
+      # @return [String] User ID
+      def get_user_id
+        ENV['USER'] || ENV['USERNAME'] || 'default-user'
+      end
+
+      # Carrega buddies do arquivo
+      #
+      # @return [void]
+      def load_buddies
+        return unless File.exist?(@config_file)
+
+        data = JSON.parse(File.read(@config_file))
+        # In a real implementation, this would load Buddy objects
+        @buddies = []
+      rescue => e
+        warn "Error loading buddies: #{e.message}"
+        @buddies = []
+      end
+
+      # Salva buddies no arquivo
+      #
+      # @return [void]
+      def save_buddies
+        FileUtils.mkdir_p(File.dirname(@config_file))
+        data = @buddies.map { |b| b.to_h }
+        File.write(@config_file, JSON.pretty_generate(data))
+      rescue => e
+        warn "Error saving buddies: #{e.message}"
+      end
+
+      # Imprime ajuda
+      #
+      # @return [void]
+      def print_help
+        puts <<~HELP
+
+          GSD Buddy CLI - Tamagotchi-style companion system
+
+          USAGE:
+            gsd buddy <command>
+
+          COMMANDS:
+            get           Get current buddy
+            stats         View buddy stats
+            feed          Feed your buddy
+            play          Play with your buddy
+            evolve        Evolve your buddy (if eligible)
+            list          List all buddies
+            pull          Pull a new buddy from gacha
+            help          Show this help
+
+          EXAMPLES:
+            gsd buddy pull
+            gsd buddy get
+            gsd buddy feed
+            gsd buddy play
+            gsd buddy stats
+            gsd buddy list
+            gsd buddy evolve
+
+          RARITY:
+            Common (50%)     - Pebblecrab, Codebug, Scriptling
+            Uncommon (30%)   - Bytebird, Loopfox, Debugdeer
+            Rare (15%)       - Testurtle, Refactoray, Mergebat
+            Epic (4%)        - Deploydragon, Pipelineon, Commitcat
+            Legendary (1%)   - Nebulynx, Quantumquail
+
+        HELP
+      end
+    end
+  end
+end