@templmf/temp-solf-lmf 0.0.140 → 0.0.141

package/package.json

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

package/confMCP.js

@@ -1,551 +0,0 @@
-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)
-);