roam-research-mcp 0.12.3 → 0.14.0

package/build/markdown-utils.js

@@ -69,18 +69,19 @@ function parseMarkdown(markdown) {
         let level = Math.floor(indentation / 2);
         // Extract content after bullet point or heading
         let content = trimmedLine;
-        if (trimmedLine.startsWith('#') || trimmedLine.includes('{{table}}')) {
+        content = trimmedLine.replace(/^\s*[-*+]\s+/, '');
+        if (trimmedLine.startsWith('#') || trimmedLine.includes('{{table}}') || (trimmedLine.startsWith('**') && trimmedLine.endsWith('**'))) {
             // Remove bullet point if it precedes a table marker
-            content = trimmedLine.replace(/^\s*[-*+]\s+/, '');
+            // content = trimmedLine.replace(/^\s*[-*+]\s+/, '');
             level = 0;
             // Reset stack but keep heading/table as parent
             stack.length = 1; // Keep only the heading/table
         }
-        else if (stack[0]?.content.startsWith('#') || stack[0]?.content.includes('{{table}}')) {
-            // If previous node was a heading or table marker, increase level by 1
+        else if (stack[0]?.content.startsWith('#') || stack[0]?.content.includes('{{table}}') || (stack[0]?.content.startsWith('**') && stack[0]?.content.endsWith('**'))) {
+            // If previous node was a heading or table marker or wrapped in double-asterisks, increase level by 1
             level = Math.max(level, 1);
             // Remove bullet point
-            content = trimmedLine.replace(/^\s*[-*+]\s+/, '');
+            // content = trimmedLine.replace(/^\s*[-*+]\s+/, '');
         }
         else {
             // Remove bullet point

package/build/search/block-ref-search.js

@@ -0,0 +1,72 @@
+import { q } from '@roam-research/roam-api-sdk';
+import { BaseSearchHandler } from './types.js';
+import { SearchUtils } from './utils.js';
+export class BlockRefSearchHandler extends BaseSearchHandler {
+    params;
+    constructor(graph, params) {
+        super(graph);
+        this.params = params;
+    }
+    async execute() {
+        const { block_uid, page_title_uid } = this.params;
+        // Get target page UID if provided
+        let targetPageUid;
+        if (page_title_uid) {
+            targetPageUid = await SearchUtils.findPageByTitleOrUid(this.graph, page_title_uid);
+        }
+        // Build query based on whether we're searching for references to a specific block
+        // or all block references within a page/graph
+        let queryStr;
+        let queryParams;
+        if (block_uid) {
+            // Search for references to a specific block
+            if (targetPageUid) {
+                queryStr = `[:find ?block-uid ?block-str
+                    :in $ ?ref-uid ?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 ?ref-uid)]]`;
+                queryParams = [`((${block_uid}))`, targetPageUid];
+            }
+            else {
+                queryStr = `[:find ?block-uid ?block-str ?page-title
+                    :in $ ?ref-uid
+                    :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 ?ref-uid)]]`;
+                queryParams = [`((${block_uid}))`];
+            }
+        }
+        else {
+            // Search for any block references
+            if (targetPageUid) {
+                queryStr = `[:find ?block-uid ?block-str
+                    :in $ ?page-uid
+                    :where [?p :block/uid ?page-uid]
+                           [?b :block/page ?p]
+                           [?b :block/string ?block-str]
+                           [?b :block/uid ?block-uid]
+                           [(re-find #"\\(\\([^)]+\\)\\)" ?block-str)]]`;
+                queryParams = [targetPageUid];
+            }
+            else {
+                queryStr = `[:find ?block-uid ?block-str ?page-title
+                    :where [?b :block/string ?block-str]
+                           [?b :block/uid ?block-uid]
+                           [?b :block/page ?p]
+                           [?p :node/title ?page-title]
+                           [(re-find #"\\(\\([^)]+\\)\\)" ?block-str)]]`;
+                queryParams = [];
+            }
+        }
+        const results = await q(this.graph, queryStr, queryParams);
+        const searchDescription = block_uid
+            ? `referencing block ((${block_uid}))`
+            : 'containing block references';
+        return SearchUtils.formatSearchResults(results, searchDescription, !targetPageUid);
+    }
+}

package/build/search/date-search.js

@@ -0,0 +1,38 @@
+import { q } from '@roam-research/roam-api-sdk';
+import { BaseSearchHandler } from './types.js';
+import { SearchUtils } from './utils.js';
+export class DateSearchHandler extends BaseSearchHandler {
+    params;
+    constructor(graph, params) {
+        super(graph);
+        this.params = params;
+    }
+    async execute() {
+        const { start_date, end_date, filter_tag } = this.params;
+        const [startDateFormatted, endDateFormatted] = SearchUtils.parseDateRange(start_date, end_date);
+        const filterTagFormatted = filter_tag ? `[[${filter_tag}]]` : undefined;
+        // Build Roam query string
+        const dateQuery = `{between: [[${startDateFormatted}]] [[${endDateFormatted}]]}`;
+        const query = filterTagFormatted
+            ? `{{query: {and: ${filterTagFormatted} ${dateQuery}}}}`
+            : `{{query: ${dateQuery}}}`;
+        // Log the query for debugging
+        console.log('Roam query:', query);
+        // Find blocks matching the query
+        const queryStr = `[:find ?block-uid ?block-str ?page-title
+                      :in $ ?query-str
+                      :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 ?query-str)]]`;
+        const results = await q(this.graph, queryStr, [query]);
+        const dateRange = start_date === end_date
+            ? `on ${SearchUtils.parseDate(start_date)}`
+            : `between ${SearchUtils.parseDate(start_date)} and ${SearchUtils.parseDate(end_date)}`;
+        const searchDescription = filterTagFormatted
+            ? `${dateRange} containing ${filterTagFormatted}`
+            : dateRange;
+        return SearchUtils.formatSearchResults(results, searchDescription, true);
+    }
+}

package/build/search/hierarchy-search.js

@@ -0,0 +1,101 @@
+import { q } from '@roam-research/roam-api-sdk';
+import { BaseSearchHandler } from './types.js';
+import { SearchUtils } from './utils.js';
+export class HierarchySearchHandler extends BaseSearchHandler {
+    params;
+    constructor(graph, params) {
+        super(graph);
+        this.params = params;
+    }
+    async execute() {
+        const { parent_uid, child_uid, page_title_uid, max_depth = 1 } = this.params;
+        if (!parent_uid && !child_uid) {
+            return {
+                success: false,
+                matches: [],
+                message: 'Either parent_uid or child_uid must be provided'
+            };
+        }
+        // Get target page UID if provided
+        let targetPageUid;
+        if (page_title_uid) {
+            targetPageUid = await SearchUtils.findPageByTitleOrUid(this.graph, page_title_uid);
+        }
+        let queryStr;
+        let queryParams;
+        if (parent_uid) {
+            // Search for children of a specific block
+            if (targetPageUid) {
+                queryStr = `[:find ?block-uid ?block-str ?depth
+                    :in $ ?parent-uid ?page-uid ?max-depth
+                    :where [?p :block/uid ?page-uid]
+                           [?parent :block/uid ?parent-uid]
+                           [?b :block/parents ?parent]
+                           [?b :block/string ?block-str]
+                           [?b :block/uid ?block-uid]
+                           [?b :block/page ?p]
+                           [(get-else $ ?b :block/path-length 1) ?depth]
+                           [(<= ?depth ?max-depth)]]`;
+                queryParams = [parent_uid, targetPageUid, max_depth];
+            }
+            else {
+                queryStr = `[:find ?block-uid ?block-str ?page-title ?depth
+                    :in $ ?parent-uid ?max-depth
+                    :where [?parent :block/uid ?parent-uid]
+                           [?b :block/parents ?parent]
+                           [?b :block/string ?block-str]
+                           [?b :block/uid ?block-uid]
+                           [?b :block/page ?p]
+                           [?p :node/title ?page-title]
+                           [(get-else $ ?b :block/path-length 1) ?depth]
+                           [(<= ?depth ?max-depth)]]`;
+                queryParams = [parent_uid, max_depth];
+            }
+        }
+        else {
+            // Search for parents of a specific block
+            if (targetPageUid) {
+                queryStr = `[:find ?block-uid ?block-str ?depth
+                    :in $ ?child-uid ?page-uid ?max-depth
+                    :where [?p :block/uid ?page-uid]
+                           [?child :block/uid ?child-uid]
+                           [?child :block/parents ?b]
+                           [?b :block/string ?block-str]
+                           [?b :block/uid ?block-uid]
+                           [?b :block/page ?p]
+                           [(get-else $ ?b :block/path-length 1) ?depth]
+                           [(<= ?depth ?max-depth)]]`;
+                queryParams = [child_uid, targetPageUid, max_depth];
+            }
+            else {
+                queryStr = `[:find ?block-uid ?block-str ?page-title ?depth
+                    :in $ ?child-uid ?max-depth
+                    :where [?child :block/uid ?child-uid]
+                           [?child :block/parents ?b]
+                           [?b :block/string ?block-str]
+                           [?b :block/uid ?block-uid]
+                           [?b :block/page ?p]
+                           [?p :node/title ?page-title]
+                           [(get-else $ ?b :block/path-length 1) ?depth]
+                           [(<= ?depth ?max-depth)]]`;
+                queryParams = [child_uid, max_depth];
+            }
+        }
+        const results = await q(this.graph, queryStr, queryParams);
+        // Format results to include depth information
+        const matches = results.map(([uid, content, pageTitle, depth]) => ({
+            block_uid: uid,
+            content,
+            depth: depth || 1,
+            ...(pageTitle && { page_title: pageTitle })
+        }));
+        const searchDescription = parent_uid
+            ? `children of block ${parent_uid} (max depth: ${max_depth})`
+            : `parents of block ${child_uid} (max depth: ${max_depth})`;
+        return {
+            success: true,
+            matches,
+            message: `Found ${matches.length} block(s) as ${searchDescription}`
+        };
+    }
+}

package/build/search/index.js

@@ -0,0 +1,6 @@
+export * from './types.js';
+export * from './utils.js';
+export * from './tag-search.js';
+export * from './status-search.js';
+export * from './block-ref-search.js';
+export * from './hierarchy-search.js';

package/build/search/status-search.js

@@ -0,0 +1,43 @@
+import { q } from '@roam-research/roam-api-sdk';
+import { BaseSearchHandler } from './types.js';
+import { SearchUtils } from './utils.js';
+export class StatusSearchHandler extends BaseSearchHandler {
+    params;
+    constructor(graph, params) {
+        super(graph);
+        this.params = params;
+    }
+    async execute() {
+        const { status, page_title_uid } = this.params;
+        // Get target page UID if provided
+        let targetPageUid;
+        if (page_title_uid) {
+            targetPageUid = await SearchUtils.findPageByTitleOrUid(this.graph, page_title_uid);
+        }
+        // Build query based on whether we're searching in a specific page
+        let queryStr;
+        let queryParams;
+        if (targetPageUid) {
+            queryStr = `[:find ?block-uid ?block-str
+                  :in $ ?status ?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 (str "{{[[" ?status "]]}}"))]]`;
+            queryParams = [status, targetPageUid];
+        }
+        else {
+            queryStr = `[:find ?block-uid ?block-str ?page-title
+                  :in $ ?status
+                  :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 (str "{{[[" ?status "]]}}"))]]`;
+            queryParams = [status];
+        }
+        const results = await q(this.graph, queryStr, queryParams);
+        return SearchUtils.formatSearchResults(results, `with status ${status}`, !targetPageUid);
+    }
+}

package/build/search/tag-search.js

@@ -0,0 +1,89 @@
+import { q } from '@roam-research/roam-api-sdk';
+import { BaseSearchHandler } from './types.js';
+import { SearchUtils } from './utils.js';
+export class TagSearchHandler extends BaseSearchHandler {
+    params;
+    constructor(graph, params) {
+        super(graph);
+        this.params = params;
+    }
+    async execute() {
+        const { primary_tag, page_title_uid, near_tag, exclude_tag } = this.params;
+        // Format tags to handle both # and [[]] formats
+        const primaryTagFormats = SearchUtils.formatTag(primary_tag);
+        const nearTagFormats = near_tag ? SearchUtils.formatTag(near_tag) : undefined;
+        const excludeTagFormats = exclude_tag ? SearchUtils.formatTag(exclude_tag) : undefined;
+        // Get target page UID if provided
+        let targetPageUid;
+        if (page_title_uid) {
+            targetPageUid = await SearchUtils.findPageByTitleOrUid(this.graph, page_title_uid);
+        }
+        // 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 (nearTagFormats) {
+                queryStr = `[:find ?block-uid ?block-str
+                    :in $ [?primary-tag1 ?primary-tag2] [?near-tag1 ?near-tag2] [?exclude-tag1 ?exclude-tag2] ?page-uid
+                    :where [?p :block/uid ?page-uid]
+                           [?b :block/page ?p]
+                           [?b :block/string ?block-str]
+                           [?b :block/uid ?block-uid]
+                           (or [(clojure.string/includes? ?block-str ?primary-tag1)]
+                               [(clojure.string/includes? ?block-str ?primary-tag2)])
+                           (or [(clojure.string/includes? ?block-str ?near-tag1)]
+                               [(clojure.string/includes? ?block-str ?near-tag2)])
+                           (not (or [(clojure.string/includes? ?block-str ?exclude-tag1)]
+                                  [(clojure.string/includes? ?block-str ?exclude-tag2)]))]`;
+                queryParams = [primaryTagFormats, nearTagFormats, excludeTagFormats || ['', ''], targetPageUid];
+            }
+            else {
+                queryStr = `[:find ?block-uid ?block-str
+                    :in $ [?primary-tag1 ?primary-tag2] [?exclude-tag1 ?exclude-tag2] ?page-uid
+                    :where [?p :block/uid ?page-uid]
+                           [?b :block/page ?p]
+                           [?b :block/string ?block-str]
+                           [?b :block/uid ?block-uid]
+                           (or [(clojure.string/includes? ?block-str ?primary-tag1)]
+                               [(clojure.string/includes? ?block-str ?primary-tag2)])
+                           (not (or [(clojure.string/includes? ?block-str ?exclude-tag1)]
+                                  [(clojure.string/includes? ?block-str ?exclude-tag2)]))]`;
+                queryParams = [primaryTagFormats, excludeTagFormats || ['', ''], targetPageUid];
+            }
+        }
+        else {
+            // Search across all pages
+            if (nearTagFormats) {
+                queryStr = `[:find ?block-uid ?block-str ?page-title
+                    :in $ [?primary-tag1 ?primary-tag2] [?near-tag1 ?near-tag2] [?exclude-tag1 ?exclude-tag2]
+                    :where [?b :block/string ?block-str]
+                           [?b :block/uid ?block-uid]
+                           [?b :block/page ?p]
+                           [?p :node/title ?page-title]
+                           (or [(clojure.string/includes? ?block-str ?primary-tag1)]
+                               [(clojure.string/includes? ?block-str ?primary-tag2)])
+                           (or [(clojure.string/includes? ?block-str ?near-tag1)]
+                               [(clojure.string/includes? ?block-str ?near-tag2)])
+                           (not (or [(clojure.string/includes? ?block-str ?exclude-tag1)]
+                                  [(clojure.string/includes? ?block-str ?exclude-tag2)]))]`;
+                queryParams = [primaryTagFormats, nearTagFormats, excludeTagFormats || ['', '']];
+            }
+            else {
+                queryStr = `[:find ?block-uid ?block-str ?page-title
+                    :in $ [?primary-tag1 ?primary-tag2] [?exclude-tag1 ?exclude-tag2]
+                    :where [?b :block/string ?block-str]
+                           [?b :block/uid ?block-uid]
+                           [?b :block/page ?p]
+                           [?p :node/title ?page-title]
+                           (or [(clojure.string/includes? ?block-str ?primary-tag1)]
+                               [(clojure.string/includes? ?block-str ?primary-tag2)])
+                           (not (or [(clojure.string/includes? ?block-str ?exclude-tag1)]
+                                  [(clojure.string/includes? ?block-str ?exclude-tag2)]))]`;
+                queryParams = [primaryTagFormats, excludeTagFormats || ['', '']];
+            }
+        }
+        const results = await q(this.graph, queryStr, queryParams);
+        const searchDescription = `containing ${primaryTagFormats.join(' or ')}${nearTagFormats ? ` near ${nearTagFormats.join(' or ')}` : ''}${excludeTagFormats ? ` excluding ${excludeTagFormats.join(' or ')}` : ''}`;
+        return SearchUtils.formatSearchResults(results, searchDescription, !targetPageUid);
+    }
+}

package/build/search/types.js

@@ -0,0 +1,7 @@
+// Base class for all search handlers
+export class BaseSearchHandler {
+    graph;
+    constructor(graph) {
+        this.graph = graph;
+    }
+}

package/build/search/utils.js

@@ -0,0 +1,98 @@
+import { ErrorCode, McpError } from '@modelcontextprotocol/sdk/types.js';
+import { q } from '@roam-research/roam-api-sdk';
+export class SearchUtils {
+    /**
+     * Find a page by title or UID
+     */
+    static async findPageByTitleOrUid(graph, titleOrUid) {
+        // Try to find page by title
+        const findQuery = `[:find ?uid :in $ ?title :where [?e :node/title ?title] [?e :block/uid ?uid]]`;
+        const findResults = await q(graph, findQuery, [titleOrUid]);
+        if (findResults && findResults.length > 0) {
+            return findResults[0][0];
+        }
+        // Try as UID
+        const uidQuery = `[:find ?uid :where [?e :block/uid "${titleOrUid}"] [?e :block/uid ?uid]]`;
+        const uidResults = await q(graph, uidQuery, []);
+        if (!uidResults || uidResults.length === 0) {
+            throw new McpError(ErrorCode.InvalidRequest, `Page with title/UID "${titleOrUid}" not found`);
+        }
+        return uidResults[0][0];
+    }
+    /**
+     * Format search results into a standard structure
+     */
+    static formatSearchResults(results, searchDescription, includePageTitle = true) {
+        if (!results || results.length === 0) {
+            return {
+                success: true,
+                matches: [],
+                message: `No blocks found ${searchDescription}`
+            };
+        }
+        const matches = results.map(([uid, content, pageTitle]) => ({
+            block_uid: uid,
+            content,
+            ...(includePageTitle && pageTitle && { page_title: pageTitle })
+        }));
+        return {
+            success: true,
+            matches,
+            message: `Found ${matches.length} block(s) ${searchDescription}`
+        };
+    }
+    /**
+     * Format a tag for searching, handling both # and [[]] formats
+     * @param tag Tag without prefix
+     * @returns Array of possible formats to search for
+     */
+    static formatTag(tag) {
+        // Remove any existing prefixes
+        const cleanTag = tag.replace(/^#|\[\[|\]\]$/g, '');
+        // Return both formats for comprehensive search
+        return [`#${cleanTag}`, `[[${cleanTag}]]`];
+    }
+    /**
+     * Parse a date string into a Roam-formatted date
+     */
+    static parseDate(dateStr) {
+        const date = new Date(dateStr);
+        const months = [
+            'January', 'February', 'March', 'April', 'May', 'June',
+            'July', 'August', 'September', 'October', 'November', 'December'
+        ];
+        // Adjust for timezone to ensure consistent date comparison
+        const utcDate = new Date(date.getTime() + date.getTimezoneOffset() * 60000);
+        return `${months[utcDate.getMonth()]} ${utcDate.getDate()}${this.getOrdinalSuffix(utcDate.getDate())}, ${utcDate.getFullYear()}`;
+    }
+    /**
+     * Parse a date string into a Roam-formatted date range
+     * Returns [startDate, endDate] with endDate being inclusive (end of day)
+     */
+    static parseDateRange(startStr, endStr) {
+        const startDate = new Date(startStr);
+        const endDate = new Date(endStr);
+        endDate.setHours(23, 59, 59, 999); // Make end date inclusive
+        const months = [
+            'January', 'February', 'March', 'April', 'May', 'June',
+            'July', 'August', 'September', 'October', 'November', 'December'
+        ];
+        // Adjust for timezone
+        const utcStart = new Date(startDate.getTime() + startDate.getTimezoneOffset() * 60000);
+        const utcEnd = new Date(endDate.getTime() + endDate.getTimezoneOffset() * 60000);
+        return [
+            `${months[utcStart.getMonth()]} ${utcStart.getDate()}${this.getOrdinalSuffix(utcStart.getDate())}, ${utcStart.getFullYear()}`,
+            `${months[utcEnd.getMonth()]} ${utcEnd.getDate()}${this.getOrdinalSuffix(utcEnd.getDate())}, ${utcEnd.getFullYear()}`
+        ];
+    }
+    static getOrdinalSuffix(day) {
+        if (day > 3 && day < 21)
+            return 'th';
+        switch (day % 10) {
+            case 1: return 'st';
+            case 2: return 'nd';
+            case 3: return 'rd';
+            default: return 'th';
+        }
+    }
+}

package/build/server/roam-server.js

@@ -0,0 +1,145 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError, } from '@modelcontextprotocol/sdk/types.js';
+import { initializeGraph } from '@roam-research/roam-api-sdk';
+import { API_TOKEN, GRAPH_NAME } from '../config/environment.js';
+import { toolSchemas } from '../tools/schemas.js';
+import { ToolHandlers } from '../tools/handlers.js';
+import { TagSearchHandler, BlockRefSearchHandler, HierarchySearchHandler } from '../search/index.js';
+export class RoamServer {
+    server;
+    toolHandlers;
+    graph;
+    constructor() {
+        this.graph = initializeGraph({
+            token: API_TOKEN,
+            graph: GRAPH_NAME,
+        });
+        this.toolHandlers = new ToolHandlers(this.graph);
+        this.server = new Server({
+            name: 'roam-research',
+            version: '0.12.1',
+        }, {
+            capabilities: {
+                tools: {
+                    roam_add_todo: {},
+                    roam_fetch_page_by_title: {},
+                    roam_create_page: {},
+                    roam_create_block: {},
+                    roam_import_markdown: {},
+                    roam_create_outline: {},
+                    roam_search_for_tag: {},
+                    roam_search_by_status: {},
+                    roam_search_block_refs: {},
+                    roam_search_hierarchy: {}
+                },
+            },
+        });
+        this.setupRequestHandlers();
+        // Error handling
+        this.server.onerror = (error) => { };
+        process.on('SIGINT', async () => {
+            await this.server.close();
+            process.exit(0);
+        });
+    }
+    setupRequestHandlers() {
+        // List available tools
+        this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
+            tools: Object.values(toolSchemas),
+        }));
+        // Handle tool calls
+        this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+            try {
+                switch (request.params.name) {
+                    case 'roam_fetch_page_by_title': {
+                        const { title } = request.params.arguments;
+                        const content = await this.toolHandlers.fetchPageByTitle(title);
+                        return {
+                            content: [{ type: 'text', text: content }],
+                        };
+                    }
+                    case 'roam_create_page': {
+                        const { title, content } = request.params.arguments;
+                        const result = await this.toolHandlers.createPage(title, content);
+                        return {
+                            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                        };
+                    }
+                    case 'roam_create_block': {
+                        const { content, page_uid, title } = request.params.arguments;
+                        const result = await this.toolHandlers.createBlock(content, page_uid, title);
+                        return {
+                            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                        };
+                    }
+                    case 'roam_import_markdown': {
+                        const { content, page_uid, page_title, parent_uid, parent_string, order = 'first' } = request.params.arguments;
+                        const result = await this.toolHandlers.importMarkdown(content, page_uid, page_title, parent_uid, parent_string, order);
+                        return {
+                            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                        };
+                    }
+                    case 'roam_add_todo': {
+                        const { todos } = request.params.arguments;
+                        const result = await this.toolHandlers.addTodos(todos);
+                        return {
+                            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                        };
+                    }
+                    case 'roam_create_outline': {
+                        const { outline, page_title_uid, block_text_uid } = request.params.arguments;
+                        const result = await this.toolHandlers.createOutline(outline, page_title_uid, block_text_uid);
+                        return {
+                            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                        };
+                    }
+                    case 'roam_search_for_tag': {
+                        const params = request.params.arguments;
+                        const handler = new TagSearchHandler(this.graph, params);
+                        const result = await handler.execute();
+                        return {
+                            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                        };
+                    }
+                    case 'roam_search_by_status': {
+                        const { status, page_title_uid, include, exclude } = request.params.arguments;
+                        const result = await this.toolHandlers.searchByStatus(status, page_title_uid, include, exclude);
+                        return {
+                            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                        };
+                    }
+                    case 'roam_search_block_refs': {
+                        const params = request.params.arguments;
+                        const handler = new BlockRefSearchHandler(this.graph, params);
+                        const result = await handler.execute();
+                        return {
+                            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                        };
+                    }
+                    case 'roam_search_hierarchy': {
+                        const params = request.params.arguments;
+                        const handler = new HierarchySearchHandler(this.graph, params);
+                        const result = await handler.execute();
+                        return {
+                            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                        };
+                    }
+                    default:
+                        throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${request.params.name}`);
+                }
+            }
+            catch (error) {
+                if (error instanceof McpError) {
+                    throw error;
+                }
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                throw new McpError(ErrorCode.InternalError, `Roam API error: ${errorMessage}`);
+            }
+        });
+    }
+    async run() {
+        const transport = new StdioServerTransport();
+        await this.server.connect(transport);
+    }
+}

package/build/test-addMarkdownText.js

@@ -1,5 +1,5 @@
 import { initializeGraph, createPage, batchActions, q } from '@roam-research/roam-api-sdk';
-import { parseMarkdown, convertToRoamActions } from './markdown-utils.js';
+import { parseMarkdown, convertToRoamActions } from '../src/markdown-utils.js';
 import * as dotenv from 'dotenv';
 import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';