roam-research-mcp 0.17.0 → 0.19.0

package/README.md

@@ -1,10 +1,11 @@
 # Roam Research MCP Server
 
 [![npm version](https://badge.fury.io/js/roam-research-mcp.svg)](https://badge.fury.io/js/roam-research-mcp)
+[![Project Status: WIP – Initial development is in progress, but there has not yet been a stable, usable release suitable for the public.](https://www.repostatus.org/badges/latest/wip.svg)](https://www.repostatus.org/#wip)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![GitHub](https://img.shields.io/github/license/2b3pro/roam-research-mcp)](https://github.com/2b3pro/roam-research-mcp/blob/main/LICENSE)
 
-A Model Context Protocol (MCP) server that provides comprehensive access to Roam Research's API functionality. This server enables AI assistants like Claude to interact with your Roam Research graph through a standardized interface.
+A Model Context Protocol (MCP) server that provides comprehensive access to Roam Research's API functionality. This server enables AI assistants like Claude to interact with your Roam Research graph through a standardized interface. (A WORK-IN-PROGRESS)
 
 <a href="https://glama.ai/mcp/servers/fzfznyaflu"><img width="380" height="200" src="https://glama.ai/mcp/servers/fzfznyaflu/badge" alt="Roam Research MCP server" /></a>
 
@@ -27,7 +28,7 @@ npm run build
 
 ## Features
 
-The server provides eleven powerful tools for interacting with Roam Research:
+The server provides twelve powerful tools for interacting with Roam Research:
 
 1. `roam_fetch_page_by_title`: Fetch and read a page's content by title, recursively resolving block references up to 4 levels deep
 2. `roam_create_page`: Create new pages with optional content
@@ -40,6 +41,7 @@ The server provides eleven powerful tools for interacting with Roam Research:
 9. `find_pages_modified_today`: Find all pages that have been modified since midnight today
 10. `roam_search_by_text`: Search for blocks containing specific text across all pages or within a specific page
 11. `roam_update_block`: Update block content with direct text or pattern-based transformations
+12. `roam_search_by_date`: Search for blocks and pages based on creation or modification dates
 
 ## Setup
 
@@ -333,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
 }
 ```
 
@@ -349,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:
 
@@ -419,6 +421,55 @@ Returns:
 }
 ```
 
+### Search By Date
+
+Search for blocks and pages based on creation or modification dates:
+
+```typescript
+use_mcp_tool roam-research roam_search_by_date {
+  "start_date": "2025-01-01",
+  "end_date": "2025-01-31",
+  "type": "modified",
+  "scope": "blocks",
+  "include_content": true
+}
+```
+
+Features:
+
+- Search by creation date, modification date, or both
+- Filter blocks, pages, or both
+- Optional date range with start and end dates
+- Include or exclude block/page content in results
+- Sort results by timestamp
+- Efficient date-based filtering using Datalog queries
+
+Parameters:
+
+- `start_date`: Start date in ISO format (YYYY-MM-DD) (required)
+- `end_date`: End date in ISO format (YYYY-MM-DD) (optional)
+- `type`: Whether to search by 'created', 'modified', or 'both' (required)
+- `scope`: Whether to search 'blocks', 'pages', or 'both' (required)
+- `include_content`: Whether to include the content of matching blocks/pages (optional, default: true)
+
+Returns:
+
+```json
+{
+  "success": true,
+  "matches": [
+    {
+      "uid": "block-or-page-uid",
+      "type": "block",
+      "time": 1704067200000,
+      "content": "Block or page content",
+      "page_title": "Page title (for blocks)"
+    }
+  ],
+  "message": "Found N matches for the given date range and criteria"
+}
+```
+
 ### Find Pages Modified Today
 
 Find all pages that have been modified since midnight today:

package/build/server/roam-server.js

@@ -18,7 +18,7 @@ export class RoamServer {
         this.toolHandlers = new ToolHandlers(this.graph);
         this.server = new Server({
             name: 'roam-research',
-            version: '0.16.0',
+            version: '0.17.0',
         }, {
             capabilities: {
                 tools: {
@@ -34,7 +34,9 @@ export class RoamServer {
                     roam_search_hierarchy: {},
                     find_pages_modified_today: {},
                     roam_search_by_text: {},
-                    roam_update_block: {}
+                    roam_update_block: {},
+                    roam_update_blocks: {},
+                    roam_search_by_date: {}
                 },
             },
         });
@@ -142,6 +144,13 @@ export class RoamServer {
                             content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
                         };
                     }
+                    case 'roam_search_by_date': {
+                        const params = request.params.arguments;
+                        const result = await this.toolHandlers.searchByDate(params);
+                        return {
+                            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                        };
+                    }
                     case 'roam_update_block': {
                         const { block_uid, content, transform_pattern } = request.params.arguments;
                         let result;
@@ -158,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: {
@@ -313,5 +324,95 @@ export const toolSchemas = {
                 { required: ['transform_pattern'] }
             ]
         }
+    },
+    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',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                start_date: {
+                    type: 'string',
+                    description: 'Start date in ISO format (YYYY-MM-DD)',
+                },
+                end_date: {
+                    type: 'string',
+                    description: 'Optional: End date in ISO format (YYYY-MM-DD)',
+                },
+                type: {
+                    type: 'string',
+                    enum: ['created', 'modified', 'both'],
+                    description: 'Whether to search by creation date, modification date, or both',
+                },
+                scope: {
+                    type: 'string',
+                    enum: ['blocks', 'pages', 'both'],
+                    description: 'Whether to search blocks, pages, or both',
+                },
+                include_content: {
+                    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];
             }
         }
@@ -900,6 +1029,73 @@ export class ToolHandlers {
             message: `Found ${matches.length} block(s) containing ${primaryTagFormatted}${nearTagFormatted ? ` near ${nearTagFormatted}` : ''}`
         };
     }
+    async searchByDate(params) {
+        // Convert dates to timestamps
+        const startTimestamp = new Date(`${params.start_date}T00:00:00`).getTime();
+        const endTimestamp = params.end_date ? new Date(`${params.end_date}T23:59:59`).getTime() : undefined;
+        // Define rule for entity type
+        const entityRule = `[
+      [(block? ?e)
+       [?e :block/string]
+       [?e :block/page ?p]
+       [?p :node/title]]
+      [(page? ?e)
+       [?e :node/title]]
+    ]`;
+        // Build query based on cheatsheet pattern
+        const timeAttr = params.type === 'created' ? ':create/time' : ':edit/time';
+        let queryStr = `[:find ?block-uid ?string ?time ?page-title
+                    :in $ ?start-ts ${endTimestamp ? '?end-ts' : ''}
+                    :where
+                    [?b ${timeAttr} ?time]
+                    [(>= ?time ?start-ts)]
+                    ${endTimestamp ? '[(<= ?time ?end-ts)]' : ''}
+                    [?b :block/uid ?block-uid]
+                    [?b :block/string ?string]
+                    [?b :block/page ?p]
+                    [?p :node/title ?page-title]]`;
+        // Execute query
+        const queryParams = endTimestamp ?
+            [startTimestamp, endTimestamp] :
+            [startTimestamp];
+        const results = await q(this.graph, queryStr, queryParams);
+        if (!results || results.length === 0) {
+            return {
+                success: true,
+                matches: [],
+                message: 'No matches found for the given date range and criteria'
+            };
+        }
+        // Process results - now we get [block-uid, string, time, page-title]
+        const matches = results.map(([uid, content, time, pageTitle]) => ({
+            uid,
+            type: 'block',
+            time,
+            ...(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 {
+            success: true,
+            matches: sortedMatches,
+            message: `Found ${sortedMatches.length} matches for the given date range and criteria`
+        };
+    }
     async addTodos(todos) {
         if (!Array.isArray(todos) || todos.length === 0) {
             throw new McpError(ErrorCode.InvalidRequest, 'todos must be a non-empty array');

package/package.json

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