token-goat 2.9.29 → 2.9.31

package/dist/{token-goat-chunk-52NSDWYY.mjs → token-goat-chunk-BFCWY73P.mjs}

@@ -1,13 +1,22 @@
 import { createRequire as __cjsRequire } from 'node:module';
 const require = __cjsRequire(import.meta.url);
 import {
+  forClient
+} from "./token-goat-chunk-KGEFFSHD.mjs";
+import {
+  GUARD_UNITS_PER_TOKEN,
+  TEXT_GUARD_UNITS,
   classifyContent,
   guardDivisor,
+  guardTokens,
+  guardUnits
+} from "./token-goat-chunk-XX6O25RN.mjs";
+import {
   stripAnsiEscapes
-} from "./token-goat-chunk-CIQ2FTY3.mjs";
+} from "./token-goat-chunk-HAVAOB3S.mjs";
 import {
   safeSlice
-} from "./token-goat-chunk-XYWPOSCN.mjs";
+} from "./token-goat-chunk-HU4TORC5.mjs";
 import {
   init_define_import_meta_env
 } from "./token-goat-chunk-A37V4PBF.mjs";
@@ -19,50 +28,77 @@ function estimateTokensFromLength(length, cls = "text") {
 }
 function estimateTokens(text) {
   const stripped = stripAnsiEscapes(text);
-  return estimateTokensFromLength(stripped.length, classifyContent(stripped));
+  return Math.max(1, Math.floor(guardTokens(stripped, classifyContent(stripped) === "dense")) + 1);
+}
+function sliceToGuardTokens(text, tokens, dense) {
+  let used = 0;
+  let end = 0;
+  for (const ch of text) {
+    used += guardTokens(ch, dense);
+    if (used > tokens) break;
+    end += ch.length;
+  }
+  return safeSlice(text, end);
 }
-function trimToBudget(text, budgetTokens, command) {
+function sliceToEstimatedTokens(text, maxTokens) {
+  if (estimateTokens(text) <= maxTokens) return text;
+  let lo = 0;
+  let hi = text.length;
+  while (lo < hi) {
+    const mid = Math.ceil((lo + hi) / 2);
+    if (estimateTokens(safeSlice(text, mid)) <= maxTokens) lo = mid;
+    else hi = mid - 1;
+  }
+  return safeSlice(text, lo);
+}
+var CAP_MARKER_PREFIX = "[token-goat: output capped at ~";
+var JSON_CUT_FLAG = /"truncated"\s*:\s*true\b/;
+function isCappedOutput(text) {
+  return text.includes(CAP_MARKER_PREFIX) || JSON_CUT_FLAG.test(text);
+}
+function trimToBudget(text, budgetTokens, command, opts = {}) {
   const markerMarginTokens = 64;
+  const reserve = Math.max(0, opts.reserveTokens ?? 0);
   const strippedAll = stripAnsiEscapes(text);
-  const contentClass = classifyContent(strippedAll);
-  const totalTokens = estimateTokensFromLength(strippedAll.length, contentClass);
-  if (totalTokens <= budgetTokens) {
+  const dense = classifyContent(strippedAll) === "dense";
+  const totalTokens = Math.max(1, Math.floor(guardTokens(strippedAll, dense)) + 1);
+  if (totalTokens <= budgetTokens - reserve) {
     return text;
   }
   const lines = text.split("\n");
   if (lines.length > 1 && lines[lines.length - 1] === "") lines.pop();
   const totalLines = lines.length;
-  const bodyBudget = Math.max(1, budgetTokens - markerMarginTokens);
-  const charBudget = bodyBudget * guardDivisor(contentClass);
+  const bodyBudget = Math.max(1, budgetTokens - markerMarginTokens - reserve);
   const kept = [];
-  let used = 0;
+  let usedTokens = 0;
   for (const ln of lines) {
     const stripped = stripAnsiEscapes(ln);
-    const cost = ln.length + 1;
-    if (kept.length === 0 && cost > charBudget) {
-      const truncated = safeSlice(stripped, charBudget);
+    const costTokens = guardTokens(`${ln}
+`, dense);
+    if (kept.length === 0 && costTokens > bodyBudget) {
+      const truncated = sliceToGuardTokens(stripped, bodyBudget, dense);
       kept.push(truncated);
       break;
     }
-    if (kept.length > 0 && used + cost > charBudget) {
+    if (kept.length > 0 && usedTokens + costTokens > bodyBudget) {
       break;
     }
     kept.push(ln);
-    used += cost;
+    usedTokens += costTokens;
   }
   const shown = kept.length;
   const hint = getHintFor(command);
-  const marker = `[token-goat: output capped at ~${budgetTokens} tokens to protect context \u2014 showing ${shown} of ${totalLines} lines. ${hint}]`;
-  return kept.join("\n") + "\n" + marker;
+  const marker = `${CAP_MARKER_PREFIX}${budgetTokens} tokens to protect context \u2014 showing ${shown} of ${totalLines} lines. ${hint}]`;
+  return kept.join("\n") + "\n" + forClient(marker);
 }
 function capJsonRows(items, budgetTokens) {
   const totalCount = items.length;
-  const charBudget = Math.max(1, budgetTokens * guardDivisor());
+  const budget = Math.max(TEXT_GUARD_UNITS, budgetTokens * GUARD_UNITS_PER_TOKEN);
   const kept = [];
   let used = 0;
   for (const item of items) {
-    const cost = JSON.stringify(item).length + 2;
-    if (kept.length > 0 && used + cost > charBudget) break;
+    const cost = guardUnits(JSON.stringify(item)) + 2 * TEXT_GUARD_UNITS;
+    if (kept.length > 0 && used + cost > budget) break;
     kept.push(item);
     used += cost;
   }
@@ -91,6 +127,8 @@ function getHintFor(command) {
 export {
   estimateTokensFromLength,
   estimateTokens,
+  sliceToEstimatedTokens,
+  isCappedOutput,
   trimToBudget,
   capJsonRows
 };

package/dist/token-goat-chunk-BPGCUMR7.mjs

@@ -0,0 +1,30 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/claude_config_dir.ts
+init_define_import_meta_env();
+import * as os from "node:os";
+import * as path from "node:path";
+function claudeConfigDir(homeDir = os.homedir()) {
+  const override = process.env["CLAUDE_CONFIG_DIR"];
+  if (override !== void 0 && override !== "") return override;
+  return path.join(homeDir, ".claude");
+}
+function claudeGlobalJsonPath(homeDir = os.homedir()) {
+  const override = process.env["CLAUDE_CONFIG_DIR"];
+  return path.join(override !== void 0 && override !== "" ? override : homeDir, ".claude.json");
+}
+function projectTranscriptsDir(projectRoot) {
+  const rootStr = path.resolve(projectRoot);
+  const slug = rootStr.replace(/[^A-Za-z0-9]/g, "-");
+  return path.join(claudeConfigDir(), "projects", slug);
+}
+
+export {
+  claudeConfigDir,
+  claudeGlobalJsonPath,
+  projectTranscriptsDir
+};

package/dist/token-goat-chunk-BWGFUZZE.mjs

@@ -0,0 +1,25 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  docxOutline,
+  docxTables,
+  docxText,
+  formatDocxTables
+} from "./token-goat-chunk-YB4VMGK2.mjs";
+import "./token-goat-chunk-2M7E4PF7.mjs";
+import "./token-goat-chunk-E45INMY3.mjs";
+import "./token-goat-chunk-EDBDRVH5.mjs";
+import "./token-goat-chunk-AH6QILZM.mjs";
+import "./token-goat-chunk-Y4AFKTHK.mjs";
+import "./token-goat-chunk-HU4TORC5.mjs";
+import "./token-goat-chunk-GGGG7RWB.mjs";
+import "./token-goat-chunk-AM5V6GSX.mjs";
+import "./token-goat-chunk-FNFBKLRD.mjs";
+import "./token-goat-chunk-CO3UYX6G.mjs";
+import "./token-goat-chunk-A37V4PBF.mjs";
+export {
+  docxOutline,
+  docxTables,
+  docxText,
+  formatDocxTables
+};

package/dist/token-goat-chunk-C75NA7PL.mjs

@@ -0,0 +1,322 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  ANTIGRAVITY_TOOL_NAME_KEY,
+  BODY_FIRST_TOOL_RESPONSE_KEYS,
+  OUTPUT_FIRST_TOOL_RESPONSE_KEYS,
+  VSCODE_TOOL_NAME_KEY,
+  antigravityNativeToolInput,
+  foldToolName,
+  replaceToolResponseField,
+  vscodeNativeToolInput
+} from "./token-goat-chunk-76FGDLRO.mjs";
+import {
+  recordUnmappedTool
+} from "./token-goat-chunk-U4WHMG6Y.mjs";
+import {
+  registerReset
+} from "./token-goat-chunk-YZAAZU2S.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/hook_registry.ts
+init_define_import_meta_env();
+
+// src/bridges/vscode_hooks.ts
+init_define_import_meta_env();
+import * as crypto from "node:crypto";
+import * as fs2 from "node:fs";
+import * as os2 from "node:os";
+import * as path2 from "node:path";
+
+// src/shrink_temp_copies.ts
+init_define_import_meta_env();
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+var SHRINK_COPY_PREFIX = "token-goat-shrink-";
+var SHRINK_COPY_MAX_AGE_MS = 60 * 60 * 1e3;
+function sweepStaleShrinkCopies(now = Date.now(), dir = os.tmpdir()) {
+  let removed = 0;
+  let names;
+  try {
+    names = fs.readdirSync(dir);
+  } catch {
+    return 0;
+  }
+  for (const name of names) {
+    if (!name.startsWith(SHRINK_COPY_PREFIX)) continue;
+    const full = path.join(dir, name);
+    try {
+      const st = fs.statSync(full);
+      if (st.isFile() && now - st.mtimeMs > SHRINK_COPY_MAX_AGE_MS) {
+        fs.unlinkSync(full);
+        removed++;
+      }
+    } catch {
+    }
+  }
+  return removed;
+}
+
+// src/bridges/vscode_hooks.ts
+function vscodeToolName(event) {
+  const name = event?.raw[VSCODE_TOOL_NAME_KEY];
+  return typeof name === "string" ? name : void 0;
+}
+var lastMaterializedSweepAtMs = 0;
+function pruneMaterialized() {
+  const now = Date.now();
+  if (now - lastMaterializedSweepAtMs < SHRINK_COPY_MAX_AGE_MS) return;
+  lastMaterializedSweepAtMs = now;
+  sweepStaleShrinkCopies(now);
+}
+function materializeShrunkImageFile(context) {
+  const idx = context.indexOf("data:image/");
+  if (idx === -1) return void 0;
+  const match = /^data:image\/([a-zA-Z0-9.+-]+);base64,([A-Za-z0-9+/=]+)$/.exec(context.slice(idx).trim());
+  if (!match) return void 0;
+  try {
+    pruneMaterialized();
+    const file = path2.join(os2.tmpdir(), `${SHRINK_COPY_PREFIX}${process.pid}-${Date.now()}-${crypto.randomUUID()}.${match[1]}`);
+    fs2.writeFileSync(file, Buffer.from(match[2], "base64"), { mode: 384 });
+    return file;
+  } catch {
+    return void 0;
+  }
+}
+function isShrunkImagePayload(eventName, context) {
+  return eventName === "pre_tool_use" && context.includes("data:image/");
+}
+var NESTED_DECISION_EVENTS = /* @__PURE__ */ new Set(["stop", "subagent_stop"]);
+function serializeVscodeOutput(output, eventName, hookEventName, event) {
+  switch (output.hookType) {
+    case "deny":
+      if (eventName === "pre_tool_use") {
+        return JSON.stringify({
+          hookSpecificOutput: { hookEventName, permissionDecision: "deny", permissionDecisionReason: output.message }
+        });
+      }
+      if (NESTED_DECISION_EVENTS.has(eventName)) {
+        return JSON.stringify({ hookSpecificOutput: { hookEventName, decision: "block", reason: output.message } });
+      }
+      return JSON.stringify({ decision: "block", reason: output.message });
+    case "context": {
+      if (NESTED_DECISION_EVENTS.has(eventName)) return "{}";
+      if (eventName === "pre_compact" || eventName === "notification") return JSON.stringify({ systemMessage: output.context });
+      if (isShrunkImagePayload(eventName, output.context)) return "{}";
+      return JSON.stringify({ hookSpecificOutput: { hookEventName, additionalContext: output.context } });
+    }
+    case "rewriteInput": {
+      const tool = vscodeToolName(event);
+      const updatedInput = tool === void 0 ? output.updatedInput : vscodeNativeToolInput(tool, output.updatedInput);
+      return JSON.stringify({ hookSpecificOutput: { hookEventName: "PreToolUse", updatedInput } });
+    }
+    case "rewriteOutput":
+      return "{}";
+    case "pass":
+      return "{}";
+  }
+}
+
+// src/bridges/antigravity_hooks.ts
+init_define_import_meta_env();
+function antigravityToolName(event) {
+  const name = event?.raw[ANTIGRAVITY_TOOL_NAME_KEY];
+  return typeof name === "string" ? name : void 0;
+}
+function serializeAntigravityOutput(output, eventName, event) {
+  if (eventName === "pre_tool_use") {
+    switch (output.hookType) {
+      case "deny":
+        return JSON.stringify({ decision: "deny", reason: output.message });
+      case "context":
+        if (output.context.includes("data:image/")) return "{}";
+        return JSON.stringify({ reason: output.context });
+      case "rewriteInput": {
+        const tool = antigravityToolName(event);
+        const overwrite = tool === void 0 ? output.updatedInput : antigravityNativeToolInput(tool, output.updatedInput);
+        return JSON.stringify({ overwrite });
+      }
+      default:
+        return "{}";
+    }
+  }
+  if (eventName === "post_tool_use" && output.hookType === "rewriteOutput" && typeof event?.raw["result"] === "string") {
+    return JSON.stringify({ overwriteResult: output.updatedOutput });
+  }
+  return "{}";
+}
+
+// src/hook_registry.ts
+function sessionStateKey(event) {
+  return event.agentId !== void 0 ? `${event.sessionId}:agent:${event.agentId}` : event.sessionId;
+}
+var _handlers = /* @__PURE__ */ new Map();
+function registerHook(eventName, handler, opts) {
+  let list = _handlers.get(eventName);
+  if (list === void 0) {
+    list = [];
+    _handlers.set(eventName, list);
+  }
+  list.push({
+    handler,
+    toolName: opts?.toolName,
+    toolPattern: opts?.toolPattern,
+    advisory: opts?.advisory === true,
+    followsMatcher: opts?.followsMatcher === true
+  });
+}
+function toolMatcherFor(eventName) {
+  const list = _handlers.get(eventName);
+  if (list === void 0 || list.length === 0) return null;
+  const parts = [];
+  for (const { toolName, toolPattern, followsMatcher } of list) {
+    if (followsMatcher) continue;
+    if (toolName === void 0 && toolPattern === void 0) return null;
+    for (const part of [toolName === void 0 ? void 0 : `^${toolName}$`, toolPattern]) {
+      if (part !== void 0 && part !== "" && !parts.includes(part)) parts.push(part);
+    }
+  }
+  if (parts.length === 0) return null;
+  return parts.join("|");
+}
+function noteUnrecognizedTool(event, list) {
+  const toolName = event.toolName;
+  if (typeof toolName !== "string" || toolName === "") return;
+  const named = [];
+  for (const { toolName: want, toolPattern } of list) {
+    if (toolPattern !== void 0) {
+      let matches = false;
+      try {
+        matches = new RegExp(toolPattern).test(toolName);
+      } catch {
+      }
+      if (matches) return;
+    }
+    if (want === void 0) continue;
+    if (want === toolName) return;
+    named.push(want);
+  }
+  if (named.length === 0) return;
+  const folded = foldToolName(toolName);
+  const nearMiss = named.find((n) => foldToolName(n) === folded) ?? null;
+  recordUnmappedTool(toolName, event.eventName, nearMiss);
+}
+async function runHook(event) {
+  const list = _handlers.get(event.eventName);
+  if (list === void 0) return { hookType: "pass" };
+  noteUnrecognizedTool(event, list);
+  let advisoryResult;
+  let noticeResult;
+  for (const { handler, toolName, advisory } of list) {
+    if (toolName !== void 0 && toolName !== event.toolName) continue;
+    let result;
+    try {
+      result = await handler(event);
+    } catch {
+      continue;
+    }
+    if (result.hookType !== "pass") {
+      if (advisory) {
+        advisoryResult = result;
+        continue;
+      }
+      return result;
+    }
+    if (result.notice !== void 0) noticeResult ??= result;
+  }
+  return advisoryResult ?? noticeResult ?? { hookType: "pass" };
+}
+function clearHooks() {
+  _handlers.clear();
+}
+registerReset(clearHooks);
+var CLAUDE_CODE_EVENT_NAMES = {
+  pre_tool_use: "PreToolUse",
+  post_tool_use: "PostToolUse",
+  notification: "Notification",
+  stop: "Stop",
+  pre_compact: "PreCompact",
+  post_compact: "PostCompact",
+  user_prompt_submit: "UserPromptSubmit",
+  subagent_stop: "SubagentStop",
+  // Wired for Copilot CLI (`subagentStart`) and VS Code (`SubagentStart`) only; hooks_agent_spawn.ts's subagentStartHandler answers it with the spawn briefing as additionalContext, which both harnesses read.
+  subagent_start: "SubagentStart",
+  session_start: "SessionStart",
+  // Claude Code sends a failed tool call here rather than to PostToolUse, and its PostToolUseFailure output schema accepts hookSpecificOutput.additionalContext (captured and read from claude.exe 2.1.281); install.ts HOOK_EVENT_MAP registers it.
+  post_tool_use_failure: "PostToolUseFailure"
+};
+var EVENTS_WITHOUT_ADDITIONAL_CONTEXT = /* @__PURE__ */ new Set([
+  "notification",
+  "pre_compact",
+  "stop"
+]);
+var EVENTS_WITH_RAW_STDOUT_CONTEXT = /* @__PURE__ */ new Set(["pre_compact"]);
+var BODY_FIRST_REWRITE_TOOLS = /* @__PURE__ */ new Set(["WebFetch", "Skill"]);
+function shapedUpdatedToolOutput(updatedOutput, harness, event) {
+  if (harness !== "claudecode") return updatedOutput;
+  const resp = event?.raw["tool_response"];
+  if (resp === null || resp === void 0 || typeof resp !== "object") return updatedOutput;
+  const keys = BODY_FIRST_REWRITE_TOOLS.has(event?.toolName ?? "") ? BODY_FIRST_TOOL_RESPONSE_KEYS : OUTPUT_FIRST_TOOL_RESPONSE_KEYS;
+  return replaceToolResponseField(resp, keys, updatedOutput) ?? updatedOutput;
+}
+function serializeOutput(output, eventName, harness, event) {
+  if (harness === "vscode") return serializeVscodeOutput(output, eventName, CLAUDE_CODE_EVENT_NAMES[eventName], event);
+  if (harness === "antigravity") return serializeAntigravityOutput(output, eventName, event);
+  switch (output.hookType) {
+    case "deny":
+      return JSON.stringify({ decision: "block", reason: output.message });
+    case "context":
+      if (EVENTS_WITH_RAW_STDOUT_CONTEXT.has(eventName) && harness === "claudecode") {
+        return output.context;
+      }
+      if (EVENTS_WITHOUT_ADDITIONAL_CONTEXT.has(eventName)) {
+        return JSON.stringify({ systemMessage: output.context });
+      }
+      if (harness === "claudecode" && isShrunkImagePayload(eventName, output.context)) {
+        return JSON.stringify(noticeField(output.notice, harness));
+      }
+      return JSON.stringify({
+        ...noticeField(output.notice, harness),
+        hookSpecificOutput: {
+          hookEventName: CLAUDE_CODE_EVENT_NAMES[eventName],
+          additionalContext: output.context
+        }
+      });
+    case "rewriteInput":
+      return JSON.stringify({
+        hookSpecificOutput: {
+          hookEventName: "PreToolUse",
+          // Claude Code matches its permission rules against updatedInput and skips the prompt on "allow", so it gets one only for a call rewrite_permission.ts proved auto-allowed. Codex applies updatedInput only beside "allow" ("Return updatedInput only with permissionDecision: allow", https://developers.openai.com/codex/hooks) and documents approval prompts as a separate PermissionRequest event, so there the field is the rewrite's required carrier. Every other harness gets none.
+          ...output.approve && harness === "claudecode" || harness === "codex" ? { permissionDecision: "allow" } : {},
+          updatedInput: output.updatedInput
+        }
+      });
+    case "rewriteOutput":
+      return JSON.stringify({
+        hookSpecificOutput: {
+          hookEventName: "PostToolUse",
+          // A block array is emitted only when the handler built one, and only for Claude Code: every other harness token-goat bridges to reads this field as a plain string into a text block of its own, so handing it an array there is the same mistake in the other direction. See HookOutput's `updatedBlocks` for the capture that proves Claude Code takes the array.
+          updatedToolOutput: output.updatedBlocks !== void 0 && harness === "claudecode" ? output.updatedBlocks : shapedUpdatedToolOutput(output.updatedOutput, harness, event),
+          ...output.context !== void 0 ? { additionalContext: output.context } : {}
+        }
+      });
+    case "pass":
+      return JSON.stringify(noticeField(output.notice, harness));
+  }
+}
+function noticeField(notice, harness) {
+  return notice !== void 0 && harness === "claudecode" ? { systemMessage: notice } : {};
+}
+
+export {
+  sweepStaleShrinkCopies,
+  materializeShrunkImageFile,
+  sessionStateKey,
+  registerHook,
+  toolMatcherFor,
+  runHook,
+  serializeOutput
+};

package/dist/token-goat-chunk-CBIQ7WTD.mjs

@@ -0,0 +1,87 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  extractErrorMessage
+} from "./token-goat-chunk-HU4TORC5.mjs";
+import {
+  displaySafeJson,
+  displaySafeText
+} from "./token-goat-chunk-FNFBKLRD.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/command_error.ts
+init_define_import_meta_env();
+var CliError = class extends Error {
+  lines;
+  constructor(message) {
+    super(typeof message === "string" ? message : message.join("\n"));
+    this.lines = typeof message === "string" ? void 0 : message;
+  }
+};
+var invocation = null;
+function setCliInvocation(argv) {
+  invocation = argv.slice(2);
+}
+function clearCliInvocation() {
+  invocation = null;
+}
+function cliInvocation() {
+  return invocation ?? process.argv.slice(2);
+}
+function formatCommandError(e) {
+  if (e instanceof CliError && e.lines !== void 0) return "token-goat: " + e.lines.map(displaySafeText).join("\n");
+  return "token-goat: " + displaySafeText(extractErrorMessage(e));
+}
+function formatGitFailure(command, stderr) {
+  if (/not a git repository/i.test(stderr)) return formatCommandError(new CliError(`git ${command} failed: not a git repository`));
+  const lines = [];
+  for (const line of stderr.trim().split(/\r?\n/)) {
+    if (/^usage:/i.test(line.trimStart())) break;
+    lines.push(line.trimEnd());
+  }
+  while (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
+  const [first, ...rest] = lines;
+  return formatCommandError(new CliError([`git ${command} failed: ${first ?? "git printed no error message"}`, ...rest]));
+}
+function formatParseError(str) {
+  const lines = (str.endsWith("\n") ? str.slice(0, -1) : str).split("\n");
+  if (lines[0].startsWith("error: ")) lines[0] = lines[0].slice("error: ".length);
+  return formatCommandError(new CliError(lines)) + "\n";
+}
+function formatFailedResultText(text) {
+  return isJsonBody(text) ? text : formatCommandError(new CliError(text.split("\n")));
+}
+function displaySafeFailureText(text) {
+  return isJsonBody(text) ? text : text.split("\n").map(displaySafeText).join("\n");
+}
+function isJsonBody(text) {
+  const head = text.trimStart()[0];
+  if (head !== "{" && head !== "[") return false;
+  try {
+    JSON.parse(text);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function writeCommandFailure(json, body, message) {
+  if (json) process.stdout.write(`${displaySafeJson(body, 0)}
+`);
+  else process.stderr.write(formatCommandError(new CliError(message)) + "\n");
+  process.exitCode = 1;
+}
+
+export {
+  CliError,
+  setCliInvocation,
+  clearCliInvocation,
+  cliInvocation,
+  formatCommandError,
+  formatGitFailure,
+  formatParseError,
+  formatFailedResultText,
+  displaySafeFailureText,
+  writeCommandFailure
+};