agent-remnote 0.0.1 → 0.1.0

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

@@ -0,0 +1,815 @@
+import { z } from "zod";
+import { withResolvedDatabase, buildGuidedResponse, safeJsonParse, parseOrThrow, } from "./shared.js";
+import { coalesceText, createPreview, stringifyAncestor } from "./searchUtils.js";
+// 针对个人库的默认优化（可根据需要调整/扩展）
+const DEFAULT_KNOWN = {
+    // 常用表头 Tag（若存在则优先加入候选）
+    tagIds: [
+        "ExWWcna6cyLPRSy3W", // 待办
+        "oZbSs7aaFPNTjLPMD", // Todo
+        "J3yx9nbpeBW8S9q4v", // TODO
+    ],
+    // 针对“待办”表已知的列与选项（存在即用作补充）
+    statusForTasks: {
+        tagId: "ExWWcna6cyLPRSy3W",
+        statusAttrId: "aQb9u7XMjFL96GGYc",
+        unfinishedOptionId: "jTCTqykroBRsA2vYm",
+        finishedOptionId: "CotJ4eARGeLvtLRBa",
+    },
+};
+export const listTodosInputSchema = z.object({
+    dbPath: z.string().optional().describe("数据库文件路径（默认自动发现）"),
+    status: z
+        .enum(["unfinished", "finished", "all"]) // 轻量枚举
+        .optional()
+        .describe("任务完成状态筛选（默认 unfinished）"),
+    // 指定候选表头 Tag 的 ID（优先级高于 tagTitles）
+    tagIds: z.array(z.string()).optional().describe("优先指定表头 Tag 的 ID 列表"),
+    // 通过标题自动发现表头 Tag，默认内置常见别名
+    tagTitles: z
+        .array(z.string())
+        .optional()
+        .describe("按标题自动发现表头 Tag（默认内置常见别名）"),
+    // 优先仅使用 Todo/TODO 标签，若存在则忽略其他（用户未显式传 tagIds/tagTitles 时生效）
+    preferTodoOnly: z
+        .boolean()
+        .optional()
+        .describe("若存在 Todo/TODO 标签，则仅使用该表头（默认 false）"),
+    // 即使无状态列，也始终纳入这些“仅打标签”的任务标题（默认 Todo/TODO）
+    alwaysIncludeTagOnlyTitles: z
+        .array(z.string())
+        .optional()
+        .describe("始终纳入仅打标签的任务标题（默认 [Todo, TODO]）"),
+    // 限定祖先范围（仅返回该节点子树内的任务）
+    ancestorId: z.string().optional().describe("限定祖先范围，仅返回该子树内任务"),
+    includeDescendants: z.boolean().optional().describe("是否包含子孙（默认 true）"),
+    // 截止日、状态等列的候选名称（用于自动解析）
+    statusAttrTitles: z.array(z.string()).optional().describe("状态列的候选名称"),
+    unfinishedOptionTitles: z.array(z.string()).optional().describe("未完成选项的候选名称"),
+    finishedOptionTitles: z.array(z.string()).optional().describe("已完成选项的候选名称"),
+    dueDateAttrTitles: z.array(z.string()).optional().describe("截止日列的候选名称"),
+    // 额外筛选：截止日期上/下界（ISO 字符串或毫秒/秒时间戳）
+    dueAfter: z
+        .union([z.string(), z.number()])
+        .optional()
+        .describe("截止日下界（ISO/毫秒/秒）"),
+    dueBefore: z
+        .union([z.string(), z.number()])
+        .optional()
+        .describe("截止日上界（ISO/毫秒/秒）"),
+    // 排序：若存在截止日列，默认 dueAsc，否则 updatedAtDesc
+    sort: z
+        .enum(["dueAsc", "dueDesc", "updatedAtAsc", "updatedAtDesc"]) // 轻量枚举
+        .optional()
+        .describe("排序方式（默认：有截止日则按 dueAsc，否则 updatedAtDesc）"),
+    // 当包含 Todo/TODO 标签结果时，优先将其排在前面（默认 true）
+    preferTodoFirst: z
+        .boolean()
+        .optional()
+        .describe("当包含 Todo/TODO 时优先置顶（默认 true）"),
+    limit: z
+        .number()
+        .int()
+        .min(1)
+        .max(200)
+        .optional()
+        .describe("返回条数上限（默认 50）"),
+    offset: z
+        .number()
+        .int()
+        .min(0)
+        .optional()
+        .describe("分页偏移量（默认 0）"),
+    snippetLength: z
+        .number()
+        .int()
+        .min(40)
+        .max(300)
+        .optional()
+        .describe("结果摘要长度（默认 160）"),
+    // 当 status=all 且某 Tag 没有 Status 列时，是否包含“仅打标签的行”（无法区分完成状态）
+    includeTagOnlyWhenNoStatus: z
+        .boolean()
+        .optional()
+        .describe("status=all 且无状态列时，是否包含仅打标签的行（默认 true）"),
+});
+export const listTodosSchema = listTodosInputSchema;
+export async function executeListTodos(params) {
+    const parsed = parseOrThrow(listTodosInputSchema, params, { label: "list_todos" });
+    const status = parsed.status ?? "unfinished";
+    const limit = parsed.limit ?? 50;
+    const offset = parsed.offset ?? 0;
+    const snippetLength = parsed.snippetLength ?? 160;
+    const includeDescendants = parsed.includeDescendants ?? true;
+    const preferTodoOnly = parsed.preferTodoOnly ?? false;
+    const alwaysIncludeTagOnlyTitles = (parsed.alwaysIncludeTagOnlyTitles && parsed.alwaysIncludeTagOnlyTitles.length > 0)
+        ? parsed.alwaysIncludeTagOnlyTitles
+        : ["Todo", "TODO"];
+    const includeTagOnlyWhenNoStatus = parsed.includeTagOnlyWhenNoStatus ?? true;
+    // 默认内置常用标题/别名（按你的个人库习惯可自行拓展）
+    const tagTitles = (parsed.tagTitles && parsed.tagTitles.length > 0)
+        ? parsed.tagTitles
+        : ["待办", "Todo", "TODO", "Tasks", "Task", "Todos", "TODOs"];
+    const statusAttrTitles = (parsed.statusAttrTitles && parsed.statusAttrTitles.length > 0)
+        ? parsed.statusAttrTitles
+        : ["Status", "状态"];
+    const unfinishedOptionTitles = (parsed.unfinishedOptionTitles && parsed.unfinishedOptionTitles.length > 0)
+        ? parsed.unfinishedOptionTitles
+        : ["Unfinished", "未完成"];
+    const finishedOptionTitles = (parsed.finishedOptionTitles && parsed.finishedOptionTitles.length > 0)
+        ? parsed.finishedOptionTitles
+        : ["Finished", "已完成", "Done", "完成"];
+    const dueDateAttrTitles = (parsed.dueDateAttrTitles && parsed.dueDateAttrTitles.length > 0)
+        ? parsed.dueDateAttrTitles
+        : ["Due", "Due Date", "截止", "截止日期", "到期", "到期日"];
+    const sortPref = parsed.sort;
+    const dueAfter = parsed.dueAfter;
+    const dueBefore = parsed.dueBefore;
+    const preferTodoFirst = parsed.preferTodoFirst ?? false;
+    const { result, info } = await withResolvedDatabase(parsed.dbPath, async (db) => {
+        // 1) 收集候选 Tag
+        const tagIdSet = new Set();
+        if (Array.isArray(parsed.tagIds)) {
+            for (const id of parsed.tagIds)
+                tagIdSet.add(id);
+        }
+        // 注入已知常用 Tag（存在即加入）
+        for (const id of DEFAULT_KNOWN.tagIds) {
+            if (remExists(db, id))
+                tagIdSet.add(id);
+        }
+        const discovered = discoverTagsByTitle(db, tagTitles);
+        // 若用户未显式给 tagIds/tagTitles，且 preferTodoOnly=true，则仅保留 Todo/TODO
+        if (!parsed.tagIds && !parsed.tagTitles && preferTodoOnly) {
+            const todoOnly = discovered.filter((t) => /^(todo)$/i.test(t.name.trim()));
+            if (todoOnly.length > 0) {
+                for (const { id } of todoOnly)
+                    tagIdSet.add(id);
+            }
+            else {
+                for (const { id } of discovered)
+                    tagIdSet.add(id);
+            }
+        }
+        else {
+            for (const { id } of discovered)
+                tagIdSet.add(id);
+        }
+        const tagIds = Array.from(tagIdSet);
+        if (tagIds.length === 0) {
+            return {
+                schemas: [],
+                rows: [],
+                dueCandidate: undefined,
+                items: [],
+                totalCandidates: 0,
+                totalMatched: 0,
+                hasMore: false,
+                nextOffset: null,
+            };
+        }
+        // 2) 为每个 Tag 解析属性/选项（重复利用 readRemTable 的思路）
+        const schemas = [];
+        for (const tagId of tagIds) {
+            const tagDocRow = db.prepare("SELECT doc FROM quanta WHERE _id = ?").get(tagId);
+            if (!tagDocRow?.doc)
+                continue;
+            const tagDoc = safeJsonParse(tagDocRow.doc);
+            const tagName = summarizeTitle(tagDoc);
+            const ctx = loadProperties(db, tagId);
+            const schema = {
+                tagId,
+                tagName,
+            };
+            // 定位 Status 属性及 Unfinished/Finished 选项
+            const statusProps = ctx.properties.filter((p) => p.kind === "select" &&
+                (statusAttrTitles.includes(p.name) || p.options.some((o) => unfinishedOptionTitles.includes(o.name) || finishedOptionTitles.includes(o.name))));
+            const statusProp = statusProps[0];
+            if (statusProp) {
+                schema.statusAttrId = statusProp.id;
+                const unfinishedOpt = statusProp.options.find((o) => unfinishedOptionTitles.includes(o.name));
+                const finishedOpt = statusProp.options.find((o) => finishedOptionTitles.includes(o.name));
+                if (unfinishedOpt)
+                    schema.unfinishedOptionId = unfinishedOpt.id;
+                if (finishedOpt)
+                    schema.finishedOptionId = finishedOpt.id;
+            }
+            // 若该 Tag 是“待办”，且未解析出列或选项，使用已知默认补充
+            if (schema.tagId === DEFAULT_KNOWN.statusForTasks.tagId &&
+                (!schema.statusAttrId || !schema.unfinishedOptionId || !schema.finishedOptionId)) {
+                if (remExists(db, DEFAULT_KNOWN.statusForTasks.statusAttrId)) {
+                    schema.statusAttrId = schema.statusAttrId ?? DEFAULT_KNOWN.statusForTasks.statusAttrId;
+                }
+                if (remExists(db, DEFAULT_KNOWN.statusForTasks.unfinishedOptionId)) {
+                    schema.unfinishedOptionId =
+                        schema.unfinishedOptionId ?? DEFAULT_KNOWN.statusForTasks.unfinishedOptionId;
+                }
+                if (remExists(db, DEFAULT_KNOWN.statusForTasks.finishedOptionId)) {
+                    schema.finishedOptionId =
+                        schema.finishedOptionId ?? DEFAULT_KNOWN.statusForTasks.finishedOptionId;
+                }
+            }
+            // 定位截止日列（date 类型优先；或按标题别名匹配）
+            const dueProps = ctx.properties.filter((p) => p.kind === "date" || dueDateAttrTitles.includes(p.name));
+            const dueProp = dueProps[0];
+            if (dueProp)
+                schema.dueDateAttrId = dueProp.id;
+            schemas.push(schema);
+        }
+        // 3) 收集候选行（根据 status 选择策略）
+        const candidate = [];
+        for (const schema of schemas) {
+            const ctx = loadProperties(db, schema.tagId);
+            const statusProp = schema.statusAttrId
+                ? ctx.properties.find((p) => p.id === schema.statusAttrId)
+                : undefined;
+            if (status === "unfinished" || status === "finished") {
+                // 仅使用选项映射（pd）快速定位
+                const optionId = status === "unfinished" ? schema.unfinishedOptionId : schema.finishedOptionId;
+                if (statusProp && optionId) {
+                    const option = statusProp.options.find((o) => o.id === optionId);
+                    let pushed = 0;
+                    if (option && option.rowIds.size > 0) {
+                        for (const rowId of option.rowIds) {
+                            candidate.push({ id: rowId, tagId: schema.tagId, source: "table" });
+                            pushed++;
+                        }
+                    }
+                    if (pushed === 0) {
+                        const set = queryRowsByAttributeOption(db, schema.tagId, schema.statusAttrId, optionId);
+                        for (const rowId of set) {
+                            candidate.push({ id: rowId, tagId: schema.tagId, source: "table" });
+                        }
+                    }
+                }
+                // 若无状态属性/选项则跳过该 Tag（保持高精度）
+            }
+            else {
+                // status = all
+                // 优先尽量包含有状态列的行（所有选项的行集合）
+                let added = 0;
+                if (statusProp) {
+                    const seen = new Set();
+                    for (const opt of statusProp.options) {
+                        for (const rowId of opt.rowIds) {
+                            if (!seen.has(rowId)) {
+                                seen.add(rowId);
+                                candidate.push({ id: rowId, tagId: schema.tagId, source: "table" });
+                                added++;
+                            }
+                        }
+                    }
+                }
+                // 补充“仅打标签”的行（没有状态列），可选开启
+                if (!statusProp && includeTagOnlyWhenNoStatus) {
+                    const rows = loadRows(db, schema.tagId, { limit: Math.min(limit * 4, 2000), offset: 0 });
+                    for (const row of rows.rows) {
+                        candidate.push({ id: row.id, tagId: schema.tagId, source: "tag-only" });
+                        added++;
+                    }
+                }
+            }
+            // 无论 status 如何，若该标签属于“仅打标签也纳入”的标题列表，则补充其行（tag-only）
+            if (alwaysIncludeTagOnlyTitles.some((t) => t.trim().toLowerCase() === schema.tagName.trim().toLowerCase())) {
+                const rows = loadRows(db, schema.tagId, { limit: Math.min(limit * 4, 2000), offset: 0 });
+                for (const row of rows.rows) {
+                    candidate.push({ id: row.id, tagId: schema.tagId, source: "tag-only" });
+                }
+            }
+        }
+        // 去重
+        const merged = new Map();
+        for (const item of candidate) {
+            const prev = merged.get(item.id);
+            if (!prev) {
+                merged.set(item.id, item);
+            }
+            else {
+                // 优先保留 table 来源
+                if (prev.source === "tag-only" && item.source === "table") {
+                    merged.set(item.id, item);
+                }
+            }
+        }
+        const allIds = Array.from(merged.keys());
+        // 4) 取元信息（文本、祖先、时间）
+        const meta = fetchMetadata(db, allIds);
+        // 祖先范围过滤
+        let filtered = allIds.filter((id) => {
+            if (!parsed.ancestorId)
+                return true;
+            const m = meta.get(id);
+            if (!m)
+                return false;
+            if (!includeDescendants)
+                return m.parentId === parsed.ancestorId;
+            return m.ancestorIds.includes(parsed.ancestorId) || m.parentId === parsed.ancestorId;
+        });
+        // 5) 截止日筛选 + 排序（截止日优先，否则更新时间）
+        // 若存在多个 Tag，优先选第一个解析到 due 的 schema
+        const dueAttrId = schemas.find((s) => s.dueDateAttrId)?.dueDateAttrId;
+        const dueValues = dueAttrId ? fetchAttributeSortValues(db, filtered, dueAttrId) : new Map();
+        if (dueAttrId && (dueAfter != null || dueBefore != null)) {
+            const lower = dueAfter != null ? normalizeDateInput(dueAfter) : null;
+            const upper = dueBefore != null ? normalizeDateInput(dueBefore) : null;
+            filtered = filtered.filter((id) => {
+                const v = dueValues.get(id);
+                let ts = null;
+                if (typeof v === "number")
+                    ts = v;
+                else if (typeof v === "string") {
+                    const parsed = Date.parse(v);
+                    ts = Number.isFinite(parsed) ? parsed : null;
+                }
+                if (ts == null)
+                    return false;
+                if (lower != null && ts < lower)
+                    return false;
+                if (upper != null && ts > upper)
+                    return false;
+                return true;
+            });
+        }
+        // 默认按更新时间倒序（最新在前）。如需到期优先，显式传入 sort=dueAsc/desc
+        const sortMode = sortPref ?? "updatedAtDesc";
+        // 形成 Todo 标签集合（名称为 Todo/TODO 或已知默认 Todo/TODO）
+        const todoTagIds = new Set(schemas
+            .filter((s) => s.tagName.trim().toLowerCase() === "todo")
+            .map((s) => s.tagId));
+        // 合并默认已知 Todo/TODO ID
+        for (const id of ["oZbSs7aaFPNTjLPMD", "J3yx9nbpeBW8S9q4v"])
+            todoTagIds.add(id);
+        filtered.sort((a, b) => {
+            const ma = meta.get(a);
+            const mb = meta.get(b);
+            const av = dueValues.get(a);
+            const bv = dueValues.get(b);
+            if (preferTodoFirst) {
+                const srcA = merged.get(a);
+                const srcB = merged.get(b);
+                const pa = srcA && todoTagIds.has(srcA.tagId) ? 0 : 1;
+                const pb = srcB && todoTagIds.has(srcB.tagId) ? 0 : 1;
+                if (pa !== pb)
+                    return pa - pb;
+            }
+            switch (sortMode) {
+                case "dueAsc": {
+                    // 先有值再无值，数值升序/字符串升序
+                    const cmp = compareSortValues(av, bv);
+                    if (cmp !== 0)
+                        return cmp;
+                    return (mb?.updatedAt ?? 0) - (ma?.updatedAt ?? 0);
+                }
+                case "dueDesc": {
+                    const cmp = compareSortValues(bv, av);
+                    if (cmp !== 0)
+                        return cmp;
+                    return (mb?.updatedAt ?? 0) - (ma?.updatedAt ?? 0);
+                }
+                case "updatedAtAsc":
+                    return (ma?.updatedAt ?? 0) - (mb?.updatedAt ?? 0);
+                case "updatedAtDesc":
+                default:
+                    return (mb?.updatedAt ?? 0) - (ma?.updatedAt ?? 0);
+            }
+        });
+        const totalMatched = filtered.length;
+        const paginated = filtered.slice(offset, offset + limit);
+        const hasMore = offset + limit < filtered.length;
+        const nextOffset = hasMore ? offset + limit : null;
+        // 6) 整形返回
+        const items = paginated.map((id) => {
+            const m = meta.get(id);
+            const src = merged.get(id);
+            const text = m?.text ?? "";
+            const { title, snippet, truncated } = createPreview(text, snippetLength);
+            return {
+                id,
+                title,
+                snippet,
+                truncated,
+                ancestor: m?.ancestorText ?? null,
+                ancestorIds: m?.ancestorIds ?? [],
+                parentId: m?.parentId ?? null,
+                updatedAt: m?.updatedAt ?? null,
+                createdAt: m?.createdAt ?? null,
+                source: src?.source ?? "tag-only",
+                tagId: src?.tagId ?? "",
+            };
+        });
+        return {
+            schemas,
+            rows: items.map((x) => ({ id: x.id, tagId: x.tagId, source: x.source })),
+            dueCandidate: dueAttrId,
+            items,
+            totalCandidates: allIds.length,
+            totalMatched,
+            hasMore,
+            nextOffset,
+        };
+    });
+    const suggestions = [];
+    if (result.items && result.items.length > 0) {
+        suggestions.push("查看全文：outline_rem_subtree 或 inspect_rem_doc");
+        if (result.hasMore && result.nextOffset != null) {
+            suggestions.push(`还有更多结果，可再次调用 list_todos 并设置 offset=${result.nextOffset}`);
+        }
+    }
+    else {
+        suggestions.push("未命中，可确认表头 Tag 或调整默认别名列表 tagTitles");
+    }
+    const schemaSumm = result.schemas
+        .map((s) => `${s.tagName}(${s.tagId})`)
+        .join(", ");
+    const guidance = result.totalMatched > 0
+        ? `共识别标签：${schemaSumm}。本次命中 ${result.totalMatched} 条，返回 ${result.items.length} 条（offset=${offset}，limit=${limit}）。`
+        : tagTitles.length > 0
+            ? `未在 ${tagTitles.join("/")} 下找到匹配任务。`
+            : `未找到匹配任务。`;
+    const payload = {
+        dbPath: info.dbPath,
+        resolution: info.source,
+        dirName: info.dirName,
+        guidance,
+        status: (parsed.status ?? "unfinished"),
+        limit,
+        offset,
+        hasMore: result.hasMore,
+        nextOffset: result.nextOffset,
+        totalCandidates: result.totalCandidates ?? 0,
+        totalMatched: result.totalMatched ?? 0,
+        usedSchemas: result.schemas,
+        items: result.items ?? [],
+    };
+    return buildGuidedResponse(payload, suggestions);
+}
+export function registerListTodos(server) {
+    server.tool("list_todos", `<usecase>高频待办查询：按个人常用标签与表格属性快速列出任务（默认仅未完成）。</usecase>
+<instructions>
+- 内置解析表头 Tag（如 “待办”/“Todo”/“TODO” 等），并定位 Status/Unfinished、Due/Due Date 等列。
+- 当 status=unfinished/finished 时，直接使用选项行映射（pd）快速命中任务，避免全表扫描。
+- 支持 ancestorId 限定子树范围，支持按截止日或更新时间排序，支持分页。
+- 如需纳入仅“打标签”的任务（无状态列），可在 status=all 时设置 includeTagOnlyWhenNoStatus=true。
+</instructions>`, listTodosInputSchema.shape, async (input) => executeListTodos(input));
+}
+// -------- 实现细节 & 复用自 read_table_rem/execute_search_query 的思路 --------
+function discoverTagsByTitle(db, titles) {
+    if (!titles || titles.length === 0)
+        return [];
+    const placeholders = titles.map(() => "?").join(",");
+    const rows = db
+        .prepare(`SELECT _id AS id, doc
+         FROM quanta
+        WHERE json_extract(doc, '$.key[0]') IN (${placeholders})`)
+        .all(...titles);
+    return rows.map((r) => ({ id: r.id, name: summarizeTitle(safeJsonParse(r.doc)) }));
+}
+function remExists(db, id) {
+    try {
+        const row = db.prepare("SELECT 1 FROM quanta WHERE _id = ? LIMIT 1").get(id);
+        return !!row;
+    }
+    catch (_) {
+        return false;
+    }
+}
+function summarizeTitle(doc) {
+    const key = doc?.key;
+    if (!Array.isArray(key) || key.length === 0)
+        return "";
+    const first = key[0];
+    if (typeof first === "string")
+        return first;
+    if (first && typeof first === "object" && typeof first.text === "string") {
+        return first.text;
+    }
+    return "";
+}
+function loadProperties(db, tagId) {
+    const stmt = db.prepare(`SELECT _id AS id, doc, json_extract(doc, '$.rcrs') AS rawType
+       FROM quanta
+      WHERE json_extract(doc, '$.parent') = @tagId
+        AND json_extract(doc, '$.rcrs') IS NOT NULL
+      ORDER BY json_extract(doc, '$.f')`);
+    const optionStmt = db.prepare(`SELECT _id AS id, doc, json_extract(doc, '$.rcre') AS rawOptionType
+       FROM quanta
+      WHERE json_extract(doc, '$.parent') = @parent
+        AND json_extract(doc, '$.rcre') IS NOT NULL
+      ORDER BY json_extract(doc, '$.f')`);
+    const properties = [];
+    const optionNameById = new Map();
+    const propertyRows = stmt.all({ tagId });
+    for (const row of propertyRows) {
+        const doc = safeJsonParse(row.doc);
+        const rawType = typeof row.rawType === "string" ? row.rawType : null;
+        const typeCode = rawType ? rawType.split(".")[1] ?? null : null;
+        const kind = mapPropertyType(typeCode);
+        const name = summarizeTitle(doc);
+        const options = [];
+        const optionRows = optionStmt.all({ parent: row.id });
+        for (const optionRow of optionRows) {
+            const optionDoc = safeJsonParse(optionRow.doc);
+            const optionName = summarizeTitle(optionDoc);
+            const pdRaw = optionDoc?.pd;
+            const pdObject = typeof pdRaw === "string" ? safeJsonParse(pdRaw) : pdRaw;
+            const rowIds = new Set();
+            if (pdObject && typeof pdObject === "object") {
+                for (const key of Object.keys(pdObject)) {
+                    if (key)
+                        rowIds.add(key);
+                }
+            }
+            options.push({ id: optionRow.id, name: optionName, rowIds });
+            optionNameById.set(optionRow.id, optionName);
+        }
+        properties.push({ id: row.id, name, rawType, kind, options });
+    }
+    return { properties, optionNameById };
+}
+function mapPropertyType(code) {
+    if (!code)
+        return "unknown";
+    switch (code) {
+        case "s":
+            return "select";
+        case "m":
+            return "multi_select";
+        case "t":
+            return "text";
+        case "n":
+            return "number";
+        case "d":
+            return "date";
+        case "c":
+            return "checkbox";
+        default:
+            return `unknown(${code})`;
+    }
+}
+function loadRows(db, tagId, options) {
+    const countRow = db
+        .prepare(`SELECT COUNT(*) AS total
+         FROM (
+           SELECT q._id
+           FROM quanta q
+           JOIN json_each(q.doc, '$.tp') jt
+             ON 1 = 1
+          WHERE jt.key = @tagId
+          GROUP BY q._id
+         )`)
+        .get({ tagId });
+    const rows = db
+        .prepare(`SELECT q._id AS id, q.doc AS doc
+         FROM quanta q
+         JOIN json_each(q.doc, '$.tp') jt
+           ON 1 = 1
+        WHERE jt.key = @tagId
+        GROUP BY q._id
+        ORDER BY COALESCE(json_extract(q.doc, '$.u'), json_extract(q.doc, '$.createdAt'), 0) DESC
+        LIMIT @limit OFFSET @offset`)
+        .all({ tagId, limit: options.limit, offset: options.offset });
+    return { rows, total: countRow?.total ?? 0 };
+}
+function fetchMetadata(db, ids) {
+    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,
+            updatedAt,
+            createdAt,
+        });
+    }
+    return result;
+}
+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 result = new Map();
+    const dateCache = new Map();
+    for (const row of rows) {
+        if (!row.parentId)
+            continue;
+        const parsed = safeJsonParse(row.doc);
+        if (!parsed)
+            continue;
+        const value = extractSortValue(parsed, db, dateCache);
+        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 strings = [];
+    const refs = [];
+    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;
+            const t = obj.text;
+            if (typeof t === "string") {
+                strings.push(t);
+                const num = Number(t);
+                if (Number.isFinite(num))
+                    numbers.push(num);
+                continue;
+            }
+            if (obj.i === "q" && typeof obj._id === "string") {
+                refs.push(String(obj._id));
+                continue;
+            }
+        }
+    }
+    if (numbers.length > 0)
+        return Math.min(...numbers);
+    const dateValues = [];
+    for (const ref of refs) {
+        const ts = resolveDateReference(db, ref, cache);
+        if (ts != null)
+            dateValues.push(ts);
+    }
+    if (dateValues.length > 0)
+        return Math.min(...dateValues);
+    if (strings.length > 0)
+        return strings[0];
+    return null;
+}
+function compareSortValues(a, b) {
+    const aU = a == null;
+    const bU = b == null;
+    if (aU && bU)
+        return 0;
+    if (aU)
+        return 1; // 无值靠后
+    if (bU)
+        return -1;
+    if (typeof a === "number" && typeof b === "number")
+        return a - b;
+    if (typeof a === "string" && typeof b === "string")
+        return a.localeCompare(b);
+    // 数值优先于字符串
+    if (typeof a === "number")
+        return -1;
+    if (typeof b === "number")
+        return 1;
+    return 0;
+}
+function normalizeDateInput(value) {
+    if (typeof value === "number")
+        return value > 10_000 ? value : value * 1000;
+    const trimmed = value.trim();
+    const lower = trimmed.toLowerCase();
+    if (lower === "today") {
+        const d = new Date();
+        d.setHours(23, 59, 59, 999);
+        return d.getTime();
+    }
+    if (lower === "yesterday") {
+        const d = new Date();
+        d.setDate(d.getDate() - 1);
+        d.setHours(23, 59, 59, 999);
+        return d.getTime();
+    }
+    if (lower === "tomorrow") {
+        const d = new Date();
+        d.setDate(d.getDate() + 1);
+        d.setHours(23, 59, 59, 999);
+        return d.getTime();
+    }
+    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;
+}
+// 在缺少选项 pd 映射时，通过属性值 Rem 反查行：
+// 条件：key[0]._id = statusAttrId 且 value 数组中包含 { i:'q', _id: optionId }
+// 同时要求该行具备指定 tagId（通过行的 tp[tagId].t = 1）
+function queryRowsByAttributeOption(db, tagId, statusAttrId, optionId) {
+    try {
+        const rows = db
+            .prepare(`WITH attr AS (
+           SELECT json_extract(doc,'$.parent') AS rowId
+             FROM quanta, json_each(quanta.doc, '$.value') je
+            WHERE json_extract(quanta.doc,'$.key[0]._id') = @statusAttrId
+              AND json_type(json_extract(quanta.doc,'$.value')) = 'array'
+              AND json_extract(je.value, '$.i') = 'q'
+              AND json_extract(je.value, '$._id') = @optionId
+         )
+         SELECT q._id AS rowId
+           FROM quanta q
+           JOIN attr a ON q._id = a.rowId
+          WHERE json_extract(q.doc, '$.tp."${tagId}".t') = 1`)
+            .all({ statusAttrId, optionId });
+        return new Set(rows.map((r) => r.rowId).filter(Boolean));
+    }
+    catch (_) {
+        const rows = db
+            .prepare(`SELECT json_extract(doc,'$.parent') AS rowId
+           FROM quanta
+          WHERE json_extract(doc,'$.key[0]._id') = @statusAttrId
+            AND doc LIKE @needle`)
+            .all({ statusAttrId, needle: `%"_id":"${optionId}"%` });
+        const ids = rows.map((r) => r.rowId).filter((x) => !!x);
+        if (ids.length === 0)
+            return new Set();
+        const placeholders = ids.map(() => "?").join(",");
+        const filtered = db
+            .prepare(`SELECT _id AS rowId
+           FROM quanta
+          WHERE _id IN (${placeholders})
+            AND json_extract(doc, '$.tp."${tagId}".t') = 1`)
+            .all(...ids);
+        return new Set(filtered.map((r) => r.rowId));
+    }
+}
+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;
+        if (typeof s === "number")
+            return s;
+        if (typeof s === "string") {
+            const n = Number(s);
+            return Number.isFinite(n) ? n : undefined;
+        }
+        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;
+}