simplecov-mcp 0.3.0 → 1.0.0

data/lib/simplecov_mcp/path_relativizer.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+module SimpleCovMcp
+  # Utility object that converts configured path-bearing keys to forms
+  # relative to the project root while leaving the original payload untouched.
+  class PathRelativizer
+    def initialize(root:, scalar_keys:, array_keys: [])
+      @root = Pathname.new(File.absolute_path(root || '.'))
+      @scalar_keys = Array(scalar_keys).map(&:to_s).freeze
+      @array_keys = Array(array_keys).map(&:to_s).freeze
+    end
+
+    def relativize(obj)
+      deep_copy_and_relativize(obj)
+    end
+
+    private
+
+    def deep_copy_and_relativize(obj, key_context = nil)
+      case obj
+      when Hash
+        obj.each_with_object({}) do |(k, v), acc|
+          acc[k] = relativize_value(k, v)
+        end
+      when Array
+        obj.map { |item| deep_copy_and_relativize(item) }
+      else
+        obj
+      end
+    end
+
+    def relativize_value(key, value)
+      key_str = key.to_s
+      if @scalar_keys.include?(key_str) && value.is_a?(String)
+        relativize_path(value)
+      elsif @array_keys.include?(key_str) && value.is_a?(Array)
+        value.map do |item|
+          item.is_a?(String) ? relativize_path(item) : deep_copy_and_relativize(item)
+        end
+      else
+        deep_copy_and_relativize(value)
+      end
+    end
+
+    def relativize_path(path)
+      abs = File.absolute_path(path, @root.to_s)
+      root_str = @root.to_s
+      return path unless abs.start_with?(root_prefix(root_str)) || abs == root_str
+
+      Pathname.new(abs).relative_path_from(@root).to_s
+    rescue ArgumentError
+      path
+    end
+
+    def root_prefix(root_str)
+      root_str.end_with?(File::SEPARATOR) ? root_str : root_str + File::SEPARATOR
+    end
+  end
+end

data/lib/simplecov_mcp/presenters/base_coverage_presenter.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module SimpleCovMcp
+  module Presenters
+    # Shared presenter behavior for single-file coverage payloads.
+    class BaseCoveragePresenter
+      attr_reader :model, :path
+
+      def initialize(model:, path:)
+        @model = model
+        @path = path
+      end
+
+      # Returns the absolute-path payload augmented with stale metadata.
+      def absolute_payload
+        @absolute_payload ||= begin
+          payload = build_payload
+          payload.merge('stale' => model.staleness_for(path))
+        end
+      end
+
+      # Returns the payload with file paths relativized for presentation.
+      def relativized_payload
+        @relativized_payload ||= model.relativize(absolute_payload)
+      end
+
+      # Returns the cached stale status for the file.
+      def stale
+        absolute_payload['stale']
+      end
+
+      # Returns the relativized file path used in CLI output.
+      def relative_path
+        relativized_payload['file']
+      end
+
+      private
+
+      def build_payload
+        raise NotImplementedError, "#{self.class} must implement #build_payload"
+      end
+    end
+  end
+end

data/lib/simplecov_mcp/presenters/coverage_detailed_presenter.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative 'base_coverage_presenter'
+
+module SimpleCovMcp
+  module Presenters
+    # Provides shared detailed coverage payloads for CLI and MCP callers.
+    class CoverageDetailedPresenter < BaseCoveragePresenter
+      private
+
+      def build_payload
+        model.detailed_for(path)
+      end
+    end
+  end
+end

data/lib/simplecov_mcp/presenters/coverage_raw_presenter.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative 'base_coverage_presenter'
+
+module SimpleCovMcp
+  module Presenters
+    # Provides shared raw coverage payloads for CLI and MCP callers.
+    class CoverageRawPresenter < BaseCoveragePresenter
+      private
+
+      def build_payload
+        model.raw_for(path)
+      end
+    end
+  end
+end

data/lib/simplecov_mcp/presenters/coverage_summary_presenter.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative 'base_coverage_presenter'
+
+module SimpleCovMcp
+  module Presenters
+    # Builds a consistent summary payload that both the CLI and MCP surfaces can use.
+    class CoverageSummaryPresenter < BaseCoveragePresenter
+      private
+
+      def build_payload
+        model.summary_for(path)
+      end
+    end
+  end
+end

data/lib/simplecov_mcp/presenters/coverage_uncovered_presenter.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative 'base_coverage_presenter'
+
+module SimpleCovMcp
+  module Presenters
+    # Provides shared uncovered coverage payloads for CLI and MCP callers.
+    class CoverageUncoveredPresenter < BaseCoveragePresenter
+      private
+
+      def build_payload
+        model.uncovered_for(path)
+      end
+    end
+  end
+end

data/lib/simplecov_mcp/presenters/project_coverage_presenter.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module SimpleCovMcp
+  module Presenters
+    # Provides repository-wide coverage summaries shared by CLI and MCP surfaces.
+    class ProjectCoveragePresenter
+      attr_reader :model, :sort_order, :check_stale, :tracked_globs
+
+      def initialize(model:, sort_order:, check_stale:, tracked_globs:)
+        @model = model
+        @sort_order = sort_order
+        @check_stale = check_stale
+        @tracked_globs = tracked_globs
+      end
+
+      # Returns the absolute-path payload including counts.
+      def absolute_payload
+        @absolute_payload ||= begin
+          files = model.all_files(
+            sort_order: sort_order,
+            check_stale: check_stale,
+            tracked_globs: tracked_globs
+          )
+          { 'files' => files, 'counts' => build_counts(files) }
+        end
+      end
+
+      # Returns the payload with file paths relativized for presentation.
+      def relativized_payload
+        @relativized_payload ||= model.relativize(absolute_payload)
+      end
+
+      # Returns the relativized file rows.
+      def relative_files
+        relativized_payload['files']
+      end
+
+      # Returns the coverage counts with relative file paths.
+      def relative_counts
+        relativized_payload['counts']
+      end
+
+      private
+
+      def build_counts(files)
+        total = files.length
+        stale = files.count { |f| f['stale'] }
+        { 'total' => total, 'ok' => total - stale, 'stale' => stale }
+      end
+    end
+  end
+end

data/lib/simplecov_mcp/resolvers/coverage_line_resolver.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module SimpleCovMcp
+  module Resolvers
+    class CoverageLineResolver
+      def initialize(cov_data)
+        @cov_data = cov_data
+      end
+
+      def lookup_lines(file_abs)
+        # First try exact match
+        if direct_match = find_direct_match(file_abs)
+          return direct_match
+        end
+
+        # Then try without current working directory prefix
+        if stripped_match = find_stripped_match(file_abs)
+          return stripped_match
+        end
+
+        raise_not_found_error(file_abs)
+      end
+
+      private
+
+      attr_reader :cov_data
+
+      def find_direct_match(file_abs)
+        entry = cov_data[file_abs]
+        lines_from_entry(entry)
+      end
+
+      def find_stripped_match(file_abs)
+        return unless file_abs.start_with?(cwd_with_slash)
+
+        relative_path = file_abs[(cwd.length + 1)..-1]
+        entry = cov_data[relative_path]
+        lines_from_entry(entry)
+      end
+
+      def cwd
+        @cwd ||= Dir.pwd
+      end
+
+      def cwd_with_slash
+        @cwd_with_slash ||= "#{cwd}/"
+      end
+
+      def raise_not_found_error(file_abs)
+        raise FileError.new("No coverage entry found for #{file_abs}")
+      end
+
+      # Entry may store exact line coverage, branch-only coverage, or neither.
+      # Prefer the provided `lines` array but fall back to synthesizing one so
+      # callers always receive something enumerable.
+      #
+      # Returning nil tells callers to keep searching; the resolver will raise
+      # a FileError if no variant yields coverage data.
+      def lines_from_entry(entry)
+        return unless entry.is_a?(Hash)
+
+        lines = entry['lines']
+        return lines if lines.is_a?(Array)
+
+        synthesize_lines_from_branches(entry['branches'])
+      end
+
+      # Some SimpleCov configurations track only branch coverage. When the
+      # resultset omits the legacy `lines` array we rebuild a minimal substitute
+      # so the rest of the pipeline (summaries, uncovered lines, staleness) can
+      # continue to operate.
+      #
+      # Branch data looks like:
+      #   "[:if, 0, 12, 4, 20, 29]" => { "[:then, ...]" => hits, ... }
+      # We care about the third tuple element (line number). We sum branch-leg
+      # hits per line so the synthetic array still behaves like legacy line
+      # coverage (any positive value counts as executed).
+      def synthesize_lines_from_branches(branch_data)
+        # Detailed shape and rationale documented in docs/BRANCH_ONLY_COVERAGE.md
+        return unless branch_data.is_a?(Hash) && branch_data.any?
+
+        line_hits = {}
+
+        branch_data
+          .values
+          .select { |targets| targets.is_a?(Hash) } # ignore malformed branch entries
+          .flat_map(&:to_a) # flatten each branch target into [meta, hits]
+          .filter_map do |meta, hits|
+            # Extract the covered line; filter_map discards nil results.
+            line_number = extract_line_number(meta)
+            line_number && [line_number, hits.to_i]
+          end
+          .each do |line_number, hits|
+            line_hits[line_number] = line_hits.fetch(line_number, 0) + hits
+          end
+
+        return if line_hits.empty?
+
+        max_line = line_hits.keys.max
+        # Build a dense array up to the highest line recorded so downstream
+        # consumers see the familiar SimpleCov shape (nil for untouched lines).
+        Array.new(max_line) { |idx| line_hits[idx + 1] }
+      end
+
+      # Branch metadata arrives as either the raw SimpleCov array
+      # (e.g. [:if, 0, 12, 4, 20, 29]) or the stringified JSON version
+      # ("[:if, 0, 12, 4, 20, 29]"). We normalize both forms and pull the line.
+      def extract_line_number(meta)
+        if meta.is_a?(Array)
+          line_token = meta[2]
+          # Integer(..., exception: false) returns nil on failure, so malformed
+          # tuples quietly drop out of the synthesized array.
+          return Integer(line_token, exception: false)
+        end
+
+        tokens = meta.to_s.tr('[]', '').split(',').map(&:strip)
+        return if tokens.length < 3
+
+        Integer(tokens[2], exception: false)
+        # Any parsing errors result in nil; callers treat that as "no line".
+      rescue ArgumentError, TypeError
+        nil
+      end
+    end
+  end
+end

data/lib/simplecov_mcp/resolvers/resolver_factory.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative 'resultset_path_resolver'
+require_relative 'coverage_line_resolver'
+
+module SimpleCovMcp
+  module Resolvers
+    class ResolverFactory
+      def self.create_resultset_resolver(root: Dir.pwd, resultset: nil, candidates: nil)
+        candidates ?
+          ResultsetPathResolver.new(root: root, candidates: candidates) :
+          ResultsetPathResolver.new(root: root)
+      end
+
+      def self.create_coverage_resolver(cov_data)
+        CoverageLineResolver.new(cov_data)
+      end
+
+      def self.find_resultset(root, resultset: nil)
+        ResultsetPathResolver.new(root: root).find_resultset(resultset: resultset)
+      end
+
+      def self.lookup_lines(cov, file_abs)
+        CoverageLineResolver.new(cov).lookup_lines(file_abs)
+      end
+    end
+  end
+end

data/lib/simplecov_mcp/resolvers/resultset_path_resolver.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+module SimpleCovMcp
+  module Resolvers
+    class ResultsetPathResolver
+      DEFAULT_CANDIDATES = [
+        '.resultset.json',
+        'coverage/.resultset.json',
+        'tmp/.resultset.json'
+      ].freeze
+
+      def initialize(root: Dir.pwd, candidates: DEFAULT_CANDIDATES)
+        @root = root
+        @candidates = candidates
+      end
+
+      def find_resultset(resultset: nil)
+        if resultset && !resultset.empty?
+          path = normalize_resultset_path(resultset)
+          if (resolved = resolve_candidate(path, strict: true))
+            return resolved
+          end
+        end
+
+        resolve_fallback or raise_not_found_error
+      end
+
+      private
+
+      def resolve_candidate(path, strict:)
+        return path if File.file?(path)
+        return resolve_directory(path) if File.directory?(path)
+
+        raise_not_found_error_for_file(path) if strict
+        nil
+      end
+
+      def resolve_directory(path)
+        candidate = File.join(path, '.resultset.json')
+        return candidate if File.file?(candidate)
+
+        raise "No .resultset.json found in directory: #{path}"
+      end
+
+      def raise_not_found_error_for_file(path)
+        raise "Specified resultset not found: #{path}"
+      end
+
+      def resolve_fallback
+        @candidates
+          .map { |p| File.absolute_path(p, @root) }
+          .find { |p| File.file?(p) }
+      end
+
+      def normalize_resultset_path(resultset)
+        candidate = Pathname.new(resultset)
+        return candidate.cleanpath.to_s if candidate.absolute?
+
+        expanded = File.expand_path(resultset, Dir.pwd)
+        return expanded if within_root?(expanded)
+
+        File.absolute_path(resultset, @root)
+      end
+
+      def within_root?(path)
+        normalized_root = Pathname.new(@root).cleanpath.to_s
+        root_with_sep = normalized_root.end_with?(File::SEPARATOR) ? normalized_root : "#{normalized_root}#{File::SEPARATOR}"
+        path == normalized_root || path.start_with?(root_with_sep)
+      end
+
+      def raise_not_found_error
+        raise "Could not find .resultset.json under #{@root.inspect}; run tests or set --resultset option"
+      end
+    end
+  end
+end

data/lib/simplecov_mcp/resultset_loader.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'time'
+
+require_relative 'errors'
+require_relative 'util'
+
+module SimpleCovMcp
+  class ResultsetLoader
+    Result = Struct.new(:coverage_map, :timestamp, :suite_names, keyword_init: true)
+    SuiteEntry = Struct.new(:name, :coverage, :timestamp, keyword_init: true)
+
+    class << self
+      def load(resultset_path:)
+        raw = JSON.parse(File.read(resultset_path))
+
+        suites = extract_suite_entries(raw, resultset_path)
+        raise CoverageDataError.new("No test suite with coverage data found in resultset file: #{resultset_path}") if suites.empty?
+
+        coverage_map = build_coverage_map(suites, resultset_path)
+        Result.new(
+          coverage_map: coverage_map,
+          timestamp: compute_combined_timestamp(suites),
+          suite_names: suites.map(&:name)
+        )
+      end
+
+      private
+
+      def extract_suite_entries(raw, resultset_path)
+        raw
+          .select { |_, data| data.is_a?(Hash) && data.key?('coverage') && !data['coverage'].nil? }
+          .map do |name, data|
+            SuiteEntry.new(
+              name: name.to_s,
+              coverage: normalize_suite_coverage(data['coverage'], suite_name: name,
+                resultset_path: resultset_path),
+              timestamp: normalize_coverage_timestamp(data['timestamp'], data['created_at'])
+            )
+          end
+      end
+
+      def build_coverage_map(suites, resultset_path)
+        return suites.first&.coverage if suites.length == 1
+
+        merge_suite_coverages(suites, resultset_path)
+      end
+
+      def normalize_suite_coverage(coverage, suite_name:, resultset_path:)
+        unless coverage.is_a?(Hash)
+          raise CoverageDataError.new("Invalid coverage data structure for suite #{suite_name.inspect} in resultset file: #{resultset_path}")
+        end
+
+        needs_adaptation = coverage.values.any? { |value| value.is_a?(Array) }
+        return coverage unless needs_adaptation
+
+        coverage.each_with_object({}) do |(file, value), acc|
+          acc[file] = value.is_a?(Array) ? { 'lines' => value } : value
+        end
+      end
+
+      def merge_suite_coverages(suites, resultset_path)
+        require_simplecov_for_merge!(resultset_path)
+        log_duplicate_suite_names(suites)
+
+        suites.reduce(nil) do |memo, suite|
+          coverage = suite.coverage
+          memo ?
+            SimpleCov::Combine.combine(SimpleCov::Combine::ResultsCombiner, memo, coverage) :
+            coverage
+        end
+      end
+
+      def require_simplecov_for_merge!(resultset_path)
+        require 'simplecov'
+      rescue LoadError
+        raise CoverageDataError.new(
+          "Multiple coverage suites detected in #{resultset_path}, but the simplecov gem could not be loaded. Install simplecov to enable suite merging."
+        )
+      end
+
+      def log_duplicate_suite_names(suites)
+        grouped = suites.group_by(&:name)
+        duplicates = grouped.select { |_, entries| entries.length > 1 }.keys
+        return if duplicates.empty?
+
+        message = "Merging duplicate coverage suites for #{duplicates.join(', ')}"
+        CovUtil.log(message)
+      rescue StandardError
+        # Logging should never block coverage loading
+      end
+
+      def compute_combined_timestamp(suites)
+        suites.map(&:timestamp).compact.max.to_i
+      end
+
+      def normalize_coverage_timestamp(timestamp_value, created_at_value)
+        raw = timestamp_value.nil? ? created_at_value : timestamp_value
+        return 0 if raw.nil?
+
+        case raw
+        when Integer
+          raw
+        when Float, Time
+          raw.to_i
+        when String
+          normalize_string_timestamp(raw)
+        else
+          log_timestamp_warning(raw)
+          0
+        end
+      rescue StandardError => e
+        log_timestamp_warning(raw, e)
+        0
+      end
+
+      def normalize_string_timestamp(value)
+        str = value.strip
+        return 0 if str.empty?
+
+        if str.match?(/\A-?\d+(\.\d+)?\z/)
+          str.to_f.to_i
+        else
+          Time.parse(str).to_i
+        end
+      end
+
+      def log_timestamp_warning(raw_value, error = nil)
+        message = "Coverage resultset timestamp could not be parsed: #{raw_value.inspect}"
+        message = "#{message} (#{error.message})" if error
+        CovUtil.log(message) rescue nil
+      end
+    end
+  end
+end