rosett-ai 1.3.3

data/lib/rosett_ai/compiler/behaviour_compiler.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+module RosettAi
+  module Compiler
+    # Backward-compatible wrapper around CompilationPipeline.
+    #
+    # Preserves the original 3-argument constructor and defaults the
+    # backend to the Claude engine backend. Existing callers that instantiate
+    # BehaviourCompiler continue to work without modification.
+    class BehaviourCompiler < CompilationPipeline
+      GENERATED_MARKER = '<!-- rosett-ai-claude-managed'
+
+      # Backward-compatible wrapper that defaults to the Claude engine backend.
+      #
+      # @param source_dir [String, Pathname] directory containing behaviour YAML files
+      # @param target_dir [String, Pathname] directory for compiled output files
+      # @param schema_dir [String, Pathname] directory containing JSON Schema files
+      def initialize(source_dir:, target_dir:, schema_dir:)
+        super(
+          source_dir: source_dir,
+          target_dir: target_dir,
+          schema_dir: schema_dir,
+          backend: Backend.for('claude')
+        )
+      end
+
+      # Delegates render to the backend for backward compatibility.
+      #
+      # @param category [String] the behaviour category name
+      # @param data [Hash] behaviour data to render
+      # @return [String] rendered output from the backend
+      def render(category, data)
+        backend.render(data.merge('category' => category))
+      end
+    end
+  end
+end

data/lib/rosett_ai/compiler/capability_checker.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+module RosettAi
+  module Compiler
+    # Checks compiled output against engine capability manifest and emits
+    # warnings when the source YAML uses features the target engine does
+    # not support (e.g. sensitive filtering, rule metadata).
+    #
+    # Called between compiler.compile and process_compiled in the CLI.
+    # With --strict, warnings become CompileErrors.
+    class CapabilityChecker
+      def initialize(engine_name)
+        @engine_name = engine_name.to_s
+        @manifest = load_manifest
+        @capabilities = @manifest['capabilities'] || {}
+      end
+
+      # Check compiled results against engine capabilities.
+      #
+      # @param source_dir [Pathname] conf/ directory to scan source YAML
+      # @return [Array<Hash>] warning hashes with :feature, :file, :message keys
+      def check(source_dir)
+        behaviour_dir = source_dir.join('behaviour')
+        return [] unless behaviour_dir.exist?
+
+        files = load_behaviour_files(behaviour_dir)
+        warnings = []
+        warnings.concat(sensitive_warnings(files))
+        warnings.concat(metadata_warnings(files))
+        warnings
+      end
+
+      # Summarized check — groups warnings by feature type.
+      #
+      # @param source_dir [Pathname] conf/ directory to scan source YAML
+      # @return [Array<Hash>] summary hashes with :feature, :count, :message keys
+      def check_summarized(source_dir)
+        warnings = check(source_dir)
+        warnings.group_by { |w| w[:feature] }.map do |feature, group|
+          {
+            feature: feature,
+            count: group.size,
+            message: "Engine '#{@engine_name}' does not support #{feature} — " \
+                     "#{group.size} rule(s) compiled without it"
+          }
+        end
+      end
+
+      private
+
+      # Load engine manifest from plugin registry. Returns an empty hash
+      # for builtin backends (claude, agents_md) that don't have plugin
+      # registration — builtin backends support all capabilities.
+      def load_manifest
+        RosettAi::Engines::Registry.manifest(@engine_name)
+      rescue RosettAi::Plugins::Registry::PluginNotFoundError
+        { 'capabilities' => { 'sensitive_filtering' => true, 'rule_metadata' => true } }
+      end
+
+      def load_behaviour_files(behaviour_dir)
+        Dir.glob(behaviour_dir.join('*.yml')).filter_map do |path|
+          data = RosettAi::YamlLoader.load_file(path)
+          next unless data.is_a?(Hash)
+
+          { path: path, basename: File.basename(path), data: data }
+        end
+      end
+
+      def sensitive_warnings(files)
+        return [] if @capabilities['sensitive_filtering']
+
+        files.filter_map do |entry|
+          next unless entry[:data]['sensitive'] == true
+
+          build_warning('sensitive_filtering', entry[:basename],
+                        "is marked sensitive but engine '#{@engine_name}' does not support sensitive filtering")
+        end
+      end
+
+      def metadata_warnings(files)
+        return [] if @capabilities['rule_metadata']
+
+        files.filter_map do |entry|
+          next unless rules_have_metadata?(entry[:data])
+
+          build_warning('rule_metadata', entry[:basename],
+                        "uses rule IDs/priority but engine '#{@engine_name}' does not preserve rule metadata")
+        end
+      end
+
+      def rules_have_metadata?(data)
+        rules = data['rules'] || []
+        rules.any? { |r| r['id'] || r['priority'] }
+      end
+
+      def build_warning(feature, filename, detail)
+        { feature: feature, file: filename, message: "#{filename} #{detail}" }
+      end
+    end
+  end
+end

data/lib/rosett_ai/compiler/compilation_pipeline.rb

@@ -0,0 +1,361 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+require 'yaml'
+require 'json'
+require 'digest'
+require 'json_schemer'
+
+module RosettAi
+  module Compiler
+    # Core compilation pipeline that transforms YAML configuration files
+    # into target-specific output formats.
+    #
+    # Delegates rendering to a pluggable Backend instance. Owns discovery,
+    # validation, checksumming, diffing, lockfile generation, and orphan
+    # management.
+    class CompilationPipeline # rubocop:disable Metrics/ClassLength
+      # Categories excluded from compilation. These directories contain
+      # configuration files validated by their respective modules
+      # (e.g., Policy::DenyList, Build::Package) rather than the
+      # compile pipeline.
+      NON_COMPILABLE_CATEGORIES = ['packaging', 'policy', 'tooling'].freeze
+
+      # Categories compiled only in project scope. Design documents are
+      # project specifications, not operational rules — compiling them
+      # globally would pollute ~/.claude/rules/ with empty files.
+      PROJECT_ONLY_CATEGORIES = ['design'].freeze
+
+      VALID_SCOPES = [:global, :project].freeze
+
+      attr_reader :source_dir, :target_dir, :schema_dir, :backend, :scope,
+                  :additional_source_dirs
+
+      # @param source_dir [String, Pathname] primary conf/ root (project scope when in project)
+      # @param target_dir [String, Pathname] output directory
+      # @param schema_dir [String, Pathname] JSON Schema directory
+      # @param backend [RosettAi::Compiler::Backend] rendering backend
+      # @param scope [Symbol] compilation scope (:global or :project)
+      # @param additional_source_dirs [Array<String, Pathname>] extra source directories
+      #   (e.g. global conf/ when compiling in project scope). Files from additional
+      #   sources are included unless overridden by a file with the same basename
+      #   in the primary source_dir. Empty by default for backward compatibility.
+      # @param source_dir [String, Pathname] primary conf/ root
+      # @param target_dir [String, Pathname] output directory
+      # @param schema_dir [String, Pathname] JSON Schema directory
+      # @param backend [RosettAi::Compiler::Backend] rendering backend
+      # @param scope [Symbol] compilation scope (:global or :project)
+      # @param additional_source_dirs [Array<String, Pathname>] extra source
+      #   directories (e.g. global conf/ when compiling in project scope)
+      def initialize(source_dir:, target_dir:, schema_dir:, backend:, # rubocop:disable Metrics/ParameterLists
+                     scope: :global, additional_source_dirs: [])
+        validate_scope!(scope)
+        @source_dir = Pathname.new(source_dir)
+        @target_dir = Pathname.new(target_dir)
+        @schema_dir = Pathname.new(schema_dir)
+        @backend = backend
+        @scope = scope
+        @additional_source_dirs = additional_source_dirs.map { |d| Pathname.new(d) }
+      end
+
+      # Returns project-only categories that were skipped in this scope.
+      #
+      # @return [Array<String>] skipped category names (empty for project scope)
+      def skipped_project_categories
+        scope == :global ? PROJECT_ONLY_CATEGORIES : []
+      end
+
+      # Discovers compilable config categories across all source directories.
+      #
+      # @return [Array<String>] category names with matching schemas
+      def discover_categories
+        skip = ['schemas', 'targets'] + NON_COMPILABLE_CATEGORIES
+        skip += PROJECT_ONLY_CATEGORIES if scope == :global
+
+        categories = Set.new
+        all_source_dirs.each do |sdir|
+          next unless sdir.exist?
+
+          Dir.children(sdir).each do |entry|
+            next unless sdir.join(entry).directory?
+            next if skip.include?(entry)
+
+            categories << entry
+          end
+        end
+
+        categories.select do |category|
+          schema_dir.join("#{category}_schema.json").exist?
+        end.sort
+      end
+
+      # Compiles all discovered categories into rendered output.
+      # When additional_source_dirs are present, files are collected from
+      # all sources. The primary source_dir takes precedence: a file with
+      # the same basename in source_dir overrides one from additional sources.
+      #
+      # After compilation, runs duplicate rule ID detection across all
+      # behaviour files. Access warnings via {#conflict_warnings}.
+      #
+      # @return [Hash{String => CompiledOutput}] keyed by output filename
+      def compile
+        results = {}
+        all_category_files = {}
+        discover_categories.each do |category|
+          yaml_files = collect_category_files(category)
+          yaml_files.concat(premium_files_for(category))
+          all_category_files[category] = yaml_files
+          yaml_files.each do |file|
+            data = load_yaml(file)
+            next unless data
+
+            validate!(category, data, file)
+            key, output = compile_file(category, data, file)
+            results[key] = output
+          end
+        end
+        @conflict_warnings = detect_duplicate_rule_ids(all_category_files)
+        results
+      end
+
+      # Returns conflict warnings from the most recent compile run.
+      #
+      # @return [Array<String>] conflict warning messages
+      def conflict_warnings
+        @conflict_warnings || []
+      end
+
+      # Validates data against the JSON Schema for the given category.
+      #
+      # @param category [String] configuration category name
+      # @param data [Hash] parsed YAML data to validate
+      # @param file [String] source file path (used in error messages)
+      # @raise [RosettAi::CompileError] when validation fails
+      # @return [void]
+      def validate!(category, data, file)
+        schema_file = schema_dir.join("#{category}_schema.json")
+        schema = JSON.parse(schema_file.read)
+        schemer = JSONSchemer.schema(schema)
+        errors = schemer.validate(data).to_a
+        return if errors.empty?
+
+        messages = errors.map do |err|
+          path = err['data_pointer'].empty? ? 'root' : err['data_pointer']
+          "#{path}: #{err['type']}"
+        end
+        raise RosettAi::CompileError, "Validation failed for #{file}: #{messages.join(', ')}"
+      end
+
+      # Computes a SHA-256 hex digest of the given content.
+      #
+      # @param content [String] content to hash
+      # @return [String] hex-encoded SHA-256 digest
+      def checksum(content)
+        Digest::SHA256.hexdigest(content)
+      end
+
+      # Checks whether the file at path was generated by the compiler.
+      #
+      # @param path [String] file path to check
+      # @return [Boolean]
+      def managed_file?(path)
+        backend.managed_file?(path)
+      end
+
+      # Finds managed target files not present in the compiled set.
+      #
+      # @param compiled_names [Array<String>] basenames of compiled outputs
+      # @return [Array<String>] full paths of orphaned files
+      def orphaned_files(compiled_names)
+        return [] unless target_dir.exist?
+
+        Dir.glob(target_dir.join("*#{backend.file_extension}")).select do |file|
+          managed_file?(file) && !compiled_names.include?(File.basename(file))
+        end
+      end
+
+      # Generates a unified diff between an existing file and new content.
+      #
+      # @param existing_path [String] path to the existing file
+      # @param new_content [String] proposed new content
+      # @return [String, nil] unified diff string, or nil if unchanged/missing
+      def diff(existing_path, new_content)
+        return nil unless File.exist?(existing_path)
+
+        existing = File.read(existing_path, encoding: 'utf-8')
+        return nil if existing == new_content
+
+        generate_unified_diff(existing_path, existing, new_content)
+      end
+
+      # Builds a lockfile hash from compiled outputs.
+      #
+      # @param compiled [Hash] compiled output map (filename => info)
+      # @return [Hash] lockfile structure suitable for YAML serialization
+      def lockfile_data(compiled)
+        timestamp = Time.now.utc.strftime('%Y-%m-%dT%H:%M:%SZ')
+        categories = {}
+        compiled.each_value do |info|
+          cat = info[:category]
+          categories[cat] ||= { 'schema' => "conf/schemas/#{cat}_schema.json", 'files' => {} }
+          categories[cat]['files'][info[:name]] = info.to_lockfile_hash(
+            display_path: RosettAi.paths.rules_display_path,
+            source_path: relative_path(info[:source]),
+            content_checksum: checksum(info[:content]),
+            timestamp: timestamp
+          )
+        end
+
+        {
+          'generated_at' => timestamp,
+          'generator' => 'rosett-ai',
+          'generator_version' => RosettAi::VERSION,
+          'target_directory' => RosettAi.paths.rules_display_path,
+          'categories' => categories
+        }
+      end
+
+      private
+
+      def compile_file(category, data, file)
+        name = RosettAi::TextSanitizer.normalize_nfc(File.basename(file, '.yml'))
+        key = "#{category}-#{name}#{backend.file_extension}"
+        rules = data['rules'] || []
+        output = CompiledOutput.new(
+          filename: key,
+          content: backend.render(data.merge('category' => category)),
+          source: file,
+          category: category,
+          name: name,
+          version: data['version'] || 'unknown',
+          rules_count: rules.size,
+          enabled_rules_count: rules.count { |r| r.fetch('enabled', true) },
+          scope: data['scope']
+        )
+        [key, output]
+      end
+
+      def validate_scope!(scope)
+        return if VALID_SCOPES.include?(scope)
+
+        raise ArgumentError, "Invalid scope: #{scope.inspect} (valid: #{VALID_SCOPES.join(', ')})"
+      end
+
+      # Returns all source directories in merge order: additional sources
+      # first (global), then primary (project). Later entries in the array
+      # override earlier ones when files share the same basename.
+      #
+      # @return [Array<Pathname>]
+      def all_source_dirs
+        @additional_source_dirs + [@source_dir]
+      end
+
+      # Collects YAML files for a category from all source directories.
+      # Files from later sources (project) override earlier sources (global)
+      # when they share the same basename. PROJECT_ONLY_CATEGORIES are
+      # collected only from the primary source_dir.
+      #
+      # @param category [String] category name
+      # @return [Array<String>] deduplicated file paths
+      def collect_category_files(category)
+        sources = project_only_category?(category) ? [@source_dir] : all_source_dirs
+        seen = {}
+        sources.each do |sdir|
+          Dir.glob(sdir.join(category, '*.yml')).each do |file|
+            seen[File.basename(file, '.yml')] = file
+          end
+        end
+        seen.values
+      end
+
+      def project_only_category?(category)
+        PROJECT_ONLY_CATEGORIES.include?(category)
+      end
+
+      def premium_files_for(category)
+        premium_dir = RosettAi.paths.premium_content_dir
+        return [] unless premium_dir.exist?
+        return [] unless RosettAi::Licensing::LicenseValidator.new.validate[:valid]
+
+        Dir.glob(premium_dir.join('*', "#{category}s", '*.yml'))
+      end
+
+      def load_yaml(file)
+        RosettAi::YamlLoader.load_file(file)
+      rescue Psych::SyntaxError => e
+        raise RosettAi::CompileError, "YAML syntax error in #{file}: #{e.message}"
+      end
+
+      def relative_path(path)
+        Pathname.new(path).relative_path_from(RosettAi.root).to_s
+      rescue ArgumentError
+        path.to_s
+      end
+
+      # Detects duplicate rule IDs within each behaviour file.
+      # Rule IDs are scoped per-file (e.g. criticalthinking/rule_001 vs
+      # operational_discipline/rule_001 are independent), so only
+      # duplicates within a single file are flagged.
+      #
+      # @param category_files [Hash{String => Array<String>}] category => file paths
+      # @return [Array<String>] warning messages for duplicate rule IDs
+      def detect_duplicate_rule_ids(category_files)
+        duplicates = []
+
+        category_files.each_value do |files|
+          files.each do |path|
+            data = load_yaml(path)
+            next unless data
+
+            basename = File.basename(path, '.yml')
+            seen = {}
+            (data['rules'] || []).each do |rule|
+              rule_id = rule['id']
+              next unless rule_id
+
+              if seen.key?(rule_id)
+                duplicates << "Duplicate rule ID '#{rule_id}' in #{basename}.yml " \
+                              '(appears more than once)'
+              else
+                seen[rule_id] = true
+              end
+            end
+          end
+        end
+
+        duplicates
+      end
+
+      def generate_unified_diff(path, old_content, new_content)
+        old_lines = old_content.lines
+        new_lines = new_content.lines
+        basename = File.basename(path)
+
+        lines = []
+        lines << "--- a/#{basename}"
+        lines << "+++ b/#{basename}"
+
+        max = [old_lines.size, new_lines.size].max
+        changes = []
+        (0...max).each do |i|
+          old_line = old_lines[i]
+          new_line = new_lines[i]
+          next if old_line == new_line
+
+          changes << { index: i, old: old_line, new: new_line }
+        end
+
+        changes.each do |change|
+          i = change[:index]
+          lines << "@@ -#{i + 1} +#{i + 1} @@"
+          lines << "-#{change[:old]&.chomp}" if change[:old]
+          lines << "+#{change[:new]&.chomp}" if change[:new]
+        end
+
+        lines.join("\n")
+      end
+    end
+  end
+end

data/lib/rosett_ai/compiler/compiled_output.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+# SPDX-License-Identifier: GPL-3.0-only
+# Copyright (C) 2026 Hugo Antonio Sepulveda Manriquez / NeatNerds
+
+module RosettAi
+  module Compiler
+    # Value object representing a single compiled output file.
+    #
+    # Replaces the raw Hash previously returned by BehaviourCompiler#compile.
+    # Struct supports both .field and [:field] access, so callers using
+    # info[:content] continue to work without modification.
+    CompiledOutput = Struct.new(
+      :filename, :content, :source, :category, :name, :version,
+      :rules_count, :enabled_rules_count, :scope
+    ) do
+      # Builds a lockfile entry hash for this compiled output.
+      #
+      # @param display_path [String] display prefix for output path
+      # @param source_path [String] relative source path
+      # @param content_checksum [String] SHA-256 hex digest of content
+      # @param timestamp [String] ISO 8601 compilation timestamp
+      # @return [Hash] lockfile entry
+      def to_lockfile_hash(display_path:, source_path:, content_checksum:, timestamp:)
+        entry = {
+          'version' => version,
+          'source' => source_path,
+          'output' => "#{display_path}/#{filename}",
+          'checksum' => "sha256:#{content_checksum}",
+          'compiled_at' => timestamp,
+          'rules_count' => rules_count,
+          'enabled_rules_count' => enabled_rules_count
+        }
+        entry['scope'] = scope if scope
+        entry
+      end
+    end
+  end
+end