mbeditor 0.10.1 → 0.12.0

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,13 +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,
                   :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]
@@ -30,16 +32,54 @@ 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 the client-generated name
       @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`.
+      @js_program = true
+      # Excluded from that program on top of excluded_paths. Vendored libraries
+      # are UMD-wrapped (the global is assigned inside a closure), so their
+      # source yields no globals to TypeScript and only costs parse time — they
+      # stay on ambient declarations instead. Add any other directory of
+      # third-party or generated JS here, e.g. "app/assets/javascripts/react".
+      @js_program_exclude = %w[vendor]
       @js_syntax_check = :auto # save-time babel parse check via host mini_racer + babel-standalone; false disables
       @babel_standalone_path = nil # explicit path to babel-standalone JS; nil auto-detects via the asset pipeline
       @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

data/lib/mbeditor/engine.rb

@@ -77,6 +77,8 @@ module Mbeditor
 
       cfg = Mbeditor.configuration
 
+      subscribe_to_exceptions if Rails.env.development? && cfg.exception_capture != false
+
       if cfg.workspace_root.present? && !File.directory?(cfg.workspace_root.to_s)
         raise ArgumentError, "[mbeditor] config.workspace_root is set to '#{cfg.workspace_root}' but that path is not a directory"
       end
@@ -110,6 +112,7 @@ module Mbeditor
         react-dom.min.js
         axios.min.js
         lodash.min.js
+        yjs-collab.js
         minisearch.min.js
         marked.min.js
         prettier-standalone.js
@@ -125,5 +128,36 @@ module Mbeditor
         fa-solid-900.woff2
       ]
     end
+
+    # Records controller exceptions into ExceptionLog and pushes them to any
+    # open editor over the existing cable channel.
+    #
+    # process_action.action_controller rather than a Rack middleware:
+    # ActionDispatch::DebugExceptions rescues and renders the error, so nothing
+    # outside it ever sees the raise. Rails.error.subscribe would be a cleaner
+    # API but only carries unhandled request errors reliably on newer Rails,
+    # and this gem supports 7.1.
+    def self.subscribe_to_exceptions
+      return if @exception_subscriber
+
+      @exception_subscriber = ActiveSupport::Notifications.subscribe(
+        "process_action.action_controller"
+      ) do |*args|
+        payload = ActiveSupport::Notifications::Event.new(*args).payload
+        exception = payload[:exception_object]
+        next unless exception
+
+        entry = Mbeditor::ExceptionLog.record(
+          exception, payload,
+          workspace_root: Mbeditor::WorkspaceRootResolver.call
+        )
+        next unless entry && defined?(ActionCable.server)
+
+        ActionCable.server.broadcast("mbeditor_editor", entry)
+      rescue StandardError => e
+        # A monitoring hook must never be able to break the request it observes.
+        Rails.logger.debug("[mbeditor] exception capture failed: #{e.class}: #{e.message}")
+      end
+    end
   end
 end

data/lib/mbeditor/exception_log.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Mbeditor
+  # A bounded, in-memory ring of exceptions raised by the host app, so a failed
+  # request shows up in the editor instead of only in the log.
+  #
+  # Lives in lib/ (required from lib/mbeditor.rb, NOT autoloaded) for the same
+  # reason as RubyLspClient: a Zeitwerk reload in the host's dev environment
+  # must not wipe the buffer you are trying to read.
+  #
+  # Fed by an ActiveSupport::Notifications subscriber wired up in the engine.
+  # A Rack middleware cannot be used here: ActionDispatch::DebugExceptions
+  # rescues and renders the error, so nothing outside it ever sees the raise.
+  module ExceptionLog
+    MAX_ENTRIES = 50
+
+    # Backtraces are mostly framework and gem frames, which this editor cannot
+    # open and which push the app's own frames off the end.
+    MAX_FRAMES = 10
+
+    MUTEX = Mutex.new
+    private_constant :MUTEX
+
+    class << self
+      # Returns the recorded entry, or nil when there was nothing to record.
+      def record(exception, payload = {}, workspace_root: nil)
+        return nil if exception.nil?
+
+        entry = build(exception, payload, workspace_root)
+        MUTEX.synchronize do
+          @entries ||= []
+          @entries << entry
+          @entries.shift while @entries.length > MAX_ENTRIES
+        end
+        entry
+      end
+
+      # Newest first — the one you just triggered is the one you want.
+      def entries
+        MUTEX.synchronize { (@entries || []).reverse }
+      end
+
+      def clear!
+        MUTEX.synchronize { @entries = [] }
+        nil
+      end
+
+      private
+
+      def build(exception, payload, workspace_root)
+        @seq = (@seq || 0) + 1
+        {
+          type: "exception",
+          id: @seq,
+          at: Time.now.utc.iso8601,
+          klass: exception.class.name,
+          message: exception.message.to_s[0, 2000],
+          controller: payload[:controller],
+          action: payload[:action],
+          path: payload[:path],
+          frames: workspace_frames(exception, workspace_root)
+        }
+      end
+
+      # Only frames inside the workspace, with the root stripped. Absolute host
+      # paths are both a leak and useless to an editor that addresses files
+      # workspace-relative.
+      def workspace_frames(exception, workspace_root)
+        root = workspace_root.to_s
+        return [] if root.empty?
+
+        prefix = root.end_with?("/") ? root : "#{root}/"
+        Array(exception.backtrace).filter_map do |frame|
+          next unless frame.start_with?(prefix)
+
+          file, line = frame.delete_prefix(prefix).split(":", 3)
+          next if file.nil? || file.empty?
+
+          { file: file, line: line.to_i }
+        end.first(MAX_FRAMES)
+      end
+    end
+  end
+end

data/lib/mbeditor/route_map.rb

@@ -17,6 +17,7 @@ module Mbeditor
     post   'file',            to: 'editors#save'
     post   'create_file',     to: 'editors#create_file'
     post   'create_dir',      to: 'editors#create_dir'
+    post   'import',          to: 'editors#import'
     patch  'rename',          to: 'editors#rename'
     delete 'delete',          to: 'editors#destroy_path'
     get    'state',           to: 'editors#state'
@@ -32,7 +33,12 @@ module Mbeditor
     get    'js_definition',   to: 'editors#js_definition'
     get    'js_members',      to: 'editors#js_members'
     get    'js_globals',      to: 'editors#js_globals'
+    get    'js_program',      to: 'editors#js_program'
     post   'ruby_lsp',        to: 'editors#ruby_lsp'
+  post   'ruby_rename',     to: 'editors#ruby_rename'
+  get    'model_graph',     to: 'editors#model_graph'
+  get    'exceptions',      to: 'editors#exceptions'
+  delete 'exceptions',      to: 'editors#clear_exceptions'
     get    'module_members',  to: 'editors#module_members'
     get    'file_includes',   to: 'editors#file_includes'
     get    'client_config',   to: 'editors#client_config'

data/lib/mbeditor/ruby_lsp_client.rb

@@ -76,6 +76,7 @@ module Mbeditor
       @next_id      = 0
       @state        = :stopped # :stopped | :ready | :crashed | :failed
       @crash_times  = []
+      @last_error   = nil # last start failure, surfaced to the editor's status chip
     end
 
     attr_reader :state
@@ -85,6 +86,28 @@ module Mbeditor
       @state == :ready
     end
 
+    # A snapshot for the editor's status indicator. Deliberately does not start
+    # the process — asking "how are you?" must not be what boots the server.
+    def health
+      @state_mutex.synchronize do
+        { state: @state, restarts: @crash_times.length, error: @last_error }
+      end
+    end
+
+    # Clears the crash budget so a client latched at :failed can be revived
+    # without restarting the whole Rails process. Clearing @crash_times is the
+    # load-bearing part: restart_allowed? re-latches :failed immediately if the
+    # window still holds MAX_RESTARTS entries.
+    def reset!
+      stop
+      @state_mutex.synchronize do
+        @crash_times.clear
+        @last_error = nil
+        @state = :stopped
+      end
+      ready?
+    end
+
     # Syncs the document (didOpen / full-text didChange) and issues a request
     # against it under one mutex, so concurrent Puma threads can't interleave
     # a positional request with a stale document.
@@ -215,6 +238,7 @@ module Mbeditor
       @state = :ready
     rescue StandardError => e
       Rails.logger.warn("[mbeditor] ruby-lsp start failed: #{e.class}: #{e.message}") if defined?(Rails)
+      @last_error = "#{e.class}: #{e.message}"
       record_crash
       cleanup_process
       @state = @crash_times.length >= MAX_RESTARTS ? :failed : :crashed
@@ -310,10 +334,13 @@ module Mbeditor
     def start_monitor_thread
       wait_thr = @wait_thr
       @monitor_thread = Thread.new do
-        wait_thr.value # blocks until process exit
+        status = wait_thr.value # blocks until process exit
         @state_mutex.synchronize do
           next if @stopping || @wait_thr != wait_thr
 
+          # A crash mid-session leaves no exception to quote, so the exit
+          # status is the only reason the status chip can show.
+          @last_error = "ruby-lsp exited (#{status.exitstatus || status})"
           record_crash
           cleanup_process
           @state = @crash_times.length >= MAX_RESTARTS ? :failed : :crashed

data/lib/mbeditor/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Mbeditor
-  VERSION = "0.10.1"
+  VERSION = "0.12.0"
 end

data/lib/mbeditor.rb

@@ -7,6 +7,7 @@ require "mbeditor/route_map"
 require "mbeditor/private_routes"
 require "mbeditor/editor_bootstrap"
 require "mbeditor/ruby_lsp_client"
+require "mbeditor/exception_log"
 require "mbeditor/engine"
 
 module Mbeditor