dodraw-mcp-server 0.1.0

package/test/test-client.ts

@@ -0,0 +1,116 @@
+
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import path from "path";
+import fs from "fs";
+
+async function main() {
+  const serverPath = path.join(process.cwd(), "dist/src/index.js");
+  
+  const transport = new StdioClientTransport({
+    command: "node",
+    args: [serverPath]
+  });
+
+  const client = new Client(
+    {
+      name: "test-client",
+      version: "1.0.0",
+    },
+    {
+      capabilities: {},
+    }
+  );
+
+  console.log("Connecting to server...");
+  await client.connect(transport);
+
+  // List tools
+  console.log("Listing tools...");
+  const tools = await client.listTools();
+  console.log("Tools found:", tools.tools.map(t => t.name).join(", "));
+
+  // Create diagram
+  const testDir = path.join(__dirname, "../../test_output");
+  if (!fs.existsSync(testDir)){
+      fs.mkdirSync(testDir);
+  }
+  const filePath = path.join(testDir, "test_diagram.3duml");
+  
+  // Clean up previous run
+  if (fs.existsSync(filePath)) {
+      fs.unlinkSync(filePath);
+  }
+
+  console.log(`Creating diagram at ${filePath}...`);
+  await client.callTool({
+    name: "create_new_diagram",
+    arguments: { filePath }
+  });
+  console.log("Created diagram.");
+
+  // Add node
+  console.log("Adding node...");
+  const nodeResult = await client.callTool({
+    name: "add_node",
+    arguments: {
+        filePath,
+        label: "Test Node 1",
+        shape: "rectangle",
+        x: 0,
+        y: 0,
+        backgroundColor: "#ff0000"
+    }
+  });
+  console.log("Added node result:", nodeResult);
+
+  // Add another node
+  await client.callTool({
+    name: "add_node",
+    arguments: {
+        filePath,
+        label: "Test Node 2",
+        shape: "rounded",
+        x: 5,
+        y: 0
+    }
+  });
+
+  // Read structure to find IDs
+  const structure: any = await client.callTool({
+      name: "read_diagram_structure",
+      arguments: { filePath }
+  });
+  
+  const content = JSON.parse(structure.content[0].text);
+  const id1 = content.nodes[0].id;
+  const id2 = content.nodes[1].id;
+
+  console.log(`Nodes created: ${id1}, ${id2}`);
+
+  // Add edge
+  console.log("Adding edge...");
+  await client.callTool({
+    name: "add_edge",
+    arguments: {
+        filePath,
+        sourceId: id1,
+        targetId: id2,
+        sourcePointIndex: 1, // Right
+        targetPointIndex: 3, // Left
+        label: "Connects to"
+    }
+  });
+  console.log("Added edge.");
+
+  // Final read
+  const finalStructure = await client.callTool({
+      name: "read_diagram_structure",
+      arguments: { filePath }
+  });
+  console.log("Final Structure:", (finalStructure as any).content[0].text);
+
+  await client.close();
+}
+
+main().catch(console.error);

package/test/test-collision.ts

@@ -0,0 +1,93 @@
+
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import path from "path";
+import process from "process";
+
+async function main() {
+    console.log("Connecting...");
+    const transport = new StdioClientTransport({
+        command: "node",
+        args: [path.join(process.cwd(), "dist", "src", "index.js")],
+    });
+    const client = new Client({ name: "test-collision", version: "1.0" }, { capabilities: {} });
+    await client.connect(transport);
+
+    try {
+        const filePath = path.join(process.cwd(), "test_output", "test_collision.3duml");
+        await client.callTool({ name: "create_new_diagram", arguments: { filePath } });
+
+        // 1. Add Root Node
+        console.log("Adding Root Node...");
+        const rootNode = await client.callTool({
+            name: "add_node",
+            arguments: { filePath, label: "Root", x: 0, y: 0, width: 2, height: 1.5 }
+        }) as any;
+        const rootId: string = rootNode.content[0].text.match(/Added node ([a-zA-Z0-9-]+)/)[1];
+
+        // 2. Add Node A to RIGHT
+        console.log("Adding Node A (RIGHT)...");
+        await client.callTool({
+            name: "add_directional_node",
+            arguments: { filePath, sourceNodeId: rootId, direction: "RIGHT", label: "Node A" }
+        });
+
+        // 3. Add Node B to RIGHT (Collision with A?)
+        console.log("Adding Node B (RIGHT) - Should Collide with A...");
+        await client.callTool({
+            name: "add_directional_node",
+            arguments: { filePath, sourceNodeId: rootId, direction: "RIGHT", label: "Node B" }
+        });
+
+        // Verify state
+        const result = await client.callTool({ name: "read_diagram_structure", arguments: { filePath } }) as any;
+        const state = JSON.parse(result.content[0].text);
+        
+        const nodeA = state.nodes.find((n: any) => n.label === "Node A");
+        const nodeB = state.nodes.find((n: any) => n.label === "Node B");
+        const root = state.nodes.find((n: any) => n.label === "Root");
+
+        console.log(`Root: (${root.x}, ${root.z})`);
+        console.log(`Node A: (${nodeA.x}, ${nodeA.z})`);
+        console.log(`Node B: (${nodeB.x}, ${nodeB.z})`);
+
+        // Check Spacing Logic
+        // Spacing = 2. Width = 2.
+        // Node A should be at: Root.x + (2 + 2) = 4?
+        // Let's check formula: newX = source.x + (dirX * (srcW + INITIAL_SPACING))
+        // srcW = 2. Spacing = 2.
+        // newX = 0 + 1 * (2 + 2) = 4.
+        
+        if (Math.abs(nodeA.x - 4) > 0.1) {
+             throw new Error(`Node A X position incorrect. Expected 4, got ${nodeA.x}`);
+        }
+        if (Math.abs(nodeA.z - 0) > 0.1) {
+             throw new Error(`Node A Z position incorrect. Expected 0, got ${nodeA.z}`);
+        }
+
+        // Check Collision Logic
+        // Node B initially tries to go to (4, 0). Collides with A.
+        // Shift Rule: Horizontal move -> Shift Z (Down).
+        // Shift Z step: srcH + COLLISION_SPACING = 1.5 + 0.5 = 2.0.
+        // New Z should be 0 + 2 = 2. (Or z + step)
+        // Wait, loop says: newZ += shiftStepZ.
+        // So Node B should be at (4, 2).
+        
+        if (Math.abs(nodeB.x - 4) > 0.1) {
+             throw new Error(`Node B X position incorrect. Expected 4, got ${nodeB.x}`);
+        }
+        if (Math.abs(nodeB.z - 2) > 0.1) {
+             throw new Error(`Node B Z position incorrect. Expected 2, got ${nodeB.z}`);
+        }
+
+        console.log("SUCCESS: Collision avoidance verified.");
+
+    } catch (e: any) {
+        console.error("FAIL:", e);
+        process.exit(1);
+    } finally {
+        await client.close();
+    }
+}
+
+main();

package/test/test-constraints.ts

@@ -0,0 +1,95 @@
+
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import path from "path";
+import process from "process";
+
+async function main() {
+    console.log("Connecting...");
+    const transport = new StdioClientTransport({
+        command: "node",
+        args: [path.join(process.cwd(), "dist", "src", "index.js")],
+    });
+    const client = new Client({ name: "test-constraints", version: "1.0" }, { capabilities: {} });
+    await client.connect(transport);
+
+    try {
+        const filePath = path.join(process.cwd(), "test_output", "test_constraints.3duml");
+        await client.callTool({ name: "create_new_diagram", arguments: { filePath } });
+
+        // 1. Test Layer Auto-Stacking
+        console.log("Adding Layer 2 (auto)...");
+        const l2 = await client.callTool({
+            name: "add_layer",
+            arguments: { filePath, name: "Layer 2" }
+        }) as any;
+        console.log("L2 Output:", l2.content[0].text);
+
+        console.log("Adding Layer 3 (auto)...");
+        const l3 = await client.callTool({
+            name: "add_layer",
+            arguments: { filePath, name: "Layer 3" }
+        }) as any;
+        console.log("L3 Output:", l3.content[0].text);
+
+        // 2. Test Node Constraints (Max Width)
+        console.log("Adding Giant Node...");
+        await client.callTool({
+            name: "add_node",
+            arguments: { filePath, label: "Giant Node", width: 1000, height: 1000 }
+        });
+
+        // 3. Test Edge Constraints (Max Thickness)
+        console.log("Add Tiny Edge...");
+         // Add nodes to connect
+        await client.callTool({ name: "add_node", arguments: { filePath, label: "N1" } });
+        await client.callTool({ name: "add_node", arguments: { filePath, label: "N2" } });
+        
+        await client.callTool({
+            name: "add_edge",
+            arguments: { 
+                filePath, 
+                sourceId: (await getNodes(client, filePath))[1].id,
+                targetId: (await getNodes(client, filePath))[2].id,
+                sourcePointIndex: 0, targetPointIndex: 0,
+                thickness: 10 // Huge thickness
+            }
+        });
+
+        // Verify
+        const state = await getState(client, filePath);
+        
+        // Check Layers
+        const layer2 = state.layers.find((l: any) => l.name === "Layer 2");
+        const layer3 = state.layers.find((l: any) => l.name === "Layer 3");
+        
+        if (layer2.position.y !== 50) throw new Error(`Layer 2 should be at Y=50, got ${layer2.position.y}`);
+        if (layer3.position.y !== 100) throw new Error(`Layer 3 should be at Y=100, got ${layer3.position.y}`);
+
+        // Check Node Size
+        const giantNode = state.nodes.find((n: any) => n.label === "Giant Node");
+        if (giantNode.width > 50) throw new Error(`Giant Node width should be capped at 50, got ${giantNode.width}`);
+
+        // Check Edge Thickness
+        const edge = state.edges[0];
+        if (edge && edge.thickness > 0.5) throw new Error(`Edge thickness should be capped at 0.5, got ${edge.thickness}`);
+
+        console.log("SUCCESS: All constraints and auto-positioning verified.");
+
+    } catch (e: any) {
+        console.error("FAIL:", e);
+    } finally {
+        await client.close();
+    }
+}
+
+async function getState(client: any, filePath: string) {
+    const result = await client.callTool({ name: "read_diagram_structure", arguments: { filePath } }) as any;
+    return JSON.parse(result.content[0].text);
+}
+
+async function getNodes(client: any, filePath: string) {
+    return (await getState(client, filePath)).nodes;
+}
+
+main();

package/test/test-debug.ts

@@ -0,0 +1,40 @@
+
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import path from "path";
+import process from "process";
+
+async function main() {
+    console.log("Connecting...");
+    const transport = new StdioClientTransport({
+        command: "node",
+        args: [path.join(process.cwd(), "dist", "src", "index.js")],
+    });
+    const client = new Client({ name: "debug", version: "1.0" }, { capabilities: {} });
+    await client.connect(transport);
+
+    try {
+        const filePath = path.join(process.cwd(), "test_output", "test_debug.3duml");
+        await client.callTool({ name: "create_new_diagram", arguments: { filePath } });
+
+        console.log("Adding Node C...");
+        await client.callTool({
+            name: "add_node",
+            arguments: { filePath, label: "Node C", x: 10, y: 10 }
+        });
+        console.log("Node C added.");
+
+        console.log("Adding Node D...");
+        await client.callTool({
+            name: "add_node",
+            arguments: { filePath, label: "Node D" }
+        });
+        console.log("Node D added.");
+
+    } catch (e: any) {
+        console.error("FAIL:", e);
+    } finally {
+        await client.close();
+    }
+}
+main();

package/test/test-directional.ts

@@ -0,0 +1,95 @@
+
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import path from "path";
+import process from "process";
+
+async function main() {
+    console.log("Connecting...");
+    const transport = new StdioClientTransport({
+        command: "node",
+        args: [path.join(process.cwd(), "dist", "src", "index.js")],
+    });
+    const client = new Client({ name: "test-directional", version: "1.0" }, { capabilities: {} });
+    await client.connect(transport);
+
+    try {
+        const filePath = path.join(process.cwd(), "test_output", "test_directional.3duml");
+        await client.callTool({ name: "create_new_diagram", arguments: { filePath } });
+
+        // 1. Add Root Node
+        console.log("Adding Root Node...");
+        const rootNode = await client.callTool({
+            name: "add_node",
+            arguments: { filePath, label: "Root", x: 0, y: 0 } // Central point
+        }) as any;
+        const rootId: string = rootNode.content[0].text.match(/Added node ([a-zA-Z0-9-]+)/)[1];
+        console.log(`Root ID: ${rootId}`);
+
+        // 2. Add RIGHT Node
+        console.log("Adding RIGHT Node...");
+        await client.callTool({
+            name: "add_directional_node",
+            arguments: { filePath, sourceNodeId: rootId, direction: "RIGHT", label: "Right Node" }
+        });
+
+        // 3. Add LEFT Node
+        console.log("Adding LEFT Node...");
+        await client.callTool({
+            name: "add_directional_node",
+            arguments: { filePath, sourceNodeId: rootId, direction: "LEFT", label: "Left Node" }
+        });
+
+        // 4. Add DOWN Node
+        console.log("Adding DOWN Node...");
+        await client.callTool({
+            name: "add_directional_node",
+            arguments: { filePath, sourceNodeId: rootId, direction: "DOWN", label: "Down Node" }
+        });
+
+        // 5. Add UP Node
+        console.log("Adding UP Node...");
+        await client.callTool({
+            name: "add_directional_node",
+            arguments: { filePath, sourceNodeId: rootId, direction: "UP", label: "Up Node" }
+        });
+
+        // Verify state
+        const result = await client.callTool({ name: "read_diagram_structure", arguments: { filePath } }) as any;
+        const state = JSON.parse(result.content[0].text);
+        
+        console.log("Verifying nodes and edges...");
+        
+        const rightNode = state.nodes.find((n: any) => n.label === "Right Node");
+        const leftNode = state.nodes.find((n: any) => n.label === "Left Node");
+        const downNode = state.nodes.find((n: any) => n.label === "Down Node");
+        const upNode = state.nodes.find((n: any) => n.label === "Up Node");
+
+        // Verify Positions
+        // Expected: Right(5, 0), Left(-5, 0), Down(0, 4), Up(0, -4)
+        console.log(`Right: (${rightNode.x}, ${rightNode.z})`); // z is diagram Y
+        console.log(`Left: (${leftNode.x}, ${leftNode.z})`);
+        console.log(`Down: (${downNode.x}, ${downNode.z})`);
+        console.log(`Up: (${upNode.x}, ${upNode.z})`);
+
+        if (rightNode.x !== 5) throw new Error("Right node X incorrect");
+        if (leftNode.x !== -5) throw new Error("Left node X incorrect");
+        if (downNode.z !== 4) throw new Error("Down node Z incorrect");
+        if (upNode.z !== -4) throw new Error("Up node Z incorrect");
+
+        // Verify Connections
+        // Start counting edges connected to Root
+        const edges = state.edges.filter((e: any) => e.sourceId === rootId || e.targetId === rootId);
+        console.log(`Edges connected to Root: ${edges.length}`);
+        if (edges.length !== 4) throw new Error("Should be 4 edges connecting to Root");
+
+        console.log("SUCCESS: Directional node creation verified.");
+
+    } catch (e: any) {
+        console.error("FAIL:", e);
+    } finally {
+        await client.close();
+    }
+}
+
+main();

package/test/test-layer-support.ts

@@ -0,0 +1,77 @@
+
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import path from "path";
+import process from "process";
+
+async function main() {
+    console.log("Connecting to server...");
+    const transport = new StdioClientTransport({
+        command: "node",
+        args: [path.join(process.cwd(), "dist", "src", "index.js")],
+    });
+
+    const client = new Client(
+        { name: "dodraw-test-client", version: "1.0.0" },
+        { capabilities: {} }
+    );
+
+    await client.connect(transport);
+    console.log("Connected.");
+
+    try {
+        const filePath = path.join(process.cwd(), "test_output", "test_layers.3duml");
+        
+        // 1. Create Diagram
+        await client.callTool({ name: "create_new_diagram", arguments: { filePath } });
+        console.log("Created diagram.");
+
+        // 2. Add Layer
+        const layerResult = await client.callTool({
+            name: "add_layer",
+            arguments: {
+                filePath,
+                name: "Upper Layer",
+                position: { x: 0, y: 50, z: 0 }
+            }
+        }) as any;
+        console.log(layerResult.content[0].text);
+        
+        // Extract Layer ID (hacky parsing for test)
+        const outputText = layerResult.content[0].text;
+        const layerId = outputText.match(/ID ([0-9a-f-]+)/)[1];
+        console.log(`Extracted Layer ID: ${layerId}`);
+
+        // 3. Add Node to new Layer
+        await client.callTool({
+            name: "add_node",
+            arguments: {
+                filePath,
+                label: "Node on Upper Layer",
+                x: 0,
+                y: 0,
+                layerId: layerId
+            }
+        });
+        console.log("Added node to upper layer.");
+
+        // 4. Read Structure
+        const structureResult = await client.callTool({
+            name: "read_diagram_structure",
+            arguments: { filePath }
+        }) as any;
+        
+        const structure = JSON.parse(structureResult.content[0].text);
+        console.log("Structure:", JSON.stringify(structure, null, 2));
+
+        if (structure.layerCount !== 2) throw new Error("Expected 2 layers (default + new)");
+        if (structure.nodes[0].layerId !== layerId) throw new Error("Node layer ID mismatch");
+
+    } catch (error) {
+        console.error("Test failed:", error);
+    } finally {
+        await client.close();
+    }
+}
+
+main();

package/test/test-refined-spacing.ts

@@ -0,0 +1,62 @@
+
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import path from "path";
+import process from "process";
+
+async function main() {
+    console.log("Connecting...");
+    const transport = new StdioClientTransport({
+        command: "node",
+        args: [path.join(process.cwd(), "dist", "src", "index.js")],
+    });
+    const client = new Client({ name: "test-refined", version: "1.0" }, { capabilities: {} });
+    await client.connect(transport);
+
+    try {
+        const filePath = path.join(process.cwd(), "test_output", "test_refined_spacing.3duml");
+        await client.callTool({ name: "create_new_diagram", arguments: { filePath } });
+
+        // Default Layer 1 is at Y=0
+
+        // 1. Add Layer 2 (auto) -> Should be -2
+        console.log("Adding Layer 2...");
+        const l2 = await client.callTool({
+            name: "add_layer",
+            arguments: { filePath, name: "Layer 2" }
+        }) as any;
+        console.log("L2 Output:", l2.content[0].text);
+
+        // 2. Add Layer 3 (auto) -> Should be -4
+        console.log("Adding Layer 3...");
+        const l3 = await client.callTool({
+            name: "add_layer",
+            arguments: { filePath, name: "Layer 3" }
+        }) as any;
+        console.log("L3 Output:", l3.content[0].text);
+
+        // Verify state
+        const result = await client.callTool({ name: "read_diagram_structure", arguments: { filePath } }) as any;
+        const state = JSON.parse(result.content[0].text);
+        
+        const layer1 = state.layers[0];
+        const layer2 = state.layers.find((l: any) => l.name === "Layer 2");
+        const layer3 = state.layers.find((l: any) => l.name === "Layer 3");
+
+        console.log(`Layer 1 Y: ${layer1.position.y}`);
+        console.log(`Layer 2 Y: ${layer2.position.y}`);
+        console.log(`Layer 3 Y: ${layer3.position.y}`);
+
+        if (layer2.position.y !== -2) throw new Error(`Layer 2 should be at Y=-2, got ${layer2.position.y}`);
+        if (layer3.position.y !== -4) throw new Error(`Layer 3 should be at Y=-4, got ${layer3.position.y}`);
+        
+        console.log("SUCCESS: Refined spacing verified.");
+
+    } catch (e: any) {
+        console.error("FAIL:", e);
+    } finally {
+        await client.close();
+    }
+}
+
+main();

package/test/verify_types.ts

@@ -0,0 +1,28 @@
+
+import fs from 'fs/promises';
+import JSZip from 'jszip';
+
+async function checkFile(filePath: string, label: string) {
+    try {
+        console.log(`Checking ${label}: ${filePath}`);
+        const content = await fs.readFile(filePath);
+        const zip = await JSZip.loadAsync(content);
+        const jsonStr = await zip.file("diagram.json")?.async("string");
+        if (!jsonStr) throw new Error("No diagram.json");
+        const json = JSON.parse(jsonStr);
+        
+        console.log(`Layer Count: ${json.layers.length}`);
+        json.layers.forEach((l: any) => {
+            console.log(`Layer '${l.name}': Y=${l.transform.position.y}`);
+        });
+
+    } catch (e: any) {
+        console.log(`Error checking ${label}: ${e.message}`);
+    }
+}
+
+async function main() {
+    await checkFile("q:/source/Antigravity/Learn/3DUML/mcp_layer_refined_test.3duml", "Refined Layer Auto-Pos Check");
+}
+
+main();

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "commonjs",
+    "outDir": "./dist",
+    "rootDir": ".",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true
+  },
+  "include": ["src/**/*", "test/**/*"]
+}