agent-remnote 0.0.1 → 0.0.2

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

@@ -0,0 +1,127 @@
+import { z } from "zod";
+export const attributeOperatorSchema = z.enum([
+    "equals",
+    "notEquals",
+    "contains",
+    "notContains",
+    "greaterThan",
+    "greaterThanOrEquals",
+    "lessThan",
+    "lessThanOrEquals",
+    "between",
+    "empty",
+    "notEmpty",
+    "before",
+    "after",
+    "on",
+    "relative",
+]);
+const numericValueSchema = z.number();
+const stringValueSchema = z.string();
+const booleanValueSchema = z.boolean();
+const dateValueSchema = z.union([z.string(), z.number()]);
+const attributeConditionSchema = z.object({
+    type: z.literal("attribute"),
+    attributeId: z.string().min(1, "attributeId is required"),
+    operator: attributeOperatorSchema,
+    value: z.union([stringValueSchema, numericValueSchema, booleanValueSchema]).optional(),
+    values: z.array(z.union([stringValueSchema, numericValueSchema])).optional(),
+    range: z
+        .object({
+        start: z.union([stringValueSchema, numericValueSchema, dateValueSchema]).optional(),
+        end: z.union([stringValueSchema, numericValueSchema, dateValueSchema]).optional(),
+    })
+        .optional(),
+    unit: z.string().optional(),
+    relativeAmount: z.number().optional(),
+    includeEmpty: z.boolean().optional(),
+});
+const textConditionSchema = z.object({
+    type: z.literal("text"),
+    value: z.string().min(1, "text value is required"),
+    mode: z.enum(["contains", "phrase", "prefix", "suffix"]).default("contains"),
+});
+const tagConditionSchema = z.object({
+    type: z.literal("tag"),
+    id: z.string().min(1, "tag id is required"),
+    includeDescendants: z.boolean().optional(),
+});
+const remConditionSchema = z.object({
+    type: z.literal("rem"),
+    id: z.string().min(1, "rem id is required"),
+});
+const pageConditionSchema = z.object({
+    type: z.literal("page"),
+});
+const queryNodeSchemaInternal = z.lazy(() => z.union([
+    attributeConditionSchema,
+    textConditionSchema,
+    tagConditionSchema,
+    remConditionSchema,
+    pageConditionSchema,
+    z.object({ type: z.literal("not"), node: queryNodeSchemaInternal }),
+    z.object({
+        type: z.union([z.literal("and"), z.literal("or")]),
+        nodes: z
+            .array(queryNodeSchemaInternal)
+            .min(1, "logical node requires at least one child"),
+    }),
+]));
+export const queryNodeSchema = queryNodeSchemaInternal;
+export const sortModeSchema = z.discriminatedUnion("mode", [
+    z.object({ mode: z.literal("rank") }),
+    z.object({ mode: z.literal("updatedAt"), direction: z.enum(["asc", "desc"]).default("desc") }),
+    z.object({ mode: z.literal("createdAt"), direction: z.enum(["asc", "desc"]).default("desc") }),
+    z.object({
+        mode: z.literal("attribute"),
+        attributeId: z.string().min(1, "attributeId is required for attribute sort"),
+        direction: z.enum(["asc", "desc"]).default("asc"),
+    }),
+]);
+export function normalizeQueryNode(node) {
+    if (node.type === "and" || node.type === "or") {
+        const normalizedChildren = node.nodes.map((child) => normalizeQueryNode(child));
+        const flatChildren = [];
+        for (const child of normalizedChildren) {
+            if (child.type === node.type) {
+                flatChildren.push(...child.nodes);
+            }
+            else if (child.type === "and" || child.type === "or") {
+                flatChildren.push(child);
+            }
+            else {
+                flatChildren.push(child);
+            }
+        }
+        if (flatChildren.length === 1) {
+            return flatChildren[0];
+        }
+        return { type: node.type, nodes: flatChildren };
+    }
+    if (node.type === "not") {
+        return { type: "not", node: normalizeQueryNode(node.node) };
+    }
+    return node;
+}
+export function describeQueryNode(node) {
+    switch (node.type) {
+        case "text":
+            return `文本包含「${node.value}」`;
+        case "tag":
+            return `包含标签 ${node.id}`;
+        case "rem":
+            return `目标 Rem 为 ${node.id}`;
+        case "page":
+            return `顶层 Page（parent=null）`;
+        case "attribute":
+            return `属性 ${node.attributeId} ${node.operator}`;
+        case "not":
+            return `非（${describeQueryNode(node.node)}）`;
+        case "and":
+            return node.nodes.map(describeQueryNode).join(" 且 ");
+        case "or":
+            return node.nodes.map(describeQueryNode).join(" 或 ");
+        default:
+            return "";
+    }
+}

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

@@ -0,0 +1,422 @@
+import { z } from "zod";
+import { buildGuidedResponse, withResolvedDatabase, getDateFormatting, formatDateWithPattern, } from "./shared.js";
+import { TIME_RANGE_PATTERN, timeValueSchema, resolveTimeFilters, } from "./timeFilters.js";
+import { createPreview, coalesceText, stringifyAncestor } from "./searchUtils.js";
+import { parseOrThrow } from "./shared.js";
+const SEARCH_MODE = z.enum(["auto", "like", "fts"]);
+const inputShape = {
+    query: z
+        .string()
+        .min(1, "query 必填")
+        .describe("关键词（1-3 个），大小写不敏感模糊匹配"),
+    limit: z
+        .number()
+        .int()
+        .min(1)
+        .max(100)
+        .optional()
+        .describe("返回条数上限（默认 10）"),
+    mode: SEARCH_MODE.optional().describe("检索模式：auto/like/fts（默认 auto）"),
+    dbPath: z.string().optional().describe("数据库文件路径（默认自动发现）"),
+    useCurrentDate: z
+        .boolean()
+        .optional()
+        .describe("将查询替换为当前日期（配合 dateOffsetDays）"),
+    dateOffsetDays: z
+        .number()
+        .int()
+        .optional()
+        .describe("相对今天的天数偏移（如 -1=昨天）"),
+    parentId: z.string().optional().describe("限定父节点或其子树范围"),
+    // Page = 顶层 Rem（parentId 为空/深度=1）
+    pagesOnly: z.boolean().optional().describe("仅返回顶层 Page"),
+    excludePages: z.boolean().optional().describe("排除顶层 Page"),
+    // 是否优先将“标题/别名精确等于查询”的结果置顶
+    preferExact: z
+        .boolean()
+        .optional()
+        .describe("标题/别名精确匹配时置顶（默认 true）"),
+    // 精确命中时仅返回 1 条；未命中则返回少量（limit 或默认 5 条）
+    exactFirstSingle: z
+        .boolean()
+        .optional()
+        .describe("精确命中仅返回 1 条，否则返回少量（默认 false）"),
+    offset: z
+        .number()
+        .int()
+        .min(0)
+        .optional()
+        .describe("分页偏移量"),
+    snippetLength: z
+        .number()
+        .int()
+        .min(30)
+        .max(400)
+        .optional()
+        .describe("结果摘要长度（字符数）"),
+    timeRange: z
+        .union([
+        z.literal("all"),
+        z.literal("*"),
+        z.string().regex(TIME_RANGE_PATTERN, "timeRange 需形如 '30d'、'2w'、'12h'"),
+    ])
+        .optional()
+        .describe("时间范围（如 30d/2w/12h 或 all/*）"),
+    createdAfter: timeValueSchema.optional().describe("创建时间下界（ISO/毫秒/秒）"),
+    createdBefore: timeValueSchema.optional().describe("创建时间上界（ISO/毫秒/秒）"),
+    updatedAfter: timeValueSchema.optional().describe("更新时间下界（ISO/毫秒/秒）"),
+    updatedBefore: timeValueSchema.optional().describe("更新时间上界（ISO/毫秒/秒）"),
+    detail: z.boolean().optional().describe("是否返回 parentId/ancestorIds/depth 等细节"),
+};
+export const searchRemOverviewSchema = z
+    .object(inputShape)
+    .superRefine((value, ctx) => {
+    if (value.pagesOnly && value.excludePages) {
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ["pagesOnly"],
+            message: "pagesOnly 与 excludePages 不能同时为 true",
+        });
+    }
+});
+export async function executeSearchRemOverview(params) {
+    const parsed = parseOrThrow(searchRemOverviewSchema, params, { label: "search_rem_overview" });
+    const limit = parsed.limit ?? 10;
+    const mode = parsed.mode ?? "auto";
+    const offset = parsed.offset ?? 0;
+    const { filters, summary } = resolveTimeFilters(parsed);
+    const detail = parsed.detail ?? false;
+    const preferExact = parsed.preferExact ?? true;
+    const exactFirstSingle = parsed.exactFirstSingle ?? false;
+    const { result, info } = await withResolvedDatabase(parsed.dbPath, async (db) => {
+        let effectiveQuery = parsed.query;
+        if (parsed.useCurrentDate) {
+            const offset = parsed.dateOffsetDays ?? 0;
+            const now = new Date();
+            const target = new Date(now.getFullYear(), now.getMonth(), now.getDate() + offset);
+            const format = (await getDateFormatting(db)) ?? "yyyy/MM/dd";
+            effectiveQuery = formatDateWithPattern(target, format);
+        }
+        const items = searchRems(db, {
+            query: effectiveQuery,
+            limit: limit + 1,
+            offset,
+            mode,
+            filters,
+            preferExact,
+            pagesOnly: parsed.pagesOnly,
+            excludePages: parsed.excludePages,
+        });
+        let filtered = items;
+        if (exactFirstSingle && preferExact) {
+            const exact = filtered.filter((it) => it.exactScore === 1);
+            if (exact.length > 0) {
+                // 仅返回第一条精确命中
+                filtered = [exact[0]];
+            }
+        }
+        if (parsed.pagesOnly) {
+            filtered = filtered.filter((item) => (item.depth ?? null) === 1 || item.parentId == null);
+        }
+        else if (parsed.excludePages) {
+            filtered = filtered.filter((item) => (item.depth ?? null) !== 1 && item.parentId != null);
+        }
+        if (parsed.parentId) {
+            filtered = filtered.filter((item) => {
+                if (item.parentId === parsed.parentId)
+                    return true;
+                return item.ancestor?.ids?.includes(parsed.parentId) ?? false;
+            });
+        }
+        return { items: filtered, query: effectiveQuery };
+    });
+    const effectiveLimit = exactFirstSingle
+        ? // 若命中精确且被裁剪为单条，则上面已经只剩一条；否则兜底使用 limit 或默认 5 条
+            (result.items.length === 1 ? 1 : parsed.limit ?? 5)
+        : limit;
+    const visible = result.items.slice(0, effectiveLimit);
+    const hasMore = result.items.length > effectiveLimit;
+    const snippetLength = parsed.snippetLength ?? 180;
+    const simplifiedMatches = visible.map((item) => simplifyMatch(item, snippetLength, detail));
+    const markdown = buildMatchesMarkdown(simplifiedMatches);
+    return {
+        dbPath: info.dbPath,
+        resolution: info.source,
+        dirName: info.dirName,
+        count: visible.length,
+        offset,
+        limit: effectiveLimit,
+        hasMore,
+        nextOffset: hasMore ? offset + effectiveLimit : null,
+        filtersApplied: summary,
+        markdown,
+        matches: simplifiedMatches,
+        queryUsed: result.query,
+        totalFetched: result.items.length,
+    };
+}
+export function registerSearchRemOverview(server) {
+    server.tool("search_rem_overview", `<usecase>定位 Rem 的通用关键词搜索工具，适合轻量、即时查找。</usecase>
+<instructions>
+- 传入 1-3 个简短关键词；若要快速定位每日笔记，可以设置 useCurrentDate/dateOffsetDays。
+- 支持时间筛选：timeRange（例如 '30d'）、createdAfter/updatedAfter（毫秒时间戳或 ISO 日期）。
+- 默认每次返回最多 10 条摘要，若还有更多结果，可使用 offset 进行分页。
+- snippetLength 控制结果摘要长度，必要时减少值以节约 Token。
+- 命中后可继续调用 outline_rem_subtree / inspect_rem_doc 查看全文；若需要组合更多条件或减少多次调用，请优先使用 build_search_query + execute_search_query。
+ - Page 支持：Page 指 parentId 为空/深度=1 的顶层 Rem。可传 pagesOnly=true 仅返回 Page，或 excludePages=true 排除 Page（两者不可同时为 true）。
+ - 精确置顶：preferExact（默认 true）。当标题/别名等于查询（忽略大小写与空格）时，将被优先置顶；设为 false 可关闭该置顶策略。
+ - 返回项包含 isPage 字段，便于快速判断是否为 Page；detail=true 时附带 parentId、ancestorIds、depth。
+</instructions>`, inputShape, async (input) => {
+        const parsed = parseOrThrow(searchRemOverviewSchema, input, { label: "search_rem_overview" });
+        const result = await executeSearchRemOverview(parsed);
+        const suggestions = [];
+        if (result.count > 0) {
+            suggestions.push("如需阅读全文，可调用 outline_rem_subtree（支持 startOffset/limit 分页）");
+            suggestions.push("如需展开引用内容，可调用 resolve_rem_reference(ids=[...])");
+            suggestions.push("若需组合更多过滤条件或减少多次调用，可改用 build_search_query → execute_search_query");
+            if (result.hasMore && result.nextOffset != null) {
+                suggestions.push(`还有更多搜索结果，可再次调用 search_rem_overview 并设置 offset=${result.nextOffset}`);
+            }
+            if (parsed.parentId) {
+                suggestions.push("已按 parentId 过滤，可调整 parentId 或移除过滤条件以放宽范围");
+            }
+        }
+        else {
+            suggestions.push("可尝试调整关键词，或使用 summarize_topic_activity keywords=[...] timeRange='30d' 获取专题摘要");
+            suggestions.push("若仍需要结构化检索，可改用 build_search_query → execute_search_query");
+        }
+        const filterDescription = describeFilterSummary(result.filtersApplied);
+        const filterSuffix = filterDescription ? `（${filterDescription}）` : "";
+        const guidance = result.count > 0
+            ? `找到 ${result.count} 条 Rem 匹配（查询 "${result.queryUsed}"，${result.hasMore ? "可继续分页" : "已到末尾"}${filterSuffix}）。`
+            : `未找到 Rem 匹配（使用查询 "${result.queryUsed}"${filterSuffix}）。`;
+        return buildGuidedResponse({ guidance, ...result }, suggestions);
+    });
+}
+function searchRems(db, options) {
+    const normalized = options.query.trim();
+    if (!normalized) {
+        return [];
+    }
+    const lowerQuery = normalized.toLowerCase();
+    const likePattern = `%${lowerQuery.replace(/\s+/g, "%")}%`;
+    const likePatternCompact = `%${lowerQuery.replace(/\s+/g, "")}%`;
+    const { clause, params: filterParams } = buildTimeFilterClause(options.filters);
+    const pageConds = [];
+    if (options.pagesOnly) {
+        pageConds.push("CAST(json_extract(doc, '$.rd') AS INTEGER) = 1");
+    }
+    else if (options.excludePages) {
+        pageConds.push("CAST(json_extract(doc, '$.rd') AS INTEGER) <> 1");
+    }
+    const extra = [clause, ...pageConds].filter(Boolean).join(" AND ");
+    const whereSuffix = extra ? ` AND ${extra}` : "";
+    const likeStmt = db.prepare(`SELECT
+      aliasId,
+      id,
+      json_extract(doc, '$.kt') AS kt,
+      json_extract(doc, '$.ke') AS ke,
+      json_extract(doc, '$.p') AS parentId,
+      json_extract(doc, '$.rd') AS depth,
+      COALESCE((SELECT rank FROM remsSearchRanks WHERE ftsRowId = remsSearchInfos.ftsRowId), 0) AS rank,
+      freqCounter,
+      freqTime,
+      ancestor_not_ref_text AS ancestorNotRefText,
+      ancestor_ids AS ancestorIds,
+      -- 精准匹配标记：标题/别名（r）等于查询（忽略大小写与空格）
+      CASE WHEN (
+        lower(json_extract(doc, '$.kt')) = @exact
+        OR REPLACE(lower(json_extract(doc, '$.kt')), ' ', '') = @exactCompact
+        OR lower(json_extract(doc, '$.ke')) = @exact
+        OR REPLACE(lower(json_extract(doc, '$.ke')), ' ', '') = @exactCompact
+        OR lower(json_extract(doc, '$.r')) = @exact
+      ) THEN 1 ELSE 0 END AS exactScore,
+      -- 根据 preferExact 动态控制置顶权重
+      CASE WHEN @preferExact != 0 THEN (
+        CASE WHEN (
+          lower(json_extract(doc, '$.kt')) = @exact
+          OR REPLACE(lower(json_extract(doc, '$.kt')), ' ', '') = @exactCompact
+          OR lower(json_extract(doc, '$.ke')) = @exact
+          OR REPLACE(lower(json_extract(doc, '$.ke')), ' ', '') = @exactCompact
+          OR lower(json_extract(doc, '$.r')) = @exact
+        ) THEN 1 ELSE 0 END
+      ) ELSE 0 END AS orderExact
+    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
+       OR lower(json_extract(doc, '$.r')) LIKE @pattern
+    )${whereSuffix}
+    ORDER BY orderExact DESC, rank DESC, freqCounter DESC
+    LIMIT @limit OFFSET @offset`);
+    const rows = likeStmt.all({
+        pattern: likePattern,
+        patternCompact: likePatternCompact,
+        limit: options.limit,
+        offset: options.offset,
+        preferExact: options.preferExact ? 1 : 0,
+        exact: lowerQuery,
+        exactCompact: lowerQuery.replace(/\s+/g, ""),
+        ...filterParams,
+    });
+    let items = rows.map(mapRowToItem);
+    if (options.mode === "fts" || (options.mode === "auto" && items.length === 0)) {
+        try {
+            const ftsStmt = db.prepare(`SELECT
+          aliasId,
+          id,
+          json_extract(doc, '$.kt') AS kt,
+          json_extract(doc, '$.ke') AS ke,
+          json_extract(doc, '$.p') AS parentId,
+          json_extract(doc, '$.rd') AS depth,
+          COALESCE((SELECT rank FROM remsSearchRanks WHERE ftsRowId = remsSearchInfos.ftsRowId), 0) AS rank,
+          freqCounter,
+          freqTime,
+          ancestor_not_ref_text AS ancestorNotRefText,
+          ancestor_ids AS ancestorIds,
+          -- 精准匹配标记
+          CASE WHEN (
+            lower(json_extract(doc, '$.kt')) = @exact
+            OR REPLACE(lower(json_extract(doc, '$.kt')), ' ', '') = @exactCompact
+            OR lower(json_extract(doc, '$.ke')) = @exact
+            OR REPLACE(lower(json_extract(doc, '$.ke')), ' ', '') = @exactCompact
+            OR lower(json_extract(doc, '$.r')) = @exact
+          ) THEN 1 ELSE 0 END AS exactScore,
+          CASE WHEN @preferExact != 0 THEN (
+            CASE WHEN (
+              lower(json_extract(doc, '$.kt')) = @exact
+              OR REPLACE(lower(json_extract(doc, '$.kt')), ' ', '') = @exactCompact
+              OR lower(json_extract(doc, '$.ke')) = @exact
+              OR REPLACE(lower(json_extract(doc, '$.ke')), ' ', '') = @exactCompact
+              OR lower(json_extract(doc, '$.r')) = @exact
+            ) THEN 1 ELSE 0 END
+          ) ELSE 0 END AS orderExact
+        FROM remsSearchInfos
+        WHERE ftsRowId IN (
+          SELECT rowid FROM remsContents WHERE remsContents MATCH @matchQuery
+        )${whereSuffix}
+        ORDER BY orderExact DESC, rank DESC, freqCounter DESC
+        LIMIT @limit OFFSET @offset`);
+            const ftsRows = ftsStmt.all({
+                matchQuery: normalized,
+                limit: options.limit,
+                offset: options.offset,
+                exact: lowerQuery,
+                exactCompact: lowerQuery.replace(/\s+/g, ""),
+                preferExact: options.preferExact ? 1 : 0,
+                ...filterParams,
+            });
+            if (ftsRows.length > 0) {
+                items = ftsRows.map(mapRowToItem);
+            }
+        }
+        catch (error) {
+            if (options.mode === "fts") {
+                throw new Error(`FTS 查询失败（可能未启用 RemNote 自定义分词器或语法不兼容）。建议改用 mode=\"like\"，或省略 mode 使用 auto。原始错误：${String(error)}`);
+            }
+            // otherwise ignore and fall back to LIKE results
+        }
+    }
+    return items;
+}
+function mapRowToItem(row) {
+    return {
+        id: row.id,
+        parentId: row.parentId,
+        text: coalesceText(row.kt, row.ke),
+        depth: row.depth,
+        exactScore: row.exactScore ?? 0,
+        ancestor: stringifyAncestor(row.ancestorNotRefText, row.ancestorIds),
+    };
+}
+function simplifyMatch(item, snippetLength, detail) {
+    const preview = createPreview(item.text, snippetLength);
+    const base = {
+        id: item.id,
+        title: preview.title,
+        snippet: preview.snippet,
+        truncated: preview.truncated,
+        ancestor: item.ancestor?.text ?? null,
+        isPage: (item.depth ?? null) === 1 || item.parentId == null,
+    };
+    if (!detail) {
+        return base;
+    }
+    return {
+        ...base,
+        parentId: item.parentId,
+        ancestorIds: item.ancestor?.ids ?? [],
+        rawText: item.text,
+        depth: item.depth ?? null,
+    };
+}
+function buildMatchesMarkdown(matches) {
+    if (!matches || matches.length === 0) {
+        return "未找到匹配 Rem。";
+    }
+    const lines = ["# 搜索结果"];
+    matches.forEach((match, index) => {
+        const title = match.title?.trim() ? match.title.trim() : "(未命名)";
+        const ancestor = match.ancestor ? `，所在：${match.ancestor}` : "";
+        const snippet = match.snippet ? `\n  - ${match.snippet}` : "";
+        lines.push(`- **${index + 1}. ${title}**（ID: ${match.id}${ancestor}）${snippet}`);
+    });
+    return lines.join("\n");
+}
+function buildTimeFilterClause(filters) {
+    const conditions = [];
+    const params = {};
+    const createdExpr = `COALESCE(
+    CAST(json_extract(doc, '$.c') AS INTEGER),
+    (SELECT CAST(json_extract(q.doc, '$.createdAt') AS INTEGER) FROM quanta q WHERE q._id = remsSearchInfos.id)
+  )`;
+    const updatedExpr = `COALESCE(
+    (SELECT CAST(json_extract(q.doc, '$.m') AS INTEGER) FROM quanta q WHERE q._id = remsSearchInfos.id),
+    CAST(json_extract(doc, '$.c') AS INTEGER)
+  )`;
+    if (filters.createdAfter !== undefined) {
+        conditions.push(`${createdExpr} >= @createdAfter`);
+        params.createdAfter = filters.createdAfter;
+    }
+    if (filters.createdBefore !== undefined) {
+        conditions.push(`${createdExpr} <= @createdBefore`);
+        params.createdBefore = filters.createdBefore;
+    }
+    if (filters.updatedAfter !== undefined) {
+        conditions.push(`${updatedExpr} >= @updatedAfter`);
+        params.updatedAfter = filters.updatedAfter;
+    }
+    if (filters.updatedBefore !== undefined) {
+        conditions.push(`${updatedExpr} <= @updatedBefore`);
+        params.updatedBefore = filters.updatedBefore;
+    }
+    return {
+        clause: conditions.join(" AND "),
+        params,
+    };
+}
+function describeFilterSummary(summary) {
+    if (!summary)
+        return null;
+    const parts = [];
+    if (summary.timeRange) {
+        parts.push(`timeRange=${summary.timeRange}`);
+    }
+    if (summary.updatedAfter) {
+        parts.push(`updated ≥ ${summary.updatedAfter.iso}`);
+    }
+    if (summary.updatedBefore) {
+        parts.push(`updated ≤ ${summary.updatedBefore.iso}`);
+    }
+    if (summary.createdAfter) {
+        parts.push(`created ≥ ${summary.createdAfter.iso}`);
+    }
+    if (summary.createdBefore) {
+        parts.push(`created ≤ ${summary.createdBefore.iso}`);
+    }
+    if (parts.length === 0)
+        return null;
+    return parts.join("，");
+}

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

@@ -0,0 +1,32 @@
+export function createPreview(text, maxLength) {
+    const normalized = text.replace(/\s+/g, " ").trim();
+    if (!normalized) {
+        return {
+            title: "(空)",
+            snippet: "",
+            truncated: false,
+        };
+    }
+    const snippet = normalized.length > maxLength ? `${normalized.slice(0, maxLength)}…` : normalized;
+    const title = normalized.split(/\n| - |——|。|！|？|\.|: /)[0]?.trim() || normalized.slice(0, 80);
+    return {
+        title: title.slice(0, 120),
+        snippet,
+        truncated: normalized.length > maxLength,
+    };
+}
+export function coalesceText(kt, ke) {
+    const combined = [kt, ke]
+        .map((value) => (typeof value === "string" ? value.trim() : ""))
+        .filter(Boolean)
+        .join(" | ");
+    return combined;
+}
+export function stringifyAncestor(text, ids) {
+    const ancestorText = typeof text === "string" ? text.trim() : "";
+    const ancestorIds = typeof ids === "string" ? ids.trim().split(/\s+/).filter(Boolean) : [];
+    return {
+        text: ancestorText,
+        ids: ancestorIds,
+    };
+}