testprune 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e0524c23f51b9afdbb9731dee285f81be5571abcff4730b09194865edcb01d0d
-  data.tar.gz: 648d2e72e49dc16a083b7ca116889e4694fdaa72e6e1337207bdc7da7376260f
+  metadata.gz: 5df7245c9484fac5c375f5bc3275e2af2ffb4a48e1090a15cfff56188a24047f
+  data.tar.gz: 23edfd9d58322bdc03dacc04d5986772dfe57690ad5a6481da6bcf21dc604715
 SHA512:
-  metadata.gz: 762a0cf8e298644d06094814b81e9579312c16247a649013da282207623e88349a0918a95657f9a33125fb9b0a029369630071806b484b8c5869f4979dafc858
-  data.tar.gz: a245409289d680cfe06bc08ad2afdc004ae1d542f9e2895e70d0840834852f8ebf75d95215129f1afd7c58d84b34925864d5af02ae34ae933b70c34aa35a0a75
+  metadata.gz: cab54aebaf7b972b7efa70c617bc769109ce74d3aee567717ddd33339d164410a78c4cb6e98ac6277f28828e26179fff8b4cf267d511a1fdbe22ea6b0e5781ca
+  data.tar.gz: 5a9ef2a87d2ce1ddd88ace0cc19dc6ba3259ba7a500db3abc9f88cb95805ef5a42736c29d7489eb4cdf992d7fec2361bf7b584fbd7532ca88044e8b6add3dde9

data/README.md

@@ -82,8 +82,15 @@ testprune scan -- bundle exec rails test test/controllers/
 
 # Restrict which source files are analyzed (-s is repeatable)
 testprune scan -s app -s lib -s packs
+
+# Show raw test output (disables the progress display)
+testprune scan --verbose        # or -V
 ```
 
+By default, `testprune scan` suppresses raw test runner output and shows a live progress display (spinner + test counter + elapsed time). If test errors occur they are flagged non-blocking — the scan completes and you're prompted to expand the error detail before continuing.
+
+Pass `--verbose` / `-V` to stream raw output directly instead (the pre-0.4.0 behavior).
+
 When run with no arguments, `testprune scan` checks your `test/` directory and flags any subdirectories whose names contain `selenium`, `request`, `piper`, or `integration` — folders that tend to be slow, browser-driven, or external and are generally poor candidates for coverage analysis. You'll be prompted to exclude them before the run starts:
 
 ```
@@ -494,6 +501,7 @@ testprune report -s app -s lib || true
 | `-o, --output DIR` | `tmp/.testprune` | all | Where `run.json` and `removal.patch` are written. |
 | `--baseline FRAC` | `0.5` | report, apply | Strip units in ≥ FRAC of tests as shared-setup noise before detection. `0` disables. |
 | `--json` | off | report | Emit machine-readable JSON instead of human text. |
+| `-V, --verbose` | off | scan | Stream raw test output directly (disables progress display). |
 | `-h, --help` | | all | Show help. |
 | `-v, --version` | | | Print version. |
 
@@ -506,6 +514,7 @@ testprune report -s app -s lib || true
 | `TESTPRUNE_OUTPUT_DIR` | Output directory. Set automatically by `testprune scan`. |
 | `TESTPRUNE_DEBUG` | Print adapter-load diagnostics (`[testprune-debug] autostart loaded in pid …`). Useful when capture produces no `run.json`. |
 | `DISABLE_SPRING` | Disable Spring preloader so the test process inherits testprune's instrumentation. |
+| `NO_COLOR` | Set to any value to disable all ANSI color output ([no-color.org](https://no-color.org/)). Styled output is also disabled automatically when stdout/stderr is not a TTY (e.g. piped output, CI without color support). |
 
 </details>
 

data/lib/testprune/cli.rb

@@ -2,6 +2,7 @@
 
 require 'optparse'
 require_relative '../testprune'
+require_relative 'ui'
 
 module Testprune
   # Command-line front end. Three real commands:
@@ -32,6 +33,7 @@ module Testprune
             --baseline FRAC    Treat units run by >= FRAC of tests as shared-setup
                                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)
         -h, --help             Show this help
         -v, --version          Show version
     TXT
@@ -78,6 +80,7 @@ module Testprune
         o.on('-o', '--output DIR')  { |v| opts[:output] = v }
         o.on('--baseline FRAC', Float) { |v| opts[:baseline] = v }
         o.on('--json')              { opts[:json] = true }
+        o.on('-V', '--verbose')     { opts[:verbose] = true }
         o.on('-h', '--help')        { puts(BANNER); exit(0) }
       end
       rest = parser.parse(argv)
@@ -104,7 +107,7 @@ module Testprune
       elsif test_command.nil?
         test_command = runner.command_for_paths(paths)
       end
-      runner.call(test_command)
+      runner.call(test_command, verbose: opts[:verbose])
     end
 
     def prompt_noisy_exclusions(runner)
@@ -131,8 +134,29 @@ module Testprune
     end
 
     def cmd_prune(argv)
+      if UI.tty?($stderr)
+        $stderr.puts UI::Styles::HEADER_BOX.render("✂️  testprune prune — scan + apply in one step")
+        $stderr.puts
+      end
       cmd_scan(argv)
-      cmd_apply([])
+      if UI.tty?($stderr)
+        sep = UI::Styles::PURPLE_TEXT.render('  ' + '━' * 58)
+        $stderr.puts
+        $stderr.puts sep
+        $stderr.puts "  #{UI::Styles::PURPLE_TEXT.render('✂️')}  Moving to apply…"
+        $stderr.puts sep
+        $stderr.puts
+      end
+      patch_path = cmd_apply([])
+      # T018: done summary
+      if UI.tty?($stdout)
+        summary = case patch_path
+                  when String then "  ✂️  Done — patch written\n     #{UI::Styles::PURPLE_TEXT.render("git apply #{patch_path}")}"
+                  when false  then "  ✂️  Done — aborted, no patch written"
+                  else             "  ✂️  Done — nothing to prune"
+                  end
+        puts UI::Styles::SUCCESS_BOX.render(summary)
+      end
     end
 
     def cmd_report(argv)
@@ -154,22 +178,46 @@ module Testprune
 
       approved = result.approved_removals
       if approved.empty?
-        puts("\nNothing safe to remove. No patch written.")
-        return
+        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
 
-      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
       unless %w[y yes].include?(answer)
-        puts('Aborted. No patch written.')
-        return
+        msg = "  Aborted — no patch written."
+        puts(UI.tty?($stdout) ? UI::Styles::DIM_TEXT.render(msg) : 'Aborted. No patch written.')
+        return false
       end
 
       require_relative 'patch_writer'
       path = PatchWriter.new(Testprune.config).write(approved)
-      puts("Wrote #{path}")
-      puts("Review it, then apply with:  git apply #{path}")
+
+      if UI.tty?($stdout)
+        box = [
+          "  #{UI::Styles::GREEN_TEXT.render('✓')}  Patch written",
+          "     #{path}",
+          "     #{UI::Styles::DIM_TEXT.render('Apply with:')}  " \
+          "#{UI::Styles::PURPLE_TEXT.render("git apply #{path}")}"
+        ].join("\n")
+        puts UI::Styles::SUCCESS_BOX.render(box)
+      else
+        puts("Wrote #{path}")
+        puts("Review it, then apply with:  git apply #{path}")
+      end
+
+      path
     end
   end
 end

data/lib/testprune/report.rb

@@ -26,27 +26,8 @@ module Testprune
     private
 
     def render_text
-      lines = []
-      lines << 'testprune — test coverage redundancy report'
-      lines << "Suite: #{test_count} test(s), framework=#{@result.run['framework']}"
-      if @result.ambient_units.positive?
-        lines << "Baseline: subtracted #{@result.ambient_units} shared-setup unit(s); " \
-                 "#{@result.setup_only} test(s) had no distinctive coverage and were set aside."
-      end
-      lines << ''
-
-      lines.concat(section('HIGH confidence — safe to remove', high_candidates))
-      lines.concat(section('MEDIUM confidence — review (structural duplicates)', medium_candidates))
-      lines.concat(section('LOW confidence — review (overlapping coverage)', low_candidates))
-
-      lines.concat(savings_section)
-      lines << ''
-      lines << if @result.approved_removals.empty?
-                 'No auto-removable candidates. Nothing to apply.'
-               else
-                 'Run `testprune apply` to review and emit a removal patch.'
-               end
-      lines.join("\n")
+      require_relative 'ui/report_renderer'
+      UI::ReportRenderer.new(@result).render
     end
 
     def section(title, candidates)

data/lib/testprune/runner.rb

@@ -2,27 +2,38 @@
 
 require 'fileutils'
 require 'json'
+require 'open3'
 require_relative '../testprune'
+require_relative 'ui'
 
 module Testprune
   # Boots the target project's suite in a subprocess, instrumented so the adapters
   # capture per-test coverage. Reuses the gem's lib via RUBYOPT (-I) so the target
   # project does not need testprune in its Gemfile.
   class Runner
+    # Progress-line patterns: match single-char Minitest/RSpec progress indicators.
+    TEST_PROGRESS_RE = /\A[.FES*P]+\z/
+    # Lines that indicate a test error or failure.
+    ERROR_RE = /Error:|FAILED|Failure:|error:/
+
     def initialize(config)
       @config = config
     end
 
-    # explicit_command: array form of a user-supplied test command (after `--`),
-    # or nil to autodetect.
-    def call(explicit_command = nil)
+    # explicit_command: array form of a user-supplied test command (after `--`), or nil.
+    # verbose: when true, stream raw output directly (no capture, no spinner).
+    def call(explicit_command = nil, verbose: false)
       framework, command = resolve(explicit_command)
 
       FileUtils.mkdir_p(@config.output_dir)
       File.delete(@config.run_file) if File.exist?(@config.run_file)
 
-      warn("testprune: framework=#{framework}  running: #{command.join(' ')}")
-      ok = system(env, *command, chdir: @config.root)
+      if verbose
+        warn("testprune: framework=#{framework}  running: #{command.join(' ')}")
+        ok = system(env, *command, chdir: @config.root)
+      else
+        ok = run_captured(framework, command)
+      end
 
       unless File.exist?(@config.run_file)
         raise Error, 'suite finished but no run.json was captured — the adapter may ' \
@@ -34,8 +45,11 @@ module Testprune
       rescue JSON::ParserError
         '(unreadable — suite may have been interrupted mid-write)'
       end
-      warn("testprune: captured #{count} test(s) -> #{@config.run_file}")
-      warn('testprune: suite exited non-zero; coverage was still captured.') unless ok
+
+      unless verbose
+        warn("testprune: captured #{count} test(s) -> #{@config.run_file}")
+      end
+
       ok
     end
 
@@ -53,6 +67,57 @@ module Testprune
 
     private
 
+    def run_captured(framework, command)
+      progress   = UI::Progress.new(io: $stderr)
+      output     = []
+      error_lines = []
+
+      progress.start
+      start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+
+      ok = Open3.popen2e(env, *command, chdir: @config.root) do |_stdin, oe, wait_thr|
+        oe.each_line do |line|
+          output << line
+          # Count progress chars
+          progress.increment if line.match?(TEST_PROGRESS_RE)
+          error_lines << line.chomp if line.match?(ERROR_RE)
+        end
+        wait_thr.value.success?
+      end
+
+      elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
+      test_count = begin
+        File.exist?(@config.run_file) ? JSON.parse(File.read(@config.run_file)).fetch('tests', []).size : 0
+      rescue StandardError
+        0
+      end
+
+      progress.stop(test_count: test_count, elapsed: elapsed)
+      print_scan_summary(test_count, elapsed, error_lines)
+
+      ok
+    end
+
+    def print_scan_summary(test_count, elapsed, error_lines)
+      mins = (elapsed / 60).to_i
+      secs = (elapsed % 60).to_i
+      time_s = format('%02d:%02d', mins, secs)
+
+      if UI.tty?($stderr)
+        lines = []
+        lines << "  #{UI::Styles::GREEN_TEXT.render('✓')}  Scan complete"
+        lines << "     #{test_count} tests · #{time_s} elapsed"
+        lines << "     Data written to #{@config.output_dir}/"
+        $stderr.puts UI::Styles::SUCCESS_BOX.render(lines.join("\n"))
+      else
+        $stderr.puts("testprune: scan complete — #{test_count} tests in #{time_s}")
+      end
+
+      return if error_lines.empty?
+
+      UI::ErrorToggle.new(errors: error_lines, io: $stderr).run
+    end
+
     def env
       gem_lib = File.expand_path('..', __dir__)
       rubyopt = ["-I#{gem_lib}", '-rtestprune/autostart', ENV['RUBYOPT']].compact.reject(&:empty?).join(' ')

data/lib/testprune/ui/error_toggle.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'testprune/ui/styles'
+
+module Testprune
+  module UI
+    # Post-scan interactive prompt. When test errors occurred (non-blocking),
+    # shows a count indicator and lets the user toggle the error detail on/off
+    # before continuing the workflow.
+    class ErrorToggle
+      def initialize(errors:, io: $stderr, stdin: $stdin)
+        @errors   = errors
+        @io       = io
+        @stdin    = stdin
+        @expanded = false
+      end
+
+      def run
+        return if @errors.empty?
+
+        print_indicator
+        loop do
+          @io.print("  [e + Enter] #{styled('[e]', Styles::PURPLE_TEXT)} show/hide errors" \
+                    "  [Enter] skip > ")
+          @io.flush
+          input = @stdin.gets&.strip&.downcase
+          break if input.nil? || input.empty?
+          if input == 'e'
+            @expanded = !@expanded
+            @expanded ? print_errors : clear_errors
+          end
+        end
+      end
+
+      private
+
+      def tty?
+        return false if ENV['NO_COLOR']
+        @io.respond_to?(:isatty) && @io.isatty
+      end
+
+      def styled(text, style)
+        tty? ? style.render(text) : text
+      end
+
+      def print_indicator
+        label = styled("⚠  #{@errors.size} test error(s) detected", Styles::AMBER_TEXT)
+        note  = styled('  (non-blocking — scan completed)', Styles::META_TEXT)
+        @io.puts("#{label}#{note}")
+      end
+
+      def print_errors
+        sep = styled('  ' + '─' * 62, Styles::DIM_TEXT)
+        @io.puts(sep)
+        @errors.each { |line| @io.puts("    #{styled(line, Styles::ERROR_TEXT)}") }
+        @io.puts(sep)
+      end
+
+      def clear_errors
+        # Errors are already scrolled — just note they're hidden
+        @io.puts(styled('  (errors hidden)', Styles::DIM_TEXT))
+      end
+    end
+  end
+end

data/lib/testprune/ui/progress.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'testprune/ui/styles'
+
+module Testprune
+  module UI
+    # Live scan progress display. Shows a Braille spinner, running test counter,
+    # and elapsed time. All output goes to io (default $stderr) and is suppressed
+    # when not a TTY or when NO_COLOR is set.
+    class Progress
+      FRAMES = %w[⠋ ⠙ ⠹ ⠸ ⠼ ⠴ ⠦ ⠧ ⠇ ⠏].freeze
+
+      def initialize(io: $stderr)
+        @io       = io
+        @counter  = 0
+        @frame    = 0
+        @thread   = nil
+        @mu       = Mutex.new
+      end
+
+      def tty?
+        return false if ENV['NO_COLOR']
+        @io.respond_to?(:isatty) && @io.isatty
+      end
+
+      def start
+        return unless tty?
+        @start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        @thread = Thread.new do
+          loop do
+            draw
+            sleep 0.1
+          end
+        end
+      end
+
+      def increment(count: 1)
+        @mu.synchronize { @counter += count }
+      end
+
+      # Stops the spinner thread and clears the line. Returns stats hash.
+      def stop(test_count:, elapsed:)
+        @thread&.kill
+        @thread&.join(0.2)
+        @thread = nil
+        @io.print("\r\e[K") if tty?
+        { test_count: test_count, elapsed: elapsed }
+      end
+
+      private
+
+      def draw
+        elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - @start
+        count   = @mu.synchronize { @counter }
+        frame   = FRAMES[@frame % FRAMES.size]
+        @frame += 1
+        mins    = (elapsed / 60).to_i
+        secs    = (elapsed % 60).to_i
+        time_s  = format('%02d:%02d', mins, secs)
+        line    = "#{Styles::PURPLE_TEXT.render(frame)}  Running suite…   " \
+                  "#{Styles::GREEN_TEXT.render(count.to_s)} tests   " \
+                  "#{Styles::META_TEXT.render(time_s)} elapsed"
+        @io.print("\r\e[K#{line}")
+        @io.flush
+      end
+    end
+  end
+end

data/lib/testprune/ui/report_renderer.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require 'testprune/ui/styles'
+
+module Testprune
+  module UI
+    # Styled replacement for Report#render_text. Renders the analysis result as a
+    # rich, color-coded terminal report using lipgloss. Degrades to plain text when
+    # NO_COLOR=1 is set or when output is not a TTY (lipgloss handles this automatically).
+    class ReportRenderer
+      GROUP_LABELS = {
+        identical:  'identical',
+        subset:     'subset',
+        structural: 'structural',
+        overlap:    'overlap'
+      }.freeze
+
+      def initialize(result)
+        @result = result
+      end
+
+      def render
+        parts = []
+        parts << header_section
+        parts << ''
+
+        if @result.candidates.empty?
+          parts << nothing_found_section
+        else
+          parts << confidence_section(:high,   'HIGH confidence — safe to remove',    Styles::HIGH_BADGE,   '●')
+          parts << confidence_section(:medium, 'MEDIUM confidence — review',           Styles::MEDIUM_BADGE, '●')
+          parts << confidence_section(:low,    'LOW confidence — review',              Styles::LOW_BADGE,    '●')
+          parts << savings_section unless @result.approved_removals.empty?
+          parts << ''
+          parts << cta_line
+        end
+
+        parts.compact.join("\n")
+      end
+
+      private
+
+      def tty?
+        return false if ENV['NO_COLOR']
+
+        $stdout.respond_to?(:isatty) && $stdout.isatty
+      end
+
+      def styled(text, style)
+        tty? ? style.render(text) : text
+      end
+
+      # ── Sections ─────────────────────────────────────────────────────────────
+
+      def header_section
+        framework  = @result.run['framework'] || 'unknown'
+        test_count = (@result.run['tests'] || []).size
+        baseline_info = @result.ambient_units.positive? ?
+          "  baseline: subtracted #{@result.ambient_units} shared-setup unit(s)" : ''
+
+        lines = [
+          "  testprune — coverage redundancy report",
+          "  #{test_count} tests · #{framework}#{baseline_info}"
+        ]
+
+        if tty?
+          Styles::REPORT_BOX.render(lines.join("\n"))
+        else
+          lines.join("\n") + "\n" + ('─' * 64)
+        end
+      end
+
+      def confidence_section(tier, title, badge_style, bullet)
+        candidates = @result.candidates.select { |c| c.confidence == tier }
+        return nil if candidates.empty?
+
+        lines = []
+        badge = styled("  #{bullet} ", badge_style)
+        title_text = styled(title, badge_style)
+        count_text = styled("  (#{candidates.size})", Styles::META_TEXT)
+        lines << "#{badge}#{title_text}#{count_text}"
+        lines << styled('  ' + '─' * 62, Styles::DIM_TEXT)
+        lines << ''
+        candidates.each do |c|
+          lines.concat(candidate_lines(c))
+          lines << ''
+        end
+        lines.join("\n")
+      end
+
+      def candidate_lines(candidate)
+        fp = candidate.footprint
+        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)}"
+        end
+
+        covers = fp.units.map { |id| @result.label_for(id) }.sort
+        covers_text = covers.size <= 4 ? covers.join(' · ') : "#{covers.first(4).join(' · ')} (+#{covers.size - 4} more)"
+        lines << "    #{styled('covers: ', Styles::DIM_TEXT)}#{styled(covers_text, Styles::DIM_TEXT)}"
+
+        safety = case candidate.safe
+                 when true  then styled('    ✓ safe — every covered unit is retained by another test', Styles::SAFE_LINE)
+                 when false then styled("    ✗ NOT safe — #{candidate.safety_note}", Styles::UNSAFE_LINE)
+                 else            styled('    · review-only — not auto-applied', Styles::DIM_TEXT)
+                 end
+        lines << safety
+        lines
+      end
+
+      def savings_section
+        s = @result.savings
+        lines = [
+          '  Estimated CI savings',
+          "  #{styled("#{s.approved_count} test(s)", Styles::GREEN_TEXT)}" \
+          "#{styled('  ·  ', Styles::META_TEXT)}" \
+          "#{styled(format('%.4fs saved', s.approved_time), Styles::GREEN_TEXT)}" \
+          "#{styled('  ·  ', Styles::META_TEXT)}" \
+          "#{styled(format('~%.1f%% of suite', s.percent_of_test_time), Styles::GREEN_TEXT)}",
+          styled('  Note: wall-clock savings lower on parallel CI runners', Styles::META_TEXT)
+        ]
+
+        if tty?
+          Styles::REPORT_BOX.render(lines.join("\n"))
+        else
+          lines.join("\n")
+        end
+      end
+
+      def nothing_found_section
+        msg = '  Nothing redundant found — suite looks clean.'
+        tty? ? Styles::SUCCESS_BOX.render(msg) : msg
+      end
+
+      def cta_line
+        "  #{styled('Run ', Styles::META_TEXT)}" \
+        "#{styled('testprune apply', Styles::PURPLE_TEXT)}" \
+        "#{styled(' to review and emit a removal patch.', Styles::META_TEXT)}"
+      end
+    end
+  end
+end

data/lib/testprune/ui/styles.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'lipgloss'
+
+module Testprune
+  module UI
+    # Centralized style palette. All UI components pull from here so the visual
+    # identity stays consistent and editable in one place.
+    #
+    # Colors degrade automatically when NO_COLOR=1 is set (lipgloss strips ANSI).
+    module Styles
+      # ── Color hex constants ──────────────────────────────────────────────────
+      PURPLE  = '#7D56F4'   # brand / borders / interactive
+      GREEN   = '#22C55E'   # HIGH confidence / success / safe
+      AMBER   = '#F59E0B'   # MEDIUM confidence / warnings
+      GRAY    = '#6B7280'   # LOW confidence
+      RED     = '#EF4444'   # errors / unsafe removals
+      EMERALD = '#10B981'   # scan complete / patch written
+      META    = '#9CA3AF'   # subdued meta-text (kept by, covers, timestamps)
+      DIM     = '#3D3D5C'   # decorators / separators
+      TEXT    = '#E2E8F0'   # default body text
+
+      # ── Pre-built reusable styles ────────────────────────────────────────────
+
+      # Rounded box with purple border — used for command headers.
+      HEADER_BOX = Lipgloss::Style.new
+                                  .border(:rounded)
+                                  .border_foreground(PURPLE)
+                                  .padding(0, 1)
+
+      # Rounded box with emerald border — used for success summaries.
+      SUCCESS_BOX = Lipgloss::Style.new
+                                   .border(:rounded)
+                                   .border_foreground(EMERALD)
+                                   .padding(0, 1)
+
+      # Rounded box with purple border — used for report sections and savings.
+      REPORT_BOX = Lipgloss::Style.new
+                                  .border(:rounded)
+                                  .border_foreground(PURPLE)
+                                  .padding(0, 1)
+
+      # Confidence badges
+      HIGH_BADGE   = Lipgloss::Style.new.foreground(GREEN).bold(true)
+      MEDIUM_BADGE = Lipgloss::Style.new.foreground(AMBER).bold(true)
+      LOW_BADGE    = Lipgloss::Style.new.foreground(GRAY)
+
+      # Inline text styles
+      SAFE_LINE    = Lipgloss::Style.new.foreground(GREEN)
+      UNSAFE_LINE  = Lipgloss::Style.new.foreground(RED).bold(true)
+      META_TEXT    = Lipgloss::Style.new.foreground(META)
+      DIM_TEXT     = Lipgloss::Style.new.foreground(DIM)
+      PURPLE_TEXT  = Lipgloss::Style.new.foreground(PURPLE)
+      GREEN_TEXT   = Lipgloss::Style.new.foreground(GREEN)
+      AMBER_TEXT   = Lipgloss::Style.new.foreground(AMBER)
+      ERROR_TEXT   = Lipgloss::Style.new.foreground(RED).bold(true)
+      EMERALD_TEXT = Lipgloss::Style.new.foreground(EMERALD)
+    end
+  end
+end

data/lib/testprune/ui.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'lipgloss'
+require_relative 'ui/styles'
+require_relative 'ui/progress'
+require_relative 'ui/error_toggle'
+require_relative 'ui/report_renderer'
+
+module Testprune
+  # Terminal UI components built on lipgloss-ruby.
+  # All components degrade gracefully when NO_COLOR=1 is set or output is not a TTY.
+  module UI
+    # Returns true when styled output is appropriate for the given IO.
+    # Respects NO_COLOR (https://no-color.org/) and non-TTY output streams.
+    def self.tty?(io = $stdout)
+      return false if ENV['NO_COLOR']
+
+      io.respond_to?(:isatty) && io.isatty
+    end
+  end
+end

data/lib/testprune/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: testprune
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Seth MacPherson
@@ -29,6 +29,20 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '3'
+- !ruby/object:Gem::Dependency
+  name: lipgloss
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.1'
 description: Combines Ruby's native Coverage execution counts with Prism AST analysis
   to map per-test coverage onto semantic units (methods, branches, conditions), find
   redundant tests grouped by duplication type with confidence levels, and emit a removal
@@ -63,6 +77,11 @@ files:
 - lib/testprune/savings_estimator.rb
 - lib/testprune/semantic_map.rb
 - lib/testprune/test_body.rb
+- lib/testprune/ui.rb
+- lib/testprune/ui/error_toggle.rb
+- lib/testprune/ui/progress.rb
+- lib/testprune/ui/report_renderer.rb
+- lib/testprune/ui/styles.rb
 - lib/testprune/version.rb
 homepage: https://github.com/seth-macpherson/testprune
 licenses: