roam-research-mcp 0.23.0 → 0.23.1

package/build/tools/operations/outline.js

@@ -54,20 +54,14 @@ export class OutlineOperations {
                 }
                 // If still not found and this is the first retry, try to create the page
                 if (retry === 0) {
-                    try {
-                        await createPage(this.graph, {
-                            action: 'create-page',
-                            page: { title: titleOrUid }
-                        });
-                        // Wait a bit and continue to next retry to check if page was created
-                        await new Promise(resolve => setTimeout(resolve, delayMs));
-                        continue;
-                    }
-                    catch (error) {
-                        console.error('Error creating page:', error);
-                        // Continue to next retry
-                        continue;
-                    }
+                    const success = await createPage(this.graph, {
+                        action: 'create-page',
+                        page: { title: titleOrUid }
+                    });
+                    // Even if createPage returns false, the page might still have been created
+                    // Wait a bit and continue to next retry
+                    await new Promise(resolve => setTimeout(resolve, delayMs));
+                    continue;
                 }
                 if (retry < maxRetries - 1) {
                     await new Promise(resolve => setTimeout(resolve, delayMs));
@@ -78,23 +72,21 @@ export class OutlineOperations {
         // 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, case_sensitive = false) => {
+        const findBlockWithRetry = async (pageUid, blockString, maxRetries = 5, initialDelay = 1000) => {
             // 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 ?block-str]
-                 [(${case_sensitive ? '=' : 'clojure.string/equals-ignore-case'} ?block-str "${blockString}")]
+                 [?b :block/string "${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 ?block-str]
-                 [(${case_sensitive ? '=' : 'clojure.string/equals-ignore-case'} ?block-str "${blockString}")]
+                 [?b :block/string "${blockString}"]
                  [?b :block/order ?order]
                  [?b :block/uid ?b-uid]]`,
                 // Strategy 3: Broader page relationship
@@ -102,8 +94,7 @@ export class OutlineOperations {
           :where [?p :block/uid "${pageUid}"]
                  [?b :block/page ?page]
                  [?p :block/page ?page]
-                 [?b :block/string ?block-str]
-                 [(${case_sensitive ? '=' : 'clojure.string/equals-ignore-case'} ?block-str "${blockString}")]
+                 [?b :block/string "${blockString}"]
                  [?b :block/order ?order]
                  [?b :block/uid ?b-uid]]`
             ];
@@ -125,7 +116,7 @@ export class OutlineOperations {
             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, case_sensitive = false) => {
+        const createAndVerifyBlock = async (content, parentUid, maxRetries = 5, initialDelay = 1000, isRetry = false) => {
             try {
                 // Initial delay before any operations
                 if (!isRetry) {
@@ -133,25 +124,25 @@ export class OutlineOperations {
                 }
                 for (let retry = 0; retry < maxRetries; retry++) {
                     console.log(`Attempt ${retry + 1}/${maxRetries} to create block "${content}" under "${parentUid}"`);
+                    // Create block
+                    const success = await createBlock(this.graph, {
+                        action: 'create-block',
+                        location: {
+                            'parent-uid': parentUid,
+                            order: 'last'
+                        },
+                        block: { string: content }
+                    });
+                    // Wait with exponential backoff
+                    const delay = initialDelay * Math.pow(2, retry);
+                    await new Promise(resolve => setTimeout(resolve, delay));
                     try {
-                        // Create block
-                        await createBlock(this.graph, {
-                            action: 'create-block',
-                            location: {
-                                'parent-uid': parentUid,
-                                order: 'first'
-                            },
-                            block: { string: content }
-                        });
-                        // Wait with exponential backoff
-                        const delay = initialDelay * Math.pow(2, retry);
-                        await new Promise(resolve => setTimeout(resolve, delay));
                         // Try to find the block using our improved findBlockWithRetry
-                        return await findBlockWithRetry(parentUid, content, maxRetries, initialDelay, case_sensitive);
+                        return await findBlockWithRetry(parentUid, content);
                     }
                     catch (error) {
                         const errorMessage = error instanceof Error ? error.message : String(error);
-                        console.log(`Failed to create/find block on attempt ${retry + 1}: ${errorMessage}`);
+                        console.log(`Failed to find block on attempt ${retry + 1}: ${errorMessage}`);
                         if (retry === maxRetries - 1)
                             throw error;
                     }
@@ -165,7 +156,7 @@ export class OutlineOperations {
                 // 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, case_sensitive);
+                return createAndVerifyBlock(content, parentUid, maxRetries, initialDelay, true);
             }
         };
         // Get or create the parent block

package/build/tools/schemas.js

@@ -429,7 +429,7 @@ export const toolSchemas = {
     },
     roam_datomic_query: {
         name: 'roam_datomic_query',
-        description: 'Execute a custom Datomic query on the Roam graph. This provides direct access to Roam\'s query engine for advanced data retrieval. Note: The Roam graph is case-sensitive.\nA list of some of Roam\'s data model Namespaces and Attributes: ancestor (descendants), attrs (lookup), block (children, heading, open, order, page, parents, props, refs, string, text-align, uid), children (view-type), create (email, time), descendant (ancestors), edit (email, seen-by, time), entity (attrs), log (id), node (title), page (uid, title), refs (text).\nPredicates (clojure.string/includes?, clojure.string/starts-with?, clojure.string/ends-with?, <, >, <=, >=, =, not=, !=).\nAggregates (distinct, count, sum, max, min, avg).\nTips: Use :block/parents for all ancestor levels, :block/children for direct descendants only; combine clojure.string for complex matching, use distinct to deduplicate, leverage Pull patterns for hierarchies, handle case-sensitivity carefully, and chain ancestry rules for multi-level queries.',
+        description: 'Execute a custom Datomic query on the Roam graph beyond the available search tools. This provides direct access to Roam\'s query engine for advanced data retrieval. Note: The Roam graph is case-sensitive.\nA list of some of Roam\'s data model Namespaces and Attributes: ancestor (descendants), attrs (lookup), block (children, heading, open, order, page, parents, props, refs, string, text-align, uid), children (view-type), create (email, time), descendant (ancestors), edit (email, seen-by, time), entity (attrs), log (id), node (title), page (uid, title), refs (text).\nPredicates (clojure.string/includes?, clojure.string/starts-with?, clojure.string/ends-with?, <, >, <=, >=, =, not=, !=).\nAggregates (distinct, count, sum, max, min, avg).\nTips: Use :block/parents for all ancestor levels, :block/children for direct descendants only; combine clojure.string for complex matching, use distinct to deduplicate, leverage Pull patterns for hierarchies, handle case-sensitivity carefully, and chain ancestry rules for multi-level queries.',
         inputSchema: {
             type: 'object',
             properties: {

package/package.json

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