agent-remnote 0.1.0 → 0.2.0

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

@@ -1,421 +0,0 @@
-import { z } from "zod";
-import { buildGuidedResponse, safeJsonParse, summarizeKey, withResolvedDatabase, parseOrThrow, } from "./shared.js";
-import { executeFindRemsByReference } from "./findRemsByReference.js";
-const inputShape = {
-    id: z.string().min(1, "id 必填").describe("目标 Rem ID（统计该节点内的 [[引用]]）"),
-    dbPath: z.string().optional().describe("数据库文件路径（默认自动发现）"),
-    includeOccurrences: z
-        .boolean()
-        .optional()
-        .describe("是否包含逐次出现的明细（默认 false，仅返回聚合统计）"),
-    resolveText: z.boolean().optional().describe("是否解析引用目标的文本摘要（默认 true）"),
-    includeDescendants: z
-        .boolean()
-        .optional()
-        .describe("是否连同子节点一并统计（默认 false）"),
-    maxDepth: z
-        .number()
-        .int()
-        .min(0)
-        .max(10)
-        .optional()
-        .describe("当 includeDescendants=true 时的最大子树深度（默认 5）"),
-    includeInbound: z
-        .boolean()
-        .optional()
-        .describe("是否同时统计被哪些 Rem 引用（入站引用，默认 false）"),
-    inboundMaxDepth: z
-        .number()
-        .int()
-        .min(1)
-        .max(3)
-        .optional()
-        .describe("入站引用的最大深度（默认 1）"),
-    inboundMaxCandidates: z
-        .number()
-        .int()
-        .min(1)
-        .max(1000)
-        .optional()
-        .describe("入站引用候选上限（默认 200）"),
-};
-export const listRemReferencesSchema = z.object(inputShape);
-export async function executeListRemReferences(params) {
-    const parsed = parseOrThrow(listRemReferencesSchema, params, { label: "list_rem_references" });
-    const includeOccurrences = parsed.includeOccurrences ?? false;
-    const resolveText = parsed.resolveText ?? true;
-    const includeDescendants = parsed.includeDescendants ?? false;
-    const maxDepth = parsed.maxDepth ?? 5;
-    const includeInbound = parsed.includeInbound ?? false;
-    const inboundMaxDepth = parsed.inboundMaxDepth ?? 1;
-    const inboundMaxCandidates = parsed.inboundMaxCandidates ?? 200;
-    const normalizedInboundCandidates = Math.min(inboundMaxCandidates, 200);
-    const { result, info } = await withResolvedDatabase(parsed.dbPath, async (db) => {
-        const docs = fetchDocs(db, parsed.id, includeDescendants, maxDepth);
-        const occurrences = [];
-        for (const doc of docs) {
-            collectReferences(doc.key, doc.id, ["key"], occurrences);
-            if (doc.value !== undefined) {
-                collectReferences(doc.value, doc.id, ["value"], occurrences);
-            }
-        }
-        const aggregate = aggregateReferences(occurrences);
-        if (resolveText && aggregate.size > 0) {
-            enrichReferenceDetails(db, aggregate);
-        }
-        const references = Array.from(aggregate.values()).sort((a, b) => b.count - a.count);
-        let inbound = [];
-        if (includeInbound) {
-            const inboundResult = await executeFindRemsByReference({
-                targetIds: docs.map((doc) => doc.id),
-                maxDepth: inboundMaxDepth,
-                maxCandidates: normalizedInboundCandidates,
-                limit: normalizedInboundCandidates,
-                offset: 0,
-                dbPath: parsed.dbPath,
-            });
-            inbound = inboundResult.matches.map((match) => ({
-                remId: match.id,
-                title: match.title ?? null,
-                snippet: match.snippet ?? null,
-                matchedTargets: match.matchedTargets ?? [],
-                anchorIds: match.anchorIds ?? [],
-                sourceIds: match.sourceIds ?? [],
-                depth: match.depth ?? inboundMaxDepth,
-                updatedAt: match.updatedAt ?? null,
-                createdAt: match.createdAt ?? null,
-                ancestor: null,
-                ancestorIds: [],
-            }));
-            enrichInboundDetails(db, inbound);
-        }
-        return {
-            remsScanned: docs.length,
-            references,
-            totalOccurrences: occurrences.length,
-            uniqueCount: references.length,
-            includeDescendants,
-            inbound,
-            inboundCount: inbound.length,
-        };
-    });
-    const guidance = result.uniqueCount > 0
-        ? `共找到 ${result.uniqueCount} 个引用（总计 ${result.totalOccurrences} 次出现）。`
-        : `未在该 Rem 中发现引用。`;
-    const originalOutbound = result.references;
-    const markdown = buildReferencesMarkdown(params.id, guidance, originalOutbound.map((item) => simplifyReference(item)), result.inbound ?? [], includeInbound);
-    const outboundForResponse = includeOccurrences
-        ? originalOutbound
-        : originalOutbound.map((item) => simplifyReference(item));
-    const inboundForResponse = includeInbound
-        ? result.inbound?.map((item) => simplifyInbound(item)) ?? []
-        : [];
-    const payload = {
-        dbPath: info.dbPath,
-        resolution: info.source,
-        dirName: info.dirName,
-        remId: params.id,
-        guidance,
-        includeDescendants,
-        maxDepth,
-        remsScanned: result.remsScanned,
-        totalOccurrences: result.totalOccurrences,
-        uniqueCount: result.uniqueCount,
-        markdown,
-        references: outboundForResponse,
-        includeInbound,
-        inboundMaxDepth,
-        inboundMaxCandidates: normalizedInboundCandidates,
-        inboundCount: result.inboundCount ?? 0,
-        inbound: inboundForResponse,
-    };
-    const suggestions = result.uniqueCount > 0
-        ? [
-            "如需展开引用内容，可调用 outline_rem_subtree id=<refId>",
-            "若需查看引用所在上下文，可结合 outline_rem_subtree id=<remId> includeEmpty=true",
-        ]
-        : ["未包含引用，可确认是否为纯文本 Rem"];
-    if (!includeDescendants) {
-        suggestions.push("若需连同子节点的引用一并统计，可设置 includeDescendants=true");
-    }
-    if (!includeInbound) {
-        suggestions.push("若需查看被哪些 Rem 引用，可设置 includeInbound=true");
-    }
-    return { payload, suggestions };
-}
-export function registerListRemReferences(server) {
-    server.tool("list_rem_references", `<usecase>列出指定 Rem 中的所有 [[引用]]。</usecase>
-<instructions>
-- 默认去重统计并给出引用文本，必要时可设置 includeOccurrences=false 精简输出。
-- 若需要展开引用的全文，可对返回的 refId 继续调用 outline_rem_subtree 或 inspect_rem_doc。
-</instructions>`, inputShape, async (input) => {
-        const result = await executeListRemReferences(input);
-        return buildGuidedResponse(result.payload, result.suggestions);
-    });
-}
-function fetchDocs(db, rootId, includeDescendants, maxDepth) {
-    const convertRow = (id, rawDoc) => {
-        const parsed = safeJsonParse(rawDoc);
-        return {
-            id,
-            doc: parsed ?? undefined,
-            key: parsed?.key,
-            value: parsed?.value,
-        };
-    };
-    if (!includeDescendants) {
-        const row = db
-            .prepare("SELECT doc FROM quanta WHERE _id = ?")
-            .get(rootId);
-        if (!row) {
-            throw new Error(`未找到该 Rem（id=${rootId}），请确认 ID 是否存在于当前数据库`);
-        }
-        return [convertRow(rootId, row.doc)];
-    }
-    const rows = db
-        .prepare(`WITH RECURSIVE tree(id, depth) AS (
-        SELECT _id, 0 FROM quanta WHERE _id = @root
-        UNION ALL
-        SELECT child._id, tree.depth + 1
-        FROM quanta child
-        JOIN tree ON json_extract(child.doc, '$.parent') = tree.id
-        WHERE tree.depth + 1 <= @maxDepth
-      )
-      SELECT tree.id, quanta.doc
-      FROM tree
-      JOIN quanta ON quanta._id = tree.id`)
-        .all({ root: rootId, maxDepth });
-    if (rows.length === 0) {
-        throw new Error(`未找到该 Rem（id=${rootId}），请确认 ID 是否存在于当前数据库`);
-    }
-    return rows.map((row) => convertRow(row.id, row.doc));
-}
-function collectReferences(value, remId, path, into) {
-    if (Array.isArray(value)) {
-        value.forEach((item, index) => {
-            collectReferences(item, remId, [...path, index], into);
-        });
-        return;
-    }
-    if (value && typeof value === "object") {
-        const maybeRef = value;
-        if (maybeRef.i === "q" && typeof maybeRef._id === "string") {
-            into.push({
-                refId: maybeRef._id,
-                remId,
-                path: formatPath(path),
-                tokenKind: classifyToken(maybeRef),
-            });
-            return;
-        }
-        if (maybeRef.i === "p" && typeof maybeRef._id === "string") {
-            into.push({
-                refId: maybeRef._id,
-                remId,
-                path: formatPath(path),
-                tokenKind: classifyToken(maybeRef),
-            });
-            return;
-        }
-        for (const [key, child] of Object.entries(maybeRef)) {
-            collectReferences(child, remId, [...path, key], into);
-        }
-    }
-}
-function formatPath(segments) {
-    return segments
-        .map((segment, index) => {
-        if (typeof segment === "number") {
-            return `[${segment}]`;
-        }
-        return index === 0 ? segment : `.${segment}`;
-    })
-        .join("");
-}
-function aggregateReferences(occurrences) {
-    const map = new Map();
-    for (const occurrence of occurrences) {
-        const existing = map.get(occurrence.refId);
-        if (existing) {
-            existing.count += 1;
-            existing.occurrences.push({
-                remId: occurrence.remId,
-                path: occurrence.path,
-                tokenKind: occurrence.tokenKind,
-            });
-            if (!existing.remIds.includes(occurrence.remId)) {
-                existing.remIds.push(occurrence.remId);
-            }
-            if (!existing.tokenKinds.includes(occurrence.tokenKind)) {
-                existing.tokenKinds.push(occurrence.tokenKind);
-            }
-        }
-        else {
-            map.set(occurrence.refId, {
-                refId: occurrence.refId,
-                count: 1,
-                text: null,
-                ancestor: null,
-                ancestorIds: [],
-                remIds: [occurrence.remId],
-                tokenKinds: [occurrence.tokenKind],
-                occurrences: [
-                    {
-                        remId: occurrence.remId,
-                        path: occurrence.path,
-                        tokenKind: occurrence.tokenKind,
-                    },
-                ],
-            });
-        }
-    }
-    return map;
-}
-function enrichReferenceDetails(db, aggregate) {
-    if (aggregate.size === 0)
-        return;
-    const infoStmt = db.prepare(`SELECT
-      json_extract(doc, '$.kt') AS plainText,
-      ancestor_not_ref_text AS ancestorText,
-      ancestor_ids AS ancestorIds
-    FROM remsSearchInfos
-    WHERE id = ?`);
-    const fallbackStmt = db.prepare("SELECT doc FROM quanta WHERE _id = ?");
-    for (const entry of aggregate.values()) {
-        const infoRow = infoStmt.get(entry.refId);
-        if (infoRow) {
-            entry.text = normalizeSnippet(infoRow.plainText);
-            entry.ancestor = infoRow.ancestorText ? infoRow.ancestorText.trim() : null;
-            entry.ancestorIds = infoRow.ancestorIds
-                ? infoRow.ancestorIds.trim().split(/\s+/).filter(Boolean)
-                : [];
-        }
-        else {
-            const fallback = fallbackStmt.get(entry.refId);
-            if (fallback) {
-                const parsed = safeJsonParse(fallback.doc);
-                const summary = summarizeKey(parsed?.key, undefined, { expand: false, maxDepth: 0 });
-                entry.text = normalizeSnippet(summary.text);
-            }
-        }
-    }
-}
-function normalizeSnippet(text) {
-    if (!text)
-        return null;
-    const normalized = text.replace(/\s+/g, " ").trim();
-    return normalized || null;
-}
-function simplifyReference(item) {
-    return {
-        refId: item.refId,
-        text: item.text,
-        count: item.count,
-        ancestor: item.ancestor,
-        remIds: item.remIds,
-        tokenKinds: item.tokenKinds,
-        representativePath: item.occurrences[0]?.path ?? null,
-    };
-}
-function simplifyInbound(item) {
-    return {
-        remId: item.remId,
-        title: item.title,
-        snippet: item.snippet,
-        depth: item.depth,
-        ancestor: item.ancestor,
-        matchedTargetsCount: item.matchedTargets.length,
-    };
-}
-function buildReferencesMarkdown(remId, guidance, outbound, inbound, includeInbound) {
-    const lines = [];
-    lines.push(`# Rem ${remId} 引用概览`);
-    lines.push(guidance);
-    lines.push("\n## 出站引用");
-    if (outbound.length === 0) {
-        lines.push("- 无出站引用");
-    }
-    else {
-        outbound.forEach((ref) => {
-            const name = ref.text?.trim() ? ref.text.trim() : "(未命名)";
-            const tokenKind = Array.isArray(ref.tokenKinds)
-                ? `类型：${formatTokenKinds(ref.tokenKinds)}`
-                : "";
-            const ancestor = ref.ancestor ? `，祖先：${ref.ancestor}` : "";
-            const count = typeof ref.count === "number" ? `${ref.count} 次` : "";
-            const path = ref.occurrences
-                ? ref.occurrences[0]?.path ?? null
-                : ref.representativePath;
-            const samplePath = path ? `，示例位置：${path}` : "";
-            lines.push(`- **${name}**（ID: ${ref.refId}，${count}${ancestor}${samplePath}${tokenKind ? `，${tokenKind}` : ""}）`);
-        });
-    }
-    if (includeInbound) {
-        lines.push("\n## 入站引用");
-        if (inbound.length === 0) {
-            lines.push("- 无入站引用");
-        }
-        else {
-            inbound.forEach((ref) => {
-                const name = ref.title?.trim() ? ref.title.trim() : "(未命名)";
-                const count = ref.matchedTargets.length > 0 ? `${ref.matchedTargets.length} 个目标` : "";
-                const breadcrumbs = ref.ancestor ? `，所在：${ref.ancestor}` : "";
-                lines.push(`- **${name}**（ID: ${ref.remId}，${count}${breadcrumbs}）`);
-            });
-        }
-    }
-    return lines.join("\n");
-}
-function enrichInboundDetails(db, inbound) {
-    if (inbound.length === 0)
-        return;
-    const infoStmt = db.prepare(`SELECT
-      json_extract(doc, '$.kt') AS plainText,
-      ancestor_not_ref_text AS ancestorText,
-      ancestor_ids AS ancestorIds
-    FROM remsSearchInfos
-    WHERE id = ?`);
-    const fallbackStmt = db.prepare("SELECT doc FROM quanta WHERE _id = ?");
-    for (const entry of inbound) {
-        const infoRow = infoStmt.get(entry.remId);
-        if (infoRow) {
-            const snippet = normalizeSnippet(infoRow.plainText);
-            if (!entry.title || entry.title === "(空)") {
-                entry.title = snippet ?? entry.title;
-            }
-            entry.snippet = entry.snippet && entry.snippet.trim().length > 0 ? entry.snippet : snippet;
-            entry.ancestor = infoRow.ancestorText ? infoRow.ancestorText.trim() : null;
-            entry.ancestorIds = infoRow.ancestorIds
-                ? infoRow.ancestorIds.trim().split(/\s+/).filter(Boolean)
-                : [];
-        }
-        else {
-            const fallback = fallbackStmt.get(entry.remId);
-            if (fallback) {
-                const parsed = safeJsonParse(fallback.doc);
-                const summary = summarizeKey(parsed?.key, undefined, { expand: false, maxDepth: 0 });
-                const snippet = normalizeSnippet(summary.text);
-                if (!entry.title || entry.title === "(空)") {
-                    entry.title = snippet ?? entry.title;
-                }
-                entry.snippet = entry.snippet && entry.snippet.trim().length > 0 ? entry.snippet : snippet;
-            }
-        }
-    }
-}
-function classifyToken(token) {
-    const raw = typeof token.i === "string" ? token.i : "";
-    const tokenMap = {
-        q: "reference",
-        p: "portal",
-        u: "url",
-        m: "text",
-        t: "tag",
-        r: "rich_text",
-    };
-    return tokenMap[raw] ?? (raw || "unknown");
-}
-function formatTokenKinds(kinds) {
-    const unique = Array.from(new Set(kinds));
-    return unique.join("/");
-}

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

@@ -1,41 +0,0 @@
-import { z } from "zod";
-// Export a concise, LLM-friendly catalog of supported op types and camelCase payload fields
-export const TYPES = {
-    create_rem: { required: [], optional: ["parentId", "text", "tags", "isDocument", "clientTempId"], description: "创建一个 Rem，可选设置父级、文本、标签。" },
-    create_single_rem_with_markdown: { required: ["markdown"], optional: ["parentId", "clientTempId"], description: "使用 Markdown 创建单个 Rem。" },
-    create_tree_with_markdown: { required: ["markdown"], optional: ["parentId", "clientTempIds"], description: "使用 Markdown 批量创建树结构。" },
-    create_link_rem: { required: ["url"], optional: ["addTitle", "parentId", "clientTempId"], description: "创建一个链接 Rem。" },
-    create_table: { required: [], optional: ["tagId", "clientTempId"], description: "创建表（指定表头 Tag）。" },
-    add_property: { required: ["tagId"], optional: ["name", "propertyId", "type", "options"], description: "在表头下新增一个属性。" },
-    set_property_type: { required: ["propertyId", "type"], optional: [], description: "设置属性类型。" },
-    set_table_filter: { required: ["tagId"], optional: ["filter"], description: "设置表过滤条件。" },
-    add_option: { required: ["propertyId"], optional: ["optionId", "name"], description: "在属性下新增选项。" },
-    remove_option: { required: ["optionId"], optional: [], description: "移除选项。" },
-    table_add_row: { required: ["tagId"], optional: ["clientTempId", "afterRowId"], description: "在表中新增一行。" },
-    table_remove_row: { required: ["rowId"], optional: [], description: "删除一行。" },
-    set_cell_select: { required: ["rowId", "columnId", "optionId"], optional: [], description: "设置单选列的值（optionId 可为 null）。" },
-    set_cell_checkbox: { required: ["rowId", "columnId", "value"], optional: [], description: "设置复选列布尔值。" },
-    set_cell_number: { required: ["rowId", "columnId", "value"], optional: [], description: "设置数字列值（可为 null）。" },
-    set_cell_date: { required: ["rowId", "columnId", "value"], optional: [], description: "设置日期列值（时间戳或 ISO，可为 null）。" },
-    update_text: { required: ["remId", "text"], optional: [], description: "更新 Rem 文本。" },
-    move_rem: { required: ["remId", "newParentId"], optional: ["position"], description: "移动 Rem 到新父级。" },
-    add_tag: { required: ["remId", "tagId"], optional: [], description: "给 Rem 添加标签。" },
-    remove_tag: { required: ["remId", "tagId"], optional: [], description: "从 Rem 移除标签。" },
-    set_attribute: { required: ["remId", "attributeId"], optional: ["value"], description: "设置属性值（可为 null）。" },
-    table_cell_write: { required: ["rowId", "columnId", "text"], optional: [], description: "向单元格写纯文本（Markdown）。" },
-    add_source: { required: ["remId", "url"], optional: ["title"], description: "给 Rem 添加来源链接。" },
-    remove_source: { required: ["sourceId"], optional: [], description: "移除来源。" },
-    set_todo_status: { required: ["remId", "done"], optional: [], description: "设置待办完成状态。" },
-    delete_rem: { required: ["remId"], optional: [], description: "删除 Rem。" },
-};
-export function registerListSupportedOps(server) {
-    server.tool("list_supported_ops", `<usecase>列出支持的队列写入类型与参数（camelCase 形式）。</usecase>
-<instructions>
-- 返回标准类型列表；点式别名（如 rem.create）会自动映射为标准类型。
-- 字段为 camelCase；入队后将自动转换为 snake_case 并进行严格校验。
-</instructions>`, z.object({}).shape, async () => {
-        const types = Object.keys(TYPES);
-        const payloadSchemas = Object.fromEntries(Object.entries(TYPES).map(([type, spec]) => [type, spec]));
-        return { types, payloadSchemas };
-    });
-}