e11y 0.2.0 → 1.0.0

data/gems/e11y-devtools/lib/e11y/devtools/mcp/tools/events_by_trace.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+begin
+  require "mcp"
+rescue LoadError
+  # mcp gem not available — ToolBase will use plain class
+end
+require_relative "../tool_base"
+
+module E11y
+  module Devtools
+    module Mcp
+      module Tools
+        # Returns all events for a specific trace ID in chronological order.
+        class EventsByTrace < ToolBase
+          description "Get all events for a specific trace ID in chronological order"
+
+          input_schema(
+            type: :object,
+            required: ["trace_id"],
+            properties: {
+              trace_id: { type: :string, description: "Trace ID" }
+            }
+          )
+
+          def self.call(trace_id:, server_context:)
+            server_context[:store].events_by_trace(trace_id)
+          end
+        end
+      end
+    end
+  end
+end

data/gems/e11y-devtools/lib/e11y/devtools/mcp/tools/interactions.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+begin
+  require "mcp"
+rescue LoadError
+  # mcp gem not available — ToolBase will use plain class
+end
+require_relative "../tool_base"
+
+module E11y
+  module Devtools
+    module Mcp
+      module Tools
+        # Returns time-grouped interactions (parallel requests from one user action).
+        class Interactions < ToolBase
+          description "Get time-grouped interactions (parallel requests from one user action)"
+
+          input_schema(
+            type: :object,
+            properties: {
+              limit: { type: :integer, description: "Max interactions", default: 20 },
+              window_ms: { type: :integer, description: "Grouping window in ms", default: 500 }
+            }
+          )
+
+          def self.call(server_context:, limit: 20, window_ms: 500)
+            server_context[:store].interactions(limit: limit, window_ms: window_ms).map do |ix|
+              {
+                started_at: ix.started_at.iso8601(3),
+                trace_ids: ix.trace_ids,
+                has_error: ix.has_error?,
+                traces_count: ix.traces_count
+              }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/gems/e11y-devtools/lib/e11y/devtools/mcp/tools/recent_events.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+begin
+  require "mcp"
+rescue LoadError
+  # mcp gem not available — ToolBase will use plain class
+end
+require_relative "../tool_base"
+
+module E11y
+  module Devtools
+    module Mcp
+      module Tools
+        # Returns the most recent events from the dev log.
+        class RecentEvents < ToolBase
+          description "Get recent E11y events from the development log"
+
+          input_schema(
+            type: :object,
+            properties: {
+              limit: { type: :integer, description: "Max events to return (default 50)", default: 50 },
+              severity: { type: :string, description: "Filter by severity",
+                          enum: %w[debug info warn error fatal] }
+            }
+          )
+
+          def self.call(server_context:, limit: 50, severity: nil)
+            server_context[:store].stored_events(limit: limit, severity: severity)
+          end
+        end
+      end
+    end
+  end
+end

data/gems/e11y-devtools/lib/e11y/devtools/mcp/tools/search.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+begin
+  require "mcp"
+rescue LoadError
+  # mcp gem not available — ToolBase will use plain class
+end
+require_relative "../tool_base"
+
+module E11y
+  module Devtools
+    module Mcp
+      module Tools
+        # Full-text search across event names and payload content.
+        class Search < ToolBase
+          description "Full-text search across event names and payload content"
+
+          input_schema(
+            type: :object,
+            required: ["query"],
+            properties: {
+              query: { type: :string, description: "Search term" },
+              limit: { type: :integer, description: "Max results", default: 50 }
+            }
+          )
+
+          def self.call(query:, server_context:, limit: 50)
+            server_context[:store].search(query, limit: limit)
+          end
+        end
+      end
+    end
+  end
+end

data/gems/e11y-devtools/lib/e11y/devtools/mcp/tools/stats.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+begin
+  require "mcp"
+rescue LoadError
+  # mcp gem not available — ToolBase will use plain class
+end
+require_relative "../tool_base"
+
+module E11y
+  module Devtools
+    module Mcp
+      module Tools
+        # Returns aggregate statistics about the E11y development log.
+        class Stats < ToolBase
+          description "Get aggregate statistics about the E11y development log"
+
+          input_schema(
+            type: :object,
+            properties: {}
+          )
+
+          def self.call(server_context:, **_opts)
+            server_context[:store].stats
+          end
+        end
+      end
+    end
+  end
+end

data/gems/e11y-devtools/lib/e11y/devtools/overlay/assets/overlay.js

@@ -0,0 +1,115 @@
+(function() {
+  'use strict';
+
+  const POLL_INTERVAL = 2000;
+  const API_BASE = '/_e11y';
+
+  class E11yOverlay extends HTMLElement {
+    connectedCallback() {
+      const shadow = this.attachShadow({ mode: 'open' });
+      shadow.innerHTML = `
+        <style>
+          :host { position: fixed; bottom: 16px; right: 16px; z-index: 99999; font-family: monospace; }
+          .badge { background: #1a1a2e; color: #e0e0e0; border-radius: 6px; padding: 6px 12px;
+                   cursor: pointer; font-size: 12px; border: 1px solid #333; }
+          .badge.has-error { border-color: #e53e3e; color: #fc8181; }
+          .panel { display: none; position: fixed; right: 16px; bottom: 60px; width: 420px;
+                   max-height: 70vh; background: #1a1a2e; border: 1px solid #444;
+                   border-radius: 8px; overflow: hidden; flex-direction: column; }
+          .panel.open { display: flex; }
+          .panel-header { padding: 10px 14px; background: #16213e; border-bottom: 1px solid #333;
+                          display: flex; justify-content: space-between; align-items: center;
+                          font-size: 12px; color: #a0aec0; }
+          .panel-title { color: #e0e0e0; font-weight: bold; }
+          .close-btn { cursor: pointer; color: #718096; }
+          .events { overflow-y: auto; flex: 1; padding: 8px; }
+          .event-row { padding: 4px 8px; border-radius: 4px; margin-bottom: 2px;
+                       font-size: 11px; cursor: pointer; display: flex; gap: 8px; }
+          .event-row:hover { background: #2d3748; }
+          .sev-error { color: #fc8181; }
+          .sev-warn  { color: #f6ad55; }
+          .sev-info  { color: #68d391; }
+          .footer { padding: 8px 14px; border-top: 1px solid #333; display: flex;
+                    gap: 12px; font-size: 11px; }
+          .footer a { color: #63b3ed; cursor: pointer; text-decoration: none; }
+          .footer a:hover { text-decoration: underline; }
+        </style>
+        <div class="badge" id="badge">e11y</div>
+        <div class="panel" id="panel">
+          <div class="panel-header">
+            <span class="panel-title" id="panel-title">e11y devtools</span>
+            <span class="close-btn" id="close-btn">x</span>
+          </div>
+          <div class="events" id="events-list"></div>
+          <div class="footer">
+            <a id="clear-btn">clear log</a>
+            <a id="copy-trace-btn">copy trace_id</a>
+          </div>
+        </div>
+      `;
+
+      this._shadow    = shadow;
+      this._panelOpen = false;
+      this._traceId   = window.__E11Y_TRACE_ID__ || null;
+      this._events    = [];
+
+      shadow.getElementById('badge').addEventListener('click', () => this.togglePanel());
+      shadow.getElementById('close-btn').addEventListener('click', () => this.closePanel());
+      shadow.getElementById('clear-btn').addEventListener('click', () => this.clearLog());
+      shadow.getElementById('copy-trace-btn').addEventListener('click', () => this.copyTrace());
+
+      this.loadEvents();
+      this._pollTimer = setInterval(() => this.loadEvents(), POLL_INTERVAL);
+    }
+
+    disconnectedCallback() { clearInterval(this._pollTimer); }
+
+    togglePanel() { this._panelOpen ? this.closePanel() : this.openPanel(); }
+    openPanel()   { this._panelOpen = true;  this._shadow.getElementById('panel').classList.add('open'); }
+    closePanel()  { this._panelOpen = false; this._shadow.getElementById('panel').classList.remove('open'); }
+
+    loadEvents() {
+      const url = this._traceId
+        ? `${API_BASE}/events?trace_id=${encodeURIComponent(this._traceId)}`
+        : `${API_BASE}/events/recent?limit=20`;
+      fetch(url)
+        .then(r => r.json())
+        .then(events => { this._events = events; this.renderBadge(); this.renderEvents(); })
+        .catch(() => {});
+    }
+
+    renderBadge() {
+      const badge    = this._shadow.getElementById('badge');
+      const errCount = this._events.filter(e => e.severity === 'error' || e.severity === 'fatal').length;
+      badge.textContent = errCount > 0
+        ? `e11y  ${this._events.length} * ${errCount}`
+        : `e11y  ${this._events.length}`;
+      badge.className = errCount > 0 ? 'badge has-error' : 'badge';
+    }
+
+    renderEvents() {
+      const list = this._shadow.getElementById('events-list');
+      list.innerHTML = this._events.map(e => `
+        <div class="event-row">
+          <span class="sev-${e.severity}">${(e.severity || 'info').toUpperCase().slice(0,4)}</span>
+          <span>${e.event_name}</span>
+          <span style="color:#718096;margin-left:auto">${(e.metadata && e.metadata.duration_ms) || ''}ms</span>
+        </div>`).join('');
+    }
+
+    clearLog() {
+      fetch(`${API_BASE}/events`, { method: 'DELETE' })
+        .then(() => { this._events = []; this.renderBadge(); this.renderEvents(); });
+    }
+
+    copyTrace() {
+      if (this._traceId) { navigator.clipboard && navigator.clipboard.writeText(this._traceId); }
+    }
+  }
+
+  customElements.define('e11y-overlay', E11yOverlay);
+
+  if (!document.querySelector('e11y-overlay')) {
+    document.body.appendChild(document.createElement('e11y-overlay'));
+  }
+})();

data/gems/e11y-devtools/lib/e11y/devtools/overlay/controller.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "e11y/adapters/dev_log/query"
+require "e11y/adapters/dev_log"
+
+module E11y
+  module Devtools
+    module Overlay
+      # Plain Ruby controller logic — testable without Rails.
+      # Used by the Rails route handlers (see config/routes.rb).
+      class Controller
+        def initialize(query = nil)
+          @query = query || resolve_query
+        end
+
+        def events_for(trace_id: nil, limit: 50)
+          if trace_id && !trace_id.empty?
+            @query.events_by_trace(trace_id)
+          else
+            @query.stored_events(limit: limit)
+          end
+        end
+
+        def recent_events(limit: 50)
+          clamped = limit.to_i.clamp(1, 500)
+          @query.stored_events(limit: clamped)
+        end
+
+        def clear_log!
+          @query.clear!
+        end
+
+        def stats
+          @query.stats
+        end
+
+        private
+
+        def resolve_query
+          if defined?(E11y) && E11y.respond_to?(:configuration)
+            adapter = E11y.configuration.adapters[:dev_log]
+            return adapter if adapter.respond_to?(:stored_events)
+          end
+          default_path = if defined?(Rails) && Rails.respond_to?(:root)
+                           Rails.root.join("log", "e11y_dev.jsonl").to_s
+                         else
+                           "log/e11y_dev.jsonl"
+                         end
+          E11y::Adapters::DevLog::Query.new(default_path)
+        end
+      end
+    end
+  end
+end

data/gems/e11y-devtools/lib/e11y/devtools/overlay/engine.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "rails"
+
+module E11y
+  module Devtools
+    module Overlay
+      # Rails Engine that mounts JSON endpoints at /_e11y/
+      # and injects the overlay badge via Rack middleware.
+      class Engine < Rails::Engine
+        isolate_namespace E11y::Devtools::Overlay
+
+        initializer "e11y_devtools.overlay.middleware" do |app|
+          next unless Rails.env.development? || Rails.env.test?
+
+          require "e11y/devtools/overlay/middleware"
+          app.middleware.use E11y::Devtools::Overlay::Middleware
+        end
+
+        config.generators do |g|
+          g.test_framework :rspec
+        end
+      end
+    end
+  end
+end

data/gems/e11y-devtools/lib/e11y/devtools/overlay/middleware.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module E11y
+  module Devtools
+    module Overlay
+      # Rack middleware that injects the e11y overlay badge into HTML responses.
+      #
+      # Skips injection for:
+      # - XHR requests (X-Requested-With: XMLHttpRequest)
+      # - Asset paths (/assets/, /packs/, /_e11y/)
+      # - Non-HTML responses
+      class Middleware
+        OVERLAY_SNIPPET = <<~HTML
+
+          <!-- e11y-overlay -->
+          <script id="e11y-overlay-loader">
+            (function() {
+              var s = document.createElement('script');
+              s.src = '/_e11y/overlay.js';
+              s.defer = true;
+              document.head.appendChild(s);
+            })();
+          </script>
+        HTML
+
+        def initialize(app)
+          @app = app
+        end
+
+        def call(env)
+          status, headers, body = @app.call(env)
+          return [status, headers, body] unless injectable?(env, headers)
+
+          new_body = inject_overlay(body, env["e11y.trace_id"])
+          [status, update_content_length(headers, new_body), [new_body]]
+        end
+
+        private
+
+        def injectable?(env, headers)
+          !xhr?(env) && !asset_path?(env) && html_response?(headers)
+        end
+
+        def xhr?(env)
+          env["HTTP_X_REQUESTED_WITH"]&.downcase == "xmlhttprequest"
+        end
+
+        def asset_path?(env)
+          path = env["PATH_INFO"] || ""
+          path.start_with?("/assets/", "/packs/", "/_e11y/")
+        end
+
+        def html_response?(headers)
+          ct = headers["Content-Type"] || headers["content-type"] || ""
+          ct.include?("text/html")
+        end
+
+        def inject_overlay(body, trace_id)
+          full = body.respond_to?(:join) ? body.join : body.to_s
+          snippet = trace_id_script(trace_id) + OVERLAY_SNIPPET
+          full.sub("</body>", "#{snippet}</body>")
+        end
+
+        def trace_id_script(trace_id)
+          return "" unless trace_id
+
+          "<script>window.__E11Y_TRACE_ID__ = '#{trace_id}';</script>\n"
+        end
+
+        def update_content_length(headers, new_body)
+          h = headers.dup
+          h.delete("Content-Length")
+          h.delete("content-length")
+          h["Content-Length"] = new_body.bytesize.to_s
+          h
+        end
+      end
+    end
+  end
+end

data/gems/e11y-devtools/lib/e11y/devtools/overlay/rails_controller.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative "controller"
+
+module E11y
+  module Devtools
+    module Overlay
+      # Thin Rails controller — delegates to plain Controller for testability.
+      # Only available in development/test.
+      class RailsController < ActionController::Base
+        before_action :development_only!
+
+        def events
+          render json: overlay_ctrl.events_for(trace_id: params[:trace_id])
+        end
+
+        def recent
+          render json: overlay_ctrl.recent_events(limit: params[:limit])
+        end
+
+        def clear
+          overlay_ctrl.clear_log!
+          head :no_content
+        end
+
+        def stats
+          render json: overlay_ctrl.stats
+        end
+
+        private
+
+        def overlay_ctrl
+          @overlay_ctrl ||= Controller.new
+        end
+
+        def development_only!
+          head :not_found unless Rails.env.development? || Rails.env.test?
+        end
+      end
+    end
+  end
+end