hone 0.1.0

data/lib/hone/reporter.rb

@@ -0,0 +1,371 @@
+# frozen_string_literal: true
+
+module Hone
+  class Reporter
+    include Formatters::Filterable
+
+    # ANSI color codes
+    COLORS = {
+      reset: "\e[0m",
+      bold: "\e[1m",
+      dim: "\e[2m",
+      red: "\e[31m",
+      green: "\e[32m",
+      yellow: "\e[33m",
+      cyan: "\e[36m",
+      white: "\e[37m",
+      bright_red: "\e[91m",
+      gray: "\e[90m"
+    }.freeze
+
+    # Priority display configuration
+    PRIORITY_CONFIG = {
+      hot_cpu: {label: "High impact", color: %i[bold bright_red], metric: :cpu},
+      hot_alloc: {label: "High impact", color: %i[bold red], metric: :alloc},
+      jit_unfriendly: {label: "JIT issue", color: %i[bold yellow], metric: nil},
+      warm: {label: "Moderate", color: [:yellow], metric: nil},
+      cold: {label: "Low", color: %i[dim gray], metric: nil},
+      unknown: {label: "Unknown", color: [:dim], metric: nil}
+    }.freeze
+
+    SEPARATOR_WIDTH = 72
+    CONTEXT_LINES = 2
+
+    def initialize(findings, options = {})
+      @findings = findings
+      @show_cold = options.fetch(:show_cold, false)
+      @quiet = options.fetch(:quiet, false)
+      @verbose = options.fetch(:verbose, false)
+      @color = options.fetch(:color, $stdout.tty? && !ENV["NO_COLOR"])
+      @profile_path = options[:profile_path]
+      @file_path = options[:file_path]
+      @hot_threshold = options.fetch(:hot_threshold, Correlator::HOT_THRESHOLD)
+      @warm_threshold = options.fetch(:warm_threshold, Correlator::WARM_THRESHOLD)
+      @source_cache = {}
+    end
+
+    def format
+      output = []
+      output << header unless @quiet
+      output << findings_output
+      output << summary
+      output.flatten.compact.join("\n")
+    end
+
+    alias_method :report, :format
+
+    private
+
+    def header
+      lines = []
+      lines << colorize("Hone v#{VERSION}", :bold)
+      lines << ""
+
+      context_parts = []
+      context_parts << "Analyzing #{@file_path}" if @file_path
+      context_parts << "with profile: #{@profile_path}" if @profile_path
+
+      lines << context_parts.join(" ") unless context_parts.empty?
+      lines
+    end
+
+    def findings_output
+      visible_findings.map { |finding| format_finding(finding) }
+    end
+
+    def visible_findings
+      filter_cold(@findings, show_cold: @show_cold)
+    end
+
+    def format_finding(finding)
+      if @quiet
+        format_finding_quiet(finding)
+      elsif @verbose
+        format_finding_verbose(finding)
+      else
+        format_finding_default(finding)
+      end
+    end
+
+    # Quiet mode: single line per finding
+    def format_finding_quiet(finding)
+      location = "#{finding.file}:#{finding.line}"
+      metric = format_primary_metric(finding)
+      original = finding.code&.strip&.split("\n")&.first&.strip || ""
+      suggestion = SuggestionGenerator.generate(finding.pattern_id, original)
+
+      if suggestion && suggestion != original
+        # Shorten for display
+        original_short = truncate(original, 30)
+        suggestion_short = truncate(suggestion, 30)
+        transform = "#{original_short} → #{suggestion_short}"
+      else
+        transform = truncate(original, 40)
+      end
+
+      "#{location}  #{metric}  #{transform}"
+    end
+
+    # Default mode: balanced detail with source context
+    def format_finding_default(finding)
+      lines = []
+      lines << separator
+      lines << ""
+
+      # Location and method
+      location = colorize("#{finding.file}:#{finding.line}", :cyan)
+      method_info = finding.method_name ? " in `#{finding.method_name}`" : ""
+      lines << "#{location}#{method_info}"
+
+      # Metrics with impact label
+      lines << format_metrics_line(finding)
+      lines << ""
+
+      # Source context with line numbers
+      lines.concat(format_source_context(finding))
+      lines << ""
+
+      # Fix suggestion
+      lines.concat(format_fix_suggestion(finding))
+      lines << ""
+
+      lines
+    end
+
+    # Verbose mode: full detail with extended explanation
+    def format_finding_verbose(finding)
+      lines = []
+      lines << separator
+      lines << ""
+
+      # Location, method, and pattern info
+      location = colorize("#{finding.file}:#{finding.line}", :cyan)
+      method_info = finding.method_name ? " in `#{finding.method_name}`" : ""
+      lines << "#{location}#{method_info}"
+
+      # Metrics
+      lines << format_metrics_line(finding)
+
+      # Pattern metadata
+      pattern_info = "Pattern: #{finding.pattern_id}"
+      pattern_info += "  Type: #{finding.optimization_type}" if finding.optimization_type
+      lines << colorize(pattern_info, :dim)
+      lines << ""
+
+      # Source context (more lines in verbose)
+      lines.concat(format_source_context(finding, context_lines: 3))
+      lines << ""
+
+      # Fix suggestion with full explanation
+      lines.concat(format_fix_suggestion(finding, include_explanation: true))
+      lines << ""
+
+      lines
+    end
+
+    def format_metrics_line(finding)
+      priority = finding.priority || :unknown
+      config = PRIORITY_CONFIG[priority]
+
+      parts = []
+
+      # Primary metric
+      if finding.alloc_percent && finding.alloc_percent > 0
+        parts << "#{format_percent(finding.alloc_percent)} of allocations"
+      end
+      if finding.cpu_percent && finding.cpu_percent > 0
+        parts << "#{format_percent(finding.cpu_percent)} of CPU"
+      end
+
+      metric_str = parts.any? ? parts.join(", ") : nil
+
+      # Impact label
+      impact = colorize_multi(config[:label], config[:color])
+
+      if metric_str
+        "#{metric_str} — #{impact}"
+      else
+        impact
+      end
+    end
+
+    def format_source_context(finding, context_lines: CONTEXT_LINES)
+      lines = []
+      source_lines = read_source_lines(finding.file)
+      return lines if source_lines.empty?
+
+      target_line = finding.line
+      start_line = [target_line - context_lines, 1].max
+      end_line = [target_line + context_lines, source_lines.size].min
+
+      # Calculate line number width for alignment
+      width = end_line.to_s.length
+
+      (start_line..end_line).each do |line_num|
+        line_content = source_lines[line_num - 1] || ""
+        line_content = line_content.chomp
+
+        if line_num == target_line
+          # Highlight the target line
+          prefix = colorize("#{line_num.to_s.rjust(width)} │ ", :dim)
+          lines << "#{prefix}#{line_content}"
+
+          # Add caret marker
+          if finding.column && finding.column > 0
+            caret_padding = " " * (width + 3 + finding.column)
+            code_length = [finding.code&.split("\n")&.first&.length || 5, 3].max
+            carets = colorize("^" * [code_length, 40].min, :bright_red)
+            lines << "#{caret_padding}#{carets}"
+          end
+        else
+          prefix = colorize("#{line_num.to_s.rjust(width)} │ ", :dim)
+          lines << colorize("#{prefix}#{line_content}", :dim)
+        end
+      end
+
+      lines
+    end
+
+    def format_fix_suggestion(finding, include_explanation: false)
+      lines = []
+      original_code = finding.code&.strip&.split("\n")&.first&.strip || ""
+      suggested_code = SuggestionGenerator.generate(finding.pattern_id, original_code)
+
+      if suggested_code && suggested_code != original_code
+        lines << "#{colorize("Fix:", :bold)} #{colorize(suggested_code, :green)}"
+      end
+
+      # Explanation (merged Why/Speedup into single line)
+      explanation = finding.message
+      if explanation
+        lines << "     #{explanation}"
+      end
+
+      lines
+    end
+
+    def format_primary_metric(finding)
+      if finding.alloc_percent && finding.alloc_percent >= 1
+        "#{format_percent(finding.alloc_percent)} alloc"
+      elsif finding.cpu_percent && finding.cpu_percent >= 1
+        "#{format_percent(finding.cpu_percent)} CPU"
+      elsif finding.alloc_percent
+        "#{format_percent(finding.alloc_percent)} alloc"
+      elsif finding.cpu_percent
+        "#{format_percent(finding.cpu_percent)} CPU"
+      else
+        "?"
+      end
+    end
+
+    def summary
+      stats = calculate_stats
+      build_summary_output(stats)
+    end
+
+    def calculate_stats
+      counts = @findings.map { |f| f.priority || :unknown }.tally
+      {
+        total: @findings.size,
+        hot_cpu: counts[:hot_cpu] || 0,
+        hot_alloc: counts[:hot_alloc] || 0,
+        jit_unfriendly: counts[:jit_unfriendly] || 0,
+        warm: counts[:warm] || 0,
+        cold: counts[:cold] || 0,
+        unknown: counts[:unknown] || 0
+      }
+    end
+
+    def build_summary_output(stats)
+      lines = []
+      lines << separator
+      lines << ""
+
+      total = stats[:total]
+      high_impact = stats[:hot_cpu] + stats[:hot_alloc]
+
+      if @quiet
+        parts = []
+        parts << "#{high_impact} high" if high_impact > 0
+        parts << "#{stats[:jit_unfriendly]} jit" if stats[:jit_unfriendly] > 0
+        parts << "#{stats[:warm]} moderate" if stats[:warm] > 0
+        parts << "#{stats[:cold]} low" if stats[:cold] > 0
+        lines << "#{total} findings: #{parts.join(", ")}"
+        return lines
+      end
+
+      lines << colorize("Summary: #{total} #{(total == 1) ? "finding" : "findings"}", :bold)
+      lines << ""
+
+      if high_impact > 0
+        label = colorize_multi("#{high_impact} high impact", PRIORITY_CONFIG[:hot_cpu][:color])
+        arrow = colorize("← fix these first", :bold)
+        lines << "  #{label}  (>#{@hot_threshold.to_i}% of CPU or allocations)  #{arrow}"
+      end
+
+      if stats[:jit_unfriendly] > 0
+        label = colorize_multi("#{stats[:jit_unfriendly]} JIT issues", PRIORITY_CONFIG[:jit_unfriendly][:color])
+        lines << "  #{label}  (may hurt YJIT optimization)"
+      end
+
+      if stats[:warm] > 0
+        label = colorize_multi("#{stats[:warm]} moderate", PRIORITY_CONFIG[:warm][:color])
+        lines << "  #{label}  (#{@warm_threshold.to_i}-#{@hot_threshold.to_i}%)"
+      end
+
+      if stats[:cold] > 0
+        label = colorize_multi("#{stats[:cold]} low", PRIORITY_CONFIG[:cold][:color])
+        hint = @show_cold ? "" : "  (use --show-cold to display)"
+        lines << "  #{label}  (<#{@warm_threshold.to_i}%)#{hint}"
+      end
+
+      if stats[:unknown] > 0
+        label = colorize_multi("#{stats[:unknown]} unknown", PRIORITY_CONFIG[:unknown][:color])
+        lines << "  #{label}  (no profile data)"
+      end
+
+      if @verbose
+        lines << ""
+        lines << colorize("Percentages show share of total profiled CPU time or allocations.", :dim)
+      end
+
+      lines << ""
+      lines
+    end
+
+    def read_source_lines(file_path)
+      return @source_cache[file_path] if @source_cache.key?(file_path)
+
+      @source_cache[file_path] = if File.exist?(file_path)
+        File.readlines(file_path)
+      else
+        []
+      end
+    end
+
+    def separator
+      colorize("─" * SEPARATOR_WIDTH, :dim)
+    end
+
+    def truncate(str, max_length)
+      return str if str.length <= max_length
+      "#{str[0, max_length - 3]}..."
+    end
+
+    def colorize(text, *colors)
+      return text unless @color
+
+      codes = colors.flatten.map { |c| COLORS[c] }.compact.join
+      "#{codes}#{text}#{COLORS[:reset]}"
+    end
+
+    def colorize_multi(text, colors)
+      colorize(text, *colors)
+    end
+
+    def format_percent(value)
+      return "0%" if value.nil? || value == 0
+      value < 0.1 ? "<0.1%" : "#{value.round(1)}%"
+    end
+  end
+end

data/lib/hone/scanner.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module Hone
+  # Scans Ruby files for optimization patterns using Prism AST analysis.
+  # Coordinates multiple pattern matchers and collects their findings.
+  class Scanner
+    # Default glob pattern for finding Ruby files
+    DEFAULT_RUBY_GLOB = "**/*.rb"
+
+    def initialize(patterns: Patterns.registered, rails: false)
+      @rails = rails
+      @patterns = patterns.select do |pattern|
+        # Skip abstract base classes (no pattern_id)
+        next false if pattern.pattern_id.nil?
+
+        if @rails
+          true
+        else
+          pattern.scope.nil? || pattern.scope == :ruby
+        end
+      end
+    end
+
+    # Scan a single file with all patterns
+    # Returns an array of findings from all pattern matchers
+    def scan_file(path)
+      result = Prism.parse_file(path)
+
+      if result.errors.any?
+        warn "Parse errors in #{path}:"
+        result.errors.each { |e| warn "  #{e.message}" }
+        return []
+      end
+
+      @patterns.flat_map do |pattern_class|
+        matcher = pattern_class.new(path)
+        result.value.accept(matcher)
+        matcher.findings
+      end
+    end
+
+    # Scan all Ruby files in a directory
+    # Returns an array of findings from all files
+    def scan_directory(path, pattern: DEFAULT_RUBY_GLOB)
+      files = Dir.glob(File.join(path, pattern))
+
+      files.flat_map do |file|
+        scan_file(file)
+      end
+    end
+
+    # Scan multiple files
+    # Returns an array of findings from all files
+    def scan_files(paths)
+      paths.flat_map { |path| scan_file(path) }
+    end
+
+    # Group findings by file
+    def self.group_by_file(findings)
+      findings.group_by(&:file)
+    end
+
+    # Group findings by pattern type
+    def self.group_by_pattern(findings)
+      findings.group_by(&:pattern_id)
+    end
+
+    # Group findings by optimization type (:cpu, :allocation, :jit)
+    def self.group_by_optimization_type(findings)
+      findings.group_by(&:optimization_type)
+    end
+  end
+end

data/lib/hone/suggestion_generator.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Hone
+  class SuggestionGenerator
+    TRANSFORMS = {
+      positive_predicate: ->(code) { code.gsub(".positive?", " > 0") },
+      negative_predicate: ->(code) { code.gsub(".negative?", " < 0") },
+      zero_predicate: ->(code) { code.gsub(".zero?", " == 0") },
+      map_select_chain: ->(code) { code.gsub(/\.map\s*[({].*?[)}]\s*\.select/, ".filter_map") },
+      kernel_loop: ->(code) { code.gsub(/\bloop\s*(?:do|\{)/, "while true do") },
+      chars_map_ord: ->(code) { code.gsub(/\.chars\.map\s*\(&:ord\)/, ".bytes") },
+      dynamic_ivar: ->(code) { code },
+      dynamic_ivar_get: ->(code) { code },
+      lazy_ivar: ->(code) { code.gsub(/defined\?\(@\w+\)\s*\?\s*@(\w+)\s*:/, '@\1 ||=') },
+      slice_with_length: ->(code) { code.gsub(/\[(\d+),\s*\w+\.(?:length|size)\]/, '[\1..]') }
+    }.freeze
+
+    def self.generate(pattern_id, code)
+      transform = TRANSFORMS[pattern_id]
+      transform ? transform.call(code) : code
+    end
+  end
+end

data/lib/hone/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Hone
+  VERSION = "0.1.0"
+end

data/lib/hone.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require_relative "hone/version"
+require_relative "hone/exit_codes"
+require_relative "hone/finding"
+require_relative "hone/method_map"
+
+# Patterns
+require_relative "hone/patterns/base"
+require_relative "hone/patterns/positive_predicate"
+require_relative "hone/patterns/kernel_loop"
+require_relative "hone/patterns/slice_with_length"
+require_relative "hone/patterns/chars_map_ord"
+require_relative "hone/patterns/map_select_chain"
+require_relative "hone/patterns/dynamic_ivar"
+require_relative "hone/patterns/dynamic_ivar_get"
+require_relative "hone/patterns/lazy_ivar"
+require_relative "hone/patterns/each_with_index"
+require_relative "hone/patterns/string_concat_in_loop"
+require_relative "hone/patterns/reverse_each"
+require_relative "hone/patterns/hash_each_key"
+require_relative "hone/patterns/shuffle_first"
+require_relative "hone/patterns/sort_first"
+require_relative "hone/patterns/count_vs_size"
+require_relative "hone/patterns/map_flatten"
+require_relative "hone/patterns/inject_sum"
+require_relative "hone/patterns/gsub_to_tr"
+require_relative "hone/patterns/hash_keys_include"
+require_relative "hone/patterns/select_count"
+require_relative "hone/patterns/range_include"
+require_relative "hone/patterns/select_first"
+require_relative "hone/patterns/string_chars_each"
+require_relative "hone/patterns/redundant_string_chars"
+require_relative "hone/patterns/parallel_assignment"
+require_relative "hone/patterns/string_shovel"
+require_relative "hone/patterns/yield_vs_block"
+require_relative "hone/patterns/sort_by_first"
+require_relative "hone/patterns/sort_last"
+require_relative "hone/patterns/sort_by_last"
+require_relative "hone/patterns/hash_values_include"
+require_relative "hone/patterns/hash_each_value"
+require_relative "hone/patterns/hash_merge_bang"
+require_relative "hone/patterns/string_delete_prefix"
+require_relative "hone/patterns/string_delete_suffix"
+require_relative "hone/patterns/string_casecmp"
+require_relative "hone/patterns/string_start_with"
+require_relative "hone/patterns/string_end_with"
+require_relative "hone/patterns/string_empty"
+require_relative "hone/patterns/map_compact"
+require_relative "hone/patterns/select_map"
+require_relative "hone/patterns/reverse_first"
+require_relative "hone/patterns/times_map"
+require_relative "hone/patterns/each_with_object"
+require_relative "hone/patterns/block_to_proc"
+require_relative "hone/patterns/regexp_match"
+require_relative "hone/patterns/constant_regexp"
+require_relative "hone/patterns/sort_reverse"
+require_relative "hone/patterns/array_compact"
+require_relative "hone/patterns/bsearch_vs_find"
+require_relative "hone/patterns/divmod"
+require_relative "hone/patterns/flatten_once"
+require_relative "hone/patterns/uniq_by"
+require_relative "hone/patterns/array_include_set"
+require_relative "hone/patterns/taint_tracking_base"
+require_relative "hone/patterns/chars_to_variable"
+require_relative "hone/patterns/chars_to_variable_tainted"
+
+require_relative "hone/scanner"
+
+# Adapters
+require_relative "hone/adapters/base"
+require_relative "hone/adapters/fasterer"
+require_relative "hone/adapters/rubocop_performance"
+
+# Profilers
+require_relative "hone/profilers/base"
+require_relative "hone/profilers/stackprof"
+require_relative "hone/profilers/vernier"
+require_relative "hone/profilers/memory_profiler"
+require_relative "hone/profilers/factory"
+
+# Correlation
+require_relative "hone/correlator"
+require_relative "hone/finding_filter"
+
+# Reporting
+require_relative "hone/suggestion_generator"
+require_relative "hone/formatters/filterable"
+require_relative "hone/formatters/base"
+require_relative "hone/reporter"
+require_relative "hone/formatters/json"
+require_relative "hone/formatters/github"
+require_relative "hone/formatters/sarif"
+require_relative "hone/formatters/junit"
+require_relative "hone/formatters/tsv"
+
+# Orchestration
+require_relative "hone/analyzer"
+
+# Harness
+require_relative "hone/harness"
+require_relative "hone/harness_runner"
+require_relative "hone/harness_generator"
+require_relative "hone/config"
+
+module Hone
+  class Error < StandardError; end
+end

data/sig/hone.rbs

@@ -0,0 +1,4 @@
+module Hone
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end