rosett-ai 1.3.3

data/lib/rosett_ai/thor/cli.rb

@@ -0,0 +1,269 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+require 'thor'
+require 'rainbow'
+
+module RosettAi
+  module Thor
+    # Main CLI entry point for Rosett-AI commands
+    class CLI < ::Thor
+      INTERNAL_COMMANDS = ['build', 'release', 'documentation', 'dbus', 'desktop'].freeze
+
+      def self.exit_on_failure?
+        true
+      end
+
+      # rubocop:disable Style/OptionalBooleanParameter -- matches Thor's API
+      def self.printable_commands(all = true, subcommand = false)
+        # rubocop:enable Style/OptionalBooleanParameter
+        cmds = super
+        return cmds if RosettAi.context.rai_internal?
+
+        cmds.reject do |row|
+          words = row.first.split
+          INTERNAL_COMMANDS.include?(words[1])
+        end
+      end
+
+      package_name 'raictl'
+
+      class_option :accessible, type: :boolean, default: false,
+                                desc: 'Enable accessible output mode'
+      class_option :locale, type: :string, default: nil,
+                            desc: 'Display output in specified locale'
+      class_option :ui, type: :string, default: nil,
+                        enum: ['tui', 'gtk4', 'qt6', 'kde'],
+                        desc: 'UI adapter to use'
+
+      map ['-v', '--version'] => :version
+
+      no_commands do # rubocop:disable Metrics/BlockLength -- telemetry helpers extend invoke_command
+        def invoke_command(command, *args)
+          cmd_name = command.name
+          if INTERNAL_COMMANDS.include?(cmd_name) && !RosettAi.context.rai_internal?
+            raise ::Thor::Error, ::I18n.t('rosett_ai.cli.internal_only', command: cmd_name)
+          end
+
+          RosettAi.setup_i18n(locale: options[:locale]) if options[:locale]
+          telemetry = start_telemetry(cmd_name)
+          super
+          finish_telemetry(telemetry, 'success')
+        rescue Errno::EACCES, Errno::ENOENT => e
+          handle_system_error(telemetry, e)
+        rescue RosettAi::Error => e
+          finish_telemetry(telemetry, 'error', error_class: e.class.name)
+          exit_code = RosettAi::ErrorHandler.handle(stderr: $stderr) { raise e }
+          exit exit_code
+        end
+
+        def handle_system_error(telemetry, error)
+          finish_telemetry(telemetry, 'error', error_class: error.class.name)
+          if error.is_a?(Errno::EACCES)
+            path = error.message.sub(/^Permission denied @ .+ - /, '')
+            warn Rainbow(::I18n.t('rosett_ai.errors.permission_denied', path: path)).red
+            exit RosettAi::ExitCodes::PERMISSION
+          else
+            warn Rainbow(error.message).red
+            exit RosettAi::ExitCodes::GENERAL
+          end
+        end
+
+        def start_telemetry(command_name)
+          return unless RosettAi::Telemetry.enabled?
+
+          RosettAi::Telemetry.reporter.command_start(command: command_name)
+          { command: command_name, start: Process.clock_gettime(Process::CLOCK_MONOTONIC) }
+        end
+
+        def finish_telemetry(context, status, **extra)
+          return unless context
+
+          duration = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - context[:start]) * 1000
+          RosettAi::Telemetry.reporter.command_end(
+            command: context[:command], duration_ms: duration.round(1), status: status, **extra
+          )
+        end
+      end
+
+      desc 'version', 'Display rosett-ai version'
+      def version
+        puts ::I18n.t('rosett_ai.cli.version', version: RosettAi::VERSION)
+        build_info = RosettAi.root.join('..', 'etc', 'BUILD_INFO')
+        return unless build_info.exist?
+
+        info = parse_build_info(build_info)
+        puts "  commit:  #{info['commit']}" if info['commit']
+        puts "  branch:  #{info['branch']}" if info['branch']
+        puts "  built:   #{info['build_date']}" if info['build_date']
+        puts "  variant: #{info['variant']}" if info['variant']
+      end
+
+      no_commands do
+        def parse_build_info(path)
+          path.read.each_line.with_object({}) do |line, hash|
+            key, value = line.strip.split('=', 2)
+            hash[key] = value if key && value
+          end
+        end
+      end
+
+      desc 'documentation SUBCOMMAND', 'Manage and generate project documentation'
+      subcommand 'documentation', RosettAi::Thor::Tasks::Documentation
+
+      desc 'behaviour SUBCOMMAND', 'Manage behaviour configuration files'
+      subcommand 'behaviour', RosettAi::Thor::Tasks::Behaviour
+
+      desc 'compile', 'Compile YAML configurations into markdown rule files'
+      subcommand 'compile', RosettAi::Thor::Tasks::Compile
+
+      desc 'adopt', 'Analyze compiled rule files for issues'
+      subcommand 'adopt', RosettAi::Thor::Tasks::Adopt
+
+      desc 'init', 'Initialize rosett-ai directory structure'
+      subcommand 'init', RosettAi::Thor::Tasks::Init
+
+      desc 'backup', 'Back up rosett-ai directory structure and assets'
+      subcommand 'backup', RosettAi::Thor::Tasks::Backup
+
+      desc 'build SUBCOMMAND', 'Build .deb packages for core and engine plugins'
+      subcommand 'build', RosettAi::Thor::Tasks::Build
+
+      desc 'validate', 'Validate all configuration files (behaviour, design, tooling)'
+      subcommand 'validate', RosettAi::Thor::Tasks::Validate
+
+      desc 'doctor', 'Run diagnostic checks on rosett-ai environment'
+      subcommand 'doctor', RosettAi::Thor::Tasks::Doctor
+
+      desc 'migrate', 'Migrate legacy .nncc and ~/.config/nncc paths'
+      subcommand 'migrate', RosettAi::Thor::Tasks::Migrate
+
+      desc 'design SUBCOMMAND', 'Manage design documents and schemas'
+      subcommand 'design', RosettAi::Thor::Tasks::Design
+
+      desc 'config SUBCOMMAND', 'Compile and inspect AI tool configurations'
+      subcommand 'config', RosettAi::Thor::Tasks::Config
+
+      desc 'tooling SUBCOMMAND', 'Validate CI/CD files and check version consistency'
+      subcommand 'tooling', RosettAi::Thor::Tasks::Tooling
+
+      desc 'license SUBCOMMAND', 'Manage license keys (activate, status, deactivate)'
+      subcommand 'license', RosettAi::Thor::Tasks::License
+
+      desc 'content SUBCOMMAND', 'Install and manage premium content packs'
+      subcommand 'content', RosettAi::Thor::Tasks::Content
+
+      desc 'release SUBCOMMAND', 'Prepare, tag, and track releases'
+      subcommand 'release', RosettAi::Thor::Tasks::Release
+
+      desc 'engines SUBCOMMAND', 'Detect and manage AI engine plugins'
+      subcommand 'engines', RosettAi::Thor::Tasks::Engines
+
+      desc 'provenance SUBCOMMAND', 'Track AI contributions and authorship'
+      subcommand 'provenance', RosettAi::Thor::Tasks::Provenance
+
+      desc 'comply', 'Run compliance checks (CRA, license, SPDX headers)'
+      subcommand 'comply', RosettAi::Thor::Tasks::Comply
+
+      desc 'workflow SUBCOMMAND', 'Run and manage declarative workflows'
+      subcommand 'workflow', RosettAi::Thor::Tasks::Workflow
+
+      desc 'project SUBCOMMAND', 'Inspect and manage project lifecycle'
+      subcommand 'project', RosettAi::Thor::Tasks::Project
+
+      desc 'retrofit SUBCOMMAND', 'Reverse-compile native configs to Rosett-AI YAML'
+      subcommand 'retrofit', RosettAi::Thor::Tasks::Retrofit
+
+      desc 'hooks SUBCOMMAND', 'Install and manage git hooks'
+      subcommand 'hooks', RosettAi::Thor::Tasks::Hooks
+
+      desc 'mcp SUBCOMMAND', 'Manage MCP servers and run security audits'
+      subcommand 'mcp', RosettAi::Thor::Tasks::Mcp
+
+      desc 'completion SUBCOMMAND', 'Generate shell completion scripts'
+      subcommand 'completion', RosettAi::Thor::Tasks::Completion
+
+      desc 'dbus SUBCOMMAND', 'Start and monitor the D-Bus session service'
+      subcommand 'dbus', RosettAi::Thor::Tasks::DBus
+
+      desc 'desktop SUBCOMMAND', 'Launch desktop GUI applications'
+      subcommand 'desktop', RosettAi::Thor::Tasks::Desktop
+
+      desc 'plugins SUBCOMMAND', 'List, install, and remove plugins'
+      subcommand 'plugins', RosettAi::Thor::Tasks::Plugins
+
+      desc 'tree', 'Print a tree of all available commands'
+      def tree
+        say 'rai', :blue
+        leaves, groups = tree_partition_entries(self.class)
+        tree_render_entries(leaves, groups, '  ')
+      end
+
+      RosettAi::SmartFeedback::ThorMiddleware.install(self)
+
+      private
+
+      # Partition a Thor class's entries into leaf commands and expandable groups.
+      def tree_partition_entries(klass)
+        groups = tree_visible_subcommands(klass).sort_by(&:first)
+        group_set = groups.to_set(&:first)
+        leaves = tree_leaf_commands(klass, group_set).sort_by(&:first)
+        [leaves, groups]
+      end
+
+      # Returns leaf commands: visible commands that aren't also subcommand groups,
+      # plus subcommand aliases that have no visible children (compile, adopt, etc.).
+      def tree_leaf_commands(klass, group_set)
+        all_subcmd_names = klass.subcommand_classes.keys
+        visible = tree_visible_commands(klass).except(*all_subcmd_names)
+        subcmd_aliases = all_subcmd_names
+          .reject { |name| group_set.include?(name) }
+          .select { |name| klass.commands.key?(name) }
+          .map { |name| [name, klass.commands[name]] }
+        visible.to_a + subcmd_aliases
+      end
+
+      def tree_render_entries(leaves, groups, indent)
+        total = leaves.size + groups.size
+        leaves.each_with_index { |(name, cmd), i| tree_print_leaf(name, cmd, indent, i + 1 == total) }
+        groups.each_with_index do |(name, subclass), i|
+          tree_print_group(name, subclass, indent, leaves.size + i + 1 == total)
+        end
+      end
+
+      def tree_print_leaf(name, cmd, indent, last)
+        icon = last ? "\u2514\u2500" : "\u251C\u2500"
+        desc = cmd.description.split("\n").first || ''
+        say "#{indent}#{icon} ", nil, false
+        say name, :green, false
+        say " (#{desc})" unless desc.empty?
+      end
+
+      def tree_print_group(name, klass, indent, last)
+        icon = last ? "\u2514\u2500" : "\u251C\u2500"
+        pipe = last ? '   ' : "\u2502  "
+        say "#{indent}#{icon} ", nil, false
+        say name, :cyan
+        leaves, children = tree_partition_entries(klass)
+        tree_render_entries(leaves, children, "#{indent}#{pipe}")
+      end
+
+      def tree_visible_commands(klass)
+        default = klass.respond_to?(:default_task) ? klass.default_task.to_s : nil
+        hidden = ['help', 'tree']
+        filtered = klass.commands.reject { |name, cmd| cmd.hidden? || hidden.include?(name) || name == default }
+        return filtered if RosettAi.context.rai_internal?
+
+        filtered.except(*INTERNAL_COMMANDS)
+      end
+
+      def tree_visible_subcommands(klass)
+        klass.subcommand_classes.select do |_, subclass|
+          !tree_visible_commands(subclass).empty? || !tree_visible_subcommands(subclass).empty?
+        end
+      end
+    end
+  end
+end

data/lib/rosett_ai/thor/tasks/adopt.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 'thor'
+require 'terminal-table'
+require 'rainbow'
+require 'tty-spinner'
+
+module RosettAi
+  module Thor
+    module Tasks
+      # Thor task for analyzing compiled rule files using the Claude API
+      class Adopt < ::Thor
+        default_task :analyze
+
+        desc 'analyze', 'Analyze compiled rule files for issues'
+        long_desc <<~LONGDESC
+          Analyzes compiled rule files for structural issues, anti-patterns, and policy violations.
+          By default, runs local-only structural checks. Use --api to enable remote AI analysis.
+
+          Flags:
+            --elaborate: Show detailed explanation column in findings table
+            --verbose: Show processing details and sensitive file list
+            --api: Enable remote API analysis (requires engine with executor)
+            --quorum: Run analysis across all available engines (requires --api)
+
+          EXAMPLES
+
+            raictl adopt
+            raictl adopt --verbose --elaborate
+            raictl adopt --api
+            raictl adopt --api --quorum
+
+          Related commands: raictl compile, rai behaviour validate
+        LONGDESC
+        method_option :elaborate,
+                      type: :boolean,
+                      default: false,
+                      desc: 'Show detailed explanation column'
+        method_option :verbose,
+                      type: :boolean,
+                      default: false,
+                      desc: 'Show processing details'
+        method_option :local,
+                      type: :boolean,
+                      default: true,
+                      desc: 'Local-only structural checks, no API calls (default)'
+        method_option :api,
+                      type: :boolean,
+                      default: false,
+                      desc: 'Enable remote API analysis (requires engine with executor)'
+        method_option :quorum,
+                      type: :boolean,
+                      default: false,
+                      desc: 'Run analysis across all available engines (requires --api)'
+
+        def analyze
+          adopter = build_adopter
+          files = adopter.discover_managed_files
+
+          if files.empty?
+            puts Rainbow(t('no_files')).yellow
+            return
+          end
+
+          log_verbose(t('found_files', count: files.size))
+
+          sensitive = adopter.sensitive_files
+          log_verbose(t('sensitive_skipped', count: sensitive.size)) unless sensitive.empty?
+          if options[:verbose] && !sensitive.empty?
+            sensitive.each { |f| puts "  #{Rainbow(File.basename(f)).yellow} #{t('sensitive_label')}" }
+          end
+
+          outcome = run_analysis(adopter)
+          print_results(outcome)
+        end
+
+        private
+
+        def t(key, **)
+          ::I18n.t("rosett_ai.cli.adopt.#{key}", **)
+        end
+
+        def build_adopter
+          xdg_conf = RosettAi.paths.rai_conf_dir
+          RosettAi::Adopter::RuleAdopter.new(
+            rules_dir: rules_dir,
+            cache_path: xdg_conf.join('adopt.cache.yml'),
+            redactions_path: xdg_conf.join('adopt_redactions.yml'),
+            engine: RosettAi.rai_config.default_engine
+          )
+        end
+
+        def rules_dir
+          RosettAi.paths.rules_dir
+        end
+
+        def run_analysis(adopter)
+          unless options[:api]
+            log_verbose(t('local_checks'))
+            return adopter.evaluate(local_only: true)
+          end
+
+          return run_quorum_analysis(adopter) if options[:quorum]
+
+          run_remote_analysis(adopter)
+        end
+
+        def run_remote_analysis(adopter)
+          spinner = TTY::Spinner.new(
+            "[:spinner] #{t('analyzing')}",
+            format: :dots,
+            clear: true
+          )
+          spinner.auto_spin
+
+          outcome = adopter.evaluate(local_only: false)
+          if outcome[:cached]
+            spinner.success(Rainbow(t('cached')).cyan)
+            log_verbose(t('cache_hit'))
+          else
+            spinner.success(Rainbow(t('done')).green)
+          end
+          outcome
+        rescue StandardError => e
+          spinner.error(Rainbow(t('failed')).red)
+          raise ::Thor::Error, t('error_prefix', message: e.message)
+        end
+
+        def run_quorum_analysis(adopter)
+          strategy = build_quorum_strategy
+          prompt = adopter.build_prompt(adopter.discover_managed_files)
+          result = run_quorum_with_spinner(strategy, prompt)
+          { result: result, sensitive_skipped: adopter.sensitive_files, cached: false }
+        end
+
+        def build_quorum_strategy
+          api_key = RosettAi::SecretsResolver.resolve('ANTHROPIC_API_KEY')
+          strategy = RosettAi::Quorum::Strategies::Adopt.new(api_key: api_key)
+          log_verbose("Quorum engines: #{strategy.eligible_engines.join(', ')}")
+          strategy
+        end
+
+        def run_quorum_with_spinner(strategy, prompt)
+          spinner = TTY::Spinner.new('[:spinner] Quorum analysis...', format: :dots, clear: true)
+          spinner.auto_spin
+          result = strategy.run(prompt)
+          spinner.success(Rainbow('done').green)
+          result
+        rescue StandardError => e
+          spinner.error(Rainbow('failed').red)
+          raise ::Thor::Error, "Quorum analysis failed: #{e.message}"
+        end
+
+        def print_results(outcome)
+          result = outcome[:result]
+          findings = result['findings'] || []
+
+          puts
+          print_status_line(result['overall_status'] || 'unknown', result['summary'] || '')
+          print_findings(findings)
+          print_sensitive_skipped(outcome[:sensitive_skipped])
+        end
+
+        def print_findings(findings)
+          if findings.empty?
+            puts Rainbow("  #{t('no_issues')}").green
+            return
+          end
+
+          findings.group_by { |f| f['category'] }.each do |category, items|
+            print_category_table(category, items)
+          end
+        end
+
+        def print_sensitive_skipped(skipped)
+          return unless options[:verbose] && skipped&.any?
+
+          puts
+          puts Rainbow(t('sensitive_skipped_title')).yellow
+          skipped.each { |f| puts "  #{File.basename(f)}" }
+        end
+
+        def print_status_line(status, summary)
+          colored_status = case status
+                           when 'pass' then Rainbow('PASS').green.bright
+                           when 'warn' then Rainbow('WARN').yellow.bright
+                           when 'fail' then Rainbow('FAIL').red.bright
+                           else Rainbow(status.upcase).white
+                           end
+          puts "Status: #{colored_status}  #{summary}"
+          puts
+        end
+
+        def print_category_table(category, findings)
+          has_engine = findings.any? { |f| f['engine'] || f['engines'] }
+          headings = category_headings(has_engine)
+          rows = findings.map { |f| finding_row(f, has_engine) }
+
+          table = ::Terminal::Table.new(
+            title: Rainbow(category.capitalize).bright,
+            headings: headings, rows: rows,
+            style: { border: :unicode_round }
+          )
+          puts table
+          puts
+        end
+
+        def category_headings(has_engine)
+          headings = ['Severity', 'File', 'Rule', 'Summary']
+          headings << 'Engine' if has_engine
+          headings << 'Explanation' if options[:elaborate]
+          headings
+        end
+
+        def finding_row(finding, has_engine)
+          sanitized = RosettAi::TextSanitizer.sanitize_for_display(finding)
+          row = [colorize_severity(sanitized['severity']),
+                 sanitized['file'] || 'N/A',
+                 sanitized['rule_id'] || 'N/A',
+                 sanitized['summary'] || '']
+          row << engine_label(finding) if has_engine
+          row << (sanitized['explanation'] || '') if options[:elaborate]
+          row
+        end
+
+        def engine_label(finding)
+          engines = finding['engines'] || [finding['engine']].compact
+          engines.join(', ')
+        end
+
+        def colorize_severity(severity)
+          case severity
+          when 'critical' then Rainbow(severity).red.bright
+          when 'high' then Rainbow(severity).red
+          when 'medium' then Rainbow(severity).yellow
+          when 'low' then Rainbow(severity).cyan
+          else severity
+          end
+        end
+
+        def log_verbose(message)
+          puts "  #{message}" if options[:verbose]
+        end
+      end
+    end
+  end
+end