bugsage 0.2.0

data/lib/bugsage/page_actions.rb

@@ -0,0 +1,255 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Bugsage
+  module PageActions
+    module_function
+
+    def render_clear_button(label: Bugsage.t("ui.page_actions.clear_session_logs"))
+      <<~HTML
+        <button type="button" class="bugsage-clear-logs secondary-button">#{CodeContext.escape_html(label)}</button>
+      HTML
+    end
+
+    def render_fix_actions(location:, suffix: "", hidden: true)
+      editor = EditorLinks.for_location(location)
+      return "" if editor.empty?
+
+      hidden_class = hidden ? " hidden" : ""
+      location_attr = CodeContext.escape_html(location)
+
+      <<~HTML
+        <div class="fix-actions#{hidden_class}" id="bugsage-fix-actions#{suffix}" data-location="#{location_attr}">
+          <button type="button" class="secondary-button bugsage-open-editor" data-editor="cursor" data-url="#{CodeContext.escape_html(editor[:cursor])}">
+            #{CodeContext.escape_html(Bugsage.t("ui.page_actions.open_in_cursor"))}
+          </button>
+          <button type="button" class="secondary-button bugsage-open-editor" data-editor="vscode" data-url="#{CodeContext.escape_html(editor[:vscode])}">
+            #{CodeContext.escape_html(Bugsage.t("ui.page_actions.open_in_vscode"))}
+          </button>
+          <button type="button" class="secondary-button bugsage-copy-fix">#{CodeContext.escape_html(Bugsage.t("ui.page_actions.copy_fix"))}</button>
+          <button type="button" class="secondary-button bugsage-apply-fix">#{CodeContext.escape_html(Bugsage.t("ui.page_actions.apply_fix_to_file"))}</button>
+        </div>
+      HTML
+    end
+
+    def styles
+      <<~CSS
+        .page-actions {
+          display: flex;
+          justify-content: flex-end;
+          gap: 8px;
+          margin-bottom: 16px;
+        }
+        .fix-actions {
+          display: flex;
+          flex-wrap: wrap;
+          gap: 8px;
+          margin-top: 12px;
+        }
+        .fix-actions.hidden {
+          display: none;
+        }
+        .secondary-button {
+          background: #45475a;
+          color: #cdd6f4;
+          border: 1px solid #585869;
+          border-radius: 6px;
+          padding: 8px 12px;
+          font-family: inherit;
+          font-size: 12px;
+          font-weight: bold;
+          cursor: pointer;
+        }
+        .secondary-button:hover {
+          border-color: #89b4fa;
+          color: #89b4fa;
+        }
+        .bugsage-clear-logs {
+          background: rgba(243, 139, 168, 0.15);
+          border-color: #f38ba8;
+          color: #f5c2e7;
+        }
+      CSS
+    end
+
+    def render_script
+      empty_list_html = <<~HTML.strip.gsub("\n", "")
+        <div class="empty-list"><p>#{CodeContext.escape_html(Bugsage.t("ui.dashboard.empty_list_title"))}</p><p class="empty-hint">#{CodeContext.escape_html(Bugsage.t("ui.dashboard.empty_list_hint"))}</p></div>
+      HTML
+      empty_detail_html = <<~HTML.strip.gsub("\n", "")
+        <div class="detail-placeholder"><h2>#{CodeContext.escape_html(Bugsage.t("ui.dashboard.empty_detail_title"))}</h2><p>#{CodeContext.escape_html(Bugsage.t("ui.dashboard.empty_detail_body"))}</p></div>
+      HTML
+
+      <<~HTML
+        <script>
+          (function () {
+            if (window.__bugsagePageActionsInitialized) return;
+            window.__bugsagePageActionsInitialized = true;
+
+            var EMPTY_LIST_HTML = #{JSON.generate(empty_list_html)};
+            var EMPTY_DETAIL_HTML = #{JSON.generate(empty_detail_html)};
+            var CAUGHT_COUNT_ZERO = #{JSON.generate(Bugsage.t("ui.dashboard.caught_count", count: 0))};
+            var AVG_EMPTY = #{JSON.generate(Bugsage.t("ui.dashboard.avg_empty"))};
+            var CONFIRM_CLEAR = #{JSON.generate(Bugsage.t("ui.page_actions.confirm_clear"))};
+            var COULD_NOT_CLEAR = #{JSON.generate(Bugsage.t("ui.page_actions.could_not_clear"))};
+            var QUICK_FIX_TITLE = #{JSON.generate(Bugsage.t("ui.page_actions.quick_fix_title"))};
+            var QUICK_FIX_LOCATION = #{JSON.generate(Bugsage.t("ui.page_actions.quick_fix_location"))};
+            var QUICK_FIX_SUGGESTION = #{JSON.generate(Bugsage.t("ui.page_actions.quick_fix_suggestion"))};
+            var COPIED = #{JSON.generate(Bugsage.t("ui.page_actions.copied"))};
+            var COPY_FIX = #{JSON.generate(Bugsage.t("ui.page_actions.copy_fix"))};
+            var CONFIRM_APPLY = #{JSON.generate(Bugsage.t("ui.page_actions.confirm_apply"))};
+            var APPLYING = #{JSON.generate(Bugsage.t("ui.page_actions.applying"))};
+            var COULD_NOT_APPLY = #{JSON.generate(Bugsage.t("ui.page_actions.could_not_apply"))};
+            var APPLIED = #{JSON.generate(Bugsage.t("ui.page_actions.applied"))};
+
+            function selectedFixText(actions) {
+              var panel = actions.closest(".bug-detail, .container");
+              if (!panel) return "";
+
+              var activeFix = panel.querySelector(".fixes li.selected, .fixes li");
+              return activeFix ? activeFix.textContent.trim() : "";
+            }
+
+            function clipboardCopy(text) {
+              if (navigator.clipboard && navigator.clipboard.writeText) {
+                return navigator.clipboard.writeText(text);
+              }
+
+              var area = document.createElement("textarea");
+              area.value = text;
+              document.body.appendChild(area);
+              area.select();
+              document.execCommand("copy");
+              document.body.removeChild(area);
+              return Promise.resolve();
+            }
+
+            function clearDashboardUi() {
+              var bugList = document.querySelector(".bug-list");
+              var detailPanel = document.querySelector(".detail-panel");
+              var clearButton = document.querySelector(".bugsage-clear-logs");
+              var statPills = document.querySelectorAll(".sidebar-stats .stat-pill");
+
+              if (bugList) {
+                bugList.innerHTML = EMPTY_LIST_HTML;
+              }
+
+              if (detailPanel) {
+                detailPanel.innerHTML = EMPTY_DETAIL_HTML;
+              }
+
+              if (statPills[0]) statPills[0].textContent = CAUGHT_COUNT_ZERO;
+              if (statPills[1]) statPills[1].textContent = AVG_EMPTY;
+              if (clearButton) clearButton.hidden = true;
+            }
+
+            function openEditorUrl(url) {
+              var link = document.createElement("a");
+              link.href = url;
+              link.rel = "noopener";
+              link.style.display = "none";
+              document.body.appendChild(link);
+              link.click();
+              document.body.removeChild(link);
+            }
+
+            document.addEventListener("click", function (event) {
+              var clearButton = event.target.closest(".bugsage-clear-logs");
+              if (clearButton) {
+                event.preventDefault();
+                if (!window.confirm(CONFIRM_CLEAR)) return;
+
+                clearButton.disabled = true;
+                fetch("#{SessionClear::ENDPOINT}", {
+                  method: "POST",
+                  headers: { "Content-Type": "application/json", "Accept": "application/json" }
+                })
+                  .then(function (response) { return response.json(); })
+                  .then(function () { clearDashboardUi(); })
+                  .catch(function (error) {
+                    clearButton.disabled = false;
+                    window.alert(error.message || COULD_NOT_CLEAR);
+                  });
+                return;
+              }
+
+              var openButton = event.target.closest(".bugsage-open-editor");
+              if (openButton) {
+                event.preventDefault();
+                var url = openButton.dataset.url;
+                if (url) openEditorUrl(url);
+                return;
+              }
+
+              var copyButton = event.target.closest(".bugsage-copy-fix");
+              if (copyButton) {
+                var actions = copyButton.closest(".fix-actions");
+                var fix = selectedFixText(actions);
+                var location = actions.dataset.location || "";
+                var prompt = [
+                  QUICK_FIX_TITLE,
+                  QUICK_FIX_LOCATION.replace("%{location}", location),
+                  QUICK_FIX_SUGGESTION.replace("%{fix}", fix)
+                ].join("\\n");
+                clipboardCopy(prompt).then(function () {
+                  copyButton.textContent = COPIED;
+                  setTimeout(function () { copyButton.textContent = COPY_FIX; }, 1500);
+                });
+                return;
+              }
+
+              var applyButton = event.target.closest(".bugsage-apply-fix");
+              if (applyButton) {
+                event.preventDefault();
+                var actionBar = applyButton.closest(".fix-actions");
+                var fixText = selectedFixText(actionBar);
+                var fixLocation = actionBar.dataset.location || "";
+                if (!fixText) return;
+                if (!window.confirm(CONFIRM_APPLY)) return;
+
+                var originalText = applyButton.textContent;
+                applyButton.disabled = true;
+                applyButton.textContent = APPLYING;
+                fetch("#{FixApplicator::ENDPOINT}", {
+                  method: "POST",
+                  headers: { "Content-Type": "application/json" },
+                  body: JSON.stringify({ location: fixLocation, fix: fixText })
+                })
+                  .then(function (response) { return response.json(); })
+                  .then(function (result) {
+                    applyButton.disabled = false;
+                    applyButton.textContent = originalText;
+                    if (!result.ok) {
+                      window.alert(result.error || COULD_NOT_APPLY);
+                      return;
+                    }
+
+                    applyButton.textContent = APPLIED;
+                    setTimeout(function () { applyButton.textContent = originalText; }, 2000);
+                  })
+                  .catch(function (error) {
+                    applyButton.disabled = false;
+                    applyButton.textContent = originalText;
+                    window.alert(error.message);
+                  });
+              }
+            });
+
+            document.addEventListener("click", function (event) {
+              var fixItem = event.target.closest(".fixes li");
+              if (!fixItem) return;
+
+              var panel = fixItem.closest(".bug-detail, .container");
+              if (!panel) return;
+
+              panel.querySelectorAll(".fixes li").forEach(function (item) {
+                item.classList.toggle("selected", item === fixItem);
+              });
+            });
+          })();
+        </script>
+      HTML
+    end
+  end
+end

data/lib/bugsage/railtie.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+# BugSage Rails integration.
+#
+# Installation (zero-config):
+#   1. gem "bugsage" in Gemfile
+#   2. bundle install
+#   3. bin/rails server
+#
+# See Bugsage::Installation for the full guide.
+module Bugsage
+  class Railtie < Rails::Railtie
+    config.bugsage = ActiveSupport::OrderedOptions.new
+
+    initializer "bugsage.configuration" do |app|
+      Bugsage.configure do |bugsage_config|
+        if app.config.bugsage.respond_to?(:each_pair)
+          app.config.bugsage.each_pair do |key, value|
+            bugsage_config.public_send("#{key}=", value) if bugsage_config.respond_to?("#{key}=")
+          end
+        end
+      end
+
+      Bugsage::AutoConfigurator.apply!
+    end
+
+    initializer "bugsage.i18n" do
+      Bugsage::Translations.load!
+    end
+
+    initializer "bugsage.middleware" do |app|
+      app.config.middleware.use Bugsage::Middleware
+    end
+
+    initializer "bugsage.exceptions_app" do |app|
+      Bugsage.configuration.fallback_exceptions_app ||= app.config.exceptions_app
+      app.config.exceptions_app = Bugsage::ExceptionsApp
+    end
+
+    initializer "bugsage.debug_interceptor" do
+      ActionDispatch::DebugExceptions.register_interceptor do |request, exception|
+        next unless Bugsage.configuration.enabled?
+        next unless Bugsage.configuration.capture_errors?
+
+        Bugsage::ExceptionHandler.store_exception(request.env, exception)
+      end
+    end
+  end
+end

data/lib/bugsage/request_context.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Bugsage
+  # Builds a labeled Rails request context hash from a Rack env.
+  module RequestContext
+    class << self
+      def from_env(env)
+        return {} unless env.is_a?(Hash)
+
+        {
+          Bugsage.t("context.request_method") => env["REQUEST_METHOD"],
+          Bugsage.t("context.path") => env["PATH_INFO"],
+          Bugsage.t("context.query_string") => env["QUERY_STRING"],
+          Bugsage.t("context.host") => env["HTTP_HOST"] || env["SERVER_NAME"],
+          Bugsage.t("context.request_id") => env["action_dispatch.request_id"] || env["HTTP_X_REQUEST_ID"],
+          Bugsage.t("context.controller") => path_parameter_value(env, "controller"),
+          Bugsage.t("context.action") => path_parameter_value(env, "action"),
+          Bugsage.t("context.path_parameters") => path_parameters(env),
+          Bugsage.t("context.request_parameters") => request_parameters(env),
+          Bugsage.t("context.query_parameters") => query_parameters(env),
+          Bugsage.t("context.form_parameters") => form_parameters(env),
+          Bugsage.t("context.user_agent") => env["HTTP_USER_AGENT"]
+        }.compact.reject { |_, value| blank?(value) }
+      end
+
+      private
+
+      def path_parameter_value(env, key)
+        params = path_parameters(env)
+        return nil unless params.is_a?(Hash)
+
+        params[key.to_s] || params[key.to_sym]
+      end
+
+      def path_parameters(env)
+        env["action_dispatch.request.path_parameters"]
+      end
+
+      def request_parameters(env)
+        env["action_dispatch.request.parameters"]
+      end
+
+      def query_parameters(env)
+        env["action_dispatch.request.query_parameters"]
+      end
+
+      def form_parameters(env)
+        env["action_dispatch.request.form_parameters"]
+      end
+
+      def blank?(value)
+        value.respond_to?(:empty?) ? value.empty? : value.nil? || value == ""
+      end
+    end
+  end
+end

data/lib/bugsage/rule.rb

@@ -0,0 +1,271 @@
+# frozen_string_literal: true
+
+module Bugsage
+  class Rule
+    # Ordering matters: more specific classes must be listed before their
+    # parents because matching walks the exception's ancestor chain.
+    MATCHERS = [
+      { classes: ["ActionController::RoutingError"], message: /No route matches/i, handler: :match_routing_error },
+      { classes: ["NoMethodError"], handler: :match_no_method_error },
+      { classes: ["ActiveRecord::RecordNotFound"], handler: :match_record_not_found },
+      { classes: ["ActionController::ParameterMissing"], handler: :match_parameter_missing },
+      { classes: ["ActionController::UnpermittedParameters"], handler: :match_unpermitted_parameters },
+      { classes: ["ActionController::BadRequest"], handler: :match_bad_request },
+      { classes: ["Bugsage::HttpResponseError"], handler: :match_http_response_error },
+      { classes: ["ActionController::InvalidAuthenticityToken"], handler: :match_invalid_authenticity_token },
+      { classes: ["ActionDispatch::Http::Parameters::ParseError"], handler: :match_parse_error },
+      { classes: ["ActiveJob::DeserializationError"], handler: :match_deserialization_error },
+      { classes: ["ActionView::Template::Error"], handler: :match_template_error },
+      { classes: ["ActionController::MissingExactTemplate"], handler: :match_missing_exact_template },
+      { classes: ["ActionController::UnknownFormat"], handler: :match_unknown_format },
+      { classes: ["ActionController::InvalidCrossOriginRequest"], handler: :match_invalid_cross_origin_request },
+      { classes: ["ActionDispatch::Flash::FlashError"], handler: :match_flash_error },
+      { classes: ["ActiveStorage::FileNotFoundError"], handler: :match_active_storage_error },
+      { classes: ["ActiveStorage::IntegrityError"], handler: :match_active_storage_integrity_error },
+      { classes: ["ActiveSupport::MessageVerifier::InvalidSignature"], handler: :match_invalid_signature },
+      # Database — specific violations before the generic StatementInvalid.
+      { classes: ["ActiveRecord::RecordNotUnique"], handler: :match_record_not_unique },
+      { classes: ["ActiveRecord::NotNullViolation"], handler: :match_not_null_violation },
+      { classes: ["ActiveRecord::StatementInvalid"], handler: :match_statement_invalid },
+      { classes: ["ActiveRecord::ConnectionNotEstablished"], handler: :match_connection_not_established },
+      { classes: ["ActiveRecord::StaleObjectError"], handler: :match_stale_object },
+      { classes: ["ActiveRecord::RecordInvalid"], handler: :match_record_invalid },
+      { classes: ["PG::Error"], handler: :match_pg_error },
+      { classes: ["Redis::BaseError"], handler: :match_redis_error },
+      { classes: ["Faraday::Error"], handler: :match_faraday_error },
+      # Ruby core — NoMethodError (above) is a subclass of NameError, so it wins first.
+      { classes: ["NameError"], handler: :match_name_error },
+      { classes: ["KeyError"], handler: :match_key_error },
+      { classes: ["ArgumentError"], handler: :match_argument_error },
+      { classes: ["TypeError"], handler: :match_type_error },
+      { classes: ["ZeroDivisionError"], handler: :match_zero_division_error },
+      { classes: ["JSON::ParserError"], handler: :match_json_parse_error },
+      { classes: ["Net::OpenTimeout", "Net::ReadTimeout", "Timeout::Error"],
+        message: /timed out|timeout|execution expired/i, handler: :match_timeout_error },
+      { classes: ["FrozenError"], handler: :match_frozen_error },
+      { classes: ["RuntimeError"], handler: :match_runtime_error }
+    ].freeze
+
+    def self.match(exception)
+      exception = ExceptionSupport.unwrap(exception)
+      return nil unless exception.is_a?(Exception)
+
+      handler = matcher_for(exception)
+      send(handler, exception)
+    end
+
+    def self.matcher_for(exception)
+      definition = MATCHERS.find { |matcher| matches_definition?(exception, matcher) }
+      definition&.fetch(:handler) || :match_generic_exception
+    end
+
+    def self.matches_definition?(exception, definition)
+      return true if definition[:classes]&.any? { |class_name| ExceptionSupport.matches_class?(exception, class_name) }
+
+      return true if definition[:message] && ExceptionSupport.message_matches?(exception, definition[:message])
+
+      false
+    end
+
+    def self.rule_fixes(key)
+      Array(Bugsage.t("rules.#{key}.fixes"))
+    end
+
+    def self.rule_issue(key, exception)
+      issue = Bugsage.t("rules.#{key}.issue", default: nil)
+      return issue if issue
+
+      class_name = exception.class.name.to_s
+      return class_name unless class_name.empty?
+
+      Bugsage.t("rules.#{key}.issue_fallback", default: class_name)
+    end
+
+    def self.from_rule(key, exception, confidence:, root_cause: nil)
+      build_suggestion(
+        exception: exception,
+        issue: rule_issue(key, exception),
+        root_cause: root_cause.nil? ? exception.message : root_cause,
+        fixes: rule_fixes(key),
+        confidence: confidence
+      )
+    end
+
+    def self.match_no_method_error(exception)
+      root_cause = if exception.message.to_s.empty?
+                     Bugsage.t("rules.no_method_error.root_cause_default")
+                   else
+                     exception.message
+                   end
+      from_rule(:no_method_error, exception, confidence: 95, root_cause: root_cause)
+    end
+
+    def self.match_record_not_found(exception)
+      from_rule(:record_not_found, exception, confidence: 90)
+    end
+
+    def self.match_routing_error(exception)
+      from_rule(:routing_error, exception, confidence: 92)
+    end
+
+    def self.match_parameter_missing(exception)
+      from_rule(:parameter_missing, exception, confidence: 91)
+    end
+
+    def self.match_unpermitted_parameters(exception)
+      from_rule(:unpermitted_parameters, exception, confidence: 90)
+    end
+
+    def self.match_bad_request(exception)
+      from_rule(:bad_request, exception, confidence: 88)
+    end
+
+    def self.match_http_response_error(exception)
+      status = exception.status
+      build_suggestion(
+        exception: exception,
+        issue: Bugsage.t("http_errors.issue", status: status),
+        root_cause: exception.message,
+        fixes: HttpErrorCapture.fixes_for_status(status),
+        confidence: HttpErrorCapture.confidence_for_status(status)
+      )
+    end
+
+    def self.match_invalid_authenticity_token(exception)
+      from_rule(:invalid_authenticity_token, exception, confidence: 91)
+    end
+
+    def self.match_parse_error(exception)
+      from_rule(:parse_error, exception, confidence: 88)
+    end
+
+    def self.match_deserialization_error(exception)
+      from_rule(:deserialization_error, exception, confidence: 87)
+    end
+
+    def self.match_template_error(exception)
+      from_rule(:template_error, exception, confidence: 88)
+    end
+
+    def self.match_missing_exact_template(exception)
+      from_rule(:missing_exact_template, exception, confidence: 88)
+    end
+
+    def self.match_active_storage_error(exception)
+      from_rule(:active_storage_error, exception, confidence: 87)
+    end
+
+    def self.match_active_storage_integrity_error(exception)
+      from_rule(:active_storage_integrity_error, exception, confidence: 88)
+    end
+
+    def self.match_redis_error(exception)
+      from_rule(:redis_error, exception, confidence: 86)
+    end
+
+    def self.match_unknown_format(exception)
+      from_rule(:unknown_format, exception, confidence: 87)
+    end
+
+    def self.match_invalid_cross_origin_request(exception)
+      from_rule(:invalid_cross_origin_request, exception, confidence: 88)
+    end
+
+    def self.match_flash_error(exception)
+      from_rule(:flash_error, exception, confidence: 86)
+    end
+
+    def self.match_invalid_signature(exception)
+      from_rule(:invalid_signature, exception, confidence: 88)
+    end
+
+    def self.match_faraday_error(exception)
+      from_rule(:faraday_error, exception, confidence: 85)
+    end
+
+    def self.match_record_invalid(exception)
+      from_rule(:record_invalid, exception, confidence: 89)
+    end
+
+    def self.match_record_not_unique(exception)
+      from_rule(:record_not_unique, exception, confidence: 90)
+    end
+
+    def self.match_not_null_violation(exception)
+      from_rule(:not_null_violation, exception, confidence: 89)
+    end
+
+    def self.match_statement_invalid(exception)
+      from_rule(:statement_invalid, exception, confidence: 86)
+    end
+
+    def self.match_connection_not_established(exception)
+      from_rule(:connection_not_established, exception, confidence: 88)
+    end
+
+    def self.match_stale_object(exception)
+      from_rule(:stale_object, exception, confidence: 87)
+    end
+
+    def self.match_pg_error(exception)
+      from_rule(:pg_error, exception, confidence: 85)
+    end
+
+    def self.match_name_error(exception)
+      from_rule(:name_error, exception, confidence: 88)
+    end
+
+    def self.match_key_error(exception)
+      from_rule(:key_error, exception, confidence: 86)
+    end
+
+    def self.match_argument_error(exception)
+      from_rule(:argument_error, exception, confidence: 85)
+    end
+
+    def self.match_type_error(exception)
+      from_rule(:type_error, exception, confidence: 85)
+    end
+
+    def self.match_zero_division_error(exception)
+      from_rule(:zero_division_error, exception, confidence: 90)
+    end
+
+    def self.match_json_parse_error(exception)
+      from_rule(:json_parse_error, exception, confidence: 88)
+    end
+
+    def self.match_timeout_error(exception)
+      from_rule(:timeout_error, exception, confidence: 84)
+    end
+
+    def self.match_frozen_error(exception)
+      from_rule(:frozen_error, exception, confidence: 87)
+    end
+
+    def self.match_runtime_error(exception)
+      from_rule(:runtime_error, exception, confidence: 80)
+    end
+
+    def self.match_generic_exception(exception)
+      from_rule(:generic_exception, exception, confidence: 75)
+    end
+
+    def self.build_suggestion(exception:, issue:, root_cause:, fixes:, confidence:)
+      Suggestion.new(
+        issue: issue,
+        location: location_for(exception),
+        root_cause: root_cause,
+        fixes: fixes,
+        confidence: confidence
+      )
+    end
+
+    def self.location_for(exception)
+      return exception.location if exception.respond_to?(:location) && !exception.location.to_s.strip.empty?
+
+      frame = TraceCleaner.first_application_frame(exception.backtrace) || exception.backtrace&.first
+      frame || Bugsage.t("common.unknown")
+    end
+  end
+end

data/lib/bugsage/session_clear.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Bugsage
+  class SessionClear
+    extend JsonEndpoint
+
+    ENDPOINT = "/bugsage/clear"
+
+    def self.handle_request(env)
+      return not_found unless Bugsage.configuration.enabled?
+
+      Store.clear!
+      ConsoleContext.clear!
+      AiContext.clear!
+
+      redirect_to = "/bugsage"
+
+      if json_request?(env)
+        json_response({ ok: true, message: Bugsage.t("errors.session_logs_cleared") })
+      else
+        redirect_response(redirect_to)
+      end
+    end
+
+    def self.json_request?(env)
+      accept = env["HTTP_ACCEPT"].to_s
+      content_type = env["CONTENT_TYPE"].to_s
+      accept.include?("application/json") || content_type.include?("application/json")
+    end
+
+    def self.redirect_response(path)
+      [302, { "Location" => path, "Content-Type" => "text/plain" }, [Bugsage.t("errors.session_logs_cleared")]]
+    end
+  end
+end