rosett-ai 1.3.3

data/lib/rosett_ai/compiler/locale_compiler.rb

@@ -0,0 +1,250 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+require 'fileutils'
+require 'time'
+
+module RosettAi
+  module Compiler
+    # Compiles ruby-i18n YAML locale files into gettext (.pot/.po) and
+    # Qt Linguist (.ts) formats.
+    #
+    # Reads all *.yml files from the source directory, flattens nested
+    # keys into dotted paths, and generates platform-native locale files
+    # for distribution.
+    class LocaleCompiler
+      PLURAL_FORMS = ['zero', 'one', 'two', 'few', 'many', 'other'].freeze
+
+      PLURAL_HEADERS = {
+        'en' => 'nplurals=2; plural=(n != 1);',
+        'fr' => 'nplurals=2; plural=(n > 1);',
+        'ar' => 'nplurals=6; plural=(n==0 ? 0 : n==1 ? 1 : n==2 ? 2 : n%100>=3 && n%100<=10 ? 3 : n%100>=11 ? 4 : 5);'
+      }.freeze
+
+      attr_reader :source_dir, :gettext_dir, :qt_dir
+
+      # Initialize the locale compiler with source and output directories.
+      #
+      # @param source_dir [String, Pathname] locale YAML directory
+      # @param gettext_dir [String, Pathname] gettext output directory
+      # @param qt_dir [String, Pathname] Qt .ts output directory
+      def initialize(source_dir:, gettext_dir:, qt_dir:)
+        @source_dir = Pathname.new(source_dir)
+        @gettext_dir = Pathname.new(gettext_dir)
+        @qt_dir = Pathname.new(qt_dir)
+      end
+
+      # Compiles all locale YAML files to gettext and Qt Linguist formats.
+      #
+      # @return [Hash{Symbol => Array<String>}] output paths keyed by :gettext and :qt
+      def compile
+        locale_files = discover_locale_files
+        results = { gettext: [], qt: [] }
+
+        locale_files.each do |file|
+          data = RosettAi::YamlLoader.load_file(file)
+          locale = data.keys.first
+          entries = flatten_keys(data[locale])
+
+          results[:gettext] << compile_gettext(locale, entries)
+          results[:qt] << compile_qt(locale, entries)
+        end
+
+        results
+      end
+
+      private
+
+      def discover_locale_files
+        Dir.glob(source_dir.join('*.yml'))
+      end
+
+      def flatten_keys(data, prefix = nil)
+        entries = []
+        data.each do |key, value|
+          full_key = prefix ? "#{prefix}.#{key}" : key
+          case value
+          when Hash
+            if plural_hash?(value)
+              entries << { key: full_key, value: value, plural: true }
+            else
+              entries.concat(flatten_keys(value, full_key))
+            end
+          when String
+            entries << { key: full_key, value: value }
+          end
+        end
+        entries
+      end
+
+      def plural_hash?(hash)
+        hash.keys.any? { |k| PLURAL_FORMS.include?(k) }
+      end
+
+      def compile_gettext(locale, entries)
+        FileUtils.mkdir_p(gettext_dir)
+
+        pot_path = gettext_dir.join('rosett_ai.pot')
+        write_pot(pot_path, entries)
+
+        locale_dir = gettext_dir.join(locale, 'LC_MESSAGES')
+        FileUtils.mkdir_p(locale_dir)
+        po_path = locale_dir.join('rosett_ai.po')
+        write_po(po_path, locale, entries)
+
+        po_path.to_s
+      end
+
+      def compile_qt(locale, entries)
+        FileUtils.mkdir_p(qt_dir)
+
+        ts_path = qt_dir.join("rosett_ai_#{locale}.ts")
+        write_ts(ts_path, locale, entries)
+
+        ts_path.to_s
+      end
+
+      def write_pot(path, entries)
+        File.open(path, 'w', 0o644) do |file|
+          file.puts pot_header
+          entries.each do |entry|
+            file.puts
+            file.puts "#: #{entry[:key]}"
+            if entry[:plural]
+              singular = entry[:value]['one'] || entry[:value].values.first
+              plural = entry[:value]['other'] || singular
+              file.puts "msgid #{quote_po(singular)}"
+              file.puts "msgid_plural #{quote_po(plural)}"
+              file.puts 'msgstr[0] ""'
+              file.puts 'msgstr[1] ""'
+            else
+              file.puts "msgid #{quote_po(entry[:value])}"
+              file.puts 'msgstr ""'
+            end
+          end
+        end
+      end
+
+      def write_po(path, locale, entries)
+        File.open(path, 'w', 0o644) do |file|
+          file.puts po_header(locale)
+          entries.each do |entry|
+            file.puts
+            file.puts "#: #{entry[:key]}"
+            if entry[:plural]
+              write_po_plural(file, entry)
+            else
+              file.puts "msgid #{quote_po(entry[:value])}"
+              file.puts "msgstr #{quote_po(entry[:value])}"
+            end
+          end
+        end
+      end
+
+      def write_po_plural(file, entry)
+        forms = entry[:value]
+        singular = forms['one'] || forms.values.first
+        plural = forms['other'] || singular
+        file.puts "msgid #{quote_po(singular)}"
+        file.puts "msgid_plural #{quote_po(plural)}"
+        forms.each_with_index do |(_, form_text), idx|
+          file.puts "msgstr[#{idx}] #{quote_po(form_text)}"
+        end
+      end
+
+      def write_ts(path, locale, entries)
+        contexts = group_by_context(entries)
+
+        File.open(path, 'w', 0o644) do |file|
+          file.puts '<?xml version="1.0" encoding="utf-8"?>'
+          file.puts '<!DOCTYPE TS>'
+          file.puts "<TS version=\"2.1\" language=\"#{escape_xml(locale)}\">"
+
+          contexts.each do |context_name, messages|
+            file.puts '  <context>'
+            file.puts "    <name>#{escape_xml(context_name)}</name>"
+            messages.each { |msg| write_ts_message(file, msg) }
+            file.puts '  </context>'
+          end
+
+          file.puts '</TS>'
+        end
+      end
+
+      def write_ts_message(file, msg)
+        if msg[:plural]
+          file.puts '    <message numerus="yes">'
+          file.puts "      <source>#{escape_xml(msg[:key])}</source>"
+          file.puts '      <translation>'
+          msg[:value].each_value { |text| file.puts "        <numerusform>#{escape_xml(text)}</numerusform>" }
+          file.puts '      </translation>'
+        else
+          file.puts '    <message>'
+          file.puts "      <source>#{escape_xml(msg[:key])}</source>"
+          file.puts "      <translation>#{escape_xml(msg[:value])}</translation>"
+        end
+        file.puts '    </message>'
+      end
+
+      def group_by_context(entries)
+        groups = {}
+        entries.each do |entry|
+          parts = entry[:key].split('.')
+          context = parts.length > 1 ? parts[0...-1].join('.') : 'default'
+          groups[context] ||= []
+          groups[context] << entry
+        end
+        groups
+      end
+
+      def pot_header
+        <<~HEADER.chomp
+          # SOME DESCRIPTIVE TITLE.
+          # Copyright (C) 2026 NeatNerds
+          # This file is distributed under the GPL-3.0-only license.
+          #
+          msgid ""
+          msgstr ""
+          "Project-Id-Version: rosett-ai #{RosettAi::VERSION}\\n"
+          "POT-Creation-Date: #{Time.now.utc.strftime('%Y-%m-%d %H:%M%z')}\\n"
+          "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\\n"
+          "Last-Translator: FULL NAME <EMAIL@ADDRESS>\\n"
+          "Language-Team: LANGUAGE <LL@li.org>\\n"
+          "MIME-Version: 1.0\\n"
+          "Content-Type: text/plain; charset=UTF-8\\n"
+          "Content-Transfer-Encoding: 8bit\\n"
+        HEADER
+      end
+
+      def po_header(locale)
+        plural_forms = PLURAL_HEADERS.fetch(locale, 'nplurals=2; plural=(n != 1);')
+        <<~HEADER.chomp
+          # #{locale.upcase} translations for Rosett-AI.
+          # Copyright (C) 2026 NeatNerds
+          # This file is distributed under the GPL-3.0-only license.
+          #
+          msgid ""
+          msgstr ""
+          "Project-Id-Version: rosett-ai #{RosettAi::VERSION}\\n"
+          "PO-Revision-Date: #{Time.now.utc.strftime('%Y-%m-%d %H:%M%z')}\\n"
+          "Last-Translator: rosett-ai\\n"
+          "Language: #{locale}\\n"
+          "MIME-Version: 1.0\\n"
+          "Content-Type: text/plain; charset=UTF-8\\n"
+          "Content-Transfer-Encoding: 8bit\\n"
+          "Plural-Forms: #{plural_forms}\\n"
+        HEADER
+      end
+
+      def quote_po(string)
+        "\"#{string.gsub('\\', '\\\\\\\\').gsub('"', '\\"').gsub("\n", '\\n')}\""
+      end
+
+      def escape_xml(string)
+        string.gsub('&', '&amp;').gsub('<', '&lt;').gsub('>', '&gt;').gsub('"', '&quot;')
+      end
+    end
+  end
+end

data/lib/rosett_ai/compiler/target_profile.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+require 'json'
+require 'json_schemer'
+
+module RosettAi
+  module Compiler
+    # Loads and validates target profiles from conf/engines/<name>/target.yml,
+    # with fallback to conf/targets/<name>.yml for backward compatibility.
+    #
+    # Target profiles declare which backend to use, the output format, and
+    # rendering options for a specific AI assistant target. Adding a new
+    # target requires only a new YAML file — no code changes.
+    class TargetProfile
+      FIELDS = [
+        :name, :description, :backend, :engine_version, :output_format,
+        :output_dir, :max_context_window, :rendering
+      ].freeze
+
+      attr_reader(*FIELDS)
+
+      def initialize(data)
+        FIELDS.each do |field|
+          instance_variable_set(:"@#{field}", data[field.to_s])
+        end
+      end
+
+      # Load and validate a target profile by name.
+      #
+      # Resolution order:
+      # 1. Plugin registry (engine gem's `target_profile_path`)
+      # 2. `conf/engines/<name>/target.yml` (core tree)
+      # 3. `conf/targets/<name>.yml` (legacy)
+      #
+      # @param target_name [String] engine/target identifier
+      # @return [TargetProfile]
+      # @raise [RosettAi::CompileError] if target not found or invalid
+      def self.load(target_name)
+        # 1. Check plugin registry for engine-provided target profile
+        if RosettAi::Plugins::Registry.registered?(:engine, target_name)
+          plugin = RosettAi::Plugins::Registry.plugin_module(:engine, target_name)
+          if plugin.respond_to?(:target_profile_path) && plugin.target_profile_path.exist?
+            data = RosettAi::YamlLoader.load_file(plugin.target_profile_path)
+            validate!(data, plugin.target_profile_path)
+            return new(data)
+          end
+        end
+
+        # 2. Fallback: file-based lookup (core conf/ tree)
+        path = engine_target_path(target_name)
+        path = legacy_target_path(target_name) unless path.exist?
+        unless path.exist?
+          available_list = available
+          hint = if available_list.empty?
+                   "Install an engine: apt install rosett-ai-engine-#{target_name.tr('_', '-')}"
+                 else
+                   available_list.join(', ')
+                 end
+          raise RosettAi::CompileError,
+                "Unknown target: #{target_name}. Available: #{hint}"
+        end
+
+        data = RosettAi::YamlLoader.load_file(path)
+        validate!(data, path)
+        new(data)
+      end
+
+      # @return [Array<String>] sorted list of all available target names
+      #   (from plugins, engine dir, and legacy targets dir)
+      def self.available
+        plugin_targets = RosettAi::Plugins::Registry.available(:engine)
+        engine_targets = Dir.glob(RosettAi.root.join('conf', 'engines', '*', 'target.yml')).map do |file|
+          File.basename(File.dirname(file))
+        end
+        legacy_targets = Dir.glob(legacy_targets_dir.join('*.yml')).map do |file|
+          File.basename(file, '.yml')
+        end
+        (plugin_targets + engine_targets + legacy_targets).uniq.sort
+      end
+
+      def self.engine_target_path(name)
+        RosettAi.root.join('conf', 'engines', name, 'target.yml')
+      end
+
+      def self.legacy_target_path(name)
+        legacy_targets_dir.join("#{name}.yml")
+      end
+
+      def self.legacy_targets_dir
+        RosettAi.root.join('conf', 'targets')
+      end
+
+      def self.validate!(data, path)
+        schema_path = RosettAi.root.join('conf', 'schemas', 'target_schema.json')
+        schema = JSON.parse(schema_path.read)
+        schemer = JSONSchemer.schema(schema)
+        errors = schemer.validate(data).to_a
+        return if errors.empty?
+
+        messages = errors.map do |err|
+          pointer = err['data_pointer'].empty? ? 'root' : err['data_pointer']
+          "#{pointer}: #{err['type']}"
+        end
+        raise RosettAi::CompileError, "Invalid target profile #{path}: #{messages.join(', ')}"
+      end
+      private_class_method :validate!
+    end
+  end
+end

data/lib/rosett_ai/completion/generator.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+module RosettAi
+  module Completion
+    # Extracts command metadata from the Thor CLI registry for completion
+    # script generation. This is the single source of truth for all
+    # shell completion generators.
+    #
+    # @author hugo
+    # @author claude
+    class Generator
+      SUPPORTED_SHELLS = ['bash', 'zsh', 'fish'].freeze
+
+      # @return [Hash] command tree extracted from Thor CLI
+      attr_reader :command_tree
+
+      def initialize
+        @command_tree = extract_command_tree
+      end
+
+      # Generate a completion script for the given shell.
+      #
+      # @param shell [String] one of 'bash', 'zsh', 'fish'
+      # @return [String] the completion script content
+      # @raise [RosettAi::Error] if shell is unsupported
+      def generate(shell)
+        shell = shell.to_s.downcase
+        unless SUPPORTED_SHELLS.include?(shell)
+          raise RosettAi::Error,
+                "Shell #{shell} is not supported — available: #{SUPPORTED_SHELLS.join(', ')}"
+        end
+
+        shell_generator_for(shell).generate
+      end
+
+      # @param shell [String] shell name
+      # @return [Boolean] whether the shell is supported
+      def supported?(shell)
+        SUPPORTED_SHELLS.include?(shell.to_s.downcase)
+      end
+
+      private
+
+      def shell_generator_for(shell)
+        case shell
+        when 'bash' then Shells::BashGenerator.new(command_tree)
+        when 'zsh'  then Shells::ZshGenerator.new(command_tree)
+        when 'fish' then Shells::FishGenerator.new(command_tree)
+        end
+      end
+
+      def extract_command_tree
+        cli_class = RosettAi::Thor::CLI
+        tree = {}
+
+        cli_class.all_commands.each_value do |cmd|
+          next if cmd.name == 'help'
+
+          tree[cmd.name] = extract_command_info(cli_class, cmd)
+        end
+
+        tree
+      end
+
+      def extract_command_info(cli_class, cmd)
+        info = { description: cmd.description, options: extract_options(cmd) }
+        sub_class = find_subcommand_class(cli_class, cmd.name)
+        info[:subcommands] = extract_subcommands(sub_class) if sub_class
+        info
+      end
+
+      def extract_options(cmd)
+        return {} unless cmd.respond_to?(:options) && cmd.options
+
+        cmd.options.transform_values do |opt|
+          { type: opt.type.to_s, description: opt.description, enum: opt.enum }
+        end
+      end
+
+      def find_subcommand_class(cli_class, name)
+        cli_class.subcommand_classes[name]
+      end
+
+      def extract_subcommands(sub_class)
+        subs = {}
+        sub_class.all_commands.each_value do |cmd|
+          next if cmd.name == 'help'
+
+          subs[cmd.name] = {
+            description: cmd.description,
+            options: extract_options(cmd)
+          }
+        end
+        subs
+      end
+    end
+  end
+end

data/lib/rosett_ai/completion/shells/bash_generator.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+module RosettAi
+  module Completion
+    module Shells
+      # Generates bash completion scripts from the Thor command tree.
+      #
+      # Uses bash-completion framework conventions with _raictl() function.
+      # Dynamic completions for behaviour names and engine names use
+      # rai subcommands at tab-completion time.
+      #
+      # @author hugo
+      # @author claude
+      class BashGenerator
+        # @param command_tree [Hash] command tree from Generator
+        def initialize(command_tree)
+          @command_tree = command_tree
+        end
+
+        # @return [String] bash completion script
+        def generate
+          lines = []
+          lines << header
+          lines << main_function
+          lines << subcommand_functions
+          lines << dynamic_completions
+          lines << registration
+          lines.join("\n")
+        end
+
+        private
+
+        def header
+          <<~BASH
+            # bash completion for Rosett-AI — generated by rai completion bash
+            # Do not edit manually; regenerate with: rai completion bash
+          BASH
+        end
+
+        def main_function
+          commands = @command_tree.keys.sort
+          <<~BASH
+            _raictl() {
+                local cur prev words cword
+                _init_completion || return
+
+                local commands="#{shell_escape(commands.join(' '))}"
+
+                if [[ ${cword} -eq 1 ]]; then
+                    COMPREPLY=( $(compgen -W "${commands}" -- "${cur}") )
+                    return
+                fi
+
+                local subcmd="${words[1]}"
+                case "${subcmd}" in
+            #{subcommand_cases.chomp}
+                    *)
+                        COMPREPLY=()
+                        ;;
+                esac
+            }
+          BASH
+        end
+
+        def subcommand_cases
+          lines = []
+          @command_tree.each do |name, info|
+            subs = info[:subcommands]
+            next unless subs
+
+            sub_names = subs.keys.sort.join(' ')
+            options = collect_options(subs)
+            words = [sub_names, options].reject(&:empty?).join(' ')
+            lines << "        #{shell_escape(name)})\n"
+            lines << "            COMPREPLY=( $(compgen -W \"#{shell_escape(words)}\" -- \"${cur}\") )\n"
+            lines << "            ;;\n"
+          end
+          lines.join
+        end
+
+        def subcommand_functions
+          '' # Inline in case statement for simplicity
+        end
+
+        def dynamic_completions
+          <<~BASH
+
+            _rai_behaviour_names() {
+                local names
+                names=$(rai behaviour list --format=names 2>/dev/null)
+                COMPREPLY=( $(compgen -W "${names}" -- "${cur}") )
+            }
+
+            _rosett_ai_engine_names() {
+                local names
+                names=$(rai engines list --format=names 2>/dev/null)
+                COMPREPLY=( $(compgen -W "${names}" -- "${cur}") )
+            }
+          BASH
+        end
+
+        def registration
+          <<~BASH
+            complete -F _raictl rosett-ai
+          BASH
+        end
+
+        def collect_options(subcommands)
+          subcommands.each_value
+            .flat_map { |s| (s[:options] || {}).keys }
+            .uniq
+            .sort
+            .map { |o| "--#{o.to_s.tr('_', '-')}" }
+            .join(' ')
+        end
+
+        def shell_escape(str)
+          str.gsub(/[^a-zA-Z0-9_ .,-]/, '')
+        end
+      end
+    end
+  end
+end

data/lib/rosett_ai/completion/shells/fish_generator.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+module RosettAi
+  module Completion
+    module Shells
+      # Generates fish completion scripts from the Thor command tree.
+      #
+      # Uses fish's `complete` builtin with condition-based subcommand
+      # completion. Supports subcommand descriptions and dynamic
+      # completions for behaviour/engine names.
+      #
+      # @author hugo
+      # @author claude
+      class FishGenerator
+        # @param command_tree [Hash] command tree from Generator
+        def initialize(command_tree)
+          @command_tree = command_tree
+        end
+
+        # @return [String] fish completion script
+        def generate
+          lines = []
+          lines << header
+          lines << disable_file_completion
+          lines << top_level_completions
+          lines << subcommand_completions
+          lines.join("\n")
+        end
+
+        private
+
+        def header
+          <<~FISH
+            # fish completion for Rosett-AI — generated by rai completion fish
+            # Do not edit manually; regenerate with: rai completion fish
+          FISH
+        end
+
+        def disable_file_completion
+          "complete -c rosett-ai -f\n"
+        end
+
+        def top_level_completions
+          lines = []
+          @command_tree.each do |name, info|
+            desc = fish_escape(info[:description].to_s)
+            lines << "complete -c rosett-ai -n '__fish_use_subcommand' " \
+                     "-a '#{fish_escape(name)}' -d '#{desc}'"
+          end
+          "#{lines.sort.join("\n")}\n"
+        end
+
+        def subcommand_completions
+          lines = []
+          @command_tree.each do |name, info|
+            subs = info[:subcommands]
+            next unless subs
+
+            subs.each do |sub_name, sub_info|
+              desc = fish_escape(sub_info[:description].to_s)
+              lines << 'complete -c rosett-ai ' \
+                       "-n '__fish_seen_subcommand_from #{fish_escape(name)}' " \
+                       "-a '#{fish_escape(sub_name)}' -d '#{desc}'"
+            end
+          end
+          "#{lines.sort.join("\n")}\n"
+        end
+
+        def fish_escape(str)
+          str.gsub("'", "\\\\'")
+        end
+      end
+    end
+  end
+end