@particle-academy/agent-integrations 0.6.2 → 0.7.0

package/dist/bridges-artboard.cjs

@@ -0,0 +1,576 @@
+'use strict';
+
+// src/mcp/server.ts
+function textResult(text, structured) {
+  return {
+    content: [{ type: "text", text }],
+    ...structured !== void 0 ? { structuredContent: structured } : {}
+  };
+}
+function errorResult(text) {
+  return { content: [{ type: "text", text }], isError: true };
+}
+var listeners = /* @__PURE__ */ new Set();
+function emitActivity(event) {
+  for (const l of listeners) l(event);
+}
+
+// src/presence/wrap-tool-with-activity.ts
+function wrapToolWithActivity(handler, options) {
+  return async (args) => {
+    const result = await handler(args);
+    if (result.isError) return result;
+    let target;
+    if (options.resolveTarget) {
+      target = options.resolveTarget({ toolName: options.toolName, args, result });
+    } else {
+      target = { kind: options.kind, screenId: options.screenId };
+    }
+    if (!target) return result;
+    emitActivity({
+      agentId: options.agent.id,
+      agentName: options.agent.name,
+      agentColor: options.agent.color,
+      target: { ...target, kind: target.kind ?? options.kind, screenId: target.screenId ?? options.screenId },
+      action: options.toolName,
+      timestamp: Date.now(),
+      meta: extractMeta(result),
+      ttlMs: options.ttlMs
+    });
+    return result;
+  };
+}
+function extractMeta(result) {
+  const sc = result.structuredContent;
+  if (sc && typeof sc === "object" && !Array.isArray(sc)) {
+    return sc;
+  }
+  return void 0;
+}
+
+// src/undo/undo-stack.ts
+var stacks = /* @__PURE__ */ new Map();
+var CAP = 200;
+function getStack(agentId) {
+  let s = stacks.get(agentId);
+  if (!s) {
+    s = { past: [], future: [] };
+    stacks.set(agentId, s);
+  }
+  return s;
+}
+function pushUndoEntry(agentId, entry) {
+  const s = getStack(agentId);
+  s.past.push(entry);
+  if (s.past.length > CAP) s.past.splice(0, s.past.length - CAP);
+  s.future.length = 0;
+}
+async function undoOne(agentId) {
+  const s = getStack(agentId);
+  const entry = s.past.pop();
+  if (!entry) return null;
+  await entry.undo();
+  s.future.push(entry);
+  return entry;
+}
+async function redoOne(agentId) {
+  const s = getStack(agentId);
+  const entry = s.future.pop();
+  if (!entry) return null;
+  await entry.redo();
+  s.past.push(entry);
+  return entry;
+}
+function readHistory(agentId) {
+  return getStack(agentId).past.slice();
+}
+
+// src/undo/undo-tools.ts
+var installedHosts = /* @__PURE__ */ new WeakSet();
+function ensureUndoToolsRegistered(host, options = {}) {
+  if (installedHosts.has(host)) return;
+  installedHosts.add(host);
+  registerUndoTools(host, options);
+}
+function registerUndoTools(host, options = {}) {
+  const defaultAgent = options.defaultAgentId ?? "agent";
+  const disposers = [];
+  const agentOf = (args) => typeof args?.agentId === "string" ? args.agentId : defaultAgent;
+  disposers.push(
+    host.registerTool(
+      {
+        name: "agent_undo",
+        description: "Undo the most recent action on the agent's stack. Optional agentId targets a specific agent.",
+        inputSchema: {
+          type: "object",
+          properties: { agentId: { type: "string" } },
+          additionalProperties: false
+        }
+      },
+      async (args) => {
+        const entry = await undoOne(agentOf(args));
+        if (!entry) return errorResult("Nothing to undo.");
+        return textResult(`Undid: ${entry.label}`, { entry: serialize(entry) });
+      }
+    )
+  );
+  disposers.push(
+    host.registerTool(
+      {
+        name: "agent_redo",
+        description: "Redo the most recently undone action.",
+        inputSchema: {
+          type: "object",
+          properties: { agentId: { type: "string" } },
+          additionalProperties: false
+        }
+      },
+      async (args) => {
+        const entry = await redoOne(agentOf(args));
+        if (!entry) return errorResult("Nothing to redo.");
+        return textResult(`Redid: ${entry.label}`, { entry: serialize(entry) });
+      }
+    )
+  );
+  disposers.push(
+    host.registerTool(
+      {
+        name: "agent_history",
+        description: "List the agent's undo stack (oldest first). Useful for understanding what's reversible.",
+        inputSchema: {
+          type: "object",
+          properties: { agentId: { type: "string" } },
+          additionalProperties: false
+        }
+      },
+      async (args) => {
+        const history2 = readHistory(agentOf(args)).map(serialize);
+        const text = history2.map((e) => `${new Date(e.timestamp).toISOString()} ${e.bridgeId} ${e.action}: ${e.label}`).join("\n");
+        return textResult(text || "(empty)", history2);
+      }
+    )
+  );
+  return () => disposers.forEach((d) => d());
+}
+function serialize(entry) {
+  return {
+    timestamp: entry.timestamp,
+    bridgeId: entry.bridgeId,
+    action: entry.action,
+    label: entry.label
+  };
+}
+
+// src/bridges/artboard.ts
+var DEFAULT_AGENT = { id: "agent", name: "Agent", color: "#a855f7" };
+var num = (v, fallback) => typeof v === "number" && Number.isFinite(v) ? v : fallback ?? 0;
+var str = (v, fallback = "") => typeof v === "string" ? v : fallback;
+var newId = (prefix) => `${prefix}_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 7)}`;
+var clone = (v) => JSON.parse(JSON.stringify(v));
+var coerceContent = (v) => {
+  if (v && typeof v === "object") {
+    const c = v;
+    if (c.kind === "image") return { kind: "image", src: str(c.src), ...c.alt !== void 0 ? { alt: str(c.alt) } : {} };
+    if (c.kind === "html") return { kind: "html", html: str(c.html) };
+    if (c.kind === "node") return { kind: "node" };
+  }
+  return { kind: "node" };
+};
+function registerArtboardBridge(host, options) {
+  const { adapter } = options;
+  const agent = { ...DEFAULT_AGENT, ...options.agent ?? {} };
+  const disposers = [];
+  ensureUndoToolsRegistered(host, { defaultAgentId: agent.id });
+  const abTarget = (args, result) => ({
+    kind: "artboard",
+    id: result?.structuredContent?.id ?? args?.pieceId ?? args?.sectionId
+  });
+  const reg = (name, description, inputProperties, required, handler, resolveTarget) => {
+    const wrapped = async (args) => {
+      try {
+        return await handler(args);
+      } catch (e) {
+        return errorResult(e instanceof Error ? e.message : String(e));
+      }
+    };
+    const final = resolveTarget ? wrapToolWithActivity(wrapped, {
+      toolName: name,
+      agent: { id: agent.id, name: agent.name, color: agent.color },
+      kind: "artboard",
+      resolveTarget: ({ args, result }) => resolveTarget(args, result)
+    }) : wrapped;
+    disposers.push(
+      host.registerTool(
+        {
+          name,
+          description,
+          inputSchema: {
+            type: "object",
+            properties: inputProperties,
+            required,
+            additionalProperties: false
+          }
+        },
+        final
+      )
+    );
+  };
+  reg("artboard_get_state", "Get the full board state: viewport, focus, all sections and pieces.", {}, [], () => {
+    const state = {
+      viewport: adapter.getViewport(),
+      focus: adapter.getFocus(),
+      sections: adapter.getValue().sections
+    };
+    return textResult(JSON.stringify(state, null, 2), state);
+  });
+  reg("artboard_list_pieces", "List sections and their pieces with id, label, and content kind.", {}, [], () => {
+    const lines = [];
+    const summary = [];
+    for (const s of adapter.getValue().sections) {
+      lines.push(`section ${s.id}: "${s.title}"`);
+      const pieces = s.pieces.map((p) => ({
+        id: p.id,
+        ...p.label !== void 0 ? { label: p.label } : {},
+        kind: p.content.kind,
+        ...p.pending ? { pending: true } : {}
+      }));
+      for (const p of s.pieces) {
+        lines.push(`  piece ${p.id}: ${p.label ? `"${p.label}" ` : ""}[${p.content.kind}]${p.pending ? " (pending)" : ""}`);
+      }
+      summary.push({ sectionId: s.id, title: s.title, pieces });
+    }
+    return textResult(lines.join("\n") || "(empty board)", summary);
+  });
+  reg(
+    "artboard_add_piece",
+    "Add a piece to a section. New agent-added pieces default to pending:true (trust-but-verify \u2014 a human confirms before it is final).",
+    {
+      sectionId: { type: "string" },
+      piece: {
+        type: "object",
+        description: "Piece spec: { label?, width?, height?, content }. content is { kind: 'image', src, alt? } | { kind: 'html', html } | { kind: 'node' }."
+      },
+      index: { type: "number", description: "Insertion index within the section. Defaults to the end." }
+    },
+    ["sectionId", "piece"],
+    (args) => {
+      const sectionId = str(args.sectionId);
+      const section = adapter.getValue().sections.find((s) => s.id === sectionId);
+      if (!section) return errorResult(`No section with id ${sectionId}`);
+      const spec = args.piece ?? {};
+      const piece = {
+        id: newId("p"),
+        ...spec.label !== void 0 ? { label: str(spec.label) } : {},
+        ...spec.width !== void 0 ? { width: num(spec.width) } : {},
+        ...spec.height !== void 0 ? { height: num(spec.height) } : {},
+        content: coerceContent(spec.content),
+        pending: true
+      };
+      const insertAt = args.index !== void 0 ? Math.max(0, Math.min(num(args.index), section.pieces.length)) : section.pieces.length;
+      adapter.setValue((prev) => ({
+        sections: prev.sections.map(
+          (s) => s.id !== sectionId ? s : { ...s, pieces: [...s.pieces.slice(0, insertAt), piece, ...s.pieces.slice(insertAt)] }
+        )
+      }));
+      pushUndoEntry(agent.id, {
+        timestamp: Date.now(),
+        bridgeId: "artboard",
+        action: "artboard_add_piece",
+        label: `Added piece ${piece.id} to ${sectionId}`,
+        undo: () => adapter.setValue((prev) => ({
+          sections: prev.sections.map(
+            (s) => s.id !== sectionId ? s : { ...s, pieces: s.pieces.filter((p) => p.id !== piece.id) }
+          )
+        })),
+        redo: () => adapter.setValue((prev) => ({
+          sections: prev.sections.map(
+            (s) => s.id !== sectionId ? s : { ...s, pieces: [...s.pieces.slice(0, insertAt), piece, ...s.pieces.slice(insertAt)] }
+          )
+        }))
+      });
+      return textResult(`Added piece ${piece.id} to section ${sectionId} (pending)`, piece);
+    },
+    abTarget
+  );
+  reg(
+    "artboard_remove_piece",
+    "Remove a piece by id.",
+    { pieceId: { type: "string" } },
+    ["pieceId"],
+    (args) => {
+      const pieceId = str(args.pieceId);
+      let removed = null;
+      let fromSection = null;
+      let oldIndex = -1;
+      for (const s of adapter.getValue().sections) {
+        const idx = s.pieces.findIndex((p) => p.id === pieceId);
+        if (idx !== -1) {
+          removed = clone(s.pieces[idx]);
+          fromSection = s.id;
+          oldIndex = idx;
+          break;
+        }
+      }
+      if (!removed || fromSection === null) return errorResult(`No piece with id ${pieceId}`);
+      const sectionId = fromSection;
+      const snapshot = removed;
+      const at = oldIndex;
+      adapter.setValue((prev) => ({
+        sections: prev.sections.map(
+          (s) => s.id !== sectionId ? s : { ...s, pieces: s.pieces.filter((p) => p.id !== pieceId) }
+        )
+      }));
+      pushUndoEntry(agent.id, {
+        timestamp: Date.now(),
+        bridgeId: "artboard",
+        action: "artboard_remove_piece",
+        label: `Removed piece ${pieceId}`,
+        undo: () => adapter.setValue((prev) => ({
+          sections: prev.sections.map(
+            (s) => s.id !== sectionId ? s : { ...s, pieces: [...s.pieces.slice(0, at), clone(snapshot), ...s.pieces.slice(at)] }
+          )
+        })),
+        redo: () => adapter.setValue((prev) => ({
+          sections: prev.sections.map(
+            (s) => s.id !== sectionId ? s : { ...s, pieces: s.pieces.filter((p) => p.id !== pieceId) }
+          )
+        }))
+      });
+      return textResult(`Removed piece ${pieceId}`, { id: pieceId });
+    },
+    abTarget
+  );
+  reg(
+    "artboard_reorder_piece",
+    "Move a piece to a new index, optionally into a different section.",
+    {
+      pieceId: { type: "string" },
+      sectionId: { type: "string", description: "Target section id. Defaults to the piece's current section." },
+      toIndex: { type: "number" }
+    },
+    ["pieceId", "toIndex"],
+    (args) => {
+      const pieceId = str(args.pieceId);
+      const before = adapter.getValue();
+      let piece = null;
+      let srcSection = null;
+      for (const s of before.sections) {
+        const found = s.pieces.find((p) => p.id === pieceId);
+        if (found) {
+          piece = found;
+          srcSection = s.id;
+          break;
+        }
+      }
+      if (!piece || srcSection === null) return errorResult(`No piece with id ${pieceId}`);
+      const dstSection = args.sectionId !== void 0 ? str(args.sectionId) : srcSection;
+      if (!before.sections.some((s) => s.id === dstSection)) return errorResult(`No section with id ${dstSection}`);
+      const toIndex = Math.max(0, num(args.toIndex));
+      const moving = piece;
+      const snapshot = clone(before);
+      adapter.setValue((prev) => {
+        const stripped = prev.sections.map((s) => ({ ...s, pieces: s.pieces.filter((p) => p.id !== pieceId) }));
+        return {
+          sections: stripped.map((s) => {
+            if (s.id !== dstSection) return s;
+            const clamped = Math.min(toIndex, s.pieces.length);
+            return { ...s, pieces: [...s.pieces.slice(0, clamped), moving, ...s.pieces.slice(clamped)] };
+          })
+        };
+      });
+      pushUndoEntry(agent.id, {
+        timestamp: Date.now(),
+        bridgeId: "artboard",
+        action: "artboard_reorder_piece",
+        label: `Reordered piece ${pieceId}`,
+        undo: () => adapter.setValue(() => clone(snapshot)),
+        redo: () => adapter.setValue((prev) => {
+          const stripped = prev.sections.map((s) => ({ ...s, pieces: s.pieces.filter((p) => p.id !== pieceId) }));
+          return {
+            sections: stripped.map((s) => {
+              if (s.id !== dstSection) return s;
+              const clamped = Math.min(toIndex, s.pieces.length);
+              return { ...s, pieces: [...s.pieces.slice(0, clamped), moving, ...s.pieces.slice(clamped)] };
+            })
+          };
+        })
+      });
+      return textResult(`Reordered piece ${pieceId} \u2192 ${dstSection}[${toIndex}]`, { id: pieceId, sectionId: dstSection, toIndex });
+    },
+    abTarget
+  );
+  reg(
+    "artboard_rename_piece",
+    "Set a piece's label.",
+    { pieceId: { type: "string" }, label: { type: "string" } },
+    ["pieceId", "label"],
+    (args) => {
+      const pieceId = str(args.pieceId);
+      const label = str(args.label);
+      const existing = adapter.getValue().sections.flatMap((s) => s.pieces).find((p) => p.id === pieceId);
+      if (!existing) return errorResult(`No piece with id ${pieceId}`);
+      const prevLabel = existing.label;
+      const apply = (l) => adapter.setValue((prev) => ({
+        sections: prev.sections.map((s) => ({
+          ...s,
+          pieces: s.pieces.map((p) => p.id !== pieceId ? p : { ...p, ...l !== void 0 ? { label: l } : {} })
+        }))
+      }));
+      apply(label);
+      pushUndoEntry(agent.id, {
+        timestamp: Date.now(),
+        bridgeId: "artboard",
+        action: "artboard_rename_piece",
+        label: `Renamed piece ${pieceId}`,
+        undo: () => apply(prevLabel),
+        redo: () => apply(label)
+      });
+      return textResult(`Renamed piece ${pieceId} \u2192 "${label}"`, { id: pieceId, label });
+    },
+    abTarget
+  );
+  reg(
+    "artboard_set_piece_content",
+    "Replace a piece's content. content is { kind: 'image', src, alt? } | { kind: 'html', html } | { kind: 'node' }.",
+    { pieceId: { type: "string" }, content: { type: "object" } },
+    ["pieceId", "content"],
+    (args) => {
+      const pieceId = str(args.pieceId);
+      const existing = adapter.getValue().sections.flatMap((s) => s.pieces).find((p) => p.id === pieceId);
+      if (!existing) return errorResult(`No piece with id ${pieceId}`);
+      const prevContent = clone(existing.content);
+      const nextContent = coerceContent(args.content);
+      const apply = (c) => adapter.setValue((prev) => ({
+        sections: prev.sections.map((s) => ({
+          ...s,
+          pieces: s.pieces.map((p) => p.id !== pieceId ? p : { ...p, content: clone(c) })
+        }))
+      }));
+      apply(nextContent);
+      pushUndoEntry(agent.id, {
+        timestamp: Date.now(),
+        bridgeId: "artboard",
+        action: "artboard_set_piece_content",
+        label: `Set content of piece ${pieceId}`,
+        undo: () => apply(prevContent),
+        redo: () => apply(nextContent)
+      });
+      return textResult(`Set content of piece ${pieceId} \u2192 ${nextContent.kind}`, { id: pieceId, content: nextContent });
+    },
+    abTarget
+  );
+  reg(
+    "artboard_focus_piece",
+    "Focus a piece by id (or pass null to clear focus).",
+    { pieceId: { type: ["string", "null"] } },
+    [],
+    (args) => {
+      const raw = args.pieceId;
+      const pieceId = typeof raw === "string" ? raw : null;
+      if (pieceId !== null && !adapter.getValue().sections.some((s) => s.pieces.some((p) => p.id === pieceId))) {
+        return errorResult(`No piece with id ${pieceId}`);
+      }
+      adapter.setFocus(pieceId);
+      return textResult(pieceId ? `Focused piece ${pieceId}` : "Cleared focus", { id: pieceId });
+    },
+    abTarget
+  );
+  reg(
+    "artboard_add_section",
+    "Add a section. Provide an explicit id or one is generated.",
+    {
+      section: { type: "object", description: "Section spec: { id?, title, subtitle? }." },
+      index: { type: "number", description: "Insertion index. Defaults to the end." }
+    },
+    ["section"],
+    (args) => {
+      const spec = args.section ?? {};
+      const section = {
+        id: spec.id !== void 0 ? str(spec.id) : newId("sec"),
+        title: str(spec.title),
+        ...spec.subtitle !== void 0 ? { subtitle: str(spec.subtitle) } : {},
+        pieces: []
+      };
+      if (adapter.getValue().sections.some((s) => s.id === section.id)) {
+        return errorResult(`Section id ${section.id} already exists`);
+      }
+      const insertAt = args.index !== void 0 ? Math.max(0, Math.min(num(args.index), adapter.getValue().sections.length)) : adapter.getValue().sections.length;
+      adapter.setValue((prev) => ({
+        sections: [...prev.sections.slice(0, insertAt), section, ...prev.sections.slice(insertAt)]
+      }));
+      pushUndoEntry(agent.id, {
+        timestamp: Date.now(),
+        bridgeId: "artboard",
+        action: "artboard_add_section",
+        label: `Added section ${section.id}`,
+        undo: () => adapter.setValue((prev) => ({ sections: prev.sections.filter((s) => s.id !== section.id) })),
+        redo: () => adapter.setValue((prev) => ({
+          sections: [...prev.sections.slice(0, insertAt), section, ...prev.sections.slice(insertAt)]
+        }))
+      });
+      return textResult(`Added section ${section.id}`, section);
+    },
+    abTarget
+  );
+  reg(
+    "artboard_rename_section",
+    "Set a section's title and optionally its subtitle.",
+    { sectionId: { type: "string" }, title: { type: "string" }, subtitle: { type: "string" } },
+    ["sectionId", "title"],
+    (args) => {
+      const sectionId = str(args.sectionId);
+      const existing = adapter.getValue().sections.find((s) => s.id === sectionId);
+      if (!existing) return errorResult(`No section with id ${sectionId}`);
+      const prevTitle = existing.title;
+      const prevSubtitle = existing.subtitle;
+      const title = str(args.title);
+      const hasSubtitle = args.subtitle !== void 0;
+      const subtitle = hasSubtitle ? str(args.subtitle) : prevSubtitle;
+      const apply = (t, sub) => adapter.setValue((prev) => ({
+        sections: prev.sections.map(
+          (s) => s.id !== sectionId ? s : { ...s, title: t, ...sub !== void 0 ? { subtitle: sub } : {} }
+        )
+      }));
+      apply(title, subtitle);
+      pushUndoEntry(agent.id, {
+        timestamp: Date.now(),
+        bridgeId: "artboard",
+        action: "artboard_rename_section",
+        label: `Renamed section ${sectionId}`,
+        undo: () => apply(prevTitle, prevSubtitle),
+        redo: () => apply(title, subtitle)
+      });
+      return textResult(`Renamed section ${sectionId} \u2192 "${title}"`, { id: sectionId, title, subtitle });
+    },
+    abTarget
+  );
+  reg(
+    "artboard_set_viewport",
+    "Pan / zoom the viewport.",
+    { x: { type: "number" }, y: { type: "number" }, zoom: { type: "number" } },
+    [],
+    (args) => {
+      const v = adapter.getViewport();
+      const next = {
+        x: args.x !== void 0 ? num(args.x) : v.x,
+        y: args.y !== void 0 ? num(args.y) : v.y,
+        zoom: args.zoom !== void 0 ? num(args.zoom) : v.zoom
+      };
+      adapter.setViewport(next);
+      return textResult(`Viewport \u2192 ${JSON.stringify(next)}`, next);
+    },
+    abTarget
+  );
+  return {
+    id: "artboard",
+    title: "Artboard",
+    dispose: () => {
+      for (const d of disposers) d();
+      adapter.setAgentCursor?.(null);
+    }
+  };
+}
+
+exports.registerArtboardBridge = registerArtboardBridge;
+//# sourceMappingURL=bridges-artboard.cjs.map
+//# sourceMappingURL=bridges-artboard.cjs.map