dodraw-mcp-server 0.1.0

package/README.md

@@ -0,0 +1,63 @@
+
+# DoDraw MCP Server
+
+An MCP server implementation for DoDraw (formerly 3DUML), providing tools to programmatically generate and manipulate 3D UML diagrams.
+
+## Distribution & Usage
+
+There are two primary ways to distribute and use this server:
+
+### 1. Via NPM (Recommended)
+
+This method allows users to run the server immediately without cloning the repository.
+
+#### For Use (Running with `npx`)
+
+Users can run the server directly using `npx`:
+
+```bash
+npx -y dodraw-mcp-server
+```
+
+*(Note: Replace `dodraw-mcp-server` with your actual package name if scoped, e.g., `@your-org/dodraw-mcp-server`)*
+
+#### For Distribution (Publishing to NPM)
+
+To make the server available via `npx`, follow these steps:
+
+1.  **Login to NPM:**
+    ```bash
+    npm login
+    ```
+
+2.  **Verify Package Details:**
+    Ensure `package.json` has the correct `name`, `version`, and `bin` entry.
+    ```json
+    "bin": {
+      "dodraw-mcp-server": "dist/src/index.js"
+    }
+    ```
+
+3.  **Build the Project:**
+    Ensure the `dist` folder is up-to-date.
+    ```bash
+    npm run build
+    ```
+
+4.  **Publish:**
+    ```bash
+    npm publish --access public
+    ```
+
+### 2. Via Source Code
+
+1.  Clone the repository.
+2.  Install dependencies: `npm install`.
+3.  Build: `npm run build`.
+4.  Configure your MCP Client (e.g., Claude Desktop) to point to the built file:
+    ```json
+    "dodraw": {
+      "command": "node",
+      "args": ["/path/to/repo/mcp-server/dist/src/index.js"]
+    }
+    ```

package/dist/src/index.js

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const diagramTools_js_1 = require("./tools/diagramTools.js");
+const server = new index_js_1.Server({
+    name: "dodraw-mcp-server",
+    version: "0.1.0",
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => {
+    return {
+        tools: diagramTools_js_1.toolDefinitions,
+    };
+});
+server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
+    try {
+        return await (0, diagramTools_js_1.handleToolCall)(request.params.name, request.params.arguments);
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Error: ${error.message}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+});
+async function main() {
+    const transport = new stdio_js_1.StdioServerTransport();
+    await server.connect(transport);
+    console.error("DoDraw MCP Server running on stdio");
+}
+main().catch((error) => {
+    console.error("Fatal error in main():", error);
+    process.exit(1);
+});

package/dist/src/tools/diagramTools.js

@@ -0,0 +1,426 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toolDefinitions = void 0;
+exports.handleToolCall = handleToolCall;
+const fileHandler_1 = require("../utils/fileHandler");
+const crypto_1 = require("crypto");
+exports.toolDefinitions = [
+    {
+        name: "create_new_diagram",
+        description: "Create a new empty DoDraw diagram file",
+        inputSchema: {
+            type: "object",
+            properties: {
+                filePath: { type: "string", description: "Path to the .3duml file to create. Must include .3duml extension." }
+            },
+            required: ["filePath"]
+        }
+    },
+    {
+        name: "read_diagram_structure",
+        description: "Read the structure (nodes, edges, layers) of a diagram",
+        inputSchema: {
+            type: "object",
+            properties: {
+                filePath: { type: "string" }
+            },
+            required: ["filePath"]
+        }
+    },
+    {
+        name: "add_node",
+        description: "Add a new node to the diagram",
+        inputSchema: {
+            type: "object",
+            properties: {
+                filePath: { type: "string" },
+                label: { type: "string" },
+                shape: { type: "string", enum: ["rectangle", "rounded", "ellipse", "diamond", "actor", "cylinder", "note", "cloud", "class", "text", "table"] },
+                x: { type: "number", description: "Optional. defaults to auto-placement" },
+                y: { type: "number", description: "Optional. defaults to 0 or same as last node" },
+                z: { type: "number" },
+                width: { type: "number", description: "Default: 2. Min: 0.1, Max: 50" },
+                height: { type: "number", description: "Default: 1.5. Min: 0.1, Max: 50" },
+                layerId: { type: "string", description: "Optional layer ID, defaults to active layer" },
+                color: { type: "string" }
+            },
+            required: ["filePath", "label"]
+        }
+    },
+    {
+        name: "add_edge",
+        description: "Add a new edge connecting two nodes",
+        inputSchema: {
+            type: "object",
+            properties: {
+                filePath: { type: "string" },
+                sourceId: { type: "string" },
+                targetId: { type: "string" },
+                sourcePointIndex: { type: "number", minimum: 0, maximum: 3, description: "0:Top, 1:Right, 2:Bottom, 3:Left" },
+                targetPointIndex: { type: "number", minimum: 0, maximum: 3 },
+                label: { type: "string" },
+                color: { type: "string", description: "Edge color (hex)" },
+                thickness: { type: "number", description: "Default: 0.01. Min: 0.005, Max: 0.5" }
+            },
+            required: ["filePath", "sourceId", "targetId", "sourcePointIndex", "targetPointIndex"]
+        }
+    },
+    {
+        name: "update_node",
+        description: "Update properties of an existing node",
+        inputSchema: {
+            type: "object",
+            properties: {
+                filePath: { type: "string" },
+                nodeId: { type: "string" },
+                label: { type: "string" },
+                x: { type: "number" },
+                y: { type: "number" },
+                width: { type: "number" },
+                height: { type: "number" },
+                backgroundColor: { type: "string" }
+            },
+            required: ["filePath", "nodeId"]
+        }
+    },
+    {
+        name: "add_layer",
+        description: "Add a new layer to the diagram",
+        inputSchema: {
+            type: "object",
+            properties: {
+                filePath: { type: "string" },
+                name: { type: "string" },
+                position: {
+                    type: "object",
+                    description: "Optional. If omitted, stacks 2 units below bottom-most layer (matching app behavior).",
+                    properties: {
+                        x: { type: "number" },
+                        y: { type: "number" },
+                        z: { type: "number" }
+                    }
+                },
+                rotation: {
+                    type: "object",
+                    description: "Optional. Rotation in degrees.",
+                    properties: {
+                        x: { type: "number" },
+                        y: { type: "number" },
+                        z: { type: "number" }
+                    }
+                },
+                visible: { type: "boolean" }
+            },
+            required: ["filePath", "name"]
+        }
+    },
+    {
+        name: "add_directional_node",
+        description: "Add a new node relative to an existing node and connect them. PRIMARY method for creating diagrams.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                filePath: { type: "string" },
+                sourceNodeId: { type: "string" },
+                direction: { type: "string", enum: ["UP", "DOWN", "LEFT", "RIGHT"], description: "Direction to place the new node relative to source." },
+                label: { type: "string" },
+                shape: { type: "string", enum: ["rectangle", "rounded", "ellipse", "diamond", "actor", "cylinder", "note", "cloud", "class", "text", "table"] },
+                width: { type: "number", description: "Default: 2. Min: 0.1, Max: 50" },
+                height: { type: "number", description: "Default: 1.5. Min: 0.1, Max: 50" },
+                color: { type: "string" },
+                edgeLabel: { type: "string", description: "Optional label for the connecting edge" }
+            },
+            required: ["filePath", "sourceNodeId", "direction", "label"]
+        }
+    }
+];
+async function handleToolCall(name, args) {
+    switch (name) {
+        case "create_new_diagram": {
+            // ... (existing code)
+            const defaultLayerId = (0, crypto_1.randomUUID)();
+            const initialState = {
+                nodes: [],
+                edges: [],
+                layers: [{
+                        id: defaultLayerId,
+                        name: "Layer 1",
+                        transform: { position: { x: 0, y: 0, z: 0 }, rotation: { x: 0, y: 0, z: 0 }, scale: { x: 1, y: 1, z: 1 } },
+                        visible: true
+                    }],
+                activeLayerId: defaultLayerId,
+                gridSnappingEnabled: true,
+                gridSize: 0.5
+            };
+            await (0, fileHandler_1.saveDiagramFile)(args.filePath, initialState);
+            return { content: [{ type: "text", text: `Created new diagram at ${args.filePath}` }] };
+        }
+        case "read_diagram_structure": {
+            // ... (existing code)
+            const state = await (0, fileHandler_1.readDiagramFile)(args.filePath);
+            return {
+                content: [{
+                        type: "text",
+                        text: JSON.stringify({
+                            nodeCount: state.nodes.length,
+                            edgeCount: state.edges.length,
+                            layerCount: state.layers.length,
+                            nodes: state.nodes.map(n => ({ id: n.id, label: n.label, shape: n.shape, x: n.x, y: n.y, z: n.z, layerId: n.layerId })),
+                            edges: state.edges.map(e => ({ source: e.sourceId, target: e.targetId })),
+                            layers: state.layers.map(l => ({ id: l.id, name: l.name, position: l.transform.position }))
+                        }, null, 2)
+                    }]
+            };
+        }
+        case "add_node": {
+            // ... (existing code)
+            const state = await (0, fileHandler_1.readDiagramFile)(args.filePath);
+            // Auto-placement Logic
+            let x = 0;
+            let z = 0;
+            if (args.x !== undefined) {
+                x = Number(args.x);
+            }
+            if (args.y !== undefined) {
+                z = Number(args.y);
+            }
+            // If x was NOT provided, calculate it based on previous nodes
+            if (args.x === undefined) {
+                const targetLayerId = args.layerId || state.activeLayerId;
+                const layerNodes = state.nodes.filter(n => n.layerId === targetLayerId);
+                if (layerNodes.length > 0) {
+                    const lastNode = layerNodes[layerNodes.length - 1];
+                    // Place 2 units to the right of the last node
+                    // Assuming standard width is ~2, so gap of 2 makes center-to-center ~4
+                    x = lastNode.x + 5;
+                    // If z (input y) is also not provided, align with last node
+                    if (args.y === undefined) {
+                        z = lastNode.z;
+                    }
+                }
+            }
+            const newNode = {
+                id: (0, crypto_1.randomUUID)(),
+                x: x,
+                y: 0.05,
+                z: z,
+                width: Math.max(0.1, Math.min(50, args.width ? Number(args.width) : 2)),
+                height: Math.max(0.1, Math.min(50, args.height ? Number(args.height) : 1.5)),
+                label: args.label,
+                shape: args.shape || "rectangle",
+                layerId: args.layerId || state.activeLayerId,
+                backgroundColor: args.color,
+                textAlignVertical: 'center',
+                textAlignHorizontal: 'center'
+            };
+            console.error(`DEBUG: Adding node. Args: x=${args.x}, y=${args.y}. Computed: x=${newNode.x}, z=${newNode.z}`);
+            state.nodes.push(newNode);
+            await (0, fileHandler_1.saveDiagramFile)(args.filePath, state);
+            return { content: [{ type: "text", text: `Added node ${newNode.id} at (${newNode.x}, ${newNode.z})` }] };
+        }
+        case "add_directional_node": {
+            const state = await (0, fileHandler_1.readDiagramFile)(args.filePath);
+            const sourceNode = state.nodes.find(n => n.id === args.sourceNodeId);
+            if (!sourceNode) {
+                throw new Error(`Source node with ID ${args.sourceNodeId} not found.`);
+            }
+            const newNodeId = (0, crypto_1.randomUUID)();
+            // 1. Calculate base position with tighter spacing (matching App interaction)
+            const INITIAL_SPACING = 2.0;
+            let dirX = 0;
+            let dirZ = 0;
+            // sourceNode dimensions (safe defaults)
+            const srcW = Number(sourceNode.width) || 2;
+            const srcH = Number(sourceNode.height) || 1.5;
+            // Define Connection Points (Standard 0-3 based on direction)
+            let sourcePoint = 0;
+            let targetPoint = 0;
+            switch (args.direction) {
+                case "RIGHT":
+                    dirX = 1;
+                    sourcePoint = 1;
+                    targetPoint = 3;
+                    break;
+                case "LEFT":
+                    dirX = -1;
+                    sourcePoint = 3;
+                    targetPoint = 1;
+                    break;
+                case "DOWN":
+                    dirZ = 1;
+                    sourcePoint = 2;
+                    targetPoint = 0;
+                    break;
+                case "UP":
+                    dirZ = -1;
+                    sourcePoint = 0;
+                    targetPoint = 2;
+                    break;
+                default:
+                    throw new Error(`Invalid direction: ${args.direction}`);
+            }
+            let newX = sourceNode.x + (dirX * (srcW + INITIAL_SPACING));
+            let newZ = sourceNode.z + (dirZ * (srcH + INITIAL_SPACING));
+            // 2. Collision Avoidance (Shift if overlapping)
+            const COLLISION_SPACING = 0.5;
+            const shiftStepX = srcW + COLLISION_SPACING;
+            const shiftStepZ = srcH + COLLISION_SPACING;
+            let iterations = 0;
+            const maxIterations = 50;
+            // New node dimensions (using input or default to source size for collision check approx)
+            const newW = args.width ? Number(args.width) : srcW;
+            const newH = args.height ? Number(args.height) : srcH;
+            const checkCollision = (cx, cz) => {
+                return state.nodes.some(n => {
+                    if (n.layerId !== sourceNode.layerId)
+                        return false;
+                    const dx = Math.abs(n.x - cx);
+                    const dz = Math.abs(n.z - cz); // z is y in 2D logic
+                    const otherW = Number(n.width) || 2;
+                    const otherH = Number(n.height) || 1.5;
+                    const combinedHalfWidth = (otherW + newW) / 2;
+                    const combinedHalfHeight = (otherH + newH) / 2;
+                    // Box overlap check
+                    return dx < combinedHalfWidth && dz < combinedHalfHeight;
+                });
+            };
+            while (checkCollision(newX, newZ) && iterations < maxIterations) {
+                iterations++;
+                if (dirX !== 0) {
+                    // Moving Horizontally -> Shift Down
+                    newZ += shiftStepZ;
+                }
+                else {
+                    // Moving Vertically -> Shift Right
+                    newX += shiftStepX;
+                }
+            }
+            const newNode = {
+                id: newNodeId,
+                x: newX,
+                y: sourceNode.y, // Same height/layer-level
+                z: newZ,
+                width: Math.max(0.1, Math.min(50, args.width ? Number(args.width) : 2)),
+                height: Math.max(0.1, Math.min(50, args.height ? Number(args.height) : 1.5)),
+                label: args.label,
+                shape: args.shape || "rectangle",
+                layerId: sourceNode.layerId, // Inherit layer
+                backgroundColor: args.color || sourceNode.backgroundColor, // Inherit or new
+                textAlignVertical: 'center',
+                textAlignHorizontal: 'center'
+            };
+            const newEdge = {
+                id: (0, crypto_1.randomUUID)(),
+                sourceId: sourceNode.id,
+                targetId: newNodeId,
+                sourcePointIndex: sourcePoint,
+                targetPointIndex: targetPoint,
+                label: args.edgeLabel,
+                style: 'line',
+                routingType: 'straight',
+                color: '#000000',
+                thickness: 0.01,
+                fontSize: 20,
+                borderStyle: 'solid'
+            };
+            state.nodes.push(newNode);
+            state.edges.push(newEdge);
+            await (0, fileHandler_1.saveDiagramFile)(args.filePath, state);
+            return { content: [{ type: "text", text: `Added node '${args.label}' to the ${args.direction} of '${sourceNode.label}' and connected them.` }] };
+        }
+        case "add_edge": {
+            const state = await (0, fileHandler_1.readDiagramFile)(args.filePath);
+            // Verify nodes exist
+            const sourceExists = state.nodes.find(n => n.id === args.sourceId);
+            const targetExists = state.nodes.find(n => n.id === args.targetId);
+            if (!sourceExists)
+                throw new Error(`Source node ${args.sourceId} not found`);
+            if (!targetExists)
+                throw new Error(`Target node ${args.targetId} not found`);
+            const newEdge = {
+                id: (0, crypto_1.randomUUID)(),
+                sourceId: args.sourceId,
+                targetId: args.targetId,
+                sourcePointIndex: Number(args.sourcePointIndex),
+                targetPointIndex: Number(args.targetPointIndex),
+                label: args.label,
+                style: 'line', // default
+                routingType: 'straight', // default
+                color: args.color || '#000000',
+                thickness: Math.max(0.005, Math.min(0.5, args.thickness ? Number(args.thickness) : 0.01)),
+                fontSize: 20,
+                borderStyle: 'solid'
+            };
+            state.edges.push(newEdge);
+            await (0, fileHandler_1.saveDiagramFile)(args.filePath, state);
+            return { content: [{ type: "text", text: `Added edge ${newEdge.id}` }] };
+        }
+        case "update_node": {
+            const state = await (0, fileHandler_1.readDiagramFile)(args.filePath);
+            const nodeIndex = state.nodes.findIndex(n => n.id === args.nodeId);
+            if (nodeIndex === -1) {
+                throw new Error(`Node ${args.nodeId} not found`);
+            }
+            if (args.label)
+                state.nodes[nodeIndex].label = args.label;
+            if (args.x !== undefined)
+                state.nodes[nodeIndex].x = Number(args.x);
+            if (args.y !== undefined)
+                state.nodes[nodeIndex].z = Number(args.y); // Map input y to z
+            if (args.width !== undefined)
+                state.nodes[nodeIndex].width = Number(args.width);
+            if (args.height !== undefined)
+                state.nodes[nodeIndex].height = Number(args.height);
+            if (args.backgroundColor)
+                state.nodes[nodeIndex].backgroundColor = args.backgroundColor;
+            await (0, fileHandler_1.saveDiagramFile)(args.filePath, state);
+            return { content: [{ type: "text", text: `Updated node ${args.nodeId}` }] };
+        }
+        case "add_layer": {
+            const state = await (0, fileHandler_1.readDiagramFile)(args.filePath);
+            const newLayerId = (0, crypto_1.randomUUID)();
+            // Auto-positioning logic
+            let position = { x: 0, y: 0, z: 0 };
+            if (args.position) {
+                position = {
+                    x: args.position.x ? Number(args.position.x) : 0,
+                    y: args.position.y ? Number(args.position.y) : 0,
+                    z: args.position.z ? Number(args.position.z) : 0
+                };
+            }
+            else {
+                // Find min Y layer (stacking downwards like the app)
+                let minY = 0;
+                for (const l of state.layers) {
+                    if (l.transform?.position?.y < minY) {
+                        minY = l.transform.position.y;
+                    }
+                }
+                // App uses ~1.67, we use 2 for clean numbers
+                // If there are no layers or only Layer 1 at 0, next is -2
+                if (state.layers.length > 0) {
+                    position.y = minY - 2;
+                }
+            }
+            const newLayer = {
+                id: newLayerId,
+                name: args.name,
+                transform: {
+                    position: position,
+                    rotation: {
+                        x: args.rotation?.x ? Number(args.rotation.x) : 0,
+                        y: args.rotation?.y ? Number(args.rotation.y) : 0,
+                        z: args.rotation?.z ? Number(args.rotation.z) : 0
+                    },
+                    scale: { x: 1, y: 1, z: 1 }
+                },
+                visible: args.visible !== false
+            };
+            state.layers.push(newLayer);
+            await (0, fileHandler_1.saveDiagramFile)(args.filePath, state);
+            return { content: [{ type: "text", text: `Added layer '${args.name}' (ID: ${newLayerId}) at Y=${position.y}` }] };
+        }
+        default:
+            throw new Error(`Unknown tool: ${name}`);
+    }
+}

package/dist/src/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/utils/fileHandler.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readDiagramFile = readDiagramFile;
+exports.saveDiagramFile = saveDiagramFile;
+const promises_1 = __importDefault(require("fs/promises"));
+const jszip_1 = __importDefault(require("jszip"));
+async function readDiagramFile(filePath) {
+    try {
+        const fileContent = await promises_1.default.readFile(filePath);
+        const zip = await jszip_1.default.loadAsync(fileContent);
+        const diagramFile = zip.file("diagram.json");
+        if (!diagramFile) {
+            throw new Error("Invalid .DoDraw file: diagram.json missing");
+        }
+        const diagramJson = await diagramFile.async("string");
+        return JSON.parse(diagramJson);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            throw new Error(`File not found: ${filePath}`);
+        }
+        throw error;
+    }
+}
+async function saveDiagramFile(filePath, state) {
+    let zip;
+    // Try to load existing zip to preserve other files (e.g. images)
+    try {
+        const fileContent = await promises_1.default.readFile(filePath);
+        zip = await jszip_1.default.loadAsync(fileContent);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            // Create new zip if file doesn't exist
+            zip = new jszip_1.default();
+        }
+        else {
+            throw error;
+        }
+    }
+    // Update diagram.json
+    zip.file("diagram.json", JSON.stringify(state, null, 2));
+    // Write back to file
+    const content = await zip.generateAsync({
+        type: "nodebuffer",
+        mimeType: "application/zip",
+        compression: "DEFLATE"
+    });
+    await promises_1.default.writeFile(filePath, content);
+}

package/dist/test/test-auto-placement.js

@@ -0,0 +1,83 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_js_1 = require("@modelcontextprotocol/sdk/client/index.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/client/stdio.js");
+const path_1 = __importDefault(require("path"));
+const process_1 = __importDefault(require("process"));
+async function main() {
+    console.log("Connecting to server...");
+    const transport = new stdio_js_1.StdioClientTransport({
+        command: "node",
+        args: [path_1.default.join(process_1.default.cwd(), "dist", "src", "index.js")],
+    });
+    const client = new index_js_1.Client({ name: "dodraw-test-client", version: "1.0.0" }, { capabilities: {} });
+    await client.connect(transport);
+    console.log("Connected.");
+    try {
+        const filePath = path_1.default.join(process_1.default.cwd(), "test_output", "test_autoplacement.3duml");
+        await client.callTool({ name: "create_new_diagram", arguments: { filePath } });
+        // 1. Add First Node (auto) -> Should be 0,0
+        console.log("Adding Node A (auto)...");
+        await client.callTool({
+            name: "add_node",
+            arguments: { filePath, label: "Node A" }
+        });
+        // 2. Add Second Node (auto) -> Should be 5,0
+        console.log("Adding Node B (auto)...");
+        await client.callTool({
+            name: "add_node",
+            arguments: { filePath, label: "Node B" }
+        });
+        // 3. Add Third Node (explicit) -> 10, 10
+        console.log("Adding Node C (10, 10)...");
+        await client.callTool({
+            name: "add_node",
+            arguments: { filePath, label: "Node C", x: 10, y: 10 }
+        });
+        // 4. Add Fourth Node (auto) -> Should be 15, 10 (aligns with C)
+        console.log("Adding Node D (auto)...");
+        await client.callTool({
+            name: "add_node",
+            arguments: { filePath, label: "Node D" }
+        });
+        // Read and Verify
+        const result = await client.callTool({ name: "read_diagram_structure", arguments: { filePath } });
+        const structure = JSON.parse(result.content[0].text);
+        console.log("Verification Results:");
+        structure.nodes.forEach((n) => {
+            console.log(`Node ${n.label}: x=${n.x}, z=${n.y} (internal z)`); // n.y in JSON is z in source
+        });
+        // Assertions
+        const nodeA = structure.nodes.find((n) => n.label === "Node A");
+        const nodeB = structure.nodes.find((n) => n.label === "Node B");
+        const nodeC = structure.nodes.find((n) => n.label === "Node C");
+        const nodeD = structure.nodes.find((n) => n.label === "Node D");
+        if (nodeA.x !== 0)
+            throw new Error("Node A should be at x=0");
+        if (nodeB.x !== 5)
+            throw new Error("Node B should be at x=5");
+        if (nodeC.x !== 10)
+            throw new Error("Node C should be at x=10");
+        if (nodeD.x !== 15)
+            throw new Error("Node D should be at x=15");
+        if (nodeD.y !== 10)
+            throw new Error("Node D should align with Node C (z=10)"); // internal y=z
+        console.log("SUCCESS: Auto-placement logic verified.");
+    }
+    catch (error) {
+        console.error("Test failed Details:");
+        console.error("  Message:", error.message);
+        console.error("  Stack:", error.stack);
+        if (error.code)
+            console.error("  Code:", error.code);
+        if (error.data)
+            console.error("  Data:", JSON.stringify(error.data, null, 2));
+    }
+    finally {
+        await client.close();
+    }
+}
+main();