@templmf/temp-solf-lmf 0.0.137 → 0.0.139

package/confMCP.js

@@ -0,0 +1,551 @@
+import axios from "axios";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { z } from "zod";
+import LRUCache from "lru-cache";
+import { htmlToText } from "html-to-text";
+import BM25 from "wink-bm25-text-search";
+
+const server = new Server({
+  name: "confluence-7.4.7",
+  version: "1.0.0"
+});
+
+const baseURL = process.env.CONFLUENCE_BASE_URL;
+const authorization = process.env.CONFLUENCE_AUTHORIZATION;
+
+if (!baseURL || !authorization) {
+  throw new Error(
+    "CONFLUENCE_BASE_URL and CONFLUENCE_AUTHORIZATION are required"
+  );
+}
+
+const client = axios.create({
+  baseURL,
+  timeout: 30000,
+  headers: {
+    Authorization: authorization,
+    Accept: "application/json"
+  }
+});
+
+const pageCache = new LRUCache({
+  max: 100,
+  ttl: 1000 * 60 * 10
+});
+
+function stripHtml(html = "") {
+  return html
+    .replace(/<[^>]+>/g, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+function buildCql({
+  keywords = [],
+  spaces = [],
+  contributors = []
+}) {
+  const clauses = [];
+
+  if (spaces.length) {
+    clauses.push(
+      "(" +
+        spaces
+          .map((v) => `space="${v}"`)
+          .join(" OR ") +
+        ")"
+    );
+  }
+
+  if (contributors.length) {
+    clauses.push(
+      "(" +
+        contributors
+          .map((v) => `contributor="${v}"`)
+          .join(" OR ") +
+        ")"
+    );
+  }
+
+  if (keywords.length) {
+    clauses.push(
+      "(" +
+        keywords
+          .map((v) => `text~"${v}"`)
+          .join(" OR ") +
+        ")"
+    );
+  }
+
+  return clauses.join(" AND ");
+}
+
+async function getPageById(pageId) {
+  const cached = pageCache.get(pageId);
+
+  if (cached) {
+    return cached;
+  }
+
+  const { data } = await client.get(
+    `/rest/api/content/${pageId}`,
+    {
+      params: {
+        expand: "body.storage,version,space"
+      }
+    }
+  );
+
+  const result = {
+    id: data.id,
+    title: data.title,
+    space: data.space?.key,
+    version: data.version?.number,
+    url: `${baseURL}${data._links?.webui}`,
+    content: data.body?.storage?.value || ""
+  };
+
+  pageCache.set(pageId, result);
+
+  return result;
+}
+
+async function getPageByTitle(
+  title,
+  space
+) {
+  const params = {
+    title,
+    expand: "body.storage"
+  };
+
+  if (space) {
+    params.spaceKey = space;
+  }
+
+  const { data } = await client.get(
+    "/rest/api/content",
+    {
+      params
+    }
+  );
+
+  const page = data.results?.[0];
+
+  if (!page) {
+    return null;
+  }
+
+  return {
+    id: page.id,
+    title: page.title,
+    url: `${baseURL}${page._links?.webui}`
+  };
+}
+
+async function getSpaces() {
+  const { data } = await client.get(
+    "/rest/api/space"
+  );
+
+  return data.results.map((v) => ({
+    key: v.key,
+    name: v.name
+  }));
+}
+
+async function searchPages({
+  keywords,
+  spaces = [],
+  contributors = [],
+  limit = 10
+}) {
+  const cql = buildCql({
+    keywords,
+    spaces,
+    contributors
+  });
+
+  const { data } = await client.get(
+    "/rest/api/search",
+    {
+      params: {
+        cql,
+        limit
+      }
+    }
+  );
+
+  return data.results.map((item) => ({
+    pageId: item.content?.id,
+    title: item.title,
+    url: `${baseURL}${item.url}`
+  }));
+}
+
+server.registerTool(
+  "get_page_by_id",
+  {
+    title: "Get Page By Id",
+    description:
+      "Get Confluence page content by page id",
+    inputSchema: {
+      pageId: z.string()
+    }
+  },
+  async ({ pageId }) => {
+    return await getPageById(pageId);
+  }
+);
+
+server.registerTool(
+  "get_page_by_title",
+  {
+    title: "Get Page By Title",
+    description:
+      "Find page by title",
+    inputSchema: {
+      title: z.string(),
+      space: z.string().optional()
+    }
+  },
+  async ({ title, space }) => {
+    return await getPageByTitle(
+      title,
+      space
+    );
+  }
+);
+
+server.registerTool(
+  "get_spaces",
+  {
+    title: "Get Spaces",
+    description:
+      "List all spaces"
+  },
+  async () => {
+    return await getSpaces();
+  }
+);
+
+server.registerTool(
+  "search_pages",
+  {
+    title: "Search Pages",
+    description:
+      "Search pages by keywords, spaces and contributors",
+    inputSchema: {
+      keywords: z
+        .array(z.string())
+        .min(1),
+
+      spaces: z
+        .array(z.string())
+        .optional(),
+
+      contributors: z
+        .array(z.string())
+        .optional(),
+
+      limit: z.number().default(10)
+    }
+  },
+  async (args) => {
+    return await searchPages(args);
+  }
+);
+
+async function getChildren(pageId) {
+  const { data } = await client.get(
+    `/rest/api/content/${pageId}/child/page`
+  );
+
+  return data.results.map((v) => ({
+    id: v.id,
+    title: v.title
+  }));
+}
+
+async function buildTree(pageId, depth) {
+  const page = await getPageById(pageId);
+
+  if (depth <= 0) {
+    return {
+      id: page.id,
+      title: page.title
+    };
+  }
+
+  const children = await getChildren(pageId);
+
+  return {
+    id: page.id,
+    title: page.title,
+    children: await Promise.all(
+      children.map((v) =>
+        buildTree(v.id, depth - 1)
+      )
+    )
+  };
+}
+
+function chunkText(
+  text,
+  size = 1200,
+  overlap = 200
+) {
+  const chunks = [];
+
+  let start = 0;
+
+  while (start < text.length) {
+    chunks.push(
+      text.slice(start, start + size)
+    );
+
+    start += size - overlap;
+  }
+
+  return chunks;
+}
+
+function buildQueries(question) {
+  const queries = [question];
+
+  queries.push(
+    ...question
+      .split(/[ ,，、]/)
+      .map((v) => v.trim())
+      .filter(Boolean)
+  );
+
+  return [...new Set(queries)];
+}
+
+async function hybridSearch({
+  question,
+  spaces,
+  contributors,
+  maxPages = 10
+}) {
+  const queries = buildQueries(question);
+
+  const weights = [
+    1,
+    0.8,
+    0.6,
+    0.4,
+    0.2
+  ];
+
+  const scoreMap = new Map();
+
+  for (let i = 0; i < queries.length; i++) {
+    const pages = await searchPages({
+      keywords: [queries[i]],
+      spaces,
+      contributors,
+      limit: 20
+    });
+
+    for (const page of pages) {
+      const old =
+        scoreMap.get(page.pageId) || {
+          ...page,
+          score: 0
+        };
+
+      old.score += weights[i] || 0.1;
+
+      scoreMap.set(page.pageId, old);
+    }
+  }
+
+  return [...scoreMap.values()]
+    .sort((a, b) => b.score - a.score)
+    .slice(0, maxPages);
+}
+
+async function askConfluence({
+  question,
+  spaces,
+  contributors,
+  maxPages = 10,
+  maxChunks = 15
+}) {
+  const pages = await hybridSearch({
+    question,
+    spaces,
+    contributors,
+    maxPages
+  });
+
+  const documents = [];
+
+  for (const page of pages) {
+    const detail = await getPageById(
+      page.pageId
+    );
+
+    const text = htmlToText(
+      detail.content,
+      {
+        wordwrap: false
+      }
+    );
+
+    const chunks = chunkText(text);
+
+    chunks.forEach((chunk) => {
+      documents.push({
+        pageId: detail.id,
+        title: detail.title,
+        url: detail.url,
+        chunk
+      });
+    });
+  }
+
+  const engine = BM25();
+
+  engine.defineConfig({
+    fldWeights: {
+      chunk: 1
+    }
+  });
+
+  engine.definePrepTasks([]);
+
+  engine.defineField("chunk");
+
+  engine.defineRef("id");
+
+  engine.configure();
+
+  documents.forEach((doc, index) => {
+    engine.addDoc(index, {
+      chunk: doc.chunk
+    });
+  });
+
+  engine.consolidate();
+
+  const results = engine.search(
+    question,
+    maxChunks
+  );
+
+  return results.map((v) => {
+    const doc = documents[v[0]];
+
+    return {
+      title: doc.title,
+      url: doc.url,
+      score: v[1],
+      content: doc.chunk
+    };
+  });
+}
+
+async function exploreConfluence(
+  topic
+) {
+  const pages = await searchPages({
+    keywords: [topic],
+    limit: 5
+  });
+
+  const result = [];
+
+  for (const page of pages) {
+    const children = await getChildren(
+      page.pageId
+    );
+
+    result.push({
+      page,
+      children
+    });
+  }
+
+  return result;
+}
+
+server.registerTool(
+  "get_children",
+  {
+    title: "Get Children",
+    description:
+      "Get child pages",
+    inputSchema: {
+      pageId: z.string()
+    }
+  },
+  async ({ pageId }) =>
+    getChildren(pageId)
+);
+
+server.registerTool(
+  "get_page_tree",
+  {
+    title: "Get Page Tree",
+    description:
+      "Get page tree recursively",
+    inputSchema: {
+      rootPageId: z.string(),
+      depth: z.number().default(2)
+    }
+  },
+  async ({
+    rootPageId,
+    depth
+  }) =>
+    buildTree(rootPageId, depth)
+);
+
+server.registerTool(
+  "ask_confluence",
+  {
+    title: "Ask Confluence",
+    description:
+      "Retrieve relevant contexts from Confluence",
+
+    inputSchema: {
+      question: z.string(),
+
+      spaces: z
+        .array(z.string())
+        .optional(),
+
+      contributors: z
+        .array(z.string())
+        .optional(),
+
+      maxPages: z
+        .number()
+        .default(10),
+
+      maxChunks: z
+        .number()
+        .default(15)
+    }
+  },
+  async (args) =>
+    askConfluence(args)
+);
+
+server.registerTool(
+  "explore_confluence",
+  {
+    title: "Explore Topic",
+    description:
+      "Explore topic related pages",
+
+    inputSchema: {
+      topic: z.string()
+    }
+  },
+  async ({ topic }) =>
+    exploreConfluence(topic)
+);

package/confluenceTools.json

@@ -0,0 +1,151 @@
+{
+  "tools": [
+    {
+      "name": "get_page_by_id",
+      "description": "根据页面 ID 获取 Confluence 页面内容",
+      "parameters": [
+        {
+          "name": "pageId",
+          "type": "string",
+          "required": true,
+          "description": "Confluence 页面 ID"
+        }
+      ]
+    },
+    {
+      "name": "get_page_by_title",
+      "description": "根据标题查找页面",
+      "parameters": [
+        {
+          "name": "title",
+          "type": "string",
+          "required": true,
+          "description": "要查找的页面标题"
+        },
+        {
+          "name": "space",
+          "type": "string",
+          "required": false,
+          "description": "空间标识，缩小搜索范围（如 DEV, OPS）"
+        }
+      ]
+    },
+    {
+      "name": "get_spaces",
+      "description": "列出所有空间",
+      "parameters": []
+    },
+    {
+      "name": "search_pages",
+      "description": "按关键词、空间和贡献者搜索页面",
+      "parameters": [
+        {
+          "name": "keywords",
+          "type": "array<string>",
+          "required": true,
+          "description": "要在页面内容中搜索的关键词"
+        },
+        {
+          "name": "spaces",
+          "type": "array<string>",
+          "required": false,
+          "description": "按空间标识过滤"
+        },
+        {
+          "name": "contributors",
+          "type": "array<string>",
+          "required": false,
+          "description": "按贡献者用户名过滤"
+        },
+        {
+          "name": "limit",
+          "type": "number",
+          "required": false,
+          "default": 10,
+          "description": "最大返回结果数"
+        }
+      ]
+    },
+    {
+      "name": "get_children",
+      "description": "获取指定页面的子页面",
+      "parameters": [
+        {
+          "name": "pageId",
+          "type": "string",
+          "required": true,
+          "description": "父页面 ID"
+        }
+      ]
+    },
+    {
+      "name": "get_page_tree",
+      "description": "递归获取页面树",
+      "parameters": [
+        {
+          "name": "rootPageId",
+          "type": "string",
+          "required": true,
+          "description": "根页面 ID"
+        },
+        {
+          "name": "depth",
+          "type": "number",
+          "required": false,
+          "default": 2,
+          "description": "递归深度"
+        }
+      ]
+    },
+    {
+      "name": "ask_confluence",
+      "description": "使用混合搜索 + BM25 重排序检索 Confluence 相关内容",
+      "parameters": [
+        {
+          "name": "question",
+          "type": "string",
+          "required": true,
+          "description": "自然语言问题，用于搜索 Confluence"
+        },
+        {
+          "name": "spaces",
+          "type": "array<string>",
+          "required": false,
+          "description": "按空间标识过滤"
+        },
+        {
+          "name": "contributors",
+          "type": "array<string>",
+          "required": false,
+          "description": "按贡献者用户名过滤"
+        },
+        {
+          "name": "maxPages",
+          "type": "number",
+          "required": false,
+          "default": 10,
+          "description": "在分块前最多获取的页面数"
+        },
+        {
+          "name": "maxChunks",
+          "type": "number",
+          "required": false,
+          "default": 15,
+          "description": "BM25 重排序后返回的最大文本块数"
+        }
+      ]
+    },
+    {
+      "name": "explore_confluence",
+      "description": "探索与主题相关的页面及其子页面",
+      "parameters": [
+        {
+          "name": "topic",
+          "type": "string",
+          "required": true,
+          "description": "要探索的主题关键词"
+        }
+      ]
+    }
+  ]
+}