amai 0.0.26 → 0.0.28

package/dist/server.js

@@ -7,19 +7,17 @@ import { Hono } from 'hono';
 import { serve } from '@hono/node-server';
 import { cors } from 'hono/cors';
 import * as fs4 from 'fs';
-import fs4__default, { realpathSync as realpathSync$1, readlinkSync, readdirSync, readdir as readdir$1, lstatSync, constants } from 'fs';
-import { exec, spawn } from 'child_process';
-import { promisify } from 'util';
-import * as fsp from 'fs/promises';
-import fsp__default, { realpath, readlink, readdir, lstat, access, readFile, unlink, mkdir, writeFile } from 'fs/promises';
-import { z } from 'zod';
+import fs4__default, { realpathSync as realpathSync$1, readlinkSync, readdirSync, readdir as readdir$1, lstatSync } from 'fs';
+import { spawn } from 'child_process';
 import { createServer } from 'http';
+import { z } from 'zod';
+import { realpath, readlink, readdir, lstat, readFile, writeFile, stat, mkdir } from 'fs/promises';
 import { fileURLToPath } from 'url';
 import { EventEmitter } from 'events';
 import Stream from 'stream';
 import { StringDecoder } from 'string_decoder';
 
-var DEFAULT_SERVER_URL = "wss://bridge.ama.shujan.xyz";
+var DEFAULT_SERVER_URL = "wss://ama-bridge.shujanshaikh05.workers.dev";
 var AMA_DIR = path6.join(os3.homedir(), ".amai");
 path6.join(AMA_DIR, "code");
 path6.join(AMA_DIR, "storage");
@@ -78,12 +76,7 @@ var getUserId = () => {
     throw new Error("Error while getting userId");
   }
 };
-var MUTATING_TOOLS = /* @__PURE__ */ new Set([
-  "editFile",
-  "deleteFile",
-  "stringReplace",
-  "bash"
-]);
+var MUTATING_TOOLS = /* @__PURE__ */ new Set(["edit", "write", "bash"]);
 function isMutatingTool(toolName) {
   return MUTATING_TOOLS.has(toolName);
 }
@@ -93,9 +86,7 @@ function isPathWithinProject(filePath, projectCwd) {
     const resolved = path6.resolve(resolvedCwd, filePath);
     const resolvedTarget = safeRealpath(resolved);
     const rel = path6.relative(resolvedCwd, resolvedTarget);
-    if (rel.startsWith("..") || path6.isAbsolute(rel)) {
-      return false;
-    }
+    if (rel.startsWith("..") || path6.isAbsolute(rel)) return false;
     return true;
   } catch {
     return false;
@@ -359,255 +350,6 @@ var scanIdeProjects = async () => {
     return [];
   }
 };
-var Global;
-((Global2) => {
-  ((Path3) => {
-    Path3.data = path6.join(AMA_DIR, "data");
-  })(Global2.Path || (Global2.Path = {}));
-})(Global || (Global = {}));
-
-// src/snapshot/snapshot.ts
-var execAsync = promisify(exec);
-var Snapshot;
-((Snapshot2) => {
-  const log = {
-    info: (msg, data) => console.log(`[snapshot] ${msg}`, data || ""),
-    warn: (msg, data) => console.warn(`[snapshot] ${msg}`, data || ""),
-    error: (msg, data) => console.error(`[snapshot] ${msg}`, data || "")
-  };
-  async function runGit(command, options = {}) {
-    try {
-      const { stdout, stderr } = await execAsync(command, {
-        cwd: options.cwd,
-        env: { ...process.env, ...options.env },
-        encoding: "utf-8",
-        maxBuffer: 50 * 1024 * 1024
-      });
-      return { stdout: stdout || "", stderr: stderr || "", exitCode: 0 };
-    } catch (error) {
-      return {
-        stdout: error.stdout || "",
-        stderr: error.stderr || "",
-        exitCode: error.code || 1
-      };
-    }
-  }
-  async function track(projectId) {
-    const project = projectRegistry.getProject(projectId);
-    if (!project) {
-      log.warn("project not found", { projectId });
-      return void 0;
-    }
-    const worktree = project.cwd;
-    const git = gitdir(projectId);
-    try {
-      await fsp__default.mkdir(git, { recursive: true });
-      const gitExists = await fsp__default.access(path6.join(git, "HEAD")).then(() => true).catch(() => false);
-      if (!gitExists) {
-        await runGit(`git init`, {
-          env: { GIT_DIR: git, GIT_WORK_TREE: worktree }
-        });
-        await runGit(`git --git-dir "${git}" config core.autocrlf false`);
-        log.info("initialized", { projectId, git });
-      }
-    } catch (error) {
-      log.warn("failed to initialize git", { error });
-    }
-    await runGit(`git --git-dir "${git}" --work-tree "${worktree}" add .`, { cwd: worktree });
-    const result = await runGit(`git --git-dir "${git}" --work-tree "${worktree}" write-tree`, { cwd: worktree });
-    const hash = result.stdout.trim();
-    log.info("tracking", { hash, cwd: worktree, git });
-    return hash;
-  }
-  Snapshot2.track = track;
-  Snapshot2.Patch = z.object({
-    hash: z.string(),
-    files: z.string().array()
-  });
-  async function patch(projectId, hash) {
-    const project = projectRegistry.getProject(projectId);
-    if (!project) {
-      return { hash, files: [] };
-    }
-    const worktree = project.cwd;
-    const git = gitdir(projectId);
-    await runGit(`git --git-dir "${git}" --work-tree "${worktree}" add .`, { cwd: worktree });
-    const result = await runGit(
-      `git -c core.autocrlf=false --git-dir "${git}" --work-tree "${worktree}" diff --no-ext-diff --name-only ${hash} -- .`,
-      { cwd: worktree }
-    );
-    if (result.exitCode !== 0) {
-      log.warn("failed to get diff", { hash, exitCode: result.exitCode });
-      return { hash, files: [] };
-    }
-    const files = result.stdout;
-    return {
-      hash,
-      files: files.trim().split("\n").map((x2) => x2.trim()).filter(Boolean).map((x2) => path6.join(worktree, x2))
-    };
-  }
-  Snapshot2.patch = patch;
-  async function restore(projectId, snapshot) {
-    const project = projectRegistry.getProject(projectId);
-    if (!project) {
-      log.error("project not found", { projectId });
-      return false;
-    }
-    log.info("restore", { projectId, snapshot });
-    const worktree = project.cwd;
-    const git = gitdir(projectId);
-    const readResult = await runGit(
-      `git --git-dir "${git}" --work-tree "${worktree}" read-tree ${snapshot}`,
-      { cwd: worktree }
-    );
-    if (readResult.exitCode !== 0) {
-      log.error("failed to read-tree", { snapshot, stderr: readResult.stderr });
-      return false;
-    }
-    const checkoutResult = await runGit(
-      `git --git-dir "${git}" --work-tree "${worktree}" checkout-index -a -f`,
-      { cwd: worktree }
-    );
-    if (checkoutResult.exitCode !== 0) {
-      log.error("failed to checkout-index", { snapshot, stderr: checkoutResult.stderr });
-      return false;
-    }
-    await runGit(`git --git-dir "${git}" --work-tree "${worktree}" add .`, { cwd: worktree });
-    const currentTree = await runGit(
-      `git --git-dir "${git}" --work-tree "${worktree}" write-tree`,
-      { cwd: worktree }
-    );
-    if (currentTree.exitCode === 0 && currentTree.stdout.trim()) {
-      const diffResult = await runGit(
-        `git --git-dir "${git}" diff-tree -r --name-only --diff-filter=A ${snapshot} ${currentTree.stdout.trim()}`,
-        { cwd: worktree }
-      );
-      if (diffResult.exitCode === 0 && diffResult.stdout.trim()) {
-        const newFiles = diffResult.stdout.trim().split("\n").filter(Boolean);
-        for (const file of newFiles) {
-          const fullPath = path6.join(worktree, file);
-          try {
-            await fsp__default.unlink(fullPath);
-            log.info("deleted newly created file", { file: fullPath });
-          } catch {
-          }
-        }
-      }
-    }
-    return true;
-  }
-  Snapshot2.restore = restore;
-  async function revert(projectId, patches) {
-    const project = projectRegistry.getProject(projectId);
-    if (!project) {
-      log.error("project not found", { projectId });
-      return false;
-    }
-    const worktree = project.cwd;
-    const git = gitdir(projectId);
-    const files = /* @__PURE__ */ new Set();
-    for (const item of patches) {
-      for (const file of item.files) {
-        if (files.has(file)) continue;
-        log.info("reverting", { file, hash: item.hash });
-        const result = await runGit(
-          `git --git-dir "${git}" --work-tree "${worktree}" checkout ${item.hash} -- "${file}"`,
-          { cwd: worktree }
-        );
-        if (result.exitCode !== 0) {
-          const relativePath = path6.relative(worktree, file);
-          const checkTree = await runGit(
-            `git --git-dir "${git}" --work-tree "${worktree}" ls-tree ${item.hash} -- "${relativePath}"`,
-            { cwd: worktree }
-          );
-          if (checkTree.exitCode === 0 && checkTree.stdout.trim()) {
-            log.info("file existed in snapshot but checkout failed, keeping", { file });
-          } else {
-            log.info("file did not exist in snapshot, deleting", { file });
-            await fsp__default.unlink(file).catch(() => {
-            });
-          }
-        }
-        files.add(file);
-      }
-    }
-    return true;
-  }
-  Snapshot2.revert = revert;
-  async function diff(projectId, hash) {
-    const project = projectRegistry.getProject(projectId);
-    if (!project) {
-      return "";
-    }
-    const worktree = project.cwd;
-    const git = gitdir(projectId);
-    await runGit(`git --git-dir "${git}" --work-tree "${worktree}" add .`, { cwd: worktree });
-    const result = await runGit(
-      `git -c core.autocrlf=false --git-dir "${git}" --work-tree "${worktree}" diff --no-ext-diff ${hash} -- .`,
-      { cwd: worktree }
-    );
-    if (result.exitCode !== 0) {
-      log.warn("failed to get diff", { hash, exitCode: result.exitCode, stderr: result.stderr });
-      return "";
-    }
-    return result.stdout.trim();
-  }
-  Snapshot2.diff = diff;
-  Snapshot2.FileDiff = z.object({
-    file: z.string(),
-    before: z.string(),
-    after: z.string(),
-    additions: z.number(),
-    deletions: z.number()
-  });
-  async function diffFull(projectId, from, to) {
-    const project = projectRegistry.getProject(projectId);
-    if (!project) {
-      return [];
-    }
-    const worktree = project.cwd;
-    const git = gitdir(projectId);
-    const result = [];
-    const numstatResult = await runGit(
-      `git -c core.autocrlf=false --git-dir "${git}" --work-tree "${worktree}" diff --no-ext-diff --no-renames --numstat ${from} ${to} -- .`,
-      { cwd: worktree }
-    );
-    if (numstatResult.exitCode !== 0) {
-      return [];
-    }
-    const lines = numstatResult.stdout.trim().split("\n").filter(Boolean);
-    for (const line of lines) {
-      const [additions, deletions, file] = line.split("	");
-      const isBinaryFile2 = additions === "-" && deletions === "-";
-      let before = "";
-      let after = "";
-      if (!isBinaryFile2) {
-        const beforeResult = await runGit(
-          `git -c core.autocrlf=false --git-dir "${git}" --work-tree "${worktree}" show ${from}:${file}`,
-          { cwd: worktree }
-        );
-        before = beforeResult.stdout;
-        const afterResult = await runGit(
-          `git -c core.autocrlf=false --git-dir "${git}" --work-tree "${worktree}" show ${to}:${file}`,
-          { cwd: worktree }
-        );
-        after = afterResult.stdout;
-      }
-      result.push({
-        file,
-        before,
-        after,
-        additions: parseInt(additions) || 0,
-        deletions: parseInt(deletions) || 0
-      });
-    }
-    return result;
-  }
-  Snapshot2.diffFull = diffFull;
-  function gitdir(projectId) {
-    return path6.join(Global.Path.data, "snapshot", projectId);
-  }
-})(Snapshot || (Snapshot = {}));
 var CLIENT_ID2 = "app_EMoamEEZ73f0CkXaXp7hrann";
 var ISSUER = "https://auth.openai.com";
 var CODEX_API_ENDPOINT = "https://chatgpt.com/backend-api/codex/responses";
@@ -1126,62 +868,6 @@ var rpcHandlers = {
       arch: process.arch
     };
   },
-  // Snapshot handlers for undo functionality
-  "daemon:snapshot_track": async ({ projectId }) => {
-    if (!projectId) {
-      const error = {
-        _tag: "ValidationError",
-        message: "projectId is required"
-      };
-      throw error;
-    }
-    const hash = await Snapshot.track(projectId);
-    return { success: true, hash };
-  },
-  "daemon:snapshot_patch": async ({ projectId, hash }) => {
-    if (!projectId || !hash) {
-      const error = {
-        _tag: "ValidationError",
-        message: "projectId and hash are required"
-      };
-      throw error;
-    }
-    const patch = await Snapshot.patch(projectId, hash);
-    return { success: true, patch };
-  },
-  "daemon:snapshot_revert": async ({ projectId, patches }) => {
-    if (!projectId || !patches) {
-      const error = {
-        _tag: "ValidationError",
-        message: "projectId and patches are required"
-      };
-      throw error;
-    }
-    const success = await Snapshot.revert(projectId, patches);
-    return { success };
-  },
-  "daemon:snapshot_restore": async ({ projectId, snapshot }) => {
-    if (!projectId || !snapshot) {
-      const error = {
-        _tag: "ValidationError",
-        message: "projectId and snapshot are required"
-      };
-      throw error;
-    }
-    const success = await Snapshot.restore(projectId, snapshot);
-    return { success };
-  },
-  "daemon:snapshot_diff": async ({ projectId, hash }) => {
-    if (!projectId || !hash) {
-      const error = {
-        _tag: "ValidationError",
-        message: "projectId and hash are required"
-      };
-      throw error;
-    }
-    const diff = await Snapshot.diff(projectId, hash);
-    return { success: true, diff };
-  },
   "daemon:codex_start_auth": async () => {
     const { authUrl, waitForCallback } = await startCodexOAuth();
     void waitForCallback().catch((error) => {
@@ -1342,1092 +1028,271 @@ var connectToUserStreams = async (serverUrl) => {
   });
   return ws;
 };
-var ExplanationSchema = z.object({
-  description: z.string().describe(
-    "Clear, concise description of what this command does in 5-10 words. Examples:\nInput: ls\nOutput: Lists files in current directory\n\nInput: git status\nOutput: Shows working tree status\n\nInput: npm install\nOutput: Installs package dependencies\n\nInput: mkdir foo\nOutput: Creates directory 'foo'"
-  )
-});
-var BLOCKED_PATTERNS = [
-  /\brm\s+(-\w+\s+)*(\/ |\/\s*$|~|\/\*|\*)/,
-  /\bdd\s+.*of=\/dev\//,
-  /\bmkfs\b/,
-  /:\(\)\{.*\|.*&\}\s*;?\s*:/,
-  /\bchmod\s+.*-R.*\s+\/\s*$/,
-  /\bchown\s+.*-R.*\s+\/\s*$/,
-  /\b(curl|wget)\s+.*\|\s*(ba)?sh/,
-  /\bmv\s+(\/|\*)\s/,
-  /\bcat\s+\/dev\/(u?random|zero)\s*>\s*\/dev\//,
-  /\bformat\s+[A-Z]:/i,
-  /\bdiskpart\b/i,
-  /\bcipher\s+\/w:/i
-];
-var DANGEROUS_FLAGS = [
-  /--no-preserve-root/,
-  /\bgit\s+push\s+.*--force\b/,
-  /\bgit\s+push\s+-f\b/
-];
-var MAX_OUTPUT_SIZE = 1 * 1024 * 1024;
-var DEFAULT_TIMEOUT = 12e4;
-function evaluateCommandSafety(command) {
-  const trimmed = command.trim();
-  for (const pattern of BLOCKED_PATTERNS) {
-    if (pattern.test(trimmed)) {
-      return { safe: false, reason: `Blocked by safety policy: matches destructive pattern` };
-    }
-  }
-  for (const flag of DANGEROUS_FLAGS) {
-    if (flag.test(trimmed)) {
-      return { safe: false, reason: `Blocked by safety policy: dangerous flag detected` };
-    }
-  }
-  return { safe: true };
-}
 z.object({
-  command: z.string().describe("The terminal command to execute"),
-  is_background: z.boolean().optional().default(false).describe("Whether the command should be run in the background"),
-  timeout: z.number().optional().describe("Optional timeout in milliseconds. If not specified, commands will time out after 120000ms (2 minutes)."),
-  workdir: z.string().optional().describe("The working directory to run the command in. Defaults to the project directory. Use this instead of 'cd' commands.")
-}).merge(ExplanationSchema);
-var runSecureTerminalCommand = async (command, timeout, cwd) => {
-  try {
-    const safety = evaluateCommandSafety(command);
-    if (!safety.safe) {
-      console.log(`[CLI] Blocked command: ${command} \u2014 ${safety.reason}`);
-      return {
-        success: false,
-        message: safety.reason,
-        error: "BLOCKED_COMMAND"
-      };
-    }
-    const proc2 = spawn("sh", ["-c", command], {
-      cwd: cwd || process.cwd(),
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    let timedOut = false;
-    let timeoutId = null;
+  command: z.string().describe("Bash command to execute"),
+  timeout: z.number().optional().describe("Timeout in seconds (optional, no default timeout)")
+});
+async function bashTool(input, projectCwd) {
+  const cwd = projectCwd || process.cwd();
+  const timeoutMs = input.timeout && input.timeout > 0 ? input.timeout * 1e3 : 0;
+  return new Promise((resolve) => {
+    const proc2 = spawn("sh", ["-c", input.command], { cwd, stdio: ["ignore", "pipe", "pipe"] });
     let stdout = "";
     let stderr = "";
-    if (timeout > 0) {
-      timeoutId = setTimeout(() => {
-        timedOut = true;
-        proc2.kill("SIGTERM");
-      }, timeout);
-    }
-    if (proc2.stdout) {
-      proc2.stdout.on("data", (chunk) => {
-        stdout += chunk.toString();
-      });
-    }
-    if (proc2.stderr) {
-      proc2.stderr.on("data", (chunk) => {
-        stderr += chunk.toString();
+    let timedOut = false;
+    const timer = timeoutMs ? setTimeout(() => {
+      timedOut = true;
+      proc2.kill("SIGTERM");
+    }, timeoutMs) : void 0;
+    proc2.stdout?.on("data", (d) => stdout += d.toString());
+    proc2.stderr?.on("data", (d) => stderr += d.toString());
+    proc2.on("close", (code) => {
+      if (timer) clearTimeout(timer);
+      if (timedOut) {
+        resolve({ success: false, error: "TIMEOUT", message: `Command timed out after ${input.timeout}s` });
+        return;
+      }
+      resolve({
+        success: code === 0,
+        exitCode: code ?? 1,
+        stdout: stdout.trim(),
+        stderr: stderr.trim(),
+        message: code === 0 ? "Command executed" : "Command failed"
       });
-    }
-    const exitCode = await new Promise((resolve, reject) => {
-      proc2.once("error", reject);
-      proc2.once("close", (code) => resolve(code));
     });
-    if (timeoutId) {
-      clearTimeout(timeoutId);
-    }
-    if (timedOut) {
-      return {
-        success: false,
-        message: `Command timed out after ${timeout}ms`,
-        error: "TIMEOUT",
-        stdout: stdout.slice(0, MAX_OUTPUT_SIZE),
-        stderr: stderr.slice(0, MAX_OUTPUT_SIZE)
-      };
-    }
-    return {
-      stdout: stdout.slice(0, MAX_OUTPUT_SIZE),
-      stderr: stderr.slice(0, MAX_OUTPUT_SIZE),
-      exitCode: exitCode ?? 1
-    };
-  } catch (error) {
-    console.error("Error while executing the securedShell command", error);
-    return {
-      success: false,
-      message: "Error while executing the securedShell command",
-      error: error.message
-    };
-  }
+    proc2.on("error", (error) => {
+      if (timer) clearTimeout(timer);
+      resolve({ success: false, error: "EXEC_ERROR", message: error.message });
+    });
+  });
+}
+var ReplaceEditSchema = z.object({
+  oldText: z.string().describe("Exact text for one targeted replacement."),
+  newText: z.string().describe("Replacement text for this targeted edit.")
+});
+z.object({
+  path: z.string().describe("Path to the file to edit (relative or absolute)"),
+  edits: z.array(ReplaceEditSchema).describe("One or more targeted replacements.")
+});
+async function editTool(input, projectCwd) {
+  const absolute = path6.isAbsolute(input.path) ? input.path : path6.resolve(projectCwd || process.cwd(), input.path);
+  let content = await readFile(absolute, "utf8");
+  for (const e of input.edits) {
+    const count = content.split(e.oldText).length - 1;
+    if (count !== 1) {
+      return { success: false, error: count === 0 ? "STRING_NOT_FOUND" : "STRING_NOT_UNIQUE" };
+    }
+    content = content.replace(e.oldText, e.newText);
+  }
+  await writeFile(absolute, content, "utf8");
+  return { success: true, message: `Edited ${input.path}` };
+}
+
+// ../../node_modules/.bun/balanced-match@4.0.3/node_modules/balanced-match/dist/esm/index.js
+var balanced = (a3, b, str) => {
+  const ma = a3 instanceof RegExp ? maybeMatch(a3, str) : a3;
+  const mb = b instanceof RegExp ? maybeMatch(b, str) : b;
+  const r = ma !== null && mb != null && range(ma, mb, str);
+  return r && {
+    start: r[0],
+    end: r[1],
+    pre: str.slice(0, r[0]),
+    body: str.slice(r[0] + ma.length, r[1]),
+    post: str.slice(r[1] + mb.length)
+  };
 };
-var bashTool = async (input, projectCwd) => {
-  try {
-    const safety = evaluateCommandSafety(input.command);
-    if (!safety.safe) {
-      console.log(`[CLI] Blocked command: ${input.command} \u2014 ${safety.reason}`);
-      return {
-        success: false,
-        message: safety.reason,
-        error: "BLOCKED_COMMAND"
-      };
+var maybeMatch = (reg, str) => {
+  const m = str.match(reg);
+  return m ? m[0] : null;
+};
+var range = (a3, b, str) => {
+  let begs, beg, left, right = void 0, result;
+  let ai = str.indexOf(a3);
+  let bi = str.indexOf(b, ai + 1);
+  let i = ai;
+  if (ai >= 0 && bi > 0) {
+    if (a3 === b) {
+      return [ai, bi];
     }
-    if (input.timeout !== void 0 && input.timeout < 0) {
-      return {
-        success: false,
-        message: `Invalid timeout value: ${input.timeout}. Timeout must be a positive number.`,
-        error: "INVALID_TIMEOUT"
-      };
+    begs = [];
+    left = str.length;
+    while (i >= 0 && !result) {
+      if (i === ai) {
+        begs.push(i);
+        ai = str.indexOf(a3, i + 1);
+      } else if (begs.length === 1) {
+        const r = begs.pop();
+        if (r !== void 0)
+          result = [r, bi];
+      } else {
+        beg = begs.pop();
+        if (beg !== void 0 && beg < left) {
+          left = beg;
+          right = bi;
+        }
+        bi = str.indexOf(b, i + 1);
+      }
+      i = ai < bi && ai >= 0 ? ai : bi;
     }
-    const cwd = input.workdir || projectCwd || process.cwd();
-    const timeout = input.timeout ?? DEFAULT_TIMEOUT;
-    if (input?.is_background) {
-      const proc2 = spawn("sh", ["-c", input.command], {
-        cwd,
-        stdio: "ignore",
-        detached: true
-      });
-      proc2.unref();
-      console.log(`[LOCAL] Background command started: ${input.command}`);
-      return {
-        success: true,
-        message: `Background command started: ${input.command}`,
-        isBackground: true
-      };
-    } else {
-      const result = await runSecureTerminalCommand(
-        input.command,
-        timeout,
-        cwd
-      );
-      if (result?.error && !result?.exitCode) {
-        return result;
-      }
-      const success = result?.exitCode === 0;
-      return {
-        success,
-        stdout: result?.stdout?.trim(),
-        stderr: result?.stderr?.trim(),
-        exitCode: result?.exitCode,
-        message: success ? `Command executed successfully: ${input.command}` : `Command failed with exit code ${result?.exitCode}: ${input.command}`
-      };
+    if (begs.length && right !== void 0) {
+      result = [left, right];
     }
-  } catch (error) {
-    console.error("Error while executing the terminal command", error);
-    return {
-      success: false,
-      message: "Error while executing the terminal command",
-      error: error.message
-    };
   }
+  return result;
 };
-function isPathWithinProject2(filePath, projectCwd) {
-  try {
-    const resolvedCwd = safeRealpath2(projectCwd);
-    const resolved = path6.resolve(resolvedCwd, filePath);
-    const resolvedTarget = safeRealpath2(resolved);
-    const rel = path6.relative(resolvedCwd, resolvedTarget);
-    if (rel.startsWith("..") || path6.isAbsolute(rel)) {
-      return false;
-    }
-    return true;
-  } catch {
-    return false;
-  }
+
+// ../../node_modules/.bun/brace-expansion@5.0.2/node_modules/brace-expansion/dist/esm/index.js
+var escSlash = "\0SLASH" + Math.random() + "\0";
+var escOpen = "\0OPEN" + Math.random() + "\0";
+var escClose = "\0CLOSE" + Math.random() + "\0";
+var escComma = "\0COMMA" + Math.random() + "\0";
+var escPeriod = "\0PERIOD" + Math.random() + "\0";
+var escSlashPattern = new RegExp(escSlash, "g");
+var escOpenPattern = new RegExp(escOpen, "g");
+var escClosePattern = new RegExp(escClose, "g");
+var escCommaPattern = new RegExp(escComma, "g");
+var escPeriodPattern = new RegExp(escPeriod, "g");
+var slashPattern = /\\\\/g;
+var openPattern = /\\{/g;
+var closePattern = /\\}/g;
+var commaPattern = /\\,/g;
+var periodPattern = /\\./g;
+var EXPANSION_MAX = 1e5;
+function numeric(str) {
+  return !isNaN(str) ? parseInt(str, 10) : str.charCodeAt(0);
 }
-function safeRealpath2(p) {
-  try {
-    return fs4__default.realpathSync(p);
-  } catch {
-    const parent = path6.dirname(p);
-    try {
-      const realParent = fs4__default.realpathSync(parent);
-      return path6.join(realParent, path6.basename(p));
-    } catch {
-      return path6.resolve(p);
-    }
-  }
+function escapeBraces(str) {
+  return str.replace(slashPattern, escSlash).replace(openPattern, escOpen).replace(closePattern, escClose).replace(commaPattern, escComma).replace(periodPattern, escPeriod);
 }
-function validatePath(filePath, projectCwd) {
-  if (!projectCwd) {
-    return {
-      valid: false,
-      error: "ACCESS_DENIED: No project context provided"
-    };
+function unescapeBraces(str) {
+  return str.replace(escSlashPattern, "\\").replace(escOpenPattern, "{").replace(escClosePattern, "}").replace(escCommaPattern, ",").replace(escPeriodPattern, ".");
+}
+function parseCommaParts(str) {
+  if (!str) {
+    return [""];
   }
-  try {
-    if (!isPathWithinProject2(filePath, projectCwd)) {
-      return {
-        valid: false,
-        error: `ACCESS_DENIED: Path "${filePath}" is outside project directory "${projectCwd}"`
-      };
-    }
-    const resolvedCwd = safeRealpath2(projectCwd);
-    const resolvedPath = path6.resolve(resolvedCwd, filePath);
-    return {
-      valid: true,
-      resolvedPath
-    };
-  } catch (error) {
-    return {
-      valid: false,
-      error: `ACCESS_DENIED: Invalid path "${filePath}"`
-    };
+  const parts = [];
+  const m = balanced("{", "}", str);
+  if (!m) {
+    return str.split(",");
   }
-}
-function resolveProjectPath(filePath, projectCwd) {
-  return path6.resolve(projectCwd, filePath);
-}
-
-// ../agent/src/tools/read-file.ts
-var MAX_FILE_SIZE = 10 * 1024 * 1024;
-var MAX_LINES_RETURNED = 2e3;
-var MAX_LINE_LENGTH = 2e3;
-var MAX_LINE_SUFFIX = `... (line truncated to ${MAX_LINE_LENGTH} chars)`;
-var MAX_BYTES = 50 * 1024;
-var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
-  ".zip",
-  ".tar",
-  ".gz",
-  ".exe",
-  ".dll",
-  ".so",
-  ".class",
-  ".jar",
-  ".war",
-  ".7z",
-  ".doc",
-  ".docx",
-  ".xls",
-  ".xlsx",
-  ".ppt",
-  ".pptx",
-  ".odt",
-  ".ods",
-  ".odp",
-  ".bin",
-  ".dat",
-  ".obj",
-  ".o",
-  ".a",
-  ".lib",
-  ".wasm",
-  ".pyc",
-  ".pyo",
-  ".ico",
-  ".bmp",
-  ".ttf",
-  ".woff",
-  ".woff2",
-  ".eot",
-  ".mp3",
-  ".mp4",
-  ".avi",
-  ".mov",
-  ".flv"
-]);
-async function isBinaryFile(filepath, fileSize) {
-  const ext2 = path6.extname(filepath).toLowerCase();
-  if (BINARY_EXTENSIONS.has(ext2)) return true;
-  if (fileSize === 0) return false;
-  try {
-    const fh = await fsp.open(filepath, "r");
-    try {
-      const sampleSize = Math.min(4096, fileSize);
-      const bytes = Buffer.alloc(sampleSize);
-      const result = await fh.read(bytes, 0, sampleSize, 0);
-      if (result.bytesRead === 0) return false;
-      let nonPrintableCount = 0;
-      for (let i = 0; i < result.bytesRead; i++) {
-        if (bytes[i] === 0) return true;
-        if (bytes[i] < 9 || bytes[i] > 13 && bytes[i] < 32) {
-          nonPrintableCount++;
-        }
-      }
-      return nonPrintableCount / result.bytesRead > 0.3;
-    } finally {
-      await fh.close();
-    }
-  } catch {
-    return false;
+  const { pre, body, post } = m;
+  const p = pre.split(",");
+  p[p.length - 1] += "{" + body + "}";
+  const postParts = parseCommaParts(post);
+  if (post.length) {
+    p[p.length - 1] += postParts.shift();
+    p.push.apply(p, postParts);
   }
+  parts.push.apply(parts, p);
+  return parts;
 }
-async function findSimilarFiles(filepath) {
-  const dir = path6.dirname(filepath);
-  const base = path6.basename(filepath).toLowerCase();
-  try {
-    const entries = await fsp.readdir(dir);
-    return entries.filter(
-      (entry) => entry.toLowerCase().includes(base) || base.includes(entry.toLowerCase())
-    ).map((entry) => path6.join(dir, entry)).slice(0, 3);
-  } catch {
+function expand(str, options = {}) {
+  if (!str) {
     return [];
   }
-}
-z.object({
-  relative_file_path: z.string().describe("The path to the file or directory to read."),
-  should_read_entire_file: z.boolean().describe("Whether to read the entire file.").optional().default(true),
-  start_line_one_indexed: z.number().optional().describe("The one-indexed line number to start reading from (inclusive). Alias: offset."),
-  end_line_one_indexed: z.number().optional().describe("The one-indexed line number to end reading at (inclusive). Alias: offset + limit.")
-});
-async function readFileContent(absolute_file_path, relative_file_path, should_read_entire_file, start_line_one_indexed, end_line_one_indexed) {
-  let stat2;
-  try {
-    stat2 = fs4__default.statSync(absolute_file_path);
-  } catch {
-    const suggestions = await findSimilarFiles(absolute_file_path);
-    let message = `File not found: ${relative_file_path}`;
-    if (suggestions.length > 0) {
-      message += `
-
-Did you mean one of these?
-${suggestions.join("\n")}`;
-    }
-    return {
-      success: false,
-      message,
-      error: "FILE_NOT_FOUND"
-    };
-  }
-  if (stat2.isDirectory()) {
-    try {
-      const dirents = await fsp.readdir(absolute_file_path, { withFileTypes: true });
-      const entries = await Promise.all(
-        dirents.map(async (dirent) => {
-          if (dirent.isDirectory()) return dirent.name + "/";
-          if (dirent.isSymbolicLink()) {
-            const target = await fsp.stat(path6.join(absolute_file_path, dirent.name)).catch(() => void 0);
-            if (target?.isDirectory()) return dirent.name + "/";
-          }
-          return dirent.name;
-        })
-      );
-      entries.sort((a3, b) => a3.localeCompare(b));
-      const truncated = entries.length > MAX_LINES_RETURNED;
-      const sliced = entries.slice(0, MAX_LINES_RETURNED);
-      const output = [
-        `<path>${absolute_file_path}</path>`,
-        `<type>directory</type>`,
-        `<entries>`,
-        sliced.join("\n"),
-        truncated ? `
-(Showing ${sliced.length} of ${entries.length} entries)` : `
-(${entries.length} entries)`,
-        `</entries>`
-      ].join("\n");
-      return {
-        success: true,
-        message: `Listed directory: ${relative_file_path} (${entries.length} entries)`,
-        content: output,
-        totalLines: entries.length,
-        truncated
-      };
-    } catch (err) {
-      return {
-        success: false,
-        message: `Failed to list directory: ${relative_file_path}`,
-        error: "READ_ERROR"
-      };
-    }
-  }
-  try {
-    if (stat2.size > MAX_FILE_SIZE) {
-      return {
-        success: false,
-        message: `File too large (${Math.round(stat2.size / 1024 / 1024)}MB). Maximum is ${MAX_FILE_SIZE / 1024 / 1024}MB. Use line ranges to read portions.`,
-        error: "FILE_TOO_LARGE"
-      };
-    }
-    const binary = await isBinaryFile(absolute_file_path, stat2.size);
-    if (binary) {
-      return {
-        success: false,
-        message: `Cannot read binary file: ${relative_file_path}`,
-        error: "BINARY_FILE"
-      };
-    }
-    const fileContent = await fsp.readFile(absolute_file_path, "utf8");
-    const lines = fileContent.split(/\r?\n/);
-    const totalLines = lines.length;
-    const start = should_read_entire_file ? 0 : (start_line_one_indexed ?? 1) - 1;
-    const end = should_read_entire_file ? Math.min(totalLines, MAX_LINES_RETURNED) : Math.min(end_line_one_indexed ?? totalLines, totalLines);
-    if (start >= totalLines && !(totalLines === 0 && start === 0)) {
-      return {
-        success: false,
-        message: `Offset ${start + 1} is out of range for this file (${totalLines} lines)`,
-        error: "INVALID_LINE_RANGE"
-      };
-    }
-    const outputLines = [];
-    let bytes = 0;
-    let truncatedByBytes = false;
-    let actualEnd = start;
-    for (let i = start; i < end; i++) {
-      let line = lines[i];
-      if (line.length > MAX_LINE_LENGTH) {
-        line = line.substring(0, MAX_LINE_LENGTH) + MAX_LINE_SUFFIX;
-      }
-      const numberedLine = `${i + 1}: ${line}`;
-      const lineBytes = Buffer.byteLength(numberedLine, "utf-8") + (outputLines.length > 0 ? 1 : 0);
-      if (bytes + lineBytes > MAX_BYTES && outputLines.length > 0) {
-        truncatedByBytes = true;
-        break;
-      }
-      outputLines.push(numberedLine);
-      bytes += lineBytes;
-      actualEnd = i + 1;
-    }
-    const hasMoreLines = actualEnd < totalLines;
-    const truncated = truncatedByBytes || hasMoreLines || should_read_entire_file && totalLines > MAX_LINES_RETURNED;
-    let output = `<path>${absolute_file_path}</path>
-<type>file</type>
-<content>
-`;
-    output += outputLines.join("\n");
-    if (truncatedByBytes) {
-      output += `
-
-(Output capped at ${MAX_BYTES / 1024} KB. Showing lines ${start + 1}-${actualEnd}. Use start_line_one_indexed=${actualEnd + 1} to continue.)`;
-    } else if (hasMoreLines && !should_read_entire_file) {
-      output += `
-
-(Showing lines ${start + 1}-${actualEnd} of ${totalLines}. Use start_line_one_indexed=${actualEnd + 1} to continue.)`;
-    } else {
-      output += `
-
-(End of file - total ${totalLines} lines)`;
-    }
-    output += "\n</content>";
-    return {
-      success: true,
-      message: truncated ? `Read lines ${start + 1}-${actualEnd} of ${totalLines} from: ${relative_file_path} (truncated)` : `Successfully read file: ${relative_file_path} (${totalLines} lines)`,
-      content: output,
-      totalLines,
-      truncated
-    };
-  } catch (error) {
-    return {
-      success: false,
-      message: `Failed to read file: ${relative_file_path}`,
-      error: "READ_ERROR"
-    };
+  const { max = EXPANSION_MAX } = options;
+  if (str.slice(0, 2) === "{}") {
+    str = "\\{\\}" + str.slice(2);
   }
+  return expand_(escapeBraces(str), max, true).map(unescapeBraces);
 }
-var read_file = async function(input, projectCwd) {
-  const { relative_file_path, should_read_entire_file = true, start_line_one_indexed, end_line_one_indexed } = input;
-  try {
-    if (!relative_file_path) {
-      return {
-        success: false,
-        message: "Missing required parameter: relative_file_path",
-        error: "MISSING_TARGET_FILE"
-      };
+function embrace(str) {
+  return "{" + str + "}";
+}
+function isPadded(el) {
+  return /^-?0\d/.test(el);
+}
+function lte(i, y2) {
+  return i <= y2;
+}
+function gte(i, y2) {
+  return i >= y2;
+}
+function expand_(str, max, isTop) {
+  const expansions = [];
+  const m = balanced("{", "}", str);
+  if (!m)
+    return [str];
+  const pre = m.pre;
+  const post = m.post.length ? expand_(m.post, max, false) : [""];
+  if (/\$$/.test(m.pre)) {
+    for (let k = 0; k < post.length && k < max; k++) {
+      const expansion = pre + "{" + m.body + "}" + post[k];
+      expansions.push(expansion);
     }
-    if (!should_read_entire_file) {
-      if (start_line_one_indexed === void 0 || end_line_one_indexed === void 0) {
-        return {
-          success: false,
-          message: "start_line_one_indexed and end_line_one_indexed are required when should_read_entire_file is false",
-          error: "MISSING_LINE_RANGE"
-        };
-      }
-      if (!Number.isInteger(start_line_one_indexed) || start_line_one_indexed < 1) {
-        return {
-          success: false,
-          message: "start_line_one_indexed must be a positive integer (1-indexed)",
-          error: "INVALID_START_LINE"
-        };
-      }
-      if (!Number.isInteger(end_line_one_indexed) || end_line_one_indexed < 1) {
-        return {
-          success: false,
-          message: "end_line_one_indexed must be a positive integer (1-indexed)",
-          error: "INVALID_END_LINE"
-        };
-      }
-      if (end_line_one_indexed < start_line_one_indexed) {
-        return {
-          success: false,
-          message: "end_line_one_indexed must be greater than or equal to start_line_one_indexed",
-          error: "INVALID_LINE_RANGE"
-        };
+  } else {
+    const isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
+    const isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
+    const isSequence = isNumericSequence || isAlphaSequence;
+    const isOptions = m.body.indexOf(",") >= 0;
+    if (!isSequence && !isOptions) {
+      if (m.post.match(/,(?!,).*\}/)) {
+        str = m.pre + "{" + m.body + escClose + m.post;
+        return expand_(str, max, true);
       }
+      return [str];
     }
-    let absolute_file_path;
-    if (projectCwd) {
-      const validation = validatePath(relative_file_path, projectCwd);
-      if (!validation.valid) {
-        return {
-          success: false,
-          message: validation.error || "Path validation failed",
-          error: "ACCESS_DENIED"
-        };
-      }
-      absolute_file_path = validation.resolvedPath;
+    let n;
+    if (isSequence) {
+      n = m.body.split(/\.\./);
     } else {
-      absolute_file_path = path6.resolve(relative_file_path);
-    }
-    return await readFileContent(
-      absolute_file_path,
-      relative_file_path,
-      should_read_entire_file,
-      start_line_one_indexed,
-      end_line_one_indexed
-    );
-  } catch {
-    return {
-      success: false,
-      message: `Failed to read file: ${relative_file_path}`,
-      error: "READ_ERROR"
-    };
-  }
-};
-z.object({
-  path: z.string().describe("Relative file path to delete")
-});
-var deleteFile = async function(input, projectCwd) {
-  const { path: realPath } = input;
-  if (!realPath) {
-    return {
-      success: false,
-      message: "Missing required parameter: path",
-      error: "MISSING_PATH"
-    };
-  }
-  if (projectCwd) {
-    const validation = validatePath(realPath, projectCwd);
-    if (!validation.valid) {
-      return {
-        success: false,
-        message: validation.error || "Path validation failed",
-        error: "ACCESS_DENIED"
-      };
-    }
-  }
-  try {
-    const basePath = projectCwd || process.cwd();
-    const absolute_file_path = resolveProjectPath(realPath, basePath);
-    if (!absolute_file_path) {
-      return {
-        success: false,
-        message: "Invalid file path",
-        error: "INVALID_FILE_PATH"
-      };
-    }
-    let exists = true;
-    try {
-      await access(absolute_file_path, constants.F_OK);
-    } catch {
-      exists = false;
-    }
-    if (!exists) {
-      return {
-        success: false,
-        message: `File not found: ${realPath}`,
-        error: "FILE_NOT_FOUND"
-      };
-    }
-    let originalContent;
-    try {
-      originalContent = await readFile(absolute_file_path, "utf8");
-    } catch {
-      return {
-        success: false,
-        message: `Failed to read file before deletion: ${realPath}`,
-        error: "READ_ERROR"
-      };
-    }
-    try {
-      await unlink(absolute_file_path);
-    } catch {
-      return {
-        success: false,
-        message: `Failed to delete file: ${realPath}`,
-        error: "DELETE_ERROR"
-      };
-    }
-    return {
-      success: true,
-      message: `Successfully deleted file: ${realPath}`,
-      content: originalContent
-    };
-  } catch (error) {
-    return {
-      success: false,
-      message: `Failed to delete file: ${realPath}`,
-      error: "DELETE_ERROR"
-    };
-  }
-};
-var GREP_LIMITS = {
-  DEFAULT_MAX_MATCHES: 200,
-  MAX_LINE_LENGTH: 2e3,
-  // aligned with OpenCode's 2000-char truncation
-  MAX_TOTAL_OUTPUT_SIZE: 1 * 1024 * 1024,
-  EXECUTION_TIMEOUT_MS: 15e3,
-  TRUNCATION_MESSAGE: "\n[Results truncated due to size limits. Use more specific patterns or file filters to narrow your search.]"
-};
-z.object({
-  query: z.string().describe("The regex pattern to search for"),
-  options: z.object({
-    includePattern: z.string().optional().describe('Glob pattern for files to include (e.g., "*.ts", "*.{ts,tsx}")'),
-    excludePattern: z.string().optional().describe("Glob pattern for files to exclude"),
-    caseSensitive: z.boolean().optional().describe("Whether the search should be case sensitive"),
-    path: z.string().optional().describe("Subdirectory to search in"),
-    sortByMtime: z.boolean().optional().describe("Sort results by file modification time (default: true)")
-  }).optional()
-});
-var _cachedRgPath = null;
-var _cachedRgChecked = false;
-async function getRipgrepPath() {
-  if (_cachedRgChecked) return _cachedRgPath;
-  const candidates = [];
-  if (process.env.RG_PATH) {
-    candidates.push(process.env.RG_PATH);
-  }
-  candidates.push("/opt/homebrew/bin/rg", "/usr/local/bin/rg", "/usr/bin/rg");
-  const pathEntries = process.env.PATH?.split(path6.delimiter) ?? [];
-  const rgNames = process.platform === "win32" ? ["rg.exe", "rg"] : ["rg"];
-  for (const entry of pathEntries) {
-    for (const name of rgNames) {
-      candidates.push(path6.join(entry, name));
-    }
-  }
-  for (const rgPath of candidates) {
-    if (rgPath && fs4__default.existsSync(rgPath)) {
-      _cachedRgPath = rgPath;
-      _cachedRgChecked = true;
-      return rgPath;
-    }
-  }
-  _cachedRgChecked = true;
-  _cachedRgPath = null;
-  return null;
-}
-getRipgrepPath();
-async function getMtimesBatched(files) {
-  const mtimeMap = /* @__PURE__ */ new Map();
-  const BATCH_SIZE = 50;
-  for (let i = 0; i < files.length; i += BATCH_SIZE) {
-    const batch = files.slice(i, i + BATCH_SIZE);
-    const results = await Promise.all(
-      batch.map(async (filePath) => {
-        const mtime = await fsp__default.stat(filePath).then((stats) => stats.mtimeMs).catch(() => 0);
-        return { path: filePath, mtime };
-      })
-    );
-    results.forEach(({ path: path17, mtime }) => mtimeMap.set(path17, mtime));
-  }
-  return mtimeMap;
-}
-var grepTool = async function(input, projectCwd) {
-  const { query, options } = input;
-  if (!query || query.trim() === "") {
-    return {
-      success: false,
-      message: "Missing required parameter: query",
-      error: "MISSING_QUERY"
-    };
-  }
-  try {
-    const { includePattern, excludePattern, caseSensitive, path: subPath, sortByMtime = true } = options || {};
-    let searchDir = projectCwd || process.cwd();
-    if (subPath) {
-      searchDir = path6.isAbsolute(subPath) ? subPath : path6.resolve(searchDir, subPath);
-      if (projectCwd) {
-        const validation = validatePath(subPath, projectCwd);
-        if (!validation.valid) {
-          return {
-            success: false,
-            message: validation.error || "Path validation failed",
-            error: "ACCESS_DENIED"
-          };
+      n = parseCommaParts(m.body);
+      if (n.length === 1 && n[0] !== void 0) {
+        n = expand_(n[0], max, false).map(embrace);
+        if (n.length === 1) {
+          return post.map((p) => m.pre + n[0] + p);
         }
       }
     }
-    if (!fs4__default.existsSync(searchDir)) {
-      return {
-        success: false,
-        message: `Directory not found: ${searchDir}`,
-        error: "DIR_NOT_FOUND"
-      };
-    }
-    const rgPath = await getRipgrepPath();
-    if (!rgPath) {
-      return {
-        success: false,
-        message: "Ripgrep (rg) not found on PATH. Install ripgrep to use this tool.",
-        error: "GREP_NOT_FOUND"
-      };
-    }
-    const args = [
-      "-nH",
-      // line numbers + filename (compact form, matching OpenCode)
-      "--hidden",
-      // search hidden files (aligned with OpenCode)
-      "--no-messages",
-      // suppress error messages for unreadable files
-      "--color=never",
-      `--max-count=${GREP_LIMITS.DEFAULT_MAX_MATCHES}`,
-      "--max-columns=2000"
-    ];
-    if (!caseSensitive) {
-      args.push("-i");
-    }
-    if (includePattern) {
-      args.push("--glob", includePattern);
-    }
-    if (excludePattern) {
-      args.push("--glob", `!${excludePattern}`);
-    }
-    args.push("--glob", "!node_modules/**");
-    args.push("--glob", "!.git/**");
-    args.push("--glob", "!dist/**");
-    args.push("--glob", "!build/**");
-    args.push("--glob", "!*.min.js");
-    args.push("--glob", "!*.min.css");
-    args.push("--glob", "!package-lock.json");
-    args.push("--glob", "!yarn.lock");
-    args.push("--glob", "!bun.lockb");
-    args.push("--glob", "!pnpm-lock.yaml");
-    args.push("--regexp", query);
-    args.push(searchDir);
-    const proc2 = spawn(rgPath, args, {
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    let timedOut = false;
-    let stdout = "";
-    let stderr = "";
-    let outputTruncated = false;
-    const timeoutId = setTimeout(() => {
-      timedOut = true;
-      proc2.kill("SIGTERM");
-    }, GREP_LIMITS.EXECUTION_TIMEOUT_MS);
-    if (proc2.stdout) {
-      proc2.stdout.on("data", (chunk) => {
-        const text = chunk.toString();
-        if (stdout.length >= GREP_LIMITS.MAX_TOTAL_OUTPUT_SIZE) {
-          outputTruncated = true;
-          return;
-        }
-        const remaining = GREP_LIMITS.MAX_TOTAL_OUTPUT_SIZE - stdout.length;
-        if (text.length > remaining) {
-          stdout += text.slice(0, remaining);
-          outputTruncated = true;
-          return;
-        }
-        stdout += text;
-      });
-    }
-    if (proc2.stderr) {
-      proc2.stderr.on("data", (chunk) => {
-        stderr += chunk.toString();
-      });
-    }
-    const exitCode = await new Promise((resolve, reject) => {
-      proc2.once("error", reject);
-      proc2.once("close", (code) => resolve(code));
-    });
-    clearTimeout(timeoutId);
-    if (timedOut) {
-      return {
-        success: false,
-        message: `Search timed out after ${GREP_LIMITS.EXECUTION_TIMEOUT_MS}ms. Use more specific patterns.`,
-        error: "GREP_TIMEOUT"
-      };
-    }
-    if (exitCode === 1) {
-      return {
-        success: true,
-        matches: [],
-        detailedMatches: [],
-        query,
-        matchCount: 0,
-        message: `No matches found for pattern: ${query}`
-      };
-    }
-    if (exitCode !== 0 && exitCode !== 2) {
-      return {
-        success: false,
-        message: `Ripgrep error: ${stderr || "Unknown error"}`,
-        error: "GREP_EXEC_ERROR"
-      };
-    }
-    const lines = stdout.trim().split("\n").filter((line) => line.length > 0);
-    const rawMatches = [];
-    const uniqueFiles = /* @__PURE__ */ new Set();
-    for (const line of lines) {
-      const firstColon = line.indexOf(":");
-      const secondColon = line.indexOf(":", firstColon + 1);
-      if (firstColon > 0 && secondColon > firstColon) {
-        const file = line.substring(0, firstColon);
-        const lineNumber = parseInt(line.substring(firstColon + 1, secondColon), 10);
-        let content = line.substring(secondColon + 1);
-        if (content.length > GREP_LIMITS.MAX_LINE_LENGTH) {
-          content = content.substring(0, GREP_LIMITS.MAX_LINE_LENGTH) + "...";
+    let N;
+    if (isSequence && n[0] !== void 0 && n[1] !== void 0) {
+      const x2 = numeric(n[0]);
+      const y2 = numeric(n[1]);
+      const width = Math.max(n[0].length, n[1].length);
+      let incr = n.length === 3 && n[2] !== void 0 ? Math.abs(numeric(n[2])) : 1;
+      let test = lte;
+      const reverse = y2 < x2;
+      if (reverse) {
+        incr *= -1;
+        test = gte;
+      }
+      const pad = n.some(isPadded);
+      N = [];
+      for (let i = x2; test(i, y2); i += incr) {
+        let c;
+        if (isAlphaSequence) {
+          c = String.fromCharCode(i);
+          if (c === "\\") {
+            c = "";
+          }
+        } else {
+          c = String(i);
+          if (pad) {
+            const need = width - c.length;
+            if (need > 0) {
+              const z10 = new Array(need + 1).join("0");
+              if (i < 0) {
+                c = "-" + z10 + c.slice(1);
+              } else {
+                c = z10 + c;
+              }
+            }
+          }
         }
-        rawMatches.push({
-          file,
-          lineNumber,
-          content: content.trim(),
-          mtime: 0
-        });
-        uniqueFiles.add(file);
+        N.push(c);
       }
-    }
-    if (sortByMtime && uniqueFiles.size > 0) {
-      const mtimeMap = await getMtimesBatched(Array.from(uniqueFiles));
-      for (const match2 of rawMatches) {
-        match2.mtime = mtimeMap.get(match2.file) || 0;
+    } else {
+      N = [];
+      for (let j = 0; j < n.length; j++) {
+        N.push.apply(N, expand_(n[j], max, false));
       }
-      rawMatches.sort((a3, b) => {
-        if (b.mtime !== a3.mtime) return b.mtime - a3.mtime;
-        return a3.file.localeCompare(b.file);
-      });
     }
-    const truncated = rawMatches.length > GREP_LIMITS.DEFAULT_MAX_MATCHES || outputTruncated;
-    const finalMatches = truncated ? rawMatches.slice(0, GREP_LIMITS.DEFAULT_MAX_MATCHES) : rawMatches;
-    const detailedMatches = finalMatches.map((m) => ({
-      file: m.file,
-      lineNumber: m.lineNumber,
-      content: m.content
-    }));
-    const matches = finalMatches.map(
-      (m) => `${m.file}:${m.lineNumber}:${m.content}`
-    );
-    const groupedOutput = [`Found ${finalMatches.length} matches`];
-    let currentFile = "";
-    for (const match2 of finalMatches) {
-      if (currentFile !== match2.file) {
-        if (currentFile !== "") {
-          groupedOutput.push("");
-        }
-        currentFile = match2.file;
-        groupedOutput.push(`${match2.file}:`);
-      }
-      groupedOutput.push(`  Line ${match2.lineNumber}: ${match2.content}`);
-    }
-    if (truncated) {
-      groupedOutput.push("");
-      groupedOutput.push(GREP_LIMITS.TRUNCATION_MESSAGE);
-    }
-    return {
-      success: true,
-      matches,
-      detailedMatches,
-      query,
-      matchCount: finalMatches.length,
-      truncated,
-      message: `Found ${finalMatches.length} matches for pattern: ${query}`,
-      content: groupedOutput.join("\n")
-    };
-  } catch (error) {
-    console.error("[grep] error:", error);
-    return {
-      success: false,
-      message: error?.message || String(error),
-      error: "GREP_EXEC_ERROR"
-    };
-  }
-};
-
-// ../../node_modules/.bun/balanced-match@4.0.3/node_modules/balanced-match/dist/esm/index.js
-var balanced = (a3, b, str) => {
-  const ma = a3 instanceof RegExp ? maybeMatch(a3, str) : a3;
-  const mb = b instanceof RegExp ? maybeMatch(b, str) : b;
-  const r = ma !== null && mb != null && range(ma, mb, str);
-  return r && {
-    start: r[0],
-    end: r[1],
-    pre: str.slice(0, r[0]),
-    body: str.slice(r[0] + ma.length, r[1]),
-    post: str.slice(r[1] + mb.length)
-  };
-};
-var maybeMatch = (reg, str) => {
-  const m = str.match(reg);
-  return m ? m[0] : null;
-};
-var range = (a3, b, str) => {
-  let begs, beg, left, right = void 0, result;
-  let ai = str.indexOf(a3);
-  let bi = str.indexOf(b, ai + 1);
-  let i = ai;
-  if (ai >= 0 && bi > 0) {
-    if (a3 === b) {
-      return [ai, bi];
-    }
-    begs = [];
-    left = str.length;
-    while (i >= 0 && !result) {
-      if (i === ai) {
-        begs.push(i);
-        ai = str.indexOf(a3, i + 1);
-      } else if (begs.length === 1) {
-        const r = begs.pop();
-        if (r !== void 0)
-          result = [r, bi];
-      } else {
-        beg = begs.pop();
-        if (beg !== void 0 && beg < left) {
-          left = beg;
-          right = bi;
-        }
-        bi = str.indexOf(b, i + 1);
-      }
-      i = ai < bi && ai >= 0 ? ai : bi;
-    }
-    if (begs.length && right !== void 0) {
-      result = [left, right];
-    }
-  }
-  return result;
-};
-
-// ../../node_modules/.bun/brace-expansion@5.0.2/node_modules/brace-expansion/dist/esm/index.js
-var escSlash = "\0SLASH" + Math.random() + "\0";
-var escOpen = "\0OPEN" + Math.random() + "\0";
-var escClose = "\0CLOSE" + Math.random() + "\0";
-var escComma = "\0COMMA" + Math.random() + "\0";
-var escPeriod = "\0PERIOD" + Math.random() + "\0";
-var escSlashPattern = new RegExp(escSlash, "g");
-var escOpenPattern = new RegExp(escOpen, "g");
-var escClosePattern = new RegExp(escClose, "g");
-var escCommaPattern = new RegExp(escComma, "g");
-var escPeriodPattern = new RegExp(escPeriod, "g");
-var slashPattern = /\\\\/g;
-var openPattern = /\\{/g;
-var closePattern = /\\}/g;
-var commaPattern = /\\,/g;
-var periodPattern = /\\./g;
-var EXPANSION_MAX = 1e5;
-function numeric(str) {
-  return !isNaN(str) ? parseInt(str, 10) : str.charCodeAt(0);
-}
-function escapeBraces(str) {
-  return str.replace(slashPattern, escSlash).replace(openPattern, escOpen).replace(closePattern, escClose).replace(commaPattern, escComma).replace(periodPattern, escPeriod);
-}
-function unescapeBraces(str) {
-  return str.replace(escSlashPattern, "\\").replace(escOpenPattern, "{").replace(escClosePattern, "}").replace(escCommaPattern, ",").replace(escPeriodPattern, ".");
-}
-function parseCommaParts(str) {
-  if (!str) {
-    return [""];
-  }
-  const parts = [];
-  const m = balanced("{", "}", str);
-  if (!m) {
-    return str.split(",");
-  }
-  const { pre, body, post } = m;
-  const p = pre.split(",");
-  p[p.length - 1] += "{" + body + "}";
-  const postParts = parseCommaParts(post);
-  if (post.length) {
-    p[p.length - 1] += postParts.shift();
-    p.push.apply(p, postParts);
-  }
-  parts.push.apply(parts, p);
-  return parts;
-}
-function expand(str, options = {}) {
-  if (!str) {
-    return [];
-  }
-  const { max = EXPANSION_MAX } = options;
-  if (str.slice(0, 2) === "{}") {
-    str = "\\{\\}" + str.slice(2);
-  }
-  return expand_(escapeBraces(str), max, true).map(unescapeBraces);
-}
-function embrace(str) {
-  return "{" + str + "}";
-}
-function isPadded(el) {
-  return /^-?0\d/.test(el);
-}
-function lte(i, y2) {
-  return i <= y2;
-}
-function gte(i, y2) {
-  return i >= y2;
-}
-function expand_(str, max, isTop) {
-  const expansions = [];
-  const m = balanced("{", "}", str);
-  if (!m)
-    return [str];
-  const pre = m.pre;
-  const post = m.post.length ? expand_(m.post, max, false) : [""];
-  if (/\$$/.test(m.pre)) {
-    for (let k = 0; k < post.length && k < max; k++) {
-      const expansion = pre + "{" + m.body + "}" + post[k];
-      expansions.push(expansion);
-    }
-  } else {
-    const isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m.body);
-    const isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m.body);
-    const isSequence = isNumericSequence || isAlphaSequence;
-    const isOptions = m.body.indexOf(",") >= 0;
-    if (!isSequence && !isOptions) {
-      if (m.post.match(/,(?!,).*\}/)) {
-        str = m.pre + "{" + m.body + escClose + m.post;
-        return expand_(str, max, true);
-      }
-      return [str];
-    }
-    let n;
-    if (isSequence) {
-      n = m.body.split(/\.\./);
-    } else {
-      n = parseCommaParts(m.body);
-      if (n.length === 1 && n[0] !== void 0) {
-        n = expand_(n[0], max, false).map(embrace);
-        if (n.length === 1) {
-          return post.map((p) => m.pre + n[0] + p);
-        }
-      }
-    }
-    let N;
-    if (isSequence && n[0] !== void 0 && n[1] !== void 0) {
-      const x2 = numeric(n[0]);
-      const y2 = numeric(n[1]);
-      const width = Math.max(n[0].length, n[1].length);
-      let incr = n.length === 3 && n[2] !== void 0 ? Math.abs(numeric(n[2])) : 1;
-      let test = lte;
-      const reverse = y2 < x2;
-      if (reverse) {
-        incr *= -1;
-        test = gte;
-      }
-      const pad = n.some(isPadded);
-      N = [];
-      for (let i = x2; test(i, y2); i += incr) {
-        let c;
-        if (isAlphaSequence) {
-          c = String.fromCharCode(i);
-          if (c === "\\") {
-            c = "";
-          }
-        } else {
-          c = String(i);
-          if (pad) {
-            const need = width - c.length;
-            if (need > 0) {
-              const z13 = new Array(need + 1).join("0");
-              if (i < 0) {
-                c = "-" + z13 + c.slice(1);
-              } else {
-                c = z13 + c;
-              }
-            }
-          }
-        }
-        N.push(c);
-      }
-    } else {
-      N = [];
-      for (let j = 0; j < n.length; j++) {
-        N.push.apply(N, expand_(n[j], max, false));
-      }
-    }
-    for (let j = 0; j < N.length; j++) {
-      for (let k = 0; k < post.length && expansions.length < max; k++) {
-        const expansion = pre + N[j] + post[k];
-        if (!isTop || isSequence || expansion) {
-          expansions.push(expansion);
+    for (let j = 0; j < N.length; j++) {
+      for (let k = 0; k < post.length && expansions.length < max; k++) {
+        const expansion = pre + N[j] + post[k];
+        if (!isTop || isSequence || expansion) {
+          expansions.push(expansion);
         }
       }
     }
@@ -3112,11 +1977,11 @@ var qmarksTestNoExtDot = ([$0]) => {
   return (f) => f.length === len && f !== "." && f !== "..";
 };
 var defaultPlatform = typeof process === "object" && process ? typeof process.env === "object" && process.env && process.env.__MINIMATCH_TESTING_PLATFORM__ || process.platform : "posix";
-var path13 = {
+var path9 = {
   win32: { sep: "\\" },
   posix: { sep: "/" }
 };
-var sep = defaultPlatform === "win32" ? path13.win32.sep : path13.posix.sep;
+var sep = defaultPlatform === "win32" ? path9.win32.sep : path9.posix.sep;
 minimatch.sep = sep;
 var GLOBSTAR = /* @__PURE__ */ Symbol("globstar **");
 minimatch.GLOBSTAR = GLOBSTAR;
@@ -3158,7 +2023,7 @@ var defaults = (def) => {
     defaults: (options) => orig.defaults(ext(def, options)),
     makeRe: (pattern, options = {}) => orig.makeRe(pattern, ext(def, options)),
     braceExpand: (pattern, options = {}) => orig.braceExpand(pattern, ext(def, options)),
-    match: (list2, pattern, options = {}) => orig.match(list2, pattern, ext(def, options)),
+    match: (list, pattern, options = {}) => orig.match(list, pattern, ext(def, options)),
     sep: orig.sep,
     GLOBSTAR
   });
@@ -3174,13 +2039,13 @@ var braceExpand = (pattern, options = {}) => {
 minimatch.braceExpand = braceExpand;
 var makeRe = (pattern, options = {}) => new Minimatch(pattern, options).makeRe();
 minimatch.makeRe = makeRe;
-var match = (list2, pattern, options = {}) => {
+var match = (list, pattern, options = {}) => {
   const mm = new Minimatch(pattern, options);
-  list2 = list2.filter((f) => mm.match(f));
-  if (mm.options.nonull && !list2.length) {
-    list2.push(pattern);
+  list = list.filter((f) => mm.match(f));
+  if (mm.options.nonull && !list.length) {
+    list.push(pattern);
   }
-  return list2;
+  return list;
 };
 minimatch.match = match;
 var globMagic = /[?*]|[+@!]\(.*?\)|\[|\]/;
@@ -3713,10 +2578,10 @@ var Minimatch = class {
       }
       return filtered.join("/");
     }).join("|");
-    const [open2, close] = set.length > 1 ? ["(?:", ")"] : ["", ""];
-    re = "^" + open2 + re + close + "$";
+    const [open, close] = set.length > 1 ? ["(?:", ")"] : ["", ""];
+    re = "^" + open + re + close + "$";
     if (this.partial) {
-      re = "^(?:\\/|" + open2 + re.slice(1, -1) + close + ")$";
+      re = "^(?:\\/|" + open + re.slice(1, -1) + close + ")$";
     }
     if (this.negate)
       re = "^(?!" + re + ").+$";
@@ -3826,8 +2691,8 @@ if (typeof C > "u") {
 }
 var G = (a3) => !I.has(a3);
 var y = (a3) => a3 && a3 === Math.floor(a3) && a3 > 0 && isFinite(a3);
-var U = (a3) => y(a3) ? a3 <= Math.pow(2, 8) ? Uint8Array : a3 <= Math.pow(2, 16) ? Uint16Array : a3 <= Math.pow(2, 32) ? Uint32Array : a3 <= Number.MAX_SAFE_INTEGER ? z6 : null : null;
-var z6 = class extends Array {
+var U = (a3) => y(a3) ? a3 <= Math.pow(2, 8) ? Uint8Array : a3 <= Math.pow(2, 16) ? Uint16Array : a3 <= Math.pow(2, 32) ? Uint32Array : a3 <= Number.MAX_SAFE_INTEGER ? z3 : null : null;
+var z3 = class extends Array {
   constructor(t) {
     super(t), this.fill(0);
   }
@@ -3965,7 +2830,7 @@ var L = class a2 {
     return this.#s.has(t) ? 1 / 0 : 0;
   }
   #j() {
-    let t = new z6(this.#o), e = new z6(this.#o);
+    let t = new z3(this.#o), e = new z3(this.#o);
     this.#d = t, this.#A = e;
     let i = this.ttlAutopurge ? new Array(this.#o) : void 0;
     this.#g = i, this.#N = (n, o, r = this.#m.now()) => {
@@ -4015,7 +2880,7 @@ var L = class a2 {
   };
   #p = () => false;
   #B() {
-    let t = new z6(this.#o);
+    let t = new z3(this.#o);
     this.#_ = 0, this.#y = t, this.#W = (e) => {
       this.#_ -= t[e], t[e] = 0;
     }, this.#P = (e, i, s, h) => {
@@ -5219,7 +4084,7 @@ var defaultFS = {
   realpathSync,
   promises: {
     lstat,
-    readdir: readdir,
+    readdir,
     readlink,
     realpath
   }
@@ -5476,12 +4341,12 @@ var PathBase = class {
   /**
    * Get the Path object referenced by the string path, resolved from this Path
    */
-  resolve(path17) {
-    if (!path17) {
+  resolve(path15) {
+    if (!path15) {
       return this;
     }
-    const rootPath = this.getRootString(path17);
-    const dir = path17.substring(rootPath.length);
+    const rootPath = this.getRootString(path15);
+    const dir = path15.substring(rootPath.length);
     const dirParts = dir.split(this.splitSep);
     const result = rootPath ? this.getRoot(rootPath).#resolveParts(dirParts) : this.#resolveParts(dirParts);
     return result;
@@ -6233,8 +5098,8 @@ var PathWin32 = class _PathWin32 extends PathBase {
   /**
    * @internal
    */
-  getRootString(path17) {
-    return win32.parse(path17).root;
+  getRootString(path15) {
+    return win32.parse(path15).root;
   }
   /**
    * @internal
@@ -6280,8 +5145,8 @@ var PathPosix = class _PathPosix extends PathBase {
   /**
    * @internal
    */
-  getRootString(path17) {
-    return path17.startsWith("/") ? "/" : "";
+  getRootString(path15) {
+    return path15.startsWith("/") ? "/" : "";
   }
   /**
    * @internal
@@ -6330,8 +5195,8 @@ var PathScurryBase = class {
    *
    * @internal
    */
-  constructor(cwd = process.cwd(), pathImpl, sep2, { nocase, childrenCacheSize = 16 * 1024, fs: fs12 = defaultFS } = {}) {
-    this.#fs = fsFromOption(fs12);
+  constructor(cwd = process.cwd(), pathImpl, sep2, { nocase, childrenCacheSize = 16 * 1024, fs: fs6 = defaultFS } = {}) {
+    this.#fs = fsFromOption(fs6);
     if (cwd instanceof URL || cwd.startsWith("file://")) {
       cwd = fileURLToPath(cwd);
     }
@@ -6370,11 +5235,11 @@ var PathScurryBase = class {
   /**
    * Get the depth of a provided path, string, or the cwd
    */
-  depth(path17 = this.cwd) {
-    if (typeof path17 === "string") {
-      path17 = this.cwd.resolve(path17);
+  depth(path15 = this.cwd) {
+    if (typeof path15 === "string") {
+      path15 = this.cwd.resolve(path15);
     }
-    return path17.depth();
+    return path15.depth();
   }
   /**
    * Return the cache of child entries.  Exposed so subclasses can create
@@ -6861,9 +5726,9 @@ var PathScurryBase = class {
     process2();
     return results;
   }
-  chdir(path17 = this.cwd) {
+  chdir(path15 = this.cwd) {
     const oldCwd = this.cwd;
-    this.cwd = typeof path17 === "string" ? this.cwd.resolve(path17) : path17;
+    this.cwd = typeof path15 === "string" ? this.cwd.resolve(path15) : path15;
     this.cwd[setAsCwd](oldCwd);
   }
 };
@@ -6889,8 +5754,8 @@ var PathScurryWin32 = class extends PathScurryBase {
   /**
    * @internal
    */
-  newRoot(fs12) {
-    return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs12 });
+  newRoot(fs6) {
+    return new PathWin32(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs6 });
   }
   /**
    * Return true if the provided path string is an absolute path
@@ -6918,8 +5783,8 @@ var PathScurryPosix = class extends PathScurryBase {
   /**
    * @internal
    */
-  newRoot(fs12) {
-    return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs12 });
+  newRoot(fs6) {
+    return new PathPosix(this.rootPath, IFDIR, void 0, this.roots, this.nocase, this.childrenCache(), { fs: fs6 });
   }
   /**
    * Return true if the provided path string is an absolute path
@@ -7219,8 +6084,8 @@ var MatchRecord = class {
   }
   // match, absolute, ifdir
   entries() {
-    return [...this.store.entries()].map(([path17, n]) => [
-      path17,
+    return [...this.store.entries()].map(([path15, n]) => [
+      path15,
       !!(n & 2),
       !!(n & 1)
     ]);
@@ -7425,9 +6290,9 @@ var GlobUtil = class {
   signal;
   maxDepth;
   includeChildMatches;
-  constructor(patterns, path17, opts) {
+  constructor(patterns, path15, opts) {
     this.patterns = patterns;
-    this.path = path17;
+    this.path = path15;
     this.opts = opts;
     this.#sep = !opts.posix && opts.platform === "win32" ? "\\" : "/";
     this.includeChildMatches = opts.includeChildMatches !== false;
@@ -7446,11 +6311,11 @@ var GlobUtil = class {
       });
     }
   }
-  #ignored(path17) {
-    return this.seen.has(path17) || !!this.#ignore?.ignored?.(path17);
+  #ignored(path15) {
+    return this.seen.has(path15) || !!this.#ignore?.ignored?.(path15);
   }
-  #childrenIgnored(path17) {
-    return !!this.#ignore?.childrenIgnored?.(path17);
+  #childrenIgnored(path15) {
+    return !!this.#ignore?.childrenIgnored?.(path15);
   }
   // backpressure mechanism
   pause() {
@@ -7465,1813 +6330,631 @@ var GlobUtil = class {
       fn();
     }
   }
-  onResume(fn) {
-    if (this.signal?.aborted)
-      return;
-    if (!this.paused) {
-      fn();
-    } else {
-      this.#onResume.push(fn);
-    }
-  }
-  // do the requisite realpath/stat checking, and return the path
-  // to add or undefined to filter it out.
-  async matchCheck(e, ifDir) {
-    if (ifDir && this.opts.nodir)
-      return void 0;
-    let rpc;
-    if (this.opts.realpath) {
-      rpc = e.realpathCached() || await e.realpath();
-      if (!rpc)
-        return void 0;
-      e = rpc;
-    }
-    const needStat = e.isUnknown() || this.opts.stat;
-    const s = needStat ? await e.lstat() : e;
-    if (this.opts.follow && this.opts.nodir && s?.isSymbolicLink()) {
-      const target = await s.realpath();
-      if (target && (target.isUnknown() || this.opts.stat)) {
-        await target.lstat();
-      }
-    }
-    return this.matchCheckTest(s, ifDir);
-  }
-  matchCheckTest(e, ifDir) {
-    return e && (this.maxDepth === Infinity || e.depth() <= this.maxDepth) && (!ifDir || e.canReaddir()) && (!this.opts.nodir || !e.isDirectory()) && (!this.opts.nodir || !this.opts.follow || !e.isSymbolicLink() || !e.realpathCached()?.isDirectory()) && !this.#ignored(e) ? e : void 0;
-  }
-  matchCheckSync(e, ifDir) {
-    if (ifDir && this.opts.nodir)
-      return void 0;
-    let rpc;
-    if (this.opts.realpath) {
-      rpc = e.realpathCached() || e.realpathSync();
-      if (!rpc)
-        return void 0;
-      e = rpc;
-    }
-    const needStat = e.isUnknown() || this.opts.stat;
-    const s = needStat ? e.lstatSync() : e;
-    if (this.opts.follow && this.opts.nodir && s?.isSymbolicLink()) {
-      const target = s.realpathSync();
-      if (target && (target?.isUnknown() || this.opts.stat)) {
-        target.lstatSync();
-      }
-    }
-    return this.matchCheckTest(s, ifDir);
-  }
-  matchFinish(e, absolute) {
-    if (this.#ignored(e))
-      return;
-    if (!this.includeChildMatches && this.#ignore?.add) {
-      const ign = `${e.relativePosix()}/**`;
-      this.#ignore.add(ign);
-    }
-    const abs = this.opts.absolute === void 0 ? absolute : this.opts.absolute;
-    this.seen.add(e);
-    const mark = this.opts.mark && e.isDirectory() ? this.#sep : "";
-    if (this.opts.withFileTypes) {
-      this.matchEmit(e);
-    } else if (abs) {
-      const abs2 = this.opts.posix ? e.fullpathPosix() : e.fullpath();
-      this.matchEmit(abs2 + mark);
-    } else {
-      const rel = this.opts.posix ? e.relativePosix() : e.relative();
-      const pre = this.opts.dotRelative && !rel.startsWith(".." + this.#sep) ? "." + this.#sep : "";
-      this.matchEmit(!rel ? "." + mark : pre + rel + mark);
-    }
-  }
-  async match(e, absolute, ifDir) {
-    const p = await this.matchCheck(e, ifDir);
-    if (p)
-      this.matchFinish(p, absolute);
-  }
-  matchSync(e, absolute, ifDir) {
-    const p = this.matchCheckSync(e, ifDir);
-    if (p)
-      this.matchFinish(p, absolute);
-  }
-  walkCB(target, patterns, cb) {
-    if (this.signal?.aborted)
-      cb();
-    this.walkCB2(target, patterns, new Processor(this.opts), cb);
-  }
-  walkCB2(target, patterns, processor, cb) {
-    if (this.#childrenIgnored(target))
-      return cb();
-    if (this.signal?.aborted)
-      cb();
-    if (this.paused) {
-      this.onResume(() => this.walkCB2(target, patterns, processor, cb));
-      return;
-    }
-    processor.processPatterns(target, patterns);
-    let tasks = 1;
-    const next = () => {
-      if (--tasks === 0)
-        cb();
-    };
-    for (const [m, absolute, ifDir] of processor.matches.entries()) {
-      if (this.#ignored(m))
-        continue;
-      tasks++;
-      this.match(m, absolute, ifDir).then(() => next());
-    }
-    for (const t of processor.subwalkTargets()) {
-      if (this.maxDepth !== Infinity && t.depth() >= this.maxDepth) {
-        continue;
-      }
-      tasks++;
-      const childrenCached = t.readdirCached();
-      if (t.calledReaddir())
-        this.walkCB3(t, childrenCached, processor, next);
-      else {
-        t.readdirCB((_, entries) => this.walkCB3(t, entries, processor, next), true);
-      }
-    }
-    next();
-  }
-  walkCB3(target, entries, processor, cb) {
-    processor = processor.filterEntries(target, entries);
-    let tasks = 1;
-    const next = () => {
-      if (--tasks === 0)
-        cb();
-    };
-    for (const [m, absolute, ifDir] of processor.matches.entries()) {
-      if (this.#ignored(m))
-        continue;
-      tasks++;
-      this.match(m, absolute, ifDir).then(() => next());
-    }
-    for (const [target2, patterns] of processor.subwalks.entries()) {
-      tasks++;
-      this.walkCB2(target2, patterns, processor.child(), next);
-    }
-    next();
-  }
-  walkCBSync(target, patterns, cb) {
-    if (this.signal?.aborted)
-      cb();
-    this.walkCB2Sync(target, patterns, new Processor(this.opts), cb);
-  }
-  walkCB2Sync(target, patterns, processor, cb) {
-    if (this.#childrenIgnored(target))
-      return cb();
-    if (this.signal?.aborted)
-      cb();
-    if (this.paused) {
-      this.onResume(() => this.walkCB2Sync(target, patterns, processor, cb));
-      return;
-    }
-    processor.processPatterns(target, patterns);
-    let tasks = 1;
-    const next = () => {
-      if (--tasks === 0)
-        cb();
-    };
-    for (const [m, absolute, ifDir] of processor.matches.entries()) {
-      if (this.#ignored(m))
-        continue;
-      this.matchSync(m, absolute, ifDir);
-    }
-    for (const t of processor.subwalkTargets()) {
-      if (this.maxDepth !== Infinity && t.depth() >= this.maxDepth) {
-        continue;
-      }
-      tasks++;
-      const children = t.readdirSync();
-      this.walkCB3Sync(t, children, processor, next);
-    }
-    next();
-  }
-  walkCB3Sync(target, entries, processor, cb) {
-    processor = processor.filterEntries(target, entries);
-    let tasks = 1;
-    const next = () => {
-      if (--tasks === 0)
-        cb();
-    };
-    for (const [m, absolute, ifDir] of processor.matches.entries()) {
-      if (this.#ignored(m))
-        continue;
-      this.matchSync(m, absolute, ifDir);
-    }
-    for (const [target2, patterns] of processor.subwalks.entries()) {
-      tasks++;
-      this.walkCB2Sync(target2, patterns, processor.child(), next);
-    }
-    next();
-  }
-};
-var GlobWalker = class extends GlobUtil {
-  matches = /* @__PURE__ */ new Set();
-  constructor(patterns, path17, opts) {
-    super(patterns, path17, opts);
-  }
-  matchEmit(e) {
-    this.matches.add(e);
-  }
-  async walk() {
-    if (this.signal?.aborted)
-      throw this.signal.reason;
-    if (this.path.isUnknown()) {
-      await this.path.lstat();
-    }
-    await new Promise((res, rej) => {
-      this.walkCB(this.path, this.patterns, () => {
-        if (this.signal?.aborted) {
-          rej(this.signal.reason);
-        } else {
-          res(this.matches);
-        }
-      });
-    });
-    return this.matches;
-  }
-  walkSync() {
-    if (this.signal?.aborted)
-      throw this.signal.reason;
-    if (this.path.isUnknown()) {
-      this.path.lstatSync();
-    }
-    this.walkCBSync(this.path, this.patterns, () => {
-      if (this.signal?.aborted)
-        throw this.signal.reason;
-    });
-    return this.matches;
-  }
-};
-var GlobStream = class extends GlobUtil {
-  results;
-  constructor(patterns, path17, opts) {
-    super(patterns, path17, opts);
-    this.results = new Minipass({
-      signal: this.signal,
-      objectMode: true
-    });
-    this.results.on("drain", () => this.resume());
-    this.results.on("resume", () => this.resume());
-  }
-  matchEmit(e) {
-    this.results.write(e);
-    if (!this.results.flowing)
-      this.pause();
-  }
-  stream() {
-    const target = this.path;
-    if (target.isUnknown()) {
-      target.lstat().then(() => {
-        this.walkCB(target, this.patterns, () => this.results.end());
-      });
-    } else {
-      this.walkCB(target, this.patterns, () => this.results.end());
-    }
-    return this.results;
-  }
-  streamSync() {
-    if (this.path.isUnknown()) {
-      this.path.lstatSync();
-    }
-    this.walkCBSync(this.path, this.patterns, () => this.results.end());
-    return this.results;
-  }
-};
-
-// ../../node_modules/.bun/glob@11.1.0/node_modules/glob/dist/esm/glob.js
-var defaultPlatform3 = typeof process === "object" && process && typeof process.platform === "string" ? process.platform : "linux";
-var Glob = class {
-  absolute;
-  cwd;
-  root;
-  dot;
-  dotRelative;
-  follow;
-  ignore;
-  magicalBraces;
-  mark;
-  matchBase;
-  maxDepth;
-  nobrace;
-  nocase;
-  nodir;
-  noext;
-  noglobstar;
-  pattern;
-  platform;
-  realpath;
-  scurry;
-  stat;
-  signal;
-  windowsPathsNoEscape;
-  withFileTypes;
-  includeChildMatches;
-  /**
-   * The options provided to the constructor.
-   */
-  opts;
-  /**
-   * An array of parsed immutable {@link Pattern} objects.
-   */
-  patterns;
-  /**
-   * All options are stored as properties on the `Glob` object.
-   *
-   * See {@link GlobOptions} for full options descriptions.
-   *
-   * Note that a previous `Glob` object can be passed as the
-   * `GlobOptions` to another `Glob` instantiation to re-use settings
-   * and caches with a new pattern.
-   *
-   * Traversal functions can be called multiple times to run the walk
-   * again.
-   */
-  constructor(pattern, opts) {
-    if (!opts)
-      throw new TypeError("glob options required");
-    this.withFileTypes = !!opts.withFileTypes;
-    this.signal = opts.signal;
-    this.follow = !!opts.follow;
-    this.dot = !!opts.dot;
-    this.dotRelative = !!opts.dotRelative;
-    this.nodir = !!opts.nodir;
-    this.mark = !!opts.mark;
-    if (!opts.cwd) {
-      this.cwd = "";
-    } else if (opts.cwd instanceof URL || opts.cwd.startsWith("file://")) {
-      opts.cwd = fileURLToPath(opts.cwd);
-    }
-    this.cwd = opts.cwd || "";
-    this.root = opts.root;
-    this.magicalBraces = !!opts.magicalBraces;
-    this.nobrace = !!opts.nobrace;
-    this.noext = !!opts.noext;
-    this.realpath = !!opts.realpath;
-    this.absolute = opts.absolute;
-    this.includeChildMatches = opts.includeChildMatches !== false;
-    this.noglobstar = !!opts.noglobstar;
-    this.matchBase = !!opts.matchBase;
-    this.maxDepth = typeof opts.maxDepth === "number" ? opts.maxDepth : Infinity;
-    this.stat = !!opts.stat;
-    this.ignore = opts.ignore;
-    if (this.withFileTypes && this.absolute !== void 0) {
-      throw new Error("cannot set absolute and withFileTypes:true");
-    }
-    if (typeof pattern === "string") {
-      pattern = [pattern];
-    }
-    this.windowsPathsNoEscape = !!opts.windowsPathsNoEscape || opts.allowWindowsEscape === false;
-    if (this.windowsPathsNoEscape) {
-      pattern = pattern.map((p) => p.replace(/\\/g, "/"));
-    }
-    if (this.matchBase) {
-      if (opts.noglobstar) {
-        throw new TypeError("base matching requires globstar");
-      }
-      pattern = pattern.map((p) => p.includes("/") ? p : `./**/${p}`);
-    }
-    this.pattern = pattern;
-    this.platform = opts.platform || defaultPlatform3;
-    this.opts = { ...opts, platform: this.platform };
-    if (opts.scurry) {
-      this.scurry = opts.scurry;
-      if (opts.nocase !== void 0 && opts.nocase !== opts.scurry.nocase) {
-        throw new Error("nocase option contradicts provided scurry option");
-      }
-    } else {
-      const Scurry = opts.platform === "win32" ? PathScurryWin32 : opts.platform === "darwin" ? PathScurryDarwin : opts.platform ? PathScurryPosix : PathScurry;
-      this.scurry = new Scurry(this.cwd, {
-        nocase: opts.nocase,
-        fs: opts.fs
-      });
-    }
-    this.nocase = this.scurry.nocase;
-    const nocaseMagicOnly = this.platform === "darwin" || this.platform === "win32";
-    const mmo = {
-      // default nocase based on platform
-      ...opts,
-      dot: this.dot,
-      matchBase: this.matchBase,
-      nobrace: this.nobrace,
-      nocase: this.nocase,
-      nocaseMagicOnly,
-      nocomment: true,
-      noext: this.noext,
-      nonegate: true,
-      optimizationLevel: 2,
-      platform: this.platform,
-      windowsPathsNoEscape: this.windowsPathsNoEscape,
-      debug: !!this.opts.debug
-    };
-    const mms = this.pattern.map((p) => new Minimatch(p, mmo));
-    const [matchSet, globParts] = mms.reduce((set, m) => {
-      set[0].push(...m.set);
-      set[1].push(...m.globParts);
-      return set;
-    }, [[], []]);
-    this.patterns = matchSet.map((set, i) => {
-      const g = globParts[i];
-      if (!g)
-        throw new Error("invalid pattern object");
-      return new Pattern(set, g, 0, this.platform);
-    });
-  }
-  async walk() {
-    return [
-      ...await new GlobWalker(this.patterns, this.scurry.cwd, {
-        ...this.opts,
-        maxDepth: this.maxDepth !== Infinity ? this.maxDepth + this.scurry.cwd.depth() : Infinity,
-        platform: this.platform,
-        nocase: this.nocase,
-        includeChildMatches: this.includeChildMatches
-      }).walk()
-    ];
-  }
-  walkSync() {
-    return [
-      ...new GlobWalker(this.patterns, this.scurry.cwd, {
-        ...this.opts,
-        maxDepth: this.maxDepth !== Infinity ? this.maxDepth + this.scurry.cwd.depth() : Infinity,
-        platform: this.platform,
-        nocase: this.nocase,
-        includeChildMatches: this.includeChildMatches
-      }).walkSync()
-    ];
-  }
-  stream() {
-    return new GlobStream(this.patterns, this.scurry.cwd, {
-      ...this.opts,
-      maxDepth: this.maxDepth !== Infinity ? this.maxDepth + this.scurry.cwd.depth() : Infinity,
-      platform: this.platform,
-      nocase: this.nocase,
-      includeChildMatches: this.includeChildMatches
-    }).stream();
-  }
-  streamSync() {
-    return new GlobStream(this.patterns, this.scurry.cwd, {
-      ...this.opts,
-      maxDepth: this.maxDepth !== Infinity ? this.maxDepth + this.scurry.cwd.depth() : Infinity,
-      platform: this.platform,
-      nocase: this.nocase,
-      includeChildMatches: this.includeChildMatches
-    }).streamSync();
-  }
-  /**
-   * Default sync iteration function. Returns a Generator that
-   * iterates over the results.
-   */
-  iterateSync() {
-    return this.streamSync()[Symbol.iterator]();
-  }
-  [Symbol.iterator]() {
-    return this.iterateSync();
-  }
-  /**
-   * Default async iteration function. Returns an AsyncGenerator that
-   * iterates over the results.
-   */
-  iterate() {
-    return this.stream()[Symbol.asyncIterator]();
-  }
-  [Symbol.asyncIterator]() {
-    return this.iterate();
-  }
-};
-
-// ../../node_modules/.bun/glob@11.1.0/node_modules/glob/dist/esm/has-magic.js
-var hasMagic = (pattern, options = {}) => {
-  if (!Array.isArray(pattern)) {
-    pattern = [pattern];
-  }
-  for (const p of pattern) {
-    if (new Minimatch(p, options).hasMagic())
-      return true;
-  }
-  return false;
-};
-
-// ../../node_modules/.bun/glob@11.1.0/node_modules/glob/dist/esm/index.js
-function globStreamSync(pattern, options = {}) {
-  return new Glob(pattern, options).streamSync();
-}
-function globStream(pattern, options = {}) {
-  return new Glob(pattern, options).stream();
-}
-function globSync(pattern, options = {}) {
-  return new Glob(pattern, options).walkSync();
-}
-async function glob_(pattern, options = {}) {
-  return new Glob(pattern, options).walk();
-}
-function globIterateSync(pattern, options = {}) {
-  return new Glob(pattern, options).iterateSync();
-}
-function globIterate(pattern, options = {}) {
-  return new Glob(pattern, options).iterate();
-}
-var streamSync = globStreamSync;
-var stream = Object.assign(globStream, { sync: globStreamSync });
-var iterateSync = globIterateSync;
-var iterate = Object.assign(globIterate, {
-  sync: globIterateSync
-});
-var sync = Object.assign(globSync, {
-  stream: globStreamSync,
-  iterate: globIterateSync
-});
-var glob = Object.assign(glob_, {
-  glob: glob_,
-  globSync,
-  sync,
-  globStream,
-  stream,
-  globStreamSync,
-  streamSync,
-  globIterate,
-  iterate,
-  globIterateSync,
-  iterateSync,
-  Glob,
-  hasMagic,
-  escape,
-  unescape
-});
-glob.glob = glob;
-
-// ../agent/src/tools/glob.ts
-z.object({
-  pattern: z.string().describe('Glob pattern to match files (e.g., "**/*.js", "src/**/*.ts", "*.json"). Supports standard glob syntax with *, **, and ? wildcards'),
-  path: z.string().optional().describe("Optional directory path to limit the search scope. If not provided, searches from the project root")
-});
-var RESULT_LIMIT = 100;
-var MTIME_BATCH_SIZE = 50;
-async function getMtimesBatched2(files) {
-  const results = [];
-  for (let i = 0; i < files.length; i += MTIME_BATCH_SIZE) {
-    const batch = files.slice(i, i + MTIME_BATCH_SIZE);
-    const batchResults = await Promise.all(
-      batch.map(async (filePath) => {
-        const mtime = await fsp__default.stat(filePath).then((stats) => stats.mtimeMs).catch(() => 0);
-        return { path: filePath, mtime };
-      })
-    );
-    results.push(...batchResults);
-  }
-  return results;
-}
-var globTool = async function(input, projectCwd) {
-  const { pattern, path: inputPath } = input;
-  if (!pattern) {
-    return {
-      success: false,
-      message: "Missing required parameter: pattern",
-      error: "MISSING_PATTERN"
-    };
+  onResume(fn) {
+    if (this.signal?.aborted)
+      return;
+    if (!this.paused) {
+      fn();
+    } else {
+      this.#onResume.push(fn);
+    }
   }
-  try {
-    const basePath = projectCwd || process.cwd();
-    const searchPath = inputPath ? resolveProjectPath(inputPath, basePath) : basePath;
-    if (!fs4__default.existsSync(searchPath)) {
-      return {
-        success: false,
-        message: `Directory not found: ${searchPath}`,
-        error: "DIR_NOT_FOUND"
-      };
+  // do the requisite realpath/stat checking, and return the path
+  // to add or undefined to filter it out.
+  async matchCheck(e, ifDir) {
+    if (ifDir && this.opts.nodir)
+      return void 0;
+    let rpc;
+    if (this.opts.realpath) {
+      rpc = e.realpathCached() || await e.realpath();
+      if (!rpc)
+        return void 0;
+      e = rpc;
     }
-    if (projectCwd && inputPath) {
-      const validation = validatePath(inputPath, projectCwd);
-      if (!validation.valid) {
-        return {
-          success: false,
-          message: validation.error || "Path validation failed",
-          error: "ACCESS_DENIED"
-        };
+    const needStat = e.isUnknown() || this.opts.stat;
+    const s = needStat ? await e.lstat() : e;
+    if (this.opts.follow && this.opts.nodir && s?.isSymbolicLink()) {
+      const target = await s.realpath();
+      if (target && (target.isUnknown() || this.opts.stat)) {
+        await target.lstat();
       }
     }
-    const matches = await glob(pattern, {
-      cwd: searchPath,
-      absolute: true,
-      nodir: true,
-      follow: false,
-      ignore: ["**/node_modules/**", "**/.git/**"]
-    });
-    const truncated = matches.length > RESULT_LIMIT;
-    const files = truncated ? matches.slice(0, RESULT_LIMIT) : matches;
-    let sortedFiles;
-    if (files.length > 0) {
-      const filesWithMtime = await getMtimesBatched2(files);
-      filesWithMtime.sort((a3, b) => b.mtime - a3.mtime);
-      sortedFiles = filesWithMtime.map((f) => f.path);
-    } else {
-      sortedFiles = files;
+    return this.matchCheckTest(s, ifDir);
+  }
+  matchCheckTest(e, ifDir) {
+    return e && (this.maxDepth === Infinity || e.depth() <= this.maxDepth) && (!ifDir || e.canReaddir()) && (!this.opts.nodir || !e.isDirectory()) && (!this.opts.nodir || !this.opts.follow || !e.isSymbolicLink() || !e.realpathCached()?.isDirectory()) && !this.#ignored(e) ? e : void 0;
+  }
+  matchCheckSync(e, ifDir) {
+    if (ifDir && this.opts.nodir)
+      return void 0;
+    let rpc;
+    if (this.opts.realpath) {
+      rpc = e.realpathCached() || e.realpathSync();
+      if (!rpc)
+        return void 0;
+      e = rpc;
     }
-    const output = [];
-    if (sortedFiles.length === 0) {
-      output.push("No files found");
-    } else {
-      output.push(...sortedFiles);
-      if (truncated) {
-        output.push("");
-        output.push("(Results are truncated. Consider using a more specific path or pattern.)");
+    const needStat = e.isUnknown() || this.opts.stat;
+    const s = needStat ? e.lstatSync() : e;
+    if (this.opts.follow && this.opts.nodir && s?.isSymbolicLink()) {
+      const target = s.realpathSync();
+      if (target && (target?.isUnknown() || this.opts.stat)) {
+        target.lstatSync();
       }
     }
-    const searchLocation = inputPath ? ` in "${inputPath}"` : " in current directory";
-    const message = `Found ${sortedFiles.length} matches for pattern "${pattern}"${searchLocation}`;
-    return {
-      success: true,
-      message,
-      metadata: {
-        count: sortedFiles.length,
-        truncated
-      },
-      content: output.join("\n")
-    };
-  } catch (error) {
-    console.error("[glob] error:", error);
-    return {
-      success: false,
-      message: `Failed to find files matching pattern: ${pattern}`,
-      error: "GLOB_ERROR"
-    };
-  }
-};
-var DEFAULT_IGNORE_PATTERNS = [
-  "node_modules",
-  "__pycache__",
-  ".git",
-  "dist",
-  "build",
-  "target",
-  "vendor",
-  "bin",
-  "obj",
-  ".idea",
-  ".vscode",
-  ".zig-cache",
-  "zig-out",
-  ".coverage",
-  "coverage",
-  "tmp",
-  "temp",
-  ".cache",
-  "cache",
-  "logs",
-  ".venv",
-  "venv",
-  "env",
-  ".next",
-  ".turbo",
-  ".vercel",
-  ".output"
-];
-var RESULT_LIMIT2 = 500;
-var MTIME_BATCH_SIZE2 = 50;
-z.object({
-  path: z.string().optional().describe("Path to the directory to list"),
-  recursive: z.boolean().optional().describe("Whether to list files recursively (default: true)"),
-  maxDepth: z.number().optional().describe("Maximum recursion depth (default: 3)"),
-  pattern: z.string().optional().describe("File extension (e.g., '.ts') or glob-like pattern"),
-  showHidden: z.boolean().optional().describe("Whether to show hidden files (default: false)"),
-  includeMetadata: z.boolean().optional().describe("Whether to fetch file metadata like mtime (default: false -- faster without I/O)"),
-  ignore: z.array(z.string()).optional().describe("Additional glob patterns to ignore (added to default ignore list)")
-});
-function shouldIgnore(name, showHidden, ignoreSet) {
-  if (!showHidden && name.startsWith(".") && name !== ".") {
-    return true;
+    return this.matchCheckTest(s, ifDir);
   }
-  return ignoreSet.has(name);
-}
-function matchPattern(name, pattern) {
-  if (!pattern) return true;
-  if (pattern.startsWith(".") && !pattern.includes("*")) {
-    return name.endsWith(pattern);
-  }
-  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
-  const regex = new RegExp(`^${escaped}$`, "i");
-  return regex.test(name);
-}
-async function getMtimesBatched3(entries) {
-  for (let i = 0; i < entries.length; i += MTIME_BATCH_SIZE2) {
-    const batch = entries.slice(i, i + MTIME_BATCH_SIZE2);
-    await Promise.all(
-      batch.map(async (entry) => {
-        entry.mtime = await fsp__default.stat(entry.absolutePath).then((stats) => stats.mtimeMs).catch(() => 0);
-      })
-    );
+  matchFinish(e, absolute) {
+    if (this.#ignored(e))
+      return;
+    if (!this.includeChildMatches && this.#ignore?.add) {
+      const ign = `${e.relativePosix()}/**`;
+      this.#ignore.add(ign);
+    }
+    const abs = this.opts.absolute === void 0 ? absolute : this.opts.absolute;
+    this.seen.add(e);
+    const mark = this.opts.mark && e.isDirectory() ? this.#sep : "";
+    if (this.opts.withFileTypes) {
+      this.matchEmit(e);
+    } else if (abs) {
+      const abs2 = this.opts.posix ? e.fullpathPosix() : e.fullpath();
+      this.matchEmit(abs2 + mark);
+    } else {
+      const rel = this.opts.posix ? e.relativePosix() : e.relative();
+      const pre = this.opts.dotRelative && !rel.startsWith(".." + this.#sep) ? "." + this.#sep : "";
+      this.matchEmit(!rel ? "." + mark : pre + rel + mark);
+    }
   }
-}
-function buildTreeOutput(entries, basePath) {
-  const tree = /* @__PURE__ */ new Map();
-  for (const entry of entries) {
-    const dir = path6.dirname(entry.relativePath);
-    const dirKey = dir === "." ? "" : dir;
-    if (!tree.has(dirKey)) {
-      tree.set(dirKey, []);
-    }
-    tree.get(dirKey).push(entry);
-  }
-  for (const [, items] of tree) {
-    items.sort((a3, b) => {
-      if (a3.type !== b.type) {
-        return a3.type === "directory" ? -1 : 1;
-      }
-      return a3.name.localeCompare(b.name);
-    });
+  async match(e, absolute, ifDir) {
+    const p = await this.matchCheck(e, ifDir);
+    if (p)
+      this.matchFinish(p, absolute);
   }
-  const lines = [`${basePath}/`];
-  function renderLevel(dirPath, indent) {
-    const items = tree.get(dirPath) || [];
-    for (let i = 0; i < items.length; i++) {
-      const item = items[i];
-      const isLast = i === items.length - 1;
-      const prefix = isLast ? "\u2514\u2500\u2500 " : "\u251C\u2500\u2500 ";
-      const childIndent = indent + (isLast ? "    " : "\u2502   ");
-      if (item.type === "directory") {
-        lines.push(`${indent}${prefix}${item.name}/`);
-        const childPath = dirPath ? `${dirPath}/${item.name}` : item.name;
-        renderLevel(childPath, childIndent);
-      } else {
-        lines.push(`${indent}${prefix}${item.name}`);
-      }
-    }
+  matchSync(e, absolute, ifDir) {
+    const p = this.matchCheckSync(e, ifDir);
+    if (p)
+      this.matchFinish(p, absolute);
   }
-  renderLevel("", "");
-  return lines.join("\n");
-}
-var list = async function(input, projectCwd) {
-  const {
-    path: relativePath,
-    recursive = true,
-    maxDepth = 3,
-    pattern,
-    showHidden = false,
-    includeMetadata = false,
-    ignore: extraIgnore
-  } = input;
-  if (maxDepth !== void 0 && (!Number.isInteger(maxDepth) || maxDepth < 0)) {
-    return {
-      success: false,
-      message: "maxDepth must be a non-negative integer",
-      error: "INVALID_MAX_DEPTH"
-    };
+  walkCB(target, patterns, cb) {
+    if (this.signal?.aborted)
+      cb();
+    this.walkCB2(target, patterns, new Processor(this.opts), cb);
   }
-  try {
-    const basePath = projectCwd || process.cwd();
-    const absolutePath = relativePath ? resolveProjectPath(relativePath, basePath) : basePath;
-    if (projectCwd && relativePath) {
-      const validation = validatePath(relativePath, projectCwd);
-      if (!validation.valid) {
-        return {
-          success: false,
-          message: validation.error || "Path validation failed",
-          error: "ACCESS_DENIED"
-        };
-      }
-    }
-    if (!fs4__default.existsSync(absolutePath)) {
-      return {
-        success: false,
-        message: `Directory not found: ${absolutePath}`,
-        error: "DIR_NOT_FOUND"
-      };
-    }
-    const stats = fs4__default.statSync(absolutePath);
-    if (!stats.isDirectory()) {
-      return {
-        success: false,
-        message: `Path is not a directory: ${absolutePath}`,
-        error: "NOT_A_DIRECTORY"
-      };
+  walkCB2(target, patterns, processor, cb) {
+    if (this.#childrenIgnored(target))
+      return cb();
+    if (this.signal?.aborted)
+      cb();
+    if (this.paused) {
+      this.onResume(() => this.walkCB2(target, patterns, processor, cb));
+      return;
     }
-    const ignoreSet = new Set(DEFAULT_IGNORE_PATTERNS);
-    if (extraIgnore && extraIgnore.length > 0) {
-      for (const pat of extraIgnore) {
-        ignoreSet.add(pat);
-      }
+    processor.processPatterns(target, patterns);
+    let tasks = 1;
+    const next = () => {
+      if (--tasks === 0)
+        cb();
+    };
+    for (const [m, absolute, ifDir] of processor.matches.entries()) {
+      if (this.#ignored(m))
+        continue;
+      tasks++;
+      this.match(m, absolute, ifDir).then(() => next());
     }
-    const collected = [];
-    let truncated = false;
-    const walk = async (currentDir, depth) => {
-      if (collected.length >= RESULT_LIMIT2) {
-        truncated = true;
-        return;
-      }
-      let entries;
-      try {
-        entries = fs4__default.readdirSync(currentDir, { withFileTypes: true });
-      } catch {
-        return;
+    for (const t of processor.subwalkTargets()) {
+      if (this.maxDepth !== Infinity && t.depth() >= this.maxDepth) {
+        continue;
       }
-      entries.sort((a3, b) => {
-        if (a3.isDirectory() !== b.isDirectory()) {
-          return a3.isDirectory() ? -1 : 1;
-        }
-        return a3.name.localeCompare(b.name);
-      });
-      for (const entry of entries) {
-        if (collected.length >= RESULT_LIMIT2) {
-          truncated = true;
-          break;
-        }
-        if (shouldIgnore(entry.name, showHidden, ignoreSet)) {
-          continue;
-        }
-        const entryAbsolutePath = path6.join(currentDir, entry.name);
-        const entryRelativePath = path6.relative(absolutePath, entryAbsolutePath);
-        if (entry.isDirectory()) {
-          collected.push({
-            name: entry.name,
-            absolutePath: entryAbsolutePath,
-            relativePath: entryRelativePath,
-            type: "directory",
-            mtime: 0,
-            depth
-          });
-          if (recursive && depth < maxDepth) {
-            await walk(entryAbsolutePath, depth + 1);
-          }
-        } else if (entry.isFile()) {
-          if (matchPattern(entry.name, pattern)) {
-            collected.push({
-              name: entry.name,
-              absolutePath: entryAbsolutePath,
-              relativePath: entryRelativePath,
-              type: "file",
-              mtime: 0,
-              depth
-            });
-          }
-        }
+      tasks++;
+      const childrenCached = t.readdirCached();
+      if (t.calledReaddir())
+        this.walkCB3(t, childrenCached, processor, next);
+      else {
+        t.readdirCB((_, entries) => this.walkCB3(t, entries, processor, next), true);
       }
-    };
-    await walk(absolutePath, 0);
-    if (includeMetadata) {
-      await getMtimesBatched3(collected);
-    }
-    const totalFiles = collected.filter((item) => item.type === "file").length;
-    const totalDirectories = collected.filter((item) => item.type === "directory").length;
-    const treeOutput = buildTreeOutput(collected, relativePath || path6.basename(absolutePath));
-    let message = `Listed ${collected.length} items`;
-    if (relativePath) {
-      message += ` in "${relativePath}"`;
-    }
-    message += ` (${totalFiles} files, ${totalDirectories} directories)`;
-    if (recursive) {
-      message += ` [depth: ${maxDepth}]`;
-    }
-    if (pattern) {
-      message += ` [filter: ${pattern}]`;
-    }
-    if (truncated) {
-      message += ` [TRUNCATED at ${RESULT_LIMIT2} items]`;
-    }
-    const files = collected.map((item) => ({
-      name: item.name,
-      path: item.relativePath,
-      type: item.type
-    }));
-    return {
-      success: true,
-      message,
-      metadata: {
-        totalFiles,
-        totalDirectories,
-        totalItems: collected.length,
-        truncated,
-        maxDepth,
-        recursive
-      },
-      files,
-      content: treeOutput
-    };
-  } catch (error) {
-    console.error("[list] error:", error);
-    return {
-      success: false,
-      message: `Failed to list directory: ${error}`,
-      error: "LIST_ERROR"
-    };
+    }
+    next();
   }
-};
-
-// ../../node_modules/.bun/diff@8.0.3/node_modules/diff/libesm/diff/base.js
-var Diff = class {
-  diff(oldStr, newStr, options = {}) {
-    let callback;
-    if (typeof options === "function") {
-      callback = options;
-      options = {};
-    } else if ("callback" in options) {
-      callback = options.callback;
-    }
-    const oldString = this.castInput(oldStr, options);
-    const newString = this.castInput(newStr, options);
-    const oldTokens = this.removeEmpty(this.tokenize(oldString, options));
-    const newTokens = this.removeEmpty(this.tokenize(newString, options));
-    return this.diffWithOptionsObj(oldTokens, newTokens, options, callback);
-  }
-  diffWithOptionsObj(oldTokens, newTokens, options, callback) {
-    var _a;
-    const done = (value) => {
-      value = this.postProcess(value, options);
-      if (callback) {
-        setTimeout(function() {
-          callback(value);
-        }, 0);
-        return void 0;
-      } else {
-        return value;
-      }
-    };
-    const newLen = newTokens.length, oldLen = oldTokens.length;
-    let editLength = 1;
-    let maxEditLength = newLen + oldLen;
-    if (options.maxEditLength != null) {
-      maxEditLength = Math.min(maxEditLength, options.maxEditLength);
-    }
-    const maxExecutionTime = (_a = options.timeout) !== null && _a !== void 0 ? _a : Infinity;
-    const abortAfterTimestamp = Date.now() + maxExecutionTime;
-    const bestPath = [{ oldPos: -1, lastComponent: void 0 }];
-    let newPos = this.extractCommon(bestPath[0], newTokens, oldTokens, 0, options);
-    if (bestPath[0].oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
-      return done(this.buildValues(bestPath[0].lastComponent, newTokens, oldTokens));
-    }
-    let minDiagonalToConsider = -Infinity, maxDiagonalToConsider = Infinity;
-    const execEditLength = () => {
-      for (let diagonalPath = Math.max(minDiagonalToConsider, -editLength); diagonalPath <= Math.min(maxDiagonalToConsider, editLength); diagonalPath += 2) {
-        let basePath;
-        const removePath = bestPath[diagonalPath - 1], addPath = bestPath[diagonalPath + 1];
-        if (removePath) {
-          bestPath[diagonalPath - 1] = void 0;
-        }
-        let canAdd = false;
-        if (addPath) {
-          const addPathNewPos = addPath.oldPos - diagonalPath;
-          canAdd = addPath && 0 <= addPathNewPos && addPathNewPos < newLen;
-        }
-        const canRemove = removePath && removePath.oldPos + 1 < oldLen;
-        if (!canAdd && !canRemove) {
-          bestPath[diagonalPath] = void 0;
-          continue;
-        }
-        if (!canRemove || canAdd && removePath.oldPos < addPath.oldPos) {
-          basePath = this.addToPath(addPath, true, false, 0, options);
-        } else {
-          basePath = this.addToPath(removePath, false, true, 1, options);
-        }
-        newPos = this.extractCommon(basePath, newTokens, oldTokens, diagonalPath, options);
-        if (basePath.oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
-          return done(this.buildValues(basePath.lastComponent, newTokens, oldTokens)) || true;
-        } else {
-          bestPath[diagonalPath] = basePath;
-          if (basePath.oldPos + 1 >= oldLen) {
-            maxDiagonalToConsider = Math.min(maxDiagonalToConsider, diagonalPath - 1);
-          }
-          if (newPos + 1 >= newLen) {
-            minDiagonalToConsider = Math.max(minDiagonalToConsider, diagonalPath + 1);
-          }
-        }
-      }
-      editLength++;
+  walkCB3(target, entries, processor, cb) {
+    processor = processor.filterEntries(target, entries);
+    let tasks = 1;
+    const next = () => {
+      if (--tasks === 0)
+        cb();
     };
-    if (callback) {
-      (function exec2() {
-        setTimeout(function() {
-          if (editLength > maxEditLength || Date.now() > abortAfterTimestamp) {
-            return callback(void 0);
-          }
-          if (!execEditLength()) {
-            exec2();
-          }
-        }, 0);
-      })();
-    } else {
-      while (editLength <= maxEditLength && Date.now() <= abortAfterTimestamp) {
-        const ret = execEditLength();
-        if (ret) {
-          return ret;
-        }
-      }
+    for (const [m, absolute, ifDir] of processor.matches.entries()) {
+      if (this.#ignored(m))
+        continue;
+      tasks++;
+      this.match(m, absolute, ifDir).then(() => next());
     }
-  }
-  addToPath(path17, added, removed, oldPosInc, options) {
-    const last = path17.lastComponent;
-    if (last && !options.oneChangePerToken && last.added === added && last.removed === removed) {
-      return {
-        oldPos: path17.oldPos + oldPosInc,
-        lastComponent: { count: last.count + 1, added, removed, previousComponent: last.previousComponent }
-      };
-    } else {
-      return {
-        oldPos: path17.oldPos + oldPosInc,
-        lastComponent: { count: 1, added, removed, previousComponent: last }
-      };
+    for (const [target2, patterns] of processor.subwalks.entries()) {
+      tasks++;
+      this.walkCB2(target2, patterns, processor.child(), next);
     }
+    next();
   }
-  extractCommon(basePath, newTokens, oldTokens, diagonalPath, options) {
-    const newLen = newTokens.length, oldLen = oldTokens.length;
-    let oldPos = basePath.oldPos, newPos = oldPos - diagonalPath, commonCount = 0;
-    while (newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(oldTokens[oldPos + 1], newTokens[newPos + 1], options)) {
-      newPos++;
-      oldPos++;
-      commonCount++;
-      if (options.oneChangePerToken) {
-        basePath.lastComponent = { count: 1, previousComponent: basePath.lastComponent, added: false, removed: false };
-      }
+  walkCBSync(target, patterns, cb) {
+    if (this.signal?.aborted)
+      cb();
+    this.walkCB2Sync(target, patterns, new Processor(this.opts), cb);
+  }
+  walkCB2Sync(target, patterns, processor, cb) {
+    if (this.#childrenIgnored(target))
+      return cb();
+    if (this.signal?.aborted)
+      cb();
+    if (this.paused) {
+      this.onResume(() => this.walkCB2Sync(target, patterns, processor, cb));
+      return;
+    }
+    processor.processPatterns(target, patterns);
+    let tasks = 1;
+    const next = () => {
+      if (--tasks === 0)
+        cb();
+    };
+    for (const [m, absolute, ifDir] of processor.matches.entries()) {
+      if (this.#ignored(m))
+        continue;
+      this.matchSync(m, absolute, ifDir);
     }
-    if (commonCount && !options.oneChangePerToken) {
-      basePath.lastComponent = { count: commonCount, previousComponent: basePath.lastComponent, added: false, removed: false };
+    for (const t of processor.subwalkTargets()) {
+      if (this.maxDepth !== Infinity && t.depth() >= this.maxDepth) {
+        continue;
+      }
+      tasks++;
+      const children = t.readdirSync();
+      this.walkCB3Sync(t, children, processor, next);
     }
-    basePath.oldPos = oldPos;
-    return newPos;
+    next();
   }
-  equals(left, right, options) {
-    if (options.comparator) {
-      return options.comparator(left, right);
-    } else {
-      return left === right || !!options.ignoreCase && left.toLowerCase() === right.toLowerCase();
+  walkCB3Sync(target, entries, processor, cb) {
+    processor = processor.filterEntries(target, entries);
+    let tasks = 1;
+    const next = () => {
+      if (--tasks === 0)
+        cb();
+    };
+    for (const [m, absolute, ifDir] of processor.matches.entries()) {
+      if (this.#ignored(m))
+        continue;
+      this.matchSync(m, absolute, ifDir);
     }
-  }
-  removeEmpty(array) {
-    const ret = [];
-    for (let i = 0; i < array.length; i++) {
-      if (array[i]) {
-        ret.push(array[i]);
-      }
+    for (const [target2, patterns] of processor.subwalks.entries()) {
+      tasks++;
+      this.walkCB2Sync(target2, patterns, processor.child(), next);
     }
-    return ret;
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  castInput(value, options) {
-    return value;
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  tokenize(value, options) {
-    return Array.from(value);
-  }
-  join(chars) {
-    return chars.join("");
+    next();
   }
-  postProcess(changeObjects, options) {
-    return changeObjects;
+};
+var GlobWalker = class extends GlobUtil {
+  matches = /* @__PURE__ */ new Set();
+  constructor(patterns, path15, opts) {
+    super(patterns, path15, opts);
   }
-  get useLongestToken() {
-    return false;
+  matchEmit(e) {
+    this.matches.add(e);
   }
-  buildValues(lastComponent, newTokens, oldTokens) {
-    const components = [];
-    let nextComponent;
-    while (lastComponent) {
-      components.push(lastComponent);
-      nextComponent = lastComponent.previousComponent;
-      delete lastComponent.previousComponent;
-      lastComponent = nextComponent;
-    }
-    components.reverse();
-    const componentLen = components.length;
-    let componentPos = 0, newPos = 0, oldPos = 0;
-    for (; componentPos < componentLen; componentPos++) {
-      const component = components[componentPos];
-      if (!component.removed) {
-        if (!component.added && this.useLongestToken) {
-          let value = newTokens.slice(newPos, newPos + component.count);
-          value = value.map(function(value2, i) {
-            const oldValue = oldTokens[oldPos + i];
-            return oldValue.length > value2.length ? oldValue : value2;
-          });
-          component.value = this.join(value);
+  async walk() {
+    if (this.signal?.aborted)
+      throw this.signal.reason;
+    if (this.path.isUnknown()) {
+      await this.path.lstat();
+    }
+    await new Promise((res, rej) => {
+      this.walkCB(this.path, this.patterns, () => {
+        if (this.signal?.aborted) {
+          rej(this.signal.reason);
         } else {
-          component.value = this.join(newTokens.slice(newPos, newPos + component.count));
-        }
-        newPos += component.count;
-        if (!component.added) {
-          oldPos += component.count;
+          res(this.matches);
         }
-      } else {
-        component.value = this.join(oldTokens.slice(oldPos, oldPos + component.count));
-        oldPos += component.count;
-      }
+      });
+    });
+    return this.matches;
+  }
+  walkSync() {
+    if (this.signal?.aborted)
+      throw this.signal.reason;
+    if (this.path.isUnknown()) {
+      this.path.lstatSync();
     }
-    return components;
+    this.walkCBSync(this.path, this.patterns, () => {
+      if (this.signal?.aborted)
+        throw this.signal.reason;
+    });
+    return this.matches;
   }
 };
-
-// ../../node_modules/.bun/diff@8.0.3/node_modules/diff/libesm/diff/line.js
-var LineDiff = class extends Diff {
-  constructor() {
-    super(...arguments);
-    this.tokenize = tokenize;
+var GlobStream = class extends GlobUtil {
+  results;
+  constructor(patterns, path15, opts) {
+    super(patterns, path15, opts);
+    this.results = new Minipass({
+      signal: this.signal,
+      objectMode: true
+    });
+    this.results.on("drain", () => this.resume());
+    this.results.on("resume", () => this.resume());
   }
-  equals(left, right, options) {
-    if (options.ignoreWhitespace) {
-      if (!options.newlineIsToken || !left.includes("\n")) {
-        left = left.trim();
-      }
-      if (!options.newlineIsToken || !right.includes("\n")) {
-        right = right.trim();
-      }
-    } else if (options.ignoreNewlineAtEof && !options.newlineIsToken) {
-      if (left.endsWith("\n")) {
-        left = left.slice(0, -1);
-      }
-      if (right.endsWith("\n")) {
-        right = right.slice(0, -1);
-      }
-    }
-    return super.equals(left, right, options);
+  matchEmit(e) {
+    this.results.write(e);
+    if (!this.results.flowing)
+      this.pause();
   }
-};
-var lineDiff = new LineDiff();
-function diffLines(oldStr, newStr, options) {
-  return lineDiff.diff(oldStr, newStr, options);
-}
-function tokenize(value, options) {
-  if (options.stripTrailingCr) {
-    value = value.replace(/\r\n/g, "\n");
-  }
-  const retLines = [], linesAndNewlines = value.split(/(\n|\r\n)/);
-  if (!linesAndNewlines[linesAndNewlines.length - 1]) {
-    linesAndNewlines.pop();
-  }
-  for (let i = 0; i < linesAndNewlines.length; i++) {
-    const line = linesAndNewlines[i];
-    if (i % 2 && !options.newlineIsToken) {
-      retLines[retLines.length - 1] += line;
+  stream() {
+    const target = this.path;
+    if (target.isUnknown()) {
+      target.lstat().then(() => {
+        this.walkCB(target, this.patterns, () => this.results.end());
+      });
     } else {
-      retLines.push(line);
+      this.walkCB(target, this.patterns, () => this.results.end());
     }
+    return this.results;
   }
-  return retLines;
-}
-
-// ../agent/src/lib/diff.ts
-function calculateDiffStats(oldContent, newContent) {
-  const changes = diffLines(oldContent, newContent);
-  let linesAdded = 0;
-  let linesRemoved = 0;
-  for (const change of changes) {
-    if (change.added) {
-      linesAdded += change.count || 0;
-    } else if (change.removed) {
-      linesRemoved += change.count || 0;
-    }
-  }
-  return { linesAdded, linesRemoved };
-}
-
-// ../agent/src/tools/stringReplace.ts
-z.object({
-  file_path: z.string().describe("The path to the file you want to search and replace in. You can use either a relative path in the workspace or an absolute path. If an absolute path is provided, it will be preserved as is"),
-  new_string: z.string().describe("The edited text to replace the old_string (must be different from the old_string)"),
-  old_string: z.string().describe("The text to replace (must be unique within the file, and must match the file contents exactly, including all whitespace and indentation)"),
-  replaceAll: z.boolean().optional().describe("Replace all occurrences of old_string (default false)")
-});
-function levenshtein(a3, b) {
-  if (a3 === "" || b === "") return Math.max(a3.length, b.length);
-  const matrix = Array.from(
-    { length: a3.length + 1 },
-    (_, i) => Array.from({ length: b.length + 1 }, (_2, j) => i === 0 ? j : j === 0 ? i : 0)
-  );
-  for (let i = 1; i <= a3.length; i++) {
-    for (let j = 1; j <= b.length; j++) {
-      const cost = a3[i - 1] === b[j - 1] ? 0 : 1;
-      matrix[i][j] = Math.min(matrix[i - 1][j] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j - 1] + cost);
+  streamSync() {
+    if (this.path.isUnknown()) {
+      this.path.lstatSync();
     }
+    this.walkCBSync(this.path, this.patterns, () => this.results.end());
+    return this.results;
   }
-  return matrix[a3.length][b.length];
-}
-var SINGLE_CANDIDATE_SIMILARITY_THRESHOLD = 0;
-var MULTIPLE_CANDIDATES_SIMILARITY_THRESHOLD = 0.3;
-var SimpleReplacer = function* (_content, find) {
-  yield find;
 };
-var LineTrimmedReplacer = function* (content, find) {
-  const originalLines = content.split("\n");
-  const searchLines = find.split("\n");
-  if (searchLines[searchLines.length - 1] === "") searchLines.pop();
-  for (let i = 0; i <= originalLines.length - searchLines.length; i++) {
-    let matches = true;
-    for (let j = 0; j < searchLines.length; j++) {
-      if (originalLines[i + j].trim() !== searchLines[j].trim()) {
-        matches = false;
-        break;
-      }
+
+// ../../node_modules/.bun/glob@11.1.0/node_modules/glob/dist/esm/glob.js
+var defaultPlatform3 = typeof process === "object" && process && typeof process.platform === "string" ? process.platform : "linux";
+var Glob = class {
+  absolute;
+  cwd;
+  root;
+  dot;
+  dotRelative;
+  follow;
+  ignore;
+  magicalBraces;
+  mark;
+  matchBase;
+  maxDepth;
+  nobrace;
+  nocase;
+  nodir;
+  noext;
+  noglobstar;
+  pattern;
+  platform;
+  realpath;
+  scurry;
+  stat;
+  signal;
+  windowsPathsNoEscape;
+  withFileTypes;
+  includeChildMatches;
+  /**
+   * The options provided to the constructor.
+   */
+  opts;
+  /**
+   * An array of parsed immutable {@link Pattern} objects.
+   */
+  patterns;
+  /**
+   * All options are stored as properties on the `Glob` object.
+   *
+   * See {@link GlobOptions} for full options descriptions.
+   *
+   * Note that a previous `Glob` object can be passed as the
+   * `GlobOptions` to another `Glob` instantiation to re-use settings
+   * and caches with a new pattern.
+   *
+   * Traversal functions can be called multiple times to run the walk
+   * again.
+   */
+  constructor(pattern, opts) {
+    if (!opts)
+      throw new TypeError("glob options required");
+    this.withFileTypes = !!opts.withFileTypes;
+    this.signal = opts.signal;
+    this.follow = !!opts.follow;
+    this.dot = !!opts.dot;
+    this.dotRelative = !!opts.dotRelative;
+    this.nodir = !!opts.nodir;
+    this.mark = !!opts.mark;
+    if (!opts.cwd) {
+      this.cwd = "";
+    } else if (opts.cwd instanceof URL || opts.cwd.startsWith("file://")) {
+      opts.cwd = fileURLToPath(opts.cwd);
     }
-    if (matches) {
-      let matchStartIndex = 0;
-      for (let k = 0; k < i; k++) matchStartIndex += originalLines[k].length + 1;
-      let matchEndIndex = matchStartIndex;
-      for (let k = 0; k < searchLines.length; k++) {
-        matchEndIndex += originalLines[i + k].length;
-        if (k < searchLines.length - 1) matchEndIndex += 1;
-      }
-      yield content.substring(matchStartIndex, matchEndIndex);
+    this.cwd = opts.cwd || "";
+    this.root = opts.root;
+    this.magicalBraces = !!opts.magicalBraces;
+    this.nobrace = !!opts.nobrace;
+    this.noext = !!opts.noext;
+    this.realpath = !!opts.realpath;
+    this.absolute = opts.absolute;
+    this.includeChildMatches = opts.includeChildMatches !== false;
+    this.noglobstar = !!opts.noglobstar;
+    this.matchBase = !!opts.matchBase;
+    this.maxDepth = typeof opts.maxDepth === "number" ? opts.maxDepth : Infinity;
+    this.stat = !!opts.stat;
+    this.ignore = opts.ignore;
+    if (this.withFileTypes && this.absolute !== void 0) {
+      throw new Error("cannot set absolute and withFileTypes:true");
     }
-  }
-};
-var BlockAnchorReplacer = function* (content, find) {
-  const originalLines = content.split("\n");
-  const searchLines = find.split("\n");
-  if (searchLines.length < 3) return;
-  if (searchLines[searchLines.length - 1] === "") searchLines.pop();
-  const firstLineSearch = searchLines[0].trim();
-  const lastLineSearch = searchLines[searchLines.length - 1].trim();
-  const searchBlockSize = searchLines.length;
-  const candidates = [];
-  for (let i = 0; i < originalLines.length; i++) {
-    if (originalLines[i].trim() !== firstLineSearch) continue;
-    for (let j = i + 2; j < originalLines.length; j++) {
-      if (originalLines[j].trim() === lastLineSearch) {
-        candidates.push({ startLine: i, endLine: j });
-        break;
-      }
+    if (typeof pattern === "string") {
+      pattern = [pattern];
     }
-  }
-  if (candidates.length === 0) return;
-  const computeSimilarity = (startLine, endLine) => {
-    const actualBlockSize = endLine - startLine + 1;
-    const linesToCheck = Math.min(searchBlockSize - 2, actualBlockSize - 2);
-    if (linesToCheck <= 0) return 1;
-    let similarity = 0;
-    for (let j = 1; j < searchBlockSize - 1 && j < actualBlockSize - 1; j++) {
-      const originalLine = originalLines[startLine + j].trim();
-      const searchLine = searchLines[j].trim();
-      const maxLen = Math.max(originalLine.length, searchLine.length);
-      if (maxLen === 0) continue;
-      const distance = levenshtein(originalLine, searchLine);
-      similarity += (1 - distance / maxLen) / linesToCheck;
+    this.windowsPathsNoEscape = !!opts.windowsPathsNoEscape || opts.allowWindowsEscape === false;
+    if (this.windowsPathsNoEscape) {
+      pattern = pattern.map((p) => p.replace(/\\/g, "/"));
     }
-    return similarity;
-  };
-  const extractBlock = (startLine, endLine) => {
-    let matchStartIndex = 0;
-    for (let k = 0; k < startLine; k++) matchStartIndex += originalLines[k].length + 1;
-    let matchEndIndex = matchStartIndex;
-    for (let k = startLine; k <= endLine; k++) {
-      matchEndIndex += originalLines[k].length;
-      if (k < endLine) matchEndIndex += 1;
-    }
-    return content.substring(matchStartIndex, matchEndIndex);
-  };
-  if (candidates.length === 1) {
-    const { startLine, endLine } = candidates[0];
-    if (computeSimilarity(startLine, endLine) >= SINGLE_CANDIDATE_SIMILARITY_THRESHOLD) {
-      yield extractBlock(startLine, endLine);
+    if (this.matchBase) {
+      if (opts.noglobstar) {
+        throw new TypeError("base matching requires globstar");
+      }
+      pattern = pattern.map((p) => p.includes("/") ? p : `./**/${p}`);
     }
-    return;
-  }
-  let bestMatch = null;
-  let maxSimilarity = -1;
-  for (const candidate of candidates) {
-    const similarity = computeSimilarity(candidate.startLine, candidate.endLine);
-    if (similarity > maxSimilarity) {
-      maxSimilarity = similarity;
-      bestMatch = candidate;
+    this.pattern = pattern;
+    this.platform = opts.platform || defaultPlatform3;
+    this.opts = { ...opts, platform: this.platform };
+    if (opts.scurry) {
+      this.scurry = opts.scurry;
+      if (opts.nocase !== void 0 && opts.nocase !== opts.scurry.nocase) {
+        throw new Error("nocase option contradicts provided scurry option");
+      }
+    } else {
+      const Scurry = opts.platform === "win32" ? PathScurryWin32 : opts.platform === "darwin" ? PathScurryDarwin : opts.platform ? PathScurryPosix : PathScurry;
+      this.scurry = new Scurry(this.cwd, {
+        nocase: opts.nocase,
+        fs: opts.fs
+      });
     }
+    this.nocase = this.scurry.nocase;
+    const nocaseMagicOnly = this.platform === "darwin" || this.platform === "win32";
+    const mmo = {
+      // default nocase based on platform
+      ...opts,
+      dot: this.dot,
+      matchBase: this.matchBase,
+      nobrace: this.nobrace,
+      nocase: this.nocase,
+      nocaseMagicOnly,
+      nocomment: true,
+      noext: this.noext,
+      nonegate: true,
+      optimizationLevel: 2,
+      platform: this.platform,
+      windowsPathsNoEscape: this.windowsPathsNoEscape,
+      debug: !!this.opts.debug
+    };
+    const mms = this.pattern.map((p) => new Minimatch(p, mmo));
+    const [matchSet, globParts] = mms.reduce((set, m) => {
+      set[0].push(...m.set);
+      set[1].push(...m.globParts);
+      return set;
+    }, [[], []]);
+    this.patterns = matchSet.map((set, i) => {
+      const g = globParts[i];
+      if (!g)
+        throw new Error("invalid pattern object");
+      return new Pattern(set, g, 0, this.platform);
+    });
   }
-  if (maxSimilarity >= MULTIPLE_CANDIDATES_SIMILARITY_THRESHOLD && bestMatch) {
-    yield extractBlock(bestMatch.startLine, bestMatch.endLine);
+  async walk() {
+    return [
+      ...await new GlobWalker(this.patterns, this.scurry.cwd, {
+        ...this.opts,
+        maxDepth: this.maxDepth !== Infinity ? this.maxDepth + this.scurry.cwd.depth() : Infinity,
+        platform: this.platform,
+        nocase: this.nocase,
+        includeChildMatches: this.includeChildMatches
+      }).walk()
+    ];
   }
-};
-var WhitespaceNormalizedReplacer = function* (content, find) {
-  const normalizeWhitespace = (text) => text.replace(/\s+/g, " ").trim();
-  const normalizedFind = normalizeWhitespace(find);
-  const lines = content.split("\n");
-  for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    if (normalizeWhitespace(line) === normalizedFind) {
-      yield line;
-    } else {
-      const normalizedLine = normalizeWhitespace(line);
-      if (normalizedLine.includes(normalizedFind)) {
-        const words = find.trim().split(/\s+/);
-        if (words.length > 0) {
-          const pattern = words.map((word) => word.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("\\s+");
-          try {
-            const regex = new RegExp(pattern);
-            const match2 = line.match(regex);
-            if (match2) yield match2[0];
-          } catch {
-          }
-        }
-      }
-    }
+  walkSync() {
+    return [
+      ...new GlobWalker(this.patterns, this.scurry.cwd, {
+        ...this.opts,
+        maxDepth: this.maxDepth !== Infinity ? this.maxDepth + this.scurry.cwd.depth() : Infinity,
+        platform: this.platform,
+        nocase: this.nocase,
+        includeChildMatches: this.includeChildMatches
+      }).walkSync()
+    ];
   }
-  const findLines = find.split("\n");
-  if (findLines.length > 1) {
-    for (let i = 0; i <= lines.length - findLines.length; i++) {
-      const block = lines.slice(i, i + findLines.length);
-      if (normalizeWhitespace(block.join("\n")) === normalizedFind) {
-        yield block.join("\n");
-      }
-    }
+  stream() {
+    return new GlobStream(this.patterns, this.scurry.cwd, {
+      ...this.opts,
+      maxDepth: this.maxDepth !== Infinity ? this.maxDepth + this.scurry.cwd.depth() : Infinity,
+      platform: this.platform,
+      nocase: this.nocase,
+      includeChildMatches: this.includeChildMatches
+    }).stream();
   }
-};
-var IndentationFlexibleReplacer = function* (content, find) {
-  const removeIndentation = (text) => {
-    const lines = text.split("\n");
-    const nonEmptyLines = lines.filter((line) => line.trim().length > 0);
-    if (nonEmptyLines.length === 0) return text;
-    const minIndent = Math.min(
-      ...nonEmptyLines.map((line) => {
-        const match2 = line.match(/^(\s*)/);
-        return match2 ? match2[1].length : 0;
-      })
-    );
-    return lines.map((line) => line.trim().length === 0 ? line : line.slice(minIndent)).join("\n");
-  };
-  const normalizedFind = removeIndentation(find);
-  const contentLines = content.split("\n");
-  const findLines = find.split("\n");
-  for (let i = 0; i <= contentLines.length - findLines.length; i++) {
-    const block = contentLines.slice(i, i + findLines.length).join("\n");
-    if (removeIndentation(block) === normalizedFind) {
-      yield block;
-    }
+  streamSync() {
+    return new GlobStream(this.patterns, this.scurry.cwd, {
+      ...this.opts,
+      maxDepth: this.maxDepth !== Infinity ? this.maxDepth + this.scurry.cwd.depth() : Infinity,
+      platform: this.platform,
+      nocase: this.nocase,
+      includeChildMatches: this.includeChildMatches
+    }).streamSync();
   }
-};
-var EscapeNormalizedReplacer = function* (content, find) {
-  const unescapeString = (str) => {
-    return str.replace(/\\(n|t|r|'|"|`|\\|\n|\$)/g, (match2, capturedChar) => {
-      switch (capturedChar) {
-        case "n":
-          return "\n";
-        case "t":
-          return "	";
-        case "r":
-          return "\r";
-        case "'":
-          return "'";
-        case '"':
-          return '"';
-        case "`":
-          return "`";
-        case "\\":
-          return "\\";
-        case "\n":
-          return "\n";
-        case "$":
-          return "$";
-        default:
-          return match2;
-      }
-    });
-  };
-  const unescapedFind = unescapeString(find);
-  if (content.includes(unescapedFind)) {
-    yield unescapedFind;
+  /**
+   * Default sync iteration function. Returns a Generator that
+   * iterates over the results.
+   */
+  iterateSync() {
+    return this.streamSync()[Symbol.iterator]();
   }
-  const lines = content.split("\n");
-  const findLines = unescapedFind.split("\n");
-  for (let i = 0; i <= lines.length - findLines.length; i++) {
-    const block = lines.slice(i, i + findLines.length).join("\n");
-    if (unescapeString(block) === unescapedFind) {
-      yield block;
-    }
+  [Symbol.iterator]() {
+    return this.iterateSync();
   }
-};
-var TrimmedBoundaryReplacer = function* (content, find) {
-  const trimmedFind = find.trim();
-  if (trimmedFind === find) return;
-  if (content.includes(trimmedFind)) {
-    yield trimmedFind;
+  /**
+   * Default async iteration function. Returns an AsyncGenerator that
+   * iterates over the results.
+   */
+  iterate() {
+    return this.stream()[Symbol.asyncIterator]();
   }
-  const lines = content.split("\n");
-  const findLines = find.split("\n");
-  for (let i = 0; i <= lines.length - findLines.length; i++) {
-    const block = lines.slice(i, i + findLines.length).join("\n");
-    if (block.trim() === trimmedFind) {
-      yield block;
-    }
+  [Symbol.asyncIterator]() {
+    return this.iterate();
   }
 };
-var ContextAwareReplacer = function* (content, find) {
-  const findLines = find.split("\n");
-  if (findLines.length < 3) return;
-  if (findLines[findLines.length - 1] === "") findLines.pop();
-  const contentLines = content.split("\n");
-  const firstLine = findLines[0].trim();
-  const lastLine = findLines[findLines.length - 1].trim();
-  for (let i = 0; i < contentLines.length; i++) {
-    if (contentLines[i].trim() !== firstLine) continue;
-    for (let j = i + 2; j < contentLines.length; j++) {
-      if (contentLines[j].trim() === lastLine) {
-        const blockLines = contentLines.slice(i, j + 1);
-        if (blockLines.length === findLines.length) {
-          let matchingLines = 0;
-          let totalNonEmptyLines = 0;
-          for (let k = 1; k < blockLines.length - 1; k++) {
-            const blockLine = blockLines[k].trim();
-            const findLine = findLines[k].trim();
-            if (blockLine.length > 0 || findLine.length > 0) {
-              totalNonEmptyLines++;
-              if (blockLine === findLine) matchingLines++;
-            }
-          }
-          if (totalNonEmptyLines === 0 || matchingLines / totalNonEmptyLines >= 0.5) {
-            yield blockLines.join("\n");
-            break;
-          }
-        }
-        break;
-      }
-    }
+
+// ../../node_modules/.bun/glob@11.1.0/node_modules/glob/dist/esm/has-magic.js
+var hasMagic = (pattern, options = {}) => {
+  if (!Array.isArray(pattern)) {
+    pattern = [pattern];
   }
-};
-var MultiOccurrenceReplacer = function* (content, find) {
-  let startIndex = 0;
-  while (true) {
-    const index = content.indexOf(find, startIndex);
-    if (index === -1) break;
-    yield find;
-    startIndex = index + find.length;
+  for (const p of pattern) {
+    if (new Minimatch(p, options).hasMagic())
+      return true;
   }
+  return false;
 };
-var REPLACERS = [
-  SimpleReplacer,
-  LineTrimmedReplacer,
-  BlockAnchorReplacer,
-  WhitespaceNormalizedReplacer,
-  IndentationFlexibleReplacer,
-  EscapeNormalizedReplacer,
-  TrimmedBoundaryReplacer,
-  ContextAwareReplacer,
-  MultiOccurrenceReplacer
-];
-function smartReplace(content, oldString, newString, replaceAll = false) {
-  if (oldString === newString) {
-    throw new Error("No changes to apply: oldString and newString are identical.");
-  }
-  let notFound = true;
-  for (const replacer of REPLACERS) {
-    for (const search of replacer(content, oldString)) {
-      const index = content.indexOf(search);
-      if (index === -1) continue;
-      notFound = false;
-      if (replaceAll) {
-        return content.replaceAll(search, newString);
-      }
-      const lastIndex = content.lastIndexOf(search);
-      if (index !== lastIndex) continue;
-      return content.substring(0, index) + newString + content.substring(index + search.length);
-    }
-  }
-  if (notFound) {
-    throw new Error(
-      "oldString not found in content. It must match the file contents exactly, including whitespace, indentation, and line endings."
-    );
-  }
-  throw new Error(
-    "Found multiple matches for oldString. Provide more surrounding lines in oldString to identify the correct match."
-  );
+
+// ../../node_modules/.bun/glob@11.1.0/node_modules/glob/dist/esm/index.js
+function globStreamSync(pattern, options = {}) {
+  return new Glob(pattern, options).streamSync();
 }
-var apply_patch = async function(input, projectCwd) {
-  const { file_path, new_string, old_string, replaceAll: shouldReplaceAll = false } = input;
-  try {
-    if (!file_path) {
-      return {
-        success: false,
-        message: "Missing required parameter: file_path",
-        error: "MISSING_FILE_PATH"
-      };
-    }
-    if (old_string === void 0 || old_string === null) {
-      return {
-        success: false,
-        message: "Missing required parameter: old_string",
-        error: "MISSING_OLD_STRING"
-      };
-    }
-    if (new_string === void 0 || new_string === null) {
-      return {
-        success: false,
-        message: "Missing required parameter: new_string",
-        error: "MISSING_NEW_STRING"
-      };
-    }
-    if (old_string === new_string) {
-      return {
-        success: false,
-        message: "old_string and new_string must be different",
-        error: "STRINGS_IDENTICAL"
-      };
-    }
-    if (projectCwd) {
-      const validation = validatePath(file_path, projectCwd);
-      if (!validation.valid) {
-        return {
-          success: false,
-          message: validation.error || "Path validation failed",
-          error: "ACCESS_DENIED"
-        };
-      }
-    }
-    const basePath = projectCwd || process.cwd();
-    const absolute_file_path = resolveProjectPath(file_path, basePath);
-    let exists = true;
-    try {
-      await access(absolute_file_path, constants.F_OK);
-    } catch {
-      exists = false;
-    }
-    if (!exists) {
-      if (old_string === "") {
-        await mkdir(path6.dirname(absolute_file_path), { recursive: true });
-        await writeFile(absolute_file_path, new_string, "utf8");
-        const diffStats = calculateDiffStats("", new_string);
-        return {
-          success: true,
-          isNewFile: true,
-          old_string: "",
-          new_string,
-          linesAdded: diffStats.linesAdded,
-          linesRemoved: diffStats.linesRemoved,
-          message: `Created new file: ${file_path}`
-        };
-      }
-      return {
-        success: false,
-        message: `File not found: ${file_path}`,
-        error: "FILE_NOT_FOUND"
-      };
-    }
-    let fileContent;
-    try {
-      fileContent = await readFile(absolute_file_path, "utf8");
-    } catch (error) {
-      return {
-        success: false,
-        message: `Failed to read file: ${file_path}`,
-        error: "READ_ERROR"
-      };
-    }
-    let newContent;
-    try {
-      newContent = smartReplace(fileContent, old_string, new_string, shouldReplaceAll);
-    } catch (err) {
-      if (err.message.includes("not found")) {
-        return {
-          success: false,
-          message: `old_string not found in file: ${file_path}. Ensure it matches the file contents exactly, including whitespace and indentation.`,
-          error: "STRING_NOT_FOUND"
-        };
-      }
-      if (err.message.includes("multiple matches")) {
-        const occurrences = fileContent.split(old_string).length - 1;
-        return {
-          success: false,
-          message: `old_string appears ${occurrences > 1 ? occurrences + " times" : "multiple times (via fuzzy match)"} in the file. Provide more surrounding context to make it unique, or set replaceAll to true.`,
-          error: "STRING_NOT_UNIQUE"
-        };
-      }
-      return {
-        success: false,
-        message: err.message,
-        error: "REPLACE_ERROR"
-      };
-    }
-    try {
-      await writeFile(absolute_file_path, newContent, "utf8");
-      const diffStats = calculateDiffStats(fileContent, newContent);
-      return {
-        success: true,
-        old_string,
-        new_string,
-        linesAdded: diffStats.linesAdded,
-        linesRemoved: diffStats.linesRemoved,
-        message: `Successfully replaced string in file: ${file_path}`
-      };
-    } catch (error) {
-      return {
-        success: false,
-        message: `Failed to write to file: ${file_path}`,
-        error: "WRITE_ERROR"
-      };
-    }
-  } catch (error) {
-    return {
-      success: false,
-      message: `Unexpected error: ${error.message}`,
-      error: "UNEXPECTED_ERROR"
-    };
-  }
-};
+function globStream(pattern, options = {}) {
+  return new Glob(pattern, options).stream();
+}
+function globSync(pattern, options = {}) {
+  return new Glob(pattern, options).walkSync();
+}
+async function glob_(pattern, options = {}) {
+  return new Glob(pattern, options).walk();
+}
+function globIterateSync(pattern, options = {}) {
+  return new Glob(pattern, options).iterateSync();
+}
+function globIterate(pattern, options = {}) {
+  return new Glob(pattern, options).iterate();
+}
+var streamSync = globStreamSync;
+var stream = Object.assign(globStream, { sync: globStreamSync });
+var iterateSync = globIterateSync;
+var iterate = Object.assign(globIterate, {
+  sync: globIterateSync
+});
+var sync = Object.assign(globSync, {
+  stream: globStreamSync,
+  iterate: globIterateSync
+});
+var glob = Object.assign(glob_, {
+  glob: glob_,
+  globSync,
+  sync,
+  globStream,
+  stream,
+  globStreamSync,
+  streamSync,
+  globIterate,
+  iterate,
+  globIterateSync,
+  iterateSync,
+  Glob,
+  hasMagic,
+  escape,
+  unescape
+});
+glob.glob = glob;
 z.object({
-  target_file: z.string().describe("The relative path to the file to modify. The tool will create any directories in the path that don't exist"),
-  content: z.string().describe("The full content to write to the file"),
-  providedNewFile: z.boolean().describe("Whether this is a new file (true) or an edit to an existing file (false). Auto-detected if omitted.").optional()
+  pattern: z.string().describe("Glob pattern to match files, e.g. '*.ts', '**/*.json', or 'src/**/*.spec.ts'"),
+  path: z.string().optional().describe("Directory to search in (default: current directory)"),
+  limit: z.number().optional().describe("Maximum number of results (default: 1000)")
 });
-var editFiles = async function(input, projectCwd) {
-  const { target_file, content, providedNewFile } = input;
-  if (!target_file) {
-    return {
-      success: false,
-      error: "Missing required parameter: target_file",
-      message: "target_file is required"
-    };
-  }
-  try {
-    if (projectCwd) {
-      const validation = validatePath(target_file, projectCwd);
-      if (!validation.valid) {
-        return {
-          success: false,
-          error: validation.error || "Path validation failed",
-          message: `Failed to edit file: ${target_file}`
-        };
-      }
-    }
-    const basePath = projectCwd || process.cwd();
-    const filePath = resolveProjectPath(target_file, basePath);
-    const dirPath = path6.dirname(filePath);
-    await mkdir(dirPath, { recursive: true });
-    let isNewFile = providedNewFile;
-    let existingContent = "";
-    const fileExists = async () => {
-      try {
-        await access(filePath, constants.F_OK);
-        return true;
-      } catch {
-        return false;
-      }
-    };
-    if (isNewFile === void 0) {
-      const exists = await fileExists();
-      if (exists) {
-        existingContent = await readFile(filePath, "utf8");
-        isNewFile = false;
-      } else {
-        isNewFile = true;
+async function findTool(input, projectCwd) {
+  const cwd = input.path ? path6.resolve(projectCwd || process.cwd(), input.path) : projectCwd || process.cwd();
+  const limit = input.limit ?? 1e3;
+  const matches = await glob(input.pattern, { cwd, nodir: false, absolute: false, dot: true, ignore: ["**/.git/**", "**/node_modules/**"] });
+  const out = matches.slice(0, limit);
+  return { success: true, content: out.join("\n") || "No files found matching pattern" };
+}
+z.object({
+  pattern: z.string().describe("Search pattern (regex or literal string)"),
+  path: z.string().optional().describe("Directory or file to search (default: current directory)"),
+  glob: z.string().optional().describe("Filter files by glob pattern, e.g. '*.ts' or '**/*.spec.ts'"),
+  ignoreCase: z.boolean().optional().describe("Case-insensitive search (default: false)"),
+  literal: z.boolean().optional().describe("Treat pattern as literal string instead of regex (default: false)"),
+  context: z.number().optional().describe("Number of lines to show before and after each match (default: 0)"),
+  limit: z.number().optional().describe("Maximum number of matches to return (default: 100)")
+});
+async function grepTool(input, projectCwd) {
+  const searchPath = input.path ? path6.resolve(projectCwd || process.cwd(), input.path) : projectCwd || process.cwd();
+  const args = ["-nH", "--color=never", "--hidden", "--max-count", String(input.limit ?? 100)];
+  if (input.ignoreCase) args.push("-i");
+  if (input.literal) args.push("-F");
+  if (input.glob) args.push("--glob", input.glob);
+  if (input.context && input.context > 0) args.push("-C", String(input.context));
+  args.push("--", input.pattern, searchPath);
+  return new Promise((resolve) => {
+    const proc2 = spawn("rg", args, { stdio: ["ignore", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    proc2.stdout?.on("data", (d) => stdout += d.toString());
+    proc2.stderr?.on("data", (d) => stderr += d.toString());
+    proc2.on("close", (code) => {
+      if (code === 1) {
+        resolve({ success: true, content: "No matches found" });
+        return;
       }
-    } else if (!isNewFile) {
-      const exists = await fileExists();
-      if (exists) {
-        existingContent = await readFile(filePath, "utf8");
-      } else {
-        isNewFile = true;
+      if (code !== 0) {
+        resolve({ success: false, error: "GREP_ERROR", message: stderr || `rg exited ${code}` });
+        return;
       }
-    }
-    if (!isNewFile && existingContent === content) {
-      return {
-        success: true,
-        isNewFile: false,
-        message: `No changes needed: ${target_file} (content identical)`,
-        linesAdded: 0,
-        linesRemoved: 0
-      };
-    }
-    await writeFile(filePath, content, "utf8");
-    const diffStats = calculateDiffStats(existingContent, content);
-    if (isNewFile) {
-      return {
-        success: true,
-        isNewFile: true,
-        old_string: "",
-        new_string: content,
-        message: `Created new file: ${target_file} (+${diffStats.linesAdded} lines)`,
-        linesAdded: diffStats.linesAdded,
-        linesRemoved: diffStats.linesRemoved
-      };
-    } else {
-      return {
-        success: true,
-        isNewFile: false,
-        old_string: existingContent,
-        new_string: content,
-        message: `Modified file: ${target_file} (+${diffStats.linesAdded} -${diffStats.linesRemoved} lines)`,
-        linesAdded: diffStats.linesAdded,
-        linesRemoved: diffStats.linesRemoved
-      };
-    }
-  } catch (error) {
-    return {
-      success: false,
-      error: error instanceof Error ? error.message : "Unknown error",
-      message: `Failed to edit file: ${target_file}`
-    };
-  }
-};
-
-// ../agent/src/tools/batch.ts
-var toolCallSchema = z.object({
-  tool: z.string().describe("The name of the tool to execute"),
-  parameters: z.record(z.string(), z.unknown()).describe("Parameters for the tool")
+      resolve({ success: true, content: stdout.trim() });
+    });
+    proc2.on("error", (error) => resolve({ success: false, error: "GREP_ERROR", message: error.message }));
+  });
+}
+z.object({
+  path: z.string().optional().describe("Directory to list (default: current directory)"),
+  limit: z.number().optional().describe("Maximum number of entries to return (default: 500)")
 });
+async function lsTool(input, projectCwd) {
+  const dir = input.path ? path6.resolve(projectCwd || process.cwd(), input.path) : projectCwd || process.cwd();
+  const names = (await readdir(dir)).sort((a3, b) => a3.localeCompare(b));
+  const limit = input.limit ?? 500;
+  const out = [];
+  for (const n of names.slice(0, limit)) {
+    const s = await stat(path6.join(dir, n));
+    out.push(s.isDirectory() ? `${n}/` : n);
+  }
+  return { success: true, content: out.join("\n") || "(empty directory)" };
+}
 z.object({
-  tool_calls: z.array(toolCallSchema).min(1, "Provide at least one tool call").max(25, "Maximum of 25 tools allowed in batch").describe("Array of tool calls to execute in parallel")
+  path: z.string().describe("Path to the file to read (relative or absolute)"),
+  offset: z.number().optional().describe("Line number to start reading from (1-indexed)"),
+  limit: z.number().optional().describe("Maximum number of lines to read")
 });
-var DISALLOWED_TOOLS = /* @__PURE__ */ new Set(["batch"]);
-var MAX_CONCURRENCY = 5;
-var PER_CALL_TIMEOUT = 3e4;
-var MAX_BATCH_SIZE = 25;
-var batchableToolExecutors = {
-  deleteFile,
-  grep: grepTool,
-  glob: globTool,
-  listDirectory: list,
-  readFile: read_file,
-  bash: bashTool,
-  stringReplace: apply_patch,
-  editFile: editFiles
-};
-function withTimeout(promise, ms) {
-  return new Promise((resolve, reject) => {
-    const timer = setTimeout(() => {
-      reject(new Error(`BATCH_CALL_TIMEOUT: exceeded ${ms}ms`));
-    }, ms);
-    promise.then((v) => {
-      clearTimeout(timer);
-      resolve(v);
-    }).catch((e) => {
-      clearTimeout(timer);
-      reject(e);
-    });
-  });
+async function readTool(input, projectCwd) {
+  const absolute = path6.isAbsolute(input.path) ? input.path : path6.resolve(projectCwd || process.cwd(), input.path);
+  const s = await stat(absolute);
+  if (s.isDirectory()) {
+    const entries = (await readdir(absolute)).sort();
+    return { success: true, content: entries.join("\n") || "(empty directory)" };
+  }
+  const content = await readFile(absolute, "utf8");
+  const lines = content.split(/\r?\n/);
+  const start = input.offset ? Math.max(1, input.offset) : 1;
+  const end = input.limit ? start + input.limit - 1 : lines.length;
+  const slice = lines.slice(start - 1, end);
+  return { success: true, content: slice.map((l, i) => `${start + i}: ${l}`).join("\n") };
 }
-async function runWithConcurrencyLimit(tasks, limit) {
-  const results = new Array(tasks.length);
-  let nextIndex = 0;
-  async function worker() {
-    while (nextIndex < tasks.length) {
-      const idx = nextIndex++;
-      results[idx] = await tasks[idx]();
-    }
-  }
-  const workers = Array.from({ length: Math.min(limit, tasks.length) }, () => worker());
-  await Promise.all(workers);
-  return results;
+z.object({
+  path: z.string().describe("Path to the file to write (relative or absolute)"),
+  content: z.string().describe("Content to write to the file")
+});
+async function writeTool(input, projectCwd) {
+  const absolute = path6.isAbsolute(input.path) ? input.path : path6.resolve(projectCwd || process.cwd(), input.path);
+  await mkdir(path6.dirname(absolute), { recursive: true });
+  await writeFile(absolute, input.content, "utf8");
+  return { success: true, message: `Wrote ${input.path}` };
 }
-var batchTool = async function(input, projectCwd) {
-  const { tool_calls } = input;
-  const callsToExecute = tool_calls.slice(0, MAX_BATCH_SIZE);
-  const discardedCalls = tool_calls.slice(MAX_BATCH_SIZE);
-  const executeCall = async (call) => {
-    const start = performance.now();
-    try {
-      if (DISALLOWED_TOOLS.has(call.tool)) {
-        return {
-          tool: call.tool,
-          success: false,
-          error: `Tool '${call.tool}' is not allowed in batch. Disallowed tools: ${Array.from(DISALLOWED_TOOLS).join(", ")}`,
-          durationMs: 0
-        };
-      }
-      const executor = batchableToolExecutors[call.tool];
-      if (!executor) {
-        const availableTools = Object.keys(batchableToolExecutors).join(", ");
-        return {
-          tool: call.tool,
-          success: false,
-          error: `Tool '${call.tool}' not found. Available tools for batching: ${availableTools}`,
-          durationMs: 0
-        };
-      }
-      const result = await withTimeout(executor(call.parameters, projectCwd), PER_CALL_TIMEOUT);
-      const durationMs = Math.round(performance.now() - start);
-      return {
-        tool: call.tool,
-        success: result.success !== false,
-        result,
-        durationMs
-      };
-    } catch (error) {
-      const durationMs = Math.round(performance.now() - start);
-      const timedOut = error.message?.includes("BATCH_CALL_TIMEOUT");
-      return {
-        tool: call.tool,
-        success: false,
-        error: error.message || String(error),
-        durationMs,
-        timedOut
-      };
-    }
-  };
-  const tasks = callsToExecute.map(
-    (call) => () => executeCall(call)
-  );
-  const results = await runWithConcurrencyLimit(tasks, MAX_CONCURRENCY);
-  for (const call of discardedCalls) {
-    results.push({
-      tool: call.tool,
-      success: false,
-      error: `Maximum of ${MAX_BATCH_SIZE} tools allowed in batch`,
-      durationMs: 0
-    });
-  }
-  const successfulCalls = results.filter((r) => r.success).length;
-  const failedCalls = results.length - successfulCalls;
-  const outputMessage = failedCalls > 0 ? `Executed ${successfulCalls}/${results.length} tools successfully. ${failedCalls} failed.` : `All ${successfulCalls} tools executed successfully.
-
-Keep using the batch tool for optimal performance in your next response!`;
-  return {
-    success: failedCalls === 0,
-    message: outputMessage,
-    totalCalls: results.length,
-    successful: successfulCalls,
-    failed: failedCalls,
-    results
-  };
-};
-var toolCallSchema2 = z.object({
+var toolCallSchema = z.object({
   type: z.literal("tool_call"),
   id: z.string(),
   tool: z.string(),
@@ -9281,24 +6964,20 @@ var toolCallSchema2 = z.object({
 });
 var DEFAULT_TIMEOUT_MS = 3e4;
 var TOOL_TIMEOUTS = {
-  readFile: 1e4,
-  glob: 15e3,
-  grep: 2e4,
-  listDirectory: 15e3,
-  editFile: 15e3,
-  deleteFile: 1e4,
-  stringReplace: 15e3,
+  read: 1e4,
   bash: 6e4,
-  batch: 12e4
+  edit: 2e4,
+  write: 2e4,
+  grep: 2e4,
+  find: 2e4,
+  ls: 15e3
 };
 function getTimeoutForTool(tool) {
   return TOOL_TIMEOUTS[tool] ?? DEFAULT_TIMEOUT_MS;
 }
-function withTimeout2(promise, ms, tool) {
+function withTimeout(promise, ms, tool) {
   return new Promise((resolve, reject) => {
-    const timer = setTimeout(() => {
-      reject(new ToolTimeoutError(tool, ms));
-    }, ms);
+    const timer = setTimeout(() => reject(new ToolTimeoutError(tool, ms)), ms);
     promise.then((result) => {
       clearTimeout(timer);
       resolve(result);
@@ -9328,54 +7007,32 @@ async function executeTool(toolName, args, projectCwd, executors) {
   const start = performance.now();
   const executor = executors[toolName];
   if (!executor) {
-    return {
-      success: false,
-      error: { code: "UNKNOWN_TOOL", message: `Unknown tool: ${toolName}` },
-      metadata: { tool: toolName, durationMs: 0 }
-    };
+    return { success: false, error: { code: "UNKNOWN_TOOL", message: `Unknown tool: ${toolName}` }, metadata: { tool: toolName, durationMs: 0 } };
   }
   const cwdCheck = requireProjectCwd(toolName, projectCwd);
   if (!cwdCheck.allowed) {
-    return {
-      success: false,
-      error: { code: "ACCESS_DENIED", message: cwdCheck.error },
-      metadata: { tool: toolName, durationMs: 0 }
-    };
+    return { success: false, error: { code: "ACCESS_DENIED", message: cwdCheck.error }, metadata: { tool: toolName, durationMs: 0 } };
   }
   try {
-    const timeoutMs = getTimeoutForTool(toolName);
-    const result = await withTimeout2(executor(args, projectCwd), timeoutMs, toolName);
+    const result = await withTimeout(executor(args, projectCwd), getTimeoutForTool(toolName), toolName);
     const durationMs = Math.round(performance.now() - start);
-    return {
-      success: result?.success !== false,
-      data: result,
-      metadata: { tool: toolName, durationMs }
-    };
+    return { success: result?.success !== false, data: result, metadata: { tool: toolName, durationMs } };
   } catch (err) {
     const durationMs = Math.round(performance.now() - start);
     if (err instanceof ToolTimeoutError) {
-      return {
-        success: false,
-        error: { code: "TOOL_TIMEOUT", message: err.message },
-        metadata: { tool: toolName, durationMs, timedOut: true }
-      };
+      return { success: false, error: { code: "TOOL_TIMEOUT", message: err.message }, metadata: { tool: toolName, durationMs, timedOut: true } };
     }
     return {
       success: false,
-      error: {
-        code: err.code ?? "TOOL_EXECUTION_ERROR",
-        message: err.message ?? String(err)
-      },
+      error: { code: err.code ?? "TOOL_EXECUTION_ERROR", message: err.message ?? String(err) },
       metadata: { tool: toolName, durationMs }
     };
   }
 }
 function parseToolCall(raw) {
-  const result = toolCallSchema2.safeParse(raw);
+  const result = toolCallSchema.safeParse(raw);
   if (!result.success) {
-    return new ValidationError(
-      `Invalid tool_call payload: ${result.error.issues.map((i) => i.message).join(", ")}`
-    );
+    return new ValidationError(`Invalid tool_call payload: ${result.error.issues.map((i) => i.message).join(", ")}`);
   }
   return result.data;
 }
@@ -9394,30 +7051,22 @@ function getReconnectDelay2() {
   return Math.floor(delay + jitter);
 }
 var toolExecutors = {
-  editFile: editFiles,
-  deleteFile,
-  grep: grepTool,
-  glob: globTool,
-  listDirectory: list,
-  readFile: read_file,
-  stringReplace: apply_patch,
+  read: readTool,
   bash: bashTool,
-  batch: batchTool
+  edit: editTool,
+  write: writeTool,
+  grep: grepTool,
+  find: findTool,
+  ls: lsTool
 };
 function getConnectionStatus(ws) {
   return ws.readyState === WebSocket2.CONNECTING ? "connecting" : ws.readyState === WebSocket2.OPEN ? "open" : ws.readyState === WebSocket2.CLOSING ? "closing" : "closed";
 }
 function connectToServer(serverUrl = DEFAULT_SERVER_URL) {
   const tokens = getTokens();
-  if (!tokens) {
-    throw new Error("No tokens found");
-  }
+  if (!tokens) throw new Error("No tokens found");
   const wsUrl = `${serverUrl}/agent-streams`;
-  const ws = new WebSocket2(wsUrl, {
-    headers: {
-      "Authorization": `Bearer ${tokens.access_token}`
-    }
-  });
+  const ws = new WebSocket2(wsUrl, { headers: { "Authorization": `Bearer ${tokens.access_token}` } });
   ws.on("open", () => {
     reconnectAttempts2 = 0;
     console.log(pc3.cyan("connected to server"));
@@ -9433,33 +7082,16 @@ function connectToServer(serverUrl = DEFAULT_SERVER_URL) {
     if (message.type === "tool_call") {
       const validated = parseToolCall(message);
       if (validated instanceof ValidationError) {
-        ws.send(JSON.stringify({
-          type: "tool_result",
-          id: message.id ?? "unknown",
-          error: validated.message
-        }));
+        ws.send(JSON.stringify({ type: "tool_result", id: message.id ?? "unknown", error: validated.message }));
         console.error(pc3.red(`  validation error: ${validated.message}`));
         return;
       }
       console.log(pc3.gray(`> ${validated.tool}`));
-      const response = await executeTool(
-        validated.tool,
-        validated.args,
-        validated.projectCwd,
-        toolExecutors
-      );
+      const response = await executeTool(validated.tool, validated.args, validated.projectCwd, toolExecutors);
       if (response.success) {
-        ws.send(JSON.stringify({
-          type: "tool_result",
-          id: validated.id,
-          result: response.data
-        }));
+        ws.send(JSON.stringify({ type: "tool_result", id: validated.id, result: response.data }));
       } else {
-        ws.send(JSON.stringify({
-          type: "tool_result",
-          id: validated.id,
-          error: response.error?.message ?? "Unknown error"
-        }));
+        ws.send(JSON.stringify({ type: "tool_result", id: validated.id, error: response.error?.message ?? "Unknown error" }));
         console.error(pc3.red(`  ${validated.tool} failed: ${response.error?.message}`));
       }
       if (response.metadata?.durationMs && response.metadata.durationMs > 5e3) {
@@ -9469,21 +7101,11 @@ function connectToServer(serverUrl = DEFAULT_SERVER_URL) {
       console.log(pc3.gray(`> rpc: ${message.method}`));
       try {
         const handler = rpcHandlers[message.method];
-        if (!handler) {
-          throw new Error(`Unknown RPC method: ${message.method}`);
-        }
+        if (!handler) throw new Error(`Unknown RPC method: ${message.method}`);
         const result = await handler(message.args);
-        ws.send(JSON.stringify({
-          type: "tool_result",
-          id: message.id,
-          result
-        }));
+        ws.send(JSON.stringify({ type: "tool_result", id: message.id, result }));
       } catch (error) {
-        ws.send(JSON.stringify({
-          type: "tool_result",
-          id: message.id,
-          error: error.message
-        }));
+        ws.send(JSON.stringify({ type: "tool_result", id: message.id, error: error.message }));
         console.error(pc3.red(`  rpc failed: ${message.method}`));
       }
     }