mistral_translator 0.1.0

data/lib/mistral_translator/logger.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module MistralTranslator
+  module Logger
+    class << self
+      def info(message, sensitive: false)
+        log(:info, message, sensitive)
+      end
+
+      def warn(message, sensitive: false)
+        log(:warn, message, sensitive)
+      end
+
+      def debug(message, sensitive: false)
+        log(:debug, message, sensitive)
+      end
+
+      # Log seulement si pas déjà loggé récemment (évite la spam)
+      def warn_once(message, key: nil, sensitive: false, ttl: 300)
+        @warn_cache ||= {}
+        cache_key = key || message
+
+        return unless should_log_warning?(cache_key, ttl)
+
+        @warn_cache[cache_key] = Time.now
+        log(:warn, message, sensitive)
+      end
+
+      # Log de debug seulement si vraiment nécessaire
+      def debug_if_verbose(message, sensitive: false)
+        return unless ENV["MISTRAL_TRANSLATOR_VERBOSE"] == "true"
+
+        log(:debug, message, sensitive)
+      end
+
+      private
+
+      def log(level, message, sensitive)
+        # En mode Rails, utiliser le logger Rails
+        if defined?(Rails) && Rails.respond_to?(:logger)
+          Rails.logger.public_send(level, "[MistralTranslator] #{message}")
+        # Sinon, utiliser puts seulement si pas sensible et debug activé
+        elsif !sensitive && ENV["MISTRAL_TRANSLATOR_DEBUG"] == "true"
+          puts "[MistralTranslator] #{message}"
+        end
+      end
+
+      def should_log_warning?(key, ttl)
+        return true unless @warn_cache[key]
+
+        Time.now - @warn_cache[key] > ttl
+      end
+    end
+  end
+end

data/lib/mistral_translator/prompt_builder.rb

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+require_relative "logger"
+
+module MistralTranslator
+  module PromptBuilder
+    class << self
+      def translation_prompt(text, source_language, target_language)
+        source_name = LocaleHelper.locale_to_language(source_language)
+        target_name = LocaleHelper.locale_to_language(target_language)
+
+        <<~PROMPT
+          Tu es un traducteur professionnel. Traduis le texte suivant de #{source_name} vers #{target_name}.
+
+          RÈGLES :
+          - Traduis fidèlement sans ajouter d'informations
+          - Conserve le style, ton et format original
+          - Réponds UNIQUEMENT en JSON valide
+
+          FORMAT OBLIGATOIRE :
+          {
+            "content": {
+              "source": "texte original",
+              "target": "texte traduit en #{target_name}"
+            },
+            "metadata": {
+              "source_language": "#{source_language}",
+              "target_language": "#{target_language}",
+              "operation": "translation"
+            }
+          }
+
+          TEXTE À TRADUIRE :
+          #{text}
+        PROMPT
+      end
+
+      def bulk_translation_prompt(texts, source_language, target_language)
+        source_name = LocaleHelper.locale_to_language(source_language)
+        target_name = LocaleHelper.locale_to_language(target_language)
+
+        <<~PROMPT
+          Tu es un traducteur professionnel. Traduis les textes suivants de #{source_name} vers #{target_name}.
+
+          RÈGLES :
+          - Traduis fidèlement chaque texte sans ajouter d'informations
+          - Conserve le style, ton et format originaux
+          - Réponds UNIQUEMENT en JSON valide
+
+          FORMAT OBLIGATOIRE :
+          {
+            "translations": [
+              {
+                "index": 1,
+                "source": "texte original 1",
+                "target": "texte traduit 1"
+              },
+              {
+                "index": 2,
+                "source": "texte original 2",
+                "target": "texte traduit 2"
+              }
+            ],
+            "metadata": {
+              "source_language": "#{source_language}",
+              "target_language": "#{target_language}",
+              "count": #{texts.length},
+              "operation": "bulk_translation"
+            }
+          }
+
+          TEXTES À TRADUIRE :
+          #{texts.map.with_index { |text, i| "#{i + 1}. #{text}" }.join("\n")}
+        PROMPT
+      end
+
+      def summary_prompt(text, max_words, target_language = "fr")
+        target_name = LocaleHelper.locale_to_language(target_language)
+
+        <<~PROMPT
+          Tu es un rédacteur professionnel. Résume le texte suivant en #{target_name}.
+
+          RÈGLES :
+          - Résume fidèlement sans ajouter d'informations
+          - Maximum #{max_words} mots
+          - Conserve les informations essentielles
+          - Réponds UNIQUEMENT en JSON valide
+
+          FORMAT OBLIGATOIRE :
+          {
+            "content": {
+              "source": "texte original",
+              "target": "résumé en #{target_name}"
+            },
+            "metadata": {
+              "source_language": "original",
+              "target_language": "#{target_language}",
+              "word_count": #{max_words},
+              "operation": "summarization"
+            }
+          }
+
+          TEXTE À RÉSUMER :
+          #{text}
+        PROMPT
+      end
+
+      def summary_and_translation_prompt(text, source_language, target_language, max_words)
+        source_name = LocaleHelper.locale_to_language(source_language)
+        target_name = LocaleHelper.locale_to_language(target_language)
+
+        <<~PROMPT
+          Tu es un rédacteur professionnel. Résume ET traduis le texte suivant de #{source_name} vers #{target_name}.
+
+          RÈGLES :
+          - Résume fidèlement sans ajouter d'informations
+          - Traduis le résumé en #{target_name}
+          - Maximum #{max_words} mots
+          - Réponds UNIQUEMENT en JSON valide
+
+          FORMAT OBLIGATOIRE :
+          {
+            "content": {
+              "source": "texte original",
+              "target": "résumé traduit en #{target_name}"
+            },
+            "metadata": {
+              "source_language": "#{source_language}",
+              "target_language": "#{target_language}",
+              "word_count": #{max_words},
+              "operation": "summarization_and_translation"
+            }
+          }
+
+          TEXTE À RÉSUMER ET TRADUIRE :
+          #{text}
+        PROMPT
+      end
+
+      def tiered_summary_prompt(text, target_language, short, medium, long)
+        target_name = LocaleHelper.locale_to_language(target_language)
+
+        <<~PROMPT
+          Tu es un rédacteur professionnel. Crée trois résumés du texte suivant en #{target_name}.
+
+          RÈGLES :
+          - Résume fidèlement sans ajouter d'informations
+          - Respecte strictement les longueurs demandées
+          - Réponds UNIQUEMENT en JSON valide
+
+          FORMAT OBLIGATOIRE :
+          {
+            "content": {
+              "source": "texte original",
+              "target": "résumés en #{target_name}"
+            },
+            "metadata": {
+              "source_language": "original",
+              "target_language": "#{target_language}",
+              "summaries": {
+                "short": #{short},
+                "medium": #{medium},
+                "long": #{long}
+              },
+              "operation": "tiered_summarization"
+            }
+          }
+
+          TEXTE À RÉSUMER :
+          #{text}
+        PROMPT
+      end
+
+      def language_detection_prompt(text)
+        <<~PROMPT
+          Tu es un expert en linguistique. Détecte la langue du texte suivant.
+
+          RÈGLES :
+          - Identifie la langue principale
+          - Utilise le code ISO 639-1 (ex: 'fr', 'en', 'es')
+          - Réponds UNIQUEMENT en JSON valide
+
+          FORMAT OBLIGATOIRE :
+          {
+            "content": {
+              "source": "texte analysé",
+              "target": "langue détectée"
+            },
+            "metadata": {
+              "detected_language": "code_iso",
+              "operation": "language_detection"
+            }
+          }
+
+          TEXTE À ANALYSER :
+          #{text}
+        PROMPT
+      end
+
+      private
+
+      def log_prompt_generation(prompt_type, source_locale, target_locale)
+        message = "Generated #{prompt_type} prompt for #{source_locale} -> #{target_locale}"
+        Logger.debug_if_verbose(message, sensitive: false)
+      end
+
+      def log_prompt_debug(_prompt)
+        return unless ENV["MISTRAL_TRANSLATOR_DEBUG"]
+
+        if defined?(Rails) && Rails.respond_to?(:logger)
+          Rails.logger.info message
+        elsif ENV["MISTRAL_TRANSLATOR_DEBUG"]
+          # Log de debug seulement si mode verbose activé
+          Logger.debug_if_verbose(message, sensitive: false)
+        end
+      end
+    end
+  end
+end

data/lib/mistral_translator/response_parser.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module MistralTranslator
+  class ResponseParser
+    class << self
+      def parse_translation_response(raw_content)
+        return nil if raw_content.nil? || raw_content.empty?
+
+        begin
+          # Extraire le JSON de la réponse (peut contenir du texte avant/après)
+          json_content = extract_json_from_content(raw_content)
+          return nil unless json_content
+
+          # Parser le JSON
+          translation_data = JSON.parse(json_content)
+
+          # Extraire le contenu traduit selon différents formats possibles
+          translated_text = extract_target_content(translation_data)
+
+          # Vérifier si la traduction est vide et lever l'erreur appropriée
+          if translated_text.nil? || translated_text.empty?
+            raise EmptyTranslationError, "Empty translation received from API"
+          end
+
+          {
+            original: extract_source_content(translation_data),
+            translated: translated_text,
+            metadata: translation_data["metadata"] || {}
+          }
+        rescue JSON::ParserError
+          raise InvalidResponseError, "Invalid JSON in response: #{raw_content}"
+        rescue EmptyTranslationError
+          raise # Re-raise EmptyTranslationError
+        rescue StandardError => e
+          raise InvalidResponseError, "Error processing response: #{e.message}"
+        end
+      end
+
+      def parse_summary_response(raw_content)
+        return nil if raw_content.nil? || raw_content.empty?
+
+        begin
+          json_content = extract_json_from_content(raw_content)
+          return nil unless json_content
+
+          summary_data = JSON.parse(json_content)
+          summary_text = extract_target_content(summary_data)
+
+          raise EmptyTranslationError, "Empty summary received" if summary_text.nil? || summary_text.empty?
+
+          {
+            original: extract_source_content(summary_data),
+            summary: summary_text,
+            metadata: summary_data["metadata"] || {}
+          }
+        rescue JSON::ParserError
+          raise InvalidResponseError, "Invalid JSON in summary response: #{raw_content}"
+        rescue EmptyTranslationError
+          raise # Re-raise EmptyTranslationError
+        rescue StandardError => e
+          raise InvalidResponseError, "Error processing summary response: #{e.message}"
+        end
+      end
+
+      def parse_bulk_translation_response(raw_content)
+        return [] if raw_content.nil? || raw_content.empty?
+
+        begin
+          json_content = extract_json_from_content(raw_content)
+          raise InvalidResponseError, "Invalid JSON in bulk response: #{raw_content}" unless json_content
+
+          bulk_data = JSON.parse(json_content)
+          translations = bulk_data["translations"]
+
+          raise InvalidResponseError, "No translations array in response" unless translations.is_a?(Array)
+
+          translations.map do |translation|
+            {
+              index: translation["index"],
+              original: translation["source"],
+              translated: translation["target"]
+            }
+          end
+        rescue JSON::ParserError
+          raise InvalidResponseError, "Invalid JSON in bulk response: #{raw_content}"
+        rescue StandardError => e
+          # Ne pas wrapper l'erreur "No translations array in response"
+          raise e if e.message == "No translations array in response"
+
+          raise InvalidResponseError, "Error processing bulk response: #{e.message}"
+        end
+      end
+
+      private
+
+      def extract_json_from_content(content)
+        # Chercher le JSON dans la réponse (peut être entouré de texte)
+        json_match = content.match(/\{.*\}/m)
+        json_match&.[](0)
+      end
+
+      def extract_target_content(data)
+        # Essayer différents chemins possibles pour le contenu traduit
+        [
+          data.dig("content", "target"),
+          data.dig("translation", "target"),
+          data["target"],
+          data.dig("content", "translated"),
+          data["translated"]
+        ].find { |item| item && !item.to_s.empty? }
+      end
+
+      def extract_source_content(data)
+        # Essayer différents chemins possibles pour le contenu source
+        [
+          data.dig("content", "source"),
+          data.dig("translation", "source"),
+          data["source"],
+          data.dig("content", "original"),
+          data["original"]
+        ].find { |item| item && !item.to_s.empty? }
+      end
+    end
+  end
+end

data/lib/mistral_translator/summarizer.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+require_relative "logger"
+
+module MistralTranslator
+  class Summarizer
+    DEFAULT_MAX_WORDS = 250
+    DEFAULT_RETRY_COUNT = 3
+    DEFAULT_RETRY_DELAY = 2
+
+    def initialize(client: nil)
+      @client = client || Client.new
+      log_debug("Summarizer initialized")
+    end
+
+    # 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)
+
+      target_locale = LocaleHelper.validate_locale!(language)
+      log_debug("Target locale validated: #{target_locale}")
+
+      cleaned_text = clean_document_content(text)
+      log_debug("Text cleaned, length: #{cleaned_text&.length}")
+
+      result = summarize_with_retry(cleaned_text, target_locale, max_words)
+      log_debug("Summary completed successfully")
+      result
+    end
+
+    # Résumé avec traduction simultanée
+    def summarize_and_translate(text, from:, to:, max_words: DEFAULT_MAX_WORDS)
+      log_debug("Starting summarize_and_translate - from: #{from}, to: #{to}")
+      validate_summarize_translate_inputs!(text, from, to, max_words)
+
+      source_locale = LocaleHelper.validate_locale!(from)
+      target_locale = LocaleHelper.validate_locale!(to)
+      cleaned_text = clean_document_content(text)
+
+      # Si même langue, juste résumer
+      if source_locale == target_locale
+        log_debug("Same language detected, using simple summarize")
+        return summarize(cleaned_text, language: target_locale, max_words: max_words)
+      end
+
+      # Sinon, créer un prompt qui fait les deux à la fois
+      log_debug("Different languages, using combined summarize+translate")
+      prompt = build_summary_translation_prompt(cleaned_text, source_locale, target_locale, max_words)
+      raw_response = @client.complete(prompt)
+
+      result = ResponseParser.parse_summary_response(raw_response)
+      result[:summary]
+    end
+
+    # Résumé en plusieurs langues
+    def summarize_to_multiple(text, languages:, max_words: DEFAULT_MAX_WORDS)
+      log_debug("Starting summarize_to_multiple - languages: #{languages}")
+      validate_multiple_summarize_inputs!(text, languages, max_words)
+
+      target_locales = Array(languages).map { |locale| LocaleHelper.validate_locale!(locale) }
+      cleaned_text = clean_document_content(text)
+      results = {}
+
+      target_locales.each_with_index do |target_locale, index|
+        log_debug("Processing language #{index + 1}/#{target_locales.length}: #{target_locale}")
+
+        # Ajouter un délai seulement entre les requêtes (pas avant la première)
+        if index.positive?
+          log_debug("Adding delay between requests: #{DEFAULT_RETRY_DELAY}s")
+          sleep(DEFAULT_RETRY_DELAY)
+        end
+
+        results[target_locale] = summarize_with_retry(cleaned_text, target_locale, max_words)
+      end
+
+      log_debug("Multiple summarization completed")
+      results
+    end
+
+    # Résumé par niveaux (court, moyen, long)
+    def summarize_tiered(text, language: "fr", short: 50, medium: 150, long: 300)
+      log_debug("Starting summarize_tiered - short: #{short}, medium: #{medium}, long: #{long}")
+      validate_tiered_inputs!(text, language, short, medium, long)
+
+      target_locale = LocaleHelper.validate_locale!(language)
+      cleaned_text = clean_document_content(text)
+
+      {
+        short: summarize_with_retry(cleaned_text, target_locale, short),
+        medium: summarize_with_retry(cleaned_text, target_locale, medium),
+        long: summarize_with_retry(cleaned_text, target_locale, long)
+      }
+    end
+
+    private
+
+    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)
+
+      result = ResponseParser.parse_summary_response(raw_response)
+      if result.nil? || result[:summary].nil? || result[:summary].empty?
+        raise EmptyTranslationError, "Empty summary received"
+      end
+
+      log_debug("Summary successful for #{target_locale}")
+      result[:summary]
+    rescue EmptyTranslationError, InvalidResponseError => e
+      if attempt < DEFAULT_RETRY_COUNT
+        wait_time = DEFAULT_RETRY_DELAY * (2**attempt)
+        log_retry(e, attempt + 1, wait_time, target_locale)
+        sleep(wait_time)
+        summarize_with_retry(text, target_locale, max_words, attempt + 1)
+      else
+        log_debug("Max retries reached for #{target_locale}, giving up")
+        raise e
+      end
+    rescue RateLimitError => e
+      log_rate_limit_hit("summary", target_locale)
+      sleep(DEFAULT_RETRY_DELAY)
+      retry
+    end
+
+    def build_summary_translation_prompt(text, source_locale, target_locale, max_words)
+      source_name = LocaleHelper.locale_to_language(source_locale)
+      target_name = LocaleHelper.locale_to_language(target_locale)
+
+      <<~PROMPT
+        Tu es un assistant spécialisé dans la création de résumés et traductions simultanées.#{" "}
+        Résume ET traduis le texte suivant en respectant ces règles strictes :
+        1. Langue source : #{source_name} (#{source_locale})
+        2. Langue cible : #{target_name} (#{target_locale})
+        3. Longueur maximale : #{max_words} mots
+        4. Créer un résumé du texte ET le traduire vers la langue cible
+        5. Format de réponse obligatoire en JSON :
+        {
+          "content": {
+            "source": "texte original",
+            "target": "résumé traduit en #{target_name}"
+          },
+          "metadata": {
+            "source_language": "#{source_locale}",
+            "target_language": "#{target_locale}",
+            "max_words": #{max_words},
+            "operation": "summarize_and_translate"
+          }
+        }
+
+        Texte à résumer et traduire :
+        #{text}
+      PROMPT
+    end
+
+    def clean_document_content(content)
+      return content if content.nil?
+
+      log_debug("Cleaning document content - original length: #{content.length}")
+
+      result = content
+               # Étape 1: Normaliser tous les espaces/tabs en espaces simples
+               .gsub(/[ \t]+/, " ")
+               # Étape 2: Supprimer les séparateurs de ligne (---, ----, etc.)
+               .gsub(/-{3,}/, "")
+               # Étape 3: Supprimer les lignes vides multiples (y compris celles avec espaces)
+               .gsub(/\n\s*\n+/, "\n")
+               # Étape 4: Supprimer espaces en début/fin de ligne
+               .gsub(/^[ \t]+|[ \t]+$/m, "")
+               # Étape 5: Nettoyer les espaces multiples créés par les suppressions précédentes
+               .gsub(/[ \t]+/, " ")
+               # Étape 6: Nettoyer le début et la fin
+               .strip
+
+      log_debug("Text cleaned - new length: #{result.length}")
+      result
+    end
+
+    def validate_summarize_inputs!(text, language, max_words)
+      raise ArgumentError, "Text cannot be nil or empty" if text.nil? || text.empty?
+      raise ArgumentError, "Language cannot be nil" if language.nil?
+      raise ArgumentError, "Max words must be a positive integer" unless max_words.is_a?(Integer) && max_words.positive?
+    end
+
+    def validate_summarize_translate_inputs!(text, from, to, max_words)
+      validate_summarize_inputs!(text, to, max_words)
+      raise ArgumentError, "Source language cannot be nil" if from.nil?
+    end
+
+    def validate_multiple_summarize_inputs!(text, languages, max_words)
+      languages_array = Array(languages)
+      first_language = languages_array.first || "fr"
+      validate_summarize_inputs!(text, first_language, max_words)
+      raise ArgumentError, "Languages array cannot be empty" if languages_array.empty?
+    end
+
+    def validate_tiered_inputs!(text, language, short, medium, long)
+      validate_summarize_inputs!(text, language, short)
+      raise ArgumentError, "Medium length must be greater than short" unless medium > short
+      raise ArgumentError, "Long length must be greater than medium" unless long > medium
+    end
+
+    def log_retry(error, attempt, wait_time, locale)
+      message = "Summary retry #{attempt}/#{DEFAULT_RETRY_COUNT} for #{locale} in #{wait_time}s: #{error.message}"
+      # Log une seule fois par locale et type d'erreur
+      Logger.warn_once(message, key: "summary_retry_#{locale}_#{error.class.name}", sensitive: false, ttl: 120)
+    end
+
+    def log_rate_limit_hit(operation, locale)
+      message = "Rate limit hit for #{operation} in #{locale}, retrying..."
+      # Log une seule fois par opération et locale
+      Logger.warn_once(message, key: "summary_rate_limit_#{operation}_#{locale}", sensitive: false, ttl: 300)
+    end
+
+    def log_debug(message)
+      # Log de debug seulement si mode verbose activé
+      Logger.debug_if_verbose(message, sensitive: false)
+
+      # Pour les tests, permettre un output dans stdout si nécessaire
+      return unless ENV["MISTRAL_TRANSLATOR_TEST_OUTPUT"] == "true"
+
+      puts "[MistralTranslator] #{message}"
+    end
+  end
+end