mistral_translator 0.1.0 → 0.2.1

data/lib/mistral_translator/prompt_builder.rb

@@ -1,20 +1,36 @@
 # frozen_string_literal: true
 
 require_relative "logger"
+require_relative "prompt_helpers"
+require_relative "prompt_metadata_helpers"
 
 module MistralTranslator
   module PromptBuilder
+    extend PromptHelpers::ContextBuilder
+    extend PromptHelpers::HtmlInstructions
+    extend PromptHelpers::FormatInstructions
+    extend PromptMetadataHelpers
+
     class << self
-      def translation_prompt(text, source_language, target_language)
+      def translation_prompt(text, source_language, target_language, **options)
         source_name = LocaleHelper.locale_to_language(source_language)
         target_name = LocaleHelper.locale_to_language(target_language)
 
+        # Construction du contexte enrichi
+        context_section = build_context_section(options[:context], options[:glossary])
+        html_instruction = options[:preserve_html] ? build_html_preservation_instruction : ""
+
+        # Extraire les valeurs pour les métadonnées
+        context = options[:context]
+        glossary = options[:glossary]
+        preserve_html = options[:preserve_html]
+
         <<~PROMPT
           Tu es un traducteur professionnel. Traduis le texte suivant de #{source_name} vers #{target_name}.
-
+          #{context_section}
           RÈGLES :
           - Traduis fidèlement sans ajouter d'informations
-          - Conserve le style, ton et format original
+          - Conserve le style, ton et format original#{html_instruction}
           - Réponds UNIQUEMENT en JSON valide
 
           FORMAT OBLIGATOIRE :
@@ -26,7 +42,7 @@ module MistralTranslator
             "metadata": {
               "source_language": "#{source_language}",
               "target_language": "#{target_language}",
-              "operation": "translation"
+              "operation": "translation"#{build_metadata_additions(context, glossary, preserve_html)}
             }
           }
 
@@ -35,16 +51,26 @@ module MistralTranslator
         PROMPT
       end
 
-      def bulk_translation_prompt(texts, source_language, target_language)
+      # rubocop:disable Metrics/MethodLength
+      def bulk_translation_prompt(texts, source_language, target_language, **options)
         source_name = LocaleHelper.locale_to_language(source_language)
         target_name = LocaleHelper.locale_to_language(target_language)
 
+        context_section = build_context_section(options[:context], options[:glossary])
+        html_instruction = options[:preserve_html] ? build_html_preservation_instruction : ""
+
+        # Extraire les valeurs pour les métadonnées
+        context = options[:context]
+        glossary = options[:glossary]
+        preserve_html = options[:preserve_html]
+
         <<~PROMPT
           Tu es un traducteur professionnel. Traduis les textes suivants de #{source_name} vers #{target_name}.
-
+          #{context_section}
           RÈGLES :
           - Traduis fidèlement chaque texte sans ajouter d'informations
-          - Conserve le style, ton et format originaux
+          - Conserve le style, ton et format originaux#{html_instruction}
+          - Maintiens la cohérence terminologique entre tous les textes
           - Réponds UNIQUEMENT en JSON valide
 
           FORMAT OBLIGATOIRE :
@@ -65,7 +91,7 @@ module MistralTranslator
               "source_language": "#{source_language}",
               "target_language": "#{target_language}",
               "count": #{texts.length},
-              "operation": "bulk_translation"
+              "operation": "bulk_translation"#{build_metadata_additions(context, glossary, preserve_html)}
             }
           }
 
@@ -73,17 +99,21 @@ module MistralTranslator
           #{texts.map.with_index { |text, i| "#{i + 1}. #{text}" }.join("\n")}
         PROMPT
       end
+      # rubocop:enable Metrics/MethodLength
 
-      def summary_prompt(text, max_words, target_language = "fr")
+      def summary_prompt(text, max_words, target_language = "fr", context: nil, style: nil)
         target_name = LocaleHelper.locale_to_language(target_language)
 
+        context_section = build_summary_context_section(context, style)
+        style_instruction = build_style_instruction(style)
+
         <<~PROMPT
           Tu es un rédacteur professionnel. Résume le texte suivant en #{target_name}.
-
+          #{context_section}
           RÈGLES :
           - Résume fidèlement sans ajouter d'informations
           - Maximum #{max_words} mots
-          - Conserve les informations essentielles
+          - Conserve les informations essentielles#{style_instruction}
           - Réponds UNIQUEMENT en JSON valide
 
           FORMAT OBLIGATOIRE :
@@ -96,7 +126,7 @@ module MistralTranslator
               "source_language": "original",
               "target_language": "#{target_language}",
               "word_count": #{max_words},
-              "operation": "summarization"
+              "operation": "summarization"#{build_summary_metadata_additions(context, style)}
             }
           }
 
@@ -105,17 +135,24 @@ module MistralTranslator
         PROMPT
       end
 
-      def summary_and_translation_prompt(text, source_language, target_language, max_words)
+      def summary_and_translation_prompt(text, source_language, target_language, max_words, **options)
         source_name = LocaleHelper.locale_to_language(source_language)
         target_name = LocaleHelper.locale_to_language(target_language)
 
+        context_section = build_summary_context_section(options[:context], options[:style])
+        style_instruction = build_style_instruction(options[:style])
+
+        # Extraire les valeurs pour les métadonnées
+        context = options[:context]
+        style = options[:style]
+
         <<~PROMPT
           Tu es un rédacteur professionnel. Résume ET traduis le texte suivant de #{source_name} vers #{target_name}.
-
+          #{context_section}
           RÈGLES :
           - Résume fidèlement sans ajouter d'informations
           - Traduis le résumé en #{target_name}
-          - Maximum #{max_words} mots
+          - Maximum #{max_words} mots#{style_instruction}
           - Réponds UNIQUEMENT en JSON valide
 
           FORMAT OBLIGATOIRE :
@@ -128,7 +165,7 @@ module MistralTranslator
               "source_language": "#{source_language}",
               "target_language": "#{target_language}",
               "word_count": #{max_words},
-              "operation": "summarization_and_translation"
+              "operation": "summarization_and_translation"#{build_summary_metadata_additions(context, style)}
             }
           }
 
@@ -137,32 +174,44 @@ module MistralTranslator
         PROMPT
       end
 
-      def tiered_summary_prompt(text, target_language, short, medium, long)
+      def tiered_summary_prompt(text, target_language, **options)
         target_name = LocaleHelper.locale_to_language(target_language)
 
+        context_section = build_summary_context_section(options[:context], options[:style])
+        style_instruction = build_style_instruction(options[:style])
+
+        # Extraire les valeurs pour les métadonnées
+        context = options[:context]
+        style = options[:style]
+
         <<~PROMPT
           Tu es un rédacteur professionnel. Crée trois résumés du texte suivant en #{target_name}.
-
+          #{context_section}
           RÈGLES :
           - Résume fidèlement sans ajouter d'informations
           - Respecte strictement les longueurs demandées
+          - Court: #{options[:short]} mots, Moyen: #{options[:medium]} mots, Long: #{options[:long]} mots#{style_instruction}
           - Réponds UNIQUEMENT en JSON valide
 
           FORMAT OBLIGATOIRE :
           {
             "content": {
               "source": "texte original",
-              "target": "résumés en #{target_name}"
+              "summaries": {
+                "short": "résumé court (#{options[:short]} mots)",
+                "medium": "résumé moyen (#{options[:medium]} mots)",
+                "long": "résumé long (#{options[:long]} mots)"
+              }
             },
             "metadata": {
               "source_language": "original",
               "target_language": "#{target_language}",
               "summaries": {
-                "short": #{short},
-                "medium": #{medium},
-                "long": #{long}
+                "short": #{options[:short]},
+                "medium": #{options[:medium]},
+                "long": #{options[:long]}
               },
-              "operation": "tiered_summarization"
+              "operation": "tiered_summarization"#{build_summary_metadata_additions(context, style)}
             }
           }
 
@@ -171,7 +220,13 @@ module MistralTranslator
         PROMPT
       end
 
-      def language_detection_prompt(text)
+      def language_detection_prompt(text, confidence_score: false)
+        confidence_instruction = if confidence_score
+                                   ', "confidence": score_de_confiance_entre_0_et_1'
+                                 else
+                                   ""
+                                 end
+
         <<~PROMPT
           Tu es un expert en linguistique. Détecte la langue du texte suivant.
 
@@ -187,7 +242,7 @@ module MistralTranslator
               "target": "langue détectée"
             },
             "metadata": {
-              "detected_language": "code_iso",
+              "detected_language": "code_iso"#{confidence_instruction},
               "operation": "language_detection"
             }
           }
@@ -197,22 +252,19 @@ module MistralTranslator
         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
+      # Nouveau : Prompt pour traduction avec validation de qualité
+      def translation_with_validation_prompt(text, source_language, target_language, **)
+        base_prompt = translation_prompt(text, source_language, target_language, **)
+
+        base_prompt.sub(
+          '"operation": "translation"',
+          '"operation": "translation_with_validation",
+          "quality_check": {
+            "terminology_consistency": "vérifié",
+            "style_preservation": "vérifié",
+            "completeness": "vérifié"
+          }'
+        )
       end
     end
   end

data/lib/mistral_translator/prompt_helpers.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module MistralTranslator
+  module PromptHelpers
+    # Helper pour la construction des sections de contexte
+    module ContextBuilder
+      def build_context_section(context, glossary)
+        return "" unless context || glossary
+
+        sections = []
+        sections << "CONTEXTE : #{context}" if context && !context.to_s.strip.empty?
+        sections << "GLOSSAIRE : #{glossary}" if glossary && !glossary.to_s.strip.empty?
+
+        sections.any? ? "\n#{sections.join("\n")}\n" : ""
+      end
+
+      def build_summary_context_section(context, style)
+        return "" unless context || style
+
+        sections = []
+        sections << "CONTEXTE : #{context}" if context && !context.to_s.strip.empty?
+        sections << "STYLE : #{style}" if style && !style.to_s.strip.empty?
+
+        sections.any? ? "\n#{sections.join("\n")}\n" : ""
+      end
+
+      def build_style_instruction(style)
+        return "" unless style
+
+        case style.to_s.downcase
+        when "formal"
+          "\nUtilise un style formel et professionnel."
+        when "casual"
+          "\nUtilise un style décontracté et familier."
+        when "academic"
+          "\nUtilise un style académique et précis."
+        when "marketing"
+          "\nUtilise un style marketing et persuasif."
+        else
+          ""
+        end
+      end
+    end
+
+    # Helper pour les instructions HTML
+    module HtmlInstructions
+      def build_html_preservation_instruction
+        <<~HTML_INSTRUCTION
+
+          IMPORTANT : Préserve tous les éléments HTML (balises, attributs, structure).
+          Ne traduis que le contenu textuel à l'intérieur des balises.
+        HTML_INSTRUCTION
+      end
+
+      def build_html_validation_instruction
+        <<~HTML_VALIDATION
+
+          IMPORTANT : Vérifie que le HTML est valide et bien formé.
+          Corrige toute erreur de structure HTML si nécessaire.
+        HTML_VALIDATION
+      end
+    end
+
+    # Helper pour les instructions de formatage
+    module FormatInstructions
+      def build_json_format_instruction
+        <<~JSON_INSTRUCTION
+
+          FORMAT DE RÉPONSE : Réponds UNIQUEMENT avec un objet JSON valide.
+          Pas de texte avant ou après le JSON.
+        JSON_INSTRUCTION
+      end
+
+      def build_batch_format_instruction
+        <<~BATCH_INSTRUCTION
+
+          FORMAT DE RÉPONSE : Réponds avec un tableau JSON contenant les traductions dans l'ordre.
+          Chaque élément doit être la traduction correspondante.
+        BATCH_INSTRUCTION
+      end
+    end
+  end
+end

data/lib/mistral_translator/prompt_metadata_helpers.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative "logger"
+
+module MistralTranslator
+  module PromptMetadataHelpers
+    def build_metadata_additions(context, glossary, preserve_html)
+      additions = []
+
+      additions << '"has_context": true' if context && !context.to_s.strip.empty?
+      additions << '"has_glossary": true' if glossary && !glossary.to_s.strip.empty? && glossary.any?
+      additions << '"preserve_html": true' if preserve_html
+
+      additions.any? ? ",\n              #{additions.join(",\n              ")}" : ""
+    end
+
+    def build_summary_metadata_additions(context, style)
+      additions = []
+
+      additions << '"has_context": true' if context && !context.to_s.strip.empty?
+      additions << %("style": "#{style}") if style && !style.to_s.strip.empty?
+
+      additions.any? ? ",\n              #{additions.join(",\n              ")}" : ""
+    end
+
+    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

data/lib/mistral_translator/response_parser.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "logger"
+
 module MistralTranslator
   class ResponseParser
     class << self
@@ -7,28 +9,16 @@ module MistralTranslator
         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
+          translation_data = parse_json_content(json_content)
           translated_text = extract_target_content(translation_data)
+          validate_translation_content(translated_text)
 
-          # 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}"
+          build_translation_result(translation_data, translated_text)
+        rescue JSON::ParserError => e
+          handle_json_parse_error(e, raw_content, json_content)
         rescue EmptyTranslationError
           raise # Re-raise EmptyTranslationError
         rescue StandardError => e
@@ -36,12 +26,88 @@ module MistralTranslator
         end
       end
 
+      def parse_quality_check_response(raw_content)
+        return { translation: nil, quality_check: {}, metadata: {} } if raw_content.nil? || raw_content.empty?
+
+        json_content = extract_json_from_content(raw_content)
+        raise InvalidResponseError, "Invalid JSON in quality check response" unless json_content
+
+        data = JSON.parse(json_content)
+
+        translation = extract_target_content(data)
+        quality = data["quality_check"] || data.dig("metadata", "quality_check") || {}
+        {
+          translation: translation,
+          quality_check: quality,
+          metadata: data["metadata"] || {}
+        }
+      rescue JSON::ParserError
+        raise InvalidResponseError, "Invalid JSON in quality check response"
+      rescue StandardError => e
+        raise InvalidResponseError, "Error processing quality check response: #{e.message}"
+      end
+
+      def parse_json_content(json_content)
+        JSON.parse(json_content)
+      rescue JSON::ParserError
+        # Pass 1: join quoted string segments split by backslash-newline
+        # pattern: " ... " \\<newline> " ... "
+        joined_segments = json_content.gsub(/"\s*\\\r?\n\s*"/, "")
+        begin
+          JSON.parse(joined_segments)
+        rescue JSON::ParserError
+          # Pass 2: remove any remaining backslash-newline continuations
+          removed_continuations = joined_segments.gsub(/\\\s*\r?\n\s*/, "")
+          JSON.parse(removed_continuations)
+        end
+      end
+
+      def validate_translation_content(translated_text)
+        return unless translated_text.nil? || translated_text.empty?
+
+        raise EmptyTranslationError, "Empty translation received from API"
+      end
+
+      def build_translation_result(translation_data, translated_text)
+        {
+          original: extract_source_content(translation_data),
+          translated: translated_text,
+          metadata: translation_data["metadata"] || {}
+        }
+      end
+
+      def handle_json_parse_error(error, raw_content, json_content)
+        error_details = {
+          error_message: error.message,
+          raw_content_length: raw_content&.length,
+          json_content_length: json_content&.length,
+          has_json_content: !json_content.nil?
+        }
+        Logger.debug_if_verbose(
+          "JSON parse failed: #{error.message} raw_len=#{error_details[:raw_content_length]} " \
+          "json_len=#{error_details[:json_content_length]} snippet=#{raw_content&.slice(0, 120)}",
+          sensitive: false
+        )
+        raise InvalidResponseError, "Invalid JSON in response: #{error.message}. Details: #{error_details}"
+      end
+
+      # rubocop:disable Metrics/PerceivedComplexity
       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
+          unless json_content
+            # Aucun JSON détecté: utiliser le texte brut comme repli si non vide
+            text = raw_content.to_s.strip
+            raise EmptyTranslationError, "Empty summary received" if text.empty?
+
+            return {
+              original: nil,
+              summary: text,
+              metadata: { "operation" => "summarization", "fallback" => true }
+            }
+          end
 
           summary_data = JSON.parse(json_content)
           summary_text = extract_target_content(summary_data)
@@ -54,13 +120,22 @@ module MistralTranslator
             metadata: summary_data["metadata"] || {}
           }
         rescue JSON::ParserError
-          raise InvalidResponseError, "Invalid JSON in summary response: #{raw_content}"
+          # Fallback: si ce n'est pas du JSON, essayer d'utiliser le texte brut s'il a du contenu
+          text = raw_content.to_s.strip
+          raise InvalidResponseError, "Invalid JSON in summary response: #{raw_content}" if text.empty?
+
+          {
+            original: nil,
+            summary: text,
+            metadata: { "operation" => "summarization", "fallback" => true }
+          }
         rescue EmptyTranslationError
           raise # Re-raise EmptyTranslationError
         rescue StandardError => e
           raise InvalidResponseError, "Error processing summary response: #{e.message}"
         end
       end
+      # rubocop:enable Metrics/PerceivedComplexity
 
       def parse_bulk_translation_response(raw_content)
         return [] if raw_content.nil? || raw_content.empty?
@@ -94,9 +169,103 @@ module MistralTranslator
       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)
+        return nil if content.nil? || content.empty?
+
+        # Limiter la taille pour éviter les attaques DoS
+        max_content_size = 1_000_000 # 1MB max
+        if content.length > max_content_size
+          raise InvalidResponseError, "Response content too large (#{content.length} bytes, max: #{max_content_size})"
+        end
+
+        # Essayer d'abord de parser directement le contenu comme JSON
+        begin
+          JSON.parse(content)
+          content
+        rescue JSON::ParserError
+          # Si ça échoue, chercher le JSON dans la réponse (peut être entouré de texte)
+          # Utiliser une approche plus robuste pour les JSON complexes
+          find_json_in_text(content)
+        end
+      end
+
+      def find_json_in_text(text)
+        start_pos = find_json_start(text)
+        return nil unless start_pos
+
+        parse_json_until_end(text, start_pos)
+      end
+
+      def find_json_start(text)
+        text.index("{")
+      end
+
+      def parse_json_until_end(text, start_pos)
+        parser_state = JsonParserState.new
+        max_iterations = 100_000
+
+        (start_pos...text.length).each do |i|
+          parser_state.increment_iterations
+          if parser_state.iterations > max_iterations
+            raise InvalidResponseError,
+                  "JSON parsing exceeded maximum iterations"
+          end
+
+          char = text[i]
+          parser_state.process_character(char)
+
+          return text[start_pos..i] if parser_state.found_complete_json?
+        end
+
+        nil
+      end
+
+      # Helper class pour gérer l'état du parsing JSON
+      class JsonParserState
+        attr_reader :iterations
+
+        def initialize
+          @brace_count = 0
+          @in_string = false
+          @escape_next = false
+          @iterations = 0
+        end
+
+        def increment_iterations
+          @iterations += 1
+        end
+
+        def process_character(char)
+          return handle_escape_character if @escape_next
+          return handle_backslash_character if char == "\\"
+          return handle_quote_character(char) if char == '"' && !@escape_next
+          return if @in_string
+
+          handle_brace_character(char)
+        end
+
+        def handle_escape_character
+          @escape_next = false
+        end
+
+        def handle_backslash_character
+          @escape_next = true
+        end
+
+        def handle_quote_character(_char)
+          @in_string = !@in_string
+        end
+
+        def handle_brace_character(char)
+          if char == "{"
+            @brace_count += 1
+          elsif char == "}"
+            @brace_count -= 1
+          end
+        end
+
+        def found_complete_json?
+          @brace_count.zero?
+        end
       end
 
       def extract_target_content(data)
@@ -106,7 +275,9 @@ module MistralTranslator
           data.dig("translation", "target"),
           data["target"],
           data.dig("content", "translated"),
-          data["translated"]
+          data["translated"],
+          data.dig("content", "summary"),
+          data["summary"]
         ].find { |item| item && !item.to_s.empty? }
       end