roam-research-mcp 0.35.1 → 1.0.0

package/README.md

@@ -7,18 +7,17 @@
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 [![GitHub](https://img.shields.io/github/license/2b3pro/roam-research-mcp)](https://github.com/2b3pro/roam-research-mcp/blob/main/LICENSE)
 
-A Model Context Protocol (MCP) server that provides comprehensive access to Roam Research's API functionality. This server enables AI assistants like Claude to interact with your Roam Research graph through a standardized interface. It supports standard input/output (stdio), HTTP Stream, and Server-Sent Events (SSE) communication. (A WORK-IN-PROGRESS, personal project not officially endorsed by Roam Research)
+A Model Context Protocol (MCP) server that provides comprehensive access to Roam Research's API functionality. This server enables AI assistants like Claude to interact with your Roam Research graph through a standardized interface. It supports standard input/output (stdio) and HTTP Stream communication. (A WORK-IN-PROGRESS, personal project not officially endorsed by Roam Research)
 
 <a href="https://glama.ai/mcp/servers/fzfznyaflu"><img width="380" height="200" src="https://glama.ai/mcp/servers/fzfznyaflu/badge" alt="Roam Research MCP server" /></a>
 <a href="https://mseep.ai/app/2b3pro-roam-research-mcp"><img width="380" height="200" src="https://mseep.net/pr/2b3pro-roam-research-mcp-badge.png" alt="MseeP.ai Security Assessment Badge" /></a>
 
 ## Installation and Usage
 
-This MCP server supports three primary communication methods:
+This MCP server supports two primary communication methods:
 
 1.  **Stdio (Standard Input/Output):** Ideal for local inter-process communication, command-line tools, and direct integration with applications running on the same machine. This is the default communication method when running the server directly.
 2.  **HTTP Stream:** Provides network-based communication, suitable for web-based clients, remote applications, or scenarios requiring real-time updates over HTTP. The HTTP Stream endpoint runs on port `8088` by default.
-3.  **SSE (Server-Sent Events):** A transport for legacy clients that require SSE. The SSE endpoint runs on port `8087` by default. (NOTE: ⚠️ DEPRECATED: The SSE Transport has been deprecated as of MCP specification version 2025-03-26. HTTP Stream Transport preferred.)
 
 ### Running with Stdio
 
@@ -41,16 +40,16 @@ npm start
 
 ### Running with HTTP Stream
 
-To run the server with HTTP Stream or SSE support, you can either:
+To run the server with HTTP Stream support, you can either:
 
-1.  **Use the default ports:** Run `npm start` after building (as shown above). The server will automatically listen on port `8088` for HTTP Stream and `8087` for SSE.
-2.  **Specify custom ports:** Set the `HTTP_STREAM_PORT` and/or `SSE_PORT` environment variables before starting the server.
+1.  **Use the default ports:** Run `npm start` after building (as shown above). The server will automatically listen on port `8088` for HTTP Stream.
+2.  **Specify custom ports:** Set the `HTTP_STREAM_PORT` environment variable before starting the server.
 
     ```bash
-    HTTP_STREAM_PORT=9000 SSE_PORT=9001 npm start
+    HTTP_STREAM_PORT=9000 npm start
     ```
 
-    Or, if using a `.env` file, add `HTTP_STREAM_PORT=9000` and/or `SSE_PORT=9001` to it.
+    Or, if using a `.env` file, add `HTTP_STREAM_PORT=9000` to it.
 
 ## Docker
 
@@ -66,16 +65,15 @@ docker build -t roam-research-mcp .
 
 ### Run the Docker Container
 
-To run the Docker container and map the necessary ports, you must also provide the required environment variables. Use the `-e` flag to pass `ROAM_API_TOKEN`, `ROAM_GRAPH_NAME`, and optionally `MEMORIES_TAG`, `HTTP_STREAM_PORT`, and `SSE_PORT`:
+To run the Docker container and map the necessary ports, you must also provide the required environment variables. Use the `-e` flag to pass `ROAM_API_TOKEN`, `ROAM_GRAPH_NAME`, and optionally `MEMORIES_TAG` and `HTTP_STREAM_PORT`:
 
 ```bash
-docker run -p 3000:3000 -p 8088:8088 -p 8087:8087 \
+docker run -p 3000:3000 -p 8088:8088 \
   -e ROAM_API_TOKEN="your-api-token" \
   -e ROAM_GRAPH_NAME="your-graph-name" \
   -e MEMORIES_TAG="#[[LLM/Memories]]" \
   -e CUSTOM_INSTRUCTIONS_PATH="/path/to/your/custom_instructions_file.md" \
   -e HTTP_STREAM_PORT="8088" \
-  -e SSE_PORT="8087" \
   roam-research-mcp
 ```
 
@@ -117,19 +115,19 @@ The server provides powerful tools for interacting with Roam Research:
 6. `roam_create_outline`: Add a structured outline to an existing page or block, with support for `children_view_type`. Best for simpler, sequential outlines. For complex nesting (e.g., tables), consider `roam_process_batch_actions`. If `page_title_uid` and `block_text_uid` are both blank, content defaults to the daily page. (Internally uses `roam_process_batch_actions`.)
 7. `roam_search_block_refs`: Search for block references within a page or across the entire graph.
 8. `roam_search_hierarchy`: Search for parent or child blocks in the block hierarchy.
-9. `roam_find_pages_modified_today`: Find pages that have been modified today (since midnight).
-10. `roam_search_by_text`: Search for blocks containing specific text.
+9. `roam_find_pages_modified_today`: Find pages that have been modified today (since midnight), with pagination and sorting options.
+10. `roam_search_by_text`: Search for blocks containing specific text across all pages or within a specific page. This tool supports pagination via the `limit` and `offset` parameters.
 11. `roam_search_by_status`: Search for blocks with a specific status (TODO/DONE) across all pages or within a specific page.
 12. `roam_search_by_date`: Search for blocks or pages based on creation or modification dates.
-13. `roam_search_for_tag`: Search for blocks containing a specific tag and optionally filter by blocks that also contain another tag nearby.
+13. `roam_search_for_tag`: Search for blocks containing a specific tag and optionally filter by blocks that also contain another tag nearby or exclude blocks with a specific tag. This tool supports pagination via the `limit` and `offset` parameters.
 14. `roam_remember`: Add a memory or piece of information to remember. (Internally uses `roam_process_batch_actions`.)
 15. `roam_recall`: Retrieve all stored memories.
-16. `roam_datomic_query`: Execute a custom Datomic query on the Roam graph for advanced data retrieval beyond the available search tools.
+16. `roam_datomic_query`: Execute a custom Datomic query on the Roam graph for advanced data retrieval beyond the available search tools. Now supports client-side regex filtering for enhanced post-query processing. Optimal for complex filtering (including regex), highly complex boolean logic, arbitrary sorting criteria, and proximity search.
 17. `roam_markdown_cheatsheet`: Provides the content of the Roam Markdown Cheatsheet resource, optionally concatenated with custom instructions if `CUSTOM_INSTRUCTIONS_PATH` environment variable is set.
 18. `roam_process_batch_actions`: Execute a sequence of low-level block actions (create, update, move, delete) in a single, non-transactional batch. Provides granular control for complex nesting like tables. (Note: For actions on existing blocks or within a specific page context, it is often necessary to first obtain valid page or block UIDs using tools like `roam_fetch_page_by_title`.)
 
 **Deprecated Tools**:
-The following tools have been deprecated as of `v.0.30.0` in favor of the more powerful and flexible `roam_process_batch_actions`:
+The following tools have been deprecated as of `v0.36.2` in favor of the more powerful and flexible `roam_process_batch_actions`:
 
 - `roam_create_block`: Use `roam_process_batch_actions` with the `create-block` action.
 - `roam_update_block`: Use `roam_process_batch_actions` with the `update-block` action.
@@ -246,7 +244,6 @@ This demonstrates moving a block from one location to another and simultaneously
    MEMORIES_TAG='#[[LLM/Memories]]'
    CUSTOM_INSTRUCTIONS_PATH='/path/to/your/custom_instructions_file.md'
    HTTP_STREAM_PORT=8088 # Or your desired port for HTTP Stream communication
-   SSE_PORT=8087 # Or your desired port for SSE communication
    ```
 
    Option 2: Using MCP settings (Alternative method)
@@ -266,8 +263,7 @@ This demonstrates moving a block from one location to another and simultaneously
            "ROAM_GRAPH_NAME": "your-graph-name",
            "MEMORIES_TAG": "#[[LLM/Memories]]",
            "CUSTOM_INSTRUCTIONS_PATH": "/path/to/your/custom_instructions_file.md",
-           "HTTP_STREAM_PORT": "8088",
-           "SSE_PORT": "8087"
+           "HTTP_STREAM_PORT": "8088"
          }
        }
      }

package/build/Roam_Markdown_Cheatsheet.md

@@ -113,12 +113,70 @@ The provided markdown structure represents a Roam Research Kanban board. It star
 This markdown structure allows embedding custom HTML or other content using Hiccup syntax. The `:hiccup` keyword is followed by a Clojure-like vector defining the HTML elements and their attributes in one block. This provides a powerful way to inject dynamic or custom components into your Roam graph. Example: `:hiccup [:iframe {:width "600" :height "400" :src "https://www.example.com"}]`
 
 ## Specific notes and preferences concerning my Roam Research graph
-### What To Tag
+### When creating new pages
 
-NONE
+- After creating a new page, ensure you add a new block on the daily page that references it if one doesn't already exist: `Created page: [[…]]`
 
-### Don't Include…
+### What To Tag
 
-NONE
+- Always think in terms of Future Me: How will I find this gem of information in this block in the future? What about this core idea might I be looking for? Aim for high relevance and helpfulness.
+- My notes in Roam are interconnected via wrapped terms/expressions [[…]] and hashtags (#…). The general salience guidelines are as follows:
+
+  - What greater domain would this core idea be best categorization?
+  - If block is parent of children blocks, can a word/phrase in the parent be wrapped in brackets.
+    - If not, could a hashtag be appended to the block? (This is like a "please see more"-on-this-subject categorization).
+  - Wrap any proper names—no titles—(Dr. [[Werner Erhard]]), organizations, abbreviations e.g. `[NASA]([[National Aeronautics and Space Administration (NASA)]])`
+  - Any synonyms or multi-worded phrases of already established categories/pages, e.g. `[frameworks for making quality decisions]([[decision-making frameworks]])`
+
+#### Advanced tagging methodology combining [[zettelkasten]] principles with serendipity engineering for maximum intellectual discovery potential. #[[knowledge management]] #[[tagging methodology]]
+
+- # Core Philosophy
+  - Tag for **intellectual collision** and **future conversation**, not just categorization. Every tag should maximize the potential for unexpected discoveries and cross-domain insights.
+  - Traditional academic categorization creates silos; serendipity-engineered tagging creates **conceptual magnets** that attract surprising connections.
+- ## Zettelkasten-Informed Principles
+  - **Atomic Thought Units**: Each tagged concept should function as a standalone intellectual object capable of connecting to ANY other domain
+  - **Conversation-Driven Linking**: Tag by the intellectual dialogues and debates a concept could inform, not just its subject matter
+  - **Temporal Intellectual Journey**: Tag for different phases of understanding - beginner discoveries, expert refinements, teaching moments
+  - **Intellectual Genealogy**: Create concept lineages that trace how ideas evolve and connect across domains
+- ## Serendipity Engineering Techniques
+  - **Conceptual Collision Matrix**: Force unlikely intellectual meetings by tagging across disparate domains
+    - Example: #[[parenting techniques]] + [[cognitive engineering]] = developing children's meta-cognitive awareness
+    - Example: #[[cooking methods]] + [[cultural rotation]] = how different cultures balance flavors → balancing competing AI instructions
+  - **Anti-Obvious Tagging**: Deliberately tag against natural categorization to maximize surprise
+    - Tag by **structural similarities** rather than surface content: #[[has feedback loops]], #[[requires calibration]], #[[exhibits emergence]]
+    - Connect concepts through **metaphorical bridges**: meditation techniques + bias detection (both about noticing the unnoticed)
+  - **Question Cascade Strategy**: Tag by what questions a concept could answer across unexpected domains
+    - Instead of "this is about X," ask "what problems could this solve that I haven't thought of yet?"
+    - Examples: #[[how do experts prevent tunnel vision?]], #[[what creates cognitive flexibility?]], #[[how do systems self-correct?]]
+  - **Future Collision Potential**: Tag with temporal discovery triggers
+    - [[will be relevant in 5 years]], #[[connects to unborn projects]], #[[solves problems I don't know I have yet]]
+- ## Practical Implementation
+  - **The Serendipity Test**: Before tagging, ask "Could this concept surprise me by connecting to something completely unrelated?"
+  - **Cross-Domain Bridge Tags**: Use structural rather than content-based categorization
+    - [[flow dynamics]] - connects fluid mechanics, music, conversation, AI prompt sequences
+    - [[calibration processes]] - bridges instrument tuning, relationships, AI parameters, personal habits
+    - [[perspective switching]] - connects photography, negotiation, cultural analysis, prompt engineering
+  - **Problem-Solution Pairing**: Tag by the problems solved rather than methods used
+    - [[breaking cognitive constraints]], #[[expanding solution spaces]], #[[preventing expert blindness]]
+  - **Intellectual State Triggers**: Tag for when you'd actually search based on mental/emotional context
+    - [[feeling stuck in patterns]], #[[needing fresh perspective]], #[[frustrated with conventional approaches]]
+- ## Tag Maintenance Strategy
+  - **Regular Collision Audits**: Periodically review tags to identify missed connection opportunities
+  - **Surprise Discovery Log**: Track when unexpected tag connections lead to insights, then engineer more of those patterns
+  - **Question Evolution**: Update question-based tags as your intellectual interests and problems evolve
+  - **Cross-Reference Integration**: Ensure new tagging approach complements existing page reference `[[…]]` and hashtag `#[[…]]` conventions
+
+### How to Tag (nuances)
+
+- Consider that when linking a parent block, all children blocks will also accompany future search results. Linking a childblock will only link the child block, not siblings.
+- The convention for tags is lower case unless proper nouns. When tagging might affect the capitalization within a sentence, use aliases. e.g. `[Cognitive biases]([[cognitive biases]]) of the person are listed…"
+- Can longer phrases and expressions be aliased to existing notes? `How one can leverage [[cognitive dissonance]] to [hypnotically influence others using language]([[hypnotic language techniques]])`
+- Reformat quotes in this format structure: `<quote> —[[<Quoted Person>]] #quote <hashtags>` with 2-3 additional relevant hashtag links
+- Anything that needs follow-up, further research, preface with `{{[[TODO]]}}`
+  - Scheduled review: Tag future dates in ordinal format so that it can come up for review when relevant, e.g. `[[For review]]: [[August 12th, 2026]]` Optionally, prepend with label ("Deadline", "For review", "Approved", "Pending", "Deferred", "Postponed until"). Place on parent block if relevant (if children blocks are related).
+
+### Constraints
+
+- Don't overtag.
 
 ⭐️📋 END (Cheat Sheet LOADED) < < < 📋⭐️

package/build/config/environment.js

@@ -29,7 +29,7 @@ if (!API_TOKEN || !GRAPH_NAME) {
         '     "mcpServers": {\n' +
         '       "roam-research": {\n' +
         '         "command": "node",\n' +
-        '         "args": ["/path/to/roam-research/build/index.js"],\n' +
+        '         "args": ["/path/to/roam-research-mcp/build/index.js"],\n' +
         '         "env": {\n' +
         '           "ROAM_API_TOKEN": "your-api-token",\n' +
         '           "ROAM_GRAPH_NAME": "your-graph-name"\n' +
@@ -42,6 +42,5 @@ if (!API_TOKEN || !GRAPH_NAME) {
         '   ROAM_GRAPH_NAME=your-graph-name');
 }
 const HTTP_STREAM_PORT = process.env.HTTP_STREAM_PORT || '8088'; // Default to 8088
-const SSE_PORT = process.env.SSE_PORT || '8087'; // Default to 8087
 const CORS_ORIGIN = process.env.CORS_ORIGIN || 'http://localhost:5678';
-export { API_TOKEN, GRAPH_NAME, HTTP_STREAM_PORT, SSE_PORT, CORS_ORIGIN };
+export { API_TOKEN, GRAPH_NAME, HTTP_STREAM_PORT, CORS_ORIGIN };

package/build/index.js

@@ -1,4 +1,7 @@
 #!/usr/bin/env node
 import { RoamServer } from './server/roam-server.js';
 const server = new RoamServer();
-server.run().catch(() => { });
+server.run().catch((error) => {
+    console.error("Fatal error running server:", error);
+    process.exit(1);
+});

package/build/markdown-utils.js

@@ -1,3 +1,4 @@
+import { randomBytes } from 'crypto';
 /**
  * Check if text has a traditional markdown table
  */
@@ -240,11 +241,13 @@ function parseTableRows(lines) {
     return tableNodes;
 }
 function generateBlockUid() {
-    // Generate a random string of 9 characters (Roam's format)
+    // Generate a random string of 9 characters (Roam's format) using crypto for better randomness
     const chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_';
+    // 64 chars, which divides 256 evenly (256 = 64 * 4), so simple modulo is unbiased
+    const bytes = randomBytes(9);
     let uid = '';
     for (let i = 0; i < 9; i++) {
-        uid += chars.charAt(Math.floor(Math.random() * chars.length));
+        uid += chars[bytes[i] % 64];
     }
     return uid;
 }

package/build/search/datomic-search.js

@@ -8,7 +8,46 @@ export class DatomicSearchHandler extends BaseSearchHandler {
     async execute() {
         try {
             // Execute the datomic query using the Roam API
-            const results = await q(this.graph, this.params.query, this.params.inputs || []);
+            let results = await q(this.graph, this.params.query, this.params.inputs || []);
+            if (this.params.regexFilter) {
+                let regex;
+                try {
+                    regex = new RegExp(this.params.regexFilter, this.params.regexFlags);
+                }
+                catch (e) {
+                    return {
+                        success: false,
+                        matches: [],
+                        message: `Invalid regex filter provided: ${e instanceof Error ? e.message : String(e)}`
+                    };
+                }
+                results = results.filter(result => {
+                    if (this.params.regexTargetField && this.params.regexTargetField.length > 0) {
+                        for (const field of this.params.regexTargetField) {
+                            // Access nested fields if path is provided (e.g., "prop.nested")
+                            const fieldPath = field.split('.');
+                            let value = result;
+                            for (const part of fieldPath) {
+                                if (typeof value === 'object' && value !== null && part in value) {
+                                    value = value[part];
+                                }
+                                else {
+                                    value = undefined; // Field not found
+                                    break;
+                                }
+                            }
+                            if (typeof value === 'string' && regex.test(value)) {
+                                return true;
+                            }
+                        }
+                        return false;
+                    }
+                    else {
+                        // Default to stringifying the whole result if no target field is specified
+                        return regex.test(JSON.stringify(result));
+                    }
+                });
+            }
             return {
                 success: true,
                 matches: results.map(result => ({

package/build/search/tag-search.js

@@ -8,42 +8,102 @@ export class TagSearchHandler extends BaseSearchHandler {
         this.params = params;
     }
     async execute() {
-        const { primary_tag, page_title_uid, near_tag, exclude_tag } = this.params;
+        const { primary_tag, page_title_uid, near_tag, exclude_tag, case_sensitive = false, limit = -1, offset = 0 } = this.params;
+        let nearTagUid;
+        if (near_tag) {
+            nearTagUid = await SearchUtils.findPageByTitleOrUid(this.graph, near_tag);
+            if (!nearTagUid) {
+                return {
+                    success: false,
+                    matches: [],
+                    message: `Near tag "${near_tag}" not found.`,
+                    total_count: 0
+                };
+            }
+        }
+        let excludeTagUid;
+        if (exclude_tag) {
+            excludeTagUid = await SearchUtils.findPageByTitleOrUid(this.graph, exclude_tag);
+            if (!excludeTagUid) {
+                return {
+                    success: false,
+                    matches: [],
+                    message: `Exclude tag "${exclude_tag}" not found.`,
+                    total_count: 0
+                };
+            }
+        }
         // 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
-        let queryArgs = [primary_tag];
+        const searchTags = [];
+        if (case_sensitive) {
+            searchTags.push(primary_tag);
+        }
+        else {
+            searchTags.push(primary_tag);
+            searchTags.push(primary_tag.charAt(0).toUpperCase() + primary_tag.slice(1));
+            searchTags.push(primary_tag.toUpperCase());
+            searchTags.push(primary_tag.toLowerCase());
+        }
+        const tagWhereClauses = searchTags.map(tag => {
+            // Roam tags can be [[tag name]] or #tag-name or #[[tag name]]
+            // The :node/title for a tag page is just the tag name without any # or [[ ]]
+            return `[?ref-page :node/title "${tag}"]`;
+        }).join(' ');
+        let inClause = `:in $`;
+        let queryLimit = limit === -1 ? '' : `:limit ${limit}`;
+        let queryOffset = offset === 0 ? '' : `:offset ${offset}`;
+        let queryOrder = `:order ?page-edit-time asc ?block-uid asc`; // Sort by page edit time, then block UID
         let queryWhereClauses = `
-                      [?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)]
+                      (or ${tagWhereClauses})
                       [?b :block/refs ?ref-page]
                       [?b :block/string ?block-str]
                       [?b :block/uid ?block-uid]
                       [?b :block/page ?p]
-                      [?p :node/title ?page-title]`;
-        let inClause = `:in $ ?title`;
+                      [?p :node/title ?page-title]
+                      [?p :edit/time ?page-edit-time]`; // Fetch page edit time for sorting
+        if (nearTagUid) {
+            queryWhereClauses += `
+                      [?b :block/refs ?near-tag-page]
+                      [?near-tag-page :block/uid "${nearTagUid}"]`;
+        }
+        if (excludeTagUid) {
+            queryWhereClauses += `
+                      (not [?b :block/refs ?exclude-tag-page])
+                      [?exclude-tag-page :block/uid "${excludeTagUid}"]`;
+        }
         if (targetPageUid) {
             inClause += ` ?target-page-uid`;
-            queryArgs.push(targetPageUid);
             queryWhereClauses += `
                       [?p :block/uid ?target-page-uid]`;
         }
         const queryStr = `[:find ?block-uid ?block-str ?page-title
-                      ${inClause}
+                      ${inClause} ${queryLimit} ${queryOffset} ${queryOrder}
                       :where 
                       ${queryWhereClauses}]`;
+        const queryArgs = [];
+        if (targetPageUid) {
+            queryArgs.push(targetPageUid);
+        }
         const rawResults = await q(this.graph, queryStr, queryArgs);
+        // Query to get total count without limit
+        const countQueryStr = `[:find (count ?b)
+                            ${inClause}
+                            :where
+                            ${queryWhereClauses.replace(/\[\?p :edit\/time \?page-edit-time\]/, '')}]`; // Remove edit time for count query
+        const totalCountResults = await q(this.graph, countQueryStr, queryArgs);
+        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 searchDescription = `referencing "${primary_tag}"`;
-        return SearchUtils.formatSearchResults(resolvedResults, searchDescription, !targetPageUid);
+        const formattedResults = SearchUtils.formatSearchResults(resolvedResults, searchDescription, !targetPageUid);
+        formattedResults.total_count = totalCount;
+        return formattedResults;
     }
 }

package/build/search/text-search.js

@@ -8,29 +8,68 @@ export class TextSearchHandler extends BaseSearchHandler {
         this.params = params;
     }
     async execute() {
-        const { text, page_title_uid } = this.params;
+        const { text, page_title_uid, case_sensitive = false, limit = -1, offset = 0 } = 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? ?block-str ?search-text)]
-                      [?b :block/uid ?block-uid]
-                      [?b :block/page ?p]
-                      [?p :node/title ?page-title]]`;
-        const queryParams = [text];
+        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(' ');
+        let queryStr;
+        let queryParams = [];
+        let queryLimit = limit === -1 ? '' : `:limit ${limit}`;
+        let queryOffset = offset === 0 ? '' : `:offset ${offset}`;
+        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})
+                    [?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
+        if (targetPageUid) {
+            queryStr = `[:find ?block-uid ?block-str ?page-title
+                    :in $ ?page-uid ${queryLimit} ${queryOffset} ${queryOrder}
+                    :where
+                    ${baseQueryWhereClauses}
+                    [?p :block/uid ?page-uid]]`;
+            queryParams = [targetPageUid];
+        }
+        else {
+            queryStr = `[:find ?block-uid ?block-str ?page-title
+                    :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)
+                            :in $
+                            :where
+                            ${baseQueryWhereClauses.replace(/\[\?p :edit\/time \?page-edit-time\]/, '')}]`; // Remove edit time for count query
+        const totalCountResults = await q(this.graph, countQueryStr, queryParams);
+        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 searchDescription = `containing "${text}"`;
-        return SearchUtils.formatSearchResults(resolvedResults, searchDescription, !targetPageUid);
+        const formattedResults = SearchUtils.formatSearchResults(resolvedResults, searchDescription, !targetPageUid);
+        formattedResults.total_count = totalCount;
+        return formattedResults;
     }
 }

package/build/server/roam-server.js

@@ -1,7 +1,7 @@
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
-import { CallToolRequestSchema, ErrorCode, ListResourcesRequestSchema, ReadResourceRequestSchema, McpError, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { CallToolRequestSchema, ErrorCode, ListResourcesRequestSchema, ReadResourceRequestSchema, McpError, ListToolsRequestSchema, ListPromptsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
 import { initializeGraph } from '@roam-research/roam-api-sdk';
 import { API_TOKEN, GRAPH_NAME, HTTP_STREAM_PORT } from '../config/environment.js';
 import { toolSchemas } from '../tools/schemas.js';
@@ -20,7 +20,6 @@ const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
 const serverVersion = packageJson.version;
 export class RoamServer {
     constructor() {
-        // console.log('RoamServer: Constructor started.');
         try {
             this.graph = initializeGraph({
                 token: API_TOKEN,
@@ -42,7 +41,23 @@ export class RoamServer {
         if (Object.keys(toolSchemas).length === 0) {
             throw new McpError(ErrorCode.InternalError, 'No tool schemas defined in src/tools/schemas.ts');
         }
-        // console.log('RoamServer: Constructor finished.');
+    }
+    // Helper to create and configure MCP server instance
+    createMcpServer(nameSuffix = '') {
+        const server = new Server({
+            name: `roam-research${nameSuffix}`,
+            version: serverVersion,
+        }, {
+            capabilities: {
+                tools: {
+                    ...Object.fromEntries(Object.keys(toolSchemas).map((toolName) => [toolName, toolSchemas[toolName].inputSchema])),
+                },
+                resources: {}, // No resources exposed via capabilities
+                prompts: {}, // No prompts exposed via capabilities
+            },
+        });
+        this.setupRequestHandlers(server);
+        return server;
     }
     // Refactored to accept a Server instance
     setupRequestHandlers(mcpServer) {
@@ -59,6 +74,10 @@ export class RoamServer {
         mcpServer.setRequestHandler(ReadResourceRequestSchema, async (request) => {
             throw new McpError(ErrorCode.InternalError, `Resource not found: ${request.params.uri}`);
         });
+        // List available prompts
+        mcpServer.setRequestHandler(ListPromptsRequestSchema, async () => {
+            return { prompts: [] };
+        });
         // Handle tool calls
         mcpServer.setRequestHandler(CallToolRequestSchema, async (request) => {
             try {
@@ -206,49 +225,15 @@ export class RoamServer {
         });
     }
     async run() {
-        // console.log('RoamServer: run() method started.');
         try {
-            // console.log('RoamServer: Attempting to create stdioMcpServer...');
-            const stdioMcpServer = new Server({
-                name: 'roam-research',
-                version: serverVersion,
-            }, {
-                capabilities: {
-                    tools: {
-                        ...Object.fromEntries(Object.keys(toolSchemas).map((toolName) => [toolName, toolSchemas[toolName].inputSchema])),
-                    },
-                    resources: {
-                        'roam-markdown-cheatsheet.md': {}
-                    }
-                },
-            });
-            // console.log('RoamServer: stdioMcpServer created. Setting up request handlers...');
-            this.setupRequestHandlers(stdioMcpServer);
-            // console.log('RoamServer: stdioMcpServer handlers setup complete. Connecting transport...');
+            const stdioMcpServer = this.createMcpServer();
             const stdioTransport = new StdioServerTransport();
             await stdioMcpServer.connect(stdioTransport);
-            // console.log('RoamServer: stdioTransport connected. Attempting to create httpMcpServer...');
-            const httpMcpServer = new Server({
-                name: 'roam-research-http', // A distinct name for the HTTP server
-                version: serverVersion,
-            }, {
-                capabilities: {
-                    tools: {
-                        ...Object.fromEntries(Object.keys(toolSchemas).map((toolName) => [toolName, toolSchemas[toolName].inputSchema])),
-                    },
-                    resources: {
-                        'roam-markdown-cheatsheet.md': {}
-                    }
-                },
-            });
-            // console.log('RoamServer: httpMcpServer created. Setting up request handlers...');
-            this.setupRequestHandlers(httpMcpServer);
-            // console.log('RoamServer: httpMcpServer handlers setup complete. Connecting transport...');
+            const httpMcpServer = this.createMcpServer('-http');
             const httpStreamTransport = new StreamableHTTPServerTransport({
                 sessionIdGenerator: () => Math.random().toString(36).substring(2, 15) + Math.random().toString(36).substring(2, 15),
             });
             await httpMcpServer.connect(httpStreamTransport);
-            // console.log('RoamServer: httpStreamTransport connected.');
             const httpServer = createServer(async (req, res) => {
                 // Set CORS headers
                 res.setHeader('Access-Control-Allow-Origin', CORS_ORIGIN);
@@ -264,7 +249,6 @@ export class RoamServer {
                     await httpStreamTransport.handleRequest(req, res);
                 }
                 catch (error) {
-                    // // console.error('HTTP Stream Server error:', error);
                     if (!res.headersSent) {
                         res.writeHead(500, { 'Content-Type': 'application/json' });
                         res.end(JSON.stringify({ error: 'Internal Server Error' }));
@@ -273,7 +257,6 @@ export class RoamServer {
             });
             const availableHttpPort = await findAvailablePort(parseInt(HTTP_STREAM_PORT));
             httpServer.listen(availableHttpPort, () => {
-                // // console.log(`MCP Roam Research server running HTTP Stream on port ${availableHttpPort}`);
             });
         }
         catch (error) {

package/build/tools/operations/pages.js

@@ -18,7 +18,7 @@ export class PageOperations {
     constructor(graph) {
         this.graph = graph;
     }
-    async findPagesModifiedToday(max_num_pages = 50) {
+    async findPagesModifiedToday(limit = 50, offset = 0, sort_order = 'desc') {
         // Define ancestor rule for traversing block hierarchy
         const ancestorRule = `[
       [ (ancestor ?b ?a)
@@ -31,15 +31,21 @@ export class PageOperations {
         const startOfDay = new Date();
         startOfDay.setHours(0, 0, 0, 0);
         try {
-            // Query for pages modified today
-            const results = await q(this.graph, `[:find ?title
+            // Query for pages modified today, including modification time for sorting
+            let query = `[:find ?title ?time
           :in $ ?start_of_day %
           :where
           [?page :node/title ?title]
           (ancestor ?block ?page)
           [?block :edit/time ?time]
-          [(> ?time ?start_of_day)]]
-          :limit ${max_num_pages}`, [startOfDay.getTime(), ancestorRule]);
+          [(> ?time ?start_of_day)]]`;
+            if (limit !== -1) {
+                query += ` :limit ${limit}`;
+            }
+            if (offset > 0) {
+                query += ` :offset ${offset}`;
+            }
+            const results = await q(this.graph, query, [startOfDay.getTime(), ancestorRule]);
             if (!results || results.length === 0) {
                 return {
                     success: true,
@@ -47,7 +53,16 @@ export class PageOperations {
                     message: 'No pages have been modified today'
                 };
             }
-            // Extract unique page titles
+            // Sort results by modification time
+            results.sort((a, b) => {
+                if (sort_order === 'desc') {
+                    return b[1] - a[1]; // Newest first
+                }
+                else {
+                    return a[1] - b[1]; // Oldest first
+                }
+            });
+            // Extract unique page titles from sorted results
             const uniquePages = Array.from(new Set(results.map(([title]) => title)));
             return {
                 success: true,
@@ -173,21 +188,19 @@ export class PageOperations {
             throw new McpError(ErrorCode.InvalidRequest, 'title is required');
         }
         // Try different case variations
+        // Generate variations to check
         const variations = [
             title, // Original
             capitalizeWords(title), // Each word capitalized
             title.toLowerCase() // All lowercase
         ];
-        let uid = null;
-        for (const variation of variations) {
-            const searchQuery = `[:find ?uid .
-                          :where [?e :node/title "${variation}"]
-                                 [?e :block/uid ?uid]]`;
-            const result = await q(this.graph, searchQuery, []);
-            uid = (result === null || result === undefined) ? null : String(result);
-            if (uid)
-                break;
-        }
+        // Create OR clause for query
+        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, []);
+        const uid = (result === null || result === undefined) ? null : String(result);
         if (!uid) {
             throw new McpError(ErrorCode.InvalidRequest, `Page with title "${title}" not found (tried original, capitalized words, and lowercase)`);
         }

package/build/tools/schemas.js

@@ -165,7 +165,7 @@ export const toolSchemas = {
     },
     roam_search_for_tag: {
         name: 'roam_search_for_tag',
-        description: 'Search for blocks containing a specific tag and optionally filter by blocks that also contain another tag nearby. Example: Use this to search for memories that are tagged with the MEMORIES_TAG.',
+        description: 'Search for blocks containing a specific tag and optionally filter by blocks that also contain another tag nearby or exclude blocks with a specific tag. This tool supports pagination via the `limit` and `offset` parameters. Use this tool to search for memories tagged with the MEMORIES_TAG.',
         inputSchema: {
             type: 'object',
             properties: {
@@ -180,6 +180,21 @@ export const toolSchemas = {
                 near_tag: {
                     type: 'string',
                     description: 'Optional: Another tag to filter results by - will only return blocks where both tags appear',
+                },
+                case_sensitive: {
+                    type: 'boolean',
+                    description: 'Optional: Whether the search should be case-sensitive. If false, it will search for the provided tag, capitalized versions, and first word capitalized versions.',
+                    default: false
+                },
+                limit: {
+                    type: 'integer',
+                    description: 'Optional: The maximum number of results to return. Defaults to 50. Use -1 for no limit, but be aware that very large results sets can impact performance.',
+                    default: 50
+                },
+                offset: {
+                    type: 'integer',
+                    description: 'Optional: The number of results to skip before returning matches. Useful for pagination. Defaults to 0.',
+                    default: 0
                 }
             },
             required: ['primary_tag']
@@ -259,21 +274,32 @@ export const toolSchemas = {
     },
     roam_find_pages_modified_today: {
         name: 'roam_find_pages_modified_today',
-        description: 'Find pages that have been modified today (since midnight), with limit.',
+        description: 'Find pages that have been modified today (since midnight), with pagination and sorting options.',
         inputSchema: {
             type: 'object',
             properties: {
-                max_num_pages: {
+                limit: {
                     type: 'integer',
-                    description: 'Max number of pages to retrieve (default: 50)',
+                    description: 'The maximum number of pages to retrieve (default: 50). Use -1 for no limit, but be aware that very large result sets can impact performance.',
                     default: 50
                 },
+                offset: {
+                    type: 'integer',
+                    description: 'The number of pages to skip before returning matches. Useful for pagination. Defaults to 0.',
+                    default: 0
+                },
+                sort_order: {
+                    type: 'string',
+                    description: 'Sort order for pages based on modification date. "desc" for most recent first, "asc" for oldest first.',
+                    enum: ['asc', 'desc'],
+                    default: 'desc'
+                }
             }
         }
     },
     roam_search_by_text: {
         name: 'roam_search_by_text',
-        description: 'Search for blocks containing specific text across all pages or within a specific page.',
+        description: 'Search for blocks containing specific text across all pages or within a specific page. This tool supports pagination via the `limit` and `offset` parameters.',
         inputSchema: {
             type: 'object',
             properties: {
@@ -284,6 +310,21 @@ export const toolSchemas = {
                 page_title_uid: {
                     type: 'string',
                     description: 'Optional: Title or UID of the page to search in (UID is preferred for accuracy). If not provided, searches across all pages.'
+                },
+                case_sensitive: {
+                    type: 'boolean',
+                    description: 'Optional: Whether the search should be case-sensitive. If false, it will search for the provided text, capitalized versions, and first word capitalized versions.',
+                    default: false
+                },
+                limit: {
+                    type: 'integer',
+                    description: 'Optional: The maximum number of results to return. Defaults to 50. Use -1 for no limit, but be aware that very large results sets can impact performance.',
+                    default: 50
+                },
+                offset: {
+                    type: 'integer',
+                    description: 'Optional: The number of results to skip before returning matches. Useful for pagination. Defaults to 0.',
+                    default: 0
                 }
             },
             required: ['text']
@@ -354,7 +395,7 @@ export const toolSchemas = {
     },
     roam_recall: {
         name: 'roam_recall',
-        description: 'Retrieve all stored memories on page titled MEMORIES_TAG, or tagged block content with the same name. Returns a combined, deduplicated list of memories. Optionally filter blcoks with a specified tag and sort by creation date.',
+        description: 'Retrieve all stored memories on page titled MEMORIES_TAG, or tagged block content with the same name. Returns a combined, deduplicated list of memories. Optionally filter blcoks with a specific tag and sort by creation date.',
         inputSchema: {
             type: 'object',
             properties: {
@@ -373,13 +414,13 @@ export const toolSchemas = {
     },
     roam_datomic_query: {
         name: 'roam_datomic_query',
-        description: 'Execute a custom Datomic query on the Roam graph for advanced data retrieval beyond the available search tools. This provides direct access to Roam\'s query engine. Note: Roam graph is case-sensitive.\nList of some of Roam\'s data model Namespaces and Attributes: ancestor (descendants), attrs (lookup), block (children, heading, open, order, page, parents, props, refs, string, text-align, uid), children (view-type), create (email, time), descendant (ancestors), edit (email, seen-by, time), entity (attrs), log (id), node (title), page (uid, title), refs (text).\nPredicates (clojure.string/includes?, clojure.string/starts-with?, clojure.string/ends-with?, <, >, <=, >=, =, not=, !=).\nAggregates (distinct, count, sum, max, min, avg, limit).\nTips: Use :block/parents for all ancestor levels, :block/children for direct descendants only; combine clojure.string for complex matching, use distinct to deduplicate, leverage Pull patterns for hierarchies, handle case-sensitivity carefully, and chain ancestry rules for multi-level queries.',
+        description: 'Execute a custom Datomic query on the Roam graph for advanced data retrieval beyond the available search tools. This provides direct access to Roam\'s query engine. Note: Roam graph is case-sensitive.\n\n__Optimal Use Cases for `roam_datomic_query`:__\n- __Advanced Filtering (including Regex):__ Use for scenarios requiring complex filtering, including regex matching on results post-query, which Datalog does not natively support for all data types. It can fetch broader results for client-side post-processing.\n- __Highly Complex Boolean Logic:__ Ideal for intricate combinations of "AND", "OR", and "NOT" conditions across multiple terms or attributes.\n- __Arbitrary Sorting Criteria:__ The go-to for highly customized sorting needs beyond default options.\n- __Proximity Search:__ For advanced search capabilities involving proximity, which are difficult to implement efficiently with simpler tools.\n\nList of some of Roam\'s data model Namespaces and Attributes: ancestor (descendants), attrs (lookup), block (children, heading, open, order, page, parents, props, refs, string, text-align, uid), children (view-type), create (email, time), descendant (ancestors), edit (email, seen-by, time), entity (attrs), log (id), node (title), page (uid, title), refs (text).\nPredicates (clojure.string/includes?, clojure.string/starts-with?, clojure.string/ends-with?, <, >, <=, >=, =, not=, !=).\nAggregates (distinct, count, sum, max, min, avg, limit).\nTips: Use :block/parents for all ancestor levels, :block/children for direct descendants only; combine clojure.string for complex matching, use distinct to deduplicate, leverage Pull patterns for hierarchies, handle case-sensitivity carefully, and chain ancestry rules for multi-level queries.',
         inputSchema: {
             type: 'object',
             properties: {
                 query: {
                     type: 'string',
-                    description: 'The Datomic query to execute (in Datalog syntax)'
+                    description: 'The Datomic query to execute (in Datalog syntax). Example: `[:find ?block-string :where [?block :block/string ?block-string] (or [(clojure.string/includes? ?block-string "hypnosis")] [(clojure.string/includes? ?block-string "trance")] [(clojure.string/includes? ?block-string "suggestion")]) :limit 25]`'
                 },
                 inputs: {
                     type: 'array',
@@ -387,6 +428,21 @@ export const toolSchemas = {
                     items: {
                         type: 'string'
                     }
+                },
+                regexFilter: {
+                    type: 'string',
+                    description: 'Optional: A regex pattern to filter the results client-side after the Datomic query. Applied to JSON.stringify(result) or specific fields if regexTargetField is provided.'
+                },
+                regexFlags: {
+                    type: 'string',
+                    description: 'Optional: Flags for the regex filter (e.g., "i" for case-insensitive, "g" for global).',
+                },
+                regexTargetField: {
+                    type: 'array',
+                    items: {
+                        type: 'string'
+                    },
+                    description: 'Optional: An array of field paths (e.g., ["block_string", "page_title"]) within each Datomic result object to apply the regex filter to. If not provided, the regex is applied to the stringified full result.'
                 }
             },
             required: ['query']
@@ -445,10 +501,7 @@ export const toolSchemas = {
                                         description: 'The UID of the parent block or page.'
                                     },
                                     "order": {
-                                        oneOf: [
-                                            { type: 'integer', description: 'Zero-indexed position.' },
-                                            { type: 'string', enum: ['first', 'last'], description: 'Position keyword.' }
-                                        ],
+                                        type: ['integer', 'string'],
                                         description: 'The position of the block under its parent (e.g., 0, 1, 2) or a keyword ("first", "last").'
                                     }
                                 }

package/build/tools/tool-handlers.js

@@ -13,6 +13,7 @@ import { DatomicSearchHandlerImpl } from './operations/search/handlers.js';
 export class ToolHandlers {
     constructor(graph) {
         this.graph = graph;
+        this.cachedCheatsheet = null;
         this.pageOps = new PageOperations(graph);
         this.blockOps = new BlockOperations(graph);
         this.blockRetrievalOps = new BlockRetrievalOperations(graph); // Initialize new instance
@@ -23,8 +24,8 @@ export class ToolHandlers {
         this.batchOps = new BatchOperations(graph);
     }
     // Page Operations
-    async findPagesModifiedToday(max_num_pages = 50) {
-        return this.pageOps.findPagesModifiedToday(max_num_pages);
+    async findPagesModifiedToday(limit = 50, offset = 0, sort_order = 'desc') {
+        return this.pageOps.findPagesModifiedToday(limit, offset, sort_order);
     }
     async createPage(title, content) {
         return this.pageOps.createPage(title, content);
@@ -83,20 +84,34 @@ export class ToolHandlers {
         return this.batchOps.processBatch(actions);
     }
     async getRoamMarkdownCheatsheet() {
+        if (this.cachedCheatsheet) {
+            return this.cachedCheatsheet;
+        }
         const __filename = fileURLToPath(import.meta.url);
         const __dirname = path.dirname(__filename);
         const cheatsheetPath = path.join(__dirname, '../../Roam_Markdown_Cheatsheet.md');
-        let cheatsheetContent = fs.readFileSync(cheatsheetPath, 'utf-8');
-        const customInstructionsPath = process.env.CUSTOM_INSTRUCTIONS_PATH;
-        if (customInstructionsPath && fs.existsSync(customInstructionsPath)) {
-            try {
-                const customInstructionsContent = fs.readFileSync(customInstructionsPath, 'utf-8');
-                cheatsheetContent += `\n\n${customInstructionsContent}`;
-            }
-            catch (error) {
-                console.warn(`Could not read custom instructions file at ${customInstructionsPath}: ${error}`);
+        try {
+            let cheatsheetContent = await fs.promises.readFile(cheatsheetPath, 'utf-8');
+            const customInstructionsPath = process.env.CUSTOM_INSTRUCTIONS_PATH;
+            if (customInstructionsPath) {
+                try {
+                    // Check if file exists asynchronously
+                    await fs.promises.access(customInstructionsPath);
+                    const customInstructionsContent = await fs.promises.readFile(customInstructionsPath, 'utf-8');
+                    cheatsheetContent += `\n\n${customInstructionsContent}`;
+                }
+                catch (error) {
+                    // File doesn't exist or is not readable, ignore custom instructions
+                    if (error.code !== 'ENOENT') {
+                        console.warn(`Could not read custom instructions file at ${customInstructionsPath}: ${error}`);
+                    }
+                }
             }
+            this.cachedCheatsheet = cheatsheetContent;
+            return cheatsheetContent;
+        }
+        catch (error) {
+            throw new Error(`Failed to read cheatsheet: ${error}`);
         }
-        return cheatsheetContent;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "roam-research-mcp",
-  "version": "0.35.1",
+  "version": "1.0.0",
   "description": "A Model Context Protocol (MCP) server for Roam Research API integration",
   "private": false,
   "repository": {
@@ -22,13 +22,13 @@
   "homepage": "https://github.com/2b3pro/roam-research-mcp#readme",
   "type": "module",
   "bin": {
-    "roam-research": "./build/index.js"
+    "roam-research-mcp": "./build/index.js"
   },
   "files": [
     "build"
   ],
   "scripts": {
-    "build": "tsc && cat Roam_Markdown_Cheatsheet.md .roam/${CUSTOM_INSTRUCTIONS_PREFIX}custom-instructions.md > build/Roam_Markdown_Cheatsheet.md && chmod 755 build/index.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",
     "clean": "rm -rf build",
     "watch": "tsc --watch",
     "inspector": "npx @modelcontextprotocol/inspector build/index.js",
@@ -48,4 +48,4 @@
     "ts-node": "^10.9.2",
     "typescript": "^5.3.3"
   }
-}
+}