@templmf/temp-solf-lmf 0.0.139 → 0.0.140

package/confMCP.ts

@@ -0,0 +1,639 @@
+import axios, { AxiosInstance } 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";
+
+interface ConfluencePage {
+  id: string;
+  title: string;
+  space?: string;
+  version?: number;
+  url: string;
+  content: string;
+}
+
+interface PageResult {
+  id: string;
+  title: string;
+  url: string;
+}
+
+interface SpaceInfo {
+  key: string;
+  name: string;
+}
+
+interface SearchResult {
+  pageId: string;
+  title: string;
+  url: string;
+}
+
+interface SearchParams {
+  keywords: string[];
+  spaces?: string[];
+  contributors?: string[];
+  limit?: number;
+}
+
+interface HybridSearchParams {
+  question: string;
+  spaces?: string[];
+  contributors?: string[];
+  maxPages?: number;
+}
+
+interface AskConfluenceParams {
+  question: string;
+  spaces?: string[];
+  contributors?: string[];
+  maxPages?: number;
+  maxChunks?: number;
+}
+
+interface TreePage {
+  id: string;
+  title: string;
+  children?: TreePage[];
+}
+
+interface ScoredPage extends SearchResult {
+  score: number;
+}
+
+interface Document {
+  pageId: string;
+  title: string;
+  url: string;
+  chunk: string;
+}
+
+interface SearchResultWithScore {
+  title: string;
+  url: string;
+  score: number;
+  content: string;
+}
+
+interface ExploreResult {
+  page: SearchResult;
+  children: { id: string; title: string }[];
+}
+
+interface ChildPage {
+  id: string;
+  title: string;
+}
+
+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: AxiosInstance = axios.create({
+  baseURL,
+  timeout: 30000,
+  headers: {
+    Authorization: authorization,
+    Accept: "application/json"
+  }
+});
+
+const pageCache = new LRUCache<string, ConfluencePage>({
+  max: 100,
+  ttl: 1000 * 60 * 10
+});
+
+function stripHtml(html = ""): string {
+  return html
+    .replace(/<[^>]+>/g, " ")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+interface BuildCqlParams {
+  keywords?: string[];
+  spaces?: string[];
+  contributors?: string[];
+}
+
+function buildCql({
+  keywords = [],
+  spaces = [],
+  contributors = []
+}: BuildCqlParams): string {
+  const clauses: string[] = [];
+
+  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: string): Promise<ConfluencePage> {
+  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: ConfluencePage = {
+    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: string,
+  space?: string
+): Promise<PageResult | null> {
+  const params: Record<string, string> = {
+    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(): Promise<SpaceInfo[]> {
+  const { data } = await client.get(
+    "/rest/api/space"
+  );
+
+  return data.results.map((v: any) => ({
+    key: v.key,
+    name: v.name
+  }));
+}
+
+async function searchPages({
+  keywords,
+  spaces = [],
+  contributors = [],
+  limit = 10
+}: SearchParams): Promise<SearchResult[]> {
+  const cql = buildCql({
+    keywords,
+    spaces,
+    contributors
+  });
+
+  const { data } = await client.get(
+    "/rest/api/search",
+    {
+      params: {
+        cql,
+        limit
+      }
+    }
+  );
+
+  return data.results.map((item: any) => ({
+    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 }: { pageId: string }) => {
+    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 }: { title: string; space?: string }) => {
+    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: SearchParams) => {
+    return await searchPages(args);
+  }
+);
+
+async function getChildren(pageId: string): Promise<ChildPage[]> {
+  const { data } = await client.get(
+    `/rest/api/content/${pageId}/child/page`
+  );
+
+  return data.results.map((v: any) => ({
+    id: v.id,
+    title: v.title
+  }));
+}
+
+async function buildTree(pageId: string, depth: number): Promise<TreePage> {
+  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: string,
+  size = 1200,
+  overlap = 200
+): string[] {
+  const chunks: string[] = [];
+
+  let start = 0;
+
+  while (start < text.length) {
+    chunks.push(
+      text.slice(start, start + size)
+    );
+
+    start += size - overlap;
+  }
+
+  return chunks;
+}
+
+function buildQueries(question: string): string[] {
+  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
+}: HybridSearchParams): Promise<ScoredPage[]> {
+  const queries = buildQueries(question);
+
+  const weights = [
+    1,
+    0.8,
+    0.6,
+    0.4,
+    0.2
+  ];
+
+  const scoreMap = new Map<string, ScoredPage>();
+
+  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
+}: AskConfluenceParams): Promise<SearchResultWithScore[]> {
+  const pages = await hybridSearch({
+    question,
+    spaces,
+    contributors,
+    maxPages
+  });
+
+  const documents: Document[] = [];
+
+  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: [number, number]) => {
+    const doc = documents[v[0]];
+
+    return {
+      title: doc.title,
+      url: doc.url,
+      score: v[1],
+      content: doc.chunk
+    };
+  });
+}
+
+async function exploreConfluence(
+  topic: string
+): Promise<ExploreResult[]> {
+  const pages = await searchPages({
+    keywords: [topic],
+    limit: 5
+  });
+
+  const result: ExploreResult[] = [];
+
+  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 }: { pageId: string }) =>
+    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
+  }: {
+    rootPageId: string;
+    depth: number;
+  }) =>
+    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: AskConfluenceParams) =>
+    askConfluence(args)
+);
+
+server.registerTool(
+  "explore_confluence",
+  {
+    title: "Explore Topic",
+    description:
+      "Explore topic related pages",
+
+    inputSchema: {
+      topic: z.string()
+    }
+  },
+  async ({ topic }: { topic: string }) =>
+    exploreConfluence(topic)
+);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@templmf/temp-solf-lmf",
-  "version": "0.0.139",
+  "version": "0.0.140",
   "description": "",
   "main": "index.js",
   "scripts": {