fantasy-cli 1.2.6

data/lib/gsd/ai/history.rb

@@ -0,0 +1,384 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'zlib'
+require 'securerandom'
+require 'fileutils'
+
+module Gsd
+  module AI
+    # History Management - Gerencia histórico de conversas
+    #
+    # Responsável por:
+    # - Manter histórico de mensagens
+    # - Adicionar mensagens de usuário e assistente
+    # - Adicionar resultados de tool calls
+    # - Limitar tamanho do histórico
+    # - Persistência em disco
+    # - Compressão de histórico antigo
+    # - Sumarização de conversas antigas
+    class History
+      attr_reader :messages, :max_messages, :max_tokens
+
+      # Inicializa o histórico
+      #
+      # @param max_messages [Integer] Número máximo de mensagens
+      # @param max_tokens [Integer] Número máximo de tokens
+      # @param persist_dir [String] Diretório para persistência
+      def initialize(max_messages: 100, max_tokens: 100_000, persist_dir: nil)
+        @messages = []
+        @max_messages = max_messages
+        @max_tokens = max_tokens
+        @persist_dir = persist_dir
+        @summaries = [] # Sumarizações de conversas antigas
+
+        load_from_disk if @persist_dir
+      end
+
+      # Adiciona mensagem do usuário
+      #
+      # @param content [String] Conteúdo da mensagem
+      # @return [void]
+      def add_user_message(content)
+        add_message(role: 'user', content: content)
+      end
+
+      # Adiciona mensagem do assistente
+      #
+      # @param content [String] Conteúdo da mensagem
+      # @return [void]
+      def add_assistant_message(content)
+        add_message(role: 'assistant', content: content)
+      end
+
+      # Adiciona mensagem de sistema
+      #
+      # @param content [String] Conteúdo da mensagem
+      # @return [void]
+      def add_system_message(content)
+        add_message(role: 'system', content: content)
+      end
+
+      # Adiciona resultados de tool calls
+      #
+      # @param results [Array] Resultados das tools
+      # @return [void]
+      def add_tool_results(results)
+        content = build_tool_results_content(results)
+        add_message(role: 'tool', content: content)
+      end
+
+      # Limpa o histórico
+      #
+      # @return [void]
+      def clear
+        @messages = []
+        @summaries = []
+        save_to_disk if @persist_dir
+      end
+
+      # Retorna o número de mensagens
+      #
+      # @return [Integer] Número de mensagens
+      def count
+        @messages.count
+      end
+
+      # Converte para formato da API do LLM
+      #
+      # @param include_summaries [Boolean] Incluir sumarizações antigas
+      # @return [Array] Mensagens formatadas
+      def to_api_messages(include_summaries: true)
+        result = []
+
+        # Adiciona sumarizações primeiro (se houver)
+        if include_summaries && @summaries.any?
+          result << {
+            role: 'system',
+            content: build_summaries_content
+          }
+        end
+
+        # Adiciona mensagens
+        result + @messages.map do |msg|
+          format_message_for_api(msg)
+        end
+      end
+
+      # Trunca histórico se exceder limites
+      #
+      # @return [void]
+      def truncate_if_needed
+        # Trunca por número de mensagens
+        if @messages.count > @max_messages
+          # Move mensagens antigas para summaries antes de truncar
+          to_remove = @messages.count - @max_messages
+          if to_remove > 0
+            summarize_old_messages(to_remove)
+            @messages = @messages.last(@max_messages)
+          end
+        end
+
+        # Trunca por tokens (estimativa simples)
+        while estimate_tokens > @max_tokens && @messages.count > 10
+          # Move mensagens antigas para summaries
+          to_remove = (@messages.count * 0.2).ceil # Remove 20% por vez
+          summarize_old_messages(to_remove)
+          @messages = @messages.last(@messages.count - to_remove)
+        end
+      end
+
+      # Exporta histórico para JSON
+      #
+      # @return [String] JSON do histórico
+      def to_json
+        JSON.pretty_generate({
+          messages: @messages,
+          summaries: @summaries,
+          metadata: {
+            max_messages: @max_messages,
+            max_tokens: @max_tokens,
+            created_at: @created_at,
+            updated_at: Time.now.iso8601
+          }
+        })
+      end
+
+      # Importa histórico de JSON
+      #
+      # @param json [String] JSON do histórico
+      # @return [void]
+      def from_json(json)
+        data = JSON.parse(json, symbolize_names: true)
+        @messages = data[:messages] || []
+        @summaries = data[:summaries] || []
+        @created_at = data.dig(:metadata, :created_at)
+        save_to_disk if @persist_dir
+      end
+
+      # Retorna estatísticas do histórico
+      #
+      # @return [Hash] Estatísticas
+      def stats
+        {
+          total_messages: @messages.count,
+          user_messages: @messages.count { |m| m[:role] == 'user' },
+          assistant_messages: @messages.count { |m| m[:role] == 'assistant' },
+          tool_messages: @messages.count { |m| m[:role] == 'tool' },
+          estimated_tokens: estimate_tokens,
+          summaries_count: @summaries.count,
+          oldest_message: @messages.first&.dig(:timestamp),
+          newest_message: @messages.last&.dig(:timestamp)
+        }
+      end
+
+      # Persiste histórico em disco
+      #
+      # @return [void]
+      def save_to_disk
+        return unless @persist_dir
+
+        FileUtils.mkdir_p(@persist_dir)
+        file = File.join(@persist_dir, 'history.json')
+
+        # Salva versão comprimida se for grande
+        json = to_json
+        if json.bytesize > 100_000 # 100KB
+          compressed = compress(json)
+          File.write(file + '.gz', compressed)
+          File.delete(file) if File.exist?(file)
+        else
+          File.write(file, json)
+          File.delete(file + '.gz') if File.exist?(file + '.gz')
+        end
+      end
+
+      # Carrega histórico do disco
+      #
+      # @return [void]
+      def load_from_disk
+        return unless @persist_dir
+
+        file = File.join(@persist_dir, 'history.json')
+        compressed_file = file + '.gz'
+
+        json = nil
+        if File.exist?(compressed_file)
+          json = decompress(File.read(compressed_file))
+        elsif File.exist?(file)
+          json = File.read(file)
+        end
+
+        from_json(json) if json
+      rescue => e
+        warn "[History] Erro ao carregar histórico: #{e.message}"
+      end
+
+      private
+
+      # Adiciona mensagem ao histórico
+      #
+      # @param role [String] Role da mensagem (user, assistant, tool)
+      # @param content [String] Conteúdo da mensagem
+      # @return [void]
+      def add_message(role:, content:)
+        @messages << {
+          role: role,
+          content: content,
+          timestamp: Time.now.iso8601
+        }
+
+        truncate_if_needed
+        save_to_disk if @persist_dir
+      end
+
+      # Constrói conteúdo para resultados de tools
+      #
+      # @param results [Array] Resultados das tools
+      # @return [String] Conteúdo formatado
+      def build_tool_results_content(results)
+        lines = ["## Tool Results\n"]
+
+        results.each do |result|
+          status = result[:success] ? '✅' : '❌'
+          lines << "### #{result[:tool_call_id]} #{status}"
+
+          if result[:success]
+            lines << "```json"
+            lines << JSON.pretty_generate(result[:result])
+            lines << "```"
+          else
+            lines << "Erro: #{result[:error]}"
+          end
+
+          lines << ""
+        end
+
+        lines.join("\n")
+      end
+
+      # Formata mensagem para API do LLM
+      #
+      # @param msg [Hash] Mensagem
+      # @return [Hash] Mensagem formatada
+      def format_message_for_api(msg)
+        {
+          role: msg[:role],
+          content: msg[:content]
+        }
+      end
+
+      # Estima número de tokens (4 chars ≈ 1 token)
+      #
+      # @return [Integer] Tokens estimados
+      def estimate_tokens
+        total_chars = @messages.sum { |m| m[:content].to_s.length }
+        total_chars / 4
+      end
+
+      # Sumariza mensagens antigas
+      #
+      # @param count [Integer] Número de mensagens para sumarizar
+      # @return [void]
+      def summarize_old_messages(count)
+        return if count <= 0 || @messages.empty?
+
+        messages_to_summarize = @messages.first([count, @messages.count].min)
+
+        summary = {
+          id: SecureRandom.uuid,
+          created_at: Time.now.iso8601,
+          message_count: messages_to_summarize.count,
+          content: build_summary_content(messages_to_summarize)
+        }
+
+        @summaries << summary
+      end
+
+      # Constrói conteúdo de sumarização
+      #
+      # @param messages [Array] Mensagens para sumarizar
+      # @return [String] Conteúdo sumarizado
+      def build_summary_content(messages)
+        user_count = messages.count { |m| m[:role] == 'user' }
+        assistant_count = messages.count { |m| m[:role] == 'assistant' }
+        tool_count = messages.count { |m| m[:role] == 'tool' }
+
+        <<~SUMMARY
+          ## Resumo de Conversa Antiga
+
+          Esta é uma sumarização de #{messages.count} mensagens antigas para economizar tokens.
+
+          ### Estatísticas
+          - Mensagens do usuário: #{user_count}
+          - Mensagens do assistente: #{assistant_count}
+          - Tool calls: #{tool_count}
+
+          ### Tópicos Discutidos
+          #{extract_topics(messages)}
+
+          ### Ações Realizadas
+          #{extract_actions(messages)}
+
+          ---
+          *Sumarizado em #{Time.now.strftime('%Y-%m-%d %H:%M')}*
+        SUMMARY
+      end
+
+      # Extrai tópicos das mensagens
+      #
+      # @param messages [Array] Mensagens
+      # @return [String] Tópicos extraídos
+      def extract_topics(messages)
+        # Implementação simples - em produção usaria NLP/LLM
+        "- Histórico de conversa (#{messages.count} mensagens)"
+      end
+
+      # Extrai ações das mensagens
+      #
+      # @param messages [Array] Mensagens
+      # @return [String] Ações extraídas
+      def extract_actions(messages)
+        tool_messages = messages.select { |m| m[:role] == 'tool' }
+        if tool_messages.any?
+          "- #{tool_messages.count} tool calls executados"
+        else
+          "- Nenhuma ação específica registrada"
+        end
+      end
+
+      # Constrói conteúdo de sumarizações
+      #
+      # @return [String] Conteúdo das sumarizações
+      def build_summaries_content
+        return "" if @summaries.empty?
+
+        lines = ["# Histórico Sumarizado\n"]
+
+        @summaries.each_with_index do |summary, i|
+          lines << "## Sumário #{i + 1}"
+          lines << summary[:content]
+          lines << ""
+        end
+
+        lines.join("\n")
+      end
+
+      # Comprime string com Gzip
+      #
+      # @param data [String] Dados para comprimir
+      # @return [String] Dados comprimidos
+      def compress(data)
+        Zlib::Deflate.deflate(data)
+      end
+
+      # Descomprime string com Gzip
+      #
+      # @param data [String] Dados comprimidos
+      # @return [String] Dados descomprimidos
+      def decompress(data)
+        Zlib::Inflate.inflate(data)
+      end
+    end
+  end
+end