@ghenya/clinn 0.7.0

package/Tools/index.js

@@ -0,0 +1,311 @@
+const fs = require("fs");
+const path = require("path");
+const fileTools = require("./file_tools");
+const searchTools = require("./search_tools");
+const editTools = require("./edit_tools");
+const extendedTools = require("./extended_tools");
+const browserTools = require("./browser");
+const tokenizer = require("./tokenizer");
+
+let toolRegistry = {
+  ...fileTools,
+  ...searchTools,
+  ...editTools,
+  ...extendedTools,
+  ...browserTools,
+};
+
+let permissionCallback = null;
+let trustedNames = new Set();
+const CUSTOM_DIR = path.join(require("os").homedir(), ".clinn", "Tools", "custom");
+
+function loadCustomTools() {
+  if (!fs.existsSync(CUSTOM_DIR)) return;
+  const files = fs.readdirSync(CUSTOM_DIR).filter((f) => f.endsWith(".js"));
+  for (const file of files) {
+    try {
+      const mod = require(path.join(CUSTOM_DIR, file));
+      if (typeof mod === "object" && mod !== null) {
+        Object.assign(toolRegistry, mod);
+      }
+    } catch (e) {
+      // skip broken custom tools
+    }
+  }
+}
+
+loadCustomTools();
+
+function saveToolToFile(name, code) {
+  if (!fs.existsSync(CUSTOM_DIR)) fs.mkdirSync(CUSTOM_DIR, { recursive: true });
+  if (!/^[a-z_][a-z0-9_]*$/i.test(name)) return `[失败] 工具名不合法: ${name}, 只允许字母数字下划线`;
+
+  const sanitized = code.trim();
+  if (!sanitized) return "[失败] 代码不能为空";
+  if (sanitized.length > 50000) return "[失败] 代码过长, 最大50000字符";
+
+  const filePath = path.join(CUSTOM_DIR, name + ".js");
+  fs.writeFileSync(filePath, sanitized, "utf-8");
+
+  try {
+    delete require.cache[require.resolve(filePath)];
+    const mod = require(filePath);
+    if (typeof mod !== "object" || mod === null) {
+      fs.unlinkSync(filePath);
+      return `[失败] 模块必须导出对象, 如 module.exports = { tool_name: { name, description, parameters, execute } }`;
+    }
+    Object.assign(toolRegistry, mod);
+  } catch (e) {
+    fs.unlinkSync(filePath);
+    return `[失败] 语法错误: ${e.message}`;
+  }
+
+  const keys = Object.keys(require(filePath));
+  return `[OK] 工具已持久化: ${name}.js (导出: ${keys.join(", ")}) | 路径: ${filePath}`;
+}
+
+function deleteToolFile(name) {
+  const filePath = path.join(CUSTOM_DIR, name + ".js");
+  if (!fs.existsSync(filePath)) return `[不存在] ${name}.js`;
+  if (!filePath.startsWith(CUSTOM_DIR)) return "[拒绝] 路径越界";
+
+  const keys = Object.keys(require(filePath));
+  fs.unlinkSync(filePath);
+  delete require.cache[require.resolve(filePath)];
+
+  for (const k of keys) {
+    delete toolRegistry[k];
+    trustedNames.delete(k);
+  }
+
+  return `[OK] 已删除持久化工具: ${name}.js (移除: ${keys.join(", ")})`;
+}
+
+function listCustomTools() {
+  if (!fs.existsSync(CUSTOM_DIR)) return [];
+  const files = fs.readdirSync(CUSTOM_DIR).filter((f) => f.endsWith(".js"));
+  return files.map((f) => {
+    const name = f.replace(/\.js$/, "");
+    const p = path.join(CUSTOM_DIR, f);
+    let keys = [];
+    try { keys = Object.keys(require(p)); } catch (_) {}
+    return { file: f, name, exports: keys };
+  });
+}
+
+function setPermissionCallback(cb) { permissionCallback = cb; }
+function setTrusted(names) { trustedNames = new Set(names); }
+function addTrusted(name) { trustedNames.add(name); }
+function removeTrusted(name) { trustedNames.delete(name); }
+function loadTools() { return { ...toolRegistry }; }
+
+function registerTool(name, tool) { toolRegistry[name] = tool; }
+
+function unregisterTool(name) {
+  const filePath = path.join(CUSTOM_DIR, name + ".js");
+  if (fs.existsSync(filePath)) {
+    return `[提示] ${name} 是持久化工具, 请用 /tool_del_saved ${name} 或 delete_tool_file 删除`;
+  }
+  delete toolRegistry[name];
+  trustedNames.delete(name);
+}
+
+function searchToolRegistry(query) {
+  const q = query.toLowerCase();
+  return Object.entries(toolRegistry)
+    .filter(([name, tool]) => {
+      if (name.toLowerCase().includes(q)) return true;
+      if (tool.description && tool.description.toLowerCase().includes(q)) return true;
+      return false;
+    })
+    .map(([name, tool]) => ({ name, description: tool.description || "", parameters: tool.parameters || {} }));
+}
+
+function getTool(name) { return toolRegistry[name] || null; }
+
+async function checkPermission(name, args) {
+  if (trustedNames.has(name)) return true;
+  if (permissionCallback) return permissionCallback(name, args);
+  return false;
+}
+
+async function executeTool(name, args) {
+  const tool = toolRegistry[name];
+  if (!tool) throw new Error(`unknown tool: ${name}`);
+  if (tool.dangerous) {
+    const allowed = await checkPermission(name, args);
+    if (!allowed) throw new Error(`permission denied: ${name}`);
+  }
+  return tool.execute(args);
+}
+
+function toFunctionDeclarations() {
+  return Object.entries(toolRegistry).map(([key, tool]) => {
+    const properties = {};
+    const required = [];
+    if (tool.parameters) {
+      for (const [pn, pd] of Object.entries(tool.parameters)) {
+        properties[pn] = { type: pd.type, description: pd.description };
+        if (pd.required) required.push(pn);
+      }
+    }
+    return {
+      type: "function",
+      function: {
+        name: key,
+        description: tool.description || "",
+        parameters: { type: "object", properties, required },
+      },
+    };
+  });
+}
+// ========== 动态工具过滤: 根据用户提示词正则匹配相关工具 ==========
+
+// 预计算每个工具的关键词(启动时生成一次)
+const _toolKeywordsCache = new Map();
+
+function _extractKeywords(name, description) {
+  const kws = new Set();
+  for (const part of name.split("_")) {
+    if (part.length >= 2) kws.add(part.toLowerCase());
+  }
+  if (description) {
+    const tokens = tokenizer.segment(description.toLowerCase());
+    for (const t of tokens) {
+      if (t.length >= 2) kws.add(t);
+    }
+    const enMatches = description.match(/[a-zA-Z]{2,}/g);
+    if (enMatches) {
+      for (const m of enMatches) {
+        kws.add(m.toLowerCase());
+      }
+    }
+  }
+  return [...kws];
+}
+
+function _rebuildKeywords() {
+  _toolKeywordsCache.clear();
+  for (const [name, tool] of Object.entries(toolRegistry)) {
+    _toolKeywordsCache.set(name, _extractKeywords(name, tool.description || ""));
+  }
+  tokenizer.buildDictFromKeywords([..._toolKeywordsCache.values()]);
+}
+
+// 初始化构建
+_rebuildKeywords();
+
+/**
+ * 根据用户提示词正则匹配动态过滤工具声明
+ * @param {string} prompt - 用户原始提示词
+ * @returns {Array} 匹配的工具 function_declarations 数组
+ */
+function filterToolDeclarations(prompt) {
+  if (!prompt || prompt.trim().length === 0) {
+    return toFunctionDeclarations();
+  }
+
+  const promptLower = prompt.toLowerCase();
+  const promptTokens = tokenizer.segment(promptLower);
+  const promptTokenSet = new Set(promptTokens.map((t) => t.toLowerCase()));
+
+  const showAllTriggered = promptTokenSet.has("more") || promptTokenSet.has("全部") || promptTokenSet.has("所有") || promptLower.includes("更多工具") || promptLower.includes("show all") || promptLower.includes("all tools");
+
+  if (showAllTriggered) {
+    return toFunctionDeclarations();
+  }
+
+  const matched = new Set();
+
+  for (const [name, keywords] of _toolKeywordsCache) {
+    if (promptLower.includes(name)) {
+      matched.add(name);
+      continue;
+    }
+    for (const kw of keywords) {
+      const kwLower = kw.toLowerCase();
+      if (promptTokenSet.has(kwLower)) {
+        matched.add(name);
+        break;
+      }
+      if (promptLower.includes(kwLower)) {
+        matched.add(name);
+        break;
+      }
+    }
+  }
+
+  if (matched.size === 0) {
+    return toFunctionDeclarations();
+  }
+
+  const alwaysInclude = ["search_memory", "save_memory", "list_memory", "delete_memory", "search_history", "list_history_files", "browse_page", "browse_page_text", "compress_context", "forget_conversation", "restart_session", "todo_write"];
+  for (const name of alwaysInclude) {
+    if (toolRegistry[name]) matched.add(name);
+  }
+
+  const filtered = {};
+  for (const name of matched) {
+    if (toolRegistry[name]) filtered[name] = toolRegistry[name];
+  }
+
+  return _declarationsFrom(filtered);
+}
+
+/**
+ * 从给定的工具注册表子集生成 function_declarations
+ */
+function _declarationsFrom(registry) {
+  return Object.entries(registry).map(([key, tool]) => {
+    const properties = {};
+    const required = [];
+    if (tool.parameters) {
+      for (const [pn, pd] of Object.entries(tool.parameters)) {
+        properties[pn] = { type: pd.type, description: pd.description };
+        if (pd.required) required.push(pn);
+      }
+    }
+    return {
+      type: "function",
+      function: {
+        name: key,
+        description: tool.description || "",
+        parameters: { type: "object", properties, required },
+      },
+    };
+  });
+}
+
+// 覆盖 registerTool / saveToolToFile / deleteToolFile 以保持关键词缓存同步
+const _origRegisterTool = registerTool;
+registerTool = function (name, tool) {
+  _origRegisterTool(name, tool);
+  _toolKeywordsCache.set(name, _extractKeywords(name, (tool && tool.description) || ""));
+};
+
+const _origSaveToFile = saveToolToFile;
+saveToolToFile = function (name, code) {
+  const result = _origSaveToFile(name, code);
+  if (result && result.startsWith("[OK]")) _rebuildKeywords();
+  return result;
+};
+
+const _origDelToolFile = deleteToolFile;
+deleteToolFile = function (name) {
+  const result = _origDelToolFile(name);
+  if (result && result.startsWith("[OK]")) _rebuildKeywords();
+  return result;
+};
+
+function listToolNames() { return Object.keys(toolRegistry); }
+
+function showAllToolDeclarations() { return toFunctionDeclarations(); }
+
+module.exports = {
+  loadTools, getTool, executeTool, checkPermission, toFunctionDeclarations,
+  registerTool, unregisterTool, searchToolRegistry, listToolNames,
+  setPermissionCallback, setTrusted, addTrusted, removeTrusted,
+  saveToolToFile, deleteToolFile, listCustomTools,
+  filterToolDeclarations, showAllToolDeclarations, _declarationsFrom,
+  CUSTOM_DIR,
+};

package/Tools/search_tools.js

@@ -0,0 +1,280 @@
+const { execSync, spawn } = require("child_process");
+const https = require("https");
+const http = require("http");
+
+const execConsoleTool = {
+  name: "exec_console",
+  description: "执行终端命令并返回结果. 始终返回: exit code + stdout + stderr + 耗时",
+  dangerous: true,
+  parameters: {
+    command: { type: "string", required: true, description: "要执行的命令" },
+    cwd: { type: "string", required: false, description: "工作目录, 默认当前目录" },
+    timeout: { type: "number", required: false, description: "超时毫秒, 默认30000" },
+  },
+  execute: async ({ command, cwd, timeout }) => {
+    const cwdPath = cwd || process.cwd();
+    const start = Date.now();
+    try {
+      const output = execSync(command, {
+        cwd: cwdPath,
+        encoding: "utf-8",
+        timeout: timeout || 30000,
+        maxBuffer: 2 * 1024 * 1024,
+      });
+      const ms = Date.now() - start;
+      const out = output || "(无输出)";
+      return `[exit 0 | ${ms}ms | ${cwdPath}]\n${out.slice(0, 3500)}`;
+    } catch (e) {
+      const ms = Date.now() - start;
+      const code = e.status != null ? e.status : "?";
+      const stderr = (e.stderr || e.message || "").slice(0, 1500);
+      const stdout = (e.stdout || "").slice(0, 1000);
+      let result = `[exit ${code} | ${ms}ms | ${cwdPath}]\n`;
+      if (stderr) result += `[stderr]\n${stderr}\n`;
+      if (stdout) result += `[stdout]\n${stdout}`;
+      if (!stderr && !stdout) result += `执行失败: ${e.message}`;
+      return result.slice(0, 3500);
+    }
+  },
+};
+
+const waitCommandTool = {
+  name: "wait_command",
+  description: "执行长时间命令并返回结果. 返回: exit code + stdout + stderr + 耗时",
+  dangerous: true,
+  parameters: {
+    command: { type: "string", required: true, description: "要执行的命令" },
+    args: { type: "string", required: false, description: "命令参数(空格分隔), 可选" },
+    cwd: { type: "string", required: false, description: "工作目录" },
+    timeout: { type: "number", required: false, description: "超时毫秒, 默认60000" },
+  },
+  execute: async ({ command, args, cwd, timeout }) => {
+    const cwdPath = cwd || process.cwd();
+    const start = Date.now();
+    return new Promise((resolve) => {
+      const argList = args ? args.split(/\s+/) : [];
+      const child = spawn(command, argList, {
+        cwd: cwdPath,
+        shell: true,
+      });
+      let stdout = "";
+      let stderr = "";
+      child.stdout.on("data", (d) => (stdout += d.toString()));
+      child.stderr.on("data", (d) => (stderr += d.toString()));
+      const timer = setTimeout(() => {
+        child.kill("SIGTERM");
+        const ms = Date.now() - start;
+        resolve(`[timeout ${timeout || 60000}ms | ${ms}ms | ${cwdPath}]\n${stdout.slice(0, 1500)}${stderr ? "\n[stderr]\n" + stderr.slice(0, 500) : ""}`);
+      }, timeout || 60000);
+      child.on("close", (code) => {
+        clearTimeout(timer);
+        const ms = Date.now() - start;
+        let result = `[exit ${code} | ${ms}ms | ${cwdPath}]\n`;
+        if (stdout) result += stdout;
+        if (stderr) result += `\n[stderr]\n${stderr}`;
+        resolve(result.slice(0, 3500));
+      });
+      child.on("error", (e) => {
+        clearTimeout(timer);
+        const ms = Date.now() - start;
+        resolve(`[error | ${ms}ms | ${cwdPath}] ${e.message}`);
+      });
+    });
+  },
+};
+
+const webFetchTool = {
+  name: "web_fetch",
+  description: "获取URL的网页内容, 自动回退到真实浏览器绕过反爬",
+  parameters: {
+    url: { type: "string", required: true, description: "要抓取的URL" },
+    extractMode: { type: "string", required: false, description: "text/structure/links, 默认text" },
+  },
+  execute: async ({ url, extractMode }) => {
+    const httpResult = await new Promise((resolve) => {
+      const mod = url.startsWith("https") ? https : http;
+      const start = Date.now();
+      const req = mod.get(url, { headers: { "User-Agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 Chrome/131.0.0.0 Safari/537.36" } }, (res) => {
+        const sc = res.statusCode;
+        const ms = Date.now() - start;
+        if (sc >= 300 && sc < 400 && res.headers.location) {
+          resolve({ ok: false, msg: `[HTTP ${sc} 重定向 | ${ms}ms] -> ${res.headers.location}` });
+          return;
+        }
+        if (sc === 404) { resolve({ ok: false, msg: `[HTTP 404 Not Found | ${ms}ms]` }); return; }
+        if (sc === 403) { resolve({ ok: false, msg: `[HTTP 403 Forbidden | ${ms}ms]` }); return; }
+        if (sc >= 500) { resolve({ ok: false, msg: `[HTTP ${sc} Server Error | ${ms}ms]` }); return; }
+        if (sc !== 200) { resolve({ ok: false, msg: `[HTTP ${sc} | ${ms}ms]` }); return; }
+        let data = "";
+        res.on("data", (c) => (data += c.toString()));
+        res.on("end", () => {
+          const mode = extractMode || "text";
+          const prefix = `[HTTP 200 OK | ${ms}ms]\n`;
+          if (mode === "links") {
+            const links = data.match(/href=["']([^"']+)["']/gi) || [];
+            const urls = links.map((l) => l.replace(/href=["']/i, "").replace(/["']$/, "")).filter((u) => u.length > 1);
+            resolve({ ok: true, msg: prefix + `[${urls.length} 个链接]\n${urls.slice(0, 100).join("\n")}` });
+          } else if (mode === "structure") {
+            const title = (data.match(/<title[^>]*>([^<]+)<\/title>/i) || [])[1] || "(无标题)";
+            const h1s = (data.match(/<h1[^>]*>([^<]+)<\/h1>/gi) || []).map((h) => h.replace(/<\/?h1[^>]*>/gi, "").trim());
+            const h2s = (data.match(/<h2[^>]*>([^<]+)<\/h2>/gi) || []).map((h) => h.replace(/<\/?h2[^>]*>/gi, "").trim());
+            resolve({ ok: true, msg: prefix + `标题: ${title}\n--- h1 ---\n${h1s.join("\n")}\n--- h2 ---\n${h2s.join("\n")}` });
+          } else {
+            let text = data
+              .replace(/<script[\s\S]*?<\/script>/gi, "")
+              .replace(/<style[\s\S]*?<\/style>/gi, "")
+              .replace(/<[^>]+>/g, " ")
+              .replace(/&nbsp;/g, " ")
+              .replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&amp;/g, "&")
+              .replace(/\s+/g, " ").trim();
+            resolve({ ok: true, msg: prefix + text.slice(0, 3000) });
+          }
+        });
+      });
+      req.on("error", (e) => resolve({ ok: false, msg: `[抓取失败 | ${Date.now() - start}ms] ${e.message}` }));
+      req.setTimeout(15000, () => { req.destroy(); resolve({ ok: false, msg: "[超时 15s]" }); });
+    });
+
+    if (httpResult.ok) return httpResult.msg;
+
+    try {
+      const { browse_page: bp } = require("./browser");
+      const browserResult = await bp.execute({ url, extractLinks: extractMode === "links" });
+      return `[浏览器回退] ${httpResult.msg}\n\n${browserResult}`;
+    } catch (_) {
+      return httpResult.msg + "\n[提示] 可尝试用 browse_page 工具以真实浏览器打开";
+    }
+  },
+};
+
+const setTimerTool = {
+  name: "set_timer",
+  description: "设置定时器: 在指定秒数后通知AI. AI调用后可以继续其他工作, 时间到达时会收到通知. 用于轮询等待异步任务完成",
+  parameters: {
+    seconds: { type: "number", required: true, description: "延迟秒数, 范围1-300" },
+    message: { type: "string", required: false, description: "定时触发时的提示语, 如 '检查构建结果'" },
+  },
+  execute: async ({ seconds, message }) => {
+    const s = Math.max(1, Math.min(seconds || 5, 300));
+    return `[timer set | ${s}s] ${message || "定时器已设置"}`;
+  },
+};
+
+const searchMemoryTool = {
+  name: "search_memory",
+  description: "搜索本地记忆条目(关键词匹配)",
+  parameters: {
+    query: { type: "string", required: true, description: "搜索关键词" },
+    limit: { type: "number", required: false, description: "返回条数, 默认5" },
+  },
+  execute: () => { return "search_memory must be injected"; },
+};
+
+const saveMemoryTool = {
+  name: "save_memory",
+  description: "保存一条关键信息到记忆(每条不超过200字)",
+  parameters: {
+    content: { type: "string", required: true, description: "记忆内容" },
+    tags: { type: "string", required: false, description: "标签,逗号分隔" },
+  },
+  execute: () => { return "save_memory must be injected"; },
+};
+
+const listMemoryTool = {
+  name: "list_memory",
+  description: "列出所有记忆条目",
+  parameters: {
+    limit: { type: "number", required: false, description: "返回条数, 默认20" },
+  },
+  execute: () => { return "list_memory must be injected"; },
+};
+
+const deleteMemoryTool = {
+  name: "delete_memory",
+  description: "按ID删除一条记忆",
+  parameters: {
+    id: { type: "number", required: true, description: "记忆ID" },
+  },
+  execute: () => { return "delete_memory must be injected"; },
+};
+
+const searchHistoryTool = {
+  name: "search_history",
+  description: "搜索 mem/ 文件夹中的历史对话记录, 可以找到过去的对话内容",
+  parameters: {
+    query: { type: "string", required: true, description: "搜索关键词" },
+    limit: { type: "number", required: false, description: "返回条数, 默认10" },
+  },
+  execute: () => { return "search_history must be injected"; },
+};
+
+const listHistoryTool = {
+  name: "list_history_files",
+  description: "列出 mem/ 文件夹中的历史对话文件列表",
+  parameters: {},
+  execute: () => { return "list_history_files must be injected"; },
+};
+
+const compressContextTool = {
+  name: "compress_context",
+  description: "压缩当前上下文: 将历史对话摘要存入记忆并清空对话历史",
+  parameters: {},
+  execute: () => { return "compress_context must be injected"; },
+};
+
+const agentSelfInvokeTool = {
+  name: "agent_self_invoke",
+  description: "Agent自我递归调用: 将子任务交给另一个Clinn实例处理并返回结果",
+  dangerous: true,
+  parameters: {
+    task: { type: "string", required: true, description: "要交给子Agent的任务描述" },
+    context: { type: "string", required: false, description: "额外上下文" },
+  },
+  execute: () => { return "agent_self_invoke must be injected"; },
+};
+
+const saveToolTool = {
+  name: "save_tool",
+  description: "编写并持久化一个JS工具模块. 代码必须是完整的CommonJS模块, 导出工具对象. 下次启动自动加载. 模块格式: module.exports = { tool_a: { name, description, parameters, execute: async (args) => '...' }, tool_b: { ... } }",
+  dangerous: true,
+  parameters: {
+    name: { type: "string", required: true, description: "工具文件名(不含.js), 如 'my_utils'" },
+    code: { type: "string", required: true, description: "完整的JS模块代码, CommonJS格式, 导出工具对象" },
+  },
+  execute: () => { return "save_tool must be injected"; },
+};
+
+const deleteToolFileTool = {
+  name: "delete_tool_file",
+  description: "删除一个持久化工具文件并卸载其导出的所有工具",
+  dangerous: true,
+  parameters: {
+    name: { type: "string", required: true, description: "工具文件名(不含.js), 如 'my_utils'" },
+  },
+  execute: () => { return "delete_tool_file must be injected"; },
+};
+
+const listSavedToolsTool = {
+  name: "list_saved_tools",
+  description: "列出所有持久化保存的工具文件及其导出的工具名",
+  parameters: {},
+  execute: () => { return "list_saved_tools must be injected"; },
+};
+
+module.exports = {
+  exec_console: execConsoleTool,
+  wait_command: waitCommandTool,
+  web_fetch: webFetchTool,
+  set_timer: setTimerTool,
+  search_memory: searchMemoryTool,
+  save_memory: saveMemoryTool,
+  list_memory: listMemoryTool,
+  delete_memory: deleteMemoryTool,
+  search_history: searchHistoryTool,
+  list_history_files: listHistoryTool,
+  compress_context: compressContextTool,
+  agent_self_invoke: agentSelfInvokeTool,
+  save_tool: saveToolTool,
+  delete_tool_file: deleteToolFileTool,
+  list_saved_tools: listSavedToolsTool,
+};