llm_translate 0.1.0

data/lib/llm_translate/config.rb

@@ -0,0 +1,279 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module LlmTranslate
+  class Config
+    attr_reader :data, :cli_options
+
+    def self.load(config_path, cli_options = {})
+      new(config_path, cli_options)
+    end
+
+    def initialize(config_path, cli_options = {})
+      @cli_options = cli_options
+      @data = load_config_file(config_path)
+      apply_cli_overrides
+      validate_config
+    end
+
+    # AI Configuration
+    def api_key
+      resolve_env_var(data.dig('ai', 'api_key'))
+    end
+
+    def ai_host
+      resolve_env_var(data.dig('ai', 'host')) || 'https://aihubmix.com'
+    end
+
+    def ai_provider
+      data.dig('ai', 'provider') || 'openai'
+    end
+
+    def ai_model
+      data.dig('ai', 'model') || 'claude-3-7-sonnet-20250219'
+    end
+
+    def temperature
+      data.dig('ai', 'temperature') || 0.3
+    end
+
+    def max_tokens
+      data.dig('ai', 'max_tokens') || 4000
+    end
+
+    def retry_attempts
+      data.dig('ai', 'retry_attempts') || 3
+    end
+
+    def retry_delay
+      data.dig('ai', 'retry_delay') || 2
+    end
+
+    def timeout
+      data.dig('ai', 'timeout') || 60
+    end
+
+    # Translation Configuration
+    def default_prompt
+      cli_options[:prompt] || data.dig('translation', 'default_prompt') || default_translation_prompt
+    end
+
+    def target_language
+      data.dig('translation', 'target_language') || 'zh-CN'
+    end
+
+    def source_language
+      data.dig('translation', 'source_language') || 'auto'
+    end
+
+    def preserve_formatting?
+      data.dig('translation', 'preserve_formatting') != false
+    end
+
+    def translate_code_comments?
+      data.dig('translation', 'translate_code_comments') == true
+    end
+
+    def preserve_patterns
+      data.dig('translation', 'preserve_patterns') || default_preserve_patterns
+    end
+
+    # File Configuration
+    def input_directory
+      cli_options[:input] || data.dig('files', 'input_directory') || './docs'
+    end
+
+    def output_directory
+      cli_options[:output] || data.dig('files', 'output_directory') || './docs-translated'
+    end
+
+    def input_file
+      data.dig('files', 'input_file')
+    end
+
+    def output_file
+      data.dig('files', 'output_file')
+    end
+
+    def single_file_mode?
+      !input_file.nil? && !output_file.nil?
+    end
+
+    def filename_strategy
+      data.dig('files', 'filename_strategy') || 'suffix'
+    end
+
+    def filename_suffix
+      data.dig('files', 'filename_suffix') || '.zh'
+    end
+
+    def include_patterns
+      data.dig('files', 'include_patterns') || ['**/*.md', '**/*.markdown']
+    end
+
+    def exclude_patterns
+      data.dig('files', 'exclude_patterns') || []
+    end
+
+    def preserve_directory_structure?
+      data.dig('files', 'preserve_directory_structure') != false
+    end
+
+    def overwrite_policy
+      data.dig('files', 'overwrite_policy') || 'ask'
+    end
+
+    def backup_directory
+      data.dig('files', 'backup_directory') || './backups'
+    end
+
+    # Logging Configuration
+    def log_level
+      cli_options[:verbose] ? 'debug' : (data.dig('logging', 'level') || 'info')
+    end
+
+    def log_output
+      data.dig('logging', 'output') || 'console'
+    end
+
+    def log_file_path
+      data.dig('logging', 'file_path') || './logs/llm_translate.log'
+    end
+
+    def verbose_translation?
+      cli_options[:verbose] || data.dig('logging', 'verbose_translation') == true
+    end
+
+    def error_log_path
+      data.dig('logging', 'error_log_path') || './logs/errors.log'
+    end
+
+    # Error Handling Configuration
+    def on_error
+      data.dig('error_handling', 'on_error') || 'log_and_continue'
+    end
+
+    def max_consecutive_errors
+      data.dig('error_handling', 'max_consecutive_errors') || 5
+    end
+
+    def retry_on_failure
+      data.dig('error_handling', 'retry_on_failure') || 2
+    end
+
+    def generate_error_report?
+      data.dig('error_handling', 'generate_error_report') != false
+    end
+
+    def error_report_path
+      data.dig('error_handling', 'error_report_path') || './logs/error_report.md'
+    end
+
+    def should_stop_on_error?(error_count)
+      on_error == 'stop' || error_count >= max_consecutive_errors
+    end
+
+    # Performance Configuration
+    def concurrent_files
+      data.dig('performance', 'concurrent_files') || 3
+    end
+
+    def batch_size
+      data.dig('performance', 'batch_size') || 5
+    end
+
+    def request_interval
+      data.dig('performance', 'request_interval') || 1
+    end
+
+    def max_memory_mb
+      data.dig('performance', 'max_memory_mb') || 500
+    end
+
+    # Output Configuration
+    def show_progress?
+      data.dig('output', 'show_progress') != false
+    end
+
+    def show_statistics?
+      data.dig('output', 'show_statistics') != false
+    end
+
+    def generate_report?
+      data.dig('output', 'generate_report') != false
+    end
+
+    def report_path
+      data.dig('output', 'report_path') || './reports/translation_report.md'
+    end
+
+    def output_format
+      data.dig('output', 'format') || 'markdown'
+    end
+
+    def include_metadata?
+      data.dig('output', 'include_metadata') != false
+    end
+
+    private
+
+    def load_config_file(config_path)
+      raise ConfigurationError, "Configuration file not found: #{config_path}" unless File.exist?(config_path)
+
+      begin
+        YAML.safe_load(File.read(config_path)) || {}
+      rescue Psych::SyntaxError => e
+        raise ConfigurationError, "Invalid YAML in configuration file: #{e.message}"
+      end
+    end
+
+    def apply_cli_overrides
+      # CLI options take precedence over config file
+      # This is already handled in the individual getter methods
+    end
+
+    def validate_config
+      # Validate required configuration
+      if api_key.nil? || api_key.empty?
+        raise ConfigurationError,
+              'API key is required. Set LLM_TRANSLATE_API_KEY environment variable or configure in config file.'
+      end
+
+      return if Dir.exist?(File.dirname(input_directory))
+
+      raise ConfigurationError, "Input directory parent does not exist: #{File.dirname(input_directory)}"
+    end
+
+    def resolve_env_var(value)
+      return value unless value.is_a?(String)
+
+      # Replace ${VAR_NAME} with environment variable value
+      value.gsub(/\$\{([^}]+)\}/) do |match|
+        var_name = ::Regexp.last_match(1)
+        ENV[var_name] || match
+      end
+    end
+
+    def default_translation_prompt
+      <<~PROMPT
+        Please translate the following Markdown content to #{target_language}, keeping all formatting intact:
+        - Preserve code blocks, links, images, and other Markdown syntax
+        - Keep English technical terms and product names when appropriate
+        - Ensure natural and fluent translation
+
+        Content:
+        {content}
+      PROMPT
+    end
+
+    def default_preserve_patterns
+      [
+        '```[\\s\\S]*?```',      # Code blocks
+        '`[^`]+`',               # Inline code
+        '\\[.*?\\]\\(.*?\\)',    # Links
+        '!\\[.*?\\]\\(.*?\\)'    # Images
+      ]
+    end
+  end
+end

data/lib/llm_translate/file_finder.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require 'find'
+require 'fileutils'
+require 'pathname'
+
+module LlmTranslate
+  class FileFinder
+    attr_reader :config, :logger
+
+    def initialize(config, logger)
+      @config = config
+      @logger = logger
+    end
+
+    def find_markdown_files
+      input_dir = config.input_directory
+
+      raise FileError, "Input directory does not exist: #{input_dir}" unless Dir.exist?(input_dir)
+
+      logger.debug "Scanning directory: #{input_dir}"
+      logger.debug "Include patterns: #{config.include_patterns}"
+      logger.debug "Exclude patterns: #{config.exclude_patterns}"
+
+      files = []
+
+      Find.find(input_dir) do |path|
+        next if File.directory?(path)
+
+        relative_path = Pathname.new(path).relative_path_from(Pathname.new(input_dir)).to_s
+
+        # Skip if file doesn't match include patterns
+        next unless matches_include_patterns?(relative_path)
+
+        # Skip if file matches exclude patterns
+        next if matches_exclude_patterns?(relative_path)
+
+        # Skip if file is not readable
+        unless File.readable?(path)
+          logger.warn "Skipping unreadable file: #{path}"
+          next
+        end
+
+        files << path
+        logger.debug "Found markdown file: #{relative_path}"
+      end
+
+      logger.info "Found #{files.length} markdown files"
+      files.sort
+    end
+
+    def output_path_for(input_path)
+      input_dir = Pathname.new(config.input_directory)
+      output_dir = Pathname.new(config.output_directory)
+      file_path = Pathname.new(input_path)
+
+      # Get relative path from input directory
+      relative_path = file_path.relative_path_from(input_dir)
+
+      # Apply filename strategy
+      output_filename = apply_filename_strategy(relative_path.basename.to_s)
+      output_relative_path = relative_path.dirname + output_filename
+
+      # Combine with output directory
+      output_dir + output_relative_path
+    end
+
+    def ensure_output_directory(output_path)
+      output_dir = File.dirname(output_path)
+      return if Dir.exist?(output_dir)
+
+      logger.debug "Creating output directory: #{output_dir}"
+      FileUtils.mkdir_p(output_dir)
+    end
+
+    def should_skip_file?(_input_path, output_path)
+      return false unless File.exist?(output_path)
+
+      case config.overwrite_policy
+      when 'skip'
+        logger.info "Skipping existing file: #{output_path}"
+        true
+      when 'overwrite'
+        false
+      when 'backup'
+        create_backup(output_path)
+        false
+      when 'ask'
+        ask_user_permission(output_path)
+      else
+        false
+      end
+    end
+
+    private
+
+    def matches_include_patterns?(file_path)
+      return true if config.include_patterns.empty?
+
+      config.include_patterns.any? do |pattern|
+        File.fnmatch?(pattern, file_path, File::FNM_PATHNAME | File::FNM_DOTMATCH)
+      end
+    end
+
+    def matches_exclude_patterns?(file_path)
+      return false if config.exclude_patterns.empty?
+
+      config.exclude_patterns.any? do |pattern|
+        File.fnmatch?(pattern, file_path, File::FNM_PATHNAME | File::FNM_DOTMATCH)
+      end
+    end
+
+    def apply_filename_strategy(filename)
+      case config.filename_strategy
+      when 'suffix'
+        # Add suffix before file extension
+        name = File.basename(filename, '.*')
+        ext = File.extname(filename)
+        "#{name}#{config.filename_suffix}#{ext}"
+      when 'replace'
+        # Replace file extension entirely
+        name = File.basename(filename, '.*')
+        "#{name}#{config.filename_suffix}"
+      when 'directory'
+        # Keep original filename, rely on directory structure
+        filename
+      else
+        # Default to suffix strategy
+        name = File.basename(filename, '.*')
+        ext = File.extname(filename)
+        "#{name}#{config.filename_suffix}#{ext}"
+      end
+    end
+
+    def create_backup(file_path)
+      backup_dir = config.backup_directory
+      FileUtils.mkdir_p(backup_dir)
+
+      timestamp = Time.now.strftime('%Y%m%d_%H%M%S')
+      backup_filename = "#{File.basename(file_path)}.#{timestamp}.bak"
+      backup_path = File.join(backup_dir, backup_filename)
+
+      FileUtils.cp(file_path, backup_path)
+      logger.info "Created backup: #{backup_path}"
+    end
+
+    def ask_user_permission(file_path)
+      print "File exists: #{file_path}. Overwrite? (y/N): "
+      response = $stdin.gets.chomp.downcase
+      !%w[y yes].include?(response)
+    end
+  end
+end

data/lib/llm_translate/logger.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+require 'logger'
+require 'fileutils'
+
+module LlmTranslate
+  class Logger
+    attr_reader :config, :logger, :error_logger
+
+    def initialize(config)
+      @config = config
+      @logger = create_main_logger
+      @error_logger = create_error_logger
+    end
+
+    def debug(message)
+      logger.debug(format_message(message))
+    end
+
+    def info(message)
+      logger.info(format_message(message))
+    end
+
+    def warn(message)
+      logger.warn(format_message(message))
+    end
+
+    def error(message)
+      logger.error(format_message(message))
+      error_logger&.error(format_message(message))
+    end
+
+    def fatal(message)
+      logger.fatal(format_message(message))
+      error_logger&.fatal(format_message(message))
+    end
+
+    def log_translation_start(file_path)
+      return unless config.verbose_translation?
+
+      info("Starting translation: #{file_path}")
+    end
+
+    def log_translation_complete(file_path, output_path)
+      return unless config.verbose_translation?
+
+      info("Translation complete: #{file_path} -> #{output_path}")
+    end
+
+    def log_ai_request(prompt_length, model)
+      return unless config.verbose_translation?
+
+      debug("AI Request - Model: #{model}, Prompt length: #{prompt_length} chars")
+    end
+
+    def log_ai_response(response_length, tokens_used = nil)
+      return unless config.verbose_translation?
+
+      token_info = tokens_used ? ", Tokens: #{tokens_used}" : ''
+      debug("AI Response - Length: #{response_length} chars#{token_info}")
+    end
+
+    private
+
+    def create_main_logger
+      case config.log_output
+      when 'console'
+        create_console_logger
+      when 'file'
+        create_file_logger(config.log_file_path)
+      when 'both'
+        create_multi_logger
+      else
+        create_console_logger
+      end
+    end
+
+    def create_error_logger
+      return nil unless config.error_log_path
+
+      FileUtils.mkdir_p(File.dirname(config.error_log_path))
+      error_logger = ::Logger.new(config.error_log_path)
+      error_logger.level = log_level_constant
+      error_logger.formatter = proc do |severity, datetime, _progname, msg|
+        "[#{datetime.strftime('%Y-%m-%d %H:%M:%S')}] #{severity}: #{msg}\n"
+      end
+      error_logger
+    end
+
+    def create_console_logger
+      console_logger = ::Logger.new($stdout)
+      console_logger.level = log_level_constant
+      console_logger.formatter = proc do |severity, datetime, _progname, msg|
+        color = case severity
+                when 'DEBUG' then "\e[36m" # Cyan
+                when 'INFO'  then "\e[32m" # Green
+                when 'WARN'  then "\e[33m" # Yellow
+                when 'ERROR' then "\e[31m" # Red
+                when 'FATAL' then "\e[35m" # Magenta
+                else "\e[0m"
+                end
+
+        reset = "\e[0m"
+        timestamp = datetime.strftime('%H:%M:%S')
+        "#{color}[#{timestamp}] #{severity}:#{reset} #{msg}\n"
+      end
+      console_logger
+    end
+
+    def create_file_logger(file_path)
+      FileUtils.mkdir_p(File.dirname(file_path))
+      file_logger = ::Logger.new(file_path)
+      file_logger.level = log_level_constant
+      file_logger.formatter = proc do |severity, datetime, _progname, msg|
+        "[#{datetime.strftime('%Y-%m-%d %H:%M:%S')}] #{severity}: #{msg}\n"
+      end
+      file_logger
+    end
+
+    def create_multi_logger
+      console_logger = create_console_logger
+      file_logger = create_file_logger(config.log_file_path)
+
+      MultiLogger.new([console_logger, file_logger])
+    end
+
+    def log_level_constant
+      case config.log_level.downcase
+      when 'debug'
+        ::Logger::DEBUG
+      when 'info'
+        ::Logger::INFO
+      when 'warn'
+        ::Logger::WARN
+      when 'error'
+        ::Logger::ERROR
+      when 'fatal'
+        ::Logger::FATAL
+      else
+        ::Logger::INFO
+      end
+    end
+
+    def format_message(message)
+      case message
+      when Hash, Array
+        message.inspect
+      else
+        message.to_s
+      end
+    end
+  end
+
+  # Helper class for logging to multiple destinations
+  class MultiLogger
+    def initialize(loggers)
+      @loggers = loggers
+    end
+
+    %w[debug info warn error fatal].each do |level|
+      define_method(level) do |message|
+        @loggers.each { |logger| logger.send(level, message) }
+      end
+    end
+
+    def level=(level)
+      @loggers.each { |logger| logger.level = level }
+    end
+  end
+end