simplecov-mcp 0.1.0 → 0.2.0

data/lib/simple_cov_mcp/cli.rb

@@ -0,0 +1,390 @@
+# frozen_string_literal: true
+
+module SimpleCovMcp
+  class CoverageCLI
+      SUBCOMMANDS = %w[list summary raw uncovered detailed version].freeze
+
+      # Initialize CLI for pure CLI usage only.
+      # Always runs as CLI, no mode detection needed.
+      def initialize(error_handler: nil)
+        @root = '.'
+        @resultset = nil
+        @json = false
+        @sort_order = 'ascending'
+        @cmd = nil
+        @cmd_args = []
+        @source_mode = nil   # nil, 'full', or 'uncovered'
+        @source_context = 2  # lines of context for uncovered mode
+        @color = STDOUT.tty?
+        @error_handler = error_handler || ErrorHandlerFactory.for_cli
+        @stale_mode = 'off'
+        @tracked_globs = nil
+      end
+
+      def run(argv)
+        parse_options!(argv)
+        if @cmd
+          run_subcommand(@cmd, @cmd_args)
+        else
+          show_default_report(sort_order: @sort_order)
+        end
+      rescue SimpleCovMcp::Error => e
+        handle_user_facing_error(e)
+      rescue => e
+        @error_handler.handle_error(e, context: 'CLI execution')
+      end
+
+      def show_default_report(sort_order: :ascending, output: $stdout)
+        model = CoverageModel.new(root: @root, resultset: @resultset, staleness: @stale_mode, tracked_globs: @tracked_globs)
+        rows = model.all_files(sort_order: sort_order, check_stale: (@stale_mode == 'error'), tracked_globs: @tracked_globs)
+        if @json
+          files = rows.map { |row| row.merge('file' => rel_to_root(row['file'])) }
+          total = files.length
+          stale_count = files.count { |f| f['stale'] }
+          ok_count = total - stale_count
+          output.puts JSON.pretty_generate({ files: files, counts: { total: total, ok: ok_count, stale: stale_count } })
+          return
+        end
+
+        file_summaries = rows.map do |row|
+          row.dup.tap do |h|
+            h['file'] = rel_to_root(h['file'])
+          end
+        end
+
+        # Format as table with box-style borders
+        max_file_length = file_summaries.map { |f| f['file'].length }.max.to_i
+        max_file_length = [max_file_length, 'File'.length].max
+
+        # Calculate maximum numeric values for proper column widths
+        max_covered = file_summaries.map { |f| f['covered'].to_s.length }.max
+        max_total = file_summaries.map { |f| f['total'].to_s.length }.max
+
+        # Define column widths
+        file_width = max_file_length + 2  # Extra padding
+        pct_width = 8
+        covered_width = [max_covered, 'Covered'.length].max + 2
+        total_width = [max_total, 'Total'.length].max + 2
+
+        stale_header = 'Stale'
+        stale_width = stale_header.length
+        # Use String#center for concise centering
+
+        # Horizontal line for each column span
+        h_line = ->(col_width) { '─' * (col_width + 2) }
+
+        # Border line lambda
+        border_line = ->(left, middle, right) {
+          left   + h_line.(file_width) +
+          middle + h_line.(pct_width) +
+          middle + h_line.(covered_width) +
+          middle + h_line.(total_width) +
+          middle + h_line.(stale_width) +
+          right
+        }
+
+        # Top border
+        output.puts border_line.call('┌', '┬', '┐')
+
+        # Header row
+        output.printf "│ %-#{file_width}s │ %#{pct_width}s │ %#{covered_width}s │ %#{total_width}s │ %#{stale_width}s │\n",
+               'File', ' %', 'Covered', 'Total', stale_header.to_s.center(stale_width)
+
+        # Header separator
+        output.puts border_line.call('├', '┼', '┤')
+
+        # Data rows
+        file_summaries.each do |file_data|
+          stale_text_str = file_data['stale'] ? '!' : ''
+          output.printf "│ %-#{file_width}s │ %#{pct_width - 1}.2f%% │ %#{covered_width}d │ %#{total_width}d │ %#{stale_width}s │\n",
+                 file_data['file'],
+                 file_data['percentage'],
+                 file_data['covered'],
+                 file_data['total'],
+                 stale_text_str.center(stale_width)
+        end
+
+        # Bottom border
+        output.puts border_line.call('└', '┴', '┘')
+
+        # Summary counts line
+        total = file_summaries.length
+        stale_count = file_summaries.count { |f| f['stale'] }
+        ok_count = total - stale_count
+        output.puts "Files: total #{total}, ok #{ok_count}, stale #{stale_count}"
+      end
+
+      private
+
+      def parse_options!(argv)
+        require 'optparse'
+
+        if !argv.empty? && SUBCOMMANDS.include?(argv[0])
+          @cmd = argv.shift
+        end
+
+        op = OptionParser.new do |o|
+          o.banner = 'Usage: simplecov-mcp [subcommand] [options] [args]'
+          o.separator ''
+          o.separator 'Subcommands:'
+          o.separator '  list                    Show table of all files'
+          o.separator '  summary <path>          Show covered/total/% for a file'
+          o.separator "  raw <path>              Show the SimpleCov 'lines' array"
+          o.separator '  uncovered <path>        Show uncovered lines and a summary'
+          o.separator '  detailed <path>         Show per-line rows with hits/covered'
+          o.separator '  version                 Show version information'
+          o.separator ''
+
+          o.separator ''
+          o.separator 'Options:'
+          o.on('--resultset PATH', String, 'Path or directory that contains .resultset.json') { |v| @resultset = v }
+          o.on('--root PATH', String, "Project root (default '.')") { |v| @root = v }
+          o.on('--json', 'Output JSON for machine consumption') { @json = true }
+          o.on('--sort-order ORDER', String, ['ascending', 'descending'], "Sort order for 'list' (ascending|descending)") { |v| @sort_order = v }
+          o.on('--source[=MODE]', [:full, :uncovered], 'Include source in output for summary/uncovered/detailed (MODE: full|uncovered; default full)') do |v|
+            @source_mode = (v || :full).to_s
+          end
+          o.on('--source-context N', Integer, 'For --source=uncovered, show N context lines (default 2)') { |v| @source_context = v }
+          o.on('--color', 'Enable ANSI colors for source output') { @color = true }
+          o.on('--no-color', 'Disable ANSI colors') { @color = false }
+          o.on('--stale MODE', [:off, :error], "Staleness mode: off|error (default off)") do |v|
+            @stale_mode = v.to_s
+          end
+          o.on('--tracked-globs x,y,z', Array, 'Globs for files that should be covered (list only)') { |v| @tracked_globs = v }
+          o.separator ''
+          o.separator 'Examples:'
+          o.separator '  simplecov-mcp list --resultset coverage'
+          o.separator '  simplecov-mcp summary lib/foo.rb --json --resultset coverage'
+          o.separator '  simplecov-mcp uncovered lib/foo.rb --source=uncovered --source-context 2'
+          o.on('-h', '--help', 'Show help') do
+            puts o
+            exit 0
+          end
+        end
+        op.parse!(argv)
+        @cmd_args = argv
+      end
+
+      def run_subcommand(cmd, args)
+        model = CoverageModel.new(root: @root, resultset: @resultset, staleness: @stale_mode)
+        case cmd
+        when 'list'      then handle_list(model)
+        when 'summary'   then handle_summary(model, args)
+        when 'raw'       then handle_raw(model, args)
+        when 'uncovered' then handle_uncovered(model, args)
+        when 'detailed'  then handle_detailed(model, args)
+        when 'version'   then handle_version
+        else raise UsageError.for_subcommand('list | summary <path> | raw <path> | uncovered <path> | detailed <path> | version')
+        end
+      rescue SimpleCovMcp::Error => e
+        handle_user_facing_error(e)
+      rescue => e
+        @error_handler.handle_error(e, context: "subcommand '#{cmd}'")
+      end
+
+
+      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', '-----', '----', '-------')
+        rows.each do |r|
+          out << sprintf('%6d  %6d  %7s', r['line'], r['hits'], r['covered'] ? 'yes' : 'no')
+        end
+        out.join("\n")
+      end
+
+      def handle_list(model)
+        show_default_report(sort_order: @sort_order)
+      end
+
+      def handle_version
+        if @json
+          puts JSON.pretty_generate({ version: SimpleCovMcp::VERSION })
+        else
+          puts "SimpleCovMcp version #{SimpleCovMcp::VERSION}"
+        end
+      end
+
+      def handle_summary(model, args)
+        handle_with_path(args, 'summary') do |path|
+          data = model.summary_for(path)
+          if @source_mode && @json
+            data = relativize_file(data)
+            src = build_source_payload(model, path)
+            data['source'] = src
+            break puts(JSON.pretty_generate(data))
+          end
+          break if maybe_output_json(relativize_file(data))
+          rel = rel_path(data['file'])
+          s = data['summary']
+          printf '%8.2f%%  %6d/%-6d  %s\n', s['pct'], s['covered'], s['total'], rel
+          print_source_for(model, path) if @source_mode
+        end
+      end
+
+      def handle_raw(model, args)
+        handle_with_path(args, 'raw') do |path|
+          data = model.raw_for(path)
+          break if maybe_output_json(relativize_file(data))
+          rel = rel_path(data['file'])
+          puts "File: #{rel}"
+          puts data['lines'].inspect
+        end
+      end
+
+      def handle_uncovered(model, args)
+        handle_with_path(args, 'uncovered') do |path|
+          data = model.uncovered_for(path)
+          if @source_mode && @json
+            data = relativize_file(data)
+            src = build_source_payload(model, path)
+            data['source'] = src
+            break puts(JSON.pretty_generate(data))
+          end
+          break if maybe_output_json(relativize_file(data))
+          rel = rel_path(data['file'])
+          puts "File: #{rel}"
+          puts "Uncovered lines: #{data['uncovered'].join(', ')}"
+          s = data['summary']
+          printf 'Summary: %8.2f%%  %6d/%-6d\n', s['pct'], s['covered'], s['total']
+          print_source_for(model, path) if @source_mode
+        end
+      end
+
+      def handle_detailed(model, args)
+        handle_with_path(args, 'detailed') do |path|
+          data = model.detailed_for(path)
+          if @source_mode && @json
+            data = relativize_file(data)
+            src = build_source_payload(model, path)
+            data['source'] = src
+            break puts(JSON.pretty_generate(data))
+          end
+          break if maybe_output_json(relativize_file(data))
+          rel = rel_path(data['file'])
+          puts "File: #{rel}"
+          puts format_detailed_rows(data['lines'])
+          print_source_for(model, path) if @source_mode
+        end
+      end
+
+      def handle_with_path(args, name)
+        path = args.shift or raise UsageError.for_subcommand("#{name} <path>")
+        yield(path)
+      rescue Errno::ENOENT => e
+        raise FileNotFoundError.new("File not found: #{path}")
+      rescue Errno::EACCES => e
+        raise FilePermissionError.new("Permission denied: #{path}")
+      end
+
+      def rel_path(abs)
+        rel_to_root(abs)
+      end
+
+      def maybe_output_json(obj)
+        return false unless @json
+        puts JSON.pretty_generate(obj)
+        true
+      end
+
+      def print_source_for(model, path)
+        raw = model.raw_for(path)
+        abs = raw['file']
+        lines_cov = raw['lines']
+        src = File.file?(abs) ? File.readlines(abs, chomp: true) : nil
+        unless src
+          puts '[source not available]'
+          return
+        end
+        begin
+          rows = build_source_rows(src, lines_cov, mode: @source_mode, context: @source_context)
+          puts format_source_rows(rows)
+        rescue StandardError
+          # If any unexpected formatting/indexing error occurs, avoid crashing the CLI
+          # and fall back to a neutral message rather than raising.
+          puts '[source not available]'
+        end
+      end
+
+      def build_source_payload(model, path)
+        raw = model.raw_for(path)
+        abs = raw['file']
+        lines_cov = raw['lines']
+        src = File.file?(abs) ? File.readlines(abs, chomp: true) : nil
+        return nil unless src
+        build_source_rows(src, lines_cov, mode: @source_mode, context: @source_context)
+      end
+
+      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?
+
+        n = src_lines.length
+        include_line = Array.new(n, mode == 'full')
+        if mode == 'uncovered'
+          misses = []
+          coverage_lines.each_with_index do |hits, i|
+            misses << i if !hits.nil? && hits.to_i == 0
+          end
+          misses.each do |i|
+            a = [0, i - context_line_count].max
+            b = [n - 1, i + context_line_count].min
+            (a..b).each { |j| include_line[j] = true }
+          end
+        end
+        out = []
+        src_lines.each_with_index do |code, i|
+          next unless include_line[i]
+          hits = coverage_lines[i]
+          covered = hits.nil? ? nil : hits.to_i > 0
+          out << { line: i + 1, code: code, hits: hits, covered: covered }
+        end
+        out
+      end
+
+      def format_source_rows(rows)
+        marker = ->(covered, hits) do
+          case covered
+          when true then colorize('✓', :green)
+          when false then colorize('·', :red)
+          else colorize(' ', :dim)
+          end
+        end
+        lines = []
+        lines << sprintf('%6s  %2s | %s', 'Line', ' ', 'Source')
+        lines << sprintf('%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'])
+        end
+        lines.join("\n")
+      end
+
+      def colorize(text, color)
+        return text unless @color
+        codes = { green: 32, red: 31, dim: 2 }
+        code = codes[color] || 0
+        "\e[#{code}m#{text}\e[0m"
+      end
+
+      def rel_to_root(path)
+        Pathname.new(path).relative_path_from(Pathname.new(File.absolute_path(@root))).to_s
+      end
+
+      def relativize_file(h)
+        return h unless h.is_a?(Hash) && h['file']
+        dup = h.dup
+        dup['file'] = rel_to_root(dup['file'])
+        dup
+      end
+
+
+      def handle_user_facing_error(error)
+        warn error.user_friendly_message
+        exit 1
+      end
+  end
+end

data/lib/simple_cov_mcp/error_handler.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require_relative 'errors'
+
+module SimpleCovMcp
+    # Handles error reporting and logging with configurable behavior
+    class ErrorHandler
+      attr_accessor :log_errors, :show_stack_traces, :logger
+
+      def initialize(log_errors: true, show_stack_traces: false, logger: nil)
+        @log_errors = log_errors
+        @show_stack_traces = show_stack_traces
+        @logger = logger
+      end
+
+      # Handle an error with appropriate logging and re-raising behavior
+      def handle_error(error, context: nil, reraise: true)
+        log_error(error, context)
+
+        if reraise
+          if error.is_a?(SimpleCovMcp::Error)
+            # Re-raise our custom errors as-is
+            raise error
+          else
+            # Convert standard errors to our custom errors for better UX
+            converted_error = convert_standard_error(error)
+            raise converted_error
+          end
+        end
+      end
+
+      # Convert standard Ruby errors to user-friendly custom errors
+      def convert_standard_error(error)
+        case error
+        when Errno::ENOENT
+          filename = extract_filename(error.message)
+          FileNotFoundError.new("File not found: #{filename}", error)
+        when Errno::EACCES
+          filename = extract_filename(error.message)
+          FilePermissionError.new("Permission denied accessing file: #{filename}", error)
+        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)
+        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
+        when NoMethodError
+          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?('No coverage entry found for')
+            # Extract the file path from the error message
+            filepath = error.message.match(/No coverage entry found for (.+)$/)&.[](1) || "specified file"
+            FileError.new("No coverage data found for file: #{filepath}", error)
+          elsif 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)
+          else
+            Error.new("An unexpected error occurred: #{error.message}", error)
+          end
+        else
+          Error.new("An unexpected error occurred: #{error.message}", error)
+        end
+      end
+
+      private
+
+      def log_error(error, context)
+        return unless @log_errors
+
+        message = build_log_message(error, context)
+        if @logger
+          @logger.error(message)
+        else
+          CovUtil.log(message)
+        end
+      end
+
+      def build_log_message(error, context)
+        parts = []
+        parts << "Error#{context ? " in #{context}" : ''}: #{error.class}: #{error.message}"
+
+        if @show_stack_traces && error.backtrace
+          parts << error.backtrace.join("\n")
+        end
+
+        parts.join("\n")
+      end
+
+      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 (.+)$/)
+          method_name = match[1]
+          object_info = match[2].gsub(/#<.*?>/, 'object')
+          "missing method '#{method_name}' on #{object_info}"
+        else
+          message
+        end
+      end
+    end
+
+    # Global error handler configuration
+    class << self
+      attr_writer :error_handler
+
+      def error_handler
+        @error_handler or raise "Error handler not configured. Use one of: SimpleCovMcp.run, .run_as_library, or set .error_handler= explicitly"
+      end
+    end
+end

data/lib/simple_cov_mcp/error_handler_factory.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module SimpleCovMcp
+  module ErrorHandlerFactory
+      # Error handler for CLI usage
+      # - Logs errors for debugging
+      # - Shows stack traces only in debug mode
+      # - Suitable for user-facing command line interface
+      def self.for_cli
+        ErrorHandler.new(
+          log_errors: true,
+          show_stack_traces: ENV['SIMPLECOV_MCP_DEBUG'] == '1'
+        )
+      end
+
+      # Error handler for library usage
+      # - No logging by default (avoids side effects in consuming applications)
+      # - No stack traces (libraries should let consumers handle error display)
+      # - Suitable for embedding in other applications
+      def self.for_library
+        ErrorHandler.new(
+          log_errors: false,
+          show_stack_traces: false
+        )
+      end
+
+      # Error handler for MCP server usage
+      # - Logs errors for server debugging
+      # - Shows stack traces only in debug mode
+      # - Suitable for long-running server processes
+      def self.for_mcp_server
+        ErrorHandler.new(
+          log_errors: true,
+          show_stack_traces: ENV['SIMPLECOV_MCP_DEBUG'] == '1'
+        )
+      end
+  end
+end