fastlane-plugin-translate_gpt_release_notes 0.3.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 583516edebe47c16ac07d08fad7c985ba813ee714465248654dd5dd029bd1d5b
-  data.tar.gz: 55366af37fecbdf65d587dc31464c5a9b0be8779a819261214f99c7d5affb286
+  metadata.gz: 8b804e528e753243e44795157932c4d7fe91dd86f7393fc3c27169bd46ae064a
+  data.tar.gz: 46dcb053c8eca62129b0616477a4f0b7287c63dd40de91f40749f35b04758f70
 SHA512:
-  metadata.gz: c2db228382b529fa334385d97c39e1daecbd7280894f2aa0b9b870d2a8a1027c15eee79c6253b7c2d07cd0bc228ff684d77a892eaa954842fcc8e03befef0f8e
-  data.tar.gz: 25021f03188ebbb7551ed18c5da99cce25568ba46e6c92f1c1160207997414ded93b4cbed993f10b30f7eebc1004ced57ae36fbaca6769acfe39638ad10bcb31
+  metadata.gz: 3942636066fa49fb840cb6855742b3605e71894b6ce40b235bb25c96d49282da9a7bde5ca458f32b13bb9ac015f74a05efd2995ef7c73ed6119a43aa75a7eab9
+  data.tar.gz: f37538e795cfb574c2c7a5a3a025dc4ef9d78b228e27cce6636ccb9ef7fd2fd4984c4304424a0af2f1b15f266e1df0307e283b6fe39f8cb7662d41a9c20ba475

data/README.md

@@ -171,6 +171,8 @@ translate_gpt_release_notes(
 
 **Note**: DeepL automatically detects free vs paid API keys (free keys end with `:fx`) and uses the appropriate endpoint.
 
+**Note**: DeepL requires region-qualified targets for English (`EN-US` or `EN-GB`) and Portuguese (`PT-PT` or `PT-BR`). The plugin handles this automatically based on the locale passed — `en` and `en-US` both map to `EN-US`, `en-GB` maps to `EN-GB`, and similarly for Portuguese.
+
 ## Glossary Support (Experimental)
 
 > **Note**: Glossary support is an experimental feature. If you encounter any issues, please [open an issue on GitHub](https://github.com/antonkarliner/fastlane-plugin-translate_gpt_release_notes/issues).
@@ -182,7 +184,8 @@ The glossary feature ensures consistent translation of app-specific terms (scree
 1. The plugin loads glossary terms from a JSON file and/or a directory of localization files
 2. Before each translation, it fuzzy-matches terms from the glossary against the source text
 3. Only relevant terms are included in the translation prompt (keeping it concise)
-4. Each provider uses the glossary differently:
+4. The AI is instructed to use glossary terms as **reference translations** and apply appropriate grammatical forms (declension, conjugation, agreement) as needed — so translations sound natural in inflected languages like Russian, German, or Finnish rather than copying terms verbatim
+5. Each provider uses the glossary differently:
    - **OpenAI**: Glossary terms are sent as a system message for strong instruction following
    - **Anthropic / Gemini**: Glossary terms are included in the translation prompt
    - **DeepL**: Glossary terms are passed via the `context` parameter
@@ -286,6 +289,7 @@ This keeps the glossary concise and avoids flooding the AI provider with irrelev
 | `context` | Context for translation to improve accuracy | `GPT_CONTEXT` | - |
 | `glossary` | Path to a curated JSON glossary file | `GLOSSARY_PATH` | - |
 | `glossary_dir` | Path to localization files directory for auto-extracting glossary | `GLOSSARY_DIR` | - |
+| `dry_run` | Preview translations and character counts without writing files | `TRANSLATE_DRY_RUN` | `false` |
 
 ### Provider-Specific API Keys
 
@@ -402,14 +406,46 @@ translate_gpt_release_notes(
 )
 ```
 
+## Dry Run
+
+Use `dry_run: true` to call the provider and preview what would be written — without touching any file on disk:
+
+```ruby
+lane :preview_translations do
+  translate_gpt_release_notes(
+    master_locale: 'en-US',
+    platform: 'ios',
+    dry_run: true
+  )
+end
+```
+
+Output looks like:
+
+```
+DRY RUN: no files will be written.
+  fr-FR: 142 chars
+  de-DE: 158 chars
+  ja-JP: 89 chars
+  es-ES: translation FAILED (would be skipped)
+```
+
+For Android, lines exceeding the 500-character limit are flagged:
+
+```
+  de-DE: 523 chars — EXCEEDS 500-char Android limit
+```
+
+No files are written and `last_successful_run.txt` is not updated, so the next real run will still translate.
+
 ## Important Notes
 
 ### Android 500 Character Limit
 
-Android has a limit of 500 characters for changelogs. The plugin handles this in two ways:
+Android has a hard limit of 500 characters for changelogs. The plugin enforces this in two layers:
 
-1. **AI Providers (OpenAI, Anthropic, Gemini)**: The character limit is included in the translation prompt, asking the AI to stay within the limit
-2. **DeepL**: Translations are truncated to 500 characters with a warning if they exceed the limit
+1. **Prompt constraint**: For AI providers, the limit is included near the top of the prompt (alongside core instructions) with explicit wording that the model must count carefully and shorten or summarize if needed. This positions it as a hard constraint rather than an afterthought.
+2. **Safety-net truncation**: All providers (including DeepL) truncate the result and log a warning if the model still exceeds 500 characters despite the prompt.
 
 If you frequently hit the limit, consider shortening your master locale changelog.
 
@@ -425,6 +461,8 @@ All AI translation APIs cost money. Consider these tips:
 - Google Gemini is generally the most cost-effective option
 - DeepL offers competitive pricing for European languages
 - The plugin skips translation if the source file hasn't changed (tracked via `last_successful_run.txt`)
+- If all translations fail, `last_successful_run.txt` is not updated — the next run will retry rather than skip
+- Locales where translation fails are left with their existing file content untouched
 
 ### Service Tiers (OpenAI)
 
@@ -465,9 +503,9 @@ export OPENAI_API_KEY='your-key-here'
 **Cause**: The translated text is longer than 500 characters.
 
 **Solutions**:
-1. Shorten your source changelog
-2. For DeepL, translations are automatically truncated
-3. For AI providers, the prompt includes the limit but compliance isn't guaranteed
+1. Shorten your source changelog — the most reliable fix
+2. All providers will truncate automatically if the limit is exceeded (with a warning), but this may cut mid-sentence
+3. For AI providers, the prompt strongly instructs the model to stay within the limit and shorten if needed
 
 ### API Timeout Errors
 

data/lib/fastlane/plugin/translate_gpt_release_notes/actions/translate_gpt_release_notes_action.rb

@@ -57,10 +57,22 @@ module Fastlane
           translations[locale] = helper.translate_text(master_texts, locale, params[:platform])
         end
 
-        update_translated_texts(base_directory, translated_texts, is_ios, params)
+        if params[:dry_run]
+          print_dry_run_preview(translated_texts, params)
+        else
+          update_translated_texts(base_directory, translated_texts, is_ios, params)
 
-        # Store the current time as the last run time
-        File.write(last_run_file, Time.now.to_i)
+          # Only mark the run successful if at least one translation actually succeeded;
+          # otherwise a transient failure would suppress the next run's retry.
+          any_success = translated_texts.any? do |locale, text|
+            locale != params[:master_locale] && !translation_empty?(text)
+          end
+          if any_success
+            File.write(last_run_file, Time.now.to_i)
+          else
+            UI.error("No translations succeeded; not updating #{last_run_file} so the next run will retry.")
+          end
+        end
       end
 
       def self.list_locales(base_directory)
@@ -93,17 +105,47 @@ module Fastlane
         Dir[File.join(directory, '*.txt')].max_by { |f| File.basename(f, '.txt').to_i }.split('/').last
       end      
 
+      def self.translation_empty?(text)
+        text.nil? || text.to_s.strip.empty?
+      end
+
+      def self.print_dry_run_preview(translated_texts, params)
+        android_limit = 500 # Google Play hard limit; see BaseProvider::ANDROID_CHAR_LIMIT
+        UI.important('DRY RUN: no files will be written.')
+        translated_texts.each do |locale, text|
+          next if locale == params[:master_locale]
+
+          print_locale_preview(locale, text, android_limit, params[:platform])
+        end
+      end
+
+      def self.print_locale_preview(locale, text, android_limit, platform)
+        if text.nil? || text.to_s.strip.empty?
+          UI.warning("  #{locale}: translation FAILED (would be skipped)")
+          return
+        end
+        length = text.length
+        over = platform == 'android' && length > android_limit
+        suffix = over ? " — EXCEEDS #{android_limit}-char Android limit" : ''
+        UI.message("  #{locale}: #{length} chars#{suffix}")
+      end
+
       def self.update_translated_texts(base_directory, translated_texts, is_ios, params)
         translated_texts.each do |locale, text|
           next if locale == params[:master_locale]  # Skip master locale
-      
+
+          if translation_empty?(text)
+            UI.warning("Skipping #{locale}: translation failed or returned empty; existing file left unchanged.")
+            next
+          end
+
           target_path = is_ios ? File.join(base_directory, locale) : File.join(base_directory, locale, 'changelogs')
-      
+
           # Ensure target path exists or create it
           FileUtils.mkdir_p(target_path) unless Dir.exist?(target_path)
-      
+
           filename = is_ios ? 'release_notes.txt' : highest_numbered_file(File.join(base_directory, params[:master_locale], 'changelogs'))
-      
+
           # Write the translated text to the file
           File.write(File.join(target_path, filename), text)
         end
@@ -249,6 +291,14 @@ module Fastlane
               next if value.nil? || value.to_s.strip.empty?
               UI.user_error!("Glossary directory not found: #{value}") unless Dir.exist?(value)
             end
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :dry_run,
+            env_name: 'TRANSLATE_DRY_RUN',
+            description: 'Preview translations without writing files',
+            type: Boolean,
+            optional: true,
+            default_value: false
           )
         ]
       end

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

@@ -82,22 +82,13 @@ module Fastlane
         # @param glossary_terms [Hash] Optional glossary { source_term => target_translation }
         # @return [String, nil] Translated text or nil on error
         def translate(text, source_locale, target_locale, glossary_terms: {})
-          # Build prompt using inherited method (includes instructions, glossary, and text)
-          prompt = build_prompt(text, source_locale, target_locale, glossary_terms: glossary_terms)
-
-          # Add Android limitations if needed (appended after the text)
-          prompt += "\n\n" + android_limitation_instruction 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:"
+          system_instruction = build_system_instruction(
+            source_locale, target_locale,
+            glossary_terms: glossary_terms,
+            platform: @params[:platform]
           )
-
-          # Extract text from response
-          extract_text_from_response(response)
+          response = @client.messages.create(build_create_params(system_instruction, text))
+          enforce_android_limit(extract_text_from_response(response))
         rescue StandardError => e
           UI.error "Anthropic provider error: #{e.message}"
           nil
@@ -105,14 +96,22 @@ module Fastlane
 
         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 build_create_params(system_instruction, text)
+          {
+            model: @params[:model_name] || DEFAULT_MODEL,
+            max_tokens: (@params[:max_tokens] || DEFAULT_MAX_TOKENS).to_i,
+            temperature: (@params[:temperature] || DEFAULT_TEMPERATURE).to_f,
+            system_: system_instruction,
+            messages: [{ role: 'user', content: text }]
+          }
+        end
+
         def extract_text_from_response(response)
-          return nil if response.nil?
+          content = response&.content
+          return nil if content.to_a.empty?
 
-          response['completion']&.strip
+          text = content.filter_map { |b| b.text if b.type == :text }.join.strip
+          text.empty? ? nil : text
         end
       end
     end

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

@@ -92,13 +92,19 @@ module Fastlane
         # @param target_locale [String] Target language code
         # @param glossary_terms [Hash] Optional glossary { source_term => target_translation }
         # @return [String] The formatted prompt
-        def build_prompt(text, source_locale, target_locale, glossary_terms: {})
+        def build_prompt(text, source_locale, target_locale, glossary_terms: {}, platform: nil)
           prompt_parts = []
 
           # Instructions first: role, task, and output format
           prompt_parts << "Translate the following release notes from #{source_locale} to #{target_locale}."
           prompt_parts << "Respond with ONLY the translated text. Preserve the original formatting, line breaks, and bullet points."
 
+          # Android character limit is a hard constraint — include it with core instructions
+          if platform == 'android'
+            prompt_parts << ""
+            prompt_parts << android_limitation_instruction
+          end
+
           # Add context if provided
           if @params[:context]
             prompt_parts << ""
@@ -108,7 +114,7 @@ module Fastlane
           # Add glossary terms before the text so the model reads them first
           unless glossary_terms.nil? || glossary_terms.empty?
             prompt_parts << ""
-            prompt_parts << "Use the following glossary for consistent terminology. Apply these exact translations for the specified terms:"
+            prompt_parts << "Use the following glossary for consistent terminology. These are reference translations — apply appropriate grammatical forms (declension, conjugation, agreement) as needed for natural-sounding language in the target language. Do not copy verbatim if grammar requires a different form:"
             glossary_terms.each do |source_term, target_term|
               prompt_parts << "- \"#{source_term}\" -> \"#{target_term}\""
             end
@@ -130,12 +136,18 @@ module Fastlane
         # @param target_locale [String] Target language code
         # @param glossary_terms [Hash] Optional glossary { source_term => target_translation }
         # @return [String] The system instruction
-        def build_system_instruction(source_locale, target_locale, glossary_terms: {})
+        def build_system_instruction(source_locale, target_locale, glossary_terms: {}, platform: nil)
           parts = []
 
           parts << "Translate the following release notes from #{source_locale} to #{target_locale}."
           parts << "Respond with ONLY the translated text. Preserve the original formatting, line breaks, and bullet points."
 
+          # Android character limit is a hard constraint — include it with core instructions
+          if platform == 'android'
+            parts << ""
+            parts << android_limitation_instruction
+          end
+
           if @params[:context]
             parts << ""
             parts << "Context: #{@params[:context]}"
@@ -143,7 +155,7 @@ module Fastlane
 
           unless glossary_terms.nil? || glossary_terms.empty?
             parts << ""
-            parts << "Use the following glossary for consistent terminology. Apply these exact translations for the specified terms:"
+            parts << "Use the following glossary for consistent terminology. These are reference translations — apply appropriate grammatical forms (declension, conjugation, agreement) as needed for natural-sounding language in the target language. Do not copy verbatim if grammar requires a different form:"
             glossary_terms.each do |source_term, target_term|
               parts << "- \"#{source_term}\" -> \"#{target_term}\""
             end
@@ -157,17 +169,21 @@ module Fastlane
         #
         # @return [String] The Android limitation instruction
         def android_limitation_instruction
-          "IMPORTANT: The translated text must not exceed #{ANDROID_CHAR_LIMIT} characters " \
-          "(Google Play Store release notes limit). Provide a concise translation."
+          "CRITICAL: Google Play Store enforces a hard #{ANDROID_CHAR_LIMIT}-character limit for release notes. " \
+          "Your translation MUST be #{ANDROID_CHAR_LIMIT} characters or fewer. " \
+          "Count carefully and shorten or summarize if needed to stay within this limit."
         end
 
-        # Adds Android character limit constraint to the prompt.
-        # Google Play has a 500 character limit for release notes.
+        # Truncates the translated text to the Android character limit if exceeded.
+        # Logs a warning when truncation occurs.
         #
-        # @param prompt [String] The existing prompt to append to
-        # @return [String] The prompt with limitation instruction appended
-        def apply_android_limitations(prompt)
-          prompt + android_limitation_instruction
+        # @param text [String, nil] The translated text
+        # @return [String, nil] The text, truncated to ANDROID_CHAR_LIMIT if necessary
+        def enforce_android_limit(text)
+          return text unless @params[:platform] == 'android' && text && text.length > ANDROID_CHAR_LIMIT
+
+          UI.warning("Translation exceeds #{ANDROID_CHAR_LIMIT} characters (#{text.length}), truncating...")
+          text[0...ANDROID_CHAR_LIMIT]
         end
 
         # Adds a configuration error to the errors list.

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

@@ -92,10 +92,8 @@ module Fastlane
         # @param glossary_terms [Hash] Optional glossary { source_term => target_translation }
         # @return [String, nil] Translated text or nil on error
         def translate(text, source_locale, target_locale, glossary_terms: {})
-          # 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)
+          source_lang = normalize_source_locale(source_locale)
+          target_lang = normalize_target_locale(target_locale)
 
           # Build options hash
           options = {}
@@ -118,15 +116,7 @@ module Fastlane
           # 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
+          enforce_android_limit(result.text)
         rescue DeepL::Exceptions::RequestError => e
           UI.error "DeepL API error: #{e.message}"
           nil
@@ -137,14 +127,26 @@ module Fastlane
 
         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
+        # Normalizes a locale for use as the DeepL SOURCE language.
+        # DeepL source accepts only the bare 2-letter ISO 639-1 code.
+        # 'en-US' -> 'EN', 'de-DE' -> 'DE'.
+        def normalize_source_locale(locale)
+          locale.to_s.split(/[-_]/).first.to_s.upcase
+        end
+
+        # Normalizes a locale for use as the DeepL TARGET language.
+        # DeepL requires a region for English ('EN-US'/'EN-GB') and Portuguese
+        # ('PT-PT'/'PT-BR'); bare 'EN'/'PT' are deprecated targets and rejected.
+        # All other targets use the bare 2-letter code.
+        def normalize_target_locale(locale)
+          parts = locale.to_s.split(/[-_]/)
+          lang = parts[0].to_s.downcase
+          region = parts[1].to_s.upcase
+          case lang
+          when 'en' then region == 'GB' ? 'EN-GB' : 'EN-US'
+          when 'pt' then region == 'BR' ? 'PT-BR' : 'PT-PT'
+          else lang.upcase
+          end
         end
       end
     end

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

@@ -57,7 +57,7 @@ module Fastlane
         # @param params [Hash] Configuration parameters for the provider
         def initialize(params)
           super
-          @api_key = params[:api_token]
+          @api_key = credential(:api_token)
           @model = @params[:model_name] || DEFAULT_MODEL
           @temperature = (@params[:temperature] || DEFAULT_TEMPERATURE).to_f
           @timeout = (@params[:request_timeout] || DEFAULT_TIMEOUT).to_i
@@ -80,16 +80,17 @@ module Fastlane
         # @return [String, nil] Translated text or nil on error
         def translate(text, source_locale, target_locale, glossary_terms: {})
           # Build prompt using inherited method (includes instructions, glossary, and text)
-          prompt = build_prompt(text, source_locale, target_locale, glossary_terms: glossary_terms)
-
-          # Add Android limitations if needed (appended after the text)
-          prompt += "\n\n" + android_limitation_instruction if @params[:platform] == 'android'
+          prompt = build_prompt(
+            text, source_locale, target_locale,
+            glossary_terms: glossary_terms,
+            platform: @params[:platform]
+          )
 
           # Make API call
           result = make_api_request(prompt)
 
           # Extract text from response
-          extract_text_from_response(result)
+          enforce_android_limit(extract_text_from_response(result))
         rescue StandardError => e
           UI.error "Gemini provider error: #{e.message}"
           nil

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

@@ -82,14 +82,13 @@ module Fastlane
         # @return [String, nil] Translated text or nil on error
         def translate(text, source_locale, target_locale, glossary_terms: {})
           # Build system instruction and user content separately for better results
-          system_instruction = build_system_instruction(source_locale, target_locale, glossary_terms: glossary_terms)
+          system_instruction = build_system_instruction(
+            source_locale, target_locale,
+            glossary_terms: glossary_terms,
+            platform: @params[:platform]
+          )
           user_content = text
 
-          # Add Android limitations to system instruction if needed
-          if @params[:platform] == 'android'
-            system_instruction += "\n\n" + android_limitation_instruction
-          end
-
           # Build parameters hash with separate system and user messages
           parameters = {
             model: @params[:model_name] || DEFAULT_MODEL,
@@ -112,7 +111,7 @@ module Fastlane
             UI.error "OpenAI translation error: #{error}"
             nil
           else
-            response.dig('choices', 0, 'message', 'content')&.strip
+            enforce_android_limit(response.dig('choices', 0, 'message', 'content')&.strip)
           end
         rescue StandardError => e
           UI.error "OpenAI provider error: #{e.message}"

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

@@ -44,51 +44,6 @@ module Fastlane
         @provider.translate(text, source_locale, target_locale, glossary_terms: glossary_terms)
       end
 
-      # Sleep for a specified number of seconds, displaying a progress bar
-      def wait(seconds = @params[:request_timeout])
-        sleep_time = 0
-        while sleep_time < seconds
-          percent_complete = (sleep_time.to_f / seconds.to_f) * 100.0
-          progress_bar_width = 20
-          completed_width = (progress_bar_width * percent_complete / 100.0).round
-          remaining_width = progress_bar_width - completed_width
-          print "\rTimeout ["
-          print Colorizer::code(:green)
-          print "=" * completed_width
-          print " " * remaining_width
-          print Colorizer::code(:reset)
-          print "]"
-          print " %.2f%%" % percent_complete
-          $stdout.flush
-          sleep(1)
-          sleep_time += 1
-        end
-        print "\r"
-        $stdout.flush
-      end
-    end
-
-    # Helper class for bash colors
-    class Colorizer
-      COLORS = {
-        black:   30,
-        red:     31,
-        green:   32,
-        yellow:  33,
-        blue:    34,
-        magenta: 35,
-        cyan:    36,
-        white:   37,
-        reset:   0,
-      }
-
-      def self.colorize(text, color)
-        color_code = COLORS[color.to_sym]
-        "\e[#{color_code}m#{text}\e[0m"
-      end
-      def self.code(color)
-        "\e[#{COLORS[color.to_sym]}m"
-      end
     end
   end
 end

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

@@ -1,5 +1,5 @@
 module Fastlane
   module TranslateGptReleaseNotes
-    VERSION = "0.3.1"
+    VERSION = "0.4.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.3.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Anton Karliner
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-03-12 00:00:00.000000000 Z
+date: 2026-06-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruby-openai
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.7'
+        version: '8.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.7'
+        version: '8.0'
 - !ruby/object:Gem::Dependency
   name: loco_strings
   requirement: !ruby/object:Gem::Requirement