@mentagen/mcp 0.6.0 → 0.8.0

package/dist/tools/update.js

@@ -4,6 +4,23 @@ import { formatError } from '../utils/errors.js';
 import { pixelsToUnits, unitsToPixels } from '../utils/units.js';
 import { snapToGrid } from './grid-calc.js';
 import { calculateNodeSize } from './size-calc.js';
+/**
+ * Node types that can be converted between safely.
+ * These are text-based types where content can be migrated without data loss.
+ * Note: text nodes are accepted for conversion (legacy) but MCP only creates markdown.
+ */
+const CONVERTIBLE_TYPES = [
+    NodeType.Text,
+    NodeType.Markdown,
+    NodeType.Code,
+    NodeType.URL,
+];
+/**
+ * Check if a type is convertible (text-based).
+ */
+function isConvertibleType(type) {
+    return CONVERTIBLE_TYPES.includes(type);
+}
 export const updateSchema = z.object({
     boardId: z.string().describe('The board ID containing the node'),
     nodeId: z.string().describe('The node ID to update'),
@@ -11,8 +28,12 @@ export const updateSchema = z.object({
         .string()
         .optional()
         .describe('Move node to a different board. Provide the target board ID to move the node while preserving its type and properties.'),
+    type: z
+        .enum(['markdown', 'code', 'url'])
+        .optional()
+        .describe('Change node type. Safe conversions: markdown ↔ code. Content is auto-migrated between fields.'),
     name: z.string().optional().describe('New name for the node'),
-    content: z.string().optional().describe('Content for text/markdown nodes.'),
+    content: z.string().optional().describe('Content for markdown nodes.'),
     code: z
         .string()
         .optional()
@@ -34,8 +55,70 @@ export const updateSchema = z.object({
         .optional()
         .default(true)
         .describe('Auto-resize node when name changes (default: true). Set to false to keep current size.'),
+    todos: z
+        .array(z.object({
+        id: z.string().describe('Unique identifier (UUID v4)'),
+        text: z.string().describe('Todo text content'),
+        completed: z.boolean().describe('Completion status'),
+        order: z.number().describe('Sort order (0-based)'),
+    }))
+        .optional()
+        .describe('Replace all todos on this markdown node. Only markdown/text nodes support todos; code nodes do not. Each todo needs id, text, completed, and order fields.'),
 });
 const POSITION_FIELDS = ['x', 'y', 'width', 'height'];
+/**
+ * Compute migration fields when converting TO code type.
+ */
+function migrateToCode(node, params, fields) {
+    // Migrate content → code (unless code explicitly provided)
+    if (params.code === undefined && params.content === undefined) {
+        fields.code = node.content || '';
+    }
+    // Always clear content field when moving to code type
+    fields.content = null;
+}
+/**
+ * Compute migration fields when converting FROM code type.
+ */
+function migrateFromCode(node, params, fields) {
+    // Always clear code field
+    fields.code = null;
+    // Migrate code → content (unless content explicitly provided)
+    if (params.content === undefined && params.code === undefined) {
+        fields.content = node.code || '';
+    }
+}
+/**
+ * Validate and compute migration fields for a type change.
+ *
+ * Returns the fields that need to be set/unset to migrate content
+ * between node types, or an error if the conversion is unsafe.
+ */
+export function validateTypeChange(currentType, targetType, node, params) {
+    if (currentType === targetType) {
+        return { valid: true, fields: {} };
+    }
+    if (!isConvertibleType(currentType)) {
+        return {
+            valid: false,
+            error: `Cannot convert from '${currentType}' to '${targetType}'. Only markdown, code, and url types support conversion.`,
+        };
+    }
+    const fields = { type: targetType };
+    if (targetType === NodeType.URL && !params.url && !node.url) {
+        return {
+            valid: false,
+            error: `Converting to 'url' type requires a url field. Provide url parameter.`,
+        };
+    }
+    if (targetType === NodeType.Code) {
+        migrateToCode(node, params, fields);
+    }
+    else if (currentType === NodeType.Code) {
+        migrateFromCode(node, params, fields);
+    }
+    return { valid: true, fields };
+}
 /**
  * Add content fields to update data based on node type.
  */
@@ -61,15 +144,21 @@ function addContentFields(data, params, nodeType) {
 /**
  * Builds the update data object, mapping content/url to the correct field based on node type.
  * Code nodes store their content in `code`, url nodes use `url`, others use `content`.
+ *
+ * @param params - Update parameters from the tool call
+ * @param nodeType - The target node type (after any type change)
+ * @param migrationFields - Fields from type migration (type change, content migration)
  */
-function buildUpdateData(params, nodeType) {
-    const data = {};
+function buildUpdateData(params, nodeType, migrationFields = {}) {
+    const data = { ...migrationFields };
     if (params.name !== undefined)
         data.name = params.name;
     if (params.color !== undefined)
         data.color = params.color;
     if (params.targetBoardId !== undefined)
         data.board = params.targetBoardId;
+    if (params.todos !== undefined)
+        data.todos = params.todos;
     addContentFields(data, params, nodeType);
     for (const field of POSITION_FIELDS) {
         const value = params[field];
@@ -116,29 +205,55 @@ function formatSuccessResponse(node) {
         content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
     };
 }
+/**
+ * Process type change request and return migration context.
+ */
+function processTypeChange(currentNode, params) {
+    if (!params.type || params.type === currentNode.type) {
+        return { valid: true, fields: {}, targetType: currentNode.type };
+    }
+    const result = validateTypeChange(currentNode.type, params.type, currentNode, params);
+    if (!result.valid) {
+        return result;
+    }
+    return { valid: true, fields: result.fields, targetType: params.type };
+}
+/**
+ * Build params with auto-size dimensions applied.
+ */
+function applyAutoSize(params, autoSize) {
+    return {
+        ...params,
+        width: params.width !== undefined
+            ? params.width
+            : autoSize?.width !== undefined
+                ? pixelsToUnits(autoSize.width)
+                : undefined,
+        height: params.height !== undefined
+            ? params.height
+            : autoSize?.height !== undefined
+                ? pixelsToUnits(autoSize.height)
+                : undefined,
+    };
+}
 export async function handleUpdate(client, params) {
     try {
         const { node: currentNode, autoSize } = await getNodeContext(client, params);
-        const data = buildUpdateData({
-            ...params,
-            // Convert autoSize from pixels to units since buildUpdateData expects units
-            width: params.width !== undefined
-                ? params.width
-                : autoSize?.width !== undefined
-                    ? pixelsToUnits(autoSize.width)
-                    : undefined,
-            height: params.height !== undefined
-                ? params.height
-                : autoSize?.height !== undefined
-                    ? pixelsToUnits(autoSize.height)
-                    : undefined,
-        }, currentNode.type);
+        const typeChange = processTypeChange(currentNode, params);
+        if (!typeChange.valid) {
+            return {
+                content: [{ type: 'text', text: typeChange.error }],
+                isError: true,
+            };
+        }
+        const paramsWithSize = applyAutoSize(params, autoSize);
+        const data = buildUpdateData(paramsWithSize, typeChange.targetType, typeChange.fields);
         if (!data) {
             return {
                 content: [
                     {
                         type: 'text',
-                        text: `At least one field to update must be provided (name, content, url, color, x, y, width, height, targetBoardId).`,
+                        text: `At least one field to update must be provided (name, content, url, color, x, y, width, height, targetBoardId, type, todos).`,
                     },
                 ],
                 isError: true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mentagen/mcp",
-  "version": "0.6.0",
+  "version": "0.8.0",
   "description": "MCP server for Mentagen knowledge base integration with Cursor",
   "type": "module",
   "bin": "dist/index.js",
@@ -45,6 +45,6 @@
     "node": ">=18"
   },
   "resolutions": {
-    "tar": "7.5.3"
+    "tar": "^7.5.4"
   }
 }