e11y 0.2.0 → 1.1.0

data/gems/e11y-devtools/frontend/svelte.config.js

@@ -0,0 +1,2 @@
+/** @type {import("@sveltejs/vite-plugin-svelte").SvelteConfig} */
+export default {}

data/gems/e11y-devtools/frontend/test_puppeteer.js

@@ -0,0 +1,41 @@
+import puppeteer from 'puppeteer';
+
+(async () => {
+  const browser = await puppeteer.launch({ headless: "new" });
+  const page = await browser.newPage();
+  
+  page.on('console', msg => console.log('PAGE LOG:', msg.text()));
+  
+  await page.goto('http://localhost:5173');
+  await page.waitForSelector('.e11y-fab', { timeout: 5000 });
+  await page.click('.e11y-fab');
+  await page.waitForSelector('.e11y-histo-chart-host', { timeout: 5000 });
+  
+  await page.evaluate(() => {
+    const host = document.querySelector('.e11y-histo-brush-overlay');
+    if (host) {
+      const rect = host.getBoundingClientRect();
+      const down = new PointerEvent('pointerdown', { clientX: rect.left + 50, clientY: rect.top + 20, button: 0, bubbles: true });
+      host.dispatchEvent(down);
+      
+      const move = new PointerEvent('pointermove', { clientX: rect.left + 150, clientY: rect.top + 20, button: 0, bubbles: true });
+      host.dispatchEvent(move);
+      
+      const up = new PointerEvent('pointerup', { clientX: rect.left + 150, clientY: rect.top + 20, button: 0, bubbles: true });
+      host.dispatchEvent(up);
+    }
+  });
+  
+  await new Promise(r => setTimeout(r, 500));
+  
+  await page.evaluate(() => {
+    const shade = document.querySelector('.e11y-histo-sel-shade');
+    if (shade) {
+      console.log('SHADE AFTER FAKE EVENT:', shade.style.left, shade.style.width);
+    } else {
+      console.log('SHADE AFTER FAKE EVENT: null');
+    }
+  });
+  
+  await browser.close();
+})();

data/gems/e11y-devtools/frontend/test_scale.js

@@ -0,0 +1,3 @@
+import { scaleBand } from "d3-scale";
+const scale = scaleBand().domain([0, 1, 2]).range([0, 100]).paddingInner(0.18).paddingOuter(0.06);
+console.log(scale(0), scale(1), scale(2), scale.bandwidth());

data/gems/e11y-devtools/frontend/tsconfig.app.json

@@ -0,0 +1,21 @@
+{
+  "extends": "@tsconfig/svelte/tsconfig.json",
+  "compilerOptions": {
+    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.app.tsbuildinfo",
+    "target": "ES2023",
+    "useDefineForClassFields": true,
+    "module": "ESNext",
+    "types": ["svelte", "vite/client"],
+    "noEmit": true,
+    /**
+     * Typecheck JS in `.svelte` and `.js` files by default.
+     * Disable checkJs if you'd like to use dynamic types in JS.
+     * Note that setting allowJs false does not prevent the use
+     * of JS in `.svelte` files.
+     */
+    "allowJs": true,
+    "checkJs": true,
+    "moduleDetection": "force"
+  },
+  "include": ["src/**/*.ts", "src/**/*.js", "src/**/*.svelte"]
+}

data/gems/e11y-devtools/frontend/tsconfig.json

@@ -0,0 +1,7 @@
+{
+  "files": [],
+  "references": [
+    { "path": "./tsconfig.app.json" },
+    { "path": "./tsconfig.node.json" }
+  ]
+}

data/gems/e11y-devtools/frontend/tsconfig.node.json

@@ -0,0 +1,26 @@
+{
+  "compilerOptions": {
+    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.node.tsbuildinfo",
+    "target": "ES2023",
+    "lib": ["ES2023"],
+    "module": "ESNext",
+    "types": ["node"],
+    "skipLibCheck": true,
+
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "moduleDetection": "force",
+    "noEmit": true,
+
+    /* Linting */
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "erasableSyntaxOnly": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedSideEffectImports": true
+  },
+  "include": ["vite.config.ts"]
+}

data/gems/e11y-devtools/frontend/vite.config.ts

@@ -0,0 +1,36 @@
+import path from "node:path"
+import { fileURLToPath } from "node:url"
+import { defineConfig } from "vite"
+import { svelte } from "@sveltejs/vite-plugin-svelte"
+import cssInjectedByJsPlugin from "vite-plugin-css-injected-by-js"
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const assetOutDir = path.resolve(__dirname, "../lib/e11y/devtools/overlay/assets")
+
+export default defineConfig(({ command }) => {
+  if (command === "serve") {
+    return {
+      plugins: [svelte()],
+    }
+  }
+
+    return {
+      plugins: [svelte(), cssInjectedByJsPlugin()],
+      build: {
+        copyPublicDir: false,
+        lib: {
+        entry: path.resolve(__dirname, "src/overlay-entry.ts"),
+        name: "E11yDevtoolsOverlay",
+        formats: ["iife"],
+        fileName: () => "overlay.js",
+      },
+      outDir: assetOutDir,
+      emptyOutDir: false,
+      rollupOptions: {
+        output: {
+          inlineDynamicImports: true,
+        },
+      },
+    },
+  }
+})

data/gems/e11y-devtools/lib/e11y/devtools/mcp/server.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "e11y/adapters/dev_log/query"
+require_relative "tools/recent_events"
+require_relative "tools/events_by_trace"
+require_relative "tools/search"
+require_relative "tools/stats"
+require_relative "tools/interactions"
+require_relative "tools/event_detail"
+require_relative "tools/errors"
+require_relative "tools/clear"
+
+module E11y
+  module Devtools
+    module Mcp
+      # MCP Server wrapping the E11y DevLog adapter.
+      #
+      # Exposes 8 tools to AI tools like Cursor and Claude Code.
+      # Supports stdio (default) and StreamableHTTP transports.
+      #
+      # @example Start stdio server
+      #   E11y::Devtools::Mcp::Server.new.run
+      #
+      # @example Start HTTP server on port 3099
+      #   E11y::Devtools::Mcp::Server.new.run(transport: :http, port: 3099)
+      class Server
+        TOOLS = [
+          Tools::RecentEvents, Tools::EventsByTrace, Tools::Search,
+          Tools::Stats, Tools::Interactions, Tools::EventDetail,
+          Tools::Errors, Tools::Clear
+        ].freeze
+
+        def initialize(log_path: nil)
+          @log_path = log_path || auto_detect_log_path
+          @store    = E11y::Adapters::DevLog::Query.new(@log_path)
+        end
+
+        # Start the MCP server.
+        #
+        # @param transport [:stdio, :http] Transport to use
+        # @param port      [Integer, nil]  HTTP port (default 3099)
+        def run(transport: :stdio, port: nil)
+          require "mcp"
+          server = build_mcp_server
+          case transport
+          when :stdio then run_stdio(server)
+          when :http  then run_http(server, port || 3099)
+          else raise ArgumentError, "Unknown transport: #{transport}"
+          end
+        end
+
+        private
+
+        def build_mcp_server
+          MCP::Server.new(
+            name: "e11y",
+            version: E11y::Devtools::VERSION,
+            tools: TOOLS,
+            server_context: { store: @store }
+          )
+        end
+
+        def run_stdio(server)
+          t = MCP::Server::Transports::StdioTransport.new(server)
+          server.transport = t
+          t.open
+        end
+
+        def run_http(server, port)
+          require "webrick"
+          t = MCP::Server::Transports::StreamableHTTPTransport.new(server)
+          server.transport = t
+          s = WEBrick::HTTPServer.new(Port: port, Logger: WEBrick::Log.new(nil))
+          s.mount("/mcp", t)
+          trap("INT") { s.shutdown }
+          s.start
+        end
+
+        def auto_detect_log_path
+          dir = Pathname.new(Dir.pwd)
+          loop do
+            candidate = dir.join("log", "e11y_dev.jsonl")
+            return candidate.to_s if candidate.exist?
+
+            parent = dir.parent
+            break if parent == dir
+
+            dir = parent
+          end
+          "log/e11y_dev.jsonl"
+        end
+      end
+    end
+  end
+end

data/gems/e11y-devtools/lib/e11y/devtools/mcp/tool_base.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module E11y
+  module Devtools
+    module Mcp
+      # Conditional base: use MCP::Tool if available, otherwise plain class.
+      # This allows tests to run without the mcp gem installed.
+      ToolBase = if defined?(MCP::Tool)
+                   MCP::Tool
+                 else
+                   Class.new do
+                     def self.description(desc = nil)
+                       @description = desc if desc
+                       @description
+                     end
+
+                     def self.input_schema(schema = nil)
+                       @input_schema = schema if schema
+                       @input_schema
+                     end
+                   end
+                 end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# 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
+        # Clears the E11y development log file.
+        class Clear < ToolBase
+          description "Clear the E11y development log file"
+
+          input_schema(
+            type: :object,
+            properties: {}
+          )
+
+          def self.call(server_context:, **_opts)
+            server_context[:store].clear!
+            "E11y log cleared successfully"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# 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 recent error and fatal events only.
+        class Errors < ToolBase
+          ERROR_SEVERITIES = %w[error fatal].freeze
+
+          description "Get recent error and fatal events only"
+
+          input_schema(
+            type: :object,
+            properties: {
+              limit: { type: :integer, description: "Max events", default: 20 }
+            }
+          )
+
+          def self.call(server_context:, limit: 20)
+            events = server_context[:store].stored_events(limit: limit * 5)
+            events.select { |e| ERROR_SEVERITIES.include?(e["severity"]) }.first(limit)
+          end
+        end
+      end
+    end
+  end
+end

data/gems/e11y-devtools/lib/e11y/devtools/mcp/tools/event_detail.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 the full payload of a single event by ID.
+        class EventDetail < ToolBase
+          description "Get full payload of a single event by ID"
+
+          input_schema(
+            type: :object,
+            required: ["event_id"],
+            properties: {
+              event_id: { type: :string, description: "Event UUID" }
+            }
+          )
+
+          def self.call(event_id:, server_context:)
+            server_context[:store].find_event(event_id) || { error: "Event #{event_id} not found" }
+          end
+        end
+      end
+    end
+  end
+end

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