openclaw-server 0.1.0 → 0.2.0

package/src/bookmark-search/service.ts

@@ -0,0 +1,660 @@
+import { extractBookmarkSearchQuery, inspectBookmarkSearchQuery } from "./parser.js";
+import type {
+  BookmarkArticlePage,
+  BookmarkCategory,
+  BookmarkSearchChatResult,
+  BookmarkSearchConversationState,
+  BookmarkSearchItem,
+  BookmarkSearchMessageInspection,
+  BookmarkSearchProvider,
+  BookmarkLink,
+} from "./types.js";
+
+type RankedSearchItem = BookmarkSearchItem & {
+  matchedTerms: Set<string>;
+  firstRank: number;
+};
+
+const ITEM_DESC_LIMIT = 40;
+const MARKDOWN_HARD_BREAK = "  \n";
+
+function normalizeSearchTerm(value: string): string {
+  return value.normalize("NFKC").trim().toLowerCase();
+}
+
+function normalizeCategoryKey(value: string): string {
+  return normalizeSearchTerm(value).replace(/\s+/g, "");
+}
+
+function escapeMarkdownLinkLabel(text: string): string {
+  return text.replace(/\\/g, "\\\\").replace(/\[/g, "\\[").replace(/\]/g, "\\]");
+}
+
+function isArticleItem(item: BookmarkSearchItem): boolean {
+  return item.type.includes("文章");
+}
+
+function typePriority(type: string): number {
+  if (type.includes("文章")) {
+    return 3;
+  }
+  if (type.includes("二级分类")) {
+    return 2;
+  }
+  if (type.includes("一级分类")) {
+    return 1;
+  }
+  return 0;
+}
+
+function summarizeItemDesc(item: BookmarkSearchItem): string | undefined {
+  const normalizedDesc = item.desc?.replace(/\s+/g, " ").trim();
+  if (!normalizedDesc) {
+    return undefined;
+  }
+
+  if (normalizeSearchTerm(normalizedDesc) === normalizeSearchTerm(item.title)) {
+    return undefined;
+  }
+
+  return normalizedDesc.length > ITEM_DESC_LIMIT
+    ? `${normalizedDesc.slice(0, ITEM_DESC_LIMIT).trimEnd()}...`
+    : normalizedDesc;
+}
+
+function summarizeItemMeta(item: BookmarkSearchItem): string | undefined {
+  const parts: string[] = [];
+  if (item.firstCategory && item.secondCategory) {
+    parts.push(`${item.firstCategory} > ${item.secondCategory}`);
+  } else if (item.firstCategory) {
+    parts.push(item.firstCategory);
+  } else if (item.secondCategory) {
+    parts.push(item.secondCategory);
+  }
+
+  if (item.updatedAt) {
+    parts.push(`更新：${item.updatedAt}`);
+  }
+
+  return parts.length > 0 ? parts.join(" · ") : undefined;
+}
+
+function renderClarifyReply(): string {
+  return "书签篮是一个把常用网站和资料按分类整理起来的书签导航，也支持搜索、导入导出和去重。你可以直接输入关键词，比如“百度”“python 教程”或“Notion AI”，我会帮你从书签篮里找相关结果。";
+}
+
+function renderNotFoundReply(query: string): string {
+  return `书签篮里还没找到和“${query}”相关的书签。你可以换更短的关键词再试，比如“python”“cesium”或“教程”。`;
+}
+
+function renderCategoryNotFoundReply(category: string): string {
+  return `书签篮里暂时没找到“${category}”这个分类。你可以先让我列出分类列表，再继续看某个分类的文章或常用链接。`;
+}
+
+function renderActionErrorReply(subject: string): string {
+  return `书签篮暂时不可用，刚刚没能完成“${subject}”的查询。请稍后重试。`;
+}
+
+function formatIndexedLine(index: number, content: string, numbered: boolean): string {
+  return numbered ? `${index + 1}、${content}` : content;
+}
+
+function renderArticleBlocks(params: {
+  items: BookmarkSearchItem[];
+  limit: number;
+  includeMeta?: boolean;
+}): string[] {
+  const visibleItems = params.items.slice(0, params.limit);
+  const numbered = visibleItems.length > 1;
+
+  return visibleItems.map((item, index) => {
+    const lines = [
+      formatIndexedLine(
+        index,
+        `[${escapeMarkdownLinkLabel(item.title)}](${item.url})`,
+        numbered,
+      ),
+    ];
+    const desc = summarizeItemDesc(item);
+    if (desc) {
+      lines.push(`简介：${desc}`);
+    }
+    if (params.includeMeta !== false) {
+      const meta = summarizeItemMeta(item);
+      if (meta) {
+        lines.push(meta);
+      }
+    }
+    return lines.join(MARKDOWN_HARD_BREAK);
+  });
+}
+
+function renderArticleListReply(params: {
+  intro: string;
+  items: BookmarkSearchItem[];
+  limit: number;
+  browseLink?: { label: string; url: string };
+  includeMeta?: boolean;
+}): string {
+  const parts = [params.intro, ...renderArticleBlocks(params)];
+  if (params.browseLink) {
+    parts.push(`[${escapeMarkdownLinkLabel(params.browseLink.label)}](${params.browseLink.url})`);
+  }
+  return parts.join("\n\n");
+}
+
+function renderSearchReply(params: {
+  query: string;
+  items: BookmarkSearchItem[];
+  limit: number;
+}): string {
+  const intro =
+    params.items.length > params.limit
+      ? `找到 ${params.items.length} 条“${params.query}”相关结果，先看前 ${params.limit} 条：`
+      : `找到 ${params.items.length} 条“${params.query}”相关结果：`;
+
+  return renderArticleListReply({
+    intro,
+    items: params.items,
+    limit: params.limit,
+  });
+}
+
+function renderLatestReply(params: {
+  page: BookmarkArticlePage;
+  limit: number;
+}): string {
+  const total = params.page.total ?? params.page.items.length;
+  const intro =
+    total > params.limit ? `最近更新，先看前 ${params.limit} 篇：` : "最近更新：";
+
+  return renderArticleListReply({
+    intro,
+    items: params.page.items,
+    limit: params.limit,
+    includeMeta: false,
+    browseLink: params.page.browseUrl
+      ? {
+          label: "查看全部文章",
+          url: params.page.browseUrl,
+        }
+      : undefined,
+  });
+}
+
+function renderCategoryArticlesReply(params: {
+  category: BookmarkCategory;
+  page: BookmarkArticlePage;
+  limit: number;
+}): string {
+  const total = params.page.total ?? params.page.items.length;
+  const intro =
+    total > params.limit
+      ? `“${params.category.name}”文章，先看前 ${params.limit} 篇：`
+      : `“${params.category.name}”文章：`;
+
+  return renderArticleListReply({
+    intro,
+    items: params.page.items,
+    limit: params.limit,
+    browseLink: {
+      label: `打开“${params.category.name}”分类页`,
+      url: params.page.browseUrl ?? params.category.url,
+    },
+  });
+}
+
+function renderCategoryListReply(params: {
+  categories: BookmarkCategory[];
+  limit: number;
+}): string {
+  const visibleCategories = params.categories.slice(0, params.limit);
+  const intro =
+    params.categories.length > params.limit
+      ? `一级分类，先看前 ${params.limit} 个：`
+      : "一级分类：";
+  const numbered = visibleCategories.length > 1;
+
+  const blocks = visibleCategories.map((category, index) => {
+    const suffix = typeof category.articleCount === "number" ? `（${category.articleCount} 篇）` : "";
+    return formatIndexedLine(
+      index,
+      `[${escapeMarkdownLinkLabel(category.name)}](${category.url})${suffix}`,
+      numbered,
+    );
+  });
+
+  return [
+    intro,
+    ...blocks,
+    "继续看某个分类，直接说“前端分类”或“前端常用链接”。",
+  ].join("\n\n");
+}
+
+function renderCategoryLinksReply(params: {
+  category: BookmarkCategory;
+  links: BookmarkLink[];
+  limit: number;
+}): string {
+  const visibleLinks = params.links.slice(0, params.limit);
+  const intro =
+    params.links.length > params.limit
+      ? `“${params.category.name}”常用链接，先看前 ${params.limit} 个：`
+      : `“${params.category.name}”常用链接：`;
+  const numbered = visibleLinks.length > 1;
+
+  const blocks = visibleLinks.map((link, index) =>
+    formatIndexedLine(index, `[${escapeMarkdownLinkLabel(link.name)}](${link.url})`, numbered)
+  );
+
+  return [
+    intro,
+    ...blocks,
+    `[${escapeMarkdownLinkLabel(`打开“${params.category.name}”分类页`)}](${params.category.url})`,
+  ].join("\n\n");
+}
+
+function renderEmptyLatestReply(): string {
+  return "书签篮暂时还没有可展示的最新文章。";
+}
+
+function renderEmptyCategoryListReply(): string {
+  return "书签篮暂时还没有可展示的分类。";
+}
+
+function renderEmptyCategoryLinksReply(category: string): string {
+  return `“${category}”分类暂时没有配置常用链接。`;
+}
+
+function tokenizeSearchQuery(query: string): string[] {
+  const normalized = normalizeSearchTerm(query);
+  if (!normalized) {
+    return [];
+  }
+
+  const tokens = normalized.match(/[a-z0-9]+|[\u3400-\u9fff]+/giu) ?? [];
+  const result: string[] = [];
+  const seen = new Set<string>();
+
+  for (const token of tokens) {
+    const normalizedToken = normalizeSearchTerm(token);
+    if (!normalizedToken) {
+      continue;
+    }
+    if (seen.has(normalizedToken)) {
+      continue;
+    }
+    seen.add(normalizedToken);
+    result.push(normalizedToken);
+  }
+
+  return result;
+}
+
+function mergeTokenSearchResults(
+  termResults: Array<{ term: string; items: BookmarkSearchItem[] }>,
+): BookmarkSearchItem[] {
+  const merged = new Map<string, RankedSearchItem>();
+  let rank = 0;
+
+  for (const termResult of termResults) {
+    for (const item of termResult.items) {
+      const existing = merged.get(item.url);
+      if (existing) {
+        existing.matchedTerms.add(termResult.term);
+        continue;
+      }
+
+      merged.set(item.url, {
+        ...item,
+        matchedTerms: new Set([termResult.term]),
+        firstRank: rank,
+      });
+      rank += 1;
+    }
+  }
+
+  const rankedItems = Array.from(merged.values()).sort((left, right) => {
+    const matchedDelta = right.matchedTerms.size - left.matchedTerms.size;
+    if (matchedDelta !== 0) {
+      return matchedDelta;
+    }
+
+    const typeDelta = typePriority(right.type) - typePriority(left.type);
+    if (typeDelta !== 0) {
+      return typeDelta;
+    }
+
+    return left.firstRank - right.firstRank;
+  });
+
+  const maxMatches = rankedItems[0]?.matchedTerms.size ?? 0;
+  const filteredItems =
+    maxMatches > 1
+      ? rankedItems.filter((item) => item.matchedTerms.size === maxMatches)
+      : rankedItems;
+
+  return filteredItems.map(({ matchedTerms: _matchedTerms, firstRank: _firstRank, ...item }) => item);
+}
+
+export class BookmarkSearchService {
+  private readonly pending = new Map<string, BookmarkSearchConversationState>();
+
+  constructor(
+    private readonly provider: BookmarkSearchProvider,
+    private readonly options: { pendingTtlMs?: number; resultLimit?: number } = {},
+  ) {}
+
+  inspectMessage(params: { userId: string; text: string }): BookmarkSearchMessageInspection {
+    const directInspection = inspectBookmarkSearchQuery(params.text);
+    const pending = this.getPending(params.userId);
+    if (!pending) {
+      return directInspection;
+    }
+
+    if (directInspection.shouldHandle && directInspection.action !== "search") {
+      return directInspection;
+    }
+
+    if (directInspection.shouldHandle && directInspection.query) {
+      return directInspection;
+    }
+
+    const query = this.resolveConversationQuery(params.text);
+    if (!query) {
+      return {
+        shouldHandle: true,
+        reason: "conversation",
+        action: "search",
+        missing: "query",
+      };
+    }
+
+    return {
+      shouldHandle: true,
+      reason: "conversation",
+      action: "search",
+      query,
+    };
+  }
+
+  async processMessage(params: { userId: string; text: string }): Promise<BookmarkSearchChatResult> {
+    const inspection = this.inspectMessage(params);
+    const action = inspection.action ?? "search";
+    const query = inspection.reason === "conversation"
+      ? this.resolveConversationQuery(params.text)
+      : inspection.query;
+    const categoryName = inspection.category;
+
+    if (action === "search" && !query) {
+      this.pending.set(params.userId, {
+        userId: params.userId,
+        updatedAt: Date.now(),
+      });
+      return {
+        reply: renderClarifyReply(),
+        intent: "clarify",
+      };
+    }
+
+    this.pending.delete(params.userId);
+
+    try {
+      switch (action) {
+        case "latest": {
+          const page = await this.listLatestArticles();
+          if (page.items.length === 0) {
+            return {
+              reply: renderEmptyLatestReply(),
+              intent: "not_found",
+              total: 0,
+              items: [],
+            };
+          }
+
+          return {
+            reply: renderLatestReply({
+              page,
+              limit: this.options.resultLimit ?? 6,
+            }),
+            intent: "latest_results",
+            total: page.total ?? page.items.length,
+            items: page.items,
+          };
+        }
+        case "categories": {
+          const categories = await this.listTopCategories();
+          if (categories.length === 0) {
+            return {
+              reply: renderEmptyCategoryListReply(),
+              intent: "not_found",
+              total: 0,
+            };
+          }
+
+          return {
+            reply: renderCategoryListReply({
+              categories,
+              limit: this.options.resultLimit ?? 6,
+            }),
+            intent: "category_list",
+            total: categories.length,
+          };
+        }
+        case "category_articles": {
+          const category = categoryName ? await this.findCategory(categoryName) : undefined;
+          if (!category) {
+            return {
+              reply: renderCategoryNotFoundReply(categoryName ?? ""),
+              intent: "not_found",
+              category: categoryName,
+              total: 0,
+            };
+          }
+
+          const page = await this.listCategoryArticles(category);
+          if (page.items.length === 0) {
+            return {
+              reply: renderNotFoundReply(category.name),
+              intent: "not_found",
+              category: category.name,
+              total: 0,
+              items: [],
+            };
+          }
+
+          return {
+            reply: renderCategoryArticlesReply({
+              category,
+              page,
+              limit: this.options.resultLimit ?? 6,
+            }),
+            intent: "category_results",
+            category: category.name,
+            total: page.total ?? page.items.length,
+            items: page.items,
+          };
+        }
+        case "category_links": {
+          const category = categoryName ? await this.findCategory(categoryName) : undefined;
+          if (!category) {
+            return {
+              reply: renderCategoryNotFoundReply(categoryName ?? ""),
+              intent: "not_found",
+              category: categoryName,
+              total: 0,
+            };
+          }
+
+          const links = await this.listCategoryLinks(category);
+          if (links.length === 0) {
+            return {
+              reply: renderEmptyCategoryLinksReply(category.name),
+              intent: "not_found",
+              category: category.name,
+              total: 0,
+            };
+          }
+
+          return {
+            reply: renderCategoryLinksReply({
+              category,
+              links,
+              limit: this.options.resultLimit ?? 6,
+            }),
+            intent: "category_links",
+            category: category.name,
+            total: links.length,
+          };
+        }
+        case "search":
+        default:
+          break;
+      }
+
+      const items = await this.searchQuery(query ?? "");
+      if (items.length === 0) {
+        return {
+          reply: renderNotFoundReply(query ?? ""),
+          intent: "not_found",
+          query,
+          total: 0,
+          items: [],
+        };
+      }
+
+      return {
+        reply: renderSearchReply({
+          query: query ?? "",
+          items,
+          limit: this.options.resultLimit ?? 6,
+        }),
+        intent: "search_results",
+        query,
+        total: items.length,
+        items,
+      };
+    } catch {
+      const subject = action === "search"
+        ? query ?? "搜索"
+        : action === "latest"
+          ? "最新更新"
+          : action === "categories"
+            ? "分类列表"
+            : categoryName ?? "分类";
+      return {
+        reply: renderActionErrorReply(subject),
+        intent: "error",
+        query,
+        category: categoryName,
+      };
+    }
+  }
+
+  private resolveConversationQuery(text: string): string | undefined {
+    const directQuery = extractBookmarkSearchQuery(text);
+    if (directQuery) {
+      return directQuery;
+    }
+
+    const normalized = text.normalize("NFKC").trim();
+    return normalized || undefined;
+  }
+
+  private async searchQuery(query: string): Promise<BookmarkSearchItem[]> {
+    const normalizedQuery = normalizeSearchTerm(query);
+    const exactMatches = (await this.provider.searchKeyword({ keyword: normalizedQuery }))
+      .filter(isArticleItem);
+    if (exactMatches.length > 0) {
+      return exactMatches;
+    }
+
+    const tokens = tokenizeSearchQuery(query).filter((token) => token !== normalizedQuery);
+    if (tokens.length === 0) {
+      return [];
+    }
+
+    const termResults = await Promise.all(
+      tokens.map(async (term) => ({
+        term,
+        items: (await this.provider.searchKeyword({ keyword: term })).filter(isArticleItem),
+      })),
+    );
+
+    return mergeTokenSearchResults(termResults);
+  }
+
+  private async listLatestArticles(): Promise<BookmarkArticlePage> {
+    if (!this.provider.listLatestArticles) {
+      throw new Error("latest articles are unavailable");
+    }
+
+    return this.provider.listLatestArticles({ page: 1 });
+  }
+
+  private async listTopCategories(): Promise<BookmarkCategory[]> {
+    if (!this.provider.listTopCategories) {
+      throw new Error("categories are unavailable");
+    }
+
+    return this.provider.listTopCategories();
+  }
+
+  private async listCategoryArticles(category: BookmarkCategory): Promise<BookmarkArticlePage> {
+    if (!this.provider.listCategoryArticles) {
+      throw new Error("category articles are unavailable");
+    }
+
+    return this.provider.listCategoryArticles({
+      category,
+      page: 1,
+    });
+  }
+
+  private async listCategoryLinks(category: BookmarkCategory): Promise<BookmarkLink[]> {
+    if (!this.provider.listCategoryLinks) {
+      throw new Error("category links are unavailable");
+    }
+
+    return this.provider.listCategoryLinks({ category });
+  }
+
+  private async findCategory(query: string): Promise<BookmarkCategory | undefined> {
+    const categories = await this.listTopCategories();
+    const normalizedQuery = normalizeCategoryKey(query);
+    if (!normalizedQuery) {
+      return undefined;
+    }
+
+    const exactMatch = categories.find((category) => normalizeCategoryKey(category.name) === normalizedQuery);
+    if (exactMatch) {
+      return exactMatch;
+    }
+
+    const partialMatches = categories.filter((category) => {
+      const normalizedCategory = normalizeCategoryKey(category.name);
+      return normalizedCategory.includes(normalizedQuery) || normalizedQuery.includes(normalizedCategory);
+    });
+
+    if (partialMatches.length === 0) {
+      return undefined;
+    }
+
+    return partialMatches.sort((left, right) => left.name.length - right.name.length)[0];
+  }
+
+  private getPending(userId: string): BookmarkSearchConversationState | undefined {
+    const pending = this.pending.get(userId);
+    if (!pending) {
+      return undefined;
+    }
+
+    const ttlMs = this.options.pendingTtlMs ?? 10 * 60_000;
+    if (Date.now() - pending.updatedAt <= ttlMs) {
+      return pending;
+    }
+
+    this.pending.delete(userId);
+    return undefined;
+  }
+}