@templmf/temp-solf-lmf 0.0.137 → 0.0.139

package/langgraphConfluenceTools.js

@@ -0,0 +1,324 @@
+import { DynamicStructuredTool } from "@langchain/core/tools";
+import { z } from "zod";
+import axios from "axios";
+import { htmlToText } from "html-to-text";
+import BM25 from "wink-bm25-text-search";
+import LRUCache from "lru-cache";
+import express from "express";
+
+export class ConfluenceClient {
+  constructor(baseURL, authorization) {
+    if (!baseURL || !authorization) {
+      throw new Error("CONFLUENCE_BASE_URL and CONFLUENCE_AUTHORIZATION are required");
+    }
+    this.baseURL = baseURL;
+    this.client = axios.create({
+      baseURL,
+      timeout: 30000,
+      headers: {
+        Authorization: authorization,
+        Accept: "application/json"
+      }
+    });
+    this.pageCache = new LRUCache({ max: 100, ttl: 1000 * 60 * 10 });
+  }
+
+  stripHtml(html = "") {
+    return html.replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim();
+  }
+
+  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 getPageById(pageId) {
+    const cached = this.pageCache.get(pageId);
+    if (cached) return cached;
+
+    const { data } = await this.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: `${this.baseURL}${data._links?.webui}`,
+      content: data.body?.storage?.value || ""
+    };
+    this.pageCache.set(pageId, result);
+    return result;
+  }
+
+  async getPageByTitle(title, space) {
+    const params = { title, expand: "body.storage" };
+    if (space) params.spaceKey = space;
+
+    const { data } = await this.client.get("/rest/api/content", { params });
+    const page = data.results?.[0];
+    if (!page) return null;
+
+    return {
+      id: page.id,
+      title: page.title,
+      url: `${this.baseURL}${page._links?.webui}`
+    };
+  }
+
+  async getSpaces() {
+    const { data } = await this.client.get("/rest/api/space");
+    return data.results.map((v) => ({ key: v.key, name: v.name }));
+  }
+
+  async searchPages({ keywords, spaces = [], contributors = [], limit = 10 }) {
+    const cql = this.buildCql({ keywords, spaces, contributors });
+    const { data } = await this.client.get("/rest/api/search", {
+      params: { cql, limit }
+    });
+    return data.results.map((item) => ({
+      pageId: item.content?.id,
+      title: item.title,
+      url: `${this.baseURL}${item.url}`
+    }));
+  }
+
+  async getChildren(pageId) {
+    const { data } = await this.client.get(`/rest/api/content/${pageId}/child/page`);
+    return data.results.map((v) => ({ id: v.id, title: v.title }));
+  }
+
+  async buildTree(pageId, depth) {
+    const page = await this.getPageById(pageId);
+    if (depth <= 0) return { id: page.id, title: page.title };
+
+    const children = await this.getChildren(pageId);
+    return {
+      id: page.id,
+      title: page.title,
+      children: await Promise.all(children.map((v) => this.buildTree(v.id, depth - 1)))
+    };
+  }
+
+  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;
+  }
+
+  buildQueries(question) {
+    const queries = [question];
+    queries.push(
+      ...question.split(/[ ,，、]/).map((v) => v.trim()).filter(Boolean)
+    );
+    return [...new Set(queries)];
+  }
+
+  async hybridSearch({ question, spaces, contributors, maxPages = 10 }) {
+    const queries = this.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 this.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 askConfluence({ question, spaces, contributors, maxPages = 10, maxChunks = 15 }) {
+    const pages = await this.hybridSearch({ question, spaces, contributors, maxPages });
+    const documents = [];
+
+    for (const page of pages) {
+      const detail = await this.getPageById(page.pageId);
+      const text = htmlToText(detail.content, { wordwrap: false });
+      const chunks = this.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();
+
+    return engine.search(question, maxChunks).map((v) => {
+      const doc = documents[v[0]];
+      return { title: doc.title, url: doc.url, score: v[1], content: doc.chunk };
+    });
+  }
+
+  async exploreConfluence(topic) {
+    const pages = await this.searchPages({ keywords: [topic], limit: 5 });
+    const result = [];
+    for (const page of pages) {
+      const children = await this.getChildren(page.pageId);
+      result.push({ page, children });
+    }
+    return result;
+  }
+}
+
+export function createConfluenceTools(baseURL, authorization) {
+  const client = new ConfluenceClient(baseURL, authorization);
+
+  return {
+    getPageById: new DynamicStructuredTool({
+      name: "get_page_by_id",
+      description: "Get Confluence page content by page id",
+      schema: z.object({ pageId: z.string() }),
+      func: async ({ pageId }) => JSON.stringify(await client.getPageById(pageId))
+    }),
+
+    getPageByTitle: new DynamicStructuredTool({
+      name: "get_page_by_title",
+      description: "Find page by title",
+      schema: z.object({
+        title: z.string(),
+        space: z.string().optional()
+      }),
+      func: async ({ title, space }) => JSON.stringify(await client.getPageByTitle(title, space))
+    }),
+
+    getSpaces: new DynamicStructuredTool({
+      name: "get_spaces",
+      description: "List all spaces",
+      schema: z.object({}),
+      func: async () => JSON.stringify(await client.getSpaces())
+    }),
+
+    searchPages: new DynamicStructuredTool({
+      name: "search_pages",
+      description: "Search pages by keywords, spaces and contributors",
+      schema: z.object({
+        keywords: z.array(z.string()).min(1),
+        spaces: z.array(z.string()).optional(),
+        contributors: z.array(z.string()).optional(),
+        limit: z.number().default(10)
+      }),
+      func: async (args) => JSON.stringify(await client.searchPages(args))
+    }),
+
+    getChildren: new DynamicStructuredTool({
+      name: "get_children",
+      description: "Get child pages of a given page",
+      schema: z.object({ pageId: z.string() }),
+      func: async ({ pageId }) => JSON.stringify(await client.getChildren(pageId))
+    }),
+
+    getPageTree: new DynamicStructuredTool({
+      name: "get_page_tree",
+      description: "Get page tree recursively",
+      schema: z.object({
+        rootPageId: z.string(),
+        depth: z.number().default(2)
+      }),
+      func: async ({ rootPageId, depth }) => JSON.stringify(await client.buildTree(rootPageId, depth))
+    }),
+
+    askConfluence: new DynamicStructuredTool({
+      name: "ask_confluence",
+      description: "Retrieve relevant contexts from Confluence using hybrid search + BM25 reranking",
+      schema: z.object({
+        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)
+      }),
+      func: async (args) => JSON.stringify(await client.askConfluence(args))
+    }),
+
+    exploreConfluence: new DynamicStructuredTool({
+      name: "explore_confluence",
+      description: "Explore topic related pages and their children",
+      schema: z.object({ topic: z.string() }),
+      func: async ({ topic }) => JSON.stringify(await client.exploreConfluence(topic))
+    })
+  };
+}
+
+export function startServer(port = 3000) {
+  const app = express();
+  app.use(express.json());
+
+  app.post("/tools/:toolName", async (req, res) => {
+    const { baseURL, authorization, ...args } = req.body;
+
+    if (!baseURL || !authorization) {
+      return res.status(400).json({
+        error: "baseURL and authorization are required in request body"
+      });
+    }
+
+    try {
+      const tools = createConfluenceTools(baseURL, authorization);
+      const tool = tools[req.params.toolName];
+      if (!tool) {
+        return res.status(404).json({
+          error: `Tool "${req.params.toolName}" not found`,
+          availableTools: Object.keys(tools)
+        });
+      }
+      const result = await tool.invoke(args);
+      res.json({ result: JSON.parse(result) });
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+
+  app.get("/tools", (_req, res) => {
+    res.json({
+      availableTools: Object.keys(createConfluenceTools("http://dummy", "dummy"))
+    });
+  });
+
+  app.listen(port, () => {
+    console.log(`Confluence tools HTTP server running on http://localhost:${port}`);
+    console.log(`Usage: curl -X POST http://localhost:${port}/tools/get_spaces \\`);
+    console.log(`  -H "Content-Type: application/json" \\`);
+    console.log(`  -d '{"baseURL":"<base>","authorization":"Bearer <token>"}'`);
+  });
+}
+
+const isMain = process.argv[1] && (
+  process.argv[1] === new URL(import.meta.url).pathname ||
+  process.argv[1].endsWith("/langgraphConfluenceTools.js")
+);
+
+if (isMain) {
+  const port = process.env.PORT ? parseInt(process.env.PORT) : 3000;
+  startServer(port);
+}

package/package.json

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