sbuilder-mcp 0.17.0 → 0.17.1

package/CHANGELOG.md

@@ -6,6 +6,13 @@ All notable changes to this project are documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.17.1] - 2026-09-10
+
+### Fixed
+- sb_add and sb_import no longer store a nested node's children twice: a patch batch that gets applied more than once (as every write already is, to validate it before it lands) mutated itself on the first pass by carrying an added node by reference, so the second pass re-inserted its children into a node that already held them.
+- sb_import and sb_import_site now cap a flattened row at 12 columns and treat a grid container as wrapping rather than single-line, so a page whose content wrapper is a CSS grid (a documentation site, for example) no longer imports as one row of hundreds of slivered columns.
+- sb_import and sb_import_site now capture a `<pre>`/`<code>` block as one node instead of one node per syntax-highlighting `<span>`, so a code sample no longer arrives broken into dozens of single-token fragments.
+
 ## [0.17.0] - 2026-09-10
 
 ### Added

package/CHANGELOG.vi.md

@@ -6,6 +6,13 @@ Mọi thay đổi đáng chú ý của dự án được ghi lại trong file n
 Định dạng dựa trên [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 và dự án tuân theo [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.17.1] - 2026-09-10
+
+### Fixed
+- sb_add và sb_import giờ không còn lưu nhân đôi các con của một node lồng nhau: một batch patch bị áp dụng nhiều hơn một lần (như mọi lần ghi vẫn vậy, để kiểm tra trước khi áp thật) trước đây tự làm thay đổi chính nó ngay ở lượt đầu vì mang theo một node vừa thêm bằng tham chiếu, khiến lượt thứ hai chèn lại các con vào một node đã sẵn có chúng.
+- sb_import và sb_import_site giờ giới hạn một row được làm phẳng ở tối đa 12 cột và coi container dạng grid là tự xuống dòng thay vì nằm trên một hàng, để một trang có content wrapper là CSS grid (chẳng hạn một trang tài liệu kỹ thuật) không còn bị import thành một row hàng trăm cột mỏng dính.
+- sb_import và sb_import_site giờ lấy một khối `<pre>`/`<code>` thành một node duy nhất thay vì một node cho mỗi `<span>` tô cú pháp, để một đoạn code không còn bị vỡ thành hàng chục mảnh một-token-một-node.
+
 ## [0.17.0] - 2026-09-10
 
 ### Added

package/dist/core/patch.js

@@ -78,6 +78,16 @@ function parentOf(state, path) {
  * half-edited with nothing anywhere to say so — which is the exact failure shape
  * this whole repo exists to rule out.
  */
+/**
+ * A patch's value, detached from whatever the caller still holds.
+ *
+ * Primitives are returned as they are — a style key is a string, and cloning
+ * one on every `sb_set` would be pure cost. Only a structure can be aliased,
+ * and only an alias can be mutated behind the batch's back.
+ */
+function clone(value) {
+    return value !== null && typeof value === 'object' ? structuredClone(value) : value;
+}
 export function applyPatches(state, patches) {
     for (const p of patches) {
         if (!isSyncablePatch(p)) {
@@ -86,7 +96,27 @@ export function applyPatches(state, patches) {
         const { holder, key } = parentOf(state, p.path);
         switch (p.op) {
             case 'set':
-                holder[key] = p.value;
+                // THE VALUE IS NEVER ALIASED INTO THE DOCUMENT.
+                //
+                // `addSubtree` builds a node, emits `set nodes/<id>` carrying THAT
+                // object, and then emits `insert` patches that push child ids into
+                // `data.nodes`. Assigning the reference means the first apply MUTATES
+                // the patch's own value, so the batch is no longer the thing it was: a
+                // second apply re-establishes a node that already holds its children and
+                // then inserts them again.
+                //
+                // Applying a batch twice is not hypothetical — `applyAndSave` does it by
+                // design, once through `preview` to judge the write and once for real.
+                // Between v0.16.1 (which introduced that check) and this fix, EVERY
+                // nested `sb_add` stored each child twice, and `sb_import` three times.
+                // It is silent: the tree is well-formed, every id resolves, the save is
+                // accepted, and the page simply renders its content twice. Measured on
+                // a real import — 106 of 231 containers listing one child id three
+                // times.
+                //
+                // A copy makes the batch idempotent for this shape: the re-`set` puts a
+                // pristine node back, and the inserts that follow rebuild the same list.
+                holder[key] = clone(p.value);
                 break;
             case 'unset':
                 delete holder[key];
@@ -95,7 +125,7 @@ export function applyPatches(state, patches) {
                 const arr = holder[key];
                 if (!Array.isArray(arr))
                     break;
-                arr.splice(p.index, 0, p.value);
+                arr.splice(p.index, 0, clone(p.value));
                 break;
             }
             case 'remove': {

package/dist/vision/capture.js

@@ -183,6 +183,25 @@ function capturePage(limits) {
                 taken.nodes++;
                 return [{ kind: 'list', items }];
             }
+            // A CODE BLOCK IS ONE THING, and walking into it produces rubble.
+            //
+            // Every syntax highlighter wraps each token in its own <span>, so the leaf
+            // walk took them one at a time: a twenty-line JSON config arrived as forty
+            // separate text nodes — `{`, `"mcpServers"`, `: {` — each its own block on
+            // its own line. Measured on a real import; it also ate forty of the node
+            // budget to say what one node says.
+            //
+            // Whitespace is collapsed like any other text because this platform has no
+            // code element to preserve it in — the six kinds are what can cross — so
+            // the honest translation is one paragraph the merchant can then restyle,
+            // not a shredded imitation of a listing.
+            if (tag === 'PRE' || tag === 'CODE') {
+                const text = clean(el.textContent);
+                if (!text)
+                    return [];
+                taken.nodes++;
+                return [{ kind: 'text', text }];
+            }
             if (tag === 'P' || tag === 'BLOCKQUOTE') {
                 const text = clean(el.textContent);
                 if (!text)
@@ -197,12 +216,34 @@ function capturePage(limits) {
                     cs.display === 'inline-flex' || cs.display === 'inline-grid';
                 // A ROW is worth keeping; a column is what the page already is, so
                 // wrapping one in a group would add a level that renders identically.
-                const row = cs.display.indexOf('grid') >= 0
-                    ? true
-                    : cs.flexDirection === 'row' || cs.flexDirection === 'row-reverse';
-                if (lays && row && kids.length >= 2) {
+                const grid = cs.display.indexOf('grid') >= 0;
+                const row = grid || cs.flexDirection === 'row' || cs.flexDirection === 'row-reverse';
+                // A ROW OF 279 IS NOT A ROW.
+                //
+                // Measured on a real import of a documentation site: its content wrapper
+                // is a GRID, every grid was read as a single row, and the whole page came
+                // back as one flex row of 279 columns — each column a sliver, every line
+                // of prose broken to one word, and 80 nodes hanging past the viewport.
+                // The page was structurally perfect and visually destroyed.
+                //
+                // A design row is a feature trio, a card shelf, a logo wall: a handful of
+                // columns, chosen. Past that the container is not arranging things side
+                // by side, it is the page's own content column and the browser is
+                // wrapping it — so the honest translation is the stack it already reads
+                // as. Twelve is above any real row seen here and far below a content
+                // grid.
+                const ROW_MAX = 12;
+                if (lays && row && kids.length >= 2 && kids.length <= ROW_MAX) {
                     taken.nodes++;
-                    return [{ kind: 'group', direction: 'row', wrap: cs.flexWrap === 'wrap', children: kids }];
+                    return [{
+                            kind: 'group',
+                            direction: 'row',
+                            // A GRID ALWAYS WRAPS — that is what a grid IS — and `flexWrap` reads
+                            // `nowrap` on one because the property does not apply. Carrying that
+                            // literally gave the columns nowhere to go at any width.
+                            wrap: grid || cs.flexWrap === 'wrap',
+                            children: kids,
+                        }];
                 }
                 return kids;
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sbuilder-mcp",
-  "version": "0.17.0",
+  "version": "0.17.1",
   "description": "MCP server that designs and operates a Store Builder site — pages, data, theme and publish — through the platform's own API and live-edit protocol.",
   "mcpName": "io.github.vuluu2k/sbuilder-mcp",
   "type": "module",