fastlane-plugin-translate_gpt_release_notes 0.1.0 → 0.2.0

data/lib/fastlane/plugin/translate_gpt_release_notes/helper/credential_resolver.rb

@@ -0,0 +1,118 @@
+module Fastlane
+  module Helper
+    # CredentialResolver manages multiple provider API keys simultaneously,
+    # allowing users to configure keys for all providers and select which
+    # to use via the provider parameter.
+    #
+    # This class provides a centralized way to resolve API credentials from
+    # various sources (parameters, environment variables) with a defined
+    # priority order.
+    class CredentialResolver
+      # Maps each provider to its credential configuration
+      # Each provider has:
+      # - env_vars: Array of environment variable names to check (in order)
+      # - param_key: Symbol for the parameter key in the params hash
+      PROVIDER_CREDENTIALS = {
+        'openai' => {
+          env_vars: ['OPENAI_API_KEY', 'GPT_API_KEY'],  # GPT_API_KEY for backward compatibility
+          param_key: :openai_api_key
+        },
+        'anthropic' => {
+          env_vars: ['ANTHROPIC_API_KEY'],
+          param_key: :anthropic_api_key
+        },
+        'gemini' => {
+          env_vars: ['GEMINI_API_KEY'],
+          param_key: :gemini_api_key
+        },
+        'deepl' => {
+          env_vars: ['DEEPL_API_KEY'],
+          param_key: :deepl_api_key
+        }
+      }.freeze
+
+      # Resolves the API key for a given provider following priority order:
+      # 1. Direct parameter (e.g., params[:openai_api_key])
+      # 2. Environment variables in order defined in PROVIDER_CREDENTIALS
+      # 3. Legacy fallback for OpenAI (GPT_API_KEY) if defined in env_vars
+      #
+      # @param provider_name [String] The provider identifier (e.g., 'openai', 'anthropic')
+      # @param params [Hash] Hash of parameters that may contain API keys
+      # @return [String, nil] The resolved API key or nil if not found
+      def self.resolve(provider_name, params = {})
+        config = provider_config(provider_name)
+        return nil unless config
+
+        # Priority 1: Check direct parameter
+        param_value = params[config[:param_key]]
+        return param_value.to_s.strip unless param_value.nil? || param_value.to_s.strip.empty?
+
+        # Priority 2: Check environment variables in order
+        config[:env_vars].each do |env_var|
+          env_value = ENV[env_var]
+          return env_value.to_s.strip unless env_value.nil? || env_value.to_s.strip.empty?
+        end
+
+        nil
+      end
+
+      # Checks if credentials exist for a given provider.
+      #
+      # @param provider_name [String] The provider identifier
+      # @param params [Hash] Hash of parameters that may contain API keys
+      # @return [Boolean] true if credentials exist, false otherwise
+      def self.credentials_exist?(provider_name, params = {})
+        !resolve(provider_name, params).nil?
+      end
+
+      # Returns an array of provider names that have configured credentials.
+      #
+      # @param params [Hash] Hash of parameters that may contain API keys
+      # @return [Array<String>] Array of provider names with valid credentials
+      def self.available_providers(params = {})
+        PROVIDER_CREDENTIALS.keys.select do |provider_name|
+          credentials_exist?(provider_name, params)
+        end
+      end
+
+      # Returns help text explaining how to configure credentials for a provider.
+      #
+      # @param provider_name [String] The provider identifier
+      # @return [String] Help text for configuring credentials
+      def self.credential_help(provider_name)
+        config = provider_config(provider_name)
+        return "Unknown provider: #{provider_name}" unless config
+
+        env_vars = config[:env_vars]
+        param_key = config[:param_key]
+
+        if env_vars.length == 1
+          "Set #{env_vars.first} environment variable, or pass :#{param_key} parameter"
+        else
+          env_vars_str = env_vars.join(' or ')
+          "Set #{env_vars_str} environment variable, or pass :#{param_key} parameter"
+        end
+      end
+
+      # Returns an array of all supported provider names.
+      #
+      # @return [Array<String>] Array of all supported provider names
+      def self.all_providers
+        PROVIDER_CREDENTIALS.keys.freeze
+      end
+
+      private
+
+      # Retrieves the credential configuration for a provider.
+      # Handles case-insensitive provider names by downcasing.
+      #
+      # @param provider_name [String] The provider identifier
+      # @return [Hash, nil] The credential configuration or nil if provider not found
+      def self.provider_config(provider_name)
+        return nil if provider_name.nil?
+
+        PROVIDER_CREDENTIALS[provider_name.to_s.downcase]
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/translate_gpt_release_notes/helper/providers/anthropic_provider.rb

@@ -0,0 +1,119 @@
+require 'anthropic'
+require_relative 'base_provider'
+
+module Fastlane
+  module Helper
+    module Providers
+      # Provider implementation for Anthropic Claude translation API.
+      # Uses the Claude models for high-quality text translation with strong reasoning capabilities.
+      class AnthropicProvider < BaseProvider
+        # Default model for Anthropic translations
+        DEFAULT_MODEL = 'claude-sonnet-4.5'.freeze
+
+        # Default maximum tokens for translation response
+        DEFAULT_MAX_TOKENS = 1024
+
+        # Default temperature for translation generation (0.5 = balanced creativity)
+        DEFAULT_TEMPERATURE = 0.5
+
+        # Default request timeout in seconds
+        DEFAULT_TIMEOUT = 60
+
+        # Returns the provider identifier string.
+        #
+        # @return [String] Provider identifier
+        def self.provider_name
+          'anthropic'
+        end
+
+        # Returns the human-readable display name for the provider.
+        #
+        # @return [String] Human-readable name
+        def self.display_name
+          'Anthropic Claude'
+        end
+
+        # Returns the list of required credential symbols for this provider.
+        #
+        # @return [Array<Symbol>] Array of required credential keys
+        def self.required_credentials
+          [:api_token]
+        end
+
+        # Returns a hash of optional parameter definitions for this provider.
+        #
+        # @return [Hash] Optional parameter definitions
+        def self.optional_params
+          {
+            model_name: { default: DEFAULT_MODEL, description: 'Anthropic model to use', env: 'ANTHROPIC_MODEL_NAME' },
+            max_tokens: { default: DEFAULT_MAX_TOKENS, description: 'Maximum tokens in response', env: 'ANTHROPIC_MAX_TOKENS' },
+            temperature: { default: DEFAULT_TEMPERATURE, description: 'Sampling temperature (0-1)', env: 'ANTHROPIC_TEMPERATURE' },
+            request_timeout: { default: DEFAULT_TIMEOUT, description: 'Request timeout in seconds', env: 'ANTHROPIC_REQUEST_TIMEOUT' }
+          }
+        end
+
+        # Initializes the Anthropic provider with configuration parameters.
+        # Sets up the Anthropic::Client with appropriate credentials and timeout.
+        #
+        # @param params [Hash] Configuration parameters for the provider
+        def initialize(params)
+          super
+
+          timeout = @params[:request_timeout] || DEFAULT_TIMEOUT
+          @client = Anthropic::Client.new(
+            api_key: credential(:api_token),
+            timeout: timeout.to_i
+          )
+        end
+
+        # Validates the provider configuration.
+        # Ensures that the required api_token credential is present.
+        #
+        # @return [void]
+        def validate_config!
+          require_credential(:api_token)
+        end
+
+        # Translates text from source locale to target locale using Anthropic's API.
+        #
+        # @param text [String] The text to translate
+        # @param source_locale [String] Source language code (e.g., 'en', 'de')
+        # @param target_locale [String] Target language code (e.g., 'es', 'fr')
+        # @return [String, nil] Translated text or nil on error
+        def translate(text, source_locale, target_locale)
+          # Build prompt using inherited method
+          prompt = build_prompt(text, source_locale, target_locale)
+
+          # Add Android limitations if needed
+          prompt = apply_android_limitations(prompt) if @params[:platform] == 'android'
+
+          # Make API call using ruby-anthropic gem API
+          response = @client.complete(
+            model: @params[:model_name] || DEFAULT_MODEL,
+            max_tokens_to_sample: (@params[:max_tokens] || DEFAULT_MAX_TOKENS).to_i,
+            temperature: (@params[:temperature] || DEFAULT_TEMPERATURE).to_f,
+            prompt: "\n\nHuman: #{prompt}\n\nAssistant:"
+          )
+
+          # Extract text from response
+          extract_text_from_response(response)
+        rescue StandardError => e
+          UI.error "Anthropic provider error: #{e.message}"
+          nil
+        end
+
+        private
+
+        # Extracts translated text from the Anthropic API response
+        #
+        # @param response [Hash] The API response hash
+        # @return [String, nil] The translated text or nil
+        def extract_text_from_response(response)
+          return nil if response.nil?
+
+          response['completion']&.strip
+        end
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/translate_gpt_release_notes/helper/providers/base_provider.rb

@@ -0,0 +1,161 @@
+module Fastlane
+  module Helper
+    module Providers
+      # Abstract base class for all translation providers.
+      # Subclasses must implement all abstract methods to provide
+      # provider-specific translation functionality.
+      class BaseProvider
+        # Maximum character length for Google Play release notes
+        ANDROID_CHAR_LIMIT = 500
+
+        attr_reader :params, :config_errors
+
+        # Initializes the provider with configuration parameters.
+        # Automatically validates the configuration.
+        #
+        # @param params [Hash] Configuration parameters for the provider
+        def initialize(params)
+          @params = params
+          @config_errors = []
+          validate_config!
+        end
+
+        # Translates text from source locale to target locale.
+        # Must be implemented by subclasses.
+        #
+        # @param text [String] The text to translate
+        # @param source_locale [String] Source language code (e.g., 'en', 'de')
+        # @param target_locale [String] Target language code (e.g., 'es', 'fr')
+        # @return [String, nil] Translated text or nil on error
+        def translate(text, source_locale, target_locale)
+          raise NotImplementedError, "#{self.class.name} must implement #translate"
+        end
+
+        # Validates provider-specific configuration.
+        # Should populate @config_errors with any validation failures.
+        # Must be implemented by subclasses.
+        #
+        # @return [void]
+        def validate_config!
+          raise NotImplementedError, "#{self.class.name} must implement #validate_config!"
+        end
+
+        # Returns the provider identifier string.
+        # Must be implemented by subclasses.
+        #
+        # @return [String] Provider identifier (e.g., 'openai', 'anthropic')
+        def self.provider_name
+          raise NotImplementedError, "#{name} must implement .provider_name"
+        end
+
+        # Returns the human-readable display name for the provider.
+        # Must be implemented by subclasses.
+        #
+        # @return [String] Human-readable name (e.g., 'OpenAI GPT', 'Anthropic Claude')
+        def self.display_name
+          raise NotImplementedError, "#{name} must implement .display_name"
+        end
+
+        # Returns the list of required credential symbols for this provider.
+        # Must be implemented by subclasses.
+        #
+        # @return [Array<Symbol>] Array of required credential keys
+        def self.required_credentials
+          raise NotImplementedError, "#{name} must implement .required_credentials"
+        end
+
+        # Returns a hash of optional parameter definitions for this provider.
+        # Keys are parameter names, values are hashes with :default and :description.
+        # Must be implemented by subclasses.
+        #
+        # @return [Hash] Optional parameter definitions
+        def self.optional_params
+          raise NotImplementedError, "#{name} must implement .optional_params"
+        end
+
+        # Checks if the provider configuration is valid.
+        #
+        # @return [Boolean] true if no configuration errors exist
+        def valid?
+          @config_errors.empty?
+        end
+
+        protected
+
+        # Builds a translation prompt for the AI provider.
+        # Includes context about platform limitations if applicable.
+        #
+        # @param text [String] The text to translate
+        # @param source_locale [String] Source language code
+        # @param target_locale [String] Target language code
+        # @return [String] The formatted prompt
+        def build_prompt(text, source_locale, target_locale)
+          prompt_parts = []
+
+          # Base translation instruction
+          prompt_parts << "Translate the following text from #{source_locale} to #{target_locale}:"
+          prompt_parts << ""
+          prompt_parts << "\"#{text}\""
+
+          # Add context if provided
+          if @params[:context]
+            prompt_parts << ""
+            prompt_parts << "Context: #{@params[:context]}"
+          end
+
+          # Apply Android limitations if specified
+          if @params[:android_limitations]
+            prompt_parts << ""
+            prompt_parts << apply_android_limitations("")
+          end
+
+          prompt_parts.join("\n")
+        end
+
+        # Adds Android character limit constraint to the prompt.
+        # Google Play has a 500 character limit for release notes.
+        #
+        # @param prompt [String] The existing prompt to append to
+        # @return [String] The prompt with limitation instruction appended
+        def apply_android_limitations(prompt)
+          prompt + "IMPORTANT: The translated text must not exceed #{ANDROID_CHAR_LIMIT} characters " \
+          "(Google Play Store release notes limit). Please provide a concise translation."
+        end
+
+        # Adds a configuration error to the errors list.
+        #
+        # @param message [String] The error message
+        # @return [void]
+        def add_config_error(message)
+          @config_errors << message
+          UI.error("[#{self.class.display_name}] #{message}") if defined?(UI)
+        end
+
+        # Retrieves a credential value from environment variables or params.
+        # Checks environment variable first, then falls back to params.
+        #
+        # @param key [Symbol] The credential key
+        # @return [String, nil] The credential value or nil if not found
+        def credential(key)
+          env_var = "TRANSLATE_#{self.class.provider_name.upcase}_#{key.to_s.upcase}"
+          ENV[env_var] || @params[key]
+        end
+
+        # Checks if a required credential is present.
+        # Adds a config error if the credential is missing.
+        #
+        # @param key [Symbol] The credential key to validate
+        # @return [Boolean] true if the credential is present
+        def require_credential(key)
+          value = credential(key)
+          if value.nil? || value.to_s.empty?
+            add_config_error("Missing required credential: #{key}")
+            false
+          else
+            true
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/translate_gpt_release_notes/helper/providers/deepl_provider.rb

@@ -0,0 +1,145 @@
+require 'deepl'
+require_relative 'base_provider'
+
+module Fastlane
+  module Helper
+    module Providers
+      # Provider implementation for DeepL translation API.
+      # DeepL is a purpose-built neural machine translation service (not an LLM)
+      # known for high-quality European language translations.
+      class DeepLProvider < BaseProvider
+        # Default request timeout in seconds
+        DEFAULT_TIMEOUT = 30
+
+        # Returns the provider identifier string.
+        #
+        # @return [String] Provider identifier
+        def self.provider_name
+          'deepl'
+        end
+
+        # Returns the human-readable display name for the provider.
+        #
+        # @return [String] Human-readable name
+        def self.display_name
+          'DeepL'
+        end
+
+        # Returns the list of required credential symbols for this provider.
+        #
+        # @return [Array<Symbol>] Array of required credential keys
+        def self.required_credentials
+          [:api_token]
+        end
+
+        # Returns a hash of optional parameter definitions for this provider.
+        #
+        # @return [Hash] Optional parameter definitions
+        def self.optional_params
+          {
+            request_timeout: {
+              default: DEFAULT_TIMEOUT,
+              env: 'DEEPL_REQUEST_TIMEOUT',
+              description: 'Request timeout in seconds'
+            },
+            formality: {
+              default: 'default',
+              env: 'DEEPL_FORMALITY',
+              description: 'Formality level: default, more, or less'
+            }
+          }
+        end
+
+        # Free DeepL API keys end with ':fx' and use a different endpoint
+        FREE_KEY_SUFFIX = ':fx'.freeze
+
+        # API endpoints for different key types
+        API_HOST_PAID = 'https://api.deepl.com'.freeze
+        API_HOST_FREE = 'https://api-free.deepl.com'.freeze
+
+        # Initializes the DeepL provider with configuration parameters.
+        # Configures the DeepL gem with the API authentication key.
+        # Automatically detects free vs paid keys and uses the appropriate endpoint.
+        #
+        # @param params [Hash] Configuration parameters for the provider
+        def initialize(params)
+          super(params)
+
+          api_key = params[:api_token].to_s
+          return if api_key.nil? || api_key.empty?
+
+          host = api_key.end_with?(FREE_KEY_SUFFIX) ? API_HOST_FREE : API_HOST_PAID
+
+          DeepL.configure do |config|
+            config.auth_key = api_key
+            config.host = host
+          end
+        end
+
+        # Validates the provider configuration.
+        # Ensures that the required api_token credential is present.
+        #
+        # @return [void]
+        def validate_config!
+          require_credential(:api_token)
+        end
+
+        # Translates text from source locale to target locale using DeepL's API.
+        #
+        # @param text [String] The text to translate
+        # @param source_locale [String] Source language code (e.g., 'en-US', 'de-DE')
+        # @param target_locale [String] Target language code (e.g., 'es', 'fr')
+        # @return [String, nil] Translated text or nil on error
+        def translate(text, source_locale, target_locale)
+          # DeepL uses ISO 639-1 language codes (2-letter codes)
+          # Convert locales like 'en-US' to 'EN'
+          source_lang = normalize_locale(source_locale)
+          target_lang = normalize_locale(target_locale)
+
+          # Build options hash
+          options = {}
+
+          # Add formality if specified (not available for all languages)
+          formality = @params[:formality].to_s.strip
+          options[:formality] = formality unless formality.empty? || formality == 'default'
+
+          # DeepL supports context parameter for better translations
+          if @params[:context] && !@params[:context].empty?
+            options[:context] = @params[:context]
+          end
+
+          # Make API call
+          result = DeepL.translate(text, source_lang, target_lang, options)
+
+          translated = result.text
+
+          # Handle Android 500 character limit
+          if @params[:platform] == 'android' && translated.length > 500
+            UI.warning "DeepL translation exceeds 500 characters (#{translated.length}), truncating..."
+            translated = translated[0...500]
+          end
+
+          translated
+        rescue DeepL::Exceptions::RequestError => e
+          UI.error "DeepL API error: #{e.message}"
+          nil
+        rescue StandardError => e
+          UI.error "DeepL provider error: #{e.message}"
+          nil
+        end
+
+        private
+
+        # Normalizes locale codes for DeepL API.
+        # DeepL uses 2-letter ISO 639-1 codes (e.g., 'EN', 'DE', 'FR').
+        # Converts 'en-US' → 'EN', 'de-DE' → 'DE'.
+        #
+        # @param locale [String] The locale string to normalize
+        # @return [String] The normalized 2-letter language code
+        def normalize_locale(locale)
+          locale.to_s.split('-').first.upcase
+        end
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/translate_gpt_release_notes/helper/providers/gemini_provider.rb

@@ -0,0 +1,153 @@
+require 'net/http'
+require 'json'
+require_relative 'base_provider'
+
+module Fastlane
+  module Helper
+    module Providers
+      # Provider implementation for Google Gemini translation API using direct HTTP calls.
+      # Offers cost-effective translations suitable for high-volume use cases.
+      class GeminiProvider < BaseProvider
+        # Default model for Gemini translations
+        DEFAULT_MODEL = 'gemini-2.5-flash'.freeze
+
+        # Default temperature for translation generation (0.5 = balanced creativity)
+        DEFAULT_TEMPERATURE = 0.5
+
+        # Default request timeout in seconds
+        DEFAULT_TIMEOUT = 60
+
+        # Base URL for Gemini Generative Language API
+        API_BASE_URL = 'https://generativelanguage.googleapis.com'.freeze
+
+        # Returns the provider identifier string.
+        #
+        # @return [String] Provider identifier
+        def self.provider_name
+          'gemini'
+        end
+
+        # Returns the human-readable display name for the provider.
+        #
+        # @return [String] Human-readable name
+        def self.display_name
+          'Google Gemini'
+        end
+
+        # Returns the list of required credential symbols for this provider.
+        #
+        # @return [Array<Symbol>] Array of required credential keys
+        def self.required_credentials
+          [:api_token]
+        end
+
+        # Returns a hash of optional parameter definitions for this provider.
+        #
+        # @return [Hash] Optional parameter definitions
+        def self.optional_params
+          {
+            model_name: { default: DEFAULT_MODEL, description: 'Gemini model to use', env: 'GEMINI_MODEL_NAME' },
+            temperature: { default: DEFAULT_TEMPERATURE, description: 'Sampling temperature (0-1)', env: 'GEMINI_TEMPERATURE' },
+            request_timeout: { default: DEFAULT_TIMEOUT, description: 'Request timeout in seconds', env: 'GEMINI_REQUEST_TIMEOUT' }
+          }
+        end
+
+        # Initializes the Gemini provider with configuration parameters.
+        #
+        # @param params [Hash] Configuration parameters for the provider
+        def initialize(params)
+          super
+          @api_key = params[:api_token]
+          @model = @params[:model_name] || DEFAULT_MODEL
+          @temperature = (@params[:temperature] || DEFAULT_TEMPERATURE).to_f
+          @timeout = (@params[:request_timeout] || DEFAULT_TIMEOUT).to_i
+        end
+
+        # Validates the provider configuration.
+        # Ensures that the required api_token credential is present.
+        #
+        # @return [void]
+        def validate_config!
+          require_credential(:api_token)
+        end
+
+        # Translates text from source locale to target locale using Gemini's API.
+        #
+        # @param text [String] The text to translate
+        # @param source_locale [String] Source language code (e.g., 'en', 'de')
+        # @param target_locale [String] Target language code (e.g., 'es', 'fr')
+        # @return [String, nil] Translated text or nil on error
+        def translate(text, source_locale, target_locale)
+          # Build prompt using inherited method
+          prompt = build_prompt(text, source_locale, target_locale)
+
+          # Add Android limitations if needed
+          prompt = apply_android_limitations(prompt) if @params[:platform] == 'android'
+
+          # Make API call
+          result = make_api_request(prompt)
+
+          # Extract text from response
+          extract_text_from_response(result)
+        rescue StandardError => e
+          UI.error "Gemini provider error: #{e.message}"
+          nil
+        end
+
+        private
+
+        # Makes the HTTP API request to Gemini.
+        #
+        # @param prompt [String] The prompt to send
+        # @return [Hash] The parsed JSON response
+        def make_api_request(prompt)
+          uri = URI("#{API_BASE_URL}/v1beta/models/#{@model}:generateContent")
+          uri.query = URI.encode_www_form(key: @api_key)
+
+          request_body = {
+            contents: [{
+              role: 'user',
+              parts: { text: prompt }
+            }],
+            generationConfig: {
+              temperature: @temperature
+            }
+          }
+
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.use_ssl = true
+          http.read_timeout = @timeout
+
+          request = Net::HTTP::Post.new(uri.request_uri)
+          request['Content-Type'] = 'application/json'
+          request.body = request_body.to_json
+
+          response = http.request(request)
+
+          unless response.is_a?(Net::HTTPSuccess)
+            raise "API request failed: #{response.code} - #{response.message}"
+          end
+
+          JSON.parse(response.body)
+        end
+
+        # Extracts the translated text from the API response.
+        #
+        # @param response [Hash] The parsed JSON response
+        # @return [String, nil] The translated text or nil
+        def extract_text_from_response(response)
+          candidates = response['candidates']
+          return nil if candidates.nil? || candidates.empty?
+
+          content = candidates.dig(0, 'content')
+          return nil if content.nil?
+
+          parts = content['parts']
+          return nil if parts.nil? || parts.empty?
+
+          parts.dig(0, 'text')&.strip
+        end
+      end
+    end
+  end
+end