hone 0.1.0

data/lib/hone/formatters/junit.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+module Hone
+  module Formatters
+    class JUnit < Base
+      PRIORITY_TO_TYPE = {
+        hot_cpu: "failure",
+        hot_alloc: "failure",
+        jit_unfriendly: "failure",
+        warm: "failure",
+        cold: "skipped",
+        unknown: "failure"
+      }.freeze
+
+      def format
+        require_rexml!
+        doc = build_document
+        output = +""
+        formatter = REXML::Formatters::Pretty.new(2)
+        formatter.compact = true
+        output << %(<?xml version="1.0" encoding="UTF-8"?>\n)
+        formatter.write(doc.root, output)
+        output
+      end
+
+      private
+
+      def require_rexml!
+        require "rexml/document"
+      rescue LoadError
+        raise Hone::Error, "JUnit format requires the 'rexml' gem. Add it to your Gemfile: gem 'rexml'"
+      end
+
+      def build_document
+        doc = REXML::Document.new
+        testsuites = doc.add_element("testsuites")
+        testsuites.add_attribute("name", "Hone")
+
+        findings_by_file = filtered_findings.group_by(&:file)
+
+        total_tests = 0
+        total_failures = 0
+        total_skipped = 0
+
+        findings_by_file.each do |file, file_findings|
+          suite = testsuites.add_element("testsuite")
+          suite.add_attribute("name", file)
+
+          suite_failures = 0
+          suite_skipped = 0
+
+          file_findings.each do |finding|
+            add_testcase(suite, finding, file)
+
+            case result_type(finding)
+            when "failure"
+              suite_failures += 1
+            when "skipped"
+              suite_skipped += 1
+            end
+          end
+
+          suite.add_attribute("tests", file_findings.size.to_s)
+          suite.add_attribute("failures", suite_failures.to_s)
+          suite.add_attribute("skipped", suite_skipped.to_s)
+
+          total_tests += file_findings.size
+          total_failures += suite_failures
+          total_skipped += suite_skipped
+        end
+
+        testsuites.add_attribute("tests", total_tests.to_s)
+        testsuites.add_attribute("failures", total_failures.to_s)
+        testsuites.add_attribute("skipped", total_skipped.to_s)
+
+        doc
+      end
+
+      def add_testcase(suite, finding, file)
+        testcase = suite.add_element("testcase")
+        testcase.add_attribute("name", testcase_name(finding))
+        testcase.add_attribute("classname", classname_from_file(file))
+
+        case result_type(finding)
+        when "failure"
+          add_failure_element(testcase, finding)
+        when "skipped"
+          add_skipped_element(testcase, finding)
+        end
+      end
+
+      def testcase_name(finding)
+        name = finding.pattern_id.to_s
+        name += " at line #{finding.line}" if finding.line
+        name
+      end
+
+      def classname_from_file(file)
+        # Convert path like "app/models/order.rb" to "app.models.order"
+        file
+          .sub(/\.rb\z/, "")
+          .tr("/", ".")
+      end
+
+      def result_type(finding)
+        priority = finding.priority || :unknown
+        PRIORITY_TO_TYPE.fetch(priority, "failure")
+      end
+
+      def add_failure_element(testcase, finding)
+        failure = testcase.add_element("failure")
+        failure.add_attribute("message", finding.message)
+        failure.add_attribute("type", (finding.priority || :unknown).to_s)
+        failure.add_text(failure_details(finding))
+      end
+
+      def add_skipped_element(testcase, finding)
+        skipped = testcase.add_element("skipped")
+        skipped.add_attribute("message", finding.message)
+      end
+
+      def failure_details(finding)
+        heat = priority_label(finding.priority || :unknown)
+
+        cpu_info = finding.cpu_percent ? "#{format_percent(finding.cpu_percent)} CPU" : nil
+        alloc_info = finding.alloc_percent ? "#{format_percent(finding.alloc_percent)} alloc" : nil
+        metrics = [cpu_info, alloc_info].compact.join(", ")
+
+        details = if metrics.empty?
+          "[#{heat}] #{finding.message}"
+        else
+          "[#{heat} #{metrics}] #{finding.message}"
+        end
+
+        details += "\nCode: #{finding.code}" if finding.code
+        details += "\nFile: #{finding.file}:#{finding.line}" if finding.file && finding.line
+        details
+      end
+
+      def priority_label(priority)
+        case priority
+        when :hot_cpu then "HOT-CPU"
+        when :hot_alloc then "HOT-ALLOC"
+        when :jit_unfriendly then "JIT-UNFRIENDLY"
+        else priority.to_s.upcase
+        end
+      end
+
+      def format_percent(percent)
+        "%.1f%%" % percent
+      end
+    end
+  end
+end

data/lib/hone/formatters/sarif.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Hone
+  module Formatters
+    # SARIF (Static Analysis Results Interchange Format) formatter for GitHub Code Scanning.
+    #
+    # SARIF is a standard format for static analysis tools, supported by GitHub Code Scanning
+    # and other security/code quality platforms.
+    #
+    # @see https://docs.oasis-open.org/sarif/sarif/v2.1.0/sarif-v2.1.0.html
+    #
+    # @example Usage
+    #   formatter = Hone::Formatters::SARIF.new(findings)
+    #   puts formatter.format
+    class SARIF < Base
+      SARIF_VERSION = "2.1.0"
+      SARIF_SCHEMA = "https://raw.githubusercontent.com/oasis-tcs/sarif-spec/master/Schemata/sarif-schema-2.1.0.json"
+
+      # Maps Hone priority levels to SARIF severity levels.
+      # - error: A serious problem that should be addressed immediately
+      # - warning: A potential problem that should be reviewed
+      # - note: Informational finding
+      PRIORITY_TO_LEVEL = {
+        hot_cpu: "error",
+        hot_alloc: "error",
+        jit_unfriendly: "warning",
+        warm: "warning",
+        cold: "note",
+        unknown: "note"
+      }.freeze
+
+      def format
+        ::JSON.pretty_generate(build_sarif)
+      end
+
+      private
+
+      def build_sarif
+        {
+          "$schema" => SARIF_SCHEMA,
+          "version" => SARIF_VERSION,
+          "runs" => [build_run]
+        }
+      end
+
+      def build_run
+        {
+          "tool" => build_tool,
+          "results" => build_results
+        }
+      end
+
+      def build_tool
+        {
+          "driver" => {
+            "name" => "Hone",
+            "version" => Hone::VERSION,
+            "informationUri" => "https://github.com/your-org/hone",
+            "rules" => build_rules
+          }
+        }
+      end
+
+      def build_rules
+        # Collect unique pattern IDs from findings to build rule definitions
+        unique_patterns = @findings.map(&:pattern_id).uniq
+
+        unique_patterns.map { |pattern_id| build_rule(pattern_id) }
+      end
+
+      def build_rule(pattern_id)
+        {
+          "id" => pattern_id.to_s,
+          "name" => humanize_pattern_id(pattern_id),
+          "shortDescription" => {
+            "text" => "#{humanize_pattern_id(pattern_id)} optimization opportunity"
+          },
+          "helpUri" => "https://github.com/your-org/hone##{pattern_id}"
+        }
+      end
+
+      def humanize_pattern_id(pattern_id)
+        pattern_id.to_s.split("_").map(&:capitalize).join(" ")
+      end
+
+      def build_results
+        @findings.map { |finding| build_result(finding) }
+      end
+
+      def build_result(finding)
+        result = {
+          "ruleId" => finding.pattern_id.to_s,
+          "level" => sarif_level(finding),
+          "message" => {
+            "text" => build_message_text(finding)
+          },
+          "locations" => [build_location(finding)]
+        }
+
+        # Add optional properties if available
+        result["partialFingerprints"] = build_fingerprints(finding) if finding.method_name
+
+        result
+      end
+
+      def sarif_level(finding)
+        priority = finding.priority || :unknown
+        PRIORITY_TO_LEVEL.fetch(priority, "note")
+      end
+
+      def build_message_text(finding)
+        parts = [finding.message]
+
+        if finding.cpu_percent
+          parts << "CPU: %.1f%%" % finding.cpu_percent
+        end
+
+        if finding.alloc_percent
+          parts << "Allocations: %.1f%%" % finding.alloc_percent
+        end
+
+        if finding.speedup
+          parts << "Expected speedup: #{finding.speedup}"
+        end
+
+        parts.join(" | ")
+      end
+
+      def build_location(finding)
+        location = {
+          "physicalLocation" => {
+            "artifactLocation" => {
+              "uri" => finding.file
+            },
+            "region" => build_region(finding)
+          }
+        }
+
+        # Add logical location (method name) if available
+        if finding.method_name
+          location["logicalLocations"] = [
+            {
+              "name" => finding.method_name,
+              "kind" => "function"
+            }
+          ]
+        end
+
+        location
+      end
+
+      def build_region(finding)
+        region = {
+          "startLine" => finding.line
+        }
+
+        region["startColumn"] = finding.column if finding.column
+
+        # Include the source code snippet if available
+        if finding.code
+          region["snippet"] = {
+            "text" => finding.code
+          }
+        end
+
+        region
+      end
+
+      def build_fingerprints(finding)
+        # Partial fingerprints help GitHub track results across runs
+        {
+          "methodName" => finding.method_name
+        }
+      end
+    end
+  end
+end

data/lib/hone/formatters/tsv.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Hone
+  module Formatters
+    class TSV < Base
+      HEADERS = %w[priority cpu_percent alloc_percent file line pattern_id message method_name].freeze
+      COLUMN_SEPARATOR = "\t"
+
+      def format
+        lines = [header_row]
+        lines.concat(filtered_findings.map { |finding| format_row(finding) })
+        lines.join("\n")
+      end
+
+      private
+
+      def header_row
+        HEADERS.join(COLUMN_SEPARATOR)
+      end
+
+      def format_row(finding)
+        [
+          (finding.priority || "").to_s,
+          format_percent(finding.cpu_percent),
+          format_percent(finding.alloc_percent),
+          finding.file.to_s,
+          finding.line.to_s,
+          finding.pattern_id.to_s,
+          escape_field(finding.message.to_s),
+          finding.method_name.to_s
+        ].join(COLUMN_SEPARATOR)
+      end
+
+      def format_percent(value)
+        return "" if value.nil?
+
+        value.to_s
+      end
+
+      def escape_field(value)
+        # Escape tabs and newlines for TSV compatibility
+        value
+          .gsub("\t", "\\t")
+          .gsub("\n", "\\n")
+          .gsub("\r", "\\r")
+      end
+    end
+  end
+end

data/lib/hone/harness.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Hone
+  class Harness
+    attr_reader :setup_block, :exercise_block, :teardown_block, :iterations
+
+    def self.load(path)
+      raise Hone::Error, "Harness file not found: #{path}" unless File.exist?(path)
+
+      harness = new
+      harness.instance_eval(File.read(path), path)
+      harness
+    end
+
+    def initialize
+      @setup_block = nil
+      @exercise_block = nil
+      @teardown_block = nil
+      @iterations = 1
+    end
+
+    # Setup block - runs once before profiling (not profiled)
+    # Used for loading the application, creating test data, etc.
+    def setup(&block)
+      @setup_block = block
+    end
+
+    # Exercise block - the code to profile
+    # @param iterations [Integer] Number of times to run the block during profiling
+    def exercise(iterations: 1, &block)
+      @iterations = iterations
+      @exercise_block = block
+    end
+
+    # Teardown block - runs once after profiling (not profiled)
+    # Used for cleanup, closing connections, etc.
+    def teardown(&block)
+      @teardown_block = block
+    end
+
+    def run_setup
+      @setup_block&.call
+    end
+
+    def run_exercise
+      @exercise_block&.call
+    end
+
+    def run_teardown
+      @teardown_block&.call
+    end
+
+    def valid?
+      !@exercise_block.nil?
+    end
+  end
+end

data/lib/hone/harness_generator.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Hone
+  class HarnessGenerator
+    HARNESS_DIR = ".hone"
+    HARNESS_FILE = "harness.rb"
+
+    def initialize(rails: false)
+      @rails = rails
+    end
+
+    def generate
+      FileUtils.mkdir_p(HARNESS_DIR)
+
+      path = File.join(HARNESS_DIR, HARNESS_FILE)
+
+      if File.exist?(path)
+        puts "Harness already exists: #{path}"
+        puts "Delete it first if you want to regenerate."
+        return false
+      end
+
+      template = @rails ? rails_template : ruby_template
+      File.write(path, template)
+
+      puts "Created #{path}"
+      puts
+      puts "Next steps:"
+      puts "  1. Edit #{path} to exercise your application's hot paths"
+      puts "  2. Run: hone profile"
+      puts "  3. Run: hone analyze ."
+      puts
+
+      true
+    end
+
+    private
+
+    def ruby_template
+      <<~RUBY
+        # frozen_string_literal: true
+
+        # Hone Performance Harness
+        # ========================
+        # This file defines how to exercise your code for profiling.
+        #
+        # Run with: hone profile
+        # Analyze:  hone analyze . (uses generated profiles automatically)
+
+        # Setup: Load your application (not profiled)
+        setup do
+          # Load your library or application
+          # require_relative "../lib/my_gem"
+
+          # Create any test data needed
+          # @data = generate_test_data
+        end
+
+        # Exercise: The code to profile
+        # This block runs multiple times during profiling.
+        # Put your realistic workload here.
+        exercise iterations: 100 do
+          # Example: Call your hot methods
+          # result = MyClass.new(@data).process
+          #
+          # Example: Simulate typical usage
+          # parser = Parser.new
+          # 100.times { parser.parse(sample_input) }
+        end
+
+        # Teardown: Cleanup (not profiled)
+        teardown do
+          # Close connections, clean up temp files, etc.
+        end
+      RUBY
+    end
+
+    def rails_template
+      <<~RUBY
+        # frozen_string_literal: true
+
+        # Hone Performance Harness (Rails)
+        # =================================
+        # This file defines how to exercise your Rails app for profiling.
+        #
+        # Run with: hone profile
+        # Analyze:  hone analyze app/ (uses generated profiles automatically)
+
+        # Setup: Boot Rails (not profiled)
+        setup do
+          require_relative "../config/environment"
+          Rails.application.eager_load!
+
+          # Create test data if needed
+          # @user = User.first || User.create!(name: "Test", email: "test@example.com")
+          # @items = Item.limit(10).to_a
+        end
+
+        # Exercise: Your hot paths
+        # This block runs multiple times during profiling.
+        # Replace with YOUR app's actual hot code paths.
+        exercise iterations: 100 do
+          # Example: Model queries
+          # User.where(active: true).includes(:orders).limit(10).to_a
+
+          # Example: Business logic
+          # Order.new(user: @user, items: @items).calculate_total
+
+          # Example: Service objects
+          # PaymentProcessor.new(order).validate
+
+          # Example: Simulate a controller action
+          # app = Rails.application
+          # env = Rack::MockRequest.env_for("/users/1")
+          # app.call(env)
+        end
+
+        # Teardown: Cleanup (not profiled)
+        teardown do
+          # Clean up test data if needed
+          # @user&.destroy
+        end
+      RUBY
+    end
+  end
+end