@shadow-garden/bapbong-mcp 0.1.0

package/dist/session.cjs

@@ -0,0 +1,372 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// packages/mcp/src/session.ts
+var session_exports = {};
+__export(session_exports, {
+  AnchorError: () => AnchorError,
+  NoDocumentError: () => NoDocumentError,
+  PmDocSession: () => PmDocSession,
+  RemoteSession: () => RemoteSession,
+  VersionConflictError: () => VersionConflictError,
+  executeOp: () => executeOp,
+  reviveError: () => reviveError
+});
+module.exports = __toCommonJS(session_exports);
+
+// packages/mcp/src/lib/contract.ts
+var VersionConflictError = class extends Error {
+  constructor(current, expected) {
+    super(
+      `Document changed (version is now ${current}, you expected ${expected}). Call get_document again, re-locate your anchor, then retry.`
+    );
+    this.name = "VersionConflictError";
+  }
+};
+var AnchorError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "AnchorError";
+  }
+};
+var NoDocumentError = class extends Error {
+  constructor(message = "No document is open. Ask the user to open a document first.") {
+    super(message);
+    this.name = "NoDocumentError";
+  }
+};
+
+// packages/mcp/src/lib/pm-session.ts
+var MARK_BY_FLAG = { bold: "strong", italic: "em", underline: "underline", strike: "strike" };
+var PmDocSession = class {
+  constructor(host) {
+    this.host = host;
+    this.capabilities = { selection: typeof host.selection === "function" };
+  }
+  host;
+  capabilities;
+  // ── reads ────────────────────────────────────────────────────────────
+  async snapshot() {
+    const blocks = this.textblocks().map(({ node }, index) => {
+      const block = { index, type: blockType(node), text: node.textContent };
+      const images = blockImages(node).map(({ node: img }, i) => ({
+        index: i,
+        alt: String(img.attrs["alt"] ?? ""),
+        width: Number(img.attrs["width"]) || 0,
+        height: Number(img.attrs["height"]) || 0,
+        rotation: Number(img.attrs["rotation"]) || 0,
+        kind: img.attrs["shape"] ? "shape" : "bitmap"
+      }));
+      if (images.length > 0) block.images = images;
+      return block;
+    });
+    return { docVersion: this.host.getVersion(), blocks, meta: this.host.meta() };
+  }
+  async find(query) {
+    return this.hits(query).map((h, i) => ({ blockIndex: h.blockIndex, occurrence: i + 1, context: h.context }));
+  }
+  async getSelection() {
+    const sel = this.host.selection?.();
+    if (!sel || sel.from === sel.to) return null;
+    const state = this.host.getState();
+    const text = state.doc.textBetween(sel.from, sel.to, "\n");
+    const blockIndex = this.textblocks().findIndex(
+      ({ node, pos }) => sel.from >= pos && sel.from <= pos + node.nodeSize
+    );
+    return { text, blockIndex };
+  }
+  // ── mutations ────────────────────────────────────────────────────────
+  async replaceText(oldText, newText, opts = {}) {
+    this.checkVersion(opts.expectedVersion);
+    const hit = this.uniqueHit(oldText, opts.occurrence);
+    this.host.apply(this.host.getState().tr.insertText(newText, hit.from, hit.to));
+    return { docVersion: this.host.getVersion(), range: { from: hit.from, to: hit.from + newText.length } };
+  }
+  async insertContent(content, anchor, opts = {}) {
+    this.checkVersion(opts.expectedVersion);
+    const state = this.host.getState();
+    const { schema } = state;
+    const paragraphs = content.split("\n").map((line) => schema.node("paragraph", null, line.length > 0 ? [schema.text(line)] : []));
+    let insertAt;
+    if (anchor.position === "document_end") {
+      insertAt = state.doc.content.size;
+    } else {
+      const hit = this.uniqueHit(anchor.text, anchor.occurrence);
+      const block = this.textblocks()[hit.blockIndex];
+      insertAt = anchor.position === "before" ? block.pos : block.pos + block.node.nodeSize;
+    }
+    const inserted = paragraphs.reduce((size, node) => size + node.nodeSize, 0);
+    this.host.apply(state.tr.insert(insertAt, paragraphs));
+    return { docVersion: this.host.getVersion(), range: { from: insertAt, to: insertAt + inserted } };
+  }
+  async applyFormatting(target, format, opts = {}) {
+    this.checkVersion(opts.expectedVersion);
+    const hit = this.uniqueHit(target, opts.occurrence);
+    const state = this.host.getState();
+    const { schema } = state;
+    let tr = state.tr;
+    for (const [flag, markName] of Object.entries(MARK_BY_FLAG)) {
+      const want = format[flag];
+      if (want === void 0) continue;
+      const mark = schema.marks[markName];
+      if (!mark) continue;
+      tr = want ? tr.addMark(hit.from, hit.to, mark.create()) : tr.removeMark(hit.from, hit.to, mark);
+    }
+    if (format.align) {
+      const block = this.textblocks()[hit.blockIndex];
+      tr = tr.setNodeMarkup(block.pos, void 0, { ...block.node.attrs, align: format.align });
+    }
+    if (tr.steps.length === 0) {
+      return { docVersion: this.host.getVersion() };
+    }
+    this.host.apply(tr);
+    return { docVersion: this.host.getVersion(), range: { from: hit.from, to: hit.to } };
+  }
+  async updateImage(blockIndex, imageIndex, changes, opts = {}) {
+    this.checkVersion(opts.expectedVersion);
+    const blocks = this.textblocks();
+    const block = blocks[blockIndex];
+    if (!block) {
+      throw new AnchorError(
+        `blockIndex ${blockIndex} is out of range \u2014 the document has ${blocks.length} block(s). Block indexes change with every edit; call get_document again.`
+      );
+    }
+    const images = blockImages(block.node).map((img2) => ({ ...img2, pos: block.pos + 1 + img2.offset }));
+    if (images.length === 0) {
+      throw new AnchorError(`Block ${blockIndex} has no images. get_document lists each block's images.`);
+    }
+    const img = images[imageIndex];
+    if (!img) {
+      throw new AnchorError(
+        `imageIndex ${imageIndex} is out of range \u2014 block ${blockIndex} has ${images.length} image(s) (0-${images.length - 1}).`
+      );
+    }
+    let tr = this.host.getState().tr;
+    if (changes.width !== void 0) tr = tr.setNodeAttribute(img.pos, "width", Math.max(1, Math.round(changes.width)));
+    if (changes.height !== void 0) tr = tr.setNodeAttribute(img.pos, "height", Math.max(1, Math.round(changes.height)));
+    if (changes.rotation !== void 0) {
+      tr = tr.setNodeAttribute(img.pos, "rotation", (changes.rotation % 360 + 360) % 360);
+    }
+    if (tr.steps.length === 0) return { docVersion: this.host.getVersion() };
+    this.host.apply(tr);
+    return { docVersion: this.host.getVersion(), range: { from: img.pos, to: img.pos + 1 } };
+  }
+  async save() {
+    await this.host.save();
+  }
+  async close() {
+  }
+  // ── internals ────────────────────────────────────────────────────────
+  checkVersion(expected) {
+    const current = this.host.getVersion();
+    if (expected !== void 0 && expected !== current) {
+      throw new VersionConflictError(current, expected);
+    }
+  }
+  /** All textblocks (paragraphs, incl. inside table cells) in reading order. */
+  textblocks() {
+    const out = [];
+    this.host.getState().doc.descendants((node, pos) => {
+      if (node.isTextblock) {
+        out.push({ node, pos });
+        return false;
+      }
+      return true;
+    });
+    return out;
+  }
+  /** Every occurrence of `query`, atom-safe (matches never span images/fields
+   *  or block boundaries), in document order with absolute PM positions. */
+  hits(query) {
+    if (query.length === 0) return [];
+    const out = [];
+    this.textblocks().forEach(({ node, pos }, blockIndex) => {
+      const segments = [];
+      let joined = "";
+      node.forEach((child, offset) => {
+        if (child.isText && child.text) {
+          segments.push({ joinedStart: joined.length, length: child.text.length, startPos: pos + 1 + offset });
+          joined += child.text;
+        } else {
+          joined += "\uFFFF";
+        }
+      });
+      let at = joined.indexOf(query);
+      while (at !== -1) {
+        const seg = segments.find((s) => at >= s.joinedStart && at < s.joinedStart + s.length);
+        if (seg) {
+          const from = seg.startPos + (at - seg.joinedStart);
+          out.push({
+            from,
+            to: from + query.length,
+            blockIndex,
+            context: contextAround(joined.replace(/￿/g, " "), at, query.length)
+          });
+        }
+        at = joined.indexOf(query, at + 1);
+      }
+    });
+    return out;
+  }
+  uniqueHit(text, occurrence) {
+    const all = this.hits(text);
+    if (all.length === 0) {
+      throw new AnchorError(
+        `Text not found in the document: ${JSON.stringify(clip(text))}. Anchors match within one paragraph \u2014 check get_document for the exact text.`
+      );
+    }
+    if (occurrence !== void 0) {
+      const hit = all[occurrence - 1];
+      if (!hit) {
+        throw new AnchorError(`occurrence ${occurrence} is out of range \u2014 the text matches ${all.length} time(s).`);
+      }
+      return hit;
+    }
+    if (all.length > 1) {
+      throw new AnchorError(
+        `The text matches ${all.length} times \u2014 pass occurrence (1-${all.length}) to pick one, or use a longer, unique anchor.`
+      );
+    }
+    return all[0];
+  }
+};
+function blockImages(block) {
+  const out = [];
+  block.forEach((child, offset) => {
+    if (child.type.name === "image") out.push({ node: child, offset });
+  });
+  return out;
+}
+function blockType(node) {
+  const heading = node.attrs["heading"];
+  if (typeof heading === "number" && heading >= 1) return `heading${heading}`;
+  return node.type.name;
+}
+function contextAround(text, at, len) {
+  const before = text.slice(Math.max(0, at - 30), at);
+  const after = text.slice(at + len, at + len + 30);
+  return `${before}\xAB${text.slice(at, at + len)}\xBB${after}`;
+}
+function clip(s) {
+  return s.length > 60 ? `${s.slice(0, 57)}\u2026` : s;
+}
+
+// packages/mcp/src/lib/wire.ts
+async function executeOp(session, request) {
+  try {
+    if (!session) throw new NoDocumentError();
+    const value = await run(session, request);
+    return { id: request.id, ok: true, value };
+  } catch (err) {
+    const e = err instanceof Error ? err : new Error(String(err));
+    return { id: request.id, ok: false, error: { name: e.name, message: e.message } };
+  }
+}
+function run(session, { op, args }) {
+  switch (op) {
+    case "snapshot":
+      return session.snapshot();
+    case "find":
+      return session.find(args[0]);
+    case "replaceText":
+      return session.replaceText(args[0], args[1], args[2]);
+    case "insertContent":
+      return session.insertContent(args[0], args[1], args[2]);
+    case "applyFormatting":
+      return session.applyFormatting(args[0], args[1], args[2]);
+    case "updateImage":
+      return session.updateImage(
+        args[0],
+        args[1],
+        args[2],
+        args[3]
+      );
+    case "getSelection":
+      return session.getSelection?.() ?? Promise.resolve(null);
+    case "save":
+      return session.save();
+    default:
+      return Promise.reject(new Error(`unknown session op: ${op}`));
+  }
+}
+function reviveError(error) {
+  switch (error.name) {
+    case "AnchorError":
+      return new AnchorError(error.message);
+    case "NoDocumentError":
+      return new NoDocumentError(error.message);
+    case "VersionConflictError": {
+      const revived = new VersionConflictError("?", "?");
+      revived.message = error.message;
+      return revived;
+    }
+    default: {
+      const generic = new Error(error.message);
+      generic.name = error.name;
+      return generic;
+    }
+  }
+}
+var RemoteSession = class {
+  constructor(send, capabilities) {
+    this.send = send;
+    this.capabilities = capabilities;
+  }
+  send;
+  capabilities;
+  async call(op, args = []) {
+    return await this.send(op, args);
+  }
+  snapshot() {
+    return this.call("snapshot");
+  }
+  find(query) {
+    return this.call("find", [query]);
+  }
+  replaceText(oldText, newText, opts) {
+    return this.call("replaceText", [oldText, newText, opts]);
+  }
+  insertContent(content, anchor, opts) {
+    return this.call("insertContent", [content, anchor, opts]);
+  }
+  applyFormatting(target, format, opts) {
+    return this.call("applyFormatting", [target, format, opts]);
+  }
+  updateImage(blockIndex, imageIndex, changes, opts) {
+    return this.call("updateImage", [blockIndex, imageIndex, changes, opts]);
+  }
+  async getSelection() {
+    return this.call("getSelection");
+  }
+  async save() {
+    await this.call("save");
+  }
+  async close() {
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AnchorError,
+  NoDocumentError,
+  PmDocSession,
+  RemoteSession,
+  VersionConflictError,
+  executeOp,
+  reviveError
+});

package/dist/session.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Browser-safe surface: the contract, the shared PM session semantics, and
+ * the wire protocol — zero runtime dependencies (prosemirror imports are
+ * type-only). The desktop WebView imports THIS to execute session ops against
+ * its live editor; it must never pull the MCP SDK into the web bundle.
+ */
+export * from './lib/contract.js';
+export { PmDocSession, type PmSessionHost } from './lib/pm-session.js';
+export { executeOp, reviveError, RemoteSession, type SessionOpName, type SessionOpRequest, type SessionOpResponse, } from './lib/wire.js';
+//# sourceMappingURL=session.d.ts.map

package/dist/session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../src/session.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,cAAc,mBAAmB,CAAC;AAClC,OAAO,EAAE,YAAY,EAAE,KAAK,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACvE,OAAO,EACL,SAAS,EACT,WAAW,EACX,aAAa,EACb,KAAK,aAAa,EAClB,KAAK,gBAAgB,EACrB,KAAK,iBAAiB,GACvB,MAAM,eAAe,CAAC"}