@dexto/tui 1.6.2

package/dist/utils/streamSplitter.js

@@ -0,0 +1,100 @@
+function isIndexInsideCodeBlock(content, indexToTest) {
+  let fenceCount = 0;
+  let searchPos = 0;
+  while (searchPos < content.length) {
+    const nextFence = content.indexOf("```", searchPos);
+    if (nextFence === -1 || nextFence >= indexToTest) {
+      break;
+    }
+    fenceCount++;
+    searchPos = nextFence + 3;
+  }
+  return fenceCount % 2 === 1;
+}
+function findEnclosingCodeBlockStart(content, index) {
+  if (!isIndexInsideCodeBlock(content, index)) {
+    return -1;
+  }
+  let currentSearchPos = 0;
+  while (currentSearchPos < index) {
+    const blockStartIndex = content.indexOf("```", currentSearchPos);
+    if (blockStartIndex === -1 || blockStartIndex >= index) {
+      break;
+    }
+    const blockEndIndex = content.indexOf("```", blockStartIndex + 3);
+    if (blockStartIndex < index) {
+      if (blockEndIndex === -1 || index < blockEndIndex + 3) {
+        return blockStartIndex;
+      }
+    }
+    if (blockEndIndex === -1) break;
+    currentSearchPos = blockEndIndex + 3;
+  }
+  return -1;
+}
+function findLastSafeSplitPoint(content) {
+  const enclosingBlockStart = findEnclosingCodeBlockStart(content, content.length);
+  if (enclosingBlockStart !== -1) {
+    return enclosingBlockStart;
+  }
+  let searchStartIndex = content.length;
+  while (searchStartIndex >= 0) {
+    const dnlIndex = content.lastIndexOf("\n\n", searchStartIndex);
+    if (dnlIndex === -1) {
+      break;
+    }
+    const potentialSplitPoint = dnlIndex + 2;
+    if (!isIndexInsideCodeBlock(content, potentialSplitPoint)) {
+      return potentialSplitPoint;
+    }
+    searchStartIndex = dnlIndex - 1;
+  }
+  return content.length;
+}
+function findLastSafeNewline(content) {
+  let searchPos = content.length;
+  while (searchPos > 0) {
+    const nlIndex = content.lastIndexOf("\n", searchPos - 1);
+    if (nlIndex === -1) {
+      break;
+    }
+    if (!isIndexInsideCodeBlock(content, nlIndex)) {
+      return nlIndex + 1;
+    }
+    searchPos = nlIndex;
+  }
+  return -1;
+}
+const MIN_PARAGRAPH_SPLIT_LENGTH = 200;
+const MAX_PENDING_LENGTH = 300;
+function checkForSplit(content) {
+  if (content.length < MIN_PARAGRAPH_SPLIT_LENGTH) {
+    return { shouldSplit: false };
+  }
+  const paragraphSplitPoint = findLastSafeSplitPoint(content);
+  if (paragraphSplitPoint > 80 && paragraphSplitPoint < content.length - 20) {
+    return {
+      shouldSplit: true,
+      splitIndex: paragraphSplitPoint,
+      before: content.substring(0, paragraphSplitPoint),
+      after: content.substring(paragraphSplitPoint)
+    };
+  }
+  if (content.length > MAX_PENDING_LENGTH) {
+    const lineSplitPoint = findLastSafeNewline(content);
+    if (lineSplitPoint > 80 && lineSplitPoint < content.length - 20) {
+      return {
+        shouldSplit: true,
+        splitIndex: lineSplitPoint,
+        before: content.substring(0, lineSplitPoint),
+        after: content.substring(lineSplitPoint)
+      };
+    }
+  }
+  return { shouldSplit: false };
+}
+export {
+  checkForSplit,
+  findLastSafeNewline,
+  findLastSafeSplitPoint
+};

package/dist/utils/textUtils.cjs

@@ -0,0 +1,223 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var textUtils_exports = {};
+__export(textUtils_exports, {
+  clearStringWidthCache: () => clearStringWidthCache,
+  cpLen: () => cpLen,
+  cpSlice: () => cpSlice,
+  findNextWordBoundary: () => findNextWordBoundary,
+  findNextWordStartInLine: () => findNextWordStartInLine,
+  findPrevWordBoundary: () => findPrevWordBoundary,
+  findPrevWordStartInLine: () => findPrevWordStartInLine,
+  getCachedStringWidth: () => getCachedStringWidth,
+  getCharScript: () => getCharScript,
+  isCombiningMark: () => isCombiningMark,
+  isDifferentScript: () => isDifferentScript,
+  isWhitespace: () => isWhitespace,
+  isWordCharStrict: () => isWordCharStrict,
+  isWordCharWithCombining: () => isWordCharWithCombining,
+  stripUnsafeCharacters: () => stripUnsafeCharacters,
+  toCodePoints: () => toCodePoints
+});
+module.exports = __toCommonJS(textUtils_exports);
+var import_strip_ansi = __toESM(require("strip-ansi"), 1);
+var import_string_width = __toESM(require("string-width"), 1);
+const codePointsCache = /* @__PURE__ */ new Map();
+const MAX_STRING_LENGTH_TO_CACHE = 1e3;
+function toCodePoints(str) {
+  let isAscii = true;
+  for (let i = 0; i < str.length; i++) {
+    if (str.charCodeAt(i) > 127) {
+      isAscii = false;
+      break;
+    }
+  }
+  if (isAscii) {
+    return str.split("");
+  }
+  if (str.length <= MAX_STRING_LENGTH_TO_CACHE) {
+    const cached = codePointsCache.get(str);
+    if (cached) {
+      return [...cached];
+    }
+  }
+  const result = Array.from(str);
+  if (str.length <= MAX_STRING_LENGTH_TO_CACHE) {
+    codePointsCache.set(str, result);
+  }
+  return result;
+}
+function cpLen(str) {
+  return toCodePoints(str).length;
+}
+function cpSlice(str, start, end) {
+  const arr = toCodePoints(str).slice(start, end);
+  return arr.join("");
+}
+function stripUnsafeCharacters(str) {
+  const strippedAnsi = (0, import_strip_ansi.default)(str);
+  return toCodePoints(strippedAnsi).filter((char) => {
+    const code = char.codePointAt(0);
+    if (code === void 0) return false;
+    if (code === 10 || code === 13 || code === 9) return true;
+    if (code >= 0 && code <= 31) return false;
+    if (code === 127) return false;
+    if (code >= 128 && code <= 159) return false;
+    return true;
+  }).join("");
+}
+const stringWidthCache = /* @__PURE__ */ new Map();
+function getCachedStringWidth(str) {
+  if (/^[\x20-\x7E]*$/.test(str)) {
+    return str.length;
+  }
+  if (stringWidthCache.has(str)) {
+    return stringWidthCache.get(str);
+  }
+  const width = (0, import_string_width.default)(str);
+  stringWidthCache.set(str, width);
+  return width;
+}
+function clearStringWidthCache() {
+  stringWidthCache.clear();
+}
+const isWordCharStrict = (char) => char !== void 0 && /[\w\p{L}\p{N}]/u.test(char);
+const isWhitespace = (char) => char !== void 0 && /\s/.test(char);
+const isCombiningMark = (char) => char !== void 0 && /\p{M}/u.test(char);
+const isWordCharWithCombining = (char) => isWordCharStrict(char) || isCombiningMark(char);
+const getCharScript = (char) => {
+  if (!char) return "other";
+  if (/[\p{Script=Latin}]/u.test(char)) return "latin";
+  if (/[\p{Script=Han}]/u.test(char)) return "han";
+  if (/[\p{Script=Arabic}]/u.test(char)) return "arabic";
+  if (/[\p{Script=Hiragana}]/u.test(char)) return "hiragana";
+  if (/[\p{Script=Katakana}]/u.test(char)) return "katakana";
+  if (/[\p{Script=Cyrillic}]/u.test(char)) return "cyrillic";
+  return "other";
+};
+const isDifferentScript = (char1, char2) => {
+  if (!isWordCharStrict(char1) || !isWordCharStrict(char2)) return false;
+  return getCharScript(char1) !== getCharScript(char2);
+};
+const segmenter = new Intl.Segmenter(void 0, { granularity: "word" });
+function findPrevWordBoundary(line, cursorCol) {
+  const codePoints = toCodePoints(line);
+  const prefix = codePoints.slice(0, cursorCol).join("");
+  const cursorIdx = prefix.length;
+  let targetIdx = 0;
+  for (const seg of segmenter.segment(line)) {
+    if (seg.index >= cursorIdx) break;
+    if (seg.isWordLike) {
+      targetIdx = seg.index;
+    }
+  }
+  return toCodePoints(line.slice(0, targetIdx)).length;
+}
+function findNextWordBoundary(line, cursorCol) {
+  const codePoints = toCodePoints(line);
+  const prefix = codePoints.slice(0, cursorCol).join("");
+  const cursorIdx = prefix.length;
+  let targetIdx = line.length;
+  for (const seg of segmenter.segment(line)) {
+    const segEnd = seg.index + seg.segment.length;
+    if (segEnd > cursorIdx) {
+      if (seg.isWordLike) {
+        targetIdx = segEnd;
+        break;
+      }
+    }
+  }
+  return toCodePoints(line.slice(0, targetIdx)).length;
+}
+function findNextWordStartInLine(line, col) {
+  const chars = toCodePoints(line);
+  let i = col;
+  if (i >= chars.length) return null;
+  const currentChar = chars[i];
+  if (isWordCharStrict(currentChar)) {
+    while (i < chars.length && isWordCharWithCombining(chars[i])) {
+      if (i + 1 < chars.length && isWordCharStrict(chars[i + 1]) && isDifferentScript(chars[i], chars[i + 1])) {
+        i++;
+        break;
+      }
+      i++;
+    }
+  } else if (!isWhitespace(currentChar)) {
+    while (i < chars.length && !isWordCharStrict(chars[i]) && !isWhitespace(chars[i])) {
+      i++;
+    }
+  }
+  while (i < chars.length && isWhitespace(chars[i])) {
+    i++;
+  }
+  return i < chars.length ? i : null;
+}
+function findPrevWordStartInLine(line, col) {
+  const chars = toCodePoints(line);
+  let i = col;
+  if (i <= 0) return null;
+  i--;
+  while (i >= 0 && isWhitespace(chars[i])) {
+    i--;
+  }
+  if (i < 0) return null;
+  if (isWordCharStrict(chars[i])) {
+    while (i >= 0 && isWordCharStrict(chars[i])) {
+      if (i - 1 >= 0 && isWordCharStrict(chars[i - 1]) && isDifferentScript(chars[i], chars[i - 1])) {
+        return i;
+      }
+      i--;
+    }
+    return i + 1;
+  } else {
+    while (i >= 0 && !isWordCharStrict(chars[i]) && !isWhitespace(chars[i])) {
+      i--;
+    }
+    return i + 1;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  clearStringWidthCache,
+  cpLen,
+  cpSlice,
+  findNextWordBoundary,
+  findNextWordStartInLine,
+  findPrevWordBoundary,
+  findPrevWordStartInLine,
+  getCachedStringWidth,
+  getCharScript,
+  isCombiningMark,
+  isDifferentScript,
+  isWhitespace,
+  isWordCharStrict,
+  isWordCharWithCombining,
+  stripUnsafeCharacters,
+  toCodePoints
+});

package/dist/utils/textUtils.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Unicode-aware text utilities for terminal rendering
+ *
+ * These utilities work at the code-point level rather than UTF-16 code units,
+ * so that surrogate-pair emoji count as one "column".
+ */
+/**
+ * Convert a string to an array of code points (handles surrogate pairs correctly)
+ */
+export declare function toCodePoints(str: string): string[];
+/**
+ * Get the code-point length of a string
+ */
+export declare function cpLen(str: string): number;
+/**
+ * Slice a string by code-point indices
+ */
+export declare function cpSlice(str: string, start: number, end?: number): string;
+/**
+ * Strip characters that can break terminal rendering.
+ *
+ * Characters stripped:
+ * - ANSI escape sequences
+ * - C0 control chars (0x00-0x1F) except CR/LF/TAB
+ * - C1 control chars (0x80-0x9F)
+ *
+ * Characters preserved:
+ * - All printable Unicode including emojis
+ * - CR/LF (0x0D/0x0A) - needed for line breaks
+ * - TAB (0x09)
+ */
+export declare function stripUnsafeCharacters(str: string): string;
+/**
+ * Cached version of stringWidth function for better performance
+ */
+export declare function getCachedStringWidth(str: string): number;
+/**
+ * Clear the string width cache
+ */
+export declare function clearStringWidthCache(): void;
+export declare const isWordCharStrict: (char: string | undefined) => boolean;
+export declare const isWhitespace: (char: string | undefined) => boolean;
+export declare const isCombiningMark: (char: string | undefined) => boolean;
+export declare const isWordCharWithCombining: (char: string | undefined) => boolean;
+export declare const getCharScript: (char: string | undefined) => string;
+export declare const isDifferentScript: (char1: string | undefined, char2: string | undefined) => boolean;
+/**
+ * Find previous word boundary in a line
+ */
+export declare function findPrevWordBoundary(line: string, cursorCol: number): number;
+/**
+ * Find next word boundary in a line
+ */
+export declare function findNextWordBoundary(line: string, cursorCol: number): number;
+/**
+ * Find next word start within a line, starting from col
+ */
+export declare function findNextWordStartInLine(line: string, col: number): number | null;
+/**
+ * Find previous word start within a line
+ */
+export declare function findPrevWordStartInLine(line: string, col: number): number | null;
+//# sourceMappingURL=textUtils.d.ts.map

package/dist/utils/textUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"textUtils.d.ts","sourceRoot":"","sources":["../../src/utils/textUtils.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AASH;;GAEG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,EAAE,CA+BlD;AAED;;GAEG;AACH,wBAAgB,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAEzC;AAED;;GAEG;AACH,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM,CAGxE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAwBzD;AAKD;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAcxD;AAED;;GAEG;AACH,wBAAgB,qBAAqB,IAAI,IAAI,CAE5C;AAID,eAAO,MAAM,gBAAgB,GAAI,MAAM,MAAM,GAAG,SAAS,KAAG,OACN,CAAC;AAEvD,eAAO,MAAM,YAAY,GAAI,MAAM,MAAM,GAAG,SAAS,KAAG,OACf,CAAC;AAE1C,eAAO,MAAM,eAAe,GAAI,MAAM,MAAM,GAAG,SAAS,KAAG,OACd,CAAC;AAE9C,eAAO,MAAM,uBAAuB,GAAI,MAAM,MAAM,GAAG,SAAS,KAAG,OAChB,CAAC;AAGpD,eAAO,MAAM,aAAa,GAAI,MAAM,MAAM,GAAG,SAAS,KAAG,MASxD,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAC1B,OAAO,MAAM,GAAG,SAAS,EACzB,OAAO,MAAM,GAAG,SAAS,KAC1B,OAGF,CAAC;AAKF;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAgB5E;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAkB5E;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAiChF;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAiChF"}

package/dist/utils/textUtils.js

@@ -0,0 +1,174 @@
+import stripAnsi from "strip-ansi";
+import stringWidth from "string-width";
+const codePointsCache = /* @__PURE__ */ new Map();
+const MAX_STRING_LENGTH_TO_CACHE = 1e3;
+function toCodePoints(str) {
+  let isAscii = true;
+  for (let i = 0; i < str.length; i++) {
+    if (str.charCodeAt(i) > 127) {
+      isAscii = false;
+      break;
+    }
+  }
+  if (isAscii) {
+    return str.split("");
+  }
+  if (str.length <= MAX_STRING_LENGTH_TO_CACHE) {
+    const cached = codePointsCache.get(str);
+    if (cached) {
+      return [...cached];
+    }
+  }
+  const result = Array.from(str);
+  if (str.length <= MAX_STRING_LENGTH_TO_CACHE) {
+    codePointsCache.set(str, result);
+  }
+  return result;
+}
+function cpLen(str) {
+  return toCodePoints(str).length;
+}
+function cpSlice(str, start, end) {
+  const arr = toCodePoints(str).slice(start, end);
+  return arr.join("");
+}
+function stripUnsafeCharacters(str) {
+  const strippedAnsi = stripAnsi(str);
+  return toCodePoints(strippedAnsi).filter((char) => {
+    const code = char.codePointAt(0);
+    if (code === void 0) return false;
+    if (code === 10 || code === 13 || code === 9) return true;
+    if (code >= 0 && code <= 31) return false;
+    if (code === 127) return false;
+    if (code >= 128 && code <= 159) return false;
+    return true;
+  }).join("");
+}
+const stringWidthCache = /* @__PURE__ */ new Map();
+function getCachedStringWidth(str) {
+  if (/^[\x20-\x7E]*$/.test(str)) {
+    return str.length;
+  }
+  if (stringWidthCache.has(str)) {
+    return stringWidthCache.get(str);
+  }
+  const width = stringWidth(str);
+  stringWidthCache.set(str, width);
+  return width;
+}
+function clearStringWidthCache() {
+  stringWidthCache.clear();
+}
+const isWordCharStrict = (char) => char !== void 0 && /[\w\p{L}\p{N}]/u.test(char);
+const isWhitespace = (char) => char !== void 0 && /\s/.test(char);
+const isCombiningMark = (char) => char !== void 0 && /\p{M}/u.test(char);
+const isWordCharWithCombining = (char) => isWordCharStrict(char) || isCombiningMark(char);
+const getCharScript = (char) => {
+  if (!char) return "other";
+  if (/[\p{Script=Latin}]/u.test(char)) return "latin";
+  if (/[\p{Script=Han}]/u.test(char)) return "han";
+  if (/[\p{Script=Arabic}]/u.test(char)) return "arabic";
+  if (/[\p{Script=Hiragana}]/u.test(char)) return "hiragana";
+  if (/[\p{Script=Katakana}]/u.test(char)) return "katakana";
+  if (/[\p{Script=Cyrillic}]/u.test(char)) return "cyrillic";
+  return "other";
+};
+const isDifferentScript = (char1, char2) => {
+  if (!isWordCharStrict(char1) || !isWordCharStrict(char2)) return false;
+  return getCharScript(char1) !== getCharScript(char2);
+};
+const segmenter = new Intl.Segmenter(void 0, { granularity: "word" });
+function findPrevWordBoundary(line, cursorCol) {
+  const codePoints = toCodePoints(line);
+  const prefix = codePoints.slice(0, cursorCol).join("");
+  const cursorIdx = prefix.length;
+  let targetIdx = 0;
+  for (const seg of segmenter.segment(line)) {
+    if (seg.index >= cursorIdx) break;
+    if (seg.isWordLike) {
+      targetIdx = seg.index;
+    }
+  }
+  return toCodePoints(line.slice(0, targetIdx)).length;
+}
+function findNextWordBoundary(line, cursorCol) {
+  const codePoints = toCodePoints(line);
+  const prefix = codePoints.slice(0, cursorCol).join("");
+  const cursorIdx = prefix.length;
+  let targetIdx = line.length;
+  for (const seg of segmenter.segment(line)) {
+    const segEnd = seg.index + seg.segment.length;
+    if (segEnd > cursorIdx) {
+      if (seg.isWordLike) {
+        targetIdx = segEnd;
+        break;
+      }
+    }
+  }
+  return toCodePoints(line.slice(0, targetIdx)).length;
+}
+function findNextWordStartInLine(line, col) {
+  const chars = toCodePoints(line);
+  let i = col;
+  if (i >= chars.length) return null;
+  const currentChar = chars[i];
+  if (isWordCharStrict(currentChar)) {
+    while (i < chars.length && isWordCharWithCombining(chars[i])) {
+      if (i + 1 < chars.length && isWordCharStrict(chars[i + 1]) && isDifferentScript(chars[i], chars[i + 1])) {
+        i++;
+        break;
+      }
+      i++;
+    }
+  } else if (!isWhitespace(currentChar)) {
+    while (i < chars.length && !isWordCharStrict(chars[i]) && !isWhitespace(chars[i])) {
+      i++;
+    }
+  }
+  while (i < chars.length && isWhitespace(chars[i])) {
+    i++;
+  }
+  return i < chars.length ? i : null;
+}
+function findPrevWordStartInLine(line, col) {
+  const chars = toCodePoints(line);
+  let i = col;
+  if (i <= 0) return null;
+  i--;
+  while (i >= 0 && isWhitespace(chars[i])) {
+    i--;
+  }
+  if (i < 0) return null;
+  if (isWordCharStrict(chars[i])) {
+    while (i >= 0 && isWordCharStrict(chars[i])) {
+      if (i - 1 >= 0 && isWordCharStrict(chars[i - 1]) && isDifferentScript(chars[i], chars[i - 1])) {
+        return i;
+      }
+      i--;
+    }
+    return i + 1;
+  } else {
+    while (i >= 0 && !isWordCharStrict(chars[i]) && !isWhitespace(chars[i])) {
+      i--;
+    }
+    return i + 1;
+  }
+}
+export {
+  clearStringWidthCache,
+  cpLen,
+  cpSlice,
+  findNextWordBoundary,
+  findNextWordStartInLine,
+  findPrevWordBoundary,
+  findPrevWordStartInLine,
+  getCachedStringWidth,
+  getCharScript,
+  isCombiningMark,
+  isDifferentScript,
+  isWhitespace,
+  isWordCharStrict,
+  isWordCharWithCombining,
+  stripUnsafeCharacters,
+  toCodePoints
+};

package/dist/utils/toolUtils.cjs

@@ -0,0 +1,40 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var toolUtils_exports = {};
+__export(toolUtils_exports, {
+  isAutoApprovableInEditMode: () => isAutoApprovableInEditMode,
+  isEditWriteTool: () => isEditWriteTool,
+  isPlanUpdateTool: () => isPlanUpdateTool
+});
+module.exports = __toCommonJS(toolUtils_exports);
+function isEditWriteTool(toolName) {
+  return toolName === "edit_file" || toolName === "write_file";
+}
+function isPlanUpdateTool(toolName) {
+  return toolName === "plan_update";
+}
+function isAutoApprovableInEditMode(toolName) {
+  return isEditWriteTool(toolName) || isPlanUpdateTool(toolName);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isAutoApprovableInEditMode,
+  isEditWriteTool,
+  isPlanUpdateTool
+});

package/dist/utils/toolUtils.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Tool utility functions for CLI
+ */
+/**
+ * Check if a tool is an edit or write file tool.
+ * Used for "accept all edits" mode which auto-approves these tools.
+ */
+export declare function isEditWriteTool(toolName: string | undefined): boolean;
+/**
+ * Check if a tool is a plan update tool.
+ * Used for "accept all edits" mode which also auto-approves plan updates
+ * (typically marking tasks as complete during implementation).
+ */
+export declare function isPlanUpdateTool(toolName: string | undefined): boolean;
+/**
+ * Check if a tool should be auto-approved in "accept all edits" mode.
+ * Includes file edit/write tools and plan update tools.
+ */
+export declare function isAutoApprovableInEditMode(toolName: string | undefined): boolean;
+//# sourceMappingURL=toolUtils.d.ts.map

package/dist/utils/toolUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toolUtils.d.ts","sourceRoot":"","sources":["../../src/utils/toolUtils.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;GAGG;AACH,wBAAgB,eAAe,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAErE;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAEtE;AAED;;;GAGG;AACH,wBAAgB,0BAA0B,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS,GAAG,OAAO,CAEhF"}

package/dist/utils/toolUtils.js

@@ -0,0 +1,14 @@
+function isEditWriteTool(toolName) {
+  return toolName === "edit_file" || toolName === "write_file";
+}
+function isPlanUpdateTool(toolName) {
+  return toolName === "plan_update";
+}
+function isAutoApprovableInEditMode(toolName) {
+  return isEditWriteTool(toolName) || isPlanUpdateTool(toolName);
+}
+export {
+  isAutoApprovableInEditMode,
+  isEditWriteTool,
+  isPlanUpdateTool
+};