dodraw-mcp-server 0.1.0

package/dist/test/test-client.js

@@ -0,0 +1,100 @@
+"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 fs_1 = __importDefault(require("fs"));
+async function main() {
+    const serverPath = path_1.default.join(process.cwd(), "dist/src/index.js");
+    const transport = new stdio_js_1.StdioClientTransport({
+        command: "node",
+        args: [serverPath]
+    });
+    const client = new index_js_1.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_1.default.join(__dirname, "../../test_output");
+    if (!fs_1.default.existsSync(testDir)) {
+        fs_1.default.mkdirSync(testDir);
+    }
+    const filePath = path_1.default.join(testDir, "test_diagram.3duml");
+    // Clean up previous run
+    if (fs_1.default.existsSync(filePath)) {
+        fs_1.default.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 = 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.content[0].text);
+    await client.close();
+}
+main().catch(console.error);

package/dist/test/test-collision.js

@@ -0,0 +1,84 @@
+"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...");
+    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: "test-collision", version: "1.0" }, { capabilities: {} });
+    await client.connect(transport);
+    try {
+        const filePath = path_1.default.join(process_1.default.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 }
+        });
+        const rootId = 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 } });
+        const state = JSON.parse(result.content[0].text);
+        const nodeA = state.nodes.find((n) => n.label === "Node A");
+        const nodeB = state.nodes.find((n) => n.label === "Node B");
+        const root = state.nodes.find((n) => 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) {
+        console.error("FAIL:", e);
+        process_1.default.exit(1);
+    }
+    finally {
+        await client.close();
+    }
+}
+main();

package/dist/test/test-constraints.js

@@ -0,0 +1,88 @@
+"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...");
+    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: "test-constraints", version: "1.0" }, { capabilities: {} });
+    await client.connect(transport);
+    try {
+        const filePath = path_1.default.join(process_1.default.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" }
+        });
+        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" }
+        });
+        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) => l.name === "Layer 2");
+        const layer3 = state.layers.find((l) => 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) => 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) {
+        console.error("FAIL:", e);
+    }
+    finally {
+        await client.close();
+    }
+}
+async function getState(client, filePath) {
+    const result = await client.callTool({ name: "read_diagram_structure", arguments: { filePath } });
+    return JSON.parse(result.content[0].text);
+}
+async function getNodes(client, filePath) {
+    return (await getState(client, filePath)).nodes;
+}
+main();

package/dist/test/test-debug.js

@@ -0,0 +1,41 @@
+"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...");
+    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: "debug", version: "1.0" }, { capabilities: {} });
+    await client.connect(transport);
+    try {
+        const filePath = path_1.default.join(process_1.default.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) {
+        console.error("FAIL:", e);
+    }
+    finally {
+        await client.close();
+    }
+}
+main();

package/dist/test/test-directional.js

@@ -0,0 +1,90 @@
+"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...");
+    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: "test-directional", version: "1.0" }, { capabilities: {} });
+    await client.connect(transport);
+    try {
+        const filePath = path_1.default.join(process_1.default.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
+        });
+        const rootId = 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 } });
+        const state = JSON.parse(result.content[0].text);
+        console.log("Verifying nodes and edges...");
+        const rightNode = state.nodes.find((n) => n.label === "Right Node");
+        const leftNode = state.nodes.find((n) => n.label === "Left Node");
+        const downNode = state.nodes.find((n) => n.label === "Down Node");
+        const upNode = state.nodes.find((n) => 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) => 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) {
+        console.error("FAIL:", e);
+    }
+    finally {
+        await client.close();
+    }
+}
+main();

package/dist/test/test-layer-support.js

@@ -0,0 +1,69 @@
+"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_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 }
+            }
+        });
+        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 }
+        });
+        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/dist/test/test-refined-spacing.js

@@ -0,0 +1,58 @@
+"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...");
+    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: "test-refined", version: "1.0" }, { capabilities: {} });
+    await client.connect(transport);
+    try {
+        const filePath = path_1.default.join(process_1.default.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" }
+        });
+        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" }
+        });
+        console.log("L3 Output:", l3.content[0].text);
+        // Verify state
+        const result = await client.callTool({ name: "read_diagram_structure", arguments: { filePath } });
+        const state = JSON.parse(result.content[0].text);
+        const layer1 = state.layers[0];
+        const layer2 = state.layers.find((l) => l.name === "Layer 2");
+        const layer3 = state.layers.find((l) => 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) {
+        console.error("FAIL:", e);
+    }
+    finally {
+        await client.close();
+    }
+}
+main();

package/dist/test/verify_types.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const promises_1 = __importDefault(require("fs/promises"));
+const jszip_1 = __importDefault(require("jszip"));
+async function checkFile(filePath, label) {
+    try {
+        console.log(`Checking ${label}: ${filePath}`);
+        const content = await promises_1.default.readFile(filePath);
+        const zip = await jszip_1.default.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) => {
+            console.log(`Layer '${l.name}': Y=${l.transform.position.y}`);
+        });
+    }
+    catch (e) {
+        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/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "dodraw-mcp-server",
+  "version": "0.1.0",
+  "description": "MCP server for DoDraw",
+  "main": "dist/src/index.js",
+  "bin": {
+    "dodraw-mcp-server": "dist/src/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/src/index.js",
+    "dev": "tsc -w"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^0.6.0",
+    "jszip": "^3.10.1",
+    "zod": "^3.22.4"
+  },
+  "devDependencies": {
+    "typescript": "^5.3.3",
+    "@types/node": "^20.10.5",
+    "@types/jszip": "^3.4.1"
+  }
+}

package/src/index.ts

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+} from "@modelcontextprotocol/sdk/types.js";
+import { toolDefinitions, handleToolCall } from "./tools/diagramTools.js";
+
+const server = new Server(
+  {
+    name: "dodraw-mcp-server",
+    version: "0.1.0",
+  },
+  {
+    capabilities: {
+      tools: {},
+    },
+  }
+);
+
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+  return {
+    tools: toolDefinitions,
+  };
+});
+
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+  try {
+    return await handleToolCall(request.params.name, request.params.arguments);
+  } catch (error: any) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error: ${error.message}`,
+        },
+      ],
+      isError: true,
+    };
+  }
+});
+
+async function main() {
+  const transport = new 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);
+});