dodraw-mcp-server 0.1.5 → 0.1.6

package/dist/src/tools/diagramTools.js

@@ -192,7 +192,7 @@ exports.toolDefinitions = [
     },
     {
         name: "create_db_table",
-        description: "Create a Database Entity (ERD Table). Use this for the FIRST table. For connected tables, use 'add_directional_node' with 'columns' to ensure correct relative positioning.",
+        description: "Create a Database Entity (ERD Table). Supports absolute positioning (x,y) OR relative positioning (referenceNodeId, direction). Can also auto-connect.",
         inputSchema: {
             type: "object",
             properties: {
@@ -213,7 +213,19 @@ exports.toolDefinitions = [
                 },
                 x: { type: "number" },
                 y: { type: "number" },
-                id: { type: "string", description: "Optional explicit ID" }
+                id: { type: "string", description: "Optional explicit ID" },
+                referenceNodeId: { type: "string", description: "Optional. ID of an existing node to place this new table relative to." },
+                direction: { type: "string", enum: ["UP", "DOWN", "LEFT", "RIGHT"], description: "Optional. Direction to place relative to referenceNodeId." },
+                connection: {
+                    type: "object",
+                    description: "Optional. If provided, creates an edge connecting the reference node to this new table.",
+                    properties: {
+                        type: { type: "string", enum: ["one-to-one", "one-to-many", "many-to-many"], description: "Relationship type" },
+                        label: { type: "string" },
+                        direction: { type: "string", enum: ["source-to-target", "target-to-source", "bi-directional"], description: "Edge direction flow" }
+                    },
+                    required: ["type"]
+                }
             },
             required: ["filePath", "tableName", "columns"]
         }
@@ -589,7 +601,62 @@ async function handleToolCall(name, args) {
             // Auto-placement logic if X/Y not provided
             let x = args.x !== undefined ? Number(args.x) : 0;
             let z = args.y !== undefined ? Number(args.y) : 0;
-            if (args.x === undefined && args.y === undefined && state.nodes.length > 0) {
+            // Relative Placement Logic
+            if (args.referenceNodeId && args.direction) {
+                const sourceNode = state.nodes.find(n => n.id === args.referenceNodeId);
+                if (!sourceNode)
+                    throw new Error(`Reference node ${args.referenceNodeId} not found`);
+                const INITIAL_SPACING = 2.0;
+                let dirX = 0;
+                let dirZ = 0;
+                const srcW = Number(sourceNode.width) || 2;
+                const srcH = Number(sourceNode.height) || 1.5;
+                switch (args.direction) {
+                    case "RIGHT":
+                        dirX = 1;
+                        break;
+                    case "LEFT":
+                        dirX = -1;
+                        break;
+                    case "DOWN":
+                        dirZ = 1;
+                        break;
+                    case "UP":
+                        dirZ = -1;
+                        break;
+                }
+                x = sourceNode.x + (dirX * (srcW + INITIAL_SPACING));
+                z = sourceNode.z + (dirZ * (srcH + INITIAL_SPACING));
+                // Collision Avoidance reuse
+                const COLLISION_SPACING = 0.5;
+                const shiftStepX = srcW + COLLISION_SPACING;
+                const shiftStepZ = srcH + COLLISION_SPACING;
+                const newW = width;
+                const newH = height;
+                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);
+                        const otherW = Number(n.width) || 2;
+                        const otherH = Number(n.height) || 1.5;
+                        const combinedHalfWidth = (otherW + newW) / 2;
+                        const combinedHalfHeight = (otherH + newH) / 2;
+                        return dx < combinedHalfWidth && dz < combinedHalfHeight;
+                    });
+                };
+                let iterations = 0;
+                while (checkCollision(x, z) && iterations < 50) {
+                    iterations++;
+                    if (dirX !== 0)
+                        z += shiftStepZ;
+                    else
+                        x += shiftStepX;
+                }
+            }
+            else if (args.x === undefined && args.y === undefined && state.nodes.length > 0) {
+                // Fallback to "next to last" if no explicit relative info
                 const lastNode = state.nodes[state.nodes.length - 1];
                 x = lastNode.x + 5;
                 z = lastNode.z;
@@ -615,6 +682,71 @@ async function handleToolCall(name, args) {
                 }
             };
             state.nodes.push(newNode);
+            // Auto-Connect logic
+            if (args.connection && args.referenceNodeId) {
+                let termStart = 'none';
+                let termEnd = 'none';
+                // Simplified mapping for DB
+                if (args.connection.type === 'one-to-many') {
+                    // Source (Reference) -> Target (New)
+                    // If Reference is "Users" (1) and New is "Orders" (N)
+                    // termStart = one, termEnd = many
+                    termStart = 'crows-one';
+                    termEnd = 'crows-many';
+                }
+                else if (args.connection.type === 'one-to-one') {
+                    termStart = 'crows-one';
+                    termEnd = 'crows-one';
+                }
+                else if (args.connection.type === 'many-to-many') {
+                    termStart = 'crows-many';
+                    termEnd = 'crows-many';
+                }
+                // Points? Simple defaults based on direction or just center-ish
+                // Let's use the logic from add_directional_node for cleaner ports if possible
+                // But simple 0-3 logic:
+                let sp = 0;
+                let tp = 0;
+                switch (args.direction) {
+                    case "RIGHT":
+                        sp = 1;
+                        tp = 3;
+                        break;
+                    case "LEFT":
+                        sp = 3;
+                        tp = 1;
+                        break;
+                    case "DOWN":
+                        sp = 2;
+                        tp = 0;
+                        break;
+                    case "UP":
+                        sp = 0;
+                        tp = 2;
+                        break;
+                    default:
+                        sp = 2;
+                        tp = 0;
+                        break;
+                }
+                const newEdge = {
+                    id: (0, crypto_1.randomUUID)(),
+                    sourceId: args.referenceNodeId,
+                    targetId: newNodeId,
+                    sourcePointIndex: sp,
+                    targetPointIndex: tp,
+                    label: args.connection.label,
+                    style: 'line',
+                    routingType: 'orthogonal',
+                    color: '#000000',
+                    thickness: 0.01,
+                    fontSize: 20,
+                    borderStyle: 'solid',
+                    terminationStart: termStart,
+                    terminationEnd: termEnd
+                };
+                state.edges.push(newEdge);
+            }
             await (0, fileHandler_1.saveDiagramFile)(args.filePath, state);
             return { content: [{ type: "text", text: `Created DB Table '${args.tableName}'` }] };
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dodraw-mcp-server",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "MCP server for DoDraw",
   "main": "dist/src/index.js",
   "bin": {

package/src/tools/diagramTools.ts

@@ -192,7 +192,8 @@ export const toolDefinitions: Tool[] = [
   },
   {
     name: "create_db_table",
-    description: "Create a Database Entity (ERD Table). Use this for the FIRST table. For connected tables, use 'add_directional_node' with 'columns' to ensure correct relative positioning.",
+
+    description: "Create a Database Entity (ERD Table). Supports absolute positioning (x,y) OR relative positioning (referenceNodeId, direction). Can also auto-connect.",
     inputSchema: {
       type: "object",
       properties: {
@@ -213,7 +214,19 @@ export const toolDefinitions: Tool[] = [
         },
         x: { type: "number" },
         y: { type: "number" },
-        id: { type: "string", description: "Optional explicit ID" }
+        id: { type: "string", description: "Optional explicit ID" },
+        referenceNodeId: { type: "string", description: "Optional. ID of an existing node to place this new table relative to." },
+        direction: { type: "string", enum: ["UP", "DOWN", "LEFT", "RIGHT"], description: "Optional. Direction to place relative to referenceNodeId." },
+        connection: { 
+             type: "object",
+             description: "Optional. If provided, creates an edge connecting the reference node to this new table.",
+             properties: {
+                 type: { type: "string", enum: ["one-to-one", "one-to-many", "many-to-many"], description: "Relationship type" },
+                 label: { type: "string" },
+                 direction: { type: "string", enum: ["source-to-target", "target-to-source", "bi-directional"], description: "Edge direction flow" }
+             },
+             required: ["type"]
+        }
       },
       required: ["filePath", "tableName", "columns"]
     }
@@ -612,7 +625,55 @@ export async function handleToolCall(name: string, args: any): Promise<any> {
             let x = args.x !== undefined ? Number(args.x) : 0;
             let z = args.y !== undefined ? Number(args.y) : 0;
             
-            if (args.x === undefined && args.y === undefined && state.nodes.length > 0) {
+            // Relative Placement Logic
+            if (args.referenceNodeId && args.direction) {
+                const sourceNode = state.nodes.find(n => n.id === args.referenceNodeId);
+                if (!sourceNode) throw new Error(`Reference node ${args.referenceNodeId} not found`);
+
+                const INITIAL_SPACING = 2.0;
+                let dirX = 0;
+                let dirZ = 0;
+                const srcW = Number(sourceNode.width) || 2;
+                const srcH = Number(sourceNode.height) || 1.5;
+
+                switch (args.direction) {
+                    case "RIGHT": dirX = 1; break;
+                    case "LEFT": dirX = -1; break;
+                    case "DOWN": dirZ = 1; break;
+                    case "UP": dirZ = -1; break;
+                }
+
+                x = sourceNode.x + (dirX * (srcW + INITIAL_SPACING));
+                z = sourceNode.z + (dirZ * (srcH + INITIAL_SPACING));
+
+                // Collision Avoidance reuse
+                const COLLISION_SPACING = 0.5;
+                const shiftStepX = srcW + COLLISION_SPACING;
+                const shiftStepZ = srcH + COLLISION_SPACING;
+                const newW = width;
+                const newH = height;
+
+                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);
+                        const otherW = Number(n.width) || 2;
+                        const otherH = Number(n.height) || 1.5;
+                        const combinedHalfWidth = (otherW + newW) / 2;
+                        const combinedHalfHeight = (otherH + newH) / 2;
+                        return dx < combinedHalfWidth && dz < combinedHalfHeight;
+                    });
+                };
+
+                let iterations = 0;
+                 while (checkCollision(x, z) && iterations < 50) {
+                    iterations++;
+                    if (dirX !== 0) z += shiftStepZ;
+                    else x += shiftStepX;
+                }
+            } else if (args.x === undefined && args.y === undefined && state.nodes.length > 0) {
+                 // Fallback to "next to last" if no explicit relative info
                  const lastNode = state.nodes[state.nodes.length - 1];
                  x = lastNode.x + 5;
                  z = lastNode.z;
@@ -640,6 +701,57 @@ export async function handleToolCall(name: string, args: any): Promise<any> {
             };
 
             state.nodes.push(newNode);
+
+            // Auto-Connect logic
+            if (args.connection && args.referenceNodeId) {
+                let termStart = 'none';
+                let termEnd = 'none';
+                // Simplified mapping for DB
+                if (args.connection.type === 'one-to-many') {
+                     // Source (Reference) -> Target (New)
+                     // If Reference is "Users" (1) and New is "Orders" (N)
+                     // termStart = one, termEnd = many
+                     termStart = 'crows-one';
+                     termEnd = 'crows-many';
+                } else if (args.connection.type === 'one-to-one') {
+                    termStart = 'crows-one';
+                    termEnd = 'crows-one';
+                } else if (args.connection.type === 'many-to-many') {
+                    termStart = 'crows-many';
+                    termEnd = 'crows-many';
+                }
+
+                // Points? Simple defaults based on direction or just center-ish
+                // Let's use the logic from add_directional_node for cleaner ports if possible
+                // But simple 0-3 logic:
+                let sp = 0; 
+                let tp = 0;
+                switch(args.direction) {
+                    case "RIGHT": sp=1; tp=3; break;
+                    case "LEFT": sp=3; tp=1; break;
+                    case "DOWN": sp=2; tp=0; break;
+                    case "UP": sp=0; tp=2; break;
+                    default: sp=2; tp=0; break; 
+                }
+
+                const newEdge: EdgeData = {
+                    id: randomUUID(),
+                    sourceId: args.referenceNodeId,
+                    targetId: newNodeId,
+                    sourcePointIndex: sp,
+                    targetPointIndex: tp,
+                    label: args.connection.label,
+                    style: 'line',
+                    routingType: 'orthogonal',
+                    color: '#000000',
+                    thickness: 0.01,
+                    fontSize: 20,
+                    borderStyle: 'solid',
+                    terminationStart: termStart as any,
+                    terminationEnd: termEnd as any
+                };
+                state.edges.push(newEdge);
+            }
             await saveDiagramFile(args.filePath, state);
             return { content: [{ type: "text", text: `Created DB Table '${args.tableName}'` }] };
         }