roam-research-mcp 2.4.0 → 2.13.0

package/build/tools/operations/outline.js

@@ -1,9 +1,10 @@
-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 { capitalizeWords } from '../helpers/text.js';
+import { findOrCreatePage, getPageUid, getOrCreateTodayPage } from '../helpers/page-resolution.js';
+import { executeBatch } from '../helpers/batch-utils.js';
 import { parseMarkdown, convertToRoamActions, convertToRoamMarkdown } from '../../markdown-utils.js';
-import { pageUidCache } from '../../cache/page-uid-cache.js';
+import { executeStagedBatch } from '../../shared/staged-batch.js';
 // Threshold for skipping child fetch during verification
 const VERIFICATION_THRESHOLD = 5;
 export class OutlineOperations {
@@ -55,21 +56,15 @@ export class OutlineOperations {
             }
             for (let retry = 0; retry < maxRetries; retry++) {
                 console.log(`Attempt ${retry + 1}/${maxRetries} to create block "${content}" under "${parentUid}"`);
-                // Create block using batchActions
-                const batchResult = await batchActions(this.graph, {
-                    action: 'batch-actions',
-                    actions: [{
-                            action: 'create-block',
-                            location: {
-                                'parent-uid': parentUid,
-                                order: 'last'
-                            },
-                            block: { string: content }
-                        }]
-                });
-                if (!batchResult) {
-                    throw new McpError(ErrorCode.InternalError, `Failed to create block "${content}" via batch action`);
-                }
+                // Create block using batch action
+                await executeBatch(this.graph, [{
+                        action: 'create-block',
+                        location: {
+                            'parent-uid': parentUid,
+                            order: 'last'
+                        },
+                        block: { string: content }
+                    }], `create block "${content}"`);
                 // Wait with exponential backoff
                 const delay = initialDelay * Math.pow(2, retry);
                 await new Promise(resolve => setTimeout(resolve, delay));
@@ -209,68 +204,8 @@ export class OutlineOperations {
         if (invalidItems.length > 0) {
             throw new McpError(ErrorCode.InvalidRequest, 'outline contains invalid items - each item must have a level (1-10) and non-empty text');
         }
-        // Helper function to find or create page with retries and caching
-        const findOrCreatePage = async (titleOrUid, maxRetries = 3, delayMs = 500) => {
-            const variations = [
-                titleOrUid, // Original
-                capitalizeWords(titleOrUid), // Each word capitalized
-                titleOrUid.toLowerCase() // All lowercase
-            ];
-            // Check cache first for any variation
-            for (const variation of variations) {
-                const cachedUid = pageUidCache.get(variation);
-                if (cachedUid) {
-                    return cachedUid;
-                }
-            }
-            const titleQuery = `[:find ?uid :in $ ?title :where [?e :node/title ?title] [?e :block/uid ?uid]]`;
-            for (let retry = 0; retry < maxRetries; retry++) {
-                // Try each case variation
-                for (const variation of variations) {
-                    const findResults = await q(this.graph, titleQuery, [variation]);
-                    if (findResults && findResults.length > 0) {
-                        const uid = findResults[0][0];
-                        // Cache the result
-                        pageUidCache.set(titleOrUid, uid);
-                        return uid;
-                    }
-                }
-                // If not found as title, try as UID
-                const uidQuery = `[:find ?uid
-                          :where [?e :block/uid "${titleOrUid}"]
-                                 [?e :block/uid ?uid]]`;
-                const uidResult = await q(this.graph, uidQuery, []);
-                if (uidResult && uidResult.length > 0) {
-                    return uidResult[0][0];
-                }
-                // If still not found and this is the first retry, try to create the page
-                if (retry === 0) {
-                    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));
-                }
-            }
-            // One more attempt to find and cache after creation attempts
-            for (const variation of variations) {
-                const findResults = await q(this.graph, titleQuery, [variation]);
-                if (findResults && findResults.length > 0) {
-                    const uid = findResults[0][0];
-                    pageUidCache.onPageCreated(titleOrUid, uid);
-                    return uid;
-                }
-            }
-            throw new McpError(ErrorCode.InvalidRequest, `Failed to find or create page "${titleOrUid}" after multiple attempts`);
-        };
         // Get or create the target page
-        const targetPageUid = await findOrCreatePage(page_title_uid || formatRoamDate(new Date()));
+        const targetPageUid = await findOrCreatePage(this.graph, page_title_uid || formatRoamDate(new Date()));
         // Get or create the parent block
         let targetParentUid;
         if (!block_text_uid) {
@@ -341,21 +276,17 @@ export class OutlineOperations {
                     ...(outlineItem?.children_view_type && { children_view_type: outlineItem.children_view_type })
                 };
             });
-            // Convert nodes to batch actions
+            // Convert nodes to batch actions (flat list)
             const actions = convertToRoamActions(nodes, targetParentUid, 'last');
             if (actions.length === 0) {
                 throw new McpError(ErrorCode.InvalidRequest, 'No valid actions generated from outline');
             }
-            // Execute batch actions to create the outline
-            result = await batchActions(this.graph, {
-                action: 'batch-actions',
-                actions
-            }).catch(error => {
-                throw new McpError(ErrorCode.InternalError, `Failed to create outline blocks: ${error.message}`);
+            // Execute with staged batch to avoid race conditions
+            // where child blocks are created before their parent blocks exist
+            result = await executeStagedBatch(this.graph, actions, {
+                context: 'outline creation',
+                delayBetweenLevels: 100
             });
-            if (!result) {
-                throw new McpError(ErrorCode.InternalError, 'Failed to create outline blocks - no result returned');
-            }
         }
         catch (error) {
             if (error instanceof McpError)
@@ -402,59 +333,25 @@ export class OutlineOperations {
     async importMarkdown(content, page_uid, page_title, parent_uid, parent_string, order = 'last') {
         // First get the page UID
         let targetPageUid = page_uid;
-        if (!targetPageUid && page_title) {
-            // Check cache first
-            const cachedUid = pageUidCache.get(page_title);
-            if (cachedUid) {
-                targetPageUid = cachedUid;
+        // If page_uid is provided, verify it exists
+        if (page_uid) {
+            const verifyQuery = `[:find ?uid :where [?e :block/uid "${page_uid}"] [?e :block/uid ?uid]]`;
+            const verifyResult = await q(this.graph, verifyQuery, []);
+            if (!verifyResult || verifyResult.length === 0) {
+                throw new McpError(ErrorCode.InvalidRequest, `Page/block with UID "${page_uid}" not found`);
             }
-            else {
-                const findQuery = `[:find ?uid :in $ ?title :where [?e :node/title ?title] [?e :block/uid ?uid]]`;
-                const findResults = await q(this.graph, findQuery, [page_title]);
-                if (findResults && findResults.length > 0) {
-                    targetPageUid = findResults[0][0];
-                    pageUidCache.set(page_title, targetPageUid);
-                }
-                else {
-                    throw new McpError(ErrorCode.InvalidRequest, `Page with title "${page_title}" not found`);
-                }
+            targetPageUid = page_uid;
+        }
+        else if (page_title) {
+            const foundUid = await getPageUid(this.graph, page_title);
+            if (!foundUid) {
+                throw new McpError(ErrorCode.InvalidRequest, `Page with title "${page_title}" not found`);
             }
+            targetPageUid = foundUid;
         }
         // If no page specified, use today's date page
         if (!targetPageUid) {
-            const today = new Date();
-            const dateStr = formatRoamDate(today);
-            // Check cache for today's page
-            const cachedDailyUid = pageUidCache.get(dateStr);
-            if (cachedDailyUid) {
-                targetPageUid = cachedDailyUid;
-            }
-            else {
-                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];
-                    pageUidCache.set(dateStr, targetPageUid);
-                }
-                else {
-                    // Create today's page
-                    try {
-                        await createPage(this.graph, {
-                            action: 'create-page',
-                            page: { title: dateStr }
-                        });
-                        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');
-                        }
-                        targetPageUid = results[0][0];
-                        pageUidCache.onPageCreated(dateStr, targetPageUid);
-                    }
-                    catch (error) {
-                        throw new McpError(ErrorCode.InternalError, `Failed to create today's page: ${error instanceof Error ? error.message : String(error)}`);
-                    }
-                }
-            }
+            targetPageUid = await getOrCreateTodayPage(this.graph);
         }
         // Now get the parent block UID
         let targetParentUid = parent_uid;
@@ -491,13 +388,7 @@ export class OutlineOperations {
             // Convert markdown nodes to batch actions
             const actions = convertToRoamActions(nodes, targetParentUid, order);
             // Execute batch actions to add content
-            const result = await batchActions(this.graph, {
-                action: 'batch-actions',
-                actions
-            });
-            if (!result) {
-                throw new McpError(ErrorCode.InternalError, 'Failed to import nested markdown content');
-            }
+            await executeBatch(this.graph, actions, 'import nested markdown content');
             // Skip nested structure fetch for large imports to reduce API calls
             const skipNestedFetch = actions.length > VERIFICATION_THRESHOLD;
             if (skipNestedFetch) {
@@ -519,24 +410,15 @@ export class OutlineOperations {
             };
         }
         else {
-            // Create a simple block for non-nested content using batchActions
-            const actions = [{
+            // Create a simple block for non-nested content
+            await executeBatch(this.graph, [{
                     action: 'create-block',
                     location: {
                         "parent-uid": targetParentUid,
                         "order": order
                     },
                     block: { string: content }
-                }];
-            try {
-                await batchActions(this.graph, {
-                    action: 'batch-actions',
-                    actions
-                });
-            }
-            catch (error) {
-                throw new McpError(ErrorCode.InternalError, `Failed to create content block: ${error instanceof Error ? error.message : String(error)}`);
-            }
+                }], 'create content block');
             // For single-line content, we still need to fetch the UID and construct a NestedBlock
             const createdUids = [];
             try {