@ghenya/clinn 0.7.0

package/Src/llm.js

@@ -0,0 +1,195 @@
+const https = require("https");
+
+class LLMClient {
+  constructor(config) {
+    this.apiKey = config.apiKey;
+    this.baseURL = config.baseURL;
+    this.model = config.model;
+    this.maxTokens = config.maxTokens;
+    this.temperature = config.temperature;
+    this.topP = config.topP;
+    this.totalPromptTokens = 0;
+    this.totalCompletionTokens = 0;
+  }
+
+  getUsage() {
+    return {
+      prompt: this.totalPromptTokens,
+      completion: this.totalCompletionTokens,
+    };
+  }
+
+  resetUsage() {
+    this.totalPromptTokens = 0;
+    this.totalCompletionTokens = 0;
+  }
+
+  async chat(messages, tools = null) {
+    const body = {
+      model: this.model,
+      messages,
+      max_tokens: this.maxTokens,
+      temperature: this.temperature,
+      top_p: this.topP,
+      stream: false,
+    };
+
+    if (tools && tools.length > 0) {
+      body.tools = tools;
+      body.tool_choice = "auto";
+    }
+
+    const result = await this._request("/chat/completions", JSON.stringify(body));
+    this._accumulateUsage(result.usage);
+    return result;
+  }
+
+  async chatStream(messages, onToken, tools = null) {
+    const body = {
+      model: this.model,
+      messages,
+      max_tokens: this.maxTokens,
+      temperature: this.temperature,
+      top_p: this.topP,
+      stream: true,
+      stream_options: { include_usage: true },
+    };
+
+    if (tools && tools.length > 0) {
+      body.tools = tools;
+      body.tool_choice = "auto";
+    }
+
+    return this._requestStream("/chat/completions", JSON.stringify(body), onToken);
+  }
+
+  _accumulateUsage(usage) {
+    if (!usage) return;
+    if (usage.prompt_tokens) this.totalPromptTokens += usage.prompt_tokens;
+    if (usage.completion_tokens) this.totalCompletionTokens += usage.completion_tokens;
+  }
+
+  _request(path, body) {
+    const url = new URL(path, this.baseURL);
+
+    const options = {
+      hostname: url.hostname,
+      port: url.port || 443,
+      path: url.pathname,
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.apiKey}`,
+      },
+    };
+
+    return new Promise((resolve, reject) => {
+      const req = https.request(options, (res) => {
+        let data = "";
+        res.on("data", (chunk) => (data += chunk));
+        res.on("end", () => {
+          try {
+            const json = JSON.parse(data);
+            if (json.error) {
+              reject(new Error(json.error.message));
+            } else {
+              resolve(json);
+            }
+          } catch (e) {
+            reject(new Error(`parse error: ${data.slice(0, 200)}`));
+          }
+        });
+      });
+
+      req.on("error", reject);
+      req.write(body);
+      req.end();
+    });
+  }
+
+  _requestStream(path, body, onToken) {
+    const url = new URL(path, this.baseURL);
+
+    const options = {
+      hostname: url.hostname,
+      port: url.port || 443,
+      path: url.pathname,
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.apiKey}`,
+      },
+    };
+
+    return new Promise((resolve, reject) => {
+      const req = https.request(options, (res) => {
+        let buffer = "";
+        const toolCallsMap = {};
+        let content = "";
+        const self = this;
+
+        res.on("data", (chunk) => {
+          buffer += chunk.toString();
+          const lines = buffer.split("\n");
+          buffer = lines.pop() || "";
+
+          for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed || !trimmed.startsWith("data: ")) continue;
+            const jsonStr = trimmed.slice(6);
+            if (jsonStr === "[DONE]") continue;
+
+            try {
+              const json = JSON.parse(jsonStr);
+              const delta = json.choices?.[0]?.delta;
+
+              if (delta?.content) {
+                content += delta.content;
+                if (onToken) onToken(delta.content);
+              }
+
+              if (delta?.tool_calls) {
+                for (const tc of delta.tool_calls) {
+                  const idx = tc.index;
+                  if (!toolCallsMap[idx]) {
+                    toolCallsMap[idx] = {
+                      id: tc.id || "",
+                      type: "function",
+                      function: { name: "", arguments: "" },
+                    };
+                  }
+                  if (tc.id) toolCallsMap[idx].id = tc.id;
+                  if (tc.function?.name) toolCallsMap[idx].function.name += tc.function.name;
+                  if (tc.function?.arguments) toolCallsMap[idx].function.arguments += tc.function.arguments;
+                }
+              }
+
+              if (json.usage) {
+                self._accumulateUsage(json.usage);
+              }
+            } catch (_) {}
+          }
+        });
+
+        res.on("end", () => {
+          const toolCalls = Object.keys(toolCallsMap)
+            .sort((a, b) => a - b)
+            .map((k) => toolCallsMap[k]);
+
+          resolve({
+            content: content || null,
+            toolCalls: toolCalls.length > 0 ? toolCalls : null,
+          });
+        });
+
+        res.on("error", reject);
+      });
+
+      req.on("error", reject);
+      req.write(body);
+      req.end();
+    });
+  }
+}
+
+module.exports = LLMClient;

package/Tools/browser.js

@@ -0,0 +1,133 @@
+const fs = require("fs");
+const path = require("path");
+
+let _puppeteer = null;
+let _chromePath = null;
+
+function _getChromePath() {
+  if (_chromePath) return _chromePath;
+  const candidates = [
+    "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+    "/Applications/Chromium.app/Contents/MacOS/Chromium",
+    "C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe",
+    "C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe",
+    "/usr/bin/google-chrome",
+    "/usr/bin/chromium-browser",
+    "/usr/bin/chromium",
+  ];
+  for (const c of candidates) {
+    if (fs.existsSync(c)) { _chromePath = c; return c; }
+  }
+  return null;
+}
+
+function _getPuppeteer() {
+  if (_puppeteer) return _puppeteer;
+  try {
+    _puppeteer = require("puppeteer-core");
+    return _puppeteer;
+  } catch (_) {
+    return null;
+  }
+}
+
+let _browserPromise = null;
+let _browser = null;
+
+async function _ensureBrowser() {
+  if (_browser && _browser.isConnected()) return _browser;
+  const pp = _getPuppeteer();
+  if (!pp) throw new Error("puppeteer-core 未安装, 请运行 npm install puppeteer-core");
+  const chromePath = _getChromePath();
+  if (!chromePath) throw new Error("未找到 Chrome/Chromium 浏览器");
+  if (!_browserPromise) {
+    _browserPromise = pp.launch({
+      executablePath: chromePath,
+      headless: "new",
+      args: [
+        "--no-sandbox",
+        "--disable-setuid-sandbox",
+        "--disable-dev-shm-usage",
+        "--disable-gpu",
+        "--disable-web-security",
+        "--disable-features=IsolateOrigins,site-per-process",
+      ],
+    });
+  }
+  _browser = await _browserPromise;
+  return _browser;
+}
+
+async function _extractText(page) {
+  return page.evaluate(() => {
+    document.querySelectorAll("script, style, noscript, iframe, nav, footer, header, aside").forEach((el) => el.remove());
+    return (document.body?.innerText || "").replace(/\n{3,}/g, "\n\n").trim();
+  });
+}
+
+const browsePageTool = {
+  name: "browse_page",
+  description: "用真实浏览器(Chrome无头模式)打开网页并提取文字内容. 能绕过反爬、执行JS渲染的SPA页面",
+  parameters: {
+    url: { type: "string", required: true, description: "要打开的URL" },
+    waitMs: { type: "number", required: false, description: "页面加载后额外等待毫秒, 默认2000" },
+    extractLinks: { type: "boolean", required: false, description: "是否同时提取链接, 默认false" },
+  },
+  execute: async ({ url, waitMs, extractLinks }) => {
+    const start = Date.now();
+    let page = null;
+    try {
+      const browser = await _ensureBrowser();
+      page = await browser.newPage();
+      await page.setUserAgent("Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36");
+      await page.setViewport({ width: 1280, height: 800 });
+      await page.setRequestInterception(true);
+      const blockedTypes = new Set(["image", "media", "font", "stylesheet"]);
+      page.on("request", (req) => {
+        if (blockedTypes.has(req.resourceType())) req.abort();
+        else req.continue();
+      });
+
+      const wait = waitMs != null ? waitMs : 2000;
+      await page.goto(url, { waitUntil: "networkidle2", timeout: 20000 });
+      await new Promise((r) => setTimeout(r, wait));
+
+      const title = await page.title();
+      const text = await _extractText(page);
+      const ms = Date.now() - start;
+
+      let result = `[浏览器 ${ms}ms] ${title}\n\n${text.slice(0, 4000)}`;
+
+      if (extractLinks) {
+        const links = await page.evaluate(() =>
+          [...document.querySelectorAll("a[href]")].map((a) => a.href).filter((h) => h.startsWith("http"))
+        );
+        const unique = [...new Set(links)].slice(0, 30);
+        result += `\n\n[链接 ${unique.length} 个]\n${unique.join("\n")}`;
+      }
+
+      await page.close();
+      return result;
+    } catch (e) {
+      if (page) await page.close().catch(() => {});
+      return `[浏览器失败 ${Date.now() - start}ms] ${e.message}`;
+    }
+  },
+};
+
+const browsePageTextTool = {
+  name: "browse_page_text",
+  description: "用浏览器打开网页, 只提取主体文字(自动过滤导航/页脚/脚本), 返回干净文本",
+  parameters: {
+    url: { type: "string", required: true, description: "要打开的URL" },
+    waitMs: { type: "number", required: false, description: "额外等待毫秒, 默认2000" },
+  },
+  execute: async ({ url, waitMs }) => {
+    return browsePageTool.execute({ url, waitMs, extractLinks: false });
+  },
+};
+
+module.exports = {
+  browse_page: browsePageTool,
+  browse_page_text: browsePageTextTool,
+};

package/Tools/edit_tools.js

@@ -0,0 +1,93 @@
+const fs = require("fs");
+
+const editLinesTool = {
+  name: "edit_lines",
+  description: "按行号编辑文件: insert_before/insert_after/replace/delete",
+  dangerous: true,
+  parameters: {
+    filePath: { type: "string", required: true, description: "文件路径" },
+    operation: { type: "string", required: true, description: "insert_before/insert_after/replace/delete" },
+    lineNumber: { type: "number", required: true, description: "目标行号(从1开始)" },
+    content: { type: "string", required: false, description: "新内容(insert/replace时必填, 支持\\n多行)" },
+    count: { type: "number", required: false, description: "delete时删除的行数, 默认1" },
+  },
+  execute: async ({ filePath, operation, lineNumber, content, count }) => {
+    if (!fs.existsSync(filePath)) return `[不存在] ${filePath}`;
+    const lines = fs.readFileSync(filePath, "utf-8").split("\n");
+    const idx = lineNumber - 1;
+    if (idx < 0 || idx > lines.length) return `[越界] 行号 ${lineNumber}, 文件共 ${lines.length} 行`;
+
+    switch (operation) {
+      case "insert_before": lines.splice(idx, 0, ...(content || "").split("\n")); break;
+      case "insert_after": lines.splice(idx + 1, 0, ...(content || "").split("\n")); break;
+      case "replace": lines.splice(idx, 1, ...(content || "").split("\n")); break;
+      case "delete": lines.splice(idx, count || 1); break;
+      default: return `[错误] 未知操作: ${operation}, 可用: insert_before/insert_after/replace/delete`;
+    }
+    fs.writeFileSync(filePath, lines.join("\n"), "utf-8");
+    return `[OK] ${operation} 行${lineNumber}, 文件现共 ${lines.length} 行`;
+  },
+};
+
+const readLinesTool = {
+  name: "read_lines",
+  description: "读取文件指定行范围, 带行号",
+  parameters: {
+    filePath: { type: "string", required: true, description: "文件路径" },
+    startLine: { type: "number", required: true, description: "起始行号(从1开始)" },
+    endLine: { type: "number", required: false, description: "结束行号, 默认到文件末尾" },
+  },
+  execute: async ({ filePath, startLine, endLine }) => {
+    if (!fs.existsSync(filePath)) return `[不存在] ${filePath}`;
+    const lines = fs.readFileSync(filePath, "utf-8").split("\n");
+    const s = Math.max(1, startLine) - 1;
+    const e = endLine ? Math.min(lines.length, endLine) : lines.length;
+    if (s >= lines.length) return `[越界] 起始 ${startLine}, 共 ${lines.length} 行`;
+    return lines.slice(s, e).map((l, i) => `${s + i + 1}| ${l}`).join("\n");
+  },
+};
+
+const searchInRangeTool = {
+  name: "search_in_range",
+  description: "在指定文件的行范围内搜索关键词, 返回匹配行+行号. 行列级别的精确搜索",
+  parameters: {
+    filePath: { type: "string", required: true, description: "文件路径" },
+    pattern: { type: "string", required: true, description: "搜索关键词或正则" },
+    startLine: { type: "number", required: false, description: "起始行号, 默认1" },
+    endLine: { type: "number", required: false, description: "结束行号, 默认文件末尾" },
+    ignoreCase: { type: "boolean", required: false, description: "忽略大小写, 默认true" },
+    maxResults: { type: "number", required: false, description: "最大结果, 默认30" },
+  },
+  execute: async ({ filePath, pattern, startLine, endLine, ignoreCase, maxResults }) => {
+    if (!fs.existsSync(filePath)) return `[不存在] ${filePath}`;
+    const lines = fs.readFileSync(filePath, "utf-8").split("\n");
+    const s = Math.max(1, (startLine || 1)) - 1;
+    const e = endLine ? Math.min(lines.length, endLine) : lines.length;
+    if (s >= lines.length) return `[越界] 起始 ${startLine || 1}, 共 ${lines.length} 行`;
+
+    const max = maxResults || 30;
+    const ic = ignoreCase !== false;
+    const target = ic ? pattern.toLowerCase() : pattern;
+    const results = [];
+
+    for (let i = s; i < e && results.length < max; i++) {
+      const line = lines[i];
+      const cmp = ic ? line.toLowerCase() : line;
+      if (cmp.includes(target)) {
+        const col = cmp.indexOf(target) + 1;
+        results.push(`${i + 1}:${col}| ${line}`);
+      }
+    }
+
+    if (results.length === 0) {
+      return `[无匹配] "${pattern}" 在 ${filePath} 第${s + 1}-${e}行 (共${e - s}行)`;
+    }
+    return `[${results.length} 处匹配 行${s + 1}-${e}]\n${results.join("\n")}`;
+  },
+};
+
+module.exports = {
+  edit_lines: editLinesTool,
+  read_lines: readLinesTool,
+  search_in_range: searchInRangeTool,
+};