roam-research-mcp 0.24.5 → 0.25.3

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.5',
+            version: '0.25.3',
         }, {
             capabilities: {
                 tools: {
@@ -81,8 +81,8 @@ export class RoamServer {
                         };
                     }
                     case 'roam_create_block': {
-                        const { content, page_uid, title } = request.params.arguments;
-                        const result = await this.toolHandlers.createBlock(content, page_uid, title);
+                        const { content, page_uid, title, heading } = request.params.arguments;
+                        const result = await this.toolHandlers.createBlock(content, page_uid, title, heading);
                         return {
                             content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
                         };
@@ -131,6 +131,10 @@ 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) }],
@@ -159,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);
@@ -182,6 +191,12 @@ export class RoamServer {
                     }
                     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/blocks.js

@@ -1,4 +1,4 @@
-import { q, createBlock as createRoamBlock, updateBlock as updateRoamBlock, batchActions, createPage } from '@roam-research/roam-api-sdk';
+import { q, updateBlock as updateRoamBlock, batchActions, createPage } 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';
@@ -7,7 +7,7 @@ export class BlockOperations {
     constructor(graph) {
         this.graph = graph;
     }
-    async createBlock(content, page_uid, title) {
+    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
@@ -68,9 +68,44 @@ export class BlockOperations {
         try {
             // If the content has multiple lines or is a table, use nested import
             if (content.includes('\n')) {
-                // Parse and import the nested content
-                const convertedContent = convertToRoamMarkdown(content);
-                const nodes = parseMarkdown(convertedContent);
+                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);
+                    // If we have simple newline-separated content (no markdown formatting),
+                    // and parseMarkdown created nodes at level 0, reverse them to maintain original order
+                    if (nodes.every(node => node.level === 0 && !node.heading_level)) {
+                        const lines = content.split('\n').filter(line => line.trim());
+                        if (lines.length === nodes.length) {
+                            nodes.reverse();
+                        }
+                    }
+                }
                 const actions = convertToRoamActions(nodes, targetPageUid, 'last');
                 // Execute batch actions to create the nested structure
                 const result = await batchActions(this.graph, {
@@ -88,27 +123,26 @@ export class BlockOperations {
                 };
             }
             else {
-                // For non-table content, create a simple block
-                await createRoamBlock(this.graph, {
-                    action: 'create-block',
-                    location: {
-                        "parent-uid": targetPageUid,
-                        "order": "last"
-                    },
-                    block: { string: content }
+                // 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
                 });
-                // Get the block's UID
-                const findBlockQuery = `[:find ?uid
-                               :in $ ?parent ?string
-                               :where [?b :block/uid ?uid]
-                                     [?b :block/string ?string]
-                                     [?b :block/parents ?p]
-                                     [?p :block/uid ?parent]]`;
-                const blockResults = await q(this.graph, findBlockQuery, [targetPageUid, content]);
-                if (!blockResults || blockResults.length === 0) {
-                    throw new Error('Could not find created block');
+                if (!result) {
+                    throw new Error('Failed to create block');
                 }
-                const blockUid = blockResults[0][0];
+                const blockUid = result.created_uids?.[0];
                 return {
                     success: true,
                     block_uid: blockUid,

package/build/tools/operations/pages.js

@@ -1,8 +1,8 @@
-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) {
@@ -80,34 +80,46 @@ 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,
+                    ...(block.heading && { heading_level: block.heading }),
+                    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)}`);
@@ -160,6 +172,21 @@ export class PageOperations {
         if (!blocks || blocks.length === 0) {
             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]
+                                 [?block :block/uid ?block-uid]
+                                 [?block :block/heading ?heading]
+                                 (ancestor ?block ?page)]`;
+        const headings = await q(this.graph, headingsQuery, [ancestorRule, title]);
+        // 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);
+            }
+        }
         // Create a map of all blocks
         const blockMap = new Map();
         const rootBlocks = [];
@@ -170,6 +197,7 @@ export class PageOperations {
                 uid: blockUid,
                 string: resolvedString,
                 order: order,
+                heading: headingMap.get(blockUid) || null,
                 children: []
             };
             blockMap.set(blockUid, block);
@@ -202,7 +230,17 @@ export class PageOperations {
         const toMarkdown = (blocks, level = 0) => {
             return blocks.map(block => {
                 const indent = '  '.repeat(level);
-                let md = `${indent}- ${block.string}`;
+                let md;
+                // Check block heading level and format accordingly
+                if (block.heading && block.heading > 0) {
+                    // Format as heading with appropriate number of hashtags
+                    const hashtags = '#'.repeat(block.heading);
+                    md = `${indent}${hashtags} ${block.string}`;
+                }
+                else {
+                    // No heading, use bullet point (current behavior)
+                    md = `${indent}- ${block.string}`;
+                }
                 if (block.children.length > 0) {
                     md += '\n' + toMarkdown(block.children, level + 1);
                 }

package/build/tools/schemas.js

@@ -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 new standalone page in Roam with optional content using explicit nesting levels and headings (H1-H3). 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,30 @@ 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
+                            },
+                            heading: {
+                                type: 'integer',
+                                description: 'Optional: Heading formatting for this block (1-3)',
+                                minimum: 1,
+                                maximum: 3
+                            }
+                        },
+                        required: ['text', 'level']
+                    }
                 },
             },
             required: ['title'],
@@ -52,7 +74,7 @@ export const toolSchemas = {
     },
     roam_create_block: {
         name: 'roam_create_block',
-        description: 'Add a new block to an existing Roam page. If no page specified, adds to today\'s daily note. Best for capturing immediate thoughts, additions to discussions, or content that doesn\'t warrant its own page. Can specify page by title or UID.\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: 'Add new block to an existing Roam page. If no page specified, adds to today\'s daily note. Best for capturing immediate thoughts, additions to discussions, or content that doesn\'t warrant its own page. Can specify page by title or UID.\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: {
@@ -68,6 +90,12 @@ export const toolSchemas = {
                     type: 'string',
                     description: 'Optional: Title of the page to add block to (defaults to today\'s date if neither page_uid nor title provided)',
                 },
+                heading: {
+                    type: 'integer',
+                    description: 'Optional: Heading formatting for this block (1-3)',
+                    minimum: 1,
+                    maximum: 3
+                }
             },
             required: ['content'],
         },
@@ -236,11 +264,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: {
@@ -310,11 +335,8 @@ 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_multiple_blocks: {
@@ -358,11 +380,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
                     }
                 }
             },

package/build/tools/tool-handlers.js

@@ -33,8 +33,8 @@ export class ToolHandlers {
         return this.pageOps.fetchPageByTitle(title);
     }
     // Block Operations
-    async createBlock(content, page_uid, title) {
-        return this.blockOps.createBlock(content, page_uid, title);
+    async createBlock(content, page_uid, title, heading) {
+        return this.blockOps.createBlock(content, page_uid, title, heading);
     }
     async updateBlock(block_uid, content, transform) {
         return this.blockOps.updateBlock(block_uid, content, transform);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "roam-research-mcp",
-  "version": "0.24.5",
+  "version": "0.25.3",
   "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`
-        };
-    }
-}