mbeditor 0.5.4 → 0.5.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6ce79d4cc314cce5975277d04c12a0d7d5fa13629fa0447d66cf742bf05aee3e
-  data.tar.gz: 820ef6cac234149c3f3e69069c5255598b27d161dea7c60939d06999d16d9c4a
+  metadata.gz: acc982f027b14cfd3ad12a911b327edef848a353f11fc64df7b2c5e194557a45
+  data.tar.gz: 768bf200ae935e14b4974249e41b27c26d2b2d105207a03a2399727f3b951912
 SHA512:
-  metadata.gz: 87cc5da11a46b54e9399ecb678c450a6f71053807a2f80bb22b788ef7c4c359b2cbcb2cc6bce4e1691763336ecd9c9ef4d9540f6a80f587f013188142a7d0b1c
-  data.tar.gz: 3cd29156eda196448f5f31eed27e5b8d7483e7a8f2f91d70ab6adc58a039a3e5cb19568a6b1a7bc94e38bee904cc4a495e9c698428117e8cd5aba4c09f6e9342
+  metadata.gz: 43a3c2adfdaf54835bca24a81d2dfbfd668b85be02ea62113ce3bb038baafbe2f717e0651cdb9e9c40657548ef3ceb3e4ee94dbf5633baf6e267a4b92fefeabf
+  data.tar.gz: 26fd951cc646560d6bdb2b0db9a02ef8f0f821e76232bfceea2c40dfcdb99d1768a8f2ddb5cc0efb037862899485845ecffe28274a5bcb9ff04e17f7fe049024

data/app/assets/javascripts/mbeditor/components/MbeditorApp.js

@@ -1740,6 +1740,29 @@ var MbeditorApp = function MbeditorApp() {
     EditorStore.setStatus('Line endings changed to ' + newEOL, 'info');
   };
 
+  var handleRefreshWorkspace = function handleRefreshWorkspace() {
+    setLoading(function (prev) {
+      return _extends({}, prev, { refreshWorkspace: true });
+    });
+    GitService.fetchStatus()["catch"](function () {});
+    FileService.getTree().then(function (data) {
+      var newData = data || [];
+      setTreeData(function (prevData) {
+        if (JSON.stringify(newData) === JSON.stringify(prevData)) return prevData;
+        SearchService.buildIndex(newData);
+        return newData;
+      });
+      checkOpenTabsForExternalChanges();
+      EditorStore.setStatus("Workspace refreshed", "success");
+    })["catch"](function (err) {
+      EditorStore.setStatus("Failed to refresh workspace", "error");
+    })["finally"](function () {
+      setLoading(function (prev) {
+        return _extends({}, prev, { refreshWorkspace: false });
+      });
+    });
+  };
+
   var handleFormat = function handleFormat() {
     if (!activeTab) return;
 
@@ -2971,6 +2994,13 @@ var MbeditorApp = function MbeditorApp() {
               actions: React.createElement(
                 SectionActionGroup,
                 { ariaLabel: "Project actions" },
+                React.createElement(SidebarActionButton, {
+                  title: "Refresh workspace",
+                  iconClass: "fas fa-sync-alt",
+                  ariaBusy: !!loading.refreshWorkspace,
+                  onClick: handleRefreshWorkspace,
+                  disabled: !!loading.refreshWorkspace
+                }),
                 React.createElement(SidebarActionButton, {
                   title: "Collapse all folders",
                   iconClass: "fas fa-compress-alt",

data/app/assets/javascripts/mbeditor/editor_plugins.js

@@ -51,6 +51,13 @@
 
   var globalsRegistered = false;
 
+  // JS global discovery: populated as definitions are found via hover/goto/auto-resolve.
+  // Persists for the page lifetime so each symbol is only declared once.
+  var discoveredJsGlobals = {};
+  var attemptedJsGlobals  = {}; // symbols already looked up (found OR not found)
+  var jsHoverCache = {};
+  var jsMembersCache = {};
+
   // Enumerate window for user-defined globals and return a TypeScript declaration string.
   // Sprockets exposes every top-level var/function as a window property before Monaco
   // initialises, so scanning at registration time captures all components and helpers.
@@ -77,6 +84,39 @@
     return lines.join('\n');
   }
 
+  // Declare a discovered global in Monaco's extra libs so the TS2304 warning disappears.
+  // Calling addExtraLib with the same URI replaces the previous content in-place.
+  function addDiscoveredGlobal(name) {
+    if (discoveredJsGlobals[name]) return;
+    discoveredJsGlobals[name] = true;
+    var mts = window.monaco && window.monaco.languages && window.monaco.languages.typescript;
+    if (!mts) return;
+    var decls = Object.keys(discoveredJsGlobals)
+      .map(function(k) { return 'declare var ' + k + ': any;'; }).join('\n');
+    mts.javascriptDefaults.addExtraLib(decls, 'inmemory://mbeditor/discovered-globals.d.ts');
+  }
+
+  // Navigate to the first workspace definition of a JS symbol.
+  // Returns a Promise<boolean> — true if a definition was found and opened.
+  function navigateToJsWord(editor, word) {
+    if (typeof FileService === 'undefined' || !FileService.getJsDefinition) return Promise.resolve(false);
+    var currentPath = editor.getModel && editor.getModel() && editor.getModel()._mbeditorPath;
+    return FileService.getJsDefinition(word)
+      .then(function(data) {
+        var results = data && data.results;
+        if (!results || !results.length) return false;
+        var r = results[0];
+        // Only declare as a global when the definition lives in a different file.
+        // Locally-defined functions/classes must not get a duplicate declare var.
+        if (r.file !== currentPath) addDiscoveredGlobal(word);
+        if (typeof TabManager !== 'undefined' && TabManager.openTab) {
+          TabManager.openTab(r.file, r.file.split('/').pop(), r.line);
+        }
+        return true;
+      })
+      .catch(function() { return false; });
+  }
+
   function leadingWhitespace(line) {
     var match = line.match(/^\s*/);
     return match ? match[0] : '';
@@ -231,6 +271,8 @@
     var emmetTabDisposable = null;
     var gotoMouseDisposable = null;
     var gotoActionDisposable = null;
+    var jsGotoMouseDisposable = null;
+    var jsGotoActionDisposable = null;
 
     // Emmet Tab expansion — active for markup and stylesheet languages
     var EMMET_MARKUP_LANGS = { html: true, xml: true, erb: true, 'html.erb': true, haml: true };
@@ -383,6 +425,42 @@
       });
     }
 
+    if (language === 'javascript') {
+      // Ctrl/Cmd+click — look up workspace definition; fall back to Monaco's built-in.
+      jsGotoMouseDisposable = editor.onMouseDown(function(event) {
+        var ctrlOrCmd = event.event.ctrlKey || event.event.metaKey;
+        if (!ctrlOrCmd) return;
+        if (!event.target || event.target.type !== 6) return;
+        var position = event.target.position;
+        if (!position) return;
+        var wordInfo = model.getWordAtPosition(position);
+        if (!wordInfo || !wordInfo.word || wordInfo.word.length < 2) return;
+        event.event.preventDefault();
+        navigateToJsWord(editor, wordInfo.word).then(function(found) {
+          if (!found) editor.trigger('', 'editor.action.revealDefinition', null);
+        });
+      });
+
+      // F12 — go to JS definition from keyboard
+      jsGotoActionDisposable = editor.addAction({
+        id: 'mbeditor.gotoJsDefinition',
+        label: 'Go to JS Definition',
+        keybindings: [window.monaco.KeyCode.F12],
+        precondition: 'editorLangId == javascript',
+        contextMenuGroupId: 'navigation',
+        contextMenuOrder: 1.5,
+        run: function(ed) {
+          var pos = ed.getPosition();
+          if (!pos) return;
+          var wordInfo = model.getWordAtPosition(pos);
+          if (!wordInfo || !wordInfo.word || wordInfo.word.length < 2) return;
+          navigateToJsWord(ed, wordInfo.word).then(function(found) {
+            if (!found) ed.trigger('', 'editor.action.revealDefinition', null);
+          });
+        }
+      });
+    }
+
     // Unused method dimming — grey out `def method_name` for methods with no
     // call-sites anywhere in the workspace.
     var unusedDecIds = [];
@@ -453,6 +531,8 @@
         if (emmetTabDisposable) emmetTabDisposable.dispose();
         if (gotoMouseDisposable) gotoMouseDisposable.dispose();
         if (gotoActionDisposable) gotoActionDisposable.dispose();
+        if (jsGotoMouseDisposable) jsGotoMouseDisposable.dispose();
+        if (jsGotoActionDisposable) jsGotoActionDisposable.dispose();
         contentDisposable.dispose();
         if (unusedSaveDisposable) unusedSaveDisposable.dispose();
         clearTimeout(unusedTimer);
@@ -517,12 +597,13 @@
       // the marker set after the worker fires and re-apply with lower severity.
       //
       // Patch markers after the TypeScript worker fires:
+      // - JS files: downgrade TS2304 ("Cannot find name") to Warning — host-app
+      //   globals injected at runtime are invisible to the language service, so
+      //   hard errors are almost always false positives. Downgrading keeps the
+      //   signal without blocking genuine undefined-variable detection.
       // - Both: downgrade TS6133 ("declared but never read") from Error to Warning.
-      // Host-app globals are handled by the dynamic window shim and explicit
-      // addExtraLib declarations above — we do not suppress TS2304 globally so
-      // that genuinely undefined names are still flagged as errors.
       var JS_SUPPRESS_CODES = {};
-      var JS_WARN_CODES    = { '6133': true };
+      var JS_WARN_CODES    = { '2304': true, '6133': true };
       var TS_WARN_CODES    = { '6133': true };
       var _severityPatchActive = false;
       monaco.editor.onDidChangeMarkers(function(uris) {
@@ -554,6 +635,35 @@
         } finally {
           _severityPatchActive = false;
         }
+
+        // Auto-resolve TS2304 ("Cannot find name 'X'") for JS files by
+        // looking up the symbol in the workspace. If found, addDiscoveredGlobal
+        // declares it via addExtraLib and Monaco re-validates, removing the warning.
+        if (typeof FileService !== 'undefined' && FileService.getJsDefinition) {
+          uris.forEach(function(uri) {
+            var model = monaco.editor.getModel(uri);
+            if (!model) return;
+            var markers = monaco.editor.getModelMarkers({ resource: uri, owner: 'javascript' });
+            markers.forEach(function(m) {
+              if (String(m.code) !== '2304') return;
+              // Extract symbol name from message: "Cannot find name 'ReactWindow'."
+              var match = m.message && m.message.match(/Cannot find name '([^']+)'/);
+              if (!match) return;
+              var sym = match[1];
+              if (attemptedJsGlobals[sym]) return;
+              attemptedJsGlobals[sym] = true;
+              var modelPath = model._mbeditorPath;
+              FileService.getJsDefinition(sym)
+                .then(function(data) {
+                  var results = data && data.results;
+                  if (results && results.length && results[0].file !== modelPath) {
+                    addDiscoveredGlobal(sym);
+                  }
+                })
+                .catch(function() {});
+            });
+          });
+        }
       });
     }
 
@@ -1076,6 +1186,94 @@
       }
     });
 
+    // JS/JSX hover provider: looks up workspace definitions for window globals.
+    // Only fires for mixed-case identifiers (skips lowercase-only names that are
+    // almost always browser builtins or local vars).
+    var JS_HOVER_CACHE_TTL_MS = 60000;
+    monaco.languages.registerHoverProvider('javascript', {
+      provideHover: function(model, position, token) {
+        var wordInfo = model.getWordAtPosition(position);
+        if (!wordInfo || !wordInfo.word || wordInfo.word.length < 2) return null;
+        var word = wordInfo.word;
+        if (!/[A-Z]/.test(word)) return null;
+        if (typeof FileService === 'undefined' || !FileService.getJsDefinition) return null;
+
+        var cached = jsHoverCache[word];
+        if (cached && (Date.now() - cached.ts) < JS_HOVER_CACHE_TTL_MS) {
+          return cached.value || null;
+        }
+
+        var controller = typeof AbortController !== 'undefined' ? new AbortController() : null;
+        if (controller && token && token.onCancellationRequested) {
+          token.onCancellationRequested(function() { controller.abort(); });
+        }
+        return FileService.getJsDefinition(word, controller ? { signal: controller.signal } : {})
+          .then(function(data) {
+            if (token && token.isCancellationRequested) return null;
+            var results = data && data.results;
+            if (!results || !results.length) {
+              jsHoverCache[word] = { ts: Date.now(), value: null };
+              return null;
+            }
+            var r = results[0];
+            // Only declare as global when the definition is in a different file —
+            // locally-defined functions must not get a duplicate declare var.
+            if (r.file !== model._mbeditorPath) addDiscoveredGlobal(word);
+            var fileRef = r.file + ':' + r.line;
+            var value = {
+              contents: [
+                { value: '```javascript\n' + r.snippet + '\n```', isTrusted: true },
+                { value: '<span style="opacity:0.55;font-size:0.9em;">' + fileRef + '</span>', isTrusted: true, supportHtml: true }
+              ]
+            };
+            jsHoverCache[word] = { ts: Date.now(), value: value };
+            return value;
+          }).catch(function() { return null; });
+      }
+    });
+
+    // JS/JSX member completion provider: suggests properties/methods of workspace globals after '.'.
+    // Only looks up PascalCase/mixed-case identifiers or previously discovered globals.
+    var JS_MEMBERS_CACHE_TTL_MS = 60000;
+    monaco.languages.registerCompletionItemProvider('javascript', {
+      triggerCharacters: ['.'],
+      provideCompletionItems: function(model, position) {
+        var line = model.getLineContent(position.lineNumber);
+        var col  = position.column - 2; // index of character just before the '.'
+        var end  = col;
+        while (col >= 0 && /[a-zA-Z0-9_$]/.test(line[col])) col--;
+        var symbol = line.slice(col + 1, end + 1);
+        if (!symbol || symbol.length < 2) return { suggestions: [] };
+        if (!discoveredJsGlobals[symbol] && !/^[A-Z]/.test(symbol)) return { suggestions: [] };
+        if (typeof FileService === 'undefined' || !FileService.getJsMembers) return { suggestions: [] };
+
+        var cached = jsMembersCache[symbol];
+        if (cached && (Date.now() - cached.ts) < JS_MEMBERS_CACHE_TTL_MS) {
+          return { suggestions: cached.suggestions };
+        }
+
+        return FileService.getJsMembers(symbol)
+          .then(function(data) {
+            var members = (data && data.members) || [];
+            var suggestions = members.map(function(m) {
+              return {
+                label: m.name,
+                kind: monaco.languages.CompletionItemKind.Method,
+                detail: symbol,
+                documentation: m.snippet,
+                insertText: m.name,
+                range: {
+                  startLineNumber: position.lineNumber, endLineNumber: position.lineNumber,
+                  startColumn: position.column, endColumn: position.column
+                }
+              };
+            });
+            jsMembersCache[symbol] = { ts: Date.now(), suggestions: suggestions };
+            return { suggestions: suggestions };
+          }).catch(function() { return { suggestions: [] }; });
+      }
+    });
+
     // Vim-style fold-marker folding provider.
     // Recognises {{{ (open) and }}} (close) anywhere in a line, matching the
     // convention used by vim's `foldmethod=marker`. Registered for every

data/app/assets/javascripts/mbeditor/file_service.js

@@ -189,6 +189,16 @@ var FileService = (function () {
     prefetchCache.delete(path);
   }
 
+  function getJsDefinition(symbol, extraOptions) {
+    var config = Object.assign({ params: { symbol: symbol }, timeout: 5000 }, extraOptions || {});
+    return axios.get(window.mbeditorBasePath() + '/js_definition', config).then(function(res) { return res.data; });
+  }
+
+  function getJsMembers(symbol, extraOptions) {
+    var config = Object.assign({ params: { symbol: symbol }, timeout: 5000 }, extraOptions || {});
+    return axios.get(window.mbeditorBasePath() + '/js_members', config).then(function(res) { return res.data; });
+  }
+
   function getModuleMembers(name, extraOptions) {
     var config = Object.assign({ params: { name: name }, timeout: 8000 }, extraOptions || {});
     return axios.get(window.mbeditorBasePath() + '/module_members', config).then(function(res) { return res.data; });
@@ -225,6 +235,8 @@ var FileService = (function () {
     saveBranchState: saveBranchState,
     pruneBranchStates: pruneBranchStates,
     getDefinition: getDefinition,
+    getJsDefinition: getJsDefinition,
+    getJsMembers: getJsMembers,
     prefetch: prefetch,
     getPrefetched: getPrefetched,
     cancelPrefetch: cancelPrefetch,

data/app/assets/javascripts/mbeditor/search_service.js

@@ -61,6 +61,7 @@ var SearchService = (function () {
 
       function traverse(nodes) {
         nodes.forEach(function(n) {
+          if (n.excluded) return; // skip excluded paths and their descendants
           if (n.type === 'file') {
             docs.push({ id: idCounter++, path: n.path, name: n.name, type: 'file' });
           } else if (n.type === 'folder') {

data/app/controllers/mbeditor/editors_controller.rb

@@ -351,6 +351,34 @@ module Mbeditor
       render json: { error: e.message }, status: :unprocessable_content
     end
 
+    # GET /mbeditor/js_definition?symbol=ReactWindow
+    # Searches workspace JS/JSX/TS/TSX files for global definitions of the named symbol.
+    def js_definition
+      symbol = params[:symbol].to_s.strip
+      return render json: { results: [] } if symbol.blank?
+      return render json: { error: "Invalid symbol" }, status: :bad_request \
+        unless symbol.match?(/\A[a-zA-Z_$][a-zA-Z0-9_$]{0,59}\z/)
+
+      results = JsDefinitionService.new(symbol, workspace_root).call
+      render json: { results: results }
+    rescue StandardError => e
+      render json: { error: e.message }, status: :unprocessable_content
+    end
+
+    # GET /mbeditor/js_members?symbol=ReactWindow
+    # Searches workspace JS/JSX/TS/TSX files for properties/methods of the named global.
+    def js_members
+      symbol = params[:symbol].to_s.strip
+      return render json: { members: [] } if symbol.blank?
+      return render json: { error: "Invalid symbol" }, status: :bad_request \
+        unless symbol.match?(/\A[a-zA-Z_$][a-zA-Z0-9_$]{0,59}\z/)
+
+      members = JsMembersService.new(symbol, workspace_root).call
+      render json: { symbol: symbol, members: members }
+    rescue StandardError => e
+      render json: { error: e.message }, status: :unprocessable_content
+    end
+
     # GET /mbeditor/module_members?name=ArticlesHelper
     # Returns methods defined in the workspace file that defines the named module/class.
     def module_members
@@ -702,7 +730,8 @@ module Mbeditor
 
     # GET /mbeditor/manifest.webmanifest — PWA manifest
     def pwa_manifest
-      base = request.script_name.to_s.sub(%r{/$}, "")
+      raw  = root_path.chomp("/")
+      base = raw.start_with?("/") || raw.empty? ? raw : "/#{raw}"
       manifest = {
         name: "Mbeditor — #{Rails.root.basename}",
         short_name: "Mbeditor",
@@ -1070,10 +1099,14 @@ module Mbeditor
         rel = relative_path(full)
 
         if File.directory?(full)
-          { name: name, type: "folder", path: rel, children: build_tree(full, depth: depth + 1) }
+          node = { name: name, type: "folder", path: rel, children: build_tree(full, depth: depth + 1) }
+          node[:excluded] = true if excluded_path?(rel, name)
+          node
         else
           size = File.size(full) rescue nil
-          { name: name, type: "file", path: rel, size: size }
+          node = { name: name, type: "file", path: rel, size: size }
+          node[:excluded] = true if excluded_path?(rel, name)
+          node
         end
       end
     rescue Errno::EACCES

data/app/services/mbeditor/js_definition_service.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module Mbeditor
+  # Searches JS/JSX/TS/TSX files in the workspace for definitions of a named
+  # JavaScript global (variable, function, class, or window property assignment).
+  #
+  # Uses ripgrep (falling back to grep) to locate lines matching common
+  # definition patterns, then returns workspace-relative results.
+  #
+  # Returns an array of hashes:
+  #   { file: String, line: Integer, snippet: String }
+  class JsDefinitionService
+    MAX_RESULTS = 20
+
+    JS_GLOBS = %w[*.js *.jsx *.ts *.tsx *.js.jsx *.js.erb *.jsx.erb].freeze
+
+    def initialize(symbol, workspace_root)
+      @symbol         = symbol.to_s
+      @workspace_root = workspace_root.to_s.chomp("/")
+    end
+
+    def call
+      return [] if @symbol.empty? || @workspace_root.empty?
+      return [] unless File.directory?(@workspace_root)
+
+      pattern = build_pattern
+      lines   = run_search(pattern)
+      parse_results(lines)
+    end
+
+    private
+
+    def build_pattern
+      s = Regexp.escape(@symbol)
+      # Matches the most common JS global-definition forms, anchored so we
+      # don't pick up every usage — only assignment / declaration lines.
+      "(?:window\\.#{s}\\s*=|\\b(?:var|let|const)\\s+#{s}[\\s=;,]|\\bfunction\\s+#{s}[\\s({]|\\bclass\\s+#{s}\\b|\\bexport\\s+(?:default\\s+)?(?:var|let|const|function|class)\\s+#{s}\\b)"
+    end
+
+    def glob_args
+      JS_GLOBS.flat_map { |g| ["-g", g] }
+    end
+
+    def run_search(pattern)
+      if rg_available?
+        run_rg(pattern)
+      else
+        run_grep(pattern)
+      end
+    end
+
+    def rg_available?
+      system("which rg > /dev/null 2>&1")
+    end
+
+    def run_rg(pattern)
+      args = ["rg", "--no-heading", "-n", "--color=never",
+              "-e", pattern] + glob_args + [@workspace_root]
+      out, = Open3.capture2(*args)
+      out.lines
+    rescue StandardError
+      []
+    end
+
+    def run_grep(pattern)
+      globs = JS_GLOBS.map { |g| "--include=#{g}" }
+      args  = ["grep", "-rn", "--color=never", "-E", pattern] + globs + [@workspace_root]
+      out, = Open3.capture2(*args)
+      out.lines
+    rescue StandardError
+      []
+    end
+
+    def parse_results(lines)
+      results = []
+      lines.each do |raw|
+        raw = raw.chomp
+        # ripgrep/grep output: /abs/path/file.js:42:  window.ReactWindow = ...
+        m = raw.match(/\A(.+?):(\d+):(.+)\z/)
+        next unless m
+
+        abs_path = m[1]
+        line_num = m[2].to_i
+        snippet  = m[3].strip
+
+        next unless abs_path.start_with?(@workspace_root)
+
+        rel_path = abs_path.delete_prefix(@workspace_root).delete_prefix("/")
+        results << { file: rel_path, line: line_num, snippet: snippet }
+        break if results.length >= MAX_RESULTS
+      end
+      results
+    end
+  end
+end

data/app/services/mbeditor/js_members_service.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module Mbeditor
+  # Searches JS/JSX/TS/TSX files for properties/methods attached to a named
+  # global object (direct assignment and prototype assignment patterns).
+  #
+  # Examples matched for symbol "ReactWindow":
+  #   ReactWindow.open = function() { ... }
+  #   ReactWindow.prototype.close = function() { ... }
+  #
+  # Returns an array of hashes:
+  #   { name: String, snippet: String }
+  class JsMembersService
+    MAX_RESULTS = 50
+
+    JS_GLOBS = %w[*.js *.jsx *.ts *.tsx *.js.jsx *.js.erb *.jsx.erb].freeze
+
+    def initialize(symbol, workspace_root)
+      @symbol         = symbol.to_s
+      @workspace_root = workspace_root.to_s.chomp("/")
+    end
+
+    def call
+      return [] if @symbol.empty? || @workspace_root.empty?
+      return [] unless File.directory?(@workspace_root)
+
+      pattern = build_pattern
+      lines   = run_search(pattern)
+      parse_results(lines)
+    end
+
+    private
+
+    def build_pattern
+      s = Regexp.escape(@symbol)
+      "#{s}\\.(?:prototype\\.)?([a-zA-Z_$][a-zA-Z0-9_$]*)\\s*="
+    end
+
+    def glob_args
+      JS_GLOBS.flat_map { |g| ["-g", g] }
+    end
+
+    def rg_available?
+      system("which rg > /dev/null 2>&1")
+    end
+
+    def run_search(pattern)
+      if rg_available?
+        run_rg(pattern)
+      else
+        run_grep(pattern)
+      end
+    end
+
+    def run_rg(pattern)
+      args = ["rg", "--no-heading", "-n", "--color=never",
+              "-e", pattern] + glob_args + [@workspace_root]
+      out, = Open3.capture2(*args)
+      out.lines
+    rescue StandardError
+      []
+    end
+
+    def run_grep(pattern)
+      globs = JS_GLOBS.map { |g| "--include=#{g}" }
+      args  = ["grep", "-rn", "--color=never", "-E", pattern] + globs + [@workspace_root]
+      out, = Open3.capture2(*args)
+      out.lines
+    rescue StandardError
+      []
+    end
+
+    def parse_results(lines)
+      results = []
+      seen    = {}
+      lines.each do |raw|
+        raw = raw.chomp
+        m = raw.match(/\A.+?:\d+:(.+)\z/)
+        next unless m
+
+        snippet = m[1].strip
+
+        # Extract member name from pattern like ReactWindow.foo = or ReactWindow.prototype.foo =
+        s = Regexp.escape(@symbol)
+        member_match = snippet.match(/#{s}\.(?:prototype\.)?([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=/)
+        next unless member_match
+
+        name = member_match[1]
+        next if seen[name]
+
+        seen[name] = true
+        results << { name: name, snippet: snippet }
+        break if results.length >= MAX_RESULTS
+      end
+      results
+    end
+  end
+end

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

@@ -7,7 +7,7 @@
   <meta name="theme-color" content="#1e1e2e" />
   <meta name="mobile-web-app-capable" content="yes" />
   <meta name="apple-mobile-web-app-capable" content="yes" />
-  <% pwa_base = request.script_name.to_s.sub(%r{/$}, '') %>
+  <% _raw_base = root_path.chomp('/'); pwa_base = (_raw_base.start_with?('/') || _raw_base.empty?) ? _raw_base : "/#{_raw_base}" %>
   <link rel="manifest" href="<%= "#{pwa_base}/manifest.webmanifest" %>" />
   <script>
     if ('serviceWorker' in navigator) {
@@ -32,7 +32,7 @@
   <script defer src="<%= asset_path('minisearch.min.js') %>"></script>
   <script defer src="<%= asset_path('marked.min.js') %>"></script>
   <!-- ── Monaco loader (sync — inline body script calls require()) ── -->
-  <% base_path = request.script_name.to_s.sub(%r{/$}, '') %>
+  <% base_path = pwa_base %>
   <script>var require = { paths: { vs: '<%= json_escape("#{base_path}/monaco-editor/vs") %>', 'monaco-editor/esm/vs': '<%= json_escape("#{base_path}/monaco-editor/vs") %>', 'monaco-vim': '<%= json_escape(asset_path("monaco-vim.js").sub(/\.js$/, "")) %>' } };</script>
   <script src="<%= "#{base_path}/monaco-editor/vs/loader.js" %>"></script>
   <!-- ── Emmet + Extra themes (non-AMD, deferred — used inside Monaco callback) ── -->

data/config/routes.rb

@@ -21,6 +21,8 @@ Mbeditor::Engine.routes.draw do
   get    'search',          to: 'editors#search'
   post   'replace_in_files', to: 'editors#replace_in_files'
   get    'definition',      to: 'editors#definition'
+  get    'js_definition',   to: 'editors#js_definition'
+  get    'js_members',      to: 'editors#js_members'
   get    'module_members',  to: 'editors#module_members'
   get    'file_includes',   to: 'editors#file_includes'
   get    'unused_methods',  to: 'editors#unused_methods'

data/lib/mbeditor/version.rb

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