roam-research-mcp 2.4.0 → 2.13.0

package/build/search/text-search.js

@@ -1,33 +1,23 @@
 import { q } from '@roam-research/roam-api-sdk';
 import { BaseSearchHandler } from './types.js';
 import { SearchUtils } from './utils.js';
-import { resolveRefs } from '../tools/helpers/refs.js';
 export class TextSearchHandler extends BaseSearchHandler {
     constructor(graph, params) {
         super(graph);
         this.params = params;
     }
     async execute() {
-        const { text, page_title_uid, case_sensitive = false, limit = -1, offset = 0 } = this.params;
+        const { text, page_title_uid, case_sensitive = false, limit = -1, offset = 0, scope = 'blocks' } = this.params;
+        // Handle page_titles scope (namespace search)
+        if (scope === 'page_titles') {
+            return this.executePageTitleSearch();
+        }
         // Get target page UID if provided for scoped search
         let targetPageUid;
         if (page_title_uid) {
             targetPageUid = await SearchUtils.findPageByTitleOrUid(this.graph, page_title_uid);
         }
-        const searchTerms = [];
-        if (case_sensitive) {
-            searchTerms.push(text);
-        }
-        else {
-            searchTerms.push(text);
-            // Add capitalized version (e.g., "Hypnosis")
-            searchTerms.push(text.charAt(0).toUpperCase() + text.slice(1));
-            // Add all caps version (e.g., "HYPNOSIS")
-            searchTerms.push(text.toUpperCase());
-            // Add all lowercase version (e.g., "hypnosis")
-            searchTerms.push(text.toLowerCase());
-        }
-        const whereClauses = searchTerms.map(term => `[(clojure.string/includes? ?block-str "${term}")]`).join(' ');
+        const textSearchClause = SearchUtils.buildTextSearchClause(text, '?block-str', case_sensitive);
         let queryStr;
         let queryParams = [];
         let queryLimit = limit === -1 ? '' : `:limit ${limit}`;
@@ -35,13 +25,15 @@ export class TextSearchHandler extends BaseSearchHandler {
         let queryOrder = `:order ?page-edit-time asc ?block-uid asc`; // Sort by page edit time, then block UID
         let baseQueryWhereClauses = `
                     [?b :block/string ?block-str]
-                    (or ${whereClauses})
+                    ${textSearchClause}
                     [?b :block/uid ?block-uid]
                     [?b :block/page ?p]
                     [?p :node/title ?page-title]
-                    [?p :edit/time ?page-edit-time]`; // Fetch page edit time for sorting
+                    [?p :edit/time ?page-edit-time]
+                    [(get-else $ ?b :create/time 0) ?block-create-time]
+                    [(get-else $ ?b :edit/time 0) ?block-edit-time]`; // Fetch page edit time for sorting, block timestamps for sort/group
         if (targetPageUid) {
-            queryStr = `[:find ?block-uid ?block-str ?page-title
+            queryStr = `[:find ?block-uid ?block-str ?page-title ?block-create-time ?block-edit-time
                     :in $ ?page-uid ${queryLimit} ${queryOffset} ${queryOrder}
                     :where
                     ${baseQueryWhereClauses}
@@ -49,27 +41,78 @@ export class TextSearchHandler extends BaseSearchHandler {
             queryParams = [targetPageUid];
         }
         else {
-            queryStr = `[:find ?block-uid ?block-str ?page-title
+            queryStr = `[:find ?block-uid ?block-str ?page-title ?block-create-time ?block-edit-time
                     :in $ ${queryLimit} ${queryOffset} ${queryOrder}
                     :where
                     ${baseQueryWhereClauses}]`;
         }
         const rawResults = await q(this.graph, queryStr, queryParams);
         // Query to get total count without limit
-        const countQueryStr = `[:find (count ?b)
+        const baseCountWhere = baseQueryWhereClauses.replace(/\[\?p :edit\/time \?page-edit-time\]/, '');
+        let countQueryStr;
+        let countQueryParams = [];
+        if (targetPageUid) {
+            countQueryStr = `[:find (count ?b)
+                            :in $ ?page-uid
+                            :where
+                            ${baseCountWhere}
+                            [?p :block/uid ?page-uid]]`;
+            countQueryParams = [targetPageUid];
+        }
+        else {
+            countQueryStr = `[:find (count ?b)
                             :in $
                             :where
-                            ${baseQueryWhereClauses.replace(/\[\?p :edit\/time \?page-edit-time\]/, '')}]`; // Remove edit time for count query
-        const totalCountResults = await q(this.graph, countQueryStr, queryParams);
+                            ${baseCountWhere}]`;
+        }
+        const totalCountResults = await q(this.graph, countQueryStr, countQueryParams);
         const totalCount = totalCountResults[0] ? totalCountResults[0][0] : 0;
         // Resolve block references in content
-        const resolvedResults = await Promise.all(rawResults.map(async ([uid, content, pageTitle]) => {
-            const resolvedContent = await resolveRefs(this.graph, content);
-            return [uid, resolvedContent, pageTitle];
-        }));
+        const resolvedResults = await this.resolveBlockRefs(rawResults);
         const searchDescription = `containing "${text}"`;
         const formattedResults = SearchUtils.formatSearchResults(resolvedResults, searchDescription, !targetPageUid);
         formattedResults.total_count = totalCount;
         return formattedResults;
     }
+    /**
+     * Search for page titles matching a namespace prefix.
+     * Normalizes the search text to ensure trailing slash for prefix matching.
+     */
+    async executePageTitleSearch() {
+        const { text, limit = -1, offset = 0 } = this.params;
+        // Normalize namespace: ensure trailing slash for prefix matching
+        const namespace = text.endsWith('/') ? text : `${text}/`;
+        // Query for pages with titles starting with the namespace
+        const queryLimit = limit === -1 ? '' : `:limit ${limit}`;
+        const queryOffset = offset === 0 ? '' : `:offset ${offset}`;
+        const queryStr = `[:find ?title ?uid
+                      :in $ ${queryLimit} ${queryOffset}
+                      :where
+                      [?e :node/title ?title]
+                      [?e :block/uid ?uid]
+                      [(clojure.string/starts-with? ?title "${namespace}")]]`;
+        const rawResults = await q(this.graph, queryStr, []);
+        // Get total count
+        const countQueryStr = `[:find (count ?e)
+                           :in $
+                           :where
+                           [?e :node/title ?title]
+                           [(clojure.string/starts-with? ?title "${namespace}")]]`;
+        const totalCountResults = await q(this.graph, countQueryStr, []);
+        const totalCount = totalCountResults[0] ? totalCountResults[0][0] : 0;
+        // Format results: page UID as block_uid, title as content
+        const matches = rawResults.map(([title, uid]) => ({
+            block_uid: uid,
+            content: title,
+            page_title: title
+        }));
+        // Sort alphabetically by title
+        matches.sort((a, b) => a.content.localeCompare(b.content));
+        return {
+            success: true,
+            matches,
+            message: `Found ${matches.length} page(s) with namespace "${namespace}"`,
+            total_count: totalCount
+        };
+    }
 }

package/build/search/types.js

@@ -1,6 +1,19 @@
+import { resolveRefs } from '../tools/helpers/refs.js';
 // Base class for all search handlers
 export class BaseSearchHandler {
     constructor(graph) {
         this.graph = graph;
     }
+    /**
+     * Resolve block references in search results.
+     * Handles both 5-tuple [uid, content, pageTitle?, created?, modified?]
+     * and 3-tuple [uid, content, pageTitle?] formats.
+     */
+    async resolveBlockRefs(results) {
+        return Promise.all(results.map(async (result) => {
+            const [uid, content, ...rest] = result;
+            const resolvedContent = await resolveRefs(this.graph, content);
+            return [uid, resolvedContent, ...rest];
+        }));
+    }
 }

package/build/search/utils.js

@@ -21,6 +21,7 @@ export class SearchUtils {
     }
     /**
      * Format search results into a standard structure
+     * Supports both basic [uid, content, pageTitle?] and extended [uid, content, pageTitle?, created?, modified?] formats
      */
     static formatSearchResults(results, searchDescription, includePageTitle = true) {
         if (!results || results.length === 0) {
@@ -30,10 +31,12 @@ export class SearchUtils {
                 message: `No blocks found ${searchDescription}`
             };
         }
-        const matches = results.map(([uid, content, pageTitle]) => ({
+        const matches = results.map(([uid, content, pageTitle, created, modified]) => ({
             block_uid: uid,
             content,
-            ...(includePageTitle && pageTitle && { page_title: pageTitle })
+            ...(includePageTitle && pageTitle && { page_title: pageTitle }),
+            ...(created && { created }),
+            ...(modified && { modified })
         }));
         return {
             success: true,
@@ -95,4 +98,70 @@ export class SearchUtils {
             default: return 'th';
         }
     }
+    /**
+     * Fetch all tag references for a set of block UIDs
+     * Returns a map of block_uid -> array of tag titles
+     */
+    static async fetchBlockTags(graph, blockUids) {
+        if (blockUids.length === 0) {
+            return new Map();
+        }
+        // Build OR clause for all UIDs
+        const uidClauses = blockUids.map(uid => `[?b :block/uid "${uid}"]`).join(' ');
+        const queryStr = `[:find ?block-uid ?tag-title
+                      :where
+                      (or ${uidClauses})
+                      [?b :block/uid ?block-uid]
+                      [?b :block/refs ?ref]
+                      [?ref :node/title ?tag-title]]`;
+        const results = await q(graph, queryStr, []);
+        // Group tags by block UID
+        const tagMap = new Map();
+        for (const [uid, tag] of results) {
+            if (!tagMap.has(uid)) {
+                tagMap.set(uid, []);
+            }
+            tagMap.get(uid).push(tag);
+        }
+        return tagMap;
+    }
+    /**
+     * Generate case variations for case-insensitive search.
+     * Returns: [original, capitalized first letter, ALL CAPS, all lowercase]
+     */
+    static getCaseVariations(text, caseSensitive = false) {
+        if (caseSensitive) {
+            return [text];
+        }
+        return [
+            text,
+            text.charAt(0).toUpperCase() + text.slice(1),
+            text.toUpperCase(),
+            text.toLowerCase()
+        ];
+    }
+    /**
+     * Build OR where clause for case-insensitive text search.
+     * @param text - The search text
+     * @param variable - The Datomic variable name (e.g., "?block-str")
+     * @param caseSensitive - Whether to use case-sensitive matching
+     * @returns Datomic OR clause string
+     */
+    static buildTextSearchClause(text, variable, caseSensitive = false) {
+        const variations = this.getCaseVariations(text, caseSensitive);
+        const clauses = variations.map(term => `[(clojure.string/includes? ${variable} "${term}")]`);
+        return `(or ${clauses.join(' ')})`;
+    }
+    /**
+     * Build OR where clause for case-insensitive tag/page title matching.
+     * @param tag - The tag/page title to match
+     * @param variable - The Datomic variable name (e.g., "?ref-page")
+     * @param caseSensitive - Whether to use case-sensitive matching
+     * @returns Datomic OR clause string
+     */
+    static buildTagMatchClause(tag, variable, caseSensitive = false) {
+        const variations = this.getCaseVariations(tag, caseSensitive);
+        const clauses = variations.map(t => `[${variable} :node/title "${t}"]`);
+        return `(or ${clauses.join(' ')})`;
+    }
 }

package/build/server/roam-server.js

@@ -44,7 +44,8 @@ export class RoamServer {
         if (cached) {
             return cached;
         }
-        const handlers = new ToolHandlers(graph);
+        const memoriesTag = this.registry.getMemoriesTag(graphKey);
+        const handlers = new ToolHandlers(graph, memoriesTag);
         this.toolHandlersCache.set(graphKey, handlers);
         return handlers;
     }
@@ -120,8 +121,8 @@ export class RoamServer {
                         };
                     }
                     case 'roam_remember': {
-                        const { memory, categories, heading, parent_uid } = cleanedArgs;
-                        const result = await toolHandlers.remember(memory, categories, heading, parent_uid);
+                        const { memory, categories, heading, parent_uid, include_memories_tag } = cleanedArgs;
+                        const result = await toolHandlers.remember(memory, categories, heading, parent_uid, include_memories_tag);
                         return {
                             content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
                         };

package/build/shared/index.js

@@ -3,3 +3,5 @@
  */
 export * from './validation.js';
 export * from './errors.js';
+export * from './staged-batch.js';
+export * from './page-validator.js';

package/build/shared/page-validator.js

@@ -0,0 +1,233 @@
+/**
+ * Page existence validator for batch operations.
+ *
+ * Provides rate-limit-friendly validation of parent UIDs before batch execution.
+ * Uses caching and batched queries to minimize API calls.
+ *
+ * Key features:
+ * - Session-scoped cache for known UIDs (no stale data across restarts)
+ * - Single batched Datomic query to check multiple UIDs
+ * - Auto-creation of daily pages (detected by MM-DD-YYYY format)
+ * - Clear error messages for missing non-daily pages
+ */
+import { q, createPage as createRoamPage } from '@roam-research/roam-api-sdk';
+import { McpError, ErrorCode } from '@modelcontextprotocol/sdk/types.js';
+import { pageUidCache } from '../cache/page-uid-cache.js';
+import { isRateLimitError } from './errors.js';
+// Daily page UID format: MM-DD-YYYY (e.g., "01-25-2026")
+const DAILY_PAGE_UID_REGEX = /^(\d{2})-(\d{2})-(\d{4})$/;
+const DEFAULT_RATE_LIMIT_CONFIG = {
+    maxRetries: 3,
+    initialDelayMs: 1000,
+    maxDelayMs: 30000,
+    backoffMultiplier: 2
+};
+/**
+ * Sleep helper for delays.
+ */
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+/**
+ * Check if a UID matches the daily page format (MM-DD-YYYY).
+ * These pages can be safely auto-created.
+ */
+export function isDailyPageUid(uid) {
+    const match = uid.match(DAILY_PAGE_UID_REGEX);
+    if (!match)
+        return false;
+    const [, month, day, year] = match;
+    const m = parseInt(month, 10);
+    const d = parseInt(day, 10);
+    const y = parseInt(year, 10);
+    // Basic validation: month 1-12, day 1-31, year reasonable
+    return m >= 1 && m <= 12 && d >= 1 && d <= 31 && y >= 2000 && y <= 2100;
+}
+/**
+ * Convert daily page UID (MM-DD-YYYY) to Roam date title format.
+ * Example: "01-25-2026" -> "January 25th, 2026"
+ */
+export function dailyUidToTitle(uid) {
+    const match = uid.match(DAILY_PAGE_UID_REGEX);
+    if (!match) {
+        throw new Error(`Invalid daily page UID format: ${uid}`);
+    }
+    const [, month, day, year] = match;
+    const date = new Date(parseInt(year, 10), parseInt(month, 10) - 1, parseInt(day, 10));
+    const monthName = date.toLocaleString('en-US', { month: 'long' });
+    const dayNum = date.getDate();
+    const yearNum = date.getFullYear();
+    // Get ordinal suffix
+    const j = dayNum % 10;
+    const k = dayNum % 100;
+    let suffix;
+    if (j === 1 && k !== 11)
+        suffix = 'st';
+    else if (j === 2 && k !== 12)
+        suffix = 'nd';
+    else if (j === 3 && k !== 13)
+        suffix = 'rd';
+    else
+        suffix = 'th';
+    return `${monthName} ${dayNum}${suffix}, ${yearNum}`;
+}
+/**
+ * Batch check existence of multiple UIDs with a single Datomic query.
+ * Returns the set of UIDs that exist.
+ */
+async function batchCheckExistence(graph, uids, config = DEFAULT_RATE_LIMIT_CONFIG) {
+    if (uids.length === 0)
+        return new Set();
+    // Build query with IN clause for multiple UIDs
+    // This checks for any entity (page or block) with the given UID
+    const query = `[:find ?uid
+                  :in $ [?uid ...]
+                  :where [?e :block/uid ?uid]]`;
+    let lastError;
+    let delay = config.initialDelayMs;
+    for (let attempt = 0; attempt <= config.maxRetries; attempt++) {
+        try {
+            const results = await q(graph, query, [uids]);
+            const existingUids = new Set(results.map(([uid]) => uid));
+            return existingUids;
+        }
+        catch (error) {
+            if (!isRateLimitError(error)) {
+                throw error;
+            }
+            lastError = error;
+            if (attempt < config.maxRetries) {
+                const waitTime = Math.min(delay, config.maxDelayMs);
+                console.log(`[page-validator] Rate limited on existence check, retrying in ${waitTime}ms (attempt ${attempt + 1}/${config.maxRetries})`);
+                await sleep(waitTime);
+                delay *= config.backoffMultiplier;
+            }
+        }
+    }
+    throw new McpError(ErrorCode.InternalError, `Rate limit exceeded checking page existence after ${config.maxRetries} retries: ${lastError?.message || 'Unknown error'}`);
+}
+/**
+ * Batch create daily pages that don't exist.
+ * Uses Roam's createPage API.
+ */
+async function batchCreateDailyPages(graph, uids, config = DEFAULT_RATE_LIMIT_CONFIG) {
+    if (uids.length === 0)
+        return;
+    // Create pages sequentially with small delays to avoid rate limits
+    // Roam's createPage doesn't support true batching
+    for (const uid of uids) {
+        const title = dailyUidToTitle(uid);
+        let lastError;
+        let delay = config.initialDelayMs;
+        for (let attempt = 0; attempt <= config.maxRetries; attempt++) {
+            try {
+                await createRoamPage(graph, {
+                    action: 'create-page',
+                    page: { title, uid }
+                });
+                // Cache the created page
+                pageUidCache.onPageCreated(title, uid);
+                console.log(`[page-validator] Created daily page: ${title} (${uid})`);
+                // Small delay between page creations to be rate-limit friendly
+                if (uids.indexOf(uid) < uids.length - 1) {
+                    await sleep(200);
+                }
+                break; // Success, move to next page
+            }
+            catch (error) {
+                if (!isRateLimitError(error)) {
+                    // Non-rate-limit error - might be page already exists, which is OK
+                    const msg = error instanceof Error ? error.message : String(error);
+                    if (msg.includes('already exists') || msg.includes('duplicate')) {
+                        pageUidCache.addUid(uid);
+                        break;
+                    }
+                    throw error;
+                }
+                lastError = error;
+                if (attempt < config.maxRetries) {
+                    const waitTime = Math.min(delay, config.maxDelayMs);
+                    console.log(`[page-validator] Rate limited creating ${uid}, retrying in ${waitTime}ms (attempt ${attempt + 1}/${config.maxRetries})`);
+                    await sleep(waitTime);
+                    delay *= config.backoffMultiplier;
+                }
+            }
+        }
+        if (lastError && !pageUidCache.hasUid(uid)) {
+            throw new McpError(ErrorCode.InternalError, `Rate limit exceeded creating daily page ${uid} after ${config.maxRetries} retries: ${lastError.message}`);
+        }
+    }
+    // Final delay to let Roam's eventual consistency settle
+    if (uids.length > 0) {
+        await sleep(400);
+    }
+}
+/**
+ * Extract all unique parent-uid values from batch actions.
+ */
+export function extractParentUids(actions) {
+    const uids = new Set();
+    for (const action of actions) {
+        // Handle standard location format
+        const parentUid = action.location?.['parent-uid'];
+        if (parentUid && typeof parentUid === 'string') {
+            // Skip UID placeholders like {{uid:parent1}}
+            if (!parentUid.startsWith('{{uid:')) {
+                uids.add(parentUid);
+            }
+        }
+    }
+    return [...uids];
+}
+/**
+ * Validates all parent UIDs in a batch, auto-creating daily pages as needed.
+ * Returns after all targets are guaranteed to exist.
+ *
+ * This is the main entry point for batch operation validation.
+ *
+ * @param graph - Roam graph connection
+ * @param actions - Array of batch actions to validate
+ * @param config - Optional rate limit configuration
+ * @throws McpError if non-daily pages are missing
+ */
+export async function ensurePagesExist(graph, actions, config = DEFAULT_RATE_LIMIT_CONFIG) {
+    // 1. Extract unique parent UIDs from actions
+    const parentUids = extractParentUids(actions);
+    if (parentUids.length === 0) {
+        return { checked: 0, created: 0, cached: 0 };
+    }
+    // 2. Filter by cache - skip UIDs we know exist
+    const uncachedUids = parentUids.filter(uid => !pageUidCache.hasUid(uid));
+    const cachedCount = parentUids.length - uncachedUids.length;
+    if (uncachedUids.length === 0) {
+        // All UIDs are cached, no API calls needed
+        return { checked: 0, created: 0, cached: cachedCount };
+    }
+    // 3. Single batched query to check existence
+    const existingUids = await batchCheckExistence(graph, uncachedUids, config);
+    // 4. Update cache with found UIDs
+    pageUidCache.addUids([...existingUids]);
+    // 5. Determine what's missing
+    const missingUids = uncachedUids.filter(uid => !existingUids.has(uid));
+    if (missingUids.length === 0) {
+        return { checked: uncachedUids.length, created: 0, cached: cachedCount };
+    }
+    // 6. Separate daily pages from other pages
+    const dailyMissing = missingUids.filter(isDailyPageUid);
+    const otherMissing = missingUids.filter(uid => !isDailyPageUid(uid));
+    // 7. Fail fast if non-daily pages are missing
+    if (otherMissing.length > 0) {
+        const examples = otherMissing.slice(0, 3).join(', ');
+        const more = otherMissing.length > 3 ? ` and ${otherMissing.length - 3} more` : '';
+        throw new McpError(ErrorCode.InvalidParams, `Parent page(s) do not exist: ${examples}${more}. Create them first with roam_create_page or use a valid existing page UID.`);
+    }
+    // 8. Auto-create missing daily pages
+    if (dailyMissing.length > 0) {
+        await batchCreateDailyPages(graph, dailyMissing, config);
+    }
+    return {
+        checked: uncachedUids.length,
+        created: dailyMissing.length,
+        cached: cachedCount
+    };
+}

package/build/shared/page-validator.test.js

@@ -0,0 +1,128 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { isDailyPageUid, dailyUidToTitle, extractParentUids } from './page-validator.js';
+import { pageUidCache } from '../cache/page-uid-cache.js';
+describe('page-validator', () => {
+    beforeEach(() => {
+        pageUidCache.clear();
+    });
+    describe('isDailyPageUid', () => {
+        it('should recognize valid daily page UIDs', () => {
+            expect(isDailyPageUid('01-25-2026')).toBe(true);
+            expect(isDailyPageUid('12-31-2024')).toBe(true);
+            expect(isDailyPageUid('01-01-2000')).toBe(true);
+            expect(isDailyPageUid('06-15-2050')).toBe(true);
+        });
+        it('should reject invalid formats', () => {
+            // Wrong separators
+            expect(isDailyPageUid('01/25/2026')).toBe(false);
+            expect(isDailyPageUid('01.25.2026')).toBe(false);
+            // Wrong order (YYYY-MM-DD)
+            expect(isDailyPageUid('2026-01-25')).toBe(false);
+            // Standard 9-char block UID
+            expect(isDailyPageUid('abc123def')).toBe(false);
+            expect(isDailyPageUid('XrXmQJ-vO')).toBe(false);
+            // Too short/long
+            expect(isDailyPageUid('1-25-2026')).toBe(false);
+            expect(isDailyPageUid('001-25-2026')).toBe(false);
+        });
+        it('should reject invalid month/day values', () => {
+            expect(isDailyPageUid('13-25-2026')).toBe(false); // Month > 12
+            expect(isDailyPageUid('00-25-2026')).toBe(false); // Month = 0
+            expect(isDailyPageUid('01-32-2026')).toBe(false); // Day > 31
+            expect(isDailyPageUid('01-00-2026')).toBe(false); // Day = 0
+        });
+        it('should reject years outside reasonable range', () => {
+            expect(isDailyPageUid('01-25-1999')).toBe(false); // Year < 2000
+            expect(isDailyPageUid('01-25-2101')).toBe(false); // Year > 2100
+        });
+    });
+    describe('dailyUidToTitle', () => {
+        it('should convert UID to Roam date title format', () => {
+            expect(dailyUidToTitle('01-25-2026')).toBe('January 25th, 2026');
+            expect(dailyUidToTitle('12-31-2024')).toBe('December 31st, 2024');
+            expect(dailyUidToTitle('01-01-2025')).toBe('January 1st, 2025');
+            expect(dailyUidToTitle('02-02-2025')).toBe('February 2nd, 2025');
+            expect(dailyUidToTitle('03-03-2025')).toBe('March 3rd, 2025');
+            expect(dailyUidToTitle('04-04-2025')).toBe('April 4th, 2025');
+            expect(dailyUidToTitle('05-11-2025')).toBe('May 11th, 2025'); // 11th exception
+            expect(dailyUidToTitle('06-12-2025')).toBe('June 12th, 2025'); // 12th exception
+            expect(dailyUidToTitle('07-13-2025')).toBe('July 13th, 2025'); // 13th exception
+            expect(dailyUidToTitle('08-21-2025')).toBe('August 21st, 2025');
+            expect(dailyUidToTitle('09-22-2025')).toBe('September 22nd, 2025');
+            expect(dailyUidToTitle('10-23-2025')).toBe('October 23rd, 2025');
+        });
+        it('should throw for invalid format', () => {
+            expect(() => dailyUidToTitle('abc123def')).toThrow('Invalid daily page UID format');
+            expect(() => dailyUidToTitle('2026-01-25')).toThrow('Invalid daily page UID format');
+        });
+    });
+    describe('extractParentUids', () => {
+        it('should extract parent-uid from actions', () => {
+            const actions = [
+                { action: 'create-block', location: { 'parent-uid': 'abc123def' }, block: { string: 'test' } },
+                { action: 'create-block', location: { 'parent-uid': 'xyz789uvw' }, block: { string: 'test2' } }
+            ];
+            const uids = extractParentUids(actions);
+            expect(uids).toHaveLength(2);
+            expect(uids).toContain('abc123def');
+            expect(uids).toContain('xyz789uvw');
+        });
+        it('should deduplicate UIDs', () => {
+            const actions = [
+                { action: 'create-block', location: { 'parent-uid': 'abc123def' }, block: { string: 'test' } },
+                { action: 'create-block', location: { 'parent-uid': 'abc123def' }, block: { string: 'test2' } }
+            ];
+            const uids = extractParentUids(actions);
+            expect(uids).toHaveLength(1);
+            expect(uids[0]).toBe('abc123def');
+        });
+        it('should skip UID placeholders', () => {
+            const actions = [
+                { action: 'create-block', location: { 'parent-uid': '{{uid:parent1}}' }, block: { string: 'test' } },
+                { action: 'create-block', location: { 'parent-uid': 'abc123def' }, block: { string: 'test2' } }
+            ];
+            const uids = extractParentUids(actions);
+            expect(uids).toHaveLength(1);
+            expect(uids[0]).toBe('abc123def');
+        });
+        it('should handle actions without location', () => {
+            const actions = [
+                { action: 'update-block', uid: 'abc123def', block: { string: 'test' } },
+                { action: 'delete-block', uid: 'xyz789uvw' }
+            ];
+            const uids = extractParentUids(actions);
+            expect(uids).toHaveLength(0);
+        });
+        it('should handle empty actions', () => {
+            const uids = extractParentUids([]);
+            expect(uids).toHaveLength(0);
+        });
+    });
+    describe('pageUidCache integration', () => {
+        it('should track known UIDs', () => {
+            expect(pageUidCache.hasUid('abc123def')).toBe(false);
+            pageUidCache.addUid('abc123def');
+            expect(pageUidCache.hasUid('abc123def')).toBe(true);
+        });
+        it('should track multiple UIDs at once', () => {
+            pageUidCache.addUids(['uid1', 'uid2', 'uid3']);
+            expect(pageUidCache.hasUid('uid1')).toBe(true);
+            expect(pageUidCache.hasUid('uid2')).toBe(true);
+            expect(pageUidCache.hasUid('uid3')).toBe(true);
+            expect(pageUidCache.hasUid('uid4')).toBe(false);
+        });
+        it('should auto-add UID when setting title mapping', () => {
+            pageUidCache.set('Test Page', 'testuid12');
+            expect(pageUidCache.hasUid('testuid12')).toBe(true);
+        });
+        it('should clear both caches', () => {
+            pageUidCache.set('Test Page', 'testuid12');
+            pageUidCache.addUid('otheruid99');
+            expect(pageUidCache.size).toBe(1);
+            expect(pageUidCache.uidCacheSize).toBe(2);
+            pageUidCache.clear();
+            expect(pageUidCache.size).toBe(0);
+            expect(pageUidCache.uidCacheSize).toBe(0);
+        });
+    });
+});