roam-research-mcp 1.3.2 → 1.6.0

package/build/diff/parser.test.js

@@ -0,0 +1,281 @@
+import { describe, it, expect } from 'vitest';
+import { parseExistingBlock, parseExistingBlocks, flattenExistingBlocks, markdownToBlocks, getBlockDepth, } from './parser.js';
+describe('parseExistingBlock', () => {
+    it('parses a simple block', () => {
+        const roamBlock = {
+            ':block/uid': 'abc123def',
+            ':block/string': 'Hello world',
+            ':block/order': 0,
+            ':block/heading': null,
+        };
+        const block = parseExistingBlock(roamBlock);
+        expect(block.uid).toBe('abc123def');
+        expect(block.text).toBe('Hello world');
+        expect(block.order).toBe(0);
+        expect(block.heading).toBeNull();
+        expect(block.children).toEqual([]);
+        expect(block.parentUid).toBeNull();
+    });
+    it('parses block with heading', () => {
+        const roamBlock = {
+            ':block/uid': 'heading1',
+            ':block/string': 'Title',
+            ':block/order': 0,
+            ':block/heading': 2,
+        };
+        const block = parseExistingBlock(roamBlock);
+        expect(block.heading).toBe(2);
+    });
+    it('parses nested children', () => {
+        const roamBlock = {
+            ':block/uid': 'parent',
+            ':block/string': 'Parent',
+            ':block/order': 0,
+            ':block/children': [
+                {
+                    ':block/uid': 'child1',
+                    ':block/string': 'Child 1',
+                    ':block/order': 0,
+                },
+                {
+                    ':block/uid': 'child2',
+                    ':block/string': 'Child 2',
+                    ':block/order': 1,
+                },
+            ],
+        };
+        const block = parseExistingBlock(roamBlock);
+        expect(block.children.length).toBe(2);
+        expect(block.children[0].uid).toBe('child1');
+        expect(block.children[0].parentUid).toBe('parent');
+        expect(block.children[1].uid).toBe('child2');
+        expect(block.children[1].parentUid).toBe('parent');
+    });
+    it('sorts children by order', () => {
+        const roamBlock = {
+            ':block/uid': 'parent',
+            ':block/string': 'Parent',
+            ':block/order': 0,
+            ':block/children': [
+                { ':block/uid': 'c', ':block/string': 'C', ':block/order': 2 },
+                { ':block/uid': 'a', ':block/string': 'A', ':block/order': 0 },
+                { ':block/uid': 'b', ':block/string': 'B', ':block/order': 1 },
+            ],
+        };
+        const block = parseExistingBlock(roamBlock);
+        expect(block.children.map((c) => c.uid)).toEqual(['a', 'b', 'c']);
+    });
+    it('handles missing properties gracefully', () => {
+        const roamBlock = {};
+        const block = parseExistingBlock(roamBlock);
+        expect(block.uid).toBe('');
+        expect(block.text).toBe('');
+        expect(block.order).toBe(0);
+        expect(block.heading).toBeNull();
+    });
+});
+describe('parseExistingBlocks', () => {
+    it('parses page children into blocks', () => {
+        const pageData = {
+            ':block/uid': 'page123',
+            ':block/children': [
+                { ':block/uid': 'b1', ':block/string': 'First', ':block/order': 0 },
+                { ':block/uid': 'b2', ':block/string': 'Second', ':block/order': 1 },
+            ],
+        };
+        const blocks = parseExistingBlocks(pageData);
+        expect(blocks.length).toBe(2);
+        expect(blocks[0].text).toBe('First');
+        expect(blocks[1].text).toBe('Second');
+        expect(blocks[0].parentUid).toBeNull();
+    });
+    it('returns empty array for page with no children', () => {
+        const pageData = { ':block/uid': 'page123' };
+        const blocks = parseExistingBlocks(pageData);
+        expect(blocks).toEqual([]);
+    });
+});
+describe('flattenExistingBlocks', () => {
+    it('flattens nested blocks into array', () => {
+        const blocks = [
+            {
+                uid: 'a',
+                text: 'A',
+                order: 0,
+                heading: null,
+                parentUid: null,
+                children: [
+                    {
+                        uid: 'a1',
+                        text: 'A1',
+                        order: 0,
+                        heading: null,
+                        parentUid: 'a',
+                        children: [],
+                    },
+                    {
+                        uid: 'a2',
+                        text: 'A2',
+                        order: 1,
+                        heading: null,
+                        parentUid: 'a',
+                        children: [],
+                    },
+                ],
+            },
+            {
+                uid: 'b',
+                text: 'B',
+                order: 1,
+                heading: null,
+                parentUid: null,
+                children: [],
+            },
+        ];
+        const flat = flattenExistingBlocks(blocks);
+        expect(flat.map((b) => b.uid)).toEqual(['a', 'a1', 'a2', 'b']);
+    });
+    it('preserves depth-first order', () => {
+        const blocks = [
+            {
+                uid: 'root',
+                text: 'Root',
+                order: 0,
+                heading: null,
+                parentUid: null,
+                children: [
+                    {
+                        uid: 'child1',
+                        text: 'Child 1',
+                        order: 0,
+                        heading: null,
+                        parentUid: 'root',
+                        children: [
+                            {
+                                uid: 'grandchild',
+                                text: 'Grandchild',
+                                order: 0,
+                                heading: null,
+                                parentUid: 'child1',
+                                children: [],
+                            },
+                        ],
+                    },
+                    {
+                        uid: 'child2',
+                        text: 'Child 2',
+                        order: 1,
+                        heading: null,
+                        parentUid: 'root',
+                        children: [],
+                    },
+                ],
+            },
+        ];
+        const flat = flattenExistingBlocks(blocks);
+        expect(flat.map((b) => b.uid)).toEqual([
+            'root',
+            'child1',
+            'grandchild',
+            'child2',
+        ]);
+    });
+    it('returns empty array for empty input', () => {
+        expect(flattenExistingBlocks([])).toEqual([]);
+    });
+});
+describe('markdownToBlocks', () => {
+    const pageUid = 'page123';
+    it('converts simple markdown to blocks', () => {
+        const markdown = `- First item
+- Second item`;
+        const blocks = markdownToBlocks(markdown, pageUid);
+        expect(blocks.length).toBe(2);
+        expect(blocks[0].text).toBe('First item');
+        expect(blocks[1].text).toBe('Second item');
+        expect(blocks[0].parentRef?.blockUid).toBe(pageUid);
+        expect(blocks[1].parentRef?.blockUid).toBe(pageUid);
+    });
+    it('handles nested markdown', () => {
+        const markdown = `- Parent
+  - Child`;
+        const blocks = markdownToBlocks(markdown, pageUid);
+        expect(blocks.length).toBe(2);
+        const parentBlock = blocks.find((b) => b.text === 'Parent');
+        const childBlock = blocks.find((b) => b.text === 'Child');
+        expect(parentBlock).toBeDefined();
+        expect(childBlock).toBeDefined();
+        expect(childBlock?.parentRef?.blockUid).toBe(parentBlock?.ref.blockUid);
+    });
+    it('preserves heading levels', () => {
+        const markdown = `# Heading 1
+## Heading 2
+### Heading 3`;
+        const blocks = markdownToBlocks(markdown, pageUid);
+        expect(blocks[0].heading).toBe(1);
+        expect(blocks[1].heading).toBe(2);
+        expect(blocks[2].heading).toBe(3);
+    });
+    it('generates unique UIDs', () => {
+        const markdown = `- Item 1
+- Item 2
+- Item 3`;
+        const blocks = markdownToBlocks(markdown, pageUid);
+        const uids = blocks.map((b) => b.ref.blockUid);
+        expect(new Set(uids).size).toBe(3); // All unique
+    });
+    it('sets order based on sibling position', () => {
+        const markdown = `- First
+- Second
+- Third`;
+        const blocks = markdownToBlocks(markdown, pageUid);
+        expect(blocks[0].order).toBe(0);
+        expect(blocks[1].order).toBe(1);
+        expect(blocks[2].order).toBe(2);
+    });
+});
+describe('getBlockDepth', () => {
+    it('returns 0 for root blocks', () => {
+        const blocks = [
+            {
+                ref: { blockUid: 'root' },
+                text: 'Root',
+                parentRef: { blockUid: 'page' },
+                order: 0,
+                open: true,
+                heading: null,
+            },
+        ];
+        expect(getBlockDepth(blocks[0], blocks)).toBe(0);
+    });
+    it('returns correct depth for nested blocks', () => {
+        const blocks = [
+            {
+                ref: { blockUid: 'parent' },
+                text: 'Parent',
+                parentRef: { blockUid: 'page' },
+                order: 0,
+                open: true,
+                heading: null,
+            },
+            {
+                ref: { blockUid: 'child' },
+                text: 'Child',
+                parentRef: { blockUid: 'parent' },
+                order: 0,
+                open: true,
+                heading: null,
+            },
+            {
+                ref: { blockUid: 'grandchild' },
+                text: 'Grandchild',
+                parentRef: { blockUid: 'child' },
+                order: 0,
+                open: true,
+                heading: null,
+            },
+        ];
+        expect(getBlockDepth(blocks[1], blocks)).toBe(1);
+        expect(getBlockDepth(blocks[2], blocks)).toBe(2);
+    });
+});

package/build/diff/types.js

@@ -0,0 +1,27 @@
+/**
+ * Diff Algorithm Types
+ *
+ * Type definitions for the smart diff algorithm that computes minimal
+ * update operations when syncing markdown content to Roam.
+ */
+/**
+ * Extract statistics from a DiffResult.
+ */
+export function getDiffStats(result) {
+    return {
+        creates: result.creates.length,
+        updates: result.updates.length,
+        moves: result.moves.length,
+        deletes: result.deletes.length,
+        preserved: result.preservedUids.size,
+    };
+}
+/**
+ * Check if a diff result contains no changes.
+ */
+export function isDiffEmpty(result) {
+    return (result.creates.length === 0 &&
+        result.updates.length === 0 &&
+        result.moves.length === 0 &&
+        result.deletes.length === 0);
+}

package/build/diff/types.test.js

@@ -0,0 +1,57 @@
+import { describe, it, expect } from 'vitest';
+import { getDiffStats, isDiffEmpty } from './types.js';
+function createDiffResult(createCount = 0, updateCount = 0, moveCount = 0, deleteCount = 0, preservedCount = 0) {
+    return {
+        creates: Array(createCount).fill({ action: 'create-block' }),
+        updates: Array(updateCount).fill({ action: 'update-block' }),
+        moves: Array(moveCount).fill({ action: 'move-block' }),
+        deletes: Array(deleteCount).fill({ action: 'delete-block' }),
+        preservedUids: new Set(Array(preservedCount).fill(null).map((_, i) => `uid${i}`)),
+    };
+}
+describe('getDiffStats', () => {
+    it('returns correct counts for all operation types', () => {
+        const diff = createDiffResult(2, 3, 1, 4, 5);
+        const stats = getDiffStats(diff);
+        expect(stats.creates).toBe(2);
+        expect(stats.updates).toBe(3);
+        expect(stats.moves).toBe(1);
+        expect(stats.deletes).toBe(4);
+        expect(stats.preserved).toBe(5);
+    });
+    it('returns zeros for empty diff', () => {
+        const diff = createDiffResult();
+        const stats = getDiffStats(diff);
+        expect(stats.creates).toBe(0);
+        expect(stats.updates).toBe(0);
+        expect(stats.moves).toBe(0);
+        expect(stats.deletes).toBe(0);
+        expect(stats.preserved).toBe(0);
+    });
+});
+describe('isDiffEmpty', () => {
+    it('returns true when no operations exist', () => {
+        const diff = createDiffResult(0, 0, 0, 0, 5);
+        expect(isDiffEmpty(diff)).toBe(true);
+    });
+    it('returns false when creates exist', () => {
+        const diff = createDiffResult(1);
+        expect(isDiffEmpty(diff)).toBe(false);
+    });
+    it('returns false when updates exist', () => {
+        const diff = createDiffResult(0, 1);
+        expect(isDiffEmpty(diff)).toBe(false);
+    });
+    it('returns false when moves exist', () => {
+        const diff = createDiffResult(0, 0, 1);
+        expect(isDiffEmpty(diff)).toBe(false);
+    });
+    it('returns false when deletes exist', () => {
+        const diff = createDiffResult(0, 0, 0, 1);
+        expect(isDiffEmpty(diff)).toBe(false);
+    });
+    it('ignores preserved count when checking empty', () => {
+        const diff = createDiffResult(0, 0, 0, 0, 100);
+        expect(isDiffEmpty(diff)).toBe(true);
+    });
+});

package/build/search/block-ref-search.js

@@ -8,17 +8,42 @@ export class BlockRefSearchHandler extends BaseSearchHandler {
         this.params = params;
     }
     async execute() {
-        const { block_uid, page_title_uid } = this.params;
+        const { block_uid, title, 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
+        // Build query based on whether we're searching for references to a specific block,
+        // a page title, or all block references within a page/graph
         let queryStr;
         let queryParams;
-        if (block_uid) {
+        if (title) {
+            // Search for references to a page by title using :block/refs
+            if (targetPageUid) {
+                queryStr = `[:find ?block-uid ?block-str
+                    :in $ ?target-title ?page-uid
+                    :where [?target :node/title ?target-title]
+                           [?p :block/uid ?page-uid]
+                           [?b :block/page ?p]
+                           [?b :block/refs ?target]
+                           [?b :block/string ?block-str]
+                           [?b :block/uid ?block-uid]]`;
+                queryParams = [title, targetPageUid];
+            }
+            else {
+                queryStr = `[:find ?block-uid ?block-str ?page-title
+                    :in $ ?target-title
+                    :where [?target :node/title ?target-title]
+                           [?b :block/refs ?target]
+                           [?b :block/string ?block-str]
+                           [?b :block/uid ?block-uid]
+                           [?b :block/page ?p]
+                           [?p :node/title ?page-title]]`;
+                queryParams = [title];
+            }
+        }
+        else if (block_uid) {
             // Search for references to a specific block
             if (targetPageUid) {
                 queryStr = `[:find ?block-uid ?block-str
@@ -69,9 +94,11 @@ export class BlockRefSearchHandler extends BaseSearchHandler {
             const resolvedContent = await resolveRefs(this.graph, content);
             return [uid, resolvedContent, pageTitle];
         }));
-        const searchDescription = block_uid
-            ? `referencing block ((${block_uid}))`
-            : 'containing block references';
+        const searchDescription = title
+            ? `referencing [[${title}]]`
+            : block_uid
+                ? `referencing block ((${block_uid}))`
+                : 'containing block references';
         return SearchUtils.formatSearchResults(resolvedResults, searchDescription, !targetPageUid);
     }
 }

package/build/server/roam-server.js

@@ -223,6 +223,13 @@ export class RoamServer {
                             content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
                         };
                     }
+                    case 'roam_update_page_markdown': {
+                        const { title, markdown, dry_run = false } = request.params.arguments;
+                        const result = await this.toolHandlers.updatePageMarkdown(title, markdown, dry_run);
+                        return {
+                            content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+                        };
+                    }
                     default:
                         throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${request.params.name}`);
                 }

package/build/tools/operations/pages.js

@@ -6,6 +6,7 @@ import { convertToRoamActions, convertToRoamMarkdown } from '../../markdown-util
 import { pageUidCache } from '../../cache/page-uid-cache.js';
 import { buildTableActions } from './table.js';
 import { BatchOperations } from './batch.js';
+import { parseExistingBlocks, markdownToBlocks, diffBlockTrees, generateBatchActions, getDiffStats, isDiffEmpty, summarizeActions, } from '../../diff/index.js';
 // Helper to get ordinal suffix for dates
 function getOrdinalSuffix(day) {
     if (day > 3 && day < 21)
@@ -410,4 +411,98 @@ export class PageOperations {
         };
         return `# ${title}\n\n${toMarkdown(rootBlocks)}`;
     }
+    /**
+     * Update an existing page with new markdown content using smart diff.
+     * Preserves block UIDs where possible and generates minimal changes.
+     *
+     * @param title - Title of the page to update
+     * @param markdown - New GFM markdown content
+     * @param dryRun - If true, returns actions without executing them
+     * @returns Result with actions, stats, and preserved UIDs
+     */
+    async updatePageMarkdown(title, markdown, dryRun = false) {
+        if (!title) {
+            throw new McpError(ErrorCode.InvalidRequest, 'title is required');
+        }
+        if (!markdown) {
+            throw new McpError(ErrorCode.InvalidRequest, 'markdown is required');
+        }
+        // 1. Fetch existing page with raw block data
+        const pageTitle = String(title).trim();
+        // Try different case variations
+        const variations = [
+            pageTitle,
+            capitalizeWords(pageTitle),
+            pageTitle.toLowerCase()
+        ];
+        let pageUid = null;
+        // Check cache first
+        for (const variation of variations) {
+            const cachedUid = pageUidCache.get(variation);
+            if (cachedUid) {
+                pageUid = cachedUid;
+                break;
+            }
+        }
+        // If not cached, query the database
+        if (!pageUid) {
+            const orClause = variations.map(v => `[?e :node/title "${v}"]`).join(' ');
+            const searchQuery = `[:find ?uid .
+                          :where [?e :block/uid ?uid]
+                                 (or ${orClause})]`;
+            const result = await q(this.graph, searchQuery, []);
+            pageUid = (result === null || result === undefined) ? null : String(result);
+            if (pageUid) {
+                pageUidCache.set(pageTitle, pageUid);
+            }
+        }
+        if (!pageUid) {
+            throw new McpError(ErrorCode.InvalidRequest, `Page with title "${title}" not found`);
+        }
+        // 2. Fetch existing blocks with full hierarchy
+        const blocksQuery = `[:find (pull ?page [
+                            :block/uid
+                            :block/string
+                            :block/order
+                            :block/heading
+                            {:block/children ...}
+                          ]) .
+                          :where [?page :block/uid "${pageUid}"]]`;
+        const pageData = await q(this.graph, blocksQuery, []);
+        if (!pageData) {
+            throw new McpError(ErrorCode.InternalError, `Failed to fetch page data for "${title}"`);
+        }
+        // 3. Parse existing blocks into our format
+        const existingBlocks = parseExistingBlocks(pageData);
+        // 4. Convert new markdown to block structure
+        const newBlocks = markdownToBlocks(markdown, pageUid);
+        // 5. Compute diff
+        const diff = diffBlockTrees(existingBlocks, newBlocks, pageUid);
+        // 6. Generate ordered batch actions
+        const actions = generateBatchActions(diff);
+        const stats = getDiffStats(diff);
+        const summary = isDiffEmpty(diff) ? 'No changes needed' : summarizeActions(actions);
+        // 7. Execute if not dry run and there are actions
+        if (!dryRun && actions.length > 0) {
+            try {
+                const batchResult = await batchActions(this.graph, {
+                    action: 'batch-actions',
+                    actions: actions
+                });
+                if (!batchResult) {
+                    throw new Error('Batch actions returned no result');
+                }
+            }
+            catch (error) {
+                throw new McpError(ErrorCode.InternalError, `Failed to apply changes: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        return {
+            success: true,
+            actions,
+            stats,
+            preservedUids: [...diff.preservedUids],
+            summary: dryRun ? `[DRY RUN] ${summary}` : summary
+        };
+    }
 }

package/build/tools/schemas.js

@@ -259,13 +259,17 @@ export const toolSchemas = {
     },
     roam_search_block_refs: {
         name: 'roam_search_block_refs',
-        description: 'Search for block references within a page or across the entire graph. Can search for references to a specific block or find all block references.',
+        description: 'Search for block references within a page or across the entire graph. Can search for references to a specific block, a page title, or find all block references.',
         inputSchema: {
             type: 'object',
             properties: {
                 block_uid: {
                     type: 'string',
-                    description: 'Optional: UID of the block to find references to'
+                    description: 'Optional: UID of the block to find references to (searches for ((uid)) patterns in text)'
+                },
+                title: {
+                    type: 'string',
+                    description: 'Optional: Page title to find references to (uses :block/refs for [[page]] and #tag links)'
                 },
                 page_title_uid: {
                     type: 'string',
@@ -612,4 +616,27 @@ export const toolSchemas = {
             required: ['parent_uid', 'headers', 'rows']
         }
     },
+    roam_update_page_markdown: {
+        name: 'roam_update_page_markdown',
+        description: 'Update an existing page with new markdown content using smart diff. Preserves block UIDs where possible and generates minimal changes. This is ideal for:\n- Syncing external markdown files to Roam\n- AI-assisted content updates that preserve references\n- Batch content modifications without losing block references\n\n**How it works:**\n1. Fetches existing page blocks\n2. Matches new content to existing blocks by text similarity\n3. Generates minimal create/update/move/delete operations\n4. Preserves UIDs for matched blocks (keeping references intact)\n\nIMPORTANT: Before using this tool, ensure that you have loaded into context the \'Roam Markdown Cheatsheet\' resource.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                title: {
+                    type: 'string',
+                    description: 'Title of the page to update'
+                },
+                markdown: {
+                    type: 'string',
+                    description: 'New GFM markdown content for the page'
+                },
+                dry_run: {
+                    type: 'boolean',
+                    description: 'If true, returns the planned actions without executing them. Useful for previewing changes.',
+                    default: false
+                }
+            },
+            required: ['title', 'markdown']
+        }
+    },
 };

package/build/tools/tool-handlers.js

@@ -89,6 +89,10 @@ export class ToolHandlers {
     async createTable(input) {
         return this.tableOps.createTable(input);
     }
+    // Page Update with Diff
+    async updatePageMarkdown(title, markdown, dryRun = false) {
+        return this.pageOps.updatePageMarkdown(title, markdown, dryRun);
+    }
     async getRoamMarkdownCheatsheet() {
         if (this.cachedCheatsheet) {
             return this.cachedCheatsheet;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "roam-research-mcp",
-  "version": "1.3.2",
+  "version": "1.6.0",
   "description": "A Model Context Protocol (MCP) server for Roam Research API integration",
   "private": false,
   "repository": {
@@ -23,13 +23,13 @@
   "type": "module",
   "bin": {
     "roam-research-mcp": "build/index.js",
-    "roam-import": "build/cli/import-markdown.js"
+    "roam": "build/cli/roam.js"
   },
   "files": [
     "build"
   ],
   "scripts": {
-    "build": "echo \"Using custom instructions: .roam/${CUSTOM_INSTRUCTIONS_PREFIX}custom-instructions.md\" && tsc && cat Roam_Markdown_Cheatsheet.md .roam/${CUSTOM_INSTRUCTIONS_PREFIX}custom-instructions.md > build/Roam_Markdown_Cheatsheet.md && chmod 755 build/index.js build/cli/import-markdown.js",
+    "build": "echo \"Using custom instructions: .roam/${CUSTOM_INSTRUCTIONS_PREFIX}custom-instructions.md\" && tsc && cat Roam_Markdown_Cheatsheet.md .roam/${CUSTOM_INSTRUCTIONS_PREFIX}custom-instructions.md > build/Roam_Markdown_Cheatsheet.md && chmod 755 build/index.js build/cli/roam.js",
     "clean": "rm -rf build",
     "watch": "tsc --watch",
     "inspector": "npx @modelcontextprotocol/inspector build/index.js",
@@ -37,16 +37,20 @@
     "prepublishOnly": "npm run clean && npm run build",
     "release:patch": "npm version patch && git push origin v$(node -p \"require('./package.json').version\")",
     "release:minor": "npm version minor && git push origin v$(node -p \"require('./package.json').version\")",
-    "release:major": "npm version major && git push origin v$(node -p \"require('./package.json').version\")"
+    "release:major": "npm version major && git push origin v$(node -p \"require('./package.json').version\")",
+    "test": "vitest run",
+    "test:watch": "vitest"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.13.2",
     "@roam-research/roam-api-sdk": "^0.10.0",
+    "commander": "^14.0.2",
     "dotenv": "^16.4.7"
   },
   "devDependencies": {
     "@types/node": "^20.11.24",
     "ts-node": "^10.9.2",
-    "typescript": "^5.3.3"
+    "typescript": "^5.3.3",
+    "vitest": "^3.2.4"
   }
 }