agent-remnote 0.1.0 → 0.3.0

package/dist/packages/mcp/src/tools/executeSearchQuery.js

@@ -1,914 +0,0 @@
-import { z } from "zod";
-import { queryNodeSchema, normalizeQueryNode, sortModeSchema, } from "./searchQueryTypes.js";
-import { withResolvedDatabase, buildGuidedResponse, safeJsonParse, parseOrThrow, } from "./shared.js";
-import { coalesceText, createPreview, stringifyAncestor } from "./searchUtils.js";
-export const executeSearchQuerySchema = z.object({
-    query: z
-        .object({
-        root: queryNodeSchema.describe("查询 AST 根节点，支持 text/tag/rem/attribute/page 与 and/or/not 组合"),
-        limitHint: z
-            .number()
-            .int()
-            .min(1)
-            .max(500)
-            .optional()
-            .describe("返回上限提示（供执行阶段参考）"),
-        pageSizeHint: z
-            .number()
-            .int()
-            .min(5)
-            .max(200)
-            .optional()
-            .describe("分页大小提示（供执行阶段参考）"),
-        sort: sortModeSchema.optional().describe("排序策略：rank/updatedAt/createdAt/attribute"),
-        description: z.string().optional().describe("查询的人类可读说明"),
-    })
-        .describe("由 build_search_query 生成或手动构造的查询对象"),
-    dbPath: z
-        .string()
-        .optional()
-        .describe("数据库文件路径（默认自动发现最新 remnote.db）"),
-    limit: z
-        .number()
-        .int()
-        .min(1)
-        .max(100)
-        .optional()
-        .describe("返回条数上限（分页）"),
-    offset: z
-        .number()
-        .int()
-        .min(0)
-        .optional()
-        .describe("分页偏移量"),
-    maxLeafResults: z
-        .number()
-        .int()
-        .min(50)
-        .max(5000)
-        .optional()
-        .describe("单个叶子条件的候选上限（避免集合过大）"),
-    snippetLength: z
-        .number()
-        .int()
-        .min(30)
-        .max(400)
-        .optional()
-        .describe("结果摘要长度（字符数）"),
-});
-const TEXT_WEIGHT = 8;
-const TAG_WEIGHT = 5;
-const REM_WEIGHT = 12;
-const ATTRIBUTE_WEIGHT = 7;
-export async function executeSearchQuery(input) {
-    const parsed = parseOrThrow(executeSearchQuerySchema, input, { label: "execute_search_query" });
-    const query = {
-        ...parsed.query,
-        root: normalizeQueryNode(parsed.query.root),
-    };
-    const limit = parsed.limit ?? query.pageSizeHint ?? query.limitHint ?? 20;
-    const offset = parsed.offset ?? 0;
-    const snippetLength = parsed.snippetLength ?? 200;
-    const maxLeaf = parsed.maxLeafResults ?? 800;
-    const { result, info } = await withResolvedDatabase(parsed.dbPath, async (db) => {
-        return executeQueryInternal({
-            db,
-            query,
-            limit,
-            offset,
-            snippetLength,
-            maxLeafResults: maxLeaf,
-        });
-    });
-    const suggestions = [];
-    if (result.items.length > 0) {
-        suggestions.push("查看全文：outline_rem_subtree 或 inspect_rem_doc");
-        if (result.hasMore && result.nextOffset != null) {
-            suggestions.push(`还有更多结果，可再次调用 execute_search_query 并设置 offset=${result.nextOffset}`);
-        }
-        suggestions.push("如需调整条件，可修改 build_search_query 的 root 后重新执行");
-    }
-    else {
-        suggestions.push("未命中，可尝试放宽关键词或删减属性过滤条件");
-    }
-    const guidance = result.items.length > 0
-        ? `共命中 ${result.totalMatched} 条，当前返回 ${result.items.length} 条（offset=${offset}，limit=${limit}）。`
-        : "未找到匹配 Rem，可调整查询条件后重试。";
-    const payload = {
-        guidance,
-        queryUsed: query,
-        dbPath: info.dbPath,
-        resolution: info.source,
-        dirName: info.dirName,
-        limit,
-        offset,
-        hasMore: result.hasMore,
-        nextOffset: result.nextOffset,
-        totalCandidates: result.totalCandidates,
-        totalMatched: result.totalMatched,
-        items: result.items,
-    };
-    return { payload, suggestions };
-}
-export function registerExecuteSearchQuery(server) {
-    server.tool("execute_search_query", `<usecase>执行 build_search_query 生成的查询 AST，返回匹配 Rem 列表。</usecase>
-<instructions>
-- 传入 query.root（可由 build_search_query 生成或手动构造），可配合 limit/offset 实现分页。
-- 默认每页返回 20 项，maxLeafResults 控制单个条件的候选上限（避免查询过大）。
-- snippetLength 控制结果摘要长度；若需阅读全文，请调用 outline_rem_subtree / inspect_rem_doc。
-- 响应会给出 guidance 与 next 建议，指引后续分页或细化条件。
-</instructions>`, executeSearchQuerySchema.shape, async (input) => {
-        const { payload, suggestions } = await executeSearchQuery(input);
-        return buildGuidedResponse(payload, suggestions);
-    });
-}
-async function executeQueryInternal(params) {
-    const { db, query, limit, offset, snippetLength, maxLeafResults } = params;
-    const leaves = collectLeaves(query.root);
-    const leafEvaluations = leaves.map((leaf) => ({
-        node: leaf,
-        result: evaluateLeaf(db, leaf, maxLeafResults),
-    }));
-    const universe = buildUniverse(leafEvaluations);
-    const rootResult = evaluateNode(query.root, leafEvaluations, universe);
-    const matchedIds = Array.from(rootResult.ids);
-    const sortMode = query.sort ?? { mode: "rank" };
-    const metadata = fetchMetadata(db, matchedIds, snippetLength);
-    const scoreMap = rootResult.scores;
-    if (query.sort?.mode === "attribute") {
-        const sortValues = fetchAttributeSortValues(db, matchedIds, query.sort.attributeId);
-        for (const [id, value] of sortValues) {
-            const meta = metadata.get(id);
-            if (meta) {
-                meta.sortValue = value ?? undefined;
-            }
-        }
-    }
-    const sortedIds = sortResults(matchedIds, sortMode, metadata, scoreMap);
-    const totalMatched = sortedIds.length;
-    const paginated = sortedIds.slice(offset, offset + limit);
-    const hasMore = offset + limit < sortedIds.length;
-    const nextOffset = hasMore ? offset + limit : null;
-    const items = paginated.map((id) => {
-        const meta = metadata.get(id);
-        if (!meta) {
-            return formatResultItem({
-                id,
-                aliasId: id,
-                text: "",
-                ancestorText: null,
-                ancestorIds: [],
-                parentId: null,
-                rank: 0,
-                freqCounter: 0,
-                freqTime: 0,
-                updatedAt: null,
-                createdAt: null,
-                snippetLength,
-                score: scoreMap.get(id) ?? 0,
-            });
-        }
-        return formatResultItem({
-            ...meta,
-            snippetLength,
-            score: scoreMap.get(id) ?? 0,
-        });
-    });
-    return {
-        items,
-        totalCandidates: universe.allIds.size,
-        totalMatched,
-        hasMore,
-        nextOffset,
-    };
-}
-function collectLeaves(node, acc = []) {
-    if (node.type === "and" || node.type === "or") {
-        for (const child of node.nodes) {
-            collectLeaves(child, acc);
-        }
-        return acc;
-    }
-    if (node.type === "not") {
-        collectLeaves(node.node, acc);
-        return acc;
-    }
-    acc.push(node);
-    return acc;
-}
-function evaluateLeaf(db, node, maxLeafResults) {
-    switch (node.type) {
-        case "text":
-            return searchText(db, node.value, node.mode ?? "contains", maxLeafResults);
-        case "tag":
-            return searchTag(db, node.id, maxLeafResults);
-        case "rem":
-            return searchSpecificRem(node.id);
-        case "page":
-            return searchPages(db, maxLeafResults);
-        case "attribute":
-            return searchAttribute(db, node, maxLeafResults);
-        default:
-            return { ids: new Set(), scores: new Map() };
-    }
-}
-function buildUniverse(evaluations) {
-    const allIds = new Set();
-    const baseScores = new Map();
-    for (const { result } of evaluations) {
-        for (const id of result.ids) {
-            allIds.add(id);
-            baseScores.set(id, (baseScores.get(id) ?? 0) + (result.scores.get(id) ?? 0));
-        }
-    }
-    return { allIds, baseScores };
-}
-function evaluateNode(node, evaluations, universe) {
-    if (node.type === "and") {
-        const children = node.nodes.map((child) => evaluateNode(child, evaluations, universe));
-        if (children.length === 0) {
-            return { ids: new Set(), scores: new Map() };
-        }
-        let ids = new Set(children[0].ids);
-        for (let i = 1; i < children.length; i++) {
-            ids = intersectSets(ids, children[i].ids);
-            if (ids.size === 0)
-                break;
-        }
-        const scores = new Map();
-        for (const id of ids) {
-            let score = 0;
-            for (const child of children) {
-                score += child.scores.get(id) ?? 0;
-            }
-            scores.set(id, score);
-        }
-        return { ids, scores };
-    }
-    if (node.type === "or") {
-        const children = node.nodes.map((child) => evaluateNode(child, evaluations, universe));
-        const ids = new Set();
-        const scores = new Map();
-        for (const child of children) {
-            for (const id of child.ids) {
-                ids.add(id);
-                const existing = scores.get(id) ?? 0;
-                const candidate = child.scores.get(id) ?? 0;
-                scores.set(id, Math.max(existing, candidate));
-            }
-        }
-        return { ids, scores };
-    }
-    if (node.type === "not") {
-        const child = evaluateNode(node.node, evaluations, universe);
-        const ids = new Set();
-        const scores = new Map();
-        for (const id of universe.allIds) {
-            if (!child.ids.has(id)) {
-                ids.add(id);
-                scores.set(id, universe.baseScores.get(id) ?? 1);
-            }
-        }
-        return { ids, scores };
-    }
-    // leaf node
-    const evaluation = evaluations.find((entry) => entry.node === node);
-    if (!evaluation) {
-        return { ids: new Set(), scores: new Map() };
-    }
-    return evaluation.result;
-}
-function intersectSets(a, b) {
-    const result = new Set();
-    for (const id of a) {
-        if (b.has(id))
-            result.add(id);
-    }
-    return result;
-}
-function searchText(db, value, mode, max) {
-    const normalized = value.trim();
-    if (!normalized) {
-        return { ids: new Set(), scores: new Map() };
-    }
-    const ids = new Set();
-    const scores = new Map();
-    const tryFts = (query) => {
-        try {
-            const stmt = db.prepare(`SELECT aliasId, id, COALESCE((SELECT rank FROM remsSearchRanks WHERE ftsRowId = remsSearchInfos.ftsRowId), 0) AS rank
-         FROM remsSearchInfos
-         WHERE ftsRowId IN (SELECT rowid FROM remsContents WHERE remsContents MATCH @query)
-         LIMIT @limit`);
-            const rows = stmt.all({ query, limit: max });
-            for (const row of rows) {
-                ids.add(row.id);
-                scores.set(row.id, (scores.get(row.id) ?? 0) + TEXT_WEIGHT + row.rank);
-            }
-        }
-        catch (error) {
-            const message = String(error ?? "");
-            if (!/malformed MATCH/i.test(message) && !/no such tokenizer/i.test(message)) {
-                throw error;
-            }
-        }
-    };
-    switch (mode) {
-        case "phrase":
-            tryFts(`"${normalized.replace(/"/g, '""')}"`);
-            if (ids.size === 0) {
-                runLikeSearch(db, `%${normalized.toLowerCase().replace(/\s+/g, "%")}%`, max, ids, scores);
-            }
-            break;
-        case "prefix":
-            tryFts(`${normalized.replace(/"/g, ' ')}*`);
-            if (ids.size === 0) {
-                runLikeSearch(db, `${normalized.toLowerCase().replace(/\s+/g, "%")}%`, max, ids, scores);
-            }
-            break;
-        case "suffix":
-            runLikeSearch(db, `%${normalized.toLowerCase()}`, max, ids, scores);
-            break;
-        case "contains":
-        default:
-            tryFts(normalized);
-            if (ids.size === 0) {
-                runLikeSearch(db, `%${normalized.toLowerCase().replace(/\s+/g, "%")}%`, max, ids, scores);
-            }
-            break;
-    }
-    return { ids, scores };
-}
-function searchPages(db, max) {
-    const ids = new Set();
-    const scores = new Map();
-    const stmt = db.prepare(`SELECT id, COALESCE((SELECT rank FROM remsSearchRanks WHERE ftsRowId = remsSearchInfos.ftsRowId), 0) AS rank
-     FROM remsSearchInfos
-     WHERE CAST(json_extract(doc,'$.rd') AS INTEGER) = 1
-     LIMIT @limit`);
-    const rows = stmt.all({ limit: max });
-    for (const row of rows) {
-        ids.add(row.id);
-        scores.set(row.id, (scores.get(row.id) ?? 0) + REM_WEIGHT + row.rank);
-    }
-    return { ids, scores };
-}
-function runLikeSearch(db, pattern, max, ids, scores) {
-    const compactSource = pattern.replace(/%/g, "").replace(/\s+/g, "");
-    const patternCompact = compactSource ? `%${compactSource}%` : pattern;
-    const stmt = db.prepare(`SELECT aliasId, id, 0 AS rank
-     FROM remsSearchInfos
-     WHERE lower(json_extract(doc, '$.kt')) LIKE @pattern
-        OR lower(json_extract(doc, '$.ke')) LIKE @pattern
-        OR REPLACE(lower(json_extract(doc, '$.kt')), ' ', '') LIKE @patternCompact
-        OR REPLACE(lower(json_extract(doc, '$.ke')), ' ', '') LIKE @patternCompact
-     LIMIT @limit`);
-    const rows = stmt.all({ pattern, patternCompact, limit: max });
-    for (const row of rows) {
-        ids.add(row.id);
-        scores.set(row.id, (scores.get(row.id) ?? 0) + TEXT_WEIGHT);
-    }
-}
-function searchTag(db, tagId, max) {
-    const stmt = db.prepare(`SELECT _id
-     FROM quanta
-     WHERE json_extract(doc, '$.tp."${tagId}".t') = 1
-     LIMIT @limit`);
-    const rows = stmt.all({ limit: max });
-    const ids = new Set();
-    const scores = new Map();
-    for (const row of rows) {
-        ids.add(row._id);
-        scores.set(row._id, (scores.get(row._id) ?? 0) + TAG_WEIGHT);
-    }
-    return { ids, scores };
-}
-function searchSpecificRem(remId) {
-    const ids = new Set([remId]);
-    const scores = new Map([[remId, REM_WEIGHT]]);
-    return { ids, scores };
-}
-function searchAttribute(db, condition, max) {
-    const stmt = db.prepare(`SELECT json_extract(doc, '$.parent') AS parentId, doc
-     FROM quanta
-     WHERE json_extract(doc, '$.key[0]._id') = @attributeId
-     LIMIT @limit`);
-    const rows = stmt.all({ attributeId: condition.attributeId, limit: max });
-    const ids = new Set();
-    const scores = new Map();
-    const dateCache = new Map();
-    for (const row of rows) {
-        if (!row.parentId)
-            continue;
-        const parsed = safeJsonParse(row.doc);
-        if (!parsed)
-            continue;
-        const match = evaluateAttributeCondition(db, parsed, condition, dateCache);
-        if (!match)
-            continue;
-        ids.add(row.parentId);
-        scores.set(row.parentId, (scores.get(row.parentId) ?? 0) + ATTRIBUTE_WEIGHT);
-    }
-    return { ids, scores };
-}
-function evaluateAttributeCondition(db, doc, condition, dateCache) {
-    const value = doc.value;
-    const type = doc.type;
-    const tokens = Array.isArray(value) ? value : value != null ? [value] : [];
-    const strings = [];
-    const refs = [];
-    for (const token of tokens) {
-        if (typeof token === "string") {
-            strings.push(token);
-            continue;
-        }
-        if (token && typeof token === "object") {
-            const obj = token;
-            if (obj.i === "q" && typeof obj._id === "string") {
-                refs.push(obj._id);
-                continue;
-            }
-            if (typeof obj.text === "string") {
-                strings.push(obj.text);
-                continue;
-            }
-            if (typeof obj.title === "string") {
-                strings.push(obj.title);
-                continue;
-            }
-        }
-    }
-    const isEmpty = tokens.length === 0;
-    switch (condition.operator) {
-        case "equals":
-            if (condition.value === undefined)
-                return false;
-            const equalsValue = normalizeConditionValue(condition.value);
-            return strings.includes(equalsValue) || refs.includes(String(condition.value));
-        case "notEquals":
-            if (condition.value === undefined)
-                return false;
-            const notEqualsValue = normalizeConditionValue(condition.value);
-            return !strings.includes(notEqualsValue) && !refs.includes(String(condition.value));
-        case "contains":
-            if (!condition.value && !condition.values)
-                return false;
-            if (condition.values) {
-                return condition.values.every((val) => strings.includes(String(val)) || refs.includes(String(val)));
-            }
-            if (condition.value === undefined)
-                return false;
-            const containsValue = normalizeConditionValue(condition.value).toLowerCase();
-            return strings.some((str) => str.toLowerCase().includes(containsValue));
-        case "notContains":
-            if (!condition.value && !condition.values)
-                return true;
-            if (condition.values) {
-                return condition.values.every((val) => !strings.includes(String(val)) && !refs.includes(String(val)));
-            }
-            if (condition.value === undefined)
-                return true;
-            const notContainsValue = normalizeConditionValue(condition.value).toLowerCase();
-            return !strings.some((str) => str.toLowerCase().includes(notContainsValue));
-        case "greaterThan":
-        case "greaterThanOrEquals":
-        case "lessThan":
-        case "lessThanOrEquals":
-        case "between":
-        case "before":
-        case "after":
-        case "on":
-        case "relative": {
-            const numeric = strings
-                .map((entry) => Number(entry))
-                .filter((entry) => Number.isFinite(entry));
-            if (numeric.length > 0) {
-                return evaluateNumericCondition(numeric, condition);
-            }
-            const dateValues = [];
-            for (const ref of refs) {
-                const ts = resolveDateReference(db, ref, dateCache);
-                if (ts != null)
-                    dateValues.push(ts);
-            }
-            if (dateValues.length > 0) {
-                return evaluateDateCondition(dateValues, condition);
-            }
-            return false;
-        }
-        case "empty":
-            return isEmpty;
-        case "notEmpty":
-            return !isEmpty;
-        default:
-            return false;
-    }
-}
-function evaluateNumericCondition(numericValues, condition) {
-    const target = condition.value != null && typeof condition.value !== "boolean"
-        ? Number(condition.value)
-        : undefined;
-    const range = condition.range;
-    switch (condition.operator) {
-        case "greaterThan":
-            if (target == null)
-                return false;
-            return numericValues.some((value) => value > target);
-        case "greaterThanOrEquals":
-            if (target == null)
-                return false;
-            return numericValues.some((value) => value >= target);
-        case "lessThan":
-            if (target == null)
-                return false;
-            return numericValues.some((value) => value < target);
-        case "lessThanOrEquals":
-            if (target == null)
-                return false;
-            return numericValues.some((value) => value <= target);
-        case "between":
-            if (!range)
-                return false;
-            const start = range.start != null ? Number(range.start) : -Infinity;
-            const end = range.end != null ? Number(range.end) : Infinity;
-            return numericValues.some((value) => value >= start && value <= end);
-        case "after":
-            if (target == null)
-                return false;
-            return numericValues.some((value) => value > target);
-        case "before":
-            if (target == null)
-                return false;
-            return numericValues.some((value) => value < target);
-        case "on":
-            if (target == null)
-                return false;
-            return numericValues.some((value) => value === target);
-        case "relative":
-            if (condition.relativeAmount == null)
-                return false;
-            const base = Date.now();
-            const unit = condition.unit ?? "day";
-            const delta = computeRelativeOffsetMs(condition.relativeAmount, unit);
-            const boundary = base + delta;
-            if (condition.relativeAmount >= 0) {
-                return numericValues.some((value) => value <= boundary);
-            }
-            return numericValues.some((value) => value >= boundary);
-        default:
-            return false;
-    }
-}
-function evaluateDateCondition(dateValues, condition) {
-    const target = condition.value != null &&
-        (typeof condition.value === "string" || typeof condition.value === "number")
-        ? normalizeDateInput(condition.value)
-        : undefined;
-    const range = condition.range;
-    const now = Date.now();
-    switch (condition.operator) {
-        case "before":
-            if (target == null)
-                return false;
-            return dateValues.some((value) => value < target);
-        case "after":
-            if (target == null)
-                return false;
-            return dateValues.some((value) => value > target);
-        case "on":
-            if (target == null)
-                return false;
-            return dateValues.some((value) => isSameDay(value, target));
-        case "between":
-            if (!range)
-                return false;
-            const start = range.start != null ? normalizeDateInput(range.start) ?? -Infinity : -Infinity;
-            const end = range.end != null ? normalizeDateInput(range.end) ?? Infinity : Infinity;
-            return dateValues.some((value) => value >= start && value <= end);
-        case "relative":
-            if (condition.relativeAmount == null)
-                return false;
-            const unit = condition.unit ?? "day";
-            const delta = computeRelativeOffsetMs(condition.relativeAmount, unit);
-            const boundary = now + delta;
-            if (condition.relativeAmount >= 0) {
-                return dateValues.some((value) => value <= boundary);
-            }
-            return dateValues.some((value) => value >= boundary);
-        default:
-            // 其他比较交给数值逻辑
-            return evaluateNumericCondition(dateValues, condition);
-    }
-}
-function computeRelativeOffsetMs(amount, unit) {
-    switch (unit) {
-        case "minute":
-        case "minutes":
-        case "m":
-            return amount * 60 * 1000;
-        case "hour":
-        case "hours":
-        case "h":
-            return amount * 60 * 60 * 1000;
-        case "day":
-        case "days":
-        case "d":
-            return amount * 24 * 60 * 60 * 1000;
-        case "week":
-        case "weeks":
-        case "w":
-            return amount * 7 * 24 * 60 * 60 * 1000;
-        case "month":
-        case "months":
-        case "M":
-            return amount * 30 * 24 * 60 * 60 * 1000;
-        case "year":
-        case "years":
-        case "y":
-            return amount * 365 * 24 * 60 * 60 * 1000;
-        default:
-            return amount * 24 * 60 * 60 * 1000;
-    }
-}
-function normalizeDateInput(value) {
-    if (typeof value === "number") {
-        return value > 10_000 ? value : value * 1000;
-    }
-    const trimmed = value.trim();
-    if (/^\d{10}$/.test(trimmed)) {
-        return Number(trimmed) * 1000;
-    }
-    if (/^\d{13}$/.test(trimmed)) {
-        return Number(trimmed);
-    }
-    const parsed = Date.parse(trimmed);
-    return Number.isFinite(parsed) ? parsed : null;
-}
-function resolveDateReference(db, remId, cache) {
-    if (cache.has(remId)) {
-        return cache.get(remId) ?? null;
-    }
-    const row = db
-        .prepare("SELECT doc FROM quanta WHERE _id = ?")
-        .get(remId);
-    if (!row?.doc) {
-        cache.set(remId, null);
-        return null;
-    }
-    const data = safeJsonParse(row.doc);
-    let result = null;
-    const crt = data?.crt;
-    const d = crt?.d;
-    const seconds = (() => {
-        const s = d?.s?.v;
-        if (Array.isArray(s)) {
-            const candidate = s[0];
-            if (typeof candidate === "string" && candidate.trim()) {
-                const num = Number(candidate);
-                if (Number.isFinite(num))
-                    return num;
-            }
-            if (typeof candidate === "number" && Number.isFinite(candidate)) {
-                return candidate;
-            }
-        }
-        return undefined;
-    })();
-    if (seconds && Number.isFinite(seconds)) {
-        result = seconds * 1000;
-    }
-    if (!result) {
-        const dArray = d?.d?.v;
-        if (Array.isArray(dArray) && dArray[0] != null) {
-            const iso = String(dArray[0]);
-            const parsed = Date.parse(iso);
-            if (Number.isFinite(parsed)) {
-                result = parsed;
-            }
-        }
-    }
-    if (!result && Array.isArray(data?.key)) {
-        const keyCandidate = data.key[0];
-        if (typeof keyCandidate === "string") {
-            const fromKey = Date.parse(keyCandidate);
-            if (Number.isFinite(fromKey)) {
-                result = fromKey;
-            }
-        }
-    }
-    cache.set(remId, result);
-    return result;
-}
-function isSameDay(a, b) {
-    const dayA = new Date(a);
-    const dayB = new Date(b);
-    return (dayA.getFullYear() === dayB.getFullYear() &&
-        dayA.getMonth() === dayB.getMonth() &&
-        dayA.getDate() === dayB.getDate());
-}
-function fetchMetadata(db, ids, snippetLength) {
-    if (ids.length === 0)
-        return new Map();
-    const placeholders = ids.map(() => "?").join(",");
-    const stmt = db.prepare(`SELECT aliasId, id, doc, ancestor_not_ref_text AS ancestorNotRefText, ancestor_ids AS ancestorIds,
-            freqCounter, freqTime
-     FROM remsSearchInfos
-     WHERE id IN (${placeholders})`);
-    const rows = stmt.all(...ids);
-    const quantaStmt = db.prepare(`SELECT _id, doc
-     FROM quanta
-     WHERE _id IN (${placeholders})`);
-    const quantaRows = quantaStmt.all(...ids);
-    const quantaMap = new Map();
-    for (const row of quantaRows) {
-        const doc = safeJsonParse(row.doc);
-        if (doc)
-            quantaMap.set(row._id, doc);
-    }
-    const result = new Map();
-    for (const row of rows) {
-        const doc = safeJsonParse(row.doc) ?? {};
-        const text = coalesceText(doc.kt, doc.ke);
-        const ancestor = stringifyAncestor(row.ancestorNotRefText, row.ancestorIds);
-        const remDoc = quantaMap.get(row.id);
-        const updatedAt = typeof remDoc?.u === "number" ? remDoc.u : null;
-        const createdAt = typeof remDoc?.createdAt === "number" ? remDoc.createdAt : null;
-        const parentId = typeof remDoc?.parent === "string" ? remDoc.parent : null;
-        result.set(row.id, {
-            id: row.id,
-            aliasId: row.aliasId,
-            text,
-            ancestorText: ancestor.text || null,
-            ancestorIds: ancestor.ids,
-            parentId,
-            rank: typeof doc.x === "number" ? doc.x : 0,
-            freqCounter: row.freqCounter,
-            freqTime: row.freqTime,
-            updatedAt,
-            createdAt,
-            sortValue: undefined,
-        });
-    }
-    return result;
-}
-function sortResults(ids, sortMode, metadata, scoreMap) {
-    const candidates = ids.map((id) => ({ id, meta: metadata.get(id) }));
-    switch (sortMode.mode) {
-        case "updatedAt":
-            return candidates
-                .sort((a, b) => {
-                const av = a.meta?.updatedAt ?? 0;
-                const bv = b.meta?.updatedAt ?? 0;
-                const dir = sortMode.direction === "asc" ? 1 : -1;
-                if (av !== bv)
-                    return dir * (av - bv);
-                const ascore = scoreMap.get(a.id) ?? 0;
-                const bscore = scoreMap.get(b.id) ?? 0;
-                return bscore - ascore;
-            })
-                .map((entry) => entry.id);
-        case "createdAt":
-            return candidates
-                .sort((a, b) => {
-                const av = a.meta?.createdAt ?? 0;
-                const bv = b.meta?.createdAt ?? 0;
-                const dir = sortMode.direction === "asc" ? 1 : -1;
-                if (av !== bv)
-                    return dir * (av - bv);
-                const ascore = scoreMap.get(a.id) ?? 0;
-                const bscore = scoreMap.get(b.id) ?? 0;
-                return bscore - ascore;
-            })
-                .map((entry) => entry.id);
-        case "attribute":
-            return candidates
-                .sort((a, b) => {
-                const av = a.meta?.sortValue;
-                const bv = b.meta?.sortValue;
-                const dir = sortMode.direction === "asc" ? 1 : -1;
-                if (typeof av === "number" && typeof bv === "number") {
-                    if (av !== bv)
-                        return dir * (av - bv);
-                }
-                else if (typeof av === "string" && typeof bv === "string") {
-                    const cmp = av.localeCompare(bv);
-                    if (cmp !== 0)
-                        return dir * cmp;
-                }
-                else if (av != null && bv == null) {
-                    return -1;
-                }
-                else if (av == null && bv != null) {
-                    return 1;
-                }
-                const ascore = scoreMap.get(a.id) ?? 0;
-                const bscore = scoreMap.get(b.id) ?? 0;
-                return bscore - ascore;
-            })
-                .map((entry) => entry.id);
-        case "rank":
-        default:
-            return candidates
-                .sort((a, b) => {
-                const ascore = scoreMap.get(a.id) ?? 0;
-                const bscore = scoreMap.get(b.id) ?? 0;
-                if (ascore !== bscore)
-                    return bscore - ascore;
-                const au = a.meta?.updatedAt ?? 0;
-                const bu = b.meta?.updatedAt ?? 0;
-                return bu - au;
-            })
-                .map((entry) => entry.id);
-    }
-}
-function formatResultItem(params) {
-    const { title, snippet, truncated } = createPreview(params.text, params.snippetLength);
-    return {
-        id: params.id,
-        aliasId: params.aliasId,
-        title,
-        snippet,
-        truncated,
-        ancestor: params.ancestorText,
-        ancestorIds: params.ancestorIds,
-        parentId: params.parentId,
-        rank: params.rank,
-        freqCounter: params.freqCounter,
-        freqTime: params.freqTime,
-        updatedAt: params.updatedAt,
-        createdAt: params.createdAt,
-        score: Number(params.score.toFixed(2)),
-    };
-}
-function fetchAttributeSortValues(db, ids, attributeId) {
-    if (ids.length === 0)
-        return new Map();
-    const placeholders = ids.map(() => "?").join(",");
-    const stmt = db.prepare(`SELECT json_extract(doc, '$.parent') AS parentId, doc
-     FROM quanta
-     WHERE json_extract(doc, '$.key[0]._id') = ?
-       AND json_extract(doc, '$.parent') IN (${placeholders})`);
-    const rows = stmt.all(attributeId, ...ids);
-    const cache = new Map();
-    const result = new Map();
-    for (const row of rows) {
-        if (!row.parentId)
-            continue;
-        const parsed = safeJsonParse(row.doc);
-        if (!parsed)
-            continue;
-        const value = extractSortValue(parsed, db, cache);
-        if (value != null) {
-            result.set(row.parentId, value);
-        }
-    }
-    return result;
-}
-function extractSortValue(doc, db, cache) {
-    const rawValue = doc.value;
-    const tokens = Array.isArray(rawValue) ? rawValue : rawValue != null ? [rawValue] : [];
-    const numbers = [];
-    const refs = [];
-    const strings = [];
-    for (const token of tokens) {
-        if (typeof token === "string") {
-            strings.push(token);
-            const num = Number(token);
-            if (Number.isFinite(num))
-                numbers.push(num);
-            continue;
-        }
-        if (token && typeof token === "object") {
-            const obj = token;
-            if (obj.i === "q" && typeof obj._id === "string") {
-                refs.push(obj._id);
-                continue;
-            }
-            if (typeof obj.text === "string") {
-                strings.push(obj.text);
-                const num = Number(obj.text);
-                if (Number.isFinite(num))
-                    numbers.push(num);
-                continue;
-            }
-        }
-    }
-    if (numbers.length > 0) {
-        return numbers[0];
-    }
-    for (const ref of refs) {
-        const ts = resolveDateReference(db, ref, cache);
-        if (ts != null) {
-            return ts;
-        }
-    }
-    if (strings.length > 0) {
-        return strings[0].toLowerCase();
-    }
-    return null;
-}
-function normalizeConditionValue(value) {
-    if (typeof value === "boolean") {
-        return value ? "Yes" : "No";
-    }
-    return String(value);
-}