fantasy-cli 1.2.6

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

@@ -0,0 +1,279 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'json'
+
+module Gsd
+  module AI
+    module Providers
+      # LM Studio Provider - Integração com LM Studio (LLMs locais)
+      #
+      # Suporta:
+      # - Qualquer modelo rodando no LM Studio
+      # - API compatível com OpenAI
+      # - Streaming de respostas
+      # - Modelos locais gratuitos
+      class LMStudio < Base
+        PROVIDER_NAME = 'LM Studio'
+        DEFAULT_MODEL = 'local-model'
+        DEFAULT_HOST = 'localhost'
+        DEFAULT_PORT = '1234'
+        API_URL = '/v1/chat/completions'
+        MODELS_URL = '/v1/models'
+
+        # Inicializa o provider LM Studio
+        #
+        # @param model [String] Modelo do LM Studio
+        # @param host [String] Host do LM Studio
+        # @param port [String] Porta do LM Studio
+        # @param debug [Boolean] Habilitar debug
+        def initialize(model: nil, host: nil, port: nil, debug: false)
+          super(model: model, debug: debug)
+          @host = host || DEFAULT_HOST
+          @port = port || DEFAULT_PORT
+          @base_url = "http://#{@host}:#{@port}"
+          @api_key = 'lm-studio' # LM Studio não requer API key real
+        end
+
+        # Chama a API do LM Studio
+        #
+        # @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_lmstudio_available!
+
+          payload = build_payload(system_prompt, messages, stream)
+
+          log_debug("Calling LM Studio 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 LMStudioError, "LM Studio API error: #{e.message}"
+        end
+
+        # Verifica se está configurado (LM Studio sempre "configurado" pois é local)
+        #
+        # @return [Boolean] true
+        def configured?
+          true
+        end
+
+        # Lista modelos disponíveis
+        #
+        # @return [Array<String>] Lista de modelos
+        def list_models
+          uri = URI("#{@base_url}#{MODELS_URL}")
+          http = Net::HTTP.new(uri.host, uri.port)
+
+          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 um modelo está disponível
+        #
+        # @param model [String] Nome do modelo
+        # @return [Boolean] true se disponível
+        def model_available?(model)
+          list_models.include?(model)
+        end
+
+        # Verifica se LM Studio está rodando
+        #
+        # @return [Boolean] true se disponível
+        def available?
+          uri = URI("#{@base_url}#{MODELS_URL}")
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.read_timeout = 5
+
+          request = Net::HTTP::Get.new(uri.path)
+          response = http.request(request)
+
+          response.code == '200'
+        rescue
+          false
+        end
+
+        private
+
+        # Valida se LM Studio está disponível
+        #
+        # @raise [RuntimeError] Se LM Studio não estiver disponível
+        def validate_lmstudio_available!
+          raise "LM Studio not available at #{@base_url}" unless available?
+        end
+
+        # Constrói o payload da requisição
+        #
+        # @param system_prompt [String] System prompt
+        # @param messages [Array] Mensagens
+        # @param stream [Boolean] Streaming
+        # @return [Hash] Payload
+        def build_payload(system_prompt, messages, stream)
+          formatted_messages = [{ role: 'system', content: system_prompt }] +
+                               messages.map { |m| { role: m[:role], content: m[:content] } }
+
+          {
+            model: @model,
+            messages: formatted_messages,
+            stream: stream,
+            temperature: 0.7,
+            max_tokens: -1 # Ilimitado
+          }
+        end
+
+        # Faz requisição síncrona
+        #
+        # @param payload [Hash] Payload da requisição
+        # @return [OpenStruct] Resposta
+        def sync_request(payload)
+          uri = URI("#{@base_url}#{API_URL}")
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = false
+
+          request = Net::HTTP::Post.new(uri.path)
+          request['Content-Type'] = 'application/json'
+          request.body = JSON.generate(payload)
+
+          log_debug("Sending request to #{uri}")
+
+          response = http.request(request)
+          log_debug("Response status: #{response.code}")
+
+          if response.code == '200'
+            parse_response(JSON.parse(response.body))
+          else
+            raise LMStudioError, "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("#{@base_url}#{API_URL}")
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = false
+
+          request = Net::HTTP::Post.new(uri.path)
+          request['Content-Type'] = 'application/json'
+          request.body = JSON.generate(payload)
+
+          content = +''
+
+          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?
+
+                    choice = event.dig(:choices, 0)
+                    if choice
+                      delta = choice[:delta]
+                      content << delta[:content].to_s if delta && delta[:content]
+                    end
+                  rescue JSON::ParserError
+                    # Ignora linhas inválidas
+                  end
+                end
+              end
+            else
+              raise LMStudioError, "API error: #{response.code}"
+            end
+          end
+
+          OpenStruct.new(
+            content: content,
+            tool_calls: [],
+            usage: { input_tokens: 0, output_tokens: 0 },
+            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)
+          # LM Studio não suporta tool calls nativamente
+          []
+        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 LM Studio
+      class LMStudioError < StandardError; end
+    end
+  end
+end

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

@@ -0,0 +1,336 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'json'
+
+module Gsd
+  module AI
+    module Providers
+      # Ollama Provider - Integração com Ollama (LLMs locais)
+      #
+      # Suporta:
+      # - Llama 2
+      # - Mistral
+      # - Codellama
+      # - Qualquer modelo rodando no Ollama
+      # - Streaming de respostas
+      # - Modelos multimodais (LLaVA)
+      # - Fallback automático
+      class Ollama < Base
+        PROVIDER_NAME = 'Ollama'
+        DEFAULT_MODEL = 'llama2'
+        DEFAULT_HOST = 'localhost'
+        DEFAULT_PORT = '11434'
+        API_URL = '/api/generate'
+        CHAT_URL = '/api/chat'
+        MODELS_URL = '/api/tags'
+
+        # Modelos recomendados
+        RECOMMENDED_MODELS = [
+          'llama2',
+          'llama2:70b',
+          'mistral',
+          'codellama',
+          'codellama:34b',
+          'phi',
+          'gemma:7b',
+          'llava' # Multimodal
+        ].freeze
+
+        # Inicializa o provider Ollama
+        #
+        # @param model [String] Modelo do Ollama
+        # @param host [String] Host do Ollama
+        # @param port [String] Porta do Ollama
+        # @param debug [Boolean] Habilitar debug
+        # @param auto_pull [Boolean] Auto pull de modelos ausentes
+        def initialize(model: nil, host: nil, port: nil, debug: false, auto_pull: false)
+          super(model: model, debug: debug)
+          @host = host || DEFAULT_HOST
+          @port = port || DEFAULT_PORT
+          @base_url = "http://#{@host}:#{@port}"
+          @auto_pull = auto_pull
+          @token_cache = {}
+        end
+
+        # Chama a API do Ollama
+        #
+        # @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_ollama_available!
+
+          payload = build_payload(system_prompt, messages, stream)
+
+          log_debug("Calling Ollama 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 OllamaError, "Ollama API error: #{e.message}"
+        end
+
+        # Verifica se está configurado (Ollama sempre "configurado" pois é local)
+        #
+        # @return [Boolean] true
+        def configured?
+          true
+        end
+
+        # Lista modelos disponíveis
+        #
+        # @return [Array<String>] Lista de modelos
+        def list_models
+          uri = URI("#{@base_url}/api/tags")
+          http = Net::HTTP.new(uri.host, uri.port)
+
+          request = Net::HTTP::Get.new(uri.path)
+          response = http.request(request)
+
+          if response.code == '200'
+            data = JSON.parse(response.body)
+            data['models']&.map { |m| m['name'] } || []
+          else
+            []
+          end
+        rescue => e
+          log_debug("Error listing models: #{e.message}")
+          []
+        end
+
+        # Verifica se um modelo está disponível
+        #
+        # @param model [String] Nome do modelo
+        # @return [Boolean] true se disponível
+        def model_available?(model)
+          list_models.include?(model)
+        end
+
+        # Conta tokens de forma precisa
+        #
+        # @param text [String] Texto para contar
+        # @return [Integer] Número de tokens
+        def count_tokens(text)
+          return @token_cache[text] if @token_cache[text]
+
+          # Estimativa: ~4 caracteres por token
+          estimated = text.length / 4
+          @token_cache[text] = estimated
+          estimated
+        end
+
+        # Limpa o cache de tokens
+        #
+        # @return [void]
+        def clear_token_cache
+          @token_cache = {}
+        end
+
+        # Formata imagem para API do Ollama (LLaVA)
+        #
+        # @param image_path [String] Caminho da imagem ou base64
+        # @return [String] Base64 da imagem
+        def format_image(image_path)
+          if image_path.start_with?('http')
+            # Download e conversão
+            require 'open-uri'
+            image_data = URI.open(image_path).read
+          elsif File.exist?(image_path)
+            image_data = File.read(image_path, mode: 'rb')
+          else
+            # Assume que já é base64
+            return image_path
+          end
+
+          [image_data].pack('m0') # Base64
+        end
+
+        # Verifica se modelo é multimodal
+        #
+        # @param model [String] Nome do modelo
+        # @return [Boolean] true se é multimodal
+        def multimodal?(model)
+          model.downcase.include?('llava') ||
+            model.downcase.include?('bakllava') ||
+            model.downcase.include?('vision')
+        end
+
+        # Faz pull do modelo se não existir
+        #
+        # @param model [String] Nome do modelo
+        # @return [void]
+        def pull_model_if_needed(model)
+          return if model_available?(model)
+
+          if @auto_pull
+            log_debug("Pulling model #{model}...")
+            # Implementação do pull seria adicionada aqui
+          else
+            raise OllamaError, "Model #{model} not available. Enable auto_pull or run: ollama pull #{model}"
+          end
+        end
+
+        private
+
+        # Valida se Ollama está disponível
+        #
+        # @raise [RuntimeError] Se Ollama não estiver disponível
+        def validate_ollama_available!
+          uri = URI("#{@base_url}/api/tags")
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.read_timeout = 5
+
+          request = Net::HTTP::Get.new(uri.path)
+          response = http.request(request)
+
+          raise "Ollama not available at #{@base_url}" unless response.code == '200'
+        rescue => e
+          raise "Ollama not available: #{e.message}"
+        end
+
+        # Constrói o payload da requisição
+        #
+        # @param system_prompt [String] System prompt
+        # @param messages [Array] Mensagens
+        # @param stream [Boolean] Streaming
+        # @return [Hash] Payload
+        def build_payload(system_prompt, messages, stream)
+          # Ollama usa formato diferente para chat
+          formatted_messages = messages.map do |msg|
+            {
+              role: msg[:role],
+              content: msg[:content]
+            }
+          end
+
+          # Adiciona system prompt como primeira mensagem se não existir
+          if formatted_messages.empty? || formatted_messages.first[:role] != 'system'
+            formatted_messages.unshift({ role: 'system', content: system_prompt })
+          end
+
+          {
+            model: @model,
+            messages: formatted_messages,
+            stream: stream,
+            options: {
+              temperature: 0.7,
+              top_p: 0.9
+            }
+          }
+        end
+
+        # Faz requisição síncrona
+        #
+        # @param payload [Hash] Payload da requisição
+        # @return [OpenStruct] Resposta
+        def sync_request(payload)
+          uri = URI("#{@base_url}#{CHAT_URL}")
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = false
+
+          request = Net::HTTP::Post.new(uri.path)
+          request['Content-Type'] = 'application/json'
+          request.body = JSON.generate(payload)
+
+          log_debug("Sending request to #{uri}")
+
+          response = http.request(request)
+          log_debug("Response status: #{response.code}")
+
+          if response.code == '200'
+            parse_response(JSON.parse(response.body))
+          else
+            raise OllamaError, "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)
+          # Para streaming, precisamos ler a resposta chunk por chunk
+          # Cada linha é um JSON completo
+          uri = URI("#{@base_url}#{CHAT_URL}")
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = false
+
+          request = Net::HTTP::Post.new(uri.path)
+          request['Content-Type'] = 'application/json'
+          request.body = JSON.generate(payload)
+
+          content = +''
+          total_duration = 0
+
+          http.request(request) do |response|
+            if response.code == '200'
+              response.read_body do |chunk|
+                chunk.each_line do |line|
+                  begin
+                    data = JSON.parse(line.strip)
+                    if block_given?
+                      yield(data)
+                    end
+
+                    if data['message']
+                      content << data['message']['content'].to_s
+                    end
+
+                    total_duration += data['total_duration'].to_i
+                  rescue JSON::ParserError
+                    # Ignora linhas inválidas
+                  end
+                end
+              end
+            else
+              raise OllamaError, "API error: #{response.code}"
+            end
+          end
+
+          OpenStruct.new(
+            content: content,
+            tool_calls: [],
+            usage: {
+              input_tokens: 0,
+              output_tokens: 0,
+              total_duration: total_duration
+            },
+            raw: {}
+          )
+        end
+
+        # Parseia a resposta da API
+        #
+        # @param data [Hash] Dados da resposta
+        # @return [OpenStruct] Resposta parseada
+        def parse_response(data)
+          content = data.dig('message', 'content') || ''
+
+          OpenStruct.new(
+            content: content,
+            tool_calls: [],
+            usage: {
+              input_tokens: 0,
+              output_tokens: 0,
+              total_duration: data['total_duration'].to_i
+            },
+            raw: data
+          )
+        end
+      end
+
+      # Erro customizado para Ollama
+      class OllamaError < StandardError; end
+    end
+  end
+end