roam-research-mcp 1.6.0 → 2.4.3

package/build/tools/operations/pages.js

@@ -1,8 +1,8 @@
-import { q, createPage as createRoamPage, batchActions, createBlock } from '@roam-research/roam-api-sdk';
+import { q, createPage as createRoamPage, batchActions, updatePage } from '@roam-research/roam-api-sdk';
 import { McpError, ErrorCode } from '@modelcontextprotocol/sdk/types.js';
 import { capitalizeWords } from '../helpers/text.js';
 import { resolveRefs } from '../helpers/refs.js';
-import { convertToRoamActions, convertToRoamMarkdown } from '../../markdown-utils.js';
+import { convertToRoamMarkdown, generateBlockUid } from '../../markdown-utils.js';
 import { pageUidCache } from '../../cache/page-uid-cache.js';
 import { buildTableActions } from './table.js';
 import { BatchOperations } from './batch.js';
@@ -135,137 +135,179 @@ export class PageOperations {
                     // Return success without adding duplicate content
                     return { success: true, uid: pageUid };
                 }
-                // Separate text content from table content, maintaining order
-                const textItems = [];
-                const tableItems = [];
-                for (let i = 0; i < content.length; i++) {
-                    const item = content[i];
-                    if (item.type === 'table') {
-                        tableItems.push({ index: i, item: item });
+                // Process content items in order, tracking position for correct placement
+                // Tables and text blocks are interleaved at their original positions
+                // Tables can be nested under text blocks based on their level
+                let currentOrder = 0;
+                let pendingTextItems = [];
+                // Track last block UID at each level for nesting tables
+                const levelToLastUid = {};
+                // Helper to assign UIDs to nodes and track level mapping
+                const assignUidsToNodes = (nodes) => {
+                    return nodes.map(node => {
+                        const uid = generateBlockUid();
+                        levelToLastUid[node.level] = uid;
+                        return {
+                            ...node,
+                            uid,
+                            children: assignUidsToNodes(node.children)
+                        };
+                    });
+                };
+                // Helper to build batch actions from nodes with pre-assigned UIDs
+                const buildActionsFromNodes = (nodes, parentUid, startOrder) => {
+                    const actions = [];
+                    for (let i = 0; i < nodes.length; i++) {
+                        const node = nodes[i];
+                        actions.push({
+                            action: 'create-block',
+                            location: { 'parent-uid': parentUid, order: startOrder + i },
+                            block: {
+                                uid: node.uid,
+                                string: node.content,
+                                ...(node.heading_level && { heading: node.heading_level })
+                            }
+                        });
+                        if (node.children.length > 0) {
+                            actions.push(...buildActionsFromNodes(node.children, node.uid, 0));
+                        }
                     }
-                    else {
-                        // Default to text type
-                        textItems.push(item);
+                    return actions;
+                };
+                // Helper to flush pending text items as a batch
+                const flushTextItems = async (startOrder) => {
+                    if (pendingTextItems.length === 0)
+                        return startOrder;
+                    // Filter out empty blocks
+                    const nonEmptyContent = pendingTextItems.filter(block => block.text && block.text.trim().length > 0);
+                    if (nonEmptyContent.length === 0) {
+                        pendingTextItems = [];
+                        return startOrder;
                     }
-                }
-                // Process text blocks
-                const allActions = [];
-                if (textItems.length > 0) {
-                    // Filter out empty blocks (empty or whitespace-only text) to prevent creating visual linebreaks
-                    const nonEmptyContent = textItems.filter(block => block.text && block.text.trim().length > 0);
-                    if (nonEmptyContent.length > 0) {
-                        // Normalize levels to prevent gaps after filtering
-                        const normalizedContent = [];
-                        for (let i = 0; i < nonEmptyContent.length; i++) {
-                            const block = nonEmptyContent[i];
-                            if (i === 0) {
-                                normalizedContent.push({ ...block, level: 1 });
-                            }
-                            else {
-                                const prevLevel = normalizedContent[i - 1].level;
-                                const maxAllowedLevel = prevLevel + 1;
-                                normalizedContent.push({
-                                    ...block,
-                                    level: Math.min(block.level, maxAllowedLevel)
-                                });
-                            }
+                    // Normalize levels to prevent gaps after filtering
+                    const normalizedContent = [];
+                    for (let i = 0; i < nonEmptyContent.length; i++) {
+                        const block = nonEmptyContent[i];
+                        if (i === 0) {
+                            normalizedContent.push({ ...block, level: 1 });
                         }
-                        // Convert content array to MarkdownNode format expected by convertToRoamActions
-                        const nodes = normalizedContent.map(block => ({
-                            content: convertToRoamMarkdown(block.text.replace(/^#+\s*/, '')),
-                            level: block.level,
-                            ...(block.heading && { heading_level: block.heading }),
-                            children: []
-                        }));
-                        // Create hierarchical structure based on levels
-                        const rootNodes = [];
-                        const levelMap = {};
-                        for (const node of nodes) {
-                            if (node.level === 1) {
-                                rootNodes.push(node);
-                                levelMap[1] = node;
-                            }
-                            else {
-                                const parentLevel = node.level - 1;
-                                const parent = levelMap[parentLevel];
-                                if (!parent) {
-                                    throw new Error(`Invalid block hierarchy: level ${node.level} block has no parent`);
-                                }
-                                parent.children.push(node);
-                                levelMap[node.level] = node;
+                        else {
+                            const prevLevel = normalizedContent[i - 1].level;
+                            const maxAllowedLevel = prevLevel + 1;
+                            normalizedContent.push({
+                                ...block,
+                                level: Math.min(block.level, maxAllowedLevel)
+                            });
+                        }
+                    }
+                    // Convert to node format with level info
+                    const nodes = normalizedContent.map(block => ({
+                        content: convertToRoamMarkdown(block.text.replace(/^#+\s*/, '')),
+                        level: block.level,
+                        ...(block.heading && { heading_level: block.heading }),
+                        children: []
+                    }));
+                    // Create hierarchical structure based on levels
+                    const rootNodes = [];
+                    const levelMap = {};
+                    for (const node of nodes) {
+                        if (node.level === 1) {
+                            rootNodes.push(node);
+                            levelMap[1] = node;
+                        }
+                        else {
+                            const parentLevel = node.level - 1;
+                            const parent = levelMap[parentLevel];
+                            if (!parent) {
+                                throw new Error(`Invalid block hierarchy: level ${node.level} block has no parent`);
                             }
+                            parent.children.push(node);
+                            levelMap[node.level] = node;
                         }
-                        // Generate batch actions for text blocks
-                        const textActions = convertToRoamActions(rootNodes, pageUid, 'last');
-                        allActions.push(...textActions);
                     }
-                }
-                // Execute text block actions first (no placeholders, use SDK directly)
-                if (allActions.length > 0) {
-                    const batchResult = await batchActions(this.graph, {
-                        action: 'batch-actions',
-                        actions: allActions
-                    });
-                    if (!batchResult) {
-                        throw new Error('Failed to create text blocks');
+                    // Assign UIDs to all nodes and track level->UID mapping
+                    const nodesWithUids = assignUidsToNodes(rootNodes);
+                    // Build batch actions from nodes with UIDs
+                    const textActions = buildActionsFromNodes(nodesWithUids, pageUid, startOrder);
+                    if (textActions.length > 0) {
+                        const batchResult = await batchActions(this.graph, {
+                            action: 'batch-actions',
+                            actions: textActions
+                        });
+                        if (!batchResult) {
+                            throw new Error('Failed to create text blocks');
+                        }
                     }
-                }
-                // Process table items separately (use BatchOperations to handle UID placeholders)
-                for (const { item } of tableItems) {
-                    const tableActions = buildTableActions({
-                        parent_uid: pageUid,
-                        headers: item.headers,
-                        rows: item.rows,
-                        order: 'last'
-                    });
-                    // Use BatchOperations.processBatch to handle {{uid:*}} placeholders
-                    const tableResult = await this.batchOps.processBatch(tableActions);
-                    if (!tableResult.success) {
-                        throw new Error(`Failed to create table: ${typeof tableResult.error === 'string' ? tableResult.error : tableResult.error?.message}`);
+                    // Return the next order position (number of root-level blocks added)
+                    const nextOrder = startOrder + rootNodes.length;
+                    pendingTextItems = [];
+                    return nextOrder;
+                };
+                // Process content items in order
+                for (let i = 0; i < content.length; i++) {
+                    const item = content[i];
+                    if (item.type === 'table') {
+                        // Flush any pending text items first
+                        currentOrder = await flushTextItems(currentOrder);
+                        // Process table - determine parent based on level
+                        const tableItem = item;
+                        const tableLevel = tableItem.level || 1;
+                        let tableParentUid = pageUid;
+                        let tableOrder = currentOrder;
+                        if (tableLevel > 1) {
+                            // Nested table - find parent block at level-1
+                            const parentLevel = tableLevel - 1;
+                            if (levelToLastUid[parentLevel]) {
+                                tableParentUid = levelToLastUid[parentLevel];
+                                tableOrder = 'last'; // Append to parent's children
+                            }
+                            // If no parent found, fall back to page level
+                        }
+                        const tableActions = buildTableActions({
+                            parent_uid: tableParentUid,
+                            headers: tableItem.headers,
+                            rows: tableItem.rows,
+                            order: tableOrder
+                        });
+                        const tableResult = await this.batchOps.processBatch(tableActions);
+                        if (!tableResult.success) {
+                            throw new Error(`Failed to create table: ${typeof tableResult.error === 'string' ? tableResult.error : tableResult.error?.message}`);
+                        }
+                        // Only increment top-level order for level 1 tables
+                        if (tableLevel === 1) {
+                            currentOrder++;
+                        }
+                    }
+                    else {
+                        // Accumulate text items
+                        pendingTextItems.push(item);
                     }
                 }
+                // Flush any remaining text items
+                await flushTextItems(currentOrder);
             }
             catch (error) {
                 throw new McpError(ErrorCode.InternalError, `Failed to add content to page: ${error instanceof Error ? error.message : String(error)}`);
             }
         }
-        // Add a link to the created page on today's daily page
+        // Add a "Processed: [[date]]" block as the last block of the newly created page
         try {
             const today = new Date();
             const day = today.getDate();
             const month = today.toLocaleString('en-US', { month: 'long' });
             const year = today.getFullYear();
             const formattedTodayTitle = `${month} ${day}${getOrdinalSuffix(day)}, ${year}`;
-            // Check cache for daily page
-            let dailyPageUid = pageUidCache.get(formattedTodayTitle);
-            if (!dailyPageUid) {
-                const dailyPageQuery = `[:find ?uid .
-                                :where [?e :node/title "${formattedTodayTitle}"]
-                                       [?e :block/uid ?uid]]`;
-                const dailyPageResult = await q(this.graph, dailyPageQuery, []);
-                dailyPageUid = dailyPageResult ? String(dailyPageResult) : undefined;
-                if (dailyPageUid) {
-                    pageUidCache.set(formattedTodayTitle, dailyPageUid);
-                }
-            }
-            if (dailyPageUid) {
-                await createBlock(this.graph, {
-                    action: 'create-block',
-                    block: {
-                        string: `Created page: [[${pageTitle}]]`
-                    },
-                    location: {
-                        'parent-uid': dailyPageUid,
-                        order: 'last'
-                    }
-                });
-            }
-            else {
-                console.warn(`Could not find daily page with title: ${formattedTodayTitle}. Link to created page not added.`);
-            }
+            await batchActions(this.graph, {
+                action: 'batch-actions',
+                actions: [{
+                        action: 'create-block',
+                        location: { 'parent-uid': pageUid, order: 'last' },
+                        block: { string: `Processed: [[${formattedTodayTitle}]]` }
+                    }]
+            });
         }
         catch (error) {
-            console.error(`Failed to add link to daily page: ${error instanceof Error ? error.message : String(error)}`);
+            console.error(`Failed to add Processed block: ${error instanceof Error ? error.message : String(error)}`);
         }
         return { success: true, uid: pageUid };
     }
@@ -505,4 +547,37 @@ export class PageOperations {
             summary: dryRun ? `[DRY RUN] ${summary}` : summary
         };
     }
+    /**
+     * Rename a page by updating its title
+     */
+    async renamePage(params) {
+        const { old_title, uid, new_title } = params;
+        if (!old_title && !uid) {
+            throw new McpError(ErrorCode.InvalidParams, 'Either old_title or uid must be provided to identify the page');
+        }
+        // Build the page identifier
+        const pageIdentifier = uid ? { uid } : { title: old_title };
+        try {
+            const success = await updatePage(this.graph, {
+                page: pageIdentifier,
+                title: new_title
+            });
+            if (success) {
+                const identifier = uid ? `((${uid}))` : `"${old_title}"`;
+                return {
+                    success: true,
+                    message: `Renamed ${identifier} → "${new_title}"`
+                };
+            }
+            else {
+                return {
+                    success: false,
+                    message: 'Failed to rename page (API returned false)'
+                };
+            }
+        }
+        catch (error) {
+            throw new McpError(ErrorCode.InternalError, `Failed to rename page: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
 }

package/build/tools/operations/search/index.js

@@ -1,4 +1,4 @@
-import { TagSearchHandlerImpl, BlockRefSearchHandlerImpl, HierarchySearchHandlerImpl, TextSearchHandlerImpl, StatusSearchHandlerImpl } from './handlers.js';
+import { TagSearchHandlerImpl, BlockRefSearchHandlerImpl, HierarchySearchHandlerImpl, TextSearchHandlerImpl, StatusSearchHandlerImpl, DatomicSearchHandlerImpl } from './handlers.js';
 export class SearchOperations {
     constructor(graph) {
         this.graph = graph;
@@ -57,6 +57,10 @@ export class SearchOperations {
         const handler = new TextSearchHandlerImpl(this.graph, params);
         return handler.execute();
     }
+    async executeDatomicQuery(params) {
+        const handler = new DatomicSearchHandlerImpl(this.graph, params);
+        return handler.execute();
+    }
     async searchByDate(params) {
         // Convert dates to timestamps
         const startTimestamp = new Date(`${params.start_date}T00:00:00`).getTime();

package/build/tools/operations/todos.js

@@ -37,7 +37,7 @@ export class TodoOperations {
                 throw new Error('Failed to create today\'s page');
             }
         }
-        const todo_tag = "{{TODO}}";
+        const todo_tag = "{{[[TODO]]}}";
         const actions = todos.map((todo, index) => ({
             action: 'create-block',
             location: {