rosett-ai 1.3.3

data/lib/rosett_ai/provenance/trailer_generator.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+module RosettAi
+  module Provenance
+    # Generates commit trailers from provenance entries.
+    #
+    # Produces standardised commit trailers in the format:
+    #   Role: Tool Version (Provider) <email>
+    class TrailerGenerator
+      # Generates a commit trailer from a provenance entry.
+      #
+      # @param entry [Entry, Hash] provenance entry
+      # @return [String] formatted commit trailer
+      def generate(entry)
+        entry_hash = entry.is_a?(Hash) ? entry : entry.to_h
+        role = entry_hash['ai_role'] || entry_hash[:ai_role]
+        tool = entry_hash['ai_tool'] || entry_hash[:ai_tool]
+
+        "#{role}: #{tool}"
+      end
+
+      # Generates trailers for all entries in a provenance dataset.
+      #
+      # @param data [Hash] full provenance data with 'entries' key
+      # @return [Array<String>] unique trailers
+      def generate_all(data)
+        entries = data.fetch('entries', [])
+        entries.map { |entry| generate(entry) }.uniq
+      end
+
+      # Formats trailers as a block suitable for appending to a commit message.
+      #
+      # @param data [Hash] full provenance data
+      # @return [String] newline-separated trailer block
+      def trailer_block(data)
+        generate_all(data).join("\n")
+      end
+    end
+  end
+end

data/lib/rosett_ai/provenance/validator.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+require 'json'
+require 'json_schemer'
+
+module RosettAi
+  module Provenance
+    # Validates provenance entries against the provenance JSON Schema.
+    class Validator
+      SCHEMA_PATH = File.join(RosettAi.root, 'conf', 'schemas', 'provenance_schema.json')
+
+      # Validates provenance data against the schema.
+      #
+      # @param data [Hash] provenance data (parsed YAML)
+      # @return [Array<String>] list of validation errors (empty if valid)
+      def validate(data)
+        schema = load_schema
+        schemer = JSONSchemer.schema(schema)
+        errors = schemer.validate(data)
+        errors.map { |error| format_error(error) }
+      end
+
+      # @param data [Hash] provenance data
+      # @return [Boolean] true if data is valid
+      def valid?(data)
+        validate(data).empty?
+      end
+
+      private
+
+      def load_schema
+        JSON.parse(File.read(SCHEMA_PATH))
+      end
+
+      def format_error(error)
+        path = error['data_pointer']
+        message = error['type']
+        "#{path}: #{message}"
+      end
+    end
+  end
+end

data/lib/rosett_ai/quorum/collector.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+module RosettAi
+  module Quorum
+    # Normalizes per-engine responses to the standard adopt contract:
+    # { findings: [...], overall_status: "pass|warn|fail", summary: "..." }
+    #
+    # Annotates each finding with its source engine.
+    class Collector
+      # Normalize dispatched results into per-engine response hashes.
+      #
+      # @param dispatched [Hash<String, Hash>] engine_name => dispatch result
+      # @return [Hash<String, Hash>] engine_name => normalized result
+      def collect(dispatched)
+        dispatched.transform_values { |dispatch_entry| normalize(dispatch_entry) }
+      end
+
+      private
+
+      def normalize(dispatch_entry)
+        engine_name = dispatch_entry[:engine]
+        error = dispatch_entry[:error]
+
+        return error_result(engine_name, error) if error
+
+        annotate_findings(engine_name, dispatch_entry[:result])
+      end
+
+      def annotate_findings(engine_name, result)
+        findings = (result['findings'] || []).map do |finding|
+          finding.merge('engine' => engine_name)
+        end
+
+        {
+          'findings' => findings,
+          'overall_status' => result['overall_status'] || 'pass',
+          'summary' => result['summary'] || ''
+        }
+      end
+
+      def error_result(engine_name, error_message)
+        {
+          'findings' => [{
+            'category' => 'other', 'severity' => 'high',
+            'file' => 'N/A', 'rule_id' => nil,
+            'summary' => "Engine #{engine_name} failed",
+            'explanation' => error_message,
+            'engine' => engine_name
+          }],
+          'overall_status' => 'fail',
+          'summary' => "Engine #{engine_name} failed: #{error_message}"
+        }
+      end
+    end
+  end
+end

data/lib/rosett_ai/quorum/comparator.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+module RosettAi
+  module Quorum
+    # Aggregates findings from multiple engines.
+    #
+    # Cross-engine findings (same category + file + rule_id from 2+ engines)
+    # are promoted by severity. Unique findings are annotated with their
+    # source engine for transparency.
+    class Comparator
+      FAIL_SEVERITIES = ['high', 'critical'].freeze
+      SEVERITY_RANK = { 'low' => 0, 'medium' => 1, 'high' => 2, 'critical' => 3 }.freeze
+
+      # Compare and aggregate collected engine results.
+      #
+      # @param collected [Hash<String, Hash>] engine_name => normalized result
+      # @return [Hash] merged result with findings, overall_status, summary
+      def compare(collected)
+        all_findings = collected.values.flat_map { |r| r['findings'] }
+        grouped = group_findings(all_findings)
+        merged = grouped.map { |_key, group| merge_group(group) }
+
+        {
+          'findings' => merged,
+          'overall_status' => determine_status(merged),
+          'summary' => build_summary(merged, collected.keys)
+        }
+      end
+
+      private
+
+      def group_findings(findings)
+        findings.group_by { |f| finding_key(f) }
+      end
+
+      def finding_key(finding)
+        [finding['category'], finding['file'], finding['rule_id']].join('|')
+      end
+
+      def merge_group(group)
+        engines = extract_engines(group)
+        merged = highest_severity_finding(group)
+        merged['engines'] = engines
+        merged['cross_engine'] = engines.size > 1
+        merged
+      end
+
+      def extract_engines(group)
+        group.map { |entry| entry['engine'] }.uniq
+      end
+
+      def highest_severity_finding(group)
+        group.max_by { |entry| SEVERITY_RANK.fetch(entry['severity'], -1) }.dup
+      end
+
+      def determine_status(findings)
+        if findings.any? { |f| FAIL_SEVERITIES.include?(f['severity']) }
+          'fail'
+        elsif findings.any?
+          'warn'
+        else
+          'pass'
+        end
+      end
+
+      def build_summary(findings, engine_names)
+        return "No issues found across #{engine_names.size} engine(s)" if findings.empty?
+
+        cross = findings.count { |f| f['cross_engine'] }
+        unique = findings.size - cross
+        parts = ["#{findings.size} finding(s) across #{engine_names.size} engine(s)"]
+        parts << "#{cross} cross-engine" if cross.positive?
+        parts << "#{unique} unique" if unique.positive?
+        parts.join(', ')
+      end
+    end
+  end
+end

data/lib/rosett_ai/quorum/dispatcher.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+module RosettAi
+  module Quorum
+    # Dispatches a prompt to multiple engine executors in parallel.
+    #
+    # Uses Thread (not Ractor) because the anthropic gem and Net::HTTP
+    # are not Ractor-safe. Thread is sufficient for I/O-bound API calls.
+    class Dispatcher
+      # Dispatch a prompt to the given executors.
+      #
+      # @param prompt [String] the analysis prompt
+      # @param executors [Hash<String, Object>] engine_name => executor pairs
+      # @return [Hash<String, Hash>] engine_name => {result:, error:, elapsed:}
+      def dispatch(prompt, executors)
+        threads = spawn_threads(prompt, executors)
+        collect_thread_results(threads)
+      end
+
+      private
+
+      def spawn_threads(prompt, executors)
+        executors.map do |engine_name, executor|
+          Thread.new(engine_name, executor) do |name, exec|
+            Thread.current[:engine] = name
+            dispatch_single(name, exec, prompt)
+          end
+        end
+      end
+
+      def dispatch_single(engine_name, executor, prompt)
+        start = monotonic_now
+        result = executor.analyze(prompt)
+
+        { engine: engine_name, result: result, error: nil, elapsed: monotonic_now - start }
+      rescue StandardError => e
+        { engine: engine_name, result: nil, error: e.message, elapsed: monotonic_now - start }
+      end
+
+      def monotonic_now
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+
+      def collect_thread_results(threads)
+        results = {}
+        threads.each do |thread|
+          thread.join
+          results[thread[:engine]] = thread.value
+        end
+        results
+      end
+    end
+  end
+end

data/lib/rosett_ai/quorum/strategies/adopt.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+module RosettAi
+  module Quorum
+    module Strategies
+      # Orchestrates multi-engine adopt analysis:
+      # 1. Detect available engines with adopt_api capability
+      # 2. Resolve executors via ExecutorResolver
+      # 3. Dispatch prompt to all executors in parallel
+      # 4. Collect and compare results
+      class Adopt
+        def initialize(api_key: nil)
+          @api_key = api_key
+        end
+
+        # Run quorum adopt analysis.
+        #
+        # @param prompt [String] the analysis prompt
+        # @return [Hash] aggregated result with findings, overall_status, summary
+        def run(prompt)
+          executors = resolve_executors
+          raise RosettAi::AdoptError, 'No engines with adopt_api capability detected' if executors.empty?
+
+          dispatched = Dispatcher.new.dispatch(prompt, executors)
+          collected = Collector.new.collect(dispatched)
+          Comparator.new.compare(collected)
+        end
+
+        # List engines eligible for quorum adopt.
+        #
+        # @return [Array<String>] engine names
+        def eligible_engines
+          RosettAi::Engines::Registry.available.select do |name|
+            manifest = RosettAi::Engines::Registry.manifest(name)
+            manifest.dig('capabilities', 'adopt_api') == true &&
+              manifest.dig('components', 'executor') == true
+          end
+        end
+
+        private
+
+        def resolve_executors
+          eligible_engines.each_with_object({}) do |name, hash|
+            resolver = RosettAi::Adopter::ExecutorResolver.new(name)
+            hash[name] = resolver.resolve(api_key: @api_key)
+          rescue RosettAi::AdoptError => e
+            RosettAi.logger.warn("Skipping engine #{name} for quorum: #{e.message}")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rosett_ai/rai_config.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+require 'json_schemer'
+
+module RosettAi
+  # Loads and validates Rosett-AI runtime configuration from ~/.config/rosett-ai/config.yml.
+  #
+  # Returns compiled defaults when no config file exists. User values are
+  # deep-merged over defaults and validated against the rai config JSON Schema.
+  class RaiConfig
+    DEFAULTS = {
+      'default_engine' => 'claude',
+      'cache' => { 'enabled' => true, 'ttl_hours' => 24 },
+      'detect' => { 'on_init' => true },
+      'dbus' => { 'allow_plugin_management' => false }
+    }.freeze
+
+    attr_reader :config_path
+
+    def initialize(config_path: nil)
+      @config_path = config_path || RosettAi.paths.rai_config_dir.join('config.yml')
+      @data = load_config
+    end
+
+    def default_engine     = @data['default_engine']
+    def cache_enabled?     = @data.dig('cache', 'enabled')
+    def cache_ttl_hours    = @data.dig('cache', 'ttl_hours')
+    def detect_on_init?    = @data.dig('detect', 'on_init')
+    def dbus_allow_plugin_management? = @data.dig('dbus', 'allow_plugin_management') == true
+
+    def self.load(config_path: nil)
+      new(config_path: config_path)
+    end
+
+    # Update a configuration key and persist to disk.
+    #
+    # @param key [String] dot-separated key (e.g. 'default_engine', 'cache.enabled')
+    # @param value [String] new value (coerced to boolean/integer where appropriate)
+    def update(key, value)
+      coerced = coerce_value(value)
+      set_nested_key(@data, key, coerced)
+      validate!(@data)
+      persist!
+    end
+
+    private
+
+    def load_config
+      return DEFAULTS.dup unless @config_path.exist?
+
+      user_data = RosettAi::YamlLoader.load_file(@config_path.to_s)
+      merged = deep_merge(DEFAULTS, user_data || {})
+      validate!(merged)
+      merged
+    end
+
+    def validate!(data)
+      schema_path = RosettAi.root.join('conf', 'schemas', 'rai_config_schema.json')
+      schema = JSON.parse(schema_path.read)
+      schemer = JSONSchemer.schema(schema)
+      errors = schemer.validate(data).to_a
+
+      return if errors.empty?
+
+      messages = errors.map { |e| "#{e['data_pointer']}: #{e['type']}" }
+      raise RosettAi::ConfigurationError,
+            "Invalid rai config at #{@config_path}: #{messages.join(', ')}"
+    end
+
+    def persist!
+      FileUtils.mkdir_p(@config_path.dirname)
+      File.write(@config_path, YAML.dump(@data))
+      File.chmod(0o600, @config_path)
+    end
+
+    def coerce_value(value)
+      case value
+      when 'true' then true
+      when 'false' then false
+      when /\A\d+\z/ then value.to_i
+      else value
+      end
+    end
+
+    def set_nested_key(data, key, value)
+      parts = key.split('.')
+      target = parts[0..-2].reduce(data) { |hash, k| hash[k] ||= {} }
+      target[parts.last] = value
+    end
+
+    def deep_merge(base, overlay)
+      base.each_with_object(overlay.dup) do |(key, base_val), result|
+        overlay_val = result[key]
+        result[key] = if result.key?(key) && base_val.is_a?(Hash) && overlay_val.is_a?(Hash)
+                        deep_merge(base_val, overlay_val)
+                      elsif result.key?(key)
+                        overlay_val
+                      else
+                        base_val.is_a?(Hash) ? base_val.dup : base_val
+                      end
+      end
+    end
+  end
+end

data/lib/rosett_ai/retrofit/base_parser.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+module RosettAi
+  module Retrofit
+    # Abstract base class for engine-specific retrofit parsers.
+    #
+    # Each engine provides a parser that knows how to discover and read
+    # native config files, convert them to Rosett-AI YAML structure, and
+    # identify unknown keys.
+    #
+    # @abstract Subclasses must implement {#discover}, {#parse}, and {#engine_name}.
+    # @author hugo
+    # @author claude
+    class BaseParser
+      # @return [String] engine identifier
+      def engine_name
+        raise NotImplementedError, "#{self.class}#engine_name must be implemented"
+      end
+
+      # Discovers native config files for this engine.
+      #
+      # @return [Array<Pathname>] list of discovered config file paths
+      def discover
+        raise NotImplementedError, "#{self.class}#discover must be implemented"
+      end
+
+      # Parses a native config file into Rosett-AI YAML structure.
+      #
+      # @param path [Pathname] path to the native config file
+      # @return [Hash] parsed configuration data with :data, :unknown_keys, :source_file keys
+      def parse(path)
+        raise NotImplementedError, "#{self.class}#parse must be implemented"
+      end
+
+      # @return [Boolean] true if this engine's native config is present
+      def available?
+        discover.any?
+      end
+
+      private
+
+      # Validates that a path is safe to read (within HOME, no symlink escape).
+      #
+      # @param path [Pathname] path to validate
+      # @return [Boolean] true if path is safe
+      def safe_path?(path)
+        home = Pathname.new(Dir.home)
+        resolved = path.realpath
+        resolved.to_s.start_with?(home.to_s)
+      rescue Errno::ENOENT
+        false
+      end
+
+      # Strips ANSI escape sequences and control characters from a string.
+      #
+      # @param text [String] input text
+      # @return [String] sanitized text
+      def sanitize(text)
+        text.to_s.gsub(/\e\[[0-9;]*[a-zA-Z]/, '').gsub(/[\x00-\x08\x0B\x0C\x0E-\x1F]/, '')
+      end
+    end
+  end
+end

data/lib/rosett_ai/retrofit/engine.rb

@@ -0,0 +1,171 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+require 'yaml'
+require 'fileutils'
+
+module RosettAi
+  module Retrofit
+    # Orchestrates reverse compilation from native AI tool configs to Rosett-AI YAML.
+    #
+    # Discovers installed engines, parses native configs, redacts secrets,
+    # and writes rosett-ai-compatible YAML source files.
+    #
+    # @author hugo
+    # @author claude
+    class Engine
+      PARSER_REGISTRY = {
+        'claude' => 'RosettAi::Retrofit::Parsers::ClaudeParser',
+        'cursor' => 'RosettAi::Retrofit::Parsers::CursorParser',
+        'agents_md' => 'RosettAi::Retrofit::Parsers::AgentsMdParser'
+      }.freeze
+
+      # @param output_dir [Pathname] directory to write generated YAML
+      # @param engines [Array<String>, nil] specific engines or nil for auto-detect
+      # @param force [Boolean] overwrite existing files
+      def initialize(output_dir:, engines: nil, force: false)
+        @output_dir = output_dir
+        @requested_engines = engines
+        @force = force
+        @warnings = []
+        @secret_detector = SecretDetector.new(warnings: @warnings)
+      end
+
+      # Performs the retrofit operation.
+      #
+      # @return [Hash] result with :generated, :skipped, :errors, :warnings keys
+      def retrofit
+        results = { generated: [], skipped: [], errors: [], warnings: [] }
+        parsers = resolve_parsers(results)
+
+        parsers.each { |parser| retrofit_engine(parser, results) }
+
+        write_manifest(results) unless results[:generated].empty?
+        results[:warnings] = @warnings
+        results
+      end
+
+      # Simulates retrofit without writing files.
+      #
+      # @return [Hash] same structure as retrofit but read-only
+      def simulate
+        results = { generated: [], skipped: [], errors: [], warnings: [] }
+        parsers = resolve_parsers(results)
+
+        parsers.each { |parser| simulate_engine(parser, results) }
+
+        results[:warnings] = @warnings
+        results
+      end
+
+      # @return [Array<String>] list of available engine names
+      def self.available_engines
+        PARSER_REGISTRY.keys
+      end
+
+      private
+
+      def resolve_parsers(results)
+        if @requested_engines
+          @requested_engines.filter_map do |name|
+            klass_name = PARSER_REGISTRY[name]
+            unless klass_name
+              results[:errors] << "No retrofit adapter for engine '#{name}'"
+              next
+            end
+            Object.const_get(klass_name).new
+          end
+        else
+          auto_detect_parsers
+        end
+      end
+
+      def auto_detect_parsers
+        PARSER_REGISTRY.filter_map do |_name, klass_name|
+          parser = Object.const_get(klass_name).new
+          parser if parser.available?
+        end
+      end
+
+      def retrofit_engine(parser, results)
+        parser.discover.each do |path|
+          parsed = parser.parse(path)
+          redacted = @secret_detector.redact(parsed[:data])
+          output_path = resolve_output_path(parser.engine_name, parsed[:scope])
+
+          write_yaml(output_path, redacted, parsed, results)
+        rescue RosettAi::RetrofitError => e
+          results[:errors] << "#{parser.engine_name}: #{e.message}"
+        end
+      end
+
+      def simulate_engine(parser, results)
+        parser.discover.each do |path|
+          parsed = parser.parse(path)
+          @secret_detector.redact(parsed[:data])
+          output_path = resolve_output_path(parser.engine_name, parsed[:scope])
+
+          if output_path.exist? && !@force
+            results[:skipped] << output_path.to_s
+          else
+            results[:generated] << output_path.to_s
+          end
+        rescue RosettAi::RetrofitError => e
+          results[:errors] << "#{parser.engine_name}: #{e.message}"
+        end
+      end
+
+      def resolve_output_path(engine_name, scope)
+        @output_dir.join('conf', engine_name, "#{scope}.yml")
+      end
+
+      def write_yaml(path, data, parsed, results)
+        if path.exist? && !@force
+          results[:skipped] << path.to_s
+          return
+        end
+
+        path.dirname.mkpath
+        content = build_yaml_content(data, parsed)
+        File.write(path, content)
+        results[:generated] << path.to_s
+      end
+
+      def build_yaml_content(data, parsed)
+        lines = []
+        lines << "# Retrofitted from: #{parsed[:source_file]}"
+        lines << "# Engine: #{parsed.fetch(:scope, 'unknown')}"
+        lines << "# Date: #{Time.now.utc.iso8601}"
+        lines << "# rosett-ai version: #{RosettAi::VERSION}"
+
+        unknown = parsed[:unknown_keys]
+        unless unknown.empty?
+          lines << '#'
+          lines << '# Unknown keys (not in rosett-ai schema, preserved for compatibility):'
+          unknown.each { |key| lines << "#   - #{key}" }
+        end
+
+        lines << '---'
+        lines << YAML.dump(data).delete_prefix("---\n")
+        lines.join("\n")
+      end
+
+      def write_manifest(results)
+        manifest_path = @output_dir.join('conf', 'retrofit_manifest.yml')
+        manifest_path.dirname.mkpath
+
+        manifest = {
+          'retrofitted_at' => Time.now.utc.iso8601,
+          'rai_version' => RosettAi::VERSION,
+          'sources' => results[:generated].map do |path|
+            { 'output' => path, 'engine' => File.basename(File.dirname(path)) }
+          end
+        }
+
+        File.write(manifest_path, YAML.dump(manifest))
+      end
+    end
+  end
+end