roam-research-mcp 0.2.0

package/build/server/roam-server.js

@@ -0,0 +1,108 @@
+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';
+export class RoamServer {
+    server;
+    toolHandlers;
+    constructor() {
+        const graph = initializeGraph({
+            token: API_TOKEN,
+            graph: GRAPH_NAME,
+        });
+        this.toolHandlers = new ToolHandlers(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: {}
+                },
+            },
+        });
+        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) }],
+                        };
+                    }
+                    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

@@ -0,0 +1,87 @@
+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

@@ -0,0 +1,116 @@
+#!/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);