@qwen-code/qwen-code 0.19.10 → 0.19.11-nightly.20260717.f8e6e8931

package/chunks/{chunk-DK33QJ3V.js → chunk-GCRFH57X.js}

@@ -1,5 +1,8 @@
 // Force strict mode and setup for ESM
 "use strict";
+import {
+  noteInteraction
+} from "./chunk-KW7NOTN6.js";
 import {
   Box_default,
   Text,
@@ -8,39 +11,43 @@ import {
   use_is_screen_reader_enabled_default,
   use_stdin_default,
   use_stdout_default
-} from "./chunk-K4PZ5F5T.js";
+} from "./chunk-OWT2CAEQ.js";
 import {
   require_react
 } from "./chunk-HTHUX2T5.js";
-import {
-  noteInteraction
-} from "./chunk-KW7NOTN6.js";
 import {
   formatHistoryGapNotice,
   indexGapsByChild
-} from "./chunk-SPUYQB4T.js";
+} from "./chunk-DPXB3XRN.js";
 import {
-  sanitizeFilenameForDisplay
-} from "./chunk-WTSXKLG5.js";
+  sanitizeFilenameForDisplay,
+  stringWidth
+} from "./chunk-SUARMD4Q.js";
+import {
+  eastAsianWidth
+} from "./chunk-QHTIBUWB.js";
 import {
   formatDuration
 } from "./chunk-E5Z2AVNV.js";
 import {
   t
-} from "./chunk-RDRVMDWV.js";
+} from "./chunk-EMJJBXS7.js";
 import {
   fetchGitDiff,
   findProviderByCredentials,
   getToolResponseDisplayText,
   resolveMetadataKey
-} from "./chunk-K7CRWKOE.js";
+} from "./chunk-R6AO7HBQ.js";
+import {
+  stripAnsi
+} from "./chunk-T4TZQJ7W.js";
 import {
   KittySequenceOverflowEvent,
   logKittySequenceOverflow
-} from "./chunk-P6LART6G.js";
+} from "./chunk-BTSE2DUP.js";
 import {
   ToolDisplayNames
-} from "./chunk-2UUAIFQO.js";
+} from "./chunk-JGUT3LWZ.js";
 import {
   createDebugLogger
 } from "./chunk-7NFB7LBQ.js";
@@ -3485,6 +3492,679 @@ import * as path2 from "node:path";
 // packages/cli/src/ui/components/messages/CompactToolGroupDisplay.tsx
 init_esbuild_shims();
 
+// packages/cli/node_modules/wrap-ansi/index.js
+init_esbuild_shims();
+
+// packages/cli/node_modules/wrap-ansi/node_modules/string-width/index.js
+init_esbuild_shims();
+var segmenter = new Intl.Segmenter();
+var zeroWidthClusterRegex = new RegExp("^(?:\\p{Default_Ignorable_Code_Point}|\\p{Control}|\\p{Format}|\\p{Mark}|\\p{Surrogate})+$", "v");
+var leadingNonPrintingRegex = new RegExp("^[\\p{Default_Ignorable_Code_Point}\\p{Control}\\p{Format}\\p{Mark}\\p{Surrogate}]+", "v");
+var rgiEmojiRegex = new RegExp("^\\p{RGI_Emoji}$", "v");
+var unqualifiedKeycapRegex = /^[\d#*]\u20E3$/;
+var extendedPictographicRegex = new RegExp("\\p{Extended_Pictographic}", "gu");
+function isDoubleWidthNonRgiEmojiSequence(segment) {
+  if (segment.length > 50) {
+    return false;
+  }
+  if (unqualifiedKeycapRegex.test(segment)) {
+    return true;
+  }
+  if (segment.includes("\u200D")) {
+    const pictographics = segment.match(extendedPictographicRegex);
+    return pictographics !== null && pictographics.length >= 2;
+  }
+  return false;
+}
+__name(isDoubleWidthNonRgiEmojiSequence, "isDoubleWidthNonRgiEmojiSequence");
+function baseVisible(segment) {
+  return segment.replace(leadingNonPrintingRegex, "");
+}
+__name(baseVisible, "baseVisible");
+function isZeroWidthCluster(segment) {
+  return zeroWidthClusterRegex.test(segment);
+}
+__name(isZeroWidthCluster, "isZeroWidthCluster");
+function isHangulLeadingJamo(codePoint) {
+  return codePoint >= 4352 && codePoint <= 4447 || codePoint >= 43360 && codePoint <= 43388;
+}
+__name(isHangulLeadingJamo, "isHangulLeadingJamo");
+function isHangulVowelJamo(codePoint) {
+  return codePoint >= 4448 && codePoint <= 4519 || codePoint >= 55216 && codePoint <= 55238;
+}
+__name(isHangulVowelJamo, "isHangulVowelJamo");
+function isHangulTrailingJamo(codePoint) {
+  return codePoint >= 4520 && codePoint <= 4607 || codePoint >= 55243 && codePoint <= 55291;
+}
+__name(isHangulTrailingJamo, "isHangulTrailingJamo");
+function isHangulJamo(codePoint) {
+  return isHangulLeadingJamo(codePoint) || isHangulVowelJamo(codePoint) || isHangulTrailingJamo(codePoint);
+}
+__name(isHangulJamo, "isHangulJamo");
+function hangulClusterWidth(visibleSegment, eastAsianWidthOptions) {
+  const codePoints = [];
+  for (const character of visibleSegment) {
+    if (zeroWidthClusterRegex.test(character)) {
+      continue;
+    }
+    codePoints.push(character.codePointAt(0));
+  }
+  if (codePoints.length === 0) {
+    return void 0;
+  }
+  let width = 0;
+  for (let index = 0; index < codePoints.length; index++) {
+    const codePoint = codePoints[index];
+    if (!isHangulJamo(codePoint)) {
+      if (width === 0) {
+        return void 0;
+      }
+      for (let remaining = index; remaining < codePoints.length; remaining++) {
+        width += eastAsianWidth(codePoints[remaining], eastAsianWidthOptions);
+      }
+      return width;
+    }
+    if (isHangulLeadingJamo(codePoint) && isHangulVowelJamo(codePoints[index + 1])) {
+      width += 2;
+      index += isHangulTrailingJamo(codePoints[index + 2]) ? 2 : 1;
+      continue;
+    }
+    width += eastAsianWidth(codePoint, eastAsianWidthOptions);
+  }
+  return width;
+}
+__name(hangulClusterWidth, "hangulClusterWidth");
+function trailingHalfwidthWidth(visibleSegment, eastAsianWidthOptions) {
+  let extra = 0;
+  let first = true;
+  for (const character of visibleSegment) {
+    if (first) {
+      first = false;
+      continue;
+    }
+    if (character >= "\uFF00" && character <= "\uFFEF") {
+      extra += eastAsianWidth(character.codePointAt(0), eastAsianWidthOptions);
+    }
+  }
+  return extra;
+}
+__name(trailingHalfwidthWidth, "trailingHalfwidthWidth");
+function stringWidth2(input, options = {}) {
+  if (typeof input !== "string" || input.length === 0) {
+    return 0;
+  }
+  const {
+    ambiguousIsNarrow = true,
+    countAnsiEscapeCodes = false
+  } = options;
+  let string = input;
+  if (!countAnsiEscapeCodes && (string.includes("\x1B") || string.includes("\x9B"))) {
+    string = stripAnsi(string);
+  }
+  if (string.length === 0) {
+    return 0;
+  }
+  if (/^[\u0020-\u007E]*$/.test(string)) {
+    return string.length;
+  }
+  let width = 0;
+  const eastAsianWidthOptions = { ambiguousAsWide: !ambiguousIsNarrow };
+  for (const { segment } of segmenter.segment(string)) {
+    if (isZeroWidthCluster(segment)) {
+      continue;
+    }
+    if (rgiEmojiRegex.test(segment) || isDoubleWidthNonRgiEmojiSequence(segment)) {
+      width += 2;
+      continue;
+    }
+    const visibleSegment = baseVisible(segment);
+    const hangulWidth = hangulClusterWidth(visibleSegment, eastAsianWidthOptions);
+    if (hangulWidth !== void 0) {
+      width += hangulWidth;
+      continue;
+    }
+    const codePoint = visibleSegment.codePointAt(0);
+    width += eastAsianWidth(codePoint, eastAsianWidthOptions);
+    width += trailingHalfwidthWidth(visibleSegment, eastAsianWidthOptions);
+  }
+  return width;
+}
+__name(stringWidth2, "stringWidth");
+
+// packages/cli/node_modules/ansi-styles/index.js
+init_esbuild_shims();
+var ANSI_BACKGROUND_OFFSET = 10;
+var wrapAnsi16 = /* @__PURE__ */ __name((offset = 0) => (code) => `\x1B[${code + offset}m`, "wrapAnsi16");
+var wrapAnsi256 = /* @__PURE__ */ __name((offset = 0) => (code) => `\x1B[${38 + offset};5;${code}m`, "wrapAnsi256");
+var wrapAnsi16m = /* @__PURE__ */ __name((offset = 0) => (red, green, blue) => `\x1B[${38 + offset};2;${red};${green};${blue}m`, "wrapAnsi16m");
+var styles = {
+  modifier: {
+    reset: [0, 0],
+    // 21 isn't widely supported and 22 does the same thing
+    bold: [1, 22],
+    dim: [2, 22],
+    italic: [3, 23],
+    underline: [4, 24],
+    overline: [53, 55],
+    inverse: [7, 27],
+    hidden: [8, 28],
+    strikethrough: [9, 29]
+  },
+  color: {
+    black: [30, 39],
+    red: [31, 39],
+    green: [32, 39],
+    yellow: [33, 39],
+    blue: [34, 39],
+    magenta: [35, 39],
+    cyan: [36, 39],
+    white: [37, 39],
+    // Bright color
+    blackBright: [90, 39],
+    gray: [90, 39],
+    // Alias of `blackBright`
+    grey: [90, 39],
+    // Alias of `blackBright`
+    redBright: [91, 39],
+    greenBright: [92, 39],
+    yellowBright: [93, 39],
+    blueBright: [94, 39],
+    magentaBright: [95, 39],
+    cyanBright: [96, 39],
+    whiteBright: [97, 39]
+  },
+  bgColor: {
+    bgBlack: [40, 49],
+    bgRed: [41, 49],
+    bgGreen: [42, 49],
+    bgYellow: [43, 49],
+    bgBlue: [44, 49],
+    bgMagenta: [45, 49],
+    bgCyan: [46, 49],
+    bgWhite: [47, 49],
+    // Bright color
+    bgBlackBright: [100, 49],
+    bgGray: [100, 49],
+    // Alias of `bgBlackBright`
+    bgGrey: [100, 49],
+    // Alias of `bgBlackBright`
+    bgRedBright: [101, 49],
+    bgGreenBright: [102, 49],
+    bgYellowBright: [103, 49],
+    bgBlueBright: [104, 49],
+    bgMagentaBright: [105, 49],
+    bgCyanBright: [106, 49],
+    bgWhiteBright: [107, 49]
+  }
+};
+var modifierNames = Object.keys(styles.modifier);
+var foregroundColorNames = Object.keys(styles.color);
+var backgroundColorNames = Object.keys(styles.bgColor);
+var colorNames = [...foregroundColorNames, ...backgroundColorNames];
+function assembleStyles() {
+  const codes = /* @__PURE__ */ new Map();
+  for (const [groupName, group] of Object.entries(styles)) {
+    for (const [styleName, style] of Object.entries(group)) {
+      styles[styleName] = {
+        open: `\x1B[${style[0]}m`,
+        close: `\x1B[${style[1]}m`
+      };
+      group[styleName] = styles[styleName];
+      codes.set(style[0], style[1]);
+    }
+    Object.defineProperty(styles, groupName, {
+      value: group,
+      enumerable: false
+    });
+  }
+  Object.defineProperty(styles, "codes", {
+    value: codes,
+    enumerable: false
+  });
+  styles.color.close = "\x1B[39m";
+  styles.bgColor.close = "\x1B[49m";
+  styles.color.ansi = wrapAnsi16();
+  styles.color.ansi256 = wrapAnsi256();
+  styles.color.ansi16m = wrapAnsi16m();
+  styles.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
+  styles.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
+  styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
+  Object.defineProperties(styles, {
+    rgbToAnsi256: {
+      value(red, green, blue) {
+        if (red === green && green === blue) {
+          if (red < 8) {
+            return 16;
+          }
+          if (red > 248) {
+            return 231;
+          }
+          return Math.round((red - 8) / 247 * 24) + 232;
+        }
+        return 16 + 36 * Math.round(red / 255 * 5) + 6 * Math.round(green / 255 * 5) + Math.round(blue / 255 * 5);
+      },
+      enumerable: false
+    },
+    hexToRgb: {
+      value(hex) {
+        const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16));
+        if (!matches) {
+          return [0, 0, 0];
+        }
+        let [colorString] = matches;
+        if (colorString.length === 3) {
+          colorString = [...colorString].map((character) => character + character).join("");
+        }
+        const integer = Number.parseInt(colorString, 16);
+        return [
+          /* eslint-disable no-bitwise */
+          integer >> 16 & 255,
+          integer >> 8 & 255,
+          integer & 255
+          /* eslint-enable no-bitwise */
+        ];
+      },
+      enumerable: false
+    },
+    hexToAnsi256: {
+      value: /* @__PURE__ */ __name((hex) => styles.rgbToAnsi256(...styles.hexToRgb(hex)), "value"),
+      enumerable: false
+    },
+    ansi256ToAnsi: {
+      value(code) {
+        if (code < 8) {
+          return 30 + code;
+        }
+        if (code < 16) {
+          return 90 + (code - 8);
+        }
+        let red;
+        let green;
+        let blue;
+        if (code >= 232) {
+          red = ((code - 232) * 10 + 8) / 255;
+          green = red;
+          blue = red;
+        } else {
+          code -= 16;
+          const remainder = code % 36;
+          red = Math.floor(code / 36) / 5;
+          green = Math.floor(remainder / 6) / 5;
+          blue = remainder % 6 / 5;
+        }
+        const value = Math.max(red, green, blue) * 2;
+        if (value === 0) {
+          return 30;
+        }
+        let result = 30 + (Math.round(blue) << 2 | Math.round(green) << 1 | Math.round(red));
+        if (value === 2) {
+          result += 60;
+        }
+        return result;
+      },
+      enumerable: false
+    },
+    rgbToAnsi: {
+      value: /* @__PURE__ */ __name((red, green, blue) => styles.ansi256ToAnsi(styles.rgbToAnsi256(red, green, blue)), "value"),
+      enumerable: false
+    },
+    hexToAnsi: {
+      value: /* @__PURE__ */ __name((hex) => styles.ansi256ToAnsi(styles.hexToAnsi256(hex)), "value"),
+      enumerable: false
+    }
+  });
+  return styles;
+}
+__name(assembleStyles, "assembleStyles");
+var ansiStyles = assembleStyles();
+var ansi_styles_default = ansiStyles;
+
+// packages/cli/node_modules/wrap-ansi/index.js
+var ANSI_ESCAPE = "\x1B";
+var ANSI_ESCAPE_CSI = "\x9B";
+var ESCAPES = /* @__PURE__ */ new Set([
+  ANSI_ESCAPE,
+  ANSI_ESCAPE_CSI
+]);
+var ANSI_ESCAPE_BELL = "\x07";
+var ANSI_CSI = "[";
+var ANSI_OSC = "]";
+var ANSI_SGR_TERMINATOR = "m";
+var ANSI_SGR_RESET = 0;
+var ANSI_SGR_RESET_FOREGROUND = 39;
+var ANSI_SGR_RESET_BACKGROUND = 49;
+var ANSI_SGR_RESET_UNDERLINE_COLOR = 59;
+var ANSI_SGR_FOREGROUND_EXTENDED = 38;
+var ANSI_SGR_BACKGROUND_EXTENDED = 48;
+var ANSI_SGR_UNDERLINE_COLOR_EXTENDED = 58;
+var ANSI_SGR_COLOR_MODE_256 = 5;
+var ANSI_SGR_COLOR_MODE_RGB = 2;
+var ANSI_ESCAPE_LINK = `${ANSI_OSC}8;;`;
+var ANSI_ESCAPE_REGEX = new RegExp(`^\\u001B(?:\\${ANSI_CSI}(?<sgr>[0-9;]*)${ANSI_SGR_TERMINATOR}|${ANSI_ESCAPE_LINK}(?<uri>[^\\u0007\\u001B]*)(?:\\u0007|\\u001B\\\\))`);
+var ANSI_ESCAPE_CSI_REGEX = new RegExp(`^\\u009B(?<sgr>[0-9;]*)${ANSI_SGR_TERMINATOR}`);
+var ANSI_SGR_MODIFIER_CLOSE_CODES = new Set(ansi_styles_default.codes.values());
+ANSI_SGR_MODIFIER_CLOSE_CODES.delete(ANSI_SGR_RESET);
+var segmenter2 = new Intl.Segmenter();
+var getGraphemes = /* @__PURE__ */ __name((string) => Array.from(segmenter2.segment(string), ({ segment }) => segment), "getGraphemes");
+var TAB_SIZE = 8;
+var wrapAnsiCode = /* @__PURE__ */ __name((code) => `${ANSI_ESCAPE}${ANSI_CSI}${code}${ANSI_SGR_TERMINATOR}`, "wrapAnsiCode");
+var wrapAnsiHyperlink = /* @__PURE__ */ __name((url) => `${ANSI_ESCAPE}${ANSI_ESCAPE_LINK}${url}${ANSI_ESCAPE_BELL}`, "wrapAnsiHyperlink");
+var getSgrTokens = /* @__PURE__ */ __name((sgrParameters) => {
+  const codes = sgrParameters.split(";").map((sgrParameter) => sgrParameter === "" ? ANSI_SGR_RESET : Number.parseInt(sgrParameter, 10));
+  const sgrTokens = [];
+  for (let index = 0; index < codes.length; index++) {
+    const code = codes[index];
+    if (!Number.isFinite(code)) {
+      continue;
+    }
+    if (code === ANSI_SGR_FOREGROUND_EXTENDED || code === ANSI_SGR_BACKGROUND_EXTENDED || code === ANSI_SGR_UNDERLINE_COLOR_EXTENDED) {
+      if (index + 1 >= codes.length) {
+        break;
+      }
+      const mode = codes[index + 1];
+      if (mode === ANSI_SGR_COLOR_MODE_256 && Number.isFinite(codes[index + 2])) {
+        sgrTokens.push([code, mode, codes[index + 2]]);
+        index += 2;
+        continue;
+      }
+      const red = codes[index + 2];
+      const green = codes[index + 3];
+      const blue = codes[index + 4];
+      if (mode === ANSI_SGR_COLOR_MODE_RGB && Number.isFinite(red) && Number.isFinite(green) && Number.isFinite(blue)) {
+        sgrTokens.push([code, mode, red, green, blue]);
+        index += 4;
+        continue;
+      }
+      break;
+    }
+    sgrTokens.push([code]);
+  }
+  return sgrTokens;
+}, "getSgrTokens");
+var removeActiveStyle = /* @__PURE__ */ __name((activeStyles, family) => {
+  const activeStyleIndex = activeStyles.findIndex((activeStyle) => activeStyle.family === family);
+  if (activeStyleIndex !== -1) {
+    activeStyles.splice(activeStyleIndex, 1);
+  }
+}, "removeActiveStyle");
+var upsertActiveStyle = /* @__PURE__ */ __name((activeStyles, nextActiveStyle) => {
+  removeActiveStyle(activeStyles, nextActiveStyle.family);
+  activeStyles.push(nextActiveStyle);
+}, "upsertActiveStyle");
+var removeModifierStylesByClose = /* @__PURE__ */ __name((activeStyles, closeCode) => {
+  for (let index = activeStyles.length - 1; index >= 0; index--) {
+    const activeStyle = activeStyles[index];
+    if (activeStyle.family.startsWith("modifier-") && activeStyle.close === closeCode) {
+      activeStyles.splice(index, 1);
+    }
+  }
+}, "removeModifierStylesByClose");
+var getColorStyle = /* @__PURE__ */ __name((code, sgrToken) => {
+  if (code >= 30 && code <= 37 || code >= 90 && code <= 97 || code === ANSI_SGR_FOREGROUND_EXTENDED && sgrToken.length > 1) {
+    return {
+      family: "foreground",
+      open: sgrToken.join(";"),
+      close: ANSI_SGR_RESET_FOREGROUND
+    };
+  }
+  if (code >= 40 && code <= 47 || code >= 100 && code <= 107 || code === ANSI_SGR_BACKGROUND_EXTENDED && sgrToken.length > 1) {
+    return {
+      family: "background",
+      open: sgrToken.join(";"),
+      close: ANSI_SGR_RESET_BACKGROUND
+    };
+  }
+  if (code === ANSI_SGR_UNDERLINE_COLOR_EXTENDED && sgrToken.length > 1) {
+    return {
+      family: "underlineColor",
+      open: sgrToken.join(";"),
+      close: ANSI_SGR_RESET_UNDERLINE_COLOR
+    };
+  }
+}, "getColorStyle");
+var applySgrResetCode = /* @__PURE__ */ __name((code, activeStyles) => {
+  if (code === ANSI_SGR_RESET) {
+    activeStyles.length = 0;
+    return true;
+  }
+  if (code === ANSI_SGR_RESET_FOREGROUND) {
+    removeActiveStyle(activeStyles, "foreground");
+    return true;
+  }
+  if (code === ANSI_SGR_RESET_BACKGROUND) {
+    removeActiveStyle(activeStyles, "background");
+    return true;
+  }
+  if (code === ANSI_SGR_RESET_UNDERLINE_COLOR) {
+    removeActiveStyle(activeStyles, "underlineColor");
+    return true;
+  }
+  if (ANSI_SGR_MODIFIER_CLOSE_CODES.has(code)) {
+    removeModifierStylesByClose(activeStyles, code);
+    return true;
+  }
+  return false;
+}, "applySgrResetCode");
+var applySgrToken = /* @__PURE__ */ __name((sgrToken, activeStyles) => {
+  const [code] = sgrToken;
+  if (applySgrResetCode(code, activeStyles)) {
+    return;
+  }
+  const colorStyle = getColorStyle(code, sgrToken);
+  if (colorStyle) {
+    upsertActiveStyle(activeStyles, colorStyle);
+    return;
+  }
+  const close = ansi_styles_default.codes.get(code);
+  if (close !== void 0 && close !== ANSI_SGR_RESET) {
+    upsertActiveStyle(activeStyles, {
+      family: `modifier-${code}`,
+      open: sgrToken.join(";"),
+      close
+    });
+  }
+}, "applySgrToken");
+var applySgrParameters = /* @__PURE__ */ __name((sgrParameters, activeStyles) => {
+  for (const sgrToken of getSgrTokens(sgrParameters)) {
+    applySgrToken(sgrToken, activeStyles);
+  }
+}, "applySgrParameters");
+var applySgrResets = /* @__PURE__ */ __name((sgrParameters, activeStyles) => {
+  for (const sgrToken of getSgrTokens(sgrParameters)) {
+    const [code] = sgrToken;
+    applySgrResetCode(code, activeStyles);
+  }
+}, "applySgrResets");
+var applyLeadingSgrResets = /* @__PURE__ */ __name((string, activeStyles) => {
+  let remainder = string;
+  while (remainder.length > 0) {
+    if (remainder.startsWith(ANSI_ESCAPE) && remainder[1] !== "\\") {
+      const match = ANSI_ESCAPE_REGEX.exec(remainder);
+      if (!match) {
+        break;
+      }
+      if (match.groups.sgr !== void 0) {
+        applySgrResets(match.groups.sgr, activeStyles);
+      }
+      remainder = remainder.slice(match[0].length);
+      continue;
+    }
+    if (remainder.startsWith(ANSI_ESCAPE_CSI)) {
+      const match = ANSI_ESCAPE_CSI_REGEX.exec(remainder);
+      if (!match || match.groups.sgr === void 0) {
+        break;
+      }
+      applySgrResets(match.groups.sgr, activeStyles);
+      remainder = remainder.slice(match[0].length);
+      continue;
+    }
+    break;
+  }
+}, "applyLeadingSgrResets");
+var getClosingSgrSequence = /* @__PURE__ */ __name((activeStyles) => [...activeStyles].reverse().map((activeStyle) => wrapAnsiCode(activeStyle.close)).join(""), "getClosingSgrSequence");
+var getOpeningSgrSequence = /* @__PURE__ */ __name((activeStyles) => activeStyles.map((activeStyle) => wrapAnsiCode(activeStyle.open)).join(""), "getOpeningSgrSequence");
+var wordLengths = /* @__PURE__ */ __name((string) => string.split(" ").map((word) => stringWidth2(word)), "wordLengths");
+var wrapWord = /* @__PURE__ */ __name((rows, word, columns) => {
+  const characters = getGraphemes(word);
+  let isInsideEscape = false;
+  let isInsideLinkEscape = false;
+  let visible = stringWidth2(stripAnsi(rows.at(-1)));
+  for (const [index, character] of characters.entries()) {
+    const characterLength = stringWidth2(character);
+    if (visible + characterLength <= columns) {
+      rows[rows.length - 1] += character;
+    } else {
+      rows.push(character);
+      visible = 0;
+    }
+    if (ESCAPES.has(character) && !(isInsideLinkEscape && character === ANSI_ESCAPE && characters[index + 1] === "\\")) {
+      isInsideEscape = true;
+      const ansiEscapeLinkCandidate = characters.slice(index + 1, index + 1 + ANSI_ESCAPE_LINK.length).join("");
+      isInsideLinkEscape = ansiEscapeLinkCandidate === ANSI_ESCAPE_LINK;
+    }
+    if (isInsideEscape) {
+      if (isInsideLinkEscape) {
+        if (character === ANSI_ESCAPE_BELL || character === "\\" && index > 0 && characters[index - 1] === ANSI_ESCAPE) {
+          isInsideEscape = false;
+          isInsideLinkEscape = false;
+        }
+      } else if (character === ANSI_SGR_TERMINATOR) {
+        isInsideEscape = false;
+      }
+      continue;
+    }
+    visible += characterLength;
+    if (visible === columns && index < characters.length - 1) {
+      rows.push("");
+      visible = 0;
+    }
+  }
+  if (!visible && rows.at(-1).length > 0 && rows.length > 1) {
+    rows[rows.length - 2] += rows.pop();
+  }
+}, "wrapWord");
+var stringVisibleTrimSpacesRight = /* @__PURE__ */ __name((string) => {
+  const words = string.split(" ");
+  let last = words.length;
+  while (last > 0) {
+    if (stringWidth2(words[last - 1]) > 0) {
+      break;
+    }
+    last--;
+  }
+  if (last === words.length) {
+    return string;
+  }
+  return words.slice(0, last).join(" ") + words.slice(last).join("");
+}, "stringVisibleTrimSpacesRight");
+var expandTabs = /* @__PURE__ */ __name((line) => {
+  if (!line.includes("	")) {
+    return line;
+  }
+  const segments = line.split("	");
+  let visible = 0;
+  let expandedLine = "";
+  for (const [index, segment] of segments.entries()) {
+    expandedLine += segment;
+    visible += stringWidth2(segment);
+    if (index < segments.length - 1) {
+      const spaces = TAB_SIZE - visible % TAB_SIZE;
+      expandedLine += " ".repeat(spaces);
+      visible += spaces;
+    }
+  }
+  return expandedLine;
+}, "expandTabs");
+var exec = /* @__PURE__ */ __name((string, columns, options = {}) => {
+  if (options.trim !== false && string.trim() === "") {
+    return "";
+  }
+  let returnValue = "";
+  let escapeUrl;
+  const activeStyles = [];
+  const lengths = wordLengths(string);
+  let rows = [""];
+  for (const [index, word] of string.split(" ").entries()) {
+    if (options.trim !== false) {
+      rows[rows.length - 1] = rows.at(-1).trimStart();
+    }
+    let rowLength = stringWidth2(rows.at(-1));
+    if (index !== 0) {
+      if (rowLength >= columns && (options.wordWrap === false || options.trim === false)) {
+        rows.push("");
+        rowLength = 0;
+      }
+      if (rowLength > 0 || options.trim === false) {
+        rows[rows.length - 1] += " ";
+        rowLength++;
+      }
+    }
+    if (options.hard && options.wordWrap !== false && lengths[index] > columns) {
+      const remainingColumns = columns - rowLength;
+      const breaksStartingThisLine = 1 + Math.floor((lengths[index] - remainingColumns - 1) / columns);
+      const breaksStartingNextLine = Math.floor((lengths[index] - 1) / columns);
+      if (breaksStartingNextLine < breaksStartingThisLine) {
+        rows.push("");
+      }
+      wrapWord(rows, word, columns);
+      continue;
+    }
+    if (rowLength + lengths[index] > columns && rowLength > 0 && lengths[index] > 0) {
+      if (options.wordWrap === false && rowLength < columns) {
+        wrapWord(rows, word, columns);
+        continue;
+      }
+      rows.push("");
+    }
+    if (rowLength + lengths[index] > columns && options.wordWrap === false) {
+      wrapWord(rows, word, columns);
+      continue;
+    }
+    rows[rows.length - 1] += word;
+  }
+  if (options.trim !== false) {
+    rows = rows.map((row) => stringVisibleTrimSpacesRight(row));
+  }
+  const preString = rows.join("\n");
+  const pre = getGraphemes(preString);
+  let preStringIndex = 0;
+  for (const [index, character] of pre.entries()) {
+    returnValue += character;
+    if (character === ANSI_ESCAPE && pre[index + 1] !== "\\") {
+      const { groups } = ANSI_ESCAPE_REGEX.exec(preString.slice(preStringIndex)) || { groups: {} };
+      if (groups.sgr !== void 0) {
+        applySgrParameters(groups.sgr, activeStyles);
+      } else if (groups.uri !== void 0) {
+        escapeUrl = groups.uri.length === 0 ? void 0 : groups.uri;
+      }
+    } else if (character === ANSI_ESCAPE_CSI) {
+      const { groups } = ANSI_ESCAPE_CSI_REGEX.exec(preString.slice(preStringIndex)) || { groups: {} };
+      if (groups.sgr !== void 0) {
+        applySgrParameters(groups.sgr, activeStyles);
+      }
+    }
+    if (pre[index + 1] === "\n") {
+      if (escapeUrl) {
+        returnValue += wrapAnsiHyperlink("");
+      }
+      returnValue += getClosingSgrSequence(activeStyles);
+    } else if (character === "\n") {
+      const openingStyles = [...activeStyles];
+      applyLeadingSgrResets(preString.slice(preStringIndex + 1), openingStyles);
+      returnValue += getOpeningSgrSequence(openingStyles);
+      if (escapeUrl) {
+        returnValue += wrapAnsiHyperlink(escapeUrl);
+      }
+    }
+    preStringIndex += character.length;
+  }
+  return returnValue;
+}, "exec");
+function wrapAnsi(string, columns, options) {
+  return String(string).normalize().replaceAll("\r\n", "\n").split("\n").map((line) => exec(expandTabs(line), columns, options)).join("\n");
+}
+__name(wrapAnsi, "wrapAnsi");
+
 // packages/cli/src/ui/constants.ts
 init_esbuild_shims();
 var EstimatedArtWidth = 59;
@@ -3658,6 +4338,9 @@ var ToolElapsedTime = /* @__PURE__ */ __name(({
 
 // packages/cli/src/ui/components/messages/CompactToolGroupDisplay.tsx
 var import_jsx_runtime5 = __toESM(require_jsx_runtime(), 1);
+var COMPACT_GROUP_HORIZONTAL_PADDING = 2;
+var ELAPSED_TIME_MARGIN_LEFT = 1;
+var EXECUTING_ELAPSED_TIME_RESERVED_LABEL = "99h 59m 59s";
 function getOverallStatus(toolCalls) {
   if (toolCalls.some((t2) => t2.status === "Confirming" /* Confirming */))
     return "Confirming" /* Confirming */;
@@ -3684,6 +4367,23 @@ function getShellTimeoutMs(tool) {
   return void 0;
 }
 __name(getShellTimeoutMs, "getShellTimeoutMs");
+function isToolGroupActive(status) {
+  return status === "Executing" /* Executing */ || status === "Pending" /* Pending */ || status === "Confirming" /* Confirming */;
+}
+__name(isToolGroupActive, "isToolGroupActive");
+function getElapsedTimeReservedWidth(tool, status) {
+  if (status !== "Executing" /* Executing */) return 0;
+  const timeoutMs = getShellTimeoutMs(tool);
+  let label = EXECUTING_ELAPSED_TIME_RESERVED_LABEL;
+  if (timeoutMs != null && timeoutMs > 0) {
+    const maxElapsedStr = formatDuration(timeoutMs, {
+      hideTrailingZeros: true
+    });
+    label = `(${maxElapsedStr} \xB7 timeout ${maxElapsedStr})`;
+  }
+  return ELAPSED_TIME_MARGIN_LEFT + stringWidth(label);
+}
+__name(getElapsedTimeReservedWidth, "getElapsedTimeReservedWidth");
 var TOOL_NAME_TO_CATEGORY = {
   [ToolDisplayNames.READ_FILE]: "read",
   [ToolDisplayNames.EDIT]: "edit",
@@ -3846,14 +4546,31 @@ function buildToolSummary(toolCalls, isActive) {
   return parts.join(", ");
 }
 __name(buildToolSummary, "buildToolSummary");
+function estimateCompactToolGroupHeight(toolCalls, contentWidth) {
+  if (toolCalls.length === 0) return 0;
+  const overallStatus = getOverallStatus(toolCalls);
+  const activeTool = getActiveTool(toolCalls);
+  const isActive = isToolGroupActive(overallStatus);
+  const summary = `${buildToolSummary(toolCalls, isActive)}${isActive ? "\u2026" : ""}`;
+  const summaryWidth = Math.max(
+    1,
+    contentWidth - COMPACT_GROUP_HORIZONTAL_PADDING - STATUS_INDICATOR_WIDTH - getElapsedTimeReservedWidth(activeTool, overallStatus)
+  );
+  const wrappedSummary = wrapAnsi(summary, summaryWidth, {
+    hard: true,
+    trim: false
+  });
+  return Math.max(1, wrappedSummary.split("\n").length);
+}
+__name(estimateCompactToolGroupHeight, "estimateCompactToolGroupHeight");
 var CompactToolGroupDisplay = /* @__PURE__ */ __name(({ toolCalls, contentWidth }) => {
   if (toolCalls.length === 0) return null;
   const overallStatus = getOverallStatus(toolCalls);
   const activeTool = getActiveTool(toolCalls);
-  const isActive = overallStatus === "Executing" /* Executing */ || overallStatus === "Pending" /* Pending */ || overallStatus === "Confirming" /* Confirming */;
+  const isActive = isToolGroupActive(overallStatus);
   return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(Box_default, { flexDirection: "column", width: contentWidth, paddingX: 1, gap: 0, children: /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(Box_default, { flexDirection: "row", children: [
     /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(ToolStatusIndicator, { status: overallStatus, name: activeTool.name }),
-    /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(Box_default, { flexGrow: 1, children: /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(Text, { wrap: "truncate-end", bold: true, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(Box_default, { flexGrow: 1, children: /* @__PURE__ */ (0, import_jsx_runtime5.jsxs)(Text, { wrap: "wrap", bold: true, children: [
       buildToolSummary(toolCalls, isActive),
       isActive && /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(Text, { children: "\u2026" }, "ellipsis")
     ] }) }),
@@ -4610,6 +5327,7 @@ export {
   useFocus,
   useKeypressContext,
   KeypressProvider,
+  wrapAnsi,
   SCREEN_READER_USER_PREFIX,
   SCREEN_READER_MODEL_PREFIX,
   SHELL_COMMAND_NAME,
@@ -4623,6 +5341,7 @@ export {
   ToolStatusIndicator,
   ToolElapsedTime,
   isCollapsibleTool,
+  estimateCompactToolGroupHeight,
   CompactToolGroupDisplay,
   getSystemInfoFields,
   calculateErrorRate,