roam-research-mcp 0.12.3 → 0.17.0

package/build/markdown-utils.js

@@ -41,25 +41,134 @@ function convertAllTables(text) {
         return '\n' + convertTableToRoamFormat(match) + '\n';
     });
 }
+/**
+ * Parse markdown heading syntax (e.g. "### Heading") and return the heading level (1-3) and content.
+ * Heading level is determined by the number of # characters (e.g. # = h1, ## = h2, ### = h3).
+ * Returns heading_level: 0 for non-heading content.
+ */
+function parseMarkdownHeadingLevel(text) {
+    const match = text.match(/^(#{1,3})\s+(.+)$/);
+    if (match) {
+        return {
+            heading_level: match[1].length, // Number of # characters determines heading level
+            content: match[2].trim()
+        };
+    }
+    return {
+        heading_level: 0, // Not a heading
+        content: text.trim()
+    };
+}
 function convertToRoamMarkdown(text) {
-    // First handle double asterisks/underscores (bold)
+    // Handle double asterisks/underscores (bold)
     text = text.replace(/\*\*(.+?)\*\*/g, '**$1**'); // Preserve double asterisks
-    // Then handle single asterisks/underscores (italic)
+    // Handle single asterisks/underscores (italic)
     text = text.replace(/(?<!\*)\*(?!\*)(.+?)(?<!\*)\*(?!\*)/g, '__$1__'); // Single asterisk to double underscore
     text = text.replace(/(?<!_)_(?!_)(.+?)(?<!_)_(?!_)/g, '__$1__'); // Single underscore to double underscore
     // Handle highlights
     text = text.replace(/==(.+?)==/g, '^^$1^^');
+    // Convert tasks
+    text = text.replace(/- \[ \]/g, '- {{[[TODO]]}}');
+    text = text.replace(/- \[x\]/g, '- {{[[DONE]]}}');
     // Convert tables
     text = convertAllTables(text);
     return text;
 }
 function parseMarkdown(markdown) {
+    // Convert markdown syntax first
+    markdown = convertToRoamMarkdown(markdown);
     const lines = markdown.split('\n');
     const rootNodes = [];
     const stack = [];
+    let inCodeBlock = false;
+    let codeBlockContent = '';
+    let codeBlockIndentation = 0;
+    let codeBlockParentLevel = 0;
     for (let i = 0; i < lines.length; i++) {
         const line = lines[i];
         const trimmedLine = line.trimEnd();
+        // Handle code blocks
+        if (trimmedLine.match(/^(\s*)```/)) {
+            if (!inCodeBlock) {
+                // Start of code block
+                inCodeBlock = true;
+                // Store the opening backticks without indentation
+                codeBlockContent = trimmedLine.trimStart() + '\n';
+                codeBlockIndentation = line.match(/^\s*/)?.[0].length ?? 0;
+                // Save current parent level
+                codeBlockParentLevel = stack.length;
+            }
+            else {
+                // End of code block
+                inCodeBlock = false;
+                // Add closing backticks without indentation
+                codeBlockContent += trimmedLine.trimStart();
+                // Process the code block content to fix indentation
+                const lines = codeBlockContent.split('\n');
+                // Find the first non-empty code line to determine base indentation
+                let baseIndentation = '';
+                let codeStartIndex = -1;
+                for (let i = 1; i < lines.length - 1; i++) {
+                    const line = lines[i];
+                    if (line.trim().length > 0) {
+                        const indentMatch = line.match(/^[\t ]*/);
+                        if (indentMatch) {
+                            baseIndentation = indentMatch[0];
+                            codeStartIndex = i;
+                            break;
+                        }
+                    }
+                }
+                // Process lines maintaining relative indentation from the first code line
+                const processedLines = lines.map((line, index) => {
+                    // Keep backticks as is
+                    if (index === 0 || index === lines.length - 1)
+                        return line.trimStart();
+                    // Empty lines should be completely trimmed
+                    if (line.trim().length === 0)
+                        return '';
+                    // For code lines, remove only the base indentation
+                    if (line.startsWith(baseIndentation)) {
+                        return line.slice(baseIndentation.length);
+                    }
+                    // If line has less indentation than base, trim all leading whitespace
+                    return line.trimStart();
+                });
+                // Create node for the entire code block
+                const level = Math.floor(codeBlockIndentation / 2);
+                const node = {
+                    content: processedLines.join('\n'),
+                    level,
+                    children: []
+                };
+                // Restore to code block's parent level
+                while (stack.length > codeBlockParentLevel) {
+                    stack.pop();
+                }
+                if (level === 0) {
+                    rootNodes.push(node);
+                    stack[0] = node;
+                }
+                else {
+                    while (stack.length > level) {
+                        stack.pop();
+                    }
+                    if (stack[level - 1]) {
+                        stack[level - 1].children.push(node);
+                    }
+                    else {
+                        rootNodes.push(node);
+                    }
+                    stack[level] = node;
+                }
+                codeBlockContent = '';
+            }
+            continue;
+        }
+        if (inCodeBlock) {
+            codeBlockContent += line + '\n';
+            continue;
+        }
         // Skip truly empty lines (no spaces)
         if (trimmedLine === '') {
             continue;
@@ -67,51 +176,54 @@ function parseMarkdown(markdown) {
         // Calculate indentation level (2 spaces = 1 level)
         const indentation = line.match(/^\s*/)?.[0].length ?? 0;
         let level = Math.floor(indentation / 2);
-        // Extract content after bullet point or heading
-        let content = trimmedLine;
-        if (trimmedLine.startsWith('#') || trimmedLine.includes('{{table}}')) {
-            // Remove bullet point if it precedes a table marker
-            content = trimmedLine.replace(/^\s*[-*+]\s+/, '');
-            level = 0;
-            // Reset stack but keep heading/table as parent
-            stack.length = 1; // Keep only the heading/table
+        // First check for headings
+        const { heading_level, content: headingContent } = parseMarkdownHeadingLevel(trimmedLine);
+        // Then handle bullet points if not a heading
+        let content;
+        if (heading_level > 0) {
+            content = headingContent; // Use clean heading content without # marks
+            level = 0; // Headings start at root level
+            stack.length = 1; // Reset stack but keep heading as parent
+            // Create heading node
+            const node = {
+                content,
+                level,
+                heading_level, // Store heading level in node
+                children: []
+            };
+            rootNodes.push(node);
+            stack[0] = node;
+            continue; // Skip to next line
         }
-        else if (stack[0]?.content.startsWith('#') || stack[0]?.content.includes('{{table}}')) {
-            // If previous node was a heading or table marker, increase level by 1
-            level = Math.max(level, 1);
-            // Remove bullet point
-            content = trimmedLine.replace(/^\s*[-*+]\s+/, '');
+        // Handle non-heading content
+        const bulletMatch = trimmedLine.match(/^(\s*)[-*+]\s+/);
+        if (bulletMatch) {
+            // For bullet points, use the bullet's indentation for level
+            content = trimmedLine.substring(bulletMatch[0].length);
+            level = Math.floor(bulletMatch[1].length / 2);
         }
         else {
-            // Remove bullet point
-            content = trimmedLine.replace(/^\s*[-*+]\s+/, '');
+            content = trimmedLine;
         }
-        // Create new node
+        // Create regular node
         const node = {
             content,
             level,
             children: []
         };
-        // Find the appropriate parent for this node based on level
-        if (level === 0) {
+        // Pop stack until we find the parent level
+        while (stack.length > level) {
+            stack.pop();
+        }
+        // Add to appropriate parent
+        if (level === 0 || !stack[level - 1]) {
             rootNodes.push(node);
             stack[0] = node;
         }
         else {
-            // Pop stack until we find the parent level
-            while (stack.length > level) {
-                stack.pop();
-            }
-            // Add as child to parent
-            if (stack[level - 1]) {
-                stack[level - 1].children.push(node);
-            }
-            else {
-                // If no parent found, treat as root node
-                rootNodes.push(node);
-            }
-            stack[level] = node;
+            stack[level - 1].children.push(node);
         }
+        stack[level] = node;
     }
     return rootNodes;
 }
@@ -167,12 +279,13 @@ function convertNodesToBlocks(nodes) {
     return nodes.map(node => ({
         uid: generateBlockUid(),
         content: node.content,
+        ...(node.heading_level && { heading_level: node.heading_level }), // Preserve heading level if present
         children: convertNodesToBlocks(node.children)
     }));
 }
 function convertToRoamActions(nodes, parentUid, order = 'last') {
-    // First convert nodes to blocks with UIDs
-    const blocks = convertNodesToBlocks(nodes);
+    // First convert nodes to blocks with UIDs, reversing to maintain original order
+    const blocks = convertNodesToBlocks([...nodes].reverse());
     const actions = [];
     // Helper function to recursively create actions
     function createBlockActions(blocks, parentUid, order) {
@@ -186,7 +299,8 @@ function convertToRoamActions(nodes, parentUid, order = 'last') {
                 },
                 block: {
                     uid: block.uid,
-                    string: block.content
+                    string: block.content,
+                    ...(block.heading_level && { heading: block.heading_level })
                 }
             };
             actions.push(action);
@@ -201,4 +315,4 @@ function convertToRoamActions(nodes, parentUid, order = 'last') {
     return actions;
 }
 // Export public functions and types
-export { parseMarkdown, convertToRoamActions, hasMarkdownTable, convertAllTables, convertToRoamMarkdown };
+export { parseMarkdown, convertToRoamActions, hasMarkdownTable, convertAllTables, convertToRoamMarkdown, parseMarkdownHeadingLevel };

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/hierarchy-search.js

@@ -0,0 +1,105 @@
+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);
+        }
+        // Define ancestor rule for recursive traversal
+        const ancestorRule = `[
+      [ (ancestor ?child ?parent) 
+          [?parent :block/children ?child] ]
+      [ (ancestor ?child ?a) 
+          [?parent :block/children ?child] 
+          (ancestor ?parent ?a) ]
+    ]`;
+        let queryStr;
+        let queryParams;
+        if (parent_uid) {
+            // Search for all descendants using ancestor rule
+            if (targetPageUid) {
+                queryStr = `[:find ?block-uid ?block-str ?depth
+                    :in $ % ?parent-uid ?page-uid
+                    :where [?p :block/uid ?page-uid]
+                           [?parent :block/uid ?parent-uid]
+                           (ancestor ?b ?parent)
+                           [?b :block/string ?block-str]
+                           [?b :block/uid ?block-uid]
+                           [?b :block/page ?p]
+                           [(get-else $ ?b :block/path-length 1) ?depth]]`;
+                queryParams = [ancestorRule, parent_uid, targetPageUid];
+            }
+            else {
+                queryStr = `[:find ?block-uid ?block-str ?page-title ?depth
+                    :in $ % ?parent-uid
+                    :where [?parent :block/uid ?parent-uid]
+                           (ancestor ?b ?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]]`;
+                queryParams = [ancestorRule, parent_uid];
+            }
+        }
+        else {
+            // Search for ancestors using the same rule
+            if (targetPageUid) {
+                queryStr = `[:find ?block-uid ?block-str ?depth
+                    :in $ % ?child-uid ?page-uid
+                    :where [?p :block/uid ?page-uid]
+                           [?child :block/uid ?child-uid]
+                           (ancestor ?child ?b)
+                           [?b :block/string ?block-str]
+                           [?b :block/uid ?block-uid]
+                           [?b :block/page ?p]
+                           [(get-else $ ?b :block/path-length 1) ?depth]]`;
+                queryParams = [ancestorRule, child_uid, targetPageUid];
+            }
+            else {
+                queryStr = `[:find ?block-uid ?block-str ?page-title ?depth
+                    :in $ % ?child-uid
+                    :where [?child :block/uid ?child-uid]
+                           (ancestor ?child ?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]]`;
+                queryParams = [ancestorRule, child_uid];
+            }
+        }
+        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
+            ? `descendants of block ${parent_uid}`
+            : `ancestors of block ${child_uid}`;
+        return {
+            success: true,
+            matches,
+            message: `Found ${matches.length} block(s) as ${searchDescription}`
+        };
+    }
+}

package/build/search/index.js

@@ -0,0 +1,7 @@
+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';
+export * from './text-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,35 @@
+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;
+        // Get target page UID if provided for scoped search
+        let targetPageUid;
+        if (page_title_uid) {
+            targetPageUid = await SearchUtils.findPageByTitleOrUid(this.graph, page_title_uid);
+        }
+        // Build query to find blocks referencing the page
+        const queryStr = `[:find ?block-uid ?block-str ?page-title
+                      :in $ ?title
+                      :where 
+                      [?ref-page :node/title ?title-match]
+                      [(clojure.string/lower-case ?title-match) ?lower-title]
+                      [(clojure.string/lower-case ?title) ?search-title]
+                      [(= ?lower-title ?search-title)]
+                      [?b :block/refs ?ref-page]
+                      [?b :block/string ?block-str]
+                      [?b :block/uid ?block-uid]
+                      [?b :block/page ?p]
+                      [?p :node/title ?page-title]]`;
+        const queryParams = [primary_tag];
+        const results = await q(this.graph, queryStr, queryParams);
+        const searchDescription = `referencing "${primary_tag}"`;
+        return SearchUtils.formatSearchResults(results, searchDescription, !targetPageUid);
+    }
+}

package/build/search/text-search.js

@@ -0,0 +1,32 @@
+import { q } from '@roam-research/roam-api-sdk';
+import { BaseSearchHandler } from './types.js';
+import { SearchUtils } from './utils.js';
+export class TextSearchHandler extends BaseSearchHandler {
+    params;
+    constructor(graph, params) {
+        super(graph);
+        this.params = params;
+    }
+    async execute() {
+        const { text, page_title_uid, case_sensitive = false } = this.params;
+        // Get target page UID if provided for scoped search
+        let targetPageUid;
+        if (page_title_uid) {
+            targetPageUid = await SearchUtils.findPageByTitleOrUid(this.graph, page_title_uid);
+        }
+        // Build query to find blocks containing the text
+        const queryStr = `[:find ?block-uid ?block-str ?page-title
+                      :in $ ?search-text
+                      :where 
+                      [?b :block/string ?block-str]
+                      [(clojure.string/includes? ${case_sensitive ? '?block-str' : '(clojure.string/lower-case ?block-str)'} 
+                                               ${case_sensitive ? '?search-text' : '(clojure.string/lower-case ?search-text)'})]
+                      [?b :block/uid ?block-uid]
+                      [?b :block/page ?p]
+                      [?p :node/title ?page-title]]`;
+        const queryParams = [text];
+        const results = await q(this.graph, queryStr, queryParams);
+        const searchDescription = `containing "${text}"${case_sensitive ? ' (case sensitive)' : ''}`;
+        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';
+        }
+    }
+}