simplecov-mcp 1.0.1 → 2.0.1

data/lib/simplecov_mcp/formatters/source_formatter.rb

@@ -19,7 +19,9 @@ module SimpleCovMcp
         begin
           rows = build_source_rows(src, lines_cov, mode: mode, context: context)
           format_source_rows(rows)
-        rescue StandardError
+        rescue ArgumentError
+          raise
+        rescue
           # If any unexpected formatting/indexing error occurs, avoid crashing the CLI
           '[source not available]'
         end
@@ -40,8 +42,12 @@ module SimpleCovMcp
       def build_source_rows(src_lines, cov_lines, mode:, context: 2)
         # Normalize inputs defensively to avoid type errors in formatting
         coverage_lines = cov_lines || []
-        context_line_count = context.to_i rescue 2
-        context_line_count = 0 if context_line_count.negative?
+        context_line_count = begin
+          context.to_i
+        rescue
+          2
+        end
+        raise ArgumentError, 'Context lines cannot be negative' if context_line_count.negative?
 
         n = src_lines.length
         include_line = Array.new(n, mode == :full)
@@ -53,7 +59,7 @@ module SimpleCovMcp
       end
 
       def format_source_rows(rows)
-        marker = ->(covered, hits) do
+        marker = ->(covered, _hits) do
           case covered
           when true then colorize('✓', :green)
           when false then colorize('·', :red)
@@ -62,12 +68,12 @@ module SimpleCovMcp
         end
 
         lines = []
-        lines << sprintf('%6s  %2s | %s', 'Line', ' ', 'Source')
-        lines << sprintf('%6s  %2s-+-%s', '------', '--', '-' * 60)
+        lines << format('%6s  %2s | %s', 'Line', ' ', 'Source')
+        lines << format('%6s  %2s-+-%s', '------', '--', '-' * 60)
 
         rows.each do |r|
           m = marker.call(r['covered'], r['hits'])
-          lines << sprintf('%6d  %2s | %s', r['line'], m, r['code'])
+          lines << format('%6d  %2s | %s', r['line'], m, r['code'])
         end
         lines.join("\n")
       end
@@ -75,29 +81,27 @@ module SimpleCovMcp
       def format_detailed_rows(rows)
         # Simple aligned columns: line, hits, covered
         out = []
-        out << sprintf('%6s  %6s  %7s', 'Line', 'Hits', 'Covered')
-        out << sprintf('%6s  %6s  %7s', '-----', '----', '-------')
+        out << format('%6s  %6s  %7s', 'Line', 'Hits', 'Covered')
+        out << format('%6s  %6s  %7s', '-----', '----', '-------')
         rows.each do |r|
-          out << sprintf('%6d  %6d  %7s', r['line'], r['hits'], r['covered'] ? 'yes' : 'no')
+          out << format('%6d  %6d  %5s', r['line'], r['hits'], r['covered'] ? 'yes' : 'no')
         end
         out.join("\n")
       end
 
-      private
-
       attr_reader :color_enabled
 
-      def fetch_raw(model, path)
+      private def fetch_raw(model, path)
         @raw_cache ||= {}
         return @raw_cache[path] if @raw_cache.key?(path)
 
         raw = model.raw_for(path)
         @raw_cache[path] = raw
-      rescue StandardError
+      rescue
         nil
       end
 
-      def mark_uncovered_lines_with_context(coverage_lines, context_line_count, total_lines)
+      private def mark_uncovered_lines_with_context(coverage_lines, context_line_count, total_lines)
         include_line = Array.new(total_lines, false)
         misses = find_uncovered_lines(coverage_lines)
 
@@ -108,7 +112,7 @@ module SimpleCovMcp
         include_line
       end
 
-      def find_uncovered_lines(coverage_lines)
+      private def find_uncovered_lines(coverage_lines)
         misses = []
         coverage_lines.each_with_index do |hits, i|
           misses << i if !hits.nil? && hits.to_i == 0
@@ -116,14 +120,14 @@ module SimpleCovMcp
         misses
       end
 
-      def mark_context_lines(include_line, center_line, context_count, total_lines)
+      private def mark_context_lines(include_line, center_line, context_count, total_lines)
         start_line = [0, center_line - context_count].max
         end_line = [total_lines - 1, center_line + context_count].min
 
         (start_line..end_line).each { |i| include_line[i] = true }
       end
 
-      def build_row_data(src_lines, coverage_lines, include_line)
+      private def build_row_data(src_lines, coverage_lines, include_line)
         out = []
         src_lines.each_with_index do |code, i|
           next unless include_line[i]
@@ -136,7 +140,7 @@ module SimpleCovMcp
         out
       end
 
-      def colorize(text, color)
+      private def colorize(text, color)
         return text unless color_enabled
 
         codes = { green: 32, red: 31, dim: 2 }

data/lib/simplecov_mcp/formatters.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module SimpleCovMcp
+  module Formatters
+    # Maps format symbols to their formatter lambdas
+    # Following the rexe pattern for simple, extensible formatting
+    FORMATTERS = {
+      table: ->(obj) { obj }, # Pass through - table formatting handled elsewhere
+      json: lambda(&:to_json),
+      pretty_json: ->(obj) { JSON.pretty_generate(obj) },
+      yaml: ->(obj) {
+        require 'yaml'
+        obj.to_yaml
+      },
+      awesome_print: ->(obj) {
+        require 'awesome_print'
+        obj.ai
+      }
+    }.freeze
+
+    # Maps format symbols to their required libraries
+    # Only loaded when the format is actually used
+    FORMAT_REQUIRES = {
+      yaml: 'yaml',
+      awesome_print: 'awesome_print'
+    }.freeze
+
+    # Returns the formatter lambda for the given format
+    def self.formatter_for(format)
+      FORMATTERS[format] or raise ArgumentError, "Unknown format: #{format}"
+    end
+
+    # Ensures required libraries are loaded for the given format
+    def self.ensure_requirements_for(format)
+      requirement = FORMAT_REQUIRES[format]
+      require requirement if requirement
+    end
+
+    # Formats an object using the specified format
+    def self.format(obj, format)
+      ensure_requirements_for(format)
+      formatter_for(format).call(obj)
+    rescue LoadError => e
+      gem_name = e.message[/-- (\S+)/, 1] || 'required gem'
+      raise LoadError, "The #{format} format requires the '#{gem_name}' gem. " \
+                       "Install it with: gem install #{gem_name}"
+    end
+  end
+end

data/lib/simplecov_mcp/mcp_server.rb

@@ -17,24 +17,26 @@ module SimpleCovMcp
       end
     end
 
-    # Expose the registered tools so embedders can introspect without booting the server.
-    def toolset
-      TOOLSET
-    end
-
-    private
-
     TOOLSET = [
       Tools::AllFilesCoverageTool,
       Tools::CoverageDetailedTool,
       Tools::CoverageRawTool,
       Tools::CoverageSummaryTool,
+      Tools::CoverageTotalsTool,
       Tools::UncoveredLinesTool,
       Tools::CoverageTableTool,
+      Tools::ValidateTool,
       Tools::HelpTool,
       Tools::VersionTool
     ].freeze
 
+    # Expose the registered tools so embedders can introspect without booting the server.
+    def toolset
+      TOOLSET
+    end
+
+    private
+
     attr_reader :context
   end
 end

data/lib/simplecov_mcp/mode_detector.rb

@@ -6,15 +6,16 @@ module SimpleCovMcp
   # Centralizes the logic for detecting whether to run in CLI or MCP server mode.
   # This makes the mode detection strategy explicit and testable.
   class ModeDetector
-    SUBCOMMANDS = %w[list summary raw uncovered detailed version].freeze
+    SUBCOMMANDS = %w[list summary raw uncovered detailed totals validate version].freeze
 
     # Reference shared constant to avoid duplication with CoverageCLI
     OPTIONS_EXPECTING_ARGUMENT = Constants::OPTIONS_EXPECTING_ARGUMENT
 
-    def self.cli_mode?(argv, stdin: STDIN)
+    def self.cli_mode?(argv, stdin: $stdin)
       # 1. Explicit flags that force CLI mode always win
-      cli_options = %w[--force-cli -h --help --version]
-      return true if (argv & cli_options).any?
+      cli_options = %w[--force-cli -h --help --version -v]
+      return true if argv.intersect?(cli_options)
+
 
       # 2. Find the first non-option argument
       first_non_option = find_first_non_option(argv)
@@ -26,7 +27,7 @@ module SimpleCovMcp
       stdin.tty?
     end
 
-    def self.mcp_server_mode?(argv, stdin: STDIN)
+    def self.mcp_server_mode?(argv, stdin: $stdin)
       !cli_mode?(argv, stdin: stdin)
     end
 

data/lib/simplecov_mcp/model.rb

@@ -5,6 +5,7 @@ require 'json'
 
 require_relative 'util'
 require_relative 'errors'
+require_relative 'error_handler'
 require_relative 'staleness_checker'
 require_relative 'path_relativizer'
 require_relative 'resultset_loader'
@@ -21,10 +22,10 @@ module SimpleCovMcp
     # Params:
     # - root: project root directory (default '.')
     # - resultset: path or directory to .resultset.json
-    # - staleness: 'off' or 'error' (default 'off'). When 'error', raises
+    # - staleness: :off or :error (default :off). When :error, raises
     #   stale errors if sources are newer than coverage or line counts mismatch.
     # - tracked_globs: only used for all_files project-level staleness.
-    def initialize(root: '.', resultset: nil, staleness: 'off', tracked_globs: nil)
+    def initialize(root: '.', resultset: nil, staleness: :off, tracked_globs: nil)
       @root = File.absolute_path(root || '.')
       @resultset = resultset
       @relativizer = PathRelativizer.new(
@@ -33,47 +34,12 @@ module SimpleCovMcp
         array_keys: RELATIVIZER_ARRAY_KEYS
       )
 
-      begin
-        rs = CovUtil.find_resultset(@root, resultset: resultset)
-        loaded = ResultsetLoader.load(resultset_path: rs)
-        coverage_map = loaded.coverage_map or raise CoverageDataError.new("No 'coverage' key found in resultset file: #{rs}")
-
-        @cov = coverage_map.transform_keys { |k| File.absolute_path(k, @root) }
-        @cov_timestamp = loaded.timestamp
-
-        @checker = StalenessChecker.new(
-          root: @root,
-          resultset: @resultset,
-          mode: staleness,
-          tracked_globs: tracked_globs,
-          timestamp: @cov_timestamp
-        )
-      rescue Errno::ENOENT => e
-        raise ResultsetNotFoundError.new("Coverage data not found at #{resultset || @root}")
-      rescue JSON::ParserError => e
-        raise CoverageDataError.new("Invalid coverage data format: #{e.message}")
-      rescue Errno::EACCES => e
-        raise FilePermissionError.new("Permission denied reading coverage data: #{e.message}")
-      rescue TypeError, NoMethodError => e
-        # These typically indicate the resultset has an unexpected structure
-        raise CoverageDataError.new("Invalid coverage data structure: #{e.message}")
-      rescue ArgumentError => e
-        # ArgumentError can occur from File.absolute_path or other path operations
-        raise CoverageDataError.new("Invalid path in coverage data: #{e.message}")
-      rescue RuntimeError => e
-        # RuntimeError from find_resultset or other operations
-        # Check if it's a resultset not found error
-        if e.message.downcase.include?('resultset')
-          raise ResultsetNotFoundError.new(e.message)
-        else
-          raise CoverageDataError.new("Failed to load coverage data: #{e.message}")
-        end
-      end
+      load_coverage_data(resultset, staleness, tracked_globs)
     end
 
     # Returns { 'file' => <absolute_path>, 'lines' => [hits|nil,...] }
     def raw_for(path)
-      file_abs, coverage_lines = resolve(path)
+      file_abs, coverage_lines = coverage_data_for(path)
       { 'file' => file_abs, 'lines' => coverage_lines }
     end
 
@@ -81,15 +47,15 @@ module SimpleCovMcp
       relativizer.relativize(payload)
     end
 
-    # Returns { 'file' => <absolute_path>, 'summary' => {'covered'=>, 'total'=>, 'pct'=>} }
+    # Returns { 'file' => <absolute_path>, 'summary' => {'covered'=>, 'total'=>, 'percentage'=>} }
     def summary_for(path)
-      file_abs, coverage_lines = resolve(path)
+      file_abs, coverage_lines = coverage_data_for(path)
       { 'file' => file_abs, 'summary' => CovUtil.summary(coverage_lines) }
     end
 
     # Returns { 'file' => <absolute_path>, 'uncovered' => [line,...], 'summary' => {...} }
     def uncovered_for(path)
-      file_abs, coverage_lines = resolve(path)
+      file_abs, coverage_lines = coverage_data_for(path)
       {
         'file' => file_abs,
         'uncovered' => CovUtil.uncovered(coverage_lines),
@@ -99,7 +65,7 @@ module SimpleCovMcp
 
     # Returns { 'file' => <absolute_path>, 'lines' => [{'line'=>,'hits'=>,'covered'=>},...], 'summary' => {...} }
     def detailed_for(path)
-      file_abs, coverage_lines = resolve(path)
+      file_abs, coverage_lines = coverage_data_for(path)
       {
         'file' => file_abs,
         'lines' => CovUtil.detailed(coverage_lines),
@@ -108,8 +74,8 @@ module SimpleCovMcp
     end
 
     # Returns [ { 'file' =>, 'covered' =>, 'total' =>, 'percentage' =>, 'stale' => }, ... ]
-    def all_files(sort_order: :ascending, check_stale: !@checker.off?, tracked_globs: nil)
-      stale_checker = build_staleness_checker(mode: 'off', tracked_globs: tracked_globs)
+    def all_files(sort_order: :descending, check_stale: !@checker.off?, tracked_globs: nil)
+      stale_checker = build_staleness_checker(mode: :off, tracked_globs: tracked_globs)
 
       rows = @cov.map do |abs_path, _data|
         begin
@@ -124,7 +90,7 @@ module SimpleCovMcp
           'file' => abs_path,
           'covered' => s['covered'],
           'total' => s['total'],
-          'percentage' => s['pct'],
+          'percentage' => s['percentage'],
           'stale' => stale
         }
       end.compact
@@ -132,24 +98,29 @@ module SimpleCovMcp
       rows = filter_rows_by_globs(rows, tracked_globs)
 
       if check_stale
-        build_staleness_checker(mode: 'error', tracked_globs: tracked_globs).check_project!(@cov)
+        build_staleness_checker(mode: :error, tracked_globs: tracked_globs).check_project!(@cov)
       end
 
       sort_rows(rows, sort_order: sort_order)
     end
 
+    def project_totals(tracked_globs: nil, check_stale: !@checker.off?)
+      rows = all_files(sort_order: :ascending, check_stale: check_stale,
+        tracked_globs: tracked_globs)
+      totals_from_rows(rows)
+    end
+
     def staleness_for(path)
       file_abs = File.absolute_path(path, @root)
       coverage_lines = CovUtil.lookup_lines(@cov, file_abs)
       @checker.stale_for_file?(file_abs, coverage_lines)
-    rescue StandardError => e
-      # Log the error if possible
-      CovUtil.log("Failed to check staleness for #{path}: #{e.message}") rescue nil
+    rescue => e
+      CovUtil.safe_log("Failed to check staleness for #{path}: #{e.message}")
       false
     end
 
     # Returns formatted table string for all files coverage data
-    def format_table(rows = nil, sort_order: :ascending, check_stale: !@checker.off?,
+    def format_table(rows = nil, sort_order: :descending, check_stale: !@checker.off?,
       tracked_globs: nil)
       rows = prepare_rows(rows, sort_order: sort_order, check_stale: check_stale,
         tracked_globs: tracked_globs)
@@ -170,9 +141,28 @@ module SimpleCovMcp
       lines.join("\n")
     end
 
-    private
+    private def load_coverage_data(resultset, staleness, tracked_globs)
+      rs = CovUtil.find_resultset(@root, resultset: resultset)
+      loaded = ResultsetLoader.load(resultset_path: rs)
+      coverage_map = loaded.coverage_map or raise(CoverageDataError, "No 'coverage' key found in resultset file: #{rs}")
+
+      @cov = coverage_map.transform_keys { |k| File.absolute_path(k, @root) }
+      @cov_timestamp = loaded.timestamp
+
+      @checker = StalenessChecker.new(
+        root: @root,
+        resultset: @resultset,
+        mode: staleness,
+        tracked_globs: tracked_globs,
+        timestamp: @cov_timestamp
+      )
+    rescue SimpleCovMcp::Error
+      raise # Re-raise our own errors as-is
+    rescue => e
+      raise ErrorHandler.new.convert_standard_error(e, context: :coverage_loading)
+    end
 
-    def build_staleness_checker(mode:, tracked_globs:)
+    private def build_staleness_checker(mode:, tracked_globs:)
       StalenessChecker.new(
         root: @root,
         resultset: @resultset,
@@ -182,7 +172,7 @@ module SimpleCovMcp
       )
     end
 
-    def prepare_rows(rows, sort_order:, check_stale:, tracked_globs:)
+    private def prepare_rows(rows, sort_order:, check_stale:, tracked_globs:)
       if rows.nil?
         all_files(sort_order: sort_order, check_stale: check_stale, tracked_globs: tracked_globs)
       else
@@ -191,7 +181,7 @@ module SimpleCovMcp
       end
     end
 
-    def sort_rows(rows, sort_order: :ascending)
+    private def sort_rows(rows, sort_order: :descending)
       rows.sort do |a, b|
         pct_cmp = (sort_order == :descending) \
                     ? (b['percentage'] <=> a['percentage'])
@@ -200,7 +190,7 @@ module SimpleCovMcp
       end
     end
 
-    def compute_table_widths(rows)
+    private def compute_table_widths(rows)
       max_file_length = rows.map { |f| f['file'].length }.max.to_i
       file_width = [max_file_length, 'File'.length].max + 2
       pct_width = 8
@@ -218,7 +208,7 @@ module SimpleCovMcp
       }
     end
 
-    def border_line(widths, left, middle, right)
+    private def border_line(widths, left, middle, right)
       h_line = ->(col_width) { '─' * (col_width + 2) }
       left +
         h_line.call(widths[:file]) +
@@ -229,16 +219,16 @@ module SimpleCovMcp
         right
     end
 
-    def header_row(widths)
-      sprintf(
+    private def header_row(widths)
+      format(
         "│ %-#{widths[:file]}s │ %#{widths[:pct]}s │ %#{widths[:covered]}s │ %#{widths[:total]}s │ %#{widths[:stale]}s │",
         'File', ' %', 'Covered', 'Total', 'Stale'.center(widths[:stale])
       )
     end
 
-    def data_row(file_data, widths)
+    private def data_row(file_data, widths)
       stale_text_str = file_data['stale'] ? file_data['stale'].to_s : ''
-      sprintf(
+      format(
         "│ %-#{widths[:file]}s │ %#{widths[:pct] - 1}.2f%% │ %#{widths[:covered]}d │ %#{widths[:total]}d │ %#{widths[:stale]}s │",
         file_data['file'],
         file_data['percentage'],
@@ -248,58 +238,102 @@ module SimpleCovMcp
       )
     end
 
-    def summary_counts(rows)
+    private def summary_counts(rows)
       total = rows.length
       stale_count = rows.count { |f| f['stale'] }
       ok_count = total - stale_count
       "Files: total #{total}, ok #{ok_count}, stale #{stale_count}"
     end
 
-    def filter_rows_by_globs(rows, tracked_globs)
+    # Filters coverage rows to only include files matching the given glob patterns.
+    #
+    # @param rows [Array<Hash>] coverage rows with 'file' keys containing absolute paths
+    # @param tracked_globs [Array<String>, String, nil] glob patterns to match against
+    # @return [Array<Hash>] rows whose files match at least one pattern (or all rows if no patterns)
+    private def filter_rows_by_globs(rows, tracked_globs)
       patterns = Array(tracked_globs).compact.map(&:to_s).reject(&:empty?)
       return rows if patterns.empty?
 
-      root_pathname = Pathname.new(@root)
-      flags = File::FNM_PATHNAME | File::FNM_EXTGLOB
+      absolute_patterns = patterns.map { |p| absolutize_pattern(p) }
+      rows.select { |row| matches_any_pattern?(row['file'], absolute_patterns) }
+    end
 
-      rows.select do |row|
-        abs_path = row['file']
-        rel_path = begin
-          Pathname.new(abs_path).relative_path_from(root_pathname).to_s
-        rescue ArgumentError
-          abs_path
-        end
+    # Converts a relative pattern to absolute by joining with root.
+    # Absolute patterns are returned unchanged.
+    #
+    # @param pattern [String] glob pattern (e.g., "lib/**/*.rb")
+    # @return [String] absolute pattern
+    private def absolutize_pattern(pattern)
+      absolute_pattern?(pattern) ? pattern : File.join(@root, pattern)
+    end
 
-        patterns.any? do |pattern|
-          target = Pathname.new(pattern).absolute? ? abs_path : rel_path
-          File.fnmatch?(pattern, target, flags)
-        end
-      end
+    # Checks if a pattern is absolute, handling both Unix and Windows-style paths.
+    # On Unix, Pathname won't recognize "C:/" as absolute, so we check explicitly.
+    #
+    # @param pattern [String] glob pattern
+    # @return [Boolean] true if pattern is absolute
+    private def absolute_pattern?(pattern)
+      Pathname.new(pattern).absolute? || pattern.match?(/\A[A-Za-z]:/)
+    end
+
+    # Tests if a file path matches any of the given absolute glob patterns.
+    # Uses File.fnmatch? for pure string matching without filesystem access,
+    # which is faster and works for paths that may no longer exist on disk.
+    #
+    # @param abs_path [String] absolute file path to test
+    # @param patterns [Array<String>] absolute glob patterns
+    # @return [Boolean] true if the path matches at least one pattern
+    private def matches_any_pattern?(abs_path, patterns)
+      flags = File::FNM_PATHNAME | File::FNM_EXTGLOB
+      patterns.any? { |pattern| File.fnmatch?(pattern, abs_path, flags) }
     end
 
-    def resolve(path)
+    # Retrieves coverage data for a file path.
+    # Converts the path to absolute form and performs staleness checking if enabled.
+    #
+    # @param path [String] relative or absolute file path
+    # @return [Array(String, Array)] tuple of [absolute_path, coverage_lines]
+    # @raise [FileError] if no coverage data exists for the file
+    # @raise [FileNotFoundError] if the file does not exist
+    # @raise [CoverageDataStaleError] if staleness checking is enabled and data is stale
+    private def coverage_data_for(path)
       file_abs = File.absolute_path(path, @root)
       begin
         coverage_lines = CovUtil.lookup_lines(@cov, file_abs)
-      rescue RuntimeError => e
-        raise FileError.new("No coverage data found for file: #{path}")
+      rescue RuntimeError
+        raise FileError, "No coverage data found for file: #{path}"
       end
       @checker.check_file!(file_abs, coverage_lines) unless @checker.off?
       if coverage_lines.nil?
-        raise FileError.new("No coverage data found for file: #{path}")
+        raise FileError, "No coverage data found for file: #{path}"
       end
 
       [file_abs, coverage_lines]
-    rescue Errno::ENOENT => e
-      raise FileNotFoundError.new("File not found: #{path}")
+    rescue Errno::ENOENT
+      raise FileNotFoundError, "File not found: #{path}"
     end
 
-    # staleness handled by StalenessChecker
+    private def totals_from_rows(rows)
+      covered = rows.sum { |row| row['covered'].to_i }
+      total = rows.sum { |row| row['total'].to_i }
+      uncovered = total - covered
+      percentage = total.zero? ? 100.0 : ((covered.to_f * 100.0 / total) * 100).round / 100.0
+      stale_count = rows.count { |row| row['stale'] }
+      files_total = rows.length
 
-    def check_all_files_staleness!(cov_timestamp, tracked_globs: nil)
-      # handled by StalenessChecker
+      {
+        'lines' => {
+          'covered' => covered,
+          'uncovered' => uncovered,
+          'total' => total
+        },
+        'percentage' => percentage,
+        'files' => {
+          'total' => files_total,
+          'ok' => files_total - stale_count,
+          'stale' => stale_count
+        }
+      }
     end
-
-    # Detailed stale message construction moved to CoverageDataStaleError
   end
 end