agent-remnote 0.0.1 → 0.0.2

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

@@ -0,0 +1,203 @@
+import { z } from "zod";
+import { buildGuidedResponse, summarizeKey, safeJsonParse, withResolvedDatabase, parseOrThrow, SYSTEM_REM_IDS, SYSTEM_REM_KEYS, } from "./shared.js";
+const inputShape = {
+    id: z.string().min(1, "id 必填").describe("根 Rem ID"),
+    maxDepth: z
+        .number()
+        .int()
+        .min(0)
+        .max(10)
+        .optional()
+        .describe("最大展开深度（默认 5）"),
+    includeEmpty: z.boolean().optional().describe("是否包含空白节点（默认 false）"),
+    expandReferences: z.boolean().optional().describe("是否展开 [[引用]] 文本（默认 true）"),
+    maxReferenceDepth: z
+        .number()
+        .int()
+        .min(0)
+        .max(5)
+        .optional()
+        .describe("引用展开的最大深度（默认 1）"),
+    format: z
+        .enum(["json", "markdown"]).optional().describe("返回格式：json/markdown（默认 markdown）"),
+    dbPath: z.string().optional().describe("数据库文件路径（默认自动发现）"),
+    startOffset: z
+        .number()
+        .int()
+        .min(0)
+        .optional()
+        .describe("分页起始节点序号（默认 0）"),
+    maxNodes: z
+        .number()
+        .int()
+        .min(1)
+        .max(200)
+        .optional()
+        .describe("本次返回的最大节点数（默认 80）"),
+    excludeProperties: z
+        .boolean()
+        .optional()
+        .describe("是否排除表格属性/选项节点（默认 false）"),
+    detail: z
+        .boolean()
+        .optional()
+        .describe("json 格式时是否包含完整节点信息（默认 false）"),
+};
+export const outlineRemSubtreeSchema = z.object(inputShape);
+export async function executeOutlineRemSubtree(params) {
+    const parsed = parseOrThrow(outlineRemSubtreeSchema, params, { label: "outline_rem_subtree" });
+    const maxDepth = parsed.maxDepth ?? 5;
+    const includeEmpty = parsed.includeEmpty ?? false;
+    const expandReferences = parsed.expandReferences ?? true;
+    const maxReferenceDepth = parsed.maxReferenceDepth ?? 1;
+    const format = parsed.format ?? "markdown";
+    const offset = parsed.startOffset ?? 0;
+    const maxNodes = parsed.maxNodes ?? 80;
+    const excludeProperties = parsed.excludeProperties ?? false;
+    const detail = parsed.detail ?? false;
+    const { result, info } = await withResolvedDatabase(parsed.dbPath, async (db) => {
+        const nodes = fetchOutlineNodes(db, {
+            rootId: parsed.id,
+            maxDepth,
+            includeEmpty,
+            expandReferences,
+            maxReferenceDepth,
+            excludeProperties,
+        });
+        const sliced = nodes.slice(offset, offset + maxNodes);
+        const markdown = format === "markdown" ? toMarkdown(sliced) : undefined;
+        return {
+            allNodes: nodes,
+            sliced,
+            markdown,
+        };
+    });
+    const title = result.allNodes[0]?.text ?? parsed.id;
+    const nodeCount = result.sliced.length;
+    const total = result.allNodes.length;
+    const hasMore = offset + nodeCount < total;
+    const response = {
+        dbPath: info.dbPath,
+        resolution: info.source,
+        dirName: info.dirName,
+        rootId: parsed.id,
+        title,
+        maxDepth,
+        nodeCount,
+        totalNodeCount: total,
+        offset,
+        maxNodes,
+        hasMore,
+        nextOffset: hasMore ? offset + nodeCount : null,
+        excludeProperties,
+        markdown: result.markdown,
+    };
+    if (format === "json") {
+        return {
+            ...response,
+            tree: detail ? result.sliced : simplifyOutlineNodes(result.sliced),
+        };
+    }
+    if (detail) {
+        return {
+            ...response,
+            tree: result.sliced,
+        };
+    }
+    return response;
+}
+export function registerOutlineRemSubtree(server) {
+    server.tool("outline_rem_subtree", `<usecase>获取指定 Rem 的大纲视图。常用于阅读每日笔记或任意文档的结构。</usecase>
+<instructions>
+- 默认返回 Markdown，可通过 format=json 获取结构化节点。
+- startOffset/maxNodes 用于分页浏览长文档；返回值会告知是否还有剩余内容。
+- excludeProperties=true 时会跳过表格属性/选项节点，阅读文档结构更清爽。
+- 工具自动过滤每日模板节点（Date String、timestamp、Status 等）。
+- 如需进一步展开引用，请结合 resolve_rem_reference。
+- 若需完整的结构化节点信息，请设置 detail=true；默认仅输出与 UI 相近的 Markdown。
+</instructions>`, inputShape, async (input) => {
+        const parsed = parseOrThrow(outlineRemSubtreeSchema, input, { label: "outline_rem_subtree" });
+        const result = await executeOutlineRemSubtree(parsed);
+        const suggestions = [
+            "如需展开引用内容，可调用 resolve_rem_reference(ids=[...])",
+        ];
+        if (result.hasMore && result.nextOffset != null) {
+            suggestions.unshift(`继续阅读：再次调用 outline_rem_subtree 并设置 startOffset=${result.nextOffset}`);
+        }
+        const guidance = result.nodeCount > 0
+            ? `生成 "${result.title}" 的大纲，本次返回 ${result.nodeCount} 个节点（总计 ${result.totalNodeCount}，${result.hasMore ? "尚有剩余" : "全部读取"}）。`
+            : `未找到可用节点（"${result.title}" 可能为空或仅包含模板内容）。`;
+        return buildGuidedResponse({ guidance, ...result }, suggestions);
+    });
+}
+function fetchOutlineNodes(db, options) {
+    const stmt = db.prepare(`WITH RECURSIVE tree(id, depth, order_path) AS (
+      SELECT _id, 0 AS depth, COALESCE(json_extract(doc, '$.f'), '')
+      FROM quanta WHERE _id = @rootId
+      UNION ALL
+      SELECT child._id,
+             tree.depth + 1,
+             tree.order_path || char(0) || COALESCE(json_extract(child.doc, '$.f'), '')
+      FROM quanta child
+      JOIN tree ON json_extract(child.doc, '$.parent') = tree.id
+      WHERE tree.depth + 1 <= @maxDepth
+    )
+    SELECT tree.id,
+           tree.depth,
+           tree.order_path AS orderPath,
+           quanta.doc AS doc
+    FROM tree
+    JOIN quanta ON quanta._id = tree.id
+    ORDER BY tree.order_path`);
+    const rows = stmt.all({ rootId: options.rootId, maxDepth: options.maxDepth });
+    const nodes = [];
+    for (const row of rows) {
+        const doc = safeJsonParse(row.doc);
+        const rawKey = doc?.key;
+        const keySummary = summarizeKey(rawKey, db, {
+            expand: options.expandReferences,
+            maxDepth: options.maxReferenceDepth,
+        });
+        if (!options.includeEmpty && !keySummary.text && row.depth !== 0) {
+            continue;
+        }
+        const isSystemRem = SYSTEM_REM_IDS.has(row.id) || SYSTEM_REM_KEYS.has(keySummary.text);
+        if (isSystemRem) {
+            continue;
+        }
+        if (options.excludeProperties) {
+            const rcrs = typeof doc?.rcrs === "string" ? doc.rcrs : null;
+            const rcre = typeof doc?.rcre === "string" ? doc.rcre : null;
+            if ((rcrs && rcrs.startsWith("t.")) || (rcre && rcre.startsWith("t."))) {
+                continue;
+            }
+        }
+        nodes.push({
+            id: row.id,
+            depth: row.depth,
+            sortKey: typeof doc?.f === "string" ? doc.f : null,
+            parentId: typeof doc?.parent === "string" ? doc.parent : null,
+            text: keySummary.text,
+            references: keySummary.references,
+            rawKey,
+        });
+    }
+    return nodes;
+}
+function simplifyOutlineNodes(nodes) {
+    return nodes.map((node) => ({
+        id: node.id,
+        depth: node.depth,
+        text: node.text,
+        references: node.references,
+    }));
+}
+function toMarkdown(nodes) {
+    return nodes
+        .map((node) => {
+        const indent = "  ".repeat(node.depth);
+        const text = node.text || "（空）";
+        return `${indent}- ${text}`;
+    })
+        .join("\n");
+}

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

@@ -0,0 +1,252 @@
+import { z } from "zod";
+import { buildGuidedResponse, summarizeKey, safeJsonParse, withResolvedDatabase, parseOrThrow, } from "./shared.js";
+const inputShape = {
+    tagId: z
+        .string()
+        .min(1, "tagId 必填")
+        .describe("表格标签 Rem ID（表头标签）"),
+    limit: z
+        .number()
+        .int()
+        .min(1)
+        .max(200)
+        .optional()
+        .describe("每次返回的行数上限（默认 50）"),
+    offset: z
+        .number()
+        .int()
+        .min(0)
+        .optional()
+        .describe("分页偏移量（默认 0）"),
+    includeOptions: z
+        .boolean()
+        .optional()
+        .describe("是否返回每个属性的全部选项信息及计数（默认 false）"),
+    dbPath: z
+        .string()
+        .optional()
+        .describe("数据库文件路径（默认自动发现）"),
+};
+export const readRemTableSchema = z.object(inputShape);
+export async function executeReadRemTable(params) {
+    const parsed = parseOrThrow(readRemTableSchema, params, { label: "read_table_rem" });
+    const limit = parsed.limit ?? 50;
+    const offset = parsed.offset ?? 0;
+    const includeOptions = parsed.includeOptions ?? false;
+    const { result, info } = await withResolvedDatabase(parsed.dbPath, async (db) => {
+        const tagRow = db
+            .prepare("SELECT doc FROM quanta WHERE _id = ?")
+            .get(parsed.tagId);
+        if (!tagRow) {
+            throw new Error(`未找到该表格标签 Rem（tagId=${parsed.tagId}），请确认 ID 是否正确`);
+        }
+        const tagDoc = safeJsonParse(tagRow.doc);
+        const tagName = summarizeKey(tagDoc?.key, db, { expand: false, maxDepth: 0 }).text || parsed.tagId;
+        const propertyContext = loadProperties(db, parsed.tagId);
+        const rowContext = loadRows(db, parsed.tagId, { limit, offset });
+        const propertyValuesByRow = buildPropertyValueIndex(propertyContext);
+        const rows = rowContext.rows.map((row) => {
+            const rowDoc = safeJsonParse(row.doc);
+            const summary = summarizeKey(rowDoc?.key, db, { expand: false, maxDepth: 0 });
+            const values = {};
+            const propertyLookup = propertyValuesByRow.get(row.id);
+            if (propertyLookup) {
+                for (const [propertyId, optionIds] of propertyLookup.entries()) {
+                    const optionNames = optionIds
+                        .map((optionId) => propertyContext.optionNameById.get(optionId) ?? optionId)
+                        .filter(Boolean);
+                    values[propertyId] = {
+                        optionIds,
+                        optionNames,
+                    };
+                }
+            }
+            return {
+                id: row.id,
+                title: summary.text || "",
+                options: values,
+            };
+        });
+        const hasMore = offset + rows.length < rowContext.total;
+        const properties = propertyContext.properties.map((property) => ({
+            id: property.id,
+            name: property.name,
+            rawType: property.rawType,
+            kind: property.kind,
+            optionCount: property.options.length,
+            options: includeOptions
+                ? property.options.map((option) => ({
+                    id: option.id,
+                    name: option.name,
+                    rowCount: option.rowIds.size,
+                }))
+                : undefined,
+        }));
+        return {
+            tagId: parsed.tagId,
+            tagName,
+            properties,
+            propertyCount: properties.length,
+            rows,
+            rowCount: rows.length,
+            totalRows: rowContext.total,
+            offset,
+            limit,
+            hasMore,
+            nextOffset: hasMore ? offset + rows.length : null,
+        };
+    });
+    const suggestions = [];
+    suggestions.push("若需要查看行的完整大纲，可结合 outline_rem_subtree id=<rowId>");
+    if (result.hasMore && result.nextOffset != null) {
+        suggestions.unshift(`还有更多行，可再次调用 read_table_rem 并设置 offset=${result.nextOffset}`);
+    }
+    if (result.properties.length === 0) {
+        suggestions.push("未检测到表格属性，检查 tagId 是否为表格标签或是否使用 Powerup 表格");
+    }
+    const guidance = `已解析标签 "${result.tagName}" 的表格，本次返回 ${result.rowCount} 行（总计 ${result.totalRows}）。`;
+    return buildGuidedResponse({ guidance, ...result, dbPath: info.dbPath, resolution: info.source, dirName: info.dirName }, suggestions);
+}
+export function registerReadRemTable(server) {
+    server.tool("read_table_rem", `<usecase>读取基于 Tag 的表格数据，列出属性与当前页的行记录。</usecase>
+<instructions>
+- 提供表格 Tag 的 Rem ID（通常是表头标签）。
+- 默认返回前 50 行，可通过 limit/offset 分页。
+- includeOptions=true 时会输出每个属性的所有选项及引用行数。
+- 如果表格未检测到属性，请确认是否为 RemNote 表格或自定义结构。
+</instructions>`, inputShape, async (input) => {
+        const parsed = parseOrThrow(readRemTableSchema, input, { label: "read_table_rem" });
+        return executeReadRemTable(parsed);
+    });
+}
+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 summary = summarizeKey(doc?.key, db, { expand: false, maxDepth: 0 });
+        const options = [];
+        const optionRows = optionStmt.all({ parent: row.id });
+        for (const optionRow of optionRows) {
+            const optionDoc = safeJsonParse(optionRow.doc);
+            const optionSummary = summarizeKey(optionDoc?.key, db, { expand: false, maxDepth: 0 });
+            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: optionSummary.text || optionRow.id,
+                rowIds,
+            });
+            optionNameById.set(optionRow.id, optionSummary.text || optionRow.id);
+        }
+        properties.push({
+            id: row.id,
+            name: summary.text || row.id,
+            rawType,
+            kind,
+            options,
+        });
+    }
+    return {
+        properties,
+        optionNameById,
+    };
+}
+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 buildPropertyValueIndex(context) {
+    const index = new Map();
+    for (const property of context.properties) {
+        for (const option of property.options) {
+            for (const rowId of option.rowIds) {
+                if (!index.has(rowId)) {
+                    index.set(rowId, new Map());
+                }
+                const propertyMap = index.get(rowId);
+                if (!propertyMap.has(property.id)) {
+                    propertyMap.set(property.id, []);
+                }
+                propertyMap.get(property.id).push(option.id);
+            }
+        }
+    }
+    // Ensure option list ordering is stable
+    for (const propertyMap of index.values()) {
+        for (const entry of propertyMap.values()) {
+            entry.sort();
+        }
+    }
+    return index;
+}
+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})`;
+    }
+}

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

@@ -0,0 +1,174 @@
+import { z } from "zod";
+import { buildGuidedResponse, summarizeKey, safeJsonParse, withResolvedDatabase, parseOrThrow, } from "./shared.js";
+const inputShape = {
+    ids: z
+        .array(z.string().min(1))
+        .min(1, "ids 必填，至少 1 个")
+        .describe("要解析的引用 Rem ID 列表"),
+    dbPath: z
+        .string()
+        .optional()
+        .describe("数据库文件路径（默认自动发现）"),
+    expandReferences: z
+        .boolean()
+        .optional()
+        .describe("是否展开引用链文本（默认 true）"),
+    maxReferenceDepth: z
+        .number()
+        .int()
+        .min(0)
+        .max(5)
+        .optional()
+        .describe("展开引用的最大深度（默认 1）"),
+    detail: z.boolean().optional().describe("是否返回原始 key/doc 等详细信息"),
+};
+export const resolveRemReferenceSchema = z.object(inputShape);
+export async function executeResolveRemReference(params) {
+    const parsed = parseOrThrow(resolveRemReferenceSchema, params, { label: "resolve_rem_reference" });
+    const expand = parsed.expandReferences ?? true;
+    const maxDepth = parsed.maxReferenceDepth ?? 1;
+    const detail = parsed.detail ?? false;
+    const { result, info } = await withResolvedDatabase(parsed.dbPath, async (db) => {
+        const stmt = db.prepare("SELECT doc FROM quanta WHERE _id = ?");
+        const referenceTexts = new Map();
+        const referenceSources = new Map();
+        const details = parsed.ids.map((id) => {
+            const row = stmt.get(id);
+            if (!row) {
+                referenceTexts.set(id, null);
+                return {
+                    id,
+                    found: false,
+                    text: "",
+                    references: [],
+                    rawKey: undefined,
+                    rawDoc: undefined,
+                };
+            }
+            const doc = safeJsonParse(row.doc);
+            const keySummary = summarizeKey(doc?.key, db, { expand, maxDepth });
+            referenceTexts.set(id, keySummary.text ?? null);
+            for (const ref of keySummary.references) {
+                if (!referenceSources.has(ref)) {
+                    referenceSources.set(ref, new Set([id]));
+                }
+                else {
+                    referenceSources.get(ref).add(id);
+                }
+            }
+            return {
+                id,
+                found: true,
+                text: keySummary.text,
+                references: keySummary.references,
+                rawKey: doc?.key,
+                rawDoc: doc,
+            };
+        });
+        const nestedTargets = [];
+        for (const refId of referenceSources.keys()) {
+            if (!referenceTexts.has(refId)) {
+                nestedTargets.push(refId);
+            }
+        }
+        const limit = Math.min(nestedTargets.length, 200);
+        for (let index = 0; index < limit; index++) {
+            const refId = nestedTargets[index];
+            const row = stmt.get(refId);
+            if (!row) {
+                referenceTexts.set(refId, null);
+                continue;
+            }
+            const doc = safeJsonParse(row.doc);
+            const summary = summarizeKey(doc?.key, db, { expand: false, maxDepth: 0 });
+            referenceTexts.set(refId, summary.text ?? null);
+        }
+        const referenceTextRecord = {};
+        for (const [id, text] of referenceTexts.entries()) {
+            referenceTextRecord[id] = text ?? null;
+        }
+        const referenceSourceRecord = {};
+        for (const [id, sources] of referenceSources.entries()) {
+            referenceSourceRecord[id] = Array.from(sources);
+        }
+        return { details, referenceTexts: referenceTextRecord, referenceSources: referenceSourceRecord };
+    });
+    const simplified = detail
+        ? result.details
+        : result.details.map((item) => ({
+            id: item.id,
+            found: item.found,
+            text: item.text,
+            references: item.references,
+        }));
+    const markdown = buildResolvedMarkdown(result.details);
+    const referenceIndex = buildReferenceIndex(result.details, result.referenceTexts, result.referenceSources);
+    return {
+        dbPath: info.dbPath,
+        resolution: info.source,
+        dirName: info.dirName,
+        count: simplified.length,
+        results: simplified,
+        markdown,
+        referenceIndex,
+    };
+}
+function buildResolvedMarkdown(details) {
+    if (!details || details.length === 0) {
+        return "未解析到任何引用。";
+    }
+    const lines = ["# 引用解析结果"];
+    for (const item of details) {
+        const status = item.found ? "" : "（未找到）";
+        lines.push(`- **${item.id}**${status}`);
+        if (item.text) {
+            lines.push(`  - 文本：${item.text}`);
+        }
+        if (item.references.length > 0) {
+            lines.push(`  - 下游引用：${item.references.join(", ")}`);
+        }
+        if (!item.found && item.references.length === 0 && !item.text) {
+            lines.push("  - 未检索到内容");
+        }
+    }
+    return lines.join("\n");
+}
+function buildReferenceIndex(details, texts, sources) {
+    const map = {};
+    const ensureEntry = (id) => {
+        if (!map[id]) {
+            map[id] = {
+                text: texts[id] ?? null,
+                sources: Array.from(new Set(sources[id] ?? [])),
+            };
+        }
+        else {
+            map[id].text ??= texts[id] ?? null;
+            const merged = new Set([...(map[id].sources ?? []), ...(sources[id] ?? [])]);
+            map[id].sources = Array.from(merged);
+        }
+    };
+    for (const detail of details) {
+        ensureEntry(detail.id);
+        map[detail.id].text ??= detail.text ?? null;
+        for (const ref of detail.references) {
+            ensureEntry(ref);
+        }
+    }
+    return map;
+}
+export function registerResolveRemReference(server) {
+    server.tool("resolve_rem_reference", `<usecase>解析 Rem 引用，获取引用文本或继续展开下一层。</usecase>
+<instructions>
+- 传入 Rem ID 列表。默认会展开一层引用；可通过 \\"maxReferenceDepth\\" 调整。
+- 通常结合 outline_rem_subtree 的输出中的 {ref:...} 再调用本工具。
+</instructions>`, inputShape, async (input) => {
+        const parsed = parseOrThrow(resolveRemReferenceSchema, input, { label: "resolve_rem_reference" });
+        const result = await executeResolveRemReference(parsed);
+        const guidance = `已解析 ${result.results.length} 条引用。`;
+        const suggestions = [
+            "若需要查看引用上下文，可调用 outline_rem_subtree（可结合 startOffset 分页）",
+        ];
+        return buildGuidedResponse({ guidance, ...result }, suggestions);
+    });
+}