rosett-ai 1.3.3

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

@@ -0,0 +1,308 @@
+# 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 tasks for CI/CD tooling validation
+      class Tooling < ::Thor
+        desc 'validate-ci-yaml', 'Validate GitLab CI YAML files for syntax errors'
+        long_desc <<~LONGDESC
+          Validates all GitLab CI YAML files (.gitlab-ci.yml and includes) for syntax errors.
+          Reports line and column numbers for any detected issues.
+
+          Flags:
+            --verbose: Show all validated files, not just errors
+            --project-dir: Project directory (defaults to current directory)
+
+          Exit codes:
+            0 - All files valid
+            1 - Validation failures
+
+          EXAMPLES
+
+            raictl tooling validate-ci-yaml
+            raictl tooling validate-ci-yaml --verbose
+            raictl tooling validate-ci-yaml --project-dir /path/to/project
+
+          Related commands: validate, check-versions
+        LONGDESC
+        method_option :verbose,
+                      type: :boolean,
+                      default: false,
+                      desc: 'Show all validated files, not just errors'
+        method_option :project_dir,
+                      type: :string,
+                      default: nil,
+                      desc: 'Project directory (defaults to current directory)'
+
+        def validate_ci_yaml
+          validator = RosettAi::Gitlab::Validators::SupplementaryGitlabCiYamlValidator.new(
+            project_dir: options[:project_dir] || ENV.fetch('RAI_ORIGINAL_PWD', Dir.pwd)
+          )
+
+          results = validator.validate
+
+          if results[:valid].empty? && results[:invalid].empty?
+            puts Rainbow(t('no_ci_files')).yellow
+            return
+          end
+
+          print_ci_results(results)
+          raise ::Thor::Error, t('ci_validation_failed') unless results[:invalid].empty?
+        end
+
+        desc 'validate [NAME]', 'Validate tooling configuration file(s) against the tooling schema'
+        long_desc <<~LONGDESC
+          Validates tooling configuration files in conf/tooling/ against the tooling schema.
+          If NAME is provided, validates only that file; otherwise validates all tooling files.
+
+          Exit codes:
+            0 - All files valid
+            1 - Validation failures
+
+          EXAMPLES
+
+            raictl tooling validate
+            raictl tooling validate ci_pipeline
+
+          Related commands: validate-ci-yaml, check-versions
+        LONGDESC
+        def validate(name = nil)
+          name = RosettAi::TextSanitizer.normalize_nfc(name) if name
+          files = files_to_validate(name)
+          return puts Rainbow(t('no_tooling_files')).yellow if files.empty?
+
+          all_valid = validate_tooling_files(files)
+          raise ::Thor::Error, t('validation_failed') unless all_valid
+        end
+
+        desc 'check-versions', 'Check Ruby and gem version consistency across the codebase'
+        long_desc <<~LONGDESC
+          Checks that Ruby version references are consistent across all configuration files.
+          Optionally also checks gem version consistency when --gems flag is used.
+
+          Flags:
+            --verbose: Show all version references, not just mismatches
+            --gems: Also check gem version consistency
+            --project-dir: Project directory (defaults to current directory)
+
+          Exit codes:
+            0 - All versions consistent
+            1 - Version mismatches detected
+
+          EXAMPLES
+
+            raictl tooling check-versions
+            raictl tooling check-versions --verbose --gems
+
+          Related commands: validate-ci-yaml, validate
+        LONGDESC
+        method_option :verbose,
+                      type: :boolean,
+                      default: false,
+                      desc: 'Show all version references, not just mismatches'
+        method_option :gems,
+                      type: :boolean,
+                      default: false,
+                      desc: 'Also check gem version consistency'
+        method_option :project_dir,
+                      type: :string,
+                      default: nil,
+                      desc: 'Project directory (defaults to current directory)'
+
+        def check_versions
+          project_dir = options[:project_dir] || ENV.fetch('RAI_ORIGINAL_PWD', Dir.pwd)
+          all_consistent = check_ruby_versions(project_dir)
+
+          if options[:gems]
+            gem_consistent = check_gem_versions(project_dir)
+            all_consistent &&= gem_consistent
+          end
+
+          raise ::Thor::Error, t('version_check_failed') unless all_consistent
+        end
+
+        private
+
+        def t(key, **)
+          ::I18n.t("rosett_ai.cli.tooling.#{key}", **)
+        end
+
+        def tooling_path
+          RosettAi.conf_root.join('conf', 'tooling')
+        end
+
+        def tooling_files
+          Dir.glob(tooling_path.join('*.yml'))
+        end
+
+        def find_tooling_file(name)
+          path = tooling_path.join("#{name}.yml")
+          path.exist? ? path.to_s : nil
+        end
+
+        def files_to_validate(name)
+          return tooling_files unless name
+
+          file = find_tooling_file(name)
+          unless file
+            puts Rainbow(t('not_found', name: name)).red
+            return []
+          end
+          [file]
+        end
+
+        def validate_tooling_files(files)
+          validator = RosettAi::Validators::ToolingValidator.new
+          files.all? { |file| tooling_file_valid?(validator, file) }
+        end
+
+        def tooling_file_valid?(validator, file)
+          basename = File.basename(file)
+          if validator.valid?(file)
+            puts "#{Rainbow(t('valid')).green}   #{basename}"
+            true
+          else
+            display_tooling_errors(basename, validator.errors)
+            false
+          end
+        end
+
+        def display_tooling_errors(basename, errors)
+          puts "#{Rainbow(t('invalid')).red} #{basename}"
+          errors.each { |err| puts "         #{err}" }
+        end
+
+        def print_ci_results(results)
+          if options[:verbose]
+            results[:valid].each do |entry|
+              puts "  #{Rainbow(t('ok')).green}    #{entry[:file]}"
+            end
+          end
+
+          results[:invalid].each do |entry|
+            puts "  #{Rainbow(t('fail')).red}  #{entry[:file]}"
+            puts "        line #{entry[:line]}, column #{entry[:column]}: #{entry[:message]}"
+          end
+
+          puts
+          print_ci_summary(results)
+        end
+
+        def print_ci_summary(results)
+          rows = [
+            [t('ci_valid'), results[:valid].size],
+            [t('ci_invalid'), results[:invalid].size]
+          ]
+
+          table = ::Terminal::Table.new(
+            title: Rainbow(t('ci_title')).bright,
+            headings: ['Status', 'Count'],
+            rows: rows,
+            style: { border: :unicode_round }
+          )
+          puts table
+        end
+
+        def check_ruby_versions(project_dir)
+          checker = RosettAi::VersionConsistencyChecker.new(project_dir: project_dir)
+          results = checker.check
+          print_version_results(results)
+          results[:consistent]
+        end
+
+        def check_gem_versions(project_dir)
+          checker = RosettAi::GemConsistencyChecker.new(project_dir: project_dir)
+          results = checker.check
+          print_gem_results(results)
+          results[:consistent]
+        end
+
+        def print_gem_results(results)
+          if options[:verbose]
+            results[:gems].each do |entry|
+              status = entry[:status] == :ok ? Rainbow(t('ok')).green : Rainbow(t(entry[:status].to_s)).red
+              resolved = entry[:resolved] || '-'
+              puts "  #{status}  #{entry[:name]}  #{entry[:constraint]}  #{resolved}"
+            end
+            puts
+          end
+
+          results[:stale_references].each do |ref|
+            puts "  #{Rainbow(t('gem_stale_reference')).red}  #{ref[:file]}:#{ref[:line]}  " \
+                 "#{ref[:gem]} found #{ref[:found]}, expected #{ref[:expected]}"
+          end
+
+          results[:gems].reject { |entry| entry[:status] == :ok }.each do |entry|
+            label = t("gem_status_#{entry[:status]}")
+            puts "  #{Rainbow(label).red}  #{entry[:name]}  #{entry[:constraint]}  #{entry[:resolved] || '-'}"
+          end
+
+          puts
+          print_gem_summary(results)
+        end
+
+        def print_gem_summary(results)
+          ok_count = results[:gems].count { |entry| entry[:status] == :ok }
+          problem_count = results[:gems].size - ok_count
+
+          rows = [
+            [t('gem_total'), results[:gems].size],
+            [t('gem_ok'), ok_count],
+            [t('gem_problems'), problem_count],
+            [t('gem_stale_refs'), results[:stale_references].size]
+          ]
+
+          table = ::Terminal::Table.new(
+            title: Rainbow(t('gem_title')).bright,
+            headings: ['Check', 'Result'],
+            rows: rows,
+            style: { border: :unicode_round }
+          )
+          puts table
+        end
+
+        def print_version_results(results)
+          if options[:verbose]
+            results[:references].each do |ref|
+              status = ref[:found] == results[:expected_version] ? Rainbow(t('ok')).green : Rainbow(t('mismatch')).red
+              puts "  #{status}  #{ref[:file]}:#{ref[:line]}  #{ref[:found]}"
+            end
+            puts
+          end
+
+          results[:mismatches].each do |ref|
+            puts "  #{Rainbow(t('mismatch')).red}  #{ref[:file]}:#{ref[:line]}  " \
+                 "found #{ref[:found]}, expected #{results[:expected_version]}"
+          end
+
+          puts
+          print_version_summary(results)
+        end
+
+        def print_version_summary(results)
+          rows = [
+            [t('expected_version'), results[:expected_version]],
+            [t('total_references'), results[:references].size],
+            [t('mismatches'), results[:mismatches].size]
+          ]
+
+          table = ::Terminal::Table.new(
+            title: Rainbow(t('version_title')).bright,
+            headings: ['Check', 'Result'],
+            rows: rows,
+            style: { border: :unicode_round }
+          )
+          puts table
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,108 @@
+# 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
+      # Unified validation command — runs all schema validators sequentially
+      # and reports aggregated results.
+      class Validate < ::Thor
+        default_task :all
+
+        CATEGORIES = [
+          { name: 'behaviour', dir: 'conf/behaviour', validator: 'BehaviourValidator' },
+          { name: 'design', dir: 'conf/design', validator: 'DesignValidator' },
+          { name: 'tooling', dir: 'conf/tooling', validator: 'ToolingValidator' }
+        ].freeze
+
+        desc 'all', 'Validate all configuration files across all categories'
+        long_desc <<~LONGDESC
+          Validates all configuration files across behaviour, design, and tooling categories.
+          Runs schema validation for each category and reports aggregated results in a summary table.
+
+          Exit codes:
+            0 - All files valid
+            1 - Validation failures detected
+
+          EXAMPLES
+
+            raictl validate
+
+          Related commands: behaviour validate, design validate, tooling validate
+        LONGDESC
+        def all
+          results = CATEGORIES.map { |cat| validate_category(cat) }
+          print_summary(results)
+
+          failed = results.any? { |r| r[:failed].positive? }
+          raise ::Thor::Error, t('validation_failed') if failed
+        end
+
+        private
+
+        def t(key, **)
+          ::I18n.t("rosett_ai.cli.validate.#{key}", **)
+        end
+
+        def validate_category(category)
+          dir = RosettAi.conf_root.join(category[:dir])
+          files = Dir.glob(dir.join('*.yml'))
+
+          result = { category: category[:name], total: files.size, passed: 0, failed: 0, errors: [] }
+          return result if files.empty?
+
+          validator = RosettAi::Validators.const_get(category[:validator]).new
+          files.each { |file| validate_file(validator, file, result) }
+          result
+        rescue RosettAi::ConfigurationError => e
+          puts "  #{Rainbow(t('invalid')).red} #{category[:name]}: #{e.message}"
+          { category: category[:name], total: 0, passed: 0, failed: 1, errors: [e.message] }
+        end
+
+        def validate_file(validator, file, result)
+          basename = File.basename(file)
+          if validator.valid?(file)
+            result[:passed] += 1
+            puts "  #{Rainbow(t('valid')).green}   #{result[:category]}/#{basename}"
+          else
+            result[:failed] += 1
+            result[:errors] << { file: basename, messages: validator.errors.dup }
+            puts "  #{Rainbow(t('invalid')).red} #{result[:category]}/#{basename}"
+            validator.errors.each { |err| puts "           #{err}" }
+          end
+        end
+
+        def print_summary(results)
+          puts
+
+          rows = results.map do |r|
+            status = r[:failed].positive? ? Rainbow(t('fail')).red : Rainbow(t('ok')).green
+            [r[:category], r[:total], r[:passed], r[:failed], status]
+          end
+
+          total_files = results.sum { |r| r[:total] }
+          total_passed = results.sum { |r| r[:passed] }
+          total_failed = results.sum { |r| r[:failed] }
+          total_status = total_failed.positive? ? Rainbow(t('fail')).red : Rainbow(t('ok')).green
+
+          rows << :separator
+          rows << [Rainbow(t('total')).bright, total_files, total_passed, total_failed, total_status]
+
+          table = ::Terminal::Table.new(
+            title: Rainbow(t('summary_title')).bright,
+            headings: [t('category'), t('files'), t('passed'), t('failed_label'), t('status')],
+            rows: rows,
+            style: { border: :unicode_round }
+          )
+          puts table
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,196 @@
+# 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 workflow` — declarative workflow execution.
+      #
+      # Provides commands to list, validate, simulate, and run workflows.
+      # Workflows are YAML files defining multi-step automation sequences.
+      #
+      # @author hugo
+      # @author claude
+      class Workflow < ::Thor
+        desc 'list', 'List available workflow files'
+        long_desc <<~LONGDESC
+          Lists all workflow YAML files found in conf/workflows/ and
+          the project .rosett-ai/workflows/ directory.
+
+          EXAMPLES
+
+            raictl workflow list
+        LONGDESC
+        def list
+          files = discover_workflows
+          if files.empty?
+            warn ::I18n.t('rosett_ai.workflow.no_files')
+            return
+          end
+
+          rows = files.filter_map do |path|
+            data = load_workflow_safe(path)
+            next unless data
+
+            [data['name'] || File.basename(path, '.yml'), data['version'] || '-',
+             data.fetch('steps', []).size, path.to_s]
+          end
+
+          table = ::Terminal::Table.new(
+            title: ::I18n.t('rosett_ai.workflow.list_title'),
+            headings: [::I18n.t('rosett_ai.workflow.name'), ::I18n.t('rosett_ai.workflow.version'),
+                       ::I18n.t('rosett_ai.workflow.steps_count'), ::I18n.t('rosett_ai.workflow.path')],
+            rows: rows
+          )
+          puts table
+        end
+
+        desc 'validate NAME', 'Validate a workflow definition'
+        long_desc <<~LONGDESC
+          Validates the workflow YAML file against the workflow schema
+          and runs security checks (array-form commands, max step count).
+
+          EXAMPLES
+
+            raictl workflow validate release
+        LONGDESC
+        def validate(name)
+          path = resolve_workflow(name)
+          engine = RosettAi::Workflow::Engine.new(workflow_path: path)
+          errors = engine.validate
+
+          if errors.empty?
+            puts Rainbow(::I18n.t('rosett_ai.workflow.valid', name: name)).green
+          else
+            warn Rainbow(::I18n.t('rosett_ai.workflow.invalid', name: name)).red
+            errors.each { |err| warn "  - #{err}" }
+            exit 2
+          end
+        end
+
+        desc 'simulate NAME', 'Dry-run a workflow (show steps without executing)'
+        long_desc <<~LONGDESC
+          Shows what each step would do without actually executing.
+          Useful for reviewing a workflow before running it.
+
+          EXAMPLES
+
+            raictl workflow simulate release
+        LONGDESC
+        def simulate(name)
+          path = resolve_workflow(name)
+          engine = RosettAi::Workflow::Engine.new(workflow_path: path)
+          descriptions = engine.simulate
+
+          puts ::I18n.t('rosett_ai.workflow.simulate_header', name: name)
+          descriptions.each_with_index do |desc, idx|
+            puts "  #{idx + 1}. #{desc}"
+          end
+        end
+
+        desc 'execute NAME', 'Execute a workflow'
+        long_desc <<~LONGDESC
+          Executes all steps in the named workflow sequentially.
+
+          Use --resume to skip steps already completed in a previous run
+          (detected via the audit log). Use --format json for CI output.
+
+          Exit codes: 0 = all pass, 1 = any failure.
+
+          EXAMPLES
+
+            raictl workflow execute release
+            raictl workflow execute deploy --resume
+            raictl workflow execute ci-check --format json
+        LONGDESC
+        method_option :resume, type: :boolean, default: false,
+                               desc: 'Resume from last completed step'
+        method_option :format, type: :string, enum: ['table', 'json'], default: 'table',
+                               desc: 'Output format'
+        def execute(name)
+          path = resolve_workflow(name)
+          audit_path = resolve_audit_log_path(name)
+          engine = RosettAi::Workflow::Engine.new(workflow_path: path, audit_log_path: audit_path)
+          summary = engine.execute(resume: options[:resume])
+
+          if options[:format] == 'json'
+            puts JSON.pretty_generate(summary)
+          else
+            render_table(summary)
+          end
+
+          exit 1 if summary[:status] == 'fail'
+        end
+
+        private
+
+        def discover_workflows
+          paths = []
+          conf_dir = RosettAi.root.join('conf', 'workflows')
+          paths += Dir.glob(conf_dir.join('*.yml').to_s).map { |path| Pathname.new(path) } if conf_dir.directory?
+
+          project_dir = Pathname.new(ENV.fetch('RAI_ORIGINAL_PWD', Dir.pwd)).join('.rosett-ai', 'workflows')
+          paths += Dir.glob(project_dir.join('*.yml').to_s).map { |path| Pathname.new(path) } if project_dir.directory?
+
+          paths
+        end
+
+        def resolve_workflow(name)
+          candidates = discover_workflows
+          match = candidates.find { |path| File.basename(path, '.yml') == name }
+          raise RosettAi::WorkflowError, ::I18n.t('rosett_ai.workflow.not_found', name: name) unless match
+
+          match
+        end
+
+        def resolve_audit_log_path(name)
+          RosettAi.root.join('tmp', 'workflow_audit', "#{name}.jsonl")
+        end
+
+        def load_workflow_safe(path)
+          YAML.safe_load(path.read, permitted_classes: [Date])
+        rescue StandardError
+          nil
+        end
+
+        def render_table(summary)
+          rows = summary[:results].map do |result|
+            status_text = colorize_status(result[:status])
+            duration = result[:duration_ms] ? "#{result[:duration_ms]}ms" : '-'
+            [result[:step], status_text, result[:message], duration]
+          end
+
+          table = ::Terminal::Table.new(
+            title: ::I18n.t('rosett_ai.workflow.run_title', name: summary[:workflow]),
+            headings: [::I18n.t('rosett_ai.workflow.step_label'), ::I18n.t('rosett_ai.workflow.status_label'),
+                       ::I18n.t('rosett_ai.workflow.message_label'), ::I18n.t('rosett_ai.workflow.duration_label')],
+            rows: rows
+          )
+          puts table
+          puts summary_line(summary)
+        end
+
+        def colorize_status(status)
+          case status
+          when 'pass' then Rainbow(status).green
+          when 'fail' then Rainbow(status).red
+          when 'skip' then Rainbow(status).yellow
+          else status
+          end
+        end
+
+        def summary_line(summary)
+          ::I18n.t('rosett_ai.workflow.run_summary',
+                   total: summary[:total], pass: summary[:pass],
+                   fail: summary[:fail], skip: summary[:skip])
+        end
+      end
+    end
+  end
+end

data/lib/rosett_ai/tooling/ci_yaml_validator.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+module RosettAi
+  module Tooling
+    # MCP-facing facade for CI YAML validation.
+    #
+    # Delegates to the GitLab CI YAML validators, providing the
+    # simplified interface expected by {Mcp::Tools::ToolingTool}.
+    #
+    # @author hugo
+    # @author claude
+    class CiYamlValidator
+      def initialize(project_dir: Dir.pwd)
+        @project_dir = project_dir
+      end
+
+      # Validates all CI YAML files in the project.
+      #
+      # @return [Hash] with :errors and :files keys
+      def validate
+        validator = RosettAi::Gitlab::Validators::SupplementaryGitlabCiYamlValidator.new(
+          project_dir: @project_dir
+        )
+        result = validator.validate
+        valid_files = result.fetch(:valid, []).map { |entry| entry[:file] }
+        invalid_entries = result.fetch(:invalid, [])
+        {
+          errors: invalid_entries.map { |entry| entry[:message] },
+          files: valid_files + invalid_entries.map { |entry| entry[:file] }
+        }
+      end
+    end
+  end
+end

data/lib/rosett_ai/tooling/version_checker.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+module RosettAi
+  module Tooling
+    # MCP-facing facade for tool version checking.
+    #
+    # Delegates to {VersionConsistencyChecker} and {GemConsistencyChecker}
+    # for the actual version checks, providing the simplified interface
+    # expected by {Mcp::Tools::ToolingTool}.
+    #
+    # @author hugo
+    # @author claude
+    class VersionChecker
+      def initialize(project_dir: Dir.pwd)
+        @project_dir = project_dir
+      end
+
+      # Checks tool and gem versions for consistency.
+      #
+      # @return [Hash] with :outdated and :tools keys
+      def check
+        checker = RosettAi::VersionConsistencyChecker.new(project_dir: @project_dir)
+        result = checker.check
+        outdated = result[:mismatches] || []
+        {
+          outdated: outdated,
+          tools: result[:references] || []
+        }
+      end
+    end
+  end
+end