roam-research-mcp 0.24.2 → 0.25.0

package/README.md

@@ -26,6 +26,14 @@ npm install
 npm run build
 ```
 
+## To Test
+
+Run [MCP Inspector](https://github.com/modelcontextprotocol/inspector) after build…
+
+```
+npx @modelcontextprotocol/inspector node build/index.js
+```
+
 ## Features
 
 The server provides powerful tools for interacting with Roam Research:
@@ -88,7 +96,7 @@ The server provides powerful tools for interacting with Roam Research:
      "mcpServers": {
        "roam-research": {
          "command": "node",
-         "args": ["/path/to/roam-research/build/index.js"],
+         "args": ["/path/to/roam-research-mcp/build/index.js"],
          "env": {
            "ROAM_API_TOKEN": "your-api-token",
            "ROAM_GRAPH_NAME": "your-graph-name",
@@ -101,9 +109,9 @@ The server provides powerful tools for interacting with Roam Research:
 
    Note: The server will first try to load from .env file, then fall back to environment variables from MCP settings.
 
-3. Build the server:
+3. Build the server (make sure you're in the root directory of the MCP):
    ```bash
-   cd roam-research
+   cd roam-research-mcp
    npm install
    npm run build
    ```

package/build/server/roam-server.js

@@ -17,7 +17,7 @@ export class RoamServer {
         this.toolHandlers = new ToolHandlers(this.graph);
         this.server = new Server({
             name: 'roam-research',
-            version: '0.24.2',
+            version: '0.25.0',
         }, {
             capabilities: {
                 tools: {
@@ -36,7 +36,7 @@ export class RoamServer {
                     roam_find_pages_modified_today: {},
                     roam_search_by_text: {},
                     roam_update_block: {},
-                    roam_update_blocks: {},
+                    roam_update_multiple_blocks: {},
                     roam_search_by_date: {},
                     roam_datomic_query: {}
                 },
@@ -131,13 +131,18 @@ export class RoamServer {
                     }
                     case 'roam_search_hierarchy': {
                         const params = request.params.arguments;
+                        // Validate that either parent_uid or child_uid is provided, but not both
+                        if ((!params.parent_uid && !params.child_uid) || (params.parent_uid && params.child_uid)) {
+                            throw new McpError(ErrorCode.InvalidRequest, 'Either parent_uid or child_uid must be provided, but not both');
+                        }
                         const result = await this.toolHandlers.searchHierarchy(params);
                         return {
                             content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
                         };
                     }
                     case 'roam_find_pages_modified_today': {
-                        const result = await this.toolHandlers.findPagesModifiedToday();
+                        const { max_num_pages } = request.params.arguments;
+                        const result = await this.toolHandlers.findPagesModifiedToday(max_num_pages || 50);
                         return {
                             content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
                         };
@@ -158,11 +163,16 @@ export class RoamServer {
                     }
                     case 'roam_update_block': {
                         const { block_uid, content, transform_pattern } = request.params.arguments;
+                        // Validate that either content or transform_pattern is provided, but not both or neither
+                        if ((!content && !transform_pattern) || (content && transform_pattern)) {
+                            throw new McpError(ErrorCode.InvalidRequest, 'Either content or transform_pattern must be provided, but not both or neither');
+                        }
                         let result;
                         if (content) {
                             result = await this.toolHandlers.updateBlock(block_uid, content);
                         }
-                        else if (transform_pattern) {
+                        else {
+                            // We know transform_pattern exists due to validation above
                             result = await this.toolHandlers.updateBlock(block_uid, undefined, (currentContent) => {
                                 const regex = new RegExp(transform_pattern.find, transform_pattern.global !== false ? 'g' : '');
                                 return currentContent.replace(regex, transform_pattern.replace);
@@ -179,8 +189,14 @@ export class RoamServer {
                             content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
                         };
                     }
-                    case 'roam_update_blocks': {
+                    case 'roam_update_multiple_blocks': {
                         const { updates } = request.params.arguments;
+                        // Validate that for each update, either content or transform is provided, but not both or neither
+                        for (const update of updates) {
+                            if ((!update.content && !update.transform) || (update.content && update.transform)) {
+                                throw new McpError(ErrorCode.InvalidRequest, 'For each update, either content or transform must be provided, but not both or neither');
+                            }
+                        }
                         const result = await this.toolHandlers.updateBlocks(updates);
                         return {
                             content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],

package/build/tools/operations/outline.js

@@ -159,6 +159,10 @@ export class OutlineOperations {
                 return createAndVerifyBlock(content, parentUid, maxRetries, initialDelay, true);
             }
         };
+        // Helper function to check if string is a valid Roam UID (9 characters)
+        const isValidUid = (str) => {
+            return typeof str === 'string' && str.length === 9;
+        };
         // Get or create the parent block
         let targetParentUid;
         if (!block_text_uid) {
@@ -166,12 +170,28 @@ export class OutlineOperations {
         }
         else {
             try {
-                // Create header block and get its UID
-                targetParentUid = await createAndVerifyBlock(block_text_uid, targetPageUid);
+                if (isValidUid(block_text_uid)) {
+                    // First try to find block by UID
+                    const uidQuery = `[:find ?uid
+                           :where [?e :block/uid "${block_text_uid}"]
+                                  [?e :block/uid ?uid]]`;
+                    const uidResult = await q(this.graph, uidQuery, []);
+                    if (uidResult && uidResult.length > 0) {
+                        // Use existing block if found
+                        targetParentUid = uidResult[0][0];
+                    }
+                    else {
+                        throw new McpError(ErrorCode.InvalidRequest, `Block with UID "${block_text_uid}" not found`);
+                    }
+                }
+                else {
+                    // Create header block and get its UID if not a valid UID
+                    targetParentUid = await createAndVerifyBlock(block_text_uid, targetPageUid);
+                }
             }
             catch (error) {
                 const errorMessage = error instanceof Error ? error.message : String(error);
-                throw new McpError(ErrorCode.InternalError, `Failed to create header block "${block_text_uid}": ${errorMessage}`);
+                throw new McpError(ErrorCode.InternalError, `Failed to ${isValidUid(block_text_uid) ? 'find' : 'create'} block "${block_text_uid}": ${errorMessage}`);
             }
         }
         // Initialize result variable

package/build/tools/operations/pages.js

@@ -1,14 +1,14 @@
-import { q, createPage as createRoamPage, batchActions, createBlock } from '@roam-research/roam-api-sdk';
+import { q, createPage as createRoamPage, batchActions } 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 { parseMarkdown, convertToRoamActions, convertToRoamMarkdown, hasMarkdownTable } from '../../markdown-utils.js';
+import { convertToRoamActions } from '../../markdown-utils.js';
 export class PageOperations {
     graph;
     constructor(graph) {
         this.graph = graph;
     }
-    async findPagesModifiedToday(num_pages = 10) {
+    async findPagesModifiedToday(max_num_pages = 50) {
         // Define ancestor rule for traversing block hierarchy
         const ancestorRule = `[
       [ (ancestor ?b ?a)
@@ -29,7 +29,7 @@ export class PageOperations {
           (ancestor ?block ?page)
           [?block :edit/time ?time]
           [(> ?time ?start_of_day)]]
-          :limit ${num_pages}`, [startOfDay.getTime(), ancestorRule]);
+          :limit ${max_num_pages}`, [startOfDay.getTime(), ancestorRule]);
             if (!results || results.length === 0) {
                 return {
                     success: true,
@@ -80,34 +80,45 @@ export class PageOperations {
                 throw new McpError(ErrorCode.InternalError, `Failed to create page: ${error instanceof Error ? error.message : String(error)}`);
             }
         }
-        // If content is provided, check if it looks like nested markdown
-        if (content) {
+        // If content is provided, create blocks using batch operations
+        if (content && content.length > 0) {
             try {
-                const isMultilined = content.includes('\n') || hasMarkdownTable(content);
-                if (isMultilined) {
-                    // Use import_nested_markdown functionality
-                    const convertedContent = convertToRoamMarkdown(content);
-                    const nodes = parseMarkdown(convertedContent);
-                    const actions = convertToRoamActions(nodes, pageUid, 'first');
-                    const result = await batchActions(this.graph, {
+                // Convert content array to MarkdownNode format expected by convertToRoamActions
+                const nodes = content.map(block => ({
+                    content: block.text,
+                    level: block.level,
+                    children: []
+                }));
+                // Create hierarchical structure based on levels
+                const rootNodes = [];
+                const levelMap = {};
+                for (const node of nodes) {
+                    if (node.level === 1) {
+                        rootNodes.push(node);
+                        levelMap[1] = node;
+                    }
+                    else {
+                        const parentLevel = node.level - 1;
+                        const parent = levelMap[parentLevel];
+                        if (!parent) {
+                            throw new Error(`Invalid block hierarchy: level ${node.level} block has no parent`);
+                        }
+                        parent.children.push(node);
+                        levelMap[node.level] = node;
+                    }
+                }
+                // Generate batch actions for all blocks
+                const actions = convertToRoamActions(rootNodes, pageUid, 'last');
+                // Execute batch operation
+                if (actions.length > 0) {
+                    const batchResult = await batchActions(this.graph, {
                         action: 'batch-actions',
                         actions
                     });
-                    if (!result) {
-                        throw new Error('Failed to import nested markdown content');
+                    if (!batchResult) {
+                        throw new Error('Failed to create blocks');
                     }
                 }
-                else {
-                    // Create a simple block for non-nested content
-                    await createBlock(this.graph, {
-                        action: 'create-block',
-                        location: {
-                            "parent-uid": pageUid,
-                            "order": "last"
-                        },
-                        block: { string: content }
-                    });
-                }
             }
             catch (error) {
                 throw new McpError(ErrorCode.InternalError, `Failed to add content to page: ${error instanceof Error ? error.message : String(error)}`);

package/build/tools/schemas.js

@@ -20,13 +20,13 @@ export const toolSchemas = {
     },
     roam_fetch_page_by_title: {
         name: 'roam_fetch_page_by_title',
-        description: 'Retrieve complete page contents by exact title, including all nested blocks and resolved block references. Use for reading and analyzing existing Roam pages.',
+        description: 'Retrieve complete page contents by exact title, including all nested blocks and resolved block references. Use for accessing daily pages, reading and analyzing existing Roam pages.',
         inputSchema: {
             type: 'object',
             properties: {
                 title: {
                     type: 'string',
-                    description: 'Title of the page to fetch and read',
+                    description: 'Title of the page. For date pages, use ordinal date formats such as January 2nd, 2025',
                 },
             },
             required: ['title'],
@@ -34,7 +34,7 @@ export const toolSchemas = {
     },
     roam_create_page: {
         name: 'roam_create_page',
-        description: 'Create a new standalone page in Roam with optional content using markdown-style formatting. The nesting structure is inferred from markdown indentation (spaces). Best for:\n- Creating foundational concept pages that other pages will link to/from\n- Establishing new topic areas that need their own namespace\n- Setting up reference materials or documentation\n- Making permanent collections of information.',
+        description: 'Create a new standalone page in Roam with optional content using explicit nesting levels. Best for:\n- Creating foundational concept pages that other pages will link to/from\n- Establishing new topic areas that need their own namespace\n- Setting up reference materials or documentation\n- Making permanent collections of information.',
         inputSchema: {
             type: 'object',
             properties: {
@@ -43,8 +43,24 @@ export const toolSchemas = {
                     description: 'Title of the new page',
                 },
                 content: {
-                    type: 'string',
-                    description: 'Initial content for the page (optional). Each line becomes a separate block. Indentation (using spaces or tabs) determines the nesting level of each block.',
+                    type: 'array',
+                    description: 'Initial content for the page as an array of blocks with explicit nesting levels',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            text: {
+                                type: 'string',
+                                description: 'Content of the block'
+                            },
+                            level: {
+                                type: 'integer',
+                                description: 'Indentation level (1-10, where 1 is top level)',
+                                minimum: 1,
+                                maximum: 10
+                            }
+                        },
+                        required: ['text', 'level']
+                    }
                 },
             },
             required: ['title'],
@@ -236,11 +252,8 @@ export const toolSchemas = {
                     minimum: 1,
                     maximum: 10
                 }
-            },
-            oneOf: [
-                { required: ['parent_uid'] },
-                { required: ['child_uid'] }
-            ]
+            }
+            // Note: Validation for either parent_uid or child_uid is handled in the server code
         }
     },
     roam_find_pages_modified_today: {
@@ -249,13 +262,12 @@ export const toolSchemas = {
         inputSchema: {
             type: 'object',
             properties: {
-                num_pages: {
+                max_num_pages: {
                     type: 'integer',
-                    description: 'Number of result pages to retrieve (default: 10)',
-                    default: 10
+                    description: 'Max number of pages to retrieve (default: 50)',
+                    default: 50
                 },
-            },
-            required: ['num_pages']
+            }
         }
     },
     roam_search_by_text: {
@@ -278,7 +290,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.\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).',
+        description: 'Update a single block identified by its UID. Use this for individual block updates when you need to either replace the entire content or apply a transform pattern to modify specific parts of the 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: {
@@ -311,16 +323,13 @@ export const toolSchemas = {
                     required: ['find', 'replace']
                 }
             },
-            required: ['block_uid'],
-            oneOf: [
-                { required: ['content'] },
-                { required: ['transform_pattern'] }
-            ]
+            required: ['block_uid']
+            // Note: Validation for either content or transform_pattern is handled in the server code
         }
     },
-    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).',
+    roam_update_multiple_blocks: {
+        name: 'roam_update_multiple_blocks',
+        description: 'Efficiently update multiple blocks in a single batch operation. Use this when you need to update several blocks at once to avoid making multiple separate API calls. Each block in the batch can independently either have its content replaced or transformed using a 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: {
@@ -359,11 +368,8 @@ export const toolSchemas = {
                                 required: ['find', 'replace']
                             }
                         },
-                        required: ['block_uid'],
-                        oneOf: [
-                            { required: ['content'] },
-                            { required: ['transform'] }
-                        ]
+                        required: ['block_uid']
+                        // Note: Validation for either content or transform is handled in the server code
                     }
                 }
             },
@@ -372,7 +378,7 @@ export const toolSchemas = {
     },
     roam_search_by_date: {
         name: 'roam_search_by_date',
-        description: 'Search for blocks or pages based on creation or modification dates',
+        description: 'Search for blocks or pages based on creation or modification dates. Not for daily pages with ordinal date titles.',
         inputSchema: {
             type: 'object',
             properties: {

package/build/tools/tool-handlers.js

@@ -23,8 +23,8 @@ export class ToolHandlers {
         this.outlineOps = new OutlineOperations(graph);
     }
     // Page Operations
-    async findPagesModifiedToday(num_pages = 10) {
-        return this.pageOps.findPagesModifiedToday(num_pages);
+    async findPagesModifiedToday(max_num_pages = 50) {
+        return this.pageOps.findPagesModifiedToday(max_num_pages);
     }
     async createPage(title, content) {
         return this.pageOps.createPage(title, content);

package/package.json

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

package/build/test-addMarkdownText.js

@@ -1,87 +0,0 @@
-import { initializeGraph, createPage, batchActions, q } from '@roam-research/roam-api-sdk';
-import { parseMarkdown, convertToRoamActions } from '../src/markdown-utils.js';
-import * as dotenv from 'dotenv';
-import { fileURLToPath } from 'url';
-import { dirname, join } from 'path';
-// Load environment variables
-const scriptPath = fileURLToPath(import.meta.url);
-const projectRoot = dirname(dirname(scriptPath));
-const envPath = join(projectRoot, '.env');
-dotenv.config({ path: envPath });
-const API_TOKEN = process.env.ROAM_API_TOKEN;
-const GRAPH_NAME = process.env.ROAM_GRAPH_NAME;
-if (!API_TOKEN || !GRAPH_NAME) {
-    throw new Error('Missing required environment variables: ROAM_API_TOKEN and/or ROAM_GRAPH_NAME');
-}
-async function testAddMarkdownText() {
-    try {
-        // Initialize graph
-        console.log('Initializing graph...');
-        const graph = initializeGraph({
-            token: API_TOKEN,
-            graph: GRAPH_NAME,
-        });
-        // Test markdown content
-        const testPageTitle = `Test Markdown Import ${new Date().toISOString()}`;
-        console.log(`Using test page title: ${testPageTitle}`);
-        const markdownContent = `
-| Month    | Savings |
-| -------- | ------- |
-| January  | $250    |
-| February | $80     |
-| March    | $420    |
-
-# Main Topic
-- First point
-  - Nested point A
-    - Deep nested point
-  - Nested point B
-- Second point
-  1. Numbered subpoint
-  2. Another numbered point
-    - Mixed list type
-- Third point
-  - With some **bold** text
-  - And *italic* text
-    - And a [[Page Reference]]
-    - And a #[[Page Tag]]
-`;
-        // First create the page
-        console.log('\nCreating page...');
-        const success = await createPage(graph, {
-            action: 'create-page',
-            page: {
-                title: testPageTitle
-            }
-        });
-        if (!success) {
-            throw new Error('Failed to create test page');
-        }
-        // Get the page UID
-        const findQuery = `[:find ?uid :in $ ?title :where [?e :node/title ?title] [?e :block/uid ?uid]]`;
-        const findResults = await q(graph, findQuery, [testPageTitle]);
-        if (!findResults || findResults.length === 0) {
-            throw new Error('Could not find created page');
-        }
-        const pageUid = findResults[0][0];
-        console.log('Page UID:', pageUid);
-        // Import markdown
-        console.log('\nImporting markdown...');
-        const nodes = parseMarkdown(markdownContent);
-        console.log('Parsed nodes:', JSON.stringify(nodes, null, 2));
-        // Convert and add markdown content
-        const actions = convertToRoamActions(nodes, pageUid, 'last');
-        const result = await batchActions(graph, {
-            action: 'batch-actions',
-            actions
-        });
-        console.log('\nImport result:', JSON.stringify(result, null, 2));
-        console.log('\nTest completed successfully!');
-        console.log(`Check your Roam graph for the page titled: ${testPageTitle}`);
-    }
-    catch (error) {
-        console.error('Error:', error);
-    }
-}
-// Run the test
-testAddMarkdownText();

package/build/test-queries.js

@@ -1,116 +0,0 @@
-#!/usr/bin/env node
-import { initializeGraph, q } from '@roam-research/roam-api-sdk';
-import * as dotenv from 'dotenv';
-// Load environment variables
-dotenv.config();
-const API_TOKEN = process.env.ROAM_API_TOKEN;
-const GRAPH_NAME = process.env.ROAM_GRAPH_NAME;
-if (!API_TOKEN || !GRAPH_NAME) {
-    throw new Error('Missing required environment variables: ROAM_API_TOKEN and ROAM_GRAPH_NAME');
-}
-async function main() {
-    const graph = initializeGraph({
-        token: API_TOKEN,
-        graph: GRAPH_NAME,
-    });
-    try {
-        // First verify we can find the page
-        console.log('Finding page...');
-        const searchQuery = `[:find ?uid .
-                         :where [?e :node/title "December 18th, 2024"]
-                                [?e :block/uid ?uid]]`;
-        const uid = await q(graph, searchQuery, []);
-        console.log('Page UID:', uid);
-        if (!uid) {
-            throw new Error('Page not found');
-        }
-        // Get all blocks under this page with their order
-        console.log('\nGetting blocks...');
-        const blocksQuery = `[:find ?block-uid ?block-str ?order ?parent-uid
-                         :where [?p :block/uid "${uid}"]
-                                [?b :block/page ?p]
-                                [?b :block/uid ?block-uid]
-                                [?b :block/string ?block-str]
-                                [?b :block/order ?order]
-                                [?b :block/parents ?parent]
-                                [?parent :block/uid ?parent-uid]]`;
-        const blocks = await q(graph, blocksQuery, []);
-        console.log('Found', blocks.length, 'blocks');
-        // Create a map of all blocks
-        const blockMap = new Map();
-        blocks.forEach(([uid, string, order]) => {
-            if (!blockMap.has(uid)) {
-                blockMap.set(uid, {
-                    uid,
-                    string,
-                    order: order,
-                    children: []
-                });
-            }
-        });
-        console.log('Created block map with', blockMap.size, 'entries');
-        // Build parent-child relationships
-        let relationshipsBuilt = 0;
-        blocks.forEach(([childUid, _, __, parentUid]) => {
-            const child = blockMap.get(childUid);
-            const parent = blockMap.get(parentUid);
-            if (child && parent && !parent.children.includes(child)) {
-                parent.children.push(child);
-                relationshipsBuilt++;
-            }
-        });
-        console.log('Built', relationshipsBuilt, 'parent-child relationships');
-        // Get top-level blocks (those directly under the page)
-        console.log('\nGetting top-level blocks...');
-        const topQuery = `[:find ?block-uid ?block-str ?order
-                      :where [?p :block/uid "${uid}"]
-                             [?b :block/page ?p]
-                             [?b :block/uid ?block-uid]
-                             [?b :block/string ?block-str]
-                             [?b :block/order ?order]
-                             (not-join [?b]
-                               [?b :block/parents ?parent]
-                               [?parent :block/page ?p])]`;
-        const topBlocks = await q(graph, topQuery, []);
-        console.log('Found', topBlocks.length, 'top-level blocks');
-        // Create root blocks
-        const rootBlocks = topBlocks
-            .map(([uid, string, order]) => ({
-            uid,
-            string,
-            order: order,
-            children: blockMap.get(uid)?.children || []
-        }))
-            .sort((a, b) => a.order - b.order);
-        // Log block hierarchy
-        console.log('\nBlock hierarchy:');
-        const logHierarchy = (blocks, level = 0) => {
-            blocks.forEach(block => {
-                console.log('  '.repeat(level) + '- ' + block.string.substring(0, 50) + '...');
-                if (block.children.length > 0) {
-                    logHierarchy(block.children.sort((a, b) => a.order - b.order), level + 1);
-                }
-            });
-        };
-        logHierarchy(rootBlocks);
-        // Convert to markdown
-        console.log('\nConverting to markdown...');
-        const toMarkdown = (blocks, level = 0) => {
-            return blocks.map(block => {
-                const indent = '  '.repeat(level);
-                let md = `${indent}- ${block.string}\n`;
-                if (block.children.length > 0) {
-                    md += toMarkdown(block.children.sort((a, b) => a.order - b.order), level + 1);
-                }
-                return md;
-            }).join('');
-        };
-        const markdown = toMarkdown(rootBlocks);
-        console.log('\nMarkdown output:');
-        console.log(markdown);
-    }
-    catch (error) {
-        console.error('Error:', error);
-    }
-}
-main().catch(console.error);

package/build/tools/operations/search.js

@@ -1,285 +0,0 @@
-import { q } from '@roam-research/roam-api-sdk';
-import { McpError, ErrorCode } from '@modelcontextprotocol/sdk/types.js';
-import { BlockRefSearchHandler, HierarchySearchHandler, TextSearchHandler } from '../../search/index.js';
-export class SearchOperations {
-    graph;
-    constructor(graph) {
-        this.graph = graph;
-    }
-    async searchBlockRefs(params) {
-        const handler = new BlockRefSearchHandler(this.graph, params);
-        return handler.execute();
-    }
-    async searchHierarchy(params) {
-        const handler = new HierarchySearchHandler(this.graph, params);
-        return handler.execute();
-    }
-    async searchByText(params) {
-        const handler = new TextSearchHandler(this.graph, params);
-        return handler.execute();
-    }
-    async searchByStatus(status, page_title_uid, include, exclude, case_sensitive = true) {
-        // Get target page UID if provided
-        let targetPageUid;
-        if (page_title_uid) {
-            // Try to find page by title or UID
-            const findQuery = `[:find ?uid :in $ ?title :where [?e :node/title ?title] [?e :block/uid ?uid]]`;
-            const findResults = await q(this.graph, findQuery, [page_title_uid]);
-            if (findResults && findResults.length > 0) {
-                targetPageUid = findResults[0][0];
-            }
-            else {
-                // Try as UID
-                const uidQuery = `[:find ?uid :where [?e :block/uid "${page_title_uid}"] [?e :block/uid ?uid]]`;
-                const uidResults = await q(this.graph, uidQuery, []);
-                if (!uidResults || uidResults.length === 0) {
-                    throw new McpError(ErrorCode.InvalidRequest, `Page with title/UID "${page_title_uid}" not found`);
-                }
-                targetPageUid = uidResults[0][0];
-            }
-        }
-        // Build query based on whether we're searching in a specific page
-        let queryStr;
-        let queryParams;
-        const statusPattern = `{{[[${status}]]}}`;
-        if (targetPageUid) {
-            queryStr = `[:find ?block-uid ?block-str
-                  :in $ ?status-pattern ?page-uid
-                  :where [?p :block/uid ?page-uid]
-                         [?b :block/page ?p]
-                         [?b :block/string ?block-str]
-                         [?b :block/uid ?block-uid]
-                         [(clojure.string/includes? ?block-str ?status-pattern)]]`;
-            queryParams = [statusPattern, targetPageUid];
-        }
-        else {
-            queryStr = `[:find ?block-uid ?block-str ?page-title
-                  :in $ ?status-pattern
-                  :where [?b :block/string ?block-str]
-                         [?b :block/uid ?block-uid]
-                         [?b :block/page ?p]
-                         [?p :node/title ?page-title]
-                         [(clojure.string/includes? ?block-str ?status-pattern)]]`;
-            queryParams = [statusPattern];
-        }
-        const results = await q(this.graph, queryStr, queryParams);
-        if (!results || results.length === 0) {
-            return {
-                success: true,
-                matches: [],
-                message: `No blocks found with status ${status}`
-            };
-        }
-        // Format initial results
-        let matches = results.map(result => {
-            const [uid, content, pageTitle] = result;
-            return {
-                block_uid: uid,
-                content,
-                ...(pageTitle && { page_title: pageTitle })
-            };
-        });
-        // Post-query filtering with case sensitivity option
-        if (include) {
-            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.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,
-            matches,
-            message: `Found ${matches.length} block(s) with status ${status}${include ? ` including "${include}"` : ''}${exclude ? ` excluding "${exclude}"` : ''}`
-        };
-    }
-    async searchForTag(primary_tag, page_title_uid, near_tag, case_sensitive = true) {
-        // Ensure tags are properly formatted with #
-        const formatTag = (tag) => {
-            return tag.replace(/^#/, '').replace(/^\[\[/, '').replace(/\]\]$/, '');
-        };
-        // Extract the tag text, removing any formatting
-        const primaryTagFormatted = formatTag(primary_tag);
-        const nearTagFormatted = near_tag ? formatTag(near_tag) : undefined;
-        // Get target page UID if provided
-        let targetPageUid;
-        if (page_title_uid) {
-            // Try to find page by title or UID
-            const findQuery = `[:find ?uid :in $ ?title :where [?e :node/title ?title] [?e :block/uid ?uid]]`;
-            const findResults = await q(this.graph, findQuery, [page_title_uid]);
-            if (findResults && findResults.length > 0) {
-                targetPageUid = findResults[0][0];
-            }
-            else {
-                // Try as UID
-                const uidQuery = `[:find ?uid :where [?e :block/uid "${page_title_uid}"] [?e :block/uid ?uid]]`;
-                const uidResults = await q(this.graph, uidQuery, []);
-                if (!uidResults || uidResults.length === 0) {
-                    throw new McpError(ErrorCode.InvalidRequest, `Page with title/UID "${page_title_uid}" not found`);
-                }
-                targetPageUid = uidResults[0][0];
-            }
-        }
-        // Build query based on whether we're searching in a specific page and/or for a nearby tag
-        let queryStr;
-        let queryParams;
-        if (targetPageUid) {
-            if (nearTagFormatted) {
-                queryStr = `[:find ?block-uid ?block-str
-                    :in $ ?primary-tag ?near-tag ?page-uid
-                    :where [?p :block/uid ?page-uid]
-                           [?b :block/page ?p]
-                           [?b :block/string ?block-str]
-                           [?b :block/uid ?block-uid]
-                           [(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 {
-                queryStr = `[:find ?block-uid ?block-str
-                    :in $ ?primary-tag ?page-uid
-                    :where [?p :block/uid ?page-uid]
-                           [?b :block/page ?p]
-                           [?b :block/string ?block-str]
-                           [?b :block/uid ?block-uid]
-                           [(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];
-            }
-        }
-        else {
-            // Search across all pages
-            if (nearTagFormatted) {
-                queryStr = `[:find ?block-uid ?block-str ?page-title
-                    :in $ ?primary-tag ?near-tag
-                    :where [?b :block/string ?block-str]
-                           [?b :block/uid ?block-uid]
-                           [?b :block/page ?p]
-                           [?p :node/title ?page-title]
-                           [(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 {
-                queryStr = `[:find ?block-uid ?block-str ?page-title
-                    :in $ ?primary-tag
-                    :where [?b :block/string ?block-str]
-                           [?b :block/uid ?block-uid]
-                           [?b :block/page ?p]
-                           [?p :node/title ?page-title]
-                           [(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];
-            }
-        }
-        const results = await q(this.graph, queryStr, queryParams);
-        if (!results || results.length === 0) {
-            return {
-                success: true,
-                matches: [],
-                message: `No blocks found containing ${primaryTagFormatted}${nearTagFormatted ? ` near ${nearTagFormatted}` : ''}`
-            };
-        }
-        // Format results
-        const matches = results.map(([uid, content, pageTitle]) => ({
-            block_uid: uid,
-            content,
-            ...(pageTitle && { page_title: pageTitle })
-        }));
-        return {
-            success: true,
-            matches,
-            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`
-        };
-    }
-}