testprune 0.4.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fdc667523d09a211fe97edcc2175b58b341ab9cfcadaa0aed693d139d95f8319
-  data.tar.gz: cc7047cf657da982ed4ba936c1b3cb4cba06ea11e6183b6619e61d08073cdb45
+  metadata.gz: 1b3054af048bc880b468b220a5fe5755ff5480a7e4c58ec4f365215b57376004
+  data.tar.gz: a0cdf1a94708a15ebab44407f40a32963ce09805f979d5a4e537affe2a8f96c4
 SHA512:
-  metadata.gz: 7d7cfef25ef87d93ea0e928409a9dd8aa778fac90ad56e501a2a29de1322b02656608a6b8761902b2e801773b8c900126f65695995d464fda44d84a71cdef5e2
-  data.tar.gz: 9ae8e0da87b1f18a54fb2b4d4a3f43875380af913694eaabd5aac78fbe2ca3d927709edb557ba9b6b9221e6f556ce37b9570d91f8359e41cfa0d99c1a880aacc
+  metadata.gz: e03f881713e69ad483d978d28699651872efede8f815db3fe113b06059c7fad3bd2a3fee86a0ff12513a8fbd573bbdbf5fe5810d66c62c465a92ac8fc96aa5f9
+  data.tar.gz: ebfab54ff0ed0e6b8a2a0424d59c10ba444f10e1ac42c09f537e79b96873fc3d1ca9f5f3202be773bc9f3486fd318c1f0d3a9e9132ac3a743c09863c15f98f47

data/README.md

@@ -112,7 +112,7 @@ testprune prune test/models test/jobs -s app -s lib
 testprune prune -- bundle exec rails test test/models/
 ```
 
-`prune` runs `scan` to capture coverage data, then immediately runs `apply` — which prints the report and prompts before writing any patch. Use this when you want the full workflow without running three separate commands.
+`prune` runs `scan` to capture coverage data, then immediately runs `apply` — which opens the guided reviewer (or, non-interactively, prompts) before writing any patch. Use this when you want the full workflow without running three separate commands.
 
 ### Step 2 — Report
 
@@ -138,23 +138,22 @@ testprune report -s app -s lib
   ──────────────────────────────────────────────────────────────
 
     [identical]  CalculatorTest#test_add_again
-    at: test/calculator_test.rb:16
-    reason: identical coverage to CalculatorTest#test_add
-    kept by: CalculatorTest#test_add
-    both cover: Calculator#add (lib/calculator.rb:4)
+    remove: test/calculator_test.rb:16
+    keep:   test/calculator_test.rb:11  CalculatorTest#test_add
+    covers 1 unit — all retained by the keeper
     ✓ safe — every covered unit is retained by another test
 
   ● MEDIUM confidence — review  (1)
   ──────────────────────────────────────────────────────────────
 
     [structural]  CalculatorTest#test_positive
-    at: test/calculator_test.rb:20
-    reason: test body structurally identical to CalculatorTest#test_nonpositive
-    covers: Calculator#sign (lib/calculator.rb:8)
+    remove: test/calculator_test.rb:20
+    keep:   test/calculator_test.rb:25  CalculatorTest#test_nonpositive
+    covers 2 units
     · review-only — not auto-applied
 
   Estimated CI savings
-  1 test(s)  ·  0.0132s saved  ·  ~85.7% of suite
+  1 test(s)  ·  0.0000s saved  ·  ~20.3% of suite
   Note: wall-clock savings lower on parallel CI runners
 
   Run testprune apply to review and emit a removal patch.
@@ -168,14 +167,35 @@ testprune report -s app -s lib
 testprune apply
 ```
 
-The tool reprints the full report, then prompts:
+In an interactive terminal, `apply` opens a **guided reviewer** rather than dumping the whole report. It walks the safely-removable tests one *cluster* at a time — every test that duplicates a single keeper is grouped into one decision — starting with the highest-confidence `identical` matches:
 
 ```
-Apply 1 HIGH-confidence, safety-verified removal(s) as a patch?
-(MEDIUM/LOW review-only candidates are NOT patched automatically.) [y/N]
+Identical coverage   cluster 1 / 1   0 accepted
+████████████████████████████ 1/1
+
+ KEEP     test/calculator_test.rb:11
+          #test_add
+
+ REMOVE   1 test with identical coverage — all 1 unit retained by the keeper
+            :16  #test_add_again
+
+✓ safe — every covered unit remains covered by the kept test
+
+[a] accept & remove   [s] skip   [d] diff vs keeper   [q] quit & write
+```
+
+- **`a`** accept the whole cluster · **`s`** skip it · **`d`** view a side-by-side diff of the two test bodies · **`q`** stop and write a patch for whatever you've accepted so far.
+- Review-only candidates (structural / overlap) are never auto-patched; they're summarized at the end — inspect them with `testprune report`.
+
+For non-interactive use (CI, pipes):
+
+```sh
+testprune apply --yes     # accept all safe removals without prompting
 ```
 
-Answering `y` writes `tmp/.testprune/removal.patch`. **No files are modified yet.**
+When stdout isn't a TTY and `--yes` isn't given, `apply` falls back to printing the report and a single `[y/N]` prompt.
+
+Accepted removals are written to `tmp/.testprune/removal.patch`. **No files are modified yet.**
 
 ```sh
 git apply --check tmp/.testprune/removal.patch   # dry-run first

data/assets/report-example.svg

@@ -1,5 +1,5 @@
-<svg viewBox="0 0 661 668" xmlns="http://www.w3.org/2000/svg" role="img" aria-label="testprune report — styled terminal output">
-  <rect width="661" height="668" fill="#0d1117" rx="14"/>
+<svg viewBox="0 0 598 648" xmlns="http://www.w3.org/2000/svg" role="img" aria-label="testprune report — styled terminal output">
+  <rect width="598" height="648" fill="#0d1117" rx="14"/>
   <g font-family="ui-monospace,'SF Mono',Menlo,Consolas,monospace" font-size="13" xml:space="preserve">
     <text x="22" y="34"><tspan fill="#7D56F4">╭──────────────────────────────────────────╮</tspan></text>
     <text x="22" y="54"><tspan fill="#7D56F4">│ </tspan><tspan fill="#E2E8F0">  testprune — coverage redundancy report</tspan><tspan fill="#E2E8F0"> </tspan><tspan fill="#7D56F4">│</tspan></text>
@@ -8,23 +8,22 @@
     <text x="22" y="134"><tspan fill="#22C55E" font-weight="700">  ● HIGH confidence — safe to remove</tspan><tspan fill="#9CA3AF">  (1)</tspan></text>
     <text x="22" y="154"><tspan fill="#3D3D5C">  ──────────────────────────────────────────────────────────────</tspan></text>
     <text x="22" y="194"><tspan fill="#7D56F4">    [identical]</tspan><tspan fill="#E2E8F0">  CalculatorTest#test_add_again</tspan></text>
-    <text x="22" y="214"><tspan fill="#3D3D5C">    at: </tspan><tspan fill="#9CA3AF">test/calculator_test.rb:16</tspan></text>
-    <text x="22" y="234"><tspan fill="#3D3D5C">    reason: </tspan><tspan fill="#9CA3AF">identical coverage to CalculatorTest#test_add</tspan></text>
-    <text x="22" y="254"><tspan fill="#3D3D5C">    kept by: CalculatorTest#test_add</tspan></text>
-    <text x="22" y="274"><tspan fill="#3D3D5C">    both cover: Calculator#add (lib/calculator.rb:4)</tspan></text>
-    <text x="22" y="294"><tspan fill="#22C55E">    ✓ safe — every covered unit is retained by another test</tspan></text>
-    <text x="22" y="334"><tspan fill="#F59E0B" font-weight="700">  ● MEDIUM confidence — review</tspan><tspan fill="#9CA3AF">  (1)</tspan></text>
-    <text x="22" y="354"><tspan fill="#3D3D5C">  ──────────────────────────────────────────────────────────────</tspan></text>
-    <text x="22" y="394"><tspan fill="#7D56F4">    [structural]</tspan><tspan fill="#E2E8F0">  CalculatorTest#test_positive</tspan></text>
-    <text x="22" y="414"><tspan fill="#3D3D5C">    at: </tspan><tspan fill="#9CA3AF">test/calculator_test.rb:20</tspan></text>
-    <text x="22" y="434"><tspan fill="#3D3D5C">    reason: </tspan><tspan fill="#9CA3AF">test body structurally identical to CalculatorTest#test_nonpositive</tspan></text>
-    <text x="22" y="454"><tspan fill="#3D3D5C">    covers: Calculator#sign (lib/calculator.rb:8)</tspan></text>
-    <text x="22" y="474"><tspan fill="#3D3D5C">    · review-only — not auto-applied</tspan></text>
-    <text x="22" y="514"><tspan fill="#7D56F4">╭─────────────────────────────────────────────────────────╮</tspan></text>
-    <text x="22" y="534"><tspan fill="#7D56F4">│ </tspan><tspan fill="#E2E8F0">  Estimated CI savings</tspan><tspan fill="#E2E8F0">                                  </tspan><tspan fill="#7D56F4">│</tspan></text>
-    <text x="22" y="554"><tspan fill="#7D56F4">│ </tspan><tspan fill="#22C55E">  1 test(s)</tspan><tspan fill="#9CA3AF">  ·  </tspan><tspan fill="#22C55E">0.0132s saved</tspan><tspan fill="#9CA3AF">  ·  </tspan><tspan fill="#22C55E">~85.7% of suite</tspan><tspan fill="#E2E8F0">       </tspan><tspan fill="#7D56F4">│</tspan></text>
-    <text x="22" y="574"><tspan fill="#7D56F4">│ </tspan><tspan fill="#9CA3AF">  Note: wall-clock savings lower on parallel CI runners</tspan><tspan fill="#E2E8F0"> </tspan><tspan fill="#7D56F4">│</tspan></text>
-    <text x="22" y="594"><tspan fill="#7D56F4">╰─────────────────────────────────────────────────────────╯</tspan></text>
-    <text x="22" y="634"><tspan fill="#9CA3AF">  Run </tspan><tspan fill="#7D56F4">testprune apply</tspan><tspan fill="#9CA3AF"> to review and emit a removal patch.</tspan></text>
+    <text x="22" y="214"><tspan fill="#3D3D5C">    remove: </tspan><tspan fill="#9CA3AF">test/calculator_test.rb:16</tspan></text>
+    <text x="22" y="234"><tspan fill="#3D3D5C">    keep:   </tspan><tspan fill="#9CA3AF">test/calculator_test.rb:11</tspan><tspan fill="#E2E8F0">  </tspan><tspan fill="#3D3D5C">CalculatorTest#test_add</tspan></text>
+    <text x="22" y="254"><tspan fill="#3D3D5C">    covers 1 unit — all retained by the keeper</tspan></text>
+    <text x="22" y="274"><tspan fill="#22C55E">    ✓ safe — every covered unit is retained by another test</tspan></text>
+    <text x="22" y="314"><tspan fill="#F59E0B" font-weight="700">  ● MEDIUM confidence — review</tspan><tspan fill="#9CA3AF">  (1)</tspan></text>
+    <text x="22" y="334"><tspan fill="#3D3D5C">  ──────────────────────────────────────────────────────────────</tspan></text>
+    <text x="22" y="374"><tspan fill="#7D56F4">    [structural]</tspan><tspan fill="#E2E8F0">  CalculatorTest#test_positive</tspan></text>
+    <text x="22" y="394"><tspan fill="#3D3D5C">    remove: </tspan><tspan fill="#9CA3AF">test/calculator_test.rb:20</tspan></text>
+    <text x="22" y="414"><tspan fill="#3D3D5C">    keep:   </tspan><tspan fill="#9CA3AF">test/calculator_test.rb:25</tspan><tspan fill="#E2E8F0">  </tspan><tspan fill="#3D3D5C">CalculatorTest#test_nonpositive</tspan></text>
+    <text x="22" y="434"><tspan fill="#3D3D5C">    covers 2 units</tspan></text>
+    <text x="22" y="454"><tspan fill="#3D3D5C">    · review-only — not auto-applied</tspan></text>
+    <text x="22" y="494"><tspan fill="#7D56F4">╭─────────────────────────────────────────────────────────╮</tspan></text>
+    <text x="22" y="514"><tspan fill="#7D56F4">│ </tspan><tspan fill="#E2E8F0">  Estimated CI savings</tspan><tspan fill="#E2E8F0">                                  </tspan><tspan fill="#7D56F4">│</tspan></text>
+    <text x="22" y="534"><tspan fill="#7D56F4">│ </tspan><tspan fill="#22C55E">  1 test(s)</tspan><tspan fill="#9CA3AF">  ·  </tspan><tspan fill="#22C55E">0.0000s saved</tspan><tspan fill="#9CA3AF">  ·  </tspan><tspan fill="#22C55E">~20.3% of suite</tspan><tspan fill="#E2E8F0">       </tspan><tspan fill="#7D56F4">│</tspan></text>
+    <text x="22" y="554"><tspan fill="#7D56F4">│ </tspan><tspan fill="#9CA3AF">  Note: wall-clock savings lower on parallel CI runners</tspan><tspan fill="#E2E8F0"> </tspan><tspan fill="#7D56F4">│</tspan></text>
+    <text x="22" y="574"><tspan fill="#7D56F4">╰─────────────────────────────────────────────────────────╯</tspan></text>
+    <text x="22" y="614"><tspan fill="#9CA3AF">  Run </tspan><tspan fill="#7D56F4">testprune apply</tspan><tspan fill="#9CA3AF"> to review and emit a removal patch.</tspan></text>
   </g>
 </svg>

data/lib/testprune/cli.rb

@@ -34,6 +34,7 @@ module Testprune
                                noise and subtract them (0..1; default 0.5; 0 to disable)
             --json             Emit machine-readable JSON (report only)
         -V, --verbose          Show raw test output during scan (disables progress display)
+        -y, --yes              Skip interactive review; accept all safe removals (apply)
         -h, --help             Show this help
         -v, --version          Show version
     TXT
@@ -81,6 +82,7 @@ module Testprune
         o.on('--baseline FRAC', Float) { |v| opts[:baseline] = v }
         o.on('--json')              { opts[:json] = true }
         o.on('-V', '--verbose')     { opts[:verbose] = true }
+        o.on('-y', '--yes')         { opts[:yes] = true }
         o.on('-h', '--help')        { puts(BANNER); exit(0) }
       end
       rest = parser.parse(argv)
@@ -173,40 +175,54 @@ module Testprune
       apply_config(opts)
       require_relative 'analysis'
       result = Analysis.new(Testprune.config).call
-      require_relative 'report'
-      puts(Report.new(result).render)
 
       approved = result.approved_removals
       if approved.empty?
+        require_relative 'report'
+        puts(Report.new(result).render)
         msg = "  Nothing safe to remove. No patch written."
         puts(UI.tty?($stdout) ? UI::Styles::SUCCESS_BOX.render(msg) : "\n#{msg.strip}")
         return nil
       end
 
-      # Styled confirmation prompt
-      if UI.tty?($stdout)
-        puts
-        puts "  Apply #{UI::Styles::GREEN_TEXT.render(approved.size.to_s)} HIGH-confidence removal(s) as a patch?"
-        puts "  #{UI::Styles::DIM_TEXT.render('(MEDIUM/LOW review-only candidates are NOT patched.)')}"
-        print "  #{UI::Styles::PURPLE_TEXT.render('[y/N]')} > "
-      else
-        print("\nApply #{approved.size} HIGH-confidence, safety-verified removal(s) as a patch?\n" \
-              "(MEDIUM/LOW review-only candidates are NOT patched automatically.) [y/N] ")
-      end
-
-      answer = $stdin.gets&.strip&.downcase
-      unless %w[y yes].include?(answer)
-        msg = "  Aborted — no patch written."
-        puts(UI.tty?($stdout) ? UI::Styles::DIM_TEXT.render(msg) : 'Aborted. No patch written.')
-        return false
+      accepted =
+        if opts[:yes]
+          approved
+        elsif UI.tty?($stdout)
+          require_relative 'ui/reviewer'
+          UI::Reviewer.new(result).run
+        else
+          noninteractive_confirm(result, approved)
+        end
+
+      return false if accepted == false # explicit abort at the non-interactive prompt
+      if accepted.nil? || accepted.empty?
+        msg = "  Nothing accepted — no patch written."
+        puts(UI.tty?($stdout) ? UI::Styles::DIM_TEXT.render(msg) : msg.strip)
+        return nil
       end
 
       require_relative 'patch_writer'
-      path = PatchWriter.new(Testprune.config).write(approved)
+      path = PatchWriter.new(Testprune.config).write(accepted)
+      print_patch_written(path, accepted.size)
+      path
+    end
+
+    # Non-TTY (piped/CI without --yes): show the full report and ask once.
+    # Returns the approved set on yes, or false on abort.
+    def noninteractive_confirm(result, approved)
+      require_relative 'report'
+      puts(Report.new(result).render)
+      print("\nApply #{approved.size} HIGH-confidence, safety-verified removal(s) as a patch?\n" \
+            "(MEDIUM/LOW review-only candidates are NOT patched automatically.) [y/N] ")
+      answer = $stdin.gets&.strip&.downcase
+      %w[y yes].include?(answer) ? approved : false
+    end
 
+    def print_patch_written(path, count)
       if UI.tty?($stdout)
         box = [
-          "  #{UI::Styles::GREEN_TEXT.render('✓')}  Patch written",
+          "  #{UI::Styles::GREEN_TEXT.render('✓')}  Patch written — #{count} test(s)",
           "     #{path}",
           "     #{UI::Styles::DIM_TEXT.render('Apply with:')}  " \
           "#{UI::Styles::PURPLE_TEXT.render("git apply #{path}")}"
@@ -216,8 +232,6 @@ module Testprune
         puts("Wrote #{path}")
         puts("Review it, then apply with:  git apply #{path}")
       end
-
-      path
     end
   end
 end

data/lib/testprune/report.rb

@@ -30,77 +30,11 @@ module Testprune
       UI::ReportRenderer.new(@result).render
     end
 
-    def section(title, candidates)
-      return [] if candidates.empty?
-
-      out = ["#{title}: #{candidates.size}"]
-      candidates.each { |c| out.concat(candidate_lines(c)) }
-      out << ''
-      out
-    end
-
-    def candidate_lines(candidate)
-      fp = candidate.footprint
-      out = []
-      out << "  [#{candidate.group}] #{fp.id}"
-      out << "      at: #{fp.file}:#{fp.line}" if fp.file
-      out << "      reason: #{candidate.reason}"
-      out << "      kept by: #{candidate.kept_by.join(', ')}" unless candidate.kept_by.empty?
-      out.concat(coverage_text_lines(candidate, fp))
-      out << "      #{safety_line(candidate)}"
-      out
-    end
-
-    def coverage_text_lines(candidate, fp)
-      case candidate.group
-      when :identical
-        ["      both cover: #{covered_labels(fp.units)}"]
-      when :subset
-        keeper = find_keeper(candidate)
-        lines = ["      candidate covers: #{covered_labels(fp.units)}"]
-        if keeper
-          extra = keeper.units - fp.units
-          lines << "      keeper adds: #{covered_labels(extra)}" unless extra.empty?
-        end
-        lines
-      else
-        ["      covers: #{covered_labels(fp.units)}"]
-      end
-    end
-
-    def find_keeper(candidate)
-      return nil if candidate.kept_by.empty?
-      return nil unless @result.respond_to?(:detector_result)
-
-      @result.detector_result.footprints.find { |f| f.id == candidate.kept_by.first }
-    end
-
     def covered_labels(units)
       labels = units.map { |id| @result.label_for(id) }.sort
       labels.size <= 4 ? labels.join('; ') : "#{labels.first(4).join('; ')} (+#{labels.size - 4} more)"
     end
 
-    def safety_line(candidate)
-      case candidate.safe
-      when true  then '✓ safe — every covered unit remains covered by a retained test'
-      when false then "✗ NOT safe — #{candidate.safety_note} (kept)"
-      else            '· review-only — not auto-applied'
-      end
-    end
-
-    def savings_section
-      s = @result.savings
-      [
-        'Estimated CI savings:',
-        "  #{s.approved_count} test(s), #{format('%.4f', s.approved_time)}s " \
-        "(~#{format('%.1f', s.percent_of_test_time)}% of #{format('%.4f', s.total_test_time)}s test time)",
-        '  Note: under parallel CI runners, wall-clock savings will be lower.'
-      ]
-    end
-
-    def high_candidates   = @result.candidates.select { |c| c.confidence == :high }
-    def medium_candidates = @result.candidates.select { |c| c.confidence == :medium }
-    def low_candidates    = @result.candidates.select { |c| c.confidence == :low }
     def test_count        = (@result.run['tests'] || []).size
 
     def render_json

data/lib/testprune/review_plan.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module Testprune
+  # Pure (IO-free) transformation of an Analysis::Result into an ordered, clustered
+  # review plan. Candidates are ordered by tier — identical first — and within each
+  # tier grouped by their *keeper*, so a reviewer can approve a whole cluster of
+  # redundant tests in one decision instead of N. File paths are relativized to the
+  # scan root here so every consumer renders short, consistent locations.
+  module ReviewPlan
+    # Review order. `actionable` tiers contain candidates that can actually be
+    # patched (HIGH-confidence, safety-verified); the rest are review-only.
+    TIERS = [
+      { tier: :identical,  title: 'Identical coverage',          actionable: true  },
+      { tier: :subset,     title: 'Subset / subsumed coverage',  actionable: true  },
+      { tier: :structural, title: 'Structurally duplicated body', actionable: false },
+      { tier: :overlap,    title: 'High coverage overlap',        actionable: false }
+    ].freeze
+
+    Loc     = Struct.new(:id, :method, :file, :line, :unit_count, keyword_init: true)
+    Member  = Struct.new(:candidate, :loc, :safe, keyword_init: true)
+    Cluster = Struct.new(:keeper, :members, keyword_init: true) do
+      def size = members.size
+    end
+    TierPlan = Struct.new(:tier, :title, :actionable, :clusters, keyword_init: true) do
+      def count = clusters.sum(&:size)
+    end
+
+    module_function
+
+    # Returns an array of TierPlan in review order. Empty tiers are omitted.
+    # When actionable_only: true, only safety-verified removable candidates are
+    # included (what the interactive reviewer turns into a patch).
+    def build(result, actionable_only: false)
+      root      = result.run['root']
+      keepers   = index_footprints(result)
+      approved  = result.approved_removals.to_set
+
+      TIERS.filter_map do |spec|
+        members = result.candidates.select { |c| c.group == spec[:tier] }
+        members = members.select { |c| approved.include?(c) } if actionable_only
+        next if members.empty?
+
+        clusters = members
+                   .group_by { |c| c.kept_by.first }
+                   .map { |keeper_id, group| cluster_for(keeper_id, group, keepers, approved, root) }
+                   .sort_by { |cl| [-cl.size, cl.keeper&.id || ''] }
+
+        TierPlan.new(tier: spec[:tier], title: spec[:title],
+                     actionable: spec[:actionable], clusters: clusters)
+      end
+    end
+
+    def cluster_for(keeper_id, group, keepers, approved, root)
+      keeper_fp = keepers[keeper_id]
+      keeper_loc = keeper_fp && loc_for(keeper_id, keeper_fp.file, keeper_fp.line,
+                                        keeper_fp.units.size, root)
+      members = group
+                .sort_by { |c| [c.footprint.file.to_s, c.footprint.line.to_i, c.footprint.id] }
+                .map do |c|
+        fp = c.footprint
+        Member.new(candidate: c, safe: approved.include?(c),
+                   loc: loc_for(fp.id, fp.file, fp.line, fp.units.size, root))
+      end
+      Cluster.new(keeper: keeper_loc, members: members)
+    end
+
+    def loc_for(id, file, line, unit_count, root)
+      Loc.new(id: id, method: short_method(id), file: relpath(file, root),
+              line: line, unit_count: unit_count)
+    end
+
+    # `ClassName#method` -> `#method`; leaves bare ids untouched.
+    def short_method(id)
+      idx = id.index('#')
+      idx ? id[idx..] : id
+    end
+
+    def relpath(file, root)
+      return file unless file && root && file.start_with?("#{root}/")
+
+      file[(root.length + 1)..]
+    end
+
+    def index_footprints(result)
+      return {} unless result.respond_to?(:detector_result)
+
+      result.detector_result.footprints.each_with_object({}) { |fp, h| h[fp.id] = fp }
+    end
+  end
+end

data/lib/testprune/ui/report_renderer.rb

@@ -90,18 +90,19 @@ module Testprune
 
       def candidate_lines(candidate)
         fp = candidate.footprint
+        keeper = keeper_footprint(candidate)
         lines = []
 
         group_badge = styled("[#{GROUP_LABELS[candidate.group] || candidate.group}]", Styles::PURPLE_TEXT)
         lines << "    #{group_badge}  #{fp.id}"
-        lines << "    #{styled('at: ', Styles::DIM_TEXT)}#{styled("#{fp.file}:#{fp.line}", Styles::META_TEXT)}" if fp.file
-        lines << "    #{styled('reason: ', Styles::DIM_TEXT)}#{styled(candidate.reason, Styles::META_TEXT)}"
-
-        unless candidate.kept_by.empty?
-          lines << "    #{styled('kept by: ', Styles::DIM_TEXT)}#{styled(candidate.kept_by.join(', '), Styles::DIM_TEXT)}"
+        # Compare block: the two tests under review, both as relative file:line.
+        lines << "    #{styled('remove:', Styles::DIM_TEXT)} #{styled(location(fp), Styles::META_TEXT)}" if fp.file
+        if keeper
+          lines << "    #{styled('keep:  ', Styles::DIM_TEXT)} #{styled(location(keeper), Styles::META_TEXT)}" \
+                   "  #{styled(keeper.id, Styles::DIM_TEXT)}"
         end
 
-        lines.concat(coverage_detail_lines(candidate, fp))
+        lines.concat(coverage_detail_lines(candidate, fp, keeper))
 
         safety = case candidate.safe
                  when true  then styled('    ✓ safe — every covered unit is retained by another test', Styles::SAFE_LINE)
@@ -136,25 +137,36 @@ module Testprune
         tty? ? Styles::SUCCESS_BOX.render(msg) : msg
       end
 
-      def coverage_detail_lines(candidate, fp)
+      # The full per-unit coverage list (a 60+ item dump on large controller tests)
+      # carries no decision value for identical matches — both tests cover exactly
+      # the same units by construction, and the safety check guarantees the keeper
+      # retains them. So we summarize as a count. Only the subset *delta* (what the
+      # keeper covers beyond the candidate) earns a labeled list, since that's the
+      # reason the keeper is worth keeping.
+      def coverage_detail_lines(candidate, fp, keeper)
         case candidate.group
         when :identical
-          [coverage_line('both cover', fp.units)]
+          [count_line("covers #{unit_word(fp.units.size)} — all retained by the keeper")]
         when :subset
-          keeper = keeper_footprint(candidate)
-          lines = [coverage_line('candidate covers', fp.units)]
-          if keeper
-            extra = keeper.units - fp.units
-            lines << coverage_line('keeper adds', extra) unless extra.empty?
-          end
-          lines
+          extra = keeper ? (keeper.units - fp.units) : []
+          extra.empty? ? [count_line("covers #{unit_word(fp.units.size)}")]
+                       : ["    #{styled('keeper adds: ', Styles::DIM_TEXT)}#{styled(format_units(extra), Styles::DIM_TEXT)}"]
         else
-          [coverage_line('covers', fp.units)]
+          [count_line("covers #{unit_word(fp.units.size)}")]
         end
       end
 
-      def coverage_line(label, units)
-        "    #{styled("#{label}: ", Styles::DIM_TEXT)}#{styled(format_units(units), Styles::DIM_TEXT)}"
+      def count_line(text) = "    #{styled(text, Styles::DIM_TEXT)}"
+
+      def unit_word(n) = "#{n} unit#{'s' if n != 1}"
+
+      def location(fp) = "#{relpath(fp.file)}:#{fp.line}"
+
+      def relpath(file)
+        root = @result.run['root']
+        return file unless file && root && file.start_with?("#{root}/")
+
+        file[(root.length + 1)..]
       end
 
       def keeper_footprint(candidate)

data/lib/testprune/ui/reviewer.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+require 'prism'
+require_relative 'styles'
+require_relative '../review_plan'
+require_relative '../test_body'
+
+module Testprune
+  module UI
+    # Interactive, cluster-at-a-time reviewer for `apply`. Walks the actionable
+    # removals in review order (identical first), grouping redundant tests under a
+    # shared keeper so one keystroke accepts a whole cluster. Returns the list of
+    # accepted candidates for the patch writer.
+    #
+    # Input is read one keystroke at a time. The key reader is injectable so the
+    # flow is testable without a real TTY (see ReviewerTest).
+    class Reviewer
+      KEYS = "  [a] accept & remove   [s] skip   [d] diff vs keeper   [q] quit & write"
+
+      def initialize(result, input: $stdin, output: $stdout, color: nil, read_key: nil)
+        @result   = result
+        @in       = input
+        @out      = output
+        @color    = color.nil? ? UI.tty?(output) : color
+        @read_key = read_key || method(:default_read_key)
+        @fp_by_id = ReviewPlan.index_footprints(result)
+      end
+
+      # Returns an Array of accepted Candidate objects (subset of approved_removals).
+      def run
+        clusters = ReviewPlan.build(@result, actionable_only: true)
+                             .flat_map { |tier| tier.clusters.map { |c| [tier, c] } }
+        return finish([]) if clusters.empty?
+
+        accepted = []
+        clusters.each_with_index do |(tier, cluster), i|
+          @diff_idx = 0
+          loop do
+            render_cluster(tier, cluster, i + 1, clusters.size, accepted.size)
+            case @read_key.call
+            when 'a', ' ', "\r", "\n"
+              accepted.concat(cluster.members.select(&:safe).map(&:candidate))
+              break
+            when 's' then break
+            when 'd' then show_diff(cluster)
+            when 'q', "", nil then return finish(accepted)
+            end
+          end
+        end
+        finish(accepted)
+      end
+
+      private
+
+      # ── Rendering ──────────────────────────────────────────────────────────
+
+      def render_cluster(tier, cluster, idx, total, accepted_count)
+        clear
+        line "  #{styled(tier.title, Styles::PURPLE_TEXT)}   " \
+             "#{styled("cluster #{idx} / #{total}", Styles::META_TEXT)}   " \
+             "#{styled("#{accepted_count} accepted", Styles::GREEN_TEXT)}"
+        line "  #{progress_bar(idx, total)}"
+        line ''
+
+        keeper = cluster.keeper
+        line "  #{badge('KEEP', Styles::GREEN_TEXT)}    #{loc(keeper)}"
+        line "            #{styled(keeper.method, Styles::META_TEXT)}" if keeper && keeper.method != keeper.id
+
+        n = cluster.size
+        line ''
+        units = keeper&.unit_count
+        line "  #{badge('REMOVE', Styles::AMBER_TEXT)}  " \
+             "#{n} test#{'s' if n > 1} with identical coverage — " \
+             "#{styled("all #{units} unit#{'s' if units != 1} retained by the keeper", Styles::DIM_TEXT)}"
+        cluster.members.each do |m|
+          where = m.loc.file == keeper&.file ? "    :#{m.loc.line}" : "    #{m.loc.file}:#{m.loc.line}"
+          line "          #{styled(where, Styles::DIM_TEXT)}  #{styled(m.loc.method, Styles::META_TEXT)}"
+        end
+
+        line ''
+        line "  #{styled('✓ safe', Styles::GREEN_TEXT)}#{styled(' — every covered unit remains covered by the kept test', Styles::DIM_TEXT)}"
+        line ''
+        line styled(KEYS, Styles::META_TEXT)
+      end
+
+      def show_diff(cluster)
+        member  = cluster.members[@diff_idx % cluster.size]
+        @diff_idx += 1
+        keeper_fp = cluster.keeper && @fp_by_id[cluster.keeper.id]
+
+        clear
+        kb = keeper_fp ? body_lines(keeper_fp.file, keeper_fp.line) : []
+        mb = body_lines(member.candidate.footprint.file, member.candidate.footprint.line)
+        render_diff(cluster.keeper&.method || '(keeper)', kb, member.loc.method, mb)
+        more = cluster.size > 1 ? ' · [d] next member' : ''
+        line ''
+        line styled("  press any key to return#{more}", Styles::DIM_TEXT)
+        @read_key.call
+      end
+
+      COL = 46
+
+      def render_diff(keep_name, keep_lines, rm_name, rm_lines)
+        line "  #{badge('KEEP', Styles::GREEN_TEXT)} #{styled(keep_name, Styles::META_TEXT)}" \
+             "#{' ' * [COL - keep_name.length - 7, 1].max}#{badge('REMOVE', Styles::AMBER_TEXT)} #{styled(rm_name, Styles::META_TEXT)}"
+        line "  #{styled('─' * COL, Styles::DIM_TEXT)} #{styled('─' * COL, Styles::DIM_TEXT)}"
+        [keep_lines.size, rm_lines.size].max.times do |i|
+          left  = fmt_code(keep_lines[i])
+          right = fmt_code(rm_lines[i])
+          line "  #{left} #{right}"
+        end
+      end
+
+      def fmt_code(entry)
+        return ' ' * COL unless entry
+
+        num, text = entry
+        s = format('%4d  %s', num, text)
+        clip(s, COL)
+      end
+
+      def progress_bar(idx, total)
+        width  = 28
+        filled = total.zero? ? width : (idx.to_f / total * width).round
+        bar = ('█' * filled) + ('░' * (width - filled))
+        "#{styled(bar, Styles::PURPLE_TEXT)} #{styled("#{idx}/#{total}", Styles::META_TEXT)}"
+      end
+
+      def finish(accepted)
+        clear
+        if accepted.empty?
+          line "  #{styled('No removals accepted', Styles::DIM_TEXT)} — no patch will be written."
+        else
+          line "  #{styled('✓', Styles::GREEN_TEXT)}  Accepted #{styled(accepted.size.to_s, Styles::GREEN_TEXT)} removal(s)."
+        end
+
+        review_only = ReviewPlan.build(@result).reject(&:actionable)
+        unless review_only.empty?
+          counts = review_only.map { |t| "#{t.count} #{t.title.downcase}" }.join(', ')
+          line "  #{styled("Review-only candidates not shown here (never auto-patched): #{counts}.", Styles::DIM_TEXT)}"
+          line "  #{styled('See them with:', Styles::DIM_TEXT)} testprune report"
+        end
+        accepted
+      end
+
+      # ── Helpers ────────────────────────────────────────────────────────────
+
+      def loc(l)
+        return styled('(keeper not found)', Styles::DIM_TEXT) unless l
+
+        "#{styled("#{l.file}:#{l.line}", Styles::META_TEXT)}"
+      end
+
+      def badge(text, style) = styled(" #{text} ", style)
+
+      def styled(text, style) = @color ? style.render(text) : text
+
+      def line(text = '') = @out.puts(text)
+
+      def clear = (@out.print("\e[2J\e[H") if @color)
+
+      def clip(str, width)
+        return str.ljust(width) if str.length <= width
+
+        "#{str[0, width - 1]}…"
+      end
+
+      def body_lines(file, start_line)
+        return [] unless file && File.exist?(file)
+
+        src  = File.read(file).lines
+        node = TestBody.locate(Prism.parse(File.read(file)).value, start_line)
+        return [] unless node
+
+        (node.location.start_line..node.location.end_line).map do |n|
+          [n, (src[n - 1] || '').chomp]
+        end
+      rescue StandardError
+        []
+      end
+
+      def default_read_key
+        require 'io/console'
+        if @color && @in.respond_to?(:getch)
+          @in.getch
+        else
+          (@in.gets || 'q')[0]
+        end
+      end
+    end
+  end
+end

data/lib/testprune/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Testprune
-  VERSION = '0.4.1'
+  VERSION = '0.5.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: testprune
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.5.0
 platform: ruby
 authors:
 - Seth MacPherson
@@ -73,6 +73,7 @@ files:
 - lib/testprune/patch_writer.rb
 - lib/testprune/recorder.rb
 - lib/testprune/report.rb
+- lib/testprune/review_plan.rb
 - lib/testprune/runner.rb
 - lib/testprune/safety_check.rb
 - lib/testprune/savings_estimator.rb
@@ -82,6 +83,7 @@ files:
 - lib/testprune/ui/error_toggle.rb
 - lib/testprune/ui/progress.rb
 - lib/testprune/ui/report_renderer.rb
+- lib/testprune/ui/reviewer.rb
 - lib/testprune/ui/styles.rb
 - lib/testprune/version.rb
 homepage: https://github.com/seth-macpherson/testprune
@@ -103,7 +105,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 4.0.10
 specification_version: 4
 summary: Audits a Ruby test suite for duplicate/redundant coverage using Prism AST
   + Coverage data