fantasy-cli 1.2.14 → 1.3.0

data/lib/gsd/tui/session.rb

@@ -0,0 +1,273 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+require 'gsd/tui/persistence'
+
+module Gsd
+  module TUI
+    # Session - Gerenciamento de sessões do TUI
+    #
+    # Responsável por:
+    # - Criar, salvar e restaurar sessões
+    # - Auto-save periódico
+    # - Checkpoints manuais e automáticos
+    class Session
+      attr_reader :id, :name, :created_at, :last_saved_at
+      attr_accessor :auto_save_interval, :max_checkpoints
+
+      def initialize(
+        id: nil,
+        name: nil,
+        auto_save_interval: 60,  # segundos
+        max_checkpoints: 10
+      )
+        @id = id || generate_session_id
+        @name = name || "Session #{Time.now.strftime('%Y-%m-%d %H:%M')}"
+        @created_at = Time.now.to_s
+        @last_saved_at = nil
+        @auto_save_interval = auto_save_interval
+        @max_checkpoints = max_checkpoints
+        
+        @persistence = Persistence.new
+        @auto_save_thread = nil
+        @running = false
+      end
+
+      # Inicia auto-save
+      def start_auto_save
+        return if @running
+        
+        @running = true
+        @auto_save_thread = Thread.new do
+          while @running
+            sleep(@auto_save_interval)
+            auto_save if @running
+          end
+        end
+      end
+
+      # Para auto-save
+      def stop_auto_save
+        @running = false
+        @auto_save_thread&.kill
+      end
+
+      # Salva estado atual da aplicação
+      #
+      # @param app [App] Instância do App do TUI
+      # @param metadata [Hash] Metadados adicionais
+      # @return [String] Caminho do arquivo salvo
+      def save(app:, metadata: {})
+        data = capture_state(app, metadata)
+        @last_saved_at = Time.now.to_s
+        
+        @persistence.save(session_id: @id, data: data)
+      end
+
+      # Auto-save (silent)
+      def auto_save(app: nil)
+        return unless app
+        
+        data = capture_state(app, { auto_save: true })
+        @last_saved_at = Time.now.to_s
+        
+        @persistence.save(session_id: "#{@id}_auto", data: data)
+      end
+
+      # Restaura sessão
+      #
+      # @param app [App] Instância do App do TUI
+      # @return [Boolean] true se restaurou com sucesso
+      def restore(app:)
+        data = @persistence.load(session_id: @id)
+        return false unless data
+
+        restore_state(app, data)
+        true
+      end
+
+      # Cria checkpoint manual
+      #
+      # @param app [App] Instância do App
+      # @param name [String] Nome do checkpoint
+      # @return [String] ID do checkpoint
+      def checkpoint(app:, name:)
+        save(app: app, metadata: { checkpoint: true, checkpoint_name: name })
+        
+        checkpoint_id = @persistence.create_checkpoint(
+          session_id: @id,
+          checkpoint_name: name
+        )
+        
+        cleanup_old_checkpoints
+        checkpoint_id
+      end
+
+      # Restaura de checkpoint
+      #
+      # @param app [App] Instância do App
+      # @param checkpoint_id [String] ID do checkpoint
+      # @return [Boolean] true se restaurou com sucesso
+      def restore_checkpoint(app:, checkpoint_id:)
+        data = @persistence.restore_checkpoint(checkpoint_id: checkpoint_id)
+        return false unless data
+
+        restore_state(app, data)
+        true
+      end
+
+      # Lista checkpoints disponíveis
+      #
+      # @return [Array<Hash>] Lista de checkpoints
+      def checkpoints
+        @persistence.list_checkpoints(session_id: @id)
+      end
+
+      # Exporta sessão
+      #
+      # @param format [Symbol] Formato de exportação
+      # @return [String] Conteúdo exportado
+      def export(format: :markdown)
+        @persistence.export(session_id: @id, format: format)
+      end
+
+      # Renomeia sessão
+      #
+      # @param new_name [String] Novo nome
+      def rename(new_name:)
+        @name = new_name
+      end
+
+      # Deleta sessão
+      def delete
+        @persistence.delete(session_id: @id)
+        stop_auto_save
+      end
+
+      # Informações da sessão
+      #
+      # @return [Hash] Metadados da sessão
+      def info
+        {
+          id: @id,
+          name: @name,
+          created_at: @created_at,
+          last_saved_at: @last_saved_at,
+          auto_save_enabled: @running,
+          auto_save_interval: @auto_save_interval
+        }
+      end
+
+      # Estatísticas da sessão
+      #
+      # @return [Hash] Estatísticas
+      def stats
+        data = @persistence.load(session_id: @id)
+        return {} unless data
+
+        {
+          message_count: data[:output]&.length || 0,
+          user_messages: data[:output]&.count { |m| m[:type] == :user } || 0,
+          assistant_messages: data[:output]&.count { |m| m[:type] == :assistant } || 0,
+          duration: calculate_duration(data),
+          agent_count: data[:swarm_stats]&.dig(:total_agents) || 0
+        }
+      end
+
+      class << self
+        # Lista todas as sessões disponíveis
+        #
+        # @return [Array<Hash>] Lista de sessões
+        def list_all
+          Persistence.new.list_sessions
+        end
+
+        # Carrega uma sessão existente
+        #
+        # @param session_id [String] ID da sessão
+        # @return [Session, nil] Sessão ou nil
+        def load(session_id:)
+          data = Persistence.new.load(session_id: session_id)
+          return nil unless data
+
+          session = new(
+            id: session_id,
+            name: data[:name]
+          )
+          session.instance_variable_set(:@created_at, data[:created_at])
+          session.instance_variable_set(:@last_saved_at, data[:updated_at])
+          session
+        end
+      end
+
+      private
+
+      def generate_session_id
+        "session-#{Time.now.to_i}-#{SecureRandom.hex(4)}"
+      end
+
+      def capture_state(app, metadata)
+        {
+          id: @id,
+          name: @name,
+          version: Gsd::VERSION,
+          created_at: @created_at,
+          updated_at: Time.now.to_s,
+          theme: app.instance_variable_get(:@theme),
+          output: app.instance_variable_get(:@output)&.dup || [],
+          history: app.instance_variable_get(:@history)&.dup || [],
+          selected_agent: app.instance_variable_get(:@selected_agent),
+          swarm_stats: app.instance_variable_get(:@swarm)&.stats || {},
+          **metadata
+        }
+      end
+
+      def restore_state(app, data)
+        app.instance_variable_set(:@output, data[:output] || [])
+        app.instance_variable_set(:@history, data[:history] || [])
+        app.instance_variable_set(:@selected_agent, data[:selected_agent] || 0)
+        
+        # Restore theme if different
+        if data[:theme] && data[:theme] != app.instance_variable_get(:@theme)
+          app.send(:set_theme, data[:theme])
+        end
+      end
+
+      def cleanup_old_checkpoints
+        all_checkpoints = @persistence.list_checkpoints(session_id: @id)
+        return if all_checkpoints.length <= @max_checkpoints
+
+        # Remove oldest checkpoints
+        to_remove = all_checkpoints[@max_checkpoints..-1]
+        to_remove.each do |checkpoint|
+          checkpoint_file = File.join(
+            @persistence.sessions_dir,
+            'checkpoints',
+            "#{checkpoint[:id]}.json"
+          )
+          File.delete(checkpoint_file) if File.exist?(checkpoint_file)
+        end
+      end
+
+      def calculate_duration(data)
+        return 'N/A' unless data[:created_at] && data[:updated_at]
+
+        begin
+          created = Time.parse(data[:created_at])
+          updated = Time.parse(data[:updated_at])
+          duration = updated - created
+          
+          if duration < 60
+            "#{duration.to_i}s"
+          elsif duration < 3600
+            "#{(duration / 60).to_i}m"
+          else
+            "#{(duration / 3600).to_i}h #{(duration % 3600 / 60).to_i}m"
+          end
+        rescue
+          'N/A'
+        end
+      end
+    end
+  end
+end

data/lib/gsd/tui/status_bar.rb

@@ -4,10 +4,12 @@ require 'gsd/tui/colors'
 
 module Gsd
   module TUI
+    # StatusBar estilo Warp com badges coloridos
     class StatusBar
       def initialize
         @mode = 'NORMAL'
-        @branch = 'master'
+        @branch = 'main'
+        @cwd = Dir.pwd
       end
 
       def update_mode(mode)
@@ -18,33 +20,79 @@ module Gsd
         @branch = branch
       end
 
+      def update_cwd(cwd)
+        @cwd = cwd
+      end
+
       def render(width: 80)
         t = Colors.theme
-        dim = t[:dim]
-        accent = t[:accent]
+        reset = Colors::RESET
+
+        # Cores Cyber Wave
+        cyan = t[:accent]          # Ciano neon
+        magenta = t[:accent2]      # Roxo neon  
+        pink = t[:accent3]         # Rosa
         white = t[:text]
+        dim = t[:dim]
         bg = t[:bg]
-        bg_accent = t[:bg_accent]
-        reset = Colors::RESET
+        bg_cyan = t[:bg_accent]
 
         time = Time.now.strftime('%H:%M:%S')
+        dir = File.basename(@cwd)
+
+        # Badge de modo (CODE/PLAN/DEBUG) com background colorido
+        mode_badge = "#{bg_cyan}#{Colors::BLACK} #{@mode} #{reset}"
 
-        # Left side: Branch and Mode
-        left = " #{dim}~/#{@branch}:#{accent}#{@branch}#{reset} "
+        # Badge de diretório
+        dir_badge = "#{dim}📁 #{dir}#{reset}"
 
-        # Right side: Time
-        right = " #{dim}#{time}#{reset} "
+        # Badge de git
+        if git_info_available?
+          git_badge = "#{magenta}git:(#{@branch})#{reset}"
+          git_status = git_clean? ? "#{Colors::GREEN}✓#{reset}" : "#{pink}●#{reset}"
+          git_section = " #{git_badge} #{git_status}"
+        else
+          git_section = ""
+        end
 
-        # Center: Shortcuts
-        center = "#{dim}tab#{reset} #{white}agents#{reset}  #{dim}ctrl+p#{reset} #{white}commands#{reset}  #{dim}ctrl+q#{reset} #{white}quit#{reset}"
+        # Left side: badges
+        left = "#{mode_badge} #{dir_badge}#{git_section}"
+
+        # Right side: time
+        right = "#{dim}#{time}#{reset}"
+
+        # Center: shortcuts
+        center = "#{dim}tab#{reset} #{white}mode#{reset}  #{dim}ctrl+p#{reset} #{white}cmds#{reset}  #{dim}ctrl+q#{reset} #{white}quit#{reset}"
 
         # Calculate padding
+        clean_left = left.gsub(/\e\[\d+m/, '').length
         clean_center = center.gsub(/\e\[\d+m/, '').length
-        padding = width - left.length - right.length - clean_center - 2
-        padding = [padding, 0].max
+        clean_right = right.gsub(/\e\[\d+m/, '').length
+        
+        total_content = clean_left + clean_center + clean_right
+        padding = width - total_content
+        padding_left = padding / 2
+        padding_right = padding - padding_left
+        padding_left = [padding_left, 0].max
+        padding_right = [padding_right, 0].max
+
+        # Status bar line estilo Warp
+        "#{bg}#{left}#{' ' * padding_left}#{center}#{' ' * padding_right}#{right}#{reset}"
+      end
+
+      private
+
+      def git_info_available?
+        File.directory?(File.join(@cwd, '.git'))
+      end
 
-        # Status bar line
-        "#{bg_accent}#{white} #{@mode} #{reset}#{bg}#{left}#{' ' * padding}#{center}  #{right}#{reset}"
+      def git_clean?
+        return true unless git_info_available?
+        
+        status = `git -C #{@cwd} status --porcelain 2>/dev/null`.strip
+        status.empty?
+      rescue
+        true
       end
     end
   end

data/lib/gsd/tui/tab.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Gsd
+  module TUI
+    # Tab - Representa uma aba individual no TUI
+    #
+    # Cada aba mantém seu próprio estado:
+    # - Histórico de mensagens
+    # - Input box state
+    # - Agentes ativos
+    # - Tema/configurações
+    class Tab
+      attr_accessor :id, :title, :output, :history, :history_index, :input_text
+      attr_accessor :selected_agent, :theme, :swarm_stats
+      attr_reader :created_at, :updated_at
+
+      def initialize(id: nil, title: nil, theme: :cyber_wave)
+        @id = id || generate_id
+        @title = title || "Tab #{@id[-4..-1]}"
+        @theme = theme
+        
+        # State per tab
+        @output = []
+        @history = []
+        @history_index = -1
+        @input_text = ''
+        @selected_agent = 1
+        @swarm_stats = {}
+        
+        @created_at = Time.now
+        @updated_at = @created_at
+      end
+
+      # Adiciona mensagem ao output
+      def add_message(type, text)
+        @output << { type: type, text: text, timestamp: Time.now.to_s }
+        @output = @output.last(100)  # Keep last 100 messages
+        touch
+      end
+
+      # Adiciona ao histórico
+      def add_to_history(text)
+        @history << text
+        @history = @history.last(50)  # Keep last 50
+        @history_index = @history.length
+        touch
+      end
+
+      # Atualiza timestamp
+      def touch
+        @updated_at = Time.now
+      end
+
+      # Renomeia aba
+      def rename(new_title)
+        @title = new_title
+        touch
+      end
+
+      # Estado para persistência
+      def to_h
+        {
+          id: @id,
+          title: @title,
+          theme: @theme,
+          output: @output,
+          history: @history,
+          history_index: @history_index,
+          selected_agent: @selected_agent,
+          created_at: @created_at.to_s,
+          updated_at: @updated_at.to_s
+        }
+      end
+
+      # Carrega de hash
+      def self.from_h(hash)
+        tab = new(
+          id: hash[:id],
+          title: hash[:title],
+          theme: hash[:theme]&.to_sym || :cyber_wave
+        )
+        tab.output = hash[:output] || []
+        tab.history = hash[:history] || []
+        tab.history_index = hash[:history_index] || -1
+        tab.selected_agent = hash[:selected_agent] || 1
+        tab
+      end
+
+      # Contador de mensagens
+      def message_count
+        @output.length
+      end
+
+      # Resumo do conteúdo para preview
+      def preview
+        return 'Empty' if @output.empty?
+        
+        last_msg = @output.last
+        text = last_msg[:text] || ''
+        text.length > 30 ? "#{text[0..27]}..." : text
+      end
+
+      private
+
+      def generate_id
+        "tab-#{SecureRandom.hex(4)}"
+      end
+    end
+  end
+end

data/lib/gsd/tui/tab_manager.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+require 'gsd/tui/tab'
+
+module Gsd
+  module TUI
+    # TabManager - Gerenciamento de múltiplas abas no TUI
+    #
+    # Funcionalidades:
+    # - Criar, fechar, navegar entre abas
+    # - Switch de contexto (cada aba tem estado independente)
+    # - Keybindings: Ctrl+T (new), Ctrl+W (close), Ctrl+Tab (next)
+    class TabManager
+      attr_reader :tabs, :current_index, :max_tabs
+
+      def initialize(max_tabs: 10)
+        @tabs = []
+        @current_index = -1
+        @max_tabs = max_tabs
+        
+        # Cria primeira aba automaticamente
+        create_tab(title: 'Main')
+      end
+
+      # Cria nova aba
+      #
+      # @param title [String] Título da aba (opcional)
+      # @return [Tab] A nova aba criada
+      def create_tab(title: nil)
+        return nil if @tabs.length >= @max_tabs
+
+        tab = Tab.new(title: title)
+        @tabs << tab
+        @current_index = @tabs.length - 1
+        tab
+      end
+
+      # Fecha aba atual
+      #
+      # @return [Boolean] true se fechou, false se não (única aba)
+      def close_current_tab
+        return false if @tabs.length <= 1
+
+        @tabs.delete_at(@current_index)
+        @current_index = [@current_index, @tabs.length - 1].min
+        true
+      end
+
+      # Fecha aba específica
+      #
+      # @param index [Integer] Índice da aba
+      def close_tab(index)
+        return false if @tabs.length <= 1
+        return false unless index.between?(0, @tabs.length - 1)
+
+        @tabs.delete_at(index)
+        @current_index = [@current_index, @tabs.length - 1].min
+        true
+      end
+
+      # Navega para próxima aba
+      def next_tab
+        @current_index = (@current_index + 1) % @tabs.length
+        current_tab
+      end
+
+      # Navega para aba anterior
+      def previous_tab
+        @current_index = (@current_index - 1) % @tabs.length
+        current_tab
+      end
+
+      # Vai para aba específica
+      #
+      # @param index [Integer] Índice da aba
+      def switch_to_tab(index)
+        return unless index.between?(0, @tabs.length - 1)
+        
+        @current_index = index
+        current_tab
+      end
+
+      # Aba atual
+      #
+      # @return [Tab, nil] Aba atual ou nil
+      def current_tab
+        @tabs[@current_index]
+      end
+
+      # Renomeia aba atual
+      #
+      # @param title [String] Novo título
+      def rename_current_tab(title)
+        current_tab&.rename(title)
+      end
+
+      # Total de abas
+      def tab_count
+        @tabs.length
+      end
+
+      # Verifica se pode criar mais abas
+      def can_create_more?
+        @tabs.length < @max_tabs
+      end
+
+      # Renderiza barra de tabs
+      #
+      # @param width [Integer] Largura disponível
+      # @return [String] Representação em string das tabs
+      def render_tab_bar(width: 80)
+        return '' if @tabs.empty?
+
+        t = Colors.theme
+        cyan = t[:accent]
+        magenta = t[:accent2]
+        white = t[:text]
+        dim = t[:dim]
+        bg = t[:bg]
+        reset = Colors::RESET
+
+        parts = @tabs.each_with_index.map do |tab, i|
+          is_active = i == @current_index
+          
+          if is_active
+            "#{cyan}[#{reset} #{white}#{tab.title}#{reset} #{cyan}]#{reset}"
+          else
+            "#{dim}[#{tab.title}]#{reset}"
+          end
+        end
+
+        bar = parts.join('  ')
+        
+        # Truncate if too long
+        clean_len = bar.gsub(/\e\[\d+m/, '').length
+        if clean_len > width
+          # Show current tab and neighbors
+          start_idx = [@current_index - 1, 0].max
+          end_idx = [start_idx + 2, @tabs.length - 1].min
+          
+          visible = (start_idx..end_idx).map do |i|
+            tab = @tabs[i]
+            is_active = i == @current_index
+            
+            if is_active
+              "#{cyan}[#{reset} #{white}#{tab.title}#{reset} #{cyan}]#{reset}"
+            else
+              "#{dim}[#{tab.title}]#{reset}"
+            end
+          end
+          
+          bar = visible.join('  ')
+          bar = "#{dim}... #{reset}#{bar}" if start_idx > 0
+          bar = "#{bar} #{dim}...#{reset}" if end_idx < @tabs.length - 1
+        end
+
+        bar
+      end
+
+      # Lista abas para seleção
+      #
+      # @return [Array<Hash>] Lista com id, título, índice
+      def list_tabs
+        @tabs.map.with_index do |tab, i|
+          {
+            index: i,
+            id: tab.id,
+            title: tab.title,
+            message_count: tab.message_count,
+            is_active: i == @current_index
+          }
+        end
+      end
+
+      # Persistência: salva todas as abas
+      #
+      # @return [Array<Hash>] Array de hashes das abas
+      def to_a
+        @tabs.map(&:to_h)
+      end
+
+      # Persistência: carrega abas
+      #
+      # @param data [Array<Hash>] Dados das abas
+      def load_from_array(data)
+        @tabs = data.map { |h| Tab.from_h(h) }
+        @current_index = 0
+      end
+    end
+  end
+end