fastlane-plugin-translate_gpt_release_notes 0.1.0 → 0.2.0

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

@@ -0,0 +1,136 @@
+require 'openai'
+require_relative 'base_provider'
+
+module Fastlane
+  module Helper
+    module Providers
+      # Provider implementation for OpenAI GPT translation API.
+      # Supports various GPT models including gpt-5.2 for translation tasks.
+      class OpenAIProvider < BaseProvider
+        # Default model for OpenAI translations
+        DEFAULT_MODEL = 'gpt-5.2'.freeze
+
+        # Default temperature for translation generation (0.5 = balanced creativity)
+        DEFAULT_TEMPERATURE = 0.5
+
+        # Default request timeout in seconds
+        DEFAULT_TIMEOUT = 30
+
+        # Returns the provider identifier string.
+        #
+        # @return [String] Provider identifier
+        def self.provider_name
+          'openai'
+        end
+
+        # Returns the human-readable display name for the provider.
+        #
+        # @return [String] Human-readable name
+        def self.display_name
+          'OpenAI GPT'
+        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: 'OpenAI model to use' },
+            temperature: { default: DEFAULT_TEMPERATURE, description: 'Sampling temperature (0-2)' },
+            service_tier: { default: nil, description: 'Service tier (e.g., "flex")' },
+            request_timeout: { default: DEFAULT_TIMEOUT, description: 'Request timeout in seconds' }
+          }
+        end
+
+        # Initializes the OpenAI provider with configuration parameters.
+        # Sets up the OpenAI::Client with appropriate credentials and timeout.
+        #
+        # @param params [Hash] Configuration parameters for the provider
+        def initialize(params)
+          super
+
+          timeout = normalized_timeout
+          @client = OpenAI::Client.new(
+            access_token: credential(:api_token),
+            request_timeout: timeout
+          )
+        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 OpenAI'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 build_prompt method
+          prompt = build_prompt(text, source_locale, target_locale)
+
+          # Add Android limitations if needed
+          prompt = apply_android_limitations(prompt) if @params[:platform] == 'android'
+
+          # Build parameters hash
+          parameters = {
+            model: @params[:model_name] || DEFAULT_MODEL,
+            messages: [{ role: 'user', content: prompt }],
+            temperature: (@params[:temperature] || DEFAULT_TEMPERATURE).to_f
+          }
+
+          # Add service_tier if present
+          service_tier = @params[:service_tier].to_s.strip
+          parameters[:service_tier] = service_tier unless service_tier.empty?
+
+          # Make API call
+          response = @client.chat(parameters: parameters)
+
+          # Handle errors and extract text
+          if (error = response.dig('error', 'message'))
+            UI.error "OpenAI translation error: #{error}"
+            nil
+          else
+            response.dig('choices', 0, 'message', 'content')&.strip
+          end
+        rescue StandardError => e
+          UI.error "OpenAI provider error: #{e.message}"
+          nil
+        end
+
+        private
+
+        # Normalizes the request timeout value based on service tier.
+        # Flex service tier requires a minimum timeout of 900 seconds.
+        #
+        # @return [Integer, nil] Normalized timeout value or nil
+        def normalized_timeout
+          service_tier = @params[:service_tier].to_s.strip
+          raw_timeout = @params[:request_timeout]
+
+          # Use default timeout if not specified
+          timeout = raw_timeout.nil? ? DEFAULT_TIMEOUT : raw_timeout.to_i
+
+          if service_tier == 'flex' && timeout > 0 && timeout < 900
+            UI.message('Flex processing detected; increasing request_timeout to 900s.')
+            return 900
+          end
+
+          timeout
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,148 @@
+require_relative '../credential_resolver'
+require_relative 'base_provider'
+require_relative 'openai_provider'
+require_relative 'anthropic_provider'
+require_relative 'gemini_provider'
+require_relative 'deepl_provider'
+
+module Fastlane
+  module Helper
+    module Providers
+      # ProviderFactory is the central component for creating provider instances.
+      # It uses CredentialResolver to resolve API keys and instantiates the
+      # appropriate provider based on the provider_name parameter.
+      #
+      # This class provides a unified interface for creating any supported provider
+      # with automatic credential resolution and validation.
+      #
+      # @example Creating a provider with automatic credential resolution
+      #   provider = ProviderFactory.create('openai', { model_name: 'gpt-5.2' })
+      #
+      # @example Creating a provider with explicit API key
+      #   provider = ProviderFactory.create_with_key('openai', 'sk-...', { model_name: 'gpt-5.2' })
+      #
+      class ProviderFactory
+        # Mapping of provider names to their respective provider classes.
+        # Used to look up and instantiate the correct provider implementation.
+        PROVIDERS = {
+          OpenAIProvider.provider_name => OpenAIProvider,
+          AnthropicProvider.provider_name => AnthropicProvider,
+          GeminiProvider.provider_name => GeminiProvider,
+          DeepLProvider.provider_name => DeepLProvider
+        }.freeze
+
+        # Default provider to use when none is specified.
+        DEFAULT_PROVIDER = 'openai'.freeze
+
+        # Creates a provider instance with automatic credential resolution.
+        #
+        # This method resolves the API key using CredentialResolver, merges it into
+        # the params, and instantiates the appropriate provider class.
+        #
+        # @param provider_name [String, nil] The provider identifier (e.g., 'openai', 'anthropic').
+        #   Defaults to DEFAULT_PROVIDER if nil or not provided.
+        # @param params [Hash] Configuration parameters for the provider.
+        #   May include provider-specific options and credential overrides.
+        # @return [BaseProvider] An instance of the requested provider class.
+        # @raise [FastlaneCore::Interface::FastlaneError] If the provider name is unknown
+        #   or if no API key can be resolved.
+        def self.create(provider_name, params)
+          provider_name = provider_name.to_s.empty? ? DEFAULT_PROVIDER : provider_name.to_s.downcase
+          provider_class = PROVIDERS[provider_name]
+
+          unless provider_class
+            UI.user_error!("Unknown provider '#{provider_name}'. Available: #{available_provider_names.join(', ')}")
+            return nil
+          end
+
+          # Resolve API key
+          api_key = CredentialResolver.resolve(provider_name, params)
+
+          unless api_key
+            UI.user_error!("No API key found for provider '#{provider_name}'. #{CredentialResolver.credential_help(provider_name)}")
+            return nil
+          end
+
+          # Merge API key into params
+          provider_params = params.merge(api_token: api_key)
+
+          provider_class.new(provider_params)
+        end
+
+        # Creates a provider instance with an explicit API key.
+        #
+        # This method bypasses credential resolution and uses the provided API key
+        # directly. Useful when the key is obtained from an external source or
+        # when credential resolution is not desired.
+        #
+        # @param provider_name [String] The provider identifier (e.g., 'openai', 'anthropic').
+        # @param api_key [String] The API key to use for authentication.
+        # @param params [Hash] Optional configuration parameters for the provider.
+        # @return [BaseProvider] An instance of the requested provider class.
+        # @raise [FastlaneCore::Interface::FastlaneError] If the provider name is unknown.
+        def self.create_with_key(provider_name, api_key, params = {})
+          provider_name = provider_name.to_s.downcase
+          provider_class = PROVIDERS[provider_name]
+
+          unless provider_class
+            UI.user_error!("Unknown provider '#{provider_name}'")
+            return nil
+          end
+
+          provider_params = params.merge(api_token: api_key)
+          provider_class.new(provider_params)
+        end
+
+        # Returns an array of all available provider names.
+        #
+        # @return [Array<String>] Array of provider identifiers.
+        def self.available_provider_names
+          PROVIDERS.keys.freeze
+        end
+
+        # Returns a hash mapping provider names to their display names.
+        #
+        # @return [Hash<String, String>] Hash with provider names as keys and
+        #   human-readable display names as values.
+        def self.provider_display_names
+          PROVIDERS.transform_values(&:display_name)
+        end
+
+        # Checks if a provider name is valid.
+        #
+        # @param provider_name [String] The provider identifier to check.
+        # @return [Boolean] true if the provider is supported, false otherwise.
+        def self.valid_provider?(provider_name)
+          PROVIDERS.key?(provider_name.to_s.downcase)
+        end
+
+        # Gets the full configuration for a provider.
+        #
+        # Returns a comprehensive hash containing all configuration details
+        # for the specified provider, including name, display name, required
+        # credentials, optional parameters, and credential help text.
+        #
+        # @param provider_name [String] The provider identifier.
+        # @return [Hash] Provider configuration hash with keys:
+        #   - :name [String] Provider identifier
+        #   - :display_name [String] Human-readable name
+        #   - :required_credentials [Array<Symbol>] Required credential symbols
+        #   - :optional_params [Hash] Optional parameter definitions
+        #   - :credential_help [String] Help text for configuring credentials
+        # @return [Hash] Empty hash if provider is not found.
+        def self.provider_config(provider_name)
+          provider_class = PROVIDERS[provider_name.to_s.downcase]
+          return {} unless provider_class
+
+          {
+            name: provider_class.provider_name,
+            display_name: provider_class.display_name,
+            required_credentials: provider_class.required_credentials,
+            optional_params: provider_class.optional_params,
+            credential_help: CredentialResolver.credential_help(provider_name)
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -1,6 +1,5 @@
 require 'fastlane_core/ui/ui'
-require 'openai'
-require 'json'
+require_relative 'providers/provider_factory'
 
 module Fastlane
   UI = FastlaneCore::UI unless Fastlane.const_defined?("UI")
@@ -9,49 +8,29 @@ module Fastlane
     class TranslateGptReleaseNotesHelper
       def initialize(params)
         @params = params
-        @client = OpenAI::Client.new(
-          access_token: params[:api_token],
-          request_timeout: params[:request_timeout]
-        )
-      end
-
-      # Request a translation from the GPT API
-      def translate_text(text, target_locale, platform)
-        source_locale = @params[:master_locale]
-        prompt = "Translate this text from #{source_locale} to #{target_locale}:\n#{text}"
-
-
-        # Add condition for Android platform
-        if platform == 'android'
-          prompt += "\n\nNote: The length of the translated text should be 500 symbols maximum. Rephrase a little if needed."
-        end
+        provider_name = params[:provider] || 'openai'
 
-        # Context handling
-        if @params[:context] && !@params[:context].empty?
-          prompt = "Context: #{@params[:context]}\n" + prompt
+        # Validate provider selection
+        unless Providers::ProviderFactory.valid_provider?(provider_name)
+          UI.warning "Unknown provider '#{provider_name}', falling back to OpenAI"
+          provider_name = 'openai'
         end
 
-        # Updated API call with max_tokens
-        response = @client.chat(
-          parameters: {
-            model: @params[:model_name] || 'gpt-4-1106-preview',
-            messages: [{ role: "user", content: prompt }],
-            temperature: @params[:temperature] || 0.5
-          }
-        )
+        # Create provider via factory (handles credential resolution)
+        @provider = Providers::ProviderFactory.create(provider_name, params)
 
-      
-        error = response.dig("error", "message")
-        if error
-          UI.error "Error translating text: #{error}"
-          return nil
-        else
-          translated_text = response.dig("choices", 0, "message", "content").strip
-          UI.message "Translated text: #{translated_text}"
-          return translated_text
+        # Validate provider configuration
+        unless @provider.valid?
+          UI.user_error!("Provider configuration errors: #{@provider.config_errors.join(', ')}")
         end
       end
-      
+
+      # Request a translation from the configured provider
+      def translate_text(text, target_locale, _platform)
+        source_locale = @params[:master_locale]
+        @provider.translate(text, source_locale, target_locale)
+      end
+
       # Sleep for a specified number of seconds, displaying a progress bar
       def wait(seconds = @params[:request_timeout])
         sleep_time = 0
@@ -89,7 +68,7 @@ module Fastlane
         white:   37,
         reset:   0,
       }
-    
+
       def self.colorize(text, color)
         color_code = COLORS[color.to_sym]
         "\e[#{color_code}m#{text}\e[0m"

data/lib/fastlane/plugin/translate_gpt_release_notes/version.rb

@@ -1,5 +1,5 @@
 module Fastlane
   module TranslateGptReleaseNotes
-    VERSION = "0.0.3"
+    VERSION = "0.2.0"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fastlane-plugin-translate_gpt_release_notes
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Anton Karliner
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-09-11 00:00:00.000000000 Z
+date: 2026-01-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruby-openai
@@ -52,6 +52,48 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 1.18.9
+- !ruby/object:Gem::Dependency
+  name: anthropic
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: deepl-rb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
+- !ruby/object:Gem::Dependency
+  name: openssl
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.2.0
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -202,6 +244,13 @@ files:
 - README.md
 - lib/fastlane/plugin/translate_gpt_release_notes.rb
 - lib/fastlane/plugin/translate_gpt_release_notes/actions/translate_gpt_release_notes_action.rb
+- lib/fastlane/plugin/translate_gpt_release_notes/helper/credential_resolver.rb
+- lib/fastlane/plugin/translate_gpt_release_notes/helper/providers/anthropic_provider.rb
+- lib/fastlane/plugin/translate_gpt_release_notes/helper/providers/base_provider.rb
+- lib/fastlane/plugin/translate_gpt_release_notes/helper/providers/deepl_provider.rb
+- lib/fastlane/plugin/translate_gpt_release_notes/helper/providers/gemini_provider.rb
+- lib/fastlane/plugin/translate_gpt_release_notes/helper/providers/openai_provider.rb
+- lib/fastlane/plugin/translate_gpt_release_notes/helper/providers/provider_factory.rb
 - lib/fastlane/plugin/translate_gpt_release_notes/helper/translate_gpt_release_notes_helper.rb
 - lib/fastlane/plugin/translate_gpt_release_notes/version.rb
 homepage: https://github.com/antonkarliner/fastlane-plugin-translate_gpt_release_notes
@@ -229,6 +278,5 @@ requirements: []
 rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
-summary: Translate release notes or changelogs for iOS and Android apps using OpenAI
-  GPT API
+summary: 'Translate release notes using AI providers: OpenAI, Claude, Gemini, or DeepL'
 test_files: []