mbeditor 0.14.0 → 0.14.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 89b467923bfe67c35d68e57b667357c96c4217c39fff779f5ff98911eed59f25
-  data.tar.gz: e1b82cc6eddeaec6d31f00f83eff3b3e56abba423411304c9025b68dd9efbd81
+  metadata.gz: ee847e8e0df709bf840fedf585eafa79ef7097336b60f081174d5fc464244c9d
+  data.tar.gz: b787b613243fa9848f785d9931a6464b1356ee9207b7ace7bd27c92b8ea6064f
 SHA512:
-  metadata.gz: 1e15d0215eba919681e9a435de8aeadcd3d24bbc1c9dc72f95f9036c2a39a89e39b28461d2acce844b4a9b5c2b1507318d84da3cdae62b08162f6412daa4dd8c
-  data.tar.gz: 611f9efe9f06536eb81ecf2b8f09d2da282958a17131b56baca6b47c07d10c2508a7797cba2f5469df457c2647b052a26f97a281fa8f44d7e574a2d89fe12d83
+  metadata.gz: 6e49e0b4921e6e84e4064d7c5f497f57f7ea8992671b9deb773e11adf97c77e7dd2fd6fc83e177147b03ab2d79942b08569b6284b12e75bb6d67771e27d50950
+  data.tar.gz: c55fa561506959fdd07b43dabeddab66900e82e3795cb5e4a2c264f89cec4862a298bee59e5419b4c8c61ec6a10fa74a1b699cc078aae4788cb1faad8c539297

data/CHANGELOG.md

@@ -5,6 +5,70 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.14.2] - 2026-10-20
+
+### Added
+- **Combined View picker.** One "Copy .md" / "Download .md" at the top
+  replaces the per-file buttons, above a scrollable picker with a checkbox per
+  file and, for `.rb` files, per method. Unticked files are left out; ticked
+  methods limit a file to those methods.
+- The Markdown export now opens with a `# Files` index of the included paths.
+- **Open all editors in Combined View**: a stacked-layers action on the OPEN
+  EDITORS header.
+
+### Fixed
+- **Checkboxes inside editor panes did not respond to clicks.** The pane's
+  click-capture focus handler set store state on every click, and under the
+  legacy React root that re-render reset the controlled checkbox before React
+  saw it change. Focusing is now a no-op when nothing changes, and happens on
+  mousedown.
+- **The editor right-click menu was dim and unreadable** (since Monaco 0.57):
+  it rendered in a shadow root the theme's `--vscode-*` variables cannot reach.
+  Editors now use `useShadowDOM: false`.
+- **The explorer's workspace header went transparent on hover** with Liquid
+  Glass off, letting the scrolled tree show through.
+
+## [0.14.1] - 2026-10-19
+
+### Added
+- **Combined View.** Ctrl/Cmd-select files or folders in the explorer, right-click,
+  "Open in Combined View": every file on one scrolling page under its path, with
+  Copy and Download per file. Folders expand recursively; capped at 200 files with
+  a visible note. The tab is virtual and is not restored on reload.
+- **Method picking and Markdown export.** In Combined View, Ruby files get a
+  method checklist; "Download .md" / "Copy .md" bundle the view into one file,
+  method-limited files keeping their `class`/`module` skeleton with `# ...`
+  between pieces. Built for chat assistants that take only a few attachments.
+- **Paste & Place** (editor context menu or F1, Ruby). Paste methods from a
+  chat reply and mbeditor finds where each goes: the active file, then a repo
+  search for `def name` narrowed by class. New methods go into the file that
+  holds the class, before `private`. Diff preview first; Apply is one undoable
+  edit in the buffer and nothing is saved.
+- **Compare on upload conflicts.** When an upload or drop would overwrite a
+  file, each text file gets a "Compare" diff of disk vs incoming.
+- `POST /ruby_methods`: Ripper-based method ranges (owner, singleton, doc
+  comment start) behind the two features above.
+- A help-panel section describing all of the above.
+
+### Fixed
+- **Unreadable status bar and buttons.** The Liquid Glass status bar and the
+  title-bar buttons painted "text on the accent fill" onto panel-coloured
+  surfaces; glass also hid the amber pending-migration background; Dracula,
+  Night Owl and Tomorrow Night had white text on light accents. 44 combinations
+  (11 themes × glass × pending) now all clear 4.5:1 on the status bar.
+- **Flicker while migrations are pending.** `/cable` was not covered by the
+  pending-migration bypass, so every reconnect raised and the live channel
+  (presence, collaboration, file-change push) stayed dead.
+- Paste & Place searches use POSIX classes, because the `git grep` search tier
+  is ERE and silently matches nothing for `\s`.
+
+### Changed
+- **Monaco 0.57.0** (from 0.55.1). Its TypeScript API moved from
+  `monaco.languages.typescript` to `monaco.typescript`; every call site is
+  migrated. DOMPurify inside Monaco is still 3.4.15 (advisory rated low) until a
+  Monaco release ships 3.4.16+.
+- **axios 1.20.0** (from 1.17.0 vendored), for new high-severity advisories.
+
 ## [0.14.0] - 2026-09-21
 
 ### Added

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

@@ -26,6 +26,7 @@
 //= require mbeditor/components/CommitGraph
 //= require mbeditor/components/ModelGraph
 //= require mbeditor/components/ChangelogView
+//= require mbeditor/components/CombinedFileView
 //= require mbeditor/components/FileHistoryPanel
 //= require mbeditor/components/TestResultsPanel
 //= require mbeditor/components/LogPanel
@@ -42,5 +43,6 @@
 // whole app down the first time it renders.
 //= require mbeditor/components/ImportConflictModal
 //= require mbeditor/components/ImportDialog
+//= require mbeditor/components/PastePlaceModal
 //= require mbeditor/components/MbeditorApp
 //= require mbeditor/application_iife_tail

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

@@ -0,0 +1,228 @@
+"use strict";
+
+// CombinedFileView — read-only stack of several files on one scrolling page.
+// `paths` are workspace-relative file paths (already capped by the caller);
+// `total` is the pre-cap count so truncation is shown, never silent.
+
+(function() {
+  var useEffect = React.useEffect;
+  var useState = React.useState;
+  var CONCURRENCY = 6;
+
+  function languageFor(path) {
+    if (!(window.monaco && monaco.editor && monaco.editor.colorize)) return null;
+    var m = /\.[^./]+$/.exec(path);
+    if (!m) return null;
+    var ext = m[0].toLowerCase();
+    var lang = monaco.languages.getLanguages().find(function (l) { return (l.extensions || []).indexOf(ext) !== -1; });
+    return lang ? lang.id : null;
+  }
+
+  function copyText(text, okMsg, failMsg) {
+    if (!navigator.clipboard) return;
+    navigator.clipboard.writeText(text).then(
+      function () { EditorStore.setStatus(okMsg, 'info'); },
+      function () { EditorStore.setStatus(failMsg, 'error'); }
+    );
+  }
+
+  function indentOf(line) { return /^\s*/.exec(line || '')[0]; }
+
+  // The selected methods (indexes into info.methods) with the class/module
+  // skeleton that holds them, in source order. Pieces that are not adjacent
+  // inside the same owner are separated by a `# ...` line.
+  function methodSlice(content, info, picked) {
+    var lines = content.split('\n');
+    var out = [];
+    var open = [];
+    var prev = null;
+    function contains(o, m) { return o.start_line <= m.start_line && o.end_line >= m.end_line; }
+    function close(n) {
+      while (open.length > n) { var o = open.pop(); out.push(indentOf(lines[o.start_line - 1]) + 'end'); }
+    }
+    info.methods.filter(function (m, i) { return picked[i]; })
+      .sort(function (a, b) { return a.start_line - b.start_line; })
+      .forEach(function (m) {
+        var chain = info.owners.filter(function (o) { return contains(o, m); });
+        var keep = 0;
+        while (keep < open.length && keep < chain.length && open[keep] === chain[keep]) keep++;
+        close(keep);
+        var reopened = open.length < chain.length;
+        for (var k = open.length; k < chain.length; k++) { out.push(lines[chain[k].start_line - 1]); open.push(chain[k]); }
+        if (prev && !reopened && m.doc_start_line > prev.end_line + 1) out.push(indentOf(lines[m.start_line - 1]) + '# ...');
+        else if (prev && !reopened) out.push('');
+        out.push.apply(out, lines.slice(m.doc_start_line - 1, m.end_line));
+        prev = m;
+      });
+    close(0);
+    return out.join('\n');
+  }
+
+  function fenceFor(text) {
+    var f = '```';
+    while (text.indexOf(f) !== -1) f += '`';
+    return f;
+  }
+
+  // paths: ordered file paths; files: path -> loaded entry; info: path -> {methods, owners};
+  // picked: path -> {methodIndex: true}; excluded: path -> true. A file with any picked
+  // method exports only those. Returns '' when no loaded file is included.
+  function buildMarkdown(paths, files, info, picked, excluded) {
+    var index = [];
+    var parts = [];
+    paths.forEach(function (path) {
+      var e = files[path];
+      if (excluded[path] || !e || e.content == null) return;
+      var sel = picked[path] || {};
+      var body = e.content;
+      var line = '- ' + path;
+      if (info[path] && info[path].methods && Object.keys(sel).some(function (k) { return sel[k]; })) {
+        body = methodSlice(e.content, info[path], sel);
+        line += ' (methods: ' + info[path].methods.filter(function (m, i) { return sel[i]; }).map(function (m) { return m.name; }).join(', ') + ')';
+      }
+      index.push(line);
+      var fence = fenceFor(body);
+      var ext = (/\.([^./]+)$/.exec(path) || [])[1] || '';
+      var lang = { rb: 'ruby', js: 'javascript', jsx: 'jsx', ts: 'typescript', tsx: 'tsx', yml: 'yaml', md: 'markdown', sh: 'bash' }[ext] || ext;
+      parts.push('## ' + path + '\n\n' + fence + lang + '\n' + body.replace(/\n$/, '') + '\n' + fence + '\n');
+    });
+    return index.length ? '# Files\n' + index.join('\n') + '\n\n' + parts.join('\n') : '';
+  }
+
+  function bundleName() {
+    return 'mbeditor-bundle-' + new Date().toISOString().replace(/[-:]/g, '').replace(/\..*$/, '').replace('T', '-') + '.md';
+  }
+
+  function downloadText(text, filename) {
+    var objectUrl = URL.createObjectURL(new Blob([text], { type: 'text/markdown' }));
+    var link = document.createElement('a');
+    link.href = objectUrl;
+    link.download = filename;
+    link.rel = 'noopener';
+    document.body.appendChild(link);
+    link.click();
+    document.body.removeChild(link);
+    // Revoking in the same tick can free the blob before the browser has
+    // started reading it, which cancels the download instead of saving it.
+    setTimeout(function () { URL.revokeObjectURL(objectUrl); }, 60000);
+    EditorStore.setStatus('Downloading ' + filename + '...', 'info');
+  }
+
+  var CombinedFileView = function CombinedFileView(props) {
+    var paths = props.paths;
+    var _s = useState({});
+    var files = _s[0];
+    var setFiles = _s[1];
+    var _m = useState({});
+    var info = _m[0];
+    var setInfo = _m[1];
+    var asked = React.useRef({});
+    var _p = useState({});
+    var picked = _p[0];
+    var setPicked = _p[1];
+
+    // Method ranges for Ruby files, fetched once each file has loaded. No
+    // cancel-on-rerun: every file load re-runs this, and cancelling would drop
+    // the requests still in flight. The view is keyed per tab, so paths never
+    // change underneath it.
+    useEffect(function () {
+      paths.forEach(function (path) {
+        if (!/\.rb$/.test(path) || !files[path] || files[path].content == null || asked.current[path]) return;
+        asked.current[path] = true;
+        FileService.getRubyMethods(files[path].content).then(function (r) {
+          setInfo(function (prev) { var o = Object.assign({}, prev); o[path] = r.error ? { error: r.error } : r; return o; });
+        }, function () {
+          setInfo(function (prev) { var o = Object.assign({}, prev); o[path] = { error: 'Could not read methods' }; return o; });
+        });
+      });
+    }, [paths, files]);
+
+    var _x = useState({});
+    var excluded = _x[0];
+    var setExcluded = _x[1];
+
+    var toggle = function (path, i) {
+      setPicked(function (prev) {
+        var o = Object.assign({}, prev);
+        var sel = Object.assign({}, o[path] || {});
+        if (sel[i]) delete sel[i]; else sel[i] = true;
+        o[path] = sel;
+        return o;
+      });
+      setExcluded(function (prev) { var o = Object.assign({}, prev); delete o[path]; return o; });
+    };
+
+    var toggleFile = function (path) {
+      setExcluded(function (prev) { var o = Object.assign({}, prev); if (o[path]) delete o[path]; else o[path] = true; return o; });
+    };
+
+    var exportMd = function (action) {
+      var md = buildMarkdown(paths, files, info, picked, excluded);
+      if (!md) { EditorStore.setStatus('No files selected', 'info'); return; }
+      action(md);
+    };
+
+    useEffect(function () {
+      var cancelled = false;
+      var next = 0;
+      function put(path, entry) {
+        if (!cancelled) setFiles(function (prev) { var o = Object.assign({}, prev); o[path] = entry; return o; });
+      }
+      function worker() {
+        if (cancelled || next >= paths.length) return Promise.resolve();
+        var path = paths[next++];
+        return FileService.getFile(path).then(function (data) {
+          if (data && data.image) { put(path, { note: 'Image file, not shown' }); return; }
+          if (!data || typeof data.content !== 'string') { put(path, { note: 'Binary or unreadable file, not shown' }); return; }
+          var lang = languageFor(path);
+          if (!lang) { put(path, { content: data.content }); return; }
+          return monaco.editor.colorize(data.content, lang, { tabSize: 2 }).then(
+            function (html) { put(path, { content: data.content, html: html }); },
+            function () { put(path, { content: data.content }); }
+          );
+        })['catch'](function () { put(path, { note: 'Could not load file' }); }).then(worker);
+      }
+      for (var i = 0; i < CONCURRENCY; i++) worker();
+      return function () { cancelled = true; };
+    }, [paths]);
+
+    return React.createElement('div', { className: 'combined-view' },
+      React.createElement('div', { className: 'combined-toolbar' },
+        React.createElement('button', { type: 'button', className: 'combined-file-btn', onClick: function () { exportMd(function (md) { copyText(md, 'Copied Markdown bundle', 'Could not copy Markdown bundle'); }); } }, 'Copy .md'),
+        React.createElement('button', { type: 'button', className: 'combined-file-btn', onClick: function () { exportMd(function (md) { downloadText(md, bundleName()); }); } }, 'Download .md')
+      ),
+      React.createElement('div', { className: 'combined-picker' },
+        paths.map(function (path) {
+          var methods = info[path] && info[path].methods;
+          return React.createElement('div', { key: path },
+            React.createElement('label', { className: 'combined-pick-file' },
+              React.createElement('input', { type: 'checkbox', checked: !excluded[path], onChange: function () { toggleFile(path); } }),
+              path),
+            methods && methods.map(function (m, i) {
+              var label = (m.owner ? m.owner + (m.singleton ? '.' : '#') : (m.singleton ? '.' : '#')) + m.name;
+              return React.createElement('label', { key: i, className: 'combined-pick-method', title: 'lines ' + m.start_line + '-' + m.end_line },
+                React.createElement('input', { type: 'checkbox', checked: !!(picked[path] && picked[path][i]), onChange: function () { toggle(path, i); } }),
+                label);
+            })
+          );
+        })
+      ),
+      props.total > paths.length && React.createElement('div', { className: 'combined-note' },
+        'Showing the first ' + paths.length + ' of ' + props.total + ' files.'),
+      paths.map(function (path) {
+        var e = files[path];
+        return React.createElement('section', { key: path, className: 'combined-file' },
+          React.createElement('div', { className: 'combined-file-header' },
+            React.createElement('span', { className: 'combined-file-path' }, path)
+          ),
+          !e ? React.createElement('div', { className: 'combined-note' }, 'Loading...') :
+            e.note ? React.createElement('div', { className: 'combined-note' }, e.note) :
+            e.html ? React.createElement('pre', { className: 'combined-file-body', dangerouslySetInnerHTML: { __html: e.html } }) :
+            React.createElement('pre', { className: 'combined-file-body' }, e.content)
+        );
+      })
+    );
+  };
+
+  window.CombinedFileView = CombinedFileView;
+})();

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

@@ -39,7 +39,8 @@ var DiffViewer = function DiffViewer(_ref) {
       scrollBeyondLastLine: false,
       fontFamily: editorPrefs.fontFamily || "'JetBrains Mono', 'Fira Code', 'Menlo', 'Consolas', monospace",
       fontSize: editorPrefs.fontSize || 13,
-      wordWrap: editorPrefs.wordWrap || 'off'
+      wordWrap: editorPrefs.wordWrap || 'off',
+      useShadowDOM: false // same unthemed-context-menu reason as EditorPanel
     });
 
     diffEditor.setModel({

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

@@ -661,6 +661,11 @@ var EditorPanel = function EditorPanel(_ref) {
       acceptSuggestionOnEnter: editorPrefs.acceptSuggestionOnEnter || 'on',
       linkedEditing: true,
       fixedOverflowWidgets: true,
+      // The context menu otherwise renders in a shadow root hung off our
+      // container, out of reach of the theme's --vscode-* variables (they live
+      // on .monaco-editor/.monaco-component), so it drew transparent with black
+      // text. Light DOM puts it in .context-view.monaco-component, which is themed.
+      useShadowDOM: false,
       hover: { above: false }
     });
 
@@ -792,6 +797,17 @@ var EditorPanel = function EditorPanel(_ref) {
       }
     });
 
+    // Paste & Place: Ruby only. An editor action gets the context-menu entry and
+    // the F1 command palette listing without another toolbar button.
+    var pastePlaceDisposable = editor.addAction({
+      id: 'mbeditor.pastePlace',
+      label: 'Paste & Place Ruby Method...',
+      precondition: 'editorLangId == ruby',
+      contextMenuGroupId: 'navigation',
+      contextMenuOrder: 1.7,
+      run: function() { EditorStore.setState({ isPastePlaceVisible: true }); }
+    });
+
     // No custom "Format Document" action: Ruby now has a real formatting
     // provider, so Monaco contributes that context-menu entry itself, and a
     // second one of our own showed up as a duplicate. Languages with no
@@ -1139,6 +1155,7 @@ var EditorPanel = function EditorPanel(_ref) {
       if (editorPluginDisposable) editorPluginDisposable.dispose();
       if (formatActionDisposable) formatActionDisposable.dispose();
       runTestAtCursorDisposable.dispose();
+      pastePlaceDisposable.dispose();
       columnSelectDisposable.dispose();
       contentDisposable.dispose();
       EditorStore.setState({ canUndo: false, canRedo: false });
@@ -2183,7 +2200,7 @@ var EditorPanel = function EditorPanel(_ref) {
   // our own, which makes it async — the worker is where the parse already
   // lives, and it tracks the live buffer, so unsaved edits are included.
   function loadJsOutline(model) {
-    var ts = window.monaco && window.monaco.languages && window.monaco.languages.typescript;
+    var ts = window.monaco && window.monaco.typescript;
     if (!ts || !window.JsOutline) return Promise.reject(new Error('outline unavailable'));
 
     var workerFor = model.getLanguageId() === 'typescript' ? ts.getTypeScriptWorker : ts.getJavaScriptWorker;

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

@@ -58,13 +58,51 @@ window.useModalFocusTrap = function useModalFocusTrap(modalRef, onDismiss) {
   }, [onDismiss]);
 };
 
+// Compare is offered only for files that look like text and are small enough
+// to diff in a modal. file.type is '' for most source files, so this rules
+// out the known-binary families rather than requiring a text/* type.
+var COMPARE_MAX_BYTES = 512 * 1024;
+function canCompare(file) {
+  if (!file || file.size > COMPARE_MAX_BYTES) return false;
+  return !/^(image|audio|video|font)\/|^application\/(octet-stream|zip|pdf|gzip|x-)/.test(file.type || '');
+}
+
 var ImportConflictModal = function ImportConflictModal(_ref) {
   var conflicts = _ref.conflicts || [];
   var errors = _ref.errors || [];
   var onResolve = _ref.onResolve;
   var modalRef = React.useRef(null);
+  var _cmp = React.useState(null);
+  var compare = _cmp[0];
+  var setCompare = _cmp[1];
+
+  // Incoming file per conflicting target path.
+  var incoming = React.useMemo(function () {
+    var byPath = {};
+    FileImport.conflictedEntries(_ref.entries || [], _ref.targetFolderPath, conflicts).forEach(function (e) {
+      byPath[FileImport.joinPath(_ref.targetFolderPath, e.relativePath)] = e.file;
+    });
+    return byPath;
+  }, [_ref.entries, _ref.targetFolderPath, conflicts]);
 
-  window.useModalFocusTrap(modalRef, React.useCallback(function () { onResolve('skip'); }, [onResolve]));
+  // Escape closes an open comparison first; only then does it mean skip.
+  var dismiss = React.useCallback(function () {
+    if (compare) setCompare(null); else onResolve('skip');
+  }, [onResolve, compare]);
+  window.useModalFocusTrap(modalRef, dismiss);
+
+  var openCompare = function (path) {
+    var file = incoming[path];
+    setCompare({ path: path, loading: true });
+    Promise.all([FileService.getFile(path), file.text()]).then(function (r) {
+      var current = r[0] && r[0].content;
+      if (typeof current !== 'string' || r[1].indexOf('\u0000') !== -1) {
+        setCompare({ path: path, note: 'Binary or unreadable file, cannot compare.' });
+      } else {
+        setCompare({ path: path, original: current, modified: r[1] });
+      }
+    }, function () { setCompare({ path: path, note: 'Could not load the current file.' }); });
+  };
 
   var button = function (label, mode, className) {
     return React.createElement(
@@ -84,7 +122,7 @@ var ImportConflictModal = function ImportConflictModal(_ref) {
       'div',
       {
         ref: modalRef,
-        className: 'schema-modal import-conflict-modal',
+        className: 'schema-modal import-conflict-modal' + (compare ? ' import-conflict-wide' : ''),
         role: 'dialog',
         'aria-modal': 'true',
         'aria-label': 'Resolve import conflicts',
@@ -95,16 +133,33 @@ var ImportConflictModal = function ImportConflictModal(_ref) {
         'div', { className: 'schema-modal-header' },
         React.createElement(
           'div', { className: 'schema-modal-title' },
-          conflicts.length + ' file' + (conflicts.length === 1 ? '' : 's') + ' already exist' +
+          compare ? 'Current (left) vs incoming (right)' : conflicts.length + ' file' + (conflicts.length === 1 ? '' : 's') + ' already exist' +
             (conflicts.length === 1 ? 's' : '')
         )
       ),
-      React.createElement(
+      compare && React.createElement(
+        'div', { className: 'schema-modal-body import-conflict-compare-body' },
+        React.createElement('button', { type: 'button', className: 'import-conflict-btn', onClick: function () { setCompare(null); } }, 'Back'),
+        compare.original != null
+          ? React.createElement('div', { className: 'import-conflict-diff' },
+              React.createElement(window.DiffViewer, {
+                path: compare.path, original: compare.original, modified: compare.modified,
+                isDark: _ref.isDark, editorPrefs: _ref.editorPrefs
+              }))
+          : React.createElement('div', { className: 'combined-note' }, compare.note || 'Loading...')
+      ),
+      !compare && React.createElement(
         'div', { className: 'schema-modal-body' },
         React.createElement(
           'ul', { className: 'import-conflict-list' },
           conflicts.map(function (c) {
-            return React.createElement('li', { key: c.path, title: c.path }, c.path);
+            return React.createElement('li', { key: c.path, title: c.path },
+              c.path,
+              canCompare(incoming[c.path]) && React.createElement('button', {
+                type: 'button', className: 'import-conflict-compare',
+                onClick: function () { openCompare(c.path); }
+              }, 'Compare')
+            );
           })
         ),
         errors.length > 0 && React.createElement(