@agenticmail/enterprise 0.5.325 → 0.5.327

package/dist/local-S7SDOQHN.js

@@ -1,1128 +0,0 @@
-import {
-  createDependencyManagerTools
-} from "./chunk-OOU7JUYE.js";
-import "./chunk-KFQGP6VL.js";
-
-// src/agent-tools/tools/local/file-read.ts
-import { readFile } from "fs/promises";
-
-// src/agent-tools/tools/local/resolve-path.ts
-import { join, resolve } from "path";
-import { homedir } from "os";
-function resolvePath(inputPath, sandbox) {
-  var expanded = inputPath.startsWith("~") ? join(homedir(), inputPath.slice(1)) : inputPath;
-  var resolved = resolve(expanded);
-  if (sandbox) {
-    var sandboxResolved = resolve(sandbox);
-    if (!resolved.startsWith(sandboxResolved)) {
-      throw new Error("Access denied: path is outside the allowed directory (" + sandbox + ")");
-    }
-  }
-  return resolved;
-}
-
-// src/agent-tools/tools/local/file-read.ts
-function createFileReadTool(sandbox) {
-  return {
-    name: "file_read",
-    description: "Read file contents. Use offset/limit for large files.",
-    input_schema: {
-      type: "object",
-      properties: {
-        path: { type: "string" },
-        offset: { type: "number", description: "Start line (1-indexed)" },
-        limit: { type: "number", description: "Max lines" }
-      },
-      required: ["path"]
-    },
-    execute: async (input) => {
-      var filePath = resolvePath(input.path, sandbox);
-      var content = await readFile(filePath, "utf-8");
-      if (input.offset || input.limit) {
-        var lines = content.split("\n");
-        var start = Math.max(0, (input.offset || 1) - 1);
-        var end = input.limit ? start + input.limit : lines.length;
-        content = lines.slice(start, end).join("\n");
-      }
-      if (content.length > 5e4) {
-        content = content.slice(0, 5e4) + "\n\n[...truncated at 50KB]";
-      }
-      return { content, path: filePath, size: content.length };
-    }
-  };
-}
-
-// src/agent-tools/tools/local/file-write.ts
-import { writeFile, mkdir } from "fs/promises";
-import { dirname } from "path";
-function createFileWriteTool(sandbox) {
-  return {
-    name: "file_write",
-    description: "Write content to a file. Creates parent directories. Overwrites if exists.",
-    input_schema: {
-      type: "object",
-      properties: {
-        path: { type: "string" },
-        content: { type: "string" }
-      },
-      required: ["path", "content"]
-    },
-    execute: async (input) => {
-      var filePath = resolvePath(input.path, sandbox);
-      await mkdir(dirname(filePath), { recursive: true });
-      await writeFile(filePath, input.content, "utf-8");
-      return { ok: true, path: filePath, bytesWritten: Buffer.byteLength(input.content, "utf-8") };
-    }
-  };
-}
-
-// src/agent-tools/tools/local/file-edit.ts
-import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
-function createFileEditTool(sandbox) {
-  return {
-    name: "file_edit",
-    description: "Edit a file by replacing exact text match.",
-    input_schema: {
-      type: "object",
-      properties: {
-        path: { type: "string" },
-        old_text: { type: "string", description: "Exact text to find" },
-        new_text: { type: "string", description: "Replacement text" }
-      },
-      required: ["path", "old_text", "new_text"]
-    },
-    execute: async (input) => {
-      var filePath = resolvePath(input.path, sandbox);
-      var content = await readFile2(filePath, "utf-8");
-      if (!content.includes(input.old_text)) {
-        return { error: "old_text not found in file. Must match exactly including whitespace." };
-      }
-      await writeFile2(filePath, content.replace(input.old_text, input.new_text), "utf-8");
-      return { ok: true, path: filePath };
-    }
-  };
-}
-
-// src/agent-tools/tools/local/file-list.ts
-import { readdir, stat } from "fs/promises";
-import { join as join2 } from "path";
-function createFileListTool(sandbox) {
-  return {
-    name: "file_list",
-    description: "List files and directories at a path.",
-    input_schema: {
-      type: "object",
-      properties: {
-        path: { type: "string" }
-      },
-      required: ["path"]
-    },
-    execute: async (input) => {
-      var dirPath = resolvePath(input.path, sandbox);
-      var entries = await readdir(dirPath, { withFileTypes: true });
-      var results = [];
-      for (var entry of entries) {
-        var info = { name: entry.name, type: entry.isDirectory() ? "directory" : "file" };
-        try {
-          var s = await stat(join2(dirPath, entry.name));
-          info.size = s.size;
-          info.modified = s.mtime.toISOString();
-        } catch {
-        }
-        results.push(info);
-        if (results.length >= 500) break;
-      }
-      return { path: dirPath, entries: results, count: results.length };
-    }
-  };
-}
-
-// src/agent-tools/tools/local/file-search.ts
-import { readdir as readdir2 } from "fs/promises";
-import { join as join3, relative } from "path";
-function createFileSearchTool(sandbox) {
-  return {
-    name: "file_search",
-    description: "Search for files by name pattern (* wildcard supported).",
-    input_schema: {
-      type: "object",
-      properties: {
-        path: { type: "string" },
-        pattern: { type: "string", description: "Filename pattern (e.g. *.ts)" },
-        maxResults: { type: "number" }
-      },
-      required: ["path", "pattern"]
-    },
-    execute: async (input) => {
-      var dirPath = resolvePath(input.path, sandbox);
-      var max = input.maxResults || 50;
-      var regex = new RegExp("^" + input.pattern.replace(/\*/g, ".*").replace(/\?/g, ".") + "$", "i");
-      var results = [];
-      async function walk(dir, depth) {
-        if (depth > 10 || results.length >= max) return;
-        try {
-          var entries = await readdir2(dir, { withFileTypes: true });
-          for (var entry of entries) {
-            if (results.length >= max) break;
-            if (regex.test(entry.name)) results.push(relative(dirPath, join3(dir, entry.name)));
-            if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules") {
-              await walk(join3(dir, entry.name), depth + 1);
-            }
-          }
-        } catch {
-        }
-      }
-      await walk(dirPath, 0);
-      return { path: dirPath, matches: results, count: results.length };
-    }
-  };
-}
-
-// src/agent-tools/tools/local/file-ops.ts
-import { rename, unlink, mkdir as mkdir2 } from "fs/promises";
-import { dirname as dirname2 } from "path";
-function createFileMoveTool(sandbox) {
-  return {
-    name: "file_move",
-    description: "Move or rename a file.",
-    input_schema: {
-      type: "object",
-      properties: {
-        from: { type: "string" },
-        to: { type: "string" }
-      },
-      required: ["from", "to"]
-    },
-    execute: async (input) => {
-      var fromPath = resolvePath(input.from, sandbox);
-      var toPath = resolvePath(input.to, sandbox);
-      await mkdir2(dirname2(toPath), { recursive: true });
-      await rename(fromPath, toPath);
-      return { ok: true, from: fromPath, to: toPath };
-    }
-  };
-}
-function createFileDeleteTool(sandbox) {
-  return {
-    name: "file_delete",
-    description: "Delete a file. Use with caution.",
-    input_schema: {
-      type: "object",
-      properties: {
-        path: { type: "string" }
-      },
-      required: ["path"]
-    },
-    execute: async (input) => {
-      var filePath = resolvePath(input.path, sandbox);
-      await unlink(filePath);
-      return { ok: true, deleted: filePath };
-    }
-  };
-}
-
-// src/agent-tools/tools/local/shell.ts
-import { exec as cpExec, spawn } from "child_process";
-import { promisify } from "util";
-import { platform } from "os";
-var execAsync = promisify(cpExec);
-var activeSessions = /* @__PURE__ */ new Map();
-setInterval(() => {
-  var now = Date.now();
-  for (var [id, s] of activeSessions) {
-    if (now - s.startedAt > 30 * 60 * 1e3) {
-      try {
-        s.proc?.kill();
-      } catch {
-      }
-      activeSessions.delete(id);
-    }
-  }
-}, 6e4);
-function createShellTools(opts) {
-  return [
-    {
-      name: "shell_exec",
-      description: "Execute a shell command. For interactive commands (sudo, installers), use shell_interactive instead.",
-      input_schema: {
-        type: "object",
-        properties: {
-          command: { type: "string" },
-          cwd: { type: "string" },
-          timeout: { type: "number", description: "Seconds (default 30)" }
-        },
-        required: ["command"]
-      },
-      execute: async (input) => {
-        var timeoutMs = (input.timeout || opts?.timeout || 30) * 1e3;
-        var cwd = input.cwd || opts?.cwd || process.cwd();
-        try {
-          var r = await execAsync(input.command, {
-            cwd,
-            timeout: timeoutMs,
-            maxBuffer: 1024 * 1024,
-            env: { ...process.env, TERM: "dumb", DEBIAN_FRONTEND: "noninteractive" }
-          });
-          var stdout = r.stdout || "";
-          var stderr = r.stderr || "";
-          if (stdout.length > 5e4) stdout = stdout.slice(0, 5e4) + "\n[...truncated]";
-          if (stderr.length > 1e4) stderr = stderr.slice(0, 1e4) + "\n[...truncated]";
-          return { stdout, stderr, exitCode: 0 };
-        } catch (err) {
-          return { stdout: (err.stdout || "").slice(0, 5e4), stderr: (err.stderr || err.message || "").slice(0, 1e4), exitCode: err.code || 1 };
-        }
-      }
-    },
-    {
-      name: "shell_interactive",
-      description: "Run an interactive command with PTY (sudo, apt install, ssh, etc.). Can send input like passwords. Returns session ID for follow-up.",
-      input_schema: {
-        type: "object",
-        properties: {
-          command: { type: "string", description: 'Command to run (e.g. "sudo apt install nginx")' },
-          input: { type: "string", description: "Text to send to stdin (e.g. password). Sent after command starts." },
-          inputDelay: { type: "number", description: "ms to wait before sending input (default 500)" },
-          cwd: { type: "string" },
-          timeout: { type: "number", description: "Seconds to wait for output (default 30)" },
-          sessionId: { type: "string", description: "Resume existing session instead of starting new command" }
-        },
-        required: []
-      },
-      execute: async (input) => {
-        if (input.sessionId) {
-          var session = activeSessions.get(input.sessionId);
-          if (!session) return { error: "Session not found or expired" };
-          if (input.input) {
-            try {
-              session.proc.stdin.write(input.input + "\n");
-            } catch {
-            }
-          }
-          await new Promise((r) => setTimeout(r, (input.timeout || 3) * 1e3));
-          var output = session.output;
-          session.output = "";
-          if (output.length > 5e4) output = output.slice(-5e4);
-          return { sessionId: input.sessionId, output, exitCode: session.exitCode, done: session.exitCode !== null };
-        }
-        var sessionId = "sh_" + Date.now().toString(36) + Math.random().toString(36).slice(2, 6);
-        var shell = platform() === "win32" ? "powershell.exe" : "/bin/bash";
-        var args = platform() === "win32" ? ["-Command", input.command || "echo ready"] : ["-c", input.command || "echo ready"];
-        var cwd = input.cwd || opts?.cwd || process.cwd();
-        var proc = spawn(shell, args, {
-          cwd,
-          env: { ...process.env, TERM: "xterm-256color" },
-          stdio: ["pipe", "pipe", "pipe"]
-        });
-        var entry = { proc, output: "", exitCode: null, startedAt: Date.now() };
-        activeSessions.set(sessionId, entry);
-        proc.stdout?.on("data", (d) => {
-          entry.output += d.toString();
-        });
-        proc.stderr?.on("data", (d) => {
-          entry.output += d.toString();
-        });
-        proc.on("close", (code) => {
-          entry.exitCode = code ?? 0;
-        });
-        proc.on("error", (err) => {
-          entry.output += "\n[ERROR] " + err.message;
-          entry.exitCode = 1;
-        });
-        if (input.input) {
-          var delay = input.inputDelay || 500;
-          setTimeout(() => {
-            try {
-              proc.stdin.write(input.input + "\n");
-            } catch {
-            }
-          }, delay);
-        }
-        var waitMs = Math.min((input.timeout || 30) * 1e3, 6e4);
-        await new Promise((resolve2) => {
-          var timer = setTimeout(resolve2, waitMs);
-          proc.on("close", () => {
-            clearTimeout(timer);
-            setTimeout(resolve2, 200);
-          });
-        });
-        var output = entry.output;
-        entry.output = "";
-        if (output.length > 5e4) output = output.slice(-5e4);
-        return { sessionId, output, exitCode: entry.exitCode, done: entry.exitCode !== null };
-      }
-    },
-    {
-      name: "shell_sudo",
-      description: "Run a command with sudo. Handles password prompt automatically.",
-      input_schema: {
-        type: "object",
-        properties: {
-          command: { type: "string", description: "Command to run (without sudo prefix)" },
-          password: { type: "string", description: "User password for sudo" },
-          cwd: { type: "string" },
-          timeout: { type: "number", description: "Seconds (default 60)" }
-        },
-        required: ["command", "password"]
-      },
-      execute: async (input) => {
-        if (platform() === "win32") {
-          return { error: 'Use shell_interactive with "Start-Process ... -Verb RunAs" for Windows elevation' };
-        }
-        var timeoutMs = (input.timeout || 60) * 1e3;
-        var cwd = input.cwd || opts?.cwd || process.cwd();
-        var cmd = `echo '${input.password.replace(/'/g, "'\\''")}' | sudo -S ${input.command}`;
-        try {
-          var r = await execAsync(cmd, {
-            cwd,
-            timeout: timeoutMs,
-            maxBuffer: 2 * 1024 * 1024,
-            env: { ...process.env, TERM: "dumb", DEBIAN_FRONTEND: "noninteractive" }
-          });
-          var stdout = r.stdout || "";
-          var stderr = (r.stderr || "").replace(/\[sudo\].*\n?/g, "");
-          if (stdout.length > 5e4) stdout = stdout.slice(0, 5e4) + "\n[...truncated]";
-          return { stdout, stderr, exitCode: 0 };
-        } catch (err) {
-          var stderrMsg = (err.stderr || err.message || "").replace(/\[sudo\].*\n?/g, "");
-          return { stdout: (err.stdout || "").slice(0, 5e4), stderr: stderrMsg.slice(0, 1e4), exitCode: err.code || 1 };
-        }
-      }
-    },
-    {
-      name: "shell_install",
-      description: "Install a package using the system package manager. Auto-detects apt/yum/dnf/pacman/brew/choco/winget.",
-      input_schema: {
-        type: "object",
-        properties: {
-          package: { type: "string", description: "Package name(s) to install" },
-          password: { type: "string", description: "Sudo password (not needed for brew/choco/winget)" }
-        },
-        required: ["package"]
-      },
-      execute: async (input) => {
-        var os = platform();
-        var pkg = input.package;
-        var cmd;
-        var needsSudo = true;
-        if (os === "darwin") {
-          cmd = `brew install ${pkg}`;
-          needsSudo = false;
-        } else if (os === "win32") {
-          cmd = `winget install ${pkg}`;
-          needsSudo = false;
-        } else {
-          try {
-            await execAsync("which apt-get");
-            cmd = `apt-get install -y ${pkg}`;
-          } catch {
-            try {
-              await execAsync("which dnf");
-              cmd = `dnf install -y ${pkg}`;
-            } catch {
-              try {
-                await execAsync("which yum");
-                cmd = `yum install -y ${pkg}`;
-              } catch {
-                try {
-                  await execAsync("which pacman");
-                  cmd = `pacman -S --noconfirm ${pkg}`;
-                } catch {
-                  try {
-                    await execAsync("which apk");
-                    cmd = `apk add ${pkg}`;
-                  } catch {
-                    return { error: "No supported package manager found (apt/dnf/yum/pacman/apk)" };
-                  }
-                }
-              }
-            }
-          }
-        }
-        if (needsSudo && input.password) {
-          cmd = `echo '${input.password.replace(/'/g, "'\\''")}' | sudo -S ${cmd}`;
-        } else if (needsSudo) {
-          cmd = `sudo ${cmd}`;
-        }
-        try {
-          var r = await execAsync(cmd, {
-            timeout: 3e5,
-            maxBuffer: 2 * 1024 * 1024,
-            env: { ...process.env, DEBIAN_FRONTEND: "noninteractive", TERM: "dumb" }
-          });
-          return { ok: true, stdout: (r.stdout || "").slice(-5e3), stderr: (r.stderr || "").slice(-2e3) };
-        } catch (err) {
-          return { error: (err.stderr || err.message || "").slice(0, 1e4), exitCode: err.code || 1 };
-        }
-      }
-    },
-    {
-      name: "shell_session_list",
-      description: "List active interactive shell sessions.",
-      input_schema: { type: "object", properties: {}, required: [] },
-      execute: async () => ({
-        sessions: Array.from(activeSessions.entries()).map(([id, s]) => ({
-          id,
-          done: s.exitCode !== null,
-          exitCode: s.exitCode,
-          age: Math.round((Date.now() - s.startedAt) / 1e3) + "s",
-          buffered: s.output.length + " chars"
-        }))
-      })
-    },
-    {
-      name: "shell_session_kill",
-      description: "Kill an interactive shell session.",
-      input_schema: {
-        type: "object",
-        properties: { sessionId: { type: "string" } },
-        required: ["sessionId"]
-      },
-      execute: async (input) => {
-        var s = activeSessions.get(input.sessionId);
-        if (!s) return { error: "Not found" };
-        try {
-          s.proc.kill("SIGKILL");
-        } catch {
-        }
-        activeSessions.delete(input.sessionId);
-        return { ok: true };
-      }
-    }
-  ];
-}
-function createShellExecTool(opts) {
-  return createShellTools(opts)[0];
-}
-
-// src/agent-tools/tools/local/system-info.ts
-import { hostname, platform as platform2, arch, cpus, totalmem, freemem, uptime, homedir as homedir2, userInfo } from "os";
-function createSystemInfoTool() {
-  return {
-    name: "system_info",
-    description: "Get host system info (OS, CPU, memory, uptime).",
-    input_schema: { type: "object", properties: {} },
-    execute: async () => {
-      return {
-        hostname: hostname(),
-        platform: platform2(),
-        arch: arch(),
-        cpuCount: cpus().length,
-        cpuModel: cpus()[0]?.model || "unknown",
-        totalMemoryGB: +(totalmem() / 1073741824).toFixed(1),
-        freeMemoryGB: +(freemem() / 1073741824).toFixed(1),
-        uptimeHours: +(uptime() / 3600).toFixed(1),
-        homeDir: homedir2(),
-        user: userInfo().username,
-        cwd: process.cwd(),
-        nodeVersion: process.version
-      };
-    }
-  };
-}
-
-// src/agent-tools/tools/local/coding.ts
-import { readFile as readFile3, writeFile as writeFile3, readdir as readdir3, access } from "fs/promises";
-import { exec as cpExec2 } from "child_process";
-import { promisify as promisify2 } from "util";
-import { join as join4, relative as relative2, extname, dirname as dirname3 } from "path";
-var execAsync2 = promisify2(cpExec2);
-async function exists(p) {
-  try {
-    await access(p);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function detectProjectRoot(startDir) {
-  var dir = startDir;
-  for (var i = 0; i < 10; i++) {
-    for (var marker of ["package.json", "Cargo.toml", "go.mod", "pyproject.toml", "pom.xml", ".git"]) {
-      if (await exists(join4(dir, marker))) return dir;
-    }
-    var parent = dirname3(dir);
-    if (parent === dir) break;
-    dir = parent;
-  }
-  return startDir;
-}
-async function getProjectType(root) {
-  if (await exists(join4(root, "package.json"))) {
-    try {
-      var pkg = JSON.parse(await readFile3(join4(root, "package.json"), "utf-8"));
-      return {
-        type: "node",
-        buildCmd: pkg.scripts?.build ? "npm run build" : void 0,
-        testCmd: pkg.scripts?.test ? "npm test" : void 0,
-        lintCmd: pkg.scripts?.lint ? "npm run lint" : void 0
-      };
-    } catch {
-    }
-  }
-  if (await exists(join4(root, "Cargo.toml"))) return { type: "rust", buildCmd: "cargo build", testCmd: "cargo test" };
-  if (await exists(join4(root, "go.mod"))) return { type: "go", buildCmd: "go build ./...", testCmd: "go test ./..." };
-  if (await exists(join4(root, "pyproject.toml"))) return { type: "python", testCmd: "pytest" };
-  return { type: "unknown" };
-}
-function parseBuildErrors(output) {
-  var errors = [];
-  var tsPattern = /([^\s]+\.[tj]sx?)[:(](\d+)[,:](\d+)[):]?\s*[-–]?\s*(error\s+\w+:\s*.+)/gi;
-  var m;
-  while (m = tsPattern.exec(output)) {
-    errors.push({ file: m[1], line: parseInt(m[2]), message: m[4] });
-  }
-  var genericPattern = /(?:error|Error)[:\s]+(.+)/g;
-  if (errors.length === 0) {
-    while (m = genericPattern.exec(output)) {
-      if (!m[1].includes("node_modules")) errors.push({ message: m[1].trim() });
-    }
-  }
-  var rustPattern = /error\[(\w+)\]:\s*(.+)\n\s*-->\s*([^:]+):(\d+)/g;
-  while (m = rustPattern.exec(output)) {
-    errors.push({ file: m[3], line: parseInt(m[4]), message: `${m[1]}: ${m[2]}` });
-  }
-  return errors.slice(0, 20);
-}
-function createCodingTools(opts) {
-  var defaultCwd = opts?.cwd || process.cwd();
-  var sandbox = opts?.sandbox;
-  return [
-    // ─── 1. Code Plan ─────────────────────────────────
-    {
-      name: "code_plan",
-      description: "Create a structured implementation plan before writing code. Analyzes the codebase, identifies files to change, and outputs a step-by-step plan. ALWAYS use this before multi-file changes.",
-      input_schema: {
-        type: "object",
-        properties: {
-          task: { type: "string", description: "What you need to implement" },
-          cwd: { type: "string", description: "Project root directory" },
-          context_files: {
-            type: "array",
-            items: { type: "string" },
-            description: "Key files to read for context before planning"
-          }
-        },
-        required: ["task"]
-      },
-      execute: async (input) => {
-        var cwd = input.cwd || defaultCwd;
-        var root = await detectProjectRoot(cwd);
-        var project = await getProjectType(root);
-        var contexts = [];
-        if (input.context_files) {
-          for (var f of input.context_files.slice(0, 10)) {
-            try {
-              var fp = resolvePath(f, sandbox);
-              var content = await readFile3(fp, "utf-8");
-              var lines = content.split("\n");
-              contexts.push({
-                path: relative2(root, fp),
-                snippet: lines.slice(0, 200).join("\n") + (lines.length > 200 ? `
-[...${lines.length - 200} more lines]` : "")
-              });
-            } catch {
-            }
-          }
-        }
-        var tree = [];
-        async function walk(dir, depth, prefix) {
-          if (depth > 2) return;
-          try {
-            var entries = await readdir3(dir, { withFileTypes: true });
-            var filtered = entries.filter(
-              (e2) => !["node_modules", ".git", "dist", "build", ".next", "__pycache__", "target", ".cache", "coverage"].includes(e2.name) && !e2.name.startsWith(".")
-            ).sort((a, b) => {
-              if (a.isDirectory() !== b.isDirectory()) return a.isDirectory() ? -1 : 1;
-              return a.name.localeCompare(b.name);
-            });
-            for (var e of filtered.slice(0, 50)) {
-              tree.push(`${prefix}${e.isDirectory() ? "\u{1F4C1} " : "  "}${e.name}`);
-              if (e.isDirectory()) await walk(join4(dir, e.name), depth + 1, prefix + "  ");
-            }
-          } catch {
-          }
-        }
-        await walk(root, 0, "");
-        return {
-          projectRoot: root,
-          projectType: project.type,
-          buildCommand: project.buildCmd || "unknown",
-          testCommand: project.testCmd || "unknown",
-          structure: tree.join("\n"),
-          contextFiles: contexts,
-          instructions: [
-            "Based on the project info above, create your plan:",
-            "1. List ALL files you need to create or modify",
-            "2. For each file, describe the specific changes",
-            "3. Identify the order of changes (dependencies first)",
-            "4. Note any imports/exports that need updating",
-            "5. Plan your build + test verification step",
-            `6. Build command: ${project.buildCmd || "determine from project"}`
-          ].join("\n")
-        };
-      }
-    },
-    // ─── 2. Code Search (ripgrep-powered) ─────────────
-    {
-      name: "code_search",
-      description: "Search codebase for pattern matches. Uses ripgrep if available, falls back to grep. Returns matches with file, line number, and context.",
-      input_schema: {
-        type: "object",
-        properties: {
-          pattern: { type: "string", description: "Search pattern (regex supported)" },
-          path: { type: "string", description: "Directory or file to search (default: project root)" },
-          file_pattern: { type: "string", description: 'File glob filter (e.g. "*.ts", "*.py")' },
-          context_lines: { type: "number", description: "Lines of context around matches (default 2)" },
-          max_results: { type: "number", description: "Max matches (default 30)" },
-          case_sensitive: { type: "boolean", description: "Case sensitive (default false)" },
-          whole_word: { type: "boolean", description: "Match whole words only" },
-          fixed_string: { type: "boolean", description: "Treat pattern as literal string, not regex" }
-        },
-        required: ["pattern"]
-      },
-      execute: async (input) => {
-        var searchPath = resolvePath(input.path || defaultCwd, sandbox);
-        var ctx = input.context_lines ?? 2;
-        var max = input.max_results || 30;
-        var flags = [];
-        if (!input.case_sensitive) flags.push("-i");
-        if (input.whole_word) flags.push("-w");
-        if (input.fixed_string) flags.push("-F");
-        var useRg = false;
-        try {
-          await execAsync2("which rg");
-          useRg = true;
-        } catch {
-        }
-        var cmd;
-        if (useRg) {
-          cmd = `rg --json -C ${ctx} -m ${max} ${flags.join(" ")}`;
-          if (input.file_pattern) cmd += ` -g '${input.file_pattern}'`;
-          cmd += ` -- '${input.pattern.replace(/'/g, "'\\''")}' '${searchPath}'`;
-        } else {
-          cmd = `grep -rn ${flags.join(" ")} -C ${ctx}`;
-          if (input.file_pattern) cmd += ` --include='${input.file_pattern}'`;
-          cmd += ` -- '${input.pattern.replace(/'/g, "'\\''")}' '${searchPath}'`;
-          cmd += ` | head -${max * (ctx * 2 + 3)}`;
-        }
-        try {
-          var { stdout, stderr } = await execAsync2(cmd, {
-            timeout: 15e3,
-            maxBuffer: 512 * 1024,
-            cwd: searchPath
-          });
-          if (useRg && stdout) {
-            var matches = [];
-            var currentFile = "";
-            var contextBuf = [];
-            for (var line of stdout.split("\n").filter(Boolean)) {
-              try {
-                var j = JSON.parse(line);
-                if (j.type === "match") {
-                  matches.push({
-                    file: relative2(searchPath, j.data.path.text),
-                    line: j.data.line_number,
-                    text: j.data.lines.text.trimEnd()
-                  });
-                }
-              } catch {
-              }
-            }
-            return { matches: matches.slice(0, max), total: matches.length, engine: "ripgrep" };
-          }
-          return { output: stdout.slice(0, 5e4), engine: "grep" };
-        } catch (err) {
-          if (err.code === 1) return { matches: [], message: "No matches found" };
-          return { error: (err.stderr || err.message).slice(0, 5e3) };
-        }
-      }
-    },
-    // ─── 3. Code Read (with line numbers + ranges) ────
-    {
-      name: "code_read",
-      description: "Read a file with line numbers. Supports reading specific line ranges. Better than file_read for code \u2014 always shows line numbers.",
-      input_schema: {
-        type: "object",
-        properties: {
-          path: { type: "string" },
-          from_line: { type: "number", description: "Start line (1-indexed, default 1)" },
-          to_line: { type: "number", description: "End line (default: from_line + 200 or EOF)" },
-          symbols: { type: "boolean", description: "Show only function/class/type definitions (outline mode)" }
-        },
-        required: ["path"]
-      },
-      execute: async (input) => {
-        var fp = resolvePath(input.path, sandbox);
-        var content = await readFile3(fp, "utf-8");
-        var lines = content.split("\n");
-        var totalLines = lines.length;
-        if (input.symbols) {
-          var ext = extname(fp).toLowerCase();
-          var symbolPattern;
-          if ([".ts", ".tsx", ".js", ".jsx"].includes(ext)) {
-            symbolPattern = /^(?:export\s+)?(?:async\s+)?(?:function|class|type|interface|enum|const|var|let)\s+\w+|^\s*(?:static\s+)?(?:async\s+)?(?:get\s+|set\s+)?\w+\s*\(/;
-          } else if ([".py"].includes(ext)) {
-            symbolPattern = /^(?:class|def|async def)\s+\w+/;
-          } else if ([".rs"].includes(ext)) {
-            symbolPattern = /^(?:pub\s+)?(?:fn|struct|enum|trait|impl|type|const|static)\s+/;
-          } else if ([".go"].includes(ext)) {
-            symbolPattern = /^(?:func|type|var|const)\s+/;
-          } else {
-            symbolPattern = /^(?:function|class|def|fn|type|interface|struct|enum)\s+/;
-          }
-          var symbols = [];
-          for (var i = 0; i < lines.length; i++) {
-            if (symbolPattern.test(lines[i])) {
-              symbols.push(`${String(i + 1).padStart(4)}\u2502 ${lines[i]}`);
-            }
-          }
-          return { path: fp, totalLines, symbols: symbols.join("\n") || "No symbols found" };
-        }
-        var from = Math.max(1, input.from_line || 1);
-        var to = Math.min(totalLines, input.to_line || from + 199);
-        var slice = lines.slice(from - 1, to);
-        var numbered = slice.map((l, i2) => `${String(from + i2).padStart(4)}\u2502 ${l}`).join("\n");
-        return {
-          path: fp,
-          totalLines,
-          range: `${from}-${to}`,
-          content: numbered,
-          hasMore: to < totalLines
-        };
-      }
-    },
-    // ─── 4. Code Multi-Edit (batch edits in one call) ─
-    {
-      name: "code_multi_edit",
-      description: "Apply multiple edits to one or more files in a single call. More efficient than repeated file_edit calls. Edits are applied in order.",
-      input_schema: {
-        type: "object",
-        properties: {
-          edits: {
-            type: "array",
-            items: {
-              type: "object",
-              properties: {
-                path: { type: "string" },
-                old_text: { type: "string" },
-                new_text: { type: "string" }
-              },
-              required: ["path", "old_text", "new_text"]
-            },
-            description: "Array of {path, old_text, new_text} edits"
-          }
-        },
-        required: ["edits"]
-      },
-      execute: async (input) => {
-        var results = [];
-        var byFile = /* @__PURE__ */ new Map();
-        for (var edit of input.edits) {
-          var fp = resolvePath(edit.path, sandbox);
-          if (!byFile.has(fp)) byFile.set(fp, []);
-          byFile.get(fp).push({ old_text: edit.old_text, new_text: edit.new_text });
-        }
-        for (var [filePath, edits] of byFile) {
-          try {
-            var content = await readFile3(filePath, "utf-8");
-            for (var e of edits) {
-              if (!content.includes(e.old_text)) {
-                results.push({ path: filePath, ok: false, error: `old_text not found: "${e.old_text.slice(0, 60)}..."` });
-                continue;
-              }
-              content = content.replace(e.old_text, e.new_text);
-              results.push({ path: filePath, ok: true });
-            }
-            await writeFile3(filePath, content, "utf-8");
-          } catch (err) {
-            results.push({ path: filePath, ok: false, error: err.message });
-          }
-        }
-        var success = results.filter((r) => r.ok).length;
-        var failed = results.filter((r) => !r.ok);
-        return { total: results.length, success, failed: failed.length > 0 ? failed : void 0 };
-      }
-    },
-    // ─── 5. Code Build (with error parsing) ───────────
-    {
-      name: "code_build",
-      description: "Build the project and parse errors. Auto-detects build command from package.json/Cargo.toml/etc. Returns structured error list with file + line.",
-      input_schema: {
-        type: "object",
-        properties: {
-          cwd: { type: "string", description: "Project root (auto-detected if omitted)" },
-          command: { type: "string", description: "Custom build command (overrides auto-detect)" },
-          clean: { type: "boolean", description: "Clean dist/build before building" }
-        },
-        required: []
-      },
-      execute: async (input) => {
-        var cwd = input.cwd || defaultCwd;
-        var root = await detectProjectRoot(cwd);
-        var project = await getProjectType(root);
-        var buildCmd = input.command || project.buildCmd;
-        if (!buildCmd) return { error: `Cannot auto-detect build command for ${project.type} project. Specify command manually.` };
-        if (input.clean) {
-          try {
-            if (project.type === "node") await execAsync2("rm -rf dist build .next", { cwd: root });
-            else if (project.type === "rust") await execAsync2("cargo clean", { cwd: root });
-          } catch {
-          }
-        }
-        var startTime = Date.now();
-        try {
-          var { stdout, stderr } = await execAsync2(buildCmd, {
-            cwd: root,
-            timeout: 12e4,
-            maxBuffer: 2 * 1024 * 1024,
-            env: { ...process.env, FORCE_COLOR: "0", NO_COLOR: "1" }
-          });
-          var duration = Date.now() - startTime;
-          return {
-            ok: true,
-            duration: `${duration}ms`,
-            output: (stdout + "\n" + stderr).trim().slice(-5e3)
-          };
-        } catch (err) {
-          var duration = Date.now() - startTime;
-          var output = ((err.stdout || "") + "\n" + (err.stderr || "")).trim();
-          var errors = parseBuildErrors(output);
-          return {
-            ok: false,
-            duration: `${duration}ms`,
-            exitCode: err.code,
-            errors: errors.length > 0 ? errors : void 0,
-            output: output.slice(-1e4)
-          };
-        }
-      }
-    },
-    // ─── 6. Code Test ─────────────────────────────────
-    {
-      name: "code_test",
-      description: "Run project tests and parse results. Auto-detects test framework.",
-      input_schema: {
-        type: "object",
-        properties: {
-          cwd: { type: "string" },
-          command: { type: "string", description: "Custom test command" },
-          filter: { type: "string", description: "Test name/file filter pattern" },
-          coverage: { type: "boolean", description: "Run with coverage" }
-        },
-        required: []
-      },
-      execute: async (input) => {
-        var cwd = input.cwd || defaultCwd;
-        var root = await detectProjectRoot(cwd);
-        var project = await getProjectType(root);
-        var testCmd = input.command || project.testCmd;
-        if (!testCmd) return { error: "No test command found. Specify one manually." };
-        if (input.filter) {
-          if (project.type === "node") testCmd += ` -- --grep "${input.filter}"`;
-          else if (project.type === "rust") testCmd += ` ${input.filter}`;
-          else if (project.type === "python") testCmd += ` -k "${input.filter}"`;
-        }
-        if (input.coverage && project.type === "node") testCmd += " -- --coverage";
-        try {
-          var { stdout, stderr } = await execAsync2(testCmd, {
-            cwd: root,
-            timeout: 3e5,
-            maxBuffer: 2 * 1024 * 1024,
-            env: { ...process.env, FORCE_COLOR: "0", NO_COLOR: "1", CI: "1" }
-          });
-          return { ok: true, output: (stdout + "\n" + stderr).trim().slice(-1e4) };
-        } catch (err) {
-          return {
-            ok: false,
-            exitCode: err.code,
-            output: ((err.stdout || "") + "\n" + (err.stderr || "")).trim().slice(-1e4)
-          };
-        }
-      }
-    },
-    // ─── 7. Code Git ──────────────────────────────────
-    {
-      name: "code_git",
-      description: "Git operations: status, diff, log, commit, push, branch, stash, blame.",
-      input_schema: {
-        type: "object",
-        properties: {
-          action: { type: "string", description: "status|diff|log|commit|push|pull|branch|checkout|stash|blame|add" },
-          args: { type: "string", description: "Additional arguments (e.g. file path for diff/blame, message for commit)" },
-          cwd: { type: "string" }
-        },
-        required: ["action"]
-      },
-      execute: async (input) => {
-        var cwd = input.cwd || defaultCwd;
-        var root = await detectProjectRoot(cwd);
-        var args = input.args || "";
-        var cmdMap = {
-          status: "git status --short",
-          diff: `git diff ${args}`,
-          log: `git log --oneline -20 ${args}`,
-          commit: `git commit ${args.startsWith("-") ? args : `-m "${args.replace(/"/g, '\\"')}"`}`,
-          push: `git push ${args}`,
-          pull: `git pull ${args}`,
-          branch: args ? `git checkout -b ${args}` : "git branch -a",
-          checkout: `git checkout ${args}`,
-          stash: `git stash ${args || "push"}`,
-          blame: `git blame ${args}`,
-          add: `git add ${args || "."}`
-        };
-        var cmd = cmdMap[input.action];
-        if (!cmd) return { error: `Unknown action: ${input.action}. Use: ${Object.keys(cmdMap).join(", ")}` };
-        try {
-          var { stdout, stderr } = await execAsync2(cmd, { cwd: root, timeout: 3e4 });
-          return { output: (stdout || stderr || "").trim().slice(0, 5e4) };
-        } catch (err) {
-          return { error: (err.stderr || err.message).slice(0, 5e3), exitCode: err.code };
-        }
-      }
-    },
-    // ─── 8. Code Create File (with directory creation) ─
-    {
-      name: "code_create",
-      description: "Create a new file with content. Automatically creates parent directories. Better for new files than file_write.",
-      input_schema: {
-        type: "object",
-        properties: {
-          path: { type: "string" },
-          content: { type: "string" },
-          overwrite: { type: "boolean", description: "Overwrite if exists (default false)" }
-        },
-        required: ["path", "content"]
-      },
-      execute: async (input) => {
-        var fp = resolvePath(input.path, sandbox);
-        if (!input.overwrite && await exists(fp)) {
-          return { error: `File already exists: ${fp}. Set overwrite: true to replace.` };
-        }
-        var { mkdir: mkdir3 } = await import("fs/promises");
-        await mkdir3(dirname3(fp), { recursive: true });
-        await writeFile3(fp, input.content, "utf-8");
-        var lines = input.content.split("\n").length;
-        return { ok: true, path: fp, lines };
-      }
-    },
-    // ─── 9. Code Diff Preview ─────────────────────────
-    {
-      name: "code_diff",
-      description: "Preview what a file edit would look like as a unified diff, without applying it. Use to verify changes before committing.",
-      input_schema: {
-        type: "object",
-        properties: {
-          path: { type: "string" },
-          old_text: { type: "string" },
-          new_text: { type: "string" }
-        },
-        required: ["path", "old_text", "new_text"]
-      },
-      execute: async (input) => {
-        var fp = resolvePath(input.path, sandbox);
-        var content = await readFile3(fp, "utf-8");
-        if (!content.includes(input.old_text)) {
-          return { error: "old_text not found in file" };
-        }
-        var newContent = content.replace(input.old_text, input.new_text);
-        var oldLines = content.split("\n");
-        var newLines = newContent.split("\n");
-        var diff = [`--- ${input.path}`, `+++ ${input.path}`];
-        var start = 0;
-        while (start < oldLines.length && start < newLines.length && oldLines[start] === newLines[start]) start++;
-        var endOld = oldLines.length - 1;
-        var endNew = newLines.length - 1;
-        while (endOld > start && endNew > start && oldLines[endOld] === newLines[endNew]) {
-          endOld--;
-          endNew--;
-        }
-        diff.push(`@@ -${start + 1},${endOld - start + 1} +${start + 1},${endNew - start + 1} @@`);
-        for (var i = start; i <= endOld; i++) diff.push(`-${oldLines[i]}`);
-        for (var i = start; i <= endNew; i++) diff.push(`+${newLines[i]}`);
-        return { diff: diff.join("\n") };
-      }
-    },
-    // ─── 10. Process Manager ──────────────────────────
-    {
-      name: "code_pm2",
-      description: "Manage pm2 processes: list, restart, logs, stop, start.",
-      input_schema: {
-        type: "object",
-        properties: {
-          action: { type: "string", description: "list|restart|logs|stop|start|status" },
-          name: { type: "string", description: "Process name (for restart/logs/stop)" },
-          lines: { type: "number", description: "Number of log lines (default 30)" }
-        },
-        required: ["action"]
-      },
-      execute: async (input) => {
-        var cmdMap = {
-          list: "pm2 jlist",
-          restart: `pm2 restart ${input.name || "all"}`,
-          logs: `pm2 logs ${input.name || ""} --nostream --lines ${input.lines || 30}`,
-          stop: `pm2 stop ${input.name}`,
-          start: `pm2 start ${input.name}`,
-          status: "pm2 jlist"
-        };
-        var cmd = cmdMap[input.action];
-        if (!cmd) return { error: `Unknown action. Use: ${Object.keys(cmdMap).join(", ")}` };
-        try {
-          var { stdout, stderr } = await execAsync2(cmd, { timeout: 15e3 });
-          if (input.action === "list" || input.action === "status") {
-            try {
-              var procs = JSON.parse(stdout);
-              return {
-                processes: procs.map((p) => ({
-                  name: p.name,
-                  id: p.pm_id,
-                  status: p.pm2_env?.status,
-                  cpu: p.monit?.cpu,
-                  memory: Math.round((p.monit?.memory || 0) / 1024 / 1024) + "MB",
-                  restarts: p.pm2_env?.restart_time,
-                  uptime: p.pm2_env?.pm_uptime
-                }))
-              };
-            } catch {
-            }
-          }
-          return { output: (stdout + "\n" + stderr).trim().slice(-1e4) };
-        } catch (err) {
-          return { error: (err.stderr || err.message).slice(0, 5e3) };
-        }
-      }
-    }
-  ];
-}
-
-// src/agent-tools/tools/local/index.ts
-function createLocalSystemTools(config) {
-  var sandbox = config?.sandboxRoot;
-  return [
-    createFileReadTool(sandbox),
-    createFileWriteTool(sandbox),
-    createFileEditTool(sandbox),
-    createFileListTool(sandbox),
-    createFileSearchTool(sandbox),
-    createFileMoveTool(sandbox),
-    createFileDeleteTool(sandbox),
-    ...createShellTools({ cwd: config?.shellCwd, timeout: config?.shellTimeout }),
-    ...createDependencyManagerTools(),
-    createSystemInfoTool(),
-    ...createCodingTools({ cwd: config?.shellCwd, sandbox })
-  ];
-}
-export {
-  createCodingTools,
-  createDependencyManagerTools,
-  createFileDeleteTool,
-  createFileEditTool,
-  createFileListTool,
-  createFileMoveTool,
-  createFileReadTool,
-  createFileSearchTool,
-  createFileWriteTool,
-  createLocalSystemTools,
-  createShellExecTool,
-  createShellTools,
-  createSystemInfoTool
-};