fantasy-cli 1.2.14 → 1.3.0

data/lib/gsd/tui/mouse.rb

@@ -0,0 +1,388 @@
+# frozen_string_literal: true
+
+module Gsd
+  module TUI
+    # Mouse - Suporte a mouse e eventos de clique
+    #
+    # Suporta:
+    # - Cliques (left, right, middle)
+    # - Scroll (up, down)
+    # - Drag
+    # - Hover
+    # - Seleção de texto
+    class Mouse
+      attr_reader :x, :y, :button, :event_type
+
+      BUTTONS = {
+        0 => :left,
+        1 => :middle,
+        2 => :right,
+        64 => :scroll_up,
+        65 => :scroll_down
+      }.freeze
+
+      def initialize
+        @enabled = false
+        @x = 0
+        @y = 0
+        @button = nil
+        @event_type = nil
+        @handlers = {}
+        @drag_start = nil
+        @selection = nil
+      end
+
+      # Habilita suporte ao mouse
+      def enable
+        return if @enabled
+
+        @enabled = true
+        # Habilita modo mouse do terminal (1000, 1002, 1006)
+        print "\e[?1000h\e[?1002h\e[?1006h" unless Gem.win_platform?
+      end
+
+      # Desabilita suporte ao mouse
+      def disable
+        return unless @enabled
+
+        @enabled = false
+        print "\e[?1000l\e[?1002l\e[?1006l" unless Gem.win_platform?
+      end
+
+      # Processa input de mouse
+      # Formato: \e[<button;x;yM (press) ou \e[<button;x;ym (release)
+      def parse(input)
+        return nil unless input.start_with?("\e[<")
+
+        # Extrai dados do formato SGR (1006)
+        match = input.match(/\e\[<(\d+);(\d+);(\d+)([Mm])/)
+        return nil unless match
+
+        button_code = match[1].to_i
+        @x = match[2].to_i
+        @y = match[3].to_i
+        action = match[4] == 'M' ? :press : :release
+
+        @button = BUTTONS[button_code] || :unknown
+        @event_type = determine_event_type(button_code, action)
+
+        MouseEvent.new(
+          x: @x,
+          y: @y,
+          button: @button,
+          type: @event_type,
+          raw: input
+        )
+      end
+
+      # Registra handler para evento
+      def on(event, &block)
+        @handlers[event] ||= []
+        @handlers[event] << block
+      end
+
+      # Processa evento
+      def handle(event)
+        return unless event.is_a?(MouseEvent)
+
+        # Atualiza estado de drag
+        update_drag_state(event)
+
+        # Chama handlers
+        handlers = @handlers[event.type] || []
+        handlers.each { |h| h.call(event) }
+
+        # Handler genérico
+        generic = @handlers[:any] || []
+        generic.each { |h| h.call(event) }
+      end
+
+      # Verifica se coordenada está dentro de uma região
+      def in_region?(x, y, width, height)
+        @x >= x && @x < x + width && @y >= y && @y < y + height
+      end
+
+      # Verifica se está em uma linha específica
+      def on_line?(y)
+        @y == y
+      end
+
+      # Seleção atual
+      def selection
+        @selection
+      end
+
+      # Inicia seleção
+      def start_selection(x, y)
+        @selection = { start_x: x, start_y: y, end_x: x, end_y: y }
+      end
+
+      # Atualiza seleção
+      def update_selection(x, y)
+        return unless @selection
+        @selection[:end_x] = x
+        @selection[:end_y] = y
+      end
+
+      # Finaliza seleção
+      def end_selection
+        sel = @selection
+        @selection = nil
+        sel
+      end
+
+      # Estado de drag
+      def dragging?
+        @drag_start && !@drag_start[:ended]
+      end
+
+      # Posição inicial do drag
+      def drag_start
+        @drag_start
+      end
+
+      private
+
+      def determine_event_type(button_code, action)
+        case button_code
+        when 64
+          :scroll_up
+        when 65
+          :scroll_down
+        else
+          action == :press ? :click : :release
+        end
+      end
+
+      def update_drag_state(event)
+        case event.type
+        when :click
+          @drag_start = { x: event.x, y: event.y, button: event.button, ended: false }
+        when :release
+          @drag_start[:ended] = true if @drag_start
+        end
+      end
+    end
+
+    # MouseEvent - Representa um evento de mouse
+    class MouseEvent
+      attr_reader :x, :y, :button, :type, :raw
+
+      def initialize(x:, y:, button:, type:, raw: nil)
+        @x = x
+        @y = y
+        @button = button
+        @type = type
+        @raw = raw
+      end
+
+      # Verifica se é clique esquerdo
+      def left_click?
+        @button == :left && @type == :click
+      end
+
+      # Verifica se é clique direito
+      def right_click?
+        @button == :right && @type == :click
+      end
+
+      # Verifica se é scroll
+      def scroll?
+        @type == :scroll_up || @type == :scroll_down
+      end
+
+      # Direção do scroll
+      def scroll_direction
+        return nil unless scroll?
+        @type == :scroll_up ? :up : :down
+      end
+
+      # Converte para string legível
+      def to_s
+        "#{type} at (#{x},#{y}) with #{button}"
+      end
+    end
+
+    # ClickableRegion - Região clicável na tela
+    class ClickableRegion
+      attr_reader :x, :y, :width, :height, :id, :data
+
+      def initialize(x:, y:, width:, height:, id:, data: nil, &block)
+        @x = x
+        @y = y
+        @width = width
+        @height = height
+        @id = id
+        @data = data
+        @callback = block
+        @hover = false
+      end
+
+      # Verifica se ponto está dentro da região
+      def contains?(px, py)
+        px >= @x && px < @x + @width && py >= @y && py < @y + @height
+      end
+
+      # Handler de clique
+      def on_click(event)
+        @callback&.call(event, self)
+      end
+
+      # Handler de hover
+      def on_hover(event)
+        @hover = true
+      end
+
+      # Handler de leave
+      def on_leave
+        @hover = false
+      end
+
+      # Está com hover?
+      def hover?
+        @hover
+      end
+
+      # Renderiza com highlight se hover
+      def render(content, theme: nil)
+        t = theme || Colors.theme
+        if @hover
+          "#{t[:accent]}#{content}#{Colors::RESET}"
+        else
+          content
+        end
+      end
+    end
+
+    # RegionManager - Gerencia regiões clicáveis
+    class RegionManager
+      def initialize
+        @regions = []
+        @mutex = Mutex.new
+      end
+
+      # Adiciona região
+      def add(region)
+        @mutex.synchronize { @regions << region }
+      end
+
+      # Remove região
+      def remove(id)
+        @mutex.synchronize { @regions.delete_if { |r| r.id == id } }
+      end
+
+      # Limpa todas
+      def clear
+        @mutex.synchronize { @regions.clear }
+      end
+
+      # Encontra região em coordenada
+      def find_at(x, y)
+        @mutex.synchronize do
+          @regions.find { |r| r.contains?(x, y) }
+        end
+      end
+
+      # Processa evento de mouse
+      def handle_event(event)
+        region = find_at(event.x, event.y)
+
+        case event.type
+        when :click
+          region&.on_click(event)
+        when :scroll_up, :scroll_down
+          region&.on_scroll(event)
+        end
+
+        # Atualiza hover states
+        update_hover_states(event)
+
+        region
+      end
+
+      # Lista todas regiões
+      def all
+        @mutex.synchronize { @regions.dup }
+      end
+
+      private
+
+      def update_hover_states(event)
+        @regions.each do |r|
+          was_hover = r.hover?
+          is_hover = r.contains?(event.x, event.y)
+
+          if !was_hover && is_hover
+            r.on_hover(event)
+          elsif was_hover && !is_hover
+            r.on_leave
+          end
+        end
+      end
+    end
+
+    # MouseIntegration - Integração com App
+    class MouseIntegration
+      def initialize(app)
+        @app = app
+        @mouse = Mouse.new
+        @regions = RegionManager.new
+        setup_handlers
+      end
+
+      def enable
+        @mouse.enable
+      end
+
+      def disable
+        @mouse.disable
+      end
+
+      def process(input)
+        event = @mouse.parse(input)
+        return nil unless event
+
+        @mouse.handle(event)
+        @regions.handle_event(event)
+
+        # Integração específica com App
+        handle_app_interaction(event)
+
+        event
+      end
+
+      def add_clickable_region(x, y, width, height, id, data = nil, &block)
+        @regions.add(ClickableRegion.new(
+          x: x, y: y, width: width, height: height,
+          id: id, data: data, &block
+        ))
+      end
+
+      private
+
+      def setup_handlers
+        @mouse.on(:scroll_up) do |event|
+          # Scroll up no output
+          @app.scroll_output(-3)
+        end
+
+        @mouse.on(:scroll_down) do |event|
+          # Scroll down no output
+          @app.scroll_output(3)
+        end
+
+        @mouse.on(:click) do |event|
+          # Verifica se clicou em elemento específico
+          if event.y == 0
+            # Header area - toggle palette
+            @app.toggle_palette if event.x < 20
+          end
+        end
+      end
+
+      def handle_app_interaction(event)
+        # Delega para regiões ou comportamentos padrão
+      end
+    end
+  end
+end

data/lib/gsd/tui/persistence.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'fileutils'
+
+module Gsd
+  module TUI
+    # Persistence - Camada de persistência para o TUI
+    #
+    # Gerencia:
+    # - Save/restore de estado do TUI
+    # - Persistência de conversas
+    # - Checkpoints
+    # - Auto-save
+    class Persistence
+      SESSIONS_DIR = File.expand_path('~/.gsd/sessions').freeze
+      
+      attr_reader :sessions_dir
+
+      def initialize(sessions_dir: SESSIONS_DIR)
+        @sessions_dir = sessions_dir
+        ensure_directory
+      end
+
+      # Salva um estado de sessão
+      #
+      # @param session_id [String] ID da sessão
+      # @param data [Hash] Dados a serem salvos
+      # @return [String] Caminho do arquivo salvo
+      def save(session_id:, data:)
+        filepath = session_path(session_id)
+        
+        File.write(filepath, JSON.pretty_generate(data))
+        filepath
+      end
+
+      # Carrega um estado de sessão
+      #
+      # @param session_id [String] ID da sessão
+      # @return [Hash, nil] Dados da sessão ou nil se não existir
+      def load(session_id:)
+        filepath = session_path(session_id)
+        return nil unless File.exist?(filepath)
+
+        JSON.parse(File.read(filepath), symbolize_names: true)
+      rescue JSON::ParserError => e
+        puts "Error loading session #{session_id}: #{e.message}"
+        nil
+      end
+
+      # Lista todas as sessões disponíveis
+      #
+      # @return [Array<Hash>] Lista de metadados das sessões
+      def list_sessions
+        return [] unless Dir.exist?(@sessions_dir)
+
+        Dir.glob(File.join(@sessions_dir, '*.json')).map do |filepath|
+          begin
+            data = JSON.parse(File.read(filepath), symbolize_names: true)
+            {
+              id: File.basename(filepath, '.json'),
+              name: data[:name] || 'Unnamed Session',
+              created_at: data[:created_at],
+              updated_at: data[:updated_at],
+              message_count: data[:output]&.length || 0,
+              agent_count: data[:swarm_stats]&.dig(:total_agents) || 0
+            }
+          rescue => e
+            nil
+          end
+        end.compact.sort_by { |s| s[:updated_at] || s[:created_at] || '' }.reverse
+      end
+
+      # Deleta uma sessão
+      #
+      # @param session_id [String] ID da sessão
+      def delete(session_id:)
+        filepath = session_path(session_id)
+        File.delete(filepath) if File.exist?(filepath)
+      end
+
+      # Cria um checkpoint (snapshot) da sessão
+      #
+      # @param session_id [String] ID da sessão
+      # @param checkpoint_name [String] Nome do checkpoint
+      def create_checkpoint(session_id:, checkpoint_name:)
+        data = load(session_id: session_id)
+        return unless data
+
+        checkpoint_id = "#{session_id}_#{checkpoint_name}_#{Time.now.to_i}"
+        checkpoint_path = File.join(@sessions_dir, 'checkpoints', "#{checkpoint_id}.json")
+        
+        FileUtils.mkdir_p(File.dirname(checkpoint_path))
+        File.write(checkpoint_path, JSON.pretty_generate(data))
+        
+        checkpoint_id
+      end
+
+      # Restaura de um checkpoint
+      #
+      # @param checkpoint_id [String] ID do checkpoint
+      # @return [Hash, nil] Dados do checkpoint
+      def restore_checkpoint(checkpoint_id:)
+        checkpoint_path = File.join(@sessions_dir, 'checkpoints', "#{checkpoint_id}.json")
+        return nil unless File.exist?(checkpoint_path)
+
+        JSON.parse(File.read(checkpoint_path), symbolize_names: true)
+      end
+
+      # Lista checkpoints de uma sessão
+      #
+      # @param session_id [String] ID da sessão
+      # @return [Array<Hash>] Lista de checkpoints
+      def list_checkpoints(session_id:)
+        pattern = File.join(@sessions_dir, 'checkpoints', "#{session_id}_*.json")
+        
+        Dir.glob(pattern).map do |filepath|
+          filename = File.basename(filepath, '.json')
+          parts = filename.split('_')
+          
+          {
+            id: filename,
+            name: parts[1..-2].join('_'),
+            timestamp: parts.last.to_i,
+            created_at: Time.at(parts.last.to_i).to_s
+          }
+        end.sort_by { |c| c[:timestamp] }.reverse
+      end
+
+      # Exporta sessão para formato legível (Markdown)
+      #
+      # @param session_id [String] ID da sessão
+      # @param format [Symbol] Formato (:markdown, :json)
+      # @return [String] Conteúdo exportado
+      def export(session_id:, format: :markdown)
+        data = load(session_id: session_id)
+        return nil unless data
+
+        case format
+        when :markdown
+          export_to_markdown(data)
+        when :json
+          JSON.pretty_generate(data)
+        else
+          JSON.pretty_generate(data)
+        end
+      end
+
+      private
+
+      def ensure_directory
+        FileUtils.mkdir_p(@sessions_dir)
+        FileUtils.mkdir_p(File.join(@sessions_dir, 'checkpoints'))
+      end
+
+      def session_path(session_id)
+        File.join(@sessions_dir, "#{session_id}.json")
+      end
+
+      def export_to_markdown(data)
+        lines = []
+        lines << "# Session: #{data[:name] || 'Unnamed'}"
+        lines << ""
+        lines << "**Created:** #{data[:created_at]}"
+        lines << "**Updated:** #{data[:updated_at]}"
+        lines << ""
+        lines << "## Conversation"
+        lines << ""
+
+        data[:output]&.each do |msg|
+          case msg[:type]
+          when :user
+            lines << "### User"
+            lines << ""
+            lines << msg[:text]
+            lines << ""
+          when :assistant
+            lines << "### Assistant"
+            lines << ""
+            lines << msg[:text]
+            lines << ""
+          when :system
+            lines << "*#{msg[:text]}*"
+            lines << ""
+          end
+        end
+
+        lines.join("\n")
+      end
+    end
+  end
+end