@imenam/mcp-design 1.0.1

package/dist/src/tools/add-nodes.js

@@ -0,0 +1,26 @@
+import { buildNode } from "../core/node-factory.js";
+import { requireString, textResult } from "./types.js";
+export function addNodes(store, args) {
+    const id = requireString(args, "design_id");
+    const input = args?.nodes;
+    if (!Array.isArray(input) || input.length === 0) {
+        throw new Error(`"nodes" is required and must be a non-empty array.`);
+    }
+    const current = store.get(id);
+    const existingIds = new Set(current.nodes.map((n) => n.id));
+    const created = [];
+    // Tout est construit avant d'écrire : une entrée invalide n'ajoute rien du tout.
+    input.forEach((raw, index) => {
+        const node = buildNode(raw, existingIds, current.nodes.length + index + 1);
+        existingIds.add(node.id);
+        created.push(node);
+    });
+    const design = store.mutate(id, "agent", (draft) => {
+        draft.nodes.push(...created);
+    });
+    const lines = created.map((n) => `- ${n.id} — "${n.name}" (${n.type}) at ${Math.round(n.x)},${Math.round(n.y)} size ${Math.round(n.width)}x${Math.round(n.height)}`);
+    return {
+        ...textResult([`Added ${created.length} node(s) to "${design.name}":`, ...lines].join("\n")),
+        design,
+    };
+}

package/dist/src/tools/create-design.d.ts

@@ -0,0 +1,7 @@
+import type { DesignStore } from "../core/design-store.js";
+import type { Design } from "../../shared/schemas/design.schema.js";
+import { type ToolResult } from "./types.js";
+export interface CreateDesignResult extends ToolResult {
+    design?: Design;
+}
+export declare function createDesign(store: DesignStore, args: Record<string, unknown> | undefined): CreateDesignResult;

package/dist/src/tools/create-design.js

@@ -0,0 +1,15 @@
+import { textResult, requireString } from "./types.js";
+export function createDesign(store, args) {
+    const name = requireString(args, "name");
+    const design = store.create({
+        name,
+        width: args?.width === undefined ? undefined : Number(args.width),
+        height: args?.height === undefined ? undefined : Number(args.height),
+        background: typeof args?.background === "string" ? args.background : undefined,
+    });
+    return {
+        ...textResult(`Design "${design.name}" created with id "${design.id}" (${design.width}x${design.height}, background ${design.background}).\n` +
+            `Add content with add_nodes, then open the GUI to let the user refine it.`),
+        design,
+    };
+}

package/dist/src/tools/delete-design.d.ts

@@ -0,0 +1,3 @@
+import type { DesignStore } from "../core/design-store.js";
+import { type ToolResult } from "./types.js";
+export declare function deleteDesign(store: DesignStore, args: Record<string, unknown> | undefined): ToolResult;

package/dist/src/tools/delete-design.js

@@ -0,0 +1,7 @@
+import { requireString, textResult } from "./types.js";
+export function deleteDesign(store, args) {
+    const id = requireString(args, "design_id");
+    const design = store.get(id);
+    store.delete(id);
+    return textResult(`Design "${design.name}" (${id}) deleted, along with its ${design.nodes.length} node(s).`);
+}

package/dist/src/tools/delete-nodes.d.ts

@@ -0,0 +1,3 @@
+import type { DesignStore } from "../core/design-store.js";
+import type { MutationResult } from "./add-nodes.js";
+export declare function deleteNodes(store: DesignStore, args: Record<string, unknown> | undefined): MutationResult;

package/dist/src/tools/delete-nodes.js

@@ -0,0 +1,29 @@
+import { DesignError } from "../core/node-factory.js";
+import { withDescendants } from "../core/hierarchy.js";
+import { requireString, textResult } from "./types.js";
+export function deleteNodes(store, args) {
+    const id = requireString(args, "design_id");
+    const nodeIds = args?.node_ids;
+    if (!Array.isArray(nodeIds) || nodeIds.length === 0) {
+        throw new Error(`"node_ids" is required and must be a non-empty array of node ids.`);
+    }
+    const current = store.get(id);
+    const known = new Set(current.nodes.map((n) => n.id));
+    const missing = nodeIds.filter((nodeId) => !known.has(String(nodeId)));
+    if (missing.length > 0) {
+        throw new DesignError(`Node(s) not found in design "${id}": ${missing.join(", ")}.`);
+    }
+    // Supprimer un groupe emporte son contenu : le laisser derrière lui produirait
+    // des noeuds orphelins pointant vers un parent disparu.
+    const toRemove = withDescendants(current.nodes, nodeIds.map((nodeId) => String(nodeId)));
+    const nested = toRemove.size - nodeIds.length;
+    const design = store.mutate(id, "agent", (draft) => {
+        draft.nodes = draft.nodes.filter((n) => !toRemove.has(n.id));
+    });
+    return {
+        ...textResult(`Deleted ${toRemove.size} node(s) from "${design.name}"` +
+            `${nested > 0 ? ` (${nested} of them nested inside a deleted group)` : ""}. ` +
+            `${design.nodes.length} node(s) remaining.`),
+        design,
+    };
+}

package/dist/src/tools/export-design.d.ts

@@ -0,0 +1,3 @@
+import type { DesignStore } from "../core/design-store.js";
+import { type ToolResult } from "./types.js";
+export declare function exportDesignTool(store: DesignStore, args: Record<string, unknown> | undefined): ToolResult;

package/dist/src/tools/export-design.js

@@ -0,0 +1,21 @@
+import fs from "fs";
+import path from "path";
+import { EXPORT_FORMATS, exportDesign as render } from "../core/export.js";
+import { requireString, textResult } from "./types.js";
+export function exportDesignTool(store, args) {
+    const id = requireString(args, "design_id");
+    const format = (args?.format ?? "html");
+    if (!EXPORT_FORMATS.includes(format)) {
+        throw new Error(`Unknown format "${String(format)}". Expected one of: ${EXPORT_FORMATS.join(", ")}.`);
+    }
+    const design = store.get(id);
+    const content = render(design, format);
+    const outputPath = typeof args?.output_path === "string" ? args.output_path.trim() : "";
+    if (outputPath) {
+        const target = path.resolve(outputPath);
+        fs.mkdirSync(path.dirname(target), { recursive: true });
+        fs.writeFileSync(target, content, "utf-8");
+        return textResult(`Design "${design.name}" exported as ${format} to ${target} (${content.length} characters).`);
+    }
+    return textResult(content);
+}

package/dist/src/tools/get-changes.d.ts

@@ -0,0 +1,11 @@
+import type { DesignStore } from "../core/design-store.js";
+import { type ToolResult } from "./types.js";
+/**
+ * Cœur de la boucle agent <-> utilisateur : ce que la GUI (ou l'agent) a changé
+ * depuis le dernier `mark_synced`.
+ *
+ * Lire les changements ne les acquitte jamais : seul `mark_synced` déplace la
+ * référence, pour qu'un appel de lecture ne puisse pas faire disparaître un
+ * diff que l'agent n'a pas encore intégré.
+ */
+export declare function getChanges(store: DesignStore, args: Record<string, unknown> | undefined): ToolResult;

package/dist/src/tools/get-changes.js

@@ -0,0 +1,27 @@
+import { diffNodes, formatDiff } from "../core/diff.js";
+import { requireString, textResult } from "./types.js";
+/**
+ * Cœur de la boucle agent <-> utilisateur : ce que la GUI (ou l'agent) a changé
+ * depuis le dernier `mark_synced`.
+ *
+ * Lire les changements ne les acquitte jamais : seul `mark_synced` déplace la
+ * référence, pour qu'un appel de lecture ne puisse pas faire disparaître un
+ * diff que l'agent n'a pas encore intégré.
+ */
+export function getChanges(store, args) {
+    const id = requireString(args, "design_id");
+    const design = store.get(id);
+    const diff = diffNodes(design.baseline.nodes, design.nodes);
+    const total = diff.added.length + diff.updated.length + diff.removed.length;
+    if (total === 0 && !diff.reordered) {
+        return textResult(`No change in "${design.name}" since the baseline taken at ${design.baseline.at} (revision ${design.baseline.revision}).`);
+    }
+    const header = [
+        `Changes in "${design.name}" (${id}) since revision ${design.baseline.revision} (${design.baseline.at}).`,
+        `Current revision ${design.revision}, last edited by ${design.lastEditor}.`,
+        "",
+    ].join("\n");
+    const footer = "\n\nOnce these changes are integrated into the codebase, call mark_synced to move the baseline forward. " +
+        "Use export_design (format html or jsx) to get ready-to-adapt markup.";
+    return textResult(header + formatDiff(diff) + footer);
+}

package/dist/src/tools/get-design.d.ts

@@ -0,0 +1,7 @@
+import type { DesignStore } from "../core/design-store.js";
+import { type ToolResult } from "./types.js";
+/**
+ * Deux niveaux de détail : `summary` (défaut) pour se repérer sans saturer le
+ * contexte, `json` quand l'agent a besoin des valeurs exactes pour patcher.
+ */
+export declare function getDesign(store: DesignStore, args: Record<string, unknown> | undefined): ToolResult;

package/dist/src/tools/get-design.js

@@ -0,0 +1,29 @@
+import { toSummary } from "../core/export.js";
+import { countChanges } from "../core/diff.js";
+import { requireString, textResult } from "./types.js";
+/**
+ * Deux niveaux de détail : `summary` (défaut) pour se repérer sans saturer le
+ * contexte, `json` quand l'agent a besoin des valeurs exactes pour patcher.
+ */
+export function getDesign(store, args) {
+    const id = requireString(args, "design_id");
+    const format = args?.format === "json" ? "json" : "summary";
+    const design = store.get(id);
+    const pending = countChanges(design.baseline.nodes, design.nodes);
+    const notice = pending > 0
+        ? `\n\nNOTE: ${pending} node(s) differ from the last synced baseline. Call get_changes to see exactly what the user edited.`
+        : "";
+    if (format === "json") {
+        return textResult(JSON.stringify({
+            id: design.id,
+            name: design.name,
+            width: design.width,
+            height: design.height,
+            background: design.background,
+            revision: design.revision,
+            lastEditor: design.lastEditor,
+            nodes: design.nodes,
+        }, null, 2) + notice);
+    }
+    return textResult(toSummary(design) + notice);
+}

package/dist/src/tools/group-nodes.d.ts

@@ -0,0 +1,10 @@
+import type { DesignStore } from "../core/design-store.js";
+import type { MutationResult } from "./add-nodes.js";
+/**
+ * Regroupe des éléments sous un nouveau groupe.
+ *
+ * Les éléments doivent partager le même parent : regrouper des éléments situés
+ * dans des groupes différents changerait leur ordre d'empilement de façon
+ * imprévisible, mieux vaut le refuser que le deviner.
+ */
+export declare function groupNodes(store: DesignStore, args: Record<string, unknown> | undefined): MutationResult;

package/dist/src/tools/group-nodes.js

@@ -0,0 +1,83 @@
+import { boundsOf, computeLayout, descendantIds, spaceOriginOf } from "../../shared/tree.js";
+import { DesignError } from "../core/node-factory.js";
+import { shortId } from "../core/ids.js";
+import { requireString, textResult } from "./types.js";
+/**
+ * Regroupe des éléments sous un nouveau groupe.
+ *
+ * Les éléments doivent partager le même parent : regrouper des éléments situés
+ * dans des groupes différents changerait leur ordre d'empilement de façon
+ * imprévisible, mieux vaut le refuser que le deviner.
+ */
+export function groupNodes(store, args) {
+    const id = requireString(args, "design_id");
+    const nodeIds = args?.node_ids;
+    if (!Array.isArray(nodeIds) || nodeIds.length === 0) {
+        throw new Error(`"node_ids" is required and must be a non-empty array of node ids.`);
+    }
+    const current = store.get(id);
+    const byId = new Map(current.nodes.map((node) => [node.id, node]));
+    const targets = nodeIds.map((raw) => {
+        const node = byId.get(String(raw));
+        if (!node)
+            throw new DesignError(`Node "${String(raw)}" not found in design "${id}".`);
+        return node;
+    });
+    const parents = new Set(targets.map((node) => node.parentId));
+    if (parents.size > 1) {
+        throw new DesignError(`Cannot group nodes that live in different groups. Move them under the same parent first (update_nodes with parentId).`);
+    }
+    const parentId = targets[0].parentId;
+    // Regrouper un groupe et l'un de ses propres descendants n'a pas de sens.
+    for (const node of targets) {
+        const inside = descendantIds(current.nodes, node.id);
+        const nested = targets.find((other) => other.id !== node.id && inside.has(other.id));
+        if (nested) {
+            throw new DesignError(`Cannot group "${nested.id}" together with its own ancestor "${node.id}".`);
+        }
+    }
+    const layout = computeLayout(current.nodes);
+    const spaceOrigin = spaceOriginOf(layout, parentId);
+    const boxes = targets.map((node) => boundsOf(layout, node.id));
+    const groupX = Math.min(...boxes.map((box) => box.x)) - spaceOrigin.x;
+    const groupY = Math.min(...boxes.map((box) => box.y)) - spaceOrigin.y;
+    const groupId = typeof args?.group_id === "string" && args.group_id.trim() !== "" ? args.group_id.trim() : shortId("g");
+    if (byId.has(groupId))
+        throw new DesignError(`Node id "${groupId}" already exists in this design.`);
+    const group = {
+        id: groupId,
+        type: "group",
+        name: typeof args?.name === "string" && args.name.trim() !== "" ? args.name.trim() : "Groupe",
+        parentId,
+        x: groupX,
+        y: groupY,
+        width: 0,
+        height: 0,
+        rotation: 0,
+        opacity: 1,
+    };
+    const moved = new Set(targets.map((node) => node.id));
+    const design = store.mutate(id, "agent", (draft) => {
+        // Les coordonnées deviennent relatives au groupe : le contenu ne bouge pas à l'écran.
+        const rebased = draft.nodes.map((node) => moved.has(node.id) ? { ...node, parentId: groupId, x: node.x - groupX, y: node.y - groupY } : node);
+        // Le groupe prend la place du plus haut de ses membres dans l'ordre
+        // d'empilement, et ses membres le suivent dans leur ordre relatif d'origine.
+        const members = rebased.filter((node) => moved.has(node.id));
+        const lastMemberId = members[members.length - 1].id;
+        const reordered = [];
+        for (const node of rebased) {
+            if (!moved.has(node.id)) {
+                reordered.push(node);
+            }
+            else if (node.id === lastMemberId) {
+                reordered.push(group, ...members);
+            }
+        }
+        draft.nodes = reordered;
+    });
+    return {
+        ...textResult(`Grouped ${targets.length} node(s) into "${group.name}" (${groupId})` +
+            `${parentId ? ` inside group ${parentId}` : ""}. The content did not move on screen.`),
+        design,
+    };
+}

package/dist/src/tools/list-designs.d.ts

@@ -0,0 +1,3 @@
+import type { DesignStore } from "../core/design-store.js";
+import { type ToolResult } from "./types.js";
+export declare function listDesigns(store: DesignStore): ToolResult;

package/dist/src/tools/list-designs.js

@@ -0,0 +1,13 @@
+import { textResult } from "./types.js";
+export function listDesigns(store) {
+    const designs = store.list();
+    if (designs.length === 0) {
+        return textResult("No design yet. Use create_design to start one.");
+    }
+    const lines = designs.map((d) => {
+        const pending = d.pendingChanges > 0 ? ` — ${d.pendingChanges} unsynced change(s)` : "";
+        return (`- ${d.id} — "${d.name}" ${d.width}x${d.height}, ${d.nodeCount} node(s), ` +
+            `rev ${d.revision} last edited by ${d.lastEditor} at ${d.updatedAt}${pending}`);
+    });
+    return textResult([`${designs.length} design(s):`, ...lines].join("\n"));
+}

package/dist/src/tools/mark-synced.d.ts

@@ -0,0 +1,7 @@
+import type { DesignStore } from "../core/design-store.js";
+import type { MutationResult } from "./add-nodes.js";
+/**
+ * Seul point d'acquittement des changements. Appelé une fois le design réellement
+ * reporté dans le code, jamais "au cas où".
+ */
+export declare function markSynced(store: DesignStore, args: Record<string, unknown> | undefined): MutationResult;

package/dist/src/tools/mark-synced.js

@@ -0,0 +1,19 @@
+import { countChanges } from "../core/diff.js";
+import { requireString, textResult } from "./types.js";
+/**
+ * Seul point d'acquittement des changements. Appelé une fois le design réellement
+ * reporté dans le code, jamais "au cas où".
+ */
+export function markSynced(store, args) {
+    const id = requireString(args, "design_id");
+    const before = store.get(id);
+    const pending = countChanges(before.baseline.nodes, before.nodes);
+    const design = store.markSynced(id);
+    return {
+        ...textResult(pending === 0
+            ? `Baseline of "${design.name}" was already up to date (revision ${design.revision}).`
+            : `Baseline of "${design.name}" moved to revision ${design.revision}. ` +
+                `${pending} change(s) acknowledged — get_changes now reports nothing until the next edit.`),
+        design,
+    };
+}

package/dist/src/tools/reorder-nodes.d.ts

@@ -0,0 +1,7 @@
+import type { DesignStore } from "../core/design-store.js";
+import type { MutationResult } from "./add-nodes.js";
+/**
+ * Change l'ordre d'empilement d'éléments — l'équivalent agent du panneau de
+ * calques de la GUI, dont il partage la logique (`reorderNodes` dans shared/tree).
+ */
+export declare function reorderNodesTool(store: DesignStore, args: Record<string, unknown> | undefined): MutationResult;

package/dist/src/tools/reorder-nodes.js

@@ -0,0 +1,60 @@
+import { REORDER_DIRECTIONS, childrenByParent, reorderNodes as reorder, } from "../../shared/tree.js";
+import { DesignError } from "../core/node-factory.js";
+import { requireString, textResult } from "./types.js";
+/**
+ * Change l'ordre d'empilement d'éléments — l'équivalent agent du panneau de
+ * calques de la GUI, dont il partage la logique (`reorderNodes` dans shared/tree).
+ */
+export function reorderNodesTool(store, args) {
+    const id = requireString(args, "design_id");
+    const nodeIds = args?.node_ids;
+    if (!Array.isArray(nodeIds) || nodeIds.length === 0) {
+        throw new Error(`"node_ids" is required and must be a non-empty array of node ids.`);
+    }
+    const direction = args?.position;
+    if (!REORDER_DIRECTIONS.includes(direction)) {
+        throw new Error(`"position" is required and must be one of: ${REORDER_DIRECTIONS.join(", ")} ` +
+            `(received: ${JSON.stringify(args?.position)}).`);
+    }
+    const current = store.get(id);
+    const byId = new Map(current.nodes.map((node) => [node.id, node]));
+    const targets = nodeIds.map((raw) => {
+        const node = byId.get(String(raw));
+        if (!node)
+            throw new DesignError(`Node "${String(raw)}" not found in design "${id}".`);
+        return node;
+    });
+    const moved = new Set(targets.map((node) => node.id));
+    const before = current.nodes.map((node) => node.id).join(" ");
+    const design = store.mutate(id, "agent", (draft) => {
+        draft.nodes = reorder(draft.nodes, [...moved], direction);
+    });
+    if (design.nodes.map((node) => node.id).join(" ") === before) {
+        // Le cas est fréquent, et silencieux autrement : un élément déjà au sommet
+        // de sa fratrie ne bougera jamais, quel que soit le nombre d'appels.
+        const edge = direction === "back" || direction === "backward" ? "bottom" : "top";
+        const subject = targets.length === 1 ? `"${targets[0].name}" (${targets[0].id}) is` : "those nodes are";
+        return {
+            ...textResult(`Nothing moved: ${subject} already at the ${edge} of their sibling order. ` +
+                `Stacking is relative to siblings only — to move an element past the content of another group, ` +
+                `reorder that group itself, or reparent the element with update_nodes.`),
+            design,
+        };
+    }
+    // L'ordre final, fratrie par fratrie : évite à l'agent un get_design de contrôle.
+    const siblings = childrenByParent(design.nodes);
+    const parents = new Set(design.nodes.filter((node) => moved.has(node.id)).map((node) => node.parentId));
+    const lines = [...parents].map((parentId) => {
+        const order = (siblings.get(parentId) ?? [])
+            .map((node) => (moved.has(node.id) ? `[${node.name}]` : node.name))
+            .join(" then ");
+        return `- ${parentId === null ? "root level" : `inside group ${parentId}`}, bottom to top: ${order}`;
+    });
+    return {
+        ...textResult([
+            `Moved ${targets.length} node(s) ${direction} in "${design.name}" (moved nodes in brackets):`,
+            ...lines,
+        ].join("\n")),
+        design,
+    };
+}

package/dist/src/tools/screenshot-design.d.ts

@@ -0,0 +1,3 @@
+import type { DesignStore } from "../core/design-store.js";
+import { type ImageToolResult } from "./types.js";
+export declare function screenshotDesignTool(store: DesignStore, args: Record<string, unknown> | undefined): ImageToolResult;

package/dist/src/tools/screenshot-design.js

@@ -0,0 +1,36 @@
+import fs from "fs";
+import path from "path";
+import { screenshotDesign } from "../core/screenshot.js";
+import { requireString } from "./types.js";
+/** Marge par défaut autour d'un noeud capturé : de l'air, sans noyer l'élément. */
+const NODE_PADDING = 16;
+export function screenshotDesignTool(store, args) {
+    const id = requireString(args, "design_id");
+    const design = store.get(id);
+    const nodeId = typeof args?.node_id === "string" && args.node_id.trim() !== "" ? args.node_id.trim() : undefined;
+    const node = nodeId ? design.nodes.find((candidate) => candidate.id === nodeId) : undefined;
+    if (nodeId && !node) {
+        throw new Error(`Node "${nodeId}" not found in design "${design.name}" (${design.id}).`);
+    }
+    const shot = screenshotDesign(design, {
+        nodeId,
+        scale: args?.scale === undefined ? undefined : Number(args.scale),
+        padding: args?.padding === undefined ? (nodeId ? NODE_PADDING : 0) : Number(args.padding),
+    });
+    const subject = node ? `${node.type} "${node.name}" (${node.id})` : `design "${design.name}"`;
+    const geometry = `${Math.round(shot.sourceWidth)}x${Math.round(shot.sourceHeight)} design px ` +
+        `rendered at ${shot.width}x${shot.height} px (scale ${Math.round(shot.scale * 100) / 100})`;
+    const outputPath = typeof args?.output_path === "string" ? args.output_path.trim() : "";
+    if (outputPath) {
+        const target = path.resolve(outputPath);
+        fs.mkdirSync(path.dirname(target), { recursive: true });
+        fs.writeFileSync(target, shot.png);
+        return { content: [{ type: "text", text: `Screenshot of ${subject} written to ${target} — ${geometry}.` }] };
+    }
+    return {
+        content: [
+            { type: "text", text: `Screenshot of ${subject} — ${geometry}, revision ${design.revision}.` },
+            { type: "image", data: shot.png.toString("base64"), mimeType: "image/png" },
+        ],
+    };
+}

package/dist/src/tools/types.d.ts

@@ -0,0 +1,25 @@
+/** Forme de réponse attendue par le SDK MCP pour un appel d'outil. */
+export interface ToolResult {
+    [key: string]: unknown;
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+    isError?: boolean;
+}
+export declare function textResult(text: string): ToolResult;
+export declare function errorResult(text: string): ToolResult;
+export declare function requireString(args: Record<string, unknown> | undefined, field: string): string;
+/** Variante de ToolResult pour les outils qui renvoient une image (capture d'écran). */
+export interface ImageToolResult {
+    [key: string]: unknown;
+    content: Array<{
+        type: "text";
+        text: string;
+    } | {
+        type: "image";
+        data: string;
+        mimeType: string;
+    }>;
+    isError?: boolean;
+}

package/dist/src/tools/types.js

@@ -0,0 +1,13 @@
+export function textResult(text) {
+    return { content: [{ type: "text", text }] };
+}
+export function errorResult(text) {
+    return { content: [{ type: "text", text: `Error: ${text}` }], isError: true };
+}
+export function requireString(args, field) {
+    const value = args?.[field];
+    if (typeof value !== "string" || value.trim() === "") {
+        throw new Error(`"${field}" is required and must be a non-empty string.`);
+    }
+    return value.trim();
+}

package/dist/src/tools/ungroup-nodes.d.ts

@@ -0,0 +1,7 @@
+import type { DesignStore } from "../core/design-store.js";
+import type { MutationResult } from "./add-nodes.js";
+/**
+ * Dissout un ou plusieurs groupes : leur contenu remonte d'un niveau, à la place
+ * qu'occupait le groupe dans l'ordre d'empilement, sans bouger à l'écran.
+ */
+export declare function ungroupNodes(store: DesignStore, args: Record<string, unknown> | undefined): MutationResult;

package/dist/src/tools/ungroup-nodes.js

@@ -0,0 +1,64 @@
+import { DesignError } from "../core/node-factory.js";
+import { requireString, textResult } from "./types.js";
+/**
+ * Dissout un ou plusieurs groupes : leur contenu remonte d'un niveau, à la place
+ * qu'occupait le groupe dans l'ordre d'empilement, sans bouger à l'écran.
+ */
+export function ungroupNodes(store, args) {
+    const id = requireString(args, "design_id");
+    const groupIds = args?.group_ids;
+    if (!Array.isArray(groupIds) || groupIds.length === 0) {
+        throw new Error(`"group_ids" is required and must be a non-empty array of group ids.`);
+    }
+    const current = store.get(id);
+    const byId = new Map(current.nodes.map((node) => [node.id, node]));
+    const groups = groupIds.map((raw) => {
+        const node = byId.get(String(raw));
+        if (!node)
+            throw new DesignError(`Node "${String(raw)}" not found in design "${id}".`);
+        if (node.type !== "group") {
+            throw new DesignError(`Node "${node.id}" is a "${node.type}", not a group — nothing to ungroup.`);
+        }
+        return node;
+    });
+    const dissolved = new Set(groups.map((group) => group.id));
+    let promoted = 0;
+    const design = store.mutate(id, "agent", (draft) => {
+        const nodesById = new Map(draft.nodes.map((node) => [node.id, node]));
+        /**
+         * Remonte la chaîne d'ancêtres jusqu'au premier groupe conservé, en
+         * accumulant les offsets traversés. Gère du même coup le cas où plusieurs
+         * groupes imbriqués sont dissous en un seul appel.
+         */
+        const surviving = (parentId) => {
+            let dx = 0;
+            let dy = 0;
+            let cursor = parentId;
+            while (cursor !== null && dissolved.has(cursor)) {
+                const group = nodesById.get(cursor);
+                dx += group.x;
+                dy += group.y;
+                cursor = group.parentId;
+            }
+            return { parentId: cursor, dx, dy };
+        };
+        const result = [];
+        for (const node of draft.nodes) {
+            if (dissolved.has(node.id))
+                continue;
+            const target = surviving(node.parentId);
+            if (target.parentId === node.parentId) {
+                result.push(node);
+                continue;
+            }
+            // Le contenu absorbe l'offset des groupes traversés : rien ne bouge à l'écran.
+            promoted++;
+            result.push({ ...node, parentId: target.parentId, x: node.x + target.dx, y: node.y + target.dy });
+        }
+        draft.nodes = result;
+    });
+    return {
+        ...textResult(`Ungrouped ${groups.length} group(s); ${promoted} node(s) moved up one level. Nothing moved on screen.`),
+        design,
+    };
+}

package/dist/src/tools/update-design.d.ts

@@ -0,0 +1,4 @@
+import type { DesignStore } from "../core/design-store.js";
+import type { MutationResult } from "./add-nodes.js";
+/** Propriétés de la planche elle-même (nom, dimensions, fond) — pas de ses noeuds. */
+export declare function updateDesign(store: DesignStore, args: Record<string, unknown> | undefined): MutationResult;

package/dist/src/tools/update-design.js

@@ -0,0 +1,33 @@
+import { requireString, textResult } from "./types.js";
+/** Propriétés de la planche elle-même (nom, dimensions, fond) — pas de ses noeuds. */
+export function updateDesign(store, args) {
+    const id = requireString(args, "design_id");
+    const fields = ["name", "width", "height", "background"];
+    if (fields.every((field) => args?.[field] === undefined)) {
+        throw new Error(`Nothing to update. Provide at least one of: ${fields.join(", ")}.`);
+    }
+    const changed = [];
+    const design = store.mutate(id, "agent", (draft) => {
+        if (args?.name !== undefined) {
+            const name = String(args.name).trim();
+            if (name === "")
+                throw new Error(`"name" must be a non-empty string.`);
+            draft.name = name;
+            changed.push(`name -> "${name}"`);
+        }
+        for (const field of ["width", "height"]) {
+            if (args?.[field] === undefined)
+                continue;
+            const value = Number(args[field]);
+            if (!Number.isFinite(value) || value <= 0)
+                throw new Error(`"${field}" must be a positive number.`);
+            draft[field] = value;
+            changed.push(`${field} -> ${value}`);
+        }
+        if (args?.background !== undefined) {
+            draft.background = String(args.background);
+            changed.push(`background -> ${draft.background}`);
+        }
+    });
+    return { ...textResult(`Design "${design.id}" updated: ${changed.join(", ")}.`), design };
+}

package/dist/src/tools/update-nodes.d.ts

@@ -0,0 +1,3 @@
+import type { DesignStore } from "../core/design-store.js";
+import type { MutationResult } from "./add-nodes.js";
+export declare function updateNodes(store: DesignStore, args: Record<string, unknown> | undefined): MutationResult;