roam-research-mcp 2.4.0 → 2.13.0

package/build/tools/operations/blocks.js

@@ -1,194 +1,9 @@
-import { q, updateBlock as updateRoamBlock, moveBlock as moveRoamBlock, batchActions, createPage } from '@roam-research/roam-api-sdk';
+import { q, moveBlock as moveRoamBlock } from '@roam-research/roam-api-sdk';
 import { McpError, ErrorCode } from '@modelcontextprotocol/sdk/types.js';
-import { formatRoamDate } from '../../utils/helpers.js';
-import { parseMarkdown, convertToRoamActions, convertToRoamMarkdown } from '../../markdown-utils.js';
 export class BlockOperations {
     constructor(graph) {
         this.graph = graph;
     }
-    async createBlock(content, page_uid, title, heading) {
-        // If page_uid provided, use it directly
-        let targetPageUid = page_uid;
-        // If no page_uid but title provided, search for page by title
-        if (!targetPageUid && title) {
-            const findQuery = `[:find ?uid :in $ ?title :where [?e :node/title ?title] [?e :block/uid ?uid]]`;
-            const findResults = await q(this.graph, findQuery, [title]);
-            if (findResults && findResults.length > 0) {
-                targetPageUid = findResults[0][0];
-            }
-            else {
-                // Create page with provided title if it doesn't exist
-                try {
-                    await createPage(this.graph, {
-                        action: 'create-page',
-                        page: { title }
-                    });
-                    // Get the new page's UID
-                    const results = await q(this.graph, findQuery, [title]);
-                    if (!results || results.length === 0) {
-                        throw new Error('Could not find created page');
-                    }
-                    targetPageUid = results[0][0];
-                }
-                catch (error) {
-                    throw new McpError(ErrorCode.InternalError, `Failed to create page: ${error instanceof Error ? error.message : String(error)}`);
-                }
-            }
-        }
-        // If neither page_uid nor title provided, use today's date page
-        if (!targetPageUid) {
-            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]);
-            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 McpError(ErrorCode.InternalError, `Failed to create today's page: ${error instanceof Error ? error.message : String(error)}`);
-                }
-            }
-        }
-        try {
-            // If the content has multiple lines or is a table, use nested import
-            if (content.includes('\n')) {
-                let nodes;
-                // If heading parameter is provided, manually construct nodes to preserve heading
-                if (heading) {
-                    const lines = content.split('\n');
-                    const firstLine = lines[0].trim();
-                    const remainingLines = lines.slice(1);
-                    // Create the first node with heading formatting
-                    const firstNode = {
-                        content: firstLine,
-                        level: 0,
-                        heading_level: heading,
-                        children: []
-                    };
-                    // If there are remaining lines, parse them as children or siblings
-                    if (remainingLines.length > 0 && remainingLines.some(line => line.trim())) {
-                        const remainingContent = remainingLines.join('\n');
-                        const convertedRemainingContent = convertToRoamMarkdown(remainingContent);
-                        const remainingNodes = parseMarkdown(convertedRemainingContent);
-                        // Add remaining nodes as siblings to the first node
-                        nodes = [firstNode, ...remainingNodes];
-                    }
-                    else {
-                        nodes = [firstNode];
-                    }
-                }
-                else {
-                    // No heading parameter, use original parsing logic
-                    const convertedContent = convertToRoamMarkdown(content);
-                    nodes = parseMarkdown(convertedContent);
-                }
-                const actions = convertToRoamActions(nodes, targetPageUid, 'last');
-                // Execute batch actions to create the nested structure
-                const result = await batchActions(this.graph, {
-                    action: 'batch-actions',
-                    actions
-                });
-                if (!result) {
-                    throw new Error('Failed to create nested blocks');
-                }
-                const blockUid = result.created_uids?.[0];
-                return {
-                    success: true,
-                    block_uid: blockUid,
-                    parent_uid: targetPageUid
-                };
-            }
-            else {
-                // For single block content, use the same convertToRoamActions approach that works in roam_create_page
-                const nodes = [{
-                        content: content,
-                        level: 0,
-                        ...(heading && typeof heading === 'number' && heading > 0 && { heading_level: heading }),
-                        children: []
-                    }];
-                if (!targetPageUid) {
-                    throw new McpError(ErrorCode.InternalError, 'targetPageUid is undefined');
-                }
-                const actions = convertToRoamActions(nodes, targetPageUid, 'last');
-                // Execute batch actions to create the block
-                const result = await batchActions(this.graph, {
-                    action: 'batch-actions',
-                    actions
-                });
-                if (!result) {
-                    throw new Error('Failed to create block');
-                }
-                const blockUid = result.created_uids?.[0];
-                return {
-                    success: true,
-                    block_uid: blockUid,
-                    parent_uid: targetPageUid
-                };
-            }
-        }
-        catch (error) {
-            throw new McpError(ErrorCode.InternalError, `Failed to create block: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-    async updateBlock(block_uid, content, transform) {
-        if (!block_uid) {
-            throw new McpError(ErrorCode.InvalidRequest, 'block_uid is required');
-        }
-        // Get current block content
-        const blockQuery = `[:find ?string .
-                        :where [?b :block/uid "${block_uid}"]
-                               [?b :block/string ?string]]`;
-        const result = await q(this.graph, blockQuery, []);
-        if (result === null || result === undefined) {
-            throw new McpError(ErrorCode.InvalidRequest, `Block with UID "${block_uid}" not found`);
-        }
-        const currentContent = String(result);
-        if (currentContent === null || currentContent === undefined) {
-            throw new McpError(ErrorCode.InvalidRequest, `Block with UID "${block_uid}" not found`);
-        }
-        // Determine new content
-        let newContent;
-        if (content) {
-            newContent = content;
-        }
-        else if (transform) {
-            newContent = transform(currentContent);
-        }
-        else {
-            throw new McpError(ErrorCode.InvalidRequest, 'Either content or transform function must be provided');
-        }
-        try {
-            await updateRoamBlock(this.graph, {
-                action: 'update-block',
-                block: {
-                    uid: block_uid,
-                    string: newContent
-                }
-            });
-            return {
-                success: true,
-                content: newContent
-            };
-        }
-        catch (error) {
-            throw new McpError(ErrorCode.InternalError, `Failed to update block: ${error.message}`);
-        }
-    }
     async moveBlock(block_uid, parent_uid, order = 'last') {
         if (!block_uid) {
             throw new McpError(ErrorCode.InvalidRequest, 'block_uid is required');
@@ -226,106 +41,4 @@ export class BlockOperations {
             throw new McpError(ErrorCode.InternalError, `Failed to move block: ${error.message}`);
         }
     }
-    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
-        };
-    }
 }

package/build/tools/operations/memory.js

@@ -1,53 +1,20 @@
-import { q, createPage, batchActions } from '@roam-research/roam-api-sdk';
+import { q } from '@roam-research/roam-api-sdk';
 import { McpError, ErrorCode } from '@modelcontextprotocol/sdk/types.js';
-import { formatRoamDate } from '../../utils/helpers.js';
 import { generateBlockUid } from '../../markdown-utils.js';
+import { ANCESTOR_RULE } from '../../search/ancestor-rule.js';
 import { resolveRefs } from '../helpers/refs.js';
+import { getOrCreateTodayPage } from '../helpers/page-resolution.js';
+import { executeBatch } from '../helpers/batch-utils.js';
 import { SearchOperations } from './search/index.js';
-import { pageUidCache } from '../../cache/page-uid-cache.js';
 export class MemoryOperations {
-    constructor(graph) {
+    constructor(graph, memoriesTag = 'Memories') {
         this.graph = graph;
         this.searchOps = new SearchOperations(graph);
+        this.memoriesTag = memoriesTag;
     }
-    async remember(memory, categories, heading, parent_uid) {
-        // Get today's date
-        const today = new Date();
-        const dateStr = formatRoamDate(today);
-        let pageUid;
-        // Check cache first for today's page
-        const cachedUid = pageUidCache.get(dateStr);
-        if (cachedUid) {
-            pageUid = cachedUid;
-        }
-        else {
-            // 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]);
-            if (findResults && findResults.length > 0) {
-                pageUid = findResults[0][0];
-                pageUidCache.set(dateStr, pageUid);
-            }
-            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 McpError(ErrorCode.InternalError, 'Could not find created today\'s page');
-                    }
-                    pageUid = results[0][0];
-                    pageUidCache.onPageCreated(dateStr, pageUid);
-                }
-                catch (error) {
-                    throw new McpError(ErrorCode.InternalError, 'Failed to create today\'s page');
-                }
-            }
-        }
+    async remember(memory, categories, heading, parent_uid, include_memories_tag = true) {
+        // Get or create today's daily page
+        const pageUid = await getOrCreateTodayPage(this.graph);
         // Determine parent block for the memory
         let targetParentUid;
         if (parent_uid) {
@@ -70,38 +37,33 @@ export class MemoryOperations {
             else {
                 // Create the heading block
                 const headingBlockUid = generateBlockUid();
-                try {
-                    await batchActions(this.graph, {
-                        action: 'batch-actions',
-                        actions: [{
-                                action: 'create-block',
-                                location: { 'parent-uid': pageUid, order: 'last' },
-                                block: { uid: headingBlockUid, string: heading }
-                            }]
-                    });
-                    targetParentUid = headingBlockUid;
-                }
-                catch (error) {
-                    throw new McpError(ErrorCode.InternalError, `Failed to create heading block: ${error instanceof Error ? error.message : String(error)}`);
-                }
+                await executeBatch(this.graph, [{
+                        action: 'create-block',
+                        location: { 'parent-uid': pageUid, order: 'last' },
+                        block: { uid: headingBlockUid, string: heading }
+                    }], 'create heading block');
+                targetParentUid = headingBlockUid;
             }
         }
         else {
             // Default: use daily page root
             targetParentUid = pageUid;
         }
-        // Get memories tag from environment
-        const memoriesTag = process.env.MEMORIES_TAG;
-        if (!memoriesTag) {
-            throw new McpError(ErrorCode.InternalError, 'MEMORIES_TAG environment variable not set');
-        }
+        // Get memories tag (use instance property) and format as Roam tag
+        // If memoriesTag is null (disabled for this graph), treat as if include_memories_tag is false
+        const memoriesTagFormatted = (include_memories_tag && this.memoriesTag)
+            ? (this.memoriesTag.includes(' ') || this.memoriesTag.includes('/')
+                ? `#[[${this.memoriesTag}]]`
+                : `#${this.memoriesTag}`)
+            : undefined;
         // Format categories as Roam tags if provided
         const categoryTags = categories?.map(cat => {
             // Handle multi-word categories
             return cat.includes(' ') ? `#[[${cat}]]` : `#${cat}`;
-        }).join(' ') || '';
+        }) ?? [];
         // Create block with memory, then all tags together at the end
-        const blockContent = `${memory} ${categoryTags} ${memoriesTag}`.trim();
+        const tags = memoriesTagFormatted ? [...categoryTags, memoriesTagFormatted] : categoryTags;
+        const blockContent = [memory, ...tags].join(' ').trim();
         // Pre-generate UID so we can return it
         const blockUid = generateBlockUid();
         const actions = [{
@@ -115,49 +77,29 @@ export class MemoryOperations {
                     string: blockContent
                 }
             }];
-        try {
-            const result = await batchActions(this.graph, {
-                action: 'batch-actions',
-                actions
-            });
-            if (!result) {
-                throw new McpError(ErrorCode.InternalError, 'Failed to create memory block via batch action');
-            }
-        }
-        catch (error) {
-            throw new McpError(ErrorCode.InternalError, `Failed to create memory block: ${error instanceof Error ? error.message : String(error)}`);
-        }
+        await executeBatch(this.graph, actions, 'create memory block');
         return { success: true, block_uid: blockUid, parent_uid: targetParentUid };
     }
     async recall(sort_by = 'newest', filter_tag) {
-        // Get memories tag from environment
-        var memoriesTag = process.env.MEMORIES_TAG;
-        if (!memoriesTag) {
-            memoriesTag = "Memories";
+        // If memories tag is disabled for this graph, return empty
+        if (!this.memoriesTag) {
+            return { success: true, memories: [] };
         }
         // Extract the tag text, removing any formatting
-        const tagText = memoriesTag
+        const tagText = this.memoriesTag
             .replace(/^#/, '') // Remove leading #
             .replace(/^\[\[/, '').replace(/\]\]$/, ''); // Remove [[ and ]]
         try {
-            // Get page blocks using query to access actual block content
-            const ancestorRule = `[
-        [ (ancestor ?b ?a)
-          [?a :block/children ?b] ]
-        [ (ancestor ?b ?a)
-          [?parent :block/children ?b]
-          (ancestor ?parent ?a) ]
-      ]`;
             // Query to find all blocks on the page
             const pageQuery = `[:find ?string ?time
                          :in $ % ?title
-                         :where 
+                         :where
                          [?page :node/title ?title]
                          [?block :block/string ?string]
                          [?block :create/time ?time]
                          (ancestor ?block ?page)]`;
             // Execute query
-            const pageResults = await q(this.graph, pageQuery, [ancestorRule, tagText]);
+            const pageResults = await q(this.graph, pageQuery, [ANCESTOR_RULE, tagText]);
             // Process page blocks with sorting
             let pageMemories = pageResults
                 .sort(([_, aTime], [__, bTime]) => sort_by === 'newest' ? bTime - aTime : aTime - bTime)