@jucie.io/cli 1.0.0

package/dist/stage-bundles/react/chunks/aiRelay-RULC7GEA.js

@@ -0,0 +1,184 @@
+import "./chunk-3NLDBJQD.js";
+import {
+  L
+} from "./chunk-3BDWFE4Q.js";
+import {
+  getAvailableFrames
+} from "./chunk-6R3QXFFF.js";
+import "./chunk-ZHZLVPR6.js";
+
+// src/lib/utils/buildAiContext.js
+function buildAiContext(state, sceneCompiler, cache) {
+  const selectedRids = cache.get(["selectedRids"]) ?? [];
+  const allNodes = state.get(["nodes"]) ?? {};
+  const selectedIds = selectedRids.length > 0 ? sceneCompiler.getIds(selectedRids) : [];
+  const nodesContext = selectedRids.length > 0 ? buildLocalContext(allNodes, selectedIds, selectedRids, sceneCompiler) : buildGlobalContext(sceneCompiler);
+  return {
+    framework: cache.get(["config", "framework"]) ?? "react",
+    componentCatalog: sceneCompiler.getMeta(),
+    stores: state.get(["stores"]) ?? {},
+    tokens: state.get(["tokens"]) ?? {},
+    animations: state.get(["animations"]) ?? {},
+    ...nodesContext,
+    availableFrames: getAvailableFrames(),
+    layoutHints: buildLayoutHints(allNodes, selectedRids)
+  };
+}
+function buildGlobalContext(sceneCompiler) {
+  return {
+    scope: "global",
+    jsx: sceneCompiler.projectPuppetJsx("app", { maxDepth: 8 })
+  };
+}
+function buildLocalContext(allNodes, selectedIds, selectedRids, sceneCompiler) {
+  const frameId = findFrameAncestor(allNodes, selectedIds[0]) ?? "app";
+  return {
+    scope: "local",
+    selectedIds,
+    jsx: sceneCompiler.projectPuppetJsx(frameId)
+  };
+}
+function buildLayoutHints(allNodes, selectedRids) {
+  const hints = {
+    viewportPositions: [],
+    usedPositions: [],
+    containerLayouts: {},
+    suggestedViewportPosition: null
+  };
+  let maxRight = 0;
+  Object.entries(allNodes).forEach(([id, node]) => {
+    if (node.type === "frame" && node.bounds) {
+      const { top, left, width, height } = node.bounds;
+      const pos = {
+        id,
+        name: node.name,
+        top: top || 0,
+        left: left || 0,
+        width: width || 375,
+        height: height || 667
+      };
+      hints.viewportPositions.push(pos);
+      const right = pos.left + pos.width;
+      if (right > maxRight) {
+        maxRight = right;
+      }
+    }
+    if (node.type !== "frame" && node.style?.default?.position === "absolute") {
+      const { top, left, width, height } = node.style.default;
+      hints.usedPositions.push({
+        id,
+        top: parseInt(top) || 0,
+        left: parseInt(left) || 0,
+        width: parseInt(width) || 100,
+        height: parseInt(height) || 50
+      });
+    }
+    if (node.layout === "flex" || node.style?.default?.display === "flex") {
+      hints.containerLayouts[id] = "flex";
+    }
+    if (node.layout === "grid" || node.style?.default?.display === "grid") {
+      hints.containerLayouts[id] = "grid";
+    }
+  });
+  hints.suggestedViewportPosition = {
+    top: 0,
+    left: maxRight + 50
+    // 50px gap between viewports
+  };
+  return hints;
+}
+function findParent(allNodes, childId) {
+  for (const [id, node] of Object.entries(allNodes)) {
+    if (node.children?.includes(childId)) {
+      return id;
+    }
+  }
+  return null;
+}
+function findFrameAncestor(allNodes, id) {
+  let cur = id;
+  while (cur) {
+    const node = allNodes[cur];
+    if (!node) return null;
+    if (node.type === "frame") return cur;
+    cur = findParent(allNodes, cur);
+  }
+  return null;
+}
+
+// src/lib/contracts/aiRelay.js
+var RENDER_TIMEOUT_MS = 5e3;
+var aiContracts = L("ai", (inject) => {
+  const [channel, state, sceneCompiler, cache, socket, log, aiOps] = inject("channel", "state", "sceneCompiler", "cache", "socket", "log", "aiOps");
+  function waitForRender(timeout = RENDER_TIMEOUT_MS) {
+    return new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        unsub();
+        resolve(null);
+      }, timeout);
+      const unsub = sceneCompiler.addNodeGraphListener((updated, removed) => {
+        clearTimeout(timer);
+        unsub();
+        resolve({ updated, removed });
+      });
+    });
+  }
+  const io = socket.get();
+  io.on("stage:ai:progress", (progress) => {
+    channel.to("editor").publish("ai:progress", progress);
+  });
+  io.on("stage:ai:response", (response) => {
+    channel.to("editor").publish("ai:response", response);
+  });
+  io.on("stage:ai:context:capture", async ({ requestId, awaitRender } = {}) => {
+    try {
+      if (awaitRender) {
+        await waitForRender();
+      }
+      const context = buildAiContext(state, sceneCompiler, cache);
+      io.emit("server:ai:result", { requestId, result: context });
+    } catch (error) {
+      log.error("ai context capture failed", { error: error.message });
+      io.emit("server:ai:result", { requestId, error: error.message });
+    }
+  });
+  io.on("stage:ai:operations:execute", async ({ requestId, batch } = {}) => {
+    try {
+      state.history.group();
+      let result;
+      try {
+        result = await aiOps.executeBatch(batch ?? { operations: [] });
+      } finally {
+        state.history.commit(batch?.description || batch?.message || "AI changes");
+      }
+      io.emit("server:ai:result", { requestId, result });
+    } catch (error) {
+      log.error("ai operations execute failed", { error: error.message });
+      io.emit("server:ai:result", { requestId, error: error.message });
+    }
+  });
+  return {
+    agent: {
+      schema: ["String", "Object"],
+      namespace: "stage",
+      timeoutMs: 18e4,
+      handler: async (prompt, options = {}) => {
+        io.emit("server:ai:agent", {
+          prompt,
+          sessionId: options.sessionId ?? null,
+          token: cache.get(["token"]) ?? null
+        });
+      }
+    },
+    stop: {
+      schema: [],
+      namespace: "stage",
+      handler: () => {
+        io.emit("server:ai:stop");
+      }
+    }
+  };
+});
+export {
+  aiContracts
+};

package/dist/stage-bundles/react/chunks/assets-24YGC7SD.js

@@ -0,0 +1,42 @@
+import {
+  L
+} from "./chunk-3BDWFE4Q.js";
+import "./chunk-ZHZLVPR6.js";
+
+// src/lib/contracts/assets.js
+var assetsContracts = L("assets", (useContext) => {
+  const [socket, channel, log] = useContext("socket", "channel", "log");
+  if (!socket || !channel) {
+    throw new Error("Socket or channel not found");
+  }
+  return {
+    upload: {
+      namespace: "stage",
+      schema: ["Object", "ArrayBuffer"],
+      handler: async (meta, arrayBuffer) => {
+        log.debug("upload request received", { name: meta.name });
+        try {
+          socket.get().emit("server:upload:asset", {
+            meta,
+            data: arrayBuffer
+          });
+          const responseHandler = (result) => {
+            log.debug("upload response received", { success: result.success });
+            channel.to("editor").publish("asset:uploaded", result);
+            socket.get().off("stage:asset:uploaded", responseHandler);
+          };
+          socket.get().on("stage:asset:uploaded", responseHandler);
+        } catch (error) {
+          log.error("upload failed", { error: error.message });
+          channel.to("editor").publish("asset:uploaded", {
+            success: false,
+            error: error.message
+          });
+        }
+      }
+    }
+  };
+});
+export {
+  assetsContracts
+};