bugsage 0.2.0

data/lib/bugsage/http_error_capture.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Bugsage
+  module HttpErrorCapture
+    module_function
+
+    def capture?(status, env)
+      return false unless status.to_i >= 400
+      return false if bugsage_path?(env)
+      return false if ExceptionSupport.extract(env)
+
+      true
+    end
+
+    def build_exception(env, status, body)
+      body_text = body.to_s.strip
+      location = location_for(env)
+      message = build_message(status, body_text, location)
+
+      HttpResponseError.new(
+        status: status.to_i,
+        message: message,
+        response_body: body_text.empty? ? nil : body_text,
+        location: location
+      )
+    end
+
+    def location_for(env)
+      params = env["action_dispatch.request.path_parameters"]
+      return Bugsage.t("common.unknown") unless params.is_a?(Hash)
+
+      controller = params[:controller] || params["controller"]
+      action = params[:action] || params["action"]
+      return Bugsage.t("common.unknown") if controller.to_s.strip.empty?
+
+      "#{format_controller_name(controller)}Controller##{action}"
+    end
+
+    def format_controller_name(controller)
+      controller.to_s.split("/").map do |segment|
+        segment.split("_").map(&:capitalize).join
+      end.join("::")
+    end
+
+    def build_message(status, body, location)
+      status_label = http_status_label(status)
+      detail = extract_detail(body)
+      base = Bugsage.t("http_errors.message.base", status: status, status_label: status_label)
+      unknown = Bugsage.t("common.unknown")
+      base += Bugsage.t("http_errors.message.at_location", location: location) unless location == unknown
+      detail.empty? ? base : "#{base}#{Bugsage.t("http_errors.message.with_detail", detail: detail)}"
+    end
+
+    def extract_detail(body)
+      return "" if body.to_s.strip.empty?
+
+      payload = JSON.parse(body)
+      return body.strip unless payload.is_a?(Hash)
+
+      detail = payload["error"] || payload["message"] || payload["errors"]
+      case detail
+      when String
+        detail.strip
+      when Hash
+        detail.map { |key, value| "#{key}: #{value}" }.join(", ")
+      when Array
+        detail.join(", ")
+      else
+        body.strip
+      end
+    rescue JSON::ParserError
+      body.strip
+    end
+
+    def bugsage_path?(env)
+      path = env["PATH_INFO"].to_s
+      path.start_with?("/bugsage")
+    end
+
+    def http_status_label(status)
+      if defined?(Rack::Utils)
+        Rack::Utils::HTTP_STATUS_CODES[status.to_i] || Bugsage.t("http_errors.status_label_fallback", status: status)
+      else
+        Bugsage.t("http_errors.status_label_fallback", status: status)
+      end
+    end
+
+    def fixes_for_status(status)
+      fixes = Bugsage.t("http_errors.fixes.#{status.to_i}", default: nil)
+      fixes = Bugsage.t("http_errors.fixes.default", default: nil) if fixes.nil?
+      Array(fixes)
+    end
+
+    def confidence_for_status(status)
+      case status.to_i
+      when 400, 401, 422 then 86
+      when 403, 404 then 84
+      else 80
+      end
+    end
+  end
+end

data/lib/bugsage/http_response_error.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Bugsage
+  class HttpResponseError < StandardError
+    attr_reader :status, :response_body, :location
+
+    def initialize(status:, message:, response_body: nil, location: nil)
+      @status = status
+      @response_body = response_body
+      @location = location
+      super(message)
+    end
+  end
+end

data/lib/bugsage/inline_console.rb

@@ -0,0 +1,226 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Bugsage
+  class InlineConsole
+    extend JsonEndpoint
+
+    def self.evaluate(code)
+      return error_response("Console is not available for this error.") unless ConsoleContext.available?
+
+      stripped = code.to_s.strip
+      return error_response("Enter a Ruby expression to evaluate.") if stripped.empty?
+
+      binding = ConsoleContext.binding_for_eval
+      result = eval(stripped, binding, "(bugsage-console)", 1) # rubocop:disable Security/Eval
+
+      success_response(result)
+    rescue SyntaxError, StandardError => e
+      error_response(format_exception(e))
+    end
+
+    def self.handle_request(env)
+      return not_found unless Bugsage.configuration.show_inline_console?
+
+      payload = parse_request_body(env)
+      return json_response(error_response("Console is not available for this error.")) unless prepare_context!(payload)
+
+      response = evaluate(payload["code"])
+      json_response(response)
+    end
+
+    def self.prepare_context!(payload)
+      return true unless payload.key?("index")
+
+      load_context_for_index(payload["index"])
+    end
+
+    def self.load_context_for_index(index)
+      event = Store.all[index.to_i]
+      ConsoleContext.load_from_event(event)
+    end
+
+    def self.render_panel(bug_index: nil, include_script: true)
+      return "" unless Bugsage.configuration.show_inline_console?
+
+      suffix = bug_index.nil? ? "" : "-bug-#{bug_index}"
+      output_id = "bugsage-console-output#{suffix}"
+      input_id = "bugsage-console-input#{suffix}"
+      index_attr = bug_index.nil? ? "" : %( data-bug-index="#{bug_index}")
+
+      <<~HTML
+        <div class="section inline-console">
+          <div class="label">Inline Rails Console</div>
+          <p class="console-help">
+            Evaluate Ruby in the context of this error. Available locals:
+            <code>exception</code>, <code>request_context</code>, <code>params</code>
+          </p>
+          <form
+            class="console-form bugsage-console-form"
+            data-output-target="#{output_id}"
+            data-input-target="#{input_id}"#{index_attr}
+          >
+            <label class="console-prompt" for="#{input_id}">&gt;&gt;</label>
+            <input
+              id="#{input_id}"
+              class="console-input"
+              type="text"
+              name="code"
+              autocomplete="off"
+              spellcheck="false"
+              placeholder="exception.class"
+            />
+            <button type="submit" class="console-submit">Run</button>
+          </form>
+          <div id="#{output_id}" class="console-output" aria-live="polite"></div>
+        </div>
+        #{render_script if include_script}
+      HTML
+    end
+
+    def self.styles
+      <<~CSS
+        .inline-console {
+          background: #313244;
+          border: 1px solid #45475a;
+          border-radius: 8px;
+          padding: 16px;
+          margin-bottom: 20px;
+        }
+        .console-help {
+          color: #a6adc8;
+          font-size: 13px;
+          margin: 0 0 12px 0;
+        }
+        .console-help code {
+          color: #89b4fa;
+        }
+        .console-output {
+          background: #1e1e2e;
+          border: 1px solid #45475a;
+          border-radius: 6px;
+          min-height: 72px;
+          max-height: 260px;
+          overflow-y: auto;
+          padding: 12px;
+          margin-top: 12px;
+        }
+        .console-output:empty {
+          display: none;
+        }
+        .console-line {
+          white-space: pre-wrap;
+          margin-bottom: 6px;
+          font-size: 13px;
+        }
+        .console-line.input { color: #cdd6f4; }
+        .console-line.result { color: #a6e3a1; }
+        .console-line.error { color: #f38ba8; }
+        .console-form {
+          display: flex;
+          align-items: center;
+          gap: 8px;
+        }
+        .console-prompt {
+          color: #a6e3a1;
+          font-weight: bold;
+        }
+        .console-input {
+          flex: 1;
+          background: #1e1e2e;
+          color: #cdd6f4;
+          border: 1px solid #45475a;
+          border-radius: 6px;
+          padding: 10px 12px;
+          font-family: inherit;
+          font-size: 13px;
+        }
+        .console-input:focus {
+          outline: none;
+          border-color: #89b4fa;
+        }
+        .console-submit {
+          background: #89b4fa;
+          color: #1e1e2e;
+          border: 0;
+          border-radius: 6px;
+          padding: 10px 14px;
+          font-family: inherit;
+          font-size: 13px;
+          font-weight: bold;
+          cursor: pointer;
+        }
+      CSS
+    end
+
+    def self.render_script
+      <<~HTML
+        <script>
+          (function () {
+            if (window.__bugsageConsoleInitialized) return;
+            window.__bugsageConsoleInitialized = true;
+
+            function appendLine(output, text, type) {
+              var line = document.createElement("div");
+              line.className = "console-line" + (type ? " " + type : "");
+              line.textContent = text;
+              output.appendChild(line);
+              output.scrollTop = output.scrollHeight;
+            }
+
+            document.addEventListener("submit", function (event) {
+              var form = event.target;
+              if (!form.classList || !form.classList.contains("bugsage-console-form")) return;
+
+              event.preventDefault();
+              var input = document.getElementById(form.dataset.inputTarget);
+              var output = document.getElementById(form.dataset.outputTarget);
+              if (!input || !output) return;
+
+              var code = input.value.trim();
+              if (!code) return;
+
+              appendLine(output, ">> " + code, "input");
+              input.value = "";
+
+              var payload = { code: code };
+              if (form.dataset.bugIndex !== undefined) {
+                payload.index = parseInt(form.dataset.bugIndex, 10);
+              }
+
+              fetch("/bugsage/console", {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify(payload)
+              })
+                .then(function (response) { return response.json(); })
+                .then(function (result) {
+                  appendLine(output, result.output, result.ok ? "result" : "error");
+                })
+                .catch(function (error) {
+                  appendLine(output, error.message, "error");
+                });
+            });
+          })();
+        </script>
+      HTML
+    end
+
+    def self.success_response(result)
+      { ok: true, output: "=> #{format_value(result)}" }
+    end
+
+    def self.error_response(message)
+      { ok: false, output: message.to_s }
+    end
+
+    def self.format_value(value)
+      value.inspect
+    end
+
+    def self.format_exception(exception)
+      "#{exception.class}: #{exception.message}"
+    end
+  end
+end

data/lib/bugsage/installation.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Bugsage
+  # Single source of truth for installing BugSage in a Rails application.
+  # Referenced by the README, install generator, CLI, and initializer template.
+  module Installation
+    STEPS = [
+      {
+        title: "Add the gem to your Gemfile",
+        command: 'gem "bugsage"',
+        note: "Use a git/path source while developing locally if needed."
+      },
+      {
+        title: "Install dependencies",
+        command: "bundle install",
+        note: nil
+      },
+      {
+        title: "Start your Rails server",
+        command: "bin/rails server",
+        note: "BugSage auto-wires via Bugsage::Railtie — no routes.rb or middleware changes required."
+      },
+      {
+        title: "Trigger an error to verify",
+        command: "Visit any route that raises an exception in development.",
+        note: "You should see the BugSage error page instead of the default Rails page."
+      },
+      {
+        title: "Open the session dashboard (optional)",
+        command: "http://localhost:3000/bugsage",
+        note: "Lists all errors caught during the current server session."
+      }
+    ].freeze
+
+    OPTIONAL_STEPS = [
+      {
+        title: "Generate a commented initializer for custom overrides",
+        command: "bundle exec rails generate bugsage:install",
+        alternative: "bundle exec bugsage install"
+      },
+      {
+        title: "Enable AI-enhanced suggestions (optional)",
+        command: "export OPENAI_API_KEY=sk-your-key",
+        alternative: "export CURSOR_API_KEY=crsr_your-key",
+        note: "BugSage auto-detects the provider from the key prefix on boot."
+      },
+      {
+        title: "Control enabled environments (optional)",
+        command: "export BUGSAGE_ENABLED_ENVIRONMENTS=development,test,staging",
+        note: "Defaults to development and test."
+      }
+    ].freeze
+
+    AUTO_WIRED = [
+      "Exception capture middleware",
+      "BugSage HTML error pages in development",
+      "Session dashboard at /bugsage",
+      "Inline Rails console at /bugsage/console",
+      "Routing error capture via exceptions_app",
+      "AI provider auto-detection when API keys are present"
+    ].freeze
+
+    module_function
+
+    def guide_lines
+      lines = ["BugSage — Rails installation steps", ""]
+
+      STEPS.each_with_index do |step, index|
+        lines << "#{index + 1}. #{step[:title]}"
+        lines << "   #{step[:command]}"
+        lines << "   #{step[:note]}" if step[:note]
+        lines << ""
+      end
+
+      lines << "Optional:"
+      OPTIONAL_STEPS.each_with_index do |step, index|
+        lines << "#{index + 1}. #{step[:title]}"
+        lines << "   #{step[:command]}"
+        lines << "   or: #{step[:alternative]}" if step[:alternative]
+        lines << "   #{step[:note]}" if step[:note]
+        lines << ""
+      end
+
+      lines << "Auto-wired on boot (no manual setup):"
+      AUTO_WIRED.each { |item| lines << "  - #{item}" }
+
+      lines
+    end
+
+    def print_guide
+      guide_lines.each { |line| puts line }
+    end
+  end
+end

data/lib/bugsage/installer.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Bugsage
+  class Installer
+    INITIALIZER_PATH = "config/initializers/bugsage.rb"
+    TEMPLATE_PATH = File.expand_path("../../generators/bugsage/install/templates/bugsage.rb", __dir__)
+
+    def self.run(destination: Dir.pwd, force: false)
+      new(destination: destination, force: force).run
+    end
+
+    def initialize(destination:, force: false)
+      @destination = File.expand_path(destination)
+      @force = force
+    end
+
+    def run
+      validate_rails_app!
+
+      path = File.join(@destination, INITIALIZER_PATH)
+      created_initializer = write_initializer(path)
+      config = Bugsage::AutoConfigurator.apply!
+
+      {
+        initializer_path: path,
+        created_initializer: created_initializer,
+        summary: Bugsage::AutoConfigurator.summary(config)
+      }
+    end
+
+    private
+
+    def validate_rails_app!
+      application_file = File.join(@destination, "config/application.rb")
+      return if File.exist?(application_file)
+
+      raise Error, "Could not find a Rails app at #{@destination}. Run this from your app root."
+    end
+
+    def write_initializer(path)
+      return false if File.exist?(path) && !@force
+
+      FileUtils.mkdir_p(File.dirname(path))
+      File.write(path, initializer_template)
+      true
+    end
+
+    def initializer_template
+      if File.exist?(TEMPLATE_PATH)
+        File.read(TEMPLATE_PATH)
+      else
+        default_initializer_template
+      end
+    end
+
+    def default_initializer_template
+      <<~RUBY
+        # frozen_string_literal: true
+
+        # See Bugsage::Installation or run: bundle exec bugsage install --guide-only
+      RUBY
+    end
+  end
+end

data/lib/bugsage/json_endpoint.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Bugsage
+  # Shared Rack JSON helpers for BugSage HTTP endpoints.
+  # Extend on endpoint classes: `extend JsonEndpoint`
+  module JsonEndpoint
+    def parse_request_body(env)
+      body = env["rack.input"]
+      raw = body.respond_to?(:read) ? body.read : body.to_s
+      body.rewind if body.respond_to?(:rewind)
+
+      return {} if raw.to_s.strip.empty?
+
+      JSON.parse(raw)
+    rescue JSON::ParserError
+      {}
+    end
+
+    def json_response(payload = nil, status: 200, **attrs)
+      body = payload.nil? ? attrs : payload
+      [status, { "Content-Type" => "application/json" }, [JSON.generate(body)]]
+    end
+
+    def error_response(message)
+      { ok: false, error: message.to_s }
+    end
+
+    def not_found
+      [404, { "Content-Type" => "text/plain" }, [Bugsage.t("common.not_found")]]
+    end
+  end
+end