cov-loupe 3.0.0 → 4.0.0.pre

data/lib/cov_loupe/base_tool.rb

@@ -2,8 +2,12 @@
 
 require 'mcp'
 require 'json'
-require_relative 'errors'
-require_relative 'error_handler'
+require_relative 'errors/errors'
+require_relative 'errors/error_handler'
+require_relative 'model/model'
+require_relative 'presenters/coverage_payload_presenter'
+require_relative 'output_chars'
+require_relative 'config/option_normalizers'
 
 module CovLoupe
   class BaseTool < ::MCP::Tool
@@ -18,19 +22,26 @@ module CovLoupe
         type: 'string',
         description: 'Path to the SimpleCov .resultset.json file (absolute or relative to root).'
       },
-      staleness: {
-        type: 'string',
-        description: 'How to handle missing/outdated coverage data. ' \
-                     "'off' skips checks; 'error' raises.",
-        enum: [:off, :error],
-        default: :off
+      raise_on_stale: {
+        type: 'boolean',
+        description: 'If true, raise error if coverage data is stale (missing files, ' \
+          'timestamp mismatch). Defaults to false.',
+        default: false
       },
       error_mode: {
         type: 'string',
         description: "Error handling mode: 'off' (silent), 'log' (log errors), " \
-            "'debug' (verbose with backtraces).",
+                     "'debug' (verbose with backtraces).",
         enum: %w[off log debug],
         default: 'log'
+      },
+      output_chars: {
+        type: 'string',
+        description: "Output character mode: 'default' (UTF-8 encoding uses fancy, else ascii), " \
+                     "'fancy' (Unicode box-drawing and symbols), 'ascii' (ASCII-only 0x00-0x7F). " \
+                     'Accepts: d[efault], f[ancy], a[scii].',
+        enum: %w[default fancy ascii d f a],
+        default: 'default'
       }
     }.freeze
 
@@ -43,6 +54,17 @@ module CovLoupe
       items: { type: 'string' }
     }.freeze
 
+    DEFAULT_SORT_ORDER = CoverageModel::DEFAULT_SORT_ORDER.to_s
+
+    SORT_ORDER_PROPERTY = {
+      type: 'string',
+      description: 'Sort order for coverage percentages. ' \
+                   "'#{DEFAULT_SORT_ORDER}' (default) lists highest coverage first. " \
+                   'Accepts: a[scending], d[escending].',
+      default: DEFAULT_SORT_ORDER,
+      enum: %w[ascending descending a d]
+    }.freeze
+
     PATH_PROPERTY = {
       type: 'string',
       description: 'Repo-relative or absolute path to the file whose coverage data you need.',
@@ -50,12 +72,13 @@ module CovLoupe
     }.freeze
 
     def self.coverage_schema(additional_properties: {}, required: [])
-      {
+      schema = {
         type: 'object',
         additionalProperties: false,
-        properties: COMMON_PROPERTIES.merge(additional_properties),
-        required: required
-      }.freeze
+        properties: COMMON_PROPERTIES.merge(additional_properties)
+      }
+      schema[:required] = required unless required.empty?
+      schema.freeze
     end
 
     FILE_INPUT_SCHEMA = coverage_schema(
@@ -67,36 +90,222 @@ module CovLoupe
     # Wrap tool execution with consistent error handling.
     # Yields to the block and rescues any error, delegating to handle_mcp_error.
     # This eliminates duplicate rescue blocks across all tools.
-    def self.with_error_handling(tool_name, error_mode:)
+    #
+    # @param tool_name [String] Name of the tool for error reporting
+    # @param error_mode [Symbol, String] Error handling mode (:off, :log, :debug)
+    # @param output_chars [Symbol, String, nil] Output character mode for error messages
+    def self.with_error_handling(tool_name, error_mode:, output_chars: :default)
       yield
     rescue => e
-      handle_mcp_error(e, tool_name, error_mode: error_mode)
+      handle_mcp_error(e, tool_name, error_mode: error_mode, output_chars: output_chars)
     end
 
     # Handle errors consistently across all MCP tools
     # Returns an MCP::Tool::Response with appropriate error message
-    def self.handle_mcp_error(error, tool_name, error_mode: :log)
+    #
+    # @param error [Exception] The error to handle
+    # @param tool_name [String] Name of the tool for error reporting
+    # @param error_mode [Symbol, String] Error handling mode
+    # @param output_chars [Symbol, String, nil] Output character mode for error messages
+    # @return [MCP::Tool::Response] Error response
+    def self.handle_mcp_error(error, tool_name, error_mode: :log, output_chars: :default)
+      # Safely normalize error_mode to a symbol, defaulting to :log for invalid inputs
+      # This prevents crashes when MCP clients send invalid types (null, numbers, objects, etc.)
+      safe_mode = case error_mode
+                  when Symbol then error_mode
+                  when String then error_mode.to_sym
+                  else :log
+      end
+
+      # Validate against VALID_ERROR_MODES and fallback to :log if invalid
+      # This prevents ArgumentError when handling errors with invalid error_mode values
+      safe_mode = :log unless ErrorHandler::VALID_ERROR_MODES.include?(safe_mode)
+
       # Create error handler with the specified mode
-      error_handler = ErrorHandlerFactory.for_mcp_server(error_mode: error_mode.to_sym)
+      error_handler = ErrorHandlerFactory.for_mcp_server(error_mode: safe_mode)
 
       # Normalize to a CovLoupe::Error so we can handle/log uniformly
       normalized = error.is_a?(CovLoupe::Error) \
         ? error : error_handler.convert_standard_error(error)
       log_mcp_error(normalized, tool_name, error_handler)
-      ::MCP::Tool::Response.new([{ 'type' => 'text', 'text' => "Error: #{normalized.user_friendly_message}" }])
+
+      # Convert error message to ASCII if needed
+      error_message = normalized.user_friendly_message
+      error_message = OutputChars.convert(error_message, output_chars || :default)
+      ::MCP::Tool::Response.new([{ 'type' => 'text', 'text' => "Error: #{error_message}" }])
     end
 
     # Respond with JSON as a resource to avoid clients mutating content types.
     # The resource embeds the JSON string with a clear MIME type.
-    def self.respond_json(payload, name: 'data.json', pretty: false)
-      json = pretty ? JSON.pretty_generate(payload) : JSON.generate(payload)
+    #
+    # @param payload [Object] The data to serialize as JSON
+    # @param name [String] Logical name for the JSON resource (informational)
+    # @param pretty [Boolean] Use pretty formatting with indentation
+    # @param output_chars [Symbol, String, nil] Output character mode (:default, :fancy, :ascii)
+    # @return [MCP::Tool::Response] Response containing the JSON string
+    def self.respond_json(payload, name: 'data.json', pretty: false, output_chars: :default)
+      ascii_only = ascii_only?(output_chars)
+      json = if pretty
+        ascii_only ? JSON.pretty_generate(payload, ascii_only: true) : JSON.pretty_generate(payload)
+      else
+        ascii_only ? JSON.generate(payload, ascii_only: true) : JSON.generate(payload)
+      end
       ::MCP::Tool::Response.new([{ 'type' => 'text', 'text' => json }])
     end
 
+    # Determines if ASCII-only output is required based on the character mode setting.
+    # Normalizes string inputs to symbols (MCP JSON provides strings, internal code uses symbols).
+    # Uses strict validation to raise errors for invalid values.
+    #
+    # @param char_mode [Symbol, String, nil] The character mode (:default, :fancy, :ascii)
+    # @return [Boolean] true if ASCII-only output is required
+    # @raise [CovLoupe::UsageError] if char_mode is invalid
+    def self.ascii_only?(char_mode)
+      return false if char_mode.nil?
+
+      normalized_mode_name = normalize_output_chars_strict(char_mode)
+      OutputChars.ascii_mode?(normalized_mode_name)
+    end
+    private_class_method :ascii_only?
+
     def self.log_mcp_error(error, tool_name, error_handler)
       # Use the provided error handler for logging
       error_handler.send(:log_error, error, tool_name)
     end
     private_class_method :log_mcp_error
+
+    # Merges configuration from server context (CLI flags) with explicit tool parameters (JSON).
+    # Explicit parameters take precedence over context config, which takes precedence over defaults.
+    # @param server_context [AppContext] The server context containing app_config from CLI
+    # @param model_option_overrides [Hash] Tool call parameters that override model defaults
+    # @return [Hash] Merged configuration for CoverageModel initialization
+    def self.model_config_for(server_context:, **model_option_overrides)
+      # Start with config from context (CLI flags) or hardcoded defaults
+      base = server_context.app_config&.model_options || default_model_options
+
+      # Merge explicit params from JSON, removing nils
+      # (nil means "not provided", so use base config)
+      base.merge(model_option_overrides.compact)
+    end
+
+    # Creates and configures a CoverageModel instance.
+    # Encapsulates the common pattern of merging config and initializing the model.
+    # @param server_context [AppContext] The server context
+    # @param model_option_overrides [Hash] Tool call parameters that override model defaults
+    # @return [CoverageModel] The configured model
+    def self.create_model(server_context:, **model_option_overrides)
+      model, _config = create_configured_model(server_context: server_context,
+        **model_option_overrides)
+      model
+    end
+
+    # Creates and configures a CoverageModel instance, returning both the model and the configuration.
+    # Useful when the tool needs access to the resolved configuration (e.g., root, raise_on_stale).
+    #
+    # Models are now lightweight (data is loaded lazily via ModelDataCache), so we create
+    # a fresh instance on each call rather than caching at the model level.
+    #
+    # @param server_context [AppContext] The server context
+    # @param model_option_overrides [Hash] Tool call parameters that override model defaults
+    # @return [Array<CoverageModel, Hash>] The configured model and the configuration hash
+    def self.create_configured_model(server_context:, **model_option_overrides)
+      config = model_config_for(server_context: server_context, **model_option_overrides)
+      model = CoverageModel.new(**config)
+      [model, config]
+    end
+
+    # Default configuration when no context or explicit params are provided
+    def self.default_model_options
+      { root: '.', resultset: nil, raise_on_stale: false, tracked_globs: [] }
+    end
+
+    # Resolves output_chars from tool parameter or server context.
+    # Tool parameter takes precedence over server context config.
+    # Uses strict validation for tool parameters to catch invalid values.
+    #
+    # @param output_chars [String, Symbol, nil] Tool parameter value
+    # @param server_context [AppContext] Server context with app_config
+    # @return [Symbol] Normalized output_chars mode (:default, :fancy, or :ascii)
+    # @raise [CovLoupe::UsageError] if output_chars parameter is invalid
+    def self.resolve_output_chars(output_chars, server_context)
+      # Use explicit parameter if provided
+      return normalize_output_chars_strict(output_chars) if output_chars
+
+      # Fall back to server context config
+      server_context.app_config&.output_chars || :default
+    end
+
+    # Normalizes output_chars value with strict validation.
+    # Converts string inputs to symbols and validates against allowed values.
+    #
+    # @param value [String, Symbol, nil] The output_chars value to normalize
+    # @return [Symbol] Normalized output_chars mode (:default, :fancy, or :ascii)
+    # @raise [CovLoupe::UsageError] if value is invalid
+    def self.normalize_output_chars_strict(value)
+      case value
+      when Symbol then value
+      when String
+        begin
+          OptionNormalizers.normalize_output_chars(value, strict: true)
+        rescue OptionParser::InvalidArgument
+          raise CovLoupe::UsageError, "Invalid output_chars value: #{value.inspect}. " \
+            'Must be one of: default, fancy, ascii (or abbreviations: d, f, a)'
+        end
+      else
+        raise CovLoupe::UsageError, "Invalid output_chars type: #{value.class.name}. " \
+          'Must be a string (one of: default, fancy, ascii, or abbreviations: d, f, a)'
+      end
+    end
+    private_class_method :normalize_output_chars_strict
+
+    # Runs a file-based tool request by deriving payload method and JSON name from the tool class.
+    # @param path [String] File path to analyze
+    # @param error_mode [String] Error handling mode
+    # @param output_chars [String, Symbol, nil] Output character mode
+    # @param server_context [AppContext] Server context
+    # @param model_option_overrides [Hash] Tool call parameters that override model defaults
+    # @return [MCP::Tool::Response] JSON response
+    def self.call_with_file_payload(path:, error_mode:, server_context:, output_chars: nil,
+      **model_option_overrides)
+      tool_name = name.split('::').last
+      output_chars_sym = resolve_output_chars(output_chars, server_context)
+
+      with_error_handling(tool_name, error_mode: error_mode, output_chars: output_chars_sym) do
+        model, config = create_configured_model(server_context: server_context,
+          **model_option_overrides)
+        presenter = Presenters::CoveragePayloadPresenter.new(
+          model: model,
+          path: path,
+          payload_method: payload_method_for(tool_name),
+          raise_on_stale: config[:raise_on_stale]
+        )
+        respond_json(presenter.relativized_payload, name: json_name_for(tool_name), pretty: true,
+          output_chars: output_chars_sym)
+      end
+    end
+
+    # Infer CoverageModel method name from a tool class name.
+    # CoverageSummaryTool -> :summary_for, CoverageRawTool -> :raw_for,
+    # CoverageDetailedTool -> :detailed_for, UncoveredLinesTool -> :uncovered_for.
+    def self.payload_method_for(tool_name)
+      base = tool_name.sub(/Tool\z/, '')
+      underscored = underscore(base).sub(/\Acoverage_/, '').sub(/_lines\z/, '')
+      :"#{underscored}_for"
+    end
+
+    # Infer the MCP JSON resource name from a tool class name.
+    # CoverageSummaryTool -> coverage_summary.json, UncoveredLinesTool -> uncovered_lines.json.
+    def self.json_name_for(tool_name)
+      "#{underscore(tool_name.sub(/Tool\z/, ''))}.json"
+    end
+
+    # Minimal underscore helper to avoid pulling in ActiveSupport.
+    def self.underscore(value)
+      value
+        .gsub(/([A-Z]+)([A-Z][a-z])/, '\\1_\\2')
+        .gsub(/([a-z\\d])([A-Z])/, '\\1_\\2')
+        .downcase
+    end
+    private_class_method :payload_method_for, :json_name_for, :underscore
   end
 end

data/lib/cov_loupe/cli.rb

@@ -1,21 +1,20 @@
 # frozen_string_literal: true
 
 require 'json'
-require_relative 'app_config'
-require_relative 'option_parser_builder'
+require_relative 'config/app_config'
+require_relative 'config/option_parser_builder'
 require_relative 'commands/command_factory'
 require_relative 'option_parsers/error_helper'
 require_relative 'option_parsers/env_options_parser'
-require_relative 'constants'
 require_relative 'presenters/project_coverage_presenter'
+require_relative 'output_chars'
 
 module CovLoupe
   class CoverageCLI
-    SUBCOMMANDS = %w[list summary raw uncovered detailed totals validate version].freeze
     HORIZONTAL_RULE = '-' * 79
 
-    # Reference shared constant to avoid duplication with ModeDetector
-    OPTIONS_EXPECTING_ARGUMENT = Constants::OPTIONS_EXPECTING_ARGUMENT
+    # Valid CLI subcommands.
+    SUBCOMMANDS = %w[list summary raw uncovered detailed totals validate version].freeze
 
     attr_reader :config
 
@@ -44,6 +43,7 @@ module CovLoupe
       )
 
       CovLoupe.with_context(context) do
+        log_cli_params
         if @cmd
           run_subcommand(@cmd, @cmd_args)
         else
@@ -58,28 +58,49 @@ module CovLoupe
       with_context_if_available(context) { handle_user_facing_error(e) }
     end
 
+    private def log_cli_params
+      # Log CLI parameters for transparency
+      if CovLoupe.logger
+        params = { mode: :cli, subcommand: @cmd || 'default' }
+        params[:root] = config.root if config.root
+        params[:resultset] = config.resultset if config.resultset
+        params[:format] = config.format if config.format
+        params[:sort_order] = config.sort_order if config.sort_order
+        params[:raise_on_stale] = config.raise_on_stale if config.raise_on_stale
+        params[:tracked_globs] = config.tracked_globs if config.tracked_globs&.any?
+        params[:error_mode] = config.error_mode if config.error_mode
+        CovLoupe.logger.info("CLI parameters: #{params.inspect}")
+      end
+    end
+
     def show_default_report(sort_order: :descending, output: $stdout)
       model = CoverageModel.new(**config.model_options)
       presenter = Presenters::ProjectCoveragePresenter.new(
         model: model,
         sort_order: sort_order,
-        check_stale: (config.staleness == :error),
+        raise_on_stale: config.raise_on_stale,
         tracked_globs: config.tracked_globs
       )
 
-      if config.format != :table
-        require_relative 'formatters'
-        output.puts Formatters.format(presenter.relativized_payload, config.format)
-        return
+      if config.format == :table
+        file_summaries = presenter.relative_files
+        output.puts model.format_table(
+          file_summaries,
+          sort_order: sort_order,
+          raise_on_stale: config.raise_on_stale,
+          tracked_globs: nil,
+          output_chars: config.output_chars
+        )
+        show_exclusions_summary(presenter, $stderr)
+        warn_missing_timestamps(presenter, $stderr)
+      else
+        require_relative 'formatters/formatters'
+        output.puts Formatters.format(presenter.relativized_payload, config.format,
+          output_chars: config.output_chars)
       end
 
-      file_summaries = presenter.relative_files
-      output.puts model.format_table(
-        file_summaries,
-        sort_order: sort_order,
-        check_stale: (config.staleness == :error),
-        tracked_globs: nil
-      )
+      warn_skipped_rows(presenter)
+      warn_missing_timestamps(presenter)
     end
 
     private def parse_options!(argv)
@@ -149,16 +170,21 @@ module CovLoupe
 
     private def handle_option_parser_error(error, argv: [])
       @error_helper ||= OptionParsers::ErrorHelper.new(SUBCOMMANDS)
-      @error_helper.handle_option_parser_error(error, argv: argv)
+      @error_helper.handle_option_parser_error(error, argv: argv, output_chars: config.output_chars)
     end
 
     private def check_for_misplaced_global_options(cmd, args)
       # Global options that users commonly place after subcommands by mistake
       global_options = %w[-r --resultset -R --root -f --format -o --sort-order -s --source
-                          -c --context-lines -S --staleness -g --tracked-globs
-                          -l --log-file --error-mode --color --no-color]
+                          -c --context-lines -S --raise-on-stale -g --tracked-globs
+                          -l --log-file --error-mode --color -m --mode -v --version
+                          -O --output-chars]
 
-      misplaced = args.select { |arg| global_options.include?(arg) }
+      misplaced = args.select do |arg|
+        # Extract base option (e.g., --format from --format=json)
+        base = arg.split('=', 2).first
+        global_options.include?(base)
+      end
       return if misplaced.empty?
 
       option_list = misplaced.join(', ')
@@ -170,9 +196,92 @@ module CovLoupe
 
     private def handle_user_facing_error(error)
       error_handler.handle_error(error, context: 'CLI', reraise: false)
-      warn error.user_friendly_message
+      # Convert error message to ASCII if in ascii mode
+      message = OutputChars.convert(error.user_friendly_message, config.output_chars)
+      warn message
       warn error.backtrace.first(5).join("\n") if config.error_mode == :debug && error.backtrace
       exit 1
     end
+
+    private def warn_skipped_rows(presenter)
+      skipped = presenter.relative_skipped_files
+      return if skipped.nil? || skipped.empty?
+
+      count = skipped.length
+      warn ''
+      warn "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'], config.output_chars)
+        error_msg = OutputChars.convert(row['error'], config.output_chars)
+        warn "  - #{file_path}: #{error_msg}"
+      end
+      warn 'Run again with --raise-on-stale to exit when rows are skipped.'
+    end
+
+    private def warn_missing_timestamps(presenter, output = $stderr)
+      return unless presenter.timestamp_status == 'missing'
+
+      output.puts <<~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
+
+    private def show_exclusions_summary(presenter, output)
+      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 show if there are any exclusions
+      return if missing.empty? && newer.empty? && deleted.empty? &&
+                length_mismatch.empty? && unreadable.empty? && skipped.empty?
+
+      output.puts "\nFiles excluded from coverage:"
+
+      # Helper to convert paths to ASCII if needed
+      convert_path = ->(path) { OutputChars.convert(path, config.output_chars) }
+
+      unless missing.empty?
+        output.puts "\nMissing tracked files (#{missing.length}):"
+        missing.each { |file| output.puts "  - #{convert_path.call(file)}" }
+      end
+
+      unless newer.empty?
+        output.puts "\nFiles newer than coverage (#{newer.length}):"
+        newer.each { |file| output.puts "  - #{convert_path.call(file)}" }
+      end
+
+      unless deleted.empty?
+        output.puts "\nDeleted files with coverage (#{deleted.length}):"
+        deleted.each { |file| output.puts "  - #{convert_path.call(file)}" }
+      end
+
+      unless length_mismatch.empty?
+        output.puts "\nLine count mismatches (#{length_mismatch.length}):"
+        length_mismatch.each { |file| output.puts "  - #{convert_path.call(file)}" }
+      end
+
+      unless unreadable.empty?
+        output.puts "\nUnreadable files (#{unreadable.length}):"
+        unreadable.each { |file| output.puts "  - #{convert_path.call(file)}" }
+      end
+
+      unless skipped.empty?
+        output.puts "\nFiles skipped due to errors (#{skipped.length}):"
+        skipped.each do |row|
+          file_path = OutputChars.convert(row['file'], config.output_chars)
+          error_msg = OutputChars.convert(row['error'], config.output_chars)
+          output.puts "  - #{file_path}: #{error_msg}"
+        end
+      end
+
+      output.puts "\nRun with --raise-on-stale to exit when files are excluded."
+    end
   end
 end

data/lib/cov_loupe/commands/base_command.rb

@@ -1,10 +1,11 @@
 # frozen_string_literal: true
 
 require 'json'
-require_relative '../formatters'
+require_relative '../formatters/formatters'
 require_relative '../formatters/source_formatter'
-require_relative '../model'
-require_relative '../errors'
+require_relative '../model/model'
+require_relative '../errors/errors'
+require_relative '../output_chars'
 
 module CovLoupe
   module Commands
@@ -23,8 +24,14 @@ module CovLoupe
         @model ||= CoverageModel.new(**config.model_options)
       end
 
+      # Convert text to ASCII if output_chars is :ascii
+      protected def convert_text(text)
+        OutputChars.convert(text, config.output_chars)
+      end
+
       protected def handle_with_path(args, name)
         path = args.shift or raise UsageError.for_subcommand("#{name} <path>")
+        reject_extra_args(args, name)
         yield(path)
       rescue Errno::ENOENT
         raise FileNotFoundError, "File not found: #{path}"
@@ -32,10 +39,20 @@ module CovLoupe
         raise FilePermissionError, "Permission denied: #{path}"
       end
 
+      # Validates that no unexpected arguments remain after parsing.
+      # Raises UsageError if extra args are present.
+      protected def reject_extra_args(args, command_name)
+        return if args.empty?
+
+        extra = args.join(' ')
+        raise UsageError, "Unexpected argument(s) for '#{command_name}': #{extra}"
+      end
+
       protected def maybe_output_structured_format?(obj, model)
         return false if config.format == :table
 
-        puts CovLoupe::Formatters.format(model.relativize(obj), config.format)
+        puts CovLoupe::Formatters.format(model.relativize(obj), config.format,
+          output_chars: config.output_chars)
         true
       end
 
@@ -45,9 +62,11 @@ module CovLoupe
         relativized = model.relativize(data)
         if config.source_mode
           payload = relativized.merge('source' => build_source_payload(model, path))
-          puts CovLoupe::Formatters.format(payload, config.format)
+          puts CovLoupe::Formatters.format(payload, config.format,
+            output_chars: config.output_chars)
         else
-          puts CovLoupe::Formatters.format(relativized, config.format)
+          puts CovLoupe::Formatters.format(relativized, config.format,
+            output_chars: config.output_chars)
         end
         true
       end

data/lib/cov_loupe/commands/command_factory.rb

@@ -21,7 +21,6 @@ module CovLoupe
         'uncovered' => UncoveredCommand,
         'detailed' => DetailedCommand,
         'totals' => TotalsCommand,
-        'total' => TotalsCommand, # Alias for backward compatibility
         'validate' => ValidateCommand
       }.freeze
 

data/lib/cov_loupe/commands/detailed_command.rb

@@ -2,20 +2,24 @@
 
 require_relative 'base_command'
 require_relative '../formatters/source_formatter'
-require_relative '../presenters/coverage_detailed_presenter'
-require_relative '../table_formatter'
+require_relative '../presenters/coverage_payload_presenter'
+require_relative '../staleness/stale_status'
 
 module CovLoupe
   module Commands
     class DetailedCommand < BaseCommand
       def execute(args)
         handle_with_path(args, 'detailed') do |path|
-          presenter = Presenters::CoverageDetailedPresenter.new(model: model, path: path)
+          presenter = Presenters::CoveragePayloadPresenter.new(model: model, path: path,
+            payload_method: :detailed_for)
           data = presenter.absolute_payload
           break if emit_structured_format_with_optional_source?(data, model, path)
 
-          relative_path = presenter.relative_path
+          relative_path = convert_text(presenter.relative_path)
+          summary = data['summary']
           puts "File: #{relative_path}"
+          puts "Coverage: #{summary['covered']}/#{summary['total']} lines (#{format('%.2f%%', summary['percentage'])})"
+          puts "Stale: #{data['stale']}" if StaleStatus.stale?(data['stale'])
           puts
 
           # Table format with box-drawing
@@ -27,7 +31,8 @@ module CovLoupe
           puts TableFormatter.format(
             headers: headers,
             rows: rows,
-            alignments: [:right, :right, :center]
+            alignments: [:right, :right, :center],
+            output_chars: config.output_chars
           )
 
           print_source_for(model, path) if config.source_mode

data/lib/cov_loupe/commands/list_command.rb

@@ -5,7 +5,8 @@ require_relative 'base_command'
 module CovLoupe
   module Commands
     class ListCommand < BaseCommand
-      def execute(_args)
+      def execute(args)
+        reject_extra_args(args, 'list')
         cli.send(:show_default_report, sort_order: config.sort_order)
       end
     end