simplecov-mcp 1.0.1 → 2.0.1

data/lib/simplecov_mcp/resolvers/coverage_line_resolver.rb

@@ -9,45 +9,41 @@ module SimpleCovMcp
 
       def lookup_lines(file_abs)
         # First try exact match
-        if direct_match = find_direct_match(file_abs)
-          return direct_match
-        end
+        direct_match = find_direct_match(file_abs)
+        return direct_match if direct_match
 
         # Then try without current working directory prefix
-        if stripped_match = find_stripped_match(file_abs)
-          return stripped_match
-        end
+        stripped_match = find_stripped_match(file_abs)
+        return stripped_match if stripped_match
 
         raise_not_found_error(file_abs)
       end
 
-      private
-
       attr_reader :cov_data
 
-      def find_direct_match(file_abs)
+      private def find_direct_match(file_abs)
         entry = cov_data[file_abs]
         lines_from_entry(entry)
       end
 
-      def find_stripped_match(file_abs)
+      private def find_stripped_match(file_abs)
         return unless file_abs.start_with?(cwd_with_slash)
 
-        relative_path = file_abs[(cwd.length + 1)..-1]
+        relative_path = file_abs[(cwd.length + 1)..]
         entry = cov_data[relative_path]
         lines_from_entry(entry)
       end
 
-      def cwd
+      private def cwd
         @cwd ||= Dir.pwd
       end
 
-      def cwd_with_slash
+      private def cwd_with_slash
         @cwd_with_slash ||= "#{cwd}/"
       end
 
-      def raise_not_found_error(file_abs)
-        raise FileError.new("No coverage entry found for #{file_abs}")
+      private def raise_not_found_error(file_abs)
+        raise FileError, "No coverage entry found for #{file_abs}"
       end
 
       # Entry may store exact line coverage, branch-only coverage, or neither.
@@ -56,7 +52,7 @@ module SimpleCovMcp
       #
       # Returning nil tells callers to keep searching; the resolver will raise
       # a FileError if no variant yields coverage data.
-      def lines_from_entry(entry)
+      private def lines_from_entry(entry)
         return unless entry.is_a?(Hash)
 
         lines = entry['lines']
@@ -75,7 +71,7 @@ module SimpleCovMcp
       # We care about the third tuple element (line number). We sum branch-leg
       # hits per line so the synthetic array still behaves like legacy line
       # coverage (any positive value counts as executed).
-      def synthesize_lines_from_branches(branch_data)
+      private def synthesize_lines_from_branches(branch_data)
         # Detailed shape and rationale documented in docs/BRANCH_ONLY_COVERAGE.md
         return unless branch_data.is_a?(Hash) && branch_data.any?
 
@@ -105,7 +101,7 @@ module SimpleCovMcp
       # Branch metadata arrives as either the raw SimpleCov array
       # (e.g. [:if, 0, 12, 4, 20, 29]) or the stringified JSON version
       # ("[:if, 0, 12, 4, 20, 29]"). We normalize both forms and pull the line.
-      def extract_line_number(meta)
+      private def extract_line_number(meta)
         if meta.is_a?(Array)
           line_token = meta[2]
           # Integer(..., exception: false) returns nil on failure, so malformed

data/lib/simplecov_mcp/resolvers/resultset_path_resolver.rb

@@ -27,9 +27,7 @@ module SimpleCovMcp
         resolve_fallback or raise_not_found_error
       end
 
-      private
-
-      def resolve_candidate(path, strict:)
+      private def resolve_candidate(path, strict:)
         return path if File.file?(path)
         return resolve_directory(path) if File.directory?(path)
 
@@ -37,24 +35,24 @@ module SimpleCovMcp
         nil
       end
 
-      def resolve_directory(path)
+      private def resolve_directory(path)
         candidate = File.join(path, '.resultset.json')
         return candidate if File.file?(candidate)
 
         raise "No .resultset.json found in directory: #{path}"
       end
 
-      def raise_not_found_error_for_file(path)
+      private def raise_not_found_error_for_file(path)
         raise "Specified resultset not found: #{path}"
       end
 
-      def resolve_fallback
+      private def resolve_fallback
         @candidates
           .map { |p| File.absolute_path(p, @root) }
           .find { |p| File.file?(p) }
       end
 
-      def normalize_resultset_path(resultset)
+      private def normalize_resultset_path(resultset)
         candidate = Pathname.new(resultset)
         return candidate.cleanpath.to_s if candidate.absolute?
 
@@ -64,13 +62,13 @@ module SimpleCovMcp
         File.absolute_path(resultset, @root)
       end
 
-      def within_root?(path)
+      private def within_root?(path)
         normalized_root = Pathname.new(@root).cleanpath.to_s
         root_with_sep = normalized_root.end_with?(File::SEPARATOR) ? normalized_root : "#{normalized_root}#{File::SEPARATOR}"
         path == normalized_root || path.start_with?(root_with_sep)
       end
 
-      def raise_not_found_error
+      private def raise_not_found_error
         raise "Could not find .resultset.json under #{@root.inspect}; run tests or set --resultset option"
       end
     end

data/lib/simplecov_mcp/resultset_loader.rb

@@ -13,10 +13,11 @@ module SimpleCovMcp
 
     class << self
       def load(resultset_path:)
-        raw = JSON.parse(File.read(resultset_path))
+        raw = JSON.load_file(resultset_path)
+
 
         suites = extract_suite_entries(raw, resultset_path)
-        raise CoverageDataError.new("No test suite with coverage data found in resultset file: #{resultset_path}") if suites.empty?
+        raise CoverageDataError, "No test suite with coverage data found in resultset file: #{resultset_path}" if suites.empty?
 
         coverage_map = build_coverage_map(suites, resultset_path)
         Result.new(
@@ -26,9 +27,7 @@ module SimpleCovMcp
         )
       end
 
-      private
-
-      def extract_suite_entries(raw, resultset_path)
+      private def extract_suite_entries(raw, resultset_path)
         raw
           .select { |_, data| data.is_a?(Hash) && data.key?('coverage') && !data['coverage'].nil? }
           .map do |name, data|
@@ -41,26 +40,26 @@ module SimpleCovMcp
           end
       end
 
-      def build_coverage_map(suites, resultset_path)
+      private def build_coverage_map(suites, resultset_path)
         return suites.first&.coverage if suites.length == 1
 
         merge_suite_coverages(suites, resultset_path)
       end
 
-      def normalize_suite_coverage(coverage, suite_name:, resultset_path:)
+      private def normalize_suite_coverage(coverage, suite_name:, resultset_path:)
         unless coverage.is_a?(Hash)
-          raise CoverageDataError.new("Invalid coverage data structure for suite #{suite_name.inspect} in resultset file: #{resultset_path}")
+          raise CoverageDataError, "Invalid coverage data structure for suite #{suite_name.inspect} in resultset file: #{resultset_path}"
         end
 
         needs_adaptation = coverage.values.any? { |value| value.is_a?(Array) }
         return coverage unless needs_adaptation
 
-        coverage.each_with_object({}) do |(file, value), acc|
-          acc[file] = value.is_a?(Array) ? { 'lines' => value } : value
+        coverage.transform_values do |value|
+          value.is_a?(Array) ? { 'lines' => value } : value
         end
       end
 
-      def merge_suite_coverages(suites, resultset_path)
+      private def merge_suite_coverages(suites, resultset_path)
         require_simplecov_for_merge!(resultset_path)
         log_duplicate_suite_names(suites)
 
@@ -72,30 +71,26 @@ module SimpleCovMcp
         end
       end
 
-      def require_simplecov_for_merge!(resultset_path)
+      private def require_simplecov_for_merge!(resultset_path)
         require 'simplecov'
       rescue LoadError
-        raise CoverageDataError.new(
-          "Multiple coverage suites detected in #{resultset_path}, but the simplecov gem could not be loaded. Install simplecov to enable suite merging."
-        )
+        raise CoverageDataError, "Multiple coverage suites detected in #{resultset_path}, but the simplecov gem could not be loaded. Install simplecov to enable suite merging."
       end
 
-      def log_duplicate_suite_names(suites)
+      private def log_duplicate_suite_names(suites)
         grouped = suites.group_by(&:name)
         duplicates = grouped.select { |_, entries| entries.length > 1 }.keys
         return if duplicates.empty?
 
         message = "Merging duplicate coverage suites for #{duplicates.join(', ')}"
-        CovUtil.log(message)
-      rescue StandardError
-        # Logging should never block coverage loading
+        CovUtil.safe_log(message)
       end
 
-      def compute_combined_timestamp(suites)
+      private def compute_combined_timestamp(suites)
         suites.map(&:timestamp).compact.max.to_i
       end
 
-      def normalize_coverage_timestamp(timestamp_value, created_at_value)
+      private def normalize_coverage_timestamp(timestamp_value, created_at_value)
         raw = timestamp_value.nil? ? created_at_value : timestamp_value
         return 0 if raw.nil?
 
@@ -110,12 +105,12 @@ module SimpleCovMcp
           log_timestamp_warning(raw)
           0
         end
-      rescue StandardError => e
+      rescue => e
         log_timestamp_warning(raw, e)
         0
       end
 
-      def normalize_string_timestamp(value)
+      private def normalize_string_timestamp(value)
         str = value.strip
         return 0 if str.empty?
 
@@ -126,10 +121,10 @@ module SimpleCovMcp
         end
       end
 
-      def log_timestamp_warning(raw_value, error = nil)
+      private def log_timestamp_warning(raw_value, error = nil)
         message = "Coverage resultset timestamp could not be parsed: #{raw_value.inspect}"
         message = "#{message} (#{error.message})" if error
-        CovUtil.log(message) rescue nil
+        CovUtil.safe_log(message)
       end
     end
   end

data/lib/simplecov_mcp/staleness_checker.rb

@@ -1,9 +1,7 @@
 # frozen_string_literal: true
 
 require 'time'
-require 'json'
 require 'pathname'
-require 'set'
 require_relative 'errors'
 require_relative 'util'
 
@@ -66,62 +64,68 @@ module SimpleCovMcp
       return if off?
 
       ts = coverage_timestamp
-      newer = []
-      deleted = []
       coverage_files = coverage_map.keys
-      coverage_files.each do |abs|
-        if File.file?(abs)
-          newer << rel(abs) if File.mtime(abs).to_i > ts.to_i
-        else
-          deleted << rel(abs)
-        end
-      end
 
-      missing = []
-      if @tracked_globs && !Array(@tracked_globs).empty?
-        patterns = Array(@tracked_globs).map { |g| File.absolute_path(g, @root) }
-        tracked = patterns.flat_map { |p| Dir.glob(p, File::FNM_EXTGLOB | File::FNM_PATHNAME) }
-          .select { |p| File.file?(p) }
-        covered_set = coverage_files.to_set rescue coverage_files
-        tracked.each do |abs|
-          missing << rel(abs) unless covered_set.include?(abs)
-        end
-      end
+      newer, deleted = compute_newer_and_deleted_files(coverage_files, ts)
+      missing = compute_missing_files(coverage_files)
 
-      if !newer.empty? || !missing.empty? || !deleted.empty?
-        raise CoverageDataProjectStaleError.new(
-          nil,
-          nil,
-          cov_timestamp: ts,
-          newer_files: newer,
-          missing_files: missing,
-          deleted_files: deleted,
-          resultset_path: resultset_path
-        )
-      end
+      return if newer.empty? && missing.empty? && deleted.empty?
+
+      raise CoverageDataProjectStaleError.new(
+        nil,
+        nil,
+        cov_timestamp: ts,
+        newer_files: newer,
+        missing_files: missing,
+        deleted_files: deleted,
+        resultset_path: resultset_path
+      )
+    end
+
+    private def compute_newer_and_deleted_files(coverage_files, timestamp)
+      existing, deleted_abs = coverage_files.partition { |abs| File.file?(abs) }
+
+      newer = existing
+        .select { |abs| File.mtime(abs).to_i > timestamp.to_i }
+        .map { |abs| rel(abs) }
+      deleted = deleted_abs.map { |abs| rel(abs) }
+
+      [newer, deleted]
     end
 
-    private
+    # Identifies tracked files that are missing from coverage.
+    # Returns array of relative paths for files matched by tracked_globs but not in coverage.
+    private def compute_missing_files(coverage_files)
+      return [] unless @tracked_globs && Array(@tracked_globs).any?
+
+      patterns = Array(@tracked_globs).map { |g| File.absolute_path(g, @root) }
+      tracked = patterns
+        .flat_map { |p| Dir.glob(p, File::FNM_EXTGLOB | File::FNM_PATHNAME) }
+        .select { |p| File.file?(p) }
+
+      covered_set = coverage_files.to_set
+      tracked.reject { |abs| covered_set.include?(abs) }.map { |abs| rel(abs) }
+    end
 
-    def coverage_timestamp
+    private def coverage_timestamp
       @cov_timestamp || 0
     end
 
-    def resultset_path
+    private def resultset_path
       @resultset_path ||= CovUtil.find_resultset(@root, resultset: @resultset)
-    rescue StandardError
+    rescue
       nil
     end
 
-    def safe_count_lines(path)
+    private def safe_count_lines(path)
       return 0 unless File.file?(path)
 
       File.foreach(path).count
-    rescue StandardError
+    rescue
       0
     end
 
-    def missing_trailing_newline?(path)
+    private def missing_trailing_newline?(path)
       return false unless File.file?(path)
 
       File.open(path, 'rb') do |f|
@@ -131,11 +135,11 @@ module SimpleCovMcp
         f.seek(-1, IO::SEEK_END)
         f.getbyte != 0x0A
       end
-    rescue StandardError
+    rescue
       false
     end
 
-    def rel(path)
+    private def rel(path)
       # Handle relative vs absolute path mismatches that cause ArgumentError
       Pathname.new(path).relative_path_from(Pathname.new(@root)).to_s
     rescue ArgumentError
@@ -146,7 +150,7 @@ module SimpleCovMcp
     # Centralized computation of staleness-related details for a single file.
     # Returns a Hash with keys:
     #  :exists, :file_mtime, :coverage_timestamp, :cov_len, :src_len, :newer, :len_mismatch
-    def compute_file_staleness_details(file_abs, coverage_lines)
+    private def compute_file_staleness_details(file_abs, coverage_lines)
       coverage_ts = coverage_timestamp
 
       exists = File.file?(file_abs)
@@ -164,7 +168,7 @@ module SimpleCovMcp
       )
 
       # Check if the source file has been modified since coverage was generated
-      len_mismatch = check_length_mismatch(cov_len, adjusted_src_len)
+      len_mismatch = length_mismatch?(cov_len, adjusted_src_len)
       newer = check_file_newer_than_coverage(file_mtime, coverage_ts, len_mismatch)
 
       {
@@ -199,7 +203,7 @@ module SimpleCovMcp
     # - SimpleCov coverage array length: 3
     # - Missing trailing newline: true
     # - Adjustment: 4 - 1 = 3 (now matches)
-    def adjust_line_count_for_missing_newline(file_abs:, exists:, cov_len:, src_len:)
+    private def adjust_line_count_for_missing_newline(file_abs:, exists:, cov_len:, src_len:)
       # Only adjust if:
       # 1. File exists (can't check newlines for missing files)
       # 2. Coverage data is present (cov_len > 0)
@@ -219,7 +223,7 @@ module SimpleCovMcp
     #
     # Note: Empty coverage (cov_len == 0) is not considered a mismatch, as it may represent
     # files that were never executed or files that are legitimately empty.
-    def check_length_mismatch(cov_len, adjusted_src_len)
+    private def length_mismatch?(cov_len, adjusted_src_len)
       cov_len.positive? && adjusted_src_len != cov_len
     end
 
@@ -233,7 +237,7 @@ module SimpleCovMcp
     # The logic: newer &&= !len_mismatch means:
     # - If len_mismatch is true, set newer to false (length mismatch takes precedence)
     # - This way, staleness is categorized as either 'T' (time-based) OR 'L' (length-based), not both
-    def check_file_newer_than_coverage(file_mtime, coverage_ts, len_mismatch)
+    private def check_file_newer_than_coverage(file_mtime, coverage_ts, len_mismatch)
       newer = !!(file_mtime && file_mtime.to_i > coverage_ts.to_i)
       # If there's a length mismatch, don't also flag as "newer" - the mismatch is more specific
       newer &&= !len_mismatch

data/lib/simplecov_mcp/table_formatter.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module SimpleCovMcp
+  # General-purpose table formatter with box-drawing characters
+  # Used by commands to create consistent formatted output
+  class TableFormatter
+    # Format data as a table with box-drawing characters
+    # @param headers [Array<String>] Column headers
+    # @param rows [Array<Array>] Data rows (each row is an array of cell values)
+    # @param alignments [Array<Symbol>] Column alignments (:left, :right, :center)
+    # @return [String] Formatted table
+    def self.format(headers:, rows:, alignments: nil)
+      return 'No data to display' if rows.empty?
+
+      alignments ||= [:left] * headers.size
+      all_rows = [headers] + rows.map { |row| row.map(&:to_s) }
+
+      # Calculate column widths
+      widths = headers.size.times.map do |col|
+        all_rows.map { |row| row[col].to_s.length }.max
+      end
+
+      lines = []
+      lines << border_line(widths, '┌', '┬', '┐')
+      lines << data_row(headers, widths, alignments)
+      lines << border_line(widths, '├', '┼', '┤')
+      rows.each { |row| lines << data_row(row, widths, alignments) }
+      lines << border_line(widths, '└', '┴', '┘')
+
+      lines.join("\n")
+    end
+
+    # Format a single key-value table (vertical layout)
+    # @param data [Hash] Key-value pairs
+    # @return [String] Formatted table
+    def self.format_vertical(data)
+      rows = data.map { |k, v| [k.to_s, v.to_s] }
+      format(headers: ['Key', 'Value'], rows: rows, alignments: [:left, :left])
+    end
+
+    private_class_method def self.border_line(widths, left, mid, right)
+      segments = widths.map { |w| '─' * (w + 2) }
+      left + segments.join(mid) + right
+    end
+
+    private_class_method def self.data_row(cells, widths, alignments)
+      formatted = cells.each_with_index.map do |cell, i|
+        align_cell(cell.to_s, widths[i], alignments[i])
+      end
+      "│ #{formatted.join(' │ ')} │"
+    end
+
+    private_class_method def self.align_cell(content, width, alignment)
+      case alignment
+      when :right
+        content.rjust(width)
+      when :center
+        content.center(width)
+      else # :left
+        content.ljust(width)
+      end
+    end
+  end
+end

data/lib/simplecov_mcp/tools/all_files_coverage_tool.rb

@@ -14,19 +14,8 @@ module SimpleCovMcp
         Output: JSON {"files": [{"file","covered","total","percentage","stale"}, ...], "counts": {"total", "ok", "stale"}} sorted as requested. "stale" is a string ('M', 'T', 'L') or false.
         Examples: "List files with the lowest coverage"; "Show repo coverage sorted descending".
       DESC
-      input_schema(
-        type: 'object',
-        additionalProperties: false,
-        properties: {
-          root: {
-            type: 'string',
-            description: 'Project root used to resolve relative inputs.',
-            default: '.'
-          },
-          resultset: {
-            type: 'string',
-            description: 'Path to the SimpleCov .resultset.json file.'
-          },
+      input_schema(**coverage_schema(
+        additional_properties: {
           sort_order: {
             type: 'string',
             description: 'Sort order for coverage percentages.' \
@@ -34,46 +23,27 @@ module SimpleCovMcp
             default: 'ascending',
             enum: ['ascending', 'descending']
           },
-          stale: {
-            type: 'string',
-            description:
-              "How to handle missing/outdated coverage data. 'off' skips checks; 'error' raises.",
-            enum: ['off', 'error'],
-            default: 'off'
-          },
-          tracked_globs: {
-            type: 'array',
-            description: 'Glob patterns for files that should exist in the coverage report' \
-                         '(helps flag new files).',
-            items: { type: 'string' }
-          },
-          error_mode: {
-            type: 'string',
-            description:
-              "Error handling mode: 'off' (silent), 'on' (log errors), 'trace' (verbose).",
-            enum: ['off', 'on', 'trace'],
-            default: 'on'
-          }
+          tracked_globs: TRACKED_GLOBS_PROPERTY
         }
-      )
+      ))
       class << self
-        def call(root: '.', resultset: nil, sort_order: 'ascending', stale: 'off',
-          tracked_globs: nil, error_mode: 'on', server_context:)
-          # Convert string inputs from MCP to symbols for internal use
-          sort_order_sym = sort_order.to_sym
-          stale_sym = stale.to_sym
+        def call(root: '.', resultset: nil, sort_order: 'ascending', staleness: :off,
+          tracked_globs: nil, error_mode: 'log', server_context:)
+          with_error_handling('AllFilesCoverageTool', error_mode: error_mode) do
+            # Convert string inputs from MCP to symbols for internal use
+            sort_order_sym = sort_order.to_sym
+            staleness_sym = staleness.to_sym
 
-          model = CoverageModel.new(root: root, resultset: resultset, staleness: stale_sym,
-            tracked_globs: tracked_globs)
-          presenter = Presenters::ProjectCoveragePresenter.new(
-            model: model,
-            sort_order: sort_order_sym,
-            check_stale: (stale_sym == :error),
-            tracked_globs: tracked_globs
-          )
-          respond_json(presenter.relativized_payload, name: 'all_files_coverage.json')
-        rescue => e
-          handle_mcp_error(e, 'AllFilesCoverageTool', error_mode: error_mode)
+            model = CoverageModel.new(root: root, resultset: resultset, staleness: staleness_sym,
+              tracked_globs: tracked_globs)
+            presenter = Presenters::ProjectCoveragePresenter.new(
+              model: model,
+              sort_order: sort_order_sym,
+              check_stale: (staleness_sym == :error),
+              tracked_globs: tracked_globs
+            )
+            respond_json(presenter.relativized_payload, name: 'all_files_coverage.json')
+          end
         end
       end
     end

data/lib/simplecov_mcp/tools/coverage_detailed_tool.rb

@@ -10,18 +10,24 @@ module SimpleCovMcp
       description <<~DESC
         Use this when the user needs per-line coverage data for a single file.
         Do not use this for high-level counts; coverage.summary is cheaper for aggregate numbers.
-        Inputs: file path (required) plus optional root/resultset/stale mode inherited from BaseTool.
+        Inputs: file path (required) plus optional root/resultset/staleness mode inherited from BaseTool.
         Output: JSON object with "file", "lines" => [{"line": 12, "hits": 0, "covered": false}], plus "summary" with totals and "stale" status.
         Example: "Show detailed coverage for lib/simple_cov_mcp/model.rb".
       DESC
       input_schema(**input_schema_def)
       class << self
-        def call(path:, root: '.', resultset: nil, stale: 'off', error_mode: 'on', server_context:)
-          model = CoverageModel.new(root: root, resultset: resultset, staleness: stale)
-          presenter = Presenters::CoverageDetailedPresenter.new(model: model, path: path)
-          respond_json(presenter.relativized_payload, name: 'coverage_detailed.json', pretty: true)
-        rescue => e
-          handle_mcp_error(e, 'CoverageDetailedTool', error_mode: error_mode)
+        def call(path:, root: '.', resultset: nil, staleness: :off, error_mode: 'log',
+          server_context:)
+          with_error_handling('CoverageDetailedTool', error_mode: error_mode) do
+            model = CoverageModel.new(
+              root: root,
+              resultset: resultset,
+              staleness: staleness.to_sym
+            )
+            presenter = Presenters::CoverageDetailedPresenter.new(model: model, path: path)
+            respond_json(presenter.relativized_payload, name: 'coverage_detailed.json',
+              pretty: true)
+          end
         end
       end
     end

data/lib/simplecov_mcp/tools/coverage_raw_tool.rb

@@ -10,18 +10,23 @@ module SimpleCovMcp
       description <<~DESC
         Use this when you need the raw SimpleCov `lines` array for a file exactly as stored on disk.
         Do not use this for human-friendly explanations; choose coverage.detailed or coverage.summary instead.
-        Inputs: file path (required) plus optional root/resultset/stale mode inherited from BaseTool.
+        Inputs: file path (required) plus optional root/resultset/staleness mode inherited from BaseTool.
         Output: JSON object with "file" and "lines" (array of integers/nulls) mirroring SimpleCov's native structure, plus "stale" status.
         Example: "Fetch the raw coverage array for spec/support/foo_helper.rb".
       DESC
       input_schema(**input_schema_def)
       class << self
-        def call(path:, root: '.', resultset: nil, stale: 'off', error_mode: 'on', server_context:)
-          model = CoverageModel.new(root: root, resultset: resultset, staleness: stale)
-          presenter = Presenters::CoverageRawPresenter.new(model: model, path: path)
-          respond_json(presenter.relativized_payload, name: 'coverage_raw.json', pretty: true)
-        rescue => e
-          handle_mcp_error(e, 'CoverageRawTool', error_mode: error_mode)
+        def call(path:, root: '.', resultset: nil, staleness: :off, error_mode: 'log',
+          server_context:)
+          with_error_handling('CoverageRawTool', error_mode: error_mode) do
+            model = CoverageModel.new(
+              root: root,
+              resultset: resultset,
+              staleness: staleness.to_sym
+            )
+            presenter = Presenters::CoverageRawPresenter.new(model: model, path: path)
+            respond_json(presenter.relativized_payload, name: 'coverage_raw.json', pretty: true)
+          end
         end
       end
     end