@mag.ni/process 1.0.0

package/dist/tools/design.js

@@ -0,0 +1,1172 @@
+/**
+ * MCP Processes - Design Tools
+ * Tools for creating and modifying diagrams in design mode
+ */
+const designModeState = {
+    isDesignMode: false,
+    activeDiagramId: null,
+};
+// =============================================================================
+// Tool Definitions
+// =============================================================================
+/**
+ * Tool: enter_design_mode
+ * Switch to design mode to create and modify diagrams
+ */
+export const enterDesignModeTool = {
+    name: "enter_design_mode",
+    description: "Enter design mode to create and modify diagrams. In design mode, you can create diagrams, add nodes, connect them with arrows, and configure workflow logic. Call exit_design_mode when finished designing.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            diagramId: {
+                type: "string",
+                description: "Optional diagram ID to start editing. If not provided, use list_diagrams or create_diagram to get started.",
+            },
+        },
+        required: [],
+    },
+};
+/**
+ * Tool: exit_design_mode
+ * Exit design mode and return to work mode
+ */
+export const exitDesignModeTool = {
+    name: "exit_design_mode",
+    description: "Exit design mode and return to work mode. Any unsaved changes should be committed before exiting.",
+    inputSchema: {
+        type: "object",
+        properties: {},
+        required: [],
+    },
+};
+/**
+ * Tool: list_diagrams
+ * List all available diagrams
+ */
+export const listDiagramsTool = {
+    name: "list_diagrams",
+    description: "List all available diagrams with optional filtering. Returns diagram metadata including ID, title, token, type, and node/arrow counts.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            search: {
+                type: "string",
+                description: "Search term to filter diagrams by title or token",
+            },
+            diagramType: {
+                type: "string",
+                enum: ["all", "process", "activity", "dependency"],
+                description: "Filter by diagram type. Defaults to 'all'.",
+            },
+            sortBy: {
+                type: "string",
+                enum: ["updatedAt", "createdAt", "title"],
+                description: "Sort field. Defaults to 'updatedAt'.",
+            },
+            sortOrder: {
+                type: "string",
+                enum: ["asc", "desc"],
+                description: "Sort order. Defaults to 'desc'.",
+            },
+            topLevelOnly: {
+                type: "boolean",
+                description: "If true, only return top-level diagrams (not sub-diagrams). Defaults to false.",
+            },
+        },
+        required: [],
+    },
+};
+/**
+ * Tool: get_diagram
+ * Get a diagram's full details for editing
+ */
+export const getDiagramTool = {
+    name: "get_diagram",
+    description: "Get a diagram's full details including all nodes and arrows. Use this to load a diagram for editing in design mode.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            diagramId: {
+                type: "string",
+                description: "ID of the diagram to retrieve",
+            },
+        },
+        required: ["diagramId"],
+    },
+};
+/**
+ * Tool: create_diagram
+ * Create a new diagram
+ */
+export const createDiagramTool = {
+    name: "create_diagram",
+    description: "Create a new diagram. Returns the created diagram with its ID. You can then add nodes and arrows to it.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            title: {
+                type: "string",
+                description: "Title of the diagram (e.g., 'Customer Onboarding Process')",
+            },
+            token: {
+                type: "string",
+                description: "Unique token/slug for the diagram (e.g., 'customer-onboarding'). Must be unique across all diagrams.",
+            },
+            diagramType: {
+                type: "string",
+                enum: ["process", "activity", "dependency"],
+                description: "Type of diagram. Defaults to 'process'.",
+            },
+            mode: {
+                type: "string",
+                enum: ["reactive", "proactive"],
+                description: "Workflow mode. 'reactive' waits for user actions, 'proactive' advances automatically. Defaults to 'reactive'.",
+            },
+        },
+        required: ["title", "token"],
+    },
+};
+/**
+ * Tool: update_diagram
+ * Update diagram properties
+ */
+export const updateDiagramTool = {
+    name: "update_diagram",
+    description: "Update a diagram's properties such as title, token, type, or mode. Does not modify nodes or arrows - use create_node, update_node, create_arrow, delete_arrow for that.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            diagramId: {
+                type: "string",
+                description: "ID of the diagram to update",
+            },
+            title: {
+                type: "string",
+                description: "New title for the diagram",
+            },
+            token: {
+                type: "string",
+                description: "New token for the diagram (must be unique)",
+            },
+            diagramType: {
+                type: "string",
+                enum: ["process", "activity", "dependency"],
+                description: "New diagram type",
+            },
+            mode: {
+                type: "string",
+                enum: ["reactive", "proactive"],
+                description: "New workflow mode",
+            },
+        },
+        required: ["diagramId"],
+    },
+};
+/**
+ * Tool: create_node
+ * Add a node to a diagram
+ */
+export const createNodeTool = {
+    name: "create_node",
+    description: "Add a new node to a diagram. Nodes represent steps in the workflow. Position nodes carefully - use coordinates based on existing nodes for proper layout.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            diagramId: {
+                type: "string",
+                description: "ID of the diagram to add the node to",
+            },
+            label: {
+                type: "string",
+                description: "Label/title for the node (e.g., 'Review Application', 'Send Email')",
+            },
+            x: {
+                type: "number",
+                description: "X coordinate for the node position (horizontal). Typical spacing is 200-300 units between nodes.",
+            },
+            y: {
+                type: "number",
+                description: "Y coordinate for the node position (vertical). Typical spacing is 150-200 units between rows.",
+            },
+            shape: {
+                type: "string",
+                enum: ["roundedRect", "diamond", "ellipse", "rect"],
+                description: "Node shape. Use 'roundedRect' for tasks, 'diamond' for decisions, 'ellipse' for start/end. Defaults to 'roundedRect'.",
+            },
+            isStart: {
+                type: "boolean",
+                description: "Mark as the start node. Only one node per diagram should be the start.",
+            },
+            isEnd: {
+                type: "boolean",
+                description: "Mark as an end node. A diagram can have multiple end nodes.",
+            },
+            description: {
+                type: "string",
+                description: "Detailed description or instructions for this step",
+            },
+            waitForAll: {
+                type: "boolean",
+                description: "If true, all parallel branches must arrive at this node before any can proceed (merge point).",
+            },
+            childDiagramId: {
+                type: "string",
+                description: "Link to a sub-diagram. When workflow reaches this node, it will enter the child diagram.",
+            },
+            assignedUserId: {
+                type: "string",
+                description: "User ID to auto-assign instances when they reach this node.",
+            },
+            width: {
+                type: "number",
+                description: "Node width. Defaults to 150.",
+            },
+            height: {
+                type: "number",
+                description: "Node height. Defaults to 60.",
+            },
+            fillColor: {
+                type: "string",
+                description: "Background color (hex). Defaults to '#ffffff'.",
+            },
+            borderColor: {
+                type: "string",
+                description: "Border color (hex). Defaults to '#000000'.",
+            },
+            textColor: {
+                type: "string",
+                description: "Text color (hex). Defaults to '#000000'.",
+            },
+            durationValue: {
+                type: "number",
+                description: "Expected duration value for this step (for planning).",
+            },
+            durationUnit: {
+                type: "string",
+                enum: ["minutes", "hours", "days", "weeks", "months"],
+                description: "Duration unit.",
+            },
+        },
+        required: ["diagramId", "label", "x", "y"],
+    },
+};
+/**
+ * Tool: update_node
+ * Update an existing node's properties
+ */
+export const updateNodeTool = {
+    name: "update_node",
+    description: "Update an existing node's properties. You can change any node property including position, label, shape, and workflow behavior settings.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            diagramId: {
+                type: "string",
+                description: "ID of the diagram containing the node",
+            },
+            nodeId: {
+                type: "string",
+                description: "ID of the node to update",
+            },
+            label: {
+                type: "string",
+                description: "New label for the node",
+            },
+            x: {
+                type: "number",
+                description: "New X coordinate",
+            },
+            y: {
+                type: "number",
+                description: "New Y coordinate",
+            },
+            shape: {
+                type: "string",
+                enum: ["roundedRect", "diamond", "ellipse", "rect"],
+                description: "New shape",
+            },
+            isStart: {
+                type: "boolean",
+                description: "Set or unset as start node",
+            },
+            isEnd: {
+                type: "boolean",
+                description: "Set or unset as end node",
+            },
+            description: {
+                type: "string",
+                description: "New description",
+            },
+            waitForAll: {
+                type: "boolean",
+                description: "Enable/disable wait-for-all merge behavior",
+            },
+            childDiagramId: {
+                type: "string",
+                description: "Link to a child diagram (or null to unlink)",
+            },
+            assignedUserId: {
+                type: "string",
+                description: "User to auto-assign (or null to remove assignment)",
+            },
+            width: {
+                type: "number",
+                description: "New width",
+            },
+            height: {
+                type: "number",
+                description: "New height",
+            },
+            fillColor: {
+                type: "string",
+                description: "New background color",
+            },
+            borderColor: {
+                type: "string",
+                description: "New border color",
+            },
+            textColor: {
+                type: "string",
+                description: "New text color",
+            },
+            durationValue: {
+                type: "number",
+                description: "New duration value",
+            },
+            durationUnit: {
+                type: "string",
+                enum: ["minutes", "hours", "days", "weeks", "months"],
+                description: "New duration unit",
+            },
+        },
+        required: ["diagramId", "nodeId"],
+    },
+};
+/**
+ * Tool: delete_node
+ * Remove a node from a diagram
+ */
+export const deleteNodeTool = {
+    name: "delete_node",
+    description: "Remove a node from a diagram. This will also remove any arrows connected to this node. Use with caution.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            diagramId: {
+                type: "string",
+                description: "ID of the diagram containing the node",
+            },
+            nodeId: {
+                type: "string",
+                description: "ID of the node to delete",
+            },
+        },
+        required: ["diagramId", "nodeId"],
+    },
+};
+/**
+ * Tool: create_arrow
+ * Connect two nodes with an arrow
+ */
+export const createArrowTool = {
+    name: "create_arrow",
+    description: "Connect two nodes with an arrow. Arrows define the workflow transitions between nodes. For decision nodes, create multiple arrows with different labels for each path.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            diagramId: {
+                type: "string",
+                description: "ID of the diagram",
+            },
+            from: {
+                type: "string",
+                description: "ID of the source node (where the arrow starts)",
+            },
+            to: {
+                type: "string",
+                description: "ID of the target node (where the arrow points)",
+            },
+            label: {
+                type: "string",
+                description: "Label for the arrow (e.g., 'Yes', 'No', 'Approve', 'Reject'). Important for decision nodes.",
+            },
+            fromPoint: {
+                type: "string",
+                enum: ["top", "right", "bottom", "left"],
+                description: "Connection point on the source node. Defaults to 'right'.",
+            },
+            toPoint: {
+                type: "string",
+                enum: ["top", "right", "bottom", "left"],
+                description: "Connection point on the target node. Defaults to 'left'.",
+            },
+            delay: {
+                type: "string",
+                description: "Time delay before transition (e.g., '+3d' for 3 days, '+24h' for 24 hours, '+30m' for 30 minutes).",
+            },
+            color: {
+                type: "string",
+                description: "Arrow color (hex). Defaults to '#000000'.",
+            },
+            thickness: {
+                type: "number",
+                description: "Line thickness. Defaults to 2.",
+            },
+            lineStyle: {
+                type: "string",
+                enum: ["solid", "dashed", "dotted"],
+                description: "Line style. Defaults to 'solid'.",
+            },
+            routing: {
+                type: "string",
+                enum: ["straight", "orthogonal", "curved"],
+                description: "Arrow routing style. Defaults to 'straight'.",
+            },
+        },
+        required: ["diagramId", "from", "to"],
+    },
+};
+/**
+ * Tool: update_arrow
+ * Update an existing arrow's properties
+ */
+export const updateArrowTool = {
+    name: "update_arrow",
+    description: "Update an existing arrow's properties such as label, connection points, delay, or styling.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            diagramId: {
+                type: "string",
+                description: "ID of the diagram containing the arrow",
+            },
+            arrowId: {
+                type: "string",
+                description: "ID of the arrow to update",
+            },
+            label: {
+                type: "string",
+                description: "New label for the arrow",
+            },
+            fromPoint: {
+                type: "string",
+                enum: ["top", "right", "bottom", "left"],
+                description: "New connection point on the source node",
+            },
+            toPoint: {
+                type: "string",
+                enum: ["top", "right", "bottom", "left"],
+                description: "New connection point on the target node",
+            },
+            delay: {
+                type: "string",
+                description: "New time delay (e.g., '+3d', '+24h', '+30m', or null to remove)",
+            },
+            color: {
+                type: "string",
+                description: "New arrow color (hex)",
+            },
+            thickness: {
+                type: "number",
+                description: "New line thickness",
+            },
+            lineStyle: {
+                type: "string",
+                enum: ["solid", "dashed", "dotted"],
+                description: "New line style",
+            },
+            routing: {
+                type: "string",
+                enum: ["straight", "orthogonal", "curved"],
+                description: "New routing style",
+            },
+        },
+        required: ["diagramId", "arrowId"],
+    },
+};
+/**
+ * Tool: delete_arrow
+ * Remove an arrow from a diagram
+ */
+export const deleteArrowTool = {
+    name: "delete_arrow",
+    description: "Remove an arrow from a diagram. This disconnects two nodes without affecting the nodes themselves.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            diagramId: {
+                type: "string",
+                description: "ID of the diagram containing the arrow",
+            },
+            arrowId: {
+                type: "string",
+                description: "ID of the arrow to delete",
+            },
+        },
+        required: ["diagramId", "arrowId"],
+    },
+};
+/**
+ * Tool: delete_diagram
+ * Delete a diagram
+ */
+export const deleteDiagramTool = {
+    name: "delete_diagram",
+    description: "Delete a diagram (soft delete). If the diagram has active workflow instances, you must confirm the deletion.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            diagramId: {
+                type: "string",
+                description: "ID of the diagram to delete",
+            },
+            confirm: {
+                type: "boolean",
+                description: "Set to true to confirm deletion when there are active instances",
+            },
+        },
+        required: ["diagramId"],
+    },
+};
+/**
+ * Tool: duplicate_diagram
+ * Create a copy of an existing diagram
+ */
+export const duplicateDiagramTool = {
+    name: "duplicate_diagram",
+    description: "Create a copy of an existing diagram with all its nodes and arrows. The copy will have a new ID and a modified title/token.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            diagramId: {
+                type: "string",
+                description: "ID of the diagram to duplicate",
+            },
+        },
+        required: ["diagramId"],
+    },
+};
+// =============================================================================
+// Tool Handlers
+// =============================================================================
+/**
+ * Handler for enter_design_mode tool
+ */
+export async function handleEnterDesignMode(client, params) {
+    designModeState.isDesignMode = true;
+    designModeState.activeDiagramId = params.diagramId?.trim() || null;
+    const response = {
+        success: true,
+        message: "Entered design mode",
+        designMode: true,
+        activeDiagramId: designModeState.activeDiagramId,
+    };
+    if (designModeState.activeDiagramId) {
+        try {
+            const diagram = await client.getDiagram(designModeState.activeDiagramId);
+            response.diagram = {
+                id: diagram.id,
+                name: diagram.name,
+                nodeCount: diagram.nodes?.length || 0,
+                edgeCount: diagram.edges?.length || 0,
+            };
+        }
+        catch {
+            response.warning = "Could not load diagram. Use get_diagram to load it.";
+        }
+    }
+    else {
+        response.hint = "Use list_diagrams to see available diagrams or create_diagram to create a new one.";
+    }
+    return JSON.stringify(response, null, 2);
+}
+/**
+ * Handler for exit_design_mode tool
+ */
+export async function handleExitDesignMode() {
+    const wasInDesignMode = designModeState.isDesignMode;
+    const previousDiagramId = designModeState.activeDiagramId;
+    designModeState.isDesignMode = false;
+    designModeState.activeDiagramId = null;
+    return JSON.stringify({
+        success: true,
+        message: wasInDesignMode ? "Exited design mode" : "Was not in design mode",
+        designMode: false,
+        previousActiveDiagramId: previousDiagramId,
+    }, null, 2);
+}
+/**
+ * Handler for list_diagrams tool
+ */
+export async function handleListDiagrams(client, params) {
+    const diagrams = await client.listDiagrams({
+        search: params.search,
+        diagramType: params.diagramType,
+        sortBy: params.sortBy,
+        sortOrder: params.sortOrder,
+        topLevelOnly: params.topLevelOnly,
+    });
+    if (diagrams.length === 0) {
+        return JSON.stringify({
+            success: true,
+            message: "No diagrams found",
+            diagrams: [],
+            filter: {
+                search: params.search || null,
+                diagramType: params.diagramType || "all",
+                topLevelOnly: params.topLevelOnly || false,
+            },
+        }, null, 2);
+    }
+    const formattedDiagrams = diagrams.map((d) => ({
+        id: d.id,
+        title: d.title,
+        token: d.token,
+        diagramType: d.diagramType,
+        mode: d.mode,
+        nodeCount: d.nodeCount,
+        arrowCount: d.arrowCount,
+        updatedAt: d.updatedAt,
+    }));
+    return JSON.stringify({
+        success: true,
+        message: `Found ${diagrams.length} diagram(s)`,
+        diagrams: formattedDiagrams,
+        filter: {
+            search: params.search || null,
+            diagramType: params.diagramType || "all",
+            topLevelOnly: params.topLevelOnly || false,
+        },
+    }, null, 2);
+}
+/**
+ * Handler for get_diagram tool (design mode version with full details)
+ */
+export async function handleGetDiagramForDesign(client, params) {
+    if (!params.diagramId || params.diagramId.trim().length === 0) {
+        return JSON.stringify({
+            success: false,
+            error: "diagramId is required",
+        }, null, 2);
+    }
+    const diagram = await client.getDiagramRaw(params.diagramId.trim());
+    // Update active diagram in design mode
+    if (designModeState.isDesignMode) {
+        designModeState.activeDiagramId = params.diagramId.trim();
+    }
+    const nodes = diagram.nodes || [];
+    const arrows = diagram.arrows || [];
+    return JSON.stringify({
+        success: true,
+        diagram: {
+            id: diagram.id,
+            title: diagram.title,
+            token: diagram.token,
+            diagramType: diagram.diagramType,
+            mode: diagram.mode,
+            version: diagram.version,
+            createdAt: diagram.createdAt,
+            updatedAt: diagram.updatedAt,
+        },
+        nodes: nodes.map((n) => ({
+            id: n.id,
+            label: n.label,
+            x: n.x,
+            y: n.y,
+            width: n.width,
+            height: n.height,
+            shape: n.shape,
+            isStart: n.isStart,
+            isEnd: n.isEnd,
+            description: n.description,
+            waitForAll: n.waitForAll,
+            childDiagramId: n.childDiagramId,
+            childDiagramTitle: n.childDiagramTitle,
+            assignedUserId: n.assignedUserId,
+            assignedUserName: n.assignedUserName,
+            fillColor: n.fillColor,
+            borderColor: n.borderColor,
+            textColor: n.textColor,
+            durationValue: n.durationValue,
+            durationUnit: n.durationUnit,
+        })),
+        arrows: arrows.map((a) => ({
+            id: a.id,
+            from: a.from,
+            to: a.to,
+            label: a.label,
+            fromPoint: a.fromPoint,
+            toPoint: a.toPoint,
+            delay: a.delay,
+            color: a.color,
+            thickness: a.thickness,
+            lineStyle: a.lineStyle,
+            routing: a.routing,
+        })),
+        summary: {
+            nodeCount: nodes.length,
+            arrowCount: arrows.length,
+            hasStartNode: nodes.some((n) => n.isStart),
+            hasEndNode: nodes.some((n) => n.isEnd),
+            startNodeId: nodes.find((n) => n.isStart)?.id || null,
+            endNodeIds: nodes.filter((n) => n.isEnd).map((n) => n.id),
+        },
+    }, null, 2);
+}
+/**
+ * Handler for create_diagram tool
+ */
+export async function handleCreateDiagram(client, params) {
+    if (!params.title || params.title.trim().length === 0) {
+        return JSON.stringify({
+            success: false,
+            error: "title is required",
+        }, null, 2);
+    }
+    if (!params.token || params.token.trim().length === 0) {
+        return JSON.stringify({
+            success: false,
+            error: "token is required",
+        }, null, 2);
+    }
+    const diagram = await client.createDiagram({
+        title: params.title.trim(),
+        token: params.token.trim(),
+        diagramType: params.diagramType || "process",
+        mode: params.mode || "reactive",
+    });
+    // Set as active diagram if in design mode
+    if (designModeState.isDesignMode) {
+        designModeState.activeDiagramId = diagram.id;
+    }
+    return JSON.stringify({
+        success: true,
+        message: `Diagram '${diagram.title}' created successfully`,
+        diagram: {
+            id: diagram.id,
+            title: diagram.title,
+            token: diagram.token,
+            diagramType: diagram.diagramType,
+            mode: diagram.mode,
+        },
+        hint: "Use create_node to add nodes to this diagram. Start with a node marked as isStart: true.",
+    }, null, 2);
+}
+/**
+ * Handler for update_diagram tool
+ */
+export async function handleUpdateDiagram(client, params) {
+    if (!params.diagramId || params.diagramId.trim().length === 0) {
+        return JSON.stringify({
+            success: false,
+            error: "diagramId is required",
+        }, null, 2);
+    }
+    const updateData = {};
+    if (params.title !== undefined)
+        updateData.title = params.title;
+    if (params.token !== undefined)
+        updateData.token = params.token;
+    if (params.diagramType !== undefined)
+        updateData.diagramType = params.diagramType;
+    if (params.mode !== undefined)
+        updateData.mode = params.mode;
+    if (Object.keys(updateData).length === 0) {
+        return JSON.stringify({
+            success: false,
+            error: "At least one property to update is required (title, token, diagramType, or mode)",
+        }, null, 2);
+    }
+    const diagram = await client.updateDiagram(params.diagramId.trim(), updateData);
+    return JSON.stringify({
+        success: true,
+        message: "Diagram updated successfully",
+        diagram: {
+            id: diagram.id,
+            title: diagram.title,
+            token: diagram.token,
+            diagramType: diagram.diagramType,
+            mode: diagram.mode,
+        },
+    }, null, 2);
+}
+/**
+ * Handler for create_node tool
+ */
+export async function handleCreateNode(client, params) {
+    if (!params.diagramId || params.diagramId.trim().length === 0) {
+        return JSON.stringify({
+            success: false,
+            error: "diagramId is required",
+        }, null, 2);
+    }
+    if (!params.label || params.label.trim().length === 0) {
+        return JSON.stringify({
+            success: false,
+            error: "label is required",
+        }, null, 2);
+    }
+    if (params.x === undefined || params.y === undefined) {
+        return JSON.stringify({
+            success: false,
+            error: "x and y coordinates are required",
+        }, null, 2);
+    }
+    // Generate a unique node ID
+    const nodeId = `node-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    const nodeData = {
+        id: nodeId,
+        label: params.label.trim(),
+        x: params.x,
+        y: params.y,
+        width: params.width || 150,
+        height: params.height || 60,
+        shape: params.shape || "roundedRect",
+        fillColor: params.fillColor || "#ffffff",
+        borderColor: params.borderColor || "#000000",
+        textColor: params.textColor || "#000000",
+        lineStyle: "solid",
+        status: "none",
+    };
+    if (params.isStart !== undefined)
+        nodeData.isStart = params.isStart;
+    if (params.isEnd !== undefined)
+        nodeData.isEnd = params.isEnd;
+    if (params.description !== undefined)
+        nodeData.description = params.description;
+    if (params.waitForAll !== undefined)
+        nodeData.waitForAll = params.waitForAll;
+    if (params.childDiagramId !== undefined)
+        nodeData.childDiagramId = params.childDiagramId;
+    if (params.assignedUserId !== undefined)
+        nodeData.assignedUserId = params.assignedUserId;
+    if (params.durationValue !== undefined)
+        nodeData.durationValue = params.durationValue;
+    if (params.durationUnit !== undefined)
+        nodeData.durationUnit = params.durationUnit;
+    const result = await client.addNode(params.diagramId.trim(), nodeData);
+    return JSON.stringify({
+        success: true,
+        message: `Node '${params.label}' created successfully`,
+        node: {
+            id: result.id || nodeId,
+            label: params.label,
+            x: params.x,
+            y: params.y,
+            shape: nodeData.shape,
+            isStart: nodeData.isStart,
+            isEnd: nodeData.isEnd,
+        },
+        hint: params.isStart
+            ? "Start node created. Add more nodes and connect them with create_arrow."
+            : "Node created. Use create_arrow to connect this node to others.",
+    }, null, 2);
+}
+/**
+ * Handler for update_node tool
+ */
+export async function handleUpdateNode(client, params) {
+    if (!params.diagramId || params.diagramId.trim().length === 0) {
+        return JSON.stringify({
+            success: false,
+            error: "diagramId is required",
+        }, null, 2);
+    }
+    if (!params.nodeId || params.nodeId.trim().length === 0) {
+        return JSON.stringify({
+            success: false,
+            error: "nodeId is required",
+        }, null, 2);
+    }
+    const updateData = {};
+    if (params.label !== undefined)
+        updateData.label = params.label;
+    if (params.x !== undefined)
+        updateData.x = params.x;
+    if (params.y !== undefined)
+        updateData.y = params.y;
+    if (params.width !== undefined)
+        updateData.width = params.width;
+    if (params.height !== undefined)
+        updateData.height = params.height;
+    if (params.shape !== undefined)
+        updateData.shape = params.shape;
+    if (params.isStart !== undefined)
+        updateData.isStart = params.isStart;
+    if (params.isEnd !== undefined)
+        updateData.isEnd = params.isEnd;
+    if (params.description !== undefined)
+        updateData.description = params.description;
+    if (params.waitForAll !== undefined)
+        updateData.waitForAll = params.waitForAll;
+    if (params.childDiagramId !== undefined)
+        updateData.childDiagramId = params.childDiagramId;
+    if (params.assignedUserId !== undefined)
+        updateData.assignedUserId = params.assignedUserId;
+    if (params.fillColor !== undefined)
+        updateData.fillColor = params.fillColor;
+    if (params.borderColor !== undefined)
+        updateData.borderColor = params.borderColor;
+    if (params.textColor !== undefined)
+        updateData.textColor = params.textColor;
+    if (params.durationValue !== undefined)
+        updateData.durationValue = params.durationValue;
+    if (params.durationUnit !== undefined)
+        updateData.durationUnit = params.durationUnit;
+    if (Object.keys(updateData).length === 0) {
+        return JSON.stringify({
+            success: false,
+            error: "At least one property to update is required",
+        }, null, 2);
+    }
+    await client.updateNode(params.diagramId.trim(), params.nodeId.trim(), updateData);
+    return JSON.stringify({
+        success: true,
+        message: `Node '${params.nodeId}' updated successfully`,
+        nodeId: params.nodeId,
+        updatedProperties: Object.keys(updateData),
+    }, null, 2);
+}
+/**
+ * Handler for delete_node tool
+ */
+export async function handleDeleteNode(client, params) {
+    if (!params.diagramId || params.diagramId.trim().length === 0) {
+        return JSON.stringify({
+            success: false,
+            error: "diagramId is required",
+        }, null, 2);
+    }
+    if (!params.nodeId || params.nodeId.trim().length === 0) {
+        return JSON.stringify({
+            success: false,
+            error: "nodeId is required",
+        }, null, 2);
+    }
+    const result = await client.deleteNode(params.diagramId.trim(), params.nodeId.trim());
+    return JSON.stringify({
+        success: true,
+        message: `Node '${params.nodeId}' deleted successfully`,
+        nodeId: params.nodeId,
+        removedArrowCount: result.removedArrowCount || 0,
+    }, null, 2);
+}
+/**
+ * Handler for create_arrow tool
+ */
+export async function handleCreateArrow(client, params) {
+    if (!params.diagramId || params.diagramId.trim().length === 0) {
+        return JSON.stringify({
+            success: false,
+            error: "diagramId is required",
+        }, null, 2);
+    }
+    if (!params.from || params.from.trim().length === 0) {
+        return JSON.stringify({
+            success: false,
+            error: "from (source node ID) is required",
+        }, null, 2);
+    }
+    if (!params.to || params.to.trim().length === 0) {
+        return JSON.stringify({
+            success: false,
+            error: "to (target node ID) is required",
+        }, null, 2);
+    }
+    // Generate a unique arrow ID
+    const arrowId = `arrow-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    const arrowData = {
+        id: arrowId,
+        from: params.from.trim(),
+        to: params.to.trim(),
+        fromPoint: params.fromPoint || "right",
+        toPoint: params.toPoint || "left",
+        color: params.color || "#000000",
+        thickness: params.thickness || 2,
+        lineStyle: params.lineStyle || "solid",
+        routing: params.routing || "straight",
+        arrowHead: "default",
+    };
+    if (params.label !== undefined)
+        arrowData.label = params.label;
+    if (params.delay !== undefined)
+        arrowData.delay = params.delay;
+    const result = await client.addArrow(params.diagramId.trim(), arrowData);
+    return JSON.stringify({
+        success: true,
+        message: `Arrow created from '${params.from}' to '${params.to}'`,
+        arrow: {
+            id: result.id || arrowId,
+            from: params.from,
+            to: params.to,
+            label: params.label || null,
+            delay: params.delay || null,
+        },
+    }, null, 2);
+}
+/**
+ * Handler for update_arrow tool
+ */
+export async function handleUpdateArrow(client, params) {
+    if (!params.diagramId || params.diagramId.trim().length === 0) {
+        return JSON.stringify({
+            success: false,
+            error: "diagramId is required",
+        }, null, 2);
+    }
+    if (!params.arrowId || params.arrowId.trim().length === 0) {
+        return JSON.stringify({
+            success: false,
+            error: "arrowId is required",
+        }, null, 2);
+    }
+    const updateData = {};
+    if (params.label !== undefined)
+        updateData.label = params.label;
+    if (params.fromPoint !== undefined)
+        updateData.fromPoint = params.fromPoint;
+    if (params.toPoint !== undefined)
+        updateData.toPoint = params.toPoint;
+    if (params.delay !== undefined)
+        updateData.delay = params.delay;
+    if (params.color !== undefined)
+        updateData.color = params.color;
+    if (params.thickness !== undefined)
+        updateData.thickness = params.thickness;
+    if (params.lineStyle !== undefined)
+        updateData.lineStyle = params.lineStyle;
+    if (params.routing !== undefined)
+        updateData.routing = params.routing;
+    if (Object.keys(updateData).length === 0) {
+        return JSON.stringify({
+            success: false,
+            error: "At least one property to update is required",
+        }, null, 2);
+    }
+    await client.updateArrow(params.diagramId.trim(), params.arrowId.trim(), updateData);
+    return JSON.stringify({
+        success: true,
+        message: `Arrow '${params.arrowId}' updated successfully`,
+        arrowId: params.arrowId,
+        updatedProperties: Object.keys(updateData),
+    }, null, 2);
+}
+/**
+ * Handler for delete_arrow tool
+ */
+export async function handleDeleteArrow(client, params) {
+    if (!params.diagramId || params.diagramId.trim().length === 0) {
+        return JSON.stringify({
+            success: false,
+            error: "diagramId is required",
+        }, null, 2);
+    }
+    if (!params.arrowId || params.arrowId.trim().length === 0) {
+        return JSON.stringify({
+            success: false,
+            error: "arrowId is required",
+        }, null, 2);
+    }
+    await client.deleteArrow(params.diagramId.trim(), params.arrowId.trim());
+    return JSON.stringify({
+        success: true,
+        message: `Arrow '${params.arrowId}' deleted successfully`,
+        arrowId: params.arrowId,
+    }, null, 2);
+}
+/**
+ * Handler for delete_diagram tool
+ */
+export async function handleDeleteDiagram(client, params) {
+    if (!params.diagramId || params.diagramId.trim().length === 0) {
+        return JSON.stringify({
+            success: false,
+            error: "diagramId is required",
+        }, null, 2);
+    }
+    const result = await client.deleteDiagram(params.diagramId.trim(), params.confirm || false);
+    if (result.requiresConfirmation) {
+        return JSON.stringify({
+            success: false,
+            requiresConfirmation: true,
+            message: result.message,
+            activeInstanceCount: result.count,
+            hint: "Call delete_diagram again with confirm: true to proceed with deletion.",
+        }, null, 2);
+    }
+    // Clear active diagram if it was deleted
+    if (designModeState.activeDiagramId === params.diagramId.trim()) {
+        designModeState.activeDiagramId = null;
+    }
+    return JSON.stringify({
+        success: true,
+        message: `Diagram '${params.diagramId}' deleted successfully`,
+        diagramId: params.diagramId,
+    }, null, 2);
+}
+/**
+ * Handler for duplicate_diagram tool
+ */
+export async function handleDuplicateDiagram(client, params) {
+    if (!params.diagramId || params.diagramId.trim().length === 0) {
+        return JSON.stringify({
+            success: false,
+            error: "diagramId is required",
+        }, null, 2);
+    }
+    const diagram = await client.duplicateDiagram(params.diagramId.trim());
+    return JSON.stringify({
+        success: true,
+        message: `Diagram duplicated successfully`,
+        originalId: params.diagramId,
+        newDiagram: {
+            id: diagram.id,
+            title: diagram.title,
+            token: diagram.token,
+            diagramType: diagram.diagramType,
+        },
+        hint: "Use get_diagram with the new ID to view and edit the duplicated diagram.",
+    }, null, 2);
+}
+// =============================================================================
+// Design Mode State Accessors
+// =============================================================================
+/**
+ * Check if currently in design mode
+ */
+export function isInDesignMode() {
+    return designModeState.isDesignMode;
+}
+/**
+ * Get the active diagram ID in design mode
+ */
+export function getActiveDiagramId() {
+    return designModeState.activeDiagramId;
+}
+/**
+ * Get the full design mode state
+ */
+export function getDesignModeState() {
+    return { ...designModeState };
+}
+// =============================================================================
+// Exports
+// =============================================================================
+export const designTools = [
+    enterDesignModeTool,
+    exitDesignModeTool,
+    listDiagramsTool,
+    getDiagramTool,
+    createDiagramTool,
+    updateDiagramTool,
+    createNodeTool,
+    updateNodeTool,
+    deleteNodeTool,
+    createArrowTool,
+    updateArrowTool,
+    deleteArrowTool,
+    deleteDiagramTool,
+    duplicateDiagramTool,
+];
+//# sourceMappingURL=design.js.map