@letrquan/book 0.2.0

package/dist/chunk-MAQXCUR4.js

@@ -0,0 +1,1007 @@
+import {
+  canonicalToolName,
+  getPrimaryArg,
+  observeFile,
+  requireFreshObservation,
+  toolFailure,
+  toolSuccess
+} from "./chunk-5GDZ22YP.js";
+import {
+  globToRegex,
+  sandboxCoverage
+} from "./chunk-EYGD6X2T.js";
+
+// src/async.ts
+function throwIfAborted(signal) {
+  if (!signal?.aborted) return;
+  if (signal.reason instanceof Error) throw signal.reason;
+  throw new Error(typeof signal.reason === "string" ? signal.reason : "Operation cancelled");
+}
+function onAbort(signal, handler) {
+  if (!signal) return () => {
+  };
+  if (signal.aborted) {
+    handler();
+    return () => {
+    };
+  }
+  signal.addEventListener("abort", handler, { once: true });
+  return () => signal.removeEventListener("abort", handler);
+}
+async function delay(ms, signal) {
+  if (ms <= 0 || signal?.aborted) return;
+  await new Promise((resolve2) => {
+    const timer = setTimeout(() => {
+      unsubscribe();
+      resolve2();
+    }, ms);
+    const unsubscribe = onAbort(signal, () => {
+      clearTimeout(timer);
+      resolve2();
+    });
+  });
+}
+async function yieldToEventLoop(signal) {
+  throwIfAborted(signal);
+  await new Promise((resolve2) => setImmediate(resolve2));
+  throwIfAborted(signal);
+}
+
+// src/tools/diff.ts
+function splitLines(s) {
+  const lines = s.split("\n");
+  if (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
+  return lines;
+}
+var DIFF_YIELD_CELLS = 32768;
+var DIFF_YIELD_ITEMS = 1024;
+function commonAffixes(a, b) {
+  const max = Math.min(a.length, b.length);
+  let prefix = 0;
+  while (prefix < max && a[prefix] === b[prefix]) prefix++;
+  let suffix = 0;
+  while (suffix < max - prefix && a[a.length - 1 - suffix] === b[b.length - 1 - suffix]) suffix++;
+  return { prefix, suffix };
+}
+function contextOps(a, from, count, bOffset) {
+  const ops = [];
+  for (let index = 0; index < count; index++) {
+    const ai = from + index;
+    ops.push({ kind: "ctx", text: a[ai], ai, bi: ai + bOffset });
+  }
+  return ops;
+}
+function editScript(a, b, dp, offset) {
+  const n = a.length;
+  const m = b.length;
+  const ops = [];
+  let i = 0;
+  let j = 0;
+  while (i < n && j < m) {
+    if (a[i] === b[j]) {
+      ops.push({ kind: "ctx", text: a[i], ai: offset + i, bi: offset + j });
+      i++;
+      j++;
+    } else if (dp[i + 1][j] >= dp[i][j + 1]) {
+      ops.push({ kind: "del", text: a[i], ai: offset + i, bi: offset + j });
+      i++;
+    } else {
+      ops.push({ kind: "add", text: b[j], ai: offset + i, bi: offset + j });
+      j++;
+    }
+  }
+  while (i < n) {
+    ops.push({ kind: "del", text: a[i], ai: offset + i, bi: offset + j });
+    i++;
+  }
+  while (j < m) {
+    ops.push({ kind: "add", text: b[j], ai: offset + i, bi: offset + j });
+    j++;
+  }
+  return ops;
+}
+function hunkBounds(ops, context) {
+  const bounds = [];
+  let k = 0;
+  while (k < ops.length) {
+    if (ops[k].kind === "ctx") {
+      k++;
+      continue;
+    }
+    const start = k;
+    let ctxBefore = 0;
+    let s = start - 1;
+    while (s >= 0 && ops[s].kind === "ctx" && ctxBefore < context) {
+      s--;
+      ctxBefore++;
+    }
+    let e = start;
+    while (e < ops.length && ops[e].kind !== "ctx") e++;
+    let ctxAfter = 0;
+    while (e < ops.length && ops[e].kind === "ctx" && ctxAfter < context) {
+      e++;
+      ctxAfter++;
+    }
+    bounds.push([s + 1, e]);
+    k = e;
+  }
+  return bounds;
+}
+function hunkFrom(ops, start, end) {
+  const hunkOps = ops.slice(start, end);
+  return {
+    oldStart: (hunkOps[0]?.ai ?? 0) + 1,
+    newStart: (hunkOps[0]?.bi ?? 0) + 1,
+    lines: hunkOps.map((o) => ({ kind: o.kind, text: o.text }))
+  };
+}
+async function lineDiffAsync(oldText, newText, context = 3, signal) {
+  const a = splitLines(oldText);
+  const b = splitLines(newText);
+  const { prefix, suffix } = commonAffixes(a, b);
+  const midA = a.slice(prefix, a.length - suffix);
+  const midB = b.slice(prefix, b.length - suffix);
+  const n = midA.length;
+  const m = midB.length;
+  const dp = [];
+  for (let row = 0; row <= n; row++) {
+    dp.push(new Array(m + 1).fill(0));
+    if (row > 0 && row % 128 === 0) await yieldToEventLoop(signal);
+  }
+  let cellsUntilYield = DIFF_YIELD_CELLS;
+  for (let i = n - 1; i >= 0; i--) {
+    for (let j = m - 1; j >= 0; j--) {
+      dp[i][j] = midA[i] === midB[j] ? dp[i + 1][j + 1] + 1 : Math.max(dp[i + 1][j], dp[i][j + 1]);
+      cellsUntilYield--;
+      if (cellsUntilYield === 0) {
+        cellsUntilYield = DIFF_YIELD_CELLS;
+        await yieldToEventLoop(signal);
+      }
+    }
+  }
+  throwIfAborted(signal);
+  const ops = [
+    ...contextOps(a, 0, prefix, 0),
+    ...editScript(midA, midB, dp, prefix),
+    ...contextOps(a, a.length - suffix, suffix, b.length - a.length)
+  ];
+  if (ops.length > DIFF_YIELD_ITEMS) await yieldToEventLoop(signal);
+  const hunks = [];
+  for (const [start, end] of hunkBounds(ops, context)) {
+    hunks.push(hunkFrom(ops, start, end));
+    await yieldToEventLoop(signal);
+  }
+  throwIfAborted(signal);
+  return hunks;
+}
+function diffStatsFromHunks(hunks) {
+  let addedLines = 0;
+  let removedLines = 0;
+  for (const hunk of hunks) {
+    for (const line of hunk.lines) {
+      if (line.kind === "add") addedLines++;
+      if (line.kind === "del") removedLines++;
+    }
+  }
+  return { addedLines, removedLines };
+}
+async function renderDiffWithStatsAsync(oldText, newText, context = 3, signal) {
+  const hunks = await lineDiffAsync(oldText, newText, context, signal);
+  if (hunks.length === 0) return { diff: "", stats: { addedLines: 0, removedLines: 0 } };
+  const out = [];
+  for (let hunkIndex = 0; hunkIndex < hunks.length; hunkIndex++) {
+    const hunk = hunks[hunkIndex];
+    out.push(`@@ -${hunk.oldStart} +${hunk.newStart} @@`);
+    for (let lineIndex = 0; lineIndex < hunk.lines.length; lineIndex++) {
+      const line = hunk.lines[lineIndex];
+      const prefix = line.kind === "add" ? "+" : line.kind === "del" ? "-" : " ";
+      out.push(prefix + line.text);
+      if (lineIndex > 0 && lineIndex % DIFF_YIELD_ITEMS === 0) await yieldToEventLoop(signal);
+    }
+    if (hunkIndex > 0 && hunkIndex % 64 === 0) await yieldToEventLoop(signal);
+  }
+  return { diff: out.join("\n"), stats: diffStatsFromHunks(hunks) };
+}
+
+// src/tools/path-utils.ts
+import { existsSync, realpathSync } from "fs";
+import { dirname, isAbsolute, relative, resolve, sep } from "path";
+function isOutside(root, candidate) {
+  const rel = relative(root, candidate);
+  return rel === ".." || rel.startsWith(`..${sep}`) || isAbsolute(rel);
+}
+function nearestExistingPath(inputPath) {
+  let candidate = inputPath;
+  while (!existsSync(candidate)) {
+    const parent = dirname(candidate);
+    if (parent === candidate) return null;
+    candidate = parent;
+  }
+  return candidate;
+}
+function resolveWorkspacePath(workspaceRoot, inputPath) {
+  const lexicalRoot = resolve(workspaceRoot);
+  const filePath = resolve(isAbsolute(inputPath) ? inputPath : resolve(lexicalRoot, inputPath));
+  if (isOutside(lexicalRoot, filePath)) return null;
+  const existingPath = nearestExistingPath(filePath);
+  if (!existingPath) return null;
+  let realRoot;
+  let realExisting;
+  try {
+    realRoot = realpathSync.native(lexicalRoot);
+    realExisting = realpathSync.native(existingPath);
+  } catch {
+    return null;
+  }
+  if (isOutside(realRoot, realExisting)) return null;
+  const canonicalPath = resolve(realExisting, relative(existingPath, filePath));
+  if (isOutside(realRoot, canonicalPath)) return null;
+  const rel = relative(lexicalRoot, filePath);
+  return { filePath, canonicalPath, relativePath: rel.replace(/\\/g, "/") };
+}
+function pathOutsideWorkspaceResult(inputPath) {
+  return toolFailure(`Path outside workspace: ${inputPath}`, {
+    code: "path_outside_workspace"
+  });
+}
+
+// src/tools/mutation.ts
+import { randomUUID } from "crypto";
+import { mkdir, readFile, rename, rm, stat, writeFile } from "fs/promises";
+import { dirname as dirname2 } from "path";
+var pathLocks = /* @__PURE__ */ new Map();
+function looksBinary(bytes) {
+  const sample = bytes.subarray(0, 8192);
+  if (sample.includes(0)) return true;
+  let controls = 0;
+  for (const byte of sample) {
+    if (byte < 7 || byte > 13 && byte < 32) controls++;
+  }
+  return sample.length > 0 && controls / sample.length > 0.1;
+}
+async function readTextSnapshot(filePath, allowMissing = false) {
+  let bytes;
+  try {
+    bytes = await readFile(filePath);
+  } catch (error) {
+    if (allowMissing && error.code === "ENOENT") {
+      return {
+        exists: false,
+        bytes: Buffer.alloc(0),
+        text: "",
+        bom: false,
+        lineEnding: "lf",
+        mixedLineEndings: false,
+        binary: false,
+        mode: void 0
+      };
+    }
+    throw error;
+  }
+  const bom = bytes.length >= 3 && bytes[0] === 239 && bytes[1] === 187 && bytes[2] === 191;
+  const body = bytes.subarray(bom ? 3 : 0);
+  let binary = looksBinary(bytes);
+  let decoded;
+  try {
+    decoded = new TextDecoder("utf-8", { fatal: true }).decode(body);
+  } catch {
+    binary = true;
+    decoded = body.toString("utf8");
+  }
+  const crlfCount = (decoded.match(/\r\n/g) ?? []).length;
+  const bareLfCount = (decoded.replace(/\r\n/g, "").match(/\n/g) ?? []).length;
+  const bareCrCount = (decoded.replace(/\r\n/g, "").match(/\r/g) ?? []).length;
+  const mixedLineEndings = crlfCount > 0 && bareLfCount > 0 || bareCrCount > 0;
+  const mode = (await stat(filePath)).mode & 511;
+  return {
+    exists: true,
+    bytes,
+    text: decoded.replace(/\r\n/g, "\n"),
+    bom,
+    lineEnding: crlfCount > bareLfCount ? "crlf" : "lf",
+    mixedLineEndings,
+    binary,
+    mode
+  };
+}
+function restoreTextEncoding(text, snapshot) {
+  const body = snapshot.lineEnding === "crlf" ? text.replace(/\n/g, "\r\n") : text;
+  return Buffer.from(`${snapshot.bom ? "\uFEFF" : ""}${body}`, "utf8");
+}
+async function writeFileAtomically(filePath, bytes, signal, mode) {
+  throwIfAborted(signal);
+  await mkdir(dirname2(filePath), { recursive: true });
+  const temporary = `${filePath}.book-tmp-${randomUUID()}`;
+  try {
+    await writeFile(temporary, bytes, { flag: "wx", mode });
+    throwIfAborted(signal);
+    await rename(temporary, filePath);
+  } finally {
+    await rm(temporary, { force: true }).catch(() => void 0);
+  }
+}
+async function removeFileAtomically(filePath, signal) {
+  throwIfAborted(signal);
+  await rm(filePath, { force: false });
+}
+async function acquirePath(path) {
+  const previous = pathLocks.get(path) ?? Promise.resolve();
+  let release;
+  const current = new Promise((resolve2) => {
+    release = resolve2;
+  });
+  const queued = previous.then(() => current);
+  pathLocks.set(path, queued);
+  await previous;
+  return () => {
+    release();
+    if (pathLocks.get(path) === queued) pathLocks.delete(path);
+  };
+}
+async function withMutationLocks(paths, operation) {
+  const releases = [];
+  try {
+    for (const path of [...new Set(paths)].sort()) releases.push(await acquirePath(path));
+    return await operation();
+  } finally {
+    for (const release of releases.reverse()) release();
+  }
+}
+
+// src/tools/patch.ts
+var MAX_PATCH_BYTES = 1024 * 1024;
+var MAX_FILES = 100;
+var MAX_HUNKS = 1e3;
+function invalid(message, details) {
+  return toolFailure(message, {
+    code: "invalid_patch_syntax",
+    remediation: "Regenerate a Codex-style patch with Begin/End markers and valid file hunks.",
+    details
+  });
+}
+function parseHunkHeader(line) {
+  const match = line.match(/^@@(?: -(\d+)(?:,(\d+))?)?(?: \+(\d+)(?:,(\d+))?)?(?: @@.*)?$/);
+  if (!match) throw new Error(`Invalid hunk header: ${line}`);
+  return { oldStart: match[1] ? Number(match[1]) : void 0 };
+}
+function parsePatchUnsafe(patch) {
+  if (typeof patch !== "string" || patch.length === 0)
+    return invalid("patch must be a non-empty string");
+  const bytes = Buffer.byteLength(patch, "utf8");
+  if (bytes > MAX_PATCH_BYTES)
+    return toolFailure(`Patch input exceeds ${MAX_PATCH_BYTES} bytes`, {
+      code: "patch_limit_exceeded",
+      remediation: "Split the change into smaller patches.",
+      details: { limit: MAX_PATCH_BYTES, bytes }
+    });
+  const lines = patch.replace(/\r\n/g, "\n").split("\n");
+  if (lines.at(-1) === "") lines.pop();
+  if (lines[0] !== "*** Begin Patch" || lines.at(-1) !== "*** End Patch")
+    return invalid("Patch must start with *** Begin Patch and end with *** End Patch");
+  const operations = [];
+  let index = 1;
+  let hunkCount = 0;
+  while (index < lines.length - 1) {
+    const marker = lines[index];
+    const update = marker.match(/^\*\*\* Update File: (.+)$/);
+    const add = marker.match(/^\*\*\* Add File: (.+)$/);
+    const del = marker.match(/^\*\*\* Delete File: (.+)$/);
+    if (update) {
+      const hunks = [];
+      index++;
+      while (index < lines.length - 1 && !lines[index].startsWith("*** ")) {
+        if (!lines[index].startsWith("@@"))
+          throw new Error(`Expected @@ hunk header near line ${index + 1}`);
+        const header = lines[index];
+        const parsedHeader = parseHunkHeader(header);
+        index++;
+        const hunkLines = [];
+        while (index < lines.length - 1 && !lines[index].startsWith("@@") && !lines[index].startsWith("*** ")) {
+          const line = lines[index++];
+          if (line === "\") {
+            const previous = hunkLines.at(-1);
+            if (!previous)
+              throw new Error(`No-newline marker has no preceding hunk line near line ${index}`);
+            previous.noNewline = true;
+            continue;
+          }
+          if (line.startsWith(" ")) hunkLines.push({ kind: "context", text: line.slice(1) });
+          else if (line.startsWith("-")) hunkLines.push({ kind: "remove", text: line.slice(1) });
+          else if (line.startsWith("+")) hunkLines.push({ kind: "add", text: line.slice(1) });
+          else throw new Error(`Invalid hunk line near line ${index}`);
+        }
+        if (hunkLines.length === 0) throw new Error(`Empty hunk near line ${index}`);
+        if (!hunkLines.some((line) => line.kind !== "add"))
+          throw new Error(`Update hunk must contain context or removed lines near line ${index}`);
+        hunks.push({ header, oldStart: parsedHeader.oldStart, lines: hunkLines });
+        hunkCount++;
+      }
+      if (hunks.length === 0) throw new Error(`Update File ${update[1]} has no hunks`);
+      operations.push({ kind: "update", path: update[1].trim(), hunks });
+      continue;
+    }
+    if (add) {
+      index++;
+      const content = [];
+      while (index < lines.length - 1 && !lines[index].startsWith("*** ")) {
+        const line = lines[index++];
+        if (!line.startsWith("+"))
+          throw new Error(`Added file lines must begin with + near line ${index}`);
+        content.push(line.slice(1));
+      }
+      operations.push({ kind: "add", path: add[1].trim(), lines: content });
+      continue;
+    }
+    if (del) {
+      index++;
+      if (index < lines.length - 1 && !lines[index].startsWith("*** "))
+        throw new Error(`Delete File ${del[1]} cannot contain patch lines`);
+      operations.push({ kind: "delete", path: del[1].trim() });
+      continue;
+    }
+    throw new Error(`Expected a file operation near line ${index + 1}`);
+  }
+  if (operations.length === 0) return invalid("Patch contains no file operations");
+  if (operations.length > MAX_FILES || hunkCount > MAX_HUNKS)
+    return toolFailure(`Patch exceeds limits (${MAX_FILES} files, ${MAX_HUNKS} hunks)`, {
+      code: "patch_limit_exceeded",
+      remediation: "Split the change into smaller patches.",
+      details: { files: operations.length, hunks: hunkCount }
+    });
+  return { operations, bytes };
+}
+function parsePatch(patch) {
+  try {
+    return parsePatchUnsafe(patch);
+  } catch (error) {
+    return invalid(error instanceof Error ? error.message : String(error));
+  }
+}
+function linesOf(text) {
+  const lines = text.split("\n");
+  if (lines.at(-1) === "") lines.pop();
+  return lines;
+}
+function findUniqueSequence(haystack, needle) {
+  if (needle.length === 0) return { index: 0, count: 0 };
+  let index = -1;
+  let count = 0;
+  for (let start = 0; start <= haystack.length - needle.length; start++) {
+    if (needle.every((line, offset) => haystack[start + offset] === line)) {
+      index = start;
+      count++;
+    }
+  }
+  return { index, count };
+}
+function candidateLine(haystack, line) {
+  const matches = haystack.reduce((found, value, index) => {
+    if (value === line) found.push(index + 1);
+    return found;
+  }, []);
+  return matches.length === 1 ? matches[0] : void 0;
+}
+function applyHunks(text, hunks) {
+  let lines = linesOf(text);
+  let trailingNewline = text.endsWith("\n");
+  for (let hunkIndex = 0; hunkIndex < hunks.length; hunkIndex++) {
+    const hunk = hunks[hunkIndex];
+    const oldLines = hunk.lines.filter((line) => line.kind !== "add").map((line) => line.text);
+    const newLines = hunk.lines.filter((line) => line.kind !== "remove").map((line) => line.text);
+    const match = findUniqueSequence(lines, oldLines);
+    if (match.count === 0)
+      return {
+        text,
+        mismatch: toolFailure(`Hunk ${hunkIndex + 1}: patch context not found`, {
+          code: "patch_context_not_found",
+          remediation: "Reread the affected range and regenerate the hunk against the latest file contents.",
+          details: {
+            hunkIndex: hunkIndex + 1,
+            header: hunk.header,
+            firstContextLine: oldLines[0]?.slice(0, 200),
+            closestCandidateLine: oldLines[0] ? candidateLine(lines, oldLines[0]) : void 0,
+            suggestedReadRange: hunk.oldStart !== void 0 ? {
+              lineStart: Math.max(1, hunk.oldStart - 3),
+              lineEnd: hunk.oldStart + oldLines.length + 3
+            } : void 0
+          }
+        })
+      };
+    if (match.count > 1)
+      return {
+        text,
+        mismatch: toolFailure(`Hunk ${hunkIndex + 1}: patch context is ambiguous`, {
+          code: "ambiguous_patch_context",
+          remediation: "Reread a narrower range and include more exact context lines.",
+          details: { hunkIndex: hunkIndex + 1, header: hunk.header, matches: match.count }
+        })
+      };
+    const touchesEndOfFile = match.index + oldLines.length === lines.length;
+    lines = [
+      ...lines.slice(0, match.index),
+      ...newLines,
+      ...lines.slice(match.index + oldLines.length)
+    ];
+    if (touchesEndOfFile) {
+      const oldNoNewline = hunk.lines.some((line) => line.kind !== "add" && line.noNewline);
+      const newNoNewline = hunk.lines.some((line) => line.kind !== "remove" && line.noNewline);
+      if (newNoNewline) trailingNewline = false;
+      else if (oldNoNewline) trailingNewline = true;
+    }
+  }
+  return { text: lines.join("\n") + (trailingNewline && lines.length > 0 ? "\n" : "") };
+}
+function mutationFromDiff(relativePath, kind, stats) {
+  return {
+    kind,
+    filePath: relativePath,
+    addedLines: stats.addedLines,
+    removedLines: stats.removedLines
+  };
+}
+function errorCodeFor(error) {
+  return error instanceof Error && error.message.includes("changed or disappeared") ? "stale_file_observation" : "filesystem_error";
+}
+async function applyPatch(args, ctx) {
+  const parsed = parsePatch(args.patch);
+  if (!("operations" in parsed)) return parsed;
+  const paths = parsed.operations.map((operation) => operation.path);
+  const resolved = parsed.operations.map((operation) => {
+    const result = resolveWorkspacePath(ctx.workspaceRoot, operation.path);
+    return result ? { operation, ...result } : null;
+  });
+  if (resolved.some((entry) => !entry))
+    return pathOutsideWorkspaceResult(paths[resolved.findIndex((entry) => !entry)]);
+  const entries = resolved;
+  const canonicalKeys = entries.map(
+    (entry) => process.platform === "win32" ? entry.canonicalPath.toLowerCase() : entry.canonicalPath
+  );
+  if (new Set(canonicalKeys).size !== canonicalKeys.length)
+    return toolFailure("A patch may contain only one operation per file", {
+      code: "patch_conflict",
+      remediation: "Combine related updates into one file operation with multiple hunks."
+    });
+  return withMutationLocks(
+    entries.map((entry) => entry.canonicalPath),
+    async () => {
+      const staged = [];
+      try {
+        for (const entry of entries) {
+          throwIfAborted(ctx.signal);
+          const before = await readTextSnapshot(entry.filePath, entry.operation.kind === "add");
+          if (before.binary)
+            return toolFailure(`Binary file is unsupported: ${entry.relativePath}`, {
+              code: "binary_file_unsupported",
+              remediation: "Use a text file mutation or a dedicated binary workflow."
+            });
+          if (before.mixedLineEndings && entry.operation.kind === "update")
+            return toolFailure(
+              `Mixed line endings are unsupported for patch updates: ${entry.relativePath}`,
+              {
+                code: "patch_conflict",
+                remediation: "Normalize the file line endings, reread it, and regenerate the patch.",
+                details: { filePath: entry.relativePath, lineEnding: "mixed" }
+              }
+            );
+          const stale = entry.operation.kind === "add" ? void 0 : await requireFreshObservation(ctx, entry.filePath, entry.relativePath);
+          if (stale)
+            return toolFailure(stale, {
+              code: "stale_file_observation",
+              remediation: "Call Read before regenerating the patch."
+            });
+          if (entry.operation.kind === "add") {
+            if (before.exists)
+              return toolFailure(`File already exists: ${entry.relativePath}`, {
+                code: "patch_conflict",
+                remediation: "Use Update File for an existing file."
+              });
+            const afterText = entry.operation.lines.join("\n") + (entry.operation.lines.length > 0 ? "\n" : "");
+            const { stats } = await renderDiffWithStatsAsync("", afterText, 3, ctx.signal);
+            staged.push({
+              operation: entry.operation,
+              absolutePath: entry.filePath,
+              writePath: entry.canonicalPath,
+              relativePath: entry.relativePath,
+              before,
+              afterText,
+              afterBytes: Buffer.from(afterText, "utf8"),
+              mutation: mutationFromDiff(entry.relativePath, "create", stats)
+            });
+          } else if (entry.operation.kind === "delete") {
+            if (!before.exists)
+              return toolFailure(`File not found: ${entry.relativePath}`, {
+                code: "patch_conflict",
+                remediation: "Reread the workspace and regenerate the patch."
+              });
+            staged.push({
+              operation: entry.operation,
+              absolutePath: entry.filePath,
+              writePath: entry.filePath,
+              relativePath: entry.relativePath,
+              before,
+              mutation: {
+                kind: "delete",
+                filePath: entry.relativePath,
+                addedLines: 0,
+                removedLines: linesOf(before.text).length
+              }
+            });
+          } else {
+            if (!before.exists)
+              return toolFailure(`File not found: ${entry.relativePath}`, {
+                code: "patch_context_not_found",
+                remediation: "Reread the file and regenerate the patch."
+              });
+            const applied = applyHunks(before.text, entry.operation.hunks);
+            if (applied.mismatch)
+              return toolFailure(
+                `${entry.relativePath}: ${applied.mismatch.structuredError?.message}`,
+                {
+                  ...applied.mismatch.structuredError,
+                  code: applied.mismatch.structuredError?.code ?? "patch_context_not_found",
+                  remediation: applied.mismatch.structuredError?.remediation,
+                  details: {
+                    ...applied.mismatch.structuredError?.details,
+                    filePath: entry.relativePath,
+                    lineEnding: before.mixedLineEndings ? "mixed" : before.lineEnding,
+                    normalizedMatching: true
+                  }
+                }
+              );
+            const afterText = applied.text;
+            const { stats } = await renderDiffWithStatsAsync(before.text, afterText, 3, ctx.signal);
+            staged.push({
+              operation: entry.operation,
+              absolutePath: entry.filePath,
+              writePath: entry.canonicalPath,
+              relativePath: entry.relativePath,
+              before,
+              afterText,
+              afterBytes: restoreTextEncoding(afterText, before),
+              mutation: mutationFromDiff(entry.relativePath, "update", stats)
+            });
+          }
+        }
+        const mutations = staged.map((file) => file.mutation);
+        const changedLines = mutations.reduce(
+          (total, mutation) => total + mutation.addedLines + mutation.removedLines,
+          0
+        );
+        const contextLines = parsed.operations.reduce(
+          (total, operation) => total + (operation.kind === "update" ? operation.hunks.reduce(
+            (hunkTotal, hunk) => hunkTotal + hunk.lines.filter((line) => line.kind === "context").length,
+            0
+          ) : 0),
+          0
+        );
+        const changeBudgetWarnings = [];
+        if (changedLines > 2e3) changeBudgetWarnings.push("large_change");
+        if (changedLines > 100 && changedLines > Math.max(1, contextLines) * 20)
+          changeBudgetWarnings.push("low_context_to_change_ratio");
+        const diffs = [];
+        for (const file of staged) {
+          throwIfAborted(ctx.signal);
+          const afterText = file.afterText ?? "";
+          const { diff } = await renderDiffWithStatsAsync(
+            file.before.text,
+            afterText,
+            3,
+            ctx.signal
+          );
+          if (diff) diffs.push(`--- ${file.relativePath}
++++ ${file.relativePath}
+${diff}`);
+        }
+        const committed = [];
+        try {
+          for (const file of staged) {
+            throwIfAborted(ctx.signal);
+            committed.push(file);
+            if (file.operation.kind === "delete")
+              await removeFileAtomically(file.absolutePath, ctx.signal);
+            else
+              await writeFileAtomically(
+                file.writePath,
+                file.afterBytes,
+                ctx.signal,
+                file.before.mode
+              );
+            const check = await readTextSnapshot(
+              file.absolutePath,
+              file.operation.kind === "delete"
+            );
+            if (file.operation.kind === "delete" ? check.exists : !check.exists || !check.bytes.equals(file.afterBytes))
+              throw new Error(`Post-write verification failed for ${file.relativePath}`);
+          }
+        } catch (error) {
+          let rollbackFailed = false;
+          for (const file of committed.reverse()) {
+            try {
+              if (file.before.exists)
+                await writeFileAtomically(
+                  file.writePath,
+                  file.before.bytes,
+                  void 0,
+                  file.before.mode
+                );
+              else await removeFileAtomically(file.absolutePath).catch(() => void 0);
+            } catch {
+              rollbackFailed = true;
+            }
+          }
+          return toolFailure(
+            `Patch commit failed${rollbackFailed ? "; rollback also failed" : " and was rolled back"}: ${error instanceof Error ? error.message : String(error)}`,
+            {
+              code: rollbackFailed ? "patch_rollback_failed" : "filesystem_error",
+              remediation: rollbackFailed ? "Inspect the affected files and restore them manually." : "Retry after checking the workspace state."
+            }
+          );
+        }
+        const observations = [];
+        for (const file of staged) {
+          if (file.operation.kind !== "delete")
+            observations.push(
+              await observeFile(
+                ctx,
+                file.absolutePath,
+                file.operation.kind === "add" ? "create" : "edit"
+              )
+            );
+        }
+        const result = toolSuccess(
+          diffs.join("\n") || "Patch applied successfully (no textual change)",
+          {
+            data: {
+              files: mutations.map((mutation) => mutation.filePath),
+              changedFiles: mutations.length,
+              changedLines,
+              patchBytes: parsed.bytes,
+              changeBudgetWarnings
+            },
+            artifacts: {
+              fileMutation: mutations[0],
+              fileMutations: mutations,
+              fileObservations: observations
+            },
+            presentation: {
+              kind: "diff",
+              summary: `Applied patch to ${mutations.length} ${mutations.length === 1 ? "file" : "files"}`,
+              target: mutations.length === 1 ? mutations[0].filePath : `${mutations.length} files`
+            }
+          }
+        );
+        return result;
+      } catch (error) {
+        const code = errorCodeFor(error);
+        return toolFailure(error instanceof Error ? error.message : String(error), {
+          code,
+          remediation: "Reread the affected file and regenerate the patch."
+        });
+      }
+    }
+  );
+}
+var patchTools = [
+  {
+    name: "ApplyPatch",
+    argumentAliases: { input: "patch" },
+    description: "Apply a Codex-style patch with Update File, Add File, or Delete File operations across one or more files atomically. Read the targets first; use exact contextual hunks, and regenerate the patch after a context mismatch instead of resending it unchanged.",
+    parameters: {
+      type: "object",
+      properties: {
+        patch: {
+          type: "string",
+          minLength: 1,
+          maxLength: MAX_PATCH_BYTES,
+          description: "Patch text beginning with *** Begin Patch and ending with *** End Patch"
+        },
+        baseObservation: {
+          type: "string",
+          maxLength: 128,
+          description: "Optional short observation identifier for diagnostics; freshness is checked implicitly."
+        }
+      },
+      required: ["patch"],
+      additionalProperties: false
+    },
+    execute: applyPatch
+  }
+];
+
+// src/permissions.ts
+function parseRule(rule) {
+  const parenIdx = rule.indexOf("(");
+  if (parenIdx === -1) {
+    return { toolName: rule.trim(), pattern: null };
+  }
+  const toolName = rule.slice(0, parenIdx).trim();
+  const closeIdx = rule.lastIndexOf(")");
+  if (closeIdx === -1 || closeIdx <= parenIdx) {
+    return { toolName, pattern: null };
+  }
+  const pattern = rule.slice(parenIdx + 1, closeIdx).trim();
+  return { toolName, pattern: pattern.length === 0 ? null : pattern };
+}
+function normalizePathArg(s) {
+  if (s.startsWith("./")) return s.slice(2);
+  return s;
+}
+function toolNameMatchesRule(ruleToolName, toolName) {
+  if (ruleToolName === toolName) return true;
+  if (!ruleToolName.startsWith("mcp__")) return false;
+  const serverName = ruleToolName.slice("mcp__".length);
+  return Boolean(
+    serverName && !serverName.includes("__") && toolName.startsWith(`${ruleToolName}__`)
+  );
+}
+function ruleMatches(rule, toolName, primaryArg) {
+  if (!toolNameMatchesRule(rule.toolName, toolName)) return false;
+  if (rule.pattern === null) return true;
+  const normalizedArg = normalizePathArg(primaryArg);
+  const normalizedPattern = rule.pattern.startsWith("./") ? rule.pattern.slice(2) : rule.pattern;
+  return globToRegex(normalizedPattern).test(normalizedArg);
+}
+function permissionRuleForToolCall(call) {
+  const toolName = canonicalToolName(call.name);
+  const primaryArg = getPrimaryArg(call.arguments);
+  if (toolName === "WebSearch") return toolName;
+  if (toolName === "WebFetch" && primaryArg) {
+    try {
+      const url = new URL(primaryArg);
+      return `${toolName}(${url.origin}/**)`;
+    } catch {
+    }
+  }
+  return primaryArg ? `${toolName}(${primaryArg})` : toolName;
+}
+function permissionResultOf(decision) {
+  return typeof decision === "string" ? decision : decision.result;
+}
+function permissionRuleOf(decision) {
+  return typeof decision === "string" ? void 0 : decision.rule;
+}
+var RULE_LADDER_MAX = 3;
+var SHELL_CHAINING = /[;&|><`$(){}\n]/;
+function permissionRuleLadder(call) {
+  const exact = permissionRuleForToolCall(call);
+  if (canonicalToolName(call.name) !== "Bash") return [exact];
+  const command = getPrimaryArg(call.arguments).trim();
+  if (!command || SHELL_CHAINING.test(command)) return [exact];
+  const tokens = command.split(/\s+/);
+  const ladder = [exact];
+  for (let take = tokens.length - 1; take >= 1 && ladder.length < RULE_LADDER_MAX; take -= 1) {
+    const prefix = `Bash(${tokens.slice(0, take).join(" ")} *)`;
+    if (!ladder.includes(prefix)) ladder.push(prefix);
+  }
+  return ladder;
+}
+function permissionRuleMatchesCall(rule, call) {
+  const toolName = canonicalToolName(call.name);
+  const primaryArg = getPrimaryArg(call.arguments);
+  if (toolName === "WebFetch" && primaryArg) {
+    try {
+      return ruleMatches(parseRule(rule), toolName, new URL(primaryArg).toString());
+    } catch {
+    }
+  }
+  return ruleMatches(parseRule(rule), toolName, primaryArg);
+}
+function patchOperations(args) {
+  const parsed = parsePatch(args.patch);
+  return "operations" in parsed ? parsed.operations : [];
+}
+function ruleMatchesPatch(rule, path) {
+  return ruleMatches(rule, rule.toolName, path);
+}
+function patchRuleSupportsOperation(rule, operation) {
+  if (rule.toolName === "ApplyPatch") return true;
+  if (rule.toolName === "Edit") return operation.kind === "update";
+  if (rule.toolName === "Write") return operation.kind === "update" || operation.kind === "add";
+  return false;
+}
+function compatiblePatchRuleMatches(rule, operations) {
+  if (!["ApplyPatch", "Edit", "Write"].includes(rule.toolName)) return false;
+  if (rule.toolName === "ApplyPatch" && rule.pattern === null) return true;
+  return operations.some(
+    (operation) => patchRuleSupportsOperation(rule, operation) && (rule.pattern === null || ruleMatchesPatch(rule, operation.path))
+  );
+}
+function primaryArgForRule(_toolName, args) {
+  return getPrimaryArg(args);
+}
+function hasAdjudicationPolicy(settings) {
+  return settings.permissions.deny.length > 0 || settings.permissions.ask.length > 0;
+}
+function sandboxAutoAllows(toolName, args, settings, options) {
+  if (!settings.sandbox.autoAllowBashIfSandboxed) return false;
+  if (canonicalToolName(toolName) !== "Bash") return false;
+  if (hasAdjudicationPolicy(settings)) return false;
+  const command = typeof args.command === "string" ? args.command.trim() : "";
+  if (!command) return false;
+  return sandboxCoverage(command, settings.sandbox, options.sandboxBackendAvailable).sandboxed;
+}
+function evaluatePermission(toolName, args, settings, options = {}) {
+  return evaluatePermissionDetail(toolName, args, settings, options).decision;
+}
+function evaluatePermissionDetail(toolName, args, settings, options = {}) {
+  const { deny, ask, allow } = settings.permissions;
+  if (toolName === "ApplyPatch") {
+    const operations = patchOperations(args);
+    const compatible = (ruleStr) => {
+      const rule = parseRule(ruleStr);
+      return rule.toolName === "ApplyPatch" || rule.toolName === "Edit" || rule.toolName === "Write";
+    };
+    for (const ruleStr of deny) {
+      if (!compatible(ruleStr)) continue;
+      const rule = parseRule(ruleStr);
+      if (compatiblePatchRuleMatches(rule, operations))
+        return { decision: "deny", matchedRule: ruleStr, source: "deny" };
+    }
+    for (const ruleStr of ask) {
+      if (!compatible(ruleStr)) continue;
+      const rule = parseRule(ruleStr);
+      if (compatiblePatchRuleMatches(rule, operations))
+        return { decision: "ask", matchedRule: ruleStr, source: "ask" };
+    }
+    const allowRules = allow.filter(compatible).map(parseRule);
+    if (operations.length > 0 && operations.every(
+      (operation) => allowRules.some(
+        (rule) => patchRuleSupportsOperation(rule, operation) && (rule.pattern === null || ruleMatchesPatch(rule, operation.path))
+      )
+    )) {
+      return { decision: "allow", matchedRule: allow.find(compatible), source: "allow" };
+    }
+    if (allowRules.some((rule) => rule.toolName === "ApplyPatch" && rule.pattern === null)) {
+      return { decision: "allow", matchedRule: allow.find(compatible), source: "allow" };
+    }
+    return { decision: "ask", source: "default" };
+  }
+  const call = { id: "permission-evaluation", name: toolName, arguments: args };
+  for (const ruleStr of deny) {
+    if (permissionRuleMatchesCall(ruleStr, call)) {
+      return { decision: "deny", matchedRule: ruleStr, source: "deny" };
+    }
+  }
+  for (const ruleStr of ask) {
+    if (permissionRuleMatchesCall(ruleStr, call)) {
+      return { decision: "ask", matchedRule: ruleStr, source: "ask" };
+    }
+  }
+  for (const ruleStr of allow) {
+    if (permissionRuleMatchesCall(ruleStr, call)) {
+      return { decision: "allow", matchedRule: ruleStr, source: "allow" };
+    }
+  }
+  if (sandboxAutoAllows(toolName, args, settings, options)) {
+    return { decision: "allow", source: "sandbox" };
+  }
+  return { decision: "ask", source: "default" };
+}
+
+export {
+  throwIfAborted,
+  onAbort,
+  delay,
+  yieldToEventLoop,
+  renderDiffWithStatsAsync,
+  resolveWorkspacePath,
+  pathOutsideWorkspaceResult,
+  readTextSnapshot,
+  restoreTextEncoding,
+  writeFileAtomically,
+  withMutationLocks,
+  parsePatch,
+  applyHunks,
+  patchTools,
+  parseRule,
+  permissionRuleForToolCall,
+  permissionResultOf,
+  permissionRuleOf,
+  permissionRuleLadder,
+  permissionRuleMatchesCall,
+  primaryArgForRule,
+  hasAdjudicationPolicy,
+  evaluatePermission,
+  evaluatePermissionDetail
+};
+//# sourceMappingURL=chunk-MAQXCUR4.js.map