@ghenya/clinn 0.7.0

package/Tools/extended_tools.js

@@ -0,0 +1,408 @@
+/**
+ * Trae IDE + Claude Hermes 风格扩展工具集
+ * 参考 Trae: TodoWrite / SearchCodebase / Glob / Grep / Read / WebSearch / WebFetch
+ *            SearchReplace / Write / DeleteFile / RunCommand / CheckCommandStatus
+ *            GetDiagnostics / OpenPreview / Skill
+ * 参考 Hermes: 同上 + 对话管理 / 技能调用
+ */
+const fs = require("fs");
+const path = require("path");
+const { execSync, spawn } = require("child_process");
+const https = require("https");
+const http = require("http");
+
+const todoWriteTool = {
+  name: "todo_write",
+  description: "创建和更新结构化任务列表, 追踪当前会话中所有任务进度. 每次变更都传完整列表",
+  parameters: {
+    todos: { type: "string", required: true, description: "JSON字符串, 格式: [{\"id\":\"1\",\"content\":\"任务描述\",\"status\":\"pending|in_progress|completed\",\"priority\":\"high|medium|low\"}], 最多10项" },
+  },
+  execute: async ({ todos }) => {
+    try {
+      const list = JSON.parse(todos);
+      if (!Array.isArray(list)) return "[失败] todos 必须是数组";
+      if (list.length > 10) return `[警告] 最多10项, 收到${list.length}项`;
+      const counts = { pending: 0, in_progress: 0, completed: 0 };
+      const lines = [];
+      for (const t of list) {
+        counts[t.status] = (counts[t.status] || 0) + 1;
+        const icon = t.status === "completed" ? "✓" : t.status === "in_progress" ? "▶" : "○";
+        lines.push(`  ${icon} [${t.id}] ${t.content}`);
+      }
+      return `[Todo | ${list.length}项 | ▶${counts.in_progress} ○${counts.pending} ✓${counts.completed}]\n${lines.join("\n")}`;
+    } catch (e) {
+      return `[失败] JSON解析错误: ${e.message}`;
+    }
+  },
+};
+
+const searchReplaceTool = {
+  name: "search_replace",
+  description: "搜索并替换文件内容(精确匹配). 比edit_lines更安全: 必须唯一匹配才能替换",
+  dangerous: true,
+  parameters: {
+    filePath: { type: "string", required: true, description: "要编辑的文件路径" },
+    oldStr: { type: "string", required: true, description: "要替换的原始文本块(必须与文件中完全一致)" },
+    newStr: { type: "string", required: true, description: "替换后的新文本块" },
+  },
+  execute: async ({ filePath, oldStr, newStr }) => {
+    if (!fs.existsSync(filePath)) return `[不存在] ${filePath}`;
+    const content = fs.readFileSync(filePath, "utf-8");
+    const idx = content.indexOf(oldStr);
+    if (idx === -1) return `[失败] 未找到匹配文本, 请用 read_file 确认文件内容`;
+    const secondIdx = content.indexOf(oldStr, idx + 1);
+    if (secondIdx !== -1) return `[失败] 匹配到多处(至少2处), 请提供更精确的上下文使其唯一`;
+    const newContent = content.slice(0, idx) + newStr + content.slice(idx + oldStr.length);
+    fs.writeFileSync(filePath, newContent, "utf-8");
+    const oldLines = oldStr.split("\n").length;
+    const newLines = newStr.split("\n").length;
+    return `[OK] 已替换 ${filePath}: ${oldLines}行 → ${newLines}行`;
+  },
+};
+
+const globTool = {
+  name: "glob",
+  description: "文件模式匹配: 支持 **/*.js / src/**/*.ts 等glob模式, 按修改时间排序",
+  parameters: {
+    pattern: { type: "string", required: true, description: "glob模式, 如 '**/*.js' 或 'src/**/*.test.ts'" },
+    dirPath: { type: "string", required: false, description: "搜索根目录, 默认当前目录" },
+  },
+  execute: async ({ pattern, dirPath }) => {
+    const root = dirPath || process.cwd();
+    if (!fs.existsSync(root)) return `[不存在] ${root}`;
+    try {
+      const cmd = `Get-ChildItem -Path "${root}" -Filter "${pattern.split("/").pop()}" -Recurse -File -ErrorAction SilentlyContinue | Where-Object { $_.FullName -notmatch 'node_modules|\\\\\.git\\\\' } | Select-Object -First 100 | ForEach-Object { $_.FullName }`;
+      const output = execSync(cmd, { cwd: root, encoding: "utf-8", timeout: 8000, maxBuffer: 1024 * 1024, shell: "powershell.exe" });
+      const files = output.trim().split("\r\n").filter(Boolean);
+      return files.length > 0 ? files.join("\n") : `[无匹配] ${pattern} 在 ${root}`;
+    } catch (e) {
+      return `[无匹配] ${pattern} 在 ${root}`;
+    }
+  },
+};
+
+const grepTool = {
+  name: "grep",
+  description: "正则搜索文件内容(ripgrep风格). 返回 文件路径:行号:内容",
+  parameters: {
+    pattern: { type: "string", required: true, description: "正则表达式" },
+    dirPath: { type: "string", required: false, description: "搜索目录, 默认当前目录" },
+    glob: { type: "string", required: false, description: "文件过滤glob, 如 '*.js'" },
+    headLimit: { type: "number", required: false, description: "结果上限, 默认50" },
+    ignoreCase: { type: "boolean", required: false, description: "忽略大小写, 默认true" },
+  },
+  execute: async ({ pattern, dirPath, glob, headLimit, ignoreCase }) => {
+    const root = dirPath || process.cwd();
+    if (!fs.existsSync(root)) return `[不存在] ${root}`;
+    const max = headLimit || 50;
+    const ic = ignoreCase !== false;
+    const globFilter = glob ? ` --include="${glob}"` : "";
+    const icFlag = ic ? " -i" : "";
+    try {
+      const cmd = `grep -rn${icFlag}${globFilter} -m ${max} "${pattern.replace(/"/g, '\\"')}" "${root}"`;
+      const output = execSync(cmd, { cwd: root, encoding: "utf-8", timeout: 15000, maxBuffer: 2 * 1024 * 1024 });
+      const lines = output.trim().split("\n").slice(0, max);
+      return lines.length > 0 ? lines.join("\n") : `[无匹配] "${pattern}" 在 ${root}`;
+    } catch (e) {
+      if (e.stdout) return e.stdout.trim().split("\n").slice(0, max).join("\n");
+      return `[无匹配] "${pattern}" 在 ${root}`;
+    }
+  },
+};
+
+const readTool = {
+  name: "read",
+  description: "读取文件内容(支持行范围). 比read_file更灵活: 可指定offset+limit",
+  parameters: {
+    filePath: { type: "string", required: true, description: "文件绝对路径" },
+    offset: { type: "number", required: false, description: "起始行号(1开始), 默认1" },
+    limit: { type: "number", required: false, description: "读取行数, 默认200" },
+  },
+  execute: async ({ filePath, offset, limit }) => {
+    if (!fs.existsSync(filePath)) return `[不存在] ${filePath}`;
+    const lines = fs.readFileSync(filePath, "utf-8").split("\n");
+    const s = (offset || 1) - 1;
+    const e = Math.min(lines.length, s + (limit || 200));
+    if (s >= lines.length) return `[越界] 行${offset || 1}, 文件共 ${lines.length} 行`;
+    return lines.slice(s, e).map((l, i) => `${s + i + 1}| ${l}`).join("\n") + (e < lines.length ? `\n(共${lines.length}行, 显示${s + 1}-${e})` : "");
+  },
+};
+
+const writeTool = {
+  name: "write",
+  description: "写入文件(创建或覆盖, 自动建父目录). 内容中 \\n 表示换行",
+  dangerous: true,
+  parameters: {
+    filePath: { type: "string", required: true, description: "文件绝对路径" },
+    content: { type: "string", required: true, description: "写入内容" },
+  },
+  execute: async ({ filePath, content }) => {
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(filePath, content, "utf-8");
+    return `[OK] 已写入 ${filePath} (${content.length} 字符, ${content.split("\n").length} 行)`;
+  },
+};
+
+const lsTool = {
+  name: "ls",
+  description: "列出目录内容, 按类型分组显示",
+  parameters: {
+    dirPath: { type: "string", required: false, description: "目录路径, 默认当前目录" },
+    ignore: { type: "string", required: false, description: "忽略的glob模式, JSON数组字符串, 如 '[\"node_modules\",\".git\"]'" },
+  },
+  execute: async ({ dirPath, ignore }) => {
+    const root = dirPath || process.cwd();
+    if (!fs.existsSync(root)) return `[不存在] ${root}`;
+    const ignoreList = ignore ? JSON.parse(ignore) : [];
+    const entries = fs.readdirSync(root, { withFileTypes: true })
+      .filter((e) => !ignoreList.some((p) => e.name.includes(p) || e.name === p));
+    const dirs = entries.filter((e) => e.isDirectory()).map((e) => `[DIR]  ${e.name}/`);
+    const files = entries.filter((e) => e.isFile()).map((e) => {
+      try { return `[FILE] ${e.name} (${fs.statSync(path.join(root, e.name)).size}B)`; }
+      catch (_) { return `[FILE] ${e.name}`; }
+    });
+    return `${root}\n${dirs.concat(files).join("\n") || "(空目录)"}`;
+  },
+};
+
+const treeTool = {
+  name: "tree",
+  description: "递归生成目录文件树(一次性看完整个项目结构, 不用逐目录 ls). 自动忽略 node_modules/.git 等",
+  parameters: {
+    dirPath: { type: "string", required: false, description: "根目录路径, 默认当前目录" },
+    maxDepth: { type: "number", required: false, description: "最大递归深度, 默认5, 最大8" },
+    ignore: { type: "string", required: false, description: "额外忽略的glob模式, JSON数组字符串, 如 '[\"dist\",\"*.log\"]'" },
+  },
+  execute: async ({ dirPath, maxDepth, ignore }) => {
+    const root = dirPath || process.cwd();
+    if (!fs.existsSync(root)) return `[不存在] ${root}`;
+    const maxD = Math.min(maxDepth || 5, 8);
+    const extraIgnore = ignore ? JSON.parse(ignore) : [];
+    const defaultIgnore = ["node_modules", ".git", ".svn", "__pycache__", ".DS_Store", "Thumbs.db", ".idea", ".vscode"];
+    const ignoreSet = new Set([...defaultIgnore, ...extraIgnore]);
+
+    function shouldIgnore(name) {
+      return ignoreSet.has(name) || extraIgnore.some((p) => {
+        if (p.includes("*")) {
+          const re = new RegExp("^" + p.replace(/\*/g, ".*").replace(/\?/g, ".") + "$");
+          return re.test(name);
+        }
+        return false;
+      });
+    }
+
+    function walk(dir, depth, prefix) {
+      if (depth > maxD) return "";
+      let result = "";
+      let entries;
+      try {
+        entries = fs.readdirSync(dir, { withFileTypes: true })
+          .filter((e) => !shouldIgnore(e.name));
+      } catch (_) {
+        return prefix + "(无权限)\n";
+      }
+      const dirs = entries.filter((e) => e.isDirectory()).sort((a, b) => a.name.localeCompare(b.name));
+      const files = entries.filter((e) => e.isFile()).sort((a, b) => a.name.localeCompare(b.name));
+      const all = [...dirs, ...files];
+      for (let i = 0; i < all.length; i++) {
+        const entry = all[i];
+        const isLast = i === all.length - 1;
+        const connector = isLast ? "└── " : "├── ";
+        const childPrefix = prefix + (isLast ? "    " : "│   ");
+        if (entry.isDirectory()) {
+          result += prefix + connector + entry.name + "/\n";
+          result += walk(path.join(dir, entry.name), depth + 1, childPrefix);
+        } else {
+          let size = "";
+          try { size = ` (${fs.statSync(path.join(dir, entry.name)).size}B)`; } catch (_) {}
+          result += prefix + connector + entry.name + size + "\n";
+        }
+      }
+      return result;
+    }
+
+    const rootName = path.basename(root) || root;
+    let output = rootName + "/\n";
+    output += walk(root, 1, "");
+    const lineCount = output.split("\n").filter(Boolean).length;
+    return output.trimEnd() + `\n\n${lineCount} 项 (深度≤${maxD})`;
+  },
+};
+
+const webSearchTool = {
+  name: "web_search",
+  description: "用Bing搜索互联网获取实时信息. 用于查文档/新闻/最新资料. 自动回退浏览器",
+  parameters: {
+    query: { type: "string", required: true, description: "搜索关键词" },
+    num: { type: "number", required: false, description: "结果数量, 默认5, 最多10" },
+  },
+  execute: async ({ query, num }) => {
+    const n = Math.min(num || 5, 10);
+
+    const bingSearch = async () => {
+      const bingUrl = `https://cn.bing.com/search?q=${encodeURIComponent(query)}&count=${n}`;
+      return new Promise((resolve) => {
+        const mod = bingUrl.startsWith("https") ? https : http;
+        const req = mod.get(bingUrl, {
+          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) => {
+          if (res.statusCode !== 200) { resolve(null); return; }
+          let d = "";
+          res.on("data", (c) => (d += c));
+          res.on("end", () => {
+            const lis = d.match(/<li class="b_algo"[^>]*>([\s\S]*?)<\/li>/g) || [];
+            const results = [];
+            for (let i = 0; i < Math.min(n, lis.length); i++) {
+              const titleM = lis[i].match(/<a[^>]*href="([^"]+)"[^>]*>([\s\S]*?)<\/a>/);
+              if (!titleM) continue;
+              const title = titleM[2].replace(/<[^>]+>/g, "").trim().slice(0, 120);
+              const urlFound = titleM[1];
+              const descM = lis[i].match(/<p[^>]*>([\s\S]*?)<\/p>/);
+              const desc = descM ? descM[1].replace(/<[^>]+>/g, "").replace(/&amp;/g, "&").replace(/&ensp;|&#0183;|&nbsp;/g, " ").replace(/\s+/g, " ").trim().slice(0, 200) : "";
+              results.push(`${i + 1}. ${title}${desc ? "\n   " + desc : ""}${urlFound ? "\n   " + urlFound : ""}`);
+            }
+            resolve(results.length > 0 ? `[Bing搜索: ${query}]\n${results.join("\n")}` : null);
+          });
+        });
+        req.on("error", () => resolve(null));
+        req.setTimeout(12000, () => { req.destroy(); resolve(null); });
+      });
+    };
+
+    const browserSearch = async () => {
+      try {
+        const { browse_page: bp } = require("./browser");
+        const raw = await bp.execute({
+          url: `https://cn.bing.com/search?q=${encodeURIComponent(query)}&count=${n}`,
+          waitMs: 1500,
+          extractLinks: false,
+        });
+        const lines = raw.split("\n").map(l => l.trim()).filter(l => l.length > 20);
+        const results = [];
+        for (const line of lines) {
+          if (results.length >= n) break;
+          if (line.includes("[浏览器") || line.includes("[HTTP")) continue;
+          results.push(`${results.length + 1}. ${line.slice(0, 200)}`);
+        }
+        if (results.length > 0) return `[浏览器搜索: ${query}]\n${results.join("\n")}`;
+      } catch (_) {}
+      return null;
+    };
+
+    const bingResult = await bingSearch();
+    if (bingResult) return bingResult;
+
+    const browserResult = await browserSearch();
+    if (browserResult) return browserResult;
+
+    return `[搜索: ${query}] 未获取到有效结果, 建议用 browse_page 直接搜索`;
+  },
+};
+
+const checkStatusTool = {
+  name: "check_command_status",
+  description: "检查之前启动的非阻塞命令的状态. 用于 dev server / watch 等长时间运行的命令",
+  parameters: {
+    commandId: { type: "string", required: false, description: "命令ID(exec_console返回的PID或标识)" },
+  },
+  execute: async ({ commandId }) => {
+    return `[提示] 当前无活跃后台命令. 如需检查进程: 用 exec_console 执行 tasklist / Get-Process 查询.`;
+  },
+};
+
+const openPreviewTool = {
+  name: "open_preview",
+  description: "尝试在浏览器中打开URL预览(如本地开发服务器)",
+  parameters: {
+    url: { type: "string", required: true, description: "预览URL, 如 http://localhost:3000" },
+  },
+  execute: async ({ url }) => {
+    try {
+      execSync(`start "${url}"`, { shell: true, timeout: 3000 });
+      return `[OK] 已在浏览器中打开 ${url}`;
+    } catch (_) {
+      return `[未打开] 无法启动浏览器, 请手动访问: ${url}`;
+    }
+  },
+};
+
+const getDiagnosticsTool = {
+  name: "get_diagnostics",
+  description: "获取当前项目的语言诊断信息(语法错误/类型错误等). 调用后自动运行 lint check",
+  parameters: {},
+  execute: async () => {
+    const cwd = process.cwd();
+    const results = [];
+    try {
+      const out = execSync("npx tsc --noEmit 2>&1 || echo ''", { cwd, encoding: "utf-8", timeout: 30000, maxBuffer: 512 * 1024 });
+      const errors = out.trim().split("\n").filter((l) => l.includes("error TS"));
+      if (errors.length > 0) results.push(`[TypeScript] ${errors.length} 个错误`);
+      results.push(...errors.slice(0, 20));
+    } catch (_) {}
+    try {
+      const out = execSync("npx eslint . --format compact 2>&1 || echo ''", { cwd, encoding: "utf-8", timeout: 30000, maxBuffer: 512 * 1024 });
+      const warns = out.trim().split("\n").filter((l) => l.includes("warning") || l.includes("error"));
+      if (warns.length > 0) results.push(`[ESLint] ${warns.length} 个问题`);
+      results.push(...warns.slice(0, 10));
+    } catch (_) {}
+    return results.length > 0 ? results.join("\n") : "[无诊断] 未发现 lint/类型错误, 或项目无 tsc/eslint 配置";
+  },
+};
+
+const skillTool = {
+  name: "skill",
+  description: "执行一个技能模块: 从 Skills/ 目录加载预定义的技能脚本. 技能是一组预置指令",
+  parameters: {
+    name: { type: "string", required: true, description: "技能名, 如 'code_review' / 'refactor' / 'test_gen'" },
+  },
+  execute: async ({ name }) => {
+    const skillDir = path.join(process.cwd(), "Skills");
+    if (!fs.existsSync(skillDir)) return `[无技能目录] ${skillDir} 不存在, 请创建 Skills/ 目录并放入 .js 脚本`;
+    const skillPath = path.join(skillDir, name + ".js");
+    if (!fs.existsSync(skillPath)) {
+      const available = fs.readdirSync(skillDir).filter((f) => f.endsWith(".js")).map((f) => f.replace(".js", ""));
+      return `[无此技能] ${name}\n可用技能: ${available.length > 0 ? available.join(", ") : "(空)"}`;
+    }
+    try {
+      const mod = require(skillPath);
+      return `[技能: ${name}]\n${mod.description || "(无描述)"}\n指令: ${mod.instructions || "(无指令)"}`;
+    } catch (e) {
+      return `[技能加载失败] ${e.message}`;
+    }
+  },
+};
+
+const forgetConversationTool = {
+  name: "forget_conversation",
+  description: "主动遗忘当前对话历史(清空上下文), 保留记忆条目. 上下文过长时主动调用以节省token",
+  parameters: {
+    keepSummary: { type: "boolean", required: false, description: "是否先自动生成摘要并保存到记忆, 默认true" },
+  },
+  execute: () => { return "forget_conversation must be injected"; },
+};
+
+const restartSessionTool = {
+  name: "restart_session",
+  description: "完全重置对话: 清空历史 + 清空记忆, 开始全新会话. 相当于重启对话",
+  parameters: {},
+  execute: () => { return "restart_session must be injected"; },
+};
+
+module.exports = {
+  todo_write: todoWriteTool,
+  search_replace: searchReplaceTool,
+  glob: globTool,
+  grep: grepTool,
+  read: readTool,
+  write: writeTool,
+  ls: lsTool,
+  tree: treeTool,
+  web_search: webSearchTool,
+  check_command_status: checkStatusTool,
+  open_preview: openPreviewTool,
+  get_diagnostics: getDiagnosticsTool,
+  skill: skillTool,
+  forget_conversation: forgetConversationTool,
+  restart_session: restartSessionTool,
+};

package/Tools/file_tools.js

@@ -0,0 +1,201 @@
+const fs = require("fs");
+const path = require("path");
+const { execSync } = require("child_process");
+
+const readFileTool = {
+  name: "read_file",
+  description: "读取指定路径的文件内容",
+  parameters: {
+    filePath: { type: "string", required: true, description: "文件路径" },
+  },
+  execute: async ({ filePath }) => {
+    if (!fs.existsSync(filePath)) return `[不存在] ${filePath}`;
+    return fs.readFileSync(filePath, "utf-8");
+  },
+};
+
+const writeFileTool = {
+  name: "write_file",
+  description: "创建或覆盖文件(自动创建父目录)",
+  dangerous: true,
+  parameters: {
+    filePath: { type: "string", required: true, description: "文件路径" },
+    content: { type: "string", required: true, description: "写入内容" },
+  },
+  execute: async ({ filePath, content }) => {
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(filePath, content, "utf-8");
+    return `[OK] 已写入 ${filePath} (${content.length} 字符)`;
+  },
+};
+
+const deleteFileTool = {
+  name: "delete_file",
+  description: "删除指定文件或空目录",
+  dangerous: true,
+  parameters: {
+    filePath: { type: "string", required: true, description: "要删除的文件或目录路径" },
+  },
+  execute: async ({ filePath }) => {
+    if (!fs.existsSync(filePath)) return `[不存在] ${filePath}`;
+    const stat = fs.statSync(filePath);
+    if (stat.isDirectory()) {
+      const entries = fs.readdirSync(filePath);
+      if (entries.length > 0) return `[失败] 目录非空, 包含 ${entries.length} 个条目, 拒绝删除`;
+      fs.rmdirSync(filePath);
+      return `[OK] 已删除空目录 ${filePath}`;
+    }
+    fs.unlinkSync(filePath);
+    return `[OK] 已删除 ${filePath}`;
+  },
+};
+
+const moveFileTool = {
+  name: "move_file",
+  description: "移动/重命名文件或目录",
+  dangerous: true,
+  parameters: {
+    source: { type: "string", required: true, description: "源路径" },
+    target: { type: "string", required: true, description: "目标路径" },
+  },
+  execute: async ({ source, target }) => {
+    if (!fs.existsSync(source)) return `[不存在] ${source}`;
+    const targetDir = path.dirname(target);
+    if (!fs.existsSync(targetDir)) fs.mkdirSync(targetDir, { recursive: true });
+    fs.renameSync(source, target);
+    return `[OK] ${source} -> ${target}`;
+  },
+};
+
+const copyFileTool = {
+  name: "copy_file",
+  description: "复制文件到目标路径",
+  dangerous: true,
+  parameters: {
+    source: { type: "string", required: true, description: "源文件路径" },
+    target: { type: "string", required: true, description: "目标路径" },
+  },
+  execute: async ({ source, target }) => {
+    if (!fs.existsSync(source)) return `[不存在] ${source}`;
+    const targetDir = path.dirname(target);
+    if (!fs.existsSync(targetDir)) fs.mkdirSync(targetDir, { recursive: true });
+    fs.copyFileSync(source, target);
+    return `[OK] 已复制 ${source} -> ${target}`;
+  },
+};
+
+const listDirTool = {
+  name: "list_dir",
+  description: "列出目录内容(支持递归)",
+  parameters: {
+    dirPath: { type: "string", required: true, description: "目录路径" },
+    recursive: { type: "boolean", required: false, description: "是否递归, 默认false" },
+  },
+  execute: async ({ dirPath, recursive }) => {
+    if (!fs.existsSync(dirPath)) return `[不存在] ${dirPath}`;
+    if (!recursive) {
+      const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+      return entries.map((e) => {
+        const mark = e.isDirectory() ? "[DIR]" : "[FILE]";
+        const size = e.isFile() ? ` ${fs.statSync(path.join(dirPath, e.name)).size}B` : "";
+        return `${mark} ${e.name}${size}`;
+      }).join("\n");
+    }
+    const lines = [];
+    function walk(dir, prefix) {
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+      for (const e of entries) {
+        const fp = path.join(dir, e.name);
+        if (e.isDirectory()) { lines.push(prefix + "[DIR]  " + e.name + "/"); walk(fp, prefix + "  "); }
+        else lines.push(prefix + "[FILE] " + e.name);
+      }
+    }
+    walk(dirPath, "");
+    return lines.join("\n");
+  },
+};
+
+const searchInFilesTool = {
+  name: "search_in_files",
+  description: "grep: 在目录中搜索内容, 返回 文件:行号:匹配行",
+  parameters: {
+    pattern: { type: "string", required: true, description: "搜索模式(纯文本或正则)" },
+    dirPath: { type: "string", required: true, description: "搜索目录" },
+    fileGlob: { type: "string", required: false, description: "文件过滤, 如 '*.js', 默认所有" },
+    maxResults: { type: "number", required: false, description: "最大结果数, 默认50" },
+    ignoreCase: { type: "boolean", required: false, description: "忽略大小写, 默认true" },
+  },
+  execute: async ({ pattern, dirPath, fileGlob, maxResults, ignoreCase }) => {
+    if (!fs.existsSync(dirPath)) return `[不存在] ${dirPath}`;
+    const max = maxResults || 50;
+    const ic = ignoreCase !== false;
+    try {
+      const cmd = `grep -rn ${ic ? "-i" : ""} --include="${fileGlob || "*"}" -m ${max} "${pattern.replace(/"/g, '\\"')}" "${dirPath}"`;
+      const output = execSync(cmd, { cwd: dirPath, encoding: "utf-8", timeout: 10000, maxBuffer: 1024 * 1024 });
+      const lines = output.trim().split("\n").slice(0, max);
+      return lines.length > 0 ? lines.join("\n") : `[无匹配] "${pattern}" 在 ${dirPath}`;
+    } catch (e) {
+      if (e.stdout) return e.stdout.trim().split("\n").slice(0, max).join("\n");
+      return `[无匹配] "${pattern}" 在 ${dirPath}`;
+    }
+  },
+};
+
+const findFilesTool = {
+  name: "find_files",
+  description: "按文件名模式查找文件(glob), 如 '*.js' 或 'test*.ts'",
+  parameters: {
+    pattern: { type: "string", required: true, description: "glob模式, 如 '*.js' 或 '**/*.test.js'" },
+    dirPath: { type: "string", required: true, description: "搜索起始目录" },
+    maxResults: { type: "number", required: false, description: "最大结果数, 默认100" },
+  },
+  execute: async ({ pattern, dirPath, maxResults }) => {
+    if (!fs.existsSync(dirPath)) return `[不存在] ${dirPath}`;
+    const max = maxResults || 100;
+    try {
+      const cmd = `find "${dirPath}" -name "${pattern}" -not -path '*/node_modules/*' -not -path '*/.git/*' | head -n ${max}`;
+      const output = execSync(cmd, { encoding: "utf-8", timeout: 5000, maxBuffer: 1024 * 1024 });
+      return output.trim() || `[无匹配] ${pattern} 在 ${dirPath}`;
+    } catch (e) {
+      if (e.stdout) return e.stdout.trim() || `[无匹配] ${pattern}`;
+      return `[无匹配] ${pattern} 在 ${dirPath}`;
+    }
+  },
+};
+
+const fileInfoTool = {
+  name: "file_info",
+  description: "获取文件元信息: 大小/修改时间/权限/行数",
+  parameters: {
+    filePath: { type: "string", required: true, description: "文件路径" },
+  },
+  execute: async ({ filePath }) => {
+    if (!fs.existsSync(filePath)) return `[不存在] ${filePath}`;
+    const stat = fs.statSync(filePath);
+    const ext = path.extname(filePath);
+    let lines = "?";
+    try { lines = fs.readFileSync(filePath, "utf-8").split("\n").length; } catch (_) {}
+    return [
+      `路径: ${filePath}`,
+      `类型: ${stat.isDirectory() ? "目录" : "文件"} (${ext || "无扩展名"})`,
+      `大小: ${stat.size} B (${(stat.size / 1024).toFixed(1)} KB)`,
+      `行数: ${lines}`,
+      `权限: ${stat.mode.toString(8).slice(-3)}`,
+      `修改: ${stat.mtime.toISOString()}`,
+      `创建: ${stat.birthtime.toISOString()}`,
+    ].join("\n");
+  },
+};
+
+module.exports = {
+  read_file: readFileTool,
+  write_file: writeFileTool,
+  delete_file: deleteFileTool,
+  move_file: moveFileTool,
+  copy_file: copyFileTool,
+  list_dir: listDirTool,
+  search_in_files: searchInFilesTool,
+  find_files: findFilesTool,
+  file_info: fileInfoTool,
+};