simplecov-mcp 0.3.0 → 1.0.0

data/lib/simple_cov_mcp/errors.rb

@@ -1,176 +0,0 @@
-# frozen_string_literal: true
-
-module SimpleCovMcp
-    # Base error class for all SimpleCov MCP errors
-    class Error < StandardError
-      attr_reader :original_error
-
-      def initialize(message = nil, original_error = nil)
-        @original_error = original_error
-        super(message)
-      end
-
-      def user_friendly_message
-        message
-      end
-    end
-
-    # Configuration or setup related errors
-    class ConfigurationError < Error
-      def user_friendly_message
-        "Configuration error: #{message}"
-      end
-    end
-
-    # File or path related errors
-    class FileError < Error
-      def user_friendly_message
-        "File error: #{message}"
-      end
-    end
-
-    # More specific file errors
-    class FileNotFoundError < FileError; end
-    class FilePermissionError < FileError; end
-    class NotAFileError < FileError; end
-    class ResultsetNotFoundError < FileError; end
-
-    # Coverage data related errors
-    class CoverageDataError < Error
-      def user_friendly_message
-        "Coverage data error: #{message}"
-      end
-    end
-
-    # Coverage data is present but appears stale compared to source files
-    class CoverageDataStaleError < CoverageDataError
-      attr_reader :file_path, :file_mtime, :cov_timestamp, :src_len, :cov_len, :resultset_path
-
-      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
-      end
-
-      def user_friendly_message
-        base = "Coverage data stale: #{message || default_message}"
-        base + build_details
-      end
-
-      private
-
-      def default_message
-        fp = file_path || 'file'
-        "Coverage data appears stale for #{fp}"
-      end
-
-      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)
-        details = []
-        details << "\nFile     - time: #{file_utc || 'not found'} (local #{file_local || 'n/a'}), lines: #{@src_len}"
-        details << "\nCoverage - time: #{cov_utc  || 'not found'} (local #{cov_local  || 'n/a'}), lines: #{@cov_len}"
-        details << "\nDelta    - file is #{delta_str} newer than coverage" if delta_str
-        details << "\nResultset - #{@resultset_path}" if @resultset_path
-        details.join
-      end
-
-      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
-        [epoch_seconds.to_s, epoch_seconds.to_s]
-      end
-
-      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
-        [time.to_s, time.to_s]
-      end
-
-      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
-        nil
-      end
-    end
-
-    # Project-level stale coverage (global) — coverage timestamp older than
-    # one or more source files, or new tracked files missing from coverage.
-    class CoverageDataProjectStaleError < CoverageDataError
-      attr_reader :cov_timestamp, :newer_files, :missing_files, :deleted_files, :resultset_path
-
-      def initialize(message = nil, original_error = nil, cov_timestamp: nil, newer_files: [], missing_files: [], deleted_files: [], resultset_path: nil)
-        super(message, original_error)
-        @cov_timestamp = cov_timestamp
-        @newer_files = Array(newer_files)
-        @missing_files = Array(missing_files)
-        @deleted_files = Array(deleted_files)
-        @resultset_path = resultset_path
-      end
-
-      def user_friendly_message
-        base = "Coverage data stale (project): #{message || default_message}"
-        base + build_details
-      end
-
-      private
-
-      def default_message
-        'Coverage data appears stale for project'
-      end
-
-      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'})"
-        unless @newer_files.empty?
-          parts << "\nNewer files (#{@newer_files.size}):"
-          parts.concat(@newer_files.first(10).map { |f| "  - #{f}" })
-          parts << "  ..." if @newer_files.size > 10
-        end
-        unless @missing_files.empty?
-          parts << "\nMissing files (new in project, not in coverage, #{@missing_files.size}):"
-          parts.concat(@missing_files.first(10).map { |f| "  - #{f}" })
-          parts << "  ..." if @missing_files.size > 10
-        end
-        unless @deleted_files.empty?
-          parts << "\nCoverage-only files (deleted or moved in project, #{@deleted_files.size}):"
-          parts.concat(@deleted_files.first(10).map { |f| "  - #{f}" })
-          parts << "  ..." if @deleted_files.size > 10
-        end
-        parts << "\nResultset - #{@resultset_path}" if @resultset_path
-        parts.join
-      end
-
-      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
-        [epoch_seconds.to_s, epoch_seconds.to_s]
-      end
-    end
-
-    # Command line usage errors
-    class UsageError < Error
-      def self.for_subcommand(usage_fragment)
-        new("Usage: simplecov-mcp #{usage_fragment}")
-      end
-
-      def user_friendly_message
-        message
-      end
-    end
-end

data/lib/simple_cov_mcp/mcp_server.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-module SimpleCovMcp
-  class MCPServer
-      def initialize
-        # Configure error handling for MCP server mode using the factory
-        SimpleCovMcp.error_handler = ErrorHandlerFactory.for_mcp_server
-      end
-
-      def run
-        tools = [
-          Tools::AllFilesCoverageTool,
-          Tools::CoverageDetailedTool,
-          Tools::CoverageRawTool,
-          Tools::CoverageSummaryTool,
-          Tools::UncoveredLinesTool,
-          Tools::CoverageTableTool,
-          Tools::HelpTool,
-          Tools::VersionTool
-        ]
-
-        server = ::MCP::Server.new(
-          name:    'simplecov-mcp',
-          version: SimpleCovMcp::VERSION,
-          tools:   tools
-        )
-        ::MCP::Server::Transports::StdioTransport.new(server).open
-      end
-  end
-end

data/lib/simple_cov_mcp/model.rb

@@ -1,104 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'util'
-require_relative 'errors'
-require_relative 'staleness_checker'
-
-module SimpleCovMcp
-  class CoverageModel
-    # Create a CoverageModel
-    #
-    # Params:
-    # - root: project root directory (default '.')
-    # - resultset: path or directory to .resultset.json
-      # - staleness: 'off' or 'error' (default 'off'). When 'error', raises
-      #   stale errors if sources are newer than coverage or line counts mismatch.
-      # - tracked_globs: only used for all_files project-level staleness.
-      def initialize(root: '.', resultset: nil, staleness: 'off', tracked_globs: nil)
-        @root = File.absolute_path(root || '.')
-        @resultset = resultset
-        @checker = StalenessChecker.new(root: @root, resultset: @resultset, mode: staleness, tracked_globs: tracked_globs)
-      begin
-        @cov  = CovUtil.load_latest_coverage(@root, resultset: resultset)
-      rescue Errno::ENOENT => e
-        raise FileError.new("Coverage data not found at #{resultset || @root}")
-      rescue JSON::ParserError => e
-        raise CoverageDataError.new("Invalid coverage data format")
-      rescue => e
-        raise CoverageDataError.new("Failed to load coverage data: #{e.message}")
-      end
-    end
-
-    # Returns { 'file' => <absolute_path>, 'lines' => [hits|nil,...] }
-    def raw_for(path)
-      file_abs, coverage_lines = resolve(path)
-      { 'file' => file_abs, 'lines' => coverage_lines }
-    end
-
-    # Returns { 'file' => <absolute_path>, 'summary' => {'covered'=>, 'total'=>, 'pct'=>} }
-    def summary_for(path)
-      file_abs, coverage_lines = resolve(path)
-      { 'file' => file_abs, 'summary' => CovUtil.summary(coverage_lines) }
-    end
-
-    # Returns { 'file' => <absolute_path>, 'uncovered' => [line,...], 'summary' => {...} }
-    def uncovered_for(path)
-      file_abs, coverage_lines = resolve(path)
-      { 'file' => file_abs, 'uncovered' => CovUtil.uncovered(coverage_lines), 'summary' => CovUtil.summary(coverage_lines) }
-    end
-
-    # Returns { 'file' => <absolute_path>, 'lines' => [{'line'=>,'hits'=>,'covered'=>},...], 'summary' => {...} }
-    def detailed_for(path)
-      file_abs, coverage_lines = resolve(path)
-      { 'file' => file_abs, 'lines' => CovUtil.detailed(coverage_lines), 'summary' => CovUtil.summary(coverage_lines) }
-    end
-
-    # Returns [ { 'file' =>, 'covered' =>, 'total' =>, 'percentage' =>, 'stale' => }, ... ]
-      def all_files(sort_order: :ascending, check_stale: !@checker.off?, tracked_globs: nil)
-        stale_checker = StalenessChecker.new(root: @root, resultset: @resultset, mode: 'off', tracked_globs: tracked_globs)
-        rows = @cov.map do |abs_path, data|
-          next unless data['lines'].is_a?(Array)
-          s = CovUtil.summary(data['lines'])
-          stale = stale_checker.stale_for_file?(abs_path, data['lines'])
-          { 'file' => abs_path, 'covered' => s['covered'], 'total' => s['total'], 'percentage' => s['pct'], 'stale' => stale }
-        end.compact
-
-        if check_stale
-          StalenessChecker.new(root: @root, resultset: @resultset, mode: 'error', tracked_globs: tracked_globs)
-                           .check_project!(@cov)
-        end
-
-        rows.sort! do |a, b|
-          pct_cmp = (sort_order.to_s == 'descending') ? (b['percentage'] <=> a['percentage']) : (a['percentage'] <=> b['percentage'])
-          pct_cmp == 0 ? (a['file'] <=> b['file']) : pct_cmp
-        end
-        rows
-      end
-
-    private
-
-    def resolve(path)
-      file_abs = File.absolute_path(path, @root)
-      coverage_lines = CovUtil.lookup_lines(@cov, file_abs)
-        @checker.check_file!(file_abs, coverage_lines) unless @checker.off?
-      if coverage_lines.nil?
-        raise FileError.new("No coverage data found for file: #{path}")
-      end
-      [file_abs, coverage_lines]
-      rescue Errno::ENOENT => e
-        raise FileNotFoundError.new("File not found: #{path}")
-    end
-
-      # staleness handled by StalenessChecker
-
-      def check_all_files_staleness!(cov_timestamp, tracked_globs: nil)
-        # handled by StalenessChecker
-      end
-
-      def rel_to_root(path)
-        Pathname.new(path).relative_path_from(Pathname.new(File.absolute_path(@root))).to_s
-      end
-
-    # Detailed stale message construction moved to CoverageDataStaleError
-  end
-end

data/lib/simple_cov_mcp/staleness_checker.rb

@@ -1,125 +0,0 @@
-# frozen_string_literal: true
-
-require 'time'
-
-module SimpleCovMcp
-  # Lightweight service object to check staleness of coverage vs. sources
-  class StalenessChecker
-    MODES = %w[off error].freeze
-
-    def initialize(root:, resultset:, mode: 'off', tracked_globs: nil)
-      @root = File.absolute_path(root || '.')
-      @resultset = resultset
-      @mode = (mode || 'off').to_s
-      @tracked_globs = tracked_globs
-      @cov_timestamp = nil
-      @resultset_path = nil
-    end
-
-    def off?
-      @mode == 'off'
-    end
-
-    # Raise CoverageDataStaleError if stale (only in error mode)
-    def check_file!(file_abs, coverage_lines)
-      return if off?
-      ts = coverage_timestamp
-      fm = File.mtime(file_abs) if File.file?(file_abs)
-      cov_len = coverage_lines.respond_to?(:length) ? coverage_lines.length : 0
-      src_len = safe_count_lines(file_abs)
-      if (fm && fm.to_i > ts.to_i) || (cov_len.positive? && src_len != cov_len)
-        raise CoverageDataStaleError.new(
-          nil,
-          nil,
-          file_path: rel(file_abs),
-          file_mtime: fm,
-          cov_timestamp: ts,
-          src_len: src_len,
-          cov_len: cov_len,
-          resultset_path: resultset_path
-        )
-      end
-    end
-
-    # Compute whether a specific file appears stale relative to coverage.
-    # Ignores mode and never raises; returns true when:
-    # - the file is missing/deleted, or
-    # - the file mtime is newer than the coverage timestamp, or
-    # - the source line count differs from the coverage lines array length (when present).
-    def stale_for_file?(file_abs, coverage_lines)
-      ts = coverage_timestamp
-      return true unless File.file?(file_abs)
-
-      fm = File.mtime(file_abs)
-      cov_len = coverage_lines.respond_to?(:length) ? coverage_lines.length : 0
-      src_len = safe_count_lines(file_abs)
-      (fm && fm.to_i > ts.to_i) || (cov_len.positive? && src_len != cov_len)
-    rescue StandardError
-      # Be conservative: if we cannot determine, mark as stale
-      true
-    end
-
-    # Raise CoverageDataProjectStaleError if any covered file is newer or if
-    # tracked files are missing from coverage, or coverage includes deleted files.
-    def check_project!(coverage_map)
-      return if off?
-      ts = coverage_timestamp
-      newer = []
-      deleted = []
-      coverage_files = coverage_map.keys
-      coverage_files.each do |abs|
-        if File.file?(abs)
-          newer << rel(abs) if File.mtime(abs).to_i > ts.to_i
-        else
-          deleted << rel(abs)
-        end
-      end
-
-      missing = []
-      if @tracked_globs && !Array(@tracked_globs).empty?
-        patterns = Array(@tracked_globs).map { |g| File.absolute_path(g, @root) }
-        tracked = patterns.flat_map { |p| Dir.glob(p, File::FNM_EXTGLOB | File::FNM_PATHNAME) }
-                          .select { |p| File.file?(p) }
-        covered_set = coverage_files.to_set rescue coverage_files
-        tracked.each do |abs|
-          missing << rel(abs) unless covered_set.include?(abs)
-        end
-      end
-
-      if !newer.empty? || !missing.empty? || !deleted.empty?
-        raise CoverageDataProjectStaleError.new(
-          nil,
-          nil,
-          cov_timestamp: ts,
-          newer_files: newer,
-          missing_files: missing,
-          deleted_files: deleted,
-          resultset_path: resultset_path
-        )
-      end
-    end
-
-    private
-
-    def coverage_timestamp
-      @cov_timestamp ||= CovUtil.latest_timestamp(@root, resultset: @resultset)
-    end
-
-    def resultset_path
-      @resultset_path ||= CovUtil.find_resultset(@root, resultset: @resultset)
-    rescue StandardError
-      nil
-    end
-
-    def safe_count_lines(path)
-      return 0 unless File.file?(path)
-      File.foreach(path).count
-    rescue StandardError
-      0
-    end
-
-    def rel(path)
-      Pathname.new(path).relative_path_from(Pathname.new(@root)).to_s
-    end
-  end
-end

data/lib/simple_cov_mcp/tools/coverage_table_tool.rb

@@ -1,61 +0,0 @@
-# frozen_string_literal: true
-
-require 'stringio'
-require_relative '../cli'
-require_relative '../base_tool'
-
-module SimpleCovMcp
-  module Tools
-    class CoverageTableTool < BaseTool
-      description <<~DESC
-        Use this when a user wants the plain text coverage table exactly like `simplecov-mcp --table` would print (no ANSI colors).
-        Do not use this for machine-readable data; coverage.all_files returns structured JSON.
-        Inputs: optional project root/resultset path/sort order/staleness mode matching the CLI flags.
-        Output: text block containing the formatted coverage table with headers and percentages.
-        Example: "Show me the CLI coverage table sorted descending".
-      DESC
-      input_schema(
-        type: 'object',
-        additionalProperties: false,
-        properties: {
-          root: {
-            type: 'string',
-            description: 'Project root used to resolve relative inputs.',
-            default: '.'
-          },
-          resultset: {
-            type: 'string',
-            description: 'Path to the SimpleCov .resultset.json file.'
-          },
-          sort_order: {
-            type: 'string',
-            description: "Sort order for the printed coverage table (ascending or descending).",
-            default: 'ascending',
-            enum: ['ascending', 'descending']
-          },
-          stale: {
-            type: 'string',
-            description: "How to handle missing/outdated coverage data. 'off' skips checks; 'error' raises.",
-            enum: ['off', 'error'],
-            default: 'off'
-          }
-        }
-      )
-
-      class << self
-        def call(root: '.', resultset: nil, sort_order: 'ascending', stale: 'off', server_context:)
-          # Capture the output of the CLI's table report while honoring CLI options
-          output = StringIO.new
-          cli = CoverageCLI.new
-          cli.instance_variable_set(:@root, root || '.')
-          cli.instance_variable_set(:@resultset, resultset)
-          cli.instance_variable_set(:@stale_mode, (stale || 'off').to_s)
-          cli.show_default_report(sort_order: sort_order.to_sym, output: output)
-          ::MCP::Tool::Response.new([{ type: 'text', text: output.string }])
-        rescue => e
-          handle_mcp_error(e, 'CoverageTableTool')
-        end
-      end
-    end
-  end
-end

data/lib/simple_cov_mcp/util.rb

@@ -1,122 +0,0 @@
-# frozen_string_literal: true
-
-module SimpleCovMcp
-    RESULTSET_CANDIDATES = [
-      '.resultset.json',
-      'coverage/.resultset.json',
-      'tmp/.resultset.json'
-    ].freeze
-
-    module CovUtil
-      module_function
-
-      
-      def log(msg)
-        path = File.expand_path('~/simplecov_mcp.log')
-        File.open(path, 'a') { |f| f.puts "[#{Time.now.iso8601}] #{msg}" }
-      rescue StandardError
-        # ignore logging failures
-      end
-
-      def find_resultset(root, resultset: nil)
-        if resultset && !resultset.to_s.empty?
-          path = File.absolute_path(resultset, root)
-          if (resolved = resolve_resultset_candidate(path, strict: true))
-            return resolved
-          end
-        end
-
-        if (env = ENV['SIMPLECOV_RESULTSET']) && !env.empty?
-          path = File.absolute_path(env, root)
-          if (resolved = resolve_resultset_candidate(path, strict: false))
-            return resolved
-          end
-        end
-        RESULTSET_CANDIDATES
-          .map { |p| File.absolute_path(p, root) }
-          .find { |p| File.file?(p) } or
-          raise "Could not find .resultset.json under #{root.inspect}; run tests or set SIMPLECOV_RESULTSET"
-      end
-
-      # returns { abs_path => {'lines' => [hits|nil,...]} }
-      def load_latest_coverage(root, resultset: nil)
-        rs = find_resultset(root, resultset: resultset)
-        raw = JSON.parse(File.read(rs))
-        _suite, data = raw.max_by { |_k, v| (v['timestamp'] || v['created_at'] || 0).to_i }
-        cov = data['coverage'] or raise "No 'coverage' key found in resultset file: #{rs}"
-        cov.transform_keys { |k| File.absolute_path(k, root) }
-      end
-
-      # Returns the timestamp (Integer seconds) for the latest coverage entry
-      # in the resultset. Used for staleness checks against source mtimes.
-      def latest_timestamp(root, resultset: nil)
-        rs = find_resultset(root, resultset: resultset)
-        raw = JSON.parse(File.read(rs))
-        _suite, data = raw.max_by { |_k, v| (v['timestamp'] || v['created_at'] || 0).to_i }
-        (data['timestamp'] || data['created_at'] || 0).to_i
-      end
-
-      def resolve_resultset_candidate(path, strict:)
-        return path if File.file?(path)
-        if File.directory?(path)
-          candidate = File.join(path, '.resultset.json')
-          return candidate if File.file?(candidate)
-          raise "No .resultset.json found in directory: #{path}" if strict
-          return nil
-        end
-        raise "Specified resultset not found: #{path}" if strict
-        nil
-      end
-
-      def lookup_lines(cov, file_abs)
-        if (h = cov[file_abs]) && h['lines'].is_a?(Array)
-          return h['lines']
-        end
-
-        # try without current working directory prefix
-        cwd = Dir.pwd
-        without = file_abs.sub(/\A#{Regexp.escape(cwd)}\//, '')
-        if (h = cov[without]) && h['lines'].is_a?(Array)
-          return h['lines']
-        end
-
-        # fallback: basename match
-        base = File.basename(file_abs)
-        kv = cov.find { |k, v| File.basename(k) == base && v['lines'].is_a?(Array) }
-        kv and return kv[1]['lines']
-
-        raise "No coverage entry found for #{file_abs}"
-      end
-
-      def summary(arr)
-        total = 0
-        covered = 0
-        arr.each do |hits|
-          next if hits.nil?
-          total += 1
-          covered += 1 if hits.to_i > 0
-        end
-        pct = total.zero? ? 100.0 : ((covered.to_f * 100.0 / total) * 100).round / 100.0
-        { 'covered' => covered, 'total' => total, 'pct' => pct }
-      end
-
-      def uncovered(arr)
-        out = []
-        arr.each_with_index do |hits, i|
-          next if hits.nil?
-          out << (i + 1) if hits.to_i.zero?
-        end
-        out
-      end
-
-      def detailed(arr)
-        rows = []
-        arr.each_with_index do |hits, i|
-          next if hits.nil?
-          h = hits.to_i
-          rows << { 'line' => i + 1, 'hits' => h, 'covered' => h.positive? }
-        end
-        rows
-      end
-    end
-end