simplecov-mcp 1.0.1 → 2.0.0

data/lib/simplecov_mcp/option_normalizers.rb

@@ -18,7 +18,7 @@ module SimpleCovMcp
       'uncovered' => :uncovered
     }.freeze
 
-    STALE_MODE_MAP = {
+    STALENESS_MAP = {
       'o' => :off,
       'off' => :off,
       'e' => :error,
@@ -27,19 +27,29 @@ module SimpleCovMcp
 
     ERROR_MODE_MAP = {
       'off' => :off,
-      'on' => :on,
-      't' => :trace,
-      'trace' => :trace
+      'o' => :off,
+      'log' => :log,
+      'l' => :log,
+      'debug' => :debug,
+      'd' => :debug
     }.freeze
 
-    module_function
+    FORMAT_MAP = {
+      't' => :table,
+      'table' => :table,
+      'j' => :json,
+      'json' => :json,
+      'J' => :pretty_json,
+      'pretty_json' => :pretty_json,
+      'pretty-json' => :pretty_json,
+      'y' => :yaml,
+      'yaml' => :yaml,
+      'a' => :awesome_print,
+      'awesome_print' => :awesome_print,
+      'ap' => :awesome_print
+    }.freeze
 
-    # Normalize sort order value.
-    # @param value [String, Symbol] The value to normalize
-    # @param strict [Boolean] If true, raises on invalid value; if false, returns nil
-    # @return [Symbol, nil] The normalized symbol or nil if invalid and not strict
-    # @raise [OptionParser::InvalidArgument] If strict and value is invalid
-    def normalize_sort_order(value, strict: true)
+    module_function def normalize_sort_order(value, strict: true)
       normalized = SORT_ORDER_MAP[value.to_s.downcase]
       return normalized if normalized
       raise OptionParser::InvalidArgument, "invalid argument: #{value}" if strict
@@ -52,9 +62,7 @@ module SimpleCovMcp
     # @param strict [Boolean] If true, raises on invalid value; if false, returns nil
     # @return [Symbol, nil] The normalized symbol or nil if invalid and not strict
     # @raise [OptionParser::InvalidArgument] If strict and value is invalid
-    def normalize_source_mode(value, strict: true)
-      return :full if value.nil? || value == ''
-
+    module_function def normalize_source_mode(value, strict: true)
       normalized = SOURCE_MODE_MAP[value.to_s.downcase]
       return normalized if normalized
       raise OptionParser::InvalidArgument, "invalid argument: #{value}" if strict
@@ -67,8 +75,8 @@ module SimpleCovMcp
     # @param strict [Boolean] If true, raises on invalid value; if false, returns nil
     # @return [Symbol, nil] The normalized symbol or nil if invalid and not strict
     # @raise [OptionParser::InvalidArgument] If strict and value is invalid
-    def normalize_stale_mode(value, strict: true)
-      normalized = STALE_MODE_MAP[value.to_s.downcase]
+    module_function def normalize_staleness(value, strict: true)
+      normalized = STALENESS_MAP[value.to_s.downcase]
       return normalized if normalized
       raise OptionParser::InvalidArgument, "invalid argument: #{value}" if strict
 
@@ -81,12 +89,25 @@ module SimpleCovMcp
     # @param default [Symbol] The default value to return if invalid and not strict
     # @return [Symbol] The normalized symbol or default if invalid and not strict
     # @raise [OptionParser::InvalidArgument] If strict and value is invalid
-    def normalize_error_mode(value, strict: true, default: :on)
-      normalized = ERROR_MODE_MAP[value&.downcase]
+    module_function def normalize_error_mode(value, strict: true, default: :log)
+      normalized = ERROR_MODE_MAP[value.to_s.downcase]
       return normalized if normalized
       raise OptionParser::InvalidArgument, "invalid argument: #{value}" if strict
 
       default
     end
+
+    # Normalize format value.
+    # @param value [String, Symbol] The value to normalize
+    # @param strict [Boolean] If true, raises on invalid value; if false, returns nil
+    # @return [Symbol, nil] The normalized symbol or nil if invalid and not strict
+    # @raise [OptionParser::InvalidArgument] If strict and value is invalid
+    module_function def normalize_format(value, strict: true)
+      normalized = FORMAT_MAP[value.to_s.downcase]
+      return normalized if normalized
+      raise OptionParser::InvalidArgument, "invalid argument: #{value}" if strict
+
+      nil
+    end
   end
 end

data/lib/simplecov_mcp/option_parser_builder.rb

@@ -1,11 +1,12 @@
 # frozen_string_literal: true
 
 require_relative 'option_normalizers'
+require_relative 'version'
 
 module SimpleCovMcp
   class OptionParserBuilder
     HORIZONTAL_RULE = '-' * 79
-    SUBCOMMANDS = %w[list summary raw uncovered detailed version].freeze
+    SUBCOMMANDS = %w[list summary raw uncovered detailed totals validate version].freeze
 
     attr_reader :config
 
@@ -15,21 +16,19 @@ module SimpleCovMcp
 
     def build_option_parser
       require 'optparse'
-      OptionParser.new do |o|
-        configure_banner(o)
-        define_subcommands_help(o)
-        define_options(o)
-        define_examples(o)
-        add_help_handler(o)
+      OptionParser.new do |parser|
+        configure_banner(parser)
+        define_subcommands_help(parser)
+        define_options(parser)
+        define_examples(parser)
+        add_help_handler(parser)
       end
     end
 
-    private
-
-    def configure_banner(o)
-      o.banner = <<~BANNER
+    private def configure_banner(parser)
+      parser.banner = <<~BANNER
         #{HORIZONTAL_RULE}
-        Usage:      simplecov-mcp [subcommand] [options] [args]
+        Usage:      simplecov-mcp [options] [subcommand] [args]
         Repository: https://github.com/keithrbennett/simplecov-mcp
         Version:    #{SimpleCovMcp::VERSION}
         #{HORIZONTAL_RULE}
@@ -37,98 +36,116 @@ module SimpleCovMcp
         BANNER
     end
 
-    def define_subcommands_help(o)
-      o.separator <<~SUBCOMMANDS
+    private def define_subcommands_help(parser)
+      parser.separator <<~SUBCOMMANDS
         Subcommands:
-          list                    Show files coverage (table or --json)
+          list                    Show files coverage (default: table, or use --format)
           summary <path>          Show covered/total/% for a file
           raw <path>              Show the SimpleCov 'lines' array
           uncovered <path>        Show uncovered lines and a summary
           detailed <path>         Show per-line rows with hits/covered
+          totals                  Show aggregated line totals and average %
+          validate <file>         Evaluate coverage policy from file (exit 0=pass, 1=fail, 2=error)
+          validate -e <code>      Evaluate coverage policy from code string
           version                 Show version information
 
         SUBCOMMANDS
     end
 
-    def define_options(o)
-      o.separator 'Options:'
-      o.on('-r', '--resultset PATH', String,
+    private def define_options(parser)
+      parser.separator 'Options:'
+      parser.on('-r', '--resultset PATH', String,
         'Path or directory that contains .resultset.json (default: coverage/.resultset.json)') \
-      do |v|
-        config.resultset = v
+      do |value|
+        config.resultset = value
+      end
+      parser.on('-R', '--root PATH', String, 'Project root (default: .)') do |value|
+        config.root = value
+      end
+      parser.on(
+        '-f', '--format FORMAT', String,
+        'Output format: t[able]|j[son]|pretty-json|y[aml]|a[wesome-print] (default: table)'
+      ) do |value|
+        config.format = normalize_format(value)
       end
-      o.on('-R', '--root PATH', String, 'Project root (default: .)') { |v| config.root = v }
-      o.on('-j', '--json', 'Output JSON for machine consumption') { config.json = true }
-      o.on('-o', '--sort-order ORDER', String,
-        'Sort order for list: a[scending]|d[escending] (default ascending)') do |v|
-        config.sort_order = normalize_sort_order(v)
+      parser.on('-o', '--sort-order ORDER', String,
+        'Sort order for list: a[scending]|d[escending] (default descending)') do |value|
+        config.sort_order = normalize_sort_order(value)
       end
-      o.on('-s', '--source[=MODE]', String,
-        'Include source (MODE: f[ull]|u[ncovered]; default full)') do |v|
-        config.source_mode = normalize_source_mode(v)
+      parser.on('-s', '--source MODE', String,
+        'Source display: f[ull]|u[ncovered]') do |value|
+        config.source_mode = normalize_source_mode(value)
       end
-      o.on('-c', '--source-context N', Integer,
-        'For --source=uncovered, show N context lines (default: 2)') do |v|
-        config.source_context = v
+      parser.on('-c', '--context-lines N', Integer,
+        'Context lines around uncovered lines (non-negative, default: 2)') do |value|
+        config.source_context = value
       end
-      o.on('--color', 'Enable ANSI colors for source output') { config.color = true }
-      o.on('--no-color', 'Disable ANSI colors') { config.color = false }
-      o.on('-S', '--stale MODE', String,
-        'Staleness mode: o[ff]|e[rror] (default off)') do |v|
-        config.stale_mode = normalize_stale_mode(v)
+      parser.on('--color', 'Enable ANSI colors for source output') { config.color = true }
+      parser.on('--no-color', 'Disable ANSI colors') { config.color = false }
+      parser.on('-S', '--staleness MODE', String,
+        'Staleness detection: o[ff]|e[rror] (default off)') do |value|
+        config.staleness = normalize_staleness(value)
       end
-      o.on('-g', '--tracked-globs x,y,z', Array,
-        'Globs for filtering files (list subcommand)') do |v|
-        config.tracked_globs = v
+      parser.on('-g', '--tracked-globs x,y,z', Array,
+        'Globs for filtering files (list/totals subcommands)') do |value|
+        config.tracked_globs = value
       end
-      o.on('-l', '--log-file PATH', String,
-        'Log file path (default ./simplecov_mcp.log, use stdout/stderr for streams)') do |v|
-        config.log_file = v
+      parser.on('-l', '--log-file PATH', String,
+        'Log file path (default ./simplecov_mcp.log, use stdout/stderr for streams)') do |value|
+        config.log_file = value
       end
-      o.on('--error-mode MODE', String,
-        'Error handling mode: off|on|t[trace] (default on)') do |v|
-        config.error_mode = normalize_error_mode(v)
+      parser.on('--error-mode MODE', String,
+        'Error handling mode: o[ff]|l[og]|d[ebug] (default log). ' \
+        'off (silent), log (log errors to file), debug (verbose with backtraces)') do |value|
+        config.error_mode = normalize_error_mode(value)
       end
-      o.on('--force-cli', 'Force CLI mode (useful in scripts where auto-detection fails)') do
+      parser.on('--force-cli', 'Force CLI mode (useful in scripts where auto-detection fails)') do
         # This flag is mainly for mode detection - no action needed here
       end
-      o.on('--success-predicate FILE', String,
-        'Ruby file returning callable; exits 0 if truthy, 1 if falsy') do |v|
-        config.success_predicate = v
+      parser.on('-v', '--version', 'Show version information and exit') do
+        config.show_version = true
       end
     end
 
-    def define_examples(o)
-      o.separator <<~EXAMPLES
+    private def define_examples(parser)
+      parser.separator <<~EXAMPLES
 
         Examples:
-          simplecov-mcp list --resultset coverage
-          simplecov-mcp summary lib/foo.rb --json --resultset coverage
-          simplecov-mcp uncovered lib/foo.rb --source=uncovered --source-context 2
+          simplecov-mcp --resultset coverage list
+          simplecov-mcp --format json --resultset coverage summary lib/foo.rb
+          simplecov-mcp --source uncovered --context-lines 2 uncovered lib/foo.rb
+          simplecov-mcp totals --format json
         EXAMPLES
     end
 
-    def add_help_handler(o)
-      o.on('-h', '--help', 'Show help') do
-        puts o
+    private def add_help_handler(parser)
+      parser.on('-h', '--help', 'Show help') do
+        puts parser
+        gem_root = File.expand_path('../..', __dir__)
+        puts "\nFor more detailed help, consult README.md and docs/user/**/*.md"
+        puts "in the installed gem at: #{gem_root}"
         exit 0
       end
     end
 
-    def normalize_sort_order(v)
-      OptionNormalizers.normalize_sort_order(v, strict: true)
+    private def normalize_sort_order(value)
+      OptionNormalizers.normalize_sort_order(value, strict: true)
+    end
+
+    private def normalize_source_mode(value)
+      OptionNormalizers.normalize_source_mode(value, strict: true)
     end
 
-    def normalize_source_mode(v)
-      OptionNormalizers.normalize_source_mode(v, strict: true)
+    private def normalize_staleness(value)
+      OptionNormalizers.normalize_staleness(value, strict: true)
     end
 
-    def normalize_stale_mode(v)
-      OptionNormalizers.normalize_stale_mode(v, strict: true)
+    private def normalize_error_mode(value)
+      OptionNormalizers.normalize_error_mode(value, strict: true)
     end
 
-    def normalize_error_mode(v)
-      OptionNormalizers.normalize_error_mode(v, strict: true)
+    private def normalize_format(value)
+      OptionNormalizers.normalize_format(value, strict: true)
     end
   end
 end

data/lib/simplecov_mcp/option_parsers/env_options_parser.rb

@@ -35,15 +35,13 @@ module SimpleCovMcp
           end
         end
         nil
-      rescue StandardError
+      rescue
         # Ignore errors during pre-scan; they'll be caught during actual parsing
         nil
       end
 
-      private
-
-      def normalize_error_mode(value)
-        OptionNormalizers.normalize_error_mode(value, strict: false, default: :on)
+      private def normalize_error_mode(value)
+        OptionNormalizers.normalize_error_mode(value, strict: false, default: :log)
       end
     end
   end

data/lib/simplecov_mcp/option_parsers/error_helper.rb

@@ -3,7 +3,7 @@
 module SimpleCovMcp
   module OptionParsers
     class ErrorHelper
-      SUBCOMMANDS = %w[list summary raw uncovered detailed version].freeze
+      SUBCOMMANDS = %w[list summary raw uncovered detailed totals version].freeze
 
       def initialize(subcommands = SUBCOMMANDS)
         @subcommands = subcommands
@@ -14,7 +14,7 @@ module SimpleCovMcp
         # Suggest a subcommand when an invalid option matches a known subcommand
         option = extract_invalid_option(message)
 
-        if option && option.start_with?('--') && @subcommands.include?(option[2..-1])
+        if option&.start_with?('--') && @subcommands.include?(option[2..])
           suggest_subcommand(option)
         else
           # Generic message from OptionParser
@@ -28,19 +28,19 @@ module SimpleCovMcp
         exit 1
       end
 
-      private
-
-      def extract_invalid_option(message)
-        message.match(/invalid option: (.+)/)[1] rescue nil
+      private def extract_invalid_option(message)
+        message.match(/invalid option: (.+)/)[1]
+      rescue
+        nil
       end
 
-      def suggest_subcommand(option)
-        subcommand = option[2..-1]
+      private def suggest_subcommand(option)
+        subcommand = option[2..]
         warn "Error: '#{option}' is not a valid option. Did you mean the '#{subcommand}' subcommand?"
         warn "Try: #{program_name} #{subcommand} [args]"
       end
 
-      def build_enum_value_hint(argv)
+      private def build_enum_value_hint(argv)
         rules = enumerated_option_rules
         tokens = Array(argv)
         rules.each do |rule|
@@ -50,7 +50,7 @@ module SimpleCovMcp
         nil
       end
 
-      def build_hint_for_rule(rule, tokens)
+      private def build_hint_for_rule(rule, tokens)
         switches = rule[:switches]
         allowed = rule[:values]
         display = rule[:display] || allowed.join(', ')
@@ -72,17 +72,17 @@ module SimpleCovMcp
         nil
       end
 
-      def equal_form_match?(token, switches, preferred)
+      private def equal_form_match?(token, switches, preferred)
         token.start_with?(preferred + '=') || switches.any? { |s| token.start_with?(s + '=') }
       end
 
-      def handle_equal_form(token, switches, preferred, display, allowed)
+      private def handle_equal_form(token, switches, preferred, display, allowed)
         sw = switches.find { |s| token.start_with?(s + '=') } || preferred
         val = token.split('=', 2)[1]
         "Valid values for #{sw}: #{display}" if val && !allowed.include?(val)
       end
 
-      def handle_space_form(tokens, index, preferred, display, allowed)
+      private def handle_space_form(tokens, index, preferred, display, allowed)
         val = tokens[index + 1]
         # If missing value, provide hint; if present and invalid, also hint
         if val.nil? || val.start_with?('-') || !allowed.include?(val)
@@ -90,18 +90,19 @@ module SimpleCovMcp
         end
       end
 
-      def enumerated_option_rules
+      private def enumerated_option_rules
         [
-          { switches: ['-S', '--stale'], values: %w[off o error e], display: 'o[ff]|e[rror]' },
+          { switches: ['-S', '--staleness'], values: %w[off o error e], display: 'o[ff]|e[rror]' },
           { switches: ['-s', '--source'], values: %w[full f uncovered u],
             display: 'f[ull]|u[ncovered]' },
-          { switches: ['--error-mode'], values: %w[off on trace t], display: 'off|on|t[race]' },
+          { switches: ['--error-mode'], values: %w[off o log l debug d],
+            display: 'o[ff]|l[og]|d[ebug]' },
           { switches: ['-o', '--sort-order'], values: %w[a d ascending descending],
             display: 'a[scending]|d[escending]' }
         ]
       end
 
-      def program_name
+      private def program_name
         'simplecov-mcp'
       end
     end

data/lib/simplecov_mcp/path_relativizer.rb

@@ -16,9 +16,22 @@ module SimpleCovMcp
       deep_copy_and_relativize(obj)
     end
 
-    private
+    # Converts an absolute path to a path relative to the root.
+    # Falls back to the original path if conversion fails (e.g., different drive on Windows).
+    #
+    # @param path [String] file path (absolute or relative)
+    # @return [String] relative path or original path on failure
+    def relativize_path(path)
+      root_str = @root.to_s
+      abs = File.absolute_path(path, root_str)
+      return path unless abs.start_with?(root_prefix(root_str)) || abs == root_str
 
-    def deep_copy_and_relativize(obj, key_context = nil)
+      Pathname.new(abs).relative_path_from(@root).to_s
+    rescue ArgumentError
+      path
+    end
+
+    private def deep_copy_and_relativize(obj)
       case obj
       when Hash
         obj.each_with_object({}) do |(k, v), acc|
@@ -31,7 +44,7 @@ module SimpleCovMcp
       end
     end
 
-    def relativize_value(key, value)
+    private def relativize_value(key, value)
       key_str = key.to_s
       if @scalar_keys.include?(key_str) && value.is_a?(String)
         relativize_path(value)
@@ -44,17 +57,7 @@ module SimpleCovMcp
       end
     end
 
-    def relativize_path(path)
-      abs = File.absolute_path(path, @root.to_s)
-      root_str = @root.to_s
-      return path unless abs.start_with?(root_prefix(root_str)) || abs == root_str
-
-      Pathname.new(abs).relative_path_from(@root).to_s
-    rescue ArgumentError
-      path
-    end
-
-    def root_prefix(root_str)
+    private def root_prefix(root_str)
       root_str.end_with?(File::SEPARATOR) ? root_str : root_str + File::SEPARATOR
     end
   end

data/lib/simplecov_mcp/predicate_evaluator.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module SimpleCovMcp
+  # Evaluates coverage predicates from either Ruby code strings or files.
+  # Used by the validate subcommand, validate MCP tool, and library API.
+  #
+  # Security Warning:
+  # Predicates execute as arbitrary Ruby code with full system privileges.
+  # Only use predicates from trusted sources.
+  class PredicateEvaluator
+    # Evaluate a predicate from a code string
+    #
+    # @param code [String] Ruby code that returns a callable (lambda, proc, or object with #call)
+    # @param model [CoverageModel] The coverage model to pass to the predicate
+    # @return [Boolean] The result of calling the predicate with the model
+    # @raise [RuntimeError] If the code doesn't return a callable or has syntax errors
+    def self.evaluate_code(code, model)
+      # WARNING: The predicate code executes with full Ruby privileges.
+      # It has unrestricted access to the file system, network, and system commands.
+      # Only use predicate code from trusted sources.
+      #
+      # We evaluate in a fresh Object context to prevent accidental access to
+      # internals, but this provides NO security isolation.
+      evaluation_context = Object.new
+      predicate = evaluation_context.instance_eval(code, '<predicate>', 1)
+
+      validate_callable(predicate)
+      predicate.call(model)
+    rescue SyntaxError => e
+      raise "Syntax error in predicate code: #{e.message}"
+    end
+
+    # Evaluate a predicate from a file
+    #
+    # @param path [String] Path to Ruby file containing predicate code
+    # @param model [CoverageModel] The coverage model to pass to the predicate
+    # @return [Boolean] The result of calling the predicate with the model
+    # @raise [RuntimeError] If the file doesn't exist, doesn't return a callable, or has syntax errors
+    def self.evaluate_file(path, model)
+      unless File.exist?(path)
+        raise "Predicate file not found: #{path}"
+      end
+
+      content = File.read(path)
+
+      # WARNING: The predicate code executes with full Ruby privileges.
+      # It has unrestricted access to the file system, network, and system commands.
+      # Only use predicate files from trusted sources.
+      #
+      # We evaluate in a fresh Object context to prevent accidental access to
+      # internals, but this provides NO security isolation.
+      evaluation_context = Object.new
+      predicate = evaluation_context.instance_eval(content, path, 1)
+
+      validate_callable(predicate)
+      predicate.call(model)
+    rescue SyntaxError => e
+      raise "Syntax error in predicate file: #{e.message}"
+    end
+
+    # Validate that an object is callable
+    #
+    # @param predicate [Object] The object to check
+    # @raise [RuntimeError] If the object doesn't respond to #call
+    def self.validate_callable(predicate)
+      unless predicate.respond_to?(:call)
+        raise 'Predicate must be callable (lambda, proc, or object with #call method)'
+      end
+    end
+    private_class_method :validate_callable
+  end
+end

data/lib/simplecov_mcp/presenters/base_coverage_presenter.rb

@@ -34,9 +34,7 @@ module SimpleCovMcp
         relativized_payload['file']
       end
 
-      private
-
-      def build_payload
+      private def build_payload
         raise NotImplementedError, "#{self.class} must implement #build_payload"
       end
     end

data/lib/simplecov_mcp/presenters/coverage_detailed_presenter.rb

@@ -6,9 +6,7 @@ module SimpleCovMcp
   module Presenters
     # Provides shared detailed coverage payloads for CLI and MCP callers.
     class CoverageDetailedPresenter < BaseCoveragePresenter
-      private
-
-      def build_payload
+      private def build_payload
         model.detailed_for(path)
       end
     end

data/lib/simplecov_mcp/presenters/coverage_raw_presenter.rb

@@ -6,9 +6,7 @@ module SimpleCovMcp
   module Presenters
     # Provides shared raw coverage payloads for CLI and MCP callers.
     class CoverageRawPresenter < BaseCoveragePresenter
-      private
-
-      def build_payload
+      private def build_payload
         model.raw_for(path)
       end
     end

data/lib/simplecov_mcp/presenters/coverage_summary_presenter.rb

@@ -6,9 +6,7 @@ module SimpleCovMcp
   module Presenters
     # Builds a consistent summary payload that both the CLI and MCP surfaces can use.
     class CoverageSummaryPresenter < BaseCoveragePresenter
-      private
-
-      def build_payload
+      private def build_payload
         model.summary_for(path)
       end
     end

data/lib/simplecov_mcp/presenters/coverage_uncovered_presenter.rb

@@ -6,9 +6,7 @@ module SimpleCovMcp
   module Presenters
     # Provides shared uncovered coverage payloads for CLI and MCP callers.
     class CoverageUncoveredPresenter < BaseCoveragePresenter
-      private
-
-      def build_payload
+      private def build_payload
         model.uncovered_for(path)
       end
     end

data/lib/simplecov_mcp/presenters/project_coverage_presenter.rb

@@ -40,9 +40,7 @@ module SimpleCovMcp
         relativized_payload['counts']
       end
 
-      private
-
-      def build_counts(files)
+      private def build_counts(files)
         total = files.length
         stale = files.count { |f| f['stale'] }
         { 'total' => total, 'ok' => total - stale, 'stale' => stale }

data/lib/simplecov_mcp/presenters/project_totals_presenter.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module SimpleCovMcp
+  module Presenters
+    # Provides aggregated line totals and average coverage across the project.
+    class ProjectTotalsPresenter
+      attr_reader :model, :check_stale, :tracked_globs
+
+      def initialize(model:, check_stale:, tracked_globs:)
+        @model = model
+        @check_stale = check_stale
+        @tracked_globs = tracked_globs
+      end
+
+      def absolute_payload
+        @absolute_payload ||= model.project_totals(
+          tracked_globs: tracked_globs,
+          check_stale: check_stale
+        )
+      end
+
+      def relativized_payload
+        @relativized_payload ||= model.relativize(absolute_payload)
+      end
+    end
+  end
+end