roam-research-mcp 2.4.3 → 2.13.0

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');
+        });
+    });
+});

package/build/query/generator.js

@@ -0,0 +1,330 @@
+/**
+ * Datalog Generator for Roam Query AST
+ *
+ * Converts parsed query nodes into Datalog WHERE clauses
+ */
+export class DatalogGenerator {
+    constructor() {
+        this.refCounter = 0;
+        this.inputCounter = 0;
+    }
+    /**
+     * Generate Datalog clauses from a query AST
+     */
+    generate(node) {
+        this.refCounter = 0;
+        this.inputCounter = 0;
+        const clauses = this.generateNode(node, '?b');
+        return {
+            where: clauses.where,
+            inputs: clauses.inputs,
+            inputValues: clauses.inputValues
+        };
+    }
+    generateNode(node, blockVar) {
+        switch (node.type) {
+            case 'and':
+                return this.generateAnd(node.children, blockVar);
+            case 'or':
+                return this.generateOr(node.children, blockVar);
+            case 'not':
+                return this.generateNot(node.child, blockVar);
+            case 'between':
+                return this.generateBetween(node.startDate, node.endDate, blockVar);
+            case 'tag':
+                return this.generateTag(node.value, blockVar);
+            case 'block-ref':
+                return this.generateBlockRef(node.uid, blockVar);
+            case 'search':
+                return this.generateSearch(node.text, blockVar);
+            case 'daily-notes':
+                return this.generateDailyNotes(blockVar);
+            case 'by':
+                return this.generateBy(node.user, blockVar);
+            case 'created-by':
+                return this.generateCreatedBy(node.user, blockVar);
+            case 'edited-by':
+                return this.generateEditedBy(node.user, blockVar);
+        }
+    }
+    generateAnd(children, blockVar) {
+        const where = [];
+        const inputs = [];
+        const inputValues = [];
+        for (const child of children) {
+            const childClauses = this.generateNode(child, blockVar);
+            where.push(...childClauses.where);
+            inputs.push(...childClauses.inputs);
+            inputValues.push(...childClauses.inputValues);
+        }
+        return { where, inputs, inputValues };
+    }
+    generateOr(children, blockVar) {
+        const inputs = [];
+        const inputValues = [];
+        // For OR, we need to wrap each child's clauses in (or-join ...)
+        // to properly scope the variable bindings
+        const orBranches = [];
+        for (const child of children) {
+            const childClauses = this.generateNode(child, blockVar);
+            inputs.push(...childClauses.inputs);
+            inputValues.push(...childClauses.inputValues);
+            // Wrap multiple clauses in (and ...)
+            if (childClauses.where.length === 1) {
+                orBranches.push(childClauses.where[0]);
+            }
+            else {
+                orBranches.push(`(and ${childClauses.where.join(' ')})`);
+            }
+        }
+        const orClause = `(or-join [${blockVar}] ${orBranches.join(' ')})`;
+        return { where: [orClause], inputs, inputValues };
+    }
+    generateNot(child, blockVar) {
+        const childClauses = this.generateNode(child, blockVar);
+        // Wrap the child clauses in (not ...)
+        const notContent = childClauses.where.length === 1
+            ? childClauses.where[0]
+            : `(and ${childClauses.where.join(' ')})`;
+        const notClause = `(not ${notContent})`;
+        return {
+            where: [notClause],
+            inputs: childClauses.inputs,
+            inputValues: childClauses.inputValues
+        };
+    }
+    generateBetween(startDate, endDate, blockVar) {
+        // between matches blocks on daily pages within the date range
+        // or blocks with :create/time in the range
+        const startVar = `?start-date-${this.inputCounter++}`;
+        const endVar = `?end-date-${this.inputCounter++}`;
+        // Convert Roam date format to timestamp for comparison
+        // This assumes dates are in "January 1st, 2026" format
+        const startTs = this.roamDateToTimestamp(startDate);
+        const endTs = this.roamDateToTimestamp(endDate) + (24 * 60 * 60 * 1000 - 1); // End of day
+        const where = [
+            `[${blockVar} :create/time ?create-time]`,
+            `[(>= ?create-time ${startVar})]`,
+            `[(<= ?create-time ${endVar})]`
+        ];
+        return {
+            where,
+            inputs: [startVar, endVar],
+            inputValues: [startTs, endTs]
+        };
+    }
+    generateTag(tagName, blockVar) {
+        const refVar = `?ref-${this.refCounter++}`;
+        // A tag reference means the block has :block/refs pointing to a page with that title
+        const where = [
+            `[${refVar} :node/title "${this.escapeString(tagName)}"]`,
+            `[${blockVar} :block/refs ${refVar}]`
+        ];
+        return { where, inputs: [], inputValues: [] };
+    }
+    generateBlockRef(uid, blockVar) {
+        // Block ref means block references another block via ((uid)) syntax
+        // This can be through :block/refs or embedded in the string
+        const refVar = `?block-ref-${this.refCounter++}`;
+        const where = [
+            `[${refVar} :block/uid "${this.escapeString(uid)}"]`,
+            `[${blockVar} :block/refs ${refVar}]`
+        ];
+        return { where, inputs: [], inputValues: [] };
+    }
+    generateSearch(text, blockVar) {
+        // Search uses clojure.string/includes? to find text in block content
+        const where = [
+            `[(clojure.string/includes? ?block-str "${this.escapeString(text)}")]`
+        ];
+        return { where, inputs: [], inputValues: [] };
+    }
+    generateDailyNotes(blockVar) {
+        // Daily notes pages have titles matching the date pattern
+        // "January 1st, 2026" format - we use regex matching
+        const where = [
+            `[${blockVar} :block/page ?daily-page]`,
+            `[?daily-page :node/title ?daily-title]`,
+            `[(re-find #"^(January|February|March|April|May|June|July|August|September|October|November|December) \\d{1,2}(st|nd|rd|th), \\d{4}$" ?daily-title)]`
+        ];
+        return { where, inputs: [], inputValues: [] };
+    }
+    generateBy(user, blockVar) {
+        // "by" matches blocks created OR edited by the user
+        // Uses or-join to match either condition
+        const escapedUser = this.escapeString(user);
+        const where = [
+            `(or-join [${blockVar}]
+        (and [${blockVar} :create/user ?by-creator]
+             [?by-creator :user/display-name "${escapedUser}"])
+        (and [${blockVar} :edit/user ?by-editor]
+             [?by-editor :user/display-name "${escapedUser}"]))`
+        ];
+        return { where, inputs: [], inputValues: [] };
+    }
+    generateUserClause(user, blockVar, attribute, varName) {
+        const where = [
+            `[${blockVar} ${attribute} ?${varName}]`,
+            `[?${varName} :user/display-name "${this.escapeString(user)}"]`
+        ];
+        return { where, inputs: [], inputValues: [] };
+    }
+    generateCreatedBy(user, blockVar) {
+        return this.generateUserClause(user, blockVar, ':create/user', 'creator');
+    }
+    generateEditedBy(user, blockVar) {
+        return this.generateUserClause(user, blockVar, ':edit/user', 'editor');
+    }
+    /**
+     * Convert Roam date string to Unix timestamp
+     * Handles:
+     *   - Relative dates: "today", "yesterday", "last week", "last month", etc.
+     *   - Roam format: "January 1st, 2026"
+     *   - ISO format: "2026-01-01"
+     */
+    roamDateToTimestamp(dateStr) {
+        const normalized = dateStr.toLowerCase().trim();
+        // Check for relative dates first
+        const relativeDate = this.parseRelativeDate(normalized);
+        if (relativeDate !== null) {
+            return relativeDate;
+        }
+        // Remove ordinal suffixes (st, nd, rd, th)
+        const cleaned = dateStr.replace(/(\d+)(st|nd|rd|th)/, '$1');
+        const date = new Date(cleaned);
+        if (isNaN(date.getTime())) {
+            // If parsing fails, try as ISO date
+            const isoDate = new Date(dateStr);
+            if (!isNaN(isoDate.getTime())) {
+                return isoDate.getTime();
+            }
+            throw new Error(`Cannot parse date: ${dateStr}`);
+        }
+        return date.getTime();
+    }
+    /**
+     * Parse relative date strings like "today", "last week", "last month"
+     * Returns start-of-day timestamp or null if not a recognized relative date
+     */
+    parseRelativeDate(dateStr) {
+        const now = new Date();
+        const startOfToday = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+        switch (dateStr) {
+            case 'today':
+                return startOfToday.getTime();
+            case 'yesterday':
+                return new Date(startOfToday.getTime() - 24 * 60 * 60 * 1000).getTime();
+            case 'tomorrow':
+                return new Date(startOfToday.getTime() + 24 * 60 * 60 * 1000).getTime();
+            case 'last week':
+            case 'a week ago':
+                return new Date(startOfToday.getTime() - 7 * 24 * 60 * 60 * 1000).getTime();
+            case 'this week': {
+                // Start of current week (Sunday)
+                const dayOfWeek = now.getDay();
+                return new Date(startOfToday.getTime() - dayOfWeek * 24 * 60 * 60 * 1000).getTime();
+            }
+            case 'next week':
+                return new Date(startOfToday.getTime() + 7 * 24 * 60 * 60 * 1000).getTime();
+            case 'last month':
+            case 'a month ago': {
+                const lastMonth = new Date(now.getFullYear(), now.getMonth() - 1, now.getDate());
+                return lastMonth.getTime();
+            }
+            case 'this month': {
+                // Start of current month
+                return new Date(now.getFullYear(), now.getMonth(), 1).getTime();
+            }
+            case 'next month': {
+                const nextMonth = new Date(now.getFullYear(), now.getMonth() + 1, now.getDate());
+                return nextMonth.getTime();
+            }
+            case 'last year':
+            case 'a year ago': {
+                const lastYear = new Date(now.getFullYear() - 1, now.getMonth(), now.getDate());
+                return lastYear.getTime();
+            }
+            case 'this year': {
+                // Start of current year
+                return new Date(now.getFullYear(), 0, 1).getTime();
+            }
+            case 'next year': {
+                const nextYear = new Date(now.getFullYear() + 1, now.getMonth(), now.getDate());
+                return nextYear.getTime();
+            }
+            default:
+                // Check for "N days/weeks/months ago" pattern
+                const agoMatch = dateStr.match(/^(\d+)\s+(day|week|month|year)s?\s+ago$/);
+                if (agoMatch) {
+                    const amount = parseInt(agoMatch[1], 10);
+                    const unit = agoMatch[2];
+                    return this.subtractFromDate(startOfToday, amount, unit);
+                }
+                return null;
+        }
+    }
+    subtractFromDate(date, amount, unit) {
+        switch (unit) {
+            case 'day':
+                return new Date(date.getTime() - amount * 24 * 60 * 60 * 1000).getTime();
+            case 'week':
+                return new Date(date.getTime() - amount * 7 * 24 * 60 * 60 * 1000).getTime();
+            case 'month':
+                return new Date(date.getFullYear(), date.getMonth() - amount, date.getDate()).getTime();
+            case 'year':
+                return new Date(date.getFullYear() - amount, date.getMonth(), date.getDate()).getTime();
+            default:
+                return date.getTime();
+        }
+    }
+    escapeString(str) {
+        return str.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
+    }
+}
+/**
+ * Build a complete Datalog query from generated clauses
+ */
+export function buildDatalogQuery(clauses, options = {}) {
+    const { select = ['?block-uid', '?block-str', '?page-title'], limit, offset = 0, orderBy, pageUid } = options;
+    // Build :in clause
+    let inClause = ':in $';
+    if (clauses.inputs.length > 0) {
+        inClause += ' ' + clauses.inputs.join(' ');
+    }
+    if (pageUid) {
+        inClause += ' ?target-page-uid';
+    }
+    // Build modifiers
+    const modifiers = [];
+    if (limit !== undefined && limit !== -1) {
+        modifiers.push(`:limit ${limit}`);
+    }
+    if (offset > 0) {
+        modifiers.push(`:offset ${offset}`);
+    }
+    if (orderBy) {
+        modifiers.push(`:order ${orderBy}`);
+    }
+    // Build base WHERE clauses
+    const baseClauses = [
+        '[?b :block/string ?block-str]',
+        '[?b :block/uid ?block-uid]',
+        '[?b :block/page ?p]',
+        '[?p :node/title ?page-title]'
+    ];
+    if (pageUid) {
+        baseClauses.push('[?p :block/uid ?target-page-uid]');
+    }
+    // Combine all clauses
+    const allWhereClauses = [...baseClauses, ...clauses.where];
+    const query = `[:find ${select.join(' ')}
+                  ${inClause} ${modifiers.join(' ')}
+                  :where
+                  ${allWhereClauses.join('\n                  ')}]`;
+    // Build args
+    const args = [...clauses.inputValues];
+    if (pageUid) {
+        args.push(pageUid);
+    }
+    return { query, args };
+}