@letrquan/book 0.2.0 → 0.4.0-beta.0

package/dist/chunk-YIL6HTJX.js

@@ -0,0 +1,663 @@
+import {
+  reachesUncPath
+} from "./chunk-EEX6QNXV.js";
+import {
+  resolveBookHome
+} from "./chunk-ZPSZZUWF.js";
+
+// src/tools/aliases.ts
+var TOOL_ALIASES = {
+  read_file: "Read",
+  write_file: "Write",
+  edit_file: "Edit",
+  multi_edit: "MultiEdit",
+  apply_patch: "ApplyPatch",
+  glob: "Glob",
+  glob_files: "Glob",
+  grep: "Grep",
+  bash: "Bash",
+  // Legacy snake_case git tool names — backward compatible.
+  git_status: "GitStatus",
+  git_diff: "GitDiff",
+  git_log: "GitLog",
+  git_commit: "GitCommit",
+  git_branch: "GitBranch"
+};
+function canonicalToolName(name) {
+  return TOOL_ALIASES[name] ?? name;
+}
+var PROVIDER_TOOL_PREFIXES = [
+  "parent:",
+  "default:",
+  "tool:",
+  "parent.",
+  "default.",
+  "tool.",
+  "functions."
+];
+function unwrapProviderPrefix(name) {
+  const prefix = PROVIDER_TOOL_PREFIXES.find((candidate) => name.startsWith(candidate));
+  return prefix ? name.slice(prefix.length) : name;
+}
+function displayToolName(name) {
+  return canonicalToolName(unwrapProviderPrefix(name));
+}
+
+// src/tools/primary-arg.ts
+function getPrimaryArg(args) {
+  if (typeof args.command === "string") return args.command.split("\n")[0];
+  if (typeof args.shell_id === "string") return args.shell_id;
+  if (typeof args.shellId === "string") return args.shellId;
+  if (typeof args.taskId === "string") return args.taskId;
+  if (typeof args.task_id === "string") return args.task_id;
+  if (typeof args.filePath === "string") return args.filePath;
+  if (typeof args.file_path === "string") return args.file_path;
+  if (typeof args.patch === "string") {
+    const match = args.patch.match(/^\*\*\* (?:Update|Add|Delete) File: (.+)$/m);
+    if (match) return match[1].trim();
+  }
+  if (typeof args.notebook_path === "string") return args.notebook_path;
+  if (typeof args.pattern === "string") return args.pattern;
+  if (typeof args.path === "string") return args.path;
+  if (typeof args.agent === "string") return args.agent;
+  if (typeof args.skill === "string") return args.skill;
+  if (typeof args.message === "string") return args.message;
+  if (typeof args.url === "string") return args.url;
+  if (typeof args.query === "string") return args.query;
+  if (typeof args.subject === "string") return args.subject;
+  if (typeof args.old_string === "string") return args.old_string.slice(0, 60);
+  const keys = Object.keys(args);
+  if (keys.length > 0) {
+    const v = args[keys[0]];
+    return typeof v === "string" ? v : "";
+  }
+  return "";
+}
+
+// src/tools/result.ts
+import { mkdir, writeFile } from "fs/promises";
+import { dirname, join } from "path";
+
+// src/tools/tool-capabilities.ts
+var FILE_MUTATING_TOOLS = /* @__PURE__ */ new Set([
+  "ApplyPatch",
+  "Write",
+  "Edit",
+  "MultiEdit",
+  "NotebookEdit"
+]);
+function isFileMutatingTool(canonicalName) {
+  return FILE_MUTATING_TOOLS.has(canonicalName);
+}
+
+// src/tools/result.ts
+var TOOL_RESULT_MAX_BYTES = 50 * 1024;
+var READ_EMPTY_FILE_NOTICE = "[Empty file: 0 lines.]";
+function toolOutputDirectory() {
+  return join(resolveBookHome(), "tool-output");
+}
+function presentationFor(content, override) {
+  return {
+    kind: override?.kind ?? "text",
+    summary: override?.summary ?? content.split("\n")[0]?.trim() ?? "",
+    details: override?.details ?? content,
+    metadata: override?.metadata,
+    target: override?.target
+  };
+}
+function toolSuccess(content, options = {}) {
+  return {
+    version: 2,
+    toolCallId: options.toolCallId ?? "",
+    status: "success",
+    content,
+    data: options.data,
+    presentation: options.presentation ? presentationFor(content, options.presentation) : void 0,
+    artifacts: options.artifacts,
+    pagination: options.pagination
+  };
+}
+function toolFailure(message, options = {}) {
+  const error = {
+    code: options.code ?? "tool_error",
+    message,
+    retryable: options.retryable ?? false,
+    remediation: options.remediation,
+    details: options.details
+  };
+  const content = options.content ?? "";
+  return {
+    version: 2,
+    toolCallId: options.toolCallId ?? "",
+    status: options.status ?? "error",
+    content,
+    data: options.data,
+    structuredError: error,
+    presentation: options.presentation ? presentationFor(message, {
+      summary: message.split("\n")[0]?.trim(),
+      details: message,
+      ...options.presentation
+    }) : void 0,
+    artifacts: options.artifacts,
+    pagination: options.pagination
+  };
+}
+function toolResultSucceeded(result) {
+  return result.status === "success";
+}
+function toolResultErrorMessage(result) {
+  return result.structuredError?.message;
+}
+function rawToolResultModelContent(result) {
+  const content = result.content;
+  if (toolResultSucceeded(result)) {
+    return content.trim().length === 0 ? "(no output)" : content;
+  }
+  const remediation = result.structuredError?.remediation;
+  const fix = remediation ? `
+Fix: ${remediation}` : "";
+  const detail = content ? `
+${content}` : "";
+  return `ERROR [${result.structuredError?.code ?? result.status}]: ${toolResultErrorMessage(result) ?? "tool failed"}${fix}${detail}`;
+}
+function toolResultModelContent(result) {
+  if (result.maskedPlaceholder !== void 0) return result.maskedPlaceholder;
+  const raw = rawToolResultModelContent(result);
+  if (Buffer.byteLength(raw) <= TOOL_RESULT_MAX_BYTES) return raw;
+  if (!toolResultSucceeded(result)) {
+    const prefix = `ERROR [${result.structuredError?.code ?? result.status}]: `;
+    const fix = result.structuredError?.remediation ? `
+Fix: ${result.structuredError.remediation}` : "";
+    const budget = Math.max(
+      1,
+      TOOL_RESULT_MAX_BYTES - Buffer.byteLength(prefix) - Buffer.byteLength(fix)
+    );
+    return `${prefix}${headTailPreview(failureText(result), result.artifacts?.outputPath, budget)}${fix}`;
+  }
+  return clippedOutputPreview(raw, result.artifacts?.outputPath, TOOL_RESULT_MAX_BYTES);
+}
+function utf8Prefix(text, maxBytes) {
+  if (maxBytes <= 0) return "";
+  const bytes = Buffer.from(text);
+  if (bytes.byteLength <= maxBytes) return text;
+  return bytes.subarray(0, maxBytes).toString("utf8").replace(/\uFFFD$/u, "");
+}
+function utf8Suffix(text, maxBytes) {
+  if (maxBytes <= 0) return "";
+  const bytes = Buffer.from(text);
+  if (bytes.byteLength <= maxBytes) return text;
+  let start = bytes.byteLength - maxBytes;
+  while (start < bytes.byteLength && (bytes[start] & 192) === 128) start++;
+  return bytes.subarray(start).toString("utf8");
+}
+var FAILURE_HEAD_MAX_BYTES = 8 * 1024;
+function failureText(result) {
+  const message = toolResultErrorMessage(result) ?? "tool failed";
+  return result.content ? `${message}
+${result.content}` : message;
+}
+function headTailPreview(text, outputPath, maxBytes) {
+  const totalBytes = Buffer.byteLength(text);
+  const headWindow = Math.min(FAILURE_HEAD_MAX_BYTES, Math.floor(maxBytes * 0.2));
+  const window = utf8Prefix(text, headWindow);
+  if (Buffer.byteLength(window) >= totalBytes) return text;
+  const lastBreak = window.lastIndexOf("\n");
+  const head = lastBreak >= 0 ? window.slice(0, lastBreak + 1) : window;
+  const headShown = head.trimEnd();
+  const headBytes = Buffer.byteLength(headShown);
+  const omittedNotice = (omitted) => outputPath ? `[... ${omitted} bytes omitted. Full output: ${outputPath}]` : `[... ${omitted} bytes omitted. Full output unavailable.]`;
+  const reserve = Buffer.byteLength(omittedNotice(totalBytes)) + 2;
+  const tailRoom = maxBytes - headBytes - reserve;
+  if (tailRoom <= 0) return [headShown, omittedNotice(totalBytes - headBytes)].join("\n");
+  const tailWindow = utf8Suffix(text, tailRoom);
+  const breakAt = tailWindow.indexOf("\n");
+  const tail = breakAt >= 0 ? tailWindow.slice(breakAt + 1) : tailWindow;
+  const notice = omittedNotice(totalBytes - headBytes - Buffer.byteLength(tail));
+  return [headShown, notice, tail].join("\n");
+}
+function clippedOutputPreview(content, outputPath, maxBytes) {
+  const notice = outputPath ? `
+
+[Output truncated at ${maxBytes} bytes. Full output: ${outputPath}]` : `
+
+[Output truncated at ${maxBytes} bytes. Full output unavailable.]`;
+  const previewBudget = Math.max(0, maxBytes - Buffer.byteLength(notice));
+  return `${utf8Prefix(content, previewBudget).trimEnd()}${notice}`;
+}
+async function boundToolResultOutput(input, _workspaceRoot, maxBytes = TOOL_RESULT_MAX_BYTES, artifactRoot) {
+  const result = normalizeToolResult(input);
+  const modelContent = rawToolResultModelContent(result);
+  const modelContentBytes = Buffer.byteLength(modelContent);
+  const contentBytes = Buffer.byteLength(result.content);
+  const details = result.presentation?.details;
+  const detailsBytes = details === void 0 ? 0 : Buffer.byteLength(details);
+  if (modelContentBytes <= maxBytes && detailsBytes <= maxBytes) return result;
+  let outputPath = result.artifacts?.outputPath;
+  if (!outputPath) {
+    const outputFile = join(artifactRoot ?? toolOutputDirectory(), `${crypto.randomUUID()}.txt`);
+    try {
+      await mkdir(dirname(outputFile), { recursive: true });
+      await writeFile(
+        outputFile,
+        detailsBytes > modelContentBytes && details ? details : modelContent,
+        "utf8"
+      );
+      outputPath = outputFile.replace(/\\/g, "/");
+    } catch {
+    }
+  }
+  const modelOverflow = modelContentBytes > maxBytes;
+  const content = toolResultSucceeded(result) ? contentBytes > maxBytes ? clippedOutputPreview(result.content, outputPath, maxBytes) : result.content : modelOverflow ? "" : result.content;
+  const errorPrefix = `ERROR [${result.structuredError?.code ?? result.status}]: `;
+  const fixReserve = result.structuredError?.remediation ? Buffer.byteLength(`
+Fix: ${result.structuredError.remediation}`) : 0;
+  const errorBudget = Math.max(1, maxBytes - Buffer.byteLength(errorPrefix) - fixReserve);
+  const structuredError = result.structuredError ? {
+    ...result.structuredError,
+    // The message and the output are clipped as one text, so a failure
+    // keeps both ends: the error line and any framing at the top, and the
+    // verdict at the bottom. The room the `Fix:` line needs is reserved
+    // above, so the remediation is never what gets clipped.
+    message: modelOverflow ? headTailPreview(failureText(result), outputPath, errorBudget) : result.structuredError.message
+  } : result.structuredError;
+  const clippedDetails = details ? detailsBytes > maxBytes ? (
+    // The transcript row reads the same way the model does: a failure's
+    // head and tail, not one end of it — the same reason as above.
+    toolResultSucceeded(result) ? clippedOutputPreview(details, outputPath, maxBytes) : headTailPreview(details, outputPath, maxBytes)
+  ) : details : toolResultSucceeded(result) ? content : structuredError?.message;
+  return {
+    ...result,
+    content,
+    structuredError,
+    presentation: result.presentation ? { ...result.presentation, details: clippedDetails } : result.presentation,
+    artifacts: outputPath ? { ...result.artifacts, outputPath } : result.artifacts,
+    pagination: {
+      ...result.pagination,
+      truncated: true,
+      omittedBytes: Math.max(
+        result.pagination?.omittedBytes ?? 0,
+        Math.max(modelContentBytes, contentBytes, detailsBytes) - maxBytes
+      )
+    }
+  };
+}
+function replaceToolResult(result, patch) {
+  const status = patch.status ?? result.status;
+  const content = patch.content ?? result.content;
+  return {
+    ...result,
+    status,
+    content,
+    // New content replaces what the model read: a placeholder standing in for
+    // the previous text would hide the rewrite (a PostToolUse hook's
+    // `modifiedOutput`, the plan-approval note) behind the line the tool wrote.
+    ...patch.content !== void 0 ? { maskedPlaceholder: void 0 } : {},
+    structuredError: patch.error ?? (status === "success" ? void 0 : result.structuredError),
+    presentation: result.presentation || patch.presentation ? presentationFor(content, {
+      ...result.presentation,
+      ...patch.presentation
+    }) : void 0
+  };
+}
+function normalizeToolResult(result) {
+  const legacy = result;
+  const legacySuccess = legacy.success;
+  const legacyError = typeof legacy.error === "string" ? legacy.error : void 0;
+  const status = result.status ? result.status : legacySuccess ? "success" : legacyError?.startsWith("SKIPPED") ? "blocked" : legacyError?.startsWith("CANCELLED") ? "cancelled" : legacyError?.startsWith("Tool timeout") ? "timed_out" : "error";
+  const content = result.content ?? legacy.output ?? "";
+  const error = status === "success" ? void 0 : {
+    ...result.structuredError ?? {},
+    code: result.structuredError?.code ?? (status === "blocked" ? "blocked" : status),
+    message: legacyError ?? result.structuredError?.message ?? "Tool failed",
+    retryable: result.structuredError?.retryable ?? status === "timed_out"
+  };
+  const artifacts = result.artifacts ?? (legacy.fileMutation || legacy.fileMutations || legacy.fileObservations || legacy.eventRef || legacy.outputPath ? {
+    fileMutation: legacy.fileMutation,
+    fileMutations: legacy.fileMutations,
+    fileObservations: legacy.fileObservations,
+    eventRef: legacy.eventRef,
+    outputPath: legacy.outputPath
+  } : void 0);
+  const metrics = result.metrics ?? (legacy.durationMs !== void 0 || legacy.retryAttempt !== void 0 ? { durationMs: legacy.durationMs, retryAttempt: legacy.retryAttempt } : void 0);
+  return {
+    version: 2,
+    toolCallId: result.toolCallId,
+    status,
+    content,
+    // Masking's placeholder survives a resume, or a restored compaction's tail
+    // would come back at full size.
+    ..."maskedPlaceholder" in result && result.maskedPlaceholder !== void 0 ? { maskedPlaceholder: result.maskedPlaceholder } : {},
+    data: result.data,
+    structuredError: error,
+    presentation: result.presentation,
+    artifacts,
+    metrics,
+    pagination: result.pagination
+  };
+}
+function nonEmptyLines(content) {
+  return content.split("\n").filter((line) => line.trim()).length;
+}
+function readLineMetadata(start, count) {
+  const first = Math.max(1, Math.floor(start));
+  const lines = Math.max(0, Math.floor(count));
+  if (lines <= 0) return ["empty"];
+  const size = lines === 1 ? "1 line" : `${lines} lines`;
+  return first > 1 ? [size, `${first}-${first + lines - 1}`] : [size];
+}
+function readResultMetadata(args, content) {
+  if (args.outline === true) {
+    const entries = content.split("\n").filter((line) => /^\d+: /.test(line)).length;
+    return ["outline", entries === 1 ? "1 entry" : `${entries} entries`];
+  }
+  let body = content === READ_EMPTY_FILE_NOTICE ? "" : content.replace(/\n\[Lines? \d[^\n]*\]$/, "");
+  if (body === content) body = body.replace(/(?:^|\n)\d+: $/, "");
+  const lineCount = body ? body.split("\n").length : 0;
+  const offset = Number(args.offset ?? 0);
+  const start = Number.isFinite(offset) && offset > 0 ? Math.floor(offset) : 1;
+  return readLineMetadata(start, lineCount);
+}
+function grepResultMetadata(args, content) {
+  const noun = args.output_mode === "files_with_matches" ? "file" : "match";
+  if (/^No matches found$/i.test(content.trim()))
+    return `0 ${noun === "file" ? "files" : "matches"}`;
+  const lines = content.split("\n");
+  let count;
+  if (noun === "file") count = lines.filter((line) => line.trim()).length;
+  else if (args.output_mode === "count") {
+    count = lines.reduce((total, line) => total + (Number(/:(\d+)\s*$/.exec(line)?.[1]) || 0), 0);
+  } else count = lines.filter((line) => /:\d+:/.test(line)).length || nonEmptyLines(content);
+  return `${count} ${count === 1 ? noun : noun === "file" ? "files" : "matches"}`;
+}
+function enrichToolResultPresentation(input, toolName, args) {
+  const result = normalizeToolResult(input);
+  const name = canonicalToolName(toolName);
+  const content = result.content;
+  const explicitPresentation = result.presentation;
+  const target = explicitPresentation?.target ?? (getPrimaryArg(args) || void 0);
+  const metadata = explicitPresentation?.metadata ? [...explicitPresentation.metadata] : [];
+  const inferKind = explicitPresentation?.kind === void 0;
+  const inferSummary = explicitPresentation?.summary === void 0;
+  const inferMetadata = explicitPresentation?.metadata === void 0;
+  let kind = explicitPresentation?.kind ?? "text";
+  let summary = explicitPresentation?.summary ?? content.split("\n")[0]?.trim() ?? "";
+  if (isFileMutatingTool(name)) {
+    if (inferKind) {
+      kind = result.artifacts?.fileMutation ? "file" : /^@@/m.test(content) ? "diff" : "file";
+    }
+    const mutation = result.artifacts?.fileMutation ?? result.artifacts?.fileMutations?.[0];
+    if (mutation) {
+      if (inferMetadata) {
+        if (mutation.addedLines) metadata.push(`+${mutation.addedLines}`);
+        if (mutation.removedLines) metadata.push(`-${mutation.removedLines}`);
+        if (!mutation.addedLines && !mutation.removedLines) metadata.push("no changes");
+      }
+      if (inferSummary) {
+        summary = `${mutation.kind === "create" ? "Created" : mutation.kind === "delete" ? "Deleted" : "Updated"} ${mutation.filePath}`;
+      }
+    }
+  } else if (name === "Read") {
+    if (inferKind) kind = "file";
+    if (inferMetadata && result.status === "success")
+      metadata.push(...readResultMetadata(args, content));
+    if (inferSummary) summary = target ? `Read ${target}` : summary;
+  } else if (name === "Glob") {
+    if (inferKind) kind = "search";
+    const count = /^(?:No files found|No matches found)$/i.test(content.trim()) ? 0 : nonEmptyLines(content.replace(/\n\.\.\. \(truncated[\s\S]*$/, ""));
+    if (inferMetadata) metadata.push(`${count} ${count === 1 ? "file" : "files"}`);
+    if (inferSummary) summary = `Found ${count} ${count === 1 ? "file" : "files"}`;
+  } else if (name === "Grep") {
+    if (inferKind) kind = "search";
+    if (result.status === "success") {
+      const label = grepResultMetadata(args, content);
+      if (inferMetadata) metadata.push(label);
+      if (inferSummary) summary = `Found ${label}`;
+    }
+  } else if (name === "Bash" || name === "BashOutput" || name === "KillShell") {
+    if (inferKind) kind = "command";
+    if (inferSummary) summary = target ? `${name}: ${target}` : summary;
+  } else if (name === "GitDiff") {
+    if (inferKind) kind = "diff";
+  } else if (name.startsWith("Web") || name === "ToolSearch" || name.startsWith("SessionHistory")) {
+    if (inferKind) kind = name === "ToolSearch" ? "search" : "markdown";
+  } else if (name.startsWith("Task") || name === "TodoWrite") {
+    if (inferKind) kind = "task";
+  } else if (name.startsWith("Agent") || name.startsWith("Evidence")) {
+    if (inferKind) kind = "agent";
+  }
+  return {
+    ...result,
+    presentation: {
+      kind,
+      summary,
+      details: explicitPresentation?.details ?? content,
+      metadata,
+      target: explicitPresentation?.target ?? result.artifacts?.fileMutation?.filePath ?? target
+    }
+  };
+}
+
+// src/tools/path-utils.ts
+import { existsSync, lstatSync, realpathSync } from "fs";
+import { basename, dirname as dirname2, isAbsolute, join as join2, relative, resolve, sep } from "path";
+var REAL_PATH_COMPARISON = { relative, isAbsolute, sep };
+function isOutside(root, candidate, path = REAL_PATH_COMPARISON) {
+  const rel = path.relative(root, candidate);
+  return rel === ".." || rel.startsWith(`..${path.sep}`) || path.isAbsolute(rel);
+}
+function nearestExistingPath(inputPath) {
+  let candidate = inputPath;
+  while (!existsSync(candidate)) {
+    const parent = dirname2(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));
+  const canonicalRoot = canonicalizePath(lexicalRoot);
+  const canonicalPath = canonicalizePath(filePath);
+  if (isOutside(canonicalRoot, canonicalPath)) return null;
+  const asWrittenInside = !isOutside(lexicalRoot, filePath);
+  const rel = asWrittenInside ? relative(lexicalRoot, filePath) : relative(canonicalRoot, canonicalPath);
+  return { filePath, canonicalPath, relativePath: rel.replace(/\\/g, "/") };
+}
+function resolveReadablePathDetail(context, inputPath) {
+  const wsMatch = resolveWorkspacePath(context.workspaceRoot, inputPath);
+  if (wsMatch) {
+    return { path: { ...wsMatch, root: context.workspaceRoot, inWorkspace: true } };
+  }
+  if (!isAbsolute(inputPath)) return { reason: "unreachable" };
+  for (const root of [...context.readOnlyRoots ?? [], ...context.additionalRoots ?? []]) {
+    const match = resolveWorkspacePath(root, inputPath);
+    if (match) return { path: { ...match, root, inWorkspace: false } };
+  }
+  const memory = context.memorySearchRoot ? resolveMemorySearchPath(context.memorySearchRoot, inputPath) : null;
+  return memory ? { path: memory } : { reason: "unreachable" };
+}
+function resolveMemorySearchPath(memoryRoot, inputPath) {
+  const match = resolveWorkspacePath(memoryRoot, inputPath);
+  if (!match) return null;
+  const fromRoot = relative(canonicalizePath(resolve(memoryRoot)), match.canonicalPath);
+  const segments = [...match.relativePath.split("/"), ...fromRoot.split(sep)];
+  if (segments.some((segment) => segment.startsWith(".") && segment !== "." && segment !== "..")) {
+    return null;
+  }
+  return { ...match, root: memoryRoot, inWorkspace: false };
+}
+function resolveMentionReadablePath(roots, absolutePath) {
+  if (reachesUncPath(absolutePath)) return { reason: "unc" };
+  return resolveReadablePathDetail(
+    { workspaceRoot: roots.workspaceRoot, additionalRoots: roots.additionalRoots },
+    absolutePath
+  );
+}
+function resolveReadablePath(context, inputPath) {
+  const detail = resolveReadablePathDetail(context, inputPath);
+  return "path" in detail ? detail.path : null;
+}
+function resolveMutationPath(context, inputPath) {
+  const memory = context.memoryWrite ? resolveMemoryWritePath(context.workspaceRoot, context.memoryWrite.root, inputPath) : null;
+  if (memory) return memory;
+  const inWorkspace = resolveWorkspacePath(context.workspaceRoot, inputPath);
+  if (inWorkspace) return { ...inWorkspace, root: context.workspaceRoot, inWorkspace: true };
+  if (!isAbsolute(inputPath)) return null;
+  for (const root of context.additionalRoots ?? []) {
+    const match = resolveWorkspacePath(root, inputPath);
+    if (!match) continue;
+    const rel = relative(resolve(context.workspaceRoot), match.filePath);
+    return { ...match, relativePath: rel.replace(/\\/g, "/"), root, inWorkspace: false };
+  }
+  return null;
+}
+function hasLinkBelow(root, filePath) {
+  let current = root;
+  for (const segment of relative(root, filePath).split(sep)) {
+    current = join2(current, segment);
+    try {
+      if (lstatSync(current).isSymbolicLink()) return true;
+    } catch (error) {
+      const code = error.code;
+      if (code === "ENOENT" || code === "ENOTDIR") return false;
+      return true;
+    }
+  }
+  return false;
+}
+function resolveMemoryWritePath(workspaceRoot, memoryRoot, inputPath) {
+  if (!isAbsolute(inputPath)) return null;
+  const filePath = resolve(inputPath);
+  if (!basename(filePath).toLowerCase().endsWith(".md")) return null;
+  const lexicalRoot = resolve(memoryRoot);
+  const canonicalRoot = canonicalizePath(lexicalRoot);
+  const canonicalPath = canonicalizePath(filePath);
+  if (canonicalPath === canonicalRoot || isOutside(canonicalRoot, canonicalPath)) return null;
+  const writtenRoot = [lexicalRoot, canonicalRoot].find((root) => !isOutside(root, filePath));
+  if (!writtenRoot) return null;
+  const below = relative(writtenRoot, filePath).split(sep);
+  if (below.some((segment) => segment.startsWith("."))) return null;
+  if (relative(canonicalRoot, canonicalPath).split(sep).some((s) => s.startsWith(".")))
+    return null;
+  if (hasLinkBelow(writtenRoot, filePath)) return null;
+  const rel = relative(resolve(workspaceRoot), filePath);
+  return {
+    filePath,
+    canonicalPath,
+    relativePath: rel.replace(/\\/g, "/"),
+    root: memoryRoot,
+    inWorkspace: false,
+    memory: true
+  };
+}
+function mutationDisplayPath(resolved) {
+  if (!resolved.memory) return resolved.relativePath;
+  return memoryDisplayName(resolved.root, resolved.canonicalPath);
+}
+function memoryDisplayName(memoryRoot, canonicalPath) {
+  const below = relative(canonicalizePath(resolve(memoryRoot)), canonicalPath);
+  return `memory/${below.split(sep).join("/")}`;
+}
+function memoryReadDisplayPath(roots, resolved) {
+  const memoryRoot = roots.memorySearchRoot ?? roots.memoryWrite?.root;
+  if (!memoryRoot) return void 0;
+  const canonicalRoot = canonicalizePath(resolve(memoryRoot));
+  if (resolved.canonicalPath === canonicalRoot || isOutside(canonicalRoot, resolved.canonicalPath)) {
+    return void 0;
+  }
+  return memoryDisplayName(memoryRoot, resolved.canonicalPath);
+}
+function messagePathFor(resolved) {
+  return resolved.memory ? resolved.filePath : resolved.relativePath;
+}
+function pathOutsideWorkspaceResult(inputPath) {
+  return toolFailure(`Path outside workspace and additionalDirectories: ${inputPath}`, {
+    code: "path_outside_workspace",
+    remediation: "Add its directory to additionalDirectories, or start Book in a directory that contains it. No permission rule and no permission mode can change which roots a read may cross."
+  });
+}
+function realWorkspaceRoot(root) {
+  try {
+    return realpathSync.native(root);
+  } catch {
+    return resolve(root);
+  }
+}
+function canonicalizePath(inputPath) {
+  const absolute = resolve(inputPath);
+  const existing = nearestExistingPath(absolute);
+  if (!existing) return absolute;
+  try {
+    return resolve(realpathSync.native(existing), relative(existing, absolute));
+  } catch {
+    return absolute;
+  }
+}
+function isUnderRoot(canonicalPath, root) {
+  return !isOutside(canonicalizePath(root), canonicalPath);
+}
+function comparablePath(value, platform = process.platform) {
+  if (platform !== "win32") return value;
+  return value.replaceAll("\\", "/").toLowerCase();
+}
+function hasBookLocalSettingsShape(canonicalPath, options) {
+  const parts = canonicalPath.toLowerCase().split(/[\\/]/);
+  if (parts[parts.length - 1] === ".book") return options.directory === true;
+  return parts[parts.length - 2] === ".book" && parts[parts.length - 1] === "settings.local.json";
+}
+function isBookLocalSettingsPath(path, root, options = {}) {
+  if (!hasBookLocalSettingsShape(path, options)) return false;
+  const target = canonicalizePath(path).toLowerCase();
+  const bookDir = join2(canonicalizePath(root), ".book").toLowerCase();
+  return target === join2(bookDir, "settings.local.json") || options.directory === true && target === bookDir;
+}
+function isBookLocalSettingsUnderRoots(path, roots, options = {}) {
+  if (!hasBookLocalSettingsShape(path, options)) return false;
+  return [
+    roots.workspaceRoot,
+    ...roots.readOnlyRoots ?? [],
+    ...roots.additionalRoots ?? []
+  ].some((root) => isBookLocalSettingsPath(path, root, options));
+}
+
+export {
+  TOOL_ALIASES,
+  canonicalToolName,
+  unwrapProviderPrefix,
+  displayToolName,
+  getPrimaryArg,
+  isFileMutatingTool,
+  TOOL_RESULT_MAX_BYTES,
+  READ_EMPTY_FILE_NOTICE,
+  toolSuccess,
+  toolFailure,
+  toolResultSucceeded,
+  toolResultErrorMessage,
+  toolResultModelContent,
+  utf8Prefix,
+  boundToolResultOutput,
+  replaceToolResult,
+  normalizeToolResult,
+  readLineMetadata,
+  readResultMetadata,
+  grepResultMetadata,
+  enrichToolResultPresentation,
+  isOutside,
+  resolveWorkspacePath,
+  resolveReadablePathDetail,
+  resolveMentionReadablePath,
+  resolveReadablePath,
+  resolveMutationPath,
+  mutationDisplayPath,
+  memoryReadDisplayPath,
+  messagePathFor,
+  pathOutsideWorkspaceResult,
+  realWorkspaceRoot,
+  canonicalizePath,
+  isUnderRoot,
+  comparablePath,
+  isBookLocalSettingsPath,
+  isBookLocalSettingsUnderRoots
+};
+//# sourceMappingURL=chunk-YIL6HTJX.js.map