bugsage 0.2.0

data/lib/bugsage/ai_support.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Bugsage
+  # Shared helpers for AI provider responses.
+  module AiSupport
+    class << self
+      def extract_json(response)
+        stripped = response.to_s.strip
+        stripped = stripped.sub(/\A.*?```(?:json)?\s*/im, "").sub(/\s*```.*\z/m, "") if stripped.include?("```")
+
+        match = stripped.match(/\{.*\}/m)
+        match ? match[0] : stripped
+      end
+
+      def log_failure(label, error)
+        message = "[BugSage] #{label}: #{error.class}: #{error.message}"
+        if defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger
+          Rails.logger.warn(message)
+        else
+          warn(message)
+        end
+      end
+
+      def build_client(config = Bugsage.configuration)
+        return config.ai_client if config.ai_client
+
+        case config.resolved_ai_provider
+        when :cursor
+          CursorClient.new(config: config)
+        else
+          OpenAiClient.new(config: config)
+        end
+      end
+    end
+  end
+end

data/lib/bugsage/auto_configurator.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Bugsage
+  module AutoConfigurator
+    API_KEY_ENV_VARS = {
+      cursor: %w[CURSOR_API_KEY BUGSAGE_CURSOR_API_KEY],
+      openai: %w[OPENAI_API_KEY BUGSAGE_OPENAI_API_KEY]
+    }.freeze
+
+    module_function
+
+    def apply!(config = Bugsage.configuration, env: ENV)
+      apply_environment_settings!(config, env)
+      apply_ai_settings!(config, env)
+      config
+    end
+
+    def apply_environment_settings!(config, env)
+      environments = parse_enabled_environments(env["BUGSAGE_ENABLED_ENVIRONMENTS"])
+      return if environments.empty?
+
+      config.enabled_environments = environments
+    end
+
+    def apply_ai_settings!(config, env)
+      return if config.ai_enabled == false
+
+      credentials = detect_api_credentials(env)
+      return if credentials.nil?
+
+      config.ai_enabled = true if config.ai_enabled.nil?
+      config.ai_provider ||= credentials[:provider]
+
+      assign_api_key!(config, credentials)
+    end
+
+    def detect_api_credentials(env = ENV)
+      API_KEY_ENV_VARS.each do |provider, names|
+        names.each do |name|
+          key = env[name].to_s.strip
+          next if key.empty?
+
+          return { provider: normalize_provider(key, provider), key: key, source: name }
+        end
+      end
+
+      nil
+    end
+
+    def summary(config = Bugsage.configuration, env: ENV)
+      credentials = detect_api_credentials(env)
+      environments = Array(config.enabled_environments).join(", ")
+
+      lines = [
+        "BugSage is ready to use.",
+        "Enabled environments: #{environments}",
+        "Error page: #{enabled_label(config.show_error_page?("development"))}",
+        "Dashboard (/bugsage): #{enabled_label(config.show_dashboard?("development"))}",
+        "Inline console: #{enabled_label(config.show_inline_console?("development"))}"
+      ]
+
+      if credentials
+        lines << "AI provider: #{config.resolved_ai_provider} (from #{credentials[:source]})"
+        lines << "AI suggestions: #{enabled_label(config.ai_enabled?("development"))}"
+      else
+        lines << "AI suggestions: off (set OPENAI_API_KEY or CURSOR_API_KEY to enable)"
+      end
+
+      lines
+    end
+
+    def enabled_label(value)
+      value ? "enabled" : "disabled"
+    end
+
+    def parse_enabled_environments(raw)
+      return [] if raw.to_s.strip.empty?
+
+      raw.split(",").map { |name| name.strip.downcase.to_sym }.reject(&:empty?)
+    end
+
+    def normalize_provider(key, provider)
+      return :cursor if key.start_with?("crsr_")
+
+      provider
+    end
+
+    def assign_api_key!(config, credentials)
+      case credentials[:provider]
+      when :cursor
+        config.cursor_api_key ||= credentials[:key]
+      else
+        config.openai_api_key ||= credentials[:key]
+      end
+    end
+  end
+end

data/lib/bugsage/cli.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "thor"
+require "fileutils"
+
+module Bugsage
+  class CLI < Thor
+    desc "version", "Print BugSage version"
+    def version
+      puts "BugSage v#{Bugsage::VERSION}"
+    end
+
+    desc "hello", "Sanity check command"
+    def hello
+      puts "BugSage is alive."
+    end
+
+    desc "install", "Print install steps and generate config/initializers/bugsage.rb"
+    option :destination, aliases: "-d", desc: "Rails app root directory"
+    option :force, type: :boolean, default: false, desc: "Overwrite an existing initializer"
+    option :guide_only, type: :boolean, default: false, desc: "Print installation steps without writing files"
+    def install
+      if options[:guide_only]
+        Installation.print_guide
+        return
+      end
+
+      Installation.print_guide
+      say ""
+
+      result = Installer.run(destination: options[:destination] || Dir.pwd, force: options[:force])
+
+      if result[:created_initializer]
+        say "Created #{result[:initializer_path]}", :green
+      else
+        say "Skipped #{result[:initializer_path]} (already exists). Use --force to overwrite.", :yellow
+      end
+
+      say "\n#{result[:summary].join("\n")}\n"
+    end
+
+    desc "explain", "Run a fake exception through the rule engine (demo)"
+    def explain
+      fake_exception = begin
+        nil.foo
+      rescue NoMethodError => e
+        e
+      end
+
+      suggestion = Rule.match(fake_exception)
+
+      if suggestion
+        Formatter.print(suggestion)
+      else
+        puts "No matching rule found."
+      end
+    end
+  end
+end

data/lib/bugsage/code_context.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require "cgi"
+
+module Bugsage
+  module CodeContext
+    module_function
+
+    def extract_location(location)
+      return [nil, nil] unless location
+
+      match = location.match(/^(.+):(\d+)/)
+      return [match[1], match[2].to_i] if match
+
+      [location, nil]
+    end
+
+    def render_code_context(file_path, line_number)
+      return "" unless file_path && line_number
+
+      lines = read_file_lines(file_path)
+      return "" unless lines
+
+      context_range = 5
+      start_line = [line_number - context_range, 1].max
+      end_line = [line_number + context_range, lines.length].min
+
+      code_html = ""
+      (start_line..end_line).each do |num|
+        is_error_line = num == line_number
+        line_content = lines[num - 1] || ""
+        error_class = is_error_line ? " error" : ""
+
+        code_html += "<div class=\"code-line#{error_class}\">"
+        code_html += "<div class=\"code-line-number\">#{num}</div>"
+        code_html += "<div class=\"code-line-content\">#{escape_html(line_content)}</div>"
+        code_html += "</div>"
+      end
+
+      <<~HTML
+        <div class="code-section">
+          <div class="code-header">#{escape_html(file_path)}</div>
+          <div class="code-block">
+            #{code_html}
+          </div>
+        </div>
+      HTML
+    end
+
+    def numbered_source(file_path, line_number, context_range: 20)
+      lines = read_file_lines(file_path)
+      return nil unless lines
+
+      start_line = [line_number - context_range, 1].max
+      end_line = [line_number + context_range, lines.length].min
+      source = (start_line..end_line).map do |num|
+        marker = num == line_number ? ">>" : "  "
+        "#{marker} #{num.to_s.rjust(4)} | #{lines[num - 1]}"
+      end.join("\n")
+
+      {
+        start_line: start_line,
+        end_line: end_line,
+        error_line: line_number,
+        source: source
+      }
+    end
+
+    def read_file_lines(file_path)
+      return nil unless file_path && File.exist?(file_path)
+
+      File.readlines(file_path, chomp: true)
+    rescue StandardError
+      nil
+    end
+
+    def escape_html(value)
+      CGI.escapeHTML(value.to_s)
+    end
+  end
+end

data/lib/bugsage/code_patch.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+module Bugsage
+  class CodePatch
+    ACTIONS = %w[replace_lines delete_lines insert_before no_change].freeze
+
+    attr_reader :action, :start_line, :end_line, :replacement
+
+    def initialize(action:, start_line:, end_line: nil, replacement: "")
+      @action = normalize_action(action)
+      @start_line = start_line.to_i
+      @end_line = (end_line || start_line).to_i
+      @replacement = replacement.to_s
+    end
+
+    def self.from_ai(payload, error_line:)
+      patch = payload["code_patch"]
+      return from_legacy(payload["code_fix"], error_line) if patch.nil? || patch.empty?
+
+      new(
+        action: patch["action"],
+        start_line: patch["start_line"] || error_line,
+        end_line: patch["end_line"] || patch["start_line"] || error_line,
+        replacement: patch["replacement"]
+      )
+    end
+
+    def self.from_legacy(code_fix, error_line)
+      text = code_fix.to_s.strip
+      return nil if text.empty?
+
+      new(action: "replace_lines", start_line: error_line, end_line: error_line, replacement: text)
+    end
+
+    def self.preview_for(patch)
+      return nil if patch.nil?
+
+      instance = patch.is_a?(self) ? patch : from_hash(patch)
+      instance&.preview
+    end
+
+    def self.from_hash(hash)
+      return nil if hash.nil? || hash.empty?
+
+      new(
+        action: hash[:action] || hash["action"],
+        start_line: hash[:start_line] || hash["start_line"],
+        end_line: hash[:end_line] || hash["end_line"],
+        replacement: hash[:replacement] || hash["replacement"]
+      )
+    end
+
+    def apply!(lines)
+      validate_range!(lines)
+
+      case action
+      when "no_change"
+        nil
+      when "delete_lines"
+        delete_lines!(lines)
+      when "insert_before"
+        insert_before!(lines)
+      else
+        replace_lines!(lines)
+      end
+    end
+
+    def preview
+      case action
+      when "no_change"
+        Bugsage.t("code_patch.no_change")
+      when "delete_lines"
+        if start_line == end_line
+          Bugsage.t("code_patch.delete_line", line: start_line)
+        else
+          Bugsage.t("code_patch.delete_lines", start_line: start_line, end_line: end_line)
+        end
+      when "insert_before"
+        Bugsage.t("code_patch.insert_before", line: start_line, replacement: replacement)
+      else
+        if start_line == end_line
+          Bugsage.t("code_patch.replace_line", line: start_line, replacement: replacement)
+        else
+          Bugsage.t("code_patch.replace_lines", start_line: start_line, end_line: end_line, replacement: replacement)
+        end
+      end
+    end
+
+    def duplicates_existing?(lines)
+      return false if %w[delete_lines no_change].include?(action)
+      return true if replacement.strip.empty?
+
+      normalized = normalize_line(replacement)
+      lines.any? { |line| normalize_line(line) == normalized }
+    end
+
+    def to_h
+      {
+        action: action,
+        start_line: start_line,
+        end_line: end_line,
+        replacement: replacement
+      }
+    end
+
+    private
+
+    def normalize_action(value)
+      action = value.to_s.strip
+      ACTIONS.include?(action) ? action : "replace_lines"
+    end
+
+    def validate_range!(lines)
+      raise Bugsage::Error, Bugsage.t("code_patch.invalid_line_range") if start_line < 1 || end_line < start_line
+      raise Bugsage::Error, Bugsage.t("code_patch.patch_ends_after_file_end") if end_line > lines.length
+    end
+
+    def replace_lines!(lines)
+      indent = lines[start_line - 1].to_s[/\A(\s*)/, 1] || ""
+      delete_lines!(lines)
+      return if replacement.strip.empty?
+
+      lines.insert(start_line - 1, *indented_replacement_lines(indent))
+    end
+
+    def insert_before!(lines)
+      indent = lines[start_line - 1].to_s[/\A(\s*)/, 1] || ""
+      lines.insert(start_line - 1, *indented_replacement_lines(indent))
+    end
+
+    def delete_lines!(lines)
+      lines.slice!(start_line - 1, end_line - start_line + 1)
+    end
+
+    def replacement_lines
+      replacement.lines(chomp: true)
+    end
+
+    def indented_replacement_lines(indent)
+      replacement_lines.map { |line| line.empty? ? line : "#{indent}#{line.lstrip}" }
+    end
+
+    def normalize_line(line)
+      line.to_s.strip.gsub(/\s+/, " ")
+    end
+  end
+end

data/lib/bugsage/configuration.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module Bugsage
+  class Configuration
+    AI_PROVIDERS = %i[openai cursor].freeze
+
+    attr_accessor :enabled_environments,
+                  :show_error_page,
+                  :show_dashboard,
+                  :show_inline_console,
+                  :capture_errors,
+                  :capture_http_errors,
+                  :ai_enabled,
+                  :ai_provider,
+                  :openai_api_key,
+                  :openai_model,
+                  :openai_api_base,
+                  :cursor_api_key,
+                  :cursor_model,
+                  :cursor_api_base,
+                  :ai_timeout,
+                  :ai_client,
+                  :fallback_exceptions_app
+
+    def initialize
+      @enabled_environments = %i[development test]
+      @show_error_page = nil
+      @show_dashboard = nil
+      @show_inline_console = nil
+      @capture_errors = true
+      @capture_http_errors = true
+      @ai_enabled = nil
+      @ai_provider = nil
+      @openai_api_key = nil
+      @openai_model = "gpt-4o-mini"
+      @openai_api_base = "https://api.openai.com/v1"
+      @cursor_api_key = nil
+      @cursor_model = nil
+      @cursor_api_base = "https://api.cursor.com"
+      @ai_timeout = 15
+      @ai_client = nil
+      @fallback_exceptions_app = nil
+    end
+
+    def enabled?(environment = current_environment)
+      environment_names.include?(environment.to_s)
+    end
+
+    def show_error_page?(environment = current_environment)
+      return show_error_page unless show_error_page.nil?
+
+      environment.to_s == "development"
+    end
+
+    def show_dashboard?(environment = current_environment)
+      return show_dashboard unless show_dashboard.nil?
+
+      environment.to_s == "development"
+    end
+
+    def show_inline_console?(environment = current_environment)
+      return show_inline_console unless show_inline_console.nil?
+
+      environment.to_s == "development"
+    end
+
+    def capture_errors?(environment = current_environment)
+      return false unless enabled?(environment)
+
+      capture_errors
+    end
+
+    def capture_http_errors?(environment = current_environment)
+      return false unless capture_errors?(environment)
+
+      capture_http_errors != false
+    end
+
+    def ai_enabled?(environment = current_environment)
+      return false unless enabled?(environment)
+      return ai_enabled unless ai_enabled.nil?
+
+      credential_available?
+    end
+
+    def credential_available?
+      !resolved_openai_api_key.to_s.strip.empty? || !resolved_cursor_api_key.to_s.strip.empty?
+    end
+
+    def ai_configured?(environment = current_environment)
+      return false unless ai_enabled?(environment)
+
+      return true unless ai_client.nil?
+
+      case resolved_ai_provider
+      when :cursor
+        !resolved_cursor_api_key.to_s.strip.empty?
+      else
+        !resolved_openai_api_key.to_s.strip.empty?
+      end
+    end
+
+    def resolved_ai_provider
+      provider = ai_provider&.to_sym
+      return provider if provider && AI_PROVIDERS.include?(provider)
+
+      return :cursor if resolved_cursor_api_key.to_s.start_with?("crsr_")
+
+      :openai
+    end
+
+    def resolved_openai_api_key
+      key = openai_api_key || ENV["OPENAI_API_KEY"] || ENV.fetch("BUGSAGE_OPENAI_API_KEY", nil)
+      return nil if key.to_s.start_with?("crsr_")
+
+      key
+    end
+
+    def resolved_cursor_api_key
+      explicit = cursor_api_key || ENV["CURSOR_API_KEY"] || ENV.fetch("BUGSAGE_CURSOR_API_KEY", nil)
+      return explicit if explicit.to_s.start_with?("crsr_")
+
+      misrouted = openai_api_key || ENV["OPENAI_API_KEY"] || ENV.fetch("BUGSAGE_OPENAI_API_KEY", nil)
+      return misrouted if misrouted.to_s.start_with?("crsr_")
+
+      explicit
+    end
+
+    def effective_ai_timeout
+      return [ai_timeout, 90].max if resolved_ai_provider == :cursor
+
+      ai_timeout
+    end
+
+    def current_environment
+      if defined?(Rails) && Rails.respond_to?(:env)
+        Rails.env.to_s
+      else
+        ENV.fetch("RAILS_ENV", ENV.fetch("RACK_ENV", "development"))
+      end
+    end
+
+    private
+
+    def environment_names
+      Array(enabled_environments).map(&:to_s)
+    end
+  end
+end

data/lib/bugsage/console_context.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Bugsage
+  module ConsoleContext
+    module_function
+
+    def set(exception:, context:)
+      @exception = exception
+      @context = context || {}
+    end
+
+    def load_from_event(event)
+      return false unless event
+
+      klass = safe_constantize(event[:exception_class])
+      message = event[:exception_message].to_s
+      message = event[:root_cause].to_s if message.empty?
+
+      set(
+        exception: klass.new(message),
+        context: event[:context] || {}
+      )
+      true
+    end
+
+    def clear!
+      @exception = nil
+      @context = {}
+    end
+
+    def binding_for_eval
+      exception = @exception
+      request_context = @context || {}
+      params = request_context["Request parameters"] || request_context["Path parameters"] || {}
+
+      binding
+    end
+
+    def available?
+      !@exception.nil?
+    end
+
+    def safe_constantize(name)
+      return StandardError if name.to_s.strip.empty?
+
+      Object.const_get(name)
+    rescue NameError
+      StandardError
+    end
+  end
+end