@ashx-j/lunr-dev 0.2.13-dev.8.1 → 0.2.16-dev.9.1

package/dist/node-runtime/chunk-ZKMFUD3Q.js

@@ -0,0 +1,2834 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  processImage
+} from "./chunk-AD6VXAO7.js";
+import {
+  DEFAULT_MAX_BYTES,
+  DEFAULT_MAX_LINES,
+  formatSize,
+  truncateHead,
+  truncateLine,
+  truncateTail
+} from "./chunk-53YJI7JU.js";
+import {
+  formatGroupedCall,
+  getTextOutput,
+  invalidArgText,
+  normalizeDisplayText,
+  renderCollapsedSearchPath,
+  renderToolFileName,
+  renderToolPath,
+  replaceTabs,
+  shortenPath,
+  str,
+  toolGroupTree,
+  toolStatusDot,
+  toolStatusDotFromContext
+} from "./chunk-GZQHMEWL.js";
+import {
+  getShellConfig,
+  getShellEnv,
+  killProcessTree,
+  trackDetachedChildPid,
+  untrackDetachedChildPid
+} from "./chunk-ZCHMJ34K.js";
+import {
+  keyHint
+} from "./chunk-C4O2RSQQ.js";
+import {
+  getLanguageFromPath,
+  highlightCode,
+  theme
+} from "./chunk-MX3GJNXJ.js";
+import {
+  APP_NAME,
+  formatPathRelativeToCwdOrAbsolute,
+  getBinDir,
+  getReadmePath,
+  resolvePath,
+  waitForChildProcess
+} from "./chunk-PCIGF2XK.js";
+
+// packages/coding-agent/dist/modes/interactive/components/visual-truncate.js
+import { Text } from "@ashx-j/lunr-tui";
+function truncateToVisualLines(text, maxVisualLines, width, paddingX = 0) {
+  if (!text)
+    return { visualLines: [], skippedCount: 0 };
+  let allVisualLines = new Text(text, paddingX, 0).render(width);
+  if (allVisualLines.length <= maxVisualLines)
+    return { visualLines: allVisualLines, skippedCount: 0 };
+  let truncatedLines = allVisualLines.slice(-maxVisualLines), skippedCount = allVisualLines.length - maxVisualLines;
+  return { visualLines: truncatedLines, skippedCount };
+}
+
+// packages/coding-agent/dist/core/process-registry.js
+import { spawn } from "node:child_process";
+var isWin32 = process.platform === "win32", EXIT_NOISE_GATE_MS = 3e3, EXIT_TTL_MS = 300 * 1e3, MAX_TRACKED = 100, processes = /* @__PURE__ */ new Map();
+function register(pid, command, cwd, sessionId) {
+  if (pid) {
+    if (processes.size >= MAX_TRACKED) {
+      let oldest;
+      for (let [p, entry] of processes) {
+        if (entry.status === "exited") {
+          oldest = { pid: p, entry };
+          break;
+        }
+        (!oldest || entry.startedAt < oldest.entry.startedAt) && (oldest = { pid: p, entry });
+      }
+      oldest && processes.delete(oldest.pid);
+    }
+    processes.set(pid, { pid, command, cwd, startedAt: Date.now(), status: "running", sessionId });
+  }
+}
+function markExited(pid, exitCode) {
+  if (!pid)
+    return;
+  let entry = processes.get(pid);
+  if (!entry)
+    return;
+  if (Date.now() - entry.startedAt < EXIT_NOISE_GATE_MS) {
+    processes.delete(pid);
+    return;
+  }
+  entry.status = "exited", entry.exitCode = exitCode ?? void 0, entry.exitedAt = Date.now();
+}
+function list(sessionId) {
+  return prune(), [...processes.values()].filter((p) => sessionId === void 0 || p.sessionId === sessionId);
+}
+function prune() {
+  for (let [pid, entry] of processes) {
+    if (entry.status === "exited") {
+      (!entry.exitedAt || Date.now() - entry.exitedAt > EXIT_TTL_MS) && processes.delete(pid);
+      continue;
+    }
+    isAlive(pid) || markExited(pid, null);
+  }
+}
+function isAlive(pid) {
+  try {
+    return process.kill(pid, 0), !0;
+  } catch {
+    return !1;
+  }
+}
+function kill(pid) {
+  processes.has(pid) && (killProcessTree(pid), processes.delete(pid));
+}
+function killAll(sessionId) {
+  for (let [pid, entry] of processes)
+    if (!(sessionId !== void 0 && entry.sessionId !== sessionId)) {
+      try {
+        killProcessTree(pid);
+      } catch {
+      }
+      processes.delete(pid);
+    }
+}
+function pause(pid) {
+  if (isWin32)
+    throw new Error("Pause/resume is unsupported on Windows.");
+  if (!processes.has(pid))
+    throw new Error(`Process ${pid} is not tracked.`);
+  try {
+    process.kill(pid, "SIGSTOP");
+    let entry = processes.get(pid);
+    entry && (entry.status = "paused");
+  } catch {
+    processes.delete(pid);
+  }
+}
+function resume(pid) {
+  if (isWin32)
+    throw new Error("Pause/resume is unsupported on Windows.");
+  if (!processes.has(pid))
+    throw new Error(`Process ${pid} is not tracked.`);
+  try {
+    process.kill(pid, "SIGCONT");
+    let entry = processes.get(pid);
+    entry && (entry.status = "running");
+  } catch {
+    processes.delete(pid);
+  }
+}
+function restart(pid) {
+  let entry = processes.get(pid);
+  if (entry) {
+    try {
+      killProcessTree(pid);
+    } catch {
+    }
+    processes.delete(pid);
+    try {
+      let shellConfig = getShellConfig(), child = spawn(shellConfig.shell, [...shellConfig.args, entry.command], {
+        cwd: entry.cwd,
+        detached: !0,
+        stdio: "ignore",
+        windowsHide: !0
+      });
+      if (child.pid)
+        return register(child.pid, entry.command, entry.cwd, entry.sessionId), child.unref(), child.pid;
+    } catch {
+    }
+  }
+}
+function isWindows() {
+  return isWin32;
+}
+function clearRegistry(sessionId) {
+  if (sessionId === void 0) {
+    processes.clear();
+    return;
+  }
+  for (let [pid, entry] of processes)
+    entry.sessionId === sessionId && processes.delete(pid);
+}
+
+// packages/coding-agent/dist/core/tools/bash.js
+import { constants } from "node:fs";
+import { access as fsAccess } from "node:fs/promises";
+import { Container, Text as Text2, truncateToWidth } from "@ashx-j/lunr-tui";
+import { spawn as spawn2 } from "child_process";
+import { Type } from "typebox";
+
+// packages/coding-agent/dist/core/tools/output-accumulator.js
+import { randomBytes } from "node:crypto";
+import { createWriteStream } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+function defaultTempFilePath(prefix) {
+  let id = randomBytes(8).toString("hex");
+  return join(tmpdir(), `${prefix}-${id}.log`);
+}
+function byteLength(text) {
+  return Buffer.byteLength(text, "utf-8");
+}
+var OutputAccumulator = class {
+  maxLines;
+  maxBytes;
+  maxRollingBytes;
+  tempFilePrefix;
+  decoder = new TextDecoder();
+  rawChunks = [];
+  tailText = "";
+  tailBytes = 0;
+  tailStartsAtLineBoundary = !0;
+  totalRawBytes = 0;
+  totalDecodedBytes = 0;
+  completedLines = 0;
+  totalLines = 0;
+  currentLineBytes = 0;
+  hasOpenLine = !1;
+  finished = !1;
+  tempFilePath;
+  tempFileStream;
+  constructor(options = {}) {
+    this.maxLines = options.maxLines ?? 2e3, this.maxBytes = options.maxBytes ?? 51200, this.maxRollingBytes = Math.max(this.maxBytes * 2, 1), this.tempFilePrefix = options.tempFilePrefix ?? "lunr-output";
+  }
+  append(data) {
+    if (this.finished)
+      throw new Error("Cannot append to a finished output accumulator");
+    this.totalRawBytes += data.length, this.appendDecodedText(this.decoder.decode(data, { stream: !0 })), this.tempFileStream || this.shouldUseTempFile() ? (this.ensureTempFile(), this.tempFileStream?.write(data)) : data.length > 0 && this.rawChunks.push(data);
+  }
+  finish() {
+    this.finished || (this.finished = !0, this.appendDecodedText(this.decoder.decode()), this.shouldUseTempFile() && this.ensureTempFile());
+  }
+  snapshot(options = {}) {
+    let tailTruncation = truncateTail(this.getSnapshotText(), {
+      maxLines: this.maxLines,
+      maxBytes: this.maxBytes
+    }), truncated = this.totalLines > this.maxLines || this.totalDecodedBytes > this.maxBytes, truncatedBy = truncated ? tailTruncation.truncatedBy ?? (this.totalDecodedBytes > this.maxBytes ? "bytes" : "lines") : null, truncation = {
+      ...tailTruncation,
+      truncated,
+      truncatedBy,
+      totalLines: this.totalLines,
+      totalBytes: this.totalDecodedBytes,
+      maxLines: this.maxLines,
+      maxBytes: this.maxBytes
+    };
+    return options.persistIfTruncated && truncation.truncated && this.ensureTempFile(), {
+      content: truncation.content,
+      truncation,
+      fullOutputPath: this.tempFilePath
+    };
+  }
+  async closeTempFile() {
+    if (!this.tempFileStream)
+      return;
+    let stream = this.tempFileStream;
+    this.tempFileStream = void 0, await new Promise((resolve2, reject) => {
+      let onError = (error) => {
+        stream.off("finish", onFinish), reject(error);
+      }, onFinish = () => {
+        stream.off("error", onError), resolve2();
+      };
+      stream.once("error", onError), stream.once("finish", onFinish), stream.end();
+    });
+  }
+  getLastLineBytes() {
+    return this.currentLineBytes;
+  }
+  appendDecodedText(text) {
+    if (text.length === 0)
+      return;
+    let bytes = byteLength(text);
+    this.totalDecodedBytes += bytes, this.tailText += text, this.tailBytes += bytes, this.tailBytes > this.maxRollingBytes * 2 && this.trimTail();
+    let newlines = 0, lastNewline = -1;
+    for (let i = text.indexOf(`
+`); i !== -1; i = text.indexOf(`
+`, i + 1))
+      newlines++, lastNewline = i;
+    if (newlines === 0)
+      this.currentLineBytes += bytes, this.hasOpenLine = !0;
+    else {
+      this.completedLines += newlines;
+      let tail = text.slice(lastNewline + 1);
+      this.currentLineBytes = byteLength(tail), this.hasOpenLine = tail.length > 0;
+    }
+    this.totalLines = this.completedLines + (this.hasOpenLine ? 1 : 0);
+  }
+  trimTail() {
+    let buffer = Buffer.from(this.tailText, "utf-8");
+    if (buffer.length <= this.maxRollingBytes) {
+      this.tailBytes = buffer.length;
+      return;
+    }
+    let start = buffer.length - this.maxRollingBytes;
+    for (; start < buffer.length && (buffer[start] & 192) === 128; )
+      start++;
+    this.tailStartsAtLineBoundary = start === 0 ? this.tailStartsAtLineBoundary : buffer[start - 1] === 10, this.tailText = buffer.subarray(start).toString("utf-8"), this.tailBytes = byteLength(this.tailText);
+  }
+  getSnapshotText() {
+    if (this.tailStartsAtLineBoundary)
+      return this.tailText;
+    let firstNewline = this.tailText.indexOf(`
+`);
+    return firstNewline === -1 ? this.tailText : this.tailText.slice(firstNewline + 1);
+  }
+  shouldUseTempFile() {
+    return this.totalRawBytes > this.maxBytes || this.totalDecodedBytes > this.maxBytes || this.totalLines > this.maxLines;
+  }
+  ensureTempFile() {
+    if (!this.tempFilePath) {
+      this.tempFilePath = defaultTempFilePath(this.tempFilePrefix), this.tempFileStream = createWriteStream(this.tempFilePath);
+      for (let chunk of this.rawChunks)
+        this.tempFileStream.write(chunk);
+      this.rawChunks = [];
+    }
+  }
+};
+
+// packages/coding-agent/dist/core/tools/tool-definition-wrapper.js
+function wrapToolDefinition(definition, ctxFactory) {
+  return {
+    name: definition.name,
+    label: definition.label,
+    description: definition.description,
+    parameters: definition.parameters,
+    prepareArguments: definition.prepareArguments,
+    executionMode: definition.executionMode,
+    execute: (toolCallId, params, signal, onUpdate) => definition.execute(toolCallId, params, signal, onUpdate, ctxFactory?.())
+  };
+}
+function createToolDefinitionFromAgentTool(tool) {
+  return {
+    name: tool.name,
+    label: tool.label,
+    description: tool.description,
+    parameters: tool.parameters,
+    prepareArguments: tool.prepareArguments,
+    executionMode: tool.executionMode,
+    execute: async (toolCallId, params, signal, onUpdate) => tool.execute(toolCallId, params, signal, onUpdate)
+  };
+}
+
+// packages/coding-agent/dist/core/tools/bash.js
+var MAX_TIMEOUT_MS = 2147483647, MAX_TIMEOUT_SECONDS = MAX_TIMEOUT_MS / 1e3;
+function resolveTimeoutMs(timeout) {
+  if (timeout === void 0)
+    return;
+  if (!Number.isFinite(timeout) || timeout <= 0)
+    throw new Error("Invalid timeout: must be a finite number of seconds");
+  let timeoutMs = timeout * 1e3;
+  if (timeoutMs > MAX_TIMEOUT_MS)
+    throw new Error(`Invalid timeout: maximum is ${MAX_TIMEOUT_SECONDS} seconds`);
+  return timeoutMs;
+}
+var bashSchema = Type.Object({
+  command: Type.String({ description: "Bash command to execute" }),
+  timeout: Type.Optional(Type.Number({ description: "Timeout in seconds (optional, no default timeout)" }))
+});
+function createLocalBashOperations(options) {
+  return {
+    exec: async (command, cwd, { onData, signal, timeout, env }) => {
+      let timeoutMs = resolveTimeoutMs(timeout);
+      if (signal?.aborted)
+        throw new Error("aborted");
+      let shellConfig = getShellConfig(options?.shellPath);
+      try {
+        await fsAccess(cwd, constants.F_OK);
+      } catch {
+        throw new Error(`Working directory does not exist: ${cwd}
+Cannot execute bash commands.`);
+      }
+      let commandFromStdin = shellConfig.commandTransport === "stdin", child = spawn2(shellConfig.shell, commandFromStdin ? shellConfig.args : [...shellConfig.args, command], {
+        cwd,
+        detached: process.platform !== "win32",
+        env: env ?? getShellEnv(),
+        stdio: [commandFromStdin ? "pipe" : "ignore", "pipe", "pipe"],
+        windowsHide: !0
+      });
+      if (commandFromStdin && (child.stdin?.on("error", () => {
+      }), child.stdin?.end(command)), child.pid && trackDetachedChildPid(child.pid), child.pid)
+        try {
+          register(child.pid, command, cwd, options?.sessionId);
+        } catch {
+        }
+      let timedOut = !1, timeoutHandle, onAbort = () => {
+        child.pid && killProcessTree(child.pid);
+      };
+      try {
+        timeoutMs !== void 0 && (timeoutHandle = setTimeout(() => {
+          timedOut = !0, child.pid && killProcessTree(child.pid);
+        }, timeoutMs)), child.stdout?.on("data", onData), child.stderr?.on("data", onData), signal && (signal.aborted ? onAbort() : signal.addEventListener("abort", onAbort, { once: !0 }));
+        let exitCode = await waitForChildProcess(child);
+        if (signal?.aborted)
+          throw new Error("aborted");
+        if (timedOut)
+          throw new Error(`timeout:${timeout}`);
+        return { exitCode };
+      } finally {
+        if (child.pid && untrackDetachedChildPid(child.pid), child.pid)
+          try {
+            markExited(child.pid, child.exitCode);
+          } catch {
+          }
+        timeoutHandle && clearTimeout(timeoutHandle), signal && signal.removeEventListener("abort", onAbort);
+      }
+    }
+  };
+}
+function resolveSpawnContext(command, cwd, spawnHook) {
+  let baseContext = { command, cwd, env: { ...getShellEnv() } };
+  return spawnHook ? spawnHook(baseContext) : baseContext;
+}
+var BASH_PREVIEW_LINES = 5, BASH_UPDATE_THROTTLE_MS = 100, BashResultRenderComponent = class extends Container {
+  state = {
+    cachedWidth: void 0,
+    cachedLines: void 0,
+    cachedSkipped: void 0
+  };
+};
+function formatDuration(ms) {
+  return `${(ms / 1e3).toFixed(1)}s`;
+}
+var MAX_COLLAPSED_COMMAND_CHARS = 100;
+function formatBashCall(args, options) {
+  let command = str(args?.command), timeout = args?.timeout, timeoutSuffix = timeout && !options?.compact ? theme.fg("muted", ` (timeout ${timeout}s)`) : "", commandDisplay = command === null ? invalidArgText(theme) : command || theme.fg("toolOutput", "...");
+  if (!options?.expanded && command) {
+    let firstLine = command.split(`
+`)[0], capped = firstLine.length > MAX_COLLAPSED_COMMAND_CHARS, base = capped ? firstLine.slice(0, MAX_COLLAPSED_COMMAND_CHARS) : firstLine;
+    commandDisplay = capped || base.length < command.length ? `${base} \u2026` : base;
+  }
+  return command && (commandDisplay = theme.fg("toolTitle", theme.bold(commandDisplay))), commandDisplay + timeoutSuffix;
+}
+function rebuildBashResultRenderComponent(component, result, options, showImages, startedAt, endedAt, compact = !1) {
+  let state = component.state;
+  component.clear();
+  let output = getTextOutput(result, showImages).trim(), truncation = result.details?.truncation, fullOutputPath = result.details?.fullOutputPath;
+  if (!options.isPartial && truncation?.truncated && fullOutputPath && output.endsWith("]")) {
+    let footerStart = output.lastIndexOf(`
+
+[`);
+    footerStart !== -1 && output.slice(footerStart).includes(fullOutputPath) && (output = output.slice(0, footerStart).trimEnd());
+  }
+  if (!compact && output) {
+    let styledOutput = output.split(`
+`).map((line) => theme.fg("toolOutput", line)).join(`
+`);
+    options.expanded ? component.addChild(new Text2(`
+${styledOutput}`, 0, 0)) : component.addChild({
+      render: (width) => {
+        if (state.cachedLines === void 0 || state.cachedWidth !== width) {
+          let preview = truncateToVisualLines(styledOutput, BASH_PREVIEW_LINES, width);
+          state.cachedLines = preview.visualLines, state.cachedSkipped = preview.skippedCount, state.cachedWidth = width;
+        }
+        if (state.cachedSkipped && state.cachedSkipped > 0) {
+          let hint = theme.fg("muted", `... (${state.cachedSkipped} earlier lines)`);
+          return ["", truncateToWidth(hint, width, "..."), ...state.cachedLines ?? []];
+        }
+        return ["", ...state.cachedLines ?? []];
+      },
+      invalidate: () => {
+        state.cachedWidth = void 0, state.cachedLines = void 0, state.cachedSkipped = void 0;
+      }
+    });
+  }
+  if (!compact && startedAt !== void 0) {
+    let label = options.isPartial ? "Elapsed" : "Took", endTime = endedAt ?? Date.now();
+    component.addChild(new Text2(`
+${theme.fg("muted", `${label} ${formatDuration(endTime - startedAt)}`)}`, 0, 0));
+  }
+}
+function createBashToolDefinition(cwd, options) {
+  let ops = options?.operations ?? createLocalBashOperations({ shellPath: options?.shellPath }), commandPrefix = options?.commandPrefix, spawnHook = options?.spawnHook;
+  return {
+    name: "bash",
+    label: "bash",
+    description: `Execute a bash command in the current working directory. Returns stdout and stderr. Output is truncated to last ${2e3} lines or ${51200 / 1024}KB (whichever is hit first). If truncated, full output is saved to a temp file. Optionally provide a timeout in seconds.`,
+    promptSnippet: "Execute bash commands (ls, grep, find, etc.)",
+    parameters: bashSchema,
+    async execute(_toolCallId, { command, timeout }, signal, onUpdate, _ctx) {
+      let resolvedCommand = commandPrefix ? `${commandPrefix}
+${command}` : command, spawnContext = resolveSpawnContext(resolvedCommand, cwd, spawnHook), output = new OutputAccumulator({ tempFilePrefix: "lunr-bash" }), acceptingOutput = !0, updateTimer, updateDirty = !1, lastUpdateAt = 0, emitOutputUpdate = () => {
+        if (!onUpdate || !updateDirty)
+          return;
+        updateDirty = !1, lastUpdateAt = Date.now();
+        let snapshot = output.snapshot({ persistIfTruncated: !0 });
+        onUpdate({
+          content: [{ type: "text", text: snapshot.content || "" }],
+          details: {
+            truncation: snapshot.truncation.truncated ? snapshot.truncation : void 0,
+            fullOutputPath: snapshot.fullOutputPath
+          }
+        });
+      }, clearUpdateTimer = () => {
+        updateTimer && (clearTimeout(updateTimer), updateTimer = void 0);
+      }, scheduleOutputUpdate = () => {
+        if (!onUpdate)
+          return;
+        updateDirty = !0;
+        let delay = BASH_UPDATE_THROTTLE_MS - (Date.now() - lastUpdateAt);
+        if (delay <= 0) {
+          clearUpdateTimer(), emitOutputUpdate();
+          return;
+        }
+        updateTimer ??= setTimeout(() => {
+          updateTimer = void 0, emitOutputUpdate();
+        }, delay);
+      };
+      onUpdate && onUpdate({ content: [], details: void 0 });
+      let handleData = (data) => {
+        acceptingOutput && (output.append(data), scheduleOutputUpdate());
+      }, finishOutput = async () => {
+        acceptingOutput = !1, output.finish(), clearUpdateTimer(), emitOutputUpdate();
+        let snapshot = output.snapshot({ persistIfTruncated: !0 });
+        return await output.closeTempFile(), snapshot;
+      }, formatOutput = (snapshot, emptyText = "(no output)") => {
+        let truncation = snapshot.truncation, text = snapshot.content || emptyText, details;
+        if (truncation.truncated) {
+          details = { truncation, fullOutputPath: snapshot.fullOutputPath };
+          let startLine = truncation.totalLines - truncation.outputLines + 1, endLine = truncation.totalLines;
+          if (truncation.lastLinePartial) {
+            let lastLineSize = formatSize(output.getLastLineBytes());
+            text += `
+
+[Showing last ${formatSize(truncation.outputBytes)} of line ${endLine} (line is ${lastLineSize}). Full output: ${snapshot.fullOutputPath}]`;
+          } else truncation.truncatedBy === "lines" ? text += `
+
+[Showing lines ${startLine}-${endLine} of ${truncation.totalLines}. Full output: ${snapshot.fullOutputPath}]` : text += `
+
+[Showing lines ${startLine}-${endLine} of ${truncation.totalLines} (${formatSize(51200)} limit). Full output: ${snapshot.fullOutputPath}]`;
+        }
+        return { text, details };
+      }, appendStatus = (text, status) => `${text ? `${text}
+
+` : ""}${status}`;
+      try {
+        let exitCode;
+        try {
+          exitCode = (await ops.exec(spawnContext.command, spawnContext.cwd, {
+            onData: handleData,
+            signal,
+            timeout,
+            env: spawnContext.env
+          })).exitCode;
+        } catch (err) {
+          let snapshot2 = await finishOutput(), { text } = formatOutput(snapshot2, "");
+          if (err instanceof Error && err.message === "aborted")
+            throw new Error(appendStatus(text, "Command aborted"));
+          if (err instanceof Error && err.message.startsWith("timeout:")) {
+            let timeoutSecs = err.message.split(":")[1];
+            throw new Error(appendStatus(text, `Command timed out after ${timeoutSecs} seconds`));
+          }
+          throw err;
+        }
+        let snapshot = await finishOutput(), { text: outputText, details } = formatOutput(snapshot);
+        if (exitCode !== 0 && exitCode !== null)
+          throw new Error(appendStatus(outputText, `Command exited with code ${exitCode}`));
+        return { content: [{ type: "text", text: outputText }], details };
+      } finally {
+        clearUpdateTimer();
+      }
+    },
+    renderCall(args, _theme, context) {
+      let state = context.state;
+      context.executionStarted && state.startedAt === void 0 && (state.startedAt = Date.now(), state.endedAt = void 0), !context.isPartial && state.startedAt !== void 0 && (state.endedAt ??= Date.now());
+      let compact = !context.isPartial && !context.expanded && !context.isError, detail = formatBashCall(args, { expanded: context.expanded, compact });
+      compact && state.startedAt !== void 0 && state.endedAt !== void 0 && (detail += theme.fg("muted", ` \u2014 Took ${formatDuration(state.endedAt - state.startedAt)}`));
+      let text = context.lastComponent ?? new Text2("", 0, 0);
+      return text.setText(formatGroupedCall({
+        role: context.groupRole ?? "singleton",
+        compact,
+        tree: toolGroupTree(context),
+        dot: toolStatusDotFromContext(context, theme),
+        title: theme.fg("toolTitle", theme.bold("$")),
+        detail
+      })), text;
+    },
+    renderResult(result, options2, _theme, context) {
+      let state = context.state;
+      state.startedAt !== void 0 && options2.isPartial && !state.interval && (state.interval = setInterval(() => context.invalidate(), 1e3)), (!options2.isPartial || context.isError) && (state.endedAt ??= Date.now(), state.interval && (clearInterval(state.interval), state.interval = void 0));
+      let component = context.lastComponent ?? new BashResultRenderComponent(), compact = !options2.isPartial && !options2.expanded && !context.isError;
+      return rebuildBashResultRenderComponent(component, result, options2, context.showImages, state.startedAt, state.endedAt, compact), component.invalidate(), component;
+    }
+  };
+}
+function createBashTool(cwd, options) {
+  return wrapToolDefinition(createBashToolDefinition(cwd, options));
+}
+
+// node_modules/diff/libesm/diff/base.js
+var Diff = class {
+  diff(oldStr, newStr, options = {}) {
+    let callback;
+    typeof options == "function" ? (callback = options, options = {}) : "callback" in options && (callback = options.callback);
+    let oldString = this.castInput(oldStr, options), newString = this.castInput(newStr, options), oldTokens = this.removeEmpty(this.tokenize(oldString, options)), newTokens = this.removeEmpty(this.tokenize(newString, options));
+    return this.diffWithOptionsObj(oldTokens, newTokens, options, callback);
+  }
+  diffWithOptionsObj(oldTokens, newTokens, options, callback) {
+    var _a;
+    let done = (value) => {
+      if (value = this.postProcess(value, options), callback) {
+        setTimeout(function() {
+          callback(value);
+        }, 0);
+        return;
+      } else
+        return value;
+    }, newLen = newTokens.length, oldLen = oldTokens.length, editLength = 1, maxEditLength = newLen + oldLen;
+    options.maxEditLength != null && (maxEditLength = Math.min(maxEditLength, options.maxEditLength));
+    let maxExecutionTime = (_a = options.timeout) !== null && _a !== void 0 ? _a : 1 / 0, abortAfterTimestamp = Date.now() + maxExecutionTime, bestPath = [{ oldPos: -1, lastComponent: void 0 }], 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 = -1 / 0, maxDiagonalToConsider = 1 / 0, execEditLength = () => {
+      for (let diagonalPath = Math.max(minDiagonalToConsider, -editLength); diagonalPath <= Math.min(maxDiagonalToConsider, editLength); diagonalPath += 2) {
+        let basePath, removePath = bestPath[diagonalPath - 1], addPath = bestPath[diagonalPath + 1];
+        removePath && (bestPath[diagonalPath - 1] = void 0);
+        let canAdd = !1;
+        if (addPath) {
+          let addPathNewPos = addPath.oldPos - diagonalPath;
+          canAdd = addPath && 0 <= addPathNewPos && addPathNewPos < newLen;
+        }
+        let 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, !0, !1, 0, options) : basePath = this.addToPath(removePath, !1, !0, 1, options), newPos = this.extractCommon(basePath, newTokens, oldTokens, diagonalPath, options), basePath.oldPos + 1 >= oldLen && newPos + 1 >= newLen)
+          return done(this.buildValues(basePath.lastComponent, newTokens, oldTokens)) || !0;
+        bestPath[diagonalPath] = basePath, basePath.oldPos + 1 >= oldLen && (maxDiagonalToConsider = Math.min(maxDiagonalToConsider, diagonalPath - 1)), newPos + 1 >= newLen && (minDiagonalToConsider = Math.max(minDiagonalToConsider, diagonalPath + 1));
+      }
+      editLength++;
+    };
+    if (callback)
+      (function exec() {
+        setTimeout(function() {
+          if (editLength > maxEditLength || Date.now() > abortAfterTimestamp)
+            return callback(void 0);
+          execEditLength() || exec();
+        }, 0);
+      })();
+    else
+      for (; editLength <= maxEditLength && Date.now() <= abortAfterTimestamp; ) {
+        let ret = execEditLength();
+        if (ret)
+          return ret;
+      }
+  }
+  addToPath(path3, added, removed, oldPosInc, options) {
+    let last = path3.lastComponent;
+    return last && !options.oneChangePerToken && last.added === added && last.removed === removed ? {
+      oldPos: path3.oldPos + oldPosInc,
+      lastComponent: { count: last.count + 1, added, removed, previousComponent: last.previousComponent }
+    } : {
+      oldPos: path3.oldPos + oldPosInc,
+      lastComponent: { count: 1, added, removed, previousComponent: last }
+    };
+  }
+  extractCommon(basePath, newTokens, oldTokens, diagonalPath, options) {
+    let newLen = newTokens.length, oldLen = oldTokens.length, oldPos = basePath.oldPos, newPos = oldPos - diagonalPath, commonCount = 0;
+    for (; newPos + 1 < newLen && oldPos + 1 < oldLen && this.equals(oldTokens[oldPos + 1], newTokens[newPos + 1], options); )
+      newPos++, oldPos++, commonCount++, options.oneChangePerToken && (basePath.lastComponent = { count: 1, previousComponent: basePath.lastComponent, added: !1, removed: !1 });
+    return commonCount && !options.oneChangePerToken && (basePath.lastComponent = { count: commonCount, previousComponent: basePath.lastComponent, added: !1, removed: !1 }), basePath.oldPos = oldPos, newPos;
+  }
+  equals(left, right, options) {
+    return options.comparator ? options.comparator(left, right) : left === right || !!options.ignoreCase && left.toLowerCase() === right.toLowerCase();
+  }
+  removeEmpty(array) {
+    let ret = [];
+    for (let i = 0; i < array.length; i++)
+      array[i] && ret.push(array[i]);
+    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("");
+  }
+  postProcess(changeObjects, options) {
+    return changeObjects;
+  }
+  get useLongestToken() {
+    return !1;
+  }
+  buildValues(lastComponent, newTokens, oldTokens) {
+    let components = [], nextComponent;
+    for (; lastComponent; )
+      components.push(lastComponent), nextComponent = lastComponent.previousComponent, delete lastComponent.previousComponent, lastComponent = nextComponent;
+    components.reverse();
+    let componentLen = components.length, componentPos = 0, newPos = 0, oldPos = 0;
+    for (; componentPos < componentLen; componentPos++) {
+      let component = components[componentPos];
+      if (component.removed)
+        component.value = this.join(oldTokens.slice(oldPos, oldPos + component.count)), oldPos += component.count;
+      else {
+        if (!component.added && this.useLongestToken) {
+          let value = newTokens.slice(newPos, newPos + component.count);
+          value = value.map(function(value2, i) {
+            let oldValue = oldTokens[oldPos + i];
+            return oldValue.length > value2.length ? oldValue : value2;
+          }), component.value = this.join(value);
+        } else
+          component.value = this.join(newTokens.slice(newPos, newPos + component.count));
+        newPos += component.count, component.added || (oldPos += component.count);
+      }
+    }
+    return components;
+  }
+};
+
+// node_modules/diff/libesm/util/string.js
+function longestCommonPrefix(str1, str2) {
+  let i;
+  for (i = 0; i < str1.length && i < str2.length; i++)
+    if (str1[i] != str2[i])
+      return str1.slice(0, i);
+  return str1.slice(0, i);
+}
+function longestCommonSuffix(str1, str2) {
+  let i;
+  if (!str1 || !str2 || str1[str1.length - 1] != str2[str2.length - 1])
+    return "";
+  for (i = 0; i < str1.length && i < str2.length; i++)
+    if (str1[str1.length - (i + 1)] != str2[str2.length - (i + 1)])
+      return str1.slice(-i);
+  return str1.slice(-i);
+}
+function replacePrefix(string, oldPrefix, newPrefix) {
+  if (string.slice(0, oldPrefix.length) != oldPrefix)
+    throw Error(`string ${JSON.stringify(string)} doesn't start with prefix ${JSON.stringify(oldPrefix)}; this is a bug`);
+  return newPrefix + string.slice(oldPrefix.length);
+}
+function replaceSuffix(string, oldSuffix, newSuffix) {
+  if (!oldSuffix)
+    return string + newSuffix;
+  if (string.slice(-oldSuffix.length) != oldSuffix)
+    throw Error(`string ${JSON.stringify(string)} doesn't end with suffix ${JSON.stringify(oldSuffix)}; this is a bug`);
+  return string.slice(0, -oldSuffix.length) + newSuffix;
+}
+function removePrefix(string, oldPrefix) {
+  return replacePrefix(string, oldPrefix, "");
+}
+function removeSuffix(string, oldSuffix) {
+  return replaceSuffix(string, oldSuffix, "");
+}
+function maximumOverlap(string1, string2) {
+  return string2.slice(0, overlapCount(string1, string2));
+}
+function overlapCount(a, b) {
+  let startA = 0;
+  a.length > b.length && (startA = a.length - b.length);
+  let endB = b.length;
+  a.length < b.length && (endB = a.length);
+  let map = Array(endB), k = 0;
+  map[0] = 0;
+  for (let j = 1; j < endB; j++) {
+    for (b[j] == b[k] ? map[j] = map[k] : map[j] = k; k > 0 && b[j] != b[k]; )
+      k = map[k];
+    b[j] == b[k] && k++;
+  }
+  k = 0;
+  for (let i = startA; i < a.length; i++) {
+    for (; k > 0 && a[i] != b[k]; )
+      k = map[k];
+    a[i] == b[k] && k++;
+  }
+  return k;
+}
+function segment(string, segmenter) {
+  let parts = [];
+  for (let segmentObj of Array.from(segmenter.segment(string))) {
+    let segment2 = segmentObj.segment;
+    parts.length && /\s/.test(parts[parts.length - 1]) && /\s/.test(segment2) ? parts[parts.length - 1] += segment2 : parts.push(segment2);
+  }
+  return parts;
+}
+function trailingWs(string, segmenter) {
+  if (segmenter)
+    return leadingAndTrailingWs(string, segmenter)[1];
+  let i;
+  for (i = string.length - 1; i >= 0 && string[i].match(/\s/); i--)
+    ;
+  return string.substring(i + 1);
+}
+function leadingWs(string, segmenter) {
+  if (segmenter)
+    return leadingAndTrailingWs(string, segmenter)[0];
+  let match = string.match(/^\s*/);
+  return match ? match[0] : "";
+}
+function leadingAndTrailingWs(string, segmenter) {
+  if (!segmenter)
+    return [leadingWs(string), trailingWs(string)];
+  if (segmenter.resolvedOptions().granularity != "word")
+    throw new Error('The segmenter passed must have a granularity of "word"');
+  let segments = segment(string, segmenter), firstSeg = segments[0], lastSeg = segments[segments.length - 1], head = /\s/.test(firstSeg) ? firstSeg : "", tail = /\s/.test(lastSeg) ? lastSeg : "";
+  return [head, tail];
+}
+
+// node_modules/diff/libesm/diff/word.js
+var extendedWordChars = "a-zA-Z0-9_\\u{AD}\\u{C0}-\\u{D6}\\u{D8}-\\u{F6}\\u{F8}-\\u{2C6}\\u{2C8}-\\u{2D7}\\u{2DE}-\\u{2FF}\\u{1E00}-\\u{1EFF}", tokenizeIncludingWhitespace = new RegExp(`[${extendedWordChars}]+|\\s+|[^${extendedWordChars}]`, "ug"), WordDiff = class extends Diff {
+  equals(left, right, options) {
+    return options.ignoreCase && (left = left.toLowerCase(), right = right.toLowerCase()), left.trim() === right.trim();
+  }
+  tokenize(value, options = {}) {
+    let parts;
+    if (options.intlSegmenter) {
+      let segmenter = options.intlSegmenter;
+      if (segmenter.resolvedOptions().granularity != "word")
+        throw new Error('The segmenter passed must have a granularity of "word"');
+      parts = segment(value, segmenter);
+    } else
+      parts = value.match(tokenizeIncludingWhitespace) || [];
+    let tokens = [], prevPart = null;
+    return parts.forEach((part) => {
+      /\s/.test(part) ? prevPart == null ? tokens.push(part) : tokens.push(tokens.pop() + part) : prevPart != null && /\s/.test(prevPart) ? tokens[tokens.length - 1] == prevPart ? tokens.push(tokens.pop() + part) : tokens.push(prevPart + part) : tokens.push(part), prevPart = part;
+    }), tokens;
+  }
+  join(tokens) {
+    return tokens.map((token, i) => i == 0 ? token : token.replace(/^\s+/, "")).join("");
+  }
+  postProcess(changes, options) {
+    if (!changes || options.oneChangePerToken)
+      return changes;
+    let lastKeep = null, insertion = null, deletion = null;
+    return changes.forEach((change) => {
+      change.added ? insertion = change : change.removed ? deletion = change : ((insertion || deletion) && dedupeWhitespaceInChangeObjects(lastKeep, deletion, insertion, change, options.intlSegmenter), lastKeep = change, insertion = null, deletion = null);
+    }), (insertion || deletion) && dedupeWhitespaceInChangeObjects(lastKeep, deletion, insertion, null, options.intlSegmenter), changes;
+  }
+}, wordDiff = new WordDiff();
+function diffWords(oldStr, newStr, options) {
+  return options?.ignoreWhitespace != null && !options.ignoreWhitespace ? diffWordsWithSpace(oldStr, newStr, options) : wordDiff.diff(oldStr, newStr, options);
+}
+function dedupeWhitespaceInChangeObjects(startKeep, deletion, insertion, endKeep, segmenter) {
+  if (deletion && insertion) {
+    let [oldWsPrefix, oldWsSuffix] = leadingAndTrailingWs(deletion.value, segmenter), [newWsPrefix, newWsSuffix] = leadingAndTrailingWs(insertion.value, segmenter);
+    if (startKeep) {
+      let commonWsPrefix = longestCommonPrefix(oldWsPrefix, newWsPrefix);
+      startKeep.value = replaceSuffix(startKeep.value, newWsPrefix, commonWsPrefix), deletion.value = removePrefix(deletion.value, commonWsPrefix), insertion.value = removePrefix(insertion.value, commonWsPrefix);
+    }
+    if (endKeep) {
+      let commonWsSuffix = longestCommonSuffix(oldWsSuffix, newWsSuffix);
+      endKeep.value = replacePrefix(endKeep.value, newWsSuffix, commonWsSuffix), deletion.value = removeSuffix(deletion.value, commonWsSuffix), insertion.value = removeSuffix(insertion.value, commonWsSuffix);
+    }
+  } else if (insertion) {
+    if (startKeep) {
+      let ws = leadingWs(insertion.value, segmenter);
+      insertion.value = insertion.value.substring(ws.length);
+    }
+    if (endKeep) {
+      let ws = leadingWs(endKeep.value, segmenter);
+      endKeep.value = endKeep.value.substring(ws.length);
+    }
+  } else if (startKeep && endKeep) {
+    let newWsFull = leadingWs(endKeep.value, segmenter), [delWsStart, delWsEnd] = leadingAndTrailingWs(deletion.value, segmenter), newWsStart = longestCommonPrefix(newWsFull, delWsStart);
+    deletion.value = removePrefix(deletion.value, newWsStart);
+    let newWsEnd = longestCommonSuffix(removePrefix(newWsFull, newWsStart), delWsEnd);
+    deletion.value = removeSuffix(deletion.value, newWsEnd), endKeep.value = replacePrefix(endKeep.value, newWsFull, newWsEnd), startKeep.value = replaceSuffix(startKeep.value, newWsFull, newWsFull.slice(0, newWsFull.length - newWsEnd.length));
+  } else if (endKeep) {
+    let endKeepWsPrefix = leadingWs(endKeep.value, segmenter), deletionWsSuffix = trailingWs(deletion.value, segmenter), overlap = maximumOverlap(deletionWsSuffix, endKeepWsPrefix);
+    deletion.value = removeSuffix(deletion.value, overlap);
+  } else if (startKeep) {
+    let startKeepWsSuffix = trailingWs(startKeep.value, segmenter), deletionWsPrefix = leadingWs(deletion.value, segmenter), overlap = maximumOverlap(startKeepWsSuffix, deletionWsPrefix);
+    deletion.value = removePrefix(deletion.value, overlap);
+  }
+}
+var WordsWithSpaceDiff = class extends Diff {
+  tokenize(value) {
+    let regex = new RegExp(`(\\r?\\n)|[${extendedWordChars}]+|[^\\S\\n\\r]+|[^${extendedWordChars}]`, "ug");
+    return value.match(regex) || [];
+  }
+}, wordsWithSpaceDiff = new WordsWithSpaceDiff();
+function diffWordsWithSpace(oldStr, newStr, options) {
+  return wordsWithSpaceDiff.diff(oldStr, newStr, options);
+}
+
+// node_modules/diff/libesm/diff/line.js
+var LineDiff = class extends Diff {
+  constructor() {
+    super(...arguments), this.tokenize = tokenize;
+  }
+  equals(left, right, options) {
+    return options.ignoreWhitespace ? ((!options.newlineIsToken || !left.includes(`
+`)) && (left = left.trim()), (!options.newlineIsToken || !right.includes(`
+`)) && (right = right.trim())) : options.ignoreNewlineAtEof && !options.newlineIsToken && (left.endsWith(`
+`) && (left = left.slice(0, -1)), right.endsWith(`
+`) && (right = right.slice(0, -1))), super.equals(left, right, options);
+  }
+}, lineDiff = new LineDiff();
+function diffLines(oldStr, newStr, options) {
+  return lineDiff.diff(oldStr, newStr, options);
+}
+function tokenize(value, options) {
+  options.stripTrailingCr && (value = value.replace(/\r\n/g, `
+`));
+  let retLines = [], linesAndNewlines = value.split(/(\n|\r\n)/);
+  linesAndNewlines[linesAndNewlines.length - 1] || linesAndNewlines.pop();
+  for (let i = 0; i < linesAndNewlines.length; i++) {
+    let line = linesAndNewlines[i];
+    i % 2 && !options.newlineIsToken ? retLines[retLines.length - 1] += line : retLines.push(line);
+  }
+  return retLines;
+}
+
+// node_modules/diff/libesm/patch/create.js
+var INCLUDE_HEADERS = {
+  includeIndex: !0,
+  includeUnderline: !0,
+  includeFileHeaders: !0
+}, FILE_HEADERS_ONLY = {
+  includeIndex: !1,
+  includeUnderline: !1,
+  includeFileHeaders: !0
+};
+function structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {
+  let optionsObj;
+  options ? typeof options == "function" ? optionsObj = { callback: options } : optionsObj = options : optionsObj = {}, typeof optionsObj.context > "u" && (optionsObj.context = 4);
+  let context = optionsObj.context;
+  if (optionsObj.newlineIsToken)
+    throw new Error("newlineIsToken may not be used with patch-generation functions, only with diffing functions");
+  if (optionsObj.callback) {
+    let { callback } = optionsObj;
+    diffLines(oldStr, newStr, Object.assign(Object.assign({}, optionsObj), { callback: (diff) => {
+      let patch = diffLinesResultToPatch(diff);
+      callback(patch);
+    } }));
+  } else
+    return diffLinesResultToPatch(diffLines(oldStr, newStr, optionsObj));
+  function diffLinesResultToPatch(diff) {
+    if (!diff)
+      return;
+    diff.push({ value: "", lines: [] });
+    function contextLines(lines) {
+      return lines.map(function(entry) {
+        return " " + entry;
+      });
+    }
+    let hunks = [], oldRangeStart = 0, newRangeStart = 0, curRange = [], oldLine = 1, newLine = 1;
+    for (let i = 0; i < diff.length; i++) {
+      let current = diff[i], lines = current.lines || splitLines(current.value);
+      if (current.lines = lines, current.added || current.removed) {
+        if (!oldRangeStart) {
+          let prev = diff[i - 1];
+          oldRangeStart = oldLine, newRangeStart = newLine, prev && (curRange = context > 0 ? contextLines(prev.lines.slice(-context)) : [], oldRangeStart -= curRange.length, newRangeStart -= curRange.length);
+        }
+        for (let line of lines)
+          curRange.push((current.added ? "+" : "-") + line);
+        current.added ? newLine += lines.length : oldLine += lines.length;
+      } else {
+        if (oldRangeStart)
+          if (lines.length <= context * 2 && i < diff.length - 2)
+            for (let line of contextLines(lines))
+              curRange.push(line);
+          else {
+            let contextSize = Math.min(lines.length, context);
+            for (let line of contextLines(lines.slice(0, contextSize)))
+              curRange.push(line);
+            let hunk = {
+              oldStart: oldRangeStart,
+              oldLines: oldLine - oldRangeStart + contextSize,
+              newStart: newRangeStart,
+              newLines: newLine - newRangeStart + contextSize,
+              lines: curRange
+            };
+            hunks.push(hunk), oldRangeStart = 0, newRangeStart = 0, curRange = [];
+          }
+        oldLine += lines.length, newLine += lines.length;
+      }
+    }
+    for (let hunk of hunks)
+      for (let i = 0; i < hunk.lines.length; i++)
+        hunk.lines[i].endsWith(`
+`) ? hunk.lines[i] = hunk.lines[i].slice(0, -1) : (hunk.lines.splice(i + 1, 0, "\"), i++);
+    return {
+      oldFileName,
+      newFileName,
+      oldHeader,
+      newHeader,
+      hunks
+    };
+  }
+}
+function formatPatch(patch, headerOptions) {
+  if (headerOptions || (headerOptions = INCLUDE_HEADERS), Array.isArray(patch)) {
+    if (patch.length > 1 && !headerOptions.includeFileHeaders)
+      throw new Error("Cannot omit file headers on a multi-file patch. (The result would be unparseable; how would a tool trying to apply the patch know which changes are to which file?)");
+    return patch.map((p) => formatPatch(p, headerOptions)).join(`
+`);
+  }
+  let ret = [];
+  headerOptions.includeIndex && patch.oldFileName == patch.newFileName && ret.push("Index: " + patch.oldFileName), headerOptions.includeUnderline && ret.push("==================================================================="), headerOptions.includeFileHeaders && (ret.push("--- " + patch.oldFileName + (typeof patch.oldHeader > "u" ? "" : "	" + patch.oldHeader)), ret.push("+++ " + patch.newFileName + (typeof patch.newHeader > "u" ? "" : "	" + patch.newHeader)));
+  for (let i = 0; i < patch.hunks.length; i++) {
+    let hunk = patch.hunks[i];
+    hunk.oldLines === 0 && (hunk.oldStart -= 1), hunk.newLines === 0 && (hunk.newStart -= 1), ret.push("@@ -" + hunk.oldStart + "," + hunk.oldLines + " +" + hunk.newStart + "," + hunk.newLines + " @@");
+    for (let line of hunk.lines)
+      ret.push(line);
+  }
+  return ret.join(`
+`) + `
+`;
+}
+function createTwoFilesPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options) {
+  if (typeof options == "function" && (options = { callback: options }), options?.callback) {
+    let { callback } = options;
+    structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, Object.assign(Object.assign({}, options), { callback: (patchObj) => {
+      callback(patchObj ? formatPatch(patchObj, options.headerOptions) : void 0);
+    } }));
+  } else {
+    let patchObj = structuredPatch(oldFileName, newFileName, oldStr, newStr, oldHeader, newHeader, options);
+    return patchObj ? formatPatch(patchObj, options?.headerOptions) : void 0;
+  }
+}
+function splitLines(text) {
+  let hasTrailingNl = text.endsWith(`
+`), result = text.split(`
+`).map((line) => line + `
+`);
+  return hasTrailingNl ? result.pop() : result.push(result.pop().slice(0, -1)), result;
+}
+
+// packages/coding-agent/dist/modes/interactive/components/diff.js
+function parseDiffLine(line) {
+  let match = line.match(/^([+-\s])(\s*\d*)\s(.*)$/);
+  return match ? { prefix: match[1], lineNum: match[2], content: match[3] } : null;
+}
+function replaceTabs2(text) {
+  return text.replace(/\t/g, "   ");
+}
+function renderIntraLineDiff(oldContent, newContent) {
+  let wordDiff2 = diffWords(oldContent, newContent), removedLine = "", addedLine = "", isFirstRemoved = !0, isFirstAdded = !0;
+  for (let part of wordDiff2)
+    if (part.removed) {
+      let value = part.value;
+      if (isFirstRemoved) {
+        let leadingWs2 = value.match(/^(\s*)/)?.[1] || "";
+        value = value.slice(leadingWs2.length), removedLine += leadingWs2, isFirstRemoved = !1;
+      }
+      value && (removedLine += theme.inverse(value));
+    } else if (part.added) {
+      let value = part.value;
+      if (isFirstAdded) {
+        let leadingWs2 = value.match(/^(\s*)/)?.[1] || "";
+        value = value.slice(leadingWs2.length), addedLine += leadingWs2, isFirstAdded = !1;
+      }
+      value && (addedLine += theme.inverse(value));
+    } else
+      removedLine += part.value, addedLine += part.value;
+  return { removedLine, addedLine };
+}
+function renderDiff(diffText, _options = {}) {
+  let lines = diffText.split(`
+`), result = [], i = 0;
+  for (; i < lines.length; ) {
+    let line = lines[i], parsed = parseDiffLine(line);
+    if (!parsed) {
+      result.push(theme.fg("toolDiffContext", line)), i++;
+      continue;
+    }
+    if (parsed.prefix === "-") {
+      let removedLines = [];
+      for (; i < lines.length; ) {
+        let p = parseDiffLine(lines[i]);
+        if (!p || p.prefix !== "-")
+          break;
+        removedLines.push({ lineNum: p.lineNum, content: p.content }), i++;
+      }
+      let addedLines = [];
+      for (; i < lines.length; ) {
+        let p = parseDiffLine(lines[i]);
+        if (!p || p.prefix !== "+")
+          break;
+        addedLines.push({ lineNum: p.lineNum, content: p.content }), i++;
+      }
+      if (removedLines.length === 1 && addedLines.length === 1) {
+        let removed = removedLines[0], added = addedLines[0], { removedLine, addedLine } = renderIntraLineDiff(replaceTabs2(removed.content), replaceTabs2(added.content));
+        result.push(theme.fg("toolDiffRemoved", `-${removed.lineNum} ${removedLine}`)), result.push(theme.fg("toolDiffAdded", `+${added.lineNum} ${addedLine}`));
+      } else {
+        for (let removed of removedLines)
+          result.push(theme.fg("toolDiffRemoved", `-${removed.lineNum} ${replaceTabs2(removed.content)}`));
+        for (let added of addedLines)
+          result.push(theme.fg("toolDiffAdded", `+${added.lineNum} ${replaceTabs2(added.content)}`));
+      }
+    } else parsed.prefix === "+" ? (result.push(theme.fg("toolDiffAdded", `+${parsed.lineNum} ${replaceTabs2(parsed.content)}`)), i++) : (result.push(theme.fg("toolDiffContext", ` ${parsed.lineNum} ${replaceTabs2(parsed.content)}`)), i++);
+  }
+  return result.join(`
+`);
+}
+
+// packages/coding-agent/dist/core/tools/edit-diff.js
+import { constants as constants3 } from "fs";
+import { access as access2, readFile } from "fs/promises";
+
+// packages/coding-agent/dist/core/tools/path-utils.js
+import { accessSync, constants as constants2 } from "node:fs";
+import { access } from "node:fs/promises";
+var NARROW_NO_BREAK_SPACE = "\u202F";
+function tryMacOSScreenshotPath(filePath) {
+  return filePath.replace(/ (AM|PM)\./gi, `${NARROW_NO_BREAK_SPACE}$1.`);
+}
+function tryNFDVariant(filePath) {
+  return filePath.normalize("NFD");
+}
+function tryCurlyQuoteVariant(filePath) {
+  return filePath.replace(/'/g, "\u2019");
+}
+function fileExists(filePath) {
+  try {
+    return accessSync(filePath, constants2.F_OK), !0;
+  } catch {
+    return !1;
+  }
+}
+async function pathExists(filePath) {
+  try {
+    return await access(filePath, constants2.F_OK), !0;
+  } catch {
+    return !1;
+  }
+}
+function resolveToCwd(filePath, cwd) {
+  return resolvePath(filePath, cwd, { normalizeUnicodeSpaces: !0, stripAtPrefix: !0 });
+}
+function resolveReadPath(filePath, cwd) {
+  let resolved = resolveToCwd(filePath, cwd);
+  if (fileExists(resolved))
+    return resolved;
+  let amPmVariant = tryMacOSScreenshotPath(resolved);
+  if (amPmVariant !== resolved && fileExists(amPmVariant))
+    return amPmVariant;
+  let nfdVariant = tryNFDVariant(resolved);
+  if (nfdVariant !== resolved && fileExists(nfdVariant))
+    return nfdVariant;
+  let curlyVariant = tryCurlyQuoteVariant(resolved);
+  if (curlyVariant !== resolved && fileExists(curlyVariant))
+    return curlyVariant;
+  let nfdCurlyVariant = tryCurlyQuoteVariant(nfdVariant);
+  return nfdCurlyVariant !== resolved && fileExists(nfdCurlyVariant) ? nfdCurlyVariant : resolved;
+}
+async function resolveReadPathAsync(filePath, cwd) {
+  let resolved = resolveToCwd(filePath, cwd);
+  if (await pathExists(resolved))
+    return resolved;
+  let amPmVariant = tryMacOSScreenshotPath(resolved);
+  if (amPmVariant !== resolved && await pathExists(amPmVariant))
+    return amPmVariant;
+  let nfdVariant = tryNFDVariant(resolved);
+  if (nfdVariant !== resolved && await pathExists(nfdVariant))
+    return nfdVariant;
+  let curlyVariant = tryCurlyQuoteVariant(resolved);
+  if (curlyVariant !== resolved && await pathExists(curlyVariant))
+    return curlyVariant;
+  let nfdCurlyVariant = tryCurlyQuoteVariant(nfdVariant);
+  return nfdCurlyVariant !== resolved && await pathExists(nfdCurlyVariant) ? nfdCurlyVariant : resolved;
+}
+
+// packages/coding-agent/dist/core/tools/edit-diff.js
+function detectLineEnding(content) {
+  let crlfIdx = content.indexOf(`\r
+`), lfIdx = content.indexOf(`
+`);
+  return lfIdx === -1 || crlfIdx === -1 ? `
+` : crlfIdx < lfIdx ? `\r
+` : `
+`;
+}
+function normalizeToLF(text) {
+  return text.replace(/\r\n/g, `
+`).replace(/\r/g, `
+`);
+}
+function restoreLineEndings(text, ending) {
+  return ending === `\r
+` ? text.replace(/\n/g, `\r
+`) : text;
+}
+function normalizeForFuzzyMatch(text) {
+  return text.normalize("NFKC").split(`
+`).map((line) => line.trimEnd()).join(`
+`).replace(/[\u2018\u2019\u201A\u201B]/g, "'").replace(/[\u201C\u201D\u201E\u201F]/g, '"').replace(/[\u2010\u2011\u2012\u2013\u2014\u2015\u2212]/g, "-").replace(/[\u00A0\u2002-\u200A\u202F\u205F\u3000]/g, " ");
+}
+function splitLinesWithEndings(content) {
+  return content.match(/[^\n]*\n|[^\n]+/g) ?? [];
+}
+function getLineSpans(content) {
+  let offset = 0;
+  return splitLinesWithEndings(content).map((line) => {
+    let span = { start: offset, end: offset + line.length };
+    return offset = span.end, span;
+  });
+}
+function getReplacementLineRange(lines, replacement) {
+  let replacementStart = replacement.matchIndex, replacementEnd = replacement.matchIndex + replacement.matchLength, startLine = -1;
+  for (let i = 0; i < lines.length; i++) {
+    let line = lines[i];
+    if (replacementStart >= line.start && replacementStart < line.end) {
+      startLine = i;
+      break;
+    }
+  }
+  if (startLine === -1)
+    throw new Error("Replacement range is outside the base content.");
+  let endLine = startLine;
+  for (; endLine < lines.length && lines[endLine].end < replacementEnd; )
+    endLine++;
+  if (endLine >= lines.length)
+    throw new Error("Replacement range is outside the base content.");
+  return { startLine, endLine: endLine + 1 };
+}
+function applyReplacements(content, replacements, offset = 0) {
+  let result = content;
+  for (let i = replacements.length - 1; i >= 0; i--) {
+    let replacement = replacements[i], matchIndex = replacement.matchIndex - offset;
+    result = result.substring(0, matchIndex) + replacement.newText + result.substring(matchIndex + replacement.matchLength);
+  }
+  return result;
+}
+function applyReplacementsPreservingUnchangedLines(originalContent, baseContent, replacements) {
+  let originalLines = splitLinesWithEndings(originalContent), baseLines = getLineSpans(baseContent);
+  if (originalLines.length !== baseLines.length)
+    throw new Error("Cannot preserve unchanged lines because the base content has a different line count.");
+  let groups = [], sortedReplacements = [...replacements].sort((a, b) => a.matchIndex - b.matchIndex);
+  for (let replacement of sortedReplacements) {
+    let range = getReplacementLineRange(baseLines, replacement), current = groups[groups.length - 1];
+    if (current && range.startLine < current.endLine) {
+      current.endLine = Math.max(current.endLine, range.endLine), current.replacements.push(replacement);
+      continue;
+    }
+    groups.push({ ...range, replacements: [replacement] });
+  }
+  let originalLineIndex = 0, result = "";
+  for (let group of groups) {
+    result += originalLines.slice(originalLineIndex, group.startLine).join("");
+    let groupStartOffset = baseLines[group.startLine].start, groupEndOffset = baseLines[group.endLine - 1].end;
+    result += applyReplacements(baseContent.slice(groupStartOffset, groupEndOffset), group.replacements, groupStartOffset), originalLineIndex = group.endLine;
+  }
+  return result += originalLines.slice(originalLineIndex).join(""), result;
+}
+function fuzzyFindText(content, oldText) {
+  let exactIndex = content.indexOf(oldText);
+  if (exactIndex !== -1)
+    return {
+      found: !0,
+      index: exactIndex,
+      matchLength: oldText.length,
+      usedFuzzyMatch: !1,
+      contentForReplacement: content
+    };
+  let fuzzyContent = normalizeForFuzzyMatch(content), fuzzyOldText = normalizeForFuzzyMatch(oldText), fuzzyIndex = fuzzyContent.indexOf(fuzzyOldText);
+  return fuzzyIndex === -1 ? {
+    found: !1,
+    index: -1,
+    matchLength: 0,
+    usedFuzzyMatch: !1,
+    contentForReplacement: content
+  } : {
+    found: !0,
+    index: fuzzyIndex,
+    matchLength: fuzzyOldText.length,
+    usedFuzzyMatch: !0,
+    contentForReplacement: fuzzyContent
+  };
+}
+function stripBom(content) {
+  return content.startsWith("\uFEFF") ? { bom: "\uFEFF", text: content.slice(1) } : { bom: "", text: content };
+}
+function countOccurrences(content, oldText) {
+  let fuzzyContent = normalizeForFuzzyMatch(content), fuzzyOldText = normalizeForFuzzyMatch(oldText);
+  return fuzzyContent.split(fuzzyOldText).length - 1;
+}
+function getNotFoundError(path3, editIndex, totalEdits) {
+  return totalEdits === 1 ? new Error(`Could not find the exact text in ${path3}. The old text must match exactly including all whitespace and newlines.`) : new Error(`Could not find edits[${editIndex}] in ${path3}. The oldText must match exactly including all whitespace and newlines.`);
+}
+function getDuplicateError(path3, editIndex, totalEdits, occurrences) {
+  return totalEdits === 1 ? new Error(`Found ${occurrences} occurrences of the text in ${path3}. The text must be unique. Please provide more context to make it unique.`) : new Error(`Found ${occurrences} occurrences of edits[${editIndex}] in ${path3}. Each oldText must be unique. Please provide more context to make it unique.`);
+}
+function getEmptyOldTextError(path3, editIndex, totalEdits) {
+  return totalEdits === 1 ? new Error(`oldText must not be empty in ${path3}.`) : new Error(`edits[${editIndex}].oldText must not be empty in ${path3}.`);
+}
+function getNoChangeError(path3, totalEdits) {
+  return totalEdits === 1 ? new Error(`No changes made to ${path3}. The replacement produced identical content. This might indicate an issue with special characters or the text not existing as expected.`) : new Error(`No changes made to ${path3}. The replacements produced identical content.`);
+}
+function applyEditsToNormalizedContent(normalizedContent, edits, path3) {
+  let normalizedEdits = edits.map((edit) => ({
+    oldText: normalizeToLF(edit.oldText),
+    newText: normalizeToLF(edit.newText)
+  }));
+  for (let i = 0; i < normalizedEdits.length; i++)
+    if (normalizedEdits[i].oldText.length === 0)
+      throw getEmptyOldTextError(path3, i, normalizedEdits.length);
+  let usedFuzzyMatch = normalizedEdits.map((edit) => fuzzyFindText(normalizedContent, edit.oldText)).some((match) => match.usedFuzzyMatch), replacementBaseContent = usedFuzzyMatch ? normalizeForFuzzyMatch(normalizedContent) : normalizedContent, matchedEdits = [];
+  for (let i = 0; i < normalizedEdits.length; i++) {
+    let edit = normalizedEdits[i], matchResult = fuzzyFindText(replacementBaseContent, edit.oldText);
+    if (!matchResult.found)
+      throw getNotFoundError(path3, i, normalizedEdits.length);
+    let occurrences = countOccurrences(replacementBaseContent, edit.oldText);
+    if (occurrences > 1)
+      throw getDuplicateError(path3, i, normalizedEdits.length, occurrences);
+    matchedEdits.push({
+      editIndex: i,
+      matchIndex: matchResult.index,
+      matchLength: matchResult.matchLength,
+      newText: edit.newText
+    });
+  }
+  matchedEdits.sort((a, b) => a.matchIndex - b.matchIndex);
+  for (let i = 1; i < matchedEdits.length; i++) {
+    let previous = matchedEdits[i - 1], current = matchedEdits[i];
+    if (previous.matchIndex + previous.matchLength > current.matchIndex)
+      throw new Error(`edits[${previous.editIndex}] and edits[${current.editIndex}] overlap in ${path3}. Merge them into one edit or target disjoint regions.`);
+  }
+  let baseContent = normalizedContent, newContent = usedFuzzyMatch ? applyReplacementsPreservingUnchangedLines(normalizedContent, replacementBaseContent, matchedEdits) : applyReplacements(replacementBaseContent, matchedEdits);
+  if (baseContent === newContent)
+    throw getNoChangeError(path3, normalizedEdits.length);
+  return { baseContent, newContent };
+}
+function generateUnifiedPatch(path3, oldContent, newContent, contextLines = 4) {
+  return createTwoFilesPatch(path3, path3, oldContent, newContent, void 0, void 0, {
+    context: contextLines,
+    headerOptions: FILE_HEADERS_ONLY
+  });
+}
+function generateDiffString(oldContent, newContent, contextLines = 4) {
+  let parts = diffLines(oldContent, newContent), output = [], oldLines = oldContent.split(`
+`), newLines = newContent.split(`
+`), maxLineNum = Math.max(oldLines.length, newLines.length), lineNumWidth = String(maxLineNum).length, oldLineNum = 1, newLineNum = 1, lastWasChange = !1, firstChangedLine;
+  for (let i = 0; i < parts.length; i++) {
+    let part = parts[i], raw = part.value.split(`
+`);
+    if (raw[raw.length - 1] === "" && raw.pop(), part.added || part.removed) {
+      firstChangedLine === void 0 && (firstChangedLine = newLineNum);
+      for (let line of raw)
+        if (part.added) {
+          let lineNum = String(newLineNum).padStart(lineNumWidth, " ");
+          output.push(`+${lineNum} ${line}`), newLineNum++;
+        } else {
+          let lineNum = String(oldLineNum).padStart(lineNumWidth, " ");
+          output.push(`-${lineNum} ${line}`), oldLineNum++;
+        }
+      lastWasChange = !0;
+    } else {
+      let nextPartIsChange = i < parts.length - 1 && (parts[i + 1].added || parts[i + 1].removed), hasLeadingChange = lastWasChange, hasTrailingChange = nextPartIsChange;
+      if (hasLeadingChange && hasTrailingChange)
+        if (raw.length <= contextLines * 2)
+          for (let line of raw) {
+            let lineNum = String(oldLineNum).padStart(lineNumWidth, " ");
+            output.push(` ${lineNum} ${line}`), oldLineNum++, newLineNum++;
+          }
+        else {
+          let leadingLines = raw.slice(0, contextLines), trailingLines = raw.slice(raw.length - contextLines), skippedLines = raw.length - leadingLines.length - trailingLines.length;
+          for (let line of leadingLines) {
+            let lineNum = String(oldLineNum).padStart(lineNumWidth, " ");
+            output.push(` ${lineNum} ${line}`), oldLineNum++, newLineNum++;
+          }
+          output.push(` ${"".padStart(lineNumWidth, " ")} ...`), oldLineNum += skippedLines, newLineNum += skippedLines;
+          for (let line of trailingLines) {
+            let lineNum = String(oldLineNum).padStart(lineNumWidth, " ");
+            output.push(` ${lineNum} ${line}`), oldLineNum++, newLineNum++;
+          }
+        }
+      else if (hasLeadingChange) {
+        let shownLines = raw.slice(0, contextLines), skippedLines = raw.length - shownLines.length;
+        for (let line of shownLines) {
+          let lineNum = String(oldLineNum).padStart(lineNumWidth, " ");
+          output.push(` ${lineNum} ${line}`), oldLineNum++, newLineNum++;
+        }
+        skippedLines > 0 && (output.push(` ${"".padStart(lineNumWidth, " ")} ...`), oldLineNum += skippedLines, newLineNum += skippedLines);
+      } else if (hasTrailingChange) {
+        let skippedLines = Math.max(0, raw.length - contextLines);
+        skippedLines > 0 && (output.push(` ${"".padStart(lineNumWidth, " ")} ...`), oldLineNum += skippedLines, newLineNum += skippedLines);
+        for (let line of raw.slice(skippedLines)) {
+          let lineNum = String(oldLineNum).padStart(lineNumWidth, " ");
+          output.push(` ${lineNum} ${line}`), oldLineNum++, newLineNum++;
+        }
+      } else
+        oldLineNum += raw.length, newLineNum += raw.length;
+      lastWasChange = !1;
+    }
+  }
+  return { diff: output.join(`
+`), firstChangedLine };
+}
+async function computeEditsDiff(path3, edits, cwd) {
+  let absolutePath = resolveToCwd(path3, cwd);
+  try {
+    try {
+      await access2(absolutePath, constants3.R_OK);
+    } catch (error) {
+      let errorMessage = error instanceof Error && "code" in error ? `Error code: ${error.code}` : String(error);
+      return { error: `Could not edit file: ${path3}. ${errorMessage}.` };
+    }
+    let rawContent = await readFile(absolutePath, "utf-8"), { text: content } = stripBom(rawContent), normalizedContent = normalizeToLF(content), { baseContent, newContent } = applyEditsToNormalizedContent(normalizedContent, edits, path3);
+    return generateDiffString(baseContent, newContent);
+  } catch (err) {
+    return { error: err instanceof Error ? err.message : String(err) };
+  }
+}
+
+// packages/coding-agent/dist/core/tools/file-mutation-queue.js
+import { realpath } from "node:fs/promises";
+import { resolve } from "node:path";
+var fileMutationQueues = /* @__PURE__ */ new Map(), registrationQueue = Promise.resolve();
+function isMissingPathError(error) {
+  return typeof error == "object" && error !== null && "code" in error && (error.code === "ENOENT" || error.code === "ENOTDIR");
+}
+async function getMutationQueueKey(filePath) {
+  let resolvedPath = resolve(filePath);
+  try {
+    return await realpath(resolvedPath);
+  } catch (error) {
+    if (isMissingPathError(error))
+      return resolvedPath;
+    throw error;
+  }
+}
+async function withFileMutationQueue(filePath, fn) {
+  let registration = registrationQueue.then(async () => {
+    let key2 = await getMutationQueueKey(filePath), currentQueue2 = fileMutationQueues.get(key2) ?? Promise.resolve(), releaseNext2, nextQueue = new Promise((resolveQueue) => {
+      releaseNext2 = resolveQueue;
+    }), chainedQueue2 = currentQueue2.then(() => nextQueue);
+    return fileMutationQueues.set(key2, chainedQueue2), { key: key2, currentQueue: currentQueue2, chainedQueue: chainedQueue2, releaseNext: releaseNext2 };
+  });
+  registrationQueue = registration.then(() => {
+  }, () => {
+  });
+  let { key, currentQueue, chainedQueue, releaseNext } = await registration;
+  await currentQueue;
+  try {
+    return await fn();
+  } finally {
+    releaseNext(), fileMutationQueues.get(key) === chainedQueue && fileMutationQueues.delete(key);
+  }
+}
+
+// packages/coding-agent/dist/core/tools/edit.js
+import { Box, Container as Container2, Spacer, Text as Text3 } from "@ashx-j/lunr-tui";
+import { constants as constants4 } from "fs";
+import { access as fsAccess2, readFile as fsReadFile, writeFile as fsWriteFile } from "fs/promises";
+import { Type as Type2 } from "typebox";
+var replaceEditSchema = Type2.Object({
+  oldText: Type2.String({
+    description: "Exact text for one targeted replacement. It must be unique in the original file and must not overlap with any other edits[].oldText in the same call."
+  }),
+  newText: Type2.String({ description: "Replacement text for this targeted edit." })
+}, {}), editSchema = Type2.Object({
+  path: Type2.String({ description: "Path to the file to edit (relative or absolute)" }),
+  edits: Type2.Array(replaceEditSchema, {
+    description: "One or more targeted replacements. Each edit is matched against the original file, not incrementally. Do not include overlapping or nested edits. If two changes touch the same block or nearby lines, merge them into one edit instead."
+  })
+}, {}), defaultEditOperations = {
+  readFile: (path3) => fsReadFile(path3),
+  writeFile: (path3, content) => fsWriteFile(path3, content, "utf-8"),
+  access: (path3) => fsAccess2(path3, constants4.R_OK | constants4.W_OK)
+};
+function prepareEditArguments(input) {
+  if (!input || typeof input != "object")
+    return input;
+  let args = input;
+  if (typeof args.edits == "string")
+    try {
+      let parsed = JSON.parse(args.edits);
+      Array.isArray(parsed) && (args.edits = parsed);
+    } catch {
+    }
+  let legacy = args;
+  if (typeof legacy.oldText != "string" || typeof legacy.newText != "string")
+    return args;
+  let edits = Array.isArray(legacy.edits) ? [...legacy.edits] : [];
+  edits.push({ oldText: legacy.oldText, newText: legacy.newText });
+  let { oldText: _oldText, newText: _newText, ...rest } = legacy;
+  return { ...rest, edits };
+}
+function validateEditInput(input) {
+  if (!Array.isArray(input.edits) || input.edits.length === 0)
+    throw new Error("Edit tool input is invalid. edits must contain at least one replacement.");
+  return { path: input.path, edits: input.edits };
+}
+function createEditCallRenderComponent() {
+  return Object.assign(new Box(1, 1, (text) => text), {
+    preview: void 0,
+    previewArgsKey: void 0,
+    previewPending: !1,
+    settledError: !1
+  });
+}
+function getEditCallRenderComponent(state, lastComponent) {
+  if (lastComponent instanceof Box) {
+    let component2 = lastComponent;
+    return state.callComponent = component2, component2;
+  }
+  if (state.callComponent)
+    return state.callComponent;
+  let component = createEditCallRenderComponent();
+  return state.callComponent = component, component;
+}
+function getRenderablePreviewInput(args) {
+  if (!args)
+    return null;
+  let path3 = typeof args.path == "string" ? args.path : typeof args.file_path == "string" ? args.file_path : null;
+  return path3 ? Array.isArray(args.edits) && args.edits.length > 0 && args.edits.every((edit) => typeof edit?.oldText == "string" && typeof edit?.newText == "string") ? { path: path3, edits: args.edits } : typeof args.oldText == "string" && typeof args.newText == "string" ? { path: path3, edits: [{ oldText: args.oldText, newText: args.newText }] } : null : null;
+}
+function formatEditCall(args, theme2, cwd, compact = !1) {
+  let rawPath = str(args?.file_path ?? args?.path);
+  return compact ? renderToolFileName(rawPath, theme2, cwd) : renderToolPath(rawPath, theme2, cwd);
+}
+function formatEditResult(args, preview, result, theme2, isError) {
+  let rawPath = str(args?.file_path ?? args?.path), previewDiff = preview && !("error" in preview) ? preview.diff : void 0, previewError = preview && "error" in preview ? preview.error : void 0;
+  if (isError) {
+    let errorText = result.content.filter((c) => c.type === "text").map((c) => c.text || "").join(`
+`);
+    return !errorText || errorText === previewError ? void 0 : theme2.fg("error", errorText);
+  }
+  let resultDiff = result.details?.diff;
+  if (resultDiff && resultDiff !== previewDiff)
+    return renderDiff(resultDiff, { filePath: rawPath ?? void 0 });
+}
+function getEditHeaderBg(preview, settledError, theme2) {
+  return preview ? "error" in preview ? (text) => theme2.bg("toolErrorBg", text) : (text) => theme2.bg("toolSuccessBg", text) : settledError ? (text) => theme2.bg("toolErrorBg", text) : (text) => theme2.bg("toolPendingBg", text);
+}
+function buildEditCallComponent(component, args, theme2, cwd, dotState, compact = !1, role = "singleton", tree = compact) {
+  component.setBgFn(getEditHeaderBg(component.preview, component.settledError, theme2)), component.clear();
+  let grouped = tree && role !== "singleton", pathDisplay = formatEditCall(args, theme2, cwd, compact || grouped);
+  if (component.addChild(new Text3(formatGroupedCall({
+    role,
+    compact,
+    tree,
+    dot: toolStatusDot(dotState, theme2),
+    title: theme2.fg("toolTitle", theme2.bold("edit")),
+    detail: pathDisplay
+  }), 0, 0)), compact || grouped || !component.preview)
+    return component;
+  let body = "error" in component.preview ? theme2.fg("error", component.preview.error) : renderDiff(component.preview.diff);
+  return component.addChild(new Spacer(1)), component.addChild(new Text3(body, 0, 0)), component;
+}
+function setEditPreview(component, preview, argsKey) {
+  let current = component.preview, changed = current === void 0 || ("error" in current && "error" in preview ? current.error !== preview.error : "error" in current != "error" in preview) || !("error" in current) && !("error" in preview) && (current.diff !== preview.diff || current.firstChangedLine !== preview.firstChangedLine);
+  return component.preview = preview, component.previewArgsKey = argsKey, component.previewPending = !1, changed;
+}
+function createEditToolDefinition(cwd, options) {
+  let ops = options?.operations ?? defaultEditOperations;
+  return {
+    name: "edit",
+    label: "edit",
+    description: "Edit a single file using exact text replacement. Every edits[].oldText must match a unique, non-overlapping region of the original file. If two changes affect the same block or nearby lines, merge them into one edit instead of emitting overlapping edits. Do not include large unchanged regions just to connect distant changes.",
+    promptSnippet: "Make precise file edits with exact text replacement, including multiple disjoint edits in one call",
+    promptGuidelines: [
+      "Use edit for precise changes (edits[].oldText must match exactly)",
+      "When changing multiple separate locations in one file, use one edit call with multiple entries in edits[] instead of multiple edit calls",
+      "Each edits[].oldText is matched against the original file, not after earlier edits are applied. Do not emit overlapping or nested edits. Merge nearby changes into one edit.",
+      "Keep edits[].oldText as small as possible while still being unique in the file. Do not pad with large unchanged regions."
+    ],
+    parameters: editSchema,
+    renderShell: "self",
+    prepareArguments: prepareEditArguments,
+    async execute(_toolCallId, input, signal, _onUpdate, _ctx) {
+      let { path: path3, edits } = validateEditInput(input), absolutePath = resolveToCwd(path3, cwd);
+      return withFileMutationQueue(absolutePath, async () => {
+        let throwIfAborted = () => {
+          if (signal?.aborted)
+            throw new Error("Operation aborted");
+        };
+        throwIfAborted();
+        try {
+          await ops.access(absolutePath);
+        } catch (error) {
+          throwIfAborted();
+          let errorMessage = error instanceof Error && "code" in error ? `Error code: ${error.code}` : String(error);
+          throw new Error(`Could not edit file: ${path3}. ${errorMessage}.`);
+        }
+        throwIfAborted();
+        let rawContent = (await ops.readFile(absolutePath)).toString("utf-8");
+        throwIfAborted();
+        let { bom, text: content } = stripBom(rawContent), originalEnding = detectLineEnding(content), normalizedContent = normalizeToLF(content), { baseContent, newContent } = applyEditsToNormalizedContent(normalizedContent, edits, path3);
+        throwIfAborted();
+        let finalContent = bom + restoreLineEndings(newContent, originalEnding);
+        await ops.writeFile(absolutePath, finalContent), throwIfAborted();
+        let diffResult = generateDiffString(baseContent, newContent), patch = generateUnifiedPatch(path3, baseContent, newContent);
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Successfully replaced ${edits.length} block(s) in ${path3}.`
+            }
+          ],
+          details: { diff: diffResult.diff, patch, firstChangedLine: diffResult.firstChangedLine }
+        };
+      });
+    },
+    renderCall(args, theme2, context) {
+      let component = getEditCallRenderComponent(context.state, context.lastComponent), previewInput = getRenderablePreviewInput(args), argsKey = previewInput ? JSON.stringify({ path: previewInput.path, edits: previewInput.edits }) : void 0;
+      if (component.previewArgsKey !== argsKey && (component.preview = void 0, component.previewArgsKey = argsKey, component.previewPending = !1, component.settledError = !1), context.argsComplete && previewInput && !component.preview && !component.previewPending) {
+        component.previewPending = !0;
+        let requestKey = argsKey;
+        computeEditsDiff(previewInput.path, previewInput.edits, context.cwd).then((preview) => {
+          component.previewArgsKey === requestKey && (setEditPreview(component, preview, requestKey), context.invalidate());
+        });
+      }
+      return buildEditCallComponent(
+        component,
+        args,
+        theme2,
+        context.cwd,
+        context.isPartial ? "pending" : context.isError ? "error" : "success",
+        // lunr: compact-by-default
+        !context.isPartial && !context.expanded && !context.isError,
+        context.groupRole ?? "singleton",
+        toolGroupTree(context)
+      );
+    },
+    renderResult(result, _options, theme2, context) {
+      let callComponent = context.state.callComponent, previewInput = getRenderablePreviewInput(context.args), argsKey = previewInput ? JSON.stringify({ path: previewInput.path, edits: previewInput.edits }) : void 0, typedResult = result, resultDiff = context.isError ? void 0 : typedResult.details?.diff, compact = !_options.isPartial && !_options.expanded && !context.isError, changed = !1;
+      callComponent && (typeof resultDiff == "string" && (changed = setEditPreview(callComponent, { diff: resultDiff, firstChangedLine: typedResult.details?.firstChangedLine }, argsKey) || changed), callComponent.settledError !== context.isError && (callComponent.settledError = context.isError, changed = !0), (changed || compact) && buildEditCallComponent(callComponent, context.args, theme2, context.cwd, context.isPartial ? "pending" : context.isError ? "error" : "success", compact, context.groupRole ?? "singleton", toolGroupTree(context)));
+      let output = compact ? void 0 : formatEditResult(context.args, callComponent?.preview, typedResult, theme2, context.isError), component = context.lastComponent ?? new Container2();
+      return component.clear(), output && (component.addChild(new Spacer(1)), component.addChild(new Text3(output, 1, 0))), component;
+    }
+  };
+}
+function createEditTool(cwd, options) {
+  return wrapToolDefinition(createEditToolDefinition(cwd, options));
+}
+
+// packages/coding-agent/dist/utils/tools-manager.js
+import chalk from "chalk";
+import { spawnSync } from "child_process";
+import { chmodSync, createWriteStream as createWriteStream2, existsSync, mkdirSync, readdirSync, renameSync, rmSync } from "fs";
+import { arch, platform } from "os";
+import { join as join2 } from "path";
+import { Readable } from "stream";
+import { pipeline } from "stream/promises";
+var TOOLS_DIR = getBinDir(), NETWORK_TIMEOUT_MS = 1e4, DOWNLOAD_TIMEOUT_MS = 12e4;
+function isOfflineModeEnabled() {
+  let value = process.env.PI_OFFLINE;
+  return value ? value === "1" || value.toLowerCase() === "true" || value.toLowerCase() === "yes" : !1;
+}
+var TOOLS = {
+  fd: {
+    name: "fd",
+    repo: "sharkdp/fd",
+    binaryName: "fd",
+    systemBinaryNames: ["fd", "fdfind"],
+    tagPrefix: "v",
+    getAssetName: (version, plat, architecture) => plat === "darwin" ? `fd-v${version}-${architecture === "arm64" ? "aarch64" : "x86_64"}-apple-darwin.tar.gz` : plat === "linux" ? `fd-v${version}-${architecture === "arm64" ? "aarch64" : "x86_64"}-unknown-linux-gnu.tar.gz` : plat === "win32" ? `fd-v${version}-${architecture === "arm64" ? "aarch64" : "x86_64"}-pc-windows-msvc.zip` : null
+  },
+  rg: {
+    name: "ripgrep",
+    repo: "BurntSushi/ripgrep",
+    binaryName: "rg",
+    tagPrefix: "",
+    getAssetName: (version, plat, architecture) => plat === "darwin" ? `ripgrep-${version}-${architecture === "arm64" ? "aarch64" : "x86_64"}-apple-darwin.tar.gz` : plat === "linux" ? architecture === "arm64" ? `ripgrep-${version}-aarch64-unknown-linux-gnu.tar.gz` : `ripgrep-${version}-x86_64-unknown-linux-musl.tar.gz` : plat === "win32" ? `ripgrep-${version}-${architecture === "arm64" ? "aarch64" : "x86_64"}-pc-windows-msvc.zip` : null
+  }
+};
+function commandExists(cmd) {
+  try {
+    let result = spawnSync(cmd, ["--version"], { stdio: "pipe" });
+    return result.error === void 0 || result.error === null;
+  } catch {
+    return !1;
+  }
+}
+function getToolPath(tool) {
+  let config = TOOLS[tool];
+  if (!config)
+    return null;
+  let localPath = join2(TOOLS_DIR, config.binaryName + (platform() === "win32" ? ".exe" : ""));
+  if (existsSync(localPath))
+    return localPath;
+  let systemBinaryNames = config.systemBinaryNames ?? [config.binaryName];
+  for (let systemBinaryName of systemBinaryNames)
+    if (commandExists(systemBinaryName))
+      return systemBinaryName;
+  return null;
+}
+async function getLatestVersion(repo) {
+  let response = await fetch(`https://api.github.com/repos/${repo}/releases/latest`, {
+    headers: { "User-Agent": `${APP_NAME}-coding-agent` },
+    signal: AbortSignal.timeout(NETWORK_TIMEOUT_MS)
+  });
+  if (!response.ok)
+    throw new Error(`GitHub API error: ${response.status}`);
+  return (await response.json()).tag_name.replace(/^v/, "");
+}
+async function downloadFile(url, dest) {
+  let response = await fetch(url, {
+    signal: AbortSignal.timeout(DOWNLOAD_TIMEOUT_MS)
+  });
+  if (!response.ok)
+    throw new Error(`Failed to download: ${response.status}`);
+  if (!response.body)
+    throw new Error("No response body");
+  let fileStream = createWriteStream2(dest);
+  await pipeline(Readable.fromWeb(response.body), fileStream);
+}
+function findBinaryRecursively(rootDir, binaryFileName) {
+  let stack = [rootDir];
+  for (; stack.length > 0; ) {
+    let currentDir = stack.pop();
+    if (!currentDir)
+      continue;
+    let entries = readdirSync(currentDir, { withFileTypes: !0 });
+    for (let entry of entries) {
+      let fullPath = join2(currentDir, entry.name);
+      if (entry.isFile() && entry.name === binaryFileName)
+        return fullPath;
+      entry.isDirectory() && stack.push(fullPath);
+    }
+  }
+  return null;
+}
+function formatSpawnFailure(result) {
+  if (result.error?.message)
+    return result.error.message;
+  let stderr = result.stderr?.toString().trim();
+  if (stderr)
+    return stderr;
+  let stdout = result.stdout?.toString().trim();
+  return stdout || `exit status ${result.status ?? "unknown"}`;
+}
+function runExtractionCommand(command, args) {
+  let result = spawnSync(command, args, { stdio: "pipe" });
+  return !result.error && result.status === 0 ? null : `${command}: ${formatSpawnFailure(result)}`;
+}
+function extractTarGzArchive(archivePath, extractDir, assetName) {
+  let failure = runExtractionCommand("tar", ["xzf", archivePath, "-C", extractDir]);
+  if (failure)
+    throw new Error(`Failed to extract ${assetName}: ${failure}`);
+}
+function getWindowsTarCommand() {
+  let systemRoot = process.env.SystemRoot ?? process.env.WINDIR;
+  if (systemRoot) {
+    let systemTar = join2(systemRoot, "System32", "tar.exe");
+    if (existsSync(systemTar))
+      return systemTar;
+  }
+  return "tar.exe";
+}
+function extractZipArchive(archivePath, extractDir, assetName) {
+  let failures = [];
+  if (platform() === "win32") {
+    let tarFailure = runExtractionCommand(getWindowsTarCommand(), ["xf", archivePath, "-C", extractDir]);
+    if (!tarFailure)
+      return;
+    failures.push(tarFailure);
+    let powershellFailure = runExtractionCommand("powershell.exe", [
+      "-NoLogo",
+      "-NoProfile",
+      "-NonInteractive",
+      "-ExecutionPolicy",
+      "Bypass",
+      "-Command",
+      "& { param($archive, $destination) $ErrorActionPreference = 'Stop'; Expand-Archive -LiteralPath $archive -DestinationPath $destination -Force }",
+      archivePath,
+      extractDir
+    ]);
+    if (!powershellFailure)
+      return;
+    failures.push(powershellFailure);
+  } else {
+    let unzipFailure = runExtractionCommand("unzip", ["-q", archivePath, "-d", extractDir]);
+    if (!unzipFailure)
+      return;
+    failures.push(unzipFailure);
+    let tarFailure = runExtractionCommand("tar", ["xf", archivePath, "-C", extractDir]);
+    if (!tarFailure)
+      return;
+    failures.push(tarFailure);
+  }
+  throw new Error(`Failed to extract ${assetName}: ${failures.join("; ")}`);
+}
+async function downloadTool(tool) {
+  let config = TOOLS[tool];
+  if (!config)
+    throw new Error(`Unknown tool: ${tool}`);
+  let plat = platform(), architecture = arch(), version = await getLatestVersion(config.repo);
+  tool === "fd" && plat === "darwin" && architecture === "x64" && (version = "10.3.0");
+  let assetName = config.getAssetName(version, plat, architecture);
+  if (!assetName)
+    throw new Error(`Unsupported platform: ${plat}/${architecture}`);
+  mkdirSync(TOOLS_DIR, { recursive: !0 });
+  let downloadUrl = `https://github.com/${config.repo}/releases/download/${config.tagPrefix}${version}/${assetName}`, archivePath = join2(TOOLS_DIR, assetName), binaryExt = plat === "win32" ? ".exe" : "", binaryPath = join2(TOOLS_DIR, config.binaryName + binaryExt);
+  await downloadFile(downloadUrl, archivePath);
+  let extractDir = join2(TOOLS_DIR, `extract_tmp_${config.binaryName}_${process.pid}_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`);
+  mkdirSync(extractDir, { recursive: !0 });
+  try {
+    if (assetName.endsWith(".tar.gz"))
+      extractTarGzArchive(archivePath, extractDir, assetName);
+    else if (assetName.endsWith(".zip"))
+      extractZipArchive(archivePath, extractDir, assetName);
+    else
+      throw new Error(`Unsupported archive format: ${assetName}`);
+    let binaryFileName = config.binaryName + binaryExt, extractedDir = join2(extractDir, assetName.replace(/\.(tar\.gz|zip)$/, "")), extractedBinary = [join2(extractedDir, binaryFileName), join2(extractDir, binaryFileName)].find((candidate) => existsSync(candidate));
+    if (extractedBinary || (extractedBinary = findBinaryRecursively(extractDir, binaryFileName) ?? void 0), extractedBinary)
+      renameSync(extractedBinary, binaryPath);
+    else
+      throw new Error(`Binary not found in archive: expected ${binaryFileName} under ${extractDir}`);
+    plat !== "win32" && chmodSync(binaryPath, 493);
+  } finally {
+    rmSync(archivePath, { force: !0 }), rmSync(extractDir, { recursive: !0, force: !0 });
+  }
+  return binaryPath;
+}
+var TERMUX_PACKAGES = {
+  fd: "fd",
+  rg: "ripgrep"
+};
+async function ensureTool(tool, silent = !1) {
+  let existingPath = getToolPath(tool);
+  if (existingPath)
+    return existingPath;
+  let config = TOOLS[tool];
+  if (config) {
+    if (isOfflineModeEnabled()) {
+      silent || console.log(chalk.yellow(`${config.name} not found. Offline mode enabled, skipping download.`));
+      return;
+    }
+    if (platform() === "android") {
+      let pkgName = TERMUX_PACKAGES[tool] ?? tool;
+      silent || console.log(chalk.yellow(`${config.name} not found. Install with: pkg install ${pkgName}`));
+      return;
+    }
+    silent || console.log(chalk.dim(`${config.name} not found. Downloading...`));
+    try {
+      let path3 = await downloadTool(tool);
+      return silent || console.log(chalk.dim(`${config.name} installed to ${path3}`)), path3;
+    } catch (e) {
+      silent || console.log(chalk.yellow(`Failed to download ${config.name}: ${e instanceof Error ? e.message : e}`));
+      return;
+    }
+  }
+}
+
+// packages/coding-agent/dist/core/tools/find.js
+import { createInterface } from "node:readline";
+import { Text as Text4 } from "@ashx-j/lunr-tui";
+import { spawn as spawn3 } from "child_process";
+import path from "path";
+import { Type as Type3 } from "typebox";
+function toPosixPath(value) {
+  return value.split(path.sep).join("/");
+}
+var findSchema = Type3.Object({
+  pattern: Type3.String({
+    description: "Glob pattern to match files, e.g. '*.ts', '**/*.json', or 'src/**/*.spec.ts'"
+  }),
+  path: Type3.Optional(Type3.String({ description: "Directory to search in (default: current directory)" })),
+  limit: Type3.Optional(Type3.Number({ description: "Maximum number of results (default: 1000)" }))
+}), DEFAULT_LIMIT = 1e3, defaultFindOperations = {
+  exists: pathExists,
+  // This is a placeholder. Actual fd execution happens in execute() when no custom glob is provided.
+  glob: () => []
+};
+function formatFindCall(args, theme2, cwd, compact = !1) {
+  let pattern = str(args?.pattern), rawPath = str(args?.path), limit = args?.limit, invalidArg = invalidArgText(theme2), text = pattern === null ? invalidArg : theme2.fg("accent", pattern || "");
+  if (compact) {
+    let collapsedPath = renderCollapsedSearchPath(rawPath, theme2, cwd);
+    collapsedPath && (text += theme2.fg("toolOutput", " in ") + collapsedPath);
+  } else {
+    let path3 = rawPath !== null ? shortenPath(rawPath || ".") : null;
+    text += theme2.fg("toolOutput", ` in ${path3 === null ? invalidArg : path3}`);
+  }
+  return limit !== void 0 && (text += theme2.fg("toolOutput", ` (limit ${limit})`)), text;
+}
+function formatFindResult(result, options, theme2, showImages) {
+  let output = getTextOutput(result, showImages).trim(), text = "";
+  if (output) {
+    let lines = output.split(`
+`), maxLines = options.expanded ? lines.length : 20, displayLines = lines.slice(0, maxLines), remaining = lines.length - maxLines;
+    text += `
+${displayLines.map((line) => theme2.fg("toolOutput", line)).join(`
+`)}`, remaining > 0 && (text += `${theme2.fg("muted", `
+... (${remaining} more lines,`)} ${keyHint("app.tools.expand", "to expand")}${theme2.fg("muted", ")")}`);
+  }
+  let resultLimit = result.details?.resultLimitReached, truncation = result.details?.truncation;
+  if (resultLimit || truncation?.truncated) {
+    let warnings = [];
+    resultLimit && warnings.push(`${resultLimit} results limit`), truncation?.truncated && warnings.push(`${formatSize(truncation.maxBytes ?? 51200)} limit`), text += `
+${theme2.fg("warning", `[Truncated: ${warnings.join(", ")}]`)}`;
+  }
+  return text;
+}
+function createFindToolDefinition(cwd, options) {
+  let customOps = options?.operations;
+  return {
+    name: "find",
+    label: "find",
+    description: `Search for files by glob pattern. Returns matching file paths relative to the search directory. Respects .gitignore. Output is truncated to ${DEFAULT_LIMIT} results or ${51200 / 1024}KB (whichever is hit first).`,
+    promptSnippet: "Find files by glob pattern (respects .gitignore)",
+    parameters: findSchema,
+    async execute(_toolCallId, { pattern, path: searchDir, limit }, signal, _onUpdate, _ctx) {
+      return new Promise((resolve2, reject) => {
+        if (signal?.aborted) {
+          reject(new Error("Operation aborted"));
+          return;
+        }
+        let settled = !1, stopChild, settle = (fn) => {
+          settled || (settled = !0, signal?.removeEventListener("abort", onAbort), stopChild = void 0, fn());
+        }, onAbort = () => {
+          stopChild?.(), settle(() => reject(new Error("Operation aborted")));
+        };
+        signal?.addEventListener("abort", onAbort, { once: !0 }), (async () => {
+          try {
+            let searchPath = resolveToCwd(searchDir || ".", cwd), effectiveLimit = limit ?? DEFAULT_LIMIT, ops = customOps ?? defaultFindOperations;
+            if (customOps?.glob) {
+              if (!await ops.exists(searchPath)) {
+                settle(() => reject(new Error(`Path not found: ${searchPath}`)));
+                return;
+              }
+              if (signal?.aborted) {
+                settle(() => reject(new Error("Operation aborted")));
+                return;
+              }
+              let results = await ops.glob(pattern, searchPath, {
+                ignore: ["**/node_modules/**", "**/.git/**"],
+                limit: effectiveLimit
+              });
+              if (signal?.aborted) {
+                settle(() => reject(new Error("Operation aborted")));
+                return;
+              }
+              if (results.length === 0) {
+                settle(() => resolve2({
+                  content: [{ type: "text", text: "No files found matching pattern" }],
+                  details: void 0
+                }));
+                return;
+              }
+              let relativized = results.map((p) => p.startsWith(searchPath) ? toPosixPath(p.slice(searchPath.length + 1)) : toPosixPath(path.relative(searchPath, p))), resultLimitReached = relativized.length >= effectiveLimit, rawOutput = relativized.join(`
+`), truncation = truncateHead(rawOutput, { maxLines: Number.MAX_SAFE_INTEGER }), resultOutput = truncation.content, details = {}, notices = [];
+              resultLimitReached && (notices.push(`${effectiveLimit} results limit reached`), details.resultLimitReached = effectiveLimit), truncation.truncated && (notices.push(`${formatSize(51200)} limit reached`), details.truncation = truncation), notices.length > 0 && (resultOutput += `
+
+[${notices.join(". ")}]`), settle(() => resolve2({
+                content: [{ type: "text", text: resultOutput }],
+                details: Object.keys(details).length > 0 ? details : void 0
+              }));
+              return;
+            }
+            let fdPath = await ensureTool("fd", !0);
+            if (signal?.aborted) {
+              settle(() => reject(new Error("Operation aborted")));
+              return;
+            }
+            if (!fdPath) {
+              settle(() => reject(new Error("fd is not available and could not be downloaded")));
+              return;
+            }
+            let args = ["--glob", "--color=never", "--hidden"], insideGitRepo = !1;
+            for (let current = searchPath; ; ) {
+              if (await pathExists(path.join(current, ".git"))) {
+                insideGitRepo = !0;
+                break;
+              }
+              let parent = path.dirname(current);
+              if (parent === current)
+                break;
+              current = parent;
+            }
+            insideGitRepo || args.push("--no-require-git"), args.push("--max-results", String(effectiveLimit));
+            let effectivePattern = pattern;
+            pattern.includes("/") && (args.push("--full-path"), !pattern.startsWith("/") && !pattern.startsWith("**/") && pattern !== "**" && (effectivePattern = `**/${pattern}`)), args.push("--", effectivePattern, searchPath);
+            let child = spawn3(fdPath, args, { stdio: ["ignore", "pipe", "pipe"] }), rl = createInterface({ input: child.stdout }), stderr = "", lines = [];
+            stopChild = () => {
+              child.killed || child.kill();
+            };
+            let cleanup = () => {
+              rl.close();
+            };
+            child.stderr?.on("data", (chunk) => {
+              stderr += chunk.toString();
+            }), rl.on("line", (line) => {
+              lines.push(line);
+            }), child.on("error", (error) => {
+              cleanup(), settle(() => reject(new Error(`Failed to run fd: ${error.message}`)));
+            }), child.on("close", (code) => {
+              if (cleanup(), signal?.aborted) {
+                settle(() => reject(new Error("Operation aborted")));
+                return;
+              }
+              let output = lines.join(`
+`);
+              if (code !== 0) {
+                let errorMsg = stderr.trim() || `fd exited with code ${code}`;
+                if (!output) {
+                  settle(() => reject(new Error(errorMsg)));
+                  return;
+                }
+              }
+              if (!output) {
+                settle(() => resolve2({
+                  content: [{ type: "text", text: "No files found matching pattern" }],
+                  details: void 0
+                }));
+                return;
+              }
+              let relativized = [];
+              for (let rawLine of lines) {
+                let line = rawLine.replace(/\r$/, "").trim();
+                if (!line)
+                  continue;
+                let hadTrailingSlash = line.endsWith("/") || line.endsWith("\\"), relativePath = line;
+                line.startsWith(searchPath) ? relativePath = line.slice(searchPath.length + 1) : relativePath = path.relative(searchPath, line), hadTrailingSlash && !relativePath.endsWith("/") && (relativePath += "/"), relativized.push(toPosixPath(relativePath));
+              }
+              let resultLimitReached = relativized.length >= effectiveLimit, rawOutput = relativized.join(`
+`), truncation = truncateHead(rawOutput, { maxLines: Number.MAX_SAFE_INTEGER }), resultOutput = truncation.content, details = {}, notices = [];
+              resultLimitReached && (notices.push(`${effectiveLimit} results limit reached. Use limit=${effectiveLimit * 2} for more, or refine pattern`), details.resultLimitReached = effectiveLimit), truncation.truncated && (notices.push(`${formatSize(51200)} limit reached`), details.truncation = truncation), notices.length > 0 && (resultOutput += `
+
+[${notices.join(". ")}]`), settle(() => resolve2({
+                content: [{ type: "text", text: resultOutput }],
+                details: Object.keys(details).length > 0 ? details : void 0
+              }));
+            });
+          } catch (e) {
+            if (signal?.aborted) {
+              settle(() => reject(new Error("Operation aborted")));
+              return;
+            }
+            let error = e instanceof Error ? e : new Error(String(e));
+            settle(() => reject(error));
+          }
+        })();
+      });
+    },
+    renderCall(args, theme2, context) {
+      let text = context.lastComponent ?? new Text4("", 0, 0), compact = !context.isPartial && !context.expanded && !context.isError;
+      return text.setText(formatGroupedCall({
+        role: context.groupRole ?? "singleton",
+        compact,
+        tree: toolGroupTree(context),
+        dot: toolStatusDotFromContext(context, theme2),
+        title: theme2.fg("toolTitle", theme2.bold("find")),
+        detail: formatFindCall(args, theme2, context.cwd, !context.expanded)
+      })), text;
+    },
+    renderResult(result, options2, theme2, context) {
+      let text = context.lastComponent ?? new Text4("", 0, 0);
+      return !options2.isPartial && !options2.expanded && !context.isError ? (text.setText(""), text) : (text.setText(formatFindResult(result, options2, theme2, context.showImages)), text);
+    }
+  };
+}
+function createFindTool(cwd, options) {
+  return wrapToolDefinition(createFindToolDefinition(cwd, options));
+}
+
+// packages/coding-agent/dist/core/tools/grep.js
+import { readFile as fsReadFile2, stat as fsStat } from "node:fs/promises";
+import { createInterface as createInterface2 } from "node:readline";
+import { Text as Text5 } from "@ashx-j/lunr-tui";
+import { spawn as spawn4 } from "child_process";
+import path2 from "path";
+import { Type as Type4 } from "typebox";
+var grepSchema = Type4.Object({
+  pattern: Type4.String({ description: "Search pattern (regex or literal string)" }),
+  path: Type4.Optional(Type4.String({ description: "Directory or file to search (default: current directory)" })),
+  glob: Type4.Optional(Type4.String({ description: "Filter files by glob pattern, e.g. '*.ts' or '**/*.spec.ts'" })),
+  ignoreCase: Type4.Optional(Type4.Boolean({ description: "Case-insensitive search (default: false)" })),
+  literal: Type4.Optional(Type4.Boolean({ description: "Treat pattern as literal string instead of regex (default: false)" })),
+  context: Type4.Optional(Type4.Number({ description: "Number of lines to show before and after each match (default: 0)" })),
+  limit: Type4.Optional(Type4.Number({ description: "Maximum number of matches to return (default: 100)" }))
+}), DEFAULT_LIMIT2 = 100, defaultGrepOperations = {
+  isDirectory: async (p) => (await fsStat(p)).isDirectory(),
+  readFile: (p) => fsReadFile2(p, "utf-8")
+};
+function formatGrepCall(args, theme2, cwd, compact = !1) {
+  let pattern = str(args?.pattern), rawPath = str(args?.path), glob = str(args?.glob), limit = args?.limit, invalidArg = invalidArgText(theme2), text = pattern === null ? invalidArg : theme2.fg("accent", `/${pattern || ""}/`);
+  if (compact) {
+    let collapsedPath = renderCollapsedSearchPath(rawPath, theme2, cwd);
+    collapsedPath && (text += theme2.fg("toolOutput", " in ") + collapsedPath);
+  } else {
+    let path3 = rawPath !== null ? shortenPath(rawPath || ".") : null;
+    text += theme2.fg("toolOutput", ` in ${path3 === null ? invalidArg : path3}`);
+  }
+  return glob && (text += theme2.fg("toolOutput", ` (${glob})`)), limit !== void 0 && (text += theme2.fg("toolOutput", ` limit ${limit}`)), text;
+}
+function formatGrepResult(result, options, theme2, showImages) {
+  let output = getTextOutput(result, showImages).trim(), text = "";
+  if (output) {
+    let lines = output.split(`
+`), maxLines = options.expanded ? lines.length : 15, displayLines = lines.slice(0, maxLines), remaining = lines.length - maxLines;
+    text += `
+${displayLines.map((line) => theme2.fg("toolOutput", line)).join(`
+`)}`, remaining > 0 && (text += `${theme2.fg("muted", `
+... (${remaining} more lines,`)} ${keyHint("app.tools.expand", "to expand")}${theme2.fg("muted", ")")}`);
+  }
+  let matchLimit = result.details?.matchLimitReached, truncation = result.details?.truncation, linesTruncated = result.details?.linesTruncated;
+  if (matchLimit || truncation?.truncated || linesTruncated) {
+    let warnings = [];
+    matchLimit && warnings.push(`${matchLimit} matches limit`), truncation?.truncated && warnings.push(`${formatSize(truncation.maxBytes ?? 51200)} limit`), linesTruncated && warnings.push("some lines truncated"), text += `
+${theme2.fg("warning", `[Truncated: ${warnings.join(", ")}]`)}`;
+  }
+  return text;
+}
+function createGrepToolDefinition(cwd, options) {
+  let customOps = options?.operations;
+  return {
+    name: "grep",
+    label: "grep",
+    description: `Search file contents for a pattern. Returns matching lines with file paths and line numbers. Respects .gitignore. Output is truncated to ${DEFAULT_LIMIT2} matches or ${51200 / 1024}KB (whichever is hit first). Long lines are truncated to ${500} chars.`,
+    promptSnippet: "Search file contents for patterns (respects .gitignore)",
+    parameters: grepSchema,
+    async execute(_toolCallId, { pattern, path: searchDir, glob, ignoreCase, literal, context, limit }, signal, _onUpdate, _ctx) {
+      return new Promise((resolve2, reject) => {
+        if (signal?.aborted) {
+          reject(new Error("Operation aborted"));
+          return;
+        }
+        let settled = !1, settle = (fn) => {
+          settled || (settled = !0, fn());
+        };
+        (async () => {
+          try {
+            let rgPath = await ensureTool("rg", !0);
+            if (!rgPath) {
+              settle(() => reject(new Error("ripgrep (rg) is not available and could not be downloaded")));
+              return;
+            }
+            let searchPath = resolveToCwd(searchDir || ".", cwd), ops = customOps ?? defaultGrepOperations, isDirectory;
+            try {
+              isDirectory = await ops.isDirectory(searchPath);
+            } catch {
+              settle(() => reject(new Error(`Path not found: ${searchPath}`)));
+              return;
+            }
+            let contextValue = context && context > 0 ? context : 0, effectiveLimit = Math.max(1, limit ?? DEFAULT_LIMIT2), formatPath = (filePath) => {
+              if (isDirectory) {
+                let relative2 = path2.relative(searchPath, filePath);
+                if (relative2 && !relative2.startsWith(".."))
+                  return relative2.replace(/\\/g, "/");
+              }
+              return path2.basename(filePath);
+            }, fileCache = /* @__PURE__ */ new Map(), getFileLines = async (filePath) => {
+              let lines = fileCache.get(filePath);
+              if (!lines) {
+                try {
+                  lines = (await ops.readFile(filePath)).replace(/\r\n/g, `
+`).replace(/\r/g, `
+`).split(`
+`);
+                } catch {
+                  lines = [];
+                }
+                fileCache.set(filePath, lines);
+              }
+              return lines;
+            }, args = ["--json", "--line-number", "--color=never", "--hidden"];
+            ignoreCase && args.push("--ignore-case"), literal && args.push("--fixed-strings"), glob && args.push("--glob", glob), args.push("--", pattern, searchPath);
+            let child = spawn4(rgPath, args, { stdio: ["ignore", "pipe", "pipe"] }), rl = createInterface2({ input: child.stdout }), stderr = "", matchCount = 0, matchLimitReached = !1, linesTruncated = !1, aborted = !1, killedDueToLimit = !1, outputLines = [], cleanup = () => {
+              rl.close(), signal?.removeEventListener("abort", onAbort);
+            }, stopChild = (dueToLimit = !1) => {
+              child.killed || (killedDueToLimit = dueToLimit, child.kill());
+            }, onAbort = () => {
+              aborted = !0, stopChild();
+            };
+            signal?.addEventListener("abort", onAbort, { once: !0 }), child.stderr?.on("data", (chunk) => {
+              stderr += chunk.toString();
+            });
+            let formatBlock = async (filePath, lineNumber) => {
+              let relativePath = formatPath(filePath), lines = await getFileLines(filePath);
+              if (!lines.length)
+                return [`${relativePath}:${lineNumber}: (unable to read file)`];
+              let block = [], start = contextValue > 0 ? Math.max(1, lineNumber - contextValue) : lineNumber, end = contextValue > 0 ? Math.min(lines.length, lineNumber + contextValue) : lineNumber;
+              for (let current = start; current <= end; current++) {
+                let sanitized = (lines[current - 1] ?? "").replace(/\r/g, ""), isMatchLine = current === lineNumber, { text: truncatedText, wasTruncated } = truncateLine(sanitized);
+                wasTruncated && (linesTruncated = !0), isMatchLine ? block.push(`${relativePath}:${current}: ${truncatedText}`) : block.push(`${relativePath}-${current}- ${truncatedText}`);
+              }
+              return block;
+            }, matches = [];
+            rl.on("line", (line) => {
+              if (!line.trim() || matchCount >= effectiveLimit)
+                return;
+              let event;
+              try {
+                event = JSON.parse(line);
+              } catch {
+                return;
+              }
+              if (event.type === "match") {
+                matchCount++;
+                let filePath = event.data?.path?.text, lineNumber = event.data?.line_number, lineText = event.data?.lines?.text;
+                filePath && typeof lineNumber == "number" && matches.push({ filePath, lineNumber, lineText }), matchCount >= effectiveLimit && (matchLimitReached = !0, stopChild(!0));
+              }
+            }), child.on("error", (error) => {
+              cleanup(), settle(() => reject(new Error(`Failed to run ripgrep: ${error.message}`)));
+            }), child.on("close", async (code) => {
+              if (cleanup(), aborted) {
+                settle(() => reject(new Error("Operation aborted")));
+                return;
+              }
+              if (!killedDueToLimit && code !== 0 && code !== 1) {
+                let errorMsg = stderr.trim() || `ripgrep exited with code ${code}`;
+                settle(() => reject(new Error(errorMsg)));
+                return;
+              }
+              if (matchCount === 0) {
+                settle(() => resolve2({ content: [{ type: "text", text: "No matches found" }], details: void 0 }));
+                return;
+              }
+              for (let match of matches)
+                if (contextValue === 0 && match.lineText !== void 0) {
+                  let relativePath = formatPath(match.filePath), sanitized = match.lineText.replace(/\r\n/g, `
+`).replace(/\r/g, "").replace(/\n$/, ""), { text: truncatedText, wasTruncated } = truncateLine(sanitized);
+                  wasTruncated && (linesTruncated = !0), outputLines.push(`${relativePath}:${match.lineNumber}: ${truncatedText}`);
+                } else {
+                  let block = await formatBlock(match.filePath, match.lineNumber);
+                  outputLines.push(...block);
+                }
+              let rawOutput = outputLines.join(`
+`), truncation = truncateHead(rawOutput, { maxLines: Number.MAX_SAFE_INTEGER }), output = truncation.content, details = {}, notices = [];
+              matchLimitReached && (notices.push(`${effectiveLimit} matches limit reached. Use limit=${effectiveLimit * 2} for more, or refine pattern`), details.matchLimitReached = effectiveLimit), truncation.truncated && (notices.push(`${formatSize(51200)} limit reached`), details.truncation = truncation), linesTruncated && (notices.push(`Some lines truncated to ${500} chars. Use read tool to see full lines`), details.linesTruncated = !0), notices.length > 0 && (output += `
+
+[${notices.join(". ")}]`), settle(() => resolve2({
+                content: [{ type: "text", text: output }],
+                details: Object.keys(details).length > 0 ? details : void 0
+              }));
+            });
+          } catch (err) {
+            settle(() => reject(err));
+          }
+        })();
+      });
+    },
+    renderCall(args, theme2, context) {
+      let text = context.lastComponent ?? new Text5("", 0, 0), compact = !context.isPartial && !context.expanded && !context.isError;
+      return text.setText(formatGroupedCall({
+        role: context.groupRole ?? "singleton",
+        compact,
+        tree: toolGroupTree(context),
+        dot: toolStatusDotFromContext(context, theme2),
+        title: theme2.fg("toolTitle", theme2.bold("grep")),
+        detail: formatGrepCall(args, theme2, context.cwd, !context.expanded)
+      })), text;
+    },
+    renderResult(result, options2, theme2, context) {
+      let text = context.lastComponent ?? new Text5("", 0, 0);
+      return !options2.isPartial && !options2.expanded && !context.isError ? (text.setText(""), text) : (text.setText(formatGrepResult(result, options2, theme2, context.showImages)), text);
+    }
+  };
+}
+function createGrepTool(cwd, options) {
+  return wrapToolDefinition(createGrepToolDefinition(cwd, options));
+}
+
+// packages/coding-agent/dist/core/tools/ls.js
+import { readdir as fsReaddir, stat as fsStat2 } from "node:fs/promises";
+import { Text as Text6 } from "@ashx-j/lunr-tui";
+import nodePath from "path";
+import { Type as Type5 } from "typebox";
+var lsSchema = Type5.Object({
+  path: Type5.Optional(Type5.String({ description: "Directory to list (default: current directory)" })),
+  limit: Type5.Optional(Type5.Number({ description: "Maximum number of entries to return (default: 500)" }))
+}), DEFAULT_LIMIT3 = 500, defaultLsOperations = {
+  exists: pathExists,
+  stat: fsStat2,
+  readdir: fsReaddir
+};
+function formatLsCall(args, theme2, cwd, compact = !1) {
+  let limit = args?.limit, rawPath = str(args?.path), text = compact ? renderToolFileName(rawPath || ".", theme2, cwd) : renderToolPath(rawPath, theme2, cwd, { emptyFallback: "." });
+  return limit !== void 0 && (text += theme2.fg("toolOutput", ` (limit ${limit})`)), text;
+}
+function formatLsResult(result, options, theme2, showImages) {
+  let output = getTextOutput(result, showImages).trim(), text = "";
+  if (output) {
+    let lines = output.split(`
+`), maxLines = options.expanded ? lines.length : 20, displayLines = lines.slice(0, maxLines), remaining = lines.length - maxLines;
+    text += `
+${displayLines.map((line) => theme2.fg("toolOutput", line)).join(`
+`)}`, remaining > 0 && (text += `${theme2.fg("muted", `
+... (${remaining} more lines,`)} ${keyHint("app.tools.expand", "to expand")}${theme2.fg("muted", ")")}`);
+  }
+  let entryLimit = result.details?.entryLimitReached, truncation = result.details?.truncation;
+  if (entryLimit || truncation?.truncated) {
+    let warnings = [];
+    entryLimit && warnings.push(`${entryLimit} entries limit`), truncation?.truncated && warnings.push(`${formatSize(truncation.maxBytes ?? 51200)} limit`), text += `
+${theme2.fg("warning", `[Truncated: ${warnings.join(", ")}]`)}`;
+  }
+  return text;
+}
+function createLsToolDefinition(cwd, options) {
+  let ops = options?.operations ?? defaultLsOperations;
+  return {
+    name: "ls",
+    label: "ls",
+    description: `List directory contents. Returns entries sorted alphabetically, with '/' suffix for directories. Includes dotfiles. Output is truncated to ${DEFAULT_LIMIT3} entries or ${51200 / 1024}KB (whichever is hit first).`,
+    promptSnippet: "List directory contents",
+    parameters: lsSchema,
+    async execute(_toolCallId, { path: path3, limit }, signal, _onUpdate, _ctx) {
+      return new Promise((resolve2, reject) => {
+        if (signal?.aborted) {
+          reject(new Error("Operation aborted"));
+          return;
+        }
+        let onAbort = () => reject(new Error("Operation aborted"));
+        signal?.addEventListener("abort", onAbort, { once: !0 }), (async () => {
+          try {
+            let dirPath = resolveToCwd(path3 || ".", cwd), effectiveLimit = limit ?? DEFAULT_LIMIT3;
+            if (!await ops.exists(dirPath)) {
+              reject(new Error(`Path not found: ${dirPath}`));
+              return;
+            }
+            if (!(await ops.stat(dirPath)).isDirectory()) {
+              reject(new Error(`Not a directory: ${dirPath}`));
+              return;
+            }
+            let entries;
+            try {
+              entries = await ops.readdir(dirPath);
+            } catch (e) {
+              reject(new Error(`Cannot read directory: ${e.message}`));
+              return;
+            }
+            entries.sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()));
+            let results = [], entryLimitReached = !1;
+            for (let entry of entries) {
+              if (results.length >= effectiveLimit) {
+                entryLimitReached = !0;
+                break;
+              }
+              let fullPath = nodePath.join(dirPath, entry), suffix = "";
+              try {
+                (await ops.stat(fullPath)).isDirectory() && (suffix = "/");
+              } catch {
+                continue;
+              }
+              results.push(entry + suffix);
+            }
+            if (signal?.removeEventListener("abort", onAbort), results.length === 0) {
+              resolve2({ content: [{ type: "text", text: "(empty directory)" }], details: void 0 });
+              return;
+            }
+            let rawOutput = results.join(`
+`), truncation = truncateHead(rawOutput, { maxLines: Number.MAX_SAFE_INTEGER }), output = truncation.content, details = {}, notices = [];
+            entryLimitReached && (notices.push(`${effectiveLimit} entries limit reached. Use limit=${effectiveLimit * 2} for more`), details.entryLimitReached = effectiveLimit), truncation.truncated && (notices.push(`${formatSize(51200)} limit reached`), details.truncation = truncation), notices.length > 0 && (output += `
+
+[${notices.join(". ")}]`), resolve2({
+              content: [{ type: "text", text: output }],
+              details: Object.keys(details).length > 0 ? details : void 0
+            });
+          } catch (e) {
+            signal?.removeEventListener("abort", onAbort), reject(e);
+          }
+        })();
+      });
+    },
+    renderCall(args, theme2, context) {
+      let text = context.lastComponent ?? new Text6("", 0, 0), compact = !context.isPartial && !context.expanded && !context.isError;
+      return text.setText(formatGroupedCall({
+        role: context.groupRole ?? "singleton",
+        compact,
+        tree: toolGroupTree(context),
+        dot: toolStatusDotFromContext(context, theme2),
+        title: theme2.fg("toolTitle", theme2.bold("ls")),
+        detail: formatLsCall(args, theme2, context.cwd, !context.expanded)
+      })), text;
+    },
+    renderResult(result, options2, theme2, context) {
+      let text = context.lastComponent ?? new Text6("", 0, 0);
+      return !options2.isPartial && !options2.expanded && !context.isError ? (text.setText(""), text) : (text.setText(formatLsResult(result, options2, theme2, context.showImages)), text);
+    }
+  };
+}
+function createLsTool(cwd, options) {
+  return wrapToolDefinition(createLsToolDefinition(cwd, options));
+}
+
+// packages/coding-agent/dist/core/tools/read.js
+import { basename, dirname, isAbsolute, relative, resolve as resolvePath2, sep } from "node:path";
+import { Text as Text7 } from "@ashx-j/lunr-tui";
+import { constants as constants5 } from "fs";
+import { access as fsAccess3, readFile as fsReadFile3 } from "fs/promises";
+import { Type as Type6 } from "typebox";
+
+// packages/coding-agent/dist/utils/mime.js
+import { open } from "node:fs/promises";
+var IMAGE_TYPE_SNIFF_BYTES = 4100, PNG_SIGNATURE = [137, 80, 78, 71, 13, 10, 26, 10];
+function detectSupportedImageMimeType(buffer) {
+  return startsWith(buffer, [255, 216, 255]) ? buffer[3] === 247 ? null : "image/jpeg" : startsWith(buffer, PNG_SIGNATURE) ? isPng(buffer) && !isAnimatedPng(buffer) ? "image/png" : null : startsWithAscii(buffer, 0, "GIF") ? "image/gif" : startsWithAscii(buffer, 0, "RIFF") && startsWithAscii(buffer, 8, "WEBP") ? "image/webp" : startsWithAscii(buffer, 0, "BM") && isBmp(buffer) ? "image/bmp" : null;
+}
+async function detectSupportedImageMimeTypeFromFile(filePath) {
+  let fileHandle = await open(filePath, "r");
+  try {
+    let buffer = Buffer.alloc(IMAGE_TYPE_SNIFF_BYTES), { bytesRead } = await fileHandle.read(buffer, 0, IMAGE_TYPE_SNIFF_BYTES, 0);
+    return detectSupportedImageMimeType(buffer.subarray(0, bytesRead));
+  } finally {
+    await fileHandle.close();
+  }
+}
+function isPng(buffer) {
+  return buffer.length >= 16 && readUint32BE(buffer, PNG_SIGNATURE.length) === 13 && startsWithAscii(buffer, 12, "IHDR");
+}
+function isAnimatedPng(buffer) {
+  let offset = PNG_SIGNATURE.length;
+  for (; offset + 8 <= buffer.length; ) {
+    let chunkLength = readUint32BE(buffer, offset), chunkTypeOffset = offset + 4;
+    if (startsWithAscii(buffer, chunkTypeOffset, "acTL"))
+      return !0;
+    if (startsWithAscii(buffer, chunkTypeOffset, "IDAT"))
+      return !1;
+    let nextOffset = offset + 8 + chunkLength + 4;
+    if (nextOffset <= offset || nextOffset > buffer.length)
+      return !1;
+    offset = nextOffset;
+  }
+  return !1;
+}
+function isBmp(buffer) {
+  if (buffer.length < 26)
+    return !1;
+  let declaredFileSize = readUint32LE(buffer, 2), pixelDataOffset = readUint32LE(buffer, 10), dibHeaderSize = readUint32LE(buffer, 14);
+  if (declaredFileSize !== 0 && declaredFileSize < 26 || pixelDataOffset < 14 + dibHeaderSize || declaredFileSize !== 0 && pixelDataOffset >= declaredFileSize)
+    return !1;
+  let colorPlanes, bitsPerPixel;
+  if (dibHeaderSize === 12)
+    colorPlanes = readUint16LE(buffer, 22), bitsPerPixel = readUint16LE(buffer, 24);
+  else if (dibHeaderSize >= 40 && dibHeaderSize <= 124) {
+    if (buffer.length < 30)
+      return !1;
+    colorPlanes = readUint16LE(buffer, 26), bitsPerPixel = readUint16LE(buffer, 28);
+  } else
+    return !1;
+  return colorPlanes === 1 && [1, 4, 8, 16, 24, 32].includes(bitsPerPixel);
+}
+function readUint16LE(buffer, offset) {
+  return (buffer[offset] ?? 0) + ((buffer[offset + 1] ?? 0) << 8);
+}
+function readUint32BE(buffer, offset) {
+  return (buffer[offset] ?? 0) * 16777216 + ((buffer[offset + 1] ?? 0) << 16) + ((buffer[offset + 2] ?? 0) << 8) + (buffer[offset + 3] ?? 0);
+}
+function readUint32LE(buffer, offset) {
+  return (buffer[offset] ?? 0) + ((buffer[offset + 1] ?? 0) << 8) + ((buffer[offset + 2] ?? 0) << 16) + (buffer[offset + 3] ?? 0) * 16777216;
+}
+function startsWith(buffer, bytes) {
+  return buffer.length < bytes.length ? !1 : bytes.every((byte, index) => buffer[index] === byte);
+}
+function startsWithAscii(buffer, offset, text) {
+  if (buffer.length < offset + text.length)
+    return !1;
+  for (let index = 0; index < text.length; index++)
+    if (buffer[offset + index] !== text.charCodeAt(index))
+      return !1;
+  return !0;
+}
+
+// packages/coding-agent/dist/core/tools/read.js
+var readSchema = Type6.Object({
+  path: Type6.String({ description: "Path to the file to read (relative or absolute)" }),
+  offset: Type6.Optional(Type6.Number({ description: "Line number to start reading from (1-indexed)" })),
+  limit: Type6.Optional(Type6.Number({ description: "Maximum number of lines to read" }))
+}), COMPACT_RESOURCE_FILE_NAMES = /* @__PURE__ */ new Set(["AGENTS.md", "AGENTS.MD", "CLAUDE.md", "CLAUDE.MD"]), defaultReadOperations = {
+  readFile: (path3) => fsReadFile3(path3),
+  access: (path3) => fsAccess3(path3, constants5.R_OK),
+  detectImageMimeType: detectSupportedImageMimeTypeFromFile
+};
+function formatReadLineRange(args, theme2) {
+  if (args?.offset === void 0 && args?.limit === void 0)
+    return "";
+  let startLine = args.offset ?? 1, endLine = args.limit !== void 0 ? startLine + args.limit - 1 : "";
+  return theme2.fg("warning", `:${startLine}${endLine ? `-${endLine}` : ""}`);
+}
+function formatReadDetail(args, theme2, cwd, expanded = !1) {
+  let pathDisplay = renderToolFileName(str(args?.file_path ?? args?.path), theme2, cwd), range = expanded ? formatReadLineRange(args, theme2) : "";
+  return `${pathDisplay}${range}`;
+}
+function trimTrailingEmptyLines(lines) {
+  let end = lines.length;
+  for (; end > 0 && lines[end - 1] === ""; )
+    end--;
+  return lines.slice(0, end);
+}
+function getNonVisionImageNote(model) {
+  if (!(!model || model.input.includes("image")))
+    return "[Current model does not support images. The image will be omitted from this request.]";
+}
+function toPosixPath2(filePath) {
+  return filePath.split(sep).join("/");
+}
+function getPiDocsClassification(absolutePath) {
+  let packageRoot = dirname(getReadmePath()), relativePath = relative(resolvePath2(packageRoot), resolvePath2(absolutePath));
+  if (relativePath === "" || relativePath === ".." || relativePath.startsWith(`..${sep}`) || isAbsolute(relativePath))
+    return;
+  let label = toPosixPath2(relativePath);
+  if (label === "README.md" || label.startsWith("docs/") || label.startsWith("examples/"))
+    return { kind: "docs", label };
+}
+function getCompactReadClassification(args, cwd) {
+  let rawPath = str(args?.file_path ?? args?.path);
+  if (!rawPath)
+    return;
+  let absolutePath = resolveToCwd(rawPath, cwd), fileName = basename(absolutePath);
+  if (fileName === "SKILL.md")
+    return { kind: "skill", label: basename(dirname(absolutePath)) || fileName };
+  let docsClassification = getPiDocsClassification(absolutePath);
+  if (docsClassification)
+    return docsClassification;
+  if (COMPACT_RESOURCE_FILE_NAMES.has(fileName))
+    return { kind: "resource", label: formatPathRelativeToCwdOrAbsolute(absolutePath, cwd) };
+}
+function formatReadResult(args, result, options, theme2, showImages, _cwd, isError) {
+  if (!options.expanded && !isError)
+    return "";
+  let rawPath = str(args?.file_path ?? args?.path), output = getTextOutput(result, showImages), lang = rawPath ? getLanguageFromPath(rawPath) : void 0, renderedLines = lang ? highlightCode(replaceTabs(output), lang) : output.split(`
+`), lines = trimTrailingEmptyLines(renderedLines), maxLines = options.expanded ? lines.length : 10, displayLines = lines.slice(0, maxLines), remaining = lines.length - maxLines, text = `
+${displayLines.map((line) => lang ? replaceTabs(line) : theme2.fg("toolOutput", replaceTabs(line))).join(`
+`)}`;
+  remaining > 0 && (text += `${theme2.fg("muted", `
+... (${remaining} more lines,`)} ${keyHint("app.tools.expand", "to expand")}${theme2.fg("muted", ")")}`);
+  let truncation = result.details?.truncation;
+  return truncation?.truncated && (truncation.firstLineExceedsLimit ? text += `
+${theme2.fg("warning", `[First line exceeds ${formatSize(truncation.maxBytes ?? 51200)} limit]`)}` : truncation.truncatedBy === "lines" ? text += `
+${theme2.fg("warning", `[Truncated: showing ${truncation.outputLines} of ${truncation.totalLines} lines (${truncation.maxLines ?? 2e3} line limit)]`)}` : text += `
+${theme2.fg("warning", `[Truncated: ${truncation.outputLines} lines shown (${formatSize(truncation.maxBytes ?? 51200)} limit)]`)}`), text;
+}
+function createReadToolDefinition(cwd, options) {
+  let autoResizeImages = options?.autoResizeImages ?? !0, ops = options?.operations ?? defaultReadOperations;
+  return {
+    name: "read",
+    label: "read",
+    description: `Read the contents of a file. Supports text files and images (jpg, png, gif, webp, bmp). Images are sent as attachments. For text files, output is truncated to ${2e3} lines or ${51200 / 1024}KB (whichever is hit first). Use offset/limit for large files. When you need the full file, continue with offset until complete.`,
+    promptSnippet: "Read file contents",
+    promptGuidelines: ["Use read to examine files instead of cat or sed."],
+    parameters: readSchema,
+    async execute(_toolCallId, { path: path3, offset, limit }, signal, _onUpdate, ctx) {
+      return new Promise((resolve2, reject) => {
+        if (signal?.aborted) {
+          reject(new Error("Operation aborted"));
+          return;
+        }
+        let aborted = !1, onAbort = () => {
+          aborted = !0, reject(new Error("Operation aborted"));
+        };
+        signal?.addEventListener("abort", onAbort, { once: !0 }), (async () => {
+          try {
+            let absolutePath = await resolveReadPathAsync(path3, cwd);
+            if (aborted || (await ops.access(absolutePath), aborted))
+              return;
+            let mimeType = ops.detectImageMimeType ? await ops.detectImageMimeType(absolutePath) : void 0, content, details, nonVisionImageNote = getNonVisionImageNote(ctx?.model);
+            if (mimeType) {
+              let buffer = await ops.readFile(absolutePath), processed = await processImage(buffer, mimeType, { autoResizeImages });
+              if (processed.ok) {
+                let textNote = `Read image file [${processed.mimeType}]`;
+                processed.hints.length > 0 && (textNote += `
+${processed.hints.join(`
+`)}`), nonVisionImageNote && (textNote += `
+${nonVisionImageNote}`), content = [
+                  { type: "text", text: textNote },
+                  { type: "image", data: processed.data, mimeType: processed.mimeType }
+                ];
+              } else {
+                let textNote = `Read image file [${mimeType}]
+${processed.message}`;
+                nonVisionImageNote && (textNote += `
+${nonVisionImageNote}`), content = [{ type: "text", text: textNote }];
+              }
+            } else {
+              let allLines = (await ops.readFile(absolutePath)).toString("utf-8").split(`
+`), totalFileLines = allLines.length, startLine = offset ? Math.max(0, offset - 1) : 0, startLineDisplay = startLine + 1;
+              if (startLine >= allLines.length)
+                throw new Error(`Offset ${offset} is beyond end of file (${allLines.length} lines total)`);
+              let selectedContent, userLimitedLines;
+              if (limit !== void 0) {
+                let endLine = Math.min(startLine + limit, allLines.length);
+                selectedContent = allLines.slice(startLine, endLine).join(`
+`), userLimitedLines = endLine - startLine;
+              } else
+                selectedContent = allLines.slice(startLine).join(`
+`);
+              let truncation = truncateHead(selectedContent), outputText;
+              if (truncation.firstLineExceedsLimit) {
+                let firstLineSize = formatSize(Buffer.byteLength(allLines[startLine], "utf-8"));
+                outputText = `[Line ${startLineDisplay} is ${firstLineSize}, exceeds ${formatSize(51200)} limit. Use bash: sed -n '${startLineDisplay}p' ${path3} | head -c ${51200}]`, details = { truncation };
+              } else if (truncation.truncated) {
+                let endLineDisplay = startLineDisplay + truncation.outputLines - 1, nextOffset = endLineDisplay + 1;
+                outputText = truncation.content, truncation.truncatedBy === "lines" ? outputText += `
+
+[Showing lines ${startLineDisplay}-${endLineDisplay} of ${totalFileLines}. Use offset=${nextOffset} to continue.]` : outputText += `
+
+[Showing lines ${startLineDisplay}-${endLineDisplay} of ${totalFileLines} (${formatSize(51200)} limit). Use offset=${nextOffset} to continue.]`, details = { truncation };
+              } else if (userLimitedLines !== void 0 && startLine + userLimitedLines < allLines.length) {
+                let remaining = allLines.length - (startLine + userLimitedLines), nextOffset = startLine + userLimitedLines + 1;
+                outputText = `${truncation.content}
+
+[${remaining} more lines in file. Use offset=${nextOffset} to continue.]`;
+              } else
+                outputText = truncation.content;
+              content = [{ type: "text", text: outputText }];
+            }
+            if (aborted)
+              return;
+            signal?.removeEventListener("abort", onAbort), resolve2({ content, details });
+          } catch (error) {
+            signal?.removeEventListener("abort", onAbort), aborted || reject(error);
+          }
+        })();
+      });
+    },
+    renderCall(args, theme2, context) {
+      let text = context.lastComponent ?? new Text7("", 0, 0), compact = !context.isPartial && !context.expanded && !context.isError, classification = context.expanded ? void 0 : getCompactReadClassification(args, context.cwd), title = theme2.fg("toolTitle", theme2.bold("read")), detail;
+      return classification?.kind === "skill" ? (title = theme2.fg("customMessageLabel", "\x1B[1m[skill]\x1B[22m"), detail = theme2.fg("customMessageText", classification.label)) : classification ? (title = theme2.fg("toolTitle", theme2.bold(`read ${classification.kind}`)), detail = theme2.fg("accent", classification.label)) : detail = formatReadDetail(args, theme2, context.cwd, context.expanded), text.setText(formatGroupedCall({
+        role: context.groupRole ?? "singleton",
+        compact,
+        tree: toolGroupTree(context),
+        dot: toolStatusDotFromContext(context, theme2),
+        title,
+        detail
+      })), text;
+    },
+    renderResult(result, options2, theme2, context) {
+      let text = context.lastComponent ?? new Text7("", 0, 0);
+      return !options2.isPartial && !options2.expanded && !context.isError ? (text.setText(""), text) : (text.setText(formatReadResult(context.args, result, options2, theme2, context.showImages, context.cwd, context.isError)), text);
+    }
+  };
+}
+function createReadTool(cwd, options) {
+  return wrapToolDefinition(createReadToolDefinition(cwd, options));
+}
+
+// packages/coding-agent/dist/core/tools/write.js
+import { Container as Container3, Text as Text8 } from "@ashx-j/lunr-tui";
+import { mkdir as fsMkdir, writeFile as fsWriteFile2 } from "fs/promises";
+import { dirname as dirname2 } from "path";
+import { Type as Type7 } from "typebox";
+var writeSchema = Type7.Object({
+  path: Type7.String({ description: "Path to the file to write (relative or absolute)" }),
+  content: Type7.String({ description: "Content to write to the file" })
+}), defaultWriteOperations = {
+  writeFile: (path3, content) => fsWriteFile2(path3, content, "utf-8"),
+  mkdir: (dir) => fsMkdir(dir, { recursive: !0 }).then(() => {
+  })
+}, WriteCallRenderComponent = class extends Text8 {
+  cache;
+  constructor() {
+    super("", 0, 0);
+  }
+}, WRITE_PARTIAL_FULL_HIGHLIGHT_LINES = 50;
+function highlightSingleLine(line, lang) {
+  return highlightCode(line, lang)[0] ?? "";
+}
+function refreshWriteHighlightPrefix(cache) {
+  let prefixCount = Math.min(WRITE_PARTIAL_FULL_HIGHLIGHT_LINES, cache.normalizedLines.length);
+  if (prefixCount === 0)
+    return;
+  let prefixSource = cache.normalizedLines.slice(0, prefixCount).join(`
+`), prefixHighlighted = highlightCode(prefixSource, cache.lang);
+  for (let i = 0; i < prefixCount; i++)
+    cache.highlightedLines[i] = prefixHighlighted[i] ?? highlightSingleLine(cache.normalizedLines[i] ?? "", cache.lang);
+}
+function rebuildWriteHighlightCacheFull(rawPath, fileContent) {
+  let lang = rawPath ? getLanguageFromPath(rawPath) : void 0;
+  if (!lang)
+    return;
+  let displayContent = normalizeDisplayText(fileContent), normalized = replaceTabs(displayContent);
+  return {
+    rawPath,
+    lang,
+    rawContent: fileContent,
+    normalizedLines: normalized.split(`
+`),
+    highlightedLines: highlightCode(normalized, lang)
+  };
+}
+function updateWriteHighlightCacheIncremental(cache, rawPath, fileContent) {
+  let lang = rawPath ? getLanguageFromPath(rawPath) : void 0;
+  if (!lang)
+    return;
+  if (!cache || cache.lang !== lang || cache.rawPath !== rawPath || !fileContent.startsWith(cache.rawContent))
+    return rebuildWriteHighlightCacheFull(rawPath, fileContent);
+  if (fileContent.length === cache.rawContent.length)
+    return cache;
+  let deltaRaw = fileContent.slice(cache.rawContent.length), deltaDisplay = normalizeDisplayText(deltaRaw), deltaNormalized = replaceTabs(deltaDisplay);
+  cache.rawContent = fileContent, cache.normalizedLines.length === 0 && (cache.normalizedLines.push(""), cache.highlightedLines.push(""));
+  let segments = deltaNormalized.split(`
+`), lastIndex = cache.normalizedLines.length - 1;
+  cache.normalizedLines[lastIndex] += segments[0], cache.highlightedLines[lastIndex] = highlightSingleLine(cache.normalizedLines[lastIndex], cache.lang);
+  for (let i = 1; i < segments.length; i++)
+    cache.normalizedLines.push(segments[i]), cache.highlightedLines.push(highlightSingleLine(segments[i], cache.lang));
+  return refreshWriteHighlightPrefix(cache), cache;
+}
+function trimTrailingEmptyLines2(lines) {
+  let end = lines.length;
+  for (; end > 0 && lines[end - 1] === ""; )
+    end--;
+  return lines.slice(0, end);
+}
+function formatWriteCall(args, options, theme2, cache, cwd, compact = !1) {
+  let rawPath = str(args?.file_path ?? args?.path), fileContent = str(args?.content), pathDisplay = compact ? renderToolFileName(rawPath, theme2, cwd) : renderToolPath(rawPath, theme2, cwd), text = `${theme2.fg("toolTitle", theme2.bold("write"))} ${pathDisplay}`;
+  if (fileContent === null)
+    text += `
+
+${theme2.fg("error", "[invalid content arg - expected string]")}`;
+  else if (fileContent && !compact) {
+    let lang = rawPath ? getLanguageFromPath(rawPath) : void 0, renderedLines = lang ? cache?.highlightedLines ?? highlightCode(replaceTabs(normalizeDisplayText(fileContent)), lang) : normalizeDisplayText(fileContent).split(`
+`), lines = trimTrailingEmptyLines2(renderedLines), totalLines = lines.length, maxLines = options.expanded ? lines.length : 10, displayLines = lines.slice(0, maxLines), remaining = lines.length - maxLines;
+    text += `
+
+${displayLines.map((line) => lang ? line : theme2.fg("toolOutput", replaceTabs(line))).join(`
+`)}`, remaining > 0 && (text += `${theme2.fg("muted", `
+... (${remaining} more lines, ${totalLines} total,`)} ${keyHint("app.tools.expand", "to expand")}${theme2.fg("muted", ")")}`);
+  }
+  return text;
+}
+function formatWriteResult(result, theme2) {
+  if (!result.isError)
+    return;
+  let output = result.content.filter((c) => c.type === "text").map((c) => c.text || "").join(`
+`);
+  if (output)
+    return `
+${theme2.fg("error", output)}`;
+}
+function createWriteToolDefinition(cwd, options) {
+  let ops = options?.operations ?? defaultWriteOperations;
+  return {
+    name: "write",
+    label: "write",
+    description: "Write content to a file. Creates the file if it doesn't exist, overwrites if it does. Automatically creates parent directories.",
+    promptSnippet: "Create or overwrite files",
+    promptGuidelines: ["Use write only for new files or complete rewrites."],
+    parameters: writeSchema,
+    async execute(_toolCallId, { path: path3, content }, signal, _onUpdate, _ctx) {
+      let absolutePath = resolveToCwd(path3, cwd), dir = dirname2(absolutePath);
+      return withFileMutationQueue(absolutePath, async () => {
+        let throwIfAborted = () => {
+          if (signal?.aborted)
+            throw new Error("Operation aborted");
+        };
+        return throwIfAborted(), await ops.mkdir(dir), throwIfAborted(), await ops.writeFile(absolutePath, content), throwIfAborted(), {
+          content: [{ type: "text", text: `Successfully wrote ${content.length} bytes to ${path3}` }],
+          details: void 0
+        };
+      });
+    },
+    renderCall(args, theme2, context) {
+      let renderArgs = args, rawPath = str(renderArgs?.file_path ?? renderArgs?.path), fileContent = str(renderArgs?.content), component = context.lastComponent ?? new WriteCallRenderComponent();
+      fileContent !== null ? component.cache = context.argsComplete ? rebuildWriteHighlightCacheFull(rawPath, fileContent) : updateWriteHighlightCacheIncremental(component.cache, rawPath, fileContent) : component.cache = void 0;
+      let compact = !context.isPartial && !context.expanded && !context.isError, tree = toolGroupTree(context);
+      if (compact || tree && context.groupRole && context.groupRole !== "singleton") {
+        let detail = renderToolFileName(rawPath, theme2, context.cwd);
+        fileContent === null && (detail += `
+
+${theme2.fg("error", "[invalid content arg - expected string]")}`), component.setText(formatGroupedCall({
+          role: context.groupRole ?? "singleton",
+          compact,
+          tree,
+          dot: toolStatusDotFromContext(context, theme2),
+          title: theme2.fg("toolTitle", theme2.bold("write")),
+          detail
+        }));
+      } else
+        component.setText(`${toolStatusDotFromContext(context, theme2)} ${formatWriteCall(renderArgs, { expanded: context.expanded, isPartial: context.isPartial }, theme2, component.cache, context.cwd, !1)}`);
+      return component;
+    },
+    renderResult(result, _options, theme2, context) {
+      let output = formatWriteResult({ ...result, isError: context.isError }, theme2);
+      if (!output) {
+        let component = context.lastComponent ?? new Container3();
+        return component.clear(), component;
+      }
+      let text = context.lastComponent ?? new Text8("", 0, 0);
+      return text.setText(output), text;
+    }
+  };
+}
+function createWriteTool(cwd, options) {
+  return wrapToolDefinition(createWriteToolDefinition(cwd, options));
+}
+
+// packages/coding-agent/dist/core/tools/index.js
+function createAllToolDefinitions(cwd, options) {
+  return {
+    read: createReadToolDefinition(cwd, options?.read),
+    bash: createBashToolDefinition(cwd, options?.bash),
+    edit: createEditToolDefinition(cwd, options?.edit),
+    write: createWriteToolDefinition(cwd, options?.write),
+    grep: createGrepToolDefinition(cwd, options?.grep),
+    find: createFindToolDefinition(cwd, options?.find),
+    ls: createLsToolDefinition(cwd, options?.ls)
+  };
+}
+function createCodingTools(cwd, options) {
+  return [
+    createReadTool(cwd, options?.read),
+    createBashTool(cwd, options?.bash),
+    createEditTool(cwd, options?.edit),
+    createWriteTool(cwd, options?.write)
+  ];
+}
+function createReadOnlyTools(cwd, options) {
+  return [
+    createReadTool(cwd, options?.read),
+    createGrepTool(cwd, options?.grep),
+    createFindTool(cwd, options?.find),
+    createLsTool(cwd, options?.ls)
+  ];
+}
+
+export {
+  wrapToolDefinition,
+  createToolDefinitionFromAgentTool,
+  truncateToVisualLines,
+  list,
+  kill,
+  killAll,
+  pause,
+  resume,
+  restart,
+  isWindows,
+  clearRegistry,
+  createLocalBashOperations,
+  createBashToolDefinition,
+  createBashTool,
+  renderDiff,
+  resolveReadPath,
+  generateUnifiedPatch,
+  generateDiffString,
+  withFileMutationQueue,
+  createEditToolDefinition,
+  createEditTool,
+  getToolPath,
+  ensureTool,
+  createFindToolDefinition,
+  createFindTool,
+  createGrepToolDefinition,
+  createGrepTool,
+  createLsToolDefinition,
+  createLsTool,
+  detectSupportedImageMimeTypeFromFile,
+  createReadToolDefinition,
+  createReadTool,
+  createWriteToolDefinition,
+  createWriteTool,
+  createAllToolDefinitions,
+  createCodingTools,
+  createReadOnlyTools
+};