mbeditor 0.12.7 → 0.12.9

data/app/services/mbeditor/js_syntax_check_service.rb

@@ -14,6 +14,153 @@ module Mbeditor
     # V8 heap grows across transforms; recreate the context periodically.
     MAX_CHECKS_PER_CONTEXT = 50
     BABEL_ASSET_CANDIDATES = %w[babel.min.js babel.js babel-standalone.js babel-standalone.min.js].freeze
+    MAX_SCOPE_FINDINGS = 50
+
+    # Names defined by the browser rather than by any workspace file. ES
+    # builtins (Array, Promise, ...) are NOT listed: babel's own
+    # Scope#hasBinding already knows them, so this only needs the DOM layer.
+    BROWSER_GLOBALS = %w[
+      window document navigator location history screen console
+      alert confirm prompt getComputedStyle matchMedia scrollTo scrollBy
+      innerWidth innerHeight devicePixelRatio
+      fetch Headers Request Response XMLHttpRequest WebSocket EventSource
+      FormData URL URLSearchParams Blob File FileReader FileList DataTransfer
+      AbortController AbortSignal DOMParser XMLSerializer
+      setTimeout setInterval clearTimeout clearInterval
+      requestAnimationFrame cancelAnimationFrame requestIdleCallback cancelIdleCallback
+      queueMicrotask structuredClone atob btoa
+      localStorage sessionStorage indexedDB crypto performance
+      Event CustomEvent KeyboardEvent MouseEvent TouchEvent ErrorEvent
+      MessageEvent PopStateEvent StorageEvent ProgressEvent ClipboardEvent
+      MutationObserver ResizeObserver IntersectionObserver
+      Node NodeList Element HTMLElement SVGElement Image Audio Option
+      CSS customElements
+    ].freeze
+
+    # The React UMD globals plus the bare hook aliases host apps conventionally
+    # pull out of React at the top of a Sprockets bundle.
+    REACT_GLOBALS = %w[
+      React ReactDOM PropTypes
+      useState useEffect useLayoutEffect useRef useMemo useCallback useContext
+      useReducer useId useTransition useDeferredValue useSyncExternalStore
+      useImperativeHandle useDebugValue
+    ].freeze
+
+    # Installed into the V8 context alongside babel-standalone. collect()
+    # returns a file's top-level declaration names (Sprockets concatenates
+    # every file into one scope, so these are the cross-file globals). lint()
+    # reports references babel can bind to no scope and no whitelist entry,
+    # plus bindings that are only ever assigned inside a
+    # useEffect/useLayoutEffect callback but read during render.
+    LINT_HELPERS_JS = <<~'JS'
+      (function () {
+        if (globalThis.__mbLint) return;
+        if (typeof Babel === "undefined" || !Babel.packages || !Babel.packages.parser || !Babel.packages.traverse) return;
+        var parser = Babel.packages.parser;
+        var traverse = Babel.packages.traverse["default"] || Babel.packages.traverse;
+
+        function parse(source) {
+          return parser.parse(source, { sourceType: "script", plugins: ["jsx"], errorRecovery: true });
+        }
+
+        function bindNames(node, out) {
+          if (!node) return;
+          switch (node.type) {
+            case "Identifier": out.push(node.name); break;
+            case "ObjectPattern": node.properties.forEach(function (p) { bindNames(p.value || p.argument, out); }); break;
+            case "ArrayPattern": node.elements.forEach(function (el) { bindNames(el, out); }); break;
+            case "AssignmentPattern": bindNames(node.left, out); break;
+            case "RestElement": bindNames(node.argument, out); break;
+          }
+        }
+
+        // Is this path inside the callback argument of useEffect/useLayoutEffect?
+        function insideEffectCallback(path) {
+          var fn = path.getFunctionParent();
+          while (fn) {
+            var parent = fn.parentPath;
+            if (parent && parent.isCallExpression() && parent.node.arguments[0] === fn.node) {
+              var callee = parent.node.callee;
+              var name = callee.type === "Identifier" ? callee.name
+                : (callee.type === "MemberExpression" && !callee.computed && callee.property.type === "Identifier"
+                    ? callee.property.name : null);
+              if (name === "useEffect" || name === "useLayoutEffect") return true;
+            }
+            fn = fn.getFunctionParent();
+          }
+          return false;
+        }
+
+        globalThis.__mbLint = {
+          collect: function (source) {
+            var names = [];
+            var ast;
+            try { ast = parse(source); } catch (e) { return names; }
+            ast.program.body.forEach(function (node) {
+              if (node.type === "VariableDeclaration") {
+                node.declarations.forEach(function (d) { bindNames(d.id, names); });
+              } else if (node.type === "FunctionDeclaration" || node.type === "ClassDeclaration") {
+                if (node.id) names.push(node.id.name);
+              }
+            });
+            return names;
+          },
+
+          lint: function (source, whitelist, max) {
+            var findings = [];
+            var wl = {};
+            whitelist.forEach(function (n) { wl[n] = true; });
+            var ast;
+            try { ast = parse(source); } catch (e) { return findings; }
+            var seen = {};
+
+            try {
+              traverse(ast, {
+                ReferencedIdentifier: function (p) {
+                  if (findings.length >= max) { p.stop(); return; }
+                  var name = p.node.name;
+                  if (p.isJSXIdentifier() && !/^[A-Z]/.test(name)) return; // <div>, <span>
+                  if (wl[name]) return;
+                  if (p.scope.hasBinding(name)) return; // includes ES builtins
+                  if (p.parentPath && p.parentPath.isUnaryExpression({ operator: "typeof" })) return;
+                  var loc = p.node.loc && p.node.loc.start;
+                  var key = name + ":" + (loc ? loc.line : 0);
+                  if (seen[key]) return;
+                  seen[key] = true;
+                  findings.push({
+                    kind: "undeclared", name: name,
+                    line: loc ? loc.line : 1, column: loc ? loc.column : 0,
+                    message: "'" + name + "' is not defined in any reachable scope"
+                  });
+                },
+
+                Function: function (p) {
+                  if (findings.length >= max) { p.stop(); return; }
+                  var bindings = p.scope.bindings;
+                  Object.keys(bindings).forEach(function (name) {
+                    var b = bindings[name];
+                    if (b.kind !== "let" && b.kind !== "var") return;
+                    if (!b.path.isVariableDeclarator() || b.path.node.init) return;
+                    var writes = b.constantViolations || [];
+                    if (!writes.length) return;
+                    if (!writes.every(insideEffectCallback)) return;
+                    var renderReads = (b.referencePaths || []).filter(function (r) { return !insideEffectCallback(r); });
+                    if (!renderReads.length) return;
+                    var loc = renderReads[0].node.loc && renderReads[0].node.loc.start;
+                    findings.push({
+                      kind: "effect", name: name,
+                      line: loc ? loc.line : 1, column: loc ? loc.column : 0,
+                      message: "'" + name + "' is only assigned inside an effect but read during render — undefined on first render"
+                    });
+                  });
+                }
+              });
+            } catch (e) { /* traversal blew up on odd input — report what we have */ }
+            return findings;
+          }
+        };
+      })();
+    JS
 
     MUTEX = Mutex.new
     private_constant :MUTEX
@@ -62,11 +209,43 @@ module Mbeditor
         end
       end
 
+      # Babel-based scope lint: warnings for identifier references that bind to
+      # no scope, no top-level declaration anywhere in the workspace's own JS
+      # (Sprockets: one shared scope), no known window.X global, and no
+      # browser/React name — the typos Monaco's TS worker misses once ambient
+      # globals are declared. Plus the effect-write/render-read hazard.
+      # Report-only; returns [] whenever anything is unavailable or fails.
+      def scope_lint(workspace_root, source)
+        return [] unless available? && Mbeditor.configuration.js_scope_lint != false
+
+        MUTEX.synchronize do
+          begin
+            ctx = context
+            return [] unless ctx
+
+            ctx.eval(LINT_HELPERS_JS) unless @lint_helpers_loaded
+            @lint_helpers_loaded = true
+            return [] unless ctx.eval("typeof __mbLint !== 'undefined'")
+
+            names = whitelist(ctx, workspace_root)
+            findings = ctx.eval("__mbLint.lint(#{source.to_json}, #{names.to_json}, #{MAX_SCOPE_FINDINGS})")
+
+            @checks_run = (@checks_run || 0) + 1
+            reset_context! if @checks_run >= MAX_CHECKS_PER_CONTEXT
+            Array(findings).select { |f| f.is_a?(Hash) }
+          rescue StandardError
+            reset_context!
+            []
+          end
+        end
+      end
+
       # Exposed for tests.
       def reset!
         MUTEX.synchronize do
           reset_context!
           @babel_path = :unresolved
+          @decl_cache = nil
         end
       end
 
@@ -91,6 +270,39 @@ module Mbeditor
       def reset_context!
         @context = nil
         @checks_run = 0
+        @lint_helpers_loaded = false
+      end
+
+      # Cross-file whitelist: every top-level declaration in the workspace's
+      # own JS program, every window.X-style global JsGlobalsService knows,
+      # plus the browser and React layers. Per-file declaration names are
+      # cached by content digest, so a steady-state save re-parses only the
+      # files that changed since the last lint.
+      def whitelist(ctx, workspace_root)
+        names = []
+        @decl_cache ||= {}
+        live = {}
+
+        program = JsProgramService.call(workspace_root.to_s)
+        Array(program[:files]).each do |f|
+          digest = f[:content].hash
+          entry = @decl_cache[f[:path]]
+          entry = { digest: digest, names: collect_names(ctx, f[:content]) } unless entry && entry[:digest] == digest
+          live[f[:path]] = entry
+          names.concat(entry[:names])
+        end
+        @decl_cache = live
+
+        globals = JsGlobalsService.call(workspace_root.to_s)
+        names.concat(Array(globals[:symbols]).map { |s| s[:name].to_s })
+
+        (names + BROWSER_GLOBALS + REACT_GLOBALS).uniq
+      end
+
+      def collect_names(ctx, source)
+        Array(ctx.eval("__mbLint.collect(#{source.to_json})")).grep(String)
+      rescue StandardError
+        []
       end
 
       def babel_source_path

data/app/services/mbeditor/search_replace_service.rb

@@ -229,11 +229,20 @@ module Mbeditor
           end
         end
 
+        # Used to locate the match within each hit line so a result can carry
+        # its columns. Invalid user regexes are already reported elsewhere;
+        # here a nil pattern just means the rows come back without columns.
+        pattern = begin
+          build_pattern(query, use_regex: use_regex, match_case: match_case, whole_word: whole_word)
+        rescue RegexpError
+          nil
+        end
+
         begin
           io.each_line do |raw|
             break if results.length >= max
 
-            row = parse_line(tier, raw, root)
+            row = parse_line(tier, raw, root, pattern)
             next unless row
             next if matcher.excluded?(row[:file])
 
@@ -297,9 +306,11 @@ module Mbeditor
           # 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.
+          # The "." anchor is required: newer git reads a pathspec list of
+          # nothing but :(exclude) entries as "everything except these", but
+          # older git refuses it outright ("fatal: There is nothing to exclude
+          # from"), exits 128, and search silently returns empty.
+          args << "." if paths.nil? && exclusions.any?
           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.
@@ -334,7 +345,7 @@ module Mbeditor
         end
       end
 
-      def parse_line(tier, raw, root)
+      def parse_line(tier, raw, root, pattern = nil)
         if tier == :rg
           begin
             data = JSON.parse(raw)
@@ -344,11 +355,23 @@ module Mbeditor
           return nil unless data["type"] == "match"
 
           md = data["data"]
+          raw_text = md.dig("lines", "text").to_s
+          # rg reports submatch offsets in BYTES; Monaco columns are character
+          # based, so slice the prefix and measure it as characters.
+          sub = Array(md["submatches"]).first
+          cols = if sub && sub["start"] && sub["end"]
+            bytes = raw_text.dup.force_encoding(Encoding::BINARY)
+            start_chars = bytes[0, sub["start"]].to_s.force_encoding(Encoding::UTF_8).scrub.length
+            match_chars = bytes[sub["start"], sub["end"] - sub["start"]].to_s.force_encoding(Encoding::UTF_8).scrub.length
+            { col: start_chars + 1, end_col: start_chars + match_chars + 1 }
+          else
+            match_columns(raw_text, pattern)
+          end
           return {
             file: relative_path(md.dig("path", "text").to_s, root),
             line: md.dig("line_number"),
-            text: md.dig("lines", "text").to_s.strip
-          }
+            text: raw_text.strip
+          }.merge(cols)
         end
 
         # git grep / grep emit "path:line:text" — possibly with bytes that are
@@ -365,7 +388,25 @@ module Mbeditor
           file_path = relative_path(file_path, root)
         end
 
-        { file: file_path, line: Regexp.last_match(2).to_i, text: Regexp.last_match(3).strip }
+        raw_text = Regexp.last_match(3)
+        { file: file_path, line: Regexp.last_match(2).to_i, text: raw_text.strip }
+          .merge(match_columns(raw_text, pattern))
+      end
+
+      # 1-based Monaco columns for the first match on a hit line. Returns an
+      # empty hash when there is no usable pattern or it doesn't match — the
+      # row is still a valid result, it just opens at the start of the line.
+      # Measured against the RAW line, never the stripped `text`: the client
+      # cannot recover the leading whitespace the strip removed.
+      def match_columns(raw_text, pattern)
+        return {} unless pattern
+
+        m = pattern.match(raw_text)
+        return {} unless m
+
+        { col: m.begin(0) + 1, end_col: m.end(0) + 1 }
+      rescue StandardError
+        {}
       end
 
       def register_search(root, pid)

data/lib/mbeditor/configuration.rb

@@ -10,7 +10,7 @@ module Mbeditor
                   :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,
+                  :js_syntax_check, :babel_standalone_path, :js_scope_lint,
                   :ruby_lsp, :ruby_lsp_command, :ruby_lsp_timeout,
                   :exception_capture, :model_graph_max_models,
                   :search_respect_gitignore, :ripgrep_command
@@ -84,6 +84,7 @@ module Mbeditor
       # 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
+      @js_scope_lint   = true  # save-time undeclared-identifier warnings (needs js_syntax_check active); 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

data/lib/mbeditor/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mbeditor
 version: !ruby/object:Gem::Version
-  version: 0.12.7
+  version: 0.12.9
 platform: ruby
 authors:
 - Oliver Noonan
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-08-06 00:00:00.000000000 Z
+date: 2026-08-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails