rosett-ai 1.3.3

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

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+require 'json'
+require 'thor'
+require 'rainbow'
+require 'terminal-table'
+
+module RosettAi
+  module Thor
+    module Tasks
+      # Thor task for plugin management (list, install, remove).
+      #
+      # @author hugo
+      # @author claude
+      class Plugins < ::Thor
+        VALID_TYPES = ['engine', 'gui', 'mcp'].freeze
+
+        desc 'list TYPE', 'List installed plugins of a given type (engine, gui, mcp)'
+        long_desc <<~LONGDESC
+          List all installed plugins of the specified type. Valid types are
+          `engine` (compilation targets), `gui` (desktop interfaces), and
+          `mcp` (MCP server plugins).
+
+          Example: raictl plugins list engine
+
+          Related: plugins install, plugins remove, engines list
+        LONGDESC
+        def list(type)
+          validate_type!(type)
+          type_sym = type.to_sym
+          names = RosettAi::Plugins::Registry.available(type_sym)
+
+          if names.empty?
+            warn t('no_plugins', type: type)
+            return
+          end
+
+          if tty_output?
+            print_list_tty(type_sym, names)
+          else
+            print_list_json(type_sym, names)
+          end
+        end
+
+        desc 'install TYPE NAME', 'Install a plugin (e.g. plugins install engine ollama)'
+        long_desc <<~LONGDESC
+          Install a plugin package via apt (preferred) or gem fallback.
+
+          The package name is derived as rosett-ai-TYPE-NAME (e.g., rosett-ai-engine-ollama).
+          After installation the plugin registry is refreshed.
+
+          Example: raictl plugins install engine ollama
+
+          Exit codes: 0 success, 1 install failed.
+
+          Related: plugins remove, plugins list
+        LONGDESC
+        def install(type, name)
+          validate_type!(type)
+          package = plugin_package_name(type, name)
+
+          warn t('installing', package: package)
+          pm = select_package_manager
+
+          if pm.install(package)
+            RosettAi::Plugins::Registry.reset!
+            RosettAi::Plugins::Registry.discover!
+            warn Rainbow(t('installed', package: package)).green
+          else
+            warn Rainbow(t('install_failed', package: package)).red
+            exit 1
+          end
+        end
+
+        desc 'remove TYPE NAME', 'Remove a plugin (e.g. plugins remove engine ollama)'
+        long_desc <<~LONGDESC
+          Remove an installed plugin package.
+
+          Example: raictl plugins remove engine ollama
+
+          Exit codes: 0 success, 1 removal failed.
+
+          Related: plugins install, plugins list
+        LONGDESC
+        def remove(type, name)
+          validate_type!(type)
+          package = plugin_package_name(type, name)
+
+          warn t('removing', package: package)
+          pm = select_package_manager
+
+          if pm.remove(package)
+            RosettAi::Plugins::Registry.reset!
+            RosettAi::Plugins::Registry.discover!
+            warn Rainbow(t('removed', package: package)).green
+          else
+            warn Rainbow(t('remove_failed', package: package)).red
+            exit 1
+          end
+        end
+
+        private
+
+        def t(key, **)
+          ::I18n.t("rosett_ai.cli.plugins.#{key}", **)
+        end
+
+        def tty_output?
+          $stdout.tty?
+        end
+
+        def validate_type!(type)
+          return if VALID_TYPES.include?(type)
+
+          raise ::Thor::Error, t('invalid_type', type: type)
+        end
+
+        def plugin_package_name(type, name)
+          "rosett-ai-#{type}-#{name}"
+        end
+
+        def select_package_manager
+          apt = RosettAi::PackageManager::Apt.new
+          return apt if apt.available?
+
+          RosettAi::PackageManager::GemBackend.new
+        end
+
+        def print_list_tty(type_sym, names)
+          rows = names.map do |name|
+            mod = RosettAi::Plugins::Registry.plugin_module(type_sym, name)
+            [name, mod.display_name, mod.version]
+          end
+
+          table = ::Terminal::Table.new(
+            title: t('title'),
+            headings: [t('name'), t('display_name'), t('version')],
+            rows: rows,
+            style: { border: :unicode_round }
+          )
+          puts table
+        end
+
+        def print_list_json(type_sym, names)
+          data = names.map do |name|
+            mod = RosettAi::Plugins::Registry.plugin_module(type_sym, name)
+            { name: name, display_name: mod.display_name, version: mod.version }
+          end
+          puts JSON.generate(data)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,260 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+require 'terminal-table'
+require 'rainbow'
+require 'json'
+
+module RosettAi
+  module Thor
+    module Tasks
+      # CLI task for `rai project` — project lifecycle management.
+      #
+      # Provides commands for template application, drift detection,
+      # upstream synchronization, and project health reporting.
+      #
+      # @author hugo
+      # @author claude
+      class Project < ::Thor
+        desc 'status', 'Show project status and health'
+        long_desc <<~LONGDESC
+          Displays project metadata, drift status, and overall health.
+          Uses TTY-aware output (table when interactive, plain when piped).
+
+          EXAMPLES
+
+            raictl project status
+            raictl project status --format json
+        LONGDESC
+        method_option :format, type: :string, enum: ['table', 'json'], default: 'table',
+                               desc: 'Output format'
+        def status
+          manager = RosettAi::Project::Manager.new(project_root: resolve_project_root)
+          result = manager.status
+
+          if options[:format] == 'json'
+            puts JSON.pretty_generate(result)
+          else
+            render_status(result)
+          end
+        end
+
+        desc 'info', 'Show project metadata'
+        long_desc <<~LONGDESC
+          Displays project name, default engine, template origin,
+          and counts of behaviours and design documents.
+
+          EXAMPLES
+
+            raictl project info
+        LONGDESC
+        def info
+          manager = RosettAi::Project::Manager.new(project_root: resolve_project_root)
+          result = manager.info
+
+          rows = result.map { |key, value| [key.to_s.tr('_', ' ').capitalize, value.to_s] }
+          table = ::Terminal::Table.new(
+            title: ::I18n.t('rosett_ai.project.info_title'),
+            rows: rows
+          )
+          puts table
+        end
+
+        desc 'apply-template NAME', 'Apply a project template'
+        long_desc <<~LONGDESC
+          Applies the named template to populate .rosett-ai/ with starter configs.
+          Existing files are not overwritten unless --force is used.
+          Use --list to see available templates.
+
+          EXAMPLES
+
+            raictl project apply-template ruby-gem
+            raictl project apply-template --list
+            raictl project apply-template python-lib --force
+        LONGDESC
+        method_option :force, type: :boolean, default: false,
+                              desc: 'Overwrite existing files'
+        method_option :list, type: :boolean, default: false,
+                             desc: 'List available templates'
+        def apply_template(name = nil)
+          if options[:list]
+            list_templates
+            return
+          end
+
+          raise RosettAi::ProjectError, 'Template name required' unless name
+
+          applier = RosettAi::Project::TemplateApplier.new(
+            project_root: resolve_project_root,
+            template_name: name,
+            force: options[:force]
+          )
+          results = applier.apply
+
+          render_apply_results(results)
+          exit 1 if results[:errors].any?
+        end
+
+        desc 'drift', 'Detect configuration drift'
+        long_desc <<~LONGDESC
+          Detects drift between source YAML and compiled configs (forward)
+          or between project configs and template baseline (template).
+
+          Exit codes: 0 = no drift, 4 = drift detected.
+
+          EXAMPLES
+
+            raictl project drift
+            raictl project drift --type forward
+            raictl project drift --format json
+        LONGDESC
+        method_option :type, type: :string, enum: ['forward', 'template'],
+                             desc: 'Drift type to detect (default: both)'
+        method_option :format, type: :string, enum: ['table', 'json'], default: 'table',
+                               desc: 'Output format'
+        def drift
+          root = resolve_project_root
+          validate_project!(root)
+
+          detector = RosettAi::Project::DriftDetector.new(project_root: root)
+          results = detector.detect(type: options[:type])
+
+          if options[:format] == 'json'
+            puts JSON.pretty_generate(results)
+          else
+            render_drift_results(results)
+          end
+
+          total_drift = results.values.flatten.size
+          exit 4 if total_drift.positive?
+        end
+
+        desc 'sync', 'Synchronize with upstream template updates'
+        long_desc <<~LONGDESC
+          Updates project configs from upstream template changes.
+          Detects breaking changes and requires --force to apply.
+          Use --simulate for a dry-run preview.
+
+          Exit codes: 0 = success, 5 = unresolved conflicts.
+
+          EXAMPLES
+
+            raictl project sync
+            raictl project sync --simulate
+            raictl project sync --force
+        LONGDESC
+        method_option :force, type: :boolean, default: false,
+                              desc: 'Apply breaking changes without prompting'
+        method_option :simulate, type: :boolean, default: false,
+                                 desc: 'Preview changes without applying'
+        def sync
+          sync_mgr = RosettAi::Project::SyncManager.new(
+            project_root: resolve_project_root,
+            force: options[:force]
+          )
+
+          results = options[:simulate] ? sync_mgr.simulate : sync_mgr.sync
+          render_sync_results(results, simulate: options[:simulate])
+
+          if results[:error]
+            warn Rainbow("  Error: #{results[:error]}").red
+            exit 1
+          end
+          exit 5 if results[:conflicts].any?
+        end
+
+        private
+
+        def resolve_project_root
+          Pathname.new(ENV.fetch('RAI_ORIGINAL_PWD', Dir.pwd))
+        end
+
+        # Validates that the given root contains an .rosett-ai/ project directory.
+        #
+        # @param root [Pathname] project root path
+        # @raise [RosettAi::ProjectError] if .rosett-ai/ directory is missing
+        def validate_project!(root)
+          return if root.join('.rosett-ai').directory?
+
+          raise RosettAi::ProjectError,
+                "No .rosett-ai/ directory found in #{root}. Run 'rai init --project' first."
+        end
+
+        def list_templates
+          templates = RosettAi::Project::TemplateApplier.available_templates
+          if templates.empty?
+            warn ::I18n.t('rosett_ai.project.no_templates')
+            return
+          end
+
+          puts ::I18n.t('rosett_ai.project.templates_title')
+          templates.each { |name| puts "  - #{name}" }
+        end
+
+        def render_status(result)
+          info = result[:info]
+          health = result[:health]
+
+          puts ::I18n.t('rosett_ai.project.status_title')
+          puts "  #{::I18n.t('rosett_ai.project.name_label')}: #{info[:project_name]}"
+          puts "  #{::I18n.t('rosett_ai.project.engine_label')}: #{info[:default_engine]}"
+          puts "  #{::I18n.t('rosett_ai.project.template_label')}: #{info[:template] || '-'}"
+          puts "  #{::I18n.t('rosett_ai.project.behaviours_label')}: #{info[:behaviours]}"
+          puts "  #{::I18n.t('rosett_ai.project.designs_label')}: #{info[:designs]}"
+          puts
+
+          if health[:healthy]
+            puts Rainbow(::I18n.t('rosett_ai.project.healthy')).green
+          else
+            puts Rainbow(::I18n.t('rosett_ai.project.unhealthy')).yellow
+            health[:issues].each { |issue| puts "  - #{issue}" }
+          end
+        end
+
+        def render_apply_results(results)
+          results[:applied].each { |file| puts Rainbow("  + #{file}").green }
+          results[:skipped].each { |file| puts Rainbow("  ~ #{file} (skipped)").yellow }
+          results[:errors].each { |err| warn Rainbow("  ! #{err}").red }
+
+          puts ::I18n.t('rosett_ai.project.apply_summary',
+                        applied: results[:applied].size,
+                        skipped: results[:skipped].size)
+        end
+
+        def render_drift_results(results)
+          total = 0
+
+          results.each do |type, drifts|
+            next if drifts.empty?
+
+            puts "#{type.to_s.capitalize} drift:"
+            drifts.each do |drift|
+              puts "  - #{drift[:file]}"
+              total += 1
+            end
+          end
+
+          if total.zero?
+            puts Rainbow(::I18n.t('rosett_ai.project.no_drift')).green
+          else
+            puts ::I18n.t('rosett_ai.project.drift_detected', count: total)
+          end
+        end
+
+        def render_sync_results(results, simulate: false)
+          prefix = simulate ? ::I18n.t('rosett_ai.project.simulate_prefix') : ''
+
+          results[:updated].each { |file| puts Rainbow("  #{prefix}+ #{file}").green }
+          results[:conflicts].each { |file| puts Rainbow("  ! #{file} (conflict)").yellow }
+          results[:skipped].each { |file| puts "  ~ #{file} (unchanged)" }
+
+          puts ::I18n.t('rosett_ai.project.sync_summary',
+                        updated: results[:updated].size,
+                        conflicts: results[:conflicts].size)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,195 @@
+# 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'
+
+module RosettAi
+  module Thor
+    module Tasks
+      # Thor task for AI provenance tracking commands.
+      #
+      # @author hugo
+      # @author claude
+      class Provenance < ::Thor
+        desc 'init', 'Create .ai-provenance.yml in the current project'
+        long_desc <<~LONGDESC
+          Initializes an AI provenance tracking file in the current project root.
+          Creates .ai-provenance.yml with the necessary structure for tracking AI-assisted changes.
+
+          Exit codes:
+            0 - Success
+            1 - Initialization error
+
+          EXAMPLES
+
+            raictl provenance init
+
+          Related commands: validate, show, log
+        LONGDESC
+        def init
+          store = build_store
+          store.init
+          say "Created #{store.path}", :green
+        rescue RosettAi::ProvenanceError => e
+          say_status 'error', e.message, :red
+          exit RosettAi::ExitCodes::GENERAL
+        end
+
+        desc 'validate', 'Validate provenance entries and hash chain integrity'
+        long_desc <<~LONGDESC
+          Validates all provenance entries against the schema and verifies hash chain integrity.
+          Ensures that the provenance file has not been tampered with.
+
+          Exit codes:
+            0 - All entries valid
+            2 - Validation failures
+            1 - Other errors
+
+          EXAMPLES
+
+            raictl provenance validate
+
+          Related commands: init, show, log
+        LONGDESC
+        def validate
+          store = build_store
+          data = store.read
+          entry_count = data['entries'].size
+
+          violations = store.verify_chain
+          if violations.empty?
+            say "#{entry_count} entries validated, hash chain intact", :green
+          else
+            violations.each { |v| say_status 'error', v, :red }
+            exit RosettAi::ExitCodes::VALIDATION
+          end
+        rescue RosettAi::ProvenanceError => e
+          say_status 'error', e.message, :red
+          exit RosettAi::ExitCodes::GENERAL
+        end
+
+        desc 'show COMMIT', 'Show provenance for a specific commit'
+        long_desc <<~LONGDESC
+          Displays provenance information for a specific commit or file.
+          Shows AI tool, role, and affected files for the specified commit.
+
+          Flags:
+            --file: Show provenance for a specific file instead of a commit
+
+          Exit codes:
+            0 - Success
+            1 - Error or no entries found
+
+          EXAMPLES
+
+            raictl provenance show abc1234
+            raictl provenance show --file lib/rosett_ai.rb
+
+          Related commands: init, validate, log
+        LONGDESC
+        method_option :file, type: :string, desc: 'Show provenance for a specific file'
+        def show(commit = nil)
+          store = build_store
+          entries = if options[:file]
+                      store.entries_for_file(options[:file])
+                    elsif commit
+                      store.entries_for_commit(commit)
+                    else
+                      say_status 'error', 'Provide a commit SHA or --file path', :red
+                      exit RosettAi::ExitCodes::GENERAL
+                    end
+
+          if entries.empty?
+            say 'No provenance entries found', :yellow
+          else
+            print_entries(entries)
+          end
+        rescue RosettAi::ProvenanceError => e
+          say_status 'error', e.message, :red
+          exit RosettAi::ExitCodes::GENERAL
+        end
+
+        desc 'log', 'Show all provenance entries (reverse chronological)'
+        long_desc <<~LONGDESC
+          Lists all provenance entries in reverse chronological order.
+          Can be filtered by AI role for focused analysis.
+
+          Flags:
+            --role: Filter entries by AI role (e.g., AI-Co-Author)
+
+          Exit codes:
+            0 - Success
+            1 - Error
+
+          EXAMPLES
+
+            raictl provenance log
+            raictl provenance log --role AI-Co-Author
+
+          Related commands: init, validate, show
+        LONGDESC
+        method_option :role, type: :string, desc: 'Filter by AI role'
+        def log
+          store = build_store
+          entries = store.read['entries'].reverse
+
+          entries = entries.select { |e| e['ai_role'] == options[:role] } if options[:role]
+
+          if entries.empty?
+            say 'No provenance entries found', :yellow
+          else
+            print_entries(entries)
+          end
+        rescue RosettAi::ProvenanceError => e
+          say_status 'error', e.message, :red
+          exit RosettAi::ExitCodes::GENERAL
+        end
+
+        private
+
+        def build_store
+          root = RosettAi.context.project? ? RosettAi.context.project_root : Pathname.pwd
+          RosettAi::Provenance::Store.new(root: root)
+        end
+
+        def print_entries(entries)
+          if RosettAi::Ui::TtyHelper.interactive?
+            print_table_format(entries)
+          else
+            print_plain_format(entries)
+          end
+        end
+
+        def print_table_format(entries)
+          rows = entries.map do |entry|
+            files = Array(entry['files']).map { |f| f['path'] }.join(', ')
+            [
+              entry['commit'].to_s[0, 8],
+              entry['ai_tool'].to_s,
+              entry['ai_role'].to_s,
+              files.length > 40 ? "#{files[0, 37]}..." : files
+            ]
+          end
+
+          table = ::Terminal::Table.new(
+            headings: ['Commit', 'Tool', 'Role', 'Files'],
+            rows: rows,
+            style: { border: :unicode_round }
+          )
+          puts table
+        end
+
+        def print_plain_format(entries)
+          entries.each do |entry|
+            files = Array(entry['files']).map { |f| f['path'] }.join(', ')
+            puts "#{entry['commit'].to_s[0, 8]}\t#{entry['ai_tool']}\t#{entry['ai_role']}\t#{files}"
+          end
+        end
+      end
+    end
+  end
+end