rosett-ai 1.3.3

data/lib/rosett_ai/git_hooks/installer.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+module RosettAi
+  module GitHooks
+    # Installs and uninstalls rosett-ai-managed git hooks in .git/hooks/.
+    #
+    # Reads hook definitions from .rosett-ai/config.yml and generates POSIX sh
+    # scripts that invoke rai commands. Chains to pre-existing hooks
+    # (overcommit, husky, lefthook) without overwriting them.
+    #
+    # @author hugo
+    # @author claude
+    class Installer
+      RAI_MARKER = '# rosett-ai-managed hook'
+      BACKUP_SUFFIX = '.rosett-ai-backup'
+
+      SUPPORTED_HOOKS = [
+        'pre-commit', 'post-commit', 'post-checkout', 'post-merge', 'pre-push'
+      ].freeze
+
+      # @param project_root [Pathname] path to the project root
+      # @param hooks_config [Hash] hook definitions from .rosett-ai/config.yml
+      def initialize(project_root:, hooks_config:)
+        @project_root = Pathname.new(project_root)
+        @hooks_config = hooks_config
+        @hooks_dir = @project_root.join('.git', 'hooks')
+      end
+
+      # Installs all configured hooks.
+      #
+      # @return [Hash] result with :installed, :skipped, :errors keys
+      def install
+        results = { installed: [], skipped: [], errors: [] }
+
+        unless @hooks_dir.directory?
+          results[:errors] << 'Not a git repository (missing .git/hooks/)'
+          return results
+        end
+
+        @hooks_config.each do |hook_name, commands|
+          normalized = normalize_hook_name(hook_name)
+          install_hook(normalized, Array(commands), results)
+        end
+
+        results
+      end
+
+      # Uninstalls all rosett-ai-managed hooks, restoring backups.
+      #
+      # @return [Hash] result with :removed, :restored, :errors keys
+      def uninstall
+        results = { removed: [], restored: [], errors: [] }
+
+        unless @hooks_dir.directory?
+          results[:errors] << 'Not a git repository (missing .git/hooks/)'
+          return results
+        end
+
+        SUPPORTED_HOOKS.each { |hook| uninstall_hook(hook, results) }
+        results
+      end
+
+      # Lists currently installed rai hooks.
+      #
+      # @return [Array<Hash>] list of hook info hashes with :name and :commands
+      def list
+        SUPPORTED_HOOKS.filter_map do |hook|
+          path = @hooks_dir.join(hook)
+          next unless path.exist? && rai_managed?(path)
+
+          { name: hook, commands: extract_commands(path) }
+        end
+      end
+
+      # Reports drift between config and installed hooks.
+      #
+      # @return [Hash] status with :in_sync, :missing, :extra, :drifted keys
+      def status
+        result = { in_sync: [], missing: [], extra: [], drifted: [] }
+
+        configured = @hooks_config.transform_keys { |key| normalize_hook_name(key) }
+
+        configured.each do |hook_name, commands|
+          path = @hooks_dir.join(hook_name)
+          classify_hook(path, hook_name, Array(commands), result)
+        end
+
+        find_extra_hooks(configured, result)
+        result
+      end
+
+      private
+
+      def normalize_hook_name(name)
+        name.to_s.tr('_', '-')
+      end
+
+      def install_hook(hook_name, commands, results)
+        unless SUPPORTED_HOOKS.include?(hook_name)
+          results[:errors] << "Unsupported hook: #{hook_name}"
+          return
+        end
+
+        path = @hooks_dir.join(hook_name)
+        backup_existing_hook(path) if path.exist? && !rai_managed?(path)
+
+        script = ScriptGenerator.generate(hook_name: hook_name, commands: commands)
+        File.write(path, script)
+        File.chmod(0o755, path)
+        results[:installed] << hook_name
+      end
+
+      def uninstall_hook(hook_name, results)
+        path = @hooks_dir.join(hook_name)
+        return unless path.exist? && rai_managed?(path)
+
+        File.delete(path)
+        results[:removed] << hook_name
+
+        backup = Pathname.new("#{path}#{BACKUP_SUFFIX}")
+        return unless backup.exist?
+
+        FileUtils.mv(backup, path)
+        results[:restored] << hook_name
+      end
+
+      def backup_existing_hook(path)
+        backup = Pathname.new("#{path}#{BACKUP_SUFFIX}")
+        FileUtils.cp(path, backup) unless backup.exist?
+      end
+
+      def rai_managed?(path)
+        File.read(path).include?(RAI_MARKER)
+      end
+
+      def extract_commands(path)
+        File.read(path).scan(/^# Run: rosett-ai (.+)$/).flatten
+      end
+
+      def classify_hook(path, hook_name, commands, result)
+        unless path.exist?
+          result[:missing] << hook_name
+          return
+        end
+
+        unless rai_managed?(path)
+          result[:missing] << hook_name
+          return
+        end
+
+        installed_cmds = extract_commands(path)
+        expected_cmds = commands.map(&:to_s)
+
+        if installed_cmds == expected_cmds
+          result[:in_sync] << hook_name
+        else
+          result[:drifted] << hook_name
+        end
+      end
+
+      def find_extra_hooks(configured, result)
+        SUPPORTED_HOOKS.each do |hook|
+          path = @hooks_dir.join(hook)
+          next unless path.exist? && rai_managed?(path)
+          next if configured.key?(hook)
+
+          result[:extra] << hook
+        end
+      end
+    end
+  end
+end

data/lib/rosett_ai/git_hooks/script_generator.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+require 'shellwords'
+
+module RosettAi
+  module GitHooks
+    # Generates POSIX sh hook scripts that invoke rai commands.
+    #
+    # Scripts include timeout handling, RAI_SKIP_HOOKS bypass,
+    # and chaining to pre-existing hooks via the backup mechanism.
+    #
+    # @author hugo
+    # @author claude
+    module ScriptGenerator
+      BACKUP_SUFFIX = '.rosett-ai-backup'
+      DEFAULT_TIMEOUT = 30
+
+      # Pattern matching shell metacharacters that indicate potential injection.
+      # Matches: ; | & ` $( )
+      DANGEROUS_PATTERN = /[;|&`]|\$\(/
+
+      # Validates a command string for shell safety.
+      #
+      # @param command [String] the command to validate
+      # @raise [ArgumentError] if the command contains dangerous shell metacharacters
+      # @return [void]
+      def self.validate_command!(command)
+        return unless command.match?(DANGEROUS_PATTERN)
+
+        raise ArgumentError,
+              "Hook command contains dangerous shell metacharacters: #{command.inspect}"
+      end
+
+      # Generates a POSIX sh hook script.
+      #
+      # @param hook_name [String] the git hook name (e.g. 'pre-commit')
+      # @param commands [Array<String>] rai commands to run
+      # @param timeout [Integer] timeout in seconds (default 30)
+      # @return [String] the generated script content
+      # @raise [ArgumentError] if any command contains shell metacharacters
+      def self.generate(hook_name:, commands:, timeout: DEFAULT_TIMEOUT)
+        commands.each { |cmd| validate_command!(cmd) }
+        blocking = blocking_hook?(hook_name)
+
+        lines = [shebang, marker, skip_check, chain_call(hook_name)]
+        commands.each { |cmd| lines << command_block(cmd, timeout, blocking) }
+        lines << exit_line
+        lines.join("\n")
+      end
+
+      # @param hook_name [String]
+      # @return [Boolean] true if the hook should block the git operation on failure
+      def self.blocking_hook?(hook_name)
+        ['pre-commit', 'pre-push'].include?(hook_name)
+      end
+
+      def self.shebang
+        '#!/bin/sh'
+      end
+      private_class_method :shebang
+
+      def self.marker
+        "#{Installer::RAI_MARKER} — do not edit manually"
+      end
+      private_class_method :marker
+
+      def self.skip_check
+        <<~SH
+
+          # Emergency bypass
+          if [ "${RAI_SKIP_HOOKS:-0}" = "1" ]; then
+            exit 0
+          fi
+        SH
+      end
+      private_class_method :skip_check
+
+      def self.chain_call(hook_name)
+        <<~SH
+          # Chain to pre-existing hook if backed up
+          if [ -x "$(dirname "$0")/#{hook_name}#{BACKUP_SUFFIX}" ]; then
+            "$(dirname "$0")/#{hook_name}#{BACKUP_SUFFIX}" "$@"
+            chain_status=$?
+            if [ $chain_status -ne 0 ]; then
+              exit $chain_status
+            fi
+          fi
+        SH
+      end
+      private_class_method :chain_call
+
+      def self.command_block(command, timeout, blocking)
+        exit_line = blocking ? '    exit $cmd_status' : '    echo "rosett-ai: hook command failed (non-blocking)" >&2'
+        escaped = Shellwords.shellescape(command)
+
+        <<~SH
+          # Run: rosett-ai #{command}
+          if command -v timeout >/dev/null 2>&1; then
+            timeout #{timeout} rosett-ai #{escaped}
+          else
+            raictl #{escaped}
+          fi
+          cmd_status=$?
+          if [ $cmd_status -ne 0 ]; then
+            if [ $cmd_status -eq 124 ]; then
+              echo "rosett-ai: #{command} timed out after #{timeout}s. Run manually or set RAI_SKIP_HOOKS=1." >&2
+          #{'    exit 1' if blocking}
+            else
+          #{exit_line}
+            fi
+          fi
+        SH
+      end
+      private_class_method :command_block
+
+      def self.exit_line
+        'exit 0'
+      end
+      private_class_method :exit_line
+    end
+  end
+end

data/lib/rosett_ai/gitlab/validators/supplementary_gitlab_ci_yaml_validator.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+require 'yaml'
+require 'pathname'
+
+module RosettAi
+  module Gitlab
+    module Validators
+      # Validates GitLab CI YAML files for syntax correctness.
+      #
+      # Uses Psych.parse (AST-only parsing) rather than YAML.safe_load so that
+      # GitLab CI custom tags like !reference are accepted without needing
+      # explicit constructors. This catches genuine YAML syntax errors
+      # (e.g. double-quoted strings misinterpreted as YAML scalars) while
+      # remaining compatible with GitLab-specific extensions.
+      class SupplementaryGitlabCiYamlValidator
+        CI_ROOT_FILE = '.gitlab-ci.yml'
+        CI_FILES_DIR = '.gitlab-ci-files'
+
+        attr_reader :results
+
+        def initialize(project_dir: Dir.pwd)
+          @project_dir = Pathname.new(project_dir)
+          @results = { valid: [], invalid: [] }
+        end
+
+        def validate
+          @results = { valid: [], invalid: [] }
+
+          files = ci_files
+          return @results if files.empty?
+
+          files.each { |file| validate_file(file) }
+          @results
+        end
+
+        def valid?
+          validate if @results[:valid].empty? && @results[:invalid].empty?
+          @results[:invalid].empty?
+        end
+
+        private
+
+        def ci_files
+          files = []
+
+          root_ci = @project_dir.join(CI_ROOT_FILE)
+          files << root_ci if root_ci.exist?
+
+          ci_dir = @project_dir.join(CI_FILES_DIR)
+          files.concat(ci_dir.glob('**/*.yml').sort) if ci_dir.exist?
+
+          files
+        end
+
+        def validate_file(file)
+          content = File.read(file)
+          Psych.parse(content)
+          @results[:valid] << { file: relative_path(file), status: :ok }
+        rescue Psych::SyntaxError => e
+          @results[:invalid] << {
+            file: relative_path(file),
+            status: :error,
+            message: e.message,
+            line: e.line,
+            column: e.column
+          }
+        end
+
+        def relative_path(file)
+          file.relative_path_from(@project_dir).to_s
+        end
+      end
+    end
+  end
+end

data/lib/rosett_ai/i18n/locale_resolver.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+module RosettAi
+  module I18n
+    # Resolves the active locale using priority:
+    # explicit flag > config > LANG env > "en".
+    #
+    # Provides a fallback chain for graceful degradation:
+    # nl_BE -> nl -> en, ar_EG -> ar -> en, etc.
+    class LocaleResolver
+      # Resolves the active locale from explicit flag, env, or default.
+      #
+      # @param explicit [String, nil] explicit locale override
+      # @param env [Hash{String => String}] environment variables (defaults to ENV)
+      # @return [Hash{Symbol => Object}] hash with :locale and :chain keys
+      def resolve(explicit: nil, env: ENV)
+        locale = explicit || parse_lang(env['LANG']) || 'en'
+        { locale: locale, chain: fallback_chain(locale) }
+      end
+
+      # Builds a fallback chain from a locale string (e.g. "nl_BE" -> ["nl_BE", "nl", "en"]).
+      #
+      # @param locale [String] locale identifier
+      # @return [Array<String>] ordered fallback chain ending with "en"
+      def fallback_chain(locale)
+        parts = locale.split('_')
+        chain = [locale]
+        chain << parts.first if parts.length > 1
+        chain << 'en' unless chain.include?('en')
+        chain.uniq
+      end
+
+      private
+
+      def parse_lang(lang_value)
+        return nil if lang_value.nil? || lang_value.empty?
+
+        # LANG is typically "en_US.UTF-8" — extract the locale part
+        lang_value.split('.').first
+      end
+    end
+  end
+end

data/lib/rosett_ai/i18n/utf8_checker.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+module RosettAi
+  module I18n
+    # Validates that the runtime environment supports UTF-8 encoding.
+    #
+    # Called early in CLI startup to fail fast with a clear error
+    # rather than producing garbled output.
+    class Utf8Checker
+      # Exits with an error if the runtime is not UTF-8.
+      #
+      # @return [void]
+      def self.check!
+        return if utf8_environment?
+
+        warn "rai requires a UTF-8 terminal. Current: #{Encoding.default_external}"
+        warn 'Set: export LANG=en_US.UTF-8'
+        exit 1
+      end
+
+      # Whether the default external encoding is UTF-8.
+      #
+      # @return [Boolean]
+      def self.utf8_environment?
+        Encoding.default_external == Encoding::UTF_8
+      end
+    end
+  end
+end

data/lib/rosett_ai/init/config_file_writer.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+module RosettAi
+  module Init
+    # Writes the default rai config file at ~/.config/rosett-ai/config.yml
+    # if it does not already exist.
+    class ConfigFileWriter
+      def self.write_default(config_dir: nil)
+        dir = config_dir || RosettAi.paths.rai_config_dir
+        path = dir.join('config.yml')
+
+        return { action: :unchanged, path: path } if path.exist?
+
+        FileUtils.mkdir_p(dir)
+        content = RosettAi::RaiConfig::DEFAULTS.to_yaml
+        File.open(path, 'w', 0o644) { |f| f.write(content) }
+        { action: :created, path: path }
+      end
+    end
+  end
+end

data/lib/rosett_ai/init/directory_builder.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+require 'fileutils'
+
+module RosettAi
+  module Init
+    # Helper module for creating directories during initialization
+    module DirectoryBuilder
+      GLOBAL_DIRS = ['rules', 'locales', 'conf', 'conf/behaviour', 'conf/schemas', 'doc', 'bin', 'lib',
+                     'lib/rosett-ai'].freeze
+      LOCAL_DIRS = ['rules', 'conf', 'conf/behaviour', 'conf/schemas'].freeze
+
+      module_function
+
+      def create_global_structure(base_dir)
+        create_directories(base_dir, GLOBAL_DIRS)
+      end
+
+      def create_local_structure(base_dir)
+        create_directories(base_dir, LOCAL_DIRS)
+      end
+
+      def create_directories(base_dir, subdirs)
+        created = []
+        ([base_dir] + subdirs.map { |subdir| File.join(base_dir, subdir) }).each do |dir|
+          next if Dir.exist?(dir)
+
+          FileUtils.mkdir_p(dir)
+          created << dir
+        end
+        created
+      end
+    end
+  end
+end

data/lib/rosett_ai/init/file_copier.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+require 'fileutils'
+
+module RosettAi
+  module Init
+    # Helper module for copying files during initialization
+    module FileCopier
+      module_function
+
+      def copy_global_assets(base_dir)
+        root = RosettAi.root
+        copied = []
+        copy_single_file(root.join('settings.json'), File.join(base_dir, 'settings.json'), copied,
+                         'settings.json')
+        copy_executable(root.join('bin', 'rai'), File.join(base_dir, 'bin', 'rai'), copied, 'bin/raictl')
+        copy_directory(root.join('lib', 'rosett_ai'), File.join(base_dir, 'lib', 'rosett_ai'), copied, 'lib/rosett_ai/')
+        # Conf assets (behaviours, schemas) go to XDG-compliant ~/.config/rosett-ai/conf/
+        xdg_conf = RosettAi.paths.rai_conf_dir.to_s
+        copy_conf_assets(root, xdg_conf, copied)
+        copy_glob_files(root.join('doc'), File.join(base_dir, 'doc'), '*.md', 'doc', copied)
+        copied
+      end
+
+      def copy_local_assets(base_dir)
+        copied = []
+        # Local scope copies to .claude/conf/ (not XDG)
+        copy_conf_assets(RosettAi.root, File.join(base_dir, 'conf'), copied)
+        copied
+      end
+
+      def copy_conf_assets(source_root, conf_base, copied)
+        FileUtils.mkdir_p(File.join(conf_base, 'behaviour'))
+        FileUtils.mkdir_p(File.join(conf_base, 'schemas'))
+        # Copy template behaviours (not internal conf/behaviour/ files)
+        copy_glob_files(source_root.join('share', 'templates', 'behaviour'),
+                        File.join(conf_base, 'behaviour'), '*.yml', 'conf/behaviour', copied)
+        copy_glob_files(source_root.join('conf', 'schemas'),
+                        File.join(conf_base, 'schemas'), '*.json', 'conf/schemas', copied)
+        copy_if_new(source_root.join('conf', 'adopt_redactions.yml'),
+                    File.join(conf_base, 'adopt_redactions.yml'),
+                    copied, 'conf/adopt_redactions.yml')
+      end
+
+      def copy_single_file(source, target, copied, name)
+        return if File.exist?(target) || !File.exist?(source)
+
+        FileUtils.cp(source, target)
+        copied << name
+      end
+
+      def copy_executable(source, target, copied, name)
+        return unless File.exist?(source)
+
+        FileUtils.cp(source, target)
+        FileUtils.chmod(0o755, target)
+        copied << name
+      end
+
+      def copy_directory(source, target, copied, name)
+        return unless Dir.exist?(source)
+
+        FileUtils.cp_r("#{source}/.", target)
+        copied << name
+      end
+
+      def copy_glob_files(source_dir, target_dir, pattern, prefix, copied)
+        return unless Dir.exist?(source_dir)
+
+        Dir.glob(File.join(source_dir, pattern)).each do |file|
+          basename = File.basename(file)
+          target = File.join(target_dir, basename)
+
+          if File.exist?(target)
+            warn "  skipped #{prefix}/#{basename} (already exists)"
+            next
+          end
+
+          FileUtils.cp(file, target)
+          copied << "#{prefix}/#{basename}"
+        end
+      end
+
+      def copy_if_new(source, target, copied, name)
+        return unless File.exist?(source) && !File.exist?(target)
+
+        FileUtils.cp(source, target)
+        copied << name
+      end
+    end
+  end
+end

data/lib/rosett_ai/init/global_initializer.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+module RosettAi
+  module Init
+    # MCP-facing facade for global structure initialization.
+    #
+    # Delegates to {DirectoryBuilder} and {FileCopier} for the
+    # actual setup logic.
+    #
+    # @author hugo
+    # @author claude
+    class GlobalInitializer
+      def initialize
+        @base_dir = File.join(Dir.home, '.claude')
+      end
+
+      # Sets up the global ~/.claude/ directory structure.
+      #
+      # @return [Array<String>] created directories
+      def setup
+        DirectoryBuilder.create_global_structure(@base_dir)
+      end
+    end
+  end
+end

data/lib/rosett_ai/init/local_initializer.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+module RosettAi
+  module Init
+    # MCP-facing facade for project-local structure initialization.
+    #
+    # Delegates to {DirectoryBuilder} for the actual setup logic.
+    #
+    # @author hugo
+    # @author claude
+    class LocalInitializer
+      def initialize
+        @base_dir = File.join(Dir.pwd, '.claude')
+      end
+
+      # Sets up the project-local .claude/ directory structure.
+      #
+      # @return [Array<String>] created directories
+      def setup
+        DirectoryBuilder.create_local_structure(@base_dir)
+      end
+    end
+  end
+end