cov-loupe 3.0.0 → 4.0.0.pre

data/lib/cov_loupe/tools/coverage_detailed_tool.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 require_relative '../base_tool'
-require_relative '../model'
-require_relative '../presenters/coverage_detailed_presenter'
+require_relative '../model/model'
+require_relative '../presenters/coverage_payload_presenter'
 
 module CovLoupe
   module Tools
@@ -10,24 +10,23 @@ module CovLoupe
       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/staleness mode inherited from BaseTool.
+        Inputs: file path (required) plus optional root/resultset/raise_on_stale flag 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/cov_loupe/model.rb".
       DESC
       input_schema(**input_schema_def)
       class << self
-        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
+        def call(path:, root: nil, resultset: nil, raise_on_stale: nil, error_mode: 'log',
+          output_chars: nil, server_context:)
+          call_with_file_payload(
+            path: path,
+            error_mode: error_mode,
+            output_chars: output_chars,
+            server_context: server_context,
+            root: root,
+            resultset: resultset,
+            raise_on_stale: raise_on_stale
+          )
         end
       end
     end

data/lib/cov_loupe/tools/coverage_raw_tool.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 require_relative '../base_tool'
-require_relative '../model'
-require_relative '../presenters/coverage_raw_presenter'
+require_relative '../model/model'
+require_relative '../presenters/coverage_payload_presenter'
 
 module CovLoupe
   module Tools
@@ -10,23 +10,23 @@ module CovLoupe
       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/staleness mode inherited from BaseTool.
+        Inputs: file path (required) plus optional root/resultset/raise_on_stale flag 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, 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
+        def call(path:, root: nil, resultset: nil, raise_on_stale: nil, error_mode: 'log',
+          output_chars: nil, server_context:)
+          call_with_file_payload(
+            path: path,
+            error_mode: error_mode,
+            output_chars: output_chars,
+            server_context: server_context,
+            root: root,
+            resultset: resultset,
+            raise_on_stale: raise_on_stale
+          )
         end
       end
     end

data/lib/cov_loupe/tools/coverage_summary_tool.rb

@@ -1,32 +1,32 @@
 # frozen_string_literal: true
 
 require_relative '../base_tool'
-require_relative '../model'
-require_relative '../presenters/coverage_summary_presenter'
+require_relative '../model/model'
+require_relative '../presenters/coverage_payload_presenter'
 
 module CovLoupe
   module Tools
     class CoverageSummaryTool < BaseTool
       description <<~DESC
         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/staleness mode inherited from BaseTool.
+        Do not use this for multi-file reports; coverage.list or coverage.table handle those.
+        Inputs: file path (required) plus optional root/resultset/raise_on_stale flag inherited from BaseTool.
         Output: JSON object {"file": String, "summary": {"covered": Integer, "total": Integer, "percentage": Float}, "stale": String|False}.
-        Examples: "What is the coverage for lib/cov_loupe/tools/all_files_coverage_tool.rb?".
+        Examples: "What is the coverage for lib/cov_loupe/tools/list_tool.rb?".
       DESC
       input_schema(**input_schema_def)
       class << self
-        def call(path:, root: '.', resultset: nil, staleness: :off, error_mode: 'log',
-          server_context:)
-          with_error_handling('CoverageSummaryTool', error_mode: error_mode) do
-            model = CoverageModel.new(
-              root: root,
-              resultset: resultset,
-              staleness: staleness.to_sym
-            )
-            presenter = Presenters::CoverageSummaryPresenter.new(model: model, path: path)
-            respond_json(presenter.relativized_payload, name: 'coverage_summary.json', pretty: true)
-          end
+        def call(path:, root: nil, resultset: nil, raise_on_stale: nil, error_mode: 'log',
+          output_chars: nil, server_context:)
+          call_with_file_payload(
+            path: path,
+            error_mode: error_mode,
+            output_chars: output_chars,
+            server_context: server_context,
+            root: root,
+            resultset: resultset,
+            raise_on_stale: raise_on_stale
+          )
         end
       end
     end

data/lib/cov_loupe/tools/coverage_table_tool.rb

@@ -3,47 +3,165 @@
 
 require_relative '../base_tool'
 require_relative '../presenters/project_coverage_presenter'
+require_relative '../config/option_normalizers'
+require_relative '../output_chars'
 
 module CovLoupe
   module Tools
     class CoverageTableTool < BaseTool
       description <<~DESC
-        Use this when a user wants the plain text coverage table exactly like `cov-loupe --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.
+        Use this when a user wants the plain text coverage table exactly like `cov-loupe --format table` would print (no ANSI colors).
+        Do not use this for machine-readable data; coverage.list returns structured JSON.
+        Inputs: optional project root/resultset path/sort order/raise_on_stale flag matching the CLI flags.
+        Output: text block containing the formatted coverage table with headers and percentages, plus
+        any exclusions summary (missing/stale/deleted files) and skipped row warnings, exactly as the CLI displays.
         Example: "Show me the CLI coverage table sorted descending".
       DESC
       input_schema(**coverage_schema(
         additional_properties: {
-          sort_order: {
-            type: 'string',
-            description: 'Sort order for the printed coverage table (ascending or descending).',
-            default: 'ascending',
-            enum: ['ascending', 'descending']
-          },
+          sort_order: SORT_ORDER_PROPERTY,
           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('CoverageTableTool', 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)
+        def call(root: nil, resultset: nil, sort_order: nil, raise_on_stale: nil,
+          tracked_globs: nil, error_mode: 'log', output_chars: nil, server_context:)
+          output_chars_sym = resolve_output_chars(output_chars, server_context)
+          with_error_handling('CoverageTableTool', error_mode: error_mode, output_chars: output_chars_sym) do
+            model, config = create_configured_model(
+              server_context: server_context,
+              root: root,
+              resultset: resultset,
+              raise_on_stale: raise_on_stale,
+              tracked_globs: tracked_globs
+            )
+
+            # Normalize and validate sort_order (supports 'a'/'d' abbreviations)
+            sort_order_sym = OptionNormalizers.normalize_sort_order(
+              sort_order || BaseTool::DEFAULT_SORT_ORDER, strict: true
+            )
+
+            # Create presenter to access file summaries and exclusion data
+            presenter = Presenters::ProjectCoveragePresenter.new(
+              model: model,
+              sort_order: sort_order_sym,
+              raise_on_stale: config[:raise_on_stale],
+              tracked_globs: config[:tracked_globs]
+            )
+
+            # Format the table with file summaries
+            file_summaries = presenter.relative_files
             table = model.format_table(
+              file_summaries,
               sort_order: sort_order_sym,
-              check_stale: (staleness_sym == :error),
-              tracked_globs: tracked_globs
+              raise_on_stale: config[:raise_on_stale],
+              tracked_globs: nil,
+              output_chars: output_chars_sym
             )
+
+            # Append exclusions summary (matching CLI behavior)
+            exclusions = format_exclusions_summary(presenter, output_chars_sym)
+            table += exclusions unless exclusions.empty?
+
+            # Append timestamp warning (matching CLI behavior)
+            timestamp_warning = format_timestamp_warning(presenter)
+            table += timestamp_warning unless timestamp_warning.empty?
+
+            # Append skipped rows warning (matching CLI behavior)
+            skipped_warning = format_skipped_rows_warning(presenter, output_chars_sym)
+            table += skipped_warning unless skipped_warning.empty?
+
             # Return text response
             ::MCP::Tool::Response.new([{ 'type' => 'text', 'text' => table }])
           end
         end
+
+        private def format_exclusions_summary(presenter, output_chars)
+          missing = presenter.relative_missing_tracked_files
+          newer = presenter.relative_newer_files
+          deleted = presenter.relative_deleted_files
+          length_mismatch = presenter.relative_length_mismatch_files
+          unreadable = presenter.relative_unreadable_files
+          skipped = presenter.relative_skipped_files
+
+          # Only format if there are any exclusions
+          return '' if missing.empty? && newer.empty? && deleted.empty? &&
+                       length_mismatch.empty? && unreadable.empty? && skipped.empty?
+
+          # Helper to convert paths to ASCII if needed
+          convert_path = ->(path) { OutputChars.convert(path, output_chars) }
+
+          output = ["\nFiles excluded from coverage:"]
+
+          unless missing.empty?
+            output << "\nMissing tracked files (#{missing.length}):"
+            missing.each { |file| output << "  - #{convert_path.call(file)}" }
+          end
+
+          unless newer.empty?
+            output << "\nFiles newer than coverage (#{newer.length}):"
+            newer.each { |file| output << "  - #{convert_path.call(file)}" }
+          end
+
+          unless deleted.empty?
+            output << "\nDeleted files with coverage (#{deleted.length}):"
+            deleted.each { |file| output << "  - #{convert_path.call(file)}" }
+          end
+
+          unless length_mismatch.empty?
+            output << "\nLine count mismatches (#{length_mismatch.length}):"
+            length_mismatch.each { |file| output << "  - #{convert_path.call(file)}" }
+          end
+
+          unless unreadable.empty?
+            output << "\nUnreadable files (#{unreadable.length}):"
+            unreadable.each { |file| output << "  - #{convert_path.call(file)}" }
+          end
+
+          unless skipped.empty?
+            output << "\nFiles skipped due to errors (#{skipped.length}):"
+            skipped.each do |row|
+              file_path = OutputChars.convert(row['file'], output_chars)
+              error_msg = OutputChars.convert(row['error'], output_chars)
+              output << "  - #{file_path}: #{error_msg}"
+            end
+          end
+
+          output << "\nRun with --raise-on-stale to exit when files are excluded."
+          output.join("\n")
+        end
+
+        # Formats the timestamp warning matching CLI warn_missing_timestamps behavior
+        private def format_timestamp_warning(presenter)
+          return '' unless presenter.timestamp_status == 'missing'
+
+          <<~WARNING
+
+            WARNING: Coverage timestamps are missing. Time-based staleness checks were skipped.
+            Files may appear "ok" even if source code is newer than the coverage data.
+            Check your coverage tool configuration to ensure timestamps are recorded.
+          WARNING
+        end
+
+        # Formats the skipped rows warning matching CLI warn_skipped_rows behavior
+        private def format_skipped_rows_warning(presenter, output_chars)
+          skipped = presenter.relative_skipped_files
+          return '' if skipped.nil? || skipped.empty?
+
+          count = skipped.length
+          output = [
+            '',
+            "WARNING: #{count} coverage row#{count == 1 ? '' : 's'} skipped due to errors:"
+          ]
+          skipped.each do |row|
+            # Paths are already relativized by presenter
+            file_path = OutputChars.convert(row['file'], output_chars)
+            error_msg = OutputChars.convert(row['error'], output_chars)
+            output << "  - #{file_path}: #{error_msg}"
+          end
+          output << 'Run again with --raise-on-stale to exit when rows are skipped.'
+          output.join("\n")
+        end
       end
     end
   end

data/lib/cov_loupe/tools/coverage_totals_tool.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../model'
+require_relative '../model/model'
 require_relative '../base_tool'
 require_relative '../presenters/project_totals_presenter'
 
@@ -10,8 +10,10 @@ module CovLoupe
       description <<~DESC
         Use this when you want aggregated coverage counts for the entire project.
         It reports covered/total lines, uncovered line counts, and the overall average percentage.
-        Inputs: optional project root, alternate .resultset path, staleness mode, tracked_globs, and error mode.
-        Output: JSON {"lines":{"total","covered","uncovered"},"percentage":Float,"files":{"total","ok","stale"}}.
+        Inputs: optional project root, alternate .resultset path, raise_on_stale flag, tracked_globs, and error mode.
+        Output: JSON {"lines":{"total","covered","uncovered","percent_covered"},"tracking":{"enabled","globs"},"files":{"total","with_coverage","without_coverage"},"timestamp_status":"ok"|"missing","warnings":[string,...]}.
+        When raise_on_stale is enabled, the tool will raise an error immediately if any files have coverage data errors or staleness issues.
+        "timestamp_status" indicates whether coverage timestamps are available for time-based staleness checks. "warnings" array is present when timestamp_status is "missing".
         Example: "Give me total/covered/uncovered line counts and the overall coverage percent."
       DESC
 
@@ -22,20 +24,36 @@ module CovLoupe
       ))
 
       class << self
-        def call(root: '.', resultset: nil, staleness: :off, tracked_globs: nil,
-          error_mode: 'log', server_context:)
-          with_error_handling('CoverageTotalsTool', error_mode: error_mode) do
-            # Convert string inputs from MCP to symbols for internal use
-            staleness_sym = staleness.to_sym
+        def call(root: nil, resultset: nil, raise_on_stale: nil, tracked_globs: nil,
+          error_mode: 'log', output_chars: nil, server_context:)
+          output_chars_sym = resolve_output_chars(output_chars, server_context)
+          with_error_handling('CoverageTotalsTool', error_mode: error_mode, output_chars: output_chars_sym) do
+            model, config = create_configured_model(
+              server_context: server_context,
+              root: root,
+              resultset: resultset,
+              raise_on_stale: raise_on_stale,
+              tracked_globs: tracked_globs
+            )
 
-            model = CoverageModel.new(root: root, resultset: resultset, staleness: staleness_sym,
-              tracked_globs: tracked_globs)
             presenter = Presenters::ProjectTotalsPresenter.new(
               model: model,
-              check_stale: (staleness_sym == :error),
-              tracked_globs: tracked_globs
+              raise_on_stale: config[:raise_on_stale],
+              tracked_globs: config[:tracked_globs]
             )
-            respond_json(presenter.relativized_payload, name: 'coverage_totals.json', pretty: true)
+            payload = presenter.relativized_payload
+
+            # Add warnings array if timestamp_status is missing
+            if payload['timestamp_status'] == 'missing'
+              payload['warnings'] = [
+                'Coverage timestamps are missing. Time-based staleness checks were skipped.',
+                'Files may appear "ok" even if source code is newer than the coverage data.',
+                'Check your coverage tool configuration to ensure timestamps are recorded.'
+              ]
+            end
+
+            respond_json(payload, name: 'coverage_totals.json', pretty: true,
+              output_chars: output_chars_sym)
           end
         end
       end

data/lib/cov_loupe/tools/help_tool.rb

@@ -13,7 +13,8 @@ module CovLoupe
         type: 'object',
         additionalProperties: false,
         properties: {
-          error_mode: ERROR_MODE_PROPERTY
+          error_mode: ERROR_MODE_PROPERTY,
+          output_chars: COMMON_PROPERTIES[:output_chars]
         }
       )
 
@@ -23,63 +24,56 @@ module CovLoupe
           label: 'Single-file coverage summary',
           use_when: 'User wants covered/total line counts or percentage for one file.',
           avoid_when: 'User needs repo-wide stats or specific uncovered lines.',
-          inputs: ['path (required)', 'root/resultset/staleness (optional)']
+          inputs: ['path (required)', 'root/resultset/raise_on_stale (optional)']
         },
         {
           tool: UncoveredLinesTool,
           label: 'Uncovered line numbers',
           use_when: 'User asks which lines in a file still lack tests.',
           avoid_when: 'User only wants overall percentages or detailed per-line hit data.',
-          inputs: ['path (required)', 'root/resultset/staleness (optional)']
+          inputs: ['path (required)', 'root/resultset/raise_on_stale (optional)']
         },
         {
           tool: CoverageDetailedTool,
           label: 'Per-line coverage details',
           use_when: 'User needs per-line hit counts for a file.',
           avoid_when: 'User only wants totals or uncovered line numbers.',
-          inputs: ['path (required)', 'root/resultset/staleness (optional)']
+          inputs: ['path (required)', 'root/resultset/raise_on_stale (optional)']
         },
         {
           tool: CoverageRawTool,
           label: 'Raw SimpleCov lines array',
           use_when: 'User needs the raw SimpleCov `lines` array for a file.',
           avoid_when: 'User expects human-friendly summaries or explanations.',
-          inputs: ['path (required)', 'root/resultset/staleness (optional)']
+          inputs: ['path (required)', 'root/resultset/raise_on_stale (optional)']
         },
         {
-          tool: AllFilesCoverageTool,
+          tool: ListTool,
           label: 'Repo-wide file coverage',
           use_when: 'User wants coverage percentages for every tracked file.',
           avoid_when: 'User asks about a single file.',
-          inputs: ['root/resultset (optional)', 'sort_order', 'staleness', 'tracked_globs']
+          inputs: ['root/resultset (optional)', 'sort_order', 'raise_on_stale', 'tracked_globs']
         },
         {
           tool: CoverageTotalsTool,
           label: 'Project coverage totals',
           use_when: 'User wants total/covered/uncovered line counts or the average percent.',
           avoid_when: 'User needs per-file breakdowns.',
-          inputs: ['root/resultset (optional)', 'staleness', 'tracked_globs']
+          inputs: ['root/resultset (optional)', 'raise_on_stale', 'tracked_globs']
         },
         {
           tool: CoverageTableTool,
           label: 'Formatted coverage table',
           use_when: 'User wants the plain-text table produced by the CLI.',
           avoid_when: 'User needs JSON data for automation.',
-          inputs: ['root/resultset (optional)', 'sort_order', 'staleness']
+          inputs: ['root/resultset (optional)', 'sort_order', 'raise_on_stale']
         },
         {
           tool: ValidateTool,
           label: 'Validate coverage policy',
           use_when: 'User needs to enforce coverage rules (e.g., minimum percentage) in CI.',
           avoid_when: 'User just wants to view coverage data.',
-          inputs: ['path (required)', 'root/resultset (optional)']
-        },
-        {
-          tool: ValidateTool,
-          label: 'Validate coverage policy',
-          use_when: 'User needs to enforce coverage rules (e.g., minimum percentage) in CI.',
-          avoid_when: 'User just wants to view coverage data.',
-          inputs: ['path (required)', 'root/resultset (optional)']
+          inputs: ['code OR file (one required)', 'root/resultset/raise_on_stale (optional)']
         },
         {
           tool: VersionTool,
@@ -91,12 +85,14 @@ module CovLoupe
       ].freeze
 
       class << self
-        def call(error_mode: 'log', server_context:, **_unused)
-          with_error_handling('HelpTool', error_mode: error_mode) do
+        def call(error_mode: 'log', output_chars: nil, server_context:, **_unused)
+          # Normalize output_chars before error handling so errors also get converted
+          output_chars_sym = resolve_output_chars(output_chars, server_context)
+          with_error_handling('HelpTool', error_mode: error_mode, output_chars: output_chars_sym) do
             entries = TOOL_GUIDE.map { |guide| format_entry(guide) }
 
             data = { tools: entries }
-            respond_json(data, name: 'tools_help.json')
+            respond_json(data, name: 'tools_help.json', output_chars: output_chars_sym)
           end
         end
 

data/lib/cov_loupe/tools/list_tool.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require_relative '../model/model'
+require_relative '../base_tool'
+require_relative '../presenters/project_coverage_presenter'
+require_relative '../config/option_normalizers'
+
+module CovLoupe
+  module Tools
+    class ListTool < 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, raise_on_stale flag, and tracked_globs to alert on new files.
+        Output: JSON {"files": [{"file","covered","total","percentage","stale"}, ...], "counts": {"total", "ok", "stale"}, "skipped_files": [...], "missing_tracked_files": [...], "newer_files": [...], "deleted_files": [...], "length_mismatch_files": [...], "unreadable_files": [...], "timestamp_status": "ok"|"missing", "warnings": [string, ...]} sorted as requested. "stale" is "ok", "missing", "newer", "length_mismatch", or "error". "timestamp_status" indicates whether coverage timestamps are available for time-based staleness checks. "warnings" array is present when timestamp_status is "missing".
+        Examples: "List files with the lowest coverage"; "Show repo coverage sorted descending".
+      DESC
+      input_schema(**coverage_schema(
+        additional_properties: {
+          sort_order: SORT_ORDER_PROPERTY,
+          tracked_globs: TRACKED_GLOBS_PROPERTY
+        }
+      ))
+      class << self
+        def call(root: nil, resultset: nil, sort_order: nil, raise_on_stale: nil,
+          tracked_globs: nil, error_mode: 'log', output_chars: nil, server_context:)
+          output_chars_sym = resolve_output_chars(output_chars, server_context)
+          with_error_handling('ListTool', error_mode: error_mode, output_chars: output_chars_sym) do
+            model, config = create_configured_model(
+              server_context: server_context,
+              root: root,
+              resultset: resultset,
+              raise_on_stale: raise_on_stale,
+              tracked_globs: tracked_globs
+            )
+
+            # Normalize and validate sort_order (supports 'a'/'d' abbreviations)
+            sort_order_sym = OptionNormalizers.normalize_sort_order(
+              sort_order || BaseTool::DEFAULT_SORT_ORDER, strict: true
+            )
+
+            presenter = Presenters::ProjectCoveragePresenter.new(
+              model: model,
+              sort_order: sort_order_sym,
+              raise_on_stale: config[:raise_on_stale],
+              tracked_globs: config[:tracked_globs]
+            )
+            payload = presenter.relativized_payload
+
+            # Add warnings array if timestamp_status is missing
+            if payload['timestamp_status'] == 'missing'
+              payload['warnings'] = [
+                'Coverage timestamps are missing. Time-based staleness checks were skipped.',
+                'Files may appear "ok" even if source code is newer than the coverage data.',
+                'Check your coverage tool configuration to ensure timestamps are recorded.'
+              ]
+            end
+
+            respond_json(payload, name: 'list_coverage.json', output_chars: output_chars_sym)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cov_loupe/tools/uncovered_lines_tool.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 require_relative '../base_tool'
-require_relative '../model'
-require_relative '../presenters/coverage_uncovered_presenter'
+require_relative '../model/model'
+require_relative '../presenters/coverage_payload_presenter'
 
 module CovLoupe
   module Tools
@@ -10,23 +10,23 @@ module CovLoupe
       description <<~DESC
         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/staleness mode inherited from BaseTool.
+        Inputs: file path (required) plus optional root/resultset/raise_on_stale flag inherited from BaseTool.
         Output: JSON object with keys "file", "uncovered" (array of integers), "summary" {"covered","total","percentage"}, and "stale" status.
         Example: "List uncovered lines for lib/cov_loupe/tools/coverage_summary_tool.rb".
       DESC
       input_schema(**input_schema_def)
       class << self
-        def call(path:, root: '.', resultset: nil, staleness: :off, error_mode: 'log',
-          server_context:)
-          with_error_handling('UncoveredLinesTool', error_mode: error_mode) do
-            model = CoverageModel.new(
-              root: root,
-              resultset: resultset,
-              staleness: staleness.to_sym
-            )
-            presenter = Presenters::CoverageUncoveredPresenter.new(model: model, path: path)
-            respond_json(presenter.relativized_payload, name: 'uncovered_lines.json', pretty: true)
-          end
+        def call(path:, root: nil, resultset: nil, raise_on_stale: nil, error_mode: 'log',
+          output_chars: nil, server_context:)
+          call_with_file_payload(
+            path: path,
+            error_mode: error_mode,
+            output_chars: output_chars,
+            server_context: server_context,
+            root: root,
+            resultset: resultset,
+            raise_on_stale: raise_on_stale
+          )
         end
       end
     end