jekyll-agent-audit 0.1.0

data/lib/jekyll/agent_audit/build_inventory.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "yaml"
+require "date"
+
+module Jekyll
+  module AgentAudit
+    class BuildInventory
+      attr_reader :entries, :collisions, :diagnostics
+
+      def initialize(site, configuration)
+        @site, @configuration = site, configuration
+        @entries, @collisions, @diagnostics = [], [], []
+        @claims = Hash.new { |h, k| h[k] = [] }
+        @captured = @complete = false
+        @capture_failed = false
+      end
+
+      def capture!
+        @captured = true
+        each_owner do |owner|
+          path = output_path(owner)
+          add_claim(owner, path) if path
+        end
+        self
+      rescue StandardError => e
+        @capture_failed = true
+        @diagnostics << {code: :inventory_capture_failed, message: e.message}
+        self
+      end
+
+      def finalize!
+        capture! unless @captured
+        each_owner { |owner| add_claim(owner, output_path(owner)) if output_path(owner) }
+        destination = File.expand_path(@site.dest.to_s)
+        if Dir.exist?(destination)
+          Dir.glob(File.join(destination, "**", "*")).sort.each do |absolute|
+            next unless File.file?(absolute)
+            relative = "/#{Pathname.new(absolute).relative_path_from(Pathname.new(destination)).to_s.tr('\\', '/')}"
+            add_claim(nil, relative, final_artifact: true) unless @claims.key?(relative)
+          end
+        end
+        @entries = @claims.values.flatten.uniq { |entry| [entry[:owner_token], entry[:output_path]] }
+        @collisions = @claims.map do |path, owners|
+          unique = owners.uniq { |entry| entry[:owner_token] }
+          {output_path: path, primary: unique.first, owners: unique} if unique.length > 1
+        end.compact
+        max = config_limit(:max_documents, 50_000)
+        html_count = @entries.count { |entry| entry[:output_path].end_with?(".html") || entry[:route].to_s.end_with?("/") }
+        if html_count > max
+          @diagnostics << {code: :resource_limit, limit: :max_documents, value: html_count}
+          @complete = false
+        else
+          @complete = !@capture_failed && @diagnostics.none? { |diagnostic| %i[ownership_outside_destination inventory_capture_failed].include?(diagnostic[:code]) }
+        end
+        self
+      end
+
+      def complete?
+        @complete
+      end
+
+      private
+
+      def each_owner
+        objects = %i[pages documents static_files].flat_map { |name| @site.respond_to?(name) ? Array(@site.public_send(name)) : [] }
+        seen = {}
+        objects.each do |owner|
+          next if seen[owner.object_id]
+          seen[owner.object_id] = true
+          yield owner
+        end
+      end
+
+      def output_path(owner)
+        return owner[:output_path] if owner.is_a?(Hash) && owner[:output_path]
+        return owner.output_path.to_s if owner.respond_to?(:output_path) && owner.output_path
+        return owner.destination(@site.dest.to_s).to_s if owner.respond_to?(:destination)
+        nil
+      end
+
+      def add_claim(owner, raw_path, final_artifact: false)
+        output = normalize_output(raw_path, final_artifact: final_artifact)
+        return if output.nil? || output.empty?
+        absolute = File.expand_path(output.delete_prefix("/"), @site.dest.to_s)
+        source = source_path(owner)
+        entry = {
+          identity: identity_for(owner, output, source), source_path: (source.to_s.empty? ? nil : source), output_path: output,
+          owner_token: owner ? owner.object_id : "artifact:#{output}",
+          absolute_path: absolute, url: public_url(route_for(owner, output)), route: route_for(owner, output),
+          destination_root: (File.realpath(@site.dest.to_s) rescue @site.dest.to_s),
+          data: data_for(owner), explicit_data: explicit_data_for(owner),
+          selected: selected?(source), final_artifact: final_artifact
+        }
+        @claims[output] << entry
+      end
+
+      def normalize_output(path, final_artifact: false)
+        value = path.to_s.tr("\\", "/")
+        return nil if value.empty?
+        destination = @site.dest.to_s.tr('\\', '/').sub(%r{/\z}, '')
+        if value.start_with?("/")
+          if value == destination
+            value = ""
+          elsif value.start_with?("#{destination}/")
+            value = value.delete_prefix(destination)
+          elsif !destination.empty? && !final_artifact
+            @diagnostics << {code: :ownership_outside_destination, path: value}
+            return nil
+          end
+        end
+        value = "/#{value}" unless value.start_with?("/")
+        value = value.gsub(%r{/+}, "/")
+        return nil if Pathname.new(value).cleanpath.to_s.split("/").include?("..")
+        value
+      end
+
+      def route_for(owner, output)
+        route = owner.is_a?(Hash) ? owner[:route] : (owner.respond_to?(:url) ? owner.url : nil)
+        route = output if route.to_s.empty?
+        route = "/#{route}" unless route.to_s.start_with?("/")
+        base = @site.respond_to?(:config) ? @site.config.fetch("baseurl", "").to_s.sub(%r{/\z}, "") : ""
+        route = "#{base}#{route}" if !base.empty? && route != base && !route.start_with?("#{base}/")
+        route.to_s
+      end
+
+      def public_url(route)
+        config = @site.respond_to?(:config) ? @site.config : {}
+        host = config.fetch("url", "").to_s.sub(%r{\z/}, "")
+        "#{host}#{route}".sub(%r{(?<!:)//+}, "/")
+      end
+
+      def source_path(owner)
+        return nil unless owner
+        return owner[:source_path] if owner.is_a?(Hash) && owner.key?(:source_path)
+        source_root = @site.respond_to?(:source) ? File.realpath(@site.source.to_s) : nil
+        candidate = if owner.respond_to?(:path) && owner.path && !owner.path.to_s.empty?
+          owner.path.to_s
+        elsif owner.respond_to?(:relative_path) && owner.relative_path && !owner.relative_path.to_s.empty? && source_root
+          File.join(source_root, owner.relative_path.to_s)
+        end
+        return owner.relative_path.to_s unless source_root && candidate && !owner.respond_to?(:path) && owner.relative_path && !owner.relative_path.to_s.empty?
+        return nil unless candidate && source_root && File.file?(candidate)
+        real = File.realpath(candidate)
+        return nil unless real == source_root || real.start_with?(source_root + File::SEPARATOR)
+        Pathname.new(real).relative_path_from(Pathname.new(source_root)).to_s
+      rescue Errno::ENOENT, Errno::EACCES, Errno::ELOOP
+        nil
+      end
+
+      def identity_for(owner, output, source)
+        return owner[:identity] if owner.is_a?(Hash) && owner[:identity]
+        source || "generated:#{owner.class}:#{output}"
+      end
+
+      def data_for(owner)
+        return owner[:data] || {} if owner.is_a?(Hash)
+        owner.respond_to?(:data) ? owner.data.to_h : {}
+      end
+
+      def explicit_data_for(owner)
+        return owner[:explicit_data] || {} if owner.is_a?(Hash)
+        path = source_path(owner)
+        source_root = @site.respond_to?(:source) ? @site.source.to_s : ""
+        raw_path = path && (File.file?(path) ? path : File.join(source_root, path))
+        return frontmatter_defaults_for(owner) unless raw_path && File.file?(raw_path)
+        raw = File.binread(raw_path)
+        return {} unless raw.start_with?("---")
+        front = raw.split(/^---\s*$\n?/, 3)[1]
+        YAML.safe_load(front.to_s, permitted_classes: [Date, Time], aliases: true) || {}
+      rescue Psych::Exception, Errno::ENOENT, Errno::EACCES
+        {}
+      end
+
+      def frontmatter_defaults_for(owner)
+        return {} unless @site.respond_to?(:frontmatter_defaults) && @site.frontmatter_defaults.respond_to?(:all)
+        path = source_path(owner)
+        type = owner.respond_to?(:type) ? owner.type.to_s : "Page"
+        @site.frontmatter_defaults.all(path.to_s, type)
+      rescue StandardError
+        {}
+      end
+
+      def config_limit(key, default)
+        config = @configuration.respond_to?(:to_h) ? @configuration.to_h : @configuration
+        limits = config[:limits] || config["limits"] || {}
+        limits[key] || limits[key.to_s] || default
+      end
+
+      def selected?(source)
+        !@configuration.respond_to?(:selected?) || @configuration.selected?(source)
+      end
+    end
+  end
+end

data/lib/jekyll/agent_audit/command.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+require "tempfile"
+
+module Jekyll
+  module Commands
+    class AgentAudit < Jekyll::Command
+      class << self
+        module ParserErrors
+          def parse!(*arguments)
+            super
+          rescue OptionParser::ParseError => error
+            config = instance_variable_get(:@agent_audit_parse_config) || {}
+            if config["format"] == "json"
+              report = Jekyll::AgentAudit::Report.new(
+                complete: false, operational_error: true,
+                diagnostics: [{"code" => "invalid_options", "message" => error.message}]
+              )
+              $stdout.puts Jekyll::AgentAudit::Reporters::JSON.render(report)
+            else
+              warn "jekyll-agent-audit: #{error.message}"
+            end
+            exit 2
+          end
+        end
+
+        def init_with_program(prog)
+          prog.command(:"agent:audit") do |command|
+            command.singleton_class.prepend(CommandParser)
+            command.syntax "agent:audit [options]"
+            command.description "Audit rendered publication output"
+            add_build_options(command)
+            command.option "format", "--format FORMAT", "console or json"
+            command.option "output", "--output PATH", "Write the report atomically"
+            command.option "fail_on", "--fail-on LEVEL", "error, warning, or none"
+            command.option "only", "--only RULES", "Comma-separated rule IDs"
+            command.option "list_rules", "--list-rules", "List available rules"
+            command.option "explain", "--explain RULE", "Explain a rule"
+            command.option "verbose", "--verbose", "Include skipped checks"
+            command.action { |_, options| process(options) }
+          end
+        end
+
+        def process(options)
+          options = options.transform_keys(&:to_s)
+          validate_only!(options)
+          if options["list_rules"]
+            write_output(render_rules(options), options["output"])
+            return 0
+          end
+          if options["explain"]
+            write_output(explain(options["explain"], options), options["output"])
+            return 0
+          end
+          report = run_audit(options)
+          format = options["format"] || report.to_h.dig("run", "effective_configuration", "format") || "console"
+          output = render_report(report, format)
+          write_output(output, options["output"])
+          exit(report_exit_code(report))
+        rescue Jekyll::AgentAudit::ConfigurationError, ArgumentError => e
+          if options && options["format"] == "json"
+            write_output(render_error(e), options["output"])
+          else
+            warn "jekyll-agent-audit: #{e.message}"
+          end
+          exit 2
+        rescue SystemExit
+          raise
+        rescue StandardError => e
+          if options && options["format"] == "json"
+            write_output(render_error(e), options["output"])
+          else
+            warn "jekyll-agent-audit: #{e.message}"
+          end
+          exit 2
+        end
+
+        private
+
+        def validate_only!(options)
+          only = options["only"].to_s.split(",").map(&:strip).reject(&:empty?)
+          only.each do |id|
+            fail Jekyll::AgentAudit::ConfigurationError, "unknown or deferred rule: #{id}" unless Jekyll::AgentAudit::Registry.known?(id) && !Jekyll::AgentAudit::Registry.deferred?(id)
+          end
+          fail Jekyll::AgentAudit::ConfigurationError, "invalid fail_on" unless options["fail_on"].nil? || %w[error warning none].include?(options["fail_on"])
+          fail Jekyll::AgentAudit::ConfigurationError, "invalid format" unless options["format"].nil? || %w[console json].include?(options["format"])
+        end
+
+        def render_rules(options)
+          if options["format"] == "json"
+            JSON.generate(Jekyll::AgentAudit::Registry.all.values)
+          else
+            Jekyll::AgentAudit::Registry.all.values.map { |rule| "#{rule[:id]} (#{rule[:release] == "M" ? "enabled" : "deferred"})" }.join("\n")
+          end
+        end
+
+        def explain(id, options)
+          fail Jekyll::AgentAudit::ConfigurationError, "unknown or deferred rule: #{id}" unless Jekyll::AgentAudit::Registry.known?(id) && !Jekyll::AgentAudit::Registry.deferred?(id)
+          rule = Jekyll::AgentAudit::Registry[id]
+          if options["format"] == "json"
+            JSON.generate(rule)
+          else
+            [
+              "#{rule[:id]} — #{rule[:category]} (#{rule[:release] == "M" ? "MVP" : "deferred"})",
+              "Default severity: #{rule[:default_severity]}; evidence: #{rule[:evidence_level]}",
+              "Applicability: #{rule[:applicability]}",
+              "Required inputs: #{rule[:required_inputs].join(", ")}",
+              "Limitations: #{rule[:limitations].join("; ")}",
+              "Remediation: #{rule[:remediation]}",
+              "Evidence URLs: #{rule[:source_urls].join(", ")}"
+            ].join("\n")
+          end
+        end
+
+        def write_output(output, path)
+          if path
+            directory = File.dirname(File.expand_path(path))
+            FileUtils.mkdir_p(directory)
+            Tempfile.create(["agent-audit-", ".tmp"], directory) do |file|
+              file.write(output)
+              file.flush
+              file.fsync
+              File.rename(file.path, path)
+            end
+          else
+            $stdout.puts output
+          end
+        end
+
+        def run_audit(options)
+          original_global_stdout = $stdout
+          original_stdout = STDOUT.dup
+          STDOUT.reopen(STDERR)
+          $stdout = STDOUT
+          report = Jekyll::AgentAudit::Runner.new(options).run
+          report
+        ensure
+          STDOUT.reopen(original_stdout) if original_stdout
+          original_stdout&.close
+          $stdout = original_global_stdout
+        end
+
+        def render_report(report, format)
+          return Jekyll::AgentAudit::Reporters::Console.render(report) unless format == "json"
+
+          data = report.to_h
+          data["policy"]["exit_code"] = 130 if interrupted?(report)
+          JSON.generate(data)
+        end
+
+        def render_error(error)
+          report = Jekyll::AgentAudit::Report.new(
+            complete: false, operational_error: true,
+            diagnostics: [{"code" => "invalid_options", "message" => error.message}]
+          )
+          Jekyll::AgentAudit::Reporters::JSON.render(report)
+        end
+
+        def report_exit_code(report)
+          interrupted?(report) ? 130 : report.exit_code
+        end
+
+        def interrupted?(report)
+          report.to_h.fetch("diagnostics", []).any? { |diagnostic| diagnostic["code"].to_s == "interrupted" }
+        end
+
+        module CommandParser
+          def go(arguments, parser, config)
+            parser.instance_variable_set(:@agent_audit_parse_config, config)
+            parser.singleton_class.prepend(ParserErrors) unless parser.singleton_class < ParserErrors
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jekyll/agent_audit/configuration.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+require "date"
+require "yaml"
+require "uri"
+
+module Jekyll
+  module AgentAudit
+    class Configuration
+      DEFAULTS = {
+        "fail_on" => "error", "format" => "console", "include" => ["**/*"], "exclude" => [],
+        "content" => {"selector" => nil, "exclude_selectors" => %w[nav footer aside script style template]},
+        "metadata" => {"selectors" => {"author" => nil, "publisher" => nil, "published" => nil, "modified" => nil}},
+        "graph" => {"roots" => ["/"]}, "routes" => {"directory_index" => "index.html", "external_paths" => [], "aliases" => {}},
+        "rules" => {}, "suppressions" => [],
+        "limits" => {"max_html_bytes" => 5_242_880, "max_jsonld_bytes" => 1_048_576, "max_documents" => 50_000, "max_edges" => 1_000_000}
+      }.freeze
+      TOP_KEYS = DEFAULTS.keys.freeze
+      LIMITS = %w[max_html_bytes max_jsonld_bytes max_documents max_edges].freeze
+
+      attr_reader :raw
+
+      def initialize(raw_namespace = {}, overrides = {})
+        @raw = deep_stringify(raw_namespace || {})
+        @overrides = deep_stringify(overrides || {})
+        @effective = nil
+        validate!
+      end
+
+      def to_h
+        @effective ||= deep_freeze(deep_merge(DEFAULTS, @raw).merge(cli_values))
+        @effective
+      end
+
+      def [](key)
+        to_h[key.to_s]
+      end
+
+      def enabled_rules
+        registry = Registry.all
+        registry.each_with_object({}) do |(id, metadata), result|
+          next unless metadata[:release] == "M"
+          configured = self["rules"][id]
+          result[id] = metadata unless configured.is_a?(Hash) && configured["enabled"] == false
+        end
+      end
+
+      def selected?(source_path)
+        path = source_path.to_s.sub(%r{\A/+}, "")
+        includes = Array(self["include"])
+        excludes = Array(self["exclude"])
+        includes.any? { |pattern| File.fnmatch?(pattern.to_s, path, File::FNM_PATHNAME | File::FNM_EXTGLOB) } &&
+          !excludes.any? { |pattern| File.fnmatch?(pattern.to_s, path, File::FNM_PATHNAME | File::FNM_EXTGLOB) }
+      end
+
+      def suppression_for(rule_id, source_path: nil, fingerprint: nil, now: Date.today)
+        Array(self["suppressions"]).filter_map do |suppression|
+          next unless suppression["rule"] == rule_id.to_s
+          if suppression["paths"]
+            next unless source_path
+            next unless Array(suppression["paths"]).any? { |p| File.fnmatch?(p, source_path.to_s, File::FNM_PATHNAME | File::FNM_EXTGLOB) }
+          end
+          next if suppression["fingerprint"] && suppression["fingerprint"] != fingerprint
+          next if suppression["until"] && Date.iso8601(suppression["until"].to_s) < now
+          suppression
+        end
+      end
+
+      def expired_suppressions(now: Date.today)
+        Array(self["suppressions"]).select { |entry| entry["until"] && Date.iso8601(entry["until"].to_s) < now }
+      end
+
+      private
+
+      def cli_values
+        %w[fail_on format].each_with_object({}) { |key, values| values[key] = @overrides[key] if @overrides.key?(key) }
+      end
+
+      def validate!
+        unknown = @raw.keys - TOP_KEYS
+        fail ConfigurationError, "unknown agent_audit key(s): #{unknown.join(', ')}" unless unknown.empty?
+        fail ConfigurationError, "fail_on must be error, warning, or none" unless %w[error warning none].include?(self["fail_on"])
+        fail ConfigurationError, "format must be console or json" unless %w[console json].include?(self["format"])
+        %w[include exclude].each { |key| fail ConfigurationError, "#{key} must be an array" unless @raw.fetch(key, DEFAULTS[key]).is_a?(Array) }
+        validate_hash_keys("content", %w[selector exclude_selectors])
+        content = @raw.fetch("content", {})
+        fail ConfigurationError, "content.exclude_selectors must be an array" unless content.fetch("exclude_selectors", DEFAULTS["content"]["exclude_selectors"]).is_a?(Array)
+        fail ConfigurationError, "content selectors must be strings or null" unless (content.fetch("selector", nil).nil? || content.fetch("selector", nil).is_a?(String)) && content.fetch("exclude_selectors", DEFAULTS["content"]["exclude_selectors"]).all? { |v| v.is_a?(String) }
+        validate_hash_keys("metadata", ["selectors"])
+        selectors = @raw.fetch("metadata", {}).fetch("selectors", {})
+        fail ConfigurationError, "metadata.selectors must be a mapping" unless selectors.is_a?(Hash)
+        fail ConfigurationError, "unknown metadata selector" unless (selectors.keys - %w[author publisher published modified]).empty?
+        fail ConfigurationError, "metadata selectors must be strings or null" unless selectors.values.all? { |value| value.nil? || value.is_a?(String) }
+        validate_hash_keys("routes", %w[directory_index external_paths aliases])
+        routes = @raw.fetch("routes", {})
+        fail ConfigurationError, "routes.external_paths must be an array" unless routes.fetch("external_paths", DEFAULTS["routes"]["external_paths"]).is_a?(Array)
+        fail ConfigurationError, "routes.directory_index must be a string" unless routes.fetch("directory_index", DEFAULTS["routes"]["directory_index"]).is_a?(String)
+        validate_hash_keys("limits", LIMITS)
+        validate_hash_keys("graph", ["roots"])
+        fail ConfigurationError, "graph.roots must be an array" unless @raw.fetch("graph", {}).fetch("roots", DEFAULTS["graph"]["roots"]).is_a?(Array)
+        validate_hash_keys("rules", Registry.all.keys)
+        validate_rules!
+        validate_suppressions!
+        validate_limits!
+        validate_aliases!
+        validate_selectors!
+      end
+
+      def validate_hash_keys(section, allowed)
+        value = @raw.fetch(section, {})
+        fail ConfigurationError, "#{section} must be a mapping" unless value.is_a?(Hash)
+        unknown = value.keys - allowed
+        fail ConfigurationError, "unknown agent_audit.#{section} key(s): #{unknown.join(', ')}" unless unknown.empty?
+      end
+
+      def validate_rules!
+        @raw.fetch("rules", {}).each do |id, value|
+          fail ConfigurationError, "rule #{id} must be a mapping" unless value.is_a?(Hash)
+          fail ConfigurationError, "unknown rule option for #{id}" unless (value.keys - ["enabled"]).empty?
+          fail ConfigurationError, "rule #{id} enabled must be boolean" unless [true, false].include?(value["enabled"])
+        end
+      end
+
+      def validate_suppressions!
+        fail ConfigurationError, "suppressions must be an array" unless @raw.fetch("suppressions", []).is_a?(Array)
+        Array(@raw.fetch("suppressions", [])).each do |entry|
+          fail ConfigurationError, "suppression must be a mapping" unless entry.is_a?(Hash)
+          fail ConfigurationError, "unknown suppression key" unless (entry.keys - %w[rule paths fingerprint reason until]).empty?
+          fail ConfigurationError, "suppression requires known rule" unless Registry.known?(entry["rule"]) && !Registry.deferred?(entry["rule"])
+          fail ConfigurationError, "suppression requires a nonempty reason" if entry["reason"].to_s.strip.empty?
+          fail ConfigurationError, "suppression paths must be an array" if entry.key?("paths") && !entry["paths"].is_a?(Array)
+          if entry["until"]
+            Date.iso8601(entry["until"].to_s)
+          end
+        rescue Date::Error
+          fail ConfigurationError, "suppression until must be an ISO date"
+        end
+      end
+
+      def validate_limits!
+        limits = deep_merge(DEFAULTS["limits"], @raw.fetch("limits", {}))
+        limits.each_value { |value| fail ConfigurationError, "limits must be positive integers" unless value.is_a?(Integer) && value.positive? }
+      end
+
+      def validate_aliases!
+        aliases = self["routes"]["aliases"]
+        fail ConfigurationError, "routes.aliases must be a mapping" unless aliases.is_a?(Hash)
+        aliases.each_key do |path|
+          fail ConfigurationError, "route aliases must be site-relative" unless path.to_s.start_with?("/")
+        end
+        aliases.each_value do |target|
+          fail ConfigurationError, "route alias targets must be strings" unless target.is_a?(String) && target.start_with?("/")
+        end
+        aliases.keys.each do |key|
+          seen = {}
+          current = key
+          while aliases.key?(current)
+            fail ConfigurationError, "route aliases contain a cycle" if seen[current]
+            seen[current] = true
+            current = aliases[current]
+          end
+        end
+      end
+
+      def validate_selectors!
+        selectors = self["metadata"]["selectors"].values.compact
+        selectors << self["content"]["selector"] if self["content"]["selector"]
+        return if selectors.empty?
+        require "nokogiri"
+        selectors.each { |selector| Nokogiri::HTML5.fragment("<x></x>").css(selector.to_s) }
+      rescue Nokogiri::CSS::SyntaxError, ArgumentError => e
+        fail ConfigurationError, "invalid CSS selector: #{e.message}"
+      end
+
+      def deep_stringify(value)
+        case value
+        when Hash then value.to_h { |k, v| [k.to_s, deep_stringify(v)] }
+        when Array then value.map { |v| deep_stringify(v) }
+        else value
+        end
+      end
+
+      def deep_merge(left, right)
+        left.merge(right) do |_key, old_value, new_value|
+          old_value.is_a?(Hash) && new_value.is_a?(Hash) ? deep_merge(old_value, new_value) : new_value
+        end
+      end
+
+      def deep_freeze(value)
+        value.each { |v| deep_freeze(v) } if value.is_a?(Hash)
+        value.each { |v| deep_freeze(v) } if value.is_a?(Array)
+        value.freeze
+      end
+    end
+  end
+end

data/lib/jekyll/agent_audit/errors.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Jekyll
+  module AgentAudit
+    class Error < StandardError; end
+    class ConfigurationError < Error; end
+    class InputError < Error; end
+    class ReportError < Error; end
+  end
+end