simplecov-mcp 0.3.0 → 1.0.0

data/lib/simplecov_mcp/staleness_checker.rb

@@ -0,0 +1,243 @@
+# frozen_string_literal: true
+
+require 'time'
+require 'json'
+require 'pathname'
+require 'set'
+require_relative 'errors'
+require_relative 'util'
+
+module SimpleCovMcp
+  # 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
+      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
+
+      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
+    end
+
+    private
+
+    def coverage_timestamp
+      @cov_timestamp || 0
+    end
+
+    def resultset_path
+      @resultset_path ||= CovUtil.find_resultset(@root, resultset: @resultset)
+    rescue StandardError
+      nil
+    end
+
+    def safe_count_lines(path)
+      return 0 unless File.file?(path)
+
+      File.foreach(path).count
+    rescue StandardError
+      0
+    end
+
+    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 StandardError
+      false
+    end
+
+    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
+    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 = check_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)
+    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.
+    def check_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
+    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/{simple_cov_mcp → simplecov_mcp}/tools/all_files_coverage_tool.rb

@@ -2,6 +2,7 @@
 
 require_relative '../model'
 require_relative '../base_tool'
+require_relative '../presenters/project_coverage_presenter'
 
 module SimpleCovMcp
   module Tools
@@ -10,7 +11,7 @@ module SimpleCovMcp
         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 boolean.
+        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(
@@ -28,34 +29,51 @@ module SimpleCovMcp
           },
           sort_order: {
             type: 'string',
-            description: "Sort order for coverage percentages. 'ascending' highlights the riskiest files first.",
+            description: 'Sort order for coverage percentages.' \
+                         "'ascending' highlights the riskiest files first.",
             default: 'ascending',
             enum: ['ascending', 'descending']
           },
           stale: {
             type: 'string',
-            description: "How to handle missing/outdated coverage data. 'off' skips checks; 'error' raises.",
+            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).',
+            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'
           }
         }
       )
       class << self
-        def call(root: '.', resultset: nil, sort_order: 'ascending', stale: 'off', tracked_globs: nil, server_context:)
-          model = CoverageModel.new(root: root, resultset: resultset, staleness: stale, tracked_globs: tracked_globs)
-          files = model.all_files(sort_order: sort_order, check_stale: (stale.to_s == 'error'), tracked_globs: tracked_globs)
-          total = files.length
-          stale_count = files.count { |f| f['stale'] }
-          ok_count = total - stale_count
-          payload = { files: files, counts: { total: total, ok: ok_count, stale: stale_count } }
-          respond_json(payload, name: 'all_files_coverage.json')
+        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
+
+          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')
+          handle_mcp_error(e, 'AllFilesCoverageTool', error_mode: error_mode)
         end
       end
     end

data/lib/{simple_cov_mcp → simplecov_mcp}/tools/coverage_detailed_tool.rb

@@ -2,6 +2,7 @@
 
 require_relative '../base_tool'
 require_relative '../model'
+require_relative '../presenters/coverage_detailed_presenter'
 
 module SimpleCovMcp
   module Tools
@@ -10,18 +11,17 @@ module SimpleCovMcp
         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.
-        Output: JSON object with "file", "lines" => [{"line": 12, "hits": 0, "covered": false}], plus "summary" with totals.
+        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', server_context:)
-          mode = stale
-          model = CoverageModel.new(root: root, resultset: resultset, staleness: mode)
-          data = model.detailed_for(path)
-          respond_json(data, name: 'coverage_detailed.json', pretty: true)
+        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')
+          handle_mcp_error(e, 'CoverageDetailedTool', error_mode: error_mode)
         end
       end
     end

data/lib/{simple_cov_mcp → simplecov_mcp}/tools/coverage_raw_tool.rb

@@ -2,6 +2,7 @@
 
 require_relative '../base_tool'
 require_relative '../model'
+require_relative '../presenters/coverage_raw_presenter'
 
 module SimpleCovMcp
   module Tools
@@ -10,18 +11,17 @@ module SimpleCovMcp
         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.
-        Output: JSON object with "file" and "lines" (array of integers/nulls) mirroring SimpleCov's native structure.
+        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', server_context:)
-          mode = stale
-          model = CoverageModel.new(root: root, resultset: resultset, staleness: mode)
-          data = model.raw_for(path)
-          respond_json(data, name: 'coverage_raw.json', pretty: true)
+        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')
+          handle_mcp_error(e, 'CoverageRawTool', error_mode: error_mode)
         end
       end
     end

data/lib/{simple_cov_mcp → simplecov_mcp}/tools/coverage_summary_tool.rb

@@ -2,6 +2,7 @@
 
 require_relative '../base_tool'
 require_relative '../model'
+require_relative '../presenters/coverage_summary_presenter'
 
 module SimpleCovMcp
   module Tools
@@ -10,18 +11,17 @@ module SimpleCovMcp
         Use this when the user asks for the covered/total line counts and percentage for a specific file.
         Do not use this for multi-file reports; coverage.all_files or coverage.table handle those.
         Inputs: file path (required) plus optional root/resultset/stale mode inherited from BaseTool.
-        Output: JSON object {"file": String, "summary": {"covered": Integer, "total": Integer, "pct": Float}}.
+        Output: JSON object {"file": String, "summary": {"covered": Integer, "total": Integer, "pct": Float}, "stale": String|False}.
         Examples: "What is the coverage for lib/simple_cov_mcp/tools/all_files_coverage_tool.rb?".
       DESC
       input_schema(**input_schema_def)
       class << self
-        def call(path:, root: '.', resultset: nil, stale: 'off', server_context:)
-          mode = stale
-          model = CoverageModel.new(root: root, resultset: resultset, staleness: mode)
-          data = model.summary_for(path)
-          respond_json(data, name: 'coverage_summary.json', pretty: true)
+        def call(path:, root: '.', resultset: nil, stale: 'off', error_mode: 'on', server_context:)
+          model = CoverageModel.new(root: root, resultset: resultset, staleness: stale)
+          presenter = Presenters::CoverageSummaryPresenter.new(model: model, path: path)
+          respond_json(presenter.relativized_payload, name: 'coverage_summary.json', pretty: true)
         rescue => e
-          handle_mcp_error(e, 'CoverageSummaryTool')
+          handle_mcp_error(e, 'CoverageSummaryTool', error_mode: error_mode)
         end
       end
     end

data/lib/simplecov_mcp/tools/coverage_table_tool.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+
+require_relative '../base_tool'
+require_relative '../presenters/project_coverage_presenter'
+
+module SimpleCovMcp
+  module Tools
+    class CoverageTableTool < BaseTool
+      description <<~DESC
+        Use this when a user wants the plain text coverage table exactly like `simplecov-mcp --table` would print (no ANSI colors).
+        Do not use this for machine-readable data; coverage.all_files returns structured JSON.
+        Inputs: optional project root/resultset path/sort order/staleness mode matching the CLI flags.
+        Output: text block containing the formatted coverage table with headers and percentages.
+        Example: "Show me the CLI coverage table 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.'
+          },
+          sort_order: {
+            type: 'string',
+            description: 'Sort order for the printed coverage table (ascending or descending).',
+            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'
+          }
+        }
+      )
+
+      class << self
+        def call(root: '.', resultset: nil, sort_order: 'ascending', stale: 'off',
+          tracked_globs: nil, error_mode: 'on', server_context:)
+          # Capture the output of the CLI's table report while honoring CLI options
+          # Convert string inputs from MCP to symbols for internal use
+          sort_order_sym = sort_order.to_sym
+          stale_sym = stale.to_sym
+          check_stale = (stale_sym == :error)
+
+          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: check_stale,
+            tracked_globs: tracked_globs
+          )
+          relativized = presenter.relative_files
+          table = model.format_table(
+            relativized,
+            sort_order: sort_order_sym,
+            check_stale: check_stale,
+            tracked_globs: nil # rows already filtered via all_files
+          )
+          ::MCP::Tool::Response.new([{ type: 'text', text: table }])
+        rescue => e
+          handle_mcp_error(e, 'CoverageTableTool', error_mode: error_mode)
+        end
+      end
+    end
+  end
+end

data/lib/{simple_cov_mcp → simplecov_mcp}/tools/help_tool.rb

@@ -9,7 +9,8 @@ module SimpleCovMcp
         Use this when you are unsure which simplecov-mcp tool fits the user’s coverage request.
         Do not use this once you know the correct tool; call that tool directly.
         Inputs: optional query string to filter the list of tools.
-        Output: JSON {"tools": [...]} with per-tool "use_when", "avoid_when", "inputs", and "example" guidance.
+        Output: JSON {"tools": [...]} with per-tool "use_when", "avoid_when", "inputs",#{' '}
+          and "example" guidance.
         Example: "Which tool shows uncovered lines?".
       DESC
 
@@ -19,7 +20,15 @@ module SimpleCovMcp
         properties: {
           query: {
             type: 'string',
-            description: 'Optional keywords to filter the help entries (e.g., "uncovered", "summary").'
+            description:
+              'Optional keywords to filter the help entries (e.g., "uncovered", "summary").'
+          },
+          error_mode: {
+            type: 'string',
+            description:
+              "Error handling mode: 'off' (silent), 'on' (log errors), 'trace' (verbose).",
+            enum: ['off', 'on', 'trace'],
+            default: 'on'
           }
         }
       )
@@ -84,14 +93,14 @@ module SimpleCovMcp
       ].freeze
 
       class << self
-        def call(query: nil, server_context:, **_unused)
+        def call(query: nil, error_mode: 'on', server_context:, **_unused)
           entries = TOOL_GUIDE.map { |guide| format_entry(guide) }
           entries = filter_entries(entries, query) if query && !query.strip.empty?
 
           data = { query: query, tools: entries }
           respond_json(data, name: 'tools_help.json')
         rescue => e
-          handle_mcp_error(e, 'HelpTool')
+          handle_mcp_error(e, 'HelpTool', error_mode: error_mode)
         end
 
         private

data/lib/{simple_cov_mcp → simplecov_mcp}/tools/uncovered_lines_tool.rb

@@ -2,6 +2,7 @@
 
 require_relative '../base_tool'
 require_relative '../model'
+require_relative '../presenters/coverage_uncovered_presenter'
 
 module SimpleCovMcp
   module Tools
@@ -10,18 +11,17 @@ module SimpleCovMcp
         Use this when the user wants to know which lines in a file still lack coverage.
         Do not use this for overall percentages; coverage.summary is faster when counts are enough.
         Inputs: file path (required) plus optional root/resultset/stale mode inherited from BaseTool.
-        Output: JSON object with keys "file", "uncovered" (array of integers), and "summary" {"covered","total","pct"}.
+        Output: JSON object with keys "file", "uncovered" (array of integers), "summary" {"covered","total","pct"}, and "stale" status.
         Example: "List uncovered lines for lib/simple_cov_mcp/tools/coverage_summary_tool.rb".
       DESC
       input_schema(**input_schema_def)
       class << self
-        def call(path:, root: '.', resultset: nil, stale: 'off', server_context:)
-          mode = stale
-          model = CoverageModel.new(root: root, resultset: resultset, staleness: mode)
-          data = model.uncovered_for(path)
-          respond_json(data, name: 'uncovered_lines.json', pretty: true)
+        def call(path:, root: '.', resultset: nil, stale: 'off', error_mode: 'on', server_context:)
+          model = CoverageModel.new(root: root, resultset: resultset, staleness: stale)
+          presenter = Presenters::CoverageUncoveredPresenter.new(model: model, path: path)
+          respond_json(presenter.relativized_payload, name: 'uncovered_lines.json', pretty: true)
         rescue => e
-          handle_mcp_error(e, 'UncoveredLinesTool')
+          handle_mcp_error(e, 'UncoveredLinesTool', error_mode: error_mode)
         end
       end
     end

data/lib/{simple_cov_mcp → simplecov_mcp}/tools/version_tool.rb

@@ -14,16 +14,24 @@ module SimpleCovMcp
       input_schema(
         type: 'object',
         additionalProperties: false,
-        properties: {}
+        properties: {
+          error_mode: {
+            type: 'string',
+            description:
+              "Error handling mode: 'off' (silent), 'on' (log errors), 'trace' (verbose).",
+            enum: ['off', 'on', 'trace'],
+            default: 'on'
+          }
+        }
       )
 
       class << self
-        def call(server_context: nil, **_args)
+        def call(error_mode: 'on', server_context: nil, **_args)
           ::MCP::Tool::Response.new([
             { type: 'text', text: "SimpleCovMcp version: #{SimpleCovMcp::VERSION}" }
           ])
         rescue => error
-          handle_mcp_error(error, 'version_tool')
+          handle_mcp_error(error, 'version_tool', error_mode: error_mode)
         end
       end
     end