fantasy-cli 1.2.6

data/lib/gsd/ai/chat.rb

@@ -0,0 +1,486 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'gsd/ai/context'
+require 'gsd/ai/history'
+require 'gsd/ai/streaming'
+require 'gsd/ai/cost_tracker'
+require 'gsd/ai/command_parser'
+require 'gsd/ai/reference_resolver'
+require 'gsd/ai/commands/help'
+require 'gsd/ai/commands/clear'
+require 'gsd/ai/commands/reset'
+require 'gsd/ai/commands/model'
+require 'gsd/ai/commands/cost'
+require 'gsd/ai/commands/context'
+require 'gsd/ai/commands/export'
+require 'gsd/tools/registry'
+require 'gsd/skills/loader'
+require 'gsd/ai/providers/base'
+require 'gsd/ai/providers/base'
+require 'gsd/ai/providers/anthropic'
+require 'gsd/ai/providers/openai'
+require 'gsd/ai/providers/ollama'
+require 'gsd/ai/providers/lmstudio'
+require 'gsd/ai/providers/openrouter'
+
+module Gsd
+  module AI
+    # Chat REPL Interface - Interface principal de conversa com IA
+    #
+    # Responsável por:
+    # - Gerenciar conversas com LLMs
+    # - Executar tool calls
+    # - Manter histórico de mensagens
+    # - Streaming de respostas
+    class Chat
+      attr_reader :context, :history, :tools, :skills, :provider
+
+      # Inicializa uma nova sessão de chat
+      #
+      # @param provider [Symbol] Provider de LLM (:anthropic, :openai, :ollama)
+      # @param model [String] Modelo do LLM
+      # @param cwd [String] Diretório de trabalho
+      # @param debug [Boolean] Habilitar modo debug
+      # @param cache_ttl [Integer] TTL do cache de contexto (segundos)
+      # @param persist_history [Boolean] Persistir histórico em disco
+      # @param budget [Float] Orçamento mensal em USD
+      def initialize(provider: :anthropic, model: nil, cwd: Dir.pwd, debug: false,
+                     cache_ttl: 300, persist_history: true, budget: 100.0)
+        @cwd = cwd
+        @debug = debug
+        @provider = ProviderFactory.create(provider, model: model, debug: debug)
+        @context = Context.new(cwd: cwd, cache_ttl: cache_ttl)
+        persist_dir = persist_history ? File.join(cwd, '.gsd', 'ai') : nil
+        @history = History.new(persist_dir: persist_dir)
+        @tools = Tools::Registry.all
+        @skills = Skills::Loader.new(cwd: cwd).bundled_skills
+        @streaming = Streaming.new
+        @cost_tracker = CostTracker.new(budget: budget, persist_dir: persist_dir)
+
+        # Registra pricing do provider
+        register_provider_pricing
+      end
+
+      # Registra pricing do provider no cost tracker
+      #
+      # @return [void]
+      def register_provider_pricing
+        pricing = begin
+          @provider.class::MODELS
+        rescue
+          {}
+        end
+        provider_name = begin
+          @provider.class::PROVIDER_NAME
+        rescue
+          'unknown'
+        end
+        @cost_tracker.register_provider(provider_name, pricing) if pricing.any?
+      end
+
+      # Envia uma mensagem para a IA e retorna a resposta
+      #
+      # @param message [String] Mensagem do usuário
+      # @param options [Hash] Opções adicionais
+      # @return [String] Resposta da IA
+      def send(message, **options)
+        log_debug("User: #{message}")
+
+        # Preprocessar input (comandos e referências)
+        preprocessed = preprocess_input(message)
+
+        # Se for comando, executa e retorna
+        return preprocessed[:response] if preprocessed[:type] == :command
+
+        # Usa mensagem processada (expandida com referências)
+        final_message = preprocessed[:message]
+
+        # 1. Adicionar mensagem do usuário ao histórico
+        @history.add_user_message(final_message)
+
+        # 2. Carregar contexto do projeto
+        context_data = @context.load
+
+        # 3. Selecionar tools relevantes
+        available_tools = select_tools_for_message(message)
+
+        # 4. Construir system prompt
+        system_prompt = build_system_prompt(context_data)
+
+        # 5. Chamar LLM
+        response = call_llm(
+          system_prompt: system_prompt,
+          messages: @history.messages,
+          tools: available_tools,
+          stream: options.fetch(:stream, true)
+        )
+
+        # 6. Processar tool calls se existirem
+        if response.tool_calls
+          results = execute_tool_calls(response.tool_calls)
+          @history.add_tool_results(results)
+
+          # 7. Chamar LLM novamente com resultados das tools
+          response = call_llm(
+            system_prompt: system_prompt,
+            messages: @history.messages,
+            tools: available_tools,
+            stream: options.fetch(:stream, true)
+          )
+        end
+
+        # 8. Adicionar resposta ao histórico
+        @history.add_assistant_message(response.content)
+
+        # 9. Track custo
+        provider_name = begin
+          @provider.class::PROVIDER_NAME
+        rescue
+          'unknown'
+        end
+        @cost_tracker.track(
+          response.usage,
+          provider: provider_name,
+          model: @provider.model
+        )
+
+        log_debug("Assistant: #{response.content}")
+        log_debug("Cost: #{@cost_tracker.total_cost}")
+        log_debug("Tokens: #{@cost_tracker.total_tokens}")
+        log_debug("Budget used: #{@cost_tracker.stats[:budget_used_percent]}%")
+
+        response.content
+      end
+
+      # Inicia o REPL interativo
+      #
+      # @return [void]
+      def repl
+        puts "🤖 GSD AI Chat - #{provider.class} (#{@provider.model})"
+        puts "Digite 'quit' ou 'exit' para sair, 'clear' para limpar histórico"
+        puts "-" * 60
+
+        loop do
+          print "\n👤 "
+          input = $stdin.gets&.chomp
+
+          break if input.nil? || %w[quit exit].include?(input.downcase)
+
+          if input.downcase == 'clear'
+            @history.clear
+            puts "🧹 Histórico limpo!"
+            next
+          end
+
+          next if input.strip.empty?
+
+          begin
+            response = send(input, stream: true)
+            puts "\n🤖 #{response}"
+          rescue => e
+            puts "\n❌ Erro: #{e.message}"
+            log_debug(e.backtrace.join("\n")) if @debug
+          end
+        end
+
+        puts "\n👋 Até logo!"
+      end
+
+      # Limpa o histórico de conversas
+      #
+      # @return [void]
+      def clear_history
+        @history.clear
+      end
+
+      # Retorna estatísticas de uso
+      #
+      # @return [Hash] Estatísticas de tokens e custo
+      def stats
+        {
+          messages_count: @history.messages.count,
+          total_tokens: @cost_tracker.total_tokens,
+          total_cost: @cost_tracker.total_cost,
+          context_size: @context.size,
+          cache_info: @context.cache_info,
+          history_stats: @history.stats,
+          cost_stats: @cost_tracker.stats,
+          budget_remaining: @cost_tracker.stats[:budget_remaining],
+          budget_used_percent: @cost_tracker.stats[:budget_used_percent]
+        }
+      end
+
+      # Retorna informações detalhadas de custo
+      #
+      # @return [Hash] Informações de custo
+      def cost_info
+        @cost_tracker.stats
+      end
+
+      # Retorna histórico de custos
+      #
+      # @param limit [Integer] Limite de registros
+      # @return [Array] Histórico
+      def cost_history(limit: 50)
+        @cost_tracker.history(limit: limit)
+      end
+
+      # Define orçamento
+      #
+      # @param budget [Float] Orçamento em USD
+      # @return [void]
+      def budget=(budget)
+        @cost_tracker.budget = budget
+      end
+
+      # Retorna orçamento restante
+      #
+      # @return [Float] Orçamento restante
+      def budget_remaining
+        @cost_tracker.stats[:budget_remaining]
+      end
+
+      # Reseta estatísticas de custo
+      #
+      # @return [void]
+      def reset_cost_stats
+        @cost_tracker.reset
+      end
+
+      # Retorna informações do cache de contexto
+      #
+      # @return [Hash] Informações do cache
+      def cache_info
+        @context.cache_info
+      end
+
+      # Retorna informações do histórico
+      #
+      # @return [Hash] Estatísticas do histórico
+      def history_info
+        @history.stats
+      end
+
+      # Recarrega o contexto
+      #
+      # @return [Hash] Novo contexto
+      def reload_context
+        @context.reload
+      end
+
+      # Limpa o cache de contexto
+      #
+      # @return [void]
+      def clear_cache
+        @context.clear_cache
+      end
+
+      private
+
+      # Preprocessa input do usuário (comandos e referências)
+      #
+      # @param message [String] Input original
+      # @return [Hash] { type: :message|:command, message: String, response: String }
+      def preprocess_input(message)
+        parsed = CommandParser.parse(message)
+
+        case parsed.type
+        when :command
+          { type: :command, response: execute_command(parsed.command, parsed.args) }
+        when :reference
+          resolved = resolve_references(parsed.references)
+          expanded = expand_message_with_references(message, resolved)
+          { type: :message, message: expanded }
+        else
+          { type: :message, message: message }
+        end
+      end
+
+      # Executa um comando /
+      #
+      # @param command [String] Nome do comando
+      # @param args [Array<String>] Argumentos
+      # @return [String] Resposta do comando
+      def execute_command(command, args)
+        cmd_class = case command
+                      when 'help' then Commands::Help
+                      when 'clear' then Commands::Clear
+                      when 'reset' then Commands::Reset
+                      when 'model' then Commands::Model
+                      when 'cost' then Commands::Cost
+                      when 'context' then Commands::Context
+                      when 'export' then Commands::Export
+                      else nil
+                      end
+
+        return "Comando desconhecido: /#{command}\nUse /help para listar comandos." if cmd_class.nil?
+
+        cmd = cmd_class.new(self, args)
+        cmd.execute
+      rescue => e
+        "❌ Erro ao executar /#{command}: #{e.message}"
+      end
+
+      # Resolve referências @ para conteúdo
+      #
+      # @param references [Array<String>] Lista de referências
+      # @return [Hash] Resultado do resolver
+      def resolve_references(references)
+        resolver = ReferenceResolver.new(cwd: @cwd, provider: @provider)
+        resolver.resolve(references)
+      end
+
+      # Expande mensagem com conteúdo das referências
+      #
+      # @param original [String] Mensagem original
+      # @param resolved [Hash] Resultado do resolver
+      # @return [String] Mensagem expandida
+      def expand_message_with_references(original, resolved)
+        return original if resolved[:text].nil? || resolved[:text].empty?
+
+        <<~MESSAGE
+          #{original}
+
+          [Referências carregadas:]
+          #{resolved[:text]}
+        MESSAGE
+      end
+
+      # Seleciona tools relevantes para a mensagem
+      #
+      # @param message [String] Mensagem do usuário
+      # @return [Array<Tool>] Tools relevantes
+      def select_tools_for_message(message)
+        # Por enquanto, retorna todas as tools
+        # No futuro, pode usar embedding ou heurísticas para filtrar
+        @tools
+      end
+
+      # Constrói o system prompt com contexto do projeto
+      #
+      # @param context_data [Hash] Dados de contexto
+      # @return [String] System prompt
+      def build_system_prompt(context_data)
+        <<~PROMPT
+          Você é o GSD AI, um assistente especializado em gerenciamento de projetos GSD (Get Shit Done).
+
+          ## Contexto do Projeto
+
+          ### Estado Atual
+          #{JSON.pretty_generate(context_data[:state])}
+
+          ### Phase Atual
+          #{context_data[:current_phase]&.dig('name') || 'N/A'}
+
+          ### Roadmap
+          #{context_data[:roadmap]&.dig('summary') || 'N/A'}
+
+          ## Suas Capacidades
+
+          Você tem acesso às seguintes ferramentas:
+          - Bash: Executar comandos shell
+          - File operations: Ler, escrever e editar arquivos
+          - Grep/Glob: Buscar no código
+          - GSD commands: Operações de state, phase, roadmap
+          - Tasks: Gerenciar tarefas
+          - Web: Pesquisar e fetch de URLs
+
+          ## Instruções
+
+          1. Seja direto e prático
+          2. Use ferramentas quando necessário
+          3. Mantenha o foco nas tarefas do usuário
+          4. Reporte erros claramente
+          5. Sugira próximos passos quando relevante
+
+          ## Formato de Resposta
+
+          - Use Markdown para formatação
+          - Inclua código em blocks quando relevante
+          - Seja conciso mas completo
+        PROMPT
+      end
+
+      # Chama o provedor de LLM
+      #
+      # @param system_prompt [String] System prompt
+      # @param messages [Array] Histórico de mensagens
+      # @param tools [Array] Tools disponíveis
+      # @param stream [Boolean] Habilitar streaming
+      # @return [OpenStruct] Resposta com content, tool_calls, usage
+      def call_llm(system_prompt:, messages:, tools:, stream:)
+        @provider.call(
+          system_prompt: system_prompt,
+          messages: messages,
+          tools: tools,
+          stream: stream
+        ) do |chunk|
+          @streaming.process(chunk) if stream
+        end
+      end
+
+      # Executa tool calls retornados pelo LLM
+      #
+      # @param tool_calls [Array] Lista de tool calls
+      # @return [Array] Resultados das execuções
+      def execute_tool_calls(tool_calls)
+        tool_calls.map do |call|
+          tool = @tools.find { |t| t.name == call.name }
+
+          if tool
+            begin
+              result = tool.execute(call.arguments, cwd: @cwd)
+              {
+                tool_call_id: call.id,
+                success: true,
+                result: result
+              }
+            rescue => e
+              {
+                tool_call_id: call.id,
+                success: false,
+                error: e.message
+              }
+            end
+          else
+            {
+              tool_call_id: call.id,
+              success: false,
+              error: "Tool not found: #{call.name}"
+            }
+          end
+        end
+      end
+
+      # Log de debug
+      #
+      # @param message [String] Mensagem de log
+      def log_debug(message)
+        return unless @debug
+
+        puts "[DEBUG] #{message}"
+      end
+    end
+
+    # Factory para criar provedores de LLM
+    module ProviderFactory
+      def self.create(provider, model: nil, debug: false, **options)
+        case provider
+        when :anthropic
+          Providers::Anthropic.new(model: model, debug: debug)
+        when :openai
+          Providers::OpenAI.new(model: model, debug: debug)
+        when :ollama
+          Providers::Ollama.new(model: model, debug: debug)
+        when :lmstudio
+          Providers::LMStudio.new(model: model, debug: debug, **options)
+        when :openrouter
+          Providers::OpenRouter.new(model: model, debug: debug, **options)
+        else
+          raise ArgumentError, "Unknown provider: #{provider}. Available: :anthropic, :openai, :ollama, :lmstudio, :openrouter"
+        end
+      end
+    end
+  end
+end