fantasy-cli 1.2.6

data/lib/gsd/ai/streaming.rb

@@ -0,0 +1,438 @@
+# frozen_string_literal: true
+
+require 'io/console'
+
+module Gsd
+  module AI
+    # Streaming Output - Gerencia streaming de respostas da IA
+    #
+    # Responsável por:
+    # - Processar chunks de streaming
+    # - Exibir output em tempo real
+    # - Bufferizar conteúdo completo
+    # - Suportar diferentes formatos de chunk
+    # - Streaming real para Anthropic e OpenAI
+    class Streaming
+      attr_reader :content, :done, :output_io
+
+      # Inicializa o streaming
+      #
+      # @param output_io [IO] IO para output (default: STDOUT)
+      # @param color [Boolean] Habilitar cores
+      def initialize(output_io: $stdout, color: true)
+        @output_io = output_io
+        @content = +''
+        @done = false
+        @buffer = +''
+        @color = color
+        @chunk_count = 0
+        @start_time = nil
+      end
+
+      # Processa um chunk de streaming
+      #
+      # @param chunk [Hash,String] Chunk do streaming
+      # @return [void]
+      def process(chunk)
+        @start_time ||= Time.now
+
+        case chunk
+        when Hash
+          process_hash_chunk(chunk)
+        when String
+          process_string_chunk(chunk)
+        else
+          # Chunk desconhecido, ignora
+        end
+
+        @chunk_count += 1
+      end
+
+      # Finaliza o streaming
+      #
+      # @return [String] Conteúdo completo
+      def finish
+        @done = true
+        flush_buffer
+        @output_io.puts if @color # Nova linha após o conteúdo
+        @content
+      end
+
+      # Reseta o streaming
+      #
+      # @return [void]
+      def reset
+        @content = +''
+        @done = false
+        @buffer = +''
+        @chunk_count = 0
+        @start_time = nil
+      end
+
+      # Retorna o conteúdo acumulado até agora
+      #
+      # @return [String] Conteúdo acumulado
+      def content_so_far
+        @content + @buffer
+      end
+
+      # Retorna estatísticas do streaming
+      #
+      # @return [Hash] Estatísticas
+      def stats
+        {
+          chunk_count: @chunk_count,
+          duration: @start_time ? (Time.now - @start_time) : 0,
+          content_length: @content.length,
+          avg_chunk_size: @chunk_count > 0 ? @content.length / @chunk_count : 0
+        }
+      end
+
+      private
+
+      # Processa chunk no formato Hash
+      #
+      # @param chunk [Hash] Chunk do streaming
+      # @return [void]
+      def process_hash_chunk(chunk)
+        # Formato Anthropic: { type: 'content_block_delta', delta: { text: '...' } }
+        # Formato OpenAI: { choices: [{ delta: { content: '...' } }] }
+
+        text = nil
+
+        if chunk[:type] == 'content_block_delta'
+          # Anthropic
+          text = chunk.dig(:delta, :text)
+        elsif chunk.key?(:choices)
+          # OpenAI
+          text = chunk.dig(:choices, 0, :delta, :content)
+        elsif chunk.key?(:delta)
+          # Formato genérico
+          text = chunk[:delta].to_s
+        elsif chunk.key?(:content)
+          # Formato alternativo
+          text = chunk[:content]
+        end
+
+        add_text(text) if text
+      end
+
+      # Processa chunk no formato String
+      #
+      # @param chunk [String] Chunk do streaming
+      # @return [void]
+      def process_string_chunk(chunk)
+        add_text(chunk)
+      end
+
+      # Adiciona texto ao buffer e faz flush se necessário
+      #
+      # @param text [String] Texto para adicionar
+      # @return [void]
+      def add_text(text)
+        @buffer << text
+
+        # Flush imediato para terminal
+        flush_buffer
+      end
+
+      # Flush do buffer para output
+      #
+      # @return [void]
+      def flush_buffer
+        return if @buffer.empty?
+
+        if @color
+          @output_io.print(@buffer)
+        else
+          @output_io.print(@buffer)
+        end
+
+        @output_io.flush
+        @content << @buffer
+        @buffer = +''
+      end
+    end
+
+    # Streaming com animação de typing
+    #
+    # Subclasse que adiciona efeito de digitação
+    class TypingStreaming < Streaming
+      attr_accessor :delay, :enabled
+
+      # Inicializa o streaming com typing
+      #
+      # @param delay [Float] Delay entre caracteres (segundos)
+      # @param output_io [IO] IO para output
+      # @param enabled [Boolean] Habilitar animação
+      def initialize(delay: 0.01, output_io: $stdout, enabled: true)
+        super(output_io: output_io)
+        @delay = delay
+        @enabled = enabled
+      end
+
+      # Processa chunk com efeito de typing
+      #
+      # @param chunk [Hash,String] Chunk do streaming
+      # @return [void]
+      def process(chunk)
+        text = extract_text_from_chunk(chunk)
+        return unless text
+
+        if @enabled
+          # Efeito de digitação caractere por caractere
+          text.each_char do |char|
+            @output_io.print(char)
+            @output_io.flush
+            sleep(@delay)
+          end
+        else
+          # Sem animação, output direto
+          @output_io.print(text)
+          @output_io.flush
+        end
+
+        @content << text
+      end
+
+      private
+
+      # Extrai texto do chunk
+      #
+      # @param chunk [Hash,String] Chunk do streaming
+      # @return [String] Texto extraído
+      def extract_text_from_chunk(chunk)
+        case chunk
+        when Hash
+          if chunk[:type] == 'content_block_delta'
+            chunk.dig(:delta, :text)
+          elsif chunk.key?(:choices)
+            chunk.dig(:choices, 0, :delta, :content)
+          else
+            chunk[:delta].to_s
+          end
+        when String
+          chunk
+        else
+          ''
+        end
+      end
+    end
+
+    # Streaming com barra de progresso
+    #
+    # Mostra barra de progresso enquanto carrega
+    class ProgressStreaming < Streaming
+      attr_reader :total_expected, :received
+
+      # Inicializa o streaming com progresso
+      #
+      # @param total_expected [Integer] Total esperado de tokens/chunks
+      # @param output_io [IO] IO para output
+      def initialize(total_expected: nil, output_io: $stdout)
+        super(output_io: output_io)
+        @total_expected = total_expected
+        @received = 0
+        @show_progress = true
+      end
+
+      # Processa chunk com barra de progresso
+      #
+      # @param chunk [Hash,String] Chunk do streaming
+      # @return [void]
+      def process(chunk)
+        @received += 1
+
+        # Extrai e adiciona texto
+        text = extract_text_from_chunk(chunk)
+        @content << text if text
+
+        # Atualiza barra de progresso
+        update_progress_bar if @show_progress
+      end
+
+      # Finaliza o streaming
+      #
+      # @return [String] Conteúdo completo
+      def finish
+        @done = true
+        clear_progress_bar
+        @output_io.puts
+        @content
+      end
+
+      private
+
+      # Atualiza barra de progresso
+      #
+      # @return [void]
+      def update_progress_bar
+        return unless @total_expected
+
+        progress = @received.to_f / @total_expected
+        width = 40
+        filled = (progress * width).to_i
+        empty = width - filled
+
+        bar = '█' * filled + '░' * empty
+        percent = (progress * 100).to_i
+
+        @output_io.print("\r[#{bar}] #{percent}% (#{@received}/#{@total_expected})")
+        @output_io.flush
+      end
+
+      # Limpa barra de progresso
+      #
+      # @return [void]
+      def clear_progress_bar
+        @output_io.print("\r" + ' ' * 50 + "\r")
+        @output_io.flush
+      end
+
+      # Extrai texto do chunk
+      #
+      # @param chunk [Hash,String] Chunk do streaming
+      # @return [String] Texto extraído
+      def extract_text_from_chunk(chunk)
+        case chunk
+        when Hash
+          if chunk[:type] == 'content_block_delta'
+            chunk.dig(:delta, :text)
+          elsif chunk.key?(:choices)
+            chunk.dig(:choices, 0, :delta, :content)
+          else
+            chunk[:delta].to_s
+          end
+        when String
+          chunk
+        else
+          ''
+        end
+      end
+    end
+
+    # Streaming com output colorido
+    #
+    # Adiciona cores para diferentes tipos de conteúdo
+    class ColorStreaming < Streaming
+      # Cores ANSI
+      COLORS = {
+        reset: "\e[0m",
+        bold: "\e[1m",
+        italic: "\e[3m",
+        underline: "\e[4m",
+        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"
+      }.freeze
+
+      attr_accessor :color_scheme
+
+      # Inicializa o streaming colorido
+      #
+      # @param color_scheme [Hash] Esquema de cores
+      # @param output_io [IO] IO para output
+      def initialize(color_scheme: :default, output_io: $stdout)
+        super(output_io: output_io)
+        @color_scheme = color_scheme
+        @current_color = nil
+        @supports_color = supports_color?
+      end
+
+      # Processa chunk com cores
+      #
+      # @param chunk [Hash,String] Chunk do streaming
+      # @return [void]
+      def process(chunk)
+        text = extract_text_from_chunk(chunk)
+        return unless text
+
+        # Detecta tipo de conteúdo e aplica cor
+        color = detect_content_type(text)
+        add_text_with_color(text, color)
+      end
+
+      private
+
+      # Adiciona texto com cor
+      #
+      # @param text [String] Texto
+      # @param color [Symbol] Cor
+      # @return [void]
+      def add_text_with_color(text, color)
+        if @supports_color && color
+          colored_text = colorize(text, color)
+          @output_io.print(colored_text)
+        else
+          @output_io.print(text)
+        end
+
+        @output_io.flush
+        @content << text
+      end
+
+      # Detecta tipo de conteúdo
+      #
+      # @param text [String] Texto
+      # @return [Symbol] Tipo de conteúdo
+      def detect_content_type(text)
+        return :code if text.start_with?('```')
+        return :heading if text.start_with?('#')
+        return :emphasis if text.include?('**') || text.include?('*')
+        return :link if text.include?('[') && text.include?('](')
+        :normal
+      end
+
+      # Aplica cor ao texto
+      #
+      # @param text [String] Texto
+      # @param color [Symbol] Cor
+      # @return [String] Texto colorido
+      def colorize(text, color)
+        return text unless @supports_color
+
+        color_code = COLORS[color] || COLORS[:normal]
+        "#{color_code}#{text}#{COLORS[:reset]}"
+      end
+
+      # Verifica se terminal suporta cores
+      #
+      # @return [Boolean] true se suporta cores
+      def supports_color?
+        # Verifica variável de ambiente
+        return false if ENV['NO_COLOR']
+        return true if ENV['FORCE_COLOR']
+
+        # Verifica se é um TTY
+        @output_io.is_a?(IO) && @output_io.tty?
+      end
+
+      # Extrai texto do chunk
+      #
+      # @param chunk [Hash,String] Chunk do streaming
+      # @return [String] Texto extraído
+      def extract_text_from_chunk(chunk)
+        case chunk
+        when Hash
+          if chunk[:type] == 'content_block_delta'
+            chunk.dig(:delta, :text)
+          elsif chunk.key?(:choices)
+            chunk.dig(:choices, 0, :delta, :content)
+          else
+            chunk[:delta].to_s
+          end
+        when String
+          chunk
+        else
+          ''
+        end
+      end
+    end
+  end
+end