rosett-ai 1.3.3

data/lib/rosett_ai/backup/compressor.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+require 'rubygems/package'
+require 'zlib'
+require 'fileutils'
+
+module RosettAi
+  module Backup
+    # Factory and base for compression handlers
+    class Compressor
+      ALGORITHMS = ['zip', 'tar.gz', 'tar.xz'].freeze
+
+      # Returns a compressor instance for the given algorithm.
+      #
+      # @param algorithm [String] one of 'zip', 'tar.gz', 'tar.xz'
+      # @return [Compressor]
+      # @raise [RosettAi::BackupError] if algorithm is not supported
+      def self.for(algorithm)
+        case algorithm
+        when 'zip' then ZipCompressor.new
+        when 'tar.gz' then TarGzCompressor.new
+        when 'tar.xz' then TarXzCompressor.new
+        else
+          raise RosettAi::BackupError,
+                "Unknown compression algorithm: #{algorithm}. Supported: #{ALGORITHMS.join(', ')}"
+        end
+      end
+
+      # Whether the compression tool is available on this system.
+      #
+      # @return [Boolean]
+      # @abstract Subclasses must implement this method.
+      def available?
+        raise NotImplementedError
+      end
+
+      # File extension for archives produced by this compressor.
+      #
+      # @return [String] file extension including the leading dot
+      def extension
+        raise NotImplementedError
+      end
+
+      # Compresses files into an archive at +output_path+.
+      #
+      # @param files [Array<Hash>] entries with :full_path and :archive_path keys
+      # @param base_dirs [Array<String>] base directories for relative path resolution
+      # @param output_path [String] destination path for the archive
+      # @param level [Integer, nil] compression level (algorithm-specific; nil for default)
+      # @return [String] the output path
+      # @abstract Subclasses must implement this method.
+      def compress(files, base_dirs, output_path, level: nil)
+        raise NotImplementedError
+      end
+    end
+
+    # ZIP compression using rubyzip gem
+    class ZipCompressor < Compressor
+      # @return [Boolean] true if the rubyzip gem is loadable
+      def available?
+        require 'zip'
+        true
+      rescue LoadError
+        false
+      end
+
+      # @return [String] ".zip"
+      def extension
+        '.zip'
+      end
+
+      # @param files [Array<Hash>] entries with :full_path and :archive_path keys
+      # @param _base_dirs [Array<String>] unused
+      # @param output_path [String] destination path for the archive
+      # @param level [Integer, nil] Zlib compression level (nil for default)
+      # @return [String] the output path
+      def compress(files, _base_dirs, output_path, level: nil)
+        require 'zip'
+        compression_level = level || Zip.default_compression
+
+        ::Zip::OutputStream.open(output_path) do |zipfile|
+          files.each do |entry|
+            zipfile.put_next_entry(entry[:archive_path], nil, nil, ::Zip::Entry::DEFLATED, compression_level)
+            zipfile.write(File.read(entry[:full_path]))
+          end
+        end
+
+        output_path
+      end
+    end
+
+    # tar.gz compression using Ruby stdlib
+    class TarGzCompressor < Compressor
+      # @return [Boolean] always true (uses Ruby stdlib)
+      def available?
+        true
+      end
+
+      # @return [String] ".tar.gz"
+      def extension
+        '.tar.gz'
+      end
+
+      # @param files [Array<Hash>] entries with :full_path and :archive_path keys
+      # @param _base_dirs [Array<String>] unused
+      # @param output_path [String] destination path for the archive
+      # @param level [Integer, nil] Zlib compression level (nil for default)
+      # @return [String] the output path
+      def compress(files, _base_dirs, output_path, level: nil)
+        gz_level = level || Zlib::DEFAULT_COMPRESSION
+
+        File.open(output_path, 'wb', 0o644) do |file|
+          Zlib::GzipWriter.wrap(file, gz_level) do |gz|
+            Gem::Package::TarWriter.new(gz) do |tar|
+              files.each do |entry|
+                content = File.read(entry[:full_path])
+                tar.add_file_simple(entry[:archive_path], 0o644, content.bytesize) do |io|
+                  io.write(content)
+                end
+              end
+            end
+          end
+        end
+
+        output_path
+      end
+    end
+
+    # tar.xz compression using system xz command
+    class TarXzCompressor < Compressor
+      # @return [Boolean] true if the +xz+ binary is found on PATH
+      def available?
+        ENV.fetch('PATH', '').split(File::PATH_SEPARATOR).any? do |dir|
+          File.executable?(File.join(dir, 'xz'))
+        end
+      end
+
+      # @return [String] ".tar.xz"
+      def extension
+        '.tar.xz'
+      end
+
+      # @param files [Array<Hash>] entries with :full_path and :archive_path keys
+      # @param _base_dirs [Array<String>] unused
+      # @param output_path [String] destination path for the archive
+      # @param level [Integer, nil] xz preset level (1-9; nil for xz default)
+      # @return [String] the output path
+      # @raise [RosettAi::BackupError] if the xz command fails
+      def compress(files, _base_dirs, output_path, level: nil)
+        tar_path = "#{output_path}.tar"
+
+        File.open(tar_path, 'wb', 0o644) do |file|
+          Gem::Package::TarWriter.new(file) do |tar|
+            files.each do |entry|
+              content = File.read(entry[:full_path])
+              tar.add_file_simple(entry[:archive_path], 0o644, content.bytesize) do |io|
+                io.write(content)
+              end
+            end
+          end
+        end
+
+        xz_args = ['xz']
+        xz_args.push("-#{level}") if level
+        xz_args.push('--stdout', tar_path)
+        success = File.open(output_path, 'wb', 0o644) do |out|
+          system(*xz_args, out: out)
+        end
+        FileUtils.rm_f(tar_path)
+
+        raise RosettAi::BackupError, 'xz compression failed' unless success
+
+        output_path
+      end
+    end
+  end
+end

data/lib/rosett_ai/backup/destination.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+module RosettAi
+  module Backup
+    # Base class for backup destinations
+    class Destination
+      SUPPORTED_SCHEMES = ['file', 's3', 'ssh', 'bup', 'https'].freeze
+
+      attr_reader :uri
+
+      def initialize(uri)
+        @uri = uri
+      end
+
+      # Writes the archive to this destination.
+      #
+      # @param archive_path [String] path to the archive file to write
+      # @return [String] final destination path
+      # @abstract Subclasses must implement this method.
+      def write(archive_path)
+        raise NotImplementedError, "#{self.class}#write not implemented"
+      end
+
+      # Returns a destination instance for the given URI string.
+      #
+      # @param destination_string [String] URI (e.g. "file:///tmp/backup.zip")
+      # @return [Destination] a FileDestination or UnsupportedDestination
+      def self.for(destination_string)
+        scheme, path = parse_scheme(destination_string)
+
+        case scheme
+        when 'file'
+          FileDestination.new(path)
+        else
+          UnsupportedDestination.new(scheme, path)
+        end
+      end
+
+      # Splits a destination string into scheme and path components.
+      #
+      # @param destination_string [String] URI or bare path
+      # @return [Array(String, String)] scheme and path (defaults to "file" scheme)
+      def self.parse_scheme(destination_string)
+        if destination_string.match?(%r{^[a-z][a-z0-9+\-.]*://})
+          scheme, path = destination_string.split('://', 2)
+          [scheme, path]
+        else
+          ['file', destination_string]
+        end
+      end
+    end
+
+    # Writes archive to local filesystem
+    class FileDestination < Destination
+      attr_reader :path
+
+      def initialize(path)
+        super("file://#{path}")
+        @path = File.expand_path(path)
+      end
+
+      # Copies the archive to the local filesystem destination.
+      #
+      # @param archive_path [String] path to the archive file to copy
+      # @return [String] expanded destination path
+      def write(archive_path)
+        FileUtils.mkdir_p(File.dirname(@path))
+        FileUtils.cp(archive_path, @path)
+        @path
+      end
+    end
+
+    # Placeholder for unsupported destination schemes
+    class UnsupportedDestination < Destination
+      attr_reader :scheme
+
+      def initialize(scheme, path)
+        super("#{scheme}://#{path}")
+        @scheme = scheme
+      end
+
+      def write(_archive_path)
+        raise RosettAi::BackupError,
+              "Destination scheme '#{@scheme}' is not yet supported. Supported: file://"
+      end
+    end
+  end
+end

data/lib/rosett_ai/behaviour/manager.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+require 'yaml'
+require 'fileutils'
+require_relative '../yaml_loader'
+require_relative '../validators/schema_validator'
+require_relative '../validators/behaviour_validator'
+
+module RosettAi
+  module Behaviour
+    # MCP-facing facade for behaviour file management.
+    #
+    # Provides add/modify/delete operations for behaviour YAML files,
+    # matching the interface expected by {Mcp::Tools::BehaviourManageTool}.
+    #
+    # @author hugo
+    # @author claude
+    class Manager
+      # @param behaviour_dir [Pathname, String, nil] override for testing;
+      #   defaults to XDG user path (~/.config/rosett-ai/conf/behaviour/)
+      def initialize(behaviour_dir: nil)
+        @behaviour_dir = Pathname.new(behaviour_dir || RosettAi.paths.rai_conf_dir.join('behaviour'))
+      end
+
+      # Creates a new behaviour file.
+      #
+      # @param name [String] behaviour name
+      # @param description [String, nil] behaviour description
+      # @return [Pathname] path to created file
+      def add(name, description: nil)
+        path = behaviour_path(name)
+        raise RosettAi::BehaviourError, "Behaviour '#{name}' already exists" if path.exist?
+
+        data = build_template(name, description || "#{name} behaviour")
+        FileUtils.mkdir_p(path.dirname)
+        path.write(YAML.dump(data))
+        validate_behaviour!(path)
+        validate_enforcement!(data)
+        path
+      end
+
+      # Modifies an existing behaviour file.
+      #
+      # @param name [String] behaviour name
+      # @param description [String, nil] new description
+      # @return [Pathname] path to modified file
+      def modify(name, description: nil)
+        path = behaviour_path(name)
+        raise RosettAi::BehaviourError, "Behaviour '#{name}' not found" unless path.exist?
+
+        update_behaviour_file(path, description)
+        validate_behaviour!(path)
+        data = RosettAi::YamlLoader.load_file(path.to_s)
+        validate_enforcement!(data)
+        path
+      end
+
+      # Deletes a behaviour file.
+      #
+      # @param name [String] behaviour name
+      # @param options [Hash] :force_delete to skip existence check
+      # @return [Boolean] true on success
+      def delete(name, options: {})
+        path = behaviour_path(name)
+        force_delete = options.fetch(:force_delete, false)
+        raise RosettAi::BehaviourError, "Behaviour '#{name}' not found" unless force_delete || path.exist?
+
+        path.delete if path.exist?
+        cleanup_compiled_rules(name)
+        path
+      end
+
+      private
+
+      def behaviour_path(name)
+        @behaviour_dir.join("#{name}.yml")
+      end
+
+      def update_behaviour_file(path, description)
+        data = RosettAi::YamlLoader.load_file(path.to_s)
+        data['description'] = description if description
+        data['modified_at'] = Time.now.utc.strftime('%Y-%m-%d')
+        path.write(YAML.dump(data))
+      end
+
+      def cleanup_compiled_rules(name)
+        rules_dir = RosettAi.paths.rules_dir
+        return unless rules_dir.exist?
+
+        Dir.glob(rules_dir.join("behaviour-#{name}.*")).each do |compiled|
+          next unless managed_compiled_file?(compiled)
+
+          File.delete(compiled)
+        end
+      rescue Errno::ENOENT
+        # Race condition: file deleted between glob and delete
+      end
+
+      def managed_compiled_file?(path)
+        first_line = File.open(path, &:readline)
+        first_line.include?('rosett-ai-') && first_line.include?('managed')
+      rescue EOFError, Errno::ENOENT
+        false
+      end
+
+      def build_template(name, description)
+        {
+          'name' => name,
+          'description' => description,
+          'version' => '1.0.0',
+          'author' => 'rosett-ai',
+          'created_at' => Time.now.utc.strftime('%Y-%m-%d'),
+          'modified_at' => Time.now.utc.strftime('%Y-%m-%d'),
+          'modified_by' => 'rosett-ai',
+          'sensitive' => false,
+          'used_in' => [],
+          'rules' => [
+            {
+              'id' => 'rule_001',
+              'description' => 'Example rule - replace with actual rule',
+              'priority' => 50,
+              'enabled' => true
+            }
+          ]
+        }
+      end
+
+      def validate_behaviour!(path)
+        validator = RosettAi::Validators::BehaviourValidator.new
+        return if validator.valid?(path.to_s)
+
+        # Remove invalid file to prevent leaving bad state
+        path.delete if path.exist?
+        raise RosettAi::BehaviourError, "Validation failed: #{validator.errors.join(', ')}"
+      end
+
+      # Runs EnforcementValidator on behaviour data. Logs warnings for
+      # downgraded rules but does not block the operation (enforcement
+      # is optional and downgrades are informational).
+      #
+      # @param data [Hash] parsed behaviour YAML
+      # @return [Hash] validation result
+      def validate_enforcement!(data)
+        result = RosettAi::Mcp::Enforcement::Validator.new.validate(data)
+        result[:downgraded].each do |entry|
+          warnings = entry[:warnings].join('; ')
+          warn "[rai-enforce] #{entry[:rule_id]} downgraded to advisory: #{warnings}"
+        end
+        result
+      end
+    end
+  end
+end

data/lib/rosett_ai/compiler/backend.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+module RosettAi
+  module Compiler
+    # Abstract base class for compiler backends.
+    #
+    # Backends transform compiled category data into target-specific output
+    # formats. Each backend is paired with a TargetProfile loaded from
+    # conf/engines/<name>/target.yml.
+    #
+    # Factory method .for(target_name) loads the profile and resolves the
+    # correct backend class from the Plugins::Registry.
+    class Backend
+      # Built-in backends that don't require an external engine gem.
+      # Lazy-loaded via lambdas to avoid circular requires.
+      BUILTIN_BACKENDS = {
+        'agents_md' => -> { RosettAi::Compiler::Backends::AgentsMdBackend },
+        'claude' => -> { RosettAi::Compiler::Backends::ClaudeBackend }
+      }.freeze
+
+      attr_reader :profile
+
+      def initialize(profile)
+        @profile = profile
+      end
+
+      # Factory: load a target profile and instantiate the appropriate backend.
+      #
+      # @param target_name [String, Symbol] engine/target identifier
+      # @return [Backend] the engine-specific backend instance
+      # @raise [RosettAi::CompileError] if the target or backend is unknown
+      def self.for(target_name)
+        name = target_name.to_s
+        profile = TargetProfile.load(name)
+        resolve_backend_class(profile.backend).new(profile)
+      end
+
+      def self.resolve_backend_class(backend_name)
+        return BUILTIN_BACKENDS[backend_name].call if BUILTIN_BACKENDS.key?(backend_name)
+
+        unless Plugins::Registry.registered?(:engine, backend_name)
+          available = Plugins::Registry.available(:engine)
+          hint = if available.empty?
+                   "No engine plugins installed. Install with: apt install rosett-ai-engine-#{backend_name.tr('_', '-')}"
+                 else
+                   "Available engines: #{available.join(', ')}"
+                 end
+          raise CompileError,
+                "Unknown backend: #{backend_name}. #{hint}"
+        end
+
+        plugin = Plugins::Registry.plugin_module(:engine, backend_name)
+        plugin.backend_class
+      end
+      private_class_method :resolve_backend_class
+
+      def render(_data)
+        raise NotImplementedError, "#{self.class}#render must be implemented"
+      end
+
+      def generated_marker
+        raise NotImplementedError, "#{self.class}#generated_marker must be implemented"
+      end
+
+      def managed_file?(path)
+        return false unless File.exist?(path)
+
+        first_line = File.open(path, &:readline)
+        first_line.start_with?(generated_marker)
+      rescue EOFError
+        false
+      end
+
+      def file_extension
+        case profile.output_format
+        when 'json' then '.json'
+        when 'yaml' then '.yml'
+        else '.md'
+        end
+      end
+    end
+  end
+end

data/lib/rosett_ai/compiler/backends/agents_md_backend.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+module RosettAi
+  module Compiler
+    module Backends
+      # Compiler backend for AGENTS.md (AAIF standard format).
+      #
+      # Renders behaviour configuration into idiomatic AGENTS.md files
+      # compatible with Claude Code, Goose, Cursor, and other AAIF-aligned tools.
+      # Output is valid Markdown without YAML frontmatter, following the
+      # AGENTS.md v0.1.0 specification.
+      #
+      # @author hugo
+      # @author claude
+      class AgentsMdBackend < Backend
+        MARKER_PREFIX = '<!-- rosett-ai-agents-md-managed'
+
+        # Renders behaviour data into AGENTS.md format.
+        #
+        # @param data [Hash] parsed YAML behaviour data
+        # @return [String] rendered Markdown content
+        def render(data)
+          lines = build_header(data)
+          lines.concat(build_description(data))
+          lines.concat(build_rules(data))
+          lines << ''
+          lines.join("\n")
+        end
+
+        # @return [String] marker prefix for managed file detection
+        def generated_marker
+          MARKER_PREFIX
+        end
+
+        private
+
+        def build_header(data)
+          lines = ["#{MARKER_PREFIX} -->"]
+          if profile.rendering.fetch('include_source_metadata', false)
+            lines << "<!-- Source: conf/#{data['category']}/#{data['name']}.yml -->"
+          end
+          lines << ''
+          lines << "# #{format_title(data['name'])}"
+          lines
+        end
+
+        def build_description(data)
+          desc = data['description'].to_s.strip
+          return [] if desc.empty?
+
+          ['', desc]
+        end
+
+        def build_rules(data)
+          rules = enabled_rules(data)
+          return [] if rules.empty?
+
+          lines = ['', '## Rules', '']
+          rules.each do |rule|
+            lines << "- #{rule['description'].to_s.strip}"
+          end
+          lines
+        end
+
+        def enabled_rules(data)
+          (data['rules'] || [])
+            .select { |r| r.fetch('enabled', true) }
+            .sort_by { |r| -(r['priority'] || 50) }
+        end
+
+        def format_title(name)
+          name.to_s.tr('_', ' ').gsub(/\b\w/, &:upcase)
+        end
+      end
+    end
+  end
+end

data/lib/rosett_ai/compiler/backends/claude_backend.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+module RosettAi
+  module Compiler
+    module Backends
+      # Compiler backend for Claude Code rule files.
+      #
+      # Renders behaviour configuration into Markdown files for Claude Code's
+      # ~/.claude/rules/ directory. Output includes priority annotations,
+      # source metadata, and the rosett-ai-claude-managed marker for idempotent
+      # updates.
+      class ClaudeBackend < Backend
+        MARKER_PREFIX = '<!-- rosett-ai-claude-managed'
+
+        # Renders behaviour data into Claude Code rule format.
+        #
+        # @param data [Hash] parsed YAML behaviour data
+        # @return [String] rendered Markdown content
+        def render(data)
+          sections = [
+            build_header(data),
+            build_description(data),
+            build_rules(data),
+            ['']
+          ]
+          sections.flatten.join("\n")
+        end
+
+        # @return [String] marker prefix for managed file detection
+        def generated_marker
+          MARKER_PREFIX
+        end
+
+        private
+
+        def build_header(data)
+          header = ["#{MARKER_PREFIX} -->"]
+          append_source_metadata(header, data)
+          header << ''
+          header << "# #{data['name']}"
+        end
+
+        def append_source_metadata(header, data)
+          return unless profile.rendering.fetch('include_source_metadata', false)
+
+          header << "<!-- Source: conf/#{data['category']}/#{data['name']}.yml -->"
+          header << "<!-- Category: #{data['category']} | Version: #{data['version']} -->"
+        end
+
+        def build_description(data)
+          desc = data['description'].to_s.strip
+          return [] if desc.empty?
+
+          ['', desc]
+        end
+
+        def build_rules(data)
+          rules = enabled_rules(data)
+          return [] if rules.empty?
+
+          ['', '## Rules'] + rules.flat_map { |rule| format_rule(rule) }
+        end
+
+        def format_rule(rule)
+          heading = if priority_annotations?
+                      "### #{rule['id']} (priority: #{rule['priority'] || 50})"
+                    else
+                      "### #{rule['id']}"
+                    end
+          ['', heading, '', rule['description'].to_s.strip]
+        end
+
+        def priority_annotations?
+          profile.rendering.fetch('include_priority_annotations', false)
+        end
+
+        def enabled_rules(data)
+          (data['rules'] || [])
+            .select { |r| r.fetch('enabled', true) }
+            .sort_by { |r| -(r['priority'] || 50) }
+        end
+      end
+    end
+  end
+end

data/lib/rosett_ai/compiler/backends/generic_backend.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+module RosettAi
+  module Compiler
+    # Compiler backend adapters.
+    module Backends
+      # Deprecated — use RosettAiEngine::Generic::Backend. Will be removed in v1.1.0.
+      # Only defined when rosett-ai-engine-generic gem is installed.
+      GenericBackend = RosettAiEngine::Generic::Backend if defined?(RosettAiEngine::Generic::Backend)
+    end
+  end
+end