rosett-ai 1.3.3

data/lib/rosett_ai/thor/tasks/config.rb

@@ -0,0 +1,265 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+require 'thor'
+require 'rainbow'
+require 'terminal-table'
+
+module RosettAi
+  module Thor
+    module Tasks
+      # Thor task for compiling engine configuration YAML to settings JSON.
+      class Config < ::Thor
+        default_task :compile
+
+        desc 'show SCOPE', 'Display compiled configuration for a scope with secrets masked'
+        long_desc <<~LONGDESC
+          Displays compiled configuration for a specific scope (managed, user, project, local).
+          Secrets are automatically masked with [REDACTED] for security.
+
+          Flags:
+            --raw: Show YAML source instead of compiled JSON
+            --engine NAME: Show config for specific engine
+
+          EXAMPLES
+
+            raictl config show managed
+            raictl config show user --raw
+            raictl config show project --engine claude
+
+          Related commands: raictl config compile
+        LONGDESC
+        method_option :raw, type: :boolean, default: false,
+                            desc: 'Show YAML source instead of compiled JSON'
+        method_option :engine, type: :string, default: nil,
+                               desc: 'Engine name (default: configured default)'
+
+        def show(scope)
+          scope = RosettAi::TextSanitizer.normalize_nfc(scope)
+          compiler = resolve_config_compiler(simulate: true, masking: true)
+          scope_path = find_scope_file(scope, compiler)
+
+          if options[:raw]
+            print_raw_source(scope_path)
+          else
+            print_compiled_json(scope_path, compiler)
+          end
+        end
+
+        desc 'compile', 'Compile engine configuration YAML to native settings'
+        long_desc <<~LONGDESC
+          Compiles engine configuration YAML scopes to native settings format (JSON for Claude).
+          Processes managed, user, project, and local scopes in hierarchy order.
+
+          Flags:
+            --verbose: Show detailed compilation output with diffs
+            --simulate: Dry run without writing files
+            --scope NAME: Compile only one scope (managed, user, project, local)
+            --engine NAME: Compile for specific engine
+
+          Exit codes: 1 if any scope fails to compile
+
+          EXAMPLES
+
+            raictl config compile
+            raictl config compile --verbose --simulate
+            raictl config compile --scope managed --engine claude
+
+          Related commands: raictl config show, rai compile
+        LONGDESC
+        method_option :verbose, type: :boolean, default: false,
+                                desc: 'Show detailed output'
+        method_option :simulate, type: :boolean, default: false,
+                                 desc: 'Dry run — show diffs without writing'
+        method_option :scope, type: :string, default: nil,
+                              desc: 'Compile specific scope only (managed, user, project, local)'
+        method_option :engine, type: :string, default: nil,
+                               desc: 'Engine name (default: configured default)'
+
+        def compile
+          compiler = resolve_config_compiler(simulate: options[:simulate])
+
+          results = if options[:scope]
+                      scope_path = find_scope_file(options[:scope], compiler)
+                      [compiler.compile_scope(scope_path)]
+                    else
+                      compiler.compile
+                    end
+
+          if results.empty?
+            puts Rainbow(t('no_scopes')).yellow
+            return
+          end
+
+          results.each { |r| print_result(r) }
+          print_warnings(results) if options[:verbose]
+          compiler.write_results(results) unless options[:simulate]
+          print_summary(results)
+          abort_if_failed(results)
+        end
+
+        private
+
+        def t(key, **)
+          ::I18n.t("rosett_ai.cli.config.#{key}", **)
+        end
+
+        def resolve_engine_name
+          options[:engine] || RosettAi.rai_config.default_engine
+        end
+
+        def resolve_config_compiler(simulate: false, masking: false)
+          engine_name = resolve_engine_name
+
+          unless RosettAi::Plugins::Registry.registered?(:engine, engine_name)
+            available = RosettAi::Plugins::Registry.available(:engine)
+            raise ::Thor::Error,
+                  t('engine_not_found',
+                    engine: engine_name,
+                    hint: engine_hint(available, engine_name))
+          end
+
+          plugin = RosettAi::Plugins::Registry.plugin_module(:engine, engine_name)
+          unless plugin.respond_to?(:config_compiler_class) && plugin.config_compiler_class
+            raise ::Thor::Error,
+                  t('no_config_compiler', engine: engine_name)
+          end
+
+          secret_resolver = masking ? RosettAi::Config::MaskingSecretResolver.new : nil
+          plugin.config_compiler_class.new(simulate: simulate, secret_resolver: secret_resolver)
+        end
+
+        def engine_hint(available, engine_name)
+          if available.empty?
+            t('no_engines_hint', package: "rosett-ai-engine-#{engine_name.tr('_', '-')}")
+          else
+            t('available_engines', engines: available.join(', '))
+          end
+        end
+
+        def find_scope_file(scope, compiler)
+          dir = if compiler.respond_to?(:config_dir,
+                                        true)
+                  compiler.send(:config_dir)
+                else
+                  RosettAi.paths.claude_code_config_dir
+                end
+          path = dir.join("#{scope}.yml")
+          unless path.exist?
+            scopes = compiler.discover_scope_files.map { |f| File.basename(f, '.yml') }
+            raise ::Thor::Error,
+                  t('scope_not_found', path: path, scopes: scopes.join(', '))
+          end
+
+          path.to_s
+        end
+
+        def print_result(result)
+          return print_verbose_unchanged(result) if result.action == :unchanged
+
+          icon = action_icon(result.action)
+          message = result_message(result, icon)
+          puts message if message
+          puts result.diff if result.action == :updated && result.diff && options[:verbose]
+          result.warnings.each { |w| puts "    #{w}" } if result.action == :skipped
+        end
+
+        def print_verbose_unchanged(result)
+          return unless options[:verbose]
+
+          source = result.source_path ? File.basename(result.source_path) : '?'
+          puts "\u2500 #{Rainbow(t('unchanged', source: source)).cyan}"
+        end
+
+        def result_message(result, icon)
+          source = result.source_path ? File.basename(result.source_path) : '?'
+          target = result.target_path ? result.target_path.to_s.sub(Dir.home, '~') : '?'
+
+          case result.action
+          when :created then "#{icon} #{Rainbow(t('compiled', source: source, target: target)).green}"
+          when :updated then "#{icon} #{Rainbow(t('config_updated', source: source, target: target)).yellow}"
+          when :skipped then "#{icon} #{Rainbow(t('skipped', source: source)).red}"
+          end
+        end
+
+        def print_warnings(results)
+          warnings = results.flat_map(&:warnings).reject(&:empty?)
+          return if warnings.empty?
+
+          puts
+          warnings.each { |w| warn "\u26A0 #{w}" }
+        end
+
+        def print_summary(results)
+          counts = results.group_by(&:action).transform_values(&:size)
+
+          rows = counts.map do |action, count|
+            [format_action(action), count]
+          end
+
+          return if rows.empty?
+
+          puts
+          table = ::Terminal::Table.new(
+            title: Rainbow(t('summary_title')).bright,
+            headings: ['Action', 'Count'],
+            rows: rows,
+            style: { border: :unicode_round }
+          )
+          puts table
+        end
+
+        def abort_if_failed(results)
+          failed = results.select { |r| r.action == :skipped }
+          return if failed.empty?
+
+          raise ::Thor::Error, t('failed_compilation', count: failed.size)
+        end
+
+        def action_icon(action)
+          case action
+          when :created, :updated then "\u2713"
+          when :unchanged         then "\u2500"
+          when :skipped           then "\u2717"
+          end
+        end
+
+        def format_action(action)
+          case action
+          when :created   then Rainbow('Created').green
+          when :updated   then Rainbow('Updated').yellow
+          when :unchanged then Rainbow('Unchanged').cyan
+          when :skipped   then Rainbow('Skipped').red
+          end
+        end
+
+        def print_compiled_json(scope_path, compiler)
+          result = compiler.compile_scope(scope_path)
+
+          if result.action == :skipped
+            result.warnings.each { |w| puts Rainbow(w).red }
+            raise ::Thor::Error, t('failed_to_compile', basename: File.basename(scope_path))
+          end
+
+          puts Rainbow(JSON.pretty_generate(result.json_data)).bright
+          print_show_warnings(result.warnings)
+        end
+
+        def print_raw_source(scope_path)
+          data = RosettAi::YamlLoader.load_file(scope_path)
+          sanitized = RosettAi::TextSanitizer.sanitize_for_display(data)
+          puts YAML.dump(sanitized)
+        end
+
+        def print_show_warnings(warnings)
+          return if warnings.empty?
+
+          puts
+          warnings.each { |w| puts "\u26A0 #{Rainbow(w).yellow}" }
+        end
+      end
+    end
+  end
+end

data/lib/rosett_ai/thor/tasks/content.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+require 'thor'
+require 'rainbow'
+require 'terminal-table'
+
+module RosettAi
+  module Thor
+    module Tasks
+      # Thor task for premium content pack management.
+      #
+      # Content packs are signed tarballs of YAML files downloaded from
+      # the NeatNerds content server. License tier is checked before
+      # download — software functionality is never restricted.
+      class Content < ::Thor
+        desc 'list', 'Show installed content packs'
+        long_desc <<~LONGDESC
+          Lists installed content packs with version, tier, and description.
+
+          Flags:
+            --available: Show all available packs from content server with tier labels
+
+          EXAMPLES
+
+            raictl content list
+            raictl content list --available
+
+          Related commands: raictl content install, rai content update
+        LONGDESC
+        method_option :available, type: :boolean, default: false,
+                                  desc: 'Show all available packs with tier labels'
+        def list
+          if options[:available]
+            list_available
+          else
+            list_installed
+          end
+        end
+
+        desc 'install PACK_NAME', 'Download, verify, and install a content pack'
+        long_desc <<~LONGDESC
+          Downloads, verifies signature, and installs a premium content pack.
+          Requires appropriate license tier for the content pack being installed.
+
+          Exit codes: 1 if pack not found or license tier insufficient
+
+          EXAMPLES
+
+            raictl content install security_behaviours
+
+          Related commands: raictl content list --available, rai license status
+        LONGDESC
+        def install(pack_name)
+          result = validate_license!
+          tier = result[:tier]
+
+          client = build_client
+          catalog = client.catalog(tier: tier.name.to_s)
+          pack_info = catalog&.find { |entry| entry['name'] == pack_name }
+
+          raise ::Thor::Error, t('install.not_found', name: pack_name) unless pack_info
+
+          required_tier = RosettAi::Licensing::Tier.new(pack_info['tier_required'])
+          unless tier.entitled_to?(required_tier)
+            raise ::Thor::Error, t('install.tier_required', name: pack_name, required: required_tier,
+                                                            current: tier)
+          end
+
+          download_and_install(client, pack_name, pack_info['version'])
+        rescue RosettAi::ContentError => e
+          raise ::Thor::Error, e.message
+        end
+
+        desc 'update', 'Re-download all installed content packs (subscriber tier)'
+        long_desc <<~LONGDESC
+          Re-downloads and updates all installed content packs to latest versions.
+          Requires valid license. Displays warning if offline but continues gracefully.
+
+          EXAMPLES
+
+            raictl content update
+
+          Related commands: raictl content list, rai license status
+        LONGDESC
+        def update
+          validate_license!
+          registry = RosettAi::Content::PackRegistry.new
+          packs = registry.installed
+
+          if packs.empty?
+            puts Rainbow(t('list.no_packs')).yellow
+            return
+          end
+
+          client = build_client
+          packs.each do |manifest|
+            puts t('update.checking', name: manifest.name)
+            download_and_install(client, manifest.name, manifest.version)
+          end
+          puts Rainbow(t('update.success')).green
+        rescue RosettAi::ContentError => e
+          puts Rainbow(t('update.offline')).yellow
+          puts Rainbow(e.message).red
+        end
+
+        private
+
+        def t(key, **)
+          ::I18n.t("rosett_ai.cli.content.#{key}", **)
+        end
+
+        def validate_license!
+          result = RosettAi::Licensing::LicenseValidator.new.validate
+          return result if result[:valid]
+
+          raise ::Thor::Error, t('install.tier_required', name: '', required: 'Supporter',
+                                                          current: result[:tier])
+        end
+
+        def build_client
+          store = RosettAi::Licensing::LicenseStore.new
+          raw_key = store.load || ''
+          RosettAi::Content::ContentClient.new(license_key: raw_key)
+        end
+
+        def download_and_install(client, pack_name, version)
+          puts t('install.downloading', name: pack_name)
+          tarball = client.download(pack_name, version: version)
+
+          puts t('install.verifying')
+          signature = client.download_signature(pack_name, version: version)
+
+          installer = RosettAi::Content::PackInstaller.new
+          manifest = installer.install(tarball, signature, pack_name)
+
+          puts Rainbow(t('install.success', name: manifest.name, version: manifest.version,
+                                            behaviours: manifest.behaviour_files.size,
+                                            designs: manifest.design_files.size)).green
+        end
+
+        def list_installed
+          registry = RosettAi::Content::PackRegistry.new
+          packs = registry.installed
+
+          if packs.empty?
+            puts Rainbow(t('list.no_packs')).yellow
+            return
+          end
+
+          rows = packs.map do |manifest|
+            [manifest.name, manifest.version, manifest.tier_required, manifest.description]
+          end
+
+          table = ::Terminal::Table.new(
+            title: Rainbow(t('list.header')).bright,
+            headings: [t('list.name'), t('list.version_col'), t('list.tier'), t('list.description')],
+            rows: rows,
+            style: { border: :unicode_round }
+          )
+          puts table
+        end
+
+        def list_available
+          validate_license!
+          client = build_client
+          catalog = client.catalog(tier: 'all')
+
+          if catalog.nil? || catalog.empty?
+            puts Rainbow(t('list.no_packs')).yellow
+            return
+          end
+
+          rows = catalog.map do |pack|
+            [pack['name'], pack['version'], pack['tier_required'], pack['description']]
+          end
+
+          table = ::Terminal::Table.new(
+            title: Rainbow(t('list.available_header')).bright,
+            headings: [t('list.name'), t('list.version_col'), t('list.tier'), t('list.description')],
+            rows: rows,
+            style: { border: :unicode_round }
+          )
+          puts table
+        rescue RosettAi::ContentError => e
+          puts Rainbow(e.message).red
+        end
+      end
+    end
+  end
+end