dodraw-mcp-server 0.1.0

package/src/tools/diagramTools.ts

@@ -0,0 +1,440 @@
+
+import { CallToolRequestSchema, ListToolsRequestSchema, Tool } from "@modelcontextprotocol/sdk/types.js";
+import { readDiagramFile, saveDiagramFile } from "../utils/fileHandler";
+import { DiagramState, NodeData, EdgeData } from "../types";
+import { randomUUID } from "crypto";
+
+export const toolDefinitions: Tool[] = [
+  {
+    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"]
+    }
+  }
+];
+
+export async function handleToolCall(name: string, args: any): Promise<any> {
+    switch (name) {
+        case "create_new_diagram": {
+            // ... (existing code)
+            const defaultLayerId = randomUUID();
+            const initialState: DiagramState = {
+                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 saveDiagramFile(args.filePath, initialState);
+            return { content: [{ type: "text", text: `Created new diagram at ${args.filePath}` }] };
+        }
+        case "read_diagram_structure": {
+            // ... (existing code)
+             const state = await 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 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: NodeData = {
+                id: 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 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 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 = 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: number, cz: number) => {
+                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: NodeData = {
+                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: EdgeData = {
+                id: 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 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 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: EdgeData = {
+                id: 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 saveDiagramFile(args.filePath, state);
+             return { content: [{ type: "text", text: `Added edge ${newEdge.id}` }] };
+        }
+        case "update_node": {
+            const state = await 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 saveDiagramFile(args.filePath, state);
+            return { content: [{ type: "text", text: `Updated node ${args.nodeId}` }] };
+        }
+        case "add_layer": {
+            const state = await readDiagramFile(args.filePath);
+            const newLayerId = 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: any = {
+                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 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/src/types.ts

@@ -0,0 +1,78 @@
+
+export interface NodeData {
+  id: string;
+  x: number;
+  y: number;
+  z: number;
+  width: number;
+  height: number;
+  layerId: string;
+  label: string;
+  shape?: 'rectangle' | 'rounded' | 'ellipse' | 'diamond' | 'actor' | 'cylinder' | 'note' | 'cloud' | 'class' | 'text' | 'table';
+  fontSize?: number;
+  borderColor?: string;
+  borderWidth?: number;
+  borderStyle?: 'solid' | 'dashed' | 'dotted';
+  backgroundColor?: string;
+  opacity?: number;
+  textAlignVertical?: 'top' | 'center' | 'bottom';
+  textAlignHorizontal?: 'left' | 'center' | 'right';
+  parentId?: string;
+  imageUrl?: string;
+  isBold?: boolean;
+  isItalic?: boolean;
+  isUnderline?: boolean;
+  isStrikethrough?: boolean;
+  isVerticalText?: boolean;
+  description?: string;
+  url?: string;
+  tableData?: {
+    columns: number;
+    rows: number;
+    hasRowHeader: boolean;
+    hasColumnHeader: boolean;
+    cells?: Record<string, string>;
+  };
+}
+
+export interface EdgeData {
+  id: string;
+  sourceId: string;
+  targetId: string;
+  sourcePointIndex: number;
+  targetPointIndex: number;
+  color?: string;
+  label?: string;
+  style?: 'line' | 'arrow-source' | 'arrow-target' | 'arrow-both';
+  fontSize?: number;
+  thickness?: number;
+  borderStyle?: 'solid' | 'dashed' | 'dotted';
+  description?: string;
+  routingType?: 'straight' | 'orthogonal';
+  controlPoints?: { x: number, y: number, z: number }[];
+  isBold?: boolean;
+  isItalic?: boolean;
+  isUnderline?: boolean;
+  isStrikethrough?: boolean;
+}
+
+export interface LayerData {
+  id: string;
+  name: string;
+  transform: {
+    position: { x: number; y: number; z: number };
+    rotation: { x: number; y: number; z: number };
+    scale: { x: number; y: number; z: number };
+  };
+  visible?: boolean;
+}
+
+export interface DiagramState {
+  nodes: NodeData[];
+  edges: EdgeData[];
+  layers: LayerData[];
+  activeLayerId: string;
+  gridSnappingEnabled: boolean;
+  gridSize: number;
+  [key: string]: any; // Allow other properties from Store state
+}

package/src/utils/fileHandler.ts

@@ -0,0 +1,51 @@
+
+import fs from 'fs/promises';
+import JSZip from 'jszip';
+import { DiagramState } from '../types';
+
+export async function readDiagramFile(filePath: string): Promise<DiagramState> {
+  try {
+    const fileContent = await fs.readFile(filePath);
+    const zip = await JSZip.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) as DiagramState;
+  } catch (error: any) {
+    if (error.code === 'ENOENT') {
+      throw new Error(`File not found: ${filePath}`);
+    }
+    throw error;
+  }
+}
+
+export async function saveDiagramFile(filePath: string, state: DiagramState): Promise<void> {
+  let zip: JSZip;
+  
+  // Try to load existing zip to preserve other files (e.g. images)
+  try {
+    const fileContent = await fs.readFile(filePath);
+    zip = await JSZip.loadAsync(fileContent);
+  } catch (error: any) {
+    if (error.code === 'ENOENT') {
+      // Create new zip if file doesn't exist
+      zip = new JSZip();
+    } 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 fs.writeFile(filePath, content);
+}

package/test/test-auto-placement.ts

@@ -0,0 +1,88 @@
+
+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_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 } }) as any;
+        const structure = JSON.parse(result.content[0].text);
+        
+        console.log("Verification Results:");
+        structure.nodes.forEach((n: any) => {
+            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: any) => n.label === "Node A");
+        const nodeB = structure.nodes.find((n: any) => n.label === "Node B");
+        const nodeC = structure.nodes.find((n: any) => n.label === "Node C");
+        const nodeD = structure.nodes.find((n: any) => 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: any) {
+        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();