@mentagen/mcp 0.1.0

package/dist/tools/index.js

@@ -0,0 +1,940 @@
+// The SDK requires these Zod schemas for request handler registration.
+// Using raw objects like { method: 'tools/list' } causes "Schema is missing
+// a method literal" errors because the SDK validates against ZodLiteral types.
+import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { batchUpdateSchema, handleBatchUpdate } from './batch-update.js';
+import { boardsSchema, handleBoards } from './boards.js';
+import { checkCollisionSchema, handleCheckCollision, } from './check-collision.js';
+import { colorsSchema, handleColors } from './colors.js';
+import { createSchema, handleCreate } from './create.js';
+import { createBoardSchema, handleCreateBoard } from './create-board.js';
+import { createEdgeSchema, handleCreateEdge } from './create-edge.js';
+import { createGraphSchema, handleCreateGraph } from './create-graph.js';
+import { deleteSchema, handleDelete } from './delete.js';
+import { deleteEdgeSchema, handleDeleteEdge } from './delete-edge.js';
+import { extractBoardContentSchema, handleExtractBoardContent, } from './extract-board-content.js';
+import { findPositionSchema, handleFindPosition } from './find-position.js';
+import { gridCalcSchema, handleGridCalc } from './grid-calc.js';
+import { handleLink, linkSchema } from './link.js';
+import { handleListEdges, listEdgesSchema } from './list-edges.js';
+import { handleListNodes, listNodesSchema } from './list-nodes.js';
+import { handleListPositions, listPositionsSchema } from './list-positions.js';
+import { handleNodeTypes, nodeTypesSchema } from './node-types.js';
+import { handlePatchContent, patchContentSchema } from './patch-content.js';
+import { handleRead, readSchema } from './read.js';
+import { handleSearch, searchSchema } from './search.js';
+import { handleSearchBoard, searchBoardSchema } from './search-board.js';
+import { handleSearchBoards, searchBoardsSchema } from './search-boards.js';
+import { handleSizeCalc, sizeCalcSchema } from './size-calc.js';
+import { handleUpdate, updateSchema } from './update.js';
+import { handleUpdateBoard, updateBoardSchema } from './update-board.js';
+import { handleUpdateEdge, updateEdgeSchema } from './update-edge.js';
+export function registerTools(server, client, config) {
+    server.setRequestHandler(ListToolsRequestSchema, async () => ({
+        tools: [
+            // Board tools
+            {
+                name: 'mentagen_list_boards',
+                description: 'List all boards you have access to in Mentagen. Returns board IDs, names, node counts, and direct links.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {},
+                },
+            },
+            {
+                name: 'mentagen_search_boards',
+                description: 'Search for boards by name. Returns matching boards with their ID, name, node count, last updated date, and direct links.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        query: {
+                            type: 'string',
+                            description: 'Search query to filter boards by name',
+                        },
+                    },
+                    required: ['query'],
+                },
+            },
+            {
+                name: 'mentagen_create_board',
+                description: 'Create a new board in Mentagen.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        name: {
+                            type: 'string',
+                            description: 'The name for the new board',
+                        },
+                    },
+                    required: ['name'],
+                },
+            },
+            {
+                name: 'mentagen_update_board',
+                description: 'Update a board name in Mentagen.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        boardId: {
+                            type: 'string',
+                            description: 'The board ID to update',
+                        },
+                        name: {
+                            type: 'string',
+                            description: 'New name for the board',
+                        },
+                    },
+                    required: ['boardId', 'name'],
+                },
+            },
+            // Node tools
+            {
+                name: 'mentagen_list_nodes',
+                description: 'List all nodes in a board. Returns node ID, name, type, truncated content, and direct links. Use mentagen_read_node to get full content of a specific node.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        boardId: {
+                            type: 'string',
+                            description: 'The board ID to list nodes from',
+                        },
+                        limit: {
+                            type: 'number',
+                            description: 'Maximum number of nodes to return (default: 1000, max: 1000)',
+                            default: 100,
+                        },
+                    },
+                    required: ['boardId'],
+                },
+            },
+            {
+                name: 'mentagen_list_positions',
+                description: 'List node positions in a board. Returns minimal data (id, name, x, y, width, height) optimized for layout operations. Use this instead of list_nodes when you only need positioning info.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        boardId: {
+                            type: 'string',
+                            description: 'The board ID to list node positions from',
+                        },
+                    },
+                    required: ['boardId'],
+                },
+            },
+            {
+                name: 'mentagen_extract_board_content',
+                description: 'Extract all textual content from a board as a single markdown document. ' +
+                    'Each node is annotated with its ID, name, type, and link for easy reference. ' +
+                    'Handles code nodes (code field) and text/markdown nodes (content field) automatically. ' +
+                    'Use this to get a comprehensive view of all knowledge in a board.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        boardId: {
+                            type: 'string',
+                            description: 'The board ID to extract content from',
+                        },
+                        includeEmpty: {
+                            type: 'boolean',
+                            description: 'Include nodes with no content (default: false)',
+                            default: false,
+                        },
+                    },
+                    required: ['boardId'],
+                },
+            },
+            {
+                name: 'mentagen_search_nodes',
+                description: 'Search for nodes across ALL your boards using semantic search. Returns matching nodes with truncated content previews and direct links. Use mentagen_search_board to search within a specific board, or mentagen_read_node with the node ID to retrieve full content.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        query: {
+                            type: 'string',
+                            description: 'The search query - can be a question or keywords',
+                        },
+                        board: {
+                            type: 'string',
+                            description: 'Optional board ID to limit search scope',
+                        },
+                        limit: {
+                            type: 'number',
+                            description: 'Maximum number of results (default: 10)',
+                            default: 10,
+                        },
+                        semanticRatio: {
+                            type: 'number',
+                            description: 'Balance between semantic (1.0) and keyword (0.0) search',
+                            default: 0.5,
+                        },
+                    },
+                    required: ['query'],
+                },
+            },
+            {
+                name: 'mentagen_search_board',
+                description: 'Search for nodes within a SPECIFIC board using semantic search. Use this when you know which board to search in. Returns matching nodes with truncated content previews and direct links. Use mentagen_read_node with the node ID to retrieve full content.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        boardId: {
+                            type: 'string',
+                            description: 'The board ID to search within (required)',
+                        },
+                        query: {
+                            type: 'string',
+                            description: 'The search query - can be a question or keywords',
+                        },
+                        limit: {
+                            type: 'number',
+                            description: 'Maximum number of results (default: 10)',
+                            default: 10,
+                        },
+                        semanticRatio: {
+                            type: 'number',
+                            description: 'Balance between semantic (1.0) and keyword (0.0) search',
+                            default: 0.5,
+                        },
+                    },
+                    required: ['boardId', 'query'],
+                },
+            },
+            {
+                name: 'mentagen_read_node',
+                description: 'Read a single node by ID. Returns the full node content without truncation, unlike search results. Includes a direct link to the node.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        boardId: {
+                            type: 'string',
+                            description: 'The board ID containing the node',
+                        },
+                        nodeId: {
+                            type: 'string',
+                            description: 'The node ID to read',
+                        },
+                    },
+                    required: ['boardId', 'nodeId'],
+                },
+            },
+            {
+                name: 'mentagen_create_node',
+                description: 'Create a new node on a Mentagen board. IMPORTANT: Do NOT provide width/height - let auto-sizing calculate dimensions from the name. Only provide explicit dimensions if the user specifically requests a custom size. Content does not affect size (it scrolls inside the node).',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        boardId: {
+                            type: 'string',
+                            description: 'The board ID to create the node on',
+                        },
+                        name: {
+                            type: 'string',
+                            description: 'The node title/name (used for auto-sizing). For code nodes, use a filename with extension (e.g., "utils.ts", "app.py") for syntax highlighting.',
+                        },
+                        content: {
+                            type: 'string',
+                            description: 'Content for the node (scrollable, does NOT affect size)',
+                        },
+                        type: {
+                            type: 'string',
+                            enum: ['text', 'markdown', 'code', 'url'],
+                            description: 'Node type: text (default), markdown, code, or url. Code nodes get syntax highlighting based on the file extension in the name.',
+                        },
+                        color: {
+                            type: 'string',
+                            description: 'Optional color override. If not specified, uses default for type (markdown=cyan, code=indigo)',
+                        },
+                        x: {
+                            type: 'number',
+                            description: 'X position (snapped to 16px grid, default: 96)',
+                        },
+                        y: {
+                            type: 'number',
+                            description: 'Y position (snapped to 16px grid, default: 96)',
+                        },
+                        width: {
+                            type: 'number',
+                            description: 'DO NOT USE unless user requests specific size. Auto-calculated from name.',
+                        },
+                        height: {
+                            type: 'number',
+                            description: 'DO NOT USE unless user requests specific size. Auto-calculated from name.',
+                        },
+                    },
+                    required: ['boardId', 'name'],
+                },
+            },
+            {
+                name: 'mentagen_update_node',
+                description: 'Update an existing node in Mentagen. When name changes, size auto-adjusts unless explicit width/height provided. Returns the final position and size.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        boardId: {
+                            type: 'string',
+                            description: 'The board ID containing the node',
+                        },
+                        nodeId: {
+                            type: 'string',
+                            description: 'The node ID to update',
+                        },
+                        name: {
+                            type: 'string',
+                            description: 'New name for the node',
+                        },
+                        content: {
+                            type: 'string',
+                            description: 'New content for the node',
+                        },
+                        color: {
+                            type: 'string',
+                            description: 'Node color name (use mentagen_colors to see available colors)',
+                        },
+                        x: {
+                            type: 'number',
+                            description: 'X position on the board canvas (multiple of 16)',
+                        },
+                        y: {
+                            type: 'number',
+                            description: 'Y position on the board canvas (multiple of 16)',
+                        },
+                        width: {
+                            type: 'number',
+                            description: 'Node width in pixels (multiple of 16)',
+                        },
+                        height: {
+                            type: 'number',
+                            description: 'Node height in pixels (multiple of 16)',
+                        },
+                        autoSize: {
+                            type: 'boolean',
+                            description: 'Auto-resize when name changes (default: true). Set false to keep current size.',
+                        },
+                    },
+                    required: ['boardId', 'nodeId'],
+                },
+            },
+            {
+                name: 'mentagen_delete_node',
+                description: 'Delete a node from a Mentagen board. This is a soft delete and can be undone in the app.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        boardId: {
+                            type: 'string',
+                            description: 'The board ID containing the node',
+                        },
+                        nodeId: {
+                            type: 'string',
+                            description: 'The node ID to delete',
+                        },
+                    },
+                    required: ['boardId', 'nodeId'],
+                },
+            },
+            {
+                name: 'mentagen_batch_update',
+                description: 'Update multiple nodes and/or edges in a single call. More efficient than individual updates for bulk operations like repositioning or restyling.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        boardId: {
+                            type: 'string',
+                            description: 'The board ID containing the items to update',
+                        },
+                        nodes: {
+                            type: 'array',
+                            description: 'Array of node updates',
+                            items: {
+                                type: 'object',
+                                properties: {
+                                    nodeId: { type: 'string', description: 'The node ID' },
+                                    name: { type: 'string', description: 'New name' },
+                                    content: { type: 'string', description: 'New content' },
+                                    color: { type: 'string', description: 'Node color' },
+                                    x: { type: 'number', description: 'X position' },
+                                    y: { type: 'number', description: 'Y position' },
+                                    width: { type: 'number', description: 'Width' },
+                                    height: { type: 'number', description: 'Height' },
+                                },
+                                required: ['nodeId'],
+                            },
+                        },
+                        edges: {
+                            type: 'array',
+                            description: 'Array of edge updates',
+                            items: {
+                                type: 'object',
+                                properties: {
+                                    edgeId: { type: 'string', description: 'The edge ID' },
+                                    direction: {
+                                        type: 'string',
+                                        enum: ['none', 'source', 'target'],
+                                        description: 'Arrow direction',
+                                    },
+                                    label: { type: 'string', description: 'Edge label' },
+                                },
+                                required: ['edgeId'],
+                            },
+                        },
+                    },
+                    required: ['boardId'],
+                },
+            },
+            {
+                name: 'mentagen_patch_content',
+                description: 'Apply targeted patches to node content without sending the full text. ' +
+                    'Use this instead of mentagen_update_node for efficient edits that save tokens. ' +
+                    'Automatically uses the correct field (content for markdown/text, code for code nodes). ' +
+                    'Operations: replace (find unique string and replace), prepend (add to start), append (add to end).',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        boardId: {
+                            type: 'string',
+                            description: 'The board ID containing the node',
+                        },
+                        nodeId: {
+                            type: 'string',
+                            description: 'The node ID to patch',
+                        },
+                        operations: {
+                            type: 'array',
+                            description: 'Array of patch operations to apply sequentially',
+                            items: {
+                                oneOf: [
+                                    {
+                                        type: 'object',
+                                        description: 'Replace a unique string with new text',
+                                        properties: {
+                                            type: { const: 'replace' },
+                                            oldString: {
+                                                type: 'string',
+                                                description: 'Text to find (must be unique unless replaceAll is true). Include surrounding context if needed.',
+                                            },
+                                            newString: {
+                                                type: 'string',
+                                                description: 'Replacement text',
+                                            },
+                                            replaceAll: {
+                                                type: 'boolean',
+                                                description: 'Replace all occurrences instead of requiring uniqueness (default: false)',
+                                            },
+                                        },
+                                        required: ['type', 'oldString', 'newString'],
+                                    },
+                                    {
+                                        type: 'object',
+                                        description: 'Add content at the beginning',
+                                        properties: {
+                                            type: { const: 'prepend' },
+                                            content: {
+                                                type: 'string',
+                                                description: 'Content to add at the start',
+                                            },
+                                        },
+                                        required: ['type', 'content'],
+                                    },
+                                    {
+                                        type: 'object',
+                                        description: 'Add content at the end',
+                                        properties: {
+                                            type: { const: 'append' },
+                                            content: {
+                                                type: 'string',
+                                                description: 'Content to add at the end',
+                                            },
+                                        },
+                                        required: ['type', 'content'],
+                                    },
+                                ],
+                            },
+                        },
+                    },
+                    required: ['boardId', 'nodeId', 'operations'],
+                },
+            },
+            {
+                name: 'mentagen_create_graph',
+                description: 'Create multiple nodes with edges in a single call. IMPORTANT: Do NOT provide width/height for nodes - let auto-sizing calculate dimensions from names. Only provide explicit dimensions if the user specifically requests custom sizes.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        boardId: {
+                            type: 'string',
+                            description: 'The board ID to create the graph on',
+                        },
+                        nodes: {
+                            type: 'array',
+                            description: 'Array of nodes to create',
+                            items: {
+                                type: 'object',
+                                properties: {
+                                    tempId: {
+                                        type: 'string',
+                                        description: 'Temporary ID for referencing in edges',
+                                    },
+                                    name: {
+                                        type: 'string',
+                                        description: 'Node title/name (used for auto-sizing). For code nodes, use a filename with extension for syntax highlighting.',
+                                    },
+                                    content: {
+                                        type: 'string',
+                                        description: 'Node content (scrollable, does NOT affect size)',
+                                    },
+                                    type: {
+                                        type: 'string',
+                                        enum: ['text', 'markdown', 'code', 'url'],
+                                        description: 'Node type (default: text). Code nodes get syntax highlighting based on file extension in name.',
+                                    },
+                                    color: { type: 'string', description: 'Node color' },
+                                    x: { type: 'number', description: 'X position' },
+                                    y: { type: 'number', description: 'Y position' },
+                                    width: {
+                                        type: 'number',
+                                        description: 'DO NOT USE - auto-calculated from name',
+                                    },
+                                    height: {
+                                        type: 'number',
+                                        description: 'DO NOT USE - auto-calculated from name',
+                                    },
+                                },
+                                required: ['tempId', 'name'],
+                            },
+                        },
+                        edges: {
+                            type: 'array',
+                            description: 'Array of edges connecting nodes by tempId',
+                            items: {
+                                type: 'object',
+                                properties: {
+                                    source: {
+                                        type: 'string',
+                                        description: 'Source node tempId',
+                                    },
+                                    target: {
+                                        type: 'string',
+                                        description: 'Target node tempId',
+                                    },
+                                    direction: {
+                                        type: 'string',
+                                        enum: ['none', 'source', 'target'],
+                                        description: 'Arrow direction',
+                                    },
+                                    label: { type: 'string', description: 'Edge label' },
+                                },
+                                required: ['source', 'target'],
+                            },
+                        },
+                    },
+                    required: ['boardId', 'nodes'],
+                },
+            },
+            // Edge tools
+            {
+                name: 'mentagen_list_edges',
+                description: 'List all edges (connections) in a board. Returns edge ID, source node, target node, direction, and label.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        boardId: {
+                            type: 'string',
+                            description: 'The board ID to list edges from',
+                        },
+                        limit: {
+                            type: 'number',
+                            description: 'Maximum number of edges to return (default: 1000, max: 1000)',
+                        },
+                    },
+                    required: ['boardId'],
+                },
+            },
+            {
+                name: 'mentagen_create_edge',
+                description: 'Create an edge (connection) between two nodes. IMPORTANT: Connected nodes should have at least 96px gap between them for visual clarity.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        boardId: {
+                            type: 'string',
+                            description: 'The board ID where the edge will be created',
+                        },
+                        source: {
+                            type: 'string',
+                            description: 'The source node ID',
+                        },
+                        target: {
+                            type: 'string',
+                            description: 'The target node ID',
+                        },
+                        direction: {
+                            type: 'string',
+                            enum: ['none', 'source', 'target'],
+                            description: 'Arrow direction: "none" (no arrow, default), "source" (arrow points to source), "target" (arrow points to target)',
+                        },
+                    },
+                    required: ['boardId', 'source', 'target'],
+                },
+            },
+            {
+                name: 'mentagen_update_edge',
+                description: 'Update an edge direction or label. Direction controls arrow display: "none" (no arrow), "source" (arrow points to source), "target" (arrow points to target).',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        boardId: {
+                            type: 'string',
+                            description: 'The board ID containing the edge',
+                        },
+                        edgeId: {
+                            type: 'string',
+                            description: 'The edge ID to update',
+                        },
+                        direction: {
+                            type: 'string',
+                            enum: ['none', 'source', 'target'],
+                            description: 'Edge direction: none (no arrow), source (arrow to source), target (arrow to target)',
+                        },
+                        label: {
+                            type: 'string',
+                            description: 'Optional label text for the edge',
+                        },
+                    },
+                    required: ['boardId', 'edgeId'],
+                },
+            },
+            {
+                name: 'mentagen_delete_edge',
+                description: 'Delete an edge from a Mentagen board. This is a soft delete and can be undone in the app.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        boardId: {
+                            type: 'string',
+                            description: 'The board ID containing the edge',
+                        },
+                        edgeId: {
+                            type: 'string',
+                            description: 'The edge ID to delete',
+                        },
+                    },
+                    required: ['boardId', 'edgeId'],
+                },
+            },
+            // Utility tools
+            {
+                name: 'mentagen_link',
+                description: 'Generate a URL link to a Mentagen board or a specific node. Use this to create shareable links.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        boardId: {
+                            type: 'string',
+                            description: 'The board ID',
+                        },
+                        nodeId: {
+                            type: 'string',
+                            description: 'Optional node ID to link directly to a specific node',
+                        },
+                    },
+                    required: ['boardId'],
+                },
+            },
+            {
+                name: 'mentagen_colors',
+                description: 'Get the list of available colors for nodes. Returns color names and their RGB values.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {},
+                },
+            },
+            {
+                name: 'mentagen_node_types',
+                description: 'Get the list of supported node types with descriptions and usage guidance. Use this to understand what types of nodes can be created.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {},
+                },
+            },
+            {
+                name: 'mentagen_grid_calc',
+                description: 'Math helper for calculating node positions on the 16px grid. Use gap=96+ for connected nodes, gap=16 for unrelated nodes. Operations: "snap" rounds to 16px, "next_x"/"next_y" calculate position after a node, "grid_units" converts units to pixels.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        operation: {
+                            type: 'string',
+                            enum: ['snap', 'next_x', 'next_y', 'grid_units'],
+                            description: 'The calculation operation to perform',
+                        },
+                        value: {
+                            type: 'number',
+                            description: 'Value to snap to the grid (for snap operation)',
+                        },
+                        position: {
+                            type: 'number',
+                            description: 'Current x or y position (for next_x/next_y operations)',
+                        },
+                        size: {
+                            type: 'number',
+                            description: 'Width or height of the current node (for next_x/next_y)',
+                        },
+                        gap: {
+                            type: 'number',
+                            description: 'Gap in pixels. Use 96+ for connected nodes, 16 for unrelated (default: 16)',
+                        },
+                        units: {
+                            type: 'number',
+                            description: 'Number of grid units to convert to pixels (for grid_units)',
+                        },
+                        boardId: {
+                            type: 'string',
+                            description: 'Optional: Board ID for collision checking (requires nodeWidth and nodeHeight)',
+                        },
+                        nodeWidth: {
+                            type: 'number',
+                            description: 'Width of node being placed (required with boardId)',
+                        },
+                        nodeHeight: {
+                            type: 'number',
+                            description: 'Height of node being placed (required with boardId)',
+                        },
+                        nodeY: {
+                            type: 'number',
+                            description: 'Y position of node (for next_x collision check)',
+                        },
+                        nodeX: {
+                            type: 'number',
+                            description: 'X position of node (for next_y collision check)',
+                        },
+                        excludeNodeId: {
+                            type: 'string',
+                            description: 'Node ID to exclude from collision check',
+                        },
+                    },
+                    required: ['operation'],
+                },
+            },
+            {
+                name: 'mentagen_check_collision',
+                description: 'Check if a rectangle would collide with existing nodes on a board. Use this to validate positions before creating or moving nodes.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        boardId: {
+                            type: 'string',
+                            description: 'The board ID to check against',
+                        },
+                        x: {
+                            type: 'number',
+                            description: 'Left position of the rectangle',
+                        },
+                        y: {
+                            type: 'number',
+                            description: 'Top position of the rectangle',
+                        },
+                        width: {
+                            type: 'number',
+                            description: 'Width of the rectangle',
+                        },
+                        height: {
+                            type: 'number',
+                            description: 'Height of the rectangle',
+                        },
+                        excludeNodeId: {
+                            type: 'string',
+                            description: 'Optional node ID to exclude from check (for move operations)',
+                        },
+                    },
+                    required: ['boardId', 'x', 'y', 'width', 'height'],
+                },
+            },
+            {
+                name: 'mentagen_find_position',
+                description: 'Find a valid non-colliding position for a new node. IMPORTANT: Use gap=96 or more when nodes will be connected by edges, otherwise gap=16 is fine for unrelated nodes.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        boardId: {
+                            type: 'string',
+                            description: 'The board ID to search',
+                        },
+                        width: {
+                            type: 'number',
+                            description: 'Width of the node to place',
+                        },
+                        height: {
+                            type: 'number',
+                            description: 'Height of the node to place',
+                        },
+                        anchorNodeId: {
+                            type: 'string',
+                            description: 'Optional node ID to place relative to',
+                        },
+                        direction: {
+                            type: 'string',
+                            enum: ['right', 'below', 'left', 'above'],
+                            description: 'Search direction from anchor or start (default: right)',
+                        },
+                        gap: {
+                            type: 'number',
+                            description: 'Gap between nodes in pixels. Use 96+ for connected nodes (edges), 16 for unrelated nodes',
+                        },
+                        startX: {
+                            type: 'number',
+                            description: 'Explicit start X (ignored if anchorNodeId provided)',
+                        },
+                        startY: {
+                            type: 'number',
+                            description: 'Explicit start Y (ignored if anchorNodeId provided)',
+                        },
+                    },
+                    required: ['boardId', 'width', 'height'],
+                },
+            },
+            {
+                name: 'mentagen_size_calc',
+                description: 'Calculate recommended node dimensions based on name and type. Returns width and height values (multiples of 16) sized to fit the title. Content is intentionally ignored — nodes are sized for their title with content scrollable inside.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        name: {
+                            type: 'string',
+                            description: 'The node name/title to measure',
+                        },
+                        type: {
+                            type: 'string',
+                            description: 'Node type (text, markdown, code, url) - affects icon space',
+                        },
+                    },
+                    required: ['name'],
+                },
+            },
+        ],
+    }));
+    const toolHandlers = {
+        // Board handlers
+        mentagen_list_boards: async (args) => {
+            const params = boardsSchema.parse(args);
+            return handleBoards(client, params, config.mentagenUrl);
+        },
+        mentagen_search_boards: async (args) => {
+            const params = searchBoardsSchema.parse(args);
+            return handleSearchBoards(client, params, config.mentagenUrl);
+        },
+        mentagen_create_board: async (args) => {
+            const params = createBoardSchema.parse(args);
+            return handleCreateBoard(client, params, config.mentagenUrl);
+        },
+        mentagen_update_board: async (args) => {
+            const params = updateBoardSchema.parse(args);
+            return handleUpdateBoard(client, params, config.mentagenUrl);
+        },
+        // Node handlers
+        mentagen_list_nodes: async (args) => {
+            const params = listNodesSchema.parse(args);
+            return handleListNodes(client, params, config.mentagenUrl);
+        },
+        mentagen_list_positions: async (args) => {
+            const params = listPositionsSchema.parse(args);
+            return handleListPositions(client, params);
+        },
+        mentagen_extract_board_content: async (args) => {
+            const params = extractBoardContentSchema.parse(args);
+            return handleExtractBoardContent(client, params, config.mentagenUrl);
+        },
+        mentagen_search_nodes: async (args) => {
+            const params = searchSchema.parse(args);
+            return handleSearch(client, params, config.mentagenUrl);
+        },
+        mentagen_search_board: async (args) => {
+            const params = searchBoardSchema.parse(args);
+            return handleSearchBoard(client, params, config.mentagenUrl);
+        },
+        mentagen_read_node: async (args) => {
+            const params = readSchema.parse(args);
+            return handleRead(client, params, config.mentagenUrl);
+        },
+        mentagen_create_node: async (args) => {
+            const params = createSchema.parse(args);
+            return handleCreate(client, params, config.mentagenUrl);
+        },
+        mentagen_update_node: async (args) => {
+            const params = updateSchema.parse(args);
+            return handleUpdate(client, params);
+        },
+        mentagen_delete_node: async (args) => {
+            const params = deleteSchema.parse(args);
+            return handleDelete(client, params);
+        },
+        mentagen_batch_update: async (args) => {
+            const params = batchUpdateSchema.parse(args);
+            return handleBatchUpdate(client, params);
+        },
+        mentagen_patch_content: async (args) => {
+            const params = patchContentSchema.parse(args);
+            return handlePatchContent(client, params);
+        },
+        mentagen_create_graph: async (args) => {
+            const params = createGraphSchema.parse(args);
+            return handleCreateGraph(client, params);
+        },
+        // Edge handlers
+        mentagen_list_edges: async (args) => {
+            const params = listEdgesSchema.parse(args);
+            return handleListEdges(client, params);
+        },
+        mentagen_create_edge: async (args) => {
+            const params = createEdgeSchema.parse(args);
+            return handleCreateEdge(client, params);
+        },
+        mentagen_update_edge: async (args) => {
+            const params = updateEdgeSchema.parse(args);
+            return handleUpdateEdge(client, params);
+        },
+        mentagen_delete_edge: async (args) => {
+            const params = deleteEdgeSchema.parse(args);
+            return handleDeleteEdge(client, params);
+        },
+        // Utility handlers
+        mentagen_link: async (args) => {
+            const params = linkSchema.parse(args);
+            return handleLink(params, config);
+        },
+        mentagen_colors: async (args) => {
+            colorsSchema.parse(args);
+            return handleColors();
+        },
+        mentagen_node_types: async (args) => {
+            nodeTypesSchema.parse(args);
+            return handleNodeTypes();
+        },
+        mentagen_grid_calc: async (args) => {
+            const params = gridCalcSchema.parse(args);
+            return handleGridCalc(params, client);
+        },
+        mentagen_check_collision: async (args) => {
+            const params = checkCollisionSchema.parse(args);
+            return handleCheckCollision(client, params);
+        },
+        mentagen_find_position: async (args) => {
+            const params = findPositionSchema.parse(args);
+            return handleFindPosition(client, params);
+        },
+        mentagen_size_calc: async (args) => {
+            const params = sizeCalcSchema.parse(args);
+            return handleSizeCalc(params);
+        },
+    };
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        const handler = toolHandlers[name];
+        if (!handler) {
+            return {
+                content: [{ type: 'text', text: `Unknown tool: ${name}` }],
+                isError: true,
+            };
+        }
+        return handler(args);
+    });
+}