@qwen-code/qwen-code 0.19.3-nightly.20260701.a974594d7 → 0.19.4

package/chunks/{chunk-T44AF4I6.js → chunk-BNJLLAQ7.js}

@@ -5,7 +5,7 @@ import {
   isTranscribableVoiceModel,
   readVoiceLanguage,
   resolveVoiceTransport
-} from "./chunk-LXEW6BHF.js";
+} from "./chunk-Q7VHIRDD.js";
 import {
   resolvePath
 } from "./chunk-NIOPRZNN.js";

package/chunks/{chunk-OEY3YAL2.js → chunk-BQNJBEUA.js}

@@ -4,14 +4,14 @@ import {
   resolveModelConfig,
   resolveProviderProtocol,
   stripRuntimeSnapshotPrefix
-} from "./chunk-35FH347N.js";
+} from "./chunk-BFG6OZN7.js";
 import {
   external_exports
 } from "./chunk-K5PGHDBN.js";
 import {
   AuthType,
   MODEL_GENERATION_CONFIG_FIELDS
-} from "./chunk-B5MPZI4K.js";
+} from "./chunk-HJDF3ZVU.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";

package/chunks/{chunk-Q7TDHJ2G.js → chunk-C2IHHGBZ.js}

@@ -2,13 +2,13 @@
 "use strict";
 import {
   handleAtCommand
-} from "./chunk-YCEHOJZJ.js";
+} from "./chunk-MNDTD5E5.js";
 import {
   JsonOutputAdapter
-} from "./chunk-EUURTJY7.js";
+} from "./chunk-PIYV6COW.js";
 import {
   StreamJsonOutputAdapter
-} from "./chunk-NVTRORSK.js";
+} from "./chunk-7VPC7D7O.js";
 import {
   buildInitialSystemReminders,
   buildSystemMessage,
@@ -20,10 +20,10 @@ import {
   insertAfterFunctionResponses,
   isSlashCommand,
   normalizePartList
-} from "./chunk-NOYV2NXI.js";
+} from "./chunk-ZXCVPMIK.js";
 import {
   RunBudgetEnforcer
-} from "./chunk-ZGSV5ORL.js";
+} from "./chunk-MVZXZWGT.js";
 import {
   AlreadyReportedError,
   handleBudgetExceededError,
@@ -31,10 +31,10 @@ import {
   handleError,
   handleMaxTurnsExceededError,
   handleToolError
-} from "./chunk-AIBPG5MB.js";
+} from "./chunk-OAFUMTWW.js";
 import {
   isInlineModelOverrideAllowed
-} from "./chunk-OEY3YAL2.js";
+} from "./chunk-BQNJBEUA.js";
 import {
   ORPHAN_TOOL_USE_REPAIR_REASON,
   buildSyntheticToolResponseParts,
@@ -49,15 +49,15 @@ import {
   parseAndFormatApiError,
   promptIdContext,
   restoreWorktreeContext
-} from "./chunk-35FH347N.js";
+} from "./chunk-BFG6OZN7.js";
 import {
   isTelemetrySdkInitialized,
   shutdownTelemetry,
   uiTelemetryService
-} from "./chunk-B5MPZI4K.js";
+} from "./chunk-HJDF3ZVU.js";
 import {
   ToolNames
-} from "./chunk-JV7A66DR.js";
+} from "./chunk-4VZH35PN.js";
 import {
   FatalInputError,
   createDebugLogger

package/chunks/chunk-CG7SVARK.js

@@ -0,0 +1,367 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  disableMouseEvents,
+  enableMouseEvents,
+  useKeypressContext
+} from "./chunk-75X2VLSH.js";
+import {
+  use_stdin_default,
+  use_stdout_default
+} from "./chunk-2X2JUE47.js";
+import {
+  require_react
+} from "./chunk-KYMBIKIW.js";
+import {
+  themeManager
+} from "./chunk-HTWHAN44.js";
+import {
+  init_esbuild_shims
+} from "./chunk-A4BMJM77.js";
+import {
+  __name,
+  __toESM
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/ui/contexts/SettingsContext.tsx
+init_esbuild_shims();
+var import_react = __toESM(require_react(), 1);
+var SettingsContext = import_react.default.createContext(
+  void 0
+);
+var useSettings = /* @__PURE__ */ __name(() => {
+  const context = (0, import_react.useContext)(SettingsContext);
+  if (context === void 0) {
+    throw new Error("useSettings must be used within a SettingsProvider");
+  }
+  return context;
+}, "useSettings");
+
+// packages/cli/src/ui/hooks/useTerminalSize.ts
+init_esbuild_shims();
+var import_react2 = __toESM(require_react(), 1);
+function useTerminalSize() {
+  const [size, setSize] = (0, import_react2.useState)({
+    columns: process.stdout.columns || 80,
+    rows: process.stdout.rows || 24
+  });
+  (0, import_react2.useEffect)(() => {
+    function updateSize() {
+      setSize({
+        columns: process.stdout.columns || 80,
+        rows: process.stdout.rows || 24
+      });
+    }
+    __name(updateSize, "updateSize");
+    process.stdout.on("resize", updateSize);
+    return () => {
+      process.stdout.off("resize", updateSize);
+    };
+  }, []);
+  return size;
+}
+__name(useTerminalSize, "useTerminalSize");
+
+// packages/cli/src/ui/hooks/useMouseEvents.ts
+init_esbuild_shims();
+var import_react3 = __toESM(require_react(), 1);
+var mouseModeRefs = /* @__PURE__ */ new Map();
+function effectiveTracking(entry) {
+  if (entry.any > 0) return "any";
+  if (entry.button > 0) return "button";
+  return null;
+}
+__name(effectiveTracking, "effectiveTracking");
+function reconcileMouseMode(stdout, entry) {
+  const desired = effectiveTracking(entry);
+  if (desired === entry.active) return;
+  if (entry.active) disableMouseEvents(stdout, entry.active);
+  if (desired) enableMouseEvents(stdout, desired);
+  entry.active = desired;
+}
+__name(reconcileMouseMode, "reconcileMouseMode");
+var disableAllMouseModes = /* @__PURE__ */ __name(() => {
+  for (const [stdout, entry] of mouseModeRefs) {
+    if (entry.active) disableMouseEvents(stdout, entry.active);
+  }
+  mouseModeRefs.clear();
+}, "disableAllMouseModes");
+function acquireMouseMode(stdout, tracking) {
+  let entry = mouseModeRefs.get(stdout);
+  if (!entry) {
+    if (mouseModeRefs.size === 0) {
+      process.on("exit", disableAllMouseModes);
+    }
+    entry = { button: 0, any: 0, active: null };
+    mouseModeRefs.set(stdout, entry);
+  }
+  entry[tracking] += 1;
+  reconcileMouseMode(stdout, entry);
+}
+__name(acquireMouseMode, "acquireMouseMode");
+function releaseMouseMode(stdout, tracking) {
+  const entry = mouseModeRefs.get(stdout);
+  if (!entry) return;
+  entry[tracking] = Math.max(0, entry[tracking] - 1);
+  reconcileMouseMode(stdout, entry);
+  if (entry.button === 0 && entry.any === 0) {
+    mouseModeRefs.delete(stdout);
+    if (mouseModeRefs.size === 0) {
+      process.removeListener("exit", disableAllMouseModes);
+    }
+  }
+}
+__name(releaseMouseMode, "releaseMouseMode");
+function useMouseEvents(handler, { isActive, tracking = "button", bypassVpGate = false }) {
+  const { isRawModeSupported } = use_stdin_default();
+  const { stdout } = use_stdout_default();
+  const { subscribeMouse, unsubscribeMouse } = useKeypressContext();
+  const settings = (0, import_react3.useContext)(SettingsContext);
+  const isVpMode = settings?.merged.ui?.useTerminalBuffer ?? false;
+  const vpGateOpen = isVpMode || bypassVpGate;
+  const handlerRef = (0, import_react3.useRef)(handler);
+  handlerRef.current = handler;
+  const enabled = isActive && isRawModeSupported && vpGateOpen;
+  (0, import_react3.useEffect)(() => {
+    if (!enabled) return;
+    acquireMouseMode(stdout, tracking);
+    return () => {
+      releaseMouseMode(stdout, tracking);
+    };
+  }, [enabled, stdout, tracking]);
+  const mouseCallback = (0, import_react3.useCallback)((event) => {
+    handlerRef.current(event);
+  }, []);
+  (0, import_react3.useEffect)(() => {
+    if (!enabled) return;
+    subscribeMouse(mouseCallback);
+    return () => unsubscribeMouse(mouseCallback);
+  }, [enabled, subscribeMouse, unsubscribeMouse, mouseCallback]);
+}
+__name(useMouseEvents, "useMouseEvents");
+
+// packages/cli/src/ui/colors.ts
+init_esbuild_shims();
+var Colors = {
+  get type() {
+    return themeManager.getActiveTheme().colors.type;
+  },
+  get Foreground() {
+    return themeManager.getActiveTheme().colors.Foreground;
+  },
+  get Background() {
+    return themeManager.getActiveTheme().colors.Background;
+  },
+  get LightBlue() {
+    return themeManager.getActiveTheme().colors.LightBlue;
+  },
+  get AccentBlue() {
+    return themeManager.getActiveTheme().colors.AccentBlue;
+  },
+  get AccentPurple() {
+    return themeManager.getActiveTheme().colors.AccentPurple;
+  },
+  get AccentCyan() {
+    return themeManager.getActiveTheme().colors.AccentCyan;
+  },
+  get AccentGreen() {
+    return themeManager.getActiveTheme().colors.AccentGreen;
+  },
+  get AccentYellow() {
+    return themeManager.getActiveTheme().colors.AccentYellow;
+  },
+  get AccentRed() {
+    return themeManager.getActiveTheme().colors.AccentRed;
+  },
+  get AccentYellowDim() {
+    return themeManager.getActiveTheme().colors.AccentYellowDim;
+  },
+  get AccentRedDim() {
+    return themeManager.getActiveTheme().colors.AccentRedDim;
+  },
+  get DiffAdded() {
+    return themeManager.getActiveTheme().colors.DiffAdded;
+  },
+  get DiffRemoved() {
+    return themeManager.getActiveTheme().colors.DiffRemoved;
+  },
+  get Comment() {
+    return themeManager.getActiveTheme().colors.Comment;
+  },
+  get Gray() {
+    return themeManager.getActiveTheme().colors.Gray;
+  },
+  get GradientColors() {
+    return themeManager.getActiveTheme().colors.GradientColors;
+  }
+};
+
+// packages/cli/src/ui/utils/measure-element-position.ts
+init_esbuild_shims();
+
+// packages/cli/src/ui/utils/list-mouse.ts
+init_esbuild_shims();
+function frameAnchor(terminalHeight, frameHeight) {
+  return Math.min(0, terminalHeight - frameHeight);
+}
+__name(frameAnchor, "frameAnchor");
+function terminalRowToLayoutRow(terminalRow1Based, anchor) {
+  return terminalRow1Based - 1 - anchor;
+}
+__name(terminalRowToLayoutRow, "terminalRowToLayoutRow");
+function findItemAtLayoutRow(rects, layoutRow) {
+  for (const rect of rects) {
+    if (layoutRow >= rect.top && layoutRow < rect.top + rect.height) {
+      return rect.index;
+    }
+  }
+  return null;
+}
+__name(findItemAtLayoutRow, "findItemAtLayoutRow");
+
+// packages/cli/src/ui/utils/measure-element-position.ts
+function measureElementPosition(node) {
+  const { yogaNode } = node;
+  if (!yogaNode) {
+    return { x: 0, y: 0, width: 0, height: 0 };
+  }
+  let x = yogaNode.getComputedLeft();
+  let y = yogaNode.getComputedTop();
+  let current = node.parentNode;
+  while (current) {
+    if (current.yogaNode) {
+      x += current.yogaNode.getComputedLeft();
+      y += current.yogaNode.getComputedTop();
+    }
+    current = current.parentNode;
+  }
+  return {
+    x,
+    y,
+    width: yogaNode.getComputedWidth(),
+    height: yogaNode.getComputedHeight()
+  };
+}
+__name(measureElementPosition, "measureElementPosition");
+function measureFrameHeight(node) {
+  let root = node;
+  let current = node;
+  while (current) {
+    root = current;
+    current = current.parentNode;
+  }
+  return root.yogaNode?.getComputedHeight() ?? 0;
+}
+__name(measureFrameHeight, "measureFrameHeight");
+function layoutRowForEvent(node, terminalRow1Based, terminalHeight) {
+  const anchor = frameAnchor(terminalHeight, measureFrameHeight(node));
+  return terminalRowToLayoutRow(terminalRow1Based, anchor);
+}
+__name(layoutRowForEvent, "layoutRowForEvent");
+
+// packages/cli/src/ui/components/shared/RowMouseController.tsx
+init_esbuild_shims();
+var import_react4 = __toESM(require_react(), 1);
+function RowMouseController({
+  containerRef,
+  itemRefs,
+  scrollOffset,
+  isDisabled,
+  onHoverIndex,
+  onSelectIndex
+}) {
+  const { rows: terminalHeight } = useTerminalSize();
+  const resolveIndex = (0, import_react4.useCallback)(
+    (event) => {
+      const container = containerRef.current;
+      if (!container) return null;
+      const containerRect = measureElementPosition(container);
+      const col0 = event.col - 1;
+      if (containerRect.width > 0 && (col0 < containerRect.x || col0 >= containerRect.x + containerRect.width)) {
+        return null;
+      }
+      const layoutRow = layoutRowForEvent(container, event.row, terminalHeight);
+      const rects = [];
+      const nodes = itemRefs.current;
+      for (let visiblePos = 0; visiblePos < nodes.length; visiblePos++) {
+        const node = nodes[visiblePos];
+        if (!node) continue;
+        const rect = measureElementPosition(node);
+        if (rect.height <= 0) continue;
+        rects.push({
+          index: scrollOffset + visiblePos,
+          top: rect.y,
+          height: rect.height
+        });
+      }
+      return findItemAtLayoutRow(rects, layoutRow);
+    },
+    [containerRef, itemRefs, scrollOffset, terminalHeight]
+  );
+  const handleMouse = (0, import_react4.useCallback)(
+    (event) => {
+      if (event.name !== "move" && event.name !== "left-press") return;
+      const index = resolveIndex(event);
+      if (index === null || isDisabled?.(index)) return;
+      if (event.name === "move") {
+        onHoverIndex(index);
+      } else {
+        onSelectIndex(index);
+      }
+    },
+    [resolveIndex, isDisabled, onHoverIndex, onSelectIndex]
+  );
+  useMouseEvents(handleMouse, { isActive: true, tracking: "any" });
+  return null;
+}
+__name(RowMouseController, "RowMouseController");
+
+export {
+  SettingsContext,
+  useSettings,
+  useTerminalSize,
+  Colors,
+  useMouseEvents,
+  measureElementPosition,
+  layoutRowForEvent,
+  RowMouseController
+};
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Inspired by gemini-cli's MouseContext (Google LLC, Apache-2.0): enable SGR
+ * mouse mode while at least one subscriber is active, parse mouse sequences
+ * out of the KeypressContext pipeline, call each handler, restore on cleanup.
+ */
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Pure geometry helper for mapping a terminal mouse row onto a vertical list of
+ * items. The DOM measurement (reading yoga layout via measureElementPosition)
+ * lives in the component that owns the refs; this is pure arithmetic so it can
+ * be unit-tested without a renderer.
+ */
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Shim for ink PR #968 (vadimdemedes/ink#968): extends measureElement()
+ * to return {x, y, width, height}. Once the upstream PR is merged and
+ * ink is upgraded, replace usages with `measureElement` from 'ink'
+ * and delete this file.
+ */
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-7SP275SH.js → chunk-CS5XYDBO.js}

@@ -5,19 +5,19 @@ import {
 } from "./chunk-3GONHQOA.js";
 import {
   getErrorMessage
-} from "./chunk-AIBPG5MB.js";
+} from "./chunk-OAFUMTWW.js";
 import {
   loadSettings
-} from "./chunk-6FIWYVN4.js";
+} from "./chunk-MKHC4BYZ.js";
 import {
   getCurrentLanguage,
   initializeI18n,
   resolveLanguageSetting,
   t
-} from "./chunk-3O2BJMFW.js";
+} from "./chunk-UQYOMM6J.js";
 import {
   isWorkspaceTrusted
-} from "./chunk-Z34RYLRO.js";
+} from "./chunk-ZJP5T7IA.js";
 import {
   writeStderrLine,
   writeStdoutLine
@@ -29,7 +29,7 @@ import {
   redactUrlCredentials,
   require_prompts,
   stripAnsi
-} from "./chunk-35FH347N.js";
+} from "./chunk-BFG6OZN7.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";

package/chunks/{chunk-V5YJAUHW.js → chunk-CUGEBAKG.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   escapeAnsiCtrlCodes
-} from "./chunk-GDIG7TMG.js";
+} from "./chunk-HRZB5CSC.js";
 import {
   wrapper_default
 } from "./chunk-H6BD2ELD.js";