@mentagen/mcp 0.1.0

package/dist/tools/find-position.js

@@ -0,0 +1,117 @@
+import { z } from 'zod';
+import { findFreePosition, } from '../utils/collision.js';
+import { formatError } from '../utils/errors.js';
+export const findPositionSchema = z.object({
+    boardId: z.string().describe('The board ID to search'),
+    width: z.number().describe('Width of the node to place'),
+    height: z.number().describe('Height of the node to place'),
+    anchorNodeId: z
+        .string()
+        .optional()
+        .describe('Optional node ID to place relative to'),
+    direction: z
+        .enum(['right', 'below', 'left', 'above'])
+        .optional()
+        .describe('Search direction from anchor or start (default: right)'),
+    gap: z
+        .number()
+        .optional()
+        .describe('Gap between nodes in pixels (default: 16)'),
+    startX: z
+        .number()
+        .optional()
+        .describe('Explicit start X (ignored if anchorNodeId provided)'),
+    startY: z
+        .number()
+        .optional()
+        .describe('Explicit start Y (ignored if anchorNodeId provided)'),
+});
+export async function handleFindPosition(client, params) {
+    try {
+        // Fetch nodes from board
+        const nodes = await client.listNodes({
+            boardId: params.boardId,
+            limit: 500,
+        });
+        // Find anchor node if specified
+        let anchor;
+        let anchorInfo;
+        if (params.anchorNodeId) {
+            const anchorNode = nodes.find(n => n._id === params.anchorNodeId);
+            if (!anchorNode) {
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Anchor node not found: ${params.anchorNodeId}`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            anchor = {
+                x: anchorNode.x,
+                y: anchorNode.y,
+                width: anchorNode.width,
+                height: anchorNode.height,
+            };
+            anchorInfo = {
+                id: anchorNode._id,
+                name: anchorNode.name,
+            };
+        }
+        // Find free position
+        const result = findFreePosition({
+            width: params.width,
+            height: params.height,
+            nodes,
+            anchor,
+            direction: params.direction,
+            gap: params.gap,
+            startX: params.startX,
+            startY: params.startY,
+        });
+        if (result.found && result.position) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            found: true,
+                            position: result.position,
+                            anchor: anchorInfo || null,
+                            direction: params.direction || 'right',
+                            searchSteps: result.searchSteps,
+                        }, null, 2),
+                    },
+                ],
+            };
+        }
+        else {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: JSON.stringify({
+                            found: false,
+                            error: result.error || 'No valid position found',
+                            searchSteps: result.searchSteps,
+                        }, null, 2),
+                    },
+                ],
+                isError: true,
+            };
+        }
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Failed to find position: ${formatError(error)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}

package/dist/tools/grid-calc.js

@@ -0,0 +1,205 @@
+import { z } from 'zod';
+import { findCollidingNodes, findSuggestedPosition, } from '../utils/collision.js';
+const GRID_SIZE = 16;
+export const gridCalcSchema = z
+    .object({
+    operation: z
+        .enum(['snap', 'next_x', 'next_y', 'grid_units'])
+        .describe('The calculation operation to perform'),
+    value: z
+        .number()
+        .optional()
+        .describe('Value to snap to the grid (for snap operation)'),
+    position: z
+        .number()
+        .optional()
+        .describe('Current x or y position (for next_x/next_y operations)'),
+    size: z
+        .number()
+        .optional()
+        .describe('Width or height of the current node (for next_x/next_y)'),
+    gap: z
+        .number()
+        .optional()
+        .describe('Gap between nodes in pixels (default: 16)'),
+    units: z
+        .number()
+        .optional()
+        .describe('Number of grid units to convert to pixels (for grid_units)'),
+    // Collision-aware params (optional)
+    boardId: z
+        .string()
+        .optional()
+        .describe('Board ID - if provided, checks for collisions'),
+    nodeWidth: z
+        .number()
+        .optional()
+        .describe('Width of node being placed (required with boardId)'),
+    nodeHeight: z
+        .number()
+        .optional()
+        .describe('Height of node being placed (required with boardId)'),
+    nodeY: z
+        .number()
+        .optional()
+        .describe('Y position of node (required for next_x collision check)'),
+    nodeX: z
+        .number()
+        .optional()
+        .describe('X position of node (required for next_y collision check)'),
+    excludeNodeId: z
+        .string()
+        .optional()
+        .describe('Node ID to exclude from collision check'),
+})
+    .refine(data => {
+    if (data.operation === 'snap') {
+        return data.value !== undefined;
+    }
+    if (data.operation === 'next_x' || data.operation === 'next_y') {
+        return data.position !== undefined && data.size !== undefined;
+    }
+    if (data.operation === 'grid_units') {
+        return data.units !== undefined;
+    }
+    return true;
+}, {
+    message: 'Missing required parameters for operation. snap requires value, next_x/next_y require position and size, grid_units requires units.',
+})
+    .refine(data => {
+    // If boardId is provided, require nodeWidth and nodeHeight
+    if (data.boardId) {
+        return data.nodeWidth !== undefined && data.nodeHeight !== undefined;
+    }
+    return true;
+}, {
+    message: 'When boardId is provided, nodeWidth and nodeHeight are required for collision checking.',
+});
+/**
+ * Snap a value to the nearest multiple of the grid size (16px).
+ * Converts -0 to +0 to avoid JavaScript's signed zero quirks.
+ */
+export function snapToGrid(value) {
+    const result = Math.round(value / GRID_SIZE) * GRID_SIZE;
+    return Object.is(result, -0) ? 0 : result;
+}
+/**
+ * Calculate the next position after a node, with a gap.
+ * Result is snapped to the grid.
+ */
+export function calculateNextPosition(position, size, gap) {
+    return snapToGrid(position + size + gap);
+}
+/**
+ * Convert grid units to pixels.
+ * 1 grid unit = 16 pixels.
+ */
+export function gridUnitsToPixels(units) {
+    return units * GRID_SIZE;
+}
+/**
+ * Calculate result based on operation type.
+ */
+function calculateResult(params) {
+    if (params.operation === 'snap') {
+        return snapToGrid(params.value);
+    }
+    if (params.operation === 'grid_units') {
+        return gridUnitsToPixels(params.units);
+    }
+    // next_x or next_y
+    return calculateNextPosition(params.position, params.size, params.gap ?? GRID_SIZE);
+}
+/**
+ * Build input object for result output.
+ */
+function buildInputObject(params) {
+    const input = {};
+    if (params.value !== undefined)
+        input.value = params.value;
+    if (params.position !== undefined)
+        input.position = params.position;
+    if (params.size !== undefined)
+        input.size = params.size;
+    if (params.gap !== undefined)
+        input.gap = params.gap;
+    if (params.units !== undefined)
+        input.units = params.units;
+    return input;
+}
+/**
+ * Basic grid calculation without collision checking.
+ */
+export function handleGridCalcSync(params) {
+    return {
+        operation: params.operation,
+        input: buildInputObject(params),
+        result: calculateResult(params),
+    };
+}
+/**
+ * Format result as MCP response.
+ */
+function formatResponse(data) {
+    return {
+        content: [{ type: 'text', text: JSON.stringify(data, null, 2) }],
+    };
+}
+/**
+ * Check if operation supports collision checking.
+ */
+function supportsCollisionCheck(operation) {
+    return operation === 'next_x' || operation === 'next_y';
+}
+/**
+ * Build collision info for a position check.
+ */
+async function checkPositionCollision(params, baseResult, client) {
+    const nodes = await client.listNodes({ boardId: params.boardId, limit: 500 });
+    const x = params.operation === 'next_x' ? baseResult.result : (params.nodeX ?? 0);
+    const y = params.operation === 'next_y' ? baseResult.result : (params.nodeY ?? 0);
+    const rect = { x, y, width: params.nodeWidth, height: params.nodeHeight };
+    const collisionResult = findCollidingNodes(rect, nodes, params.excludeNodeId);
+    const collision = {
+        checked: true,
+        collides: collisionResult.collides,
+        collidingNodes: collisionResult.collidingNodes,
+    };
+    if (collisionResult.collides) {
+        const direction = params.operation === 'next_x' ? 'x' : 'y';
+        collision.suggestedPosition = findSuggestedPosition(x, y, params.nodeWidth, params.nodeHeight, nodes, direction, params.excludeNodeId);
+    }
+    return collision;
+}
+/**
+ * Grid calculation with optional collision checking.
+ * If client is provided and params include boardId, checks for collisions.
+ */
+export async function handleGridCalc(params, client) {
+    const baseResult = handleGridCalcSync(params);
+    // If no boardId or client, return basic result
+    if (!params.boardId || !client) {
+        return formatResponse(baseResult);
+    }
+    // For snap and grid_units, collision check doesn't make sense
+    if (!supportsCollisionCheck(params.operation)) {
+        return formatResponse({
+            ...baseResult,
+            collision: {
+                checked: false,
+                note: 'Collision check only available for next_x and next_y operations',
+            },
+        });
+    }
+    try {
+        const collision = await checkPositionCollision(params, baseResult, client);
+        return formatResponse({ ...baseResult, collision });
+    }
+    catch (error) {
+        const errorMsg = error instanceof Error ? error.message : 'Failed to check collision';
+        return formatResponse({
+            ...baseResult,
+            collision: { checked: false, error: errorMsg },
+        });
+    }
+}