@mentagen/mcp 0.8.0 → 0.8.2

package/dist/client/bifrost.js

@@ -0,0 +1,197 @@
+import { randomUUID } from 'crypto';
+/**
+ * Lightweight HTTP client for Mentagen's Bifrost API.
+ *
+ * Uses the HTTP transport endpoint (/__h) to call server methods.
+ * Bifrost expects text/plain with a specific payload/context structure.
+ */
+export class MentagenClient {
+    baseUrl;
+    token;
+    constructor(config) {
+        this.baseUrl = config.mentagenUrl.replace(/\/$/, '');
+        this.token = config.token;
+    }
+    /**
+     * Call a Bifrost method via HTTP.
+     *
+     * Bifrost's HTTP transport expects:
+     * - Content-Type: text/plain
+     * - Body: JSON with { payload: { uuid, method, params }, context: { token } }
+     */
+    async call(method, params = {}) {
+        const url = `${this.baseUrl}/__h`;
+        const body = JSON.stringify({
+            payload: {
+                uuid: randomUUID(),
+                method,
+                params,
+            },
+            context: {
+                token: this.token,
+            },
+        });
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'text/plain',
+            },
+            body,
+        });
+        if (!response.ok) {
+            const text = await response.text();
+            throw new Error(`HTTP ${response.status}: ${text}`);
+        }
+        const data = (await response.json());
+        if (data.type === 'error' || data.error) {
+            const errorMsg = data.message ||
+                (typeof data.error === 'string' ? data.error : data.error?.message);
+            throw new Error(errorMsg || 'Unknown error');
+        }
+        return data.result;
+    }
+    /**
+     * Verify the token and get the current user.
+     */
+    async getCurrentUser() {
+        try {
+            return await this.call('user.current');
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * List boards the user has access to.
+     */
+    async listBoards(params) {
+        return this.call('boards.listSimple', {
+            orgId: params?.orgId,
+        });
+    }
+    /**
+     * Search boards by name.
+     */
+    async searchBoards(query, limit = 20) {
+        const result = await this.call('boards.search', {
+            query,
+            limit,
+        });
+        return result.data || [];
+    }
+    /**
+     * Search nodes using hybrid semantic/keyword search.
+     */
+    async searchNodes(params) {
+        return this.call('boards.searchNodesText', params);
+    }
+    /**
+     * List organizations the user has access to.
+     */
+    async listOrganizations() {
+        return this.call('org.list', {});
+    }
+    /**
+     * List teams within an organization.
+     */
+    async listTeams(params) {
+        return this.call('team.list', params);
+    }
+    /**
+     * Add a new node to a board.
+     */
+    async addNode(params) {
+        return this.call('boards.addNode', params);
+    }
+    /**
+     * Update a node's properties.
+     */
+    async updateNode(params) {
+        return this.call('boards.updateNode', params);
+    }
+    /**
+     * Get a single node by ID.
+     * Uses getNodeForMcp which excludes large fields (chat, textDetections, _vectors)
+     * in favor of their computed alternatives (chatConcatenated, textDetectionsConcatenated).
+     */
+    async getNode(params) {
+        return this.call('boards.getNodeForMcp', params);
+    }
+    /**
+     * List all nodes in a board (basic fields only).
+     */
+    async listNodes(params) {
+        return this.call('boards.listNodesSimple', params);
+    }
+    /**
+     * List all nodes with full content fields for extraction.
+     * Includes: content, code, chatConcatenated, textDetectionsConcatenated, pdfText, article
+     * Note: Uses computed fields instead of raw chat/textDetections.
+     */
+    async listNodesWithContent(params) {
+        return this.call('boards.listNodesWithContent', params);
+    }
+    /**
+     * Soft-delete a node.
+     */
+    async deleteNode(params) {
+        await this.call('boards.deleteNode', params);
+    }
+    /**
+     * Create a new board.
+     */
+    async createBoard(params) {
+        return this.call('boards.create', params);
+    }
+    /**
+     * Get a single board by ID.
+     */
+    async getBoard(params) {
+        return this.call('boards.get', params);
+    }
+    /**
+     * Update a board's properties.
+     */
+    async updateBoard(params) {
+        return this.call('boards.update', params);
+    }
+    /**
+     * Soft-delete a board.
+     */
+    async deleteBoard(params) {
+        await this.call('boards.deleteBoard', params);
+    }
+    /**
+     * Add an edge between two nodes.
+     */
+    async addEdge(params) {
+        return this.call('boards.addEdge', params);
+    }
+    /**
+     * List all edges in a board.
+     */
+    async listEdges(params) {
+        return this.call('boards.listEdgesSimple', params);
+    }
+    /**
+     * Update an edge's metadata (direction and/or label).
+     */
+    async updateEdge(params) {
+        return this.call('boards.updateEdgeMetadata', params);
+    }
+    /**
+     * Soft-delete an edge.
+     */
+    async deleteEdge(params) {
+        await this.call('boards.deleteEdge', params);
+    }
+}
+export async function createMentagenClient(config) {
+    const client = new MentagenClient(config);
+    const user = await client.getCurrentUser();
+    if (!user) {
+        throw new Error('Authentication failed. Please check your MENTAGEN_TOKEN.\n' +
+            'Generate a new token in Mentagen Settings > Developer if needed.');
+    }
+    return client;
+}

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { createMentagenClient } from './client/helene.js';
+import { createMentagenClient } from './client/bifrost.js';
 import { registerPrompts } from './prompts/index.js';
 import { registerResources } from './resources/index.js';
 import { registerTools } from './tools/index.js';

package/dist/tools/extract-board-content.js

@@ -41,6 +41,16 @@ function stripHtml(html) {
         .replace(/'/g, "'")
         .trim();
 }
+/**
+ * Format todos as markdown checkboxes.
+ */
+function formatTodos(todos) {
+    if (!todos || todos.length === 0)
+        return '';
+    const sorted = [...todos].sort((a, b) => a.order - b.order);
+    const lines = sorted.map(t => `- [${t.completed ? 'x' : ' '}] ${t.text}`);
+    return lines.join('\n');
+}
 /**
  * Infer programming language from file extension.
  */
@@ -121,6 +131,7 @@ function formatContent(node) {
  */
 function formatNodeSection(node, baseUrl, boardId) {
     const content = formatContent(node);
+    const todos = formatTodos(node.todos);
     const link = getNodeUrl(baseUrl, boardId, node._id);
     const lines = [
         `## ${node.name}`,
@@ -128,6 +139,12 @@ function formatNodeSection(node, baseUrl, boardId) {
         '',
         content,
     ];
+    // Add todos section if present
+    if (todos) {
+        if (content)
+            lines.push('', '### Todos', '');
+        lines.push(todos);
+    }
     return lines.join('\n');
 }
 export async function handleExtractBoardContent(client, params, baseUrl) {
@@ -150,12 +167,13 @@ export async function handleExtractBoardContent(client, params, baseUrl) {
                 ],
             };
         }
-        // Filter nodes based on content
+        // Filter nodes based on content or todos
         const nodesWithContent = params.includeEmpty
             ? nodes
             : nodes.filter(n => {
                 const content = getNodeContent(n);
-                return content && content.trim().length > 0;
+                const hasTodos = n.todos && n.todos.length > 0;
+                return (content && content.trim().length > 0) || hasTodos;
             });
         if (nodesWithContent.length === 0) {
             return {

package/dist/tools/list-nodes.js

@@ -23,6 +23,13 @@ function truncateContent(content, maxLength) {
     return ((lastSpace > maxLength * 0.7 ? truncated.slice(0, lastSpace) : truncated) +
         '...');
 }
+/** Format todos as "completed/total" or empty string if no todos. */
+function formatTodoCounts(todos) {
+    if (!todos || todos.length === 0)
+        return '';
+    const completed = todos.filter(t => t.completed).length;
+    return `${completed}/${todos.length}`;
+}
 function formatNodesTsv(nodes) {
     const rows = nodes.map(n => ({
         id: n._id,
@@ -33,6 +40,7 @@ function formatNodesTsv(nodes) {
         width: pixelsToUnits(n.width),
         height: pixelsToUnits(n.height),
         content: truncateContent(n.content ?? null, MAX_CONTENT_LENGTH),
+        todos: formatTodoCounts(n.todos),
         updatedAt: formatDate(n.updatedAt),
         link: n.link,
     }));
@@ -49,6 +57,7 @@ function formatNodesTsv(nodes) {
             'width',
             'height',
             'content',
+            'todos',
             'updatedAt',
             'link',
         ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mentagen/mcp",
-  "version": "0.8.0",
+  "version": "0.8.2",
   "description": "MCP server for Mentagen knowledge base integration with Cursor",
   "type": "module",
   "bin": "dist/index.js",