roam-research-mcp 2.4.0 → 2.13.0

package/build/tools/operations/pages.js

@@ -1,8 +1,11 @@
-import { q, createPage as createRoamPage, batchActions, updatePage } from '@roam-research/roam-api-sdk';
+import { q, createPage as createRoamPage, 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 { ANCESTOR_RULE } from '../../search/ancestor-rule.js';
+import { getPageUid as getPageUidHelper } from '../helpers/page-resolution.js';
+import { resolveRefs, resolveBlockRefs } from '../helpers/refs.js';
+import { executeBatch, executeBatchSafe } from '../helpers/batch-utils.js';
 import { convertToRoamMarkdown, generateBlockUid } from '../../markdown-utils.js';
+import { executeStagedBatch } from '../../shared/staged-batch.js';
 import { pageUidCache } from '../../cache/page-uid-cache.js';
 import { buildTableActions } from './table.js';
 import { BatchOperations } from './batch.js';
@@ -24,14 +27,6 @@ export class PageOperations {
         this.batchOps = new BatchOperations(graph);
     }
     async findPagesModifiedToday(limit = 50, offset = 0, sort_order = 'desc') {
-        // Define ancestor rule for traversing block hierarchy
-        const ancestorRule = `[
-      [ (ancestor ?b ?a)
-        [?a :block/children ?b] ]
-      [ (ancestor ?b ?a)
-        [?parent :block/children ?b]
-        (ancestor ?parent ?a) ]
-    ]`;
         // Get start of today
         const startOfDay = new Date();
         startOfDay.setHours(0, 0, 0, 0);
@@ -50,7 +45,7 @@ export class PageOperations {
             if (offset > 0) {
                 query += ` :offset ${offset}`;
             }
-            const results = await q(this.graph, query, [startOfDay.getTime(), ancestorRule]);
+            const results = await q(this.graph, query, [startOfDay.getTime(), ANCESTOR_RULE]);
             if (!results || results.length === 0) {
                 return {
                     success: true,
@@ -98,22 +93,48 @@ export class PageOperations {
                 pageUidCache.set(pageTitle, pageUid);
             }
             else {
-                // Create new page
+                // Create new page by adding a page reference to today's daily page
+                // This leverages Roam's native behavior: [[Page Title]] creates the page instantly
                 try {
-                    await createRoamPage(this.graph, {
-                        action: 'create-page',
-                        page: {
-                            title: pageTitle
-                        }
-                    });
-                    // Get the new page's UID
+                    // Get today's daily page title
+                    const today = new Date();
+                    const day = today.getDate();
+                    const month = today.toLocaleString('en-US', { month: 'long' });
+                    const year = today.getFullYear();
+                    const dailyPageTitle = `${month} ${day}${getOrdinalSuffix(day)}, ${year}`;
+                    // Get or create daily page UID
+                    const dailyPageQuery = `[:find ?uid . :where [?e :node/title "${dailyPageTitle}"] [?e :block/uid ?uid]]`;
+                    let dailyPageUid = await q(this.graph, dailyPageQuery, []);
+                    if (!dailyPageUid) {
+                        // Create daily page first
+                        await createRoamPage(this.graph, {
+                            action: 'create-page',
+                            page: { title: dailyPageTitle }
+                        });
+                        // Small delay for daily page creation to be available as parent
+                        await new Promise(resolve => setTimeout(resolve, 400));
+                        dailyPageUid = await q(this.graph, dailyPageQuery, []);
+                    }
+                    if (!dailyPageUid) {
+                        throw new Error(`Could not resolve daily page "${dailyPageTitle}"`);
+                    }
+                    // Create block with page reference - this instantly creates the target page
+                    await executeBatch(this.graph, [{
+                            action: 'create-block',
+                            location: { 'parent-uid': dailyPageUid, order: 'last' },
+                            block: { string: `Created page: [[${pageTitle}]]` }
+                        }], 'create page reference block');
+                    // Now query for the page UID - should exist immediately
                     const results = await q(this.graph, findQuery, [pageTitle]);
                     if (!results || results.length === 0) {
-                        throw new Error('Could not find created page');
+                        throw new Error(`Could not find created page "${pageTitle}"`);
                     }
                     pageUid = results[0][0];
                     // Cache the newly created page
                     pageUidCache.onPageCreated(pageTitle, pageUid);
+                    // Small delay for new page to be fully available as parent in Roam
+                    // (fixes "Parent entity doesn't exist" error when adding content immediately)
+                    await new Promise(resolve => setTimeout(resolve, 400));
                 }
                 catch (error) {
                     throw new McpError(ErrorCode.InternalError, `Failed to create page: ${error instanceof Error ? error.message : String(error)}`);
@@ -230,13 +251,11 @@ export class PageOperations {
                     // 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
+                        // Use staged batch to ensure parent blocks exist before children
+                        await executeStagedBatch(this.graph, textActions, {
+                            context: 'page content creation',
+                            delayBetweenLevels: 100
                         });
-                        if (!batchResult) {
-                            throw new Error('Failed to create text blocks');
-                        }
                     }
                     // Return the next order position (number of root-level blocks added)
                     const nextOrder = startOrder + rootNodes.length;
@@ -291,94 +310,144 @@ export class PageOperations {
             }
         }
         // 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}`;
-            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 Processed block: ${error instanceof Error ? error.message : String(error)}`);
-        }
+        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}`;
+        await executeBatchSafe(this.graph, [{
+                action: 'create-block',
+                location: { 'parent-uid': pageUid, order: 'last' },
+                block: { string: `Processed: [[${formattedTodayTitle}]]` }
+            }], 'add Processed block');
         return { success: true, uid: pageUid };
     }
-    async fetchPageByTitle(title, format = 'raw') {
+    /**
+     * Get the UID for a page by its title.
+     * Tries different case variations (original, capitalized, lowercase).
+     * Returns null if not found.
+     */
+    async getPageUid(title) {
+        return getPageUidHelper(this.graph, title);
+    }
+    /**
+     * Fetch a page by its UID.
+     * Returns the page title and blocks, or null if not found.
+     */
+    async fetchPageByUid(uid) {
+        if (!uid) {
+            return null;
+        }
+        // First get the page title
+        const titleQuery = `[:find ?title . :where [?e :block/uid "${uid}"] [?e :node/title ?title]]`;
+        const title = await q(this.graph, titleQuery, []);
         if (!title) {
-            throw new McpError(ErrorCode.InvalidRequest, 'title is required');
+            return null;
         }
-        // Try different case variations
-        const variations = [
-            title, // Original
-            capitalizeWords(title), // Each word capitalized
-            title.toLowerCase() // All lowercase
-        ];
-        // Check cache first for any variation
-        let uid = null;
-        for (const variation of variations) {
-            const cachedUid = pageUidCache.get(variation);
-            if (cachedUid) {
-                uid = cachedUid;
-                break;
+        // Get all blocks under this page using ancestor rule
+        const blocksQuery = `[:find ?block-uid ?block-str ?order ?parent-uid
+                        :in $ % ?page-uid
+                        :where [?page :block/uid ?page-uid]
+                               [?block :block/string ?block-str]
+                               [?block :block/uid ?block-uid]
+                               [?block :block/order ?order]
+                               (ancestor ?block ?page)
+                               [?parent :block/children ?block]
+                               [?parent :block/uid ?parent-uid]]`;
+        const blocks = await q(this.graph, blocksQuery, [ANCESTOR_RULE, uid]);
+        if (!blocks || blocks.length === 0) {
+            return { title, blocks: [] };
+        }
+        // Get heading information for blocks that have it
+        const headingsQuery = `[:find ?block-uid ?heading
+                          :in $ % ?page-uid
+                          :where [?page :block/uid ?page-uid]
+                                 [?block :block/uid ?block-uid]
+                                 [?block :block/heading ?heading]
+                                 (ancestor ?block ?page)]`;
+        const headings = await q(this.graph, headingsQuery, [ANCESTOR_RULE, uid]);
+        // Create a map of block UIDs to heading levels
+        const headingMap = new Map();
+        if (headings) {
+            for (const [blockUid, heading] of headings) {
+                headingMap.set(blockUid, heading);
             }
         }
-        // If not cached, query the database
-        if (!uid) {
-            const orClause = variations.map(v => `[?e :node/title "${v}"]`).join(' ');
-            const searchQuery = `[:find ?uid .
-                          :where [?e :block/uid ?uid]
-                                 (or ${orClause})]`;
-            const result = await q(this.graph, searchQuery, []);
-            uid = (result === null || result === undefined) ? null : String(result);
-            // Cache the result for the original title
-            if (uid) {
-                pageUidCache.set(title, uid);
+        // Create a map of all blocks
+        const blockMap = new Map();
+        const rootBlocks = [];
+        // First pass: Create all block objects
+        for (const [blockUid, blockStr, order, parentUid] of blocks) {
+            const block = {
+                uid: blockUid,
+                string: blockStr,
+                order: order,
+                heading: headingMap.get(blockUid) || null,
+                children: []
+            };
+            blockMap.set(blockUid, block);
+            // If no parent or parent is the page itself, it's a root block
+            if (!parentUid || parentUid === uid) {
+                rootBlocks.push(block);
             }
         }
+        // Second pass: Build parent-child relationships
+        for (const [blockUid, _, __, parentUid] of blocks) {
+            if (parentUid && parentUid !== uid) {
+                const child = blockMap.get(blockUid);
+                const parent = blockMap.get(parentUid);
+                if (child && parent && !parent.children.includes(child)) {
+                    parent.children.push(child);
+                }
+            }
+        }
+        // Sort blocks recursively
+        const sortBlocks = (blocks) => {
+            blocks.sort((a, b) => a.order - b.order);
+            blocks.forEach(block => {
+                if (block.children.length > 0) {
+                    sortBlocks(block.children);
+                }
+            });
+        };
+        sortBlocks(rootBlocks);
+        return { title, blocks: rootBlocks };
+    }
+    async fetchPageByTitle(title, format = 'raw') {
+        if (!title) {
+            throw new McpError(ErrorCode.InvalidRequest, 'title is required');
+        }
+        // Use getPageUid which handles caching and case variations
+        const uid = await this.getPageUid(title);
         if (!uid) {
             throw new McpError(ErrorCode.InvalidRequest, `Page with title "${title}" not found (tried original, capitalized words, and lowercase)`);
         }
-        // Define ancestor rule for traversing block hierarchy
-        const ancestorRule = `[
-      [ (ancestor ?b ?a)
-        [?a :block/children ?b] ]
-      [ (ancestor ?b ?a)
-        [?parent :block/children ?b]
-        (ancestor ?parent ?a) ]
-    ]`;
         // Get all blocks under this page using ancestor rule
+        // Use UID to avoid case-sensitivity issues (getPageUid handles case variations)
         const blocksQuery = `[:find ?block-uid ?block-str ?order ?parent-uid
-                        :in $ % ?page-title
-                        :where [?page :node/title ?page-title]
+                        :in $ % ?page-uid
+                        :where [?page :block/uid ?page-uid]
                                [?block :block/string ?block-str]
                                [?block :block/uid ?block-uid]
                                [?block :block/order ?order]
                                (ancestor ?block ?page)
                                [?parent :block/children ?block]
                                [?parent :block/uid ?parent-uid]]`;
-        const blocks = await q(this.graph, blocksQuery, [ancestorRule, title]);
+        const blocks = await q(this.graph, blocksQuery, [ANCESTOR_RULE, uid]);
         if (!blocks || blocks.length === 0) {
             if (format === 'raw') {
-                return [];
+                return '[]'; // Return JSON string, not array (MCP text field requires string)
             }
             return `${title} (no content found)`;
         }
         // Get heading information for blocks that have it
         const headingsQuery = `[:find ?block-uid ?heading
-                          :in $ % ?page-title
-                          :where [?page :node/title ?page-title]
+                          :in $ % ?page-uid
+                          :where [?page :block/uid ?page-uid]
                                  [?block :block/uid ?block-uid]
                                  [?block :block/heading ?heading]
                                  (ancestor ?block ?page)]`;
-        const headings = await q(this.graph, headingsQuery, [ancestorRule, title]);
+        const headings = await q(this.graph, headingsQuery, [ANCESTOR_RULE, uid]);
         // Create a map of block UIDs to heading levels
         const headingMap = new Map();
         if (headings) {
@@ -389,17 +458,18 @@ export class PageOperations {
         // Create a map of all blocks
         const blockMap = new Map();
         const rootBlocks = [];
+        const allBlocks = [];
         // First pass: Create all block objects
         for (const [blockUid, blockStr, order, parentUid] of blocks) {
-            const resolvedString = await resolveRefs(this.graph, blockStr);
             const block = {
                 uid: blockUid,
-                string: resolvedString,
+                string: blockStr,
                 order: order,
                 heading: headingMap.get(blockUid) || null,
                 children: []
             };
             blockMap.set(blockUid, block);
+            allBlocks.push(block);
             // If no parent or parent is the page itself, it's a root block
             if (!parentUid || parentUid === uid) {
                 rootBlocks.push(block);
@@ -426,8 +496,14 @@ export class PageOperations {
         };
         sortBlocks(rootBlocks);
         if (format === 'raw') {
+            // Resolve structured references for raw JSON output
+            await resolveBlockRefs(this.graph, allBlocks, 2);
             return JSON.stringify(rootBlocks);
         }
+        // For markdown, resolve references inline
+        await Promise.all(allBlocks.map(async (b) => {
+            b.string = await resolveRefs(this.graph, b.string);
+        }));
         // Convert to markdown with proper nesting
         const toMarkdown = (blocks, level = 0) => {
             return blocks
@@ -470,34 +546,7 @@ export class PageOperations {
             throw new McpError(ErrorCode.InvalidRequest, 'markdown is required');
         }
         // 1. Fetch existing page with raw block data
-        const pageTitle = String(title).trim();
-        // Try different case variations
-        const variations = [
-            pageTitle,
-            capitalizeWords(pageTitle),
-            pageTitle.toLowerCase()
-        ];
-        let pageUid = null;
-        // Check cache first
-        for (const variation of variations) {
-            const cachedUid = pageUidCache.get(variation);
-            if (cachedUid) {
-                pageUid = cachedUid;
-                break;
-            }
-        }
-        // If not cached, query the database
-        if (!pageUid) {
-            const orClause = variations.map(v => `[?e :node/title "${v}"]`).join(' ');
-            const searchQuery = `[:find ?uid .
-                          :where [?e :block/uid ?uid]
-                                 (or ${orClause})]`;
-            const result = await q(this.graph, searchQuery, []);
-            pageUid = (result === null || result === undefined) ? null : String(result);
-            if (pageUid) {
-                pageUidCache.set(pageTitle, pageUid);
-            }
-        }
+        const pageUid = await getPageUidHelper(this.graph, String(title).trim());
         if (!pageUid) {
             throw new McpError(ErrorCode.InvalidRequest, `Page with title "${title}" not found`);
         }
@@ -527,13 +576,11 @@ export class PageOperations {
         // 7. Execute if not dry run and there are actions
         if (!dryRun && actions.length > 0) {
             try {
-                const batchResult = await batchActions(this.graph, {
-                    action: 'batch-actions',
-                    actions: actions
+                // Use staged batch to ensure parent blocks exist before children
+                await executeStagedBatch(this.graph, actions, {
+                    context: 'page update',
+                    delayBetweenLevels: 100
                 });
-                if (!batchResult) {
-                    throw new Error('Batch actions returned no result');
-                }
             }
             catch (error) {
                 throw new McpError(ErrorCode.InternalError, `Failed to apply changes: ${error instanceof Error ? error.message : String(error)}`);

package/build/tools/operations/todos.js

@@ -1,6 +1,6 @@
-import { q, createPage, batchActions } from '@roam-research/roam-api-sdk';
 import { McpError, ErrorCode } from '@modelcontextprotocol/sdk/types.js';
-import { formatRoamDate } from '../../utils/helpers.js';
+import { getOrCreateTodayPage } from '../helpers/page-resolution.js';
+import { executeBatch } from '../helpers/batch-utils.js';
 export class TodoOperations {
     constructor(graph) {
         this.graph = graph;
@@ -9,34 +9,8 @@ export class TodoOperations {
         if (!Array.isArray(todos) || todos.length === 0) {
             throw new McpError(ErrorCode.InvalidRequest, 'todos must be a non-empty array');
         }
-        // Get today's date
-        const today = new Date();
-        const dateStr = formatRoamDate(today);
-        // Try to find today's page
-        const findQuery = `[:find ?uid :in $ ?title :where [?e :node/title ?title] [?e :block/uid ?uid]]`;
-        const findResults = await q(this.graph, findQuery, [dateStr]);
-        let targetPageUid;
-        if (findResults && findResults.length > 0) {
-            targetPageUid = findResults[0][0];
-        }
-        else {
-            // Create today's page if it doesn't exist
-            try {
-                await createPage(this.graph, {
-                    action: 'create-page',
-                    page: { title: dateStr }
-                });
-                // Get the new page's UID
-                const results = await q(this.graph, findQuery, [dateStr]);
-                if (!results || results.length === 0) {
-                    throw new Error('Could not find created today\'s page');
-                }
-                targetPageUid = results[0][0];
-            }
-            catch (error) {
-                throw new Error('Failed to create today\'s page');
-            }
-        }
+        // Get or create today's daily page
+        const targetPageUid = await getOrCreateTodayPage(this.graph);
         const todo_tag = "{{[[TODO]]}}";
         const actions = todos.map((todo, index) => ({
             action: 'create-block',
@@ -48,13 +22,7 @@ export class TodoOperations {
                 string: `${todo_tag} ${todo}`
             }
         }));
-        const result = await batchActions(this.graph, {
-            action: 'batch-actions',
-            actions
-        });
-        if (!result) {
-            throw new Error('Failed to create todo blocks');
-        }
+        await executeBatch(this.graph, actions, 'create todo blocks');
         return { success: true };
     }
 }

package/build/tools/schemas.js

@@ -218,7 +218,7 @@ export const toolSchemas = {
     },
     roam_search_for_tag: {
         name: 'roam_search_for_tag',
-        description: 'Search for blocks containing a specific tag and optionally filter by blocks that also contain another tag nearby or exclude blocks with a specific tag. This tool supports pagination via the `limit` and `offset` parameters. Use this tool to search for memories tagged with the MEMORIES_TAG.',
+        description: 'Search for blocks containing a specific tag and optionally filter by blocks that also contain another tag nearby or exclude blocks with a specific tag. This tool supports pagination via the `limit` and `offset` parameters. Use this tool to search for memories tagged with the ROAM_MEMORIES_TAG.',
         inputSchema: {
             type: 'object',
             properties: withMultiGraphParams({
@@ -356,21 +356,27 @@ export const toolSchemas = {
     },
     roam_search_by_text: {
         name: 'roam_search_by_text',
-        description: 'Search for blocks containing specific text across all pages or within a specific page. This tool supports pagination via the `limit` and `offset` parameters.',
+        description: 'Search for blocks containing specific text across all pages or within a specific page. Use `scope: "page_titles"` to search for pages by namespace prefix (e.g., "Convention/" finds all pages starting with that prefix). This tool supports pagination via the `limit` and `offset` parameters.',
         inputSchema: {
             type: 'object',
             properties: withMultiGraphParams({
                 text: {
                     type: 'string',
-                    description: 'The text to search for'
+                    description: 'The text to search for. When scope is "page_titles", this is the namespace prefix (trailing slash optional).'
+                },
+                scope: {
+                    type: 'string',
+                    enum: ['blocks', 'page_titles'],
+                    default: 'blocks',
+                    description: 'Search scope: "blocks" for block content (default), "page_titles" for page title namespace prefix matching.'
                 },
                 page_title_uid: {
                     type: 'string',
-                    description: 'Optional: Title or UID of the page to search in (UID is preferred for accuracy). If not provided, searches across all pages.'
+                    description: 'Optional: Title or UID of the page to search in (UID is preferred for accuracy). If not provided, searches across all pages. Only used when scope is "blocks".'
                 },
                 case_sensitive: {
                     type: 'boolean',
-                    description: 'Optional: Whether the search should be case-sensitive. If false, it will search for the provided text, capitalized versions, and first word capitalized versions.',
+                    description: 'Optional: Whether the search should be case-sensitive. If false, it will search for the provided text, capitalized versions, and first word capitalized versions. Only used when scope is "blocks".',
                     default: false
                 },
                 limit: {
@@ -431,20 +437,20 @@ export const toolSchemas = {
     },
     roam_remember: {
         name: 'roam_remember',
-        description: 'Add a memory or piece of information to remember, stored on the daily page with MEMORIES_TAG tag and optional categories. \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).\nIMPORTANT: Before using this tool, ensure that you have loaded into context the \'Roam Markdown Cheatsheet\' resource.',
+        description: 'Add a memory or piece of information to remember, stored on the daily page with ROAM_MEMORIES_TAG tag and optional categories (unless include_memories_tag is false). \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).\nIMPORTANT: Before using this tool, ensure that you have loaded into context the \'Roam Markdown Cheatsheet\' resource.',
         inputSchema: {
             type: 'object',
             properties: withMultiGraphParams({
                 memory: {
                     type: 'string',
-                    description: 'The memory detail or information to remember'
+                    description: 'The memory detail or information to remember. Add tags in `categories`.'
                 },
                 categories: {
                     type: 'array',
                     items: {
                         type: 'string'
                     },
-                    description: 'Optional categories to tag the memory with (will be converted to Roam tags)'
+                    description: 'Optional categories to tag the memory with (will be converted to Roam tags). Do not duplicate tags added in `memory` parameter.'
                 },
                 heading: {
                     type: 'string',
@@ -453,6 +459,11 @@ export const toolSchemas = {
                 parent_uid: {
                     type: 'string',
                     description: 'Optional UID of a specific block to nest the memory under. Takes precedence over heading parameter.'
+                },
+                include_memories_tag: {
+                    type: 'boolean',
+                    description: 'Whether to append the ROAM_MEMORIES_TAG tag to the memory block.',
+                    default: true
                 }
             }),
             required: ['memory']
@@ -460,7 +471,7 @@ export const toolSchemas = {
     },
     roam_recall: {
         name: 'roam_recall',
-        description: 'Retrieve all stored memories on page titled MEMORIES_TAG, or tagged block content with the same name. Returns a combined, deduplicated list of memories. Optionally filter blcoks with a specific tag and sort by creation date.',
+        description: 'Retrieve all stored memories on page titled ROAM_MEMORIES_TAG, or tagged block content with the same name. Returns a combined, deduplicated list of memories. Optionally filter blcoks with a specific tag and sort by creation date.',
         inputSchema: {
             type: 'object',
             properties: withMultiGraphParams({

package/build/tools/tool-handlers.js

@@ -12,14 +12,14 @@ import { BatchOperations } from './operations/batch.js';
 import { TableOperations } from './operations/table.js';
 import { DatomicSearchHandlerImpl } from './operations/search/handlers.js';
 export class ToolHandlers {
-    constructor(graph) {
+    constructor(graph, memoriesTag = 'Memories') {
         this.graph = graph;
         this.cachedCheatsheet = null;
         this.pageOps = new PageOperations(graph);
         this.blockOps = new BlockOperations(graph);
         this.blockRetrievalOps = new BlockRetrievalOperations(graph);
         this.searchOps = new SearchOperations(graph);
-        this.memoryOps = new MemoryOperations(graph);
+        this.memoryOps = new MemoryOperations(graph, memoriesTag);
         this.todoOps = new TodoOperations(graph);
         this.outlineOps = new OutlineOperations(graph);
         this.batchOps = new BatchOperations(graph);
@@ -67,8 +67,8 @@ export class ToolHandlers {
         return handler.execute();
     }
     // Memory Operations
-    async remember(memory, categories, heading, parent_uid) {
-        return this.memoryOps.remember(memory, categories, heading, parent_uid);
+    async remember(memory, categories, heading, parent_uid, include_memories_tag) {
+        return this.memoryOps.remember(memory, categories, heading, parent_uid, include_memories_tag);
     }
     async recall(sort_by = 'newest', filter_tag) {
         return this.memoryOps.recall(sort_by, filter_tag);

package/build/utils/helpers.js

@@ -17,6 +17,33 @@ export function formatRoamDate(date) {
     const year = date.getFullYear();
     return `${month} ${day}${getOrdinalSuffix(day)}, ${year}`;
 }
+/**
+ * Parse a Roam Research URL and extract the page/block UID.
+ * Handles URLs like:
+ * - https://roamresearch.com/#/app/graph-name/page/page_uid
+ * - https://roamresearch.com/#/app/graph-name/page/page_uid?version=...
+ *
+ * Returns null if the URL doesn't match expected patterns.
+ */
+export function parseRoamUrl(url) {
+    // Match Roam URL pattern: roamresearch.com/#/app/<graph>/page/<uid>
+    const pagePattern = /roamresearch\.com\/#\/app\/([^/]+)\/page\/([a-zA-Z0-9_-]{9})/;
+    const pageMatch = url.match(pagePattern);
+    if (pageMatch) {
+        return {
+            type: 'page',
+            uid: pageMatch[2],
+            graph: pageMatch[1]
+        };
+    }
+    return null;
+}
+/**
+ * Check if a string looks like a Roam UID (9 alphanumeric characters).
+ */
+export function isRoamUid(str) {
+    return /^[a-zA-Z0-9_-]{9}$/.test(str);
+}
 /**
  * Resolve relative date keywords to Roam date format.
  * Returns the original string if not a recognized keyword.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "roam-research-mcp",
-  "version": "2.4.0",
+  "version": "2.13.0",
   "description": "MCP server and CLI for Roam Research",
   "private": false,
   "repository": {