mbeditor 0.11.0 → 0.12.1

data/app/services/mbeditor/lsp_diagnostics_translator.rb

@@ -11,24 +11,57 @@ module Mbeditor
     module_function
 
     # LSP DiagnosticSeverity -> the severity strings cop_severity also emits.
-    SEVERITIES = { 1 => "error", 2 => "warning", 3 => "info", 4 => "info" }.freeze
+    # Mirrors ruby-lsp's own RUBOCOP_TO_LSP_SEVERITY in reverse: rubocop's
+    # `info` becomes HINT(4) and convention/refactor become INFORMATION(3), so
+    # the two must map back to distinct editor severities.
+    SEVERITIES = { 1 => "error", 2 => "warning", 3 => "info", 4 => "hint" }.freeze
 
     # ruby-lsp appends this to non-correctable RuboCop messages; it's noise in
     # a Monaco hover.
     UNCORRECTABLE_SUFFIX = "This offense is not auto-correctable."
 
-    def call(result)
+    # Cops whose offense means "this code does nothing" rather than "this code
+    # is wrong". Monaco fades these out (MarkerTag.Unnecessary) instead of
+    # squiggling them, which is the whole point of greying out dead code.
+    #
+    # ruby-lsp emits no DiagnosticTag of its own, so the cop name is the only
+    # signal available — and it's the same signal on the plain-rubocop /lint
+    # path, which is why this predicate is public and shared by both.
+    #
+    # ponytail: name heuristic, not an enumeration. Upgrade path is an explicit
+    # cop list if a badly-named cop ever gets faded by mistake.
+    UNNECESSARY_COP = /Unused|Useless|Redundant|Unreachable|Deprecat/.freeze
+
+    # Prism reports the same dead code as Lint/UselessAssignment and
+    # Lint/UnreachableCode, but as a parser warning with no cop name — so both
+    # markers land on the same range. Fading only the RuboCop one leaves the
+    # Prism squiggle drawn on top and nothing looks greyed out at all.
+    UNNECESSARY_MESSAGE = /\Aassigned but unused variable|\Astatement not reached|\Aunused literal/.freeze
+
+    # Most actions a diagnostic can carry. RuboCop sends two (autocorrect and
+    # disable-for-this-line); the cap is a bound on a payload we don't control.
+    MAX_CODE_ACTIONS = 5
+
+    # Refuse to ship an absurd replacement into the browser. RuboCop's
+    # replacements are a few characters; anything near this is a bug or an
+    # attack, not a quick fix.
+    MAX_EDIT_BYTES = 64 * 1024
+
+    # +uri+ is the request's own document URI. Code actions are only accepted
+    # when every edit they carry targets exactly that document — see
+    # sanitize_code_actions.
+    def call(result, uri = nil)
       items = case result
               when Hash  then Array(result["items"])
               when Array then result
               else []
               end
 
-      markers = items.filter_map { |diag| translate_one(diag) }
+      markers = items.filter_map { |diag| translate_one(diag, uri) }
       { markers: markers, summary: { "offense_count" => markers.length } }
     end
 
-    def translate_one(diag)
+    def translate_one(diag, uri = nil)
       return nil unless diag.is_a?(Hash)
 
       range      = diag["range"] || {}
@@ -41,6 +74,7 @@ module Mbeditor
 
       cop_name = extract_code(diag["code"])
       message  = clean_message(diag["message"])
+      fixes    = sanitize_code_actions(diag, uri)
 
       {
         severity: SEVERITIES.fetch(diag["severity"], "info"),
@@ -53,10 +87,70 @@ module Mbeditor
         source: rubocop_source?(diag["source"]) ? "rubocop" : diag["source"].to_s.downcase,
         message: cop_name.empty? ? message : "[#{cop_name}] #{message}",
         startLine: start_line, startCol: start_col,
-        endLine: end_line, endCol: end_col
+        endLine: end_line, endCol: end_col,
+        unnecessary: unnecessary?(cop_name, message),
+        # RuboCop >= 1.64 ships a docs URL per cop; Monaco renders it as a link
+        # on the marker's code. Absent for non-RuboCop diagnostics.
+        # NB: the LSP wire key is camelCase.
+        codeHref: diag.dig("codeDescription", "href")
+      }.tap { |marker| marker[:fixes] = fixes if fixes.any? }
+    end
+
+    # ruby-lsp embeds the complete edits for each RuboCop fix in the diagnostic
+    # itself. Its textDocument/codeAction handler does nothing but echo these
+    # back (see Requests::CodeActions#perform), so lifting them here lets the
+    # editor apply a fix with no further request at all -- no codeAction call
+    # and no `rubocop -A` subprocess.
+    #
+    # This is a trust boundary: the payload arrives from a subprocess and is
+    # applied to the user's buffer. An action is taken only if every edit in it
+    # targets the very document we asked about.
+    def sanitize_code_actions(diag, uri)
+      return [] if uri.nil?
+
+      Array(diag.dig("data", "code_actions")).first(MAX_CODE_ACTIONS).filter_map do |action|
+        next unless action.is_a?(Hash)
+
+        changes = Array(action.dig("edit", "documentChanges"))
+        next if changes.empty?
+        # Any edit aimed at another file disqualifies the whole action. RuboCop
+        # fixes are always single-file, so this rejects nothing legitimate.
+        next unless changes.all? { |c| c.is_a?(Hash) && c.dig("textDocument", "uri") == uri }
+
+        edits = changes.flat_map { |c| Array(c["edits"]) }.filter_map { |edit| sanitize_edit(edit) }
+        next if edits.empty?
+
+        { title: action["title"].to_s, edits: edits }
+      end
+    end
+
+    # One LSP TextEdit -> the 1-based shape the rest of the marker uses.
+    def sanitize_edit(edit)
+      return nil unless edit.is_a?(Hash)
+
+      text = edit["newText"].to_s
+      return nil if text.bytesize > MAX_EDIT_BYTES
+
+      range = edit["range"]
+      return nil unless range.is_a?(Hash)
+
+      {
+        startLine: (range.dig("start", "line") || 0) + 1,
+        startCol:  (range.dig("start", "character") || 0) + 1,
+        endLine:   (range.dig("end", "line") || range.dig("start", "line") || 0) + 1,
+        endCol:    (range.dig("end", "character") || range.dig("start", "character") || 0) + 1,
+        text: text
       }
     end
 
+    def unnecessary?(cop_name, message = nil)
+      return true if UNNECESSARY_COP.match?(cop_name.to_s)
+
+      # Only consult the message when there is no cop to go on, so a RuboCop
+      # offense is never faded because of a phrase inside its description.
+      cop_name.to_s.empty? && UNNECESSARY_MESSAGE.match?(message.to_s)
+    end
+
     def rubocop_source?(source)
       source.to_s.match?(/rubocop/i)
     end

data/app/services/mbeditor/model_graph_service.rb

@@ -0,0 +1,232 @@
+# frozen_string_literal: true
+
+module Mbeditor
+  # Builds a graph of the host app's ActiveRecord models and the associations
+  # between them, for the Models sidebar tab.
+  #
+  # Reads the associations by *reflection* rather than by parsing model files.
+  # mbeditor already runs inside the host app, so `reflect_on_all_associations`
+  # is right there — and it resolves `class_name:`, `through:`, polymorphic and
+  # inverse sides correctly, which regex or AST parsing of `has_many` lines
+  # silently gets wrong. (ruby-lsp cannot help here: its index models constants
+  # and methods, not associations.)
+  #
+  # Deliberately never touches the database connection. Reflections are pure
+  # metadata, so this works on an app whose database isn't running or migrated;
+  # column counts are only filled in when a connection happens to be live.
+  class ModelGraphService
+    # Rails' own models — ActiveStorage, ActionText, SolidQueue, schema
+    # migrations — are not what you opened this tab to look at.
+    IGNORED_NAMESPACES = %w[
+      ActiveRecord ActiveStorage ActionText ActionMailbox
+      SolidQueue SolidCache SolidCable
+    ].freeze
+
+    MAX_MODELS = 300
+
+    # Only the first few columns travel: the diagram box shows that many and the
+    # full list is a click away in the schema modal, which fetches its own data
+    # from /model_schema.
+    MAX_COLUMNS_SENT = 8
+
+    class << self
+      def call(workspace_root)
+        root = workspace_root.to_s
+        fingerprint = fingerprint_for(root)
+
+        cached = MUTEX.synchronize { @cache }
+        return cached[:payload] if cached && cached[:fingerprint] == fingerprint && cached[:root] == root
+
+        payload = build(root)
+        payload[:fingerprint] = fingerprint
+        MUTEX.synchronize { @cache = { root: root, fingerprint: fingerprint, payload: payload } }
+        write_artifacts(root, payload)
+        payload
+      end
+
+      # Only needed for an explicit refresh: ordinary saves are picked up by
+      # the fingerprint below, so there is no file-change hook to keep in sync.
+      def invalidate(_root = nil)
+        MUTEX.synchronize { @cache = nil }
+        nil
+      end
+
+      # A cheap stand-in for "have the models changed": the newest mtime and the
+      # file count across the model and migration directories. Avoids
+      # eager-loading the app just to decide whether the cache is stale.
+      def fingerprint_for(root)
+        dirs = [File.join(root, "app", "models"), File.join(root, "db", "migrate")]
+        newest = 0
+        count = 0
+        dirs.each do |dir|
+          next unless File.directory?(dir)
+
+          Dir.glob(File.join(dir, "**", "*.rb")).each do |f|
+            count += 1
+            mtime = File.mtime(f).to_i
+            newest = mtime if mtime > newest
+          end
+        end
+        "#{newest}:#{count}"
+      rescue StandardError
+        "unknown"
+      end
+
+      private
+
+      MUTEX = Mutex.new
+      private_constant :MUTEX
+
+      def build(root)
+        unless defined?(::ActiveRecord::Base)
+          return unavailable("This app does not use ActiveRecord, so there are no models to graph.")
+        end
+
+        eager_load!
+        classes = model_classes
+        return unavailable("No ActiveRecord models found in this application.") if classes.empty?
+
+        models = classes.first(MAX_MODELS).map { |klass| describe_model(klass, root) }
+        known = models.map { |m| m[:name] }.to_set
+
+        {
+          ok: true,
+          models: models,
+          # Edges to classes outside the graph (a gem's model, or a typo in
+          # class_name:) would render as arrows into nowhere.
+          edges: models.flat_map { |m| m.delete(:edges) }.select { |e| known.include?(e[:to]) }.uniq,
+          truncated: classes.length > MAX_MODELS,
+          generatedAt: Time.now.utc.iso8601
+        }
+      rescue StandardError => e
+        unavailable("Could not read the model graph: #{e.class}: #{e.message}")
+      end
+
+      def unavailable(message)
+        { ok: false, error: message, models: [], edges: [], generatedAt: Time.now.utc.iso8601 }
+      end
+
+      # In development the host app is lazily loaded, so most models are not
+      # constants yet. This is the one genuinely expensive step.
+      def eager_load!
+        Rails.application.eager_load! if defined?(Rails) && Rails.respond_to?(:application) && Rails.application
+      rescue StandardError => e
+        # A model that raises on load shouldn't cost you the whole diagram —
+        # whatever did load is still worth drawing.
+        Rails.logger.warn("[mbeditor] eager_load for the model graph failed: #{e.class}: #{e.message}") if defined?(Rails)
+      end
+
+      def model_classes
+        ::ActiveRecord::Base.descendants.reject do |klass|
+          klass.name.nil? ||
+            klass.abstract_class? ||
+            IGNORED_NAMESPACES.any? { |ns| klass.name.start_with?("#{ns}::") }
+        end.sort_by(&:name)
+      rescue StandardError
+        []
+      end
+
+      def describe_model(klass, root)
+        columns = column_list(klass)
+        {
+          name: klass.name,
+          table: safe(-> { klass.table_name }),
+          columns: columns.first(MAX_COLUMNS_SENT),
+          columnCount: columns.length,
+          superclass: klass.superclass&.name,
+          file: model_file(klass, root),
+          edges: associations_for(klass)
+        }
+      end
+
+      # Needs a live database connection, so it degrades to an empty list rather
+      # than failing: the graph is still worth drawing against a database that
+      # isn't running or migrated.
+      def column_list(klass)
+        klass.columns.map { |c| { name: c.name, type: c.type.to_s } }
+      rescue StandardError
+        []
+      end
+
+      # Where the class was defined, made workspace-relative so the editor can
+      # open it. Models outside the workspace (a gem, or an engine) get no file
+      # and simply aren't clickable.
+      def model_file(klass, root)
+        location = Object.const_source_location(klass.name)
+        path = location && location.first
+        return nil unless path
+
+        prefix = root.end_with?("/") ? root : "#{root}/"
+        path.start_with?(prefix) ? path.delete_prefix(prefix) : nil
+      rescue StandardError
+        nil
+      end
+
+      def associations_for(klass)
+        klass.reflect_on_all_associations.filter_map do |reflection|
+          # A polymorphic belongs_to has no single target class — there is no
+          # edge to draw.
+          next if safe(-> { reflection.polymorphic? })
+
+          target = safe(-> { reflection.class_name })
+          next if target.nil?
+
+          {
+            from: klass.name,
+            to: target,
+            macro: reflection.macro.to_s,
+            name: reflection.name.to_s,
+            through: safe(-> { reflection.options[:through]&.to_s })
+          }
+        end
+      rescue StandardError
+        []
+      end
+
+      # Reflection can raise for half-configured associations; one bad
+      # association must not take out the whole graph.
+      def safe(callable)
+        callable.call
+      rescue StandardError
+        nil
+      end
+
+      # The user asked for a file in tmp. The JSON is what the editor reads back
+      # if it wants to; the .mmd is a Mermaid ER diagram that GitHub, VS Code
+      # and mermaid.live all render, for when you want a prettier picture than
+      # the sidebar draws.
+      def write_artifacts(root, payload)
+        dir = File.join(root, "tmp")
+        return unless File.directory?(dir)
+
+        File.write(File.join(dir, "mbeditor_model_graph.json"), JSON.pretty_generate(payload))
+        File.write(File.join(dir, "mbeditor_model_graph.mmd"), to_mermaid(payload))
+      rescue StandardError => e
+        Rails.logger.debug("[mbeditor] could not write model graph artifacts: #{e.message}") if defined?(Rails)
+      end
+
+      MERMAID_CARDINALITY = {
+        "belongs_to" => "}o--||",
+        "has_one" => "||--o|",
+        "has_many" => "||--o{",
+        "has_and_belongs_to_many" => "}o--o{"
+      }.freeze
+
+      def to_mermaid(payload)
+        lines = ["erDiagram"]
+        payload[:models].each { |m| lines << "  #{mermaid_id(m[:name])} {" << "  }" }
+        payload[:edges].each do |e|
+          arrow = MERMAID_CARDINALITY.fetch(e[:macro], "||--||")
+          label = e[:through] ? "#{e[:name]} (through #{e[:through]})" : e[:name]
+          lines << %(  #{mermaid_id(e[:from])} #{arrow} #{mermaid_id(e[:to])} : "#{label}")
+        end
+        "#{lines.join("\n")}\n"
+      end
+
+      # Mermaid entity names can't contain ::
+      def mermaid_id(name)
+        name.to_s.gsub("::", "_")
+      end
+    end
+  end
+end

data/app/services/mbeditor/presence_registry.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Mbeditor
+  # Who is currently connected for collaborative editing. Thread-safe and
+  # in-memory, modelled on CollaborationDocStore (Mutex + monotonic clock).
+  #
+  # This exists because the clients cannot maintain an accurate roster between
+  # themselves. The original protocol relayed one "here"/"leave" event per
+  # participant and every client merged those into its own roster, which meant a
+  # single dropped or missed message — a peer's browser killed outright, a relay
+  # failure, or simply reloading your own page at the moment someone else closed
+  # theirs — left a participant in your roster permanently, with no expiry to
+  # reclaim it. That is not cosmetic: the roster gates collaboration, so one ghost
+  # kept persistent undo disabled and external on-disk changes suppressed for the
+  # rest of the session, for a peer who was not there.
+  #
+  # The server already knows exactly who is subscribed — Action Cable calls
+  # `unsubscribed` on a clean close and on its own connection timeout — so it is
+  # the only party that can answer this correctly. Every broadcast now carries the
+  # complete roster and clients replace theirs wholesale, so a dropped message
+  # costs one stale interval rather than a permanent phantom. No TTL sweep: an
+  # entry outlives its connection only if the process dies, which takes the
+  # registry with it.
+  module PresenceRegistry
+    module_function
+
+    MUTEX = Mutex.new
+    private_constant :MUTEX
+
+    # Fields a participant publishes about itself. Anything else in the payload is
+    # dropped — this is relayed to every other client, so the shape is a boundary.
+    # `seq` is the sender's own heartbeat counter, echoed back so they can tell
+    # which broadcast their message caused — every participant's heartbeat now
+    # rebroadcasts everyone, so "my entry came back" alone does not mean "my
+    # message round-tripped", and timing against it inflates the measurement.
+    # `seed` is a stable number derived from the sender's persisted identity. It
+    # exists so a colour clash resolves to the same winner on both sides and stays
+    # resolved across a reload; it is deliberately a hash rather than the id itself.
+    RELAYED_FIELDS = %w[name colour current_file rtt seq seed].freeze
+
+    def record(client_id, attrs, now: monotonic)
+      id = client_id.to_s
+      return if id.empty?
+
+      entry = attrs.slice(*RELAYED_FIELDS)
+      MUTEX.synchronize do
+        participants[id] = entry.merge("client_id" => id, "last_seen" => now)
+      end
+      nil
+    end
+
+    def remove(client_id)
+      id = client_id.to_s
+      MUTEX.synchronize { participants.delete(id) }
+      nil
+    end
+
+    # The full roster, with each entry's idle time resolved against a monotonic
+    # clock here rather than compared across machines — no clock skew to correct.
+    def roster(now: monotonic)
+      MUTEX.synchronize do
+        participants.transform_values do |entry|
+          entry.except("last_seen").merge("idle" => (now - entry["last_seen"]).round)
+        end
+      end
+    end
+
+    def reset!
+      MUTEX.synchronize { @participants = {} }
+      nil
+    end
+
+    def participants
+      @participants ||= {}
+    end
+    private_class_method :participants
+
+    def monotonic
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+    private_class_method :monotonic
+  end
+end

data/app/services/mbeditor/ri_definition_service.rb

@@ -17,8 +17,18 @@ module Mbeditor
     MAX_DESC_LINES  = 3
 
     # When a method is defined on many classes, prefer these over the
-    # first-alphabetical class (e.g. prefer BasicObject#new over Addrinfo#new).
-    PREFERRED_CLASSES = %w[BasicObject Object Kernel Module Class].freeze
+    # first-alphabetical class, which is almost never the one meant:
+    # `new` would resolve to Addrinfo and `each` to ARGF.
+    #
+    # Ordered most-general first. We don't know the receiver's type, so the
+    # honest answer for a bare `each` is Enumerable's, not the first class
+    # ri happens to list.
+    PREFERRED_CLASSES = %w[
+      BasicObject Object Kernel Module Class
+      Enumerable Comparable
+      Array Hash String Symbol Integer Float Numeric Range Enumerator
+      Struct Set Time File IO Exception Proc Method NilClass
+    ].freeze
 
     @cache = {}
     @mutex = Mutex.new
@@ -55,6 +65,12 @@ module Mbeditor
 
     private
 
+    # "map()" or "each()" — a name and empty parens, telling you nothing about
+    # arguments, block or return value.
+    def bare_signature?(signature)
+      signature.to_s.strip.match?(/\A[\w.:]+\(\)\z/)
+    end
+
     def run_ri
       out = nil
       Open3.popen3("ri", "--no-pager", "--format=rdoc", @symbol) do |stdin, stdout, _stderr, wait_thr|
@@ -83,8 +99,23 @@ module Mbeditor
       blocks = extract_blocks(lines)
       return [] if blocks.empty?
 
-      best = blocks.find { |b| PREFERRED_CLASSES.include?(b[:impl]) } || blocks.first
-      return [] if best[:sigs].empty?
+      # Rank by position in PREFERRED_CLASSES, not by ri's own ordering, so the
+      # most general implementation wins rather than whichever preferred class
+      # ri happened to print first.
+      #
+      # Choose only among recognised classes when there are any — otherwise a
+      # rich signature on some obscure class (Enumerator::Lazy#map) would beat
+      # the terse one on the class actually meant.
+      preferred = blocks.select { |b| PREFERRED_CLASSES.include?(b[:impl]) }
+      candidates = preferred.any? ? preferred : blocks
+
+      # Within that set, skip entries ri prints as a bare "map()" — they
+      # document nothing — before falling back to class order.
+      best = candidates.min_by do |b|
+        [bare_signature?(b[:sigs].first) ? 1 : 0,
+         PREFERRED_CLASSES.index(b[:impl]) || PREFERRED_CLASSES.length]
+      end
+      return [] if best.nil? || best[:sigs].empty?
 
       desc = best[:desc]
                .first(MAX_DESC_LINES)
@@ -127,8 +158,11 @@ module Mbeditor
       sep_indices = lines.each_index.select { |i| lines[i].match?(/\A-{5,}\z/) }
       return nil if sep_indices.length < 2
 
+      # ri pads signatures into columns for its terminal output, e.g.
+      # "each(sep=$/)             {|line| block }  -> ARGF". Those runs of
+      # spaces are meaningless here and render as a gaping hole in the hover.
       sigs = lines[(sep_indices[0] + 1)..(sep_indices[1] - 1)]
-               .map(&:strip)
+               .map { |l| l.strip.squeeze(" ") }
                .reject(&:empty?)
       return nil if sigs.empty?
 

data/app/services/mbeditor/search_replace_service.rb

@@ -39,6 +39,19 @@ module Mbeditor
         AvailabilityProbe.rg
       end
 
+      # The resolved ripgrep executable, shared with CodeSearchService so both
+      # search paths run the same binary.
+      def rg_command
+        AvailabilityProbe.rg_command || "rg"
+      end
+
+      # Which backend a search on this workspace will actually use. Reported by
+      # GET /workspace: the difference between the tiers is 10-30x, so "why is
+      # search slow" needs to be answerable without reading the source.
+      def backend(workspace_root)
+        pick_tier(workspace_root.to_s)
+      end
+
       # Returns up to +limit+ result rows. When +paths+ is given the scan is
       # restricted to those files (used by the live result-refresh) and the
       # result cache is bypassed.
@@ -242,7 +255,7 @@ module Mbeditor
 
         case tier
         when :rg
-          args = ["rg", "--json"]
+          args = [rg_command, "--json"]
           args << "--no-ignore" unless respect_gitignore?
           args << "-F" unless use_regex
           args << "--ignore-case" unless match_case
@@ -264,9 +277,16 @@ module Mbeditor
           args << "-w" if whole_word
           args += ["-e", query, "--"]
           args += paths.map { |p| relative_path(File.expand_path(p, root), root) } if paths
-          # C locale restores fast byte-wise case folding for -i (non-ASCII
-          # characters simply don't case-fold, which is acceptable here).
-          [{ "LC_ALL" => "C" }, args]
+          # Exclusions have to reach git as pathspecs, not just be dropped from
+          # the results by the matcher below: otherwise git walks node_modules
+          # and every other excluded tree in full before we discard the matches.
+          # A pathspec list of nothing but :(exclude) entries means
+          # "everything except these", which is exactly what the unscoped
+          # search wants.
+          args += exclusions.map { |p| ":(exclude)#{p}" }
+          # No LC_ALL=C: measured neutral for the -F -i default and 2.2x slower
+          # for -E, and the UTF-8 locale case-folds non-ASCII correctly.
+          [{}, args]
         else
           base_flags = use_regex ? "-E" : "-F"
           args = ["grep", "-I", "-Hn", base_flags]

data/app/views/layouts/mbeditor/application.html.erb

@@ -29,6 +29,8 @@
   <script defer src="<%= asset_path('react-dom.min.js') %>"></script>
   <script defer src="<%= asset_path('axios.min.js') %>"></script>
   <script defer src="<%= asset_path('lodash.min.js') %>"></script>
+  <!-- Yjs + y-monaco + y-protocols (awareness) — maintainer-prebuilt bundle for collaborative editing; exposes window.Y / window.MonacoBinding / window.awarenessProtocol -->
+  <script defer src="<%= asset_path('yjs-collab.js') %>"></script>
   <script defer src="<%= asset_path('minisearch.min.js') %>"></script>
   <script defer src="<%= asset_path('marked.min.js') %>"></script>
   <!-- ── Monaco (ESM bundle, ADR 0002): stylesheet here, JS loaded in body ── -->

data/lib/mbeditor/configuration.rb

@@ -5,14 +5,15 @@ module Mbeditor
     attr_accessor :allowed_environments, :workspace_root, :excluded_paths, :rubocop_command, :rubocop_server,
                   :redmine_enabled, :redmine_url, :redmine_api_key, :redmine_ticket_source,
                   :test_framework, :test_command, :test_timeout,
-                  :authenticate_with, :authentication_cache_ttl,
+                  :authenticate_with, :authentication_cache_ttl, :user_name_callback, :user_name_methods,
                   :lint_timeout, :base_branch_candidates, :git_timeout, :search_timeout,
                   :ruby_def_include_dirs, :related_files_custom_paths,
                   :mount_path, :resilient_routing, :js_global_identifiers,
                   :js_program, :js_program_exclude,
                   :js_syntax_check, :babel_standalone_path,
                   :ruby_lsp, :ruby_lsp_command, :ruby_lsp_timeout,
-                  :search_respect_gitignore
+                  :exception_capture,
+                  :search_respect_gitignore, :ripgrep_command
 
     def initialize
       @allowed_environments = [:development]
@@ -31,10 +32,37 @@ module Mbeditor
       @base_branch_candidates = %w[origin/develop origin/main origin/master develop main master]
       @git_timeout            = 10 # seconds; nil disables (no timeout on git subprocesses)
       @search_timeout         = 15 # seconds; wall-clock bound on every search subprocess, nil disables
-      @search_respect_gitignore = false # true skips .gitignore'd files in project search and definition lookups
+      # Skip .gitignore'd files in project search and definition lookups.
+      #
+      # Defaults to true, matching VS Code and ripgrep. The false path has to
+      # ask git for --no-index, which walks every ignored tree the app has —
+      # node_modules, public/packs, app/assets/builds, caches — and on the
+      # git-grep tier (no ripgrep installed) that measured 29x slower on this
+      # repo alone: 3714 files walked instead of 253. It also fills results
+      # with matches inside minified bundles.
+      #
+      # Set to false to search ignored files too; expect it to be slow on a
+      # machine without ripgrep.
+      @search_respect_gitignore = true
+      # Path to the ripgrep binary. nil auto-resolves: PATH first, then the
+      # usual install prefixes.
+      #
+      # This matters more than it looks. ripgrep is 10-30x faster than the
+      # git-grep fallback, and the probe used to run a bare "rg" — so it found
+      # ripgrep only if the *server process* had it on PATH. A Rails server
+      # started from launchd, systemd, foreman or an IDE typically inherits a
+      # stripped PATH without /opt/homebrew/bin or /usr/local/bin, so ripgrep
+      # could be installed and still invisible, silently dropping every search
+      # to the slow tier. GET /workspace reports the tier actually in use.
+      @ripgrep_command = nil
       @ruby_def_include_dirs  = %w[app/models app/controllers app/helpers app/concerns]
       @related_files_custom_paths = []
       @authentication_cache_ttl = 0
+      @user_name_callback = nil # proc resolved in controller context (instance_exec) → collaboration display name; nil falls through to current_user, then to the client-generated name
+      # Attributes tried on current_user, in order, when no user_name_callback
+      # is set. First non-blank one wins. Name your own column here rather than
+      # writing a callback for the common case.
+      @user_name_methods = %w[name full_name display_name username login email]
       @js_global_identifiers = [] # extra ambient JS globals for the editor (runtime-only names invisible to static scan, e.g. %w[Routes I18n])
       # Load the workspace's own JS source into Monaco's TypeScript program, so
       # cross-file references get real inferred types instead of ambient `any`.
@@ -50,6 +78,12 @@ module Mbeditor
       @ruby_lsp         = :auto # use the host's ruby-lsp for Ruby definitions/hover/completion when available; false disables
       @ruby_lsp_command = nil   # override the ruby-lsp launch command (String or Array); nil auto-resolves bin/ruby-lsp > gem > bundle exec
       @ruby_lsp_timeout = 3     # seconds per LSP request before falling back to the built-in services
+      # Record exceptions raised by the host app's controllers so they show up
+      # in the editor's Problems panel instead of only in the log. Development
+      # only. Exception messages can contain interpolated request params — the
+      # same exposure the log panel already has, since it tails the dev log.
+      # Set to false to record nothing.
+      @exception_capture = :auto
       @mount_path = nil # explicit URL prefix override; nil falls through to detection/"/mbeditor"
       @resilient_routing = true # serve /mbeditor from middleware so the editor survives a broken host routes.rb; false is the escape hatch
     end