rosett-ai 1.3.3

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

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+require 'terminal-table'
+
+module RosettAi
+  module Thor
+    module Tasks
+      # Thor CLI for git hook management.
+      #
+      # Provides install, uninstall, list, and status subcommands
+      # for managing Rosett-AI-integrated git hooks.
+      #
+      # @author hugo
+      # @author claude
+      class Hooks < ::Thor
+        desc 'install', 'Install configured git hooks from .rosett-ai/config.yml'
+        long_desc <<~LONGDESC
+          Install git hooks defined in .rosett-ai/config.yml to the project's
+          .git/hooks/ directory. Detects existing hook managers (overcommit,
+          husky, lefthook) and chains with them when possible.
+
+          Hooks are defined as shell command arrays to prevent injection.
+          Use --verbose to see detected hook managers.
+
+          Exit codes: 0 success, 1 install errors, 3 no config.
+
+          EXAMPLES
+
+            raictl hooks install
+            raictl hooks install --verbose
+
+          Related: hooks uninstall, hooks status
+        LONGDESC
+        method_option :verbose, type: :boolean, default: false, desc: 'Show detailed output'
+        def install
+          config = load_hooks_config
+          return exit_with_error(t('no_config')) if config.empty?
+
+          installer = RosettAi::GitHooks::Installer.new(
+            project_root: project_root,
+            hooks_config: config
+          )
+
+          detect_existing_hooks(installer) if options[:verbose]
+          results = installer.install
+          render_install_results(results)
+          exit(results[:errors].empty? ? 0 : 1)
+        end
+
+        desc 'uninstall', 'Remove rai hooks and restore previous hooks'
+        long_desc <<~LONGDESC
+          Remove all Rosett-AI-installed hooks and restore any previously backed-up
+          hooks. Does not affect hooks installed by other managers.
+
+          EXAMPLES
+
+            raictl hooks uninstall
+
+          Related: hooks install, hooks status
+        LONGDESC
+        def uninstall
+          installer = build_installer({})
+          results = installer.uninstall
+          render_uninstall_results(results)
+          exit(results[:errors].empty? ? 0 : 1)
+        end
+
+        desc 'list', 'Show installed rai hooks'
+        long_desc <<~LONGDESC
+          List all currently installed rai hooks with their configured
+          commands. Use --format json for machine-readable output.
+
+          EXAMPLES
+
+            raictl hooks list
+            raictl hooks list --format json
+
+          Related: hooks status, hooks install
+        LONGDESC
+        method_option :format, type: :string, default: 'table', enum: ['table', 'json'], desc: 'Output format'
+        def list
+          installer = build_installer({})
+          hooks = installer.list
+
+          if hooks.empty?
+            say(t('no_hooks_installed'))
+            return
+          end
+
+          render_list(hooks)
+        end
+
+        desc 'status', 'Show hook installation status and detect drift'
+        long_desc <<~LONGDESC
+          Compare installed hooks against .rosett-ai/config.yml and report drift.
+
+          Shows four categories: in sync, missing (configured but not
+          installed), drifted (installed but modified), and extra (installed
+          but not configured).
+
+          Exit codes: 0 all in sync, 1 drift detected.
+
+          EXAMPLES
+
+            raictl hooks status
+            raictl hooks status --format json
+
+          Related: hooks install, hooks list
+        LONGDESC
+        method_option :format, type: :string, default: 'table', enum: ['table', 'json'], desc: 'Output format'
+        def status
+          config = load_hooks_config
+          installer = RosettAi::GitHooks::Installer.new(
+            project_root: project_root,
+            hooks_config: config
+          )
+
+          result = installer.status
+          render_status(result)
+
+          all_synced = result[:missing].empty? && result[:drifted].empty? && result[:extra].empty?
+          exit(all_synced ? 0 : 1)
+        end
+
+        private
+
+        def t(key, **args)
+          ::I18n.t("rosett_ai.hooks.#{key}", **args)
+        end
+
+        def project_root
+          Pathname.new(ENV.fetch('RAI_ORIGINAL_PWD', Dir.pwd))
+        end
+
+        def load_hooks_config
+          config_path = project_root.join('.rosett-ai', 'config.yml')
+          return {} unless config_path.exist?
+
+          data = YAML.safe_load_file(config_path, permitted_classes: [Symbol]) || {}
+          data.fetch('hooks', {})
+        end
+
+        def build_installer(config)
+          RosettAi::GitHooks::Installer.new(
+            project_root: project_root,
+            hooks_config: config
+          )
+        end
+
+        def detect_existing_hooks(_installer)
+          detector = RosettAi::GitHooks::ChainDetector.new(project_root: project_root)
+          managers = detector.detect
+
+          return if managers.empty?
+
+          say(t('detected_managers', managers: managers.map { |m| m[:name] }.join(', ')))
+        end
+
+        def exit_with_error(message)
+          warn(Rainbow(message).red)
+          exit(3)
+        end
+
+        def render_install_results(results)
+          results[:installed].each { |h| say(Rainbow("  installed #{h}").green) }
+          results[:skipped].each { |h| say(Rainbow("  skipped #{h}").yellow) }
+          results[:errors].each { |e| warn(Rainbow("  error: #{e}").red) }
+
+          total = results[:installed].size
+          say(t('install_summary', count: total)) if total.positive?
+        end
+
+        def render_uninstall_results(results)
+          results[:removed].each { |h| say(Rainbow("  removed #{h}").green) }
+          results[:restored].each { |h| say(Rainbow("  restored #{h}").cyan) }
+          results[:errors].each { |e| warn(Rainbow("  error: #{e}").red) }
+
+          total = results[:removed].size
+          say(t('uninstall_summary', count: total)) if total.positive?
+        end
+
+        def render_list(hooks)
+          if options[:format] == 'json'
+            say(JSON.pretty_generate(hooks))
+            return
+          end
+
+          table = ::Terminal::Table.new(
+            headings: ['Hook', 'Commands'],
+            rows: hooks.map { |h| [h[:name], h[:commands].join(', ')] }
+          )
+          say(table)
+        end
+
+        def render_status(result)
+          if options[:format] == 'json'
+            say(JSON.pretty_generate(result))
+            return
+          end
+
+          render_status_section('In sync', result[:in_sync], :green)
+          render_status_section('Missing', result[:missing], :yellow)
+          render_status_section('Drifted', result[:drifted], :red)
+          render_status_section('Extra', result[:extra], :cyan)
+        end
+
+        def render_status_section(label, hooks, color)
+          return if hooks.empty?
+
+          say("#{label}:")
+          hooks.each { |h| say(Rainbow("  #{h}").color(color)) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,259 @@
+# 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 initializing rai project structure
+      class Init < ::Thor
+        default_task :setup
+
+        PROJECT_DIRS = ['conf', 'conf/behaviour', 'conf/design'].freeze
+
+        desc 'setup', 'Initialize rai project structure'
+        long_desc <<~LONGDESC
+          Initializes Rosett-AI directory structures and configuration files.
+          Can set up global (~/.claude/), local (.claude/), or project (.rosett-ai/) structures.
+
+          Flags:
+            --global: Set up global ~/.claude/ structure
+            --local: Set up project-local .claude/ structure
+            --project: Set up rai project structure (.rosett-ai/, config.yml)
+            --no-compile: Skip the compile step after initialization
+
+          At least one of --global, --local, or --project must be specified.
+          Automatically runs compile unless --no-compile is used.
+
+          EXAMPLES
+
+            raictl init --global
+            raictl init --global --local
+            raictl init --project
+            raictl init --global --no-compile
+        LONGDESC
+        method_option :global,
+                      type: :boolean,
+                      default: false,
+                      desc: 'Set up global ~/.claude/ structure'
+        method_option :local,
+                      type: :boolean,
+                      default: false,
+                      desc: 'Set up project-local .claude/ structure'
+        method_option :project,
+                      type: :boolean,
+                      default: false,
+                      desc: 'Set up rai project structure (.rosett-ai/, config.yml)'
+        method_option :no_compile,
+                      type: :boolean,
+                      default: false,
+                      desc: 'Skip the compile step'
+
+        def setup
+          raise ::Thor::Error, t('no_scope') unless options[:global] || options[:local] || options[:project]
+
+          results = { created: 0, ok: 0, skipped: 0 }
+          setup_global(results)  if options[:global]
+          setup_project(results) if options[:project]
+          setup_local(results)   if options[:local]
+          run_compile unless options[:no_compile]
+          print_summary(results)
+        end
+
+        private
+
+        def t(key, **)
+          ::I18n.t("rosett_ai.cli.init.#{key}", **)
+        end
+
+        def setup_global(results)
+          results[:global] = run_with_spinner(t('global_init')) do
+            base_dir = RosettAi.paths.global_dir.to_s
+            {
+              dirs: RosettAi::Init::DirectoryBuilder.create_global_structure(base_dir),
+              files: RosettAi::Init::FileCopier.copy_global_assets(base_dir)
+            }
+          end
+
+          config_result = RosettAi::Init::ConfigFileWriter.write_default
+          log_config_result(config_result)
+          register_mcp_server
+          run_engine_detection if RosettAi.rai_config.detect_on_init?
+        end
+
+        def setup_local(results)
+          results[:local] = run_with_spinner(t('local_init')) do
+            base_dir = RosettAi.paths.local_dir.to_s
+            {
+              dirs: RosettAi::Init::DirectoryBuilder.create_local_structure(base_dir),
+              files: RosettAi::Init::FileCopier.copy_local_assets(base_dir)
+            }
+          end
+        end
+
+        def setup_project(results)
+          project_dir = Pathname.new(RosettAi.paths.user_pwd).join('.rosett-ai')
+
+          if project_dir.directory?
+            puts Rainbow(t('project_exists', path: project_dir)).yellow
+            return
+          end
+
+          results[:project] = run_with_spinner(t('project_init')) do
+            create_project_structure(project_dir)
+          end
+        end
+
+        def create_project_structure(project_dir)
+          dirs = create_project_dirs(project_dir)
+          files = create_project_config(project_dir)
+          { dirs: dirs, files: files }
+        end
+
+        def create_project_dirs(project_dir)
+          all_dirs = [project_dir] + PROJECT_DIRS.map { |subdir| project_dir.join(subdir) }
+          all_dirs.reject(&:directory?).each { |dir| FileUtils.mkdir_p(dir) }.map(&:to_s)
+        end
+
+        def create_project_config(project_dir)
+          path = project_dir.join('config.yml')
+          return [] if path.exist?
+
+          write_project_config(path)
+          [path.to_s]
+        end
+
+        def write_project_config(path)
+          project_name = File.basename(RosettAi.paths.user_pwd)
+          content = {
+            'project_name' => project_name,
+            'default_engine' => 'claude'
+          }
+          File.open(path, 'w', 0o644) { |f| f.write(content.to_yaml) }
+        end
+
+        def run_with_spinner(message)
+          unless RosettAi::Ui::TtyHelper.interactive?
+            warn(message)
+            return yield
+          end
+
+          spinner = TTY::Spinner.new("[:spinner] #{message}", format: :dots, clear: true)
+          spinner.auto_spin
+          result = yield
+          spinner.success(Rainbow(t('done')).green)
+          result
+        rescue StandardError => e
+          spinner&.error(Rainbow(t('failed')).red)
+          raise RosettAi::InitError, t('init_failed', message: e.message)
+        end
+
+        def run_compile
+          unless RosettAi::Ui::TtyHelper.interactive?
+            warn(t('compiling'))
+            require_relative 'compile'
+            Compile.new.invoke(:generate)
+            return
+          end
+
+          spinner = TTY::Spinner.new(
+            "[:spinner] #{t('compiling')}",
+            format: :dots,
+            clear: true
+          )
+          spinner.auto_spin
+
+          require_relative 'compile'
+          Compile.new.invoke(:generate)
+        rescue RosettAi::CompileError => e
+          spinner&.error(Rainbow(t('done')).yellow)
+          puts Rainbow("  #{e.message}").yellow
+          puts Rainbow("  #{t('compile_skipped_hint')}").yellow
+        end
+
+        def print_summary(results)
+          return unless results[:global] || results[:local] || results[:project]
+
+          puts
+          table = ::Terminal::Table.new(
+            title: Rainbow(t('summary_title')).bright,
+            headings: [t('item'), t('count')],
+            rows: build_summary_rows(results),
+            style: { border: :unicode_round }
+          )
+          puts table
+        end
+
+        def build_summary_rows(results)
+          rows = []
+          add_result_rows(rows, results[:global], 'Global') if results[:global]
+          add_result_rows(rows, results[:project], 'Project') if results[:project]
+          add_result_rows(rows, results[:local], 'Local') if results[:local]
+          rows
+        end
+
+        def add_result_rows(rows, result, prefix)
+          rows << [t('dirs_created', prefix: prefix), result[:dirs].size]
+          rows << [t('files_copied', prefix: prefix), result[:files].size]
+        end
+
+        def log_config_result(result)
+          case result[:action]
+          when :created
+            puts "  #{Rainbow(t('config_created', path: result[:path])).green}"
+          when :unchanged
+            puts "  #{Rainbow(t('config_exists', path: result[:path])).cyan}"
+          end
+        end
+
+        def register_mcp_server
+          registrar = RosettAi::Init::McpRegistrar.new
+          result = registrar.register
+          log_mcp_result(result)
+        end
+
+        def log_mcp_result(result)
+          case result[:action]
+          when :registered
+            puts "  #{Rainbow(t('mcp_registered', path: result[:path])).green}"
+          when :already_registered
+            puts "  #{Rainbow(t('mcp_already_registered')).cyan}"
+          when :skipped
+            puts "  #{Rainbow(t('mcp_skipped', reason: result[:reason])).yellow}"
+          end
+        end
+
+        def run_engine_detection
+          puts
+          puts Rainbow(t('detected_engines_title')).bright
+          RosettAi::Engines::Registry.available.each do |name|
+            manifest = RosettAi::Engines::Registry.manifest(name)
+            next unless manifest.dig('components', 'detector')
+
+            detector = resolve_detector(name, manifest)
+            result = detector.detect
+            status = result[:detected] ? Rainbow(t('detected')).green : Rainbow(t('not_detected')).yellow
+            puts "  #{result[:display_name]}: #{status}"
+          end
+          puts "  #{t('edit_config_hint', path: RosettAi.paths.rai_config_dir.join('config.yml'))}"
+        end
+
+        def resolve_detector(name, manifest)
+          engine_mod = RosettAi::Engines::Registry.engine_module(name)
+          detector_klass = engine_mod.detector_class
+          if manifest.dig('components', 'detector') && detector_klass
+            detector_klass.new(name)
+          else
+            RosettAi::Engines::Detector.new(name)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,120 @@
+# 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 license key management.
+      #
+      # License keys control access to premium content pack downloads —
+      # they NEVER restrict software functionality (GPL-3.0 compliance).
+      class License < ::Thor
+        desc 'activate KEY', 'Activate a license key'
+        long_desc <<~LONGDESC
+          Activates a premium license key for content pack downloads.
+          Validates and stores the license key for future use. License keys control access to
+          premium content only — they never restrict software functionality (GPL-3.0 compliance).
+
+          Exit codes:
+            0 - Success
+            1 - Invalid key or validation failure
+
+          EXAMPLES
+
+            raictl license activate NNCC-eyJhbGciOi...
+
+          Related commands: status, deactivate
+        LONGDESC
+        def activate(raw_key)
+          key = RosettAi::Licensing::LicenseKey.new(raw_key)
+          key.decode
+
+          store = RosettAi::Licensing::LicenseStore.new
+          store.save(raw_key)
+
+          puts Rainbow(t('activate.success', tier: key.tier.to_s)).green
+        rescue RosettAi::LicenseError => e
+          raise ::Thor::Error, t('activate.invalid', reason: e.message)
+        end
+
+        desc 'status', 'Show current license status'
+        long_desc <<~LONGDESC
+          Displays the current license tier (community or premium) and validation status.
+          Shows any warnings if the license key has issues.
+
+          EXAMPLES
+
+            raictl license status
+
+          Related commands: activate, deactivate
+        LONGDESC
+        def status
+          result = RosettAi::Licensing::LicenseValidator.new.validate
+
+          if result[:tier].name == :community
+            puts Rainbow(t('status.community')).yellow
+            return
+          end
+
+          print_status_table(result)
+          print_warnings(result[:warnings])
+        end
+
+        desc 'deactivate', 'Remove license key and revert to community tier'
+        long_desc <<~LONGDESC
+          Removes the stored license key and reverts to the community tier.
+          Does not affect already downloaded content packs.
+
+          EXAMPLES
+
+            raictl license deactivate
+
+          Related commands: activate, status
+        LONGDESC
+        def deactivate
+          store = RosettAi::Licensing::LicenseStore.new
+
+          unless store.exists?
+            puts Rainbow(t('deactivate.not_found')).yellow
+            return
+          end
+
+          store.remove!
+          puts Rainbow(t('deactivate.success')).green
+        end
+
+        private
+
+        def t(key, **)
+          ::I18n.t("rosett_ai.cli.license.#{key}", **)
+        end
+
+        def print_status_table(result)
+          rows = [
+            [t('status.tier_label'), result[:tier].to_s],
+            [t('status.valid_label'), result[:valid] ? Rainbow('Yes').green : Rainbow('No').red]
+          ]
+
+          table = ::Terminal::Table.new(
+            title: Rainbow(t('status.title')).bright,
+            rows: rows,
+            style: { border: :unicode_round }
+          )
+          puts table
+        end
+
+        def print_warnings(warnings)
+          warnings.each do |warning|
+            puts Rainbow("  #{t('status.warning_prefix')}: #{warning}").yellow
+          end
+        end
+      end
+    end
+  end
+end