fui-studio-mcp 0.1.2 → 0.1.3

package/README.md

@@ -117,12 +117,15 @@ add it, use these args instead:
 
 ## What the assistant can do
 
-These are the server's 24 tools:
+These are the server's 26 tools:
 
 - **Projects:** `new_project`, `open_project`, `save_project`,
   `list_projects`, `get_project`.
 - **Presets:** `list_presets`, `new_from_preset` — the studio's starter
   documents (radar, dial, boot sequence, depth stack…) as a place to begin.
+- **Elements:** `list_elements`, `insert_element` — layers the user saved
+  for reuse in the studio (its `elements/` folder), put into the project
+  as a new layer.
 - **Building:** `list_node_types`, `describe_node` (every param explained,
   with units and ranges), `add_node`, `add_image`, `remove_node`,
   `set_param`, `connect`, `disconnect`, `set_keyframe`, `list_nodes`.

package/dist/{chunk-S3AUIOGZ.js → chunk-NYLRWVKF.js}

@@ -1105,6 +1105,67 @@ function orderKeys(value) {
 function serializeProject(project) {
   return JSON.stringify(orderKeys(project), null, 2) + "\n";
 }
+function insertComposition(project, doc, mint, known = () => true) {
+  const elementLayer = doc.graph.nodes.find((n) => n.type === "layer");
+  if (!elementLayer) return void 0;
+  const canvas = project.graph.nodes.find((n) => n.type === "canvas");
+  const tokens = project.graph.nodes.find((n) => n.type === "style-tokens");
+  const elementTokens = doc.graph.nodes.find((n) => n.type === "style-tokens");
+  const taken = new Set(project.graph.nodes.filter((n) => n.type === "layer").map((n) => n.name?.trim()));
+  const base2 = doc.name.trim() || elementLayer.name?.trim() || "Element";
+  let name = base2;
+  for (let i = 2; taken.has(name); i++) name = `${base2} ${i}`;
+  let top = 0;
+  for (const n of project.graph.nodes) if (n.type === "layer" && typeof n.params.order === "number") top = Math.max(top, n.params.order);
+  const remap = /* @__PURE__ */ new Map();
+  const nodes = doc.graph.nodes.filter((n) => n.type !== "canvas" && n.type !== "ograf" && !(n.type === "style-tokens" && tokens) && known(n)).map((n) => {
+    const id = mint(n.type.replace(/[^a-z]/g, "") || "node");
+    remap.set(n.id, id);
+    const copy = { ...structuredClone(n), id };
+    if (n.id === elementLayer.id) {
+      copy.name = name;
+      copy.params = { ...copy.params, order: top + 1 };
+    }
+    return copy;
+  });
+  for (const n of nodes) {
+    if (ROOT_TYPES.has(n.type)) delete n.layer;
+    else if (n.layer !== void 0) {
+      const home = remap.get(n.layer);
+      if (home) n.layer = home;
+      else delete n.layer;
+    }
+  }
+  const edges = [];
+  for (const e of doc.graph.edges) {
+    const from = remap.get(e.from);
+    const to = remap.get(e.to);
+    if (from && to) edges.push({ ...e, id: mint("edge"), from, to });
+    else if (to && tokens && elementTokens && e.from === elementTokens.id) edges.push({ ...e, id: mint("edge"), from: tokens.id, to });
+  }
+  const layerId = remap.get(elementLayer.id);
+  if (canvas) edges.push({ id: mint("edge"), from: layerId, fromPort: "out", to: canvas.id, toPort: "in" });
+  const groups = doc.groups.flatMap((g) => {
+    const nodeIds = g.nodeIds.flatMap((id) => remap.has(id) ? [remap.get(id)] : []);
+    if (nodeIds.length === 0) return [];
+    return [
+      {
+        id: mint("group"),
+        name: g.name,
+        nodeIds,
+        collapsed: g.collapsed,
+        exposed: g.exposed.flatMap((entry) => {
+          const dot = entry.indexOf(".");
+          const copy = remap.get(dot < 0 ? entry : entry.slice(0, dot));
+          return copy ? [`${copy}${dot < 0 ? "" : entry.slice(dot)}`] : [];
+        })
+      }
+    ];
+  });
+  const assets = { ...project.assets };
+  for (const [key, record] of Object.entries(doc.assets)) if (!(key in assets)) assets[key] = structuredClone(record);
+  return { nodes, edges, groups, assets, layerId, name };
+}
 
 // ../../packages/engine/dist/index.js
 var DEFAULT_STYLE = {
@@ -17968,6 +18029,7 @@ export {
   adoptions,
   loadProject,
   serializeProject,
+  insertComposition,
   isExposable,
   layerDuration,
   layerLoop,

package/dist/{chunk-U3VXQSCB.js → chunk-ZCNEK4RK.js}

@@ -11,7 +11,7 @@ import {
   localFontBytes,
   parseBdf,
   resolveFace
-} from "./chunk-S3AUIOGZ.js";
+} from "./chunk-NYLRWVKF.js";
 
 // ../../packages/fonts/dist/chunk-MTHRWFM6.js
 import * as opentype from "opentype.js";

package/dist/{dist-LUAYBAOC.js → dist-3XKU7BN6.js}

@@ -28,7 +28,7 @@ import {
   stripPost,
   templateFiles,
   usedFonts
-} from "./chunk-S3AUIOGZ.js";
+} from "./chunk-NYLRWVKF.js";
 export {
   OGRAF_KINDS,
   SCHEMA_URL,

package/dist/index.js

@@ -4,7 +4,7 @@ import {
   allTtfBuffers,
   fontDefs,
   nodeOutliner
-} from "./chunk-U3VXQSCB.js";
+} from "./chunk-ZCNEK4RK.js";
 import {
   DEFAULT_FONT_FAMILY,
   Keyframe,
@@ -17,6 +17,7 @@ import {
   emptyProject,
   envName,
   evaluate,
+  insertComposition,
   isExposable,
   layerDuration,
   layerLoop,
@@ -39,7 +40,7 @@ import {
   wouldCycle,
   yuvFrameBytes,
   yuvToRgb
-} from "./chunk-S3AUIOGZ.js";
+} from "./chunk-NYLRWVKF.js";
 
 // src/index.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
@@ -834,6 +835,75 @@ var Session = class {
     this.stamp = this.mtimeOf(target);
     return target;
   }
+  /**
+   * The elements in the projects folder: `elements/<name>.tui`, each a
+   * layer saved for reuse from the studio (its layers pane) — the shelf
+   * the studio's elements button shows. Newest first.
+   */
+  listElements() {
+    if (!this.root) fail("The server was started without a projects folder (--projects <dir> or FUI_PROJECTS), so there is no elements/ folder to list.");
+    const dir = join3(this.root, "elements");
+    let entries;
+    try {
+      entries = readdirSync(dir);
+    } catch {
+      return [];
+    }
+    const out = [];
+    for (const file of entries) {
+      if (!file.endsWith(".tui")) continue;
+      const abs = join3(dir, file);
+      const at = this.mtimeOf(abs) ?? 0;
+      let description = "";
+      try {
+        const { project } = loadProject(JSON.parse(readFileSync3(abs, "utf8")));
+        const layer = project.graph.nodes.find((n) => n.type === "layer");
+        const members = project.graph.nodes.filter((n) => layer && n.layer === layer.id);
+        const kinds = [...new Set(members.map((n) => n.type))];
+        description = `${members.length} node${members.length === 1 ? "" : "s"}${kinds.length > 0 ? ` (${kinds.slice(0, 6).join(", ")}${kinds.length > 6 ? ", \u2026" : ""})` : ""}`;
+      } catch {
+        description = "unreadable";
+      }
+      out.push({ name: file.slice(0, -4), description, saved: new Date(at).toISOString(), at });
+    }
+    out.sort((a, b) => b.at - a.at);
+    return out.map(({ at: _at, ...rest }) => rest);
+  }
+  /**
+   * An element into the open project as a new Layer on top (the shared
+   * surgery in @fui/schema): its name counted up when taken, wired into the
+   * Canvas, its Tokens wires re-bound to this document's Tokens. Its
+   * pictures' bytes come along from `elements/<name>.assets/` and are
+   * written beside the project on save. The Layer and its drivers have no
+   * place here yet: the save lays them out, as it lays out any node added
+   * without a position.
+   */
+  insertElement(name) {
+    if (!this.root) fail("The server was started without a projects folder (--projects <dir> or FUI_PROJECTS), so there is no elements/ folder to insert from.");
+    const abs = join3(this.root, "elements", `${name.replace(/\.tui$/i, "")}.tui`);
+    if (!existsSync2(abs)) {
+      const have = this.listElements().map((e) => e.name);
+      fail(`No element "${name}".${have.length > 0 ? ` The elements: ${have.join(", ")}.` : " The elements/ folder is empty \u2014 save a layer as an element in the studio first."}`);
+    }
+    const { project: doc } = loadProject(JSON.parse(readFileSync3(abs, "utf8")));
+    const insertion = insertComposition(this.project, { ...doc, name: name.replace(/\.tui$/i, "") }, makeId, (n) => registry.forNode(n) !== void 0);
+    if (!insertion) fail(`${abs} is not an element: it has no Layer in it.`);
+    const dir = assetDirFor(abs);
+    for (const [key, record] of Object.entries(doc.assets)) {
+      if (record.video || this.held.has(key)) continue;
+      const found = assetFileIn(dir, key, record);
+      if (!found) continue;
+      const bytes = new Uint8Array(readFileSync3(found.path));
+      this.held.set(key, { href: `data:${record.mime};base64,${Buffer.from(bytes).toString("base64")}`, bytes, mime: record.mime });
+    }
+    this.project.graph.nodes.push(...insertion.nodes);
+    this.project.graph.edges.push(...insertion.edges);
+    this.project.groups.push(...insertion.groups);
+    this.project.assets = insertion.assets;
+    for (const n of insertion.nodes) if (n.layer === void 0) this.placed.add(n.id);
+    const layer = insertion.nodes.find((n) => n.id === insertion.layerId);
+    return { layer, nodes: insertion.nodes };
+  }
   /**
    * The projects folder's documents, loose and one folder deep — the shape
    * the studio's Open dialog shows. Newest first.
@@ -1348,6 +1418,8 @@ Pixels: shapes are vectors until a rasterize node draws them; post nodes (blur,
 
 Keep the graph readable, because the user opens it in the studio. A node whose output is wired to nothing draws straight onto the page. That works, but a page of loose nodes looks like a graph with its wires missing. Gather the parts of one element (a radar's rings, ticks, labels and crosshair) into a Merge node: add_node merge, then connect each part to its "in" port. Merge draws in connection order, so the first wire is at the bottom. Give the Merge a name ("radar", "readout") so the studio shows what it is. Leave position out of add_node: on save, nodes without one are laid out in columns that follow the wires.
 
+Elements: list_elements shows layers the user saved for reuse in the studio; insert_element puts one into the project as a new Layer, ready to change. When the user mentions something they have made before (their radar, their readout), look there first.
+
 Layers: a Layer node is a self-contained composition with its own page and its own clock. add_node with layer: "<layer id>" puts a node inside it. Arrange Layers in time with add_clip; a document with no clips plays every Layer all the time. list_layers explains the rules.
 
 The user is probably watching. When the user has the same projects folder open in FUI Studio (Choose folder in the browser) with this project loaded, every save_project appears there within a second. So save after each meaningful step, and say what changed. The user can edit in the studio too: if save_project refuses because the file changed, open_project it again, which picks up their edits, redo your change and save. Do not reach for overwrite unless the user asks for it.
@@ -1505,6 +1577,25 @@ server.registerTool(
     return text(await session.summary());
   })
 );
+server.registerTool(
+  "list_elements",
+  {
+    description: "The elements in the projects folder: layers the user saved for reuse from the studio (a radar, a readout, a panel), each a working composition with a picture. insert_element puts one into the open project as a new layer; prefer that to rebuilding what the user already has.",
+    inputSchema: {}
+  },
+  guard(() => text(session.listElements()))
+);
+server.registerTool(
+  "insert_element",
+  {
+    description: "Insert an element (list_elements) into the open project as a new Layer on top, wired into the Canvas, named after the element (counted up when the name is taken), taking the colours of this project\u2019s Style Tokens. Its nodes are ordinary nodes afterwards: list_nodes shows them, set_param changes them. Returns the new Layer and its nodes.",
+    inputSchema: { name: z2.string().describe("The element\u2019s name as list_elements gives it") }
+  },
+  guard(({ name }) => {
+    const { layer, nodes } = session.insertElement(name);
+    return text({ layer: { id: layer.id, name: layer.name, order: layer.params.order }, nodes: nodes.map((n) => ({ id: n.id, type: n.type, ...n.layer ? { layer: n.layer } : {} })) });
+  })
+);
 server.registerTool(
   "list_nodes",
   { description: "Every node in the graph, with params and incoming wires.", inputSchema: {} },
@@ -1699,8 +1790,8 @@ server.registerTool(
     const abs = session.resolvePath(path);
     mkdirSync2(dirname3(abs), { recursive: true });
     if (/\.(ograf|drfx)$/i.test(abs)) {
-      const { exportTemplate } = await import("./node-XJJEAAN7.js");
-      const { packDrfx, packOgraf } = await import("./dist-LUAYBAOC.js");
+      const { exportTemplate } = await import("./node-VANCEYKL.js");
+      const { packDrfx, packOgraf } = await import("./dist-3XKU7BN6.js");
       const template = exportTemplate(session.project, void 0, session.assetResolver());
       const errors = template.lint.filter((i) => i.level === "error");
       if (errors.length > 0) throw new SessionError(`The manifest has errors: ${errors.map((i) => `${i.where}: ${i.message}`).join("; ")}`);

package/dist/{node-XJJEAAN7.js → node-VANCEYKL.js}

@@ -2,10 +2,10 @@
 import {
   loadFaces,
   nodeOutliner
-} from "./chunk-U3VXQSCB.js";
+} from "./chunk-ZCNEK4RK.js";
 import {
   buildTemplate
-} from "./chunk-S3AUIOGZ.js";
+} from "./chunk-NYLRWVKF.js";
 
 // ../../packages/ograf/dist/node.js
 import { existsSync, readFileSync } from "fs";