simplecov-mcp 0.1.0 → 0.2.0

data/spec/model_staleness_spec.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SimpleCovMcp::CoverageModel do
+  let(:root) { (FIXTURES / 'project1').to_s }
+  
+  def with_stubbed_coverage_timestamp(ts) = begin
+    allow(SimpleCovMcp::CovUtil).to receive(:latest_timestamp).and_return(ts)
+    yield
+  end
+
+  it "raises stale error when staleness mode is 'error' and file is newer" do
+    with_stubbed_coverage_timestamp(0) do
+      model = described_class.new(root: root, staleness: 'error')
+      expect {
+        model.summary_for('lib/foo.rb')
+      }.to raise_error(SimpleCovMcp::CoverageDataStaleError, /stale/i)
+    end
+  end
+
+  it "does not check staleness when mode is 'off'" do
+    with_stubbed_coverage_timestamp(0) do
+      model = described_class.new(root: root, staleness: 'off')
+      expect { model.summary_for('lib/foo.rb') }.not_to raise_error
+    end
+  end
+  it 'all_files raises project-level stale when any source file is newer than coverage' do
+    with_stubbed_coverage_timestamp(0) do
+      model = described_class.new(root: root, staleness: 'error')
+      expect { model.all_files }.to raise_error(SimpleCovMcp::CoverageDataProjectStaleError)
+    end
+  end
+
+  it 'all_files detects new files via tracked_globs' do
+    with_stubbed_coverage_timestamp(Time.now.to_i) do
+      tmp = File.join(root, 'lib', 'brand_new_file.rb')
+      begin
+        File.write(tmp, "# new file\n")
+        model = described_class.new(root: root, staleness: 'error')
+        expect {
+          model.all_files(tracked_globs: ['lib/**/*.rb'])
+        }.to raise_error(SimpleCovMcp::CoverageDataProjectStaleError)
+      ensure
+        File.delete(tmp) if File.exist?(tmp)
+      end
+    end
+  end
+end

data/spec/simplecov_mcp_model_spec.rb

@@ -1,54 +1,73 @@
 # frozen_string_literal: true
 
-require "spec_helper"
+require 'spec_helper'
 
-RSpec.describe Simplecov::Mcp::CoverageModel do
-  let(:root)  { (FIXTURES / "project1").to_s }
+RSpec.describe SimpleCovMcp::CoverageModel do
+  let(:root)  { (FIXTURES / 'project1').to_s }
   subject(:model) { described_class.new(root: root) }
 
-  describe "raw_for" do
-    it "returns absolute file and lines array" do
-      data = model.raw_for("lib/foo.rb")
-      expect(data[:file]).to eq(File.expand_path("lib/foo.rb", root))
-      expect(data[:lines]).to eq([1, 0, nil, 2])
+  describe 'raw_for' do
+    it 'returns absolute file and lines array' do
+      data = model.raw_for('lib/foo.rb')
+      expect(data['file']).to eq(File.expand_path('lib/foo.rb', root))
+      expect(data['lines']).to eq([1, 0, nil, 2])
     end
   end
 
-  describe "summary_for" do
-    it "computes covered/total/pct" do
-      data = model.summary_for("lib/foo.rb")
-      expect(data[:summary]["total"]).to eq(3)
-      expect(data[:summary]["covered"]).to eq(2)
-      expect(data[:summary]["pct"]).to be_within(0.01).of(66.67)
+  describe 'summary_for' do
+    it 'computes covered/total/pct' do
+      data = model.summary_for('lib/foo.rb')
+      expect(data['summary']['total']).to eq(3)
+      expect(data['summary']['covered']).to eq(2)
+      expect(data['summary']['pct']).to be_within(0.01).of(66.67)
     end
   end
 
-  describe "uncovered_for" do
-    it "lists uncovered executable line numbers" do
-      data = model.uncovered_for("lib/foo.rb")
-      expect(data[:uncovered]).to eq([2])
-      expect(data[:summary]["total"]).to eq(3)
+  describe 'uncovered_for' do
+    it 'lists uncovered executable line numbers' do
+      data = model.uncovered_for('lib/foo.rb')
+      expect(data['uncovered']).to eq([2])
+      expect(data['summary']['total']).to eq(3)
     end
   end
 
-  describe "detailed_for" do
-    it "returns per-line details for non-nil lines" do
-      data = model.detailed_for("lib/foo.rb")
-      expect(data[:lines]).to eq([
-        { line: 1, hits: 1, covered: true },
-        { line: 2, hits: 0, covered: false },
-        { line: 4, hits: 2, covered: true }
+  describe 'detailed_for' do
+    it 'returns per-line details for non-nil lines' do
+      data = model.detailed_for('lib/foo.rb')
+      expect(data['lines']).to eq([
+        { 'line' => 1, 'hits' => 1, 'covered' => true },
+        { 'line' => 2, 'hits' => 0, 'covered' => false },
+        { 'line' => 4, 'hits' => 2, 'covered' => true }
       ])
     end
   end
 
-  describe "all_files" do
-    it "sorts ascending by percentage then by file path" do
+  describe 'all_files' do
+    it 'sorts ascending by percentage then by file path' do
       files = model.all_files(sort_order: :ascending)
-      expect(files.first[:file]).to eq(File.expand_path("lib/bar.rb", root))
-      expect(files.first[:percentage]).to be_within(0.01).of(33.33)
-      expect(files.last[:file]).to eq(File.expand_path("lib/foo.rb", root))
+      expect(files.first['file']).to eq(File.expand_path('lib/bar.rb', root))
+      expect(files.first['percentage']).to be_within(0.01).of(33.33)
+      expect(files.last['file']).to eq(File.expand_path('lib/foo.rb', root))
     end
   end
-end
 
+  describe 'resultset directory handling' do
+    it 'accepts a directory containing .resultset.json' do
+      model = described_class.new(root: root, resultset: 'coverage')
+      data = model.summary_for('lib/foo.rb')
+      expect(data['summary']['total']).to eq(3)
+      expect(data['summary']['covered']).to eq(2)
+    end
+
+    it 'uses SIMPLECOV_RESULTSET when it is a directory' do
+      begin
+        ENV['SIMPLECOV_RESULTSET'] = 'coverage'
+        model = described_class.new(root: root)
+        data = model.summary_for('lib/foo.rb')
+        expect(data['summary']['covered']).to eq(2)
+      ensure
+        ENV.delete('SIMPLECOV_RESULTSET')
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -1,19 +1,49 @@
 # frozen_string_literal: true
 
-ENV.delete("SIMPLECOV_RESULTSET")
+# Enable SimpleCov for this project (coverage output in ./coverage)
+begin
+  require 'simplecov'
+  SimpleCov.start do
+    enable_coverage :branch if SimpleCov.respond_to?(:enable_coverage)
+    add_filter %r{^/spec/}
+    track_files 'lib/**/*.rb'
+  end
+rescue LoadError
+  warn 'SimpleCov not available; skipping coverage'
+end
+
+ENV.delete('SIMPLECOV_RESULTSET')
 
-require "rspec"
-require "pathname"
-require "json"
+require 'rspec'
+require 'pathname'
+require 'json'
 
-require "simplecov/mcp"
+require 'simple_cov_mcp'
 
-FIXTURES = Pathname.new(File.expand_path("fixtures", __dir__))
+FIXTURES = Pathname.new(File.expand_path('fixtures', __dir__))
 
 RSpec.configure do |config|
-  config.example_status_persistence_file_path = ".rspec_status"
+  config.example_status_persistence_file_path = '.rspec_status'
   config.disable_monkey_patching!
   config.order = :random
   Kernel.srand config.seed
 end
 
+# Shared test helpers
+module TestIOHelpers
+  # Suppress stdout/stderr within the given block, yielding the StringIOs
+  def silence_output
+    original_stdout = $stdout
+    original_stderr = $stderr
+    $stdout = StringIO.new
+    $stderr = StringIO.new
+    yield $stdout, $stderr
+  ensure
+    $stdout = original_stdout
+    $stderr = original_stderr
+  end
+end
+
+RSpec.configure do |config|
+  config.include TestIOHelpers
+end

data/spec/staleness_more_spec.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe 'Additional staleness cases' do
+  let(:root) { (FIXTURES / 'project1').to_s }
+
+  describe SimpleCovMcp::CoverageModel do
+    it 'raises file-level stale when source and coverage lengths differ' do
+      # Ensure time is not the triggering factor
+      allow(SimpleCovMcp::CovUtil).to receive(:latest_timestamp).and_return(Time.now.to_i)
+      model = SimpleCovMcp::CoverageModel.new(root: root, resultset: 'coverage', staleness: 'error')
+      # bar.rb has 3 coverage entries but 4 source lines in fixtures
+      expect {
+        model.summary_for('lib/bar.rb')
+      }.to raise_error(SimpleCovMcp::CoverageDataStaleError, /stale/i)
+    end
+  end
+
+  describe SimpleCovMcp::StalenessChecker do
+    it 'flags deleted files present only in coverage' do
+      checker = described_class.new(root: root, resultset: 'coverage', mode: 'error')
+      coverage_map = {
+        File.join(root, 'lib', 'does_not_exist_anymore.rb') => { 'lines' => [1] }
+      }
+      expect {
+        checker.check_project!(coverage_map)
+      }.to raise_error(SimpleCovMcp::CoverageDataProjectStaleError)
+    end
+
+    it 'does not raise for empty tracked_globs when nothing else is stale' do
+      allow(SimpleCovMcp::CovUtil).to receive(:latest_timestamp).and_return(Time.now.to_i)
+      checker = described_class.new(root: root, resultset: 'coverage', mode: 'error', tracked_globs: [])
+      expect {
+        checker.check_project!({})
+      }.not_to raise_error
+    end
+  end
+end

data/spec/util_spec.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe SimpleCovMcp::CovUtil do
+  let(:root) { (FIXTURES / 'project1').to_s }
+  let(:resultset_file) { File.join(root, 'coverage', '.resultset.json') }
+
+  it 'latest_timestamp returns integer from fixture' do
+    ts = described_class.latest_timestamp(root, resultset: 'coverage')
+    expect(ts).to be_a(Integer)
+    expect(ts).to eq(1_720_000_000)
+  end
+
+  it 'find_resultset honors SIMPLECOV_RESULTSET file path' do
+    begin
+      ENV['SIMPLECOV_RESULTSET'] = resultset_file
+      path = described_class.find_resultset(root)
+      expect(path).to eq(File.absolute_path(resultset_file, root))
+    ensure
+      ENV.delete('SIMPLECOV_RESULTSET')
+    end
+  end
+
+  it 'lookup_lines supports cwd-stripping and basename fallbacks' do
+    lines = [1, 0]
+
+    # Exact key
+    cov = { '/abs/path/foo.rb' => { 'lines' => lines } }
+    expect(described_class.lookup_lines(cov, '/abs/path/foo.rb')).to eq(lines)
+
+    # CWD strip fallback
+    begin
+      allow(Dir).to receive(:pwd).and_return('/cwd')
+      cov = { 'sub/foo.rb' => { 'lines' => lines } }
+      expect(described_class.lookup_lines(cov, '/cwd/sub/foo.rb')).to eq(lines)
+    ensure
+      # no-op
+    end
+
+    # Basename fallback
+    cov = { '/some/where/else/foo.rb' => { 'lines' => lines } }
+    expect(described_class.lookup_lines(cov, '/another/place/foo.rb')).to eq(lines)
+
+    # Missing raises a helpful string error
+    cov = {}
+    expect {
+      described_class.lookup_lines(cov, '/nowhere/foo.rb')
+    }.to raise_error(RuntimeError, /No coverage entry found/)
+  end
+
+  it 'summary handles edge cases and coercion' do
+    expect(described_class.summary([])).to include('pct' => 100.0, 'total' => 0, 'covered' => 0)
+    expect(described_class.summary([nil, nil])).to include('pct' => 100.0, 'total' => 0, 'covered' => 0)
+    expect(described_class.summary(['1', '0', nil])).to include('pct' => 50.0, 'total' => 2, 'covered' => 1)
+  end
+
+  it 'uncovered and detailed ignore nils' do
+    arr = [1, 0, nil, 2]
+    expect(described_class.uncovered(arr)).to eq([2])
+    expect(described_class.detailed(arr)).to eq([
+      { 'line' => 1, 'hits' => 1, 'covered' => true },
+      { 'line' => 2, 'hits' => 0, 'covered' => false },
+      { 'line' => 4, 'hits' => 2, 'covered' => true }
+    ])
+  end
+
+  it 'load_latest_coverage raises CoverageDataError on invalid JSON via model' do
+    Dir.mktmpdir do |dir|
+      bad = File.join(dir, '.resultset.json')
+      File.write(bad, '{not-json')
+      expect {
+        SimpleCovMcp::CoverageModel.new(root: root, resultset: dir)
+      }.to raise_error(SimpleCovMcp::CoverageDataError, /Invalid coverage data format/)
+    end
+  end
+end
+

data/spec/version_spec.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe 'Version constant' do
+  it 'exposes a semver-like version string' do
+    expect(SimpleCovMcp::VERSION).to be_a(String)
+    expect(SimpleCovMcp::VERSION).to match(/\A\d+\.\d+\.\d+(?:[.-][0-9A-Za-z]+)?\z/)
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: simplecov-mcp
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Keith R. Bennett
@@ -57,6 +57,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.21'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.21'
 description: Provides an MCP (Model Context Protocol) server and a CLI to inspect
   SimpleCov coverage, including per-file summaries and uncovered lines.
 email:
@@ -68,20 +82,49 @@ extra_rdoc_files: []
 files:
 - README.md
 - exe/simplecov-mcp
-- lib/simplecov/mcp.rb
-- lib/simplecov/mcp/base_tool.rb
-- lib/simplecov/mcp/cli.rb
-- lib/simplecov/mcp/model.rb
-- lib/simplecov/mcp/tools/all_files_coverage.rb
-- lib/simplecov/mcp/tools/coverage_detailed.rb
-- lib/simplecov/mcp/tools/coverage_raw.rb
-- lib/simplecov/mcp/tools/coverage_summary.rb
-- lib/simplecov/mcp/tools/uncovered_lines.rb
-- lib/simplecov/mcp/util.rb
-- lib/simplecov/mcp/version.rb
+- lib/simple_cov/mcp.rb
+- lib/simple_cov_mcp.rb
+- lib/simple_cov_mcp/base_tool.rb
+- lib/simple_cov_mcp/cli.rb
+- lib/simple_cov_mcp/error_handler.rb
+- lib/simple_cov_mcp/error_handler_factory.rb
+- lib/simple_cov_mcp/errors.rb
+- lib/simple_cov_mcp/mcp_server.rb
+- lib/simple_cov_mcp/model.rb
+- lib/simple_cov_mcp/staleness_checker.rb
+- lib/simple_cov_mcp/tools/all_files_coverage_tool.rb
+- lib/simple_cov_mcp/tools/coverage_detailed_tool.rb
+- lib/simple_cov_mcp/tools/coverage_raw_tool.rb
+- lib/simple_cov_mcp/tools/coverage_summary_tool.rb
+- lib/simple_cov_mcp/tools/coverage_table_tool.rb
+- lib/simple_cov_mcp/tools/help_tool.rb
+- lib/simple_cov_mcp/tools/uncovered_lines_tool.rb
+- lib/simple_cov_mcp/tools/version_tool.rb
+- lib/simple_cov_mcp/util.rb
+- lib/simple_cov_mcp/version.rb
 - lib/simplecov_mcp.rb
+- spec/all_files_coverage_tool_spec.rb
+- spec/base_tool_spec.rb
+- spec/cli_error_spec.rb
+- spec/cli_json_source_spec.rb
+- spec/cli_source_spec.rb
+- spec/cli_spec.rb
+- spec/cli_table_spec.rb
+- spec/cli_usage_spec.rb
+- spec/coverage_table_tool_spec.rb
+- spec/error_handler_spec.rb
+- spec/errors_stale_spec.rb
+- spec/fixtures/project1/lib/bar.rb
+- spec/fixtures/project1/lib/foo.rb
+- spec/help_tool_spec.rb
+- spec/legacy_shim_spec.rb
+- spec/mcp_server_spec.rb
+- spec/model_staleness_spec.rb
 - spec/simplecov_mcp_model_spec.rb
 - spec/spec_helper.rb
+- spec/staleness_more_spec.rb
+- spec/util_spec.rb
+- spec/version_spec.rb
 homepage: https://github.com/keithrbennett/simplecov-mcp
 licenses:
 - MIT
@@ -100,7 +143,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.7.1
+rubygems_version: 3.7.2
 specification_version: 4
 summary: MCP server + CLI for SimpleCov coverage data
 test_files: []

data/lib/simplecov/mcp/base_tool.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-module Simplecov
-  module Mcp
-    class BaseTool < ::MCP::Tool
-      INPUT_SCHEMA = {
-        type: "object",
-        properties: {
-          path: { type: "string", description: "Absolute or project-relative file path" },
-          root: { type: "string", description: "Project root for resolution", default: "." }
-        },
-        required: ["path"]
-      }
-      def self.input_schema_def = INPUT_SCHEMA
-    end
-  end
-end
-

data/lib/simplecov/mcp/cli.rb

@@ -1,98 +0,0 @@
-# frozen_string_literal: true
-
-module Simplecov
-  module Mcp
-    class CoverageCLI
-      def initialize
-        @root = "."
-      end
-
-      def run(argv)
-        if force_cli?(argv)
-          show_default_report
-        else
-          run_mcp_server
-        end
-      rescue => e
-        CovUtil.log("CLI fatal error: #{e.class}: #{e.message}\n#{e.backtrace&.join("\n")}")
-        raise
-      end
-
-      private
-
-      def force_cli?(argv)
-        return true  if ENV["COVERAGE_MCP_CLI"] == "1"
-        return true  if argv.include?("--cli") || argv.include?("--report")
-        # If interactive TTY, prefer CLI; else (e.g., pipes), run MCP.
-        return STDIN.tty?
-      end
-
-      def show_default_report
-        model = CoverageModel.new(root: @root)
-        file_summaries = model.all_files(sort_order: :ascending).map do |row|
-          row.dup.tap do |h|
-            h[:file] = Pathname.new(h[:file]).relative_path_from(Pathname.new(Dir.pwd)).to_s
-          end
-        end
-
-        # Format as table with box-style borders
-        max_file_length = file_summaries.map { |f| f[:file].length }.max.to_i
-        max_file_length = [max_file_length, "File".length].max
-
-        # Calculate maximum numeric values for proper column widths
-        max_covered = file_summaries.map { |f| f[:covered].to_s.length }.max
-        max_total = file_summaries.map { |f| f[:total].to_s.length }.max
-
-        # Define column widths
-        file_width = max_file_length + 2  # Extra padding
-        pct_width = 8
-        covered_width = [max_covered, "Covered".length].max + 2
-        total_width = [max_total, "Total".length].max + 2
-
-        # Horizontal line for each column span
-        h_line = ->(col_width) { '─' * (col_width + 2) }
-
-        # Border line lambda
-        border_line = ->(left, middle, right) {
-          left   + h_line.(file_width) +
-          middle + h_line.(pct_width) +
-          middle + h_line.(covered_width) +
-          middle + h_line.(total_width) +
-          right
-        }
-
-        # Top border
-        puts border_line.call("┌", "┬", "┐")
-
-        # Header row
-        printf "│ %-#{file_width}s │ %#{pct_width}s │ %#{covered_width}s │ %#{total_width}s │\n",
-               "File", " %", "Covered", "Total"
-
-        # Header separator
-        puts border_line.call("├", "┼", "┤")
-
-        # Data rows
-        file_summaries.each do |file_data|
-          printf "│ %-#{file_width}s │ %#{pct_width - 1}.2f%% │ %#{covered_width}d │ %#{total_width}d │\n",
-                 file_data[:file],
-                 file_data[:percentage],
-                 file_data[:covered],
-                 file_data[:total]
-        end
-
-        # Bottom border
-        puts border_line.call("└", "┴", "┘")
-      end
-
-      def run_mcp_server
-        server = ::MCP::Server.new(
-          name:    "ruby_coverage_server",
-          version: Simplecov::Mcp::VERSION,
-          tools:   [CoverageRaw, CoverageSummary, UncoveredLines, CoverageDetailed, AllFilesCoverage]
-        )
-        ::MCP::Server::Transports::StdioTransport.new(server).open
-      end
-    end
-  end
-end
-

data/lib/simplecov/mcp/model.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-module Simplecov
-  module Mcp
-    class CoverageModel
-      def initialize(root: ".")
-        @root = File.absolute_path(root || ".")
-        @cov  = CovUtil.load_latest_coverage(@root)
-      end
-
-      # Returns { file: <abs>, lines: [hits|nil,...] }
-      def raw_for(path)
-        abs, arr = resolve(path)
-        { file: abs, lines: arr }
-      end
-
-      # Returns { file: <abs>, summary: {"covered"=>, "total"=>, "pct"=>} }
-      def summary_for(path)
-        abs, arr = resolve(path)
-        { file: abs, summary: CovUtil.summary(arr) }
-      end
-
-      # Returns { file: <abs>, uncovered: [line,...], summary: {...} }
-      def uncovered_for(path)
-        abs, arr = resolve(path)
-        { file: abs, uncovered: CovUtil.uncovered(arr), summary: CovUtil.summary(arr) }
-      end
-
-      # Returns { file: <abs>, lines: [{line:,hits:,covered:},...], summary: {...} }
-      def detailed_for(path)
-        abs, arr = resolve(path)
-        { file: abs, lines: CovUtil.detailed(arr), summary: CovUtil.summary(arr) }
-      end
-
-      # Returns [ { file:, covered:, total:, percentage: }, ... ]
-      def all_files(sort_order: :ascending)
-        rows = @cov.map do |abs_path, data|
-          next unless data["lines"].is_a?(Array)
-          s = CovUtil.summary(data["lines"])
-          { file: abs_path, covered: s["covered"], total: s["total"], percentage: s["pct"] }
-        end.compact
-
-        rows.sort! do |a, b|
-          pct_cmp = (sort_order.to_s == "descending") ? (b[:percentage] <=> a[:percentage]) : (a[:percentage] <=> b[:percentage])
-          pct_cmp == 0 ? (a[:file] <=> b[:file]) : pct_cmp
-        end
-        rows
-      end
-
-      private
-
-      def resolve(path)
-        abs = File.absolute_path(path, @root)
-        [abs, CovUtil.lookup_lines(@cov, abs)]
-      end
-    end
-  end
-end
-

data/lib/simplecov/mcp/tools/all_files_coverage.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-module Simplecov
-  module Mcp
-    class AllFilesCoverage < ::MCP::Tool
-      description "Return coverage percentage for all files in the project"
-      input_schema(
-        type: "object",
-        properties: {
-          root: { type: "string", description: "Project root for resolution", default: "." },
-          sort_order: { type: "string", description: "Sort order for coverage percentage: ascending or descending", default: "ascending", enum: ["ascending", "descending"] }
-        }
-      )
-      class << self
-        def call(root: ".", sort_order: "ascending", server_context:)
-          model = CoverageModel.new(root: root)
-          files = model.all_files(sort_order: sort_order)
-          ::MCP::Tool::Response.new([{ type: "json", json: { files: files } }],
-                              meta: { mimeType: "application/json" })
-        rescue => e
-          CovUtil.log("AllFilesCoverage error: #{e.class}: #{e.message}")
-          ::MCP::Tool::Response.new([{ type: "text", text: "Error: #{e.class}: #{e.message}" }])
-        end
-      end
-    end
-  end
-end
-

data/lib/simplecov/mcp/tools/coverage_detailed.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-module Simplecov
-  module Mcp
-    class CoverageDetailed < BaseTool
-      description "Verbose per-line objects [{line,hits,covered}] (token-heavy)"
-      input_schema(**input_schema_def)
-      class << self
-        def call(path:, root: ".", server_context:)
-          model = CoverageModel.new(root: root)
-          data = model.detailed_for(path)
-          ::MCP::Tool::Response.new([{ type: "json", json: data }],
-                              meta: { mimeType: "application/json" })
-        rescue => e
-          CovUtil.log("CoverageDetailed error: #{e.class}: #{e.message}")
-          ::MCP::Tool::Response.new([{ type: "text", text: "Error: #{e.class}: #{e.message}" }])
-        end
-      end
-    end
-  end
-end
-