roam-research-mcp 0.18.0 → 0.19.0

package/README.md

@@ -335,7 +335,7 @@ Search for blocks containing specific text across all pages or within a specific
 use_mcp_tool roam-research roam_search_by_text {
   "text": "search text",
   "page_title_uid": "optional-page-title-or-uid",
-  "case_sensitive": false
+  "case_sensitive": true
 }
 ```
 
@@ -351,7 +351,7 @@ Parameters:
 
 - `text`: The text to search for (required)
 - `page_title_uid`: Title or UID of the page to search in (optional)
-- `case_sensitive`: Whether to perform a case-sensitive search (optional, default: false)
+- `case_sensitive`: Whether to perform a case-sensitive search (optional, default: true to match Roam's native behavior)
 
 Returns:
 

package/build/server/roam-server.js

@@ -35,6 +35,7 @@ export class RoamServer {
                     find_pages_modified_today: {},
                     roam_search_by_text: {},
                     roam_update_block: {},
+                    roam_update_blocks: {},
                     roam_search_by_date: {}
                 },
             },
@@ -166,6 +167,13 @@ export class RoamServer {
                             content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
                         };
                     }
+                    case 'roam_update_blocks': {
+                        const { updates } = request.params.arguments;
+                        const result = await this.toolHandlers.updateBlocks(updates);
+                        return {
+                            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                        };
+                    }
                     default:
                         throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${request.params.name}`);
                 }

package/build/tools/schemas.js

@@ -2,7 +2,7 @@
 export const toolSchemas = {
     roam_add_todo: {
         name: 'roam_add_todo',
-        description: 'Add a list of todo items as individual blocks to today\'s daily page in Roam. Each item becomes its own actionable block with todo status.',
+        description: 'Add a list of todo items as individual blocks to today\'s daily page in Roam. Each item becomes its own actionable block with todo status.\nNOTE on Roam-flavored markdown: For direct linking: use [[link]] syntax. For aliased linking, use [alias]([[link]]) syntax. Do not concatenate words in links/hashtags - correct: #[[multiple words]] #self-esteem (for typically hyphenated words).',
         inputSchema: {
             type: 'object',
             properties: {
@@ -52,7 +52,7 @@ export const toolSchemas = {
     },
     roam_create_block: {
         name: 'roam_create_block',
-        description: 'Add a new block to an existing Roam page. If no page specified, adds to today\'s daily note. Best for capturing immediate thoughts, additions to discussions, or content that doesn\'t warrant its own page. Can specify page by title or UID.',
+        description: 'Add a new block to an existing Roam page. If no page specified, adds to today\'s daily note. Best for capturing immediate thoughts, additions to discussions, or content that doesn\'t warrant its own page. Can specify page by title or UID.\nNOTE on Roam-flavored markdown: For direct linking: use [[link]] syntax. For aliased linking, use [alias]([[link]]) syntax. Do not concatenate words in links/hashtags - correct: #[[multiple words]] #self-esteem (for typically hyphenated words).',
         inputSchema: {
             type: 'object',
             properties: {
@@ -161,6 +161,11 @@ export const toolSchemas = {
                 near_tag: {
                     type: 'string',
                     description: 'Optional: Another tag to filter results by - will only return blocks where both tags appear',
+                },
+                case_sensitive: {
+                    type: 'boolean',
+                    description: 'Optional: Whether to perform case-sensitive matching (default: true, matching Roam\'s native behavior)',
+                    default: true
                 }
             },
             required: ['primary_tag']
@@ -188,6 +193,11 @@ export const toolSchemas = {
                 exclude: {
                     type: 'string',
                     description: 'Optional: Comma-separated list of terms to filter results by exclusion (matches content or page title)'
+                },
+                case_sensitive: {
+                    type: 'boolean',
+                    description: 'Optional: Whether to perform case-sensitive matching (default: true, matching Roam\'s native behavior)',
+                    default: true
                 }
             },
             required: ['status']
@@ -266,7 +276,8 @@ export const toolSchemas = {
                 },
                 case_sensitive: {
                     type: 'boolean',
-                    description: 'Optional: Whether to perform a case-sensitive search (default: false)'
+                    description: 'Optional: Whether to perform case-sensitive search (default: true, matching Roam\'s native behavior)',
+                    default: true
                 }
             },
             required: ['text']
@@ -274,7 +285,7 @@ export const toolSchemas = {
     },
     roam_update_block: {
         name: 'roam_update_block',
-        description: 'Update the content of an existing block identified by its UID. Can either provide new content directly or use a transform pattern to modify existing content.',
+        description: 'Update the content of an existing block identified by its UID. Can either provide new content directly or use a transform pattern to modify existing content.\nNOTE on Roam-flavored markdown: For direct linking: use [[link]] syntax. For aliased linking, use [alias]([[link]]) syntax. Do not concatenate words in links/hashtags - correct: #[[multiple words]] #self-esteem (for typically hyphenated words).',
         inputSchema: {
             type: 'object',
             properties: {
@@ -314,6 +325,58 @@ export const toolSchemas = {
             ]
         }
     },
+    roam_update_blocks: {
+        name: 'roam_update_blocks',
+        description: 'Update multiple blocks in a single batch operation. Each update can provide either new content directly or a transform pattern.\nNOTE on Roam-flavored markdown: For direct linking: use [[link]] syntax. For aliased linking, use [alias]([[link]]) syntax. Do not concatenate words in links/hashtags - correct: #[[multiple words]] #self-esteem (for typically hyphenated words).',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                updates: {
+                    type: 'array',
+                    description: 'Array of block updates to perform',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            block_uid: {
+                                type: 'string',
+                                description: 'UID of the block to update'
+                            },
+                            content: {
+                                type: 'string',
+                                description: 'New content for the block. If not provided, transform will be used.'
+                            },
+                            transform: {
+                                type: 'object',
+                                description: 'Pattern to transform the current content. Used if content is not provided.',
+                                properties: {
+                                    find: {
+                                        type: 'string',
+                                        description: 'Text or regex pattern to find'
+                                    },
+                                    replace: {
+                                        type: 'string',
+                                        description: 'Text to replace with'
+                                    },
+                                    global: {
+                                        type: 'boolean',
+                                        description: 'Whether to replace all occurrences',
+                                        default: true
+                                    }
+                                },
+                                required: ['find', 'replace']
+                            }
+                        },
+                        required: ['block_uid'],
+                        oneOf: [
+                            { required: ['content'] },
+                            { required: ['transform'] }
+                        ]
+                    }
+                }
+            },
+            required: ['updates']
+        }
+    },
     roam_search_by_date: {
         name: 'roam_search_by_date',
         description: 'Search for blocks or pages based on creation or modification dates',
@@ -342,6 +405,11 @@ export const toolSchemas = {
                     type: 'boolean',
                     description: 'Whether to include the content of matching blocks/pages',
                     default: true,
+                },
+                case_sensitive: {
+                    type: 'boolean',
+                    description: 'Optional: Whether to perform case-sensitive matching (default: true, matching Roam\'s native behavior)',
+                    default: true
                 }
             },
             required: ['start_date', 'type', 'scope']

package/build/tools/tool-handlers.js

@@ -157,21 +157,23 @@ export class ToolHandlers {
         // Get or create the target page
         const targetPageUid = await findOrCreatePage(page_title_uid || formatRoamDate(new Date()));
         // Helper function to find block with improved relationship checks
-        const findBlockWithRetry = async (pageUid, blockString, maxRetries = 5, initialDelay = 1000) => {
+        const findBlockWithRetry = async (pageUid, blockString, maxRetries = 5, initialDelay = 1000, case_sensitive = false) => {
             // Try multiple query strategies
             const queries = [
                 // Strategy 1: Direct page and string match
                 `[:find ?b-uid ?order
           :where [?p :block/uid "${pageUid}"]
                  [?b :block/page ?p]
-                 [?b :block/string "${blockString}"]
+                 [?b :block/string ?block-str]
+                 [(${case_sensitive ? '=' : 'clojure.string/equals-ignore-case'} ?block-str "${blockString}")]
                  [?b :block/order ?order]
                  [?b :block/uid ?b-uid]]`,
                 // Strategy 2: Parent-child relationship
                 `[:find ?b-uid ?order
           :where [?p :block/uid "${pageUid}"]
                  [?b :block/parents ?p]
-                 [?b :block/string "${blockString}"]
+                 [?b :block/string ?block-str]
+                 [(${case_sensitive ? '=' : 'clojure.string/equals-ignore-case'} ?block-str "${blockString}")]
                  [?b :block/order ?order]
                  [?b :block/uid ?b-uid]]`,
                 // Strategy 3: Broader page relationship
@@ -179,7 +181,8 @@ export class ToolHandlers {
           :where [?p :block/uid "${pageUid}"]
                  [?b :block/page ?page]
                  [?p :block/page ?page]
-                 [?b :block/string "${blockString}"]
+                 [?b :block/string ?block-str]
+                 [(${case_sensitive ? '=' : 'clojure.string/equals-ignore-case'} ?block-str "${blockString}")]
                  [?b :block/order ?order]
                  [?b :block/uid ?b-uid]]`
             ];
@@ -201,7 +204,7 @@ export class ToolHandlers {
             throw new McpError(ErrorCode.InternalError, `Failed to find block "${blockString}" under page "${pageUid}" after trying multiple strategies`);
         };
         // Helper function to create and verify block with improved error handling
-        const createAndVerifyBlock = async (content, parentUid, maxRetries = 5, initialDelay = 1000, isRetry = false) => {
+        const createAndVerifyBlock = async (content, parentUid, maxRetries = 5, initialDelay = 1000, isRetry = false, case_sensitive = false) => {
             try {
                 // Initial delay before any operations
                 if (!isRetry) {
@@ -223,7 +226,7 @@ export class ToolHandlers {
                     await new Promise(resolve => setTimeout(resolve, delay));
                     try {
                         // Try to find the block using our improved findBlockWithRetry
-                        return await findBlockWithRetry(parentUid, content);
+                        return await findBlockWithRetry(parentUid, content, maxRetries, initialDelay, case_sensitive);
                     }
                     catch (error) {
                         const errorMessage = error instanceof Error ? error.message : String(error);
@@ -241,7 +244,7 @@ export class ToolHandlers {
                 // Otherwise, try one more time with a clean slate
                 console.log(`Retrying block creation for "${content}" with fresh attempt`);
                 await new Promise(resolve => setTimeout(resolve, initialDelay * 2));
-                return createAndVerifyBlock(content, parentUid, maxRetries, initialDelay, true);
+                return createAndVerifyBlock(content, parentUid, maxRetries, initialDelay, true, case_sensitive);
             }
         };
         // Get or create the parent block
@@ -728,7 +731,110 @@ export class ToolHandlers {
             throw new McpError(ErrorCode.InternalError, `Failed to update block: ${error.message}`);
         }
     }
-    async searchByStatus(status, page_title_uid, include, exclude) {
+    async updateBlocks(updates) {
+        if (!Array.isArray(updates) || updates.length === 0) {
+            throw new McpError(ErrorCode.InvalidRequest, 'updates must be a non-empty array');
+        }
+        // Validate each update has required fields
+        updates.forEach((update, index) => {
+            if (!update.block_uid) {
+                throw new McpError(ErrorCode.InvalidRequest, `Update at index ${index} missing block_uid`);
+            }
+            if (!update.content && !update.transform) {
+                throw new McpError(ErrorCode.InvalidRequest, `Update at index ${index} must have either content or transform`);
+            }
+        });
+        // Get current content for all blocks
+        const blockUids = updates.map(u => u.block_uid);
+        const blockQuery = `[:find ?uid ?string
+                        :in $ [?uid ...]
+                        :where [?b :block/uid ?uid]
+                               [?b :block/string ?string]]`;
+        const blockResults = await q(this.graph, blockQuery, [blockUids]);
+        // Create map of uid -> current content
+        const contentMap = new Map();
+        blockResults.forEach(([uid, string]) => {
+            contentMap.set(uid, string);
+        });
+        // Prepare batch actions
+        const actions = [];
+        const results = [];
+        for (const update of updates) {
+            try {
+                const currentContent = contentMap.get(update.block_uid);
+                if (!currentContent) {
+                    results.push({
+                        block_uid: update.block_uid,
+                        content: '',
+                        success: false,
+                        error: `Block with UID "${update.block_uid}" not found`
+                    });
+                    continue;
+                }
+                // Determine new content
+                let newContent;
+                if (update.content) {
+                    newContent = update.content;
+                }
+                else if (update.transform) {
+                    const regex = new RegExp(update.transform.find, update.transform.global ? 'g' : '');
+                    newContent = currentContent.replace(regex, update.transform.replace);
+                }
+                else {
+                    // This shouldn't happen due to earlier validation
+                    throw new Error('Invalid update configuration');
+                }
+                // Add to batch actions
+                actions.push({
+                    action: 'update-block',
+                    block: {
+                        uid: update.block_uid,
+                        string: newContent
+                    }
+                });
+                results.push({
+                    block_uid: update.block_uid,
+                    content: newContent,
+                    success: true
+                });
+            }
+            catch (error) {
+                results.push({
+                    block_uid: update.block_uid,
+                    content: contentMap.get(update.block_uid) || '',
+                    success: false,
+                    error: error.message
+                });
+            }
+        }
+        // Execute batch update if we have any valid actions
+        if (actions.length > 0) {
+            try {
+                const batchResult = await batchActions(this.graph, {
+                    action: 'batch-actions',
+                    actions
+                });
+                if (!batchResult) {
+                    throw new Error('Batch update failed');
+                }
+            }
+            catch (error) {
+                // Mark all previously successful results as failed
+                results.forEach(result => {
+                    if (result.success) {
+                        result.success = false;
+                        result.error = `Batch update failed: ${error.message}`;
+                    }
+                });
+            }
+        }
+        return {
+            success: results.every(r => r.success),
+            results
+        };
+    }
+    async searchByStatus(status, page_title_uid, include, exclude, case_sensitive = true // Changed to true to match Roam's behavior
+    ) {
         // Get target page UID if provided
         let targetPageUid;
         if (page_title_uid) {
@@ -789,16 +895,26 @@ export class ToolHandlers {
                 ...(pageTitle && { page_title: pageTitle })
             };
         });
-        // Post-query filtering
+        // Post-query filtering with case sensitivity option
         if (include) {
-            const includeTerms = include.toLowerCase().split(',').map(term => term.trim());
-            matches = matches.filter(match => includeTerms.some(term => match.content.toLowerCase().includes(term) ||
-                (match.page_title && match.page_title.toLowerCase().includes(term))));
+            const includeTerms = include.split(',').map(term => term.trim());
+            matches = matches.filter(match => {
+                const matchContent = case_sensitive ? match.content : match.content.toLowerCase();
+                const matchTitle = match.page_title && (case_sensitive ? match.page_title : match.page_title.toLowerCase());
+                const terms = case_sensitive ? includeTerms : includeTerms.map(t => t.toLowerCase());
+                return terms.some(term => matchContent.includes(case_sensitive ? term : term.toLowerCase()) ||
+                    (matchTitle && matchTitle.includes(case_sensitive ? term : term.toLowerCase())));
+            });
         }
         if (exclude) {
-            const excludeTerms = exclude.toLowerCase().split(',').map(term => term.trim());
-            matches = matches.filter(match => !excludeTerms.some(term => match.content.toLowerCase().includes(term) ||
-                (match.page_title && match.page_title.toLowerCase().includes(term))));
+            const excludeTerms = exclude.split(',').map(term => term.trim());
+            matches = matches.filter(match => {
+                const matchContent = case_sensitive ? match.content : match.content.toLowerCase();
+                const matchTitle = match.page_title && (case_sensitive ? match.page_title : match.page_title.toLowerCase());
+                const terms = case_sensitive ? excludeTerms : excludeTerms.map(t => t.toLowerCase());
+                return !terms.some(term => matchContent.includes(case_sensitive ? term : term.toLowerCase()) ||
+                    (matchTitle && matchTitle.includes(case_sensitive ? term : term.toLowerCase())));
+            });
         }
         return {
             success: true,
@@ -806,7 +922,8 @@ export class ToolHandlers {
             message: `Found ${matches.length} block(s) with status ${status}${include ? ` including "${include}"` : ''}${exclude ? ` excluding "${exclude}"` : ''}`
         };
     }
-    async searchForTag(primary_tag, page_title_uid, near_tag) {
+    async searchForTag(primary_tag, page_title_uid, near_tag, case_sensitive = true // Changed to true to match Roam's behavior
+    ) {
         // Ensure tags are properly formatted with #
         const formatTag = (tag) => tag.startsWith('#') ? tag : `#${tag}`;
         const primaryTagFormatted = formatTag(primary_tag);
@@ -841,8 +958,12 @@ export class ToolHandlers {
                            [?b :block/page ?p]
                            [?b :block/string ?block-str]
                            [?b :block/uid ?block-uid]
-                           [(clojure.string/includes? ?block-str ?primary-tag)]
-                           [(clojure.string/includes? ?block-str ?near-tag)]]`;
+                           [(clojure.string/includes? 
+                             ${case_sensitive ? '?block-str' : '(clojure.string/lower-case ?block-str)'} 
+                             ${case_sensitive ? '?primary-tag' : '(clojure.string/lower-case ?primary-tag)'})]
+                           [(clojure.string/includes? 
+                             ${case_sensitive ? '?block-str' : '(clojure.string/lower-case ?block-str)'} 
+                             ${case_sensitive ? '?near-tag' : '(clojure.string/lower-case ?near-tag)'})]`;
                 queryParams = [primaryTagFormatted, nearTagFormatted, targetPageUid];
             }
             else {
@@ -852,7 +973,9 @@ export class ToolHandlers {
                            [?b :block/page ?p]
                            [?b :block/string ?block-str]
                            [?b :block/uid ?block-uid]
-                           [(clojure.string/includes? ?block-str ?primary-tag)]]`;
+                           [(clojure.string/includes? 
+                             ${case_sensitive ? '?block-str' : '(clojure.string/lower-case ?block-str)'} 
+                             ${case_sensitive ? '?primary-tag' : '(clojure.string/lower-case ?primary-tag)'})]`;
                 queryParams = [primaryTagFormatted, targetPageUid];
             }
         }
@@ -865,8 +988,12 @@ export class ToolHandlers {
                            [?b :block/uid ?block-uid]
                            [?b :block/page ?p]
                            [?p :node/title ?page-title]
-                           [(clojure.string/includes? ?block-str ?primary-tag)]
-                           [(clojure.string/includes? ?block-str ?near-tag)]]`;
+                           [(clojure.string/includes? 
+                             ${case_sensitive ? '?block-str' : '(clojure.string/lower-case ?block-str)'} 
+                             ${case_sensitive ? '?primary-tag' : '(clojure.string/lower-case ?primary-tag)'})]
+                           [(clojure.string/includes? 
+                             ${case_sensitive ? '?block-str' : '(clojure.string/lower-case ?block-str)'} 
+                             ${case_sensitive ? '?near-tag' : '(clojure.string/lower-case ?near-tag)'})]`;
                 queryParams = [primaryTagFormatted, nearTagFormatted];
             }
             else {
@@ -876,7 +1003,9 @@ export class ToolHandlers {
                            [?b :block/uid ?block-uid]
                            [?b :block/page ?p]
                            [?p :node/title ?page-title]
-                           [(clojure.string/includes? ?block-str ?primary-tag)]]`;
+                           [(clojure.string/includes? 
+                             ${case_sensitive ? '?block-str' : '(clojure.string/lower-case ?block-str)'} 
+                             ${case_sensitive ? '?primary-tag' : '(clojure.string/lower-case ?primary-tag)'})]`;
                 queryParams = [primaryTagFormatted];
             }
         }
@@ -945,6 +1074,20 @@ export class ToolHandlers {
             ...(params.include_content && { content }),
             page_title: pageTitle
         }));
+        // Apply case sensitivity if content is included
+        if (params.include_content) {
+            const case_sensitive = params.case_sensitive ?? true; // Default to true to match Roam's behavior
+            if (!case_sensitive) {
+                matches.forEach(match => {
+                    if (match.content) {
+                        match.content = match.content.toLowerCase();
+                    }
+                    if (match.page_title) {
+                        match.page_title = match.page_title.toLowerCase();
+                    }
+                });
+            }
+        }
         // Sort by time
         const sortedMatches = matches.sort((a, b) => b.time - a.time);
         return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "roam-research-mcp",
-  "version": "0.18.0",
+  "version": "0.19.0",
   "description": "A Model Context Protocol (MCP) server for Roam Research API integration",
   "private": false,
   "repository": {