roam-research-mcp 2.4.0 → 2.13.0

package/build/cli/utils/graph.js

@@ -28,9 +28,13 @@ export function resolveGraph(options, isWriteOp = false) {
         const graphKey = options.graph ?? reg.defaultKey;
         if (!reg.isWriteAllowed(graphKey, options.writeKey)) {
             const config = reg.getConfig(graphKey);
-            if (config?.write_key) {
+            if (config?.protected) {
+                const systemWriteKey = process.env.ROAM_SYSTEM_WRITE_KEY;
+                if (!systemWriteKey) {
+                    throw new Error(`Write to protected graph "${graphKey}" failed: ROAM_SYSTEM_WRITE_KEY not configured.`);
+                }
                 throw new Error(`Write to "${graphKey}" graph requires --write-key confirmation.\n` +
-                    `Use: --write-key "${config.write_key}"`);
+                    `Use: --write-key "${systemWriteKey}"`);
             }
         }
     }

package/build/cli/utils/input.js

@@ -0,0 +1,10 @@
+/**
+ * Read all input from stdin
+ */
+export async function readStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(chunk);
+    }
+    return Buffer.concat(chunks).toString('utf-8');
+}

package/build/cli/utils/output.js

@@ -66,10 +66,9 @@ export function formatSearchResults(results, options) {
         return 'No results found.';
     }
     let output = `Found ${results.length} result(s):\n\n`;
-    results.forEach((result, index) => {
-        const pageInfo = result.page_title ? ` (${result.page_title})` : '';
-        output += `[${index + 1}] ${result.block_uid}${pageInfo}\n`;
-        output += `    ${result.content}\n\n`;
+    results.forEach((result) => {
+        const pageInfo = result.page_title ? ` — [[${result.page_title}]]` : '';
+        output += `[${result.block_uid}] ${result.content}${pageInfo}\n`;
     });
     return output.trim();
 }
@@ -102,7 +101,31 @@ export function formatTodoOutput(results, status, options) {
                 .replace(/\{\{TODO\}\}\s*/g, '')
                 .replace(/\{\{\[\[DONE\]\]\}\}\s*/g, '')
                 .replace(/\{\{DONE\}\}\s*/g, '');
-            output += `- [${status === 'DONE' ? 'x' : ' '}] ${cleanContent} (${item.block_uid})\n`;
+            output += `[${item.block_uid}] [${status === 'DONE' ? 'x' : ' '}] ${cleanContent}\n`;
+        }
+    }
+    return output.trim();
+}
+/**
+ * Format grouped search results for output
+ */
+export function formatGroupedOutput(grouped, options) {
+    if (options.json) {
+        return JSON.stringify(grouped, null, 2);
+    }
+    const { groups, meta } = grouped;
+    const groupKeys = Object.keys(groups);
+    if (groupKeys.length === 0) {
+        return 'No results found.';
+    }
+    let output = `Found ${meta.total} item(s) in ${meta.groups_count} group(s):\n`;
+    for (const groupName of groupKeys) {
+        const items = groups[groupName];
+        output += `\n## ${groupName}\n`;
+        for (const item of items) {
+            // Format: [uid] content with optional page reference
+            const pageRef = item.page_title ? ` — [[${item.page_title}]]` : '';
+            output += `[${item.block_uid}] ${item.content}${pageRef}\n`;
         }
     }
     return output.trim();

package/build/cli/utils/sort-group.js

@@ -0,0 +1,110 @@
+/**
+ * Sort search results by a specified field and direction
+ */
+export function sortResults(matches, options) {
+    const { field, direction } = options;
+    const multiplier = direction === 'asc' ? 1 : -1;
+    return [...matches].sort((a, b) => {
+        let comparison = 0;
+        switch (field) {
+            case 'created':
+                comparison = (a.created || 0) - (b.created || 0);
+                break;
+            case 'modified':
+                comparison = (a.modified || 0) - (b.modified || 0);
+                break;
+            case 'page':
+                comparison = (a.page_title || '').localeCompare(b.page_title || '');
+                break;
+        }
+        return comparison * multiplier;
+    });
+}
+/**
+ * Group search results by page title
+ */
+export function groupByPage(matches) {
+    const groups = {};
+    for (const match of matches) {
+        const key = match.page_title || '(No Page)';
+        if (!groups[key]) {
+            groups[key] = [];
+        }
+        groups[key].push(match);
+    }
+    return {
+        groups,
+        meta: {
+            total: matches.length,
+            groups_count: Object.keys(groups).length
+        }
+    };
+}
+/**
+ * Group search results by tag
+ * Matches are grouped by the most specific matching subtag of the search tag
+ * Each match appears only once, under its most specific matching tag
+ */
+export function groupByTag(matches, searchTag) {
+    const groups = {};
+    const normalizedSearchTag = normalizeTagName(searchTag);
+    for (const match of matches) {
+        const tags = match.tags || [];
+        // Find the most specific matching tag (longest path that starts with searchTag)
+        let bestTag = searchTag; // Default to the search tag itself
+        let bestLength = 0;
+        for (const tag of tags) {
+            const normalizedTag = normalizeTagName(tag);
+            // Check if this tag matches or is a subtag of the search tag
+            if (normalizedTag === normalizedSearchTag ||
+                normalizedTag.startsWith(normalizedSearchTag + '/')) {
+                if (normalizedTag.length > bestLength) {
+                    bestTag = tag;
+                    bestLength = normalizedTag.length;
+                }
+            }
+        }
+        // Group under the best matching tag
+        if (!groups[bestTag]) {
+            groups[bestTag] = [];
+        }
+        groups[bestTag].push(match);
+    }
+    // Sort groups by tag name for consistent output
+    const sortedGroups = {};
+    const sortedKeys = Object.keys(groups).sort();
+    for (const key of sortedKeys) {
+        sortedGroups[key] = groups[key];
+    }
+    return {
+        groups: sortedGroups,
+        meta: {
+            total: matches.length,
+            groups_count: Object.keys(sortedGroups).length
+        }
+    };
+}
+/**
+ * Group results by specified field
+ */
+export function groupResults(matches, options) {
+    switch (options.by) {
+        case 'page':
+            return groupByPage(matches);
+        case 'tag':
+            return groupByTag(matches, options.searchTag || '');
+    }
+}
+/**
+ * Normalize tag name for comparison (lowercase, trim whitespace)
+ */
+function normalizeTagName(tag) {
+    return tag.toLowerCase().trim();
+}
+/**
+ * Get default sort direction for a field
+ */
+export function getDefaultDirection(field) {
+    // Dates default to descending (newest first), alphabetical to ascending
+    return field === 'page' ? 'asc' : 'desc';
+}

package/build/config/graph-registry.js

@@ -4,7 +4,7 @@
  * Supports:
  * - Multiple graph configurations via ROAM_GRAPHS env var
  * - Backwards compatibility with single graph via ROAM_API_TOKEN/ROAM_GRAPH_NAME
- * - Write protection for non-default graphs via write_key confirmation
+ * - Write protection via protected: true flag + ROAM_SYSTEM_WRITE_KEY env var
  * - Lazy graph initialization (connects only when first accessed)
  */
 import { initializeGraph } from '@roam-research/roam-api-sdk';
@@ -54,6 +54,21 @@ export class GraphRegistry {
     getAvailableGraphs() {
         return Array.from(this.configs.keys());
     }
+    /**
+     * Get the memories tag for a graph
+     * Priority: graph config > ROAM_MEMORIES_TAG env var > "Memories"
+     * Returns null if explicitly disabled (memoriesTag: false)
+     */
+    getMemoriesTag(key) {
+        const resolvedKey = key ?? this.defaultKey;
+        const config = this.configs.get(resolvedKey);
+        // If explicitly disabled, return null
+        if (config?.memoriesTag === false) {
+            return null;
+        }
+        // Priority: per-graph config > env var > default
+        return config?.memoriesTag ?? process.env.ROAM_MEMORIES_TAG ?? 'Memories';
+    }
     /**
      * Get an initialized Graph instance, creating it lazily if needed
      * @param key - Graph key from config. Defaults to defaultKey if not specified.
@@ -84,8 +99,8 @@ export class GraphRegistry {
      * Rules:
      * - Writes to default graph are always allowed
      * - Writes to non-default graphs require:
-     *   - If write_key is configured: must provide matching write_key
-     *   - If no write_key configured: writes are allowed
+     *   - If protected: true, must provide matching ROAM_SYSTEM_WRITE_KEY
+     *   - If not protected: writes are allowed
      */
     isWriteAllowed(graphKey, providedWriteKey) {
         const resolvedKey = graphKey ?? this.defaultKey;
@@ -97,12 +112,13 @@ export class GraphRegistry {
         if (!config) {
             return false; // Unknown graph
         }
-        // If no write_key is configured, allow writes
-        if (!config.write_key) {
+        // If graph is not protected, allow writes
+        if (!config.protected) {
             return true;
         }
-        // Check if provided key matches
-        return providedWriteKey === config.write_key;
+        // Check if provided key matches ROAM_SYSTEM_WRITE_KEY
+        const systemWriteKey = process.env.ROAM_SYSTEM_WRITE_KEY;
+        return !!systemWriteKey && providedWriteKey === systemWriteKey;
     }
     /**
      * Validate write access and return an informative error if denied
@@ -117,9 +133,13 @@ export class GraphRegistry {
             if (!config) {
                 throw new McpError(ErrorCode.InvalidParams, `Unknown graph: "${resolvedKey}". Available graphs: ${this.getAvailableGraphs().join(', ')}`);
             }
+            const systemWriteKey = process.env.ROAM_SYSTEM_WRITE_KEY;
+            if (!systemWriteKey) {
+                throw new McpError(ErrorCode.InvalidParams, `Write to protected graph "${resolvedKey}" failed: ROAM_SYSTEM_WRITE_KEY not configured.`);
+            }
             // Provide informative error with the required key
             throw new McpError(ErrorCode.InvalidParams, `Write to "${resolvedKey}" graph requires write_key confirmation.\n` +
-                `Provide write_key: "${config.write_key}" to proceed.`);
+                `Provide write_key: "${systemWriteKey}" to proceed.`);
         }
     }
     /**
@@ -151,15 +171,13 @@ export class GraphRegistry {
         for (const key of graphKeys) {
             const config = this.configs.get(key);
             const isDefault = key === this.defaultKey;
-            const isProtected = !!config.write_key;
+            const isProtected = !!config.protected;
             const defaultCol = isDefault ? '✓' : '';
-            const protectedCol = isProtected
-                ? `Yes (requires \`write_key: "${config.write_key}"\`)`
-                : 'No';
+            const protectedCol = isProtected ? 'Yes' : 'No';
             lines.push(`| ${key} | ${defaultCol} | ${protectedCol} |`);
         }
         lines.push('');
-        lines.push('> **Note:** Write operations to protected graphs require the `write_key` parameter.');
+        lines.push('> **Note:** Write operations to protected graphs require the `write_key` parameter. The key will be shown in the error message if omitted.');
         lines.push('');
         lines.push('---');
         lines.push('');

package/build/config/graph-registry.test.js

@@ -1,6 +1,43 @@
-import { describe, it, expect } from 'vitest';
+import { describe, it, expect, afterEach } from 'vitest';
 import { GraphRegistry } from './graph-registry.js';
 describe('GraphRegistry', () => {
+    describe('getMemoriesTag', () => {
+        const originalEnv = process.env.ROAM_MEMORIES_TAG;
+        afterEach(() => {
+            // Restore original env
+            if (originalEnv !== undefined) {
+                process.env.ROAM_MEMORIES_TAG = originalEnv;
+            }
+            else {
+                delete process.env.ROAM_MEMORIES_TAG;
+            }
+        });
+        it('returns per-graph memoriesTag when configured', () => {
+            const registry = new GraphRegistry({
+                personal: { token: 't1', graph: 'g1', memoriesTag: '#PersonalMemories' },
+                system: { token: 't2', graph: 'g2', memoriesTag: '#[[PAI/Memories]]' },
+            }, 'personal');
+            expect(registry.getMemoriesTag('personal')).toBe('#PersonalMemories');
+            expect(registry.getMemoriesTag('system')).toBe('#[[PAI/Memories]]');
+        });
+        it('falls back to ROAM_MEMORIES_TAG env var when not configured per-graph', () => {
+            process.env.ROAM_MEMORIES_TAG = '#EnvMemories';
+            const registry = new GraphRegistry({ default: { token: 't', graph: 'g' } }, 'default');
+            expect(registry.getMemoriesTag()).toBe('#EnvMemories');
+        });
+        it('falls back to "Memories" when neither per-graph nor env configured', () => {
+            delete process.env.ROAM_MEMORIES_TAG;
+            const registry = new GraphRegistry({ default: { token: 't', graph: 'g' } }, 'default');
+            expect(registry.getMemoriesTag()).toBe('Memories');
+        });
+        it('uses default graph when key not specified', () => {
+            const registry = new GraphRegistry({
+                personal: { token: 't1', graph: 'g1', memoriesTag: '#Personal' },
+                work: { token: 't2', graph: 'g2', memoriesTag: '#Work' },
+            }, 'personal');
+            expect(registry.getMemoriesTag()).toBe('#Personal');
+        });
+    });
     describe('getGraphInfoMarkdown', () => {
         it('returns empty string for single-graph mode with default key', () => {
             const registry = new GraphRegistry({ default: { token: 'token', graph: 'graph' } }, 'default');
@@ -9,21 +46,21 @@ describe('GraphRegistry', () => {
         it('returns markdown table for multi-graph mode', () => {
             const registry = new GraphRegistry({
                 personal: { token: 'token1', graph: 'personal-graph' },
-                work: { token: 'token2', graph: 'work-graph', write_key: 'confirm' },
+                work: { token: 'token2', graph: 'work-graph', protected: true },
             }, 'personal');
             const markdown = registry.getGraphInfoMarkdown();
             expect(markdown).toContain('## Available Graphs');
             expect(markdown).toContain('| personal | ✓ | No |');
-            expect(markdown).toContain('| work |  | Yes (requires `write_key: "confirm"`) |');
+            expect(markdown).toContain('| work |  | Yes |');
             expect(markdown).toContain('> **Note:** Write operations to protected graphs');
         });
         it('shows write protection for default graph if configured', () => {
             const registry = new GraphRegistry({
-                main: { token: 'token1', graph: 'main-graph', write_key: 'secret' },
+                main: { token: 'token1', graph: 'main-graph', protected: true },
                 backup: { token: 'token2', graph: 'backup-graph' },
             }, 'main');
             const markdown = registry.getGraphInfoMarkdown();
-            expect(markdown).toContain('| main | ✓ | Yes (requires `write_key: "secret"`) |');
+            expect(markdown).toContain('| main | ✓ | Yes |');
             expect(markdown).toContain('| backup |  | No |');
         });
     });

package/build/markdown-utils.js

@@ -1,4 +1,7 @@
 import { randomBytes } from 'crypto';
+// Regex patterns for markdown elements
+const NUMBERED_LIST_REGEX = /^(\s*)\d+\.\s+(.*)$/;
+const HORIZONTAL_RULE_REGEX = /^(\s*)(-{3,}|\*{3,}|_{3,})\s*$/;
 /**
  * Check if text has a traditional markdown table
  */
@@ -61,6 +64,21 @@ function parseMarkdownHeadingLevel(text) {
     };
 }
 function convertToRoamMarkdown(text) {
+    // Protect inline code and code blocks from transformation
+    const codeBlocks = [];
+    // Use null bytes to create a unique placeholder that won't be transformed
+    const PLACEHOLDER_START = '\x00\x01CB';
+    const PLACEHOLDER_END = '\x02\x00';
+    // Extract code blocks (``` ... ```) first
+    text = text.replace(/```[\s\S]*?```/g, (match) => {
+        codeBlocks.push(match);
+        return `${PLACEHOLDER_START}${codeBlocks.length - 1}${PLACEHOLDER_END}`;
+    });
+    // Extract inline code (` ... `)
+    text = text.replace(/`[^`]+`/g, (match) => {
+        codeBlocks.push(match);
+        return `${PLACEHOLDER_START}${codeBlocks.length - 1}${PLACEHOLDER_END}`;
+    });
     // Handle double asterisks/underscores (bold)
     text = text.replace(/\*\*(.+?)\*\*/g, '**$1**'); // Preserve double asterisks
     // Handle single asterisks/underscores (italic)
@@ -73,6 +91,10 @@ function convertToRoamMarkdown(text) {
     text = text.replace(/- \[x\]/g, '- {{[[DONE]]}}');
     // Convert tables
     text = convertAllTables(text);
+    // Restore protected code blocks
+    text = text.replace(new RegExp(`${PLACEHOLDER_START}(\\d+)${PLACEHOLDER_END}`, 'g'), (_, index) => {
+        return codeBlocks[parseInt(index, 10)];
+    });
     return text;
 }
 function parseMarkdown(markdown) {
@@ -108,8 +130,13 @@ function parseMarkdown(markdown) {
         }
         if (inCodeBlockFirstPass || trimmedLine === '')
             continue;
+        // Check for numbered list, bullet list, or plain line
+        const numberedMatch = line.match(NUMBERED_LIST_REGEX);
         const bulletMatch = trimmedLine.match(/^(\s*)[-*+]\s+/);
-        if (bulletMatch) {
+        if (numberedMatch) {
+            indentationSet.add(numberedMatch[1].length);
+        }
+        else if (bulletMatch) {
             indentationSet.add(bulletMatch[1].length);
         }
         else {
@@ -214,10 +241,42 @@ function parseMarkdown(markdown) {
         if (trimmedLine === '') {
             continue;
         }
+        // Check for horizontal rule (---, ***, ___)
+        const hrMatch = line.match(HORIZONTAL_RULE_REGEX);
+        if (hrMatch) {
+            const hrIndentation = hrMatch[1].length;
+            const hrLevel = getLevel(hrIndentation);
+            const hrNode = {
+                content: '---', // Roam's HR format
+                level: hrLevel,
+                is_hr: true,
+                children: []
+            };
+            while (stack.length > hrLevel) {
+                stack.pop();
+            }
+            if (hrLevel === 0 || !stack[hrLevel - 1]) {
+                rootNodes.push(hrNode);
+                stack[0] = hrNode;
+            }
+            else {
+                stack[hrLevel - 1].children.push(hrNode);
+            }
+            stack[hrLevel] = hrNode;
+            continue;
+        }
         let indentation;
         let contentToParse;
+        let isNumberedItem = false;
+        // Check for numbered list item (1., 2., etc.)
+        const numberedMatch = line.match(NUMBERED_LIST_REGEX);
         const bulletMatch = trimmedLine.match(/^(\s*)[-*+]\s+/);
-        if (bulletMatch) {
+        if (numberedMatch) {
+            indentation = numberedMatch[1].length;
+            contentToParse = numberedMatch[2];
+            isNumberedItem = true;
+        }
+        else if (bulletMatch) {
             indentation = bulletMatch[1].length;
             contentToParse = trimmedLine.substring(bulletMatch[0].length);
         }
@@ -239,9 +298,16 @@ function parseMarkdown(markdown) {
         if (level === 0 || !stack[level - 1]) {
             rootNodes.push(node);
             stack[0] = node;
+            // Root-level numbered items: no parent to set view type on
+            // They'll appear as regular blocks (Roam doesn't support numbered view at root)
         }
         else {
-            stack[level - 1].children.push(node);
+            const parent = stack[level - 1];
+            parent.children.push(node);
+            // If this is the first numbered item under a parent, set parent's view type
+            if (isNumberedItem && parent.children_view_type !== 'numbered') {
+                parent.children_view_type = 'numbered';
+            }
         }
         stack[level] = node;
     }
@@ -302,6 +368,7 @@ function convertNodesToBlocks(nodes) {
         uid: generateBlockUid(),
         content: node.content,
         ...(node.heading_level && { heading_level: node.heading_level }), // Preserve heading level if present
+        ...(node.children_view_type && { children_view_type: node.children_view_type }), // Preserve view type for numbered lists
         children: convertNodesToBlocks(node.children)
     }));
 }
@@ -338,5 +405,48 @@ function convertToRoamActions(nodes, parentUid, order = 'last') {
     createBlockActions(blocks, parentUid, order);
     return actions;
 }
+/**
+ * Converts markdown nodes to Roam batch actions, grouped by nesting level.
+ * This ensures parent blocks exist before child blocks are created.
+ * Returns an array of action arrays, where index 0 contains root-level actions,
+ * index 1 contains first-level child actions, etc.
+ */
+function convertToRoamActionsStaged(nodes, parentUid, order = 'last') {
+    // First convert nodes to blocks with UIDs
+    const blocks = convertNodesToBlocks(nodes);
+    const actionsByLevel = [];
+    // Helper function to recursively create actions, tracking depth
+    function createBlockActions(blocks, parentUid, order, depth) {
+        // Ensure array exists for this depth
+        if (!actionsByLevel[depth]) {
+            actionsByLevel[depth] = [];
+        }
+        for (let i = 0; i < blocks.length; i++) {
+            const block = blocks[i];
+            // Create the current block
+            const action = {
+                action: 'create-block',
+                location: {
+                    'parent-uid': parentUid,
+                    order: typeof order === 'number' ? order + i : i
+                },
+                block: {
+                    uid: block.uid,
+                    string: block.content,
+                    ...(block.heading_level && { heading: block.heading_level }),
+                    ...(block.children_view_type && { 'children-view-type': block.children_view_type })
+                }
+            };
+            actionsByLevel[depth].push(action);
+            // Create child blocks if any
+            if (block.children.length > 0) {
+                createBlockActions(block.children, block.uid, 'last', depth + 1);
+            }
+        }
+    }
+    // Create all block actions starting at depth 0
+    createBlockActions(blocks, parentUid, order, 0);
+    return actionsByLevel;
+}
 // Export public functions and types
-export { parseMarkdown, convertToRoamActions, hasMarkdownTable, convertAllTables, convertToRoamMarkdown, parseMarkdownHeadingLevel };
+export { parseMarkdown, convertToRoamActions, convertToRoamActionsStaged, hasMarkdownTable, convertAllTables, convertToRoamMarkdown, parseMarkdownHeadingLevel };

package/build/markdown-utils.test.js

@@ -0,0 +1,125 @@
+import { describe, it, expect } from 'vitest';
+import { parseMarkdown, convertToRoamActions } from './markdown-utils.js';
+describe('markdown-utils', () => {
+    describe('parseMarkdown - numbered lists', () => {
+        it('should detect numbered list items and strip prefixes', () => {
+            const markdown = `1. First item
+2. Second item
+3. Third item`;
+            const nodes = parseMarkdown(markdown);
+            expect(nodes).toHaveLength(3);
+            expect(nodes[0].content).toBe('First item');
+            expect(nodes[1].content).toBe('Second item');
+            expect(nodes[2].content).toBe('Third item');
+            // Root-level numbered items don't get children_view_type (no parent)
+            expect(nodes[0].children_view_type).toBeUndefined();
+        });
+        it('should set children_view_type: numbered on parent of numbered items', () => {
+            const markdown = `Parent block
+  1. First numbered
+  2. Second numbered`;
+            const nodes = parseMarkdown(markdown);
+            expect(nodes).toHaveLength(1);
+            expect(nodes[0].content).toBe('Parent block');
+            expect(nodes[0].children_view_type).toBe('numbered');
+            expect(nodes[0].children).toHaveLength(2);
+            expect(nodes[0].children[0].content).toBe('First numbered');
+            expect(nodes[0].children[1].content).toBe('Second numbered');
+        });
+        it('should handle nested numbered lists', () => {
+            const markdown = `- Parent
+  1. First
+  2. Second
+    1. Nested first
+    2. Nested second`;
+            const nodes = parseMarkdown(markdown);
+            expect(nodes).toHaveLength(1);
+            expect(nodes[0].content).toBe('Parent');
+            expect(nodes[0].children_view_type).toBe('numbered');
+            expect(nodes[0].children).toHaveLength(2);
+            expect(nodes[0].children[1].children_view_type).toBe('numbered');
+            expect(nodes[0].children[1].children).toHaveLength(2);
+        });
+        it('should handle mixed bullet and numbered lists', () => {
+            const markdown = `- Bullet item
+1. Numbered item
+- Another bullet`;
+            const nodes = parseMarkdown(markdown);
+            expect(nodes).toHaveLength(3);
+            expect(nodes[0].content).toBe('Bullet item');
+            expect(nodes[1].content).toBe('Numbered item');
+            expect(nodes[2].content).toBe('Another bullet');
+        });
+        it('should handle double-digit numbers', () => {
+            const markdown = `10. Tenth item
+11. Eleventh item
+99. Ninety-ninth item`;
+            const nodes = parseMarkdown(markdown);
+            expect(nodes).toHaveLength(3);
+            expect(nodes[0].content).toBe('Tenth item');
+            expect(nodes[1].content).toBe('Eleventh item');
+            expect(nodes[2].content).toBe('Ninety-ninth item');
+        });
+    });
+    describe('parseMarkdown - horizontal rules', () => {
+        it('should convert --- to Roam HR', () => {
+            const markdown = `Before
+---
+After`;
+            const nodes = parseMarkdown(markdown);
+            expect(nodes).toHaveLength(3);
+            expect(nodes[0].content).toBe('Before');
+            expect(nodes[1].content).toBe('---');
+            expect(nodes[1].is_hr).toBe(true);
+            expect(nodes[2].content).toBe('After');
+        });
+        it('should convert *** to Roam HR', () => {
+            const markdown = `Before
+***
+After`;
+            const nodes = parseMarkdown(markdown);
+            expect(nodes).toHaveLength(3);
+            expect(nodes[1].content).toBe('---');
+            expect(nodes[1].is_hr).toBe(true);
+        });
+        it('should convert ___ to Roam HR', () => {
+            const markdown = `Before
+___
+After`;
+            const nodes = parseMarkdown(markdown);
+            expect(nodes).toHaveLength(3);
+            expect(nodes[1].content).toBe('---');
+            expect(nodes[1].is_hr).toBe(true);
+        });
+        it('should handle longer HR variants', () => {
+            const markdown = `-----
+*****
+_______`;
+            const nodes = parseMarkdown(markdown);
+            expect(nodes).toHaveLength(3);
+            expect(nodes[0].content).toBe('---');
+            expect(nodes[1].content).toBe('---');
+            expect(nodes[2].content).toBe('---');
+        });
+        it('should not convert inline dashes', () => {
+            const markdown = `This has -- some dashes
+And this--too`;
+            const nodes = parseMarkdown(markdown);
+            expect(nodes).toHaveLength(2);
+            expect(nodes[0].is_hr).toBeUndefined();
+            expect(nodes[1].is_hr).toBeUndefined();
+        });
+    });
+    describe('convertToRoamActions - numbered lists', () => {
+        it('should include children-view-type in block action', () => {
+            const markdown = `Parent
+  1. First
+  2. Second`;
+            const nodes = parseMarkdown(markdown);
+            const actions = convertToRoamActions(nodes, 'test-page-uid');
+            // First action is the parent block
+            const parentAction = actions[0];
+            expect(parentAction.block['children-view-type']).toBe('numbered');
+        });
+    });
+});