@agenticmail/enterprise 0.5.370 → 0.5.371

package/dist/local-2ASES4SZ.js

@@ -0,0 +1,1179 @@
+import {
+  createDependencyManagerTools
+} from "./chunk-HOYZOJMP.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 _cmdLow = (input.command || "").trim().toLowerCase();
+        var _pkgPatterns = [
+          /^(sudo\s+)?brew\s+install\s/,
+          /^(sudo\s+)?apt(-get)?\s+install\s/,
+          /^(sudo\s+)?dnf\s+install\s/,
+          /^(sudo\s+)?pacman\s+-S\s/,
+          /^(sudo\s+)?snap\s+install\s/,
+          /^choco\s+install\s/,
+          /^winget\s+install\s/,
+          /^scoop\s+install\s/,
+          /^(sudo\s+)?pip3?\s+install\s(?!-r\s|--requirement)/,
+          /^npm\s+install\s+-g\s/
+        ];
+        if (_pkgPatterns.some((p) => p.test(_cmdLow))) {
+          return { stdout: "", stderr: 'POLICY: Package installation via shell is not allowed. Use the install_dependency tool instead.\nExample: install_dependency({ command: "wget" })', exitCode: 1 };
+        }
+        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/agent-control.ts
+function createAgentControlTools(options) {
+  return [
+    {
+      name: "agent_stop",
+      description: 'Stop the current session. Use when the user says "stop", "cancel", "abort", or wants you to immediately stop what you are doing. This terminates the current conversation loop \u2014 the agent process stays running for future messages.',
+      input_schema: {
+        type: "object",
+        properties: {
+          reason: { type: "string", description: "Why the session is being stopped" }
+        },
+        required: []
+      },
+      execute: async (_id, params) => {
+        const reason = params?.reason || "User requested stop";
+        const sessionId = options?.runtimeRef?.getCurrentSessionId?.();
+        if (sessionId && options?.runtimeRef?.terminateSession) {
+          console.log(`[agent-control] Terminating session ${sessionId}: ${reason}`);
+          setTimeout(async () => {
+            try {
+              await options.runtimeRef.terminateSession(sessionId);
+            } catch (e) {
+              console.warn(`[agent-control] terminateSession error: ${e.message}`);
+            }
+          }, 500);
+          return { content: [{ type: "text", text: `Session stopped. ${reason}` }] };
+        }
+        return { content: [{ type: "text", text: `Stopped. ${reason}` }] };
+      }
+    }
+  ];
+}
+
+// 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 }),
+    ...createAgentControlTools(config?.toolOptions)
+  ];
+}
+export {
+  createAgentControlTools,
+  createCodingTools,
+  createDependencyManagerTools,
+  createFileDeleteTool,
+  createFileEditTool,
+  createFileListTool,
+  createFileMoveTool,
+  createFileReadTool,
+  createFileSearchTool,
+  createFileWriteTool,
+  createLocalSystemTools,
+  createShellExecTool,
+  createShellTools,
+  createSystemInfoTool
+};