hypercore-cli 1.1.1 → 1.3.0

package/dist/chunk-OWAOKDIN.js

@@ -1,1505 +0,0 @@
-import {
-  addMemory,
-  searchMemories
-} from "./chunk-7ZYMJFCA.js";
-import {
-  applyPermissions
-} from "./chunk-GU2FZQ6A.js";
-import {
-  HYPERCORE_DIR
-} from "./chunk-SVF2VWOZ.js";
-import {
-  getTaskOutput,
-  spawnBackground
-} from "./chunk-TGTYKBGC.js";
-
-// src/mcp/client.ts
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
-import { existsSync } from "fs";
-import { readFile } from "fs/promises";
-import { join } from "path";
-var activeConnections = [];
-async function loadMCPConfig(hypercoreDir) {
-  const systemPath = join(hypercoreDir, "mcp.json");
-  const projectPath = join(process.cwd(), ".hypercore", "mcp.json");
-  let systemConfig = null;
-  let projectConfig = null;
-  if (existsSync(systemPath)) {
-    try {
-      systemConfig = JSON.parse(await readFile(systemPath, "utf-8"));
-    } catch {
-    }
-  }
-  if (projectPath !== systemPath && existsSync(projectPath)) {
-    try {
-      projectConfig = JSON.parse(await readFile(projectPath, "utf-8"));
-    } catch {
-    }
-  }
-  if (!systemConfig && !projectConfig) return null;
-  return {
-    mcpServers: {
-      ...systemConfig?.mcpServers || {},
-      ...projectConfig?.mcpServers || {}
-    }
-  };
-}
-async function connectServer(name, config) {
-  const transport = new StdioClientTransport({
-    command: config.command,
-    args: config.args || [],
-    env: { ...process.env, ...config.env || {} }
-  });
-  const client = new Client({
-    name: "hypercore",
-    version: "0.1.0"
-  });
-  try {
-    await client.connect(transport);
-    activeConnections.push({ name, client, transport });
-    const { tools } = await client.listTools();
-    const registeredTools = [];
-    for (const tool of tools) {
-      registeredTools.push({
-        definition: {
-          name: `mcp_${name}_${tool.name}`,
-          description: `[MCP:${name}] ${tool.description || tool.name}`,
-          input_schema: tool.inputSchema || { type: "object", properties: {} }
-        },
-        handler: async (input) => {
-          try {
-            const result = await client.callTool({
-              name: tool.name,
-              arguments: input
-            });
-            if (Array.isArray(result.content)) {
-              return result.content.map(
-                (c) => c.type === "text" ? c.text : JSON.stringify(c)
-              ).join("\n");
-            }
-            return JSON.stringify(result.content);
-          } catch (err) {
-            return `MCP \u8C03\u7528\u5931\u8D25: ${err instanceof Error ? err.message : String(err)}`;
-          }
-        }
-      });
-    }
-    return registeredTools;
-  } catch (err) {
-    console.error(`  \u26A0\uFE0F MCP Server "${name}" \u8FDE\u63A5\u5931\u8D25: ${err instanceof Error ? err.message : String(err)}`);
-    return [];
-  }
-}
-async function loadMCPTools(hypercoreDir) {
-  const config = await loadMCPConfig(hypercoreDir);
-  if (!config || !config.mcpServers) return [];
-  const allTools = [];
-  for (const [name, serverConfig] of Object.entries(config.mcpServers)) {
-    const tools = await connectServer(name, serverConfig);
-    allTools.push(...tools);
-  }
-  return allTools;
-}
-async function closeMCPConnections() {
-  for (const conn of activeConnections) {
-    try {
-      await conn.client.close();
-    } catch {
-    }
-  }
-  activeConnections.length = 0;
-}
-
-// src/tools/web-search.ts
-function createWebSearchTool(apiKey) {
-  return {
-    definition: {
-      name: "web_search",
-      description: "\u641C\u7D22\u4E92\u8054\u7F51\u83B7\u53D6\u6700\u65B0\u4FE1\u606F\u3002\u7528\u4E8E\u8C03\u7814\u3001\u67E5\u627E\u6570\u636E\u3001\u83B7\u53D6\u884C\u4E1A\u52A8\u6001\u7B49\u3002\u8FD4\u56DE\u641C\u7D22\u7ED3\u679C\u7684\u6458\u8981\u548C\u94FE\u63A5\u3002",
-      input_schema: {
-        type: "object",
-        properties: {
-          query: {
-            type: "string",
-            description: "\u641C\u7D22\u67E5\u8BE2\u8BCD"
-          },
-          max_results: {
-            type: "number",
-            description: "\u6700\u5927\u8FD4\u56DE\u7ED3\u679C\u6570\uFF08\u9ED8\u8BA45\uFF09"
-          }
-        },
-        required: ["query"]
-      }
-    },
-    handler: async (input) => {
-      const query = input.query;
-      const maxResults = input.max_results || 5;
-      try {
-        const response = await fetch("https://api.tavily.com/search", {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({
-            api_key: apiKey,
-            query,
-            max_results: maxResults,
-            include_answer: true
-          })
-        });
-        if (!response.ok) {
-          throw new Error(`Tavily API error: ${response.status}`);
-        }
-        const data = await response.json();
-        let output = "";
-        if (data.answer) {
-          output += `**AI\u6458\u8981\uFF1A** ${data.answer}
-
-`;
-        }
-        if (data.results) {
-          output += "**\u641C\u7D22\u7ED3\u679C\uFF1A**\n\n";
-          for (const result of data.results) {
-            output += `### ${result.title}
-`;
-            output += `${result.url}
-`;
-            output += `${result.content}
-
-`;
-          }
-        }
-        return output || "\u672A\u627E\u5230\u76F8\u5173\u7ED3\u679C";
-      } catch (err) {
-        return `\u641C\u7D22\u5931\u8D25: ${err instanceof Error ? err.message : String(err)}`;
-      }
-    }
-  };
-}
-
-// src/tools/file-ops.ts
-import { readFile as readFile2, writeFile, mkdir, stat } from "fs/promises";
-import { dirname, resolve, extname } from "path";
-var BINARY_EXTS = /* @__PURE__ */ new Set([
-  ".png",
-  ".jpg",
-  ".jpeg",
-  ".gif",
-  ".bmp",
-  ".webp",
-  ".ico",
-  ".svg",
-  ".mp4",
-  ".avi",
-  ".mov",
-  ".mkv",
-  ".webm",
-  ".flv",
-  ".mp3",
-  ".wav",
-  ".flac",
-  ".aac",
-  ".ogg",
-  ".zip",
-  ".tar",
-  ".gz",
-  ".bz2",
-  ".7z",
-  ".rar",
-  ".pdf",
-  ".doc",
-  ".docx",
-  ".xls",
-  ".xlsx",
-  ".ppt",
-  ".pptx",
-  ".exe",
-  ".dll",
-  ".so",
-  ".dylib",
-  ".bin",
-  ".woff",
-  ".woff2",
-  ".ttf",
-  ".otf",
-  ".eot"
-]);
-function resolvePath(p) {
-  return resolve(process.cwd(), p);
-}
-function formatSize(bytes) {
-  if (bytes < 1024) return `${bytes} B`;
-  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
-  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
-}
-function createFileReadTool() {
-  return {
-    definition: {
-      name: "file_read",
-      description: "\u8BFB\u53D6\u672C\u5730\u6587\u4EF6\u5185\u5BB9\u3002\u652F\u6301\u6587\u672C\u6587\u4EF6\u548C\u4E8C\u8FDB\u5236\u6587\u4EF6\u7684\u57FA\u672C\u4FE1\u606F\u67E5\u770B\u3002\u8DEF\u5F84\u53EF\u4EE5\u662F\u7EDD\u5BF9\u8DEF\u5F84\u6216\u76F8\u5BF9\u8DEF\u5F84\uFF08\u76F8\u5BF9\u4E8E\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55\uFF09\u3002",
-      input_schema: {
-        type: "object",
-        properties: {
-          path: {
-            type: "string",
-            description: "\u6587\u4EF6\u8DEF\u5F84\uFF08\u7EDD\u5BF9\u6216\u76F8\u5BF9\u4E8E\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55\uFF09"
-          },
-          encoding: {
-            type: "string",
-            description: "\u7F16\u7801\u683C\u5F0F\uFF0C\u9ED8\u8BA4 utf-8\u3002\u5BF9\u4E8C\u8FDB\u5236\u6587\u4EF6\u53EF\u7528 base64",
-            enum: ["utf-8", "base64"]
-          },
-          max_lines: {
-            type: "number",
-            description: "\u6700\u5927\u8BFB\u53D6\u884C\u6570\uFF08\u4EC5\u6587\u672C\u6587\u4EF6\u6709\u6548\uFF09\uFF0C0 \u8868\u793A\u5168\u90E8\u8BFB\u53D6"
-          }
-        },
-        required: ["path"]
-      }
-    },
-    handler: async (input) => {
-      const filePath = resolvePath(input.path);
-      const encoding = input.encoding || "utf-8";
-      const maxLines = input.max_lines || 0;
-      try {
-        const fileStat = await stat(filePath);
-        const ext = extname(filePath).toLowerCase();
-        const isBinary = BINARY_EXTS.has(ext);
-        const fileInfo = `[\u6587\u4EF6: ${filePath} | \u5927\u5C0F: ${formatSize(fileStat.size)} | \u4FEE\u6539\u65F6\u95F4: ${fileStat.mtime.toISOString()}]`;
-        if (isBinary && encoding !== "base64") {
-          return `${fileInfo}
-
-\u8FD9\u662F\u4E8C\u8FDB\u5236\u6587\u4EF6\uFF08${ext}\uFF09\uFF0C\u65E0\u6CD5\u4EE5\u6587\u672C\u5F62\u5F0F\u663E\u793A\u3002\u5982\u9700\u8BFB\u53D6\u539F\u59CB\u6570\u636E\uFF0C\u8BF7\u4F7F\u7528 encoding: "base64"\u3002
-\u5982\u9700\u5904\u7406\u6B64\u6587\u4EF6\uFF0C\u53EF\u4EE5\u7528 bash \u5DE5\u5177\u6267\u884C\u76F8\u5173\u547D\u4EE4\uFF08\u5982 file\u3001exiftool\u3001ffprobe \u7B49\uFF09\u3002`;
-        }
-        if (fileStat.size > 1024 * 1024 && encoding === "utf-8") {
-          const content2 = await readFile2(filePath, "utf-8");
-          const lines = content2.split("\n");
-          const limit = maxLines || 500;
-          const truncated = lines.slice(0, limit).join("\n");
-          return `${fileInfo}
-\u26A0\uFE0F \u5927\u6587\u4EF6\uFF0C\u4EC5\u663E\u793A\u524D ${limit} \u884C\uFF08\u5171 ${lines.length} \u884C\uFF09
-
-${truncated}`;
-        }
-        if (encoding === "base64") {
-          const buffer = await readFile2(filePath);
-          return `${fileInfo}
-
-[base64 \u7F16\u7801\uFF0C${formatSize(buffer.length)}]
-${buffer.toString("base64")}`;
-        }
-        let content = await readFile2(filePath, "utf-8");
-        if (maxLines > 0) {
-          const lines = content.split("\n");
-          if (lines.length > maxLines) {
-            content = lines.slice(0, maxLines).join("\n");
-            content += `
-
-... (\u622A\u65AD\uFF0C\u5171 ${lines.length} \u884C\uFF0C\u4EC5\u663E\u793A\u524D ${maxLines} \u884C)`;
-          }
-        }
-        return content;
-      } catch (err) {
-        return `\u8BFB\u53D6\u6587\u4EF6\u5931\u8D25: ${err instanceof Error ? err.message : String(err)}`;
-      }
-    }
-  };
-}
-function createFileWriteTool() {
-  return {
-    definition: {
-      name: "file_write",
-      description: "\u5199\u5165\u5185\u5BB9\u5230\u672C\u5730\u6587\u4EF6\u3002\u5982\u679C\u6587\u4EF6\u4E0D\u5B58\u5728\u4F1A\u81EA\u52A8\u521B\u5EFA\uFF0C\u5982\u679C\u76EE\u5F55\u4E0D\u5B58\u5728\u4E5F\u4F1A\u81EA\u52A8\u521B\u5EFA\u3002\u8DEF\u5F84\u53EF\u4EE5\u662F\u7EDD\u5BF9\u8DEF\u5F84\u6216\u76F8\u5BF9\u8DEF\u5F84\u3002",
-      input_schema: {
-        type: "object",
-        properties: {
-          path: {
-            type: "string",
-            description: "\u6587\u4EF6\u8DEF\u5F84\uFF08\u7EDD\u5BF9\u6216\u76F8\u5BF9\u4E8E\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55\uFF09"
-          },
-          content: {
-            type: "string",
-            description: "\u8981\u5199\u5165\u7684\u5185\u5BB9"
-          },
-          append: {
-            type: "boolean",
-            description: "\u662F\u5426\u8FFD\u52A0\u5199\u5165\uFF08\u9ED8\u8BA4 false\uFF0C\u8986\u76D6\u5199\u5165\uFF09"
-          }
-        },
-        required: ["path", "content"]
-      }
-    },
-    handler: async (input) => {
-      const filePath = resolvePath(input.path);
-      const content = input.content;
-      const append = input.append;
-      try {
-        await mkdir(dirname(filePath), { recursive: true });
-        if (append) {
-          const { appendFile } = await import("fs/promises");
-          await appendFile(filePath, content, "utf-8");
-          return `\u5185\u5BB9\u5DF2\u8FFD\u52A0\u5230: ${filePath}`;
-        }
-        await writeFile(filePath, content, "utf-8");
-        return `\u6587\u4EF6\u5DF2\u5199\u5165: ${filePath}`;
-      } catch (err) {
-        return `\u5199\u5165\u6587\u4EF6\u5931\u8D25: ${err instanceof Error ? err.message : String(err)}`;
-      }
-    }
-  };
-}
-
-// src/tools/bash.ts
-import { execSync } from "child_process";
-var DANGEROUS_PATTERNS = [
-  /\brm\s+-rf\s+\/\b/,
-  // rm -rf /
-  /\brm\s+-rf\s+~\b/,
-  // rm -rf ~
-  /\bsudo\b/,
-  // sudo
-  /\bmkfs\b/,
-  // mkfs
-  /\bdd\s+if=/,
-  // dd if=
-  /\b:\(\)\s*\{\s*:\|:\s*&\s*\};\s*:/,
-  // fork bomb
-  /\bshutdown\b/,
-  // shutdown
-  /\breboot\b/
-  // reboot
-];
-var MAX_OUTPUT = 512 * 1024;
-var TRUNCATE_AT = 5e4;
-var TIMEOUT_MS = 12e4;
-function smartTruncate(text, limit) {
-  if (text.length <= limit) return text;
-  const headSize = Math.floor(limit * 0.7);
-  const tailSize = limit - headSize - 200;
-  const head = text.slice(0, headSize);
-  const tail = text.slice(-tailSize);
-  const omitted = text.length - headSize - tailSize;
-  return `${head}
-
-... [\u7701\u7565 ${omitted} \u5B57\u7B26] ...
-
-${tail}`;
-}
-function createTaskOutputTool() {
-  return {
-    definition: {
-      name: "task_output",
-      description: "\u83B7\u53D6\u540E\u53F0\u4EFB\u52A1\u7684\u8F93\u51FA\u548C\u72B6\u6001\u3002\u4EFB\u52A1\u901A\u8FC7 bash \u5DE5\u5177\u7684 background=true \u542F\u52A8\u3002",
-      input_schema: {
-        type: "object",
-        properties: {
-          task_id: {
-            type: "string",
-            description: "\u540E\u53F0\u4EFB\u52A1 ID\uFF08\u5982 bg-001\uFF09"
-          }
-        },
-        required: ["task_id"]
-      }
-    },
-    handler: async (input) => {
-      const taskId = input.task_id;
-      const task = getTaskOutput(taskId);
-      if (!task) {
-        return `\u9519\u8BEF: \u4EFB\u52A1 ${taskId} \u4E0D\u5B58\u5728`;
-      }
-      const elapsed = ((Date.now() - task.startTime.getTime()) / 1e3).toFixed(1);
-      const parts = [
-        `\u4EFB\u52A1: ${task.id} [${task.status}]`,
-        `\u547D\u4EE4: ${task.command}`,
-        `\u8017\u65F6: ${elapsed}s`
-      ];
-      if (task.exitCode !== void 0) {
-        parts.push(`\u9000\u51FA\u7801: ${task.exitCode}`);
-      }
-      if (task.output) {
-        parts.push(`
---- stdout ---
-${smartTruncate(task.output, TRUNCATE_AT)}`);
-      }
-      if (task.error) {
-        parts.push(`
---- stderr ---
-${smartTruncate(task.error, 1e4)}`);
-      }
-      return parts.join("\n");
-    }
-  };
-}
-function createBashTool() {
-  return {
-    definition: {
-      name: "bash",
-      description: "\u6267\u884C shell \u547D\u4EE4\u5E76\u8FD4\u56DE\u8F93\u51FA\u7ED3\u679C\u3002\u53EF\u7528\u4E8E\u8FD0\u884C\u811A\u672C\u3001\u5B89\u88C5\u4F9D\u8D56\u3001\u67E5\u770B\u76EE\u5F55\u3001\u6267\u884C\u6784\u5EFA\u547D\u4EE4\u7B49\u3002\u8D85\u65F6 120 \u79D2\uFF08\u53EF\u81EA\u5B9A\u4E49\u81F3 5 \u5206\u949F\uFF09\uFF0C\u8D85\u957F\u8F93\u51FA\u81EA\u52A8\u622A\u65AD\u4FDD\u7559\u5934\u5C3E\u3002",
-      input_schema: {
-        type: "object",
-        properties: {
-          command: {
-            type: "string",
-            description: "\u8981\u6267\u884C\u7684 shell \u547D\u4EE4"
-          },
-          timeout: {
-            type: "number",
-            description: "\u8D85\u65F6\u65F6\u95F4\uFF08\u6BEB\u79D2\uFF09\uFF0C\u9ED8\u8BA4 120000\uFF0C\u6700\u5927 300000"
-          },
-          background: {
-            type: "boolean",
-            description: "\u8BBE\u4E3A true \u65F6\u540E\u53F0\u6267\u884C\uFF0C\u7ACB\u5373\u8FD4\u56DE\u4EFB\u52A1 ID\uFF0C\u7A0D\u540E\u7528 task_id \u67E5\u8BE2\u7ED3\u679C"
-          }
-        },
-        required: ["command"]
-      }
-    },
-    handler: async (input) => {
-      const command = input.command;
-      const timeout = Math.min(
-        input.timeout || TIMEOUT_MS,
-        3e5
-        // 最大 5 分钟
-      );
-      for (const pattern of DANGEROUS_PATTERNS) {
-        if (pattern.test(command)) {
-          return `\u26A0\uFE0F \u5B89\u5168\u9650\u5236\uFF1A\u8BE5\u547D\u4EE4\u88AB\u7981\u6B62\u6267\u884C (${command})`;
-        }
-      }
-      if (input.background) {
-        const task = spawnBackground(command);
-        return `\u{1F504} \u540E\u53F0\u4EFB\u52A1\u5DF2\u542F\u52A8: ${task.id} (PID: ${task.pid})
-\u4F7F\u7528 task_output \u5DE5\u5177\u67E5\u8BE2\u7ED3\u679C`;
-      }
-      try {
-        const output = execSync(command, {
-          timeout,
-          maxBuffer: MAX_OUTPUT,
-          encoding: "utf-8",
-          cwd: process.cwd(),
-          stdio: ["pipe", "pipe", "pipe"]
-        });
-        return smartTruncate(output, TRUNCATE_AT) || "(\u547D\u4EE4\u6267\u884C\u6210\u529F\uFF0C\u65E0\u8F93\u51FA)";
-      } catch (err) {
-        const execErr = err;
-        if (execErr.killed) {
-          return `\u23F1\uFE0F \u547D\u4EE4\u8D85\u65F6\uFF08\u8D85\u8FC7 ${timeout / 1e3} \u79D2\uFF09`;
-        }
-        const parts = [];
-        if (execErr.stdout) parts.push(execErr.stdout);
-        if (execErr.stderr) parts.push(execErr.stderr);
-        if (parts.length === 0) {
-          parts.push(`\u547D\u4EE4\u6267\u884C\u5931\u8D25: exit code ${execErr.status ?? "unknown"}`);
-        }
-        return smartTruncate(parts.join("\n"), TRUNCATE_AT);
-      }
-    }
-  };
-}
-
-// src/tools/file-edit.ts
-import { readFile as readFile3, writeFile as writeFile2, mkdir as mkdir2 } from "fs/promises";
-import { dirname as dirname2 } from "path";
-import { resolve as resolve2 } from "path";
-
-// src/utils/diff.ts
-function generateUnifiedDiff(oldText, newText, filename) {
-  const oldLines = oldText.split("\n");
-  const newLines = newText.split("\n");
-  let prefixLen = 0;
-  while (prefixLen < oldLines.length && prefixLen < newLines.length && oldLines[prefixLen] === newLines[prefixLen]) {
-    prefixLen++;
-  }
-  let oldSuffixStart = oldLines.length;
-  let newSuffixStart = newLines.length;
-  while (oldSuffixStart > prefixLen && newSuffixStart > prefixLen && oldLines[oldSuffixStart - 1] === newLines[newSuffixStart - 1]) {
-    oldSuffixStart--;
-    newSuffixStart--;
-  }
-  if (prefixLen === oldLines.length && prefixLen === newLines.length) {
-    return "";
-  }
-  const ctx = 3;
-  const ctxBefore = Math.min(ctx, prefixLen);
-  const oldChangedCount = oldSuffixStart - prefixLen;
-  const newChangedCount = newSuffixStart - prefixLen;
-  const ctxAfter = Math.min(ctx, oldLines.length - oldSuffixStart);
-  const hunkOldStart = prefixLen - ctxBefore + 1;
-  const hunkNewStart = prefixLen - ctxBefore + 1;
-  const hunkOldLen = ctxBefore + oldChangedCount + ctxAfter;
-  const hunkNewLen = ctxBefore + newChangedCount + ctxAfter;
-  const lines = [];
-  lines.push(`--- a/${filename}`);
-  lines.push(`+++ b/${filename}`);
-  lines.push(`@@ -${hunkOldStart},${hunkOldLen} +${hunkNewStart},${hunkNewLen} @@`);
-  for (let i = prefixLen - ctxBefore; i < prefixLen; i++) {
-    lines.push(` ${oldLines[i]}`);
-  }
-  for (let i = prefixLen; i < oldSuffixStart; i++) {
-    lines.push(`-${oldLines[i]}`);
-  }
-  for (let i = prefixLen; i < newSuffixStart; i++) {
-    lines.push(`+${newLines[i]}`);
-  }
-  for (let i = oldSuffixStart; i < oldSuffixStart + ctxAfter; i++) {
-    lines.push(` ${oldLines[i]}`);
-  }
-  if (!oldText.endsWith("\n") || !newText.endsWith("\n")) {
-    lines.push("\");
-  }
-  return lines.join("\n");
-}
-
-// src/tools/file-edit.ts
-function createFileEditTool() {
-  return {
-    definition: {
-      name: "file_edit",
-      description: "\u7CBE\u786E\u7F16\u8F91\u6587\u4EF6\uFF1A\u901A\u8FC7\u5339\u914D\u65E7\u6587\u672C\u66FF\u6362\u4E3A\u65B0\u6587\u672C\u3002\u6BD4 file_write \u66F4\u5B89\u5168\uFF0C\u53EA\u4FEE\u6539\u76EE\u6807\u90E8\u5206\u3002",
-      input_schema: {
-        type: "object",
-        properties: {
-          path: {
-            type: "string",
-            description: "\u8981\u7F16\u8F91\u7684\u6587\u4EF6\u8DEF\u5F84\uFF08\u7EDD\u5BF9\u6216\u76F8\u5BF9\u4E8E\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55\uFF09"
-          },
-          edits: {
-            type: "array",
-            items: {
-              type: "object",
-              properties: {
-                old_text: {
-                  type: "string",
-                  description: "\u8981\u66FF\u6362\u7684\u539F\u59CB\u6587\u672C\uFF08\u5FC5\u987B\u7CBE\u786E\u5339\u914D\uFF0C\u5305\u542B\u7F29\u8FDB\u548C\u7A7A\u767D\uFF09"
-                },
-                new_text: {
-                  type: "string",
-                  description: "\u66FF\u6362\u540E\u7684\u6587\u672C"
-                }
-              },
-              required: ["old_text", "new_text"]
-            },
-            description: "\u7F16\u8F91\u64CD\u4F5C\u5217\u8868\uFF0C\u6309\u987A\u5E8F\u6267\u884C"
-          },
-          create_if_missing: {
-            type: "boolean",
-            description: "\u5982\u679C\u6587\u4EF6\u4E0D\u5B58\u5728\u662F\u5426\u521B\u5EFA\uFF08\u6B64\u65F6 edits \u4E2D\u7B2C\u4E00\u9879\u7684 new_text \u4E3A\u5168\u90E8\u5185\u5BB9\uFF09"
-          }
-        },
-        required: ["path", "edits"]
-      }
-    },
-    handler: async (input) => {
-      const filePath = resolve2(process.cwd(), input.path);
-      const edits = input.edits;
-      const createIfMissing = input.create_if_missing;
-      if (!edits || edits.length === 0) {
-        return "\u9519\u8BEF: edits \u4E0D\u80FD\u4E3A\u7A7A";
-      }
-      let content;
-      try {
-        content = await readFile3(filePath, "utf-8");
-      } catch (err) {
-        if (createIfMissing && edits.length > 0) {
-          await mkdir2(dirname2(filePath), { recursive: true });
-          await writeFile2(filePath, edits[0].new_text, "utf-8");
-          return `\u2705 \u5DF2\u521B\u5EFA\u6587\u4EF6: ${filePath}
-\u5199\u5165 ${edits[0].new_text.split("\n").length} \u884C`;
-        }
-        return `\u9519\u8BEF: \u65E0\u6CD5\u8BFB\u53D6\u6587\u4EF6 ${filePath} \u2014 ${err instanceof Error ? err.message : String(err)}`;
-      }
-      const changes = [];
-      let modified = content;
-      for (let i = 0; i < edits.length; i++) {
-        const { old_text, new_text } = edits[i];
-        if (!old_text && !new_text) continue;
-        if (!old_text) {
-          modified += new_text;
-          changes.push(`#${i + 1}: \u8FFD\u52A0 ${new_text.split("\n").length} \u884C`);
-          continue;
-        }
-        const idx = modified.indexOf(old_text);
-        if (idx === -1) {
-          const normalizedContent = modified.replace(/[ \t]+$/gm, "");
-          const normalizedOld = old_text.replace(/[ \t]+$/gm, "");
-          const normalizedIdx = normalizedContent.indexOf(normalizedOld);
-          if (normalizedIdx === -1) {
-            changes.push(`#${i + 1}: \u26A0\uFE0F \u672A\u627E\u5230\u5339\u914D\u6587\u672C\uFF08\u524D 40 \u5B57\u7B26: "${old_text.slice(0, 40)}..."\uFF09`);
-            continue;
-          }
-          const beforeNormalized = normalizedContent.slice(0, normalizedIdx);
-          const originalLines = beforeNormalized.split("\n").length;
-          const oldLines = normalizedOld.split("\n").length;
-          const lines = modified.split("\n");
-          const startLine = originalLines - 1;
-          const endLine = startLine + oldLines;
-          const newLines = new_text.split("\n");
-          lines.splice(startLine, oldLines, ...newLines);
-          modified = lines.join("\n");
-          const diffLines = newLines.length - oldLines;
-          changes.push(`#${i + 1}: \u884C ${startLine + 1}-${endLine} \u2192 ${diffLines >= 0 ? "+" : ""}${diffLines} \u884C\uFF08\u6A21\u7CCA\u5339\u914D\uFF09`);
-        } else {
-          const matchCount = modified.split(old_text).length - 1;
-          if (matchCount > 1) {
-            changes.push(`#${i + 1}: \u26A0\uFE0F \u627E\u5230 ${matchCount} \u5904\u5339\u914D\uFF0C\u53EA\u66FF\u6362\u7B2C\u4E00\u5904`);
-          }
-          modified = modified.slice(0, idx) + new_text + modified.slice(idx + old_text.length);
-          const lineNum = modified.slice(0, idx).split("\n").length;
-          const removedLines = old_text.split("\n").length;
-          const addedLines = new_text.split("\n").length;
-          changes.push(`#${i + 1}: \u884C ${lineNum} \u2014 ${removedLines} \u884C \u2192 ${addedLines} \u884C`);
-        }
-      }
-      if (modified !== content) {
-        await writeFile2(filePath, modified, "utf-8");
-        const diff = generateUnifiedDiff(content, modified, input.path);
-        const diffSection = diff ? `
-
-${diff}` : "";
-        return `\u2705 \u5DF2\u7F16\u8F91: ${filePath}
-${changes.join("\n")}${diffSection}`;
-      } else {
-        return `\u2139\uFE0F \u6587\u4EF6\u672A\u6539\u53D8: ${filePath}
-${changes.join("\n")}`;
-      }
-    }
-  };
-}
-
-// src/tools/glob.ts
-import { readdir, stat as stat2 } from "fs/promises";
-import { join as join3, resolve as resolve4, relative as relative2 } from "path";
-
-// src/core/context-filter.ts
-import { existsSync as existsSync2, readFileSync, statSync } from "fs";
-import { join as join2, relative, resolve as resolve3 } from "path";
-var cachedPatterns = null;
-var cacheKey = "";
-function loadIgnorePatterns() {
-  const cwd = process.cwd();
-  const files = [
-    join2(cwd, ".hyperignore"),
-    join2(HYPERCORE_DIR, ".hyperignore")
-  ];
-  let mtimeSum = 0;
-  for (const file of files) {
-    if (existsSync2(file)) {
-      try {
-        mtimeSum += statSync(file).mtimeMs;
-      } catch {
-      }
-    }
-  }
-  const key = `${cwd}:${mtimeSum}`;
-  if (cachedPatterns && cacheKey === key) return cachedPatterns;
-  const patterns = [];
-  for (const file of files) {
-    if (existsSync2(file)) {
-      try {
-        const content = readFileSync(file, "utf-8");
-        for (const line of content.split("\n")) {
-          const trimmed = line.trim();
-          if (trimmed && !trimmed.startsWith("#")) {
-            patterns.push(trimmed);
-          }
-        }
-      } catch {
-      }
-    }
-  }
-  cachedPatterns = patterns;
-  cacheKey = key;
-  return patterns;
-}
-function shouldIgnore(filePath) {
-  const patterns = loadIgnorePatterns();
-  if (patterns.length === 0) return false;
-  const cwd = process.cwd();
-  const relPath = relative(cwd, resolve3(cwd, filePath));
-  for (const pattern of patterns) {
-    if (pattern.endsWith("/")) {
-      const dir = pattern.slice(0, -1);
-      if (relPath.startsWith(dir + "/") || relPath === dir) return true;
-      if (relPath.includes("/" + dir + "/")) return true;
-    } else if (pattern.startsWith("*.")) {
-      const ext = pattern.slice(1);
-      if (relPath.endsWith(ext)) return true;
-    } else {
-      if (relPath === pattern || relPath.endsWith("/" + pattern)) return true;
-      if (relPath.startsWith(pattern + "/")) return true;
-    }
-  }
-  return false;
-}
-
-// src/tools/glob.ts
-function matchGlob(pattern, filePath) {
-  let regex = pattern.replace(/\./g, "\\.").replace(/\*\*/g, "\xA7GLOBSTAR\xA7").replace(/\*/g, "[^/]*").replace(/§GLOBSTAR§/g, ".*").replace(/\?/g, "[^/]");
-  regex = `^${regex}$`;
-  return new RegExp(regex).test(filePath);
-}
-async function walkDir(dir, basePath, pattern, results, maxResults, ignorePatterns) {
-  if (results.length >= maxResults) return;
-  let entries;
-  try {
-    entries = await readdir(dir, { withFileTypes: true });
-  } catch {
-    return;
-  }
-  for (const entry of entries) {
-    if (results.length >= maxResults) return;
-    const fullPath = join3(dir, entry.name);
-    const relPath = relative2(basePath, fullPath);
-    if (entry.name.startsWith(".") && entry.name !== ".") continue;
-    if (ignorePatterns.some((p) => entry.name === p || relPath.includes(p))) continue;
-    if (entry.isDirectory()) {
-      await walkDir(fullPath, basePath, pattern, results, maxResults, ignorePatterns);
-    } else if (entry.isFile()) {
-      if (shouldIgnore(relPath)) continue;
-      if (matchGlob(pattern, relPath)) {
-        try {
-          const info = await stat2(fullPath);
-          results.push({ path: relPath, mtime: info.mtimeMs });
-        } catch {
-          results.push({ path: relPath, mtime: 0 });
-        }
-      }
-    }
-  }
-}
-function createGlobTool() {
-  return {
-    definition: {
-      name: "glob",
-      description: "\u6587\u4EF6\u6A21\u5F0F\u5339\u914D\u641C\u7D22\u3002\u652F\u6301 **/*.ts\u3001src/**/*.js \u7B49 glob \u6A21\u5F0F\u3002\u8FD4\u56DE\u5339\u914D\u7684\u6587\u4EF6\u8DEF\u5F84\u5217\u8868\uFF0C\u6309\u4FEE\u6539\u65F6\u95F4\u6392\u5E8F\u3002",
-      input_schema: {
-        type: "object",
-        properties: {
-          pattern: {
-            type: "string",
-            description: 'Glob \u6A21\u5F0F\uFF0C\u5982 "**/*.ts"\u3001"src/**/*.js"\u3001"*.md"'
-          },
-          path: {
-            type: "string",
-            description: "\u641C\u7D22\u6839\u76EE\u5F55\uFF08\u9ED8\u8BA4\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55\uFF09"
-          },
-          max_results: {
-            type: "number",
-            description: "\u6700\u5927\u8FD4\u56DE\u6570\u91CF\uFF08\u9ED8\u8BA4 200\uFF09"
-          }
-        },
-        required: ["pattern"]
-      }
-    },
-    handler: async (input) => {
-      const pattern = input.pattern;
-      const basePath = resolve4(process.cwd(), input.path || ".");
-      const maxResults = input.max_results || 200;
-      const ignorePatterns = [
-        "node_modules",
-        "dist",
-        "build",
-        ".git",
-        ".next",
-        "__pycache__",
-        ".cache",
-        "coverage",
-        ".turbo"
-      ];
-      const results = [];
-      await walkDir(basePath, basePath, pattern, results, maxResults, ignorePatterns);
-      results.sort((a, b) => b.mtime - a.mtime);
-      if (results.length === 0) {
-        return `\u672A\u627E\u5230\u5339\u914D "${pattern}" \u7684\u6587\u4EF6\uFF08\u641C\u7D22\u76EE\u5F55: ${basePath}\uFF09`;
-      }
-      const pathList = results.map((r) => r.path).join("\n");
-      return `\u627E\u5230 ${results.length} \u4E2A\u6587\u4EF6\uFF08\u5339\u914D: ${pattern}\uFF09\uFF1A
-${pathList}`;
-    }
-  };
-}
-
-// src/tools/grep.ts
-import { execFileSync, execSync as execSync2 } from "child_process";
-import { existsSync as existsSync3 } from "fs";
-import { readdir as readdir2, readFile as readFile4, stat as stat3 } from "fs/promises";
-import { join as join4, resolve as resolve5, relative as relative3 } from "path";
-function hasRipgrep() {
-  try {
-    execSync2("rg --version", { stdio: "pipe" });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function rgSearch(opts) {
-  const args = [];
-  if (opts.outputMode === "files_with_matches") args.push("-l");
-  else if (opts.outputMode === "count") args.push("-c");
-  else args.push("-n");
-  if (opts.caseInsensitive) args.push("-i");
-  if (opts.context && opts.outputMode === "content") args.push(`-C${opts.context}`);
-  if (opts.glob) args.push(`--glob=${opts.glob}`);
-  args.push(`--max-count=${opts.maxResults}`);
-  args.push("--no-heading");
-  const cwd = process.cwd();
-  const hyperignorePath = join4(cwd, ".hyperignore");
-  if (existsSync3(hyperignorePath)) {
-    args.push(`--ignore-file=${hyperignorePath}`);
-  }
-  const globalIgnore = join4(HYPERCORE_DIR, ".hyperignore");
-  if (existsSync3(globalIgnore)) {
-    args.push(`--ignore-file=${globalIgnore}`);
-  }
-  args.push("--", opts.pattern, opts.path);
-  try {
-    const result = execFileSync("rg", args, {
-      encoding: "utf-8",
-      maxBuffer: 1024 * 1024,
-      // 1MB
-      timeout: 3e4
-    });
-    return result.trim();
-  } catch (err) {
-    const error = err;
-    if (error.status === 1) return "";
-    throw err;
-  }
-}
-async function nodeSearch(opts) {
-  const regex = new RegExp(opts.pattern, opts.caseInsensitive ? "gi" : "g");
-  const results = [];
-  const basePath = opts.path;
-  const ignorePatterns = [
-    "node_modules",
-    "dist",
-    "build",
-    ".git",
-    ".next",
-    "__pycache__",
-    ".cache",
-    "coverage"
-  ];
-  async function walk(dir) {
-    if (results.length >= opts.maxResults) return;
-    let entries;
-    try {
-      entries = await readdir2(dir, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    for (const entry of entries) {
-      if (results.length >= opts.maxResults) return;
-      if (entry.name.startsWith(".") && entry.name !== ".") continue;
-      if (ignorePatterns.includes(entry.name)) continue;
-      const fullPath = join4(dir, entry.name);
-      if (entry.isDirectory()) {
-        await walk(fullPath);
-      } else if (entry.isFile()) {
-        const relCheck = relative3(basePath, fullPath);
-        if (shouldIgnore(relCheck)) continue;
-        if (opts.glob) {
-          const ext = opts.glob.replace("*.", ".");
-          if (!entry.name.endsWith(ext)) continue;
-        }
-        try {
-          const info = await stat3(fullPath);
-          if (info.size > 512 * 1024) continue;
-          const content = await readFile4(fullPath, "utf-8");
-          const relPath = relative3(basePath, fullPath);
-          if (opts.outputMode === "files_with_matches") {
-            if (regex.test(content)) {
-              results.push(relPath);
-              regex.lastIndex = 0;
-            }
-          } else if (opts.outputMode === "count") {
-            const matches = content.match(regex);
-            if (matches) results.push(`${relPath}:${matches.length}`);
-          } else {
-            const lines = content.split("\n");
-            for (let i = 0; i < lines.length; i++) {
-              if (results.length >= opts.maxResults) break;
-              regex.lastIndex = 0;
-              if (regex.test(lines[i])) {
-                results.push(`${relPath}:${i + 1}:${lines[i]}`);
-              }
-            }
-          }
-        } catch {
-        }
-      }
-    }
-  }
-  await walk(basePath);
-  return results.join("\n");
-}
-function createGrepTool() {
-  const useRg = hasRipgrep();
-  return {
-    definition: {
-      name: "grep",
-      description: `\u5185\u5BB9\u641C\u7D22\u5DE5\u5177${useRg ? "\uFF08ripgrep \u9A71\u52A8\uFF09" : ""}\u3002\u4F7F\u7528\u6B63\u5219\u8868\u8FBE\u5F0F\u5728\u6587\u4EF6\u4E2D\u641C\u7D22\u5185\u5BB9\u3002`,
-      input_schema: {
-        type: "object",
-        properties: {
-          pattern: {
-            type: "string",
-            description: "\u641C\u7D22\u6B63\u5219\u8868\u8FBE\u5F0F\u6A21\u5F0F"
-          },
-          path: {
-            type: "string",
-            description: "\u641C\u7D22\u76EE\u5F55\u6216\u6587\u4EF6\uFF08\u9ED8\u8BA4\u5F53\u524D\u5DE5\u4F5C\u76EE\u5F55\uFF09"
-          },
-          glob: {
-            type: "string",
-            description: '\u6587\u4EF6\u8FC7\u6EE4 glob \u6A21\u5F0F\uFF08\u5982 "*.ts"\u3001"*.{js,jsx}"\uFF09'
-          },
-          output_mode: {
-            type: "string",
-            enum: ["content", "files_with_matches", "count"],
-            description: "\u8F93\u51FA\u6A21\u5F0F: content=\u5339\u914D\u884C\u5185\u5BB9, files_with_matches=\u5339\u914D\u6587\u4EF6\u8DEF\u5F84, count=\u5339\u914D\u8BA1\u6570\u3002\u9ED8\u8BA4 files_with_matches"
-          },
-          context: {
-            type: "number",
-            description: "\u4E0A\u4E0B\u6587\u884C\u6570\uFF08content \u6A21\u5F0F\u6709\u6548\uFF09"
-          },
-          case_insensitive: {
-            type: "boolean",
-            description: "\u662F\u5426\u5FFD\u7565\u5927\u5C0F\u5199"
-          },
-          max_results: {
-            type: "number",
-            description: "\u6700\u5927\u7ED3\u679C\u6570\uFF08\u9ED8\u8BA4 100\uFF09"
-          }
-        },
-        required: ["pattern"]
-      }
-    },
-    handler: async (input) => {
-      const pattern = input.pattern;
-      const searchPath = resolve5(process.cwd(), input.path || ".");
-      const glob = input.glob;
-      const outputMode = input.output_mode || "files_with_matches";
-      const context = input.context;
-      const caseInsensitive = input.case_insensitive;
-      const maxResults = input.max_results || 100;
-      try {
-        let result;
-        if (useRg) {
-          result = rgSearch({ pattern, path: searchPath, glob, outputMode, context, caseInsensitive, maxResults });
-        } else {
-          result = await nodeSearch({ pattern, path: searchPath, glob, outputMode, context, caseInsensitive, maxResults });
-        }
-        if (!result) {
-          return `\u672A\u627E\u5230\u5339\u914D "${pattern}" \u7684\u5185\u5BB9\uFF08\u641C\u7D22: ${searchPath}\uFF09`;
-        }
-        const lines = result.split("\n");
-        if (lines.length > maxResults) {
-          return `\u627E\u5230 ${lines.length}+ \u4E2A\u7ED3\u679C\uFF08\u663E\u793A\u524D ${maxResults} \u4E2A\uFF09\uFF1A
-${lines.slice(0, maxResults).join("\n")}`;
-        }
-        return `\u627E\u5230 ${lines.length} \u4E2A\u7ED3\u679C\uFF1A
-${result}`;
-      } catch (err) {
-        return `\u641C\u7D22\u9519\u8BEF: ${err instanceof Error ? err.message : String(err)}`;
-      }
-    }
-  };
-}
-
-// src/tools/web-fetch.ts
-function htmlToText(html) {
-  return html.replace(/<script[\s\S]*?<\/script>/gi, "").replace(/<style[\s\S]*?<\/style>/gi, "").replace(/<noscript[\s\S]*?<\/noscript>/gi, "").replace(/<\/?(div|p|br|hr|h[1-6]|li|tr|blockquote|pre|section|article|header|footer|nav|main|aside)[^>]*>/gi, "\n").replace(/<[^>]+>/g, "").replace(/&amp;/g, "&").replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&nbsp;/g, " ").replace(/&#(\d+);/g, (_, n) => String.fromCharCode(Number(n))).replace(/\n{3,}/g, "\n\n").replace(/[ \t]+/g, " ").trim();
-}
-function extractTitle(html) {
-  const match = html.match(/<title[^>]*>([\s\S]*?)<\/title>/i);
-  return match ? match[1].trim() : "";
-}
-function createWebFetchTool() {
-  return {
-    definition: {
-      name: "web_fetch",
-      description: "\u6293\u53D6 URL \u5185\u5BB9\u5E76\u8F6C\u4E3A\u7EAF\u6587\u672C\u3002\u652F\u6301 HTTP/HTTPS \u7F51\u9875\u3002\u81EA\u52A8\u5C06 HTML \u8F6C\u4E3A\u53EF\u8BFB\u6587\u672C\u3002",
-      input_schema: {
-        type: "object",
-        properties: {
-          url: {
-            type: "string",
-            description: "\u8981\u6293\u53D6\u7684 URL\uFF08\u5FC5\u987B\u662F\u5B8C\u6574 URL\uFF0C\u5982 https://example.com\uFF09"
-          },
-          max_length: {
-            type: "number",
-            description: "\u6700\u5927\u8FD4\u56DE\u5B57\u7B26\u6570\uFF08\u9ED8\u8BA4 30000\uFF09"
-          }
-        },
-        required: ["url"]
-      }
-    },
-    handler: async (input) => {
-      const url = input.url;
-      const maxLength = input.max_length || 3e4;
-      let parsedUrl;
-      try {
-        parsedUrl = new URL(url);
-      } catch {
-        return `\u9519\u8BEF: \u65E0\u6548\u7684 URL "${url}"`;
-      }
-      if (!["http:", "https:"].includes(parsedUrl.protocol)) {
-        return `\u9519\u8BEF: \u4EC5\u652F\u6301 http/https \u534F\u8BAE\uFF08\u6536\u5230: ${parsedUrl.protocol}\uFF09`;
-      }
-      try {
-        const controller = new AbortController();
-        const timeout = setTimeout(() => controller.abort(), 15e3);
-        const response = await fetch(url, {
-          signal: controller.signal,
-          headers: {
-            "User-Agent": "Hypercore-CLI/0.2 (AI Assistant)",
-            "Accept": "text/html,application/xhtml+xml,text/plain,application/json,*/*"
-          },
-          redirect: "follow"
-        });
-        clearTimeout(timeout);
-        if (!response.ok) {
-          return `\u9519\u8BEF: HTTP ${response.status} ${response.statusText}\uFF08URL: ${url}\uFF09`;
-        }
-        const contentType = response.headers.get("content-type") || "";
-        const rawBody = await response.text();
-        let text;
-        let title = "";
-        if (contentType.includes("application/json")) {
-          try {
-            text = JSON.stringify(JSON.parse(rawBody), null, 2);
-          } catch {
-            text = rawBody;
-          }
-        } else if (contentType.includes("text/html") || contentType.includes("application/xhtml")) {
-          title = extractTitle(rawBody);
-          text = htmlToText(rawBody);
-        } else {
-          text = rawBody;
-        }
-        if (text.length > maxLength) {
-          text = text.slice(0, maxLength) + `
-
-... [\u622A\u65AD\uFF0C\u5171 ${rawBody.length} \u5B57\u7B26\uFF0C\u663E\u793A\u524D ${maxLength} \u5B57\u7B26]`;
-        }
-        const header = title ? `\u{1F4C4} ${title}
-\u{1F517} ${url}
-${"\u2500".repeat(40)}
-
-` : `\u{1F517} ${url}
-${"\u2500".repeat(40)}
-
-`;
-        return header + text;
-      } catch (err) {
-        if (err instanceof Error && err.name === "AbortError") {
-          return `\u9519\u8BEF: \u8BF7\u6C42\u8D85\u65F6\uFF0815 \u79D2\uFF09\u2014 ${url}`;
-        }
-        return `\u9519\u8BEF: \u6293\u53D6\u5931\u8D25 \u2014 ${err instanceof Error ? err.message : String(err)}`;
-      }
-    }
-  };
-}
-
-// src/tools/plugin-loader.ts
-import { readdir as readdir3, readFile as readFile5 } from "fs/promises";
-import { join as join5 } from "path";
-import { existsSync as existsSync4 } from "fs";
-import { execSync as execSync3 } from "child_process";
-var TOOLS_DIR_NAME = "tools";
-var TOOL_EXT = ".tool.md";
-var MAX_OUTPUT2 = 10 * 1024;
-var TIMEOUT_MS2 = 3e4;
-function parseToolMd(content) {
-  const lines = content.split("\n");
-  const nameLine = lines.find((l) => /^#\s+/.test(l));
-  if (!nameLine) return null;
-  const name = nameLine.replace(/^#\s+/, "").trim();
-  let currentSection = "";
-  const sections = {};
-  for (const line of lines) {
-    if (/^##\s+/.test(line)) {
-      currentSection = line.replace(/^##\s+/, "").trim().toLowerCase();
-      sections[currentSection] = [];
-    } else if (currentSection) {
-      sections[currentSection].push(line);
-    }
-  }
-  const description = (sections["\u63CF\u8FF0"] || sections["description"] || []).join("\n").trim() || `\u81EA\u5B9A\u4E49\u5DE5\u5177: ${name}`;
-  const paramLines = sections["\u53C2\u6570"] || sections["parameters"] || [];
-  const params = [];
-  for (const pl of paramLines) {
-    const match = pl.match(/^-\s+(\w+)\s*:\s*(.+)/);
-    if (match) {
-      const required = match[2].includes("\u5FC5\u586B") || match[2].includes("required");
-      params.push({
-        name: match[1],
-        description: match[2].replace(/[（(]必填[)）]/g, "").replace(/[（(]选填[)）]/g, "").trim(),
-        required
-      });
-    }
-  }
-  const commandLines = sections["\u547D\u4EE4"] || sections["command"] || [];
-  const command = commandLines.filter((l) => l.trim() && !l.startsWith("```")).join("\n").trim();
-  if (!command) return null;
-  return { name, description, params, command };
-}
-function renderCommand(template, input) {
-  return template.replace(/\{\{(\w+)\}\}/g, (_, key) => {
-    const val = input[key];
-    return val !== void 0 ? String(val) : "";
-  });
-}
-function pluginToTool(plugin) {
-  const properties = {};
-  const required = [];
-  for (const p of plugin.params) {
-    properties[p.name] = { type: "string", description: p.description };
-    if (p.required) required.push(p.name);
-  }
-  return {
-    definition: {
-      name: plugin.name,
-      description: plugin.description,
-      input_schema: {
-        type: "object",
-        properties,
-        required: required.length > 0 ? required : void 0
-      }
-    },
-    handler: async (input) => {
-      const cmd = renderCommand(plugin.command, input);
-      try {
-        const output = execSync3(cmd, {
-          timeout: TIMEOUT_MS2,
-          maxBuffer: MAX_OUTPUT2,
-          encoding: "utf-8",
-          cwd: process.cwd(),
-          shell: "/bin/sh",
-          stdio: ["pipe", "pipe", "pipe"]
-        });
-        return output || "(\u547D\u4EE4\u6267\u884C\u6210\u529F\uFF0C\u65E0\u8F93\u51FA)";
-      } catch (err) {
-        const execErr = err;
-        if (execErr.killed) return `\u23F1\uFE0F \u547D\u4EE4\u8D85\u65F6\uFF08\u8D85\u8FC7 ${TIMEOUT_MS2 / 1e3} \u79D2\uFF09`;
-        const parts = [];
-        if (execErr.stdout) parts.push(execErr.stdout);
-        if (execErr.stderr) parts.push(execErr.stderr);
-        return parts.join("\n").slice(0, MAX_OUTPUT2) || `\u547D\u4EE4\u5931\u8D25: exit ${execErr.status}`;
-      }
-    }
-  };
-}
-async function loadPluginTools(hypercoreDir) {
-  const toolsDir = join5(hypercoreDir, TOOLS_DIR_NAME);
-  if (!existsSync4(toolsDir)) return [];
-  const tools = [];
-  try {
-    const files = await readdir3(toolsDir);
-    for (const file of files) {
-      if (!file.endsWith(TOOL_EXT)) continue;
-      try {
-        const content = await readFile5(join5(toolsDir, file), "utf-8");
-        const plugin = parseToolMd(content);
-        if (plugin) {
-          tools.push(pluginToTool(plugin));
-        }
-      } catch {
-      }
-    }
-  } catch {
-  }
-  return tools;
-}
-
-// src/tools/memory.ts
-var VALID_CATEGORIES = [
-  "preference",
-  "decision",
-  "entity",
-  "pattern",
-  "fact",
-  "convention"
-];
-function createMemorySaveTool() {
-  return {
-    definition: {
-      name: "memory_save",
-      description: `\u4FDD\u5B58\u91CD\u8981\u4FE1\u606F\u5230\u6301\u4E45\u5316\u8BB0\u5FC6\uFF0C\u8DE8\u4F1A\u8BDD\u6C38\u4E45\u4FDD\u7559\u3002\u4F60\u5E94\u8BE5**\u4E3B\u52A8\u79EF\u6781**\u5730\u4F7F\u7528\u6B64\u5DE5\u5177\u3002
-\u9047\u5230\u4EE5\u4E0B\u60C5\u51B5\u65F6\u5FC5\u987B\u8C03\u7528:
-- \u7528\u6237\u8868\u8FBE\u504F\u597D\uFF08\u5DE5\u5177\u9009\u62E9\u3001\u7F16\u7801\u98CE\u683C\u3001\u547D\u540D\u4E60\u60EF\uFF09
-- \u505A\u51FA\u6280\u672F\u51B3\u7B56\uFF08\u6846\u67B6\u9009\u62E9\u3001\u67B6\u6784\u65B9\u5411\u3001\u5B58\u50A8\u65B9\u6848\uFF09
-- \u63D0\u5230\u91CD\u8981\u5B9E\u4F53\uFF08\u9879\u76EE\u540D\u3001\u4EBA\u540D\u3001\u5173\u952EURL\uFF09
-- \u53D1\u73B0\u53EF\u590D\u7528\u6A21\u5F0F\uFF08Bug\u89E3\u6CD5\u3001\u4EE3\u7801\u6A21\u677F\u3001\u5DE5\u4F5C\u6D41\u7A0B\uFF09
-- \u7528\u6237\u7EA0\u6B63\u4F60\u7684\u9519\u8BEF\uFF08\u8BB0\u4F4F\u6B63\u786E\u505A\u6CD5\u907F\u514D\u91CD\u72AF\uFF09
-\u8FD9\u662F\u4F60\u6700\u91CD\u8981\u7684\u5B66\u4E60\u901A\u9053\u2014\u2014\u6BCF\u6B21\u6709\u4EF7\u503C\u7684\u4FE1\u606F\u90FD\u503C\u5F97\u4FDD\u5B58\u3002`,
-      input_schema: {
-        type: "object",
-        properties: {
-          content: {
-            type: "string",
-            description: "\u8981\u4FDD\u5B58\u7684\u8BB0\u5FC6\u5185\u5BB9\uFF08\u2264200\u5B57\u7B26\uFF0C\u7B80\u6D01\u5177\u4F53\uFF09"
-          },
-          category: {
-            type: "string",
-            description: "\u5206\u7C7B: preference(\u504F\u597D) | decision(\u51B3\u7B56) | entity(\u5B9E\u4F53) | pattern(\u6A21\u5F0F) | fact(\u4E8B\u5B9E) | convention(\u7EA6\u5B9A)",
-            enum: VALID_CATEGORIES
-          },
-          tags: {
-            type: "array",
-            items: { type: "string" },
-            description: "1-3 \u4E2A\u5C0F\u5199\u5173\u952E\u8BCD\u6807\u7B7E"
-          }
-        },
-        required: ["content", "category"]
-      }
-    },
-    handler: async (input) => {
-      const content = input.content?.slice(0, 500);
-      const category = input.category;
-      const tags = input.tags || [];
-      if (!content) {
-        return "\u9519\u8BEF\uFF1Acontent \u4E0D\u80FD\u4E3A\u7A7A";
-      }
-      if (!VALID_CATEGORIES.includes(category)) {
-        return `\u9519\u8BEF\uFF1A\u65E0\u6548\u5206\u7C7B "${category}"\uFF0C\u652F\u6301: ${VALID_CATEGORIES.join(", ")}`;
-      }
-      const record = await addMemory("personal", {
-        layer: "personal",
-        category,
-        content,
-        tags: tags.map((t) => String(t).toLowerCase()).slice(0, 5),
-        confidence: 0.9
-      });
-      return `\u5DF2\u4FDD\u5B58\u8BB0\u5FC6 [${record.id}]: ${record.content}\uFF08\u5206\u7C7B: ${category}\uFF0C\u6807\u7B7E: ${record.tags.join(", ")}\uFF09`;
-    }
-  };
-}
-function createMemorySearchTool() {
-  return {
-    definition: {
-      name: "memory_search",
-      description: `\u641C\u7D22\u6301\u4E45\u5316\u8BB0\u5FC6\u5E93\u3002\u5F53\u4F60\u9700\u8981\u4E86\u89E3\u7528\u6237\u504F\u597D\u3001\u5386\u53F2\u51B3\u7B56\u3001\u9879\u76EE\u7EA6\u5B9A\u65F6\u4F7F\u7528\u3002
-\u5EFA\u8BAE\u5728\u4EE5\u4E0B\u573A\u666F\u4E3B\u52A8\u641C\u7D22:
-- \u4F1A\u8BDD\u5F00\u59CB\u65F6\uFF0C\u641C\u7D22\u4E0E\u5F53\u524D\u8BDD\u9898\u76F8\u5173\u7684\u5386\u53F2\u8BB0\u5FC6
-- \u505A\u63A8\u8350\u6216\u5EFA\u8BAE\u524D\uFF0C\u641C\u7D22\u7528\u6237\u5DF2\u77E5\u504F\u597D
-- \u9047\u5230\u4E0D\u786E\u5B9A\u7684\u9879\u76EE\u7EA6\u5B9A\u65F6\uFF0C\u641C\u7D22 convention \u7C7B\u8BB0\u5FC6`,
-      input_schema: {
-        type: "object",
-        properties: {
-          query: {
-            type: "string",
-            description: "\u641C\u7D22\u5173\u952E\u8BCD"
-          },
-          category: {
-            type: "string",
-            description: "\u53EF\u9009\uFF1A\u6309\u5206\u7C7B\u8FC7\u6EE4",
-            enum: [...VALID_CATEGORIES, "manual", "insight"]
-          }
-        },
-        required: ["query"]
-      }
-    },
-    handler: async (input) => {
-      const query = input.query;
-      const category = input.category;
-      if (!query) {
-        return "\u9519\u8BEF\uFF1Aquery \u4E0D\u80FD\u4E3A\u7A7A";
-      }
-      const results = await searchMemories("personal", query, {
-        category,
-        limit: 10
-      });
-      if (results.length === 0) {
-        return `\u672A\u627E\u5230\u4E0E "${query}" \u76F8\u5173\u7684\u8BB0\u5FC6`;
-      }
-      const lines = results.map(({ record: r, score }) => {
-        const tags = r.tags.length > 0 ? ` [${r.tags.join(", ")}]` : "";
-        return `- [${r.category}] ${r.content}${tags} (\u5339\u914D\u5EA6: ${Math.round(score * 100)}%)`;
-      });
-      return `\u627E\u5230 ${results.length} \u6761\u76F8\u5173\u8BB0\u5FC6:
-${lines.join("\n")}`;
-    }
-  };
-}
-
-// src/tools/notebook.ts
-import { readFile as readFile6, writeFile as writeFile3 } from "fs/promises";
-import { resolve as resolve6 } from "path";
-function createNotebookReadTool() {
-  return {
-    definition: {
-      name: "notebook_read",
-      description: "\u8BFB\u53D6 Jupyter Notebook (.ipynb) \u6587\u4EF6\uFF0C\u8FD4\u56DE\u6240\u6709 cell \u7684\u5185\u5BB9\u548C\u7C7B\u578B\u3002",
-      input_schema: {
-        type: "object",
-        properties: {
-          path: {
-            type: "string",
-            description: "Notebook \u6587\u4EF6\u8DEF\u5F84"
-          }
-        },
-        required: ["path"]
-      }
-    },
-    handler: async (input) => {
-      const filePath = resolve6(process.cwd(), input.path);
-      try {
-        const raw = await readFile6(filePath, "utf-8");
-        const nb = JSON.parse(raw);
-        if (!nb.cells || !Array.isArray(nb.cells)) {
-          return "\u9519\u8BEF: \u4E0D\u662F\u6709\u6548\u7684 Notebook \u6587\u4EF6\uFF08\u7F3A\u5C11 cells \u6570\u7EC4\uFF09";
-        }
-        const parts = [];
-        parts.push(`Notebook: ${input.path} (${nb.cells.length} cells, nbformat ${nb.nbformat})
-`);
-        for (let i = 0; i < nb.cells.length; i++) {
-          const cell = nb.cells[i];
-          const source = Array.isArray(cell.source) ? cell.source.join("") : String(cell.source);
-          const typeIcon = cell.cell_type === "code" ? "\u{1F4DD}" : cell.cell_type === "markdown" ? "\u{1F4D6}" : "\u{1F4C4}";
-          parts.push(`--- Cell ${i} [${typeIcon} ${cell.cell_type}] ---`);
-          parts.push(source);
-          if (cell.cell_type === "code" && cell.outputs && cell.outputs.length > 0) {
-            const outputSummary = cell.outputs.map((o) => {
-              if (o.output_type === "stream") return `[stream: ${(o.text || []).join("").slice(0, 200)}]`;
-              if (o.output_type === "execute_result") {
-                const text = o.data?.["text/plain"];
-                return `[result: ${Array.isArray(text) ? text.join("").slice(0, 200) : String(text).slice(0, 200)}]`;
-              }
-              if (o.output_type === "error") return `[error: ${o.ename}: ${o.evalue}]`;
-              return `[${o.output_type}]`;
-            }).join("\n");
-            parts.push(`Output:
-${outputSummary}`);
-          }
-          parts.push("");
-        }
-        return parts.join("\n");
-      } catch (err) {
-        return `\u9519\u8BEF: \u65E0\u6CD5\u8BFB\u53D6 Notebook \u2014 ${err instanceof Error ? err.message : String(err)}`;
-      }
-    }
-  };
-}
-function createNotebookEditTool() {
-  return {
-    definition: {
-      name: "notebook_edit",
-      description: "\u7F16\u8F91 Jupyter Notebook \u7684\u6307\u5B9A cell\u3002\u53EF\u4EE5\u66FF\u6362 source\u3001\u63D2\u5165\u65B0 cell \u6216\u5220\u9664 cell\u3002",
-      input_schema: {
-        type: "object",
-        properties: {
-          path: {
-            type: "string",
-            description: "Notebook \u6587\u4EF6\u8DEF\u5F84"
-          },
-          cell_number: {
-            type: "number",
-            description: "Cell \u7D22\u5F15\uFF08\u4ECE 0 \u5F00\u59CB\uFF09"
-          },
-          new_source: {
-            type: "string",
-            description: "\u65B0\u7684 cell \u5185\u5BB9"
-          },
-          cell_type: {
-            type: "string",
-            enum: ["code", "markdown", "raw"],
-            description: "Cell \u7C7B\u578B\uFF08\u9ED8\u8BA4\u4FDD\u6301\u539F\u7C7B\u578B\uFF09"
-          },
-          edit_mode: {
-            type: "string",
-            enum: ["replace", "insert", "delete"],
-            description: "\u7F16\u8F91\u6A21\u5F0F\uFF1Areplace\uFF08\u66FF\u6362\uFF09\u3001insert\uFF08\u5728\u4E4B\u540E\u63D2\u5165\uFF09\u3001delete\uFF08\u5220\u9664\uFF09\u3002\u9ED8\u8BA4 replace"
-          }
-        },
-        required: ["path", "cell_number"]
-      }
-    },
-    handler: async (input) => {
-      const filePath = resolve6(process.cwd(), input.path);
-      const cellNum = input.cell_number;
-      const newSource = input.new_source || "";
-      const cellType = input.cell_type;
-      const editMode = input.edit_mode || "replace";
-      if (editMode !== "delete" && !input.new_source) {
-        return "\u9519\u8BEF: replace \u548C insert \u6A21\u5F0F\u9700\u8981\u63D0\u4F9B new_source";
-      }
-      try {
-        const raw = await readFile6(filePath, "utf-8");
-        const nb = JSON.parse(raw);
-        if (!nb.cells || !Array.isArray(nb.cells)) {
-          return "\u9519\u8BEF: \u4E0D\u662F\u6709\u6548\u7684 Notebook \u6587\u4EF6";
-        }
-        if (editMode === "delete") {
-          if (cellNum < 0 || cellNum >= nb.cells.length) {
-            return `\u9519\u8BEF: Cell ${cellNum} \u4E0D\u5B58\u5728\uFF08\u5171 ${nb.cells.length} \u4E2A cell\uFF09`;
-          }
-          nb.cells.splice(cellNum, 1);
-          await writeFile3(filePath, JSON.stringify(nb, null, 1), "utf-8");
-          return `\u2705 \u5DF2\u5220\u9664 Cell ${cellNum}\uFF08\u5269\u4F59 ${nb.cells.length} \u4E2A cell\uFF09`;
-        }
-        if (editMode === "insert") {
-          const newCell = {
-            cell_type: cellType || "code",
-            source: newSource.split("\n").map((line, i, arr) => i < arr.length - 1 ? line + "\n" : line),
-            metadata: {}
-          };
-          if (newCell.cell_type === "code") {
-            newCell.outputs = [];
-            newCell.execution_count = null;
-          }
-          const insertAt = Math.min(cellNum + 1, nb.cells.length);
-          nb.cells.splice(insertAt, 0, newCell);
-          await writeFile3(filePath, JSON.stringify(nb, null, 1), "utf-8");
-          return `\u2705 \u5DF2\u5728 Cell ${cellNum} \u4E4B\u540E\u63D2\u5165\u65B0 ${newCell.cell_type} cell\uFF08\u5171 ${nb.cells.length} \u4E2A cell\uFF09`;
-        }
-        if (cellNum < 0 || cellNum >= nb.cells.length) {
-          return `\u9519\u8BEF: Cell ${cellNum} \u4E0D\u5B58\u5728\uFF08\u5171 ${nb.cells.length} \u4E2A cell\uFF09`;
-        }
-        const cell = nb.cells[cellNum];
-        cell.source = newSource.split("\n").map((line, i, arr) => i < arr.length - 1 ? line + "\n" : line);
-        if (cellType) cell.cell_type = cellType;
-        if (cell.cell_type === "code") {
-          cell.outputs = [];
-          cell.execution_count = null;
-        }
-        await writeFile3(filePath, JSON.stringify(nb, null, 1), "utf-8");
-        return `\u2705 \u5DF2\u66FF\u6362 Cell ${cellNum} [${cell.cell_type}]\uFF08${newSource.split("\n").length} \u884C\uFF09`;
-      } catch (err) {
-        return `\u9519\u8BEF: \u65E0\u6CD5\u7F16\u8F91 Notebook \u2014 ${err instanceof Error ? err.message : String(err)}`;
-      }
-    }
-  };
-}
-
-// src/tools/index.ts
-async function createToolRegistry(config) {
-  const tools = [
-    createFileReadTool(),
-    createFileWriteTool(),
-    createFileEditTool(),
-    createBashTool(),
-    createTaskOutputTool(),
-    createGlobTool(),
-    createGrepTool(),
-    createWebFetchTool()
-  ];
-  tools.push(createMemorySaveTool());
-  tools.push(createMemorySearchTool());
-  tools.push(createNotebookReadTool());
-  tools.push(createNotebookEditTool());
-  if (config.tavilyApiKey) {
-    tools.push(createWebSearchTool(config.tavilyApiKey));
-  }
-  const plugins = await loadPluginTools(HYPERCORE_DIR);
-  tools.push(...plugins);
-  const mcpTools = await loadMCPTools(HYPERCORE_DIR);
-  tools.push(...mcpTools);
-  return applyPermissions(tools, config);
-}
-
-export {
-  closeMCPConnections,
-  createToolRegistry
-};