simplecov-mcp 1.0.0 → 2.0.0

data/lib/simplecov_mcp/commands/raw_command.rb

@@ -2,6 +2,7 @@
 
 require_relative 'base_command'
 require_relative '../presenters/coverage_raw_presenter'
+require_relative '../table_formatter'
 
 module SimpleCovMcp
   module Commands
@@ -10,11 +11,26 @@ module SimpleCovMcp
         handle_with_path(args, 'raw') do |path|
           presenter = Presenters::CoverageRawPresenter.new(model: model, path: path)
           data = presenter.absolute_payload
-          break if maybe_output_json(data, model)
+          break if maybe_output_structured_format?(data, model)
 
           relative_path = presenter.relative_path
           puts "File: #{relative_path}"
-          puts data['lines'].inspect
+          puts
+
+          # Table format for raw coverage data
+          headers = ['Line', 'Coverage']
+          rows = data['lines'].each_with_index.map do |coverage, index|
+            [
+              (index + 1).to_s,
+              coverage.nil? ? 'nil' : coverage.to_s
+            ]
+          end
+
+          puts TableFormatter.format(
+            headers: headers,
+            rows: rows,
+            alignments: [:right, :right]
+          )
         end
       end
     end

data/lib/simplecov_mcp/commands/summary_command.rb

@@ -2,6 +2,7 @@
 
 require_relative 'base_command'
 require_relative '../presenters/coverage_summary_presenter'
+require_relative '../table_formatter'
 
 module SimpleCovMcp
   module Commands
@@ -10,12 +11,28 @@ module SimpleCovMcp
         handle_with_path(args, 'summary') do |path|
           presenter = Presenters::CoverageSummaryPresenter.new(model: model, path: path)
           data = presenter.absolute_payload
-          break if emit_json_with_optional_source(data, model, path)
+          break if emit_structured_format_with_optional_source?(data, model, path)
 
           relative_path = presenter.relative_path
           summary = data['summary']
-          printf "%8.2f%%  %6d/%-6d  %s\n\n", summary['pct'], summary['covered'], summary['total'],
-            relative_path
+
+          # Table format with box-drawing
+          headers = ['File', '%', 'Covered', 'Total', 'Stale']
+          stale_marker = data['stale'] ? 'Yes' : ''
+          rows = [[
+            relative_path,
+            format('%.2f%%', summary['percentage']),
+            summary['covered'].to_s,
+            summary['total'].to_s,
+            stale_marker
+          ]]
+
+          puts TableFormatter.format(
+            headers: headers,
+            rows: rows,
+            alignments: [:left, :right, :right, :right, :center]
+          )
+          puts
           print_source_for(model, path) if config.source_mode
         end
       end

data/lib/simplecov_mcp/commands/totals_command.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative 'base_command'
+require_relative '../presenters/project_totals_presenter'
+require_relative '../table_formatter'
+
+module SimpleCovMcp
+  module Commands
+    class TotalsCommand < BaseCommand
+      def execute(args)
+        unless args.empty?
+          raise UsageError.for_subcommand('totals')
+        end
+
+        presenter = Presenters::ProjectTotalsPresenter.new(
+          model: model,
+          check_stale: (config.staleness == :error),
+          tracked_globs: config.tracked_globs
+        )
+        payload = presenter.absolute_payload
+        return if maybe_output_structured_format?(payload, model)
+
+        lines = payload['lines']
+        files = payload['files']
+
+        # Table format
+        headers = ['Metric', 'Total', 'Covered', 'Uncovered', '%']
+        rows = [
+          [
+            'Lines',
+            lines['total'].to_s,
+            lines['covered'].to_s,
+            lines['uncovered'].to_s,
+            format('%.2f%%', payload['percentage'])
+          ],
+          [
+            'Files',
+            files['total'].to_s,
+            files['ok'].to_s,
+            files['stale'].to_s,
+            ''
+          ]
+        ]
+
+        puts TableFormatter.format(
+          headers: headers,
+          rows: rows,
+          alignments: [:left, :right, :right, :right, :right]
+        )
+      end
+    end
+  end
+end

data/lib/simplecov_mcp/commands/uncovered_command.rb

@@ -2,6 +2,7 @@
 
 require_relative 'base_command'
 require_relative '../presenters/coverage_uncovered_presenter'
+require_relative '../table_formatter'
 
 module SimpleCovMcp
   module Commands
@@ -10,14 +11,32 @@ module SimpleCovMcp
         handle_with_path(args, 'uncovered') do |path|
           presenter = Presenters::CoverageUncoveredPresenter.new(model: model, path: path)
           data = presenter.absolute_payload
-          break if emit_json_with_optional_source(data, model, path)
+          break if emit_structured_format_with_optional_source?(data, model, path)
 
           relative_path = presenter.relative_path
-          puts "File:            #{relative_path}"
-          puts "Uncovered lines: #{data['uncovered'].join(', ')}"
           summary = data['summary']
-          printf "Summary:      %8.2f%%  %6d/%-6d\n\n", summary['pct'], summary['covered'],
-            summary['total']
+
+          puts "File: #{relative_path}"
+          puts "Coverage: #{format('%.2f%%', summary['percentage'])} " \
+               "(#{summary['covered']}/#{summary['total']} lines)"
+          puts
+
+          # Table format for uncovered lines
+          uncovered_lines = data['uncovered']
+          if uncovered_lines.empty?
+            puts 'All lines covered!'
+          else
+            headers = ['Line']
+            rows = uncovered_lines.map { |line| [line.to_s] }
+
+            puts TableFormatter.format(
+              headers: headers,
+              rows: rows,
+              alignments: [:right]
+            )
+          end
+
+          puts
           print_source_for(model, path) if config.source_mode
         end
       end

data/lib/simplecov_mcp/commands/validate_command.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_relative 'base_command'
+require_relative '../predicate_evaluator'
+
+module SimpleCovMcp
+  module Commands
+    # Validates coverage data against a predicate.
+    # Exits with code 0 (pass), 1 (fail), or 2 (error).
+    #
+    # Usage:
+    #   simplecov-mcp validate policy.rb                # File mode
+    #   simplecov-mcp validate -i '->(m) { ... }'       # Inline mode
+    class ValidateCommand < BaseCommand
+      def execute(args)
+        # Parse command-specific options
+        inline_mode = false
+        code = nil
+
+        # Simple option parsing for -i/--inline flag
+        while args.first&.start_with?('-')
+          case args.first
+          when '-i', '--inline'
+            inline_mode = true
+            args.shift
+            code = args.shift or raise UsageError.for_subcommand('validate -i <code>')
+          else
+            raise UsageError, "Unknown option for validate: #{args.first}"
+          end
+        end
+
+        # If not inline mode, expect a file path as positional argument
+        unless inline_mode
+          file_path = args.shift or raise UsageError.for_subcommand('validate <file> | -i <code>')
+          code = file_path
+        end
+
+        # Evaluate the predicate
+        result = if inline_mode
+          PredicateEvaluator.evaluate_code(code, model)
+        else
+          PredicateEvaluator.evaluate_file(code, model)
+        end
+
+        exit(result ? 0 : 1)
+      rescue UsageError
+        # Usage errors should exit with code 1, not 2
+        raise
+      rescue => e
+        handle_predicate_error(e)
+      end
+
+      private def handle_predicate_error(error)
+        warn "Predicate error: #{error.message}"
+        warn error.backtrace.first(5).join("\n") if config.error_mode == :debug
+        exit 2
+      end
+    end
+  end
+end

data/lib/simplecov_mcp/commands/version_command.rb

@@ -2,17 +2,32 @@
 
 require 'json'
 require_relative 'base_command'
+require_relative '../table_formatter'
 
 module SimpleCovMcp
   module Commands
     class VersionCommand < BaseCommand
-      def execute(args)
-        if config.json
-          puts JSON.pretty_generate({ version: SimpleCovMcp::VERSION })
+      def execute(_args)
+        @gem_root = File.expand_path('../../..', __dir__)
+
+        if config.format == :table
+          data = {
+            'Version' => SimpleCovMcp::VERSION,
+            'Gem Root' => @gem_root,
+            'Documentation' => 'README.md and docs/user/**/*.md in gem root'
+          }
+          puts TableFormatter.format_vertical(data)
         else
-          puts "SimpleCovMcp version #{SimpleCovMcp::VERSION}"
+          puts SimpleCovMcp::Formatters.format(version_info, config.format)
         end
       end
+
+      private def version_info
+        {
+          version: SimpleCovMcp::VERSION,
+          gem_root: @gem_root
+        }
+      end
     end
   end
 end

data/lib/simplecov_mcp/config_parser.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative 'app_config'
+require_relative 'option_parser_builder'
+
+module SimpleCovMcp
+  # Centralized configuration parser for both CLI and MCP modes
+  # Parses argv (which should already include environment options merged by caller)
+  class ConfigParser
+    attr_reader :config, :argv
+
+    def initialize(argv)
+      @argv = argv
+      @config = AppConfig.new
+    end
+
+    # Parse argv (with env opts already merged) and return config
+    # @param argv [Array<String>] command-line arguments (should include env opts if needed)
+    # @return [AppConfig] populated configuration object
+    def self.parse(argv)
+      new(argv).parse
+    end
+
+    def parse
+      # Build and execute the option parser
+      parser = OptionParserBuilder.new(config).build_option_parser
+      parser.parse!(argv)
+
+      config
+    end
+  end
+end

data/lib/simplecov_mcp/constants.rb

@@ -9,14 +9,14 @@ module SimpleCovMcp
     OPTIONS_EXPECTING_ARGUMENT = %w[
       -r --resultset
       -R --root
+      -f --format
       -o --sort-order
       -s --source
-      -c --source-context
-      -S --stale
+      -c --context-lines
+      -S --staleness
       -g --tracked-globs
       -l --log-file
       --error-mode
-      --success-predicate
     ].freeze
   end
 end

data/lib/simplecov_mcp/coverage_reporter.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module SimpleCovMcp
+  # Reports files with coverage below a specified threshold.
+  # Useful for displaying low coverage files after test runs.
+  #
+  # @example Basic usage in spec_helper.rb
+  #   SimpleCov.at_exit do
+  #     SimpleCov.result.format!
+  #     report = SimpleCovMcp::CoverageReporter.report(threshold: 80, count: 5)
+  #     puts report if report
+  #   end
+  #
+  module CoverageReporter
+    module_function def report(threshold: 80, count: 5, model: nil)
+      model ||= CoverageModel.new
+      file_list = model.all_files(sort_order: :ascending)
+        .select { |f| f['percentage'] < threshold }
+        .first(count)
+      file_list = model.relativize(file_list)
+
+      return nil if file_list.empty?
+
+      lines = ["\nLowest coverage files (< #{threshold}%):"]
+      file_list.each do |f|
+        lines << format('  %5.1f%%  %s', f['percentage'], f['file'])
+      end
+      lines.join("\n")
+    end
+  end
+end

data/lib/simplecov_mcp/error_handler.rb

@@ -9,9 +9,9 @@ module SimpleCovMcp
   class ErrorHandler
     attr_accessor :error_mode, :logger
 
-    VALID_ERROR_MODES = [:off, :on, :trace].freeze
+    VALID_ERROR_MODES = [:off, :log, :debug].freeze
 
-    def initialize(error_mode: :on, logger: nil)
+    def initialize(error_mode: :log, logger: nil)
       unless VALID_ERROR_MODES.include?(error_mode)
         raise ArgumentError, "Invalid error_mode: #{error_mode.inspect}. Valid modes: #{VALID_ERROR_MODES.inspect}"
       end
@@ -25,7 +25,7 @@ module SimpleCovMcp
     end
 
     def show_stack_traces?
-      error_mode == :trace
+      error_mode == :debug
     end
 
     # Handle an error with appropriate logging and re-raising behavior
@@ -36,54 +36,94 @@ module SimpleCovMcp
       end
     end
 
-    # Convert standard Ruby errors to user-friendly custom errors
-    def convert_standard_error(error)
+    # Convert standard Ruby errors to user-friendly custom errors.
+    # @param error [Exception] the error to convert
+    # @param context [Symbol] :general (default) or :coverage_loading for context-specific messages
+    def convert_standard_error(error, context: :general)
       case error
       when Errno::ENOENT
-        filename = extract_filename(error.message)
-        FileNotFoundError.new("File not found: #{filename}", error)
+        convert_enoent(error, context)
       when Errno::EACCES
-        filename = extract_filename(error.message)
-        FilePermissionError.new("Permission denied accessing file: #{filename}", error)
+        convert_eacces(error, context)
       when Errno::EISDIR
         filename = extract_filename(error.message)
         NotAFileError.new("Expected file but found directory: #{filename}", error)
       when JSON::ParserError
-        CoverageDataError.new("Invalid coverage data format - JSON parsing failed: #{error.message}", error)
+        CoverageDataError.new("Invalid coverage data format: #{error.message}", error)
+      when TypeError
+        CoverageDataError.new("Invalid coverage data structure: #{error.message}", error)
       when ArgumentError
-        if error.message.include?('wrong number of arguments')
-          UsageError.new("Invalid number of arguments: #{error.message}", error)
-        else
-          ConfigurationError.new("Invalid configuration: #{error.message}", error)
-        end
+        convert_argument_error(error, context)
       when NoMethodError
+        convert_no_method_error(error, context)
+      when RuntimeError
+        convert_runtime_error(error, context)
+      else
+        Error.new("An unexpected error occurred: #{error.message}", error)
+      end
+    end
+
+    private def convert_enoent(error, context)
+      if context == :coverage_loading
+        ResultsetNotFoundError.new('Coverage data not found', error)
+      else
+        filename = extract_filename(error.message)
+        FileNotFoundError.new("File not found: #{filename}", error)
+      end
+    end
+
+    private def convert_eacces(error, context)
+      if context == :coverage_loading
+        FilePermissionError.new("Permission denied reading coverage data: #{error.message}", error)
+      else
+        filename = extract_filename(error.message)
+        FilePermissionError.new("Permission denied accessing file: #{filename}", error)
+      end
+    end
+
+    private def convert_argument_error(error, context)
+      if context == :coverage_loading
+        CoverageDataError.new("Invalid path in coverage data: #{error.message}", error)
+      elsif error.message.include?('wrong number of arguments')
+        UsageError.new("Invalid number of arguments: #{error.message}", error)
+      else
+        ConfigurationError.new("Invalid configuration: #{error.message}", error)
+      end
+    end
+
+    private def convert_no_method_error(error, context)
+      if context == :coverage_loading
+        CoverageDataError.new("Invalid coverage data structure: #{error.message}", error)
+      else
         method_info = extract_method_info(error.message)
         CoverageDataError.new("Invalid coverage data structure - #{method_info}", error)
-      when RuntimeError, StandardError
-        # Handle string errors from CovUtil and other runtime errors
-        if error.message.include?('Could not find .resultset.json')
-          # Extract directory info if available
-          dir_info = error.message.match(/under (.+?)(?:;|$)/)&.[](1) || 'project directory'
-          CoverageDataError.new("Coverage data not found in #{dir_info} - please run your tests first", error)
-        elsif error.message.include?('No .resultset.json found in directory')
-          # Extract directory from error message
-          dir_info = error.message.match(/directory: (.+)$/)&.[](1) || 'specified directory'
-          CoverageDataError.new("Coverage data not found in directory: #{dir_info}", error)
-        elsif error.message.include?('Specified resultset not found')
-          # Extract path from error message
-          path_info = error.message.match(/not found: (.+)$/)&.[](1) || 'specified path'
-          ResultsetNotFoundError.new("Resultset file not found: #{path_info}", error)
+      end
+    end
+
+    private def convert_runtime_error(error, context)
+      message = error.message
+      if message.include?('Could not find .resultset.json')
+        dir_info = message.match(/under (.+?)(?:;|$)/)&.[](1) || 'project directory'
+        CoverageDataError.new(
+          "Coverage data not found in #{dir_info} - please run your tests first", error)
+      elsif message.include?('No .resultset.json found in directory')
+        dir_info = message.match(/directory: (.+)$/)&.[](1) || 'specified directory'
+        CoverageDataError.new("Coverage data not found in directory: #{dir_info}", error)
+      elsif message.include?('Specified resultset not found')
+        # Preserve the original message format for consistency with existing tests
+        ResultsetNotFoundError.new(message, error)
+      elsif context == :coverage_loading
+        if message.downcase.include?('resultset')
+          ResultsetNotFoundError.new(message, error)
         else
-          Error.new("An unexpected error occurred: #{error.message}", error)
+          CoverageDataError.new("Failed to load coverage data: #{message}", error)
         end
       else
-        Error.new("An unexpected error occurred: #{error.message}", error)
+        Error.new("An unexpected error occurred: #{message}", error)
       end
     end
 
-    private
-
-    def log_error(error, context)
+    private def log_error(error, context)
       return unless log_errors?
 
       message = build_log_message(error, context)
@@ -94,8 +134,9 @@ module SimpleCovMcp
       end
     end
 
-    def build_log_message(error, context)
-      parts = ["Error#{context ? " in #{context}" : ''}: #{error.class}: #{error.message}"]
+    private def build_log_message(error, context)
+      context_suffix = context ? " in #{context}" : ''
+      parts = ["Error#{context_suffix}: #{error.class}: #{error.message}"]
 
       if show_stack_traces? && error.backtrace
         parts << error.backtrace.join("\n")
@@ -104,15 +145,15 @@ module SimpleCovMcp
       parts.join("\n")
     end
 
-    def extract_filename(message)
+    private def extract_filename(message)
       # Extract filename from "No such file or directory @ rb_sysopen - filename"
       match = message.match(/@ \w+ - (.+)$/)
       match ? match[1] : 'unknown file'
     end
 
-    def extract_method_info(message)
-      # Extract method info from "undefined method `foo' for #<Object:0x...>"
-      if match = message.match(/undefined method `(.+?)' for (.+)$/)
+    private def extract_method_info(message)
+      match = message.match(/undefined method `(.+?)' for (.+)$/)
+      if match
         method_name = match[1]
         object_info = match[2].gsub(/#<.*?>/, 'object')
         "missing method '#{method_name}' on #{object_info}"

data/lib/simplecov_mcp/error_handler_factory.rb

@@ -8,7 +8,7 @@ module SimpleCovMcp
     # - Logs errors for debugging
     # - Shows stack traces only when explicitly requested
     # - Suitable for user-facing command line interface
-    def self.for_cli(error_mode: :on)
+    def self.for_cli(error_mode: :log)
       ErrorHandler.new(error_mode: error_mode)
     end
 
@@ -24,7 +24,7 @@ module SimpleCovMcp
     # - Logs errors for server debugging
     # - Shows stack traces only when explicitly requested
     # - Suitable for long-running server processes
-    def self.for_mcp_server(error_mode: :on)
+    def self.for_mcp_server(error_mode: :log)
       ErrorHandler.new(error_mode: error_mode)
     end
   end

data/lib/simplecov_mcp/errors.rb

@@ -14,33 +14,31 @@ module SimpleCovMcp
       message
     end
 
-    protected
-
-    def format_epoch_both(epoch_seconds)
+    protected def format_epoch_both(epoch_seconds)
       return [nil, nil] unless epoch_seconds
 
       t = Time.at(epoch_seconds.to_i)
       [t.utc.iso8601, t.getlocal.iso8601]
-    rescue StandardError
+    rescue
       [epoch_seconds.to_s, epoch_seconds.to_s]
     end
 
-    def format_time_both(time)
+    protected def format_time_both(time)
       return [nil, nil] unless time
 
       t = time.is_a?(Time) ? time : Time.parse(time.to_s)
       [t.utc.iso8601, t.getlocal.iso8601]
-    rescue StandardError
+    rescue
       [time.to_s, time.to_s]
     end
 
-    def format_delta_seconds(file_mtime, cov_timestamp)
+    protected def format_delta_seconds(file_mtime, cov_timestamp)
       return nil unless file_mtime && cov_timestamp
 
       seconds = file_mtime.to_i - cov_timestamp.to_i
       sign = seconds >= 0 ? '+' : '-'
       "#{sign}#{seconds.abs}s"
-    rescue StandardError
+    rescue
       nil
     end
   end
@@ -63,7 +61,26 @@ module SimpleCovMcp
   class FileNotFoundError < FileError; end
   class FilePermissionError < FileError; end
   class NotAFileError < FileError; end
-  class ResultsetNotFoundError < FileError; end
+
+  class ResultsetNotFoundError < FileError
+    def user_friendly_message
+      base = "File error: #{message}"
+
+      # Only add helpful tips in CLI and library modes, not MCP mode
+      unless SimpleCovMcp.context.mcp_mode?
+        base += <<~HELP
+
+
+          Try one of the following:
+            - cd to a directory containing coverage/.resultset.json
+            - Specify a resultset: simplecov-mcp -r PATH
+            - Use -h for help: simplecov-mcp -h
+        HELP
+      end
+
+      base
+    end
+  end
 
   # Coverage data related errors
   class CoverageDataError < Error
@@ -78,28 +95,25 @@ module SimpleCovMcp
 
     def initialize(message = nil, original_error = nil, file_path: nil, file_mtime: nil,
       cov_timestamp: nil, src_len: nil, cov_len: nil, resultset_path: nil)
-      super(message, original_error)
       @file_path = file_path
       @file_mtime = file_mtime
       @cov_timestamp = cov_timestamp
       @src_len = src_len
       @cov_len = cov_len
       @resultset_path = resultset_path
+      super(message || default_message, original_error)
     end
 
     def user_friendly_message
-      base = "Coverage data stale: #{message || default_message}"
-      base + build_details
+      "Coverage data stale: #{message}" + build_details
     end
 
-    private
-
-    def default_message
+    private def default_message
       fp = file_path || 'file'
       "Coverage data appears stale for #{fp}"
     end
 
-    def build_details
+    private def build_details
       file_utc, file_local = format_time_both(@file_mtime)
       cov_utc,  cov_local  = format_epoch_both(@cov_timestamp)
       delta_str = format_delta_seconds(@file_mtime, @cov_timestamp)
@@ -136,13 +150,11 @@ module SimpleCovMcp
       base + build_details
     end
 
-    private
-
-    def default_message
+    private def default_message
       'Coverage data appears stale for project'
     end
 
-    def build_details
+    private def build_details
       cov_utc, cov_local = format_epoch_both(@cov_timestamp)
       parts = []
       parts << "\nCoverage  - time: #{cov_utc || 'not found'} (local #{cov_local || 'n/a'})"