roam-research-mcp 2.4.0 → 2.13.0

package/build/query/parser.test.js

@@ -0,0 +1,389 @@
+import { describe, it, expect } from 'vitest';
+import { QueryParser, QueryParseError } from './parser.js';
+import { DatalogGenerator, buildDatalogQuery } from './generator.js';
+describe('QueryParser', () => {
+    describe('tag parsing', () => {
+        it('parses a single tag', () => {
+            const result = QueryParser.parse('[[Project]]');
+            expect(result).toEqual({ type: 'tag', value: 'Project' });
+        });
+        it('parses a tag with spaces', () => {
+            const result = QueryParser.parse('[[My Project]]');
+            expect(result).toEqual({ type: 'tag', value: 'My Project' });
+        });
+        it('parses a namespaced tag', () => {
+            const result = QueryParser.parse('[[Convention/Roam]]');
+            expect(result).toEqual({ type: 'tag', value: 'Convention/Roam' });
+        });
+    });
+    describe('and operator', () => {
+        it('parses and with two tags', () => {
+            const result = QueryParser.parse('{and: [[tag1]] [[tag2]]}');
+            expect(result).toEqual({
+                type: 'and',
+                children: [
+                    { type: 'tag', value: 'tag1' },
+                    { type: 'tag', value: 'tag2' }
+                ]
+            });
+        });
+        it('parses and with multiple tags', () => {
+            const result = QueryParser.parse('{and: [[a]] [[b]] [[c]]}');
+            expect(result).toEqual({
+                type: 'and',
+                children: [
+                    { type: 'tag', value: 'a' },
+                    { type: 'tag', value: 'b' },
+                    { type: 'tag', value: 'c' }
+                ]
+            });
+        });
+    });
+    describe('or operator', () => {
+        it('parses or with two tags', () => {
+            const result = QueryParser.parse('{or: [[tag1]] [[tag2]]}');
+            expect(result).toEqual({
+                type: 'or',
+                children: [
+                    { type: 'tag', value: 'tag1' },
+                    { type: 'tag', value: 'tag2' }
+                ]
+            });
+        });
+    });
+    describe('not operator', () => {
+        it('parses not with a tag', () => {
+            const result = QueryParser.parse('{not: [[excluded]]}');
+            expect(result).toEqual({
+                type: 'not',
+                child: { type: 'tag', value: 'excluded' }
+            });
+        });
+    });
+    describe('between operator', () => {
+        it('parses between with two dates', () => {
+            const result = QueryParser.parse('{between: [[January 1st, 2026]] [[January 31st, 2026]]}');
+            expect(result).toEqual({
+                type: 'between',
+                startDate: 'January 1st, 2026',
+                endDate: 'January 31st, 2026'
+            });
+        });
+        it('parses between with relative dates', () => {
+            const result = QueryParser.parse('{between: [[last month]] [[last week]]}');
+            expect(result).toEqual({
+                type: 'between',
+                startDate: 'last month',
+                endDate: 'last week'
+            });
+        });
+    });
+    describe('nested queries', () => {
+        it('parses and containing or', () => {
+            const result = QueryParser.parse('{and: {or: [[a]] [[b]]} [[c]]}');
+            expect(result).toEqual({
+                type: 'and',
+                children: [
+                    {
+                        type: 'or',
+                        children: [
+                            { type: 'tag', value: 'a' },
+                            { type: 'tag', value: 'b' }
+                        ]
+                    },
+                    { type: 'tag', value: 'c' }
+                ]
+            });
+        });
+        it('parses and with not', () => {
+            const result = QueryParser.parse('{and: [[include]] {not: [[exclude]]}}');
+            expect(result).toEqual({
+                type: 'and',
+                children: [
+                    { type: 'tag', value: 'include' },
+                    {
+                        type: 'not',
+                        child: { type: 'tag', value: 'exclude' }
+                    }
+                ]
+            });
+        });
+        it('parses complex nested query', () => {
+            const result = QueryParser.parse('{and: {or: [[Project]] [[Task]]} {not: [[Archive]]} [[TODO]]}');
+            expect(result).toEqual({
+                type: 'and',
+                children: [
+                    {
+                        type: 'or',
+                        children: [
+                            { type: 'tag', value: 'Project' },
+                            { type: 'tag', value: 'Task' }
+                        ]
+                    },
+                    {
+                        type: 'not',
+                        child: { type: 'tag', value: 'Archive' }
+                    },
+                    { type: 'tag', value: 'TODO' }
+                ]
+            });
+        });
+    });
+    describe('full query block format', () => {
+        it('parses {{[[query]]: ...}} format', () => {
+            const result = QueryParser.parse('{{[[query]]: {and: [[Convention/Roam]] [[Roam]]}}}');
+            expect(result).toEqual({
+                type: 'and',
+                children: [
+                    { type: 'tag', value: 'Convention/Roam' },
+                    { type: 'tag', value: 'Roam' }
+                ]
+            });
+        });
+        it('handles whitespace in query block', () => {
+            const result = QueryParser.parse('{{[[query]]:   {and: [[a]] [[b]]}  }}');
+            expect(result).toEqual({
+                type: 'and',
+                children: [
+                    { type: 'tag', value: 'a' },
+                    { type: 'tag', value: 'b' }
+                ]
+            });
+        });
+    });
+    describe('named queries', () => {
+        it('parses named query with parseWithName', () => {
+            const result = QueryParser.parseWithName('{{[[query]]: "My Query Name" {and: [[a]] [[b]]}}}');
+            expect(result.name).toBe('My Query Name');
+            expect(result.query).toEqual({
+                type: 'and',
+                children: [
+                    { type: 'tag', value: 'a' },
+                    { type: 'tag', value: 'b' }
+                ]
+            });
+        });
+        it('returns undefined name for unnamed query', () => {
+            const result = QueryParser.parseWithName('{{[[query]]: {and: [[a]] [[b]]}}}');
+            expect(result.name).toBeUndefined();
+            expect(result.query.type).toBe('and');
+        });
+        it('parse() ignores name and returns just the query', () => {
+            const result = QueryParser.parse('{{[[query]]: "Named Query" [[tag]]}}');
+            expect(result).toEqual({ type: 'tag', value: 'tag' });
+        });
+        it('handles escaped quotes in name', () => {
+            const result = QueryParser.parseWithName('{search: test}');
+            // Simple query without name
+            expect(result.name).toBeUndefined();
+        });
+    });
+    describe('block reference', () => {
+        it('parses block ref', () => {
+            const result = QueryParser.parse('((abc123def))');
+            expect(result).toEqual({ type: 'block-ref', uid: 'abc123def' });
+        });
+        it('parses block ref in and', () => {
+            const result = QueryParser.parse('{and: [[tag]] ((uid123))}');
+            expect(result).toEqual({
+                type: 'and',
+                children: [
+                    { type: 'tag', value: 'tag' },
+                    { type: 'block-ref', uid: 'uid123' }
+                ]
+            });
+        });
+    });
+    describe('search operator', () => {
+        it('parses search with unquoted text', () => {
+            const result = QueryParser.parse('{search: hello world}');
+            expect(result).toEqual({ type: 'search', text: 'hello world' });
+        });
+        it('parses search with quoted text', () => {
+            const result = QueryParser.parse('{search: "exact phrase"}');
+            expect(result).toEqual({ type: 'search', text: 'exact phrase' });
+        });
+    });
+    describe('daily notes operator', () => {
+        it('parses daily notes', () => {
+            const result = QueryParser.parse('{daily notes: }');
+            expect(result).toEqual({ type: 'daily-notes' });
+        });
+        it('parses daily notes in and', () => {
+            const result = QueryParser.parse('{and: {daily notes: } [[tag]]}');
+            expect(result).toEqual({
+                type: 'and',
+                children: [
+                    { type: 'daily-notes' },
+                    { type: 'tag', value: 'tag' }
+                ]
+            });
+        });
+    });
+    describe('by operator', () => {
+        it('parses by with page ref', () => {
+            const result = QueryParser.parse('{by: [[PAI System User]]}');
+            expect(result).toEqual({ type: 'by', user: 'PAI System User' });
+        });
+        it('parses by in complex query', () => {
+            const result = QueryParser.parse('{{[[query]]: "Test Query" {and: [[Test/CreatePage Fix Verification]] {by: [[PAI System User]]}}}}');
+            expect(result).toEqual({
+                type: 'and',
+                children: [
+                    { type: 'tag', value: 'Test/CreatePage Fix Verification' },
+                    { type: 'by', user: 'PAI System User' }
+                ]
+            });
+        });
+    });
+    describe('created by operator', () => {
+        it('parses created by with plain text', () => {
+            const result = QueryParser.parse('{created by: John Doe}');
+            expect(result).toEqual({ type: 'created-by', user: 'John Doe' });
+        });
+        it('parses created by with page ref', () => {
+            const result = QueryParser.parse('{created by: [[John Doe]]}');
+            expect(result).toEqual({ type: 'created-by', user: 'John Doe' });
+        });
+    });
+    describe('edited by operator', () => {
+        it('parses edited by with plain text', () => {
+            const result = QueryParser.parse('{edited by: Jane Smith}');
+            expect(result).toEqual({ type: 'edited-by', user: 'Jane Smith' });
+        });
+    });
+    describe('error handling', () => {
+        it('throws on unclosed tag', () => {
+            expect(() => QueryParser.parse('[[unclosed')).toThrow(QueryParseError);
+        });
+        it('throws on unknown operator', () => {
+            expect(() => QueryParser.parse('{unknown: [[tag]]}')).toThrow(QueryParseError);
+        });
+        it('throws on empty and', () => {
+            expect(() => QueryParser.parse('{and: }')).toThrow(QueryParseError);
+        });
+    });
+});
+describe('DatalogGenerator', () => {
+    const generator = new DatalogGenerator();
+    describe('tag generation', () => {
+        it('generates ref clauses for a tag', () => {
+            const ast = QueryParser.parse('[[Project]]');
+            const clauses = generator.generate(ast);
+            expect(clauses.where).toContain('[?ref-0 :node/title "Project"]');
+            expect(clauses.where).toContain('[?b :block/refs ?ref-0]');
+        });
+    });
+    describe('and generation', () => {
+        it('generates multiple ref clauses', () => {
+            const ast = QueryParser.parse('{and: [[tag1]] [[tag2]]}');
+            const clauses = generator.generate(ast);
+            expect(clauses.where.length).toBe(4); // 2 refs, 2 title matches
+            expect(clauses.where).toContain('[?ref-0 :node/title "tag1"]');
+            expect(clauses.where).toContain('[?ref-1 :node/title "tag2"]');
+        });
+    });
+    describe('or generation', () => {
+        it('generates or-join clause', () => {
+            const ast = QueryParser.parse('{or: [[a]] [[b]]}');
+            const clauses = generator.generate(ast);
+            expect(clauses.where.length).toBe(1);
+            expect(clauses.where[0]).toContain('or-join');
+            expect(clauses.where[0]).toContain('[?b]');
+        });
+    });
+    describe('not generation', () => {
+        it('wraps in not clause', () => {
+            const ast = QueryParser.parse('{not: [[excluded]]}');
+            const clauses = generator.generate(ast);
+            expect(clauses.where.length).toBe(1);
+            expect(clauses.where[0]).toMatch(/^\(not /);
+        });
+    });
+    describe('block-ref generation', () => {
+        it('generates block ref clauses', () => {
+            const ast = QueryParser.parse('((uid123))');
+            const clauses = generator.generate(ast);
+            expect(clauses.where).toContain('[?block-ref-0 :block/uid "uid123"]');
+            expect(clauses.where).toContain('[?b :block/refs ?block-ref-0]');
+        });
+    });
+    describe('search generation', () => {
+        it('generates search clause', () => {
+            const ast = QueryParser.parse('{search: test query}');
+            const clauses = generator.generate(ast);
+            expect(clauses.where.length).toBe(1);
+            expect(clauses.where[0]).toContain('clojure.string/includes?');
+            expect(clauses.where[0]).toContain('test query');
+        });
+    });
+    describe('daily-notes generation', () => {
+        it('generates daily notes filter', () => {
+            const ast = QueryParser.parse('{daily notes: }');
+            const clauses = generator.generate(ast);
+            expect(clauses.where.some(c => c.includes('re-find'))).toBe(true);
+            expect(clauses.where.some(c => c.includes('January|February'))).toBe(true);
+        });
+    });
+    describe('between generation with relative dates', () => {
+        it('generates between with relative dates', () => {
+            const ast = QueryParser.parse('{between: [[last month]] [[today]]}');
+            const clauses = generator.generate(ast);
+            // Should have create/time clauses
+            expect(clauses.where.some(c => c.includes(':create/time'))).toBe(true);
+            // Should have input values (timestamps)
+            expect(clauses.inputValues.length).toBe(2);
+            expect(typeof clauses.inputValues[0]).toBe('number');
+            expect(typeof clauses.inputValues[1]).toBe('number');
+            // Start should be before end
+            expect(clauses.inputValues[0]).toBeLessThan(clauses.inputValues[1]);
+        });
+        it('handles "N days ago" format', () => {
+            const ast = QueryParser.parse('{between: [[7 days ago]] [[today]]}');
+            const clauses = generator.generate(ast);
+            expect(clauses.inputValues.length).toBe(2);
+            const sevenDaysMs = 7 * 24 * 60 * 60 * 1000;
+            const diff = clauses.inputValues[1] - clauses.inputValues[0];
+            // Difference should be approximately 7 days (with some buffer for end-of-day adjustment)
+            expect(diff).toBeGreaterThanOrEqual(sevenDaysMs);
+        });
+    });
+    describe('by generation', () => {
+        it('generates by clause with or-join', () => {
+            const ast = QueryParser.parse('{by: [[Test User]]}');
+            const clauses = generator.generate(ast);
+            expect(clauses.where.length).toBe(1);
+            expect(clauses.where[0]).toContain('or-join');
+            expect(clauses.where[0]).toContain(':create/user');
+            expect(clauses.where[0]).toContain(':edit/user');
+            expect(clauses.where[0]).toContain('Test User');
+        });
+    });
+    describe('created-by generation', () => {
+        it('generates created by clause', () => {
+            const ast = QueryParser.parse('{created by: John}');
+            const clauses = generator.generate(ast);
+            expect(clauses.where.some(c => c.includes(':create/user'))).toBe(true);
+            expect(clauses.where.some(c => c.includes(':user/display-name'))).toBe(true);
+        });
+    });
+    describe('buildDatalogQuery', () => {
+        it('builds complete query string', () => {
+            const ast = QueryParser.parse('{and: [[Project]] [[TODO]]}');
+            const clauses = generator.generate(ast);
+            const { query, args } = buildDatalogQuery(clauses, { limit: 50 });
+            expect(query).toContain(':find');
+            expect(query).toContain(':where');
+            expect(query).toContain(':limit 50');
+            expect(query).toContain('[?b :block/string ?block-str]');
+            expect(args).toEqual([]);
+        });
+        it('adds page scope when pageUid provided', () => {
+            const ast = QueryParser.parse('[[tag]]');
+            const clauses = generator.generate(ast);
+            const { query, args } = buildDatalogQuery(clauses, { pageUid: 'abc123' });
+            expect(query).toContain('?target-page-uid');
+            expect(args).toContain('abc123');
+        });
+    });
+});

package/build/query/types.js

@@ -0,0 +1,4 @@
+/**
+ * Types for Roam Query Block parsing and Datalog generation
+ */
+export {};

package/build/search/ancestor-rule.js

@@ -0,0 +1,14 @@
+/**
+ * Datomic ancestor rule for traversing Roam block hierarchies.
+ * Used to find all blocks under a page or parent block.
+ *
+ * Usage in queries: Pass as second parameter (%) and use `(ancestor ?child ?parent)` in where clause.
+ * Example: `[:find ?block :in $ % ?page-uid :where (ancestor ?block ?page)]`
+ */
+export const ANCESTOR_RULE = `[
+  [ (ancestor ?b ?a)
+    [?a :block/children ?b] ]
+  [ (ancestor ?b ?a)
+    [?parent :block/children ?b]
+    (ancestor ?parent ?a) ]
+]`;

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

@@ -1,7 +1,6 @@
 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 BlockRefSearchHandler extends BaseSearchHandler {
     constructor(graph, params) {
         super(graph);
@@ -90,10 +89,7 @@ export class BlockRefSearchHandler extends BaseSearchHandler {
         }
         const rawResults = await q(this.graph, queryStr, queryParams);
         // 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 = title
             ? `referencing [[${title}]]`
             : block_uid

package/build/search/hierarchy-search.js

@@ -1,6 +1,7 @@
 import { q } from '@roam-research/roam-api-sdk';
 import { BaseSearchHandler } from './types.js';
 import { SearchUtils } from './utils.js';
+import { ANCESTOR_RULE } from './ancestor-rule.js';
 import { resolveRefs } from '../tools/helpers/refs.js';
 export class HierarchySearchHandler extends BaseSearchHandler {
     constructor(graph, params) {
@@ -21,14 +22,6 @@ export class HierarchySearchHandler extends BaseSearchHandler {
         if (page_title_uid) {
             targetPageUid = await SearchUtils.findPageByTitleOrUid(this.graph, page_title_uid);
         }
-        // Define ancestor rule for recursive traversal
-        const ancestorRule = `[
-      [ (ancestor ?child ?parent) 
-          [?parent :block/children ?child] ]
-      [ (ancestor ?child ?a) 
-          [?parent :block/children ?child] 
-          (ancestor ?parent ?a) ]
-    ]`;
         let queryStr;
         let queryParams;
         if (parent_uid) {
@@ -43,7 +36,7 @@ export class HierarchySearchHandler extends BaseSearchHandler {
                            [?b :block/uid ?block-uid]
                            [?b :block/page ?p]
                            [(get-else $ ?b :block/path-length 1) ?depth]]`;
-                queryParams = [ancestorRule, parent_uid, targetPageUid];
+                queryParams = [ANCESTOR_RULE, parent_uid, targetPageUid];
             }
             else {
                 queryStr = `[:find ?block-uid ?block-str ?page-title ?depth
@@ -55,7 +48,7 @@ export class HierarchySearchHandler extends BaseSearchHandler {
                            [?b :block/page ?p]
                            [?p :node/title ?page-title]
                            [(get-else $ ?b :block/path-length 1) ?depth]]`;
-                queryParams = [ancestorRule, parent_uid];
+                queryParams = [ANCESTOR_RULE, parent_uid];
             }
         }
         else {
@@ -70,7 +63,7 @@ export class HierarchySearchHandler extends BaseSearchHandler {
                            [?b :block/uid ?block-uid]
                            [?b :block/page ?p]
                            [(get-else $ ?b :block/path-length 1) ?depth]]`;
-                queryParams = [ancestorRule, child_uid, targetPageUid];
+                queryParams = [ANCESTOR_RULE, child_uid, targetPageUid];
             }
             else {
                 queryStr = `[:find ?block-uid ?block-str ?page-title ?depth
@@ -82,7 +75,7 @@ export class HierarchySearchHandler extends BaseSearchHandler {
                            [?b :block/page ?p]
                            [?p :node/title ?page-title]
                            [(get-else $ ?b :block/path-length 1) ?depth]]`;
-                queryParams = [ancestorRule, child_uid];
+                queryParams = [ANCESTOR_RULE, child_uid];
             }
         }
         const rawResults = await q(this.graph, queryStr, queryParams);

package/build/search/index.js

@@ -1,5 +1,6 @@
 export * from './types.js';
 export * from './utils.js';
+export * from './ancestor-rule.js';
 export * from './tag-search.js';
 export * from './status-search.js';
 export * from './block-ref-search.js';

package/build/search/status-search.js

@@ -1,7 +1,6 @@
 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 StatusSearchHandler extends BaseSearchHandler {
     constructor(graph, params) {
         super(graph);
@@ -19,31 +18,33 @@ export class StatusSearchHandler extends BaseSearchHandler {
         let queryParams;
         // Search for "{{TODO" or "{{DONE" which matches both {{[[TODO]]}} and {{TODO}} formats
         if (targetPageUid) {
-            queryStr = `[:find ?block-uid ?block-str
+            queryStr = `[:find ?block-uid ?block-str ?page-title ?block-create-time ?block-edit-time
                   :in $ ?status ?page-uid
                   :where [?p :block/uid ?page-uid]
+                         [?p :node/title ?page-title]
                          [?b :block/page ?p]
                          [?b :block/string ?block-str]
                          [?b :block/uid ?block-uid]
-                         [(clojure.string/includes? ?block-str (str "{{" ?status))]]`;
+                         [(clojure.string/includes? ?block-str (str "{{" ?status))]
+                         [(get-else $ ?b :create/time 0) ?block-create-time]
+                         [(get-else $ ?b :edit/time 0) ?block-edit-time]]`;
             queryParams = [status, 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 $ ?status
                   :where [?b :block/string ?block-str]
                          [?b :block/uid ?block-uid]
                          [?b :block/page ?p]
                          [?p :node/title ?page-title]
-                         [(clojure.string/includes? ?block-str (str "{{" ?status))]]`;
+                         [(clojure.string/includes? ?block-str (str "{{" ?status))]
+                         [(get-else $ ?b :create/time 0) ?block-create-time]
+                         [(get-else $ ?b :edit/time 0) ?block-edit-time]]`;
             queryParams = [status];
         }
         const rawResults = await q(this.graph, queryStr, queryParams);
         // 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);
         return SearchUtils.formatSearchResults(resolvedResults, `with status ${status}`, !targetPageUid);
     }
 }

package/build/search/tag-search.js

@@ -1,7 +1,6 @@
 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 TagSearchHandler extends BaseSearchHandler {
     constructor(graph, params) {
         super(graph);
@@ -38,33 +37,21 @@ export class TagSearchHandler extends BaseSearchHandler {
         if (page_title_uid) {
             targetPageUid = await SearchUtils.findPageByTitleOrUid(this.graph, page_title_uid);
         }
-        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(' ');
+        const tagMatchClause = SearchUtils.buildTagMatchClause(primary_tag, '?ref-page', case_sensitive);
         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 = `
-                      (or ${tagWhereClauses})
+                      ${tagMatchClause}
                       [?b :block/refs ?ref-page]
                       [?b :block/string ?block-str]
                       [?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 (nearTagUid) {
             queryWhereClauses += `
                       [?b :block/refs ?near-tag-page]
@@ -80,9 +67,9 @@ export class TagSearchHandler extends BaseSearchHandler {
             queryWhereClauses += `
                       [?p :block/uid ?target-page-uid]`;
         }
-        const queryStr = `[:find ?block-uid ?block-str ?page-title
+        const queryStr = `[:find ?block-uid ?block-str ?page-title ?block-create-time ?block-edit-time
                       ${inClause} ${queryLimit} ${queryOffset} ${queryOrder}
-                      :where 
+                      :where
                       ${queryWhereClauses}]`;
         const queryArgs = [];
         if (targetPageUid) {
@@ -97,10 +84,7 @@ export class TagSearchHandler extends BaseSearchHandler {
         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 resolvedResults = await this.resolveBlockRefs(rawResults);
         const searchDescription = `referencing "${primary_tag}"`;
         const formattedResults = SearchUtils.formatSearchResults(resolvedResults, searchDescription, !targetPageUid);
         formattedResults.total_count = totalCount;