mistral_translator 0.1.0 → 0.2.1

data/lib/mistral_translator/security.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+# Module de sécurité optionnel - chargé seulement si nécessaire
+module MistralTranslator
+  module Security
+    # Validation basique des entrées (version légère)
+    module BasicValidator
+      MAX_TEXT_LENGTH = 50_000
+      MIN_TEXT_LENGTH = 1
+
+      class << self
+        def validate_text!(text)
+          # Accepter nil et texte vide - ce sont des cas d'usage légitimes
+          return "" if text.nil? || text.empty?
+
+          text_str = text.to_s
+          return "" if text_str.strip.empty?
+
+          raise ArgumentError, "Text too long (max #{MAX_TEXT_LENGTH} chars)" if text_str.length > MAX_TEXT_LENGTH
+
+          text_str
+        end
+
+        def validate_batch!(texts)
+          raise ArgumentError, "Batch cannot be nil" if texts.nil?
+          raise ArgumentError, "Batch must be an array" unless texts.is_a?(Array)
+          raise ArgumentError, "Batch cannot be empty" if texts.empty?
+          raise ArgumentError, "Batch too large (max 20 items)" if texts.size > 20
+
+          texts.each { |text| validate_text!(text) }
+          texts
+        end
+      end
+    end
+
+    # Rate limiter basique (version légère)
+    class BasicRateLimiter
+      def initialize(max_requests: 50, window_seconds: 60)
+        @max_requests = max_requests
+        @window_seconds = window_seconds
+        @requests = []
+        @mutex = Mutex.new
+      end
+
+      def wait_and_record!
+        @mutex.synchronize do
+          cleanup_old_requests
+          if @requests.size >= @max_requests
+            wait_time = calculate_wait_time
+            sleep(wait_time) if wait_time.positive?
+          end
+          @requests << Time.now
+        end
+      end
+
+      private
+
+      def cleanup_old_requests
+        cutoff_time = Time.now - @window_seconds
+        @requests.reject! { |request_time| request_time < cutoff_time }
+      end
+
+      def calculate_wait_time
+        return 0 if @requests.empty?
+
+        oldest_request = @requests.min
+        time_until_oldest_expires = (oldest_request + @window_seconds) - Time.now
+        [time_until_oldest_expires, 0].max
+      end
+    end
+  end
+end

data/lib/mistral_translator/summarizer.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "logger"
+require_relative "security"
 
 module MistralTranslator
   class Summarizer
@@ -16,12 +17,18 @@ module MistralTranslator
     # Résumé simple dans une langue donnée
     def summarize(text, language: "fr", max_words: DEFAULT_MAX_WORDS)
       log_debug("Starting summarize - language: #{language}, max_words: #{max_words}")
-      validate_summarize_inputs!(text, language, max_words)
+
+      # Validation basique des entrées
+      validated_text = Security::BasicValidator.validate_text!(text)
+      raise ArgumentError, "Max words must be positive" unless max_words.is_a?(Integer) && max_words.positive?
+
+      # Si le texte est vide, retourner directement une chaîne vide
+      return "" if validated_text.empty?
 
       target_locale = LocaleHelper.validate_locale!(language)
       log_debug("Target locale validated: #{target_locale}")
 
-      cleaned_text = clean_document_content(text)
+      cleaned_text = clean_document_content(validated_text)
       log_debug("Text cleaned, length: #{cleaned_text&.length}")
 
       result = summarize_with_retry(cleaned_text, target_locale, max_words)
@@ -50,6 +57,21 @@ module MistralTranslator
       raw_response = @client.complete(prompt)
 
       result = ResponseParser.parse_summary_response(raw_response)
+      if result.nil? || result[:summary].nil? || result[:summary].empty?
+        # Fallback: si le JSON est manquant ou vide, on tente un résumé simple puis traduction
+        log_error(
+          "Empty or invalid summary response for summarize_and_translate. Using fallback. " \
+          "Raw length: #{raw_response.to_s.length}"
+        )
+        summary_only = summarize(cleaned_text, language: source_locale, max_words: max_words)
+        begin
+          return MistralTranslator.translate(summary_only, from: source_locale, to: target_locale)
+        rescue EmptyTranslationError, InvalidResponseError, RateLimitError => e
+          log_error("Translation fallback failed: #{e.class.name} - returning source summary")
+          return summary_only
+        end
+      end
+
       result[:summary]
     end
 
@@ -95,14 +117,20 @@ module MistralTranslator
 
     private
 
+    # rubocop:disable Metrics/PerceivedComplexity
     def summarize_with_retry(text, target_locale, max_words, attempt = 0)
       log_debug("Summarize attempt #{attempt + 1} for #{target_locale}")
 
       prompt = PromptBuilder.summary_prompt(text, max_words, target_locale)
       raw_response = @client.complete(prompt)
+      response_len = raw_response&.length || 0
 
       result = ResponseParser.parse_summary_response(raw_response)
       if result.nil? || result[:summary].nil? || result[:summary].empty?
+        log_error(
+          "Empty or invalid summary response for #{target_locale}. " \
+          "Raw response length: #{response_len}"
+        )
         raise EmptyTranslationError, "Empty summary received"
       end
 
@@ -123,6 +151,7 @@ module MistralTranslator
       sleep(DEFAULT_RETRY_DELAY)
       retry
     end
+    # rubocop:enable Metrics/PerceivedComplexity
 
     def build_summary_translation_prompt(text, source_locale, target_locale, max_words)
       source_name = LocaleHelper.locale_to_language(source_locale)
@@ -222,5 +251,15 @@ module MistralTranslator
 
       puts "[MistralTranslator] #{message}"
     end
+
+    def log_error(message)
+      # Utiliser le logger centralisé
+      Logger.warn(message, sensitive: false)
+
+      # Pour les tests, optionnellement afficher en stdout
+      return unless ENV["MISTRAL_TRANSLATOR_TEST_OUTPUT"] == "true"
+
+      puts "[MistralTranslator] ERROR: #{message}"
+    end
   end
 end

data/lib/mistral_translator/translator.rb

@@ -1,9 +1,19 @@
 # frozen_string_literal: true
 
 require_relative "logger"
+require_relative "translator_helpers"
+require_relative "security"
 
 module MistralTranslator
   class Translator
+    include TranslatorHelpers::InputValidator
+    include TranslatorHelpers::RetryHandler
+    include TranslatorHelpers::LoggingHelper
+    include TranslatorHelpers::PromptHandler
+    include TranslatorHelpers::AnalysisHelper
+    include TranslatorHelpers::RequestHelper
+    include TranslatorHelpers::MultiTargetHelper
+
     DEFAULT_RETRY_COUNT = 3
     DEFAULT_RETRY_DELAY = 2
 
@@ -12,50 +22,77 @@ module MistralTranslator
     end
 
     # Traduction simple d'un texte vers une langue
-    def translate(text, from:, to:)
-      validate_inputs!(text, from, to)
+    def translate(text, from:, to:, **options)
+      # Validation basique des entrées
+      validated_text = Security::BasicValidator.validate_text!(text)
+
+      # Si le texte est vide, retourner directement une chaîne vide
+      return "" if validated_text.empty?
 
       source_locale = LocaleHelper.validate_locale!(from)
       target_locale = LocaleHelper.validate_locale!(to)
 
-      translate_with_retry(text, source_locale, target_locale)
+      # Si même langue source et cible, retourner le texte original
+      return validated_text if source_locale == target_locale
+
+      translate_with_retry(validated_text, source_locale, target_locale,
+                           context: options[:context],
+                           glossary: options[:glossary],
+                           preserve_html: options.fetch(:preserve_html, false))
+    end
+
+    # Traduction avec score de confiance (expérimental)
+    def translate_with_confidence(text, from:, to:, context: nil, glossary: nil)
+      result = begin
+        translate(text, from: from, to: to, context: context, glossary: glossary)
+      rescue EmptyTranslationError
+        ""
+      end
+
+      # Score de confiance basique basé sur la longueur et la cohérence
+      confidence = calculate_confidence_score(text, result, from, to)
+
+      {
+        translation: result,
+        confidence: confidence,
+        metadata: {
+          source_locale: from,
+          target_locale: to,
+          original_length: text.length,
+          translated_length: result.length
+        }
+      }
     end
 
-    # Traduction vers plusieurs langues
-    def translate_to_multiple(text, from:, to:)
+    # Traduction vers plusieurs langues avec support du batch
+    def translate_to_multiple(text, from:, to:, **options)
       validate_translation_inputs!(text, from, to)
 
       source_locale = LocaleHelper.validate_locale!(from)
       target_locales = Array(to).map { |locale| LocaleHelper.validate_locale!(locale) }
 
-      results = {}
-
-      target_locales.each_with_index do |target_locale, index|
-        # Délai entre les requêtes, mais pas avant la première
-        sleep(DEFAULT_RETRY_DELAY) if index.positive?
-        results[target_locale] = translate_with_retry(text, source_locale, target_locale)
+      if options[:use_batch] && target_locales.size > 3
+        translate_to_multiple_batch(text, source_locale, target_locales, context: options[:context],
+                                                                         glossary: options[:glossary])
+      else
+        translate_to_multiple_sequential(text, source_locale, target_locales, context: options[:context],
+                                                                              glossary: options[:glossary])
       end
-
-      results
     end
 
     # Traduction en lot (plusieurs textes vers une langue)
-    def translate_batch(texts, from:, to:)
-      validate_batch_inputs!(texts, from, to)
-
+    def translate_batch(texts, from:, to:, context: nil, glossary: nil)
+      validated_texts = Security::BasicValidator.validate_batch!(texts)
       source_locale = LocaleHelper.validate_locale!(from)
       target_locale = LocaleHelper.validate_locale!(to)
 
-      # Pour des lots importants, on peut les découper
-      if texts.length > 10
-        translate_large_batch(texts, source_locale, target_locale)
-      else
-        translate_small_batch(texts, source_locale, target_locale)
-      end
+      return handle_same_language_batch(validated_texts) if source_locale == target_locale
+
+      process_mixed_batch(validated_texts, source_locale, target_locale, context, glossary)
     end
 
-    # Auto-détection de la langue source (utilise l'API pour détecter)
-    def translate_auto(text, to:)
+    # Auto-détection de la langue source avec support du contexte
+    def translate_auto(text, to:, context: nil, glossary: nil)
       target_locale = LocaleHelper.validate_locale!(to)
 
       # Premier appel pour détecter la langue
@@ -63,115 +100,154 @@ module MistralTranslator
       detection_response = @client.complete(detection_prompt)
       detected_language = parse_language_detection(detection_response)
 
-      # Puis traduction normale
-      translate(text, from: detected_language, to: target_locale)
+      # Vérifier que la langue détectée est différente de la cible
+      if detected_language == target_locale
+        # Si même langue, retourner le texte original
+        return text
+      end
+
+      # Puis traduction normale avec contexte
+      translate(text, from: detected_language, to: target_locale, context: context, glossary: glossary)
     end
 
     private
 
-    def translate_with_retry(text, source_locale, target_locale, attempt = 0)
-      prompt = PromptBuilder.translation_prompt(text, source_locale, target_locale)
-      raw_response = @client.complete(prompt)
+    # Ces méthodes sont héritées via MultiTargetHelper
+
+    def handle_same_language_batch(validated_texts)
+      validated_texts.each_with_index.to_h { |text, index| [index, text] }
+    end
 
-      result = ResponseParser.parse_translation_response(raw_response)
-      raise EmptyTranslationError if result.nil? || result[:translated].nil?
+    def process_mixed_batch(validated_texts, source_locale, target_locale, context, glossary)
+      results = {}
+      batch_config = { source_locale: source_locale, target_locale: target_locale, context: context,
+                       glossary: glossary }
+      requests = build_batch_requests(validated_texts, batch_config, results)
 
-      result[:translated]
-    rescue EmptyTranslationError, InvalidResponseError => e
-      raise e unless attempt < DEFAULT_RETRY_COUNT
+      process_batch_requests(requests, results) if requests.any?
 
-      wait_time = DEFAULT_RETRY_DELAY * (2**attempt) # Backoff exponentiel
-      log_retry(e, attempt + 1, wait_time)
-      sleep(wait_time)
-      translate_with_retry(text, source_locale, target_locale, attempt + 1)
-    rescue RateLimitError => e
-      log_rate_limit_hit(source_locale, target_locale)
-      sleep(DEFAULT_RETRY_DELAY)
-      retry
+      results
     end
 
-    def translate_small_batch(texts, source_locale, target_locale)
-      prompt = PromptBuilder.bulk_translation_prompt(texts, source_locale, target_locale)
-      raw_response = @client.complete(prompt)
+    def build_batch_requests(validated_texts, batch_config, results)
+      requests = []
+
+      validated_texts.each_with_index do |text, index|
+        if text.nil? || text.empty?
+          results[index] = ""
+        else
+          requests << create_batch_request(text, batch_config, index)
+        end
+      end
 
-      results = ResponseParser.parse_bulk_translation_response(raw_response)
+      requests
+    end
+
+    def create_batch_request(text, batch_config, index)
+      {
+        prompt: build_translation_prompt(text, batch_config[:source_locale], batch_config[:target_locale],
+                                         context: batch_config[:context], glossary: batch_config[:glossary]),
+        from: batch_config[:source_locale],
+        to: batch_config[:target_locale],
+        index: index,
+        original_text: text
+      }
+    end
 
-      # Retourner un hash indexé par l'ordre original
-      results.each_with_object({}) do |result, hash|
-        original_index = result[:index] - 1 # L'API retourne 1-indexed
-        hash[original_index] = result[:translated]
+    def process_batch_requests(requests, results)
+      batch_results = @client.translate_batch(requests, batch_size: 10)
+      batch_results.each do |result|
+        process_batch_result(result, results)
       end
     end
 
-    def translate_large_batch(texts, source_locale, target_locale)
-      results = {}
+    def process_batch_result(result, results)
+      index = result[:original_request][:index]
+      results[index] = (parse_batch_response(result[:result]) if result[:success])
+    end
 
-      texts.each_slice(10).with_index do |batch, batch_index|
-        sleep(DEFAULT_RETRY_DELAY) if batch_index.positive? # Délai entre les batches
+    def parse_batch_response(response)
+      parsed_result = ResponseParser.parse_translation_response(response)
+      parsed_result[:translated] if parsed_result
+    rescue EmptyTranslationError
+      ""
+    end
 
-        batch_results = translate_small_batch(batch, source_locale, target_locale)
+    def translate_with_retry(text, source_locale, target_locale, attempt = 0, **options)
+      prompt = build_prompt_for_retry(text, source_locale, target_locale, **options)
+      request_context = build_request_context(source_locale, target_locale, attempt)
 
-        # Ajuster les index pour le batch
-        batch_results.each do |local_index, translation|
-          global_index = (batch_index * 10) + local_index
-          results[global_index] = translation
-        end
+      raw_response = perform_client_request(prompt, request_context)
+      extract_translated_text!(raw_response)
+    rescue EmptyTranslationError, InvalidResponseError => e
+      handle_retryable_error!(e, attempt) do
+        translate_with_retry(text, source_locale, target_locale, attempt + 1, **options)
       end
-
-      results
+    rescue RateLimitError
+      log_rate_limit_hit(source_locale, target_locale)
+      sleep(DEFAULT_RETRY_DELAY)
+      retry
     end
 
-    def build_language_detection_prompt(text)
-      PromptBuilder.language_detection_prompt(text)
-    end
+    # Ces méthodes sont héritées via RequestHelper
 
-    def parse_language_detection(response)
-      json_content = response.match(/\{.*\}/m)&.[](0)
-      return "en" unless json_content # Défaut en anglais si détection échoue
+    # Log via LoggingHelper
 
-      data = JSON.parse(json_content)
-      detected = data["detected_language"]
+    def build_translation_prompt(text, source_locale, target_locale, **options)
+      base_prompt = PromptBuilder.translation_prompt(text, source_locale, target_locale,
+                                                     preserve_html: options.fetch(:preserve_html, false))
 
-      LocaleHelper.locale_supported?(detected) ? detected : "en"
-    rescue JSON::ParserError
-      "en" # Défaut en anglais si parsing échoue
+      # Enrichir le prompt avec le contexte et le glossaire
+      context_present = options[:context] && !options[:context].to_s.strip.empty?
+      glossary_present =
+        (options[:glossary].is_a?(Hash) && options[:glossary].any?) ||
+        (options[:glossary].is_a?(String) && !options[:glossary].to_s.strip.empty?)
+      if context_present || glossary_present
+        enrich_prompt_with_context(base_prompt, options[:context], options[:glossary])
+      else
+        base_prompt
+      end
     end
 
-    def validate_inputs!(text, from, to)
-      raise ArgumentError, "Text cannot be nil or empty" if text.nil? || text.empty?
-      raise ArgumentError, "Source language cannot be nil" if from.nil?
-      raise ArgumentError, "Target language cannot be nil" if to.nil?
-      raise ArgumentError, "Source and target languages cannot be the same" if from == to
+    def enrich_prompt_with_context(base_prompt, context, glossary)
+      enriched_parts = []
+      context_part = build_context_enrichment(context)
+      glossary_part = build_glossary_enrichment(glossary)
+      enriched_parts << context_part if context_part
+      enriched_parts << glossary_part if glossary_part
+
+      return base_prompt if enriched_parts.empty?
+
+      enriched_context = enriched_parts.join("\n")
+      base_prompt.sub("RÈGLES :", "#{enriched_context}\n\nRÈGLES :")
     end
 
-    def validate_translation_inputs!(text, from, to)
-      # Convertir to en array pour la validation
-      target_languages = Array(to)
-      raise ArgumentError, "Target languages cannot be empty" if target_languages.empty?
+    def build_context_enrichment(context)
+      return nil if context.nil? || context.to_s.strip.empty?
 
-      validate_inputs!(text, from, target_languages.first)
+      "CONTEXTE : #{context}"
     end
 
-    def validate_batch_inputs!(texts, from, to)
-      raise ArgumentError, "Texts array cannot be nil or empty" if texts.nil? || texts.empty?
-      raise ArgumentError, "Source language cannot be nil" if from.nil?
-      raise ArgumentError, "Target language cannot be nil" if to.nil?
+    def build_glossary_enrichment(glossary)
+      return nil if glossary.nil?
+      return build_glossary_hash(glossary) if glossary.is_a?(Hash)
+      return build_glossary_string(glossary) if glossary.is_a?(String)
 
-      texts.each_with_index do |text, index|
-        raise ArgumentError, "Text at index #{index} cannot be nil or empty" if text.nil? || text.empty?
-      end
+      nil
     end
 
-    def log_retry(error, attempt, wait_time)
-      message = "#{error.class.name}: #{error.message}. Retry #{attempt}/#{DEFAULT_RETRY_COUNT} in #{wait_time}s"
-      # Log une seule fois par type d'erreur pour éviter le spam
-      Logger.warn_once(message, key: "retry_#{error.class.name}", sensitive: false, ttl: 120)
+    def build_glossary_hash(glossary_hash)
+      return nil if glossary_hash.empty?
+
+      glossary_text = glossary_hash.map { |key, value| "#{key} → #{value}" }.join(", ")
+      "GLOSSAIRE (à respecter strictement) : #{glossary_text}"
     end
 
-    def log_rate_limit_hit(source, target)
-      message = "Rate limit hit for translation #{source} -> #{target}, retrying..."
-      # Log une seule fois par paire de langues
-      Logger.warn_once(message, key: "rate_limit_#{source}_#{target}", sensitive: false, ttl: 300)
+    def build_glossary_string(glossary_string)
+      value = glossary_string.to_s.strip
+      return nil if value.empty?
+
+      "GLOSSAIRE : #{value}"
     end
   end
 end