cov-loupe 3.0.0 → 4.0.0.pre

data/lib/cov_loupe/staleness_checker.rb

@@ -1,247 +0,0 @@
-# frozen_string_literal: true
-
-require 'time'
-require 'pathname'
-require_relative 'errors'
-require_relative 'util'
-
-module CovLoupe
-  # Lightweight service object to check staleness of coverage vs. sources
-  class StalenessChecker
-    MODES = [:off, :error].freeze
-
-    def initialize(root:, resultset:, mode: :off, tracked_globs: nil, timestamp: nil)
-      @root = File.absolute_path(root || '.')
-      @resultset = resultset
-      @mode = (mode || :off).to_sym
-      @tracked_globs = tracked_globs
-      @cov_timestamp = timestamp
-      @resultset_path = nil
-    end
-
-    def off?
-      @mode == :off
-    end
-
-    # Raise CoverageDataStaleError if stale (only in error mode)
-    def check_file!(file_abs, coverage_lines)
-      return if off?
-
-      d = compute_file_staleness_details(file_abs, coverage_lines)
-      # For single-file checks, missing files with recorded coverage count as stale
-      # via length mismatch; project-level checks also handle deleted files explicitly.
-      if d[:newer] || d[:len_mismatch]
-        raise CoverageDataStaleError.new(
-          nil,
-          nil,
-          file_path: rel(file_abs),
-          file_mtime: d[:file_mtime],
-          cov_timestamp: d[:coverage_timestamp],
-          src_len: d[:src_len],
-          cov_len: d[:cov_len],
-          resultset_path: resultset_path
-        )
-      end
-    end
-
-    # Compute whether a specific file appears stale relative to coverage.
-    # Ignores mode and never raises; returns true when:
-    # - the file is missing/deleted, or
-    # - the file mtime is newer than the coverage timestamp, or
-    # - the source line count differs from the coverage lines array length (when present).
-    def stale_for_file?(file_abs, coverage_lines)
-      d = compute_file_staleness_details(file_abs, coverage_lines)
-      return 'M' unless d[:exists]
-      return 'T' if d[:newer]
-      return 'L' if d[:len_mismatch]
-
-      false
-    end
-
-    # Raise CoverageDataProjectStaleError if any covered file is newer or if
-    # tracked files are missing from coverage, or coverage includes deleted files.
-    def check_project!(coverage_map)
-      return if off?
-
-      ts = coverage_timestamp
-      coverage_files = coverage_map.keys
-
-      newer, deleted = compute_newer_and_deleted_files(coverage_files, ts)
-      missing = compute_missing_files(coverage_files)
-
-      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
-
-    # 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
-
-    private def coverage_timestamp
-      @cov_timestamp || 0
-    end
-
-    private def resultset_path
-      @resultset_path ||= CovUtil.find_resultset(@root, resultset: @resultset)
-    rescue
-      nil
-    end
-
-    private def safe_count_lines(path)
-      return 0 unless File.file?(path)
-
-      File.foreach(path).count
-    rescue
-      0
-    end
-
-    private def missing_trailing_newline?(path)
-      return false unless File.file?(path)
-
-      File.open(path, 'rb') do |f|
-        size = f.size
-        return false if size.zero?
-
-        f.seek(-1, IO::SEEK_END)
-        f.getbyte != 0x0A
-      end
-    rescue
-      false
-    end
-
-    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
-      # Path is outside the project root or has a different prefix type, fall back to absolute path
-      path.to_s
-    end
-
-    # 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
-    private def compute_file_staleness_details(file_abs, coverage_lines)
-      coverage_ts = coverage_timestamp
-
-      exists = File.file?(file_abs)
-      file_mtime = exists ? File.mtime(file_abs) : nil
-
-      cov_len = coverage_lines.respond_to?(:length) ? coverage_lines.length : 0
-      src_len = exists ? safe_count_lines(file_abs) : 0
-
-      # Adjust source line count to handle edge cases with missing trailing newlines
-      adjusted_src_len = adjust_line_count_for_missing_newline(
-        file_abs: file_abs,
-        exists: exists,
-        cov_len: cov_len,
-        src_len: src_len
-      )
-
-      # Check if the source file has been modified since coverage was generated
-      len_mismatch = length_mismatch?(cov_len, adjusted_src_len)
-      newer = check_file_newer_than_coverage(file_mtime, coverage_ts, len_mismatch)
-
-      {
-        exists: exists,
-        file_mtime: file_mtime,
-        coverage_timestamp: coverage_ts,
-        cov_len: cov_len,
-        src_len: src_len,
-        newer: newer,
-        len_mismatch: len_mismatch
-      }
-    end
-
-    # Adjusts the source line count to account for files missing trailing newlines.
-    #
-    # Why this edge case exists:
-    # - File.foreach counts lines by separator (typically \n)
-    # - For a file with no trailing newline, File.foreach still counts all lines correctly
-    # - However, some editors or file operations may report one extra line when checking
-    #   if the file doesn't end with a newline
-    # - SimpleCov's coverage array length matches the logical line count (excluding trailing newline)
-    # - If src_len is exactly one more than cov_len AND the file is missing a trailing newline,
-    #   we adjust src_len down by 1 to match SimpleCov's convention
-    #
-    # Example: A file with "line1\nline2\nline3" (no final \n)
-    # - File.foreach counts: 3 lines
-    # - SimpleCov coverage array length: 3
-    # - No adjustment needed
-    #
-    # However, in certain edge cases where the file system or parsing reports an extra line:
-    # - Reported line count: 4
-    # - SimpleCov coverage array length: 3
-    # - Missing trailing newline: true
-    # - Adjustment: 4 - 1 = 3 (now matches)
-    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)
-      # 3. Source has exactly one more line than coverage
-      # 4. File is missing a trailing newline
-      needs_adjusting =
-        exists && cov_len.positive? && src_len == cov_len + 1 && missing_trailing_newline?(file_abs)
-      needs_adjusting ? src_len - 1 : src_len
-    end
-
-    # Checks if the source line count differs from the coverage line count.
-    #
-    # Why this check exists:
-    # - When a file is modified after coverage is generated, the line count often changes
-    # - A mismatch indicates the coverage data is stale and no longer represents the current file
-    # - We only flag as mismatch when coverage data exists (cov_len > 0)
-    #
-    # 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.
-    private def length_mismatch?(cov_len, adjusted_src_len)
-      cov_len.positive? && adjusted_src_len != cov_len
-    end
-
-    # Determines if a file has been modified more recently than the coverage timestamp.
-    #
-    # Why this check exists:
-    # - Files modified after coverage generation may have behavioral changes not captured
-    # - However, if there's already a length mismatch, we prioritize that as the staleness indicator
-    # - This prevents double-flagging: if lines changed, the file is already stale (length mismatch)
-    #
-    # 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
-    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
-      newer
-    end
-  end
-end

data/lib/cov_loupe/table_formatter.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-module CovLoupe
-  # 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/cov_loupe/tools/all_files_coverage_tool.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../model'
-require_relative '../base_tool'
-require_relative '../presenters/project_coverage_presenter'
-
-module CovLoupe
-  module Tools
-    class AllFilesCoverageTool < BaseTool
-      description <<~DESC
-        Use this when the user wants coverage percentages for every tracked file in the project.
-        Do not use this for single-file stats; prefer coverage.summary or coverage.uncovered_lines for that.
-        Inputs: optional project root, alternate .resultset path, sort order, staleness mode, and tracked_globs to alert on new files.
-        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(**coverage_schema(
-        additional_properties: {
-          sort_order: {
-            type: 'string',
-            description: 'Sort order for coverage percentages.' \
-                         "'ascending' highlights the riskiest files first.",
-            default: 'ascending',
-            enum: ['ascending', 'descending']
-          },
-          tracked_globs: TRACKED_GLOBS_PROPERTY
-        }
-      ))
-      class << self
-        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: 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
-  end
-end

data/lib/cov_loupe/util.rb

@@ -1,88 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'resolvers/resolver_factory'
-
-module CovLoupe
-  RESULTSET_CANDIDATES = [
-    '.resultset.json',
-    'coverage/.resultset.json',
-    'tmp/.resultset.json'
-  ].freeze
-
-  DEFAULT_LOG_FILESPEC = './cov_loupe.log'
-
-  module CovUtil
-    module_function def log(msg)
-      log_file = CovLoupe.active_log_file
-
-      case log_file
-      when 'stdout'
-        $stdout.puts "[#{Time.now.iso8601}] #{msg}"
-      when 'stderr'
-        $stderr.puts "[#{Time.now.iso8601}] #{msg}"
-      else
-        # Handles both nil (default) and custom file paths
-        path_to_log = log_file || DEFAULT_LOG_FILESPEC
-        File.open(File.expand_path(path_to_log), 'a') { |f| f.puts "[#{Time.now.iso8601}] #{msg}" }
-      end
-    rescue => e
-      # Fallback to stderr if file logging fails, but suppress in MCP mode
-      # to avoid interfering with JSON-RPC protocol
-      unless CovLoupe.context.mcp_mode?
-        begin
-          $stderr.puts "[#{Time.now.iso8601}] LOGGING ERROR: #{e.message}"
-          $stderr.puts "[#{Time.now.iso8601}] #{msg}"
-        rescue
-          # Silently ignore only stderr fallback failures
-        end
-      end
-    end
-
-    # Safe logging that never raises - use when logging should not interrupt execution.
-    # Unlike `log`, this method guarantees it will never propagate exceptions.
-    module_function def safe_log(msg)
-      log(msg)
-    rescue
-      # Silently ignore all logging failures
-    end
-
-    module_function def find_resultset(root, resultset: nil)
-      Resolvers::ResolverFactory.find_resultset(root, resultset: resultset)
-    end
-
-    module_function def lookup_lines(cov, file_abs)
-      Resolvers::ResolverFactory.lookup_lines(cov, file_abs)
-    end
-
-    module_function def summary(arr)
-      total = 0
-      covered = 0
-      arr.compact.each do |hits|
-        total += 1
-        covered += 1 if hits.to_i > 0
-      end
-      percentage = total.zero? ? 100.0 : ((covered.to_f * 100.0 / total) * 100).round / 100.0
-      { 'covered' => covered, 'total' => total, 'percentage' => percentage }
-    end
-
-    module_function def uncovered(arr)
-      out = []
-
-      arr.each_with_index do |hits, i|
-        next if hits.nil?
-
-        out << (i + 1) if hits.to_i.zero?
-      end
-      out
-    end
-
-    module_function def detailed(arr)
-      rows = []
-      arr.each_with_index do |hits, i|
-        h = hits&.to_i
-        rows << { 'line' => i + 1, 'hits' => h, 'covered' => h.positive? } if h
-      end
-      rows
-    end
-  end
-end

data/spec/MCP_INTEGRATION_TESTS_README.md

@@ -1,111 +0,0 @@
-# MCP Server Protocol Integration Tests
-
-## Overview
-
-This document describes the comprehensive integration tests added for the SimpleCov MCP server protocol in `spec/integration_spec.rb`.
-
-## Test Coverage
-
-The integration tests spawn the actual MCP server as a subprocess and communicate with it via JSON-RPC over stdio, testing the complete end-to-end protocol implementation.
-
-### Tests Added (12 total)
-
-1. **starts MCP server without errors** - Verifies the server starts and responds to basic requests without NameError or other initialization issues
-2. **handles tools/list request** - Confirms all 8 expected tools are properly registered
-3. **executes coverage_summary_tool via JSON-RPC** - Tests single-file coverage summary queries
-4. **executes all_files_coverage_tool via JSON-RPC** - Tests project-wide coverage listing
-5. **executes uncovered_lines_tool via JSON-RPC** - Tests uncovered line detection
-6. **executes help_tool via JSON-RPC** - Tests help/documentation retrieval
-7. **executes version_tool via JSON-RPC** - Tests version information queries
-8. **handles error responses for invalid tool calls** - Verifies graceful error handling
-9. **handles malformed JSON-RPC requests** - Tests robustness against invalid input
-10. **respects --log-file configuration in MCP mode** - Tests logging configuration
-11. **prohibits stdout logging in MCP mode** - Ensures stdout isn't corrupted
-12. **handles multiple sequential requests** - Tests statelessness and multi-request handling
-
-## Why These Tests Are Critical
-
-### Issue #1 from Analysis: Missing `require 'optparse'`
-
-The critical bug (missing `require 'optparse'` in `lib/cov_loupe.rb:110`) was not caught by existing tests because:
-
-- Unit tests loaded the full gem which transitively required optparse through the CLI
-- MCP tools were tested in-process without spawning the server
-- No integration tests verified the MCP server startup sequence
-
-### What These Tests Catch
-
-* ✅ **Server Initialization Errors**: NameError, LoadError, missing requires
-* ✅ **Protocol Compliance**: Valid JSON-RPC request/response format
-* ✅ **Tool Registration**: All tools properly configured and accessible
-* ✅ **Data Accuracy**: Coverage data correctly passed from fixtures
-* ✅ **Error Handling**: Graceful responses for invalid requests
-* ✅ **Configuration**: Environment variables and options properly handled
-* ✅ **Statelessness**: Multiple requests handled independently
-* ✅ **Stream Integrity**: Stdout not corrupted by logging
-
-## Test Architecture
-
-### Helper Methods
-
-- **`run_mcp_request(request_hash, timeout: 5)`**: Spawns MCP server, sends JSON-RPC request, returns stdout/stderr/status
-- **`parse_jsonrpc_response(output)`**: Extracts JSON-RPC response from output (handles mixed stderr/stdout)
-
-### Test Fixtures
-
-Uses `spec/fixtures/project1/` with known coverage data:
-- `lib/foo.rb`: 66.67% coverage (2/3 lines, line 2 uncovered)
-- `lib/bar.rb`: 33.33% coverage (1/3 lines)
-
-### Test Execution
-
-```bash
-# Run all MCP integration tests
-bundle exec rspec spec/integration_spec.rb --tag slow
-
-# Run specific integration test
-bundle exec rspec spec/integration_spec.rb:363
-```
-
-## Performance
-
-- Total execution time: ~2.1 seconds for all 12 tests
-- Tagged with `:slow` to allow exclusion from quick test runs
-- Uses `Open3.popen3` for subprocess management
-- 5-second timeout per request (configurable)
-
-## Coverage Impact
-
-These tests increased the overall test count from 272 to 284 examples and improved confidence in the MCP server mode, which is the primary use case for AI assistant integration.
-
-### Before Integration Tests
-- 272 examples
-- Missing `require 'optparse'` bug went undetected
-- MCP server mode untested end-to-end
-
-### After Integration Tests
-- 284 examples
-- MCP server startup verified
-- Full JSON-RPC protocol tested
-- Would catch Issue #1 immediately
-
-## Future Enhancements
-
-Potential additions:
-- Test connection lifecycle (startup, multiple sessions, shutdown)
-- Test concurrent requests (if supported)
-- Test large coverage datasets (performance)
-- Test network transport (if added)
-- Test authentication/authorization (if added)
-
-## Related Files
-
-- `spec/integration_spec.rb` - Main integration test file (lines 308-683)
-- `lib/cov_loupe.rb` - Entry point with mode detection
-- `lib/cov_loupe/mcp_server.rb` - MCP server implementation
-- `exe/cov-loupe` - Executable entry point
-
-## References
-
-- [MCP Protocol Specification](https://modelcontextprotocol.io/)
-- [JSON-RPC 2.0 Specification](https://www.jsonrpc.org/specification)

data/spec/TIMESTAMPS.md

@@ -1,48 +0,0 @@
-# Test Timestamp Documentation
-
-This document explains the timestamp constants used throughout the test suite for consistent and documented test data.
-
-## Constants (defined in `spec_helper.rb`)
-
-### `FIXTURE_COVERAGE_TIMESTAMP = 1_720_000_000`
-- **Human readable**: 2024-07-03 16:26:40 UTC (July 3rd, 2024)
-- **Purpose**: The "generated" timestamp for coverage data in `spec/fixtures/project1/coverage/.resultset.json`
-- **Usage**: Used in tests that verify timestamp parsing and calculations with realistic coverage data
-
-### `VERY_OLD_TIMESTAMP = 0`
-- **Human readable**: 1970-01-01 00:00:00 UTC (Unix epoch)
-- **Purpose**: Simulates extremely stale coverage data (much older than any real file)
-- **Usage**: Used in staleness tests to force stale coverage scenarios
-
-### `TEST_FILE_TIMESTAMP = 1_000`
-- **Human readable**: 1970-01-01 00:16:40 UTC (16 minutes and 40 seconds after epoch)
-- **Purpose**: Used for stale error formatting tests to create predictable time deltas
-- **Usage**: Creates a 1000-second (16m 40s) difference from `VERY_OLD_TIMESTAMP` for delta calculations
-
-## Conversion Reference
-
-To convert timestamps for debugging:
-
-```bash
-# Unix timestamp to human readable
-date -d @1720000000
-# Wed Jul  3 16:26:40 UTC 2024
-
-# Human readable to Unix timestamp  
-date -d "2024-07-03 16:26:40 UTC" +%s
-# 1720000000
-```
-
-## Why These Values?
-
-- **Realistic but static**: `FIXTURE_COVERAGE_TIMESTAMP` is a realistic recent date that won't change
-- **Predictable deltas**: The differences between timestamps create predictable test scenarios
-- **Clear intent**: Named constants make it obvious what each timestamp represents in tests
-
-## Files Using These Constants
-
-- `spec/util_spec.rb` - Tests timestamp parsing from fixture
-- `spec/model_staleness_spec.rb` - Tests staleness detection logic
-- `spec/errors_stale_spec.rb` - Tests stale error message formatting
-- `spec/cli_error_spec.rb` - Tests CLI error handling for stale coverage
-- `spec/fixtures/project1/coverage/.resultset.json` - Contains the actual timestamp data

data/spec/all_files_coverage_tool_spec.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require 'cov_loupe/tools/all_files_coverage_tool'
-
-RSpec.describe CovLoupe::Tools::AllFilesCoverageTool do
-  subject(:call_tool) { described_class.call(root: root, server_context: server_context) }
-
-  let(:root) { (FIXTURES_DIR / 'project1').to_s }
-  let(:server_context) { instance_double('ServerContext').as_null_object }
-
-  before do
-    setup_mcp_response_stub
-    model = instance_double(CovLoupe::CoverageModel)
-    allow(CovLoupe::CoverageModel).to receive(:new).and_return(model)
-
-    payload = {
-      'files' => [
-        { 'file' => 'lib/foo.rb', 'percentage' => 100.0, 'covered' => 10, 'total' => 10,
-          'stale' => false },
-        { 'file' => 'lib/bar.rb', 'percentage' => 50.0,  'covered' => 5,  'total' => 10,
-          'stale' => true }
-      ],
-      'counts' => { 'total' => 2, 'ok' => 1, 'stale' => 1 }
-    }
-
-    presenter = instance_double(CovLoupe::Presenters::ProjectCoveragePresenter)
-    allow(CovLoupe::Presenters::ProjectCoveragePresenter).to receive(:new).and_return(presenter)
-    allow(presenter).to receive(:relativized_payload).and_return(payload)
-  end
-
-
-  it_behaves_like 'an MCP tool that returns text JSON'
-
-  it 'returns all files coverage data with counts' do
-    response = call_tool
-    data, _item = expect_mcp_text_json(response, expected_keys: ['files', 'counts'])
-
-    files = data['files']
-    counts = data['counts']
-
-    expect(files.length).to eq(2)
-    expect(counts).to include('total' => 2).or include(total: 2)
-    expect(files.map { |f| f['file'] }).to eq(['lib/foo.rb', 'lib/bar.rb'])
-
-    # ok + stale equals total
-    ok = counts[:ok] || counts['ok']
-    stale = counts[:stale] || counts['stale']
-    total = counts[:total] || counts['total']
-    expect(ok + stale).to eq(total)
-    expect(stale).to eq(1)
-  end
-end