fantasy-cli 1.2.6

data/lib/gsd/ai/providers/openrouter.rb

@@ -0,0 +1,429 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'json'
+
+module Gsd
+  module AI
+    module Providers
+      # OpenRouter Provider - Integração com OpenRouter (múltiplos modelos)
+      #
+      # Suporta:
+      # - Qwen (gratuito)
+      # - Llama (gratuito)
+      # - Mistral (gratuito)
+      # - GPT-4, Claude, etc. (pagos)
+      # - 100+ modelos disponíveis
+      # - Streaming de respostas
+      # - Token counting preciso
+      class OpenRouter < Base
+        PROVIDER_NAME = 'OpenRouter'
+        DEFAULT_MODEL = 'qwen/qwen-2.5-72b-instruct'
+        API_URL = 'https://openrouter.ai/api/v1/chat/completions'
+        BASE_URL = 'https://openrouter.ai'
+
+        # Modelos gratuitos disponíveis
+        FREE_MODELS = [
+          'qwen/qwen-3.6-plus-preview:free',
+          'qwen/qwen-2.5-72b-instruct',
+          'qwen/qwen-2-7b-instruct',
+          'meta-llama/llama-3-8b-instruct',
+          'meta-llama/llama-3-70b-instruct',
+          'mistralai/mistral-7b-instruct',
+          'google/gemma-7b-it'
+        ].freeze
+
+        # Modelos com preços
+        MODELS = {
+          'qwen/qwen-3.6-plus-preview:free' => { 
+            input_price: 0.0, 
+            output_price: 0.0,
+            context_window: 1_000_000,
+            max_output: 8192,
+            vision: false,
+            caching: false,
+            latency: 0.92,
+            throughput: 33
+          },
+          'qwen/qwen-2.5-72b-instruct' => { 
+            input_price: 0.0, 
+            output_price: 0.0,
+            context_window: 32_768,
+            max_output: 8192,
+            vision: false,
+            caching: false
+          },
+          'qwen/qwen-2-7b-instruct' => { 
+            input_price: 0.0, 
+            output_price: 0.0,
+            context_window: 32_768,
+            max_output: 4096,
+            vision: false,
+            caching: false
+          },
+          'meta-llama/llama-3-8b-instruct' => { 
+            input_price: 0.0, 
+            output_price: 0.0,
+            context_window: 8192,
+            max_output: 4096,
+            vision: false,
+            caching: false
+          },
+          'meta-llama/llama-3-70b-instruct' => { 
+            input_price: 0.0, 
+            output_price: 0.0,
+            context_window: 8192,
+            max_output: 4096,
+            vision: false,
+            caching: false
+          },
+          'mistralai/mistral-7b-instruct' => { 
+            input_price: 0.0, 
+            output_price: 0.0,
+            context_window: 32768,
+            max_output: 4096,
+            vision: false,
+            caching: false
+          },
+          'google/gemma-7b-it' => { 
+            input_price: 0.0, 
+            output_price: 0.0,
+            context_window: 8192,
+            max_output: 4096,
+            vision: false,
+            caching: false
+          }
+        }.freeze
+
+        # Inicializa o provider OpenRouter
+        #
+        # @param model [String] Modelo do OpenRouter
+        # @param api_key [String] API key (ou use env OPENROUTER_API_KEY)
+        # @param debug [Boolean] Habilitar debug
+        def initialize(model: nil, api_key: nil, debug: false)
+          super(model: model, debug: debug)
+          @api_key = api_key || ENV['OPENROUTER_API_KEY']
+          @max_tokens = 4096
+          @token_cache = {}
+          @site_url = nil
+          @site_name = nil
+        end
+
+        # Configura informações do site (opcional, para ranking no OpenRouter)
+        #
+        # @param site_url [String] URL do site
+        # @param site_name [String] Nome do site
+        # @return [void]
+        def configure_site(site_url:, site_name:)
+          @site_url = site_url
+          @site_name = site_name
+        end
+
+        # Chama a API do OpenRouter
+        #
+        # @param system_prompt [String] System prompt
+        # @param messages [Array] Histórico de mensagens
+        # @param tools [Array] Tools disponíveis
+        # @param stream [Boolean] Habilitar streaming
+        # @yield [Hash] Chunk de streaming
+        # @return [OpenStruct] Resposta
+        def call(system_prompt:, messages:, tools:, stream: false, &block)
+          validate_api_key!
+
+          payload = build_payload(system_prompt, messages, tools, stream)
+
+          log_debug("Calling OpenRouter API with model: #{@model}")
+          log_debug("Messages count: #{messages.count}")
+
+          if stream
+            stream_request(payload, &block)
+          else
+            sync_request(payload)
+          end
+        rescue => e
+          log_debug("Error: #{e.message}")
+          raise OpenRouterError, "OpenRouter API error: #{e.message}"
+        end
+
+        # Verifica se está configurado
+        #
+        # @return [Boolean] true se configurado
+        def configured?
+          !@api_key.nil? && !@api_key.empty?
+        end
+
+        # Lista modelos disponíveis
+        #
+        # @return [Array<String>] Lista de modelos
+        def list_models
+          uri = URI("#{BASE_URL}/api/v1/models")
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = true
+
+          request = Net::HTTP::Get.new(uri.path)
+          response = http.request(request)
+
+          if response.code == '200'
+            data = JSON.parse(response.body)
+            data['data']&.map { |m| m['id'] } || []
+          else
+            []
+          end
+        rescue => e
+          log_debug("Error listing models: #{e.message}")
+          []
+        end
+
+        # Verifica se modelo é gratuito
+        #
+        # @param model [String] Nome do modelo
+        # @return [Boolean] true se gratuito
+        def free_model?(model)
+          FREE_MODELS.include?(model)
+        end
+
+        # Retorna o preço do modelo
+        #
+        # @return [Hash] Preço de input e output
+        def pricing
+          MODELS[@model] || { input_price: 0, output_price: 0 }
+        end
+
+        private
+
+        # Valida API key
+        #
+        # @raise [ArgumentError] Se API key não estiver configurada
+        def validate_api_key!
+          raise ArgumentError, 'OPENROUTER_API_KEY not set' unless configured?
+        end
+
+        # Constrói o payload da requisição
+        #
+        # @param system_prompt [String] System prompt
+        # @param messages [Array] Mensagens
+        # @param tools [Array] Tools
+        # @param stream [Boolean] Streaming
+        # @return [Hash] Payload
+        def build_payload(system_prompt, messages, tools, stream)
+          formatted_messages = [{ role: 'system', content: system_prompt }] +
+                               messages.map { |m| { role: m[:role], content: m[:content] } }
+
+          payload = {
+            model: @model,
+            max_tokens: @max_tokens,
+            messages: formatted_messages,
+            stream: stream
+          }
+
+          # Informações do site (opcional)
+          if @site_url && @site_name
+            payload[:site_url] = @site_url
+            payload[:site_name] = @site_name
+          end
+
+          # Tools (se suportado pelo modelo)
+          if tools.any?
+            payload[:tools] = format_tools(tools)
+          end
+
+          payload
+        end
+
+        # Formata tools para API do OpenRouter
+        #
+        # @param tools [Array] Tools
+        # @return [Array] Tools formatadas
+        def format_tools(tools)
+          tools.map do |tool|
+            {
+              type: 'function',
+              function: {
+                name: tool.name,
+                description: tool.description,
+                parameters: tool.input_schema || { type: 'object', properties: {} }
+              }
+            }
+          end
+        end
+
+        # Faz requisição síncrona
+        #
+        # @param payload [Hash] Payload da requisição
+        # @return [OpenStruct] Resposta
+        def sync_request(payload)
+          uri = URI(API_URL)
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = true
+
+          request = Net::HTTP::Post.new(uri.path)
+          request['Content-Type'] = 'application/json'
+          request['Authorization'] = "Bearer #{@api_key}"
+          request['HTTP-Referer'] = @site_url || 'https://github.com/claude-ruby'
+          request['X-Title'] = @site_name || 'GSD Tools'
+          request.body = JSON.generate(payload)
+
+          log_debug("Sending request to #{API_URL}")
+
+          response = http.request(request)
+          log_debug("Response status: #{response.code}")
+
+          if response.code == '200'
+            parse_response(JSON.parse(response.body))
+          else
+            raise OpenRouterError, "API error: #{response.code} - #{response.body}"
+          end
+        end
+
+        # Faz requisição com streaming
+        #
+        # @param payload [Hash] Payload da requisição
+        # @yield [Hash] Chunk de streaming
+        # @return [OpenStruct] Resposta
+        def stream_request(payload, &block)
+          uri = URI(API_URL)
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = true
+
+          request = Net::HTTP::Post.new(uri.path)
+          request['Content-Type'] = 'application/json'
+          request['Authorization'] = "Bearer #{@api_key}"
+          request['HTTP-Referer'] = @site_url || 'https://github.com/claude-ruby'
+          request['X-Title'] = @site_name || 'GSD Tools'
+          request.body = JSON.generate(payload)
+
+          log_debug("Sending streaming request to #{API_URL}")
+
+          content = +''
+          tool_calls = []
+          usage = {}
+
+          http.request(request) do |response|
+            if response.code == '200'
+              response.read_body do |chunk|
+                chunk.each_line do |line|
+                  line = line.strip
+                  next if line.empty?
+                  next unless line.start_with?('data: ')
+
+                  data = line[6..-1]
+                  next if data == '[DONE]'
+
+                  begin
+                    event = JSON.parse(data)
+                    yield(event) if block_given?
+
+                    # Acumula conteúdo
+                    choice = event.dig(:choices, 0)
+                    if choice
+                      delta = choice[:delta]
+                      content << delta[:content].to_s if delta && delta[:content]
+
+                      # Tool calls
+                      if delta && delta[:tool_calls]
+                        delta[:tool_calls].each do |tc|
+                          if tc[:function]
+                            tool_calls << {
+                              id: tc[:id],
+                              name: tc[:function][:name],
+                              arguments: tc[:function][:arguments].to_s
+                            }
+                          end
+                        end
+                      end
+
+                      # Usage (vem no último chunk)
+                      if choice[:finish_reason] && event[:usage]
+                        usage = extract_usage(event)
+                      end
+                    end
+                  rescue JSON::ParserError
+                    # Ignora linhas inválidas
+                  end
+                end
+              end
+            else
+              raise OpenRouterError, "API error: #{response.code}"
+            end
+          end
+
+          OpenStruct.new(
+            content: content,
+            tool_calls: tool_calls,
+            usage: usage,
+            raw: {}
+          )
+        end
+
+        # Parseia a resposta da API
+        #
+        # @param data [Hash] Dados da resposta
+        # @return [OpenStruct] Resposta parseada
+        def parse_response(data)
+          content = extract_text(data)
+          tool_calls = extract_tool_calls(data)
+          usage = extract_usage(data)
+
+          OpenStruct.new(
+            content: content,
+            tool_calls: tool_calls,
+            usage: usage,
+            raw: data
+          )
+        end
+
+        # Extrai texto da resposta
+        #
+        # @param data [Hash] Dados da resposta
+        # @return [String] Texto extraído
+        def extract_text(data)
+          choices = data['choices'] || []
+          return '' if choices.empty?
+
+          message = choices[0]['message'] || {}
+          message['content'] || ''
+        end
+
+        # Extrai tool calls da resposta
+        #
+        # @param data [Hash] Dados da resposta
+        # @return [Array] Tool calls
+        def extract_tool_calls(data)
+          choices = data['choices'] || []
+          return [] if choices.empty?
+
+          message = choices[0]['message'] || {}
+          tool_calls = message['tool_calls'] || []
+
+          tool_calls.map do |tc|
+            function = tc['function'] || {}
+            OpenStruct.new(
+              id: tc['id'],
+              name: function['name'],
+              arguments: JSON.parse(function['arguments'] || '{}')
+            )
+          end
+        rescue => e
+          log_debug("Error extracting tool calls: #{e.message}")
+          []
+        end
+
+        # Extrai usage da resposta
+        #
+        # @param data [Hash] Dados da resposta
+        # @return [Hash] Usage data
+        def extract_usage(data)
+          usage = data['usage'] || {}
+          {
+            input_tokens: usage['prompt_tokens'] || 0,
+            output_tokens: usage['completion_tokens'] || 0,
+            total_tokens: usage['total_tokens'] || 0
+          }
+        end
+      end
+
+      # Erro customizado para OpenRouter
+      class OpenRouterError < StandardError; end
+    end
+  end
+end

data/lib/gsd/ai/reference_resolver.rb

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+require 'base64'
+
+module Gsd
+  module AI
+    # ReferenceResolver - Resolve referências (@) para conteúdo
+    #
+    # Responsável por:
+    # - Ler arquivos (@arquivo.rb)
+    # - Listar pastas (@pasta/)
+    # - Converter imagens para base64 (@imagem.png)
+    # - Respeitar limites (max 5 arquivos, 100KB cada)
+    class ReferenceResolver
+      # Limite de arquivos por mensagem
+      MAX_FILES = 5
+
+      # Limite de tamanho por arquivo (bytes)
+      MAX_FILE_SIZE = 100 * 1024 # 100KB
+
+      # Extensões de imagem suportadas
+      IMAGE_EXTENSIONS = %w[.png .jpg .jpeg .gif .webp .bmp].freeze
+
+      # Inicializa o resolver
+      #
+      # @param cwd [String] Diretório base para resolver paths
+      # @param provider [Object] Provider para verificar suporte a imagens
+      def initialize(cwd: Dir.pwd, provider: nil)
+        @cwd = cwd
+        @provider = provider
+      end
+
+      # Resolve uma lista de referências
+      #
+      # @param references [Array<String>] Lista de @referências
+      # @return [Hash] { text: "expandido", images: [{...}], errors: [] }
+      def resolve(references)
+        return { text: '', images: [], errors: [] } if references.nil? || references.empty?
+
+        files = []
+        dirs = []
+        images = []
+        errors = []
+
+        references.first(MAX_FILES).each do |ref|
+          path = File.expand_path(ref, @cwd)
+
+          unless File.exist?(path)
+            errors << "Não encontrado: @#{ref}"
+            next
+          end
+
+          if File.directory?(path)
+            dirs << { ref: ref, path: path, content: list_directory(path) }
+          elsif image_file?(path)
+            images << resolve_image(ref, path, errors)
+          else
+            files << resolve_file(ref, path, errors)
+          end
+        end
+
+        # Ignora imagens se provider não suportar
+        images = [] unless provider_supports_vision?
+
+        {
+          text: build_text(files, dirs),
+          images: images.compact,
+          errors: errors
+        }
+      end
+
+      # Resolve uma única referência
+      #
+      # @param ref [String] Referência sem @
+      # @return [Hash] { type: :file|:dir|:image, content: ..., error: ... }
+      def resolve_one(ref)
+        path = File.expand_path(ref, @cwd)
+
+        return { type: :error, error: "Não encontrado: @#{ref}" } unless File.exist?(path)
+
+        if File.directory?(path)
+          { type: :dir, content: list_directory(path) }
+        elsif image_file?(path)
+          # Sempre retorna image type, mesmo se não tiver provider
+          encoded = encode_image(path)
+          if encoded[:error]
+            { type: :error, error: encoded[:error] }
+          else
+            { type: :image, content: encoded }
+          end
+        else
+          content = read_file(path)
+          return { type: :error, error: content[:error] } if content[:error]
+
+          { type: :file, content: content[:data] }
+        end
+      end
+
+      private
+
+      def resolve_file(ref, path, errors)
+        content = read_file(path)
+        if content[:error]
+          errors << content[:error]
+          nil
+        else
+          { ref: ref, path: path, content: content[:data] }
+        end
+      end
+
+      def resolve_image(ref, path, errors)
+        return nil unless provider_supports_vision?
+
+        encoded = encode_image(path)
+        if encoded[:error]
+          errors << encoded[:error]
+          nil
+        else
+          { ref: ref, path: path, base64: encoded[:data], mime: encoded[:mime] }
+        end
+      end
+
+      def read_file(path)
+        size = File.size(path)
+        if size > MAX_FILE_SIZE
+          return { error: "Arquivo muito grande (>#{MAX_FILE_SIZE / 1024}KB): #{path}" }
+        end
+
+        { data: File.read(path) }
+      rescue => e
+        { error: "Erro ao ler #{path}: #{e.message}" }
+      end
+
+      def list_directory(path)
+        entries = Dir.entries(path).reject { |e| e.start_with?('.') }
+        files = entries.select { |e| File.file?(File.join(path, e)) }
+        dirs = entries.select { |e| File.directory?(File.join(path, e)) }
+
+        {
+          path: path,
+          files: files,
+          directories: dirs,
+          total: entries.count
+        }
+      rescue => e
+        { error: "Erro ao listar #{path}: #{e.message}" }
+      end
+
+      def image_file?(path)
+        ext = File.extname(path).downcase
+        IMAGE_EXTENSIONS.include?(ext)
+      end
+
+      def encode_image(path)
+        ext = File.extname(path).downcase
+        mime = case ext
+               when '.png' then 'image/png'
+               when '.jpg', '.jpeg' then 'image/jpeg'
+               when '.gif' then 'image/gif'
+               when '.webp' then 'image/webp'
+               when '.bmp' then 'image/bmp'
+               else 'application/octet-stream'
+               end
+
+        size = File.size(path)
+        if size > MAX_FILE_SIZE
+          return { error: "Imagem muito grande (>#{MAX_FILE_SIZE / 1024}KB): #{path}" }
+        end
+
+        data = Base64.strict_encode64(File.read(path, mode: 'rb'))
+        { data: data, mime: mime }
+      rescue => e
+        { error: "Erro ao codificar imagem #{path}: #{e.message}" }
+      end
+
+      def provider_supports_vision?
+        return false if @provider.nil?
+
+        # Verifica se provider tem método supports_vision? ou inferir do nome
+        if @provider.respond_to?(:supports_vision?)
+          @provider.supports_vision?
+        else
+          # Inferir do nome da classe
+          provider_name = @provider.class.name.downcase
+          provider_name.include?('anthropic') || provider_name.include?('openai')
+        end
+      end
+
+      def build_text(files, dirs)
+        parts = []
+
+        files.each do |f|
+          next if f.nil?
+
+          parts << <<~FILE
+            --- #{f[:ref]} ---
+            #{f[:content]}
+            ---
+          FILE
+        end
+
+        dirs.each do |d|
+          content = d[:content]
+          if content.nil? || (content.is_a?(Hash) && content[:error])
+            error_msg = content&.dig(:error) || 'Erro desconhecido'
+            parts << "--- #{d[:ref]} ---\n[Erro: #{error_msg}]\n---"
+          else
+            tree = []
+            tree << "Diretório: #{content[:path]}"
+            tree << "Subdiretórios: #{content[:directories].join(', ')}" if content[:directories]&.any?
+            tree << "Arquivos: #{content[:files].join(', ')}" if content[:files]&.any?
+
+            parts << <<~DIR
+              --- #{d[:ref]} ---
+              #{tree.join("\n")}
+              ---
+            DIR
+          end
+        end
+
+        parts.join("\n")
+      end
+    end
+  end
+end