rosett-ai 1.3.3

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

@@ -0,0 +1,314 @@
+# 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 managing rai releases.
+      #
+      # Provides a repeatable, verified release workflow:
+      #   prepare — bump version, generate CHANGELOG, create release commit
+      #   tag     — create annotated git tag from current VERSION
+      #   status  — show version, last tag, and unreleased commit count
+      #
+      # Design reference: conf/design/release_management.yml
+      class Release < ::Thor
+        VALID_LEVELS = ['major', 'minor', 'patch'].freeze
+
+        VERIFICATION_GATES = [
+          ['rspec',         ['bundle', 'exec', 'rspec', '--format', 'progress']],
+          ['rubocop',       ['bundle', 'exec', 'rubocop', '--format', 'simple']],
+          ['reek',          ['bundle', 'exec', 'reek', '--no-color']],
+          ['bundler-audit', ['bundle', 'exec', 'bundler-audit', 'check']],
+          ['ruby-audit',    ['bundle', 'exec', 'ruby-audit', 'check']]
+        ].freeze
+
+        desc 'prepare LEVEL', 'Prepare a release (major|minor|patch)'
+        long_desc <<~LONGDESC
+          Prepares a new release by bumping version, generating CHANGELOG, and creating a release commit.
+          Runs full verification suite (rspec, rubocop, reek, bundler-audit, ruby-audit) unless skipped.
+
+          Flags:
+            --skip-verify: Skip verification suite (NOT recommended)
+
+          Exit codes:
+            0 - Success
+            1 - Validation or verification failure
+
+          EXAMPLES
+
+            raictl release prepare patch
+            raictl release prepare minor
+            raictl release prepare major --skip-verify
+
+          Related commands: tag, status
+        LONGDESC
+        method_option :skip_verify, type: :boolean, default: false,
+                                    desc: 'Skip verification suite (NOT recommended)'
+        def prepare(level)
+          validate_level!(level)
+          ensure_clean_working_tree!
+          run_verification_gates! unless options[:skip_verify]
+
+          old_version = current_version
+          new_version = bump_version(old_version, level)
+
+          write_version!(new_version)
+          changelog_text = generate_changelog(new_version)
+          update_changelog!(new_version, changelog_text)
+
+          create_release_commit!(new_version)
+
+          puts
+          puts Rainbow(t('prepare.success', version: new_version)).green
+          puts t('prepare.next_steps', version: new_version)
+        end
+
+        desc 'tag', 'Create an annotated git tag from current VERSION'
+        long_desc <<~LONGDESC
+          Creates an annotated git tag for the current version from the VERSION constant.
+          Extracts the changelog section for the tag message.
+
+          Exit codes:
+            0 - Success
+            1 - Tag already exists or other error
+
+          EXAMPLES
+
+            raictl release tag
+
+          Related commands: prepare, status
+        LONGDESC
+        def tag
+          version = current_version
+          tag_name = "v#{version}"
+
+          raise ::Thor::Error, t('tag.exists', tag: tag_name) if tag_exists?(tag_name)
+
+          message = extract_changelog_section(version)
+          create_annotated_tag!(tag_name, message)
+
+          puts Rainbow(t('tag.success', tag: tag_name)).green
+        end
+
+        desc 'status', 'Show current version, last tag, and unreleased changes'
+        long_desc <<~LONGDESC
+          Displays the current version, last git tag, and count of unreleased commits.
+          Useful for determining whether a new release is needed.
+
+          EXAMPLES
+
+            raictl release status
+
+          Related commands: prepare, tag
+        LONGDESC
+        def status
+          version = current_version
+          last_tag = latest_tag
+          commit_count = commits_since_tag(last_tag)
+
+          rows = [
+            [t('status.version_label'), version],
+            [t('status.last_tag_label'), last_tag || t('status.no_tags')],
+            [t('status.commits_label'), commit_count.to_s]
+          ]
+
+          table = ::Terminal::Table.new(
+            title: Rainbow(t('status.title')).bright,
+            rows: rows,
+            style: { border: :unicode_round }
+          )
+          puts table
+        end
+
+        private
+
+        def t(key, **)
+          ::I18n.t("rosett_ai.cli.release.#{key}", **)
+        end
+
+        # -- validation ----------------------------------------------------------
+
+        def validate_level!(level)
+          return if VALID_LEVELS.include?(level)
+
+          raise ::Thor::Error, t('prepare.invalid_level', level: level,
+                                                          valid: VALID_LEVELS.join(', '))
+        end
+
+        def ensure_clean_working_tree!
+          return if clean_working_tree?
+
+          raise ::Thor::Error, t('prepare.dirty_tree')
+        end
+
+        def clean_working_tree?
+          output = IO.popen(['git', 'status', '--porcelain'], &:read)
+          output.strip.empty?
+        end
+
+        # -- verification gates --------------------------------------------------
+
+        def run_verification_gates!
+          puts t('prepare.running_gates')
+
+          VERIFICATION_GATES.each do |name, cmd|
+            run_gate(name, cmd)
+          end
+
+          puts Rainbow(t('prepare.gates_passed')).green
+          puts
+        end
+
+        def run_gate(name, cmd)
+          print "  #{name}... "
+          success = system(*cmd, [:out, :err] => File::NULL)
+
+          if success
+            puts Rainbow(t('prepare.gate_ok')).green
+          else
+            puts Rainbow(t('prepare.gate_fail')).red
+            raise ::Thor::Error, t('prepare.gate_abort', gate: name)
+          end
+        end
+
+        # -- version management --------------------------------------------------
+
+        def current_version
+          RosettAi::VERSION
+        end
+
+        def bump_version(version, level)
+          parts = version.split('.').map(&:to_i)
+
+          case level
+          when 'major'
+            parts[0] += 1
+            parts[1] = 0
+            parts[2] = 0
+          when 'minor'
+            parts[1] += 1
+            parts[2] = 0
+          when 'patch'
+            parts[2] += 1
+          end
+
+          parts.join('.')
+        end
+
+        def write_version!(new_version)
+          version_file = RosettAi.root.join('lib', 'rosett_ai', 'version.rb')
+          content = version_file.read
+          updated = content.gsub(/VERSION = '[^']*'/, "VERSION = '#{new_version}'")
+          version_file.write(updated)
+          puts t('prepare.version_bumped', old: current_version, new: new_version)
+        end
+
+        # -- changelog -----------------------------------------------------------
+
+        def generate_changelog(new_version)
+          if cliff_available?
+            generate_changelog_with_cliff(new_version)
+          else
+            generate_changelog_from_git(new_version)
+          end
+        end
+
+        def cliff_available?
+          ENV.fetch('PATH', '').split(File::PATH_SEPARATOR).any? do |dir|
+            File.executable?(File.join(dir, 'git-cliff'))
+          end
+        end
+
+        def generate_changelog_with_cliff(new_version)
+          IO.popen(['git-cliff', '--tag', "v#{new_version}", '--unreleased', '--strip', 'all'], &:read)
+        end
+
+        def generate_changelog_from_git(new_version)
+          last_tag = latest_tag
+          range = last_tag ? "#{last_tag}..HEAD" : 'HEAD'
+          log = IO.popen(['git', 'log', range, '--pretty=format:- %s'], &:read)
+
+          "## [#{new_version}] - #{Date.today}\n\n### Added\n\n#{log}\n"
+        end
+
+        def update_changelog!(new_version, changelog_text)
+          changelog_path = RosettAi.root.join('CHANGELOG.md')
+
+          changelog_path.write("# Changelog\n\n## [Unreleased]\n") unless changelog_path.exist?
+
+          content = changelog_path.read
+          date_str = Date.today.to_s
+          version_header = "## [#{new_version}] - #{date_str}"
+
+          updated = if content.include?('## [Unreleased]')
+                      content.sub('## [Unreleased]',
+                                  "## [Unreleased]\n\n#{version_header}")
+                    else
+                      "## [Unreleased]\n\n#{version_header}\n\n#{changelog_text}\n\n#{content}"
+                    end
+
+          changelog_path.write(updated)
+          puts t('prepare.changelog_updated')
+        end
+
+        # -- git operations ------------------------------------------------------
+
+        def create_release_commit!(new_version)
+          unless system('git', 'add', 'lib/rosett_ai/version.rb', 'CHANGELOG.md')
+            raise ::Thor::Error, t('prepare.git_add_failed')
+          end
+
+          unless system('git', 'commit', '-m', "chore(release): prepare v#{new_version}")
+            raise ::Thor::Error, t('prepare.git_commit_failed')
+          end
+
+          puts t('prepare.commit_created', version: new_version)
+        end
+
+        def tag_exists?(tag_name)
+          system('git', 'rev-parse', tag_name, [:out, :err] => File::NULL)
+        end
+
+        def create_annotated_tag!(tag_name, message)
+          tag_message = message.empty? ? "Release #{tag_name}" : message
+
+          return if system('git', 'tag', '-a', tag_name, '-m', tag_message)
+
+          raise ::Thor::Error, t('tag.git_tag_failed', tag: tag_name)
+        end
+
+        def latest_tag
+          output = IO.popen(['git', 'describe', '--tags', '--abbrev=0'], err: File::NULL, &:read)
+          tag = output.strip
+          tag.empty? ? nil : tag
+        end
+
+        def commits_since_tag(tag)
+          output = if tag
+                     IO.popen(['git', 'rev-list', "#{tag}..HEAD", '--count'], &:read)
+                   else
+                     IO.popen(['git', 'rev-list', 'HEAD', '--count'], &:read)
+                   end
+          output.strip.to_i
+        end
+
+        def extract_changelog_section(version)
+          changelog_path = RosettAi.root.join('CHANGELOG.md')
+          return '' unless changelog_path.exist?
+
+          content = changelog_path.read
+          pattern = /^## \[#{Regexp.escape(version)}\].*?\n(.*?)(?=^## |\z)/m
+          match = content.match(pattern)
+          match ? match[1].strip : "Release v#{version}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+require 'rainbow'
+
+module RosettAi
+  module Thor
+    module Tasks
+      # CLI task for `rai retrofit` — reverse compilation from native configs.
+      #
+      # Imports existing AI tool configuration files into rosett-ai-managed YAML
+      # source files, enabling reproducible config management.
+      #
+      # @author hugo
+      # @author claude
+      class Retrofit < ::Thor
+        default_task :convert
+
+        desc 'convert', 'Import native AI tool configs into Rosett-AI YAML'
+        long_desc <<~LONGDESC
+          Reads existing AI tool configuration files and generates rosett-ai-managed
+          YAML source files. Supports auto-detection of installed tools or
+          explicit engine targeting.
+
+          Exit codes: 0 = success, 3 = config parse failure, 5 = missing adapter.
+
+          EXAMPLES
+
+            raictl retrofit convert
+            raictl retrofit convert --engine claude --simulate
+            raictl retrofit convert --force
+        LONGDESC
+        method_option :engine, type: :array, default: nil,
+                               desc: 'Engine(s) to retrofit (auto-detect if omitted)'
+        method_option :force, type: :boolean, default: false,
+                              desc: 'Overwrite existing Rosett-AI YAML files'
+        method_option :simulate, type: :boolean, default: false,
+                                 desc: 'Show what would be generated without writing'
+        def convert
+          output_dir = resolve_output_dir
+          engine = RosettAi::Retrofit::Engine.new(
+            output_dir: output_dir,
+            engines: options[:engine],
+            force: options[:force]
+          )
+
+          results = options[:simulate] ? engine.simulate : engine.retrofit
+          render_results(results, simulate: options[:simulate])
+
+          exit 3 if results[:errors].any? { |err| err.include?('parse') }
+          exit 5 if results[:errors].any? { |err| err.include?('adapter') }
+        end
+
+        desc 'engines', 'List available retrofit engines'
+        def engines
+          available = RosettAi::Retrofit::Engine.available_engines
+          if available.empty?
+            warn ::I18n.t('rosett_ai.retrofit.no_engines')
+            return
+          end
+
+          puts ::I18n.t('rosett_ai.retrofit.engines_title')
+          available.each { |name| puts "  - #{name}" }
+        end
+
+        private
+
+        def resolve_output_dir
+          Pathname.new(ENV.fetch('RAI_ORIGINAL_PWD', Dir.pwd)).join('.rosett-ai')
+        end
+
+        def render_results(results, simulate: false)
+          prefix = simulate ? ::I18n.t('rosett_ai.retrofit.simulate_prefix') : ''
+
+          results[:generated].each { |path| puts Rainbow("  #{prefix}+ #{path}").green }
+          results[:skipped].each { |path| puts "  ~ #{path} (exists, use --force)" }
+          results[:errors].each { |err| warn Rainbow("  ! #{err}").red }
+          results[:warnings].each { |warning| warn Rainbow("  * #{warning}").yellow }
+
+          puts ::I18n.t('rosett_ai.retrofit.summary',
+                        generated: results[:generated].size,
+                        skipped: results[:skipped].size,
+                        errors: results[:errors].size)
+        end
+      end
+    end
+  end
+end