@qwen-code/qwen-code 0.22.3-nightly.20260831.3a0c4c6108 → 0.23.0

package/chunks/chunk-VPSIC437.js

@@ -0,0 +1,780 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  ICON
+} from "./chunk-HJBHMANB.js";
+import {
+  theme
+} from "./chunk-PDAKFU7M.js";
+import {
+  require_jsx_runtime
+} from "./chunk-SV5PQVQE.js";
+import {
+  require_react
+} from "./chunk-5QWWOFGG.js";
+import {
+  sanitizeForOsc,
+  wrapForMultiplexer
+} from "./chunk-3AKCBZVW.js";
+import {
+  uiTelemetryService
+} from "./chunk-GH2S4GD5.js";
+import {
+  ToolDisplayNames,
+  ToolNames
+} from "./chunk-7JMGTOH7.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name,
+  __toESM
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/ui/contexts/SessionContext.tsx
+init_esbuild_shims();
+var import_react = __toESM(require_react(), 1);
+var import_jsx_runtime = __toESM(require_jsx_runtime(), 1);
+var EMPTY_SKILL_METRICS = {
+  totalCalls: 0,
+  totalSuccess: 0,
+  totalFail: 0,
+  byName: {}
+};
+function areModelMetricsCoreEqual(a, b) {
+  if (a.api.totalRequests !== b.api.totalRequests || a.api.totalErrors !== b.api.totalErrors || a.api.totalLatencyMs !== b.api.totalLatencyMs) {
+    return false;
+  }
+  if (a.tokens.prompt !== b.tokens.prompt || a.tokens.candidates !== b.tokens.candidates || a.tokens.total !== b.tokens.total || a.tokens.cached !== b.tokens.cached || a.tokens.thoughts !== b.tokens.thoughts) {
+    return false;
+  }
+  return true;
+}
+__name(areModelMetricsCoreEqual, "areModelMetricsCoreEqual");
+function areModelMetricsEqual(a, b) {
+  if (!areModelMetricsCoreEqual(a, b)) return false;
+  const aKeys = Object.keys(a.bySource);
+  const bKeys = Object.keys(b.bySource);
+  if (aKeys.length !== bKeys.length) return false;
+  for (const key of aKeys) {
+    const aSource = a.bySource[key];
+    const bSource = b.bySource[key];
+    if (!bSource || !areModelMetricsCoreEqual(aSource, bSource)) {
+      return false;
+    }
+  }
+  return true;
+}
+__name(areModelMetricsEqual, "areModelMetricsEqual");
+function areToolCallStatsEqual(a, b) {
+  if (a.count !== b.count || a.success !== b.success || a.fail !== b.fail || a.durationMs !== b.durationMs) {
+    return false;
+  }
+  if (a.decisions["accept" /* ACCEPT */] !== b.decisions["accept" /* ACCEPT */] || a.decisions["reject" /* REJECT */] !== b.decisions["reject" /* REJECT */] || a.decisions["modify" /* MODIFY */] !== b.decisions["modify" /* MODIFY */] || a.decisions["auto_accept" /* AUTO_ACCEPT */] !== b.decisions["auto_accept" /* AUTO_ACCEPT */]) {
+    return false;
+  }
+  return true;
+}
+__name(areToolCallStatsEqual, "areToolCallStatsEqual");
+function areSkillCallStatsEqual(a, b) {
+  return a.count === b.count && a.success === b.success && a.fail === b.fail;
+}
+__name(areSkillCallStatsEqual, "areSkillCallStatsEqual");
+function areSkillMetricsEqual(a, b) {
+  if (a.totalCalls !== b.totalCalls || a.totalSuccess !== b.totalSuccess || a.totalFail !== b.totalFail) {
+    return false;
+  }
+  const aKeys = Object.keys(a.byName);
+  const bKeys = Object.keys(b.byName);
+  if (aKeys.length !== bKeys.length) return false;
+  for (const key of aKeys) {
+    const skillA = a.byName[key];
+    const skillB = b.byName[key];
+    if (!skillB || !areSkillCallStatsEqual(skillA, skillB)) {
+      return false;
+    }
+  }
+  return true;
+}
+__name(areSkillMetricsEqual, "areSkillMetricsEqual");
+function areGenerationMetricsEqual(a, b) {
+  if (a === b) return true;
+  if (!a || !b) return false;
+  if (a.timedRequests !== b.timedRequests || a.totalTtftMs !== b.totalTtftMs || a.totalGenerationDurationMs !== b.totalGenerationDurationMs || a.totalThroughputOutputTokens !== b.totalThroughputOutputTokens) {
+    return false;
+  }
+  if (a.last === b.last) return true;
+  if (!a.last || !b.last) return false;
+  return a.last.model === b.last.model && a.last.ttftMs === b.last.ttftMs && a.last.generationDurationMs === b.last.generationDurationMs && a.last.outputTokens === b.last.outputTokens;
+}
+__name(areGenerationMetricsEqual, "areGenerationMetricsEqual");
+function areMetricsEqual(a, b) {
+  if (a === b) return true;
+  if (!a || !b) return false;
+  if (!areGenerationMetricsEqual(a.generation, b.generation)) {
+    return false;
+  }
+  if (a.files.totalLinesAdded !== b.files.totalLinesAdded || a.files.totalLinesRemoved !== b.files.totalLinesRemoved) {
+    return false;
+  }
+  const toolsA = a.tools;
+  const toolsB = b.tools;
+  if (toolsA.totalCalls !== toolsB.totalCalls || toolsA.totalSuccess !== toolsB.totalSuccess || toolsA.totalFail !== toolsB.totalFail || toolsA.totalDurationMs !== toolsB.totalDurationMs) {
+    return false;
+  }
+  if (toolsA.totalDecisions["accept" /* ACCEPT */] !== toolsB.totalDecisions["accept" /* ACCEPT */] || toolsA.totalDecisions["reject" /* REJECT */] !== toolsB.totalDecisions["reject" /* REJECT */] || toolsA.totalDecisions["modify" /* MODIFY */] !== toolsB.totalDecisions["modify" /* MODIFY */] || toolsA.totalDecisions["auto_accept" /* AUTO_ACCEPT */] !== toolsB.totalDecisions["auto_accept" /* AUTO_ACCEPT */]) {
+    return false;
+  }
+  const toolsByNameAKeys = Object.keys(toolsA.byName);
+  const toolsByNameBKeys = Object.keys(toolsB.byName);
+  if (toolsByNameAKeys.length !== toolsByNameBKeys.length) return false;
+  for (const key of toolsByNameAKeys) {
+    const toolA = toolsA.byName[key];
+    const toolB = toolsB.byName[key];
+    if (!toolB || !areToolCallStatsEqual(toolA, toolB)) {
+      return false;
+    }
+  }
+  if (!areSkillMetricsEqual(
+    a.skills ?? EMPTY_SKILL_METRICS,
+    b.skills ?? EMPTY_SKILL_METRICS
+  )) {
+    return false;
+  }
+  const modelsAKeys = Object.keys(a.models);
+  const modelsBKeys = Object.keys(b.models);
+  if (modelsAKeys.length !== modelsBKeys.length) return false;
+  for (const key of modelsAKeys) {
+    if (!b.models[key] || !areModelMetricsEqual(a.models[key], b.models[key])) {
+      return false;
+    }
+  }
+  return true;
+}
+__name(areMetricsEqual, "areMetricsEqual");
+function cloneSessionMetrics(metrics) {
+  return {
+    models: Object.fromEntries(
+      Object.entries(metrics.models).map(([name, model]) => [
+        name,
+        {
+          api: { ...model.api },
+          tokens: { ...model.tokens },
+          bySource: Object.fromEntries(
+            Object.entries(model.bySource).map(([source, sourceMetrics]) => [
+              source,
+              {
+                api: { ...sourceMetrics.api },
+                tokens: { ...sourceMetrics.tokens }
+              }
+            ])
+          )
+        }
+      ])
+    ),
+    ...metrics.generation ? {
+      generation: {
+        timedRequests: metrics.generation.timedRequests,
+        totalTtftMs: metrics.generation.totalTtftMs,
+        totalGenerationDurationMs: metrics.generation.totalGenerationDurationMs,
+        totalThroughputOutputTokens: metrics.generation.totalThroughputOutputTokens,
+        ...metrics.generation.last ? { last: { ...metrics.generation.last } } : {}
+      }
+    } : {},
+    tools: {
+      totalCalls: metrics.tools.totalCalls,
+      totalSuccess: metrics.tools.totalSuccess,
+      totalFail: metrics.tools.totalFail,
+      totalDurationMs: metrics.tools.totalDurationMs,
+      totalDecisions: { ...metrics.tools.totalDecisions },
+      byName: Object.fromEntries(
+        Object.entries(metrics.tools.byName).map(([name, stats]) => [
+          name,
+          {
+            count: stats.count,
+            success: stats.success,
+            fail: stats.fail,
+            durationMs: stats.durationMs,
+            decisions: { ...stats.decisions }
+          }
+        ])
+      )
+    },
+    files: {
+      totalLinesAdded: metrics.files.totalLinesAdded,
+      totalLinesRemoved: metrics.files.totalLinesRemoved
+    },
+    ...metrics.skills ? {
+      skills: {
+        totalCalls: metrics.skills.totalCalls,
+        totalSuccess: metrics.skills.totalSuccess,
+        totalFail: metrics.skills.totalFail,
+        byName: Object.fromEntries(
+          Object.entries(metrics.skills.byName).map(([name, stats]) => [
+            name,
+            {
+              count: stats.count,
+              success: stats.success,
+              fail: stats.fail
+            }
+          ])
+        )
+      }
+    } : {}
+  };
+}
+__name(cloneSessionMetrics, "cloneSessionMetrics");
+function getMetricsForDisplay(sessionId) {
+  return cloneSessionMetrics(
+    sessionId ? uiTelemetryService.getMetricsForSession(sessionId) : uiTelemetryService.getMetrics()
+  );
+}
+__name(getMetricsForDisplay, "getMetricsForDisplay");
+var SessionStatsContext = (0, import_react.createContext)(
+  void 0
+);
+var createDefaultStats = /* @__PURE__ */ __name((sessionId = "") => ({
+  sessionId,
+  sessionStartTime: /* @__PURE__ */ new Date(),
+  metrics: getMetricsForDisplay(sessionId),
+  lastPromptTokenCount: 0,
+  promptCount: 0
+}), "createDefaultStats");
+var SessionStatsProvider = /* @__PURE__ */ __name(({ sessionId, children }) => {
+  const [stats, setStats] = (0, import_react.useState)(
+    () => createDefaultStats(sessionId ?? "")
+  );
+  (0, import_react.useEffect)(() => {
+    const handleUpdate = /* @__PURE__ */ __name(({
+      metrics,
+      lastPromptTokenCount
+    }) => {
+      setStats((prevState) => {
+        const nextMetrics = prevState.sessionId ? getMetricsForDisplay(prevState.sessionId) : cloneSessionMetrics(metrics);
+        if (prevState.lastPromptTokenCount === lastPromptTokenCount && areMetricsEqual(prevState.metrics, nextMetrics)) {
+          return prevState;
+        }
+        return {
+          ...prevState,
+          metrics: nextMetrics,
+          lastPromptTokenCount
+        };
+      });
+    }, "handleUpdate");
+    uiTelemetryService.on("update", handleUpdate);
+    handleUpdate({
+      metrics: uiTelemetryService.getMetrics(),
+      lastPromptTokenCount: uiTelemetryService.getLastPromptTokenCount()
+    });
+    return () => {
+      uiTelemetryService.off("update", handleUpdate);
+    };
+  }, []);
+  const startNewSession = (0, import_react.useCallback)((sessionId2) => {
+    setStats(() => ({
+      ...createDefaultStats(sessionId2),
+      lastPromptTokenCount: uiTelemetryService.getLastPromptTokenCount()
+    }));
+  }, []);
+  const startNewPrompt = (0, import_react.useCallback)(() => {
+    setStats((prevState) => ({
+      ...prevState,
+      promptCount: prevState.promptCount + 1
+    }));
+  }, []);
+  const getPromptCount = (0, import_react.useCallback)(
+    () => stats.promptCount,
+    [stats.promptCount]
+  );
+  const seedPromptCount = (0, import_react.useCallback)((count) => {
+    setStats((prevState) => ({
+      ...prevState,
+      promptCount: Math.max(prevState.promptCount, count)
+    }));
+  }, []);
+  const value = (0, import_react.useMemo)(
+    () => ({
+      stats,
+      startNewSession,
+      startNewPrompt,
+      getPromptCount,
+      seedPromptCount
+    }),
+    [stats, startNewSession, startNewPrompt, getPromptCount, seedPromptCount]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(SessionStatsContext.Provider, { value, children });
+}, "SessionStatsProvider");
+var useSessionStats = /* @__PURE__ */ __name(() => {
+  const context = (0, import_react.useContext)(SessionStatsContext);
+  if (context === void 0) {
+    throw new Error(
+      "useSessionStats must be used within a SessionStatsProvider"
+    );
+  }
+  return context;
+}, "useSessionStats");
+
+// packages/cli/src/ui/utils/osc8.ts
+init_esbuild_shims();
+function osc8Open(url) {
+  return wrapForMultiplexer(`\x1B]8;;${sanitizeForOsc(url)}\x07`);
+}
+__name(osc8Open, "osc8Open");
+function osc8Close() {
+  return wrapForMultiplexer(`\x1B]8;;\x07`);
+}
+__name(osc8Close, "osc8Close");
+var SAFE_OSC8_SCHEMES = /* @__PURE__ */ new Set([
+  "http:",
+  "https:",
+  "mailto:",
+  "ftp:",
+  "ftps:",
+  "sftp:",
+  "ssh:"
+]);
+function isSafeOscScheme(url) {
+  const match = url.match(/^([a-z][a-z0-9+.-]*:)/i);
+  if (!match) return false;
+  return SAFE_OSC8_SCHEMES.has(match[1].toLowerCase());
+}
+__name(isSafeOscScheme, "isSafeOscScheme");
+var BARE_URL_BREAK_CHARACTERS = String.raw`\u3001-\u3004\u3008-\u3020\u302e-\u3030\u3036-\u3037\u303d-\u303f\uff01-\uff0f\uff1a-\uff20\uff3b-\uff40\uff5b-\uff65\ufe10-\ufe1f\ufe30-\ufe32\ufe35-\ufe6f`;
+var BARE_URL_BREAK_PATTERN = new RegExp(`[${BARE_URL_BREAK_CHARACTERS}]`);
+function trimTrailingUrlPunctuation(url, nextCharacter = "") {
+  let openParen = 0;
+  let openBracket = 0;
+  let openBrace = 0;
+  let closeParen = 0;
+  let closeBracket = 0;
+  let closeBrace = 0;
+  for (let i = 0; i < url.length; i++) {
+    const cc = url.charCodeAt(i);
+    if (cc === 40) openParen++;
+    else if (cc === 91) openBracket++;
+    else if (cc === 123) openBrace++;
+    else if (cc === 41) closeParen++;
+    else if (cc === 93) closeBracket++;
+    else if (cc === 125) closeBrace++;
+  }
+  let end = url.length;
+  if (url.charCodeAt(end - 1) === 95 && BARE_URL_BREAK_PATTERN.test(nextCharacter)) {
+    end--;
+  }
+  while (end > 0) {
+    const c = url.charCodeAt(end - 1);
+    if (c === 46 || c === 44 || c === 59 || c === 58 || c === 33 || c === 63 || c === 39 || c === 34 || c === 96 || c === 62) {
+      end--;
+      continue;
+    }
+    if (c === 41 && closeParen > openParen) {
+      closeParen--;
+      end--;
+      continue;
+    }
+    if (c === 93 && closeBracket > openBracket) {
+      closeBracket--;
+      end--;
+      continue;
+    }
+    if (c === 125 && closeBrace > openBrace) {
+      closeBrace--;
+      end--;
+      continue;
+    }
+    break;
+  }
+  return url.slice(0, end);
+}
+__name(trimTrailingUrlPunctuation, "trimTrailingUrlPunctuation");
+var MD_LINK_PATTERN = String.raw`\[.*?\]\((?:[^()]|\([^()]*\))*\)`;
+var MD_LINK_CAPTURE = /^\[(.*?)\]\(((?:[^()]|\([^()]*\))*)\)$/;
+var BARE_URL_PATTERN = String.raw`https?:\/\/[^\s${BARE_URL_BREAK_CHARACTERS}]+`;
+function shouldWrapMarkdownLink(url, canHyperlink) {
+  return canHyperlink && isSafeOscScheme(url) && !/\s/.test(url);
+}
+__name(shouldWrapMarkdownLink, "shouldWrapMarkdownLink");
+var HOST_LIKE_RE = /\b[a-z0-9](?:[a-z0-9-]{0,62}[a-z0-9])?(?:\.[a-z0-9](?:[a-z0-9-]{0,62}[a-z0-9])?)*\.[a-z]{2,}\b/gi;
+var IPV4_LIKE_RE = /\b(?:\d{1,3}\.){3}\d{1,3}\b/g;
+function targetHostname(url) {
+  try {
+    const u = new URL(url);
+    if (u.protocol === "mailto:") {
+      const at = u.pathname.lastIndexOf("@");
+      return at >= 0 ? u.pathname.slice(at + 1).toLowerCase() || void 0 : void 0;
+    }
+    return u.hostname.toLowerCase() || void 0;
+  } catch {
+    return void 0;
+  }
+}
+__name(targetHostname, "targetHostname");
+function labelMayDeceive(label, url) {
+  if (label === url) return false;
+  if (/:\/\//.test(label) || /^[a-z][a-z0-9+.-]*:/i.test(label.trim())) {
+    return true;
+  }
+  const lower = label.toLowerCase();
+  const labelHosts = [
+    ...lower.match(HOST_LIKE_RE) ?? [],
+    ...lower.match(IPV4_LIKE_RE) ?? []
+  ];
+  if (labelHosts.length === 0) return false;
+  const target = targetHostname(url);
+  if (!target) return true;
+  return labelHosts.some((h) => h !== target);
+}
+__name(labelMayDeceive, "labelMayDeceive");
+
+// packages/cli/src/ui/keyMatchers.ts
+init_esbuild_shims();
+
+// packages/cli/src/config/keyBindings.ts
+init_esbuild_shims();
+var Command = /* @__PURE__ */ ((Command2) => {
+  Command2["RETURN"] = "return";
+  Command2["ESCAPE"] = "escape";
+  Command2["HOME"] = "home";
+  Command2["END"] = "end";
+  Command2["KILL_LINE_RIGHT"] = "killLineRight";
+  Command2["KILL_LINE_LEFT"] = "killLineLeft";
+  Command2["CLEAR_INPUT"] = "clearInput";
+  Command2["DELETE_WORD_BACKWARD"] = "deleteWordBackward";
+  Command2["CLEAR_SCREEN"] = "clearScreen";
+  Command2["HISTORY_UP"] = "historyUp";
+  Command2["HISTORY_DOWN"] = "historyDown";
+  Command2["NAVIGATION_UP"] = "navigationUp";
+  Command2["NAVIGATION_DOWN"] = "navigationDown";
+  Command2["SELECTION_UP"] = "selectionUp";
+  Command2["SELECTION_DOWN"] = "selectionDown";
+  Command2["ACCEPT_SUGGESTION"] = "acceptSuggestion";
+  Command2["COMPLETION_UP"] = "completionUp";
+  Command2["COMPLETION_DOWN"] = "completionDown";
+  Command2["COMPLETION_TAB_LEFT"] = "completionTabLeft";
+  Command2["COMPLETION_TAB_RIGHT"] = "completionTabRight";
+  Command2["SUBMIT"] = "submit";
+  Command2["QUEUE_MESSAGE"] = "queueMessage";
+  Command2["NEWLINE"] = "newline";
+  Command2["VOICE_PUSH_TO_TALK"] = "voicePushToTalk";
+  Command2["OPEN_EXTERNAL_EDITOR"] = "openExternalEditor";
+  Command2["PASTE_CLIPBOARD_IMAGE"] = "pasteClipboardImage";
+  Command2["TOGGLE_TOOL_DESCRIPTIONS"] = "toggleToolDescriptions";
+  Command2["TOGGLE_IDE_CONTEXT_DETAIL"] = "toggleIDEContextDetail";
+  Command2["QUIT"] = "quit";
+  Command2["EXIT"] = "exit";
+  Command2["SHOW_MORE_LINES"] = "showMoreLines";
+  Command2["RETRY_LAST"] = "retryLast";
+  Command2["TOGGLE_RENDER_MODE"] = "toggleRenderMode";
+  Command2["PROMOTE_SHELL_TO_BACKGROUND"] = "promoteShellToBackground";
+  Command2["REVERSE_SEARCH"] = "reverseSearch";
+  Command2["SUBMIT_REVERSE_SEARCH"] = "submitReverseSearch";
+  Command2["ACCEPT_SUGGESTION_REVERSE_SEARCH"] = "acceptSuggestionReverseSearch";
+  Command2["TOGGLE_SHELL_INPUT_FOCUS"] = "toggleShellInputFocus";
+  Command2["EXPAND_SUGGESTION"] = "expandSuggestion";
+  Command2["COLLAPSE_SUGGESTION"] = "collapseSuggestion";
+  Command2["TOGGLE_THINKING_EXPANDED"] = "toggleThinkingExpanded";
+  Command2["SCROLL_UP"] = "scrollUp";
+  Command2["SCROLL_DOWN"] = "scrollDown";
+  Command2["PAGE_UP"] = "pageUp";
+  Command2["PAGE_DOWN"] = "pageDown";
+  Command2["SCROLL_HOME"] = "scrollHome";
+  Command2["SCROLL_END"] = "scrollEnd";
+  return Command2;
+})(Command || {});
+var defaultKeyBindings = {
+  // Basic bindings
+  ["return" /* RETURN */]: [{ key: "return" }],
+  ["escape" /* ESCAPE */]: [{ key: "escape" }],
+  // Cursor movement
+  ["home" /* HOME */]: [{ key: "a", ctrl: true }],
+  ["end" /* END */]: [{ key: "e", ctrl: true }],
+  // Text deletion
+  ["killLineRight" /* KILL_LINE_RIGHT */]: [{ key: "k", ctrl: true }],
+  ["killLineLeft" /* KILL_LINE_LEFT */]: [{ key: "u", ctrl: true }],
+  ["clearInput" /* CLEAR_INPUT */]: [{ key: "c", ctrl: true, shift: false }],
+  // Added command (meta/alt/option) for mac compatibility
+  ["deleteWordBackward" /* DELETE_WORD_BACKWARD */]: [
+    { key: "backspace", ctrl: true },
+    { key: "backspace", command: true },
+    // MinTTY (Git Bash on Windows) emits the byte \x1f (ASCII Unit
+    // Separator, rendered as "^_" by `cat -v`) for Ctrl+Backspace under
+    // its standard Ctrl-modifies-meta-keys convention. The same byte is
+    // the historical Ctrl-mapping of the Unit Separator on traditional
+    // ANSI/VT terminals (Ctrl+_ and Ctrl+/ also emit it), but qwen-code
+    // doesn't bind those keystrokes elsewhere so this entry is additive
+    // and non-conflicting on every platform.
+    { sequence: "" }
+  ],
+  // Screen control
+  ["clearScreen" /* CLEAR_SCREEN */]: [{ key: "l", ctrl: true }],
+  // History navigation
+  ["historyUp" /* HISTORY_UP */]: [{ key: "p", ctrl: true }],
+  ["historyDown" /* HISTORY_DOWN */]: [{ key: "n", ctrl: true }],
+  ["navigationUp" /* NAVIGATION_UP */]: [{ key: "up", shift: false }],
+  ["navigationDown" /* NAVIGATION_DOWN */]: [{ key: "down", shift: false }],
+  // Selection-list nav: arrows + k/j + Ctrl+P/Ctrl+N
+  // ctrl: false on bare k/j skips Ctrl+K and Ctrl+J
+  ["selectionUp" /* SELECTION_UP */]: [
+    { key: "up", shift: false },
+    { key: "k", ctrl: false },
+    { key: "p", ctrl: true }
+  ],
+  ["selectionDown" /* SELECTION_DOWN */]: [
+    { key: "down", shift: false },
+    { key: "j", ctrl: false },
+    { key: "n", ctrl: true }
+  ],
+  // Auto-completion
+  ["acceptSuggestion" /* ACCEPT_SUGGESTION */]: [
+    { key: "tab" },
+    { key: "return", ctrl: false, shift: false }
+  ],
+  // Completion navigation: arrows + readline/Vim-style Ctrl+P/Ctrl+N
+  ["completionUp" /* COMPLETION_UP */]: [
+    { key: "up", shift: false },
+    { key: "p", ctrl: true }
+  ],
+  ["completionDown" /* COMPLETION_DOWN */]: [
+    { key: "down", shift: false },
+    { key: "n", ctrl: true }
+  ],
+  // Completion category tab switching (for the tabbed @ completion UI).
+  // Bound to the BARE arrow keys: Ctrl+←/→ was the original binding but many
+  // terminals intercept it for word-jump, and on macOS the system claims it
+  // for Mission Control, so the documented gesture was unreachable for most
+  // users (#8069).
+  //
+  // Tradeoff, accepted deliberately: while the `@` category tabs are visible,
+  // the bare arrows no longer move the caret in the input buffer — press Esc
+  // to dismiss the menu first. InputPrompt only renders and handles the tabs
+  // when they own the arrows, so search and attachment navigation keep their
+  // normal behavior.
+  //
+  // Modifiers are pinned false so Alt/Option+arrow word movement and any
+  // Ctrl+arrow terminal binding fall through untouched.
+  ["completionTabLeft" /* COMPLETION_TAB_LEFT */]: [
+    { key: "left", shift: false, ctrl: false, meta: false }
+  ],
+  ["completionTabRight" /* COMPLETION_TAB_RIGHT */]: [
+    { key: "right", shift: false, ctrl: false, meta: false }
+  ],
+  // Text input
+  // Must also exclude shift to allow shift+enter for newline
+  ["submit" /* SUBMIT */]: [
+    {
+      key: "return",
+      ctrl: false,
+      command: false,
+      paste: false,
+      shift: false
+    }
+  ],
+  ["queueMessage" /* QUEUE_MESSAGE */]: [
+    { key: "q", ctrl: true, command: false, shift: false, paste: false }
+  ],
+  // Split into multiple data-driven bindings
+  // Now also includes shift+enter for multi-line input
+  ["newline" /* NEWLINE */]: [
+    { key: "return", ctrl: true },
+    { key: "return", command: true },
+    { key: "return", paste: true },
+    { key: "return", shift: true },
+    { key: "j", ctrl: true }
+  ],
+  ["voicePushToTalk" /* VOICE_PUSH_TO_TALK */]: [{ key: "space", ctrl: false, meta: false }],
+  // External tools
+  ["openExternalEditor" /* OPEN_EXTERNAL_EDITOR */]: [
+    { key: "x", ctrl: true },
+    { sequence: "", ctrl: true }
+  ],
+  ["pasteClipboardImage" /* PASTE_CLIPBOARD_IMAGE */]: process.platform === "win32" ? [
+    { key: "v", command: true },
+    { key: "v", meta: true }
+  ] : [
+    { key: "v", ctrl: true },
+    { key: "v", command: true }
+  ],
+  // App level bindings
+  ["toggleToolDescriptions" /* TOGGLE_TOOL_DESCRIPTIONS */]: [{ key: "t", ctrl: true }],
+  ["toggleIDEContextDetail" /* TOGGLE_IDE_CONTEXT_DETAIL */]: [{ key: "g", ctrl: true }],
+  ["quit" /* QUIT */]: [{ key: "c", ctrl: true, shift: false }],
+  ["exit" /* EXIT */]: [{ key: "d", ctrl: true }],
+  ["showMoreLines" /* SHOW_MORE_LINES */]: [{ key: "s", ctrl: true }],
+  ["retryLast" /* RETRY_LAST */]: [{ key: "y", ctrl: true }],
+  ["toggleRenderMode" /* TOGGLE_RENDER_MODE */]: [{ key: "m", meta: true }],
+  ["promoteShellToBackground" /* PROMOTE_SHELL_TO_BACKGROUND */]: [{ key: "b", ctrl: true }],
+  // Shell commands
+  ["reverseSearch" /* REVERSE_SEARCH */]: [{ key: "r", ctrl: true }],
+  // Note: original logic ONLY checked ctrl=false, ignored meta/shift/paste
+  ["submitReverseSearch" /* SUBMIT_REVERSE_SEARCH */]: [{ key: "return", ctrl: false }],
+  ["acceptSuggestionReverseSearch" /* ACCEPT_SUGGESTION_REVERSE_SEARCH */]: [{ key: "tab" }],
+  ["toggleShellInputFocus" /* TOGGLE_SHELL_INPUT_FOCUS */]: [{ key: "f", ctrl: true }],
+  // Suggestion expansion
+  ["expandSuggestion" /* EXPAND_SUGGESTION */]: [{ key: "right" }],
+  ["collapseSuggestion" /* COLLAPSE_SUGGESTION */]: [{ key: "left" }],
+  // Thinking expansion (Ctrl+O primary, Alt+T legacy)
+  ["toggleThinkingExpanded" /* TOGGLE_THINKING_EXPANDED */]: [
+    { key: "o", ctrl: true },
+    { key: "t", meta: true }
+  ],
+  // Scroll commands
+  ["scrollUp" /* SCROLL_UP */]: [{ key: "up", shift: true }],
+  ["scrollDown" /* SCROLL_DOWN */]: [{ key: "down", shift: true }],
+  ["pageUp" /* PAGE_UP */]: [{ key: "pageup" }],
+  ["pageDown" /* PAGE_DOWN */]: [{ key: "pagedown" }],
+  ["scrollHome" /* SCROLL_HOME */]: [{ key: "home", ctrl: true }],
+  ["scrollEnd" /* SCROLL_END */]: [{ key: "end", ctrl: true }]
+};
+
+// packages/cli/src/ui/keyMatchers.ts
+function matchKeyBinding(keyBinding, key) {
+  let keyMatches = false;
+  if (keyBinding.key !== void 0) {
+    keyMatches = keyBinding.key === key.name;
+  } else if (keyBinding.sequence !== void 0) {
+    keyMatches = keyBinding.sequence === key.sequence;
+  } else {
+    return false;
+  }
+  if (!keyMatches) {
+    return false;
+  }
+  if (keyBinding.ctrl !== void 0 && !!key.ctrl !== keyBinding.ctrl) {
+    return false;
+  }
+  if (keyBinding.shift !== void 0 && !!key.shift !== keyBinding.shift) {
+    return false;
+  }
+  if (keyBinding.command !== void 0 && !!key.meta !== keyBinding.command) {
+    return false;
+  }
+  if (keyBinding.paste !== void 0 && !!key.paste !== keyBinding.paste) {
+    return false;
+  }
+  if (keyBinding.meta !== void 0 && !!key.meta !== keyBinding.meta) {
+    return false;
+  }
+  return true;
+}
+__name(matchKeyBinding, "matchKeyBinding");
+function matchCommand(command, key, config = defaultKeyBindings) {
+  const bindings = config[command];
+  return bindings.some((binding) => matchKeyBinding(binding, key));
+}
+__name(matchCommand, "matchCommand");
+function createKeyMatchers(config = defaultKeyBindings) {
+  const matchers = {};
+  for (const command of Object.values(Command)) {
+    matchers[command] = (key) => matchCommand(command, key, config);
+  }
+  return matchers;
+}
+__name(createKeyMatchers, "createKeyMatchers");
+var keyMatchers = createKeyMatchers(defaultKeyBindings);
+
+// packages/cli/src/ui/utils/tool-display-map.ts
+init_esbuild_shims();
+var TOOL_DISPLAY_BY_NAME = Object.fromEntries(
+  Object.keys(ToolNames).map((key) => [
+    ToolNames[key],
+    ToolDisplayNames[key]
+  ])
+);
+
+// packages/cli/src/ui/utils/displayUtils.ts
+init_esbuild_shims();
+function getArenaStatusLabel(status) {
+  switch (status) {
+    case "idle" /* IDLE */:
+      return { icon: "\u2713", text: "Idle", color: theme.status.success };
+    case "completed" /* COMPLETED */:
+      return { icon: "\u2713", text: "Done", color: theme.status.success };
+    case "cancelled" /* CANCELLED */:
+      return { icon: "\u2298", text: "Cancelled", color: theme.status.warning };
+    case "failed" /* FAILED */:
+      return { icon: "\u2717", text: "Failed", color: theme.status.error };
+    case "running" /* RUNNING */:
+      return {
+        icon: ICON.CIRCLE_EMPTY,
+        text: "Running",
+        color: theme.text.secondary
+      };
+    case "initializing" /* INITIALIZING */:
+      return {
+        icon: ICON.CIRCLE_EMPTY,
+        text: "Initializing",
+        color: theme.text.secondary
+      };
+    default:
+      return {
+        icon: ICON.CIRCLE_EMPTY,
+        text: status,
+        color: theme.text.secondary
+      };
+  }
+}
+__name(getArenaStatusLabel, "getArenaStatusLabel");
+var TOOL_SUCCESS_RATE_HIGH = 95;
+var TOOL_SUCCESS_RATE_MEDIUM = 85;
+var USER_AGREEMENT_RATE_HIGH = 75;
+var USER_AGREEMENT_RATE_MEDIUM = 45;
+var getStatusColor = /* @__PURE__ */ __name((value, thresholds, options = {}) => {
+  if (value >= thresholds.green) {
+    return theme.status.success;
+  }
+  if (value >= thresholds.yellow) {
+    return theme.status.warning;
+  }
+  if (thresholds.red != null && value >= thresholds.red) {
+    return theme.status.error;
+  }
+  return options.defaultColor ?? theme.status.error;
+}, "getStatusColor");
+function formatDuration(ms) {
+  const totalSeconds = Math.round(ms / 1e3);
+  if (totalSeconds < 60) {
+    return `${totalSeconds}s`;
+  }
+  const minutes = Math.floor(totalSeconds / 60);
+  const seconds = totalSeconds % 60;
+  return seconds > 0 ? `${minutes}m ${seconds}s` : `${minutes}m`;
+}
+__name(formatDuration, "formatDuration");
+
+export {
+  osc8Open,
+  osc8Close,
+  isSafeOscScheme,
+  trimTrailingUrlPunctuation,
+  MD_LINK_PATTERN,
+  MD_LINK_CAPTURE,
+  BARE_URL_PATTERN,
+  shouldWrapMarkdownLink,
+  labelMayDeceive,
+  getArenaStatusLabel,
+  TOOL_SUCCESS_RATE_HIGH,
+  TOOL_SUCCESS_RATE_MEDIUM,
+  USER_AGREEMENT_RATE_HIGH,
+  USER_AGREEMENT_RATE_MEDIUM,
+  getStatusColor,
+  formatDuration,
+  keyMatchers,
+  TOOL_DISPLAY_BY_NAME,
+  SessionStatsProvider,
+  useSessionStats
+};
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */