dodraw-mcp-server 0.1.4 → 0.1.6

package/dist/src/tools/diagramTools.js

@@ -140,7 +140,7 @@ exports.toolDefinitions = [
     },
     {
         name: "add_directional_node",
-        description: "Add a new node relative to an existing node and connect them. PRIMARY method for creating diagrams.",
+        description: "Add a new node relative to an existing node and connect them. PRIMARY method for creating diagrams, including Class and Database diagrams. Supports 'columns' for DB tables.",
         inputSchema: {
             type: "object",
             properties: {
@@ -154,14 +154,28 @@ exports.toolDefinitions = [
                 color: { type: "string" },
                 edgeLabel: { type: "string", description: "Optional label for the connecting edge" },
                 attributes: { type: "array", items: { type: "string" }, description: "Optional list of attributes for Class nodes" },
-                methods: { type: "array", items: { type: "string" }, description: "Optional list of methods for Class nodes" }
+                methods: { type: "array", items: { type: "string" }, description: "Optional list of methods for Class nodes" },
+                columns: {
+                    type: "array",
+                    description: "Optional list of columns for Table nodes",
+                    items: {
+                        type: "object",
+                        properties: {
+                            name: { type: "string" },
+                            type: { type: "string" },
+                            isPk: { type: "boolean" },
+                            isFk: { type: "boolean" }
+                        },
+                        required: ["name", "type"]
+                    }
+                }
             },
             required: ["filePath", "sourceNodeId", "direction", "label"]
         }
     },
     {
         name: "create_uml_class",
-        description: "Create a UML Class node with methods and attributes",
+        description: "Create a UML Class node. Use this for the FIRST class. For connected classes, use 'add_directional_node' to ensure correct relative positioning.",
         inputSchema: {
             type: "object",
             properties: {
@@ -178,7 +192,7 @@ exports.toolDefinitions = [
     },
     {
         name: "create_db_table",
-        description: "Create a Database Entity (ERD Table)",
+        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: {
@@ -199,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"]
         }
@@ -402,6 +428,14 @@ async function handleToolCall(name, args) {
                     attributes: args.attributes || [],
                     methods: args.methods || []
                 } : undefined,
+                dbTableData: args.columns ? {
+                    columns: args.columns.map((c) => ({
+                        name: c.name,
+                        type: c.type,
+                        isPk: !!c.isPk,
+                        isFk: !!c.isFk
+                    }))
+                } : undefined,
                 textAlignVertical: 'center',
                 textAlignHorizontal: 'center'
             };
@@ -528,11 +562,19 @@ async function handleToolCall(name, args) {
             const methodCount = (args.methods || []).length;
             const estimatedHeight = 0.8 + (attrCount + methodCount) * 0.4;
             const height = Math.max(2, estimatedHeight);
+            // 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) {
+                const lastNode = state.nodes[state.nodes.length - 1];
+                x = lastNode.x + 5;
+                z = lastNode.z;
+            }
             const newNode = {
                 id: newNodeId,
-                x: args.x ? Number(args.x) : 0,
+                x: x,
                 y: 0,
-                z: args.y ? Number(args.y) : 0,
+                z: z,
                 width: width,
                 height: height,
                 label: args.className,
@@ -556,11 +598,74 @@ async function handleToolCall(name, args) {
             const estimatedHeight = 0.8 + cols.length * 0.4;
             const height = Math.max(2, estimatedHeight);
             const width = 3;
+            // 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;
+            // 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;
+            }
             const newNode = {
                 id: newNodeId,
-                x: args.x ? Number(args.x) : 0,
+                x: x,
                 y: 0,
-                z: args.y ? Number(args.y) : 0,
+                z: z,
                 width: width,
                 height: height,
                 label: args.tableName,
@@ -577,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.4",
+  "version": "0.1.6",
   "description": "MCP server for DoDraw",
   "main": "dist/src/index.js",
   "bin": {

package/src/tools/diagramTools.ts

@@ -140,7 +140,7 @@ export const toolDefinitions: Tool[] = [
   },
   {
     name: "add_directional_node",
-    description: "Add a new node relative to an existing node and connect them. PRIMARY method for creating diagrams.",
+    description: "Add a new node relative to an existing node and connect them. PRIMARY method for creating diagrams, including Class and Database diagrams. Supports 'columns' for DB tables.",
     inputSchema: {
       type: "object",
       properties: {
@@ -154,14 +154,28 @@ export const toolDefinitions: Tool[] = [
         color: { type: "string" },
         edgeLabel: { type: "string", description: "Optional label for the connecting edge" },
         attributes: { type: "array", items: { type: "string" }, description: "Optional list of attributes for Class nodes" },
-        methods: { type: "array", items: { type: "string" }, description: "Optional list of methods for Class nodes" }
+        methods: { type: "array", items: { type: "string" }, description: "Optional list of methods for Class nodes" },
+        columns: { 
+            type: "array", 
+            description: "Optional list of columns for Table nodes",
+            items: { 
+               type: "object",
+               properties: {
+                  name: { type: "string" },
+                  type: { type: "string" },
+                  isPk: { type: "boolean" },
+                  isFk: { type: "boolean" }
+               },
+               required: ["name", "type"]
+            } 
+        }
       },
       required: ["filePath", "sourceNodeId", "direction", "label"]
     }
   },
   {
     name: "create_uml_class",
-    description: "Create a UML Class node with methods and attributes",
+    description: "Create a UML Class node. Use this for the FIRST class. For connected classes, use 'add_directional_node' to ensure correct relative positioning.",
     inputSchema: {
       type: "object",
       properties: {
@@ -178,7 +192,8 @@ export const toolDefinitions: Tool[] = [
   },
   {
     name: "create_db_table",
-    description: "Create a Database Entity (ERD Table)",
+
+    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: {
@@ -199,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"]
     }
@@ -417,6 +444,14 @@ export async function handleToolCall(name: string, args: any): Promise<any> {
                     attributes: args.attributes || [],
                     methods: args.methods || []
                 } : undefined,
+                dbTableData: args.columns ? {
+                    columns: args.columns.map((c: any) => ({
+                        name: c.name,
+                        type: c.type,
+                        isPk: !!c.isPk,
+                        isFk: !!c.isFk
+                    }))
+                } : undefined,
                 textAlignVertical: 'center',
                 textAlignHorizontal: 'center'
             };
@@ -544,11 +579,21 @@ export async function handleToolCall(name: string, args: any): Promise<any> {
             const estimatedHeight = 0.8 + (attrCount + methodCount) * 0.4; 
             const height = Math.max(2, estimatedHeight);
 
+            // 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) {
+                 const lastNode = state.nodes[state.nodes.length - 1];
+                 x = lastNode.x + 5;
+                 z = lastNode.z;
+            }
+
             const newNode: NodeData = {
                 id: newNodeId,
-                x: args.x ? Number(args.x) : 0,
+                x: x,
                 y: 0, 
-                z: args.y ? Number(args.y) : 0,
+                z: z,
                 width: width,
                 height: height,
                 label: args.className,
@@ -573,13 +618,72 @@ export async function handleToolCall(name: string, args: any): Promise<any> {
             // Header + items
             const estimatedHeight = 0.8 + cols.length * 0.4;
             const height = Math.max(2, estimatedHeight);
+
             const width = 3;
 
+            // 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;
+            
+            // 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;
+            }
+
             const newNode: NodeData = {
                 id: newNodeId,
-                x: args.x ? Number(args.x) : 0,
+                x: x,
                 y: 0,
-                z: args.y ? Number(args.y) : 0,
+                z: z,
                 width: width,
                 height: height,
                 label: args.tableName,
@@ -597,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}'` }] };
         }