herb 0.8.10-arm-linux-gnu → 0.9.0-arm-linux-gnu

data/lib/herb/project.rb

@@ -1,9 +1,7 @@
 # frozen_string_literal: true
 # typed: ignore
-
 # rbs_inline: disabled
 
-require "io/console"
 require "timeout"
 require "tempfile"
 require "pathname"
@@ -12,12 +10,111 @@ require "stringio"
 
 module Herb
   class Project
-    attr_accessor :project_path, :output_file, :no_interactive, :no_log_file, :no_timing, :silent
+    include Colors
+
+    attr_accessor :project_path, :output_file, :no_log_file, :no_timing, :silent, :verbose, :isolate, :validate_ruby, :file_paths, :arena_stats, :leak_check
+
+    # Known error types that indicate issues in the user's template, not bugs in the parser.
+    TEMPLATE_ERRORS = [
+      "MissingOpeningTagError",
+      "MissingClosingTagError",
+      "TagNamesMismatchError",
+      "VoidElementClosingTagError",
+      "UnclosedElementError",
+      "RubyParseError",
+      "ERBControlFlowScopeError",
+      "MissingERBEndTagError",
+      "ERBMultipleBlocksInTagError",
+      "ERBCaseWithConditionsError",
+      "ConditionalElementMultipleTagsError",
+      "ConditionalElementConditionMismatchError",
+      "InvalidCommentClosingTagError",
+      "OmittedClosingTagError",
+      "UnclosedOpenTagError",
+      "UnclosedCloseTagError",
+      "UnclosedQuoteError",
+      "MissingAttributeValueError",
+      "UnclosedERBTagError",
+      "StrayERBClosingTagError",
+      "NestedERBTagError"
+    ].freeze
+
+    ISSUE_TYPES = [
+      { key: :failed, label: "Parser crashed", symbol: "✗", color: :red, reportable: true,
+        hint: "This could be a bug in the parser. Reporting it helps us improve Herb for everyone.",
+        file_hint: ->(relative) { "Run `herb parse #{relative}` to see the parser output." } },
+      { key: :template_error, label: "Template errors", symbol: "✗", color: :red,
+        hint: "These files have issues in the template. Review the errors and update your templates to fix them." },
+      { key: :unexpected_error, label: "Unexpected parse errors", symbol: "✗", color: :red, reportable: true,
+        hint: "These errors may indicate a bug in the parser. Reporting them helps us make Herb more robust.",
+        file_hint: ->(relative) { "Run `herb parse #{relative}` to see the parser output." } },
+      { key: :strict_parse_error, label: "Strict mode parse errors", symbol: "⚠", color: :yellow,
+        hint: "These files use HTML patterns like omitted closing tags. Add explicit closing tags to fix." },
+      { key: :analyze_parse_error, label: "Analyze parse errors", symbol: "⚠", color: :yellow,
+        hint: "These files have issues detected during analysis. Review the errors and update your templates." },
+      { key: :timeout, label: "Timed out", symbol: "⚠", color: :yellow, reportable: true,
+        hint: "These files took too long to parse. This could indicate a parser issue. Reporting it helps us track down edge cases." },
+      { key: :validation_error, label: "Validation errors", symbol: "⚠", color: :yellow,
+        hint: "These templates have security, nesting, or accessibility issues. The templates compile fine otherwise. Review and fix these to improve your template structure." },
+      { key: :compilation_failed, label: "Compilation errors", symbol: "✗", color: :red, reportable: true,
+        hint: "These files could not be compiled to Ruby. This could be a bug in the engine. Reporting it helps us improve Herb's compatibility.",
+        file_hint: ->(relative) { "Run `herb compile #{relative}` to see the compilation error." } },
+      { key: :strict_compilation_failed, label: "Strict mode compilation errors", symbol: "⚠", color: :yellow,
+        hint: "These files fail to compile only in strict mode. Add explicit closing tags to fix, or pass --no-strict to allow.",
+        file_hint: ->(relative) { "Run `herb compile #{relative}` to see the compilation error." } },
+      { key: :invalid_ruby, label: "Invalid Ruby output", symbol: "✗", color: :red, reportable: true,
+        hint: "The engine produced Ruby code that doesn't parse. This is most likely a bug in the engine. Reporting it helps us fix it.",
+        file_hint: ->(relative) { "Run `herb compile #{relative}` to see the compiled output." } }
+    ].freeze
+
+    class ResultTracker
+      attr_reader :successful, :failed, :timeout, :template_error, :unexpected_error,
+                  :strict_parse_error, :analyze_parse_error,
+                  :validation_error, :compilation_failed, :strict_compilation_failed,
+                  :invalid_ruby,
+                  :error_outputs, :file_contents, :parse_errors, :compilation_errors,
+                  :file_diagnostics
+
+      def initialize
+        @successful = []
+        @failed = []
+        @timeout = []
+        @template_error = []
+        @unexpected_error = []
+        @strict_parse_error = []
+        @analyze_parse_error = []
+        @validation_error = []
+        @compilation_failed = []
+        @strict_compilation_failed = []
+        @invalid_ruby = []
+        @error_outputs = {}
+        @file_contents = {}
+        @parse_errors = {}
+        @compilation_errors = {}
+        @file_diagnostics = {}
+      end
+
+      def problem_files
+        failed + timeout + template_error + unexpected_error + strict_parse_error + analyze_parse_error +
+          validation_error + compilation_failed + strict_compilation_failed + invalid_ruby
+      end
 
-    def interactive?
-      return false if no_interactive
+      def file_issue_type(file)
+        ISSUE_TYPES.find { |type| send(type[:key]).include?(file) }
+      end
+
+      def diagnostic_counts
+        counts = Hash.new { |hash, key| hash[key] = { count: 0, files: Set.new } }
+
+        file_diagnostics.each do |file, diagnostics|
+          diagnostics.each do |diagnostic|
+            counts[diagnostic[:name]][:count] += 1
+            counts[diagnostic[:name]][:files] << file
+          end
+        end
 
-      !IO.console.nil?
+        counts.sort_by { |_name, value| -value[:count] }
+      end
     end
 
     def initialize(project_path, output_file: nil)
@@ -29,12 +126,16 @@ module Herb
       @output_file = output_file || "#{date}_erb_parsing_result_#{@project_path.basename}.log"
     end
 
-    def glob
-      "**/*.{html,rhtml,html.erb,html+*.erb,turbo_stream.erb}"
+    def configuration
+      @configuration ||= Configuration.load(@project_path.to_s)
+    end
+
+    def include_patterns
+      configuration.file_include_patterns
     end
 
-    def full_path_glob
-      project_path + glob
+    def exclude_patterns
+      configuration.file_exclude_patterns
     end
 
     def absolute_path
@@ -42,10 +143,27 @@ module Herb
     end
 
     def files
-      @files ||= Dir[full_path_glob]
+      @files ||= file_paths || find_files
     end
 
-    def parse!
+    private
+
+    def find_files
+      included = include_patterns.flat_map do |pattern|
+        Dir[File.join(@project_path, pattern)]
+      end.uniq
+
+      return included if exclude_patterns.empty?
+
+      included.reject do |file|
+        relative_path = file.sub("#{@project_path}/", "")
+        exclude_patterns.any? { |pattern| File.fnmatch?(pattern, relative_path, File::FNM_PATHNAME) }
+      end
+    end
+
+    public
+
+    def analyze!
       start_time = Time.now unless no_timing
 
       log = if no_log_file
@@ -61,399 +179,681 @@ module Herb
 
         log.puts heading("PROJECT")
         log.puts "Path: #{absolute_path}"
-        log.puts "Glob: #{"#{absolute_path}#{glob}"}\n\n"
+        log.puts "Config: #{configuration.config_path || "(defaults)"}"
+        log.puts "Include: #{include_patterns.join(", ")}"
+        log.puts "Exclude: #{exclude_patterns.join(", ")}\n\n"
 
         log.puts heading("PROCESSED FILES")
 
         if files.empty?
-          message = "No .html.erb files found using #{full_path_glob}"
+          message = "No files found matching patterns: #{include_patterns.join(", ")}"
           log.puts message
           puts message
           return
         end
 
-        print "\e[H\e[2J" if interactive?
-
-        successful_files = []
-        failed_files = []
-        timeout_files = []
-        error_files = []
-        compilation_failed_files = []
-        error_outputs = {}
-        file_contents = {}
-        parse_errors = {}
-        compilation_errors = {}
-
-        files.each_with_index do |file_path, index|
-          total_failed = failed_files.count
-          total_timeout = timeout_files.count
-          total_errors = error_files.count
-          total_compilation_failed = compilation_failed_files.count
-
-          lines_to_clear = 6 + total_failed + total_timeout + total_errors + total_compilation_failed
-          lines_to_clear += 3 if total_failed.positive?
-          lines_to_clear += 3 if total_timeout.positive?
-          lines_to_clear += 3 if total_errors.positive?
-          lines_to_clear += 3 if total_compilation_failed.positive?
-
-          lines_to_clear.times { print "\e[1A\e[K" } if index.positive? && interactive?
-
-          if interactive?
-            puts "Parsing .html.erb files in: #{project_path}"
-            puts "Total files to process: #{files.count}\n"
-
-            relative_path = file_path.sub("#{project_path}/", "")
-
-            puts
-            puts progress_bar(index + 1, files.count)
-            puts
+        @results = ResultTracker.new
+        results = @results
+
+        unless silent
+          puts ""
+          puts "#{bold("Herb")} 🌿 #{dimmed("v#{Herb::VERSION}")}"
+          puts ""
+
+          if configuration.config_path
+            puts "#{green("✓")} Using Herb config file at #{dimmed(configuration.config_path)}"
           else
-            relative_path = file_path.sub("#{project_path}/", "")
+            puts dimmed("No .herb.yml found, using defaults")
           end
-          puts "Processing [#{index + 1}/#{files.count}]: #{relative_path}" unless silent
-
-          if interactive?
-            if failed_files.any?
-              puts
-              puts "Files that failed:"
-              failed_files.each { |file| puts "  - #{file}" }
-              puts
-            end
 
-            if timeout_files.any?
-              puts
-              puts "Files that timed out:"
-              timeout_files.each { |file| puts "  - #{file}" }
-              puts
-            end
+          puts dimmed("Analyzing #{files.count} #{pluralize(files.count, "file")}...")
+        end
 
-            if error_files.any?
-              puts
-              puts "Files with parse errors:"
-              error_files.each { |file| puts "  - #{file}" }
-              puts
-            end
+        total_width = files.count.to_s.length
 
-            if compilation_failed_files.any?
-              puts
-              puts "Files with compilation errors:"
-              compilation_failed_files.each { |file| puts "  - #{file}" }
-              puts
-            end
+        finish_hook = lambda do |item, index, _file_result|
+          next if silent
+
+          if verbose
+            relative_path = relative_path(item)
+            puts "  #{dimmed("[#{(index + 1).to_s.rjust(total_width)}/#{files.count}]")} #{relative_path}"
+          else
+            print "."
           end
+        end
 
-          begin
-            file_content = File.read(file_path)
+        ensure_parallel!
 
-            stdout_file = Tempfile.new("stdout")
-            stderr_file = Tempfile.new("stderr")
-            ast_file = Tempfile.new("ast")
+        file_results = Parallel.map(files, in_processes: Parallel.processor_count, finish: finish_hook) do |file_path|
+          process_file(file_path)
+        end
 
-            Timeout.timeout(1) do
-              pid = Process.fork do
-                $stdout.reopen(stdout_file.path, "w")
-                $stderr.reopen(stderr_file.path, "w")
+        unless silent
+          puts "" unless verbose
+          puts ""
+          puts separator
+        end
 
-                begin
-                  result = Herb.parse(file_content)
+        file_results.each do |result|
+          merge_file_result(result, results, log)
+        end
 
-                  if result.failed?
-                    File.open(ast_file.path, "w") do |f|
-                      f.puts result.value.inspect
-                    end
+        log.puts ""
 
-                    exit!(2)
-                  end
+        duration = no_timing ? nil : Time.now - start_time
 
-                  exit!(0)
-                rescue StandardError => e
-                  warn "Ruby exception: #{e.class}: #{e.message}"
-                  warn e.backtrace.join("\n") if e.backtrace
-                  exit!(1)
-                end
-              end
+        print_file_lists(results, log)
 
-              Process.waitpid(pid)
-
-              stdout_file.rewind
-              stderr_file.rewind
-              stdout_content = stdout_file.read
-              stderr_content = stderr_file.read
-              ast = File.exist?(ast_file.path) ? File.read(ast_file.path) : ""
-
-              case $CHILD_STATUS.exitstatus
-              when 0
-                log.puts "✅ Parsed #{file_path} successfully"
-
-                begin
-                  Herb::Engine.new(file_content, filename: file_path, escape: true)
-
-                  log.puts "✅ Compiled #{file_path} successfully"
-                  successful_files << file_path
-                rescue Herb::Engine::CompilationError => e
-                  log.puts "❌ Compilation failed for #{file_path}"
-
-                  compilation_failed_files << file_path
-                  compilation_errors[file_path] = {
-                    error: e.message,
-                    backtrace: e.backtrace&.first(10) || [],
-                  }
-
-                  file_contents[file_path] = file_content
-                rescue StandardError => e
-                  log.puts "❌ Unexpected compilation error for #{file_path}: #{e.class}: #{e.message}"
-
-                  compilation_failed_files << file_path
-                  compilation_errors[file_path] = {
-                    error: "#{e.class}: #{e.message}",
-                    backtrace: e.backtrace&.first(10) || [],
-                  }
-
-                  file_contents[file_path] = file_content
-                end
-              when 2
-                message = "⚠️ Parsing #{file_path} completed with errors"
-                log.puts message
-
-                parse_errors[file_path] = {
-                  ast: ast,
-                  stdout: stdout_content,
-                  stderr: stderr_content,
-                }
-
-                file_contents[file_path] = file_content
-
-                error_files << file_path
-              else
-                message = "❌ Parsing #{file_path} failed"
-                log.puts message
-
-                error_outputs[file_path] = {
-                  exit_code: $CHILD_STATUS.exitstatus,
-                  stdout: stdout_content,
-                  stderr: stderr_content,
-                }
-
-                file_contents[file_path] = file_content
-
-                failed_files << file_path
-              end
-            end
+        if results.problem_files.any?
+          puts "\n #{separator}"
+          print_issue_summary(results)
 
-            stdout_file.close
-            stdout_file.unlink
-            stderr_file.close
-            stderr_file.unlink
-            ast_file.close
-            ast_file.unlink
-          rescue Timeout::Error
-            message = "⏱️ Parsing #{file_path} timed out after 1 second"
-            log.puts message
-
-            begin
-              Process.kill("TERM", pid)
-            rescue StandardError
-              nil
-            end
+          if reportable_files?(results)
+            puts "\n #{separator}"
+            print_reportable_files(results)
+          end
+        end
 
-            timeout_files << file_path
-            file_contents[file_path] = file_content
-          rescue StandardError => e
-            message = "⚠️ Error processing #{file_path}: #{e.message}"
-            log.puts message
+        log_problem_file_details(results, log)
 
-            failed_files << file_path
+        if arena_stats
+          print_arena_summary(file_results)
+        end
 
-            begin
-              file_contents[file_path] = File.read(file_path)
-            rescue StandardError => read_error
-              log.puts "    Could not read file content: #{read_error.message}"
-            end
-          end
+        if leak_check
+          print_leak_check_summary(file_results)
         end
 
-        if interactive?
-          print "\e[1A\e[K"
-          puts "Completed processing all files."
-          print "\e[H\e[2J"
-        else
-          puts "Completed processing all files." unless silent
+        unless no_log_file
+          puts "\n #{separator}"
+          puts "\n #{dimmed("Results saved to #{output_file}")}"
         end
 
-        log.puts ""
+        puts "\n #{separator}"
+        print_summary(results, log, duration)
 
-        summary = [
-          heading("Summary"),
-          "Total files: #{files.count}",
-          "✅ Successful (parsed & compiled): #{successful_files.count} (#{percentage(successful_files.count,
-                                                                                      files.count)}%)",
-          "❌ Compilation errors: #{compilation_failed_files.count} (#{percentage(compilation_failed_files.count,
-                                                                                  files.count)}%)",
-          "❌ Failed to parse: #{failed_files.count} (#{percentage(failed_files.count, files.count)}%)",
-          "⚠️ Parse errors: #{error_files.count} (#{percentage(error_files.count, files.count)}%)",
-          "⏱️ Timed out: #{timeout_files.count} (#{percentage(timeout_files.count, files.count)}%)"
-        ]
-
-        summary.each do |line|
-          log.puts line
-          puts line
-        end
+        results.problem_files.any?
+      ensure
+        log.close unless no_log_file
+      end
+    end
 
-        if failed_files.any?
-          log.puts "\n#{heading("Files that failed")}"
-          puts "\nFiles that failed:"
+    def print_file_report(file_path)
+      file_path = File.expand_path(file_path)
+      results = @results
 
-          failed_files.each do |f|
-            log.puts "- #{f}"
-            puts "  - #{f}"
+      unless results
+        puts "No results available. Run parse! first."
+        return
+      end
+
+      relative = relative_path(file_path)
+      issue_type = results.file_issue_type(file_path)
+
+      unless issue_type
+        puts "No issues found for #{relative}."
+        return
+      end
+
+      diagnostics = results.file_diagnostics[file_path]
+      file_content = results.file_contents[file_path]
+
+      puts "- **Herb:** `#{Herb.version}`"
+      puts "- **Ruby:** `#{RUBY_VERSION}`"
+      puts "- **Platform:** `#{RUBY_PLATFORM}`"
+      puts "- **Category:** `#{issue_type[:label]}`"
+
+      if diagnostics&.any?
+        puts ""
+        puts "**Errors:**"
+        diagnostics.each do |diagnostic|
+          lines = diagnostic[:message].split("\n")
+          puts "- **#{diagnostic[:name]}** #{lines.first}"
+          lines.drop(1).each do |line|
+            puts "  #{line}"
           end
         end
+      end
 
-        if error_files.any?
-          log.puts "\n#{heading("Files with parse errors")}"
-          puts "\nFiles with parse errors:"
+      if file_content
+        puts ""
+        puts "**Template:**"
+        puts "```erb"
+        puts file_content
+        puts "```"
+      end
 
-          error_files.each do |f|
-            log.puts f
-            puts "  - #{f}"
-          end
+      return unless issue_type[:key] == :invalid_ruby && file_content
+
+      begin
+        engine = Herb::Engine.new(file_content, filename: file_path, escape: true, validation_mode: :none)
+        puts ""
+        puts "**Compiled Ruby:**"
+        puts "```ruby"
+        puts engine.src
+        puts "```"
+      rescue StandardError
+        # Skip if compilation fails entirely
+      end
+    end
+
+    private
+
+    def process_file(file_path)
+      isolate ? process_file_isolated(file_path) : process_file_direct(file_path)
+    end
+
+    def process_file_direct(file_path)
+      file_content = File.read(file_path)
+      result = { file_path: file_path }
+
+      if arena_stats
+        result[:arena_stats] = capture_arena_stats(file_content)
+      end
+
+      if leak_check
+        result[:leak_check] = capture_leak_check(file_content)
+      end
+
+      Timeout.timeout(1) do
+        parse_result = Herb.parse(file_content)
+
+        if parse_result.failed?
+          result[:file_content] = file_content
+          result.merge!(classify_parse_errors(file_path, file_content))
+        else
+          result[:log] = "✅ Parsed #{file_path} successfully"
+          result.merge!(compile_file(file_path, file_content))
         end
+      end
+
+      result
+    rescue Timeout::Error
+      result.merge(status: :timeout, file_content: file_content,
+                   log: "⏱️ Parsing #{file_path} timed out after 1 second")
+    rescue StandardError => e
+      file_content ||= begin
+        File.read(file_path)
+      rescue StandardError
+        nil
+      end
+
+      result.merge(status: :failed, file_content: file_content,
+                   log: "⚠️ Error processing #{file_path}: #{e.message}")
+    end
+
+    def process_file_isolated(file_path)
+      file_content = File.read(file_path)
+      result = { file_path: file_path }
 
-        if timeout_files.any?
-          log.puts "\n#{heading("Files that timed out")}"
-          puts "\nFiles that timed out:"
+      stdout_file = Tempfile.new("stdout")
+      stderr_file = Tempfile.new("stderr")
 
-          timeout_files.each do |f|
-            log.puts f
-            puts "  - #{f}"
+      Timeout.timeout(1) do
+        pid = Process.fork do
+          $stdout.reopen(stdout_file.path, "w")
+          $stderr.reopen(stderr_file.path, "w")
+
+          begin
+            parse_result = Herb.parse(file_content)
+            exit!(parse_result.failed? ? 2 : 0)
+          rescue StandardError => e
+            warn "Ruby exception: #{e.class}: #{e.message}"
+            warn e.backtrace.join("\n") if e.backtrace
+            exit!(1)
           end
         end
 
-        if compilation_failed_files.any?
-          log.puts "\n#{heading("Files with compilation errors")}"
-          puts "\nFiles with compilation errors:"
+        Process.waitpid(pid)
 
-          compilation_failed_files.each do |f|
-            log.puts f
-            puts "  - #{f}"
-          end
+        stderr_file.rewind
+        stderr_content = stderr_file.read
+
+        case $CHILD_STATUS.exitstatus
+        when 0
+          result[:log] = "✅ Parsed #{file_path} successfully"
+          result.merge!(compile_file(file_path, file_content))
+        when 2
+          result[:file_content] = file_content
+          result.merge!(classify_parse_errors(file_path, file_content))
+        else
+          result[:log] = "❌ Parsing #{file_path} failed"
+          result[:status] = :failed
+          result[:file_content] = file_content
+          result[:error_output] = { exit_code: $CHILD_STATUS.exitstatus, stderr: stderr_content }
         end
+      end
 
-        problem_files = failed_files + timeout_files + error_files + compilation_failed_files
+      result
+    rescue Timeout::Error
+      begin
+        Process.kill("TERM", pid)
+      rescue StandardError
+        nil
+      end
 
-        if problem_files.any?
-          log.puts "\n#{heading("FILE CONTENTS AND DETAILS")}"
+      { file_path: file_path, status: :timeout, file_content: file_content,
+        log: "⏱️ Parsing #{file_path} timed out after 1 second" }
+    rescue StandardError => e
+      file_content ||= begin
+        File.read(file_path)
+      rescue StandardError
+        nil
+      end
 
-          problem_files.each do |file|
-            next unless file_contents[file]
+      { file_path: file_path, status: :failed, file_content: file_content,
+        log: "⚠️ Error processing #{file_path}: #{e.message}" }
+    ensure
+      [stdout_file, stderr_file].each do |tempfile|
+        next unless tempfile
 
-            divider = "=" * [80, file.length].max
+        tempfile.close
+        tempfile.unlink
+      end
+    end
 
-            log.puts
-            log.puts divider
-            log.puts file
-            log.puts divider
+    def classify_parse_errors(file_path, file_content)
+      default_result = Herb.parse(file_content)
+
+      diagnostics = if default_result.respond_to?(:errors) && default_result.errors.any?
+                      default_result.errors.map do |error|
+                        diagnostic = { name: error.error_name, message: error.message }
+                        if error.respond_to?(:location) && error.location
+                          diagnostic[:line] = error.location.start.line
+                          diagnostic[:column] = error.location.start.column
+                        end
+                        diagnostic
+                      end
+                    end
 
-            log.puts "\n#{heading("CONTENT")}"
-            log.puts "```erb"
-            log.puts file_contents[file]
-            log.puts "```"
+      no_strict_result = Herb.parse(file_content, strict: false)
+      no_analyze_result = Herb.parse(file_content, analyze: false)
+
+      if no_strict_result.success?
+        { status: :strict_parse_error, diagnostics: diagnostics,
+          log: "⚠️ Parsing #{file_path} completed with strict mode errors" }
+      elsif no_analyze_result.success?
+        { status: :analyze_parse_error, diagnostics: diagnostics,
+          log: "⚠️ Parsing #{file_path} completed with analyze errors" }
+      elsif diagnostics&.any? && diagnostics.all? { |diagnostic| TEMPLATE_ERRORS.include?(diagnostic[:name]) }
+        { status: :template_error, diagnostics: diagnostics,
+          log: "⚠️ Parsing #{file_path} completed with template errors" }
+      else
+        { status: :unexpected_error, diagnostics: diagnostics,
+          log: "❌ Parsing #{file_path} completed with unexpected errors" }
+      end
+    end
 
-            if error_outputs[file]
-              if error_outputs[file][:exit_code]
-                log.puts "\n#{heading("EXIT CODE")}"
-                log.puts error_outputs[file][:exit_code]
-              end
+    def compile_file(file_path, file_content)
+      Herb::Engine.new(file_content, filename: file_path, escape: true, validate_ruby: validate_ruby)
 
-              if error_outputs[file][:stderr].strip.length.positive?
-                log.puts "\n#{heading("ERROR OUTPUT")}"
-                log.puts "```"
-                log.puts error_outputs[file][:stderr]
-                log.puts "```"
-              end
+      { status: :successful, log: "✅ Compiled #{file_path} successfully" }
+    rescue Herb::Engine::InvalidRubyError => e
+      { status: :invalid_ruby, file_content: file_content,
+        compilation_error: { error: e.message, backtrace: e.backtrace&.first(10) || [] },
+        diagnostics: [{ name: "InvalidRubyError", message: e.message }],
+        log: "🚨 Compiled Ruby is invalid for #{file_path}" }
+    rescue Herb::Engine::SecurityError, Herb::Engine::CompilationError => e
+      compilation_error = { error: e.message, backtrace: e.backtrace&.first(10) || [] }
 
-              if error_outputs[file][:stdout].strip.length.positive?
-                log.puts "\n#{heading("STANDARD OUTPUT")}"
-                log.puts "```"
-                log.puts error_outputs[file][:stdout]
-                log.puts "```"
-                log.puts
-              end
-            end
+      # Retry without validators
+      begin
+        Herb::Engine.new(file_content, filename: file_path, escape: true, validation_mode: :none, validate_ruby: validate_ruby)
+        error_name = e.is_a?(Herb::Engine::SecurityError) ? "SecurityError" : "ValidationError"
+        return { status: :validation_error, file_content: file_content,
+                 compilation_error: compilation_error,
+                 diagnostics: [{ name: error_name, message: e.message }],
+                 log: "⚠️ Compilation failed for #{file_path} (validation error)" }
+      rescue StandardError
+        # Not a validator-caused error, continue with other checks
+      end
 
-            if parse_errors[file]
-              if parse_errors[file][:stdout].strip.length.positive?
-                log.puts "\n#{heading("STANDARD OUTPUT")}"
-                log.puts "```"
-                log.puts parse_errors[file][:stdout]
-                log.puts "```"
-              end
+      # Retry without strict mode
+      begin
+        Herb::Engine.new(file_content, filename: file_path, escape: true, strict: false, validate_ruby: validate_ruby)
+        return { status: :strict_compilation_failed, file_content: file_content,
+                 compilation_error: compilation_error,
+                 diagnostics: [{ name: "CompilationError", message: "#{e.message} (strict mode)" }],
+                 log: "🔒 Compilation failed for #{file_path} (strict mode error)" }
+      rescue StandardError
+        # Fall through
+      end
 
-              if parse_errors[file][:stderr].strip.length.positive?
-                log.puts "\n#{heading("ERROR OUTPUT")}"
-                log.puts "```"
-                log.puts parse_errors[file][:stderr]
-                log.puts "```"
-              end
+      { status: :compilation_failed, file_content: file_content,
+        compilation_error: compilation_error,
+        diagnostics: [{ name: "CompilationError", message: e.message }],
+        log: "❌ Compilation failed for #{file_path}" }
+    rescue StandardError => e
+      { status: :compilation_failed, file_content: file_content,
+        compilation_error: { error: "#{e.class}: #{e.message}", backtrace: e.backtrace&.first(10) || [] },
+        diagnostics: [{ name: e.class.to_s, message: e.message }],
+        log: "❌ Unexpected compilation error for #{file_path}: #{e.class}: #{e.message}" }
+    end
 
-              if parse_errors[file][:ast]
-                log.puts "\n#{heading("AST")}"
-                log.puts "```"
-                log.puts parse_errors[file][:ast]
-                log.puts "```"
-                log.puts
-              end
-            end
+    def merge_file_result(result, tracker, log)
+      file_path = result[:file_path]
+      status = result[:status]
+
+      log.puts result[:log] if result[:log]
+
+      return unless status
+
+      tracker.send(status) << file_path
+
+      tracker.file_contents[file_path] = result[:file_content] if result[:file_content]
+      tracker.error_outputs[file_path] = result[:error_output] if result[:error_output]
+      tracker.parse_errors[file_path] = result[:parse_error] if result[:parse_error]
+      tracker.compilation_errors[file_path] = result[:compilation_error] if result[:compilation_error]
+      tracker.file_diagnostics[file_path] = result[:diagnostics] if result[:diagnostics]&.any?
+    end
+
+    def print_summary(results, log, duration)
+      total = files.count
+      issues = results.problem_files.count
+      passed = results.successful.count
+
+      log_summary(results, log, total, duration)
+
+      parsed = total - results.failed.count - results.timeout.count
+
+      puts "\n"
+      puts " #{bold("Summary:")}"
+
+      puts "  #{label("Version")} #{cyan(Herb.version)}"
+      puts "  #{label("Checked")} #{cyan("#{total} #{pluralize(total, "file")}")}"
 
-            next unless compilation_errors[file]
+      if total > 1
+        files_line = if issues.positive?
+                       "#{bold(green("#{passed} clean"))} | #{bold(red("#{issues} with issues"))}"
+                     else
+                       bold(green("#{total} clean"))
+                     end
 
-            log.puts "\n#{heading("COMPILATION ERROR")}"
-            log.puts "```"
-            log.puts compilation_errors[file][:error]
-            log.puts "```"
+        puts "  #{label("Files")} #{files_line}"
+      end
+
+      parser_parts = []
+      parser_parts << stat(parsed, "parsed", :green)
+      parser_parts << stat(results.failed.count, "crashed", :red) if results.failed.any?
+      parser_parts << stat(results.template_error.count, pluralize(results.template_error.count, "template error"), :red) if results.template_error.any?
+      parser_parts << stat(results.unexpected_error.count, "unexpected", :red) if results.unexpected_error.any?
+      parser_parts << stat(results.strict_parse_error.count, "strict", :yellow) if results.strict_parse_error.any?
+      parser_parts << stat(results.analyze_parse_error.count, "analyze", :yellow) if results.analyze_parse_error.any?
+      puts "  #{label("Parser")} #{parser_parts.join(" | ")}"
+
+      skipped = total - passed - results.validation_error.count - results.compilation_failed.count -
+                results.strict_compilation_failed.count - results.invalid_ruby.count
+
+      engine_parts = []
+      engine_parts << stat(passed, "compiled", :green)
+      engine_parts << stat(results.validation_error.count, "validation", :yellow) if results.validation_error.any?
+      engine_parts << stat(results.compilation_failed.count, "compilation", :red) if results.compilation_failed.any?
+      engine_parts << stat(results.strict_compilation_failed.count, "strict", :yellow) if results.strict_compilation_failed.any?
+      engine_parts << stat(results.invalid_ruby.count, "produced invalid Ruby", :red) if results.invalid_ruby.any?
+      engine_parts << dimmed("#{skipped} skipped") if skipped.positive?
+      puts "  #{label("Engine")} #{engine_parts.join(" | ")}"
+
+      if results.timeout.any?
+        puts "  #{label("Timeout")} #{stat(results.timeout.count, "timed out", :yellow)}"
+      end
+
+      if duration
+        puts "  #{label("Duration")} #{cyan(format_duration(duration))}"
+      end
+
+      return unless issues.zero? && total > 1
+
+      puts ""
+      puts " #{bold(green("✓"))} #{green("All files are clean!")}"
+    end
+
+    def log_summary(results, log, total, duration)
+      log.puts heading("Summary")
+      log.puts "Herb Version: #{Herb.version}"
+      log.puts "Total files: #{total}"
+      log.puts "Parser options: strict: true, analyze: true"
+      log.puts ""
+      log.puts "✅ Successful (parsed & compiled): #{results.successful.count} (#{percentage(results.successful.count, total)}%)"
+      log.puts ""
+      log.puts "--- Parser ---"
+      log.puts "❌ Parser crashed: #{results.failed.count} (#{percentage(results.failed.count, total)}%)"
+      log.puts "⚠️ Template errors: #{results.template_error.count} (#{percentage(results.template_error.count, total)}%)"
+      log.puts "❌ Unexpected parse errors: #{results.unexpected_error.count} (#{percentage(results.unexpected_error.count, total)}%)"
+      log.puts "🔒 Strict mode parse errors (ok with strict: false): #{results.strict_parse_error.count} (#{percentage(results.strict_parse_error.count, total)}%)"
+      log.puts "🔍 Analyze parse errors (ok with analyze: false): #{results.analyze_parse_error.count} (#{percentage(results.analyze_parse_error.count, total)}%)"
+      log.puts ""
+      log.puts "--- Engine ---"
+      log.puts "⚠️ Validation errors (ok without validators): #{results.validation_error.count} (#{percentage(results.validation_error.count, total)}%)"
+      log.puts "❌ Compilation errors: #{results.compilation_failed.count} (#{percentage(results.compilation_failed.count, total)}%)"
+      log.puts "🔒 Strict mode compilation errors (ok with strict: false): #{results.strict_compilation_failed.count} (#{percentage(results.strict_compilation_failed.count, total)}%)"
+      log.puts "🚨 Invalid Ruby output: #{results.invalid_ruby.count} (#{percentage(results.invalid_ruby.count, total)}%)"
+      log.puts ""
+      log.puts "--- Other ---"
+      log.puts "⏱️ Timed out: #{results.timeout.count} (#{percentage(results.timeout.count, total)}%)"
+
+      return unless duration
+
+      log.puts "\n⏱️ Total time: #{format_duration(duration)}"
+    end
+
+    def print_file_lists(results, log)
+      log_file_lists(results, log)
+
+      return unless results.problem_files.any?
+
+      printed_section = false
+
+      ISSUE_TYPES.each do |type|
+        file_list = results.send(type[:key])
+        next unless file_list.any?
+
+        puts "\n #{separator}" if printed_section
+        printed_section = true
+
+        puts "\n"
+        puts " #{bold("#{type[:label]}:")}"
+        puts " #{dimmed(type[:hint])}" if type[:hint]
 
-            if compilation_errors[file][:backtrace].any?
-              log.puts "\n#{heading("BACKTRACE")}"
-              log.puts "```"
-              log.puts compilation_errors[file][:backtrace].join("\n")
-              log.puts "```"
+        file_list.each do |file|
+          relative = relative_path(file)
+          diagnostics = results.file_diagnostics[file]
+
+          puts ""
+          puts " #{cyan(relative)}:"
+
+          if diagnostics&.any?
+            diagnostics.each do |diagnostic|
+              severity = send(type[:color], type[:symbol])
+              location = diagnostic[:line] ? dimmed("at #{diagnostic[:line]}:#{diagnostic[:column]}") : nil
+              lines = diagnostic[:message].split("\n")
+              puts "   #{severity} #{bold(diagnostic[:name])} #{location}#{" #{dimmed("-")} " if location}#{dimmed(lines.first)}"
+              lines.drop(1).each do |line|
+                puts "     #{dimmed(line)}"
+              end
             end
-            log.puts
+          else
+            severity = send(type[:color], type[:symbol])
+            puts "   #{severity} #{type[:label]}"
           end
-        end
 
-        unless no_timing
-          end_time = Time.now
-          duration = end_time - start_time
-          timing_message = "\n⏱️ Total time: #{format_duration(duration)}"
-          log.puts timing_message
-          puts timing_message
+          puts "\n   #{dimmed(type[:file_hint].call(relative))}" if type[:file_hint]
         end
+      end
+    end
 
-        puts "\nResults saved to #{output_file}" unless no_log_file
+    def log_file_lists(results, log)
+      ISSUE_TYPES.each do |type|
+        file_list = results.send(type[:key])
+        next unless file_list.any?
 
-        problem_files.any?
-      ensure
-        log.close unless no_log_file
+        log.puts "\n#{heading("Files: #{type[:label]}")}"
+        file_list.each { |file| log.puts file }
       end
     end
 
-    private
+    def print_issue_summary(results)
+      counts = results.diagnostic_counts
+      return if counts.empty?
+
+      puts "\n"
+      puts " #{bold("Issue summary:")}"
+
+      counts.each do |name, data|
+        count_text = dimmed("(#{data[:count]} #{pluralize(data[:count], "error")} in #{data[:files].size} #{pluralize(data[:files].size, "file")})")
+        puts "  #{white(name)} #{count_text}"
+      end
+    end
+
+    def reportable_files?(results)
+      ISSUE_TYPES.any? { |type| type[:reportable] && results.send(type[:key]).any? }
+    end
+
+    def print_reportable_files(results)
+      reportable_types = ISSUE_TYPES.select { |type| type[:reportable] }
+      reportable_files = reportable_types.flat_map { |type|
+        results.send(type[:key]).map { |file| [file, type] }
+      }
+      return if reportable_files.empty?
+
+      reportable_breakdown = reportable_types.filter_map { |type|
+        count = results.send(type[:key]).count
+        "#{count} #{type[:label].downcase}" if count.positive?
+      }
+
+      puts "\n"
+      puts " #{bold("Reportable issues:")}"
+      puts "  #{dimmed("The following files likely failed due to issues in Herb, not in your templates.")}"
+      puts "  #{dimmed("Reporting them helps improve Herb and makes it better for everyone.")}"
+      puts "  #{dimmed("See the detailed output above for more information on why each file failed.")}"
+      puts ""
+      puts "  #{dimmed("#{reportable_files.count} #{pluralize(reportable_files.count, "issue")} could be reported: #{reportable_breakdown.join(", ")}")}"
+      puts ""
+
+      reportable_files.each do |(file_path, _issue_type)|
+        puts "  #{relative_path(file_path)}"
+      end
+
+      puts ""
+      puts "  #{dimmed("Run `herb report <file>` to generate a copy-able report for filing an issue.")}"
+      puts "  #{dimmed("Run `herb playground <file>` to visually inspect the parse result, see diagnostics, or check if it's already fixed on main.")}"
+
+      puts ""
+      puts "  #{dimmed("https://github.com/marcoroth/herb/issues")}"
+    end
+
+    def log_problem_file_details(results, log)
+      return unless results.problem_files.any?
+
+      log.puts "\n#{heading("FILE CONTENTS AND DETAILS")}"
+
+      results.problem_files.each do |file|
+        next unless results.file_contents[file]
+
+        divider = "=" * [80, file.length].max
+
+        log.puts
+        log.puts divider
+        log.puts file
+        log.puts divider
+
+        log.puts "\n#{heading("CONTENT")}"
+        log.puts "```erb"
+        log.puts results.file_contents[file]
+        log.puts "```"
+
+        log_error_outputs(results.error_outputs[file], log)
+        log_parse_errors(results.parse_errors[file], log)
+        log_compilation_errors(results.compilation_errors[file], log)
+      end
+    end
+
+    def log_error_outputs(error_output, log)
+      return unless error_output
+
+      if error_output[:exit_code]
+        log.puts "\n#{heading("EXIT CODE")}"
+        log.puts error_output[:exit_code]
+      end
+
+      if error_output[:stderr].strip.length.positive?
+        log.puts "\n#{heading("ERROR OUTPUT")}"
+        log.puts "```"
+        log.puts error_output[:stderr]
+        log.puts "```"
+      end
+
+      return unless error_output[:stdout].strip.length.positive?
+
+      log.puts "\n#{heading("STANDARD OUTPUT")}"
+      log.puts "```"
+      log.puts error_output[:stdout]
+      log.puts "```"
+      log.puts
+    end
+
+    def log_parse_errors(parse_error, log)
+      return unless parse_error
+
+      if parse_error[:stdout].strip.length.positive?
+        log.puts "\n#{heading("STANDARD OUTPUT")}"
+        log.puts "```"
+        log.puts parse_error[:stdout]
+        log.puts "```"
+      end
+
+      if parse_error[:stderr].strip.length.positive?
+        log.puts "\n#{heading("ERROR OUTPUT")}"
+        log.puts "```"
+        log.puts parse_error[:stderr]
+        log.puts "```"
+      end
+
+      return unless parse_error[:ast]
+
+      log.puts "\n#{heading("AST")}"
+      log.puts "```"
+      log.puts parse_error[:ast]
+      log.puts "```"
+      log.puts
+    end
+
+    def log_compilation_errors(compilation_error, log)
+      return unless compilation_error
+
+      log.puts "\n#{heading("COMPILATION ERROR")}"
+      log.puts "```"
+      log.puts compilation_error[:error]
+      log.puts "```"
+
+      return unless compilation_error[:backtrace].any?
+
+      log.puts "\n#{heading("BACKTRACE")}"
+      log.puts "```"
+      log.puts compilation_error[:backtrace].join("\n")
+      log.puts "```"
+      log.puts
+    end
+
+    def label(text, width = 12)
+      dimmed(text.ljust(width))
+    end
 
-    def progress_bar(current, total, width = (IO.console&.winsize&.[](1) || 80) - "[] 100% (#{total}/#{total})".length)
-      progress = current.to_f / total
-      completed_length = (progress * width).to_i
-      completed = "█" * completed_length
+    def stat(count, text, color)
+      value = "#{count} #{text}"
 
-      partial_index = ((progress * width) % 1 * 8).to_i
-      partial_chars = ["", "▏", "▎", "▍", "▌", "▋", "▊", "▉"]
-      partial = partial_index.zero? ? "" : partial_chars[partial_index]
+      if count.positive?
+        bold(send(color, value))
+      else
+        bold(green(value))
+      end
+    end
 
-      remaining = " " * (width - completed_length - (partial.empty? ? 0 : 1))
-      percentage = (progress * 100).to_i
+    def relative_path(absolute_path)
+      Pathname.new(absolute_path).relative_path_from(Pathname.pwd).to_s
+    end
 
-      # Format as [███████▋       ] 42% (123/292)
-      "[#{completed}#{partial}#{remaining}] #{percentage}% (#{current}/#{total})"
+    def pluralize(count, singular, plural = nil)
+      count == 1 ? singular : (plural || "#{singular}s")
     end
 
     def percentage(part, total)
@@ -462,6 +862,21 @@ module Herb
       ((part.to_f / total) * 100).round(1)
     end
 
+    def ensure_parallel!
+      return if defined?(Parallel)
+
+      require "bundler/inline"
+
+      gemfile(true, quiet: true) do
+        source "https://rubygems.org"
+        gem "parallel"
+      end
+    end
+
+    def separator
+      dimmed("─" * 60)
+    end
+
     def heading(text)
       prefix = "--- #{text.upcase} "
 
@@ -479,5 +894,182 @@ module Herb
         "#{minutes}m #{remaining_seconds.round(2)}s"
       end
     end
+
+    def capture_leak_check(file_content)
+      Herb.leak_check(file_content)
+    rescue StandardError
+      { lex: { allocations: 0, deallocations: 0, bytes_allocated: 0, bytes_deallocated: 0 },
+        parse: { allocations: 0, deallocations: 0, bytes_allocated: 0, bytes_deallocated: 0 },
+        extract_ruby: { allocations: 0, deallocations: 0, bytes_allocated: 0, bytes_deallocated: 0 },
+        extract_html: { allocations: 0, deallocations: 0, bytes_allocated: 0, bytes_deallocated: 0 } }
+    end
+
+    def print_leak_check_summary(file_results)
+      leaky_files = file_results.filter_map { |result|
+        next unless result[:leak_check]
+
+        ops = result[:leak_check]
+        leaks = ops.select { |_op, stats| stats[:leaks]&.any? || stats[:allocations] != stats[:deallocations] || stats[:untracked_deallocations]&.positive? }
+        next if leaks.empty?
+
+        { file: result[:file_path], leaks: leaks, all: ops }
+      }
+
+      puts "\n #{separator}"
+      puts "\n"
+      puts " #{bold("Leak check:")}"
+
+      if leaky_files.empty?
+        puts ""
+        puts "  #{bold(green("✓"))} #{green("No leaks detected across all files.")}"
+        return
+      end
+
+      puts "  #{red("#{leaky_files.size} #{pluralize(leaky_files.size, "file")} with potential leaks:")}"
+      puts ""
+
+      leaky_files.each do |entry|
+        relative = relative_path(entry[:file])
+        puts "  #{cyan(relative)}:"
+
+        entry[:all].each do |op, stats|
+          leaks = stats[:leaks] || []
+          untracked_count = stats[:untracked_deallocations] || 0
+          untracked_ptrs = stats[:untracked_pointers] || []
+          leaked_bytes = stats[:bytes_allocated] - stats[:bytes_deallocated]
+
+          if leaks.any?
+            puts "    #{red("✗")} #{op}: #{stats[:allocations]} allocs, #{stats[:deallocations]} deallocs (#{bold(red("#{leaks.size} unfreed, #{format_bytes(leaked_bytes)}"))})"
+            leaks.each_with_index do |size, i|
+              puts "      #{dimmed("#{i + 1}.")} #{format_bytes(size)}"
+            end
+          elsif untracked_count.positive?
+            puts "    #{yellow("~")} #{op}: #{stats[:allocations]} allocs, #{stats[:deallocations]} deallocs"
+          else
+            puts "    #{green("✓")} #{op}: #{stats[:allocations]} allocs, #{stats[:deallocations]} deallocs"
+          end
+
+          next unless untracked_count.positive?
+
+          puts "      #{yellow("#{untracked_count} untracked #{pluralize(untracked_count, "deallocation")}")} #{dimmed("(freed through allocator but not allocated through it)")}"
+          untracked_ptrs.each_with_index do |ptr, i|
+            puts "      #{dimmed("#{i + 1}.")} #{ptr}"
+          end
+        end
+
+        puts ""
+      end
+
+      op_to_command = { lex: "lex", parse: "parse", extract_ruby: "ruby", extract_html: "html" }
+
+      commands = leaky_files.flat_map { |entry|
+        entry[:leaks].keys.map { |op| { command: op_to_command[op] || op.to_s, file: entry[:file] } }
+      }
+
+      puts "  #{dimmed("To debug, run the following from the herb repo root (build with `make` first):")}"
+      puts ""
+      puts "  #{dimmed("# macOS")}"
+      commands.each do |cmd|
+        puts "  leaks --atExit -- ./herb #{cmd[:command]} #{cmd[:file]}"
+      end
+      puts ""
+      puts "  #{dimmed("# Linux")}"
+      commands.each do |cmd|
+        puts "  valgrind --leak-check=full ./herb #{cmd[:command]} #{cmd[:file]}"
+      end
+    end
+
+    def capture_arena_stats(file_content)
+      stats = Herb.arena_stats(file_content)
+
+      {
+        pages: stats[:pages],
+        bytes: stats[:total_used],
+        allocations: stats[:allocations],
+        lines: file_content.count("\n") + 1,
+        length: file_content.bytesize,
+      }
+    rescue StandardError
+      { pages: 0, bytes: 0, allocations: 0, lines: 0, length: 0 }
+    end
+
+    def print_arena_summary(file_results)
+      stats = file_results.filter_map { |result|
+        next unless result[:arena_stats] && result[:arena_stats][:bytes].positive?
+
+        { file: result[:file_path], **result[:arena_stats] }
+      }
+
+      return if stats.empty?
+
+      stats.sort_by! { |stat| -stat[:bytes] }
+
+      puts "\n #{separator}"
+      puts "\n"
+      puts " #{bold("Arena memory usage:")}"
+      puts ""
+
+      relatives = stats.map { |stat| relative_path(stat[:file]) }
+      used_strings = stats.map { |stat| format_bytes(stat[:bytes]) }
+      length_strings = stats.map { |stat| format_bytes(stat[:length]) }
+      used_width = [used_strings.max_by(&:length).length, 4].max
+      pages_width = [stats.max_by { |stat| stat[:pages] }[:pages].to_s.length, 5].max
+      allocs_width = [stats.max_by { |stat| stat[:allocations] }[:allocations].to_s.length, 6].max
+      lines_width = [stats.max_by { |stat| stat[:lines] }[:lines].to_s.length, 5].max
+      length_width = [length_strings.max_by(&:length).length, 4].max
+      total_width = pages_width + used_width + allocs_width + lines_width + length_width + 11
+
+      puts format("  %#{lines_width}s %#{length_width}s %#{pages_width}s %#{used_width}s %#{allocs_width}s  %s", "Lines", "Size", "Pages", "Used", "Allocs", "File")
+      puts "  #{"-" * (total_width + relatives.max_by(&:length).length)}"
+
+      stats.each_with_index do |stat, index|
+        relative = relatives[index]
+        used = used_strings[index]
+        length = length_strings[index]
+        color = stat[:pages] > 1 ? :yellow : :green
+        colored_used = send(color, used)
+        padding = colored_used.length - used.length
+        puts format("  %#{lines_width}d %#{length_width}s %#{pages_width}d %#{used_width + padding}s %#{allocs_width}d  %s", stat[:lines], length, stat[:pages], colored_used, stat[:allocations], relative)
+      end
+
+      total_bytes = stats.sum { |stat| stat[:bytes] }
+      max = stats.first
+
+      puts ""
+      puts "  #{label("Total")} #{cyan(format_bytes(total_bytes))} across #{cyan("#{stats.size} #{pluralize(stats.size, "file")}")}"
+      puts "  #{label("Largest")} #{cyan(relative_path(max[:file]))} (#{cyan(format_bytes(max[:bytes]))}, #{cyan("#{max[:pages]} #{pluralize(max[:pages], "page")}")})"
+
+      boundaries = [0, 16 * 1024, 64 * 1024, 128 * 1024, 256 * 1024, 512 * 1024]
+
+      total = stats.size
+      puts ""
+      bucket_counts = []
+      boundaries.each_cons(2) do |low, high|
+        count = stats.count { |stat| stat[:bytes] > low && stat[:bytes] <= high }
+        low_label = format_bytes(low).rjust(6)
+        high_label = format_bytes(high).rjust(6)
+        bucket_counts << { label: "  #{low_label} - #{high_label}", count: count }
+      end
+      last = boundaries.last
+      count = stats.count { |stat| stat[:bytes] > last }
+      bucket_counts << { label: "         > #{format_bytes(last)}", count: count }
+
+      count_width = bucket_counts.max_by { |b| b[:count] }[:count].to_s.length
+      pct_width = bucket_counts.map { |b| "#{percentage(b[:count], total)}%".length }.max
+      bucket_counts.each do |bucket|
+        pct = "#{percentage(bucket[:count], total)}%"
+        puts "  #{label(bucket[:label], 19)} #{bucket[:count].to_s.rjust(count_width)} #{pluralize(bucket[:count], "file").ljust(5)} #{pct.rjust(pct_width)}"
+      end
+    end
+
+    def format_bytes(bytes)
+      if bytes >= 1024 * 1024
+        "#{(bytes / (1024.0 * 1024.0)).round(1)} MB"
+      elsif bytes >= 1024
+        "#{(bytes / 1024.0).round(0)} KB"
+      else
+        "#{bytes} B"
+      end
+    end
   end
 end