@qwen-code/qwen-code 0.19.12 → 0.20.0-nightly.20260721.cda0e0348

package/chunks/{channel-worker-group-NEUVTPB2.js → channel-worker-group-QZV2SP5U.js}

@@ -3,13 +3,13 @@
 import {
   ChannelWorkerReconcileError,
   createChannelWorkerGroup
-} from "./chunk-OEHCAWUA.js";
-import "./chunk-EISVEV45.js";
-import "./chunk-I7RRHHYG.js";
+} from "./chunk-ACW3VNUE.js";
+import "./chunk-H24SOJIQ.js";
+import "./chunk-QKTHJXCS.js";
 import "./chunk-TJTKSVIV.js";
 import "./chunk-M5GB774H.js";
 import "./chunk-5HBA2Z7V.js";
-import "./chunk-BKNPMEN6.js";
+import "./chunk-RVLZCXEE.js";
 import "./chunk-UDXSXLER.js";
 import "./chunk-T4TZQJ7W.js";
 import "./chunk-H6XPXXMH.js";

package/chunks/{channel-worker-manager-7CQVOVWV.js → channel-worker-manager-3GMAU45H.js}

@@ -2,18 +2,18 @@
 "use strict";
 import {
   ChannelWorkerReconcileError
-} from "./chunk-OEHCAWUA.js";
+} from "./chunk-ACW3VNUE.js";
 import {
   ChannelWorkerStartupError,
   ChannelWorkerStopError
-} from "./chunk-EISVEV45.js";
+} from "./chunk-H24SOJIQ.js";
 import {
   ChannelWebhookEnqueueError
-} from "./chunk-I7RRHHYG.js";
+} from "./chunk-QKTHJXCS.js";
 import "./chunk-TJTKSVIV.js";
 import "./chunk-M5GB774H.js";
 import "./chunk-5HBA2Z7V.js";
-import "./chunk-BKNPMEN6.js";
+import "./chunk-RVLZCXEE.js";
 import "./chunk-UDXSXLER.js";
 import "./chunk-T4TZQJ7W.js";
 import "./chunk-H6XPXXMH.js";

package/chunks/{channel-worker-supervisor-3BU2KNCZ.js → channel-worker-supervisor-QCXSXCRY.js}

@@ -4,12 +4,12 @@ import {
   ChannelWorkerStartupError,
   ChannelWorkerStopError,
   createChannelWorkerSupervisor
-} from "./chunk-EISVEV45.js";
-import "./chunk-I7RRHHYG.js";
+} from "./chunk-H24SOJIQ.js";
+import "./chunk-QKTHJXCS.js";
 import "./chunk-TJTKSVIV.js";
 import "./chunk-M5GB774H.js";
 import "./chunk-5HBA2Z7V.js";
-import "./chunk-BKNPMEN6.js";
+import "./chunk-RVLZCXEE.js";
 import "./chunk-UDXSXLER.js";
 import "./chunk-T4TZQJ7W.js";
 import "./chunk-H6XPXXMH.js";

package/chunks/{chunk-6ETOSWAO.js → chunk-246TW4IX.js}

@@ -7,16 +7,16 @@ import {
   isQwenQuotaExceededError,
   isRateLimitError,
   retryContext
-} from "./chunk-CPU6I5YV.js";
+} from "./chunk-P64HXIC5.js";
 import {
   isTlsVerificationDisabled
-} from "./chunk-4CHDYDG3.js";
+} from "./chunk-6EFTQYW7.js";
 import {
   createDebugLogger,
   getErrorMessage,
   getErrorStatus,
   isAbortError
-} from "./chunk-UE5TZ55T.js";
+} from "./chunk-C27BYUX6.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-2CCDMJM7.js → chunk-25Y6JSH2.js}

@@ -2,20 +2,20 @@
 "use strict";
 import {
   formatFetchErrorForUser
-} from "./chunk-6ETOSWAO.js";
+} from "./chunk-246TW4IX.js";
 import {
   openBrowserSecurely
 } from "./chunk-JESCGQM3.js";
 import {
   atomicWriteFile
-} from "./chunk-VAJS2E2D.js";
+} from "./chunk-BDBMYST4.js";
 import {
   combineAbortSignals
 } from "./chunk-DJ2GSRLV.js";
 import {
   Storage,
   createDebugLogger
-} from "./chunk-UE5TZ55T.js";
+} from "./chunk-C27BYUX6.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-XSEWNUMZ.js → chunk-2CWOJ2FA.js}

@@ -7,28 +7,28 @@ import {
   parseAcpBaseModelId,
   resolveCliGenerationConfig,
   sanitizeProviderBaseUrl
-} from "./chunk-HVGJWOR6.js";
+} from "./chunk-L4YSPHR4.js";
 import {
   snapshotProcessEnv
-} from "./chunk-5QSVANRT.js";
+} from "./chunk-JR6UJ24K.js";
 import {
   STATUS_SCHEMA_VERSION
-} from "./chunk-64GC5EMF.js";
+} from "./chunk-DZZIOIVF.js";
 import {
   loadSettings
-} from "./chunk-6IITZE7O.js";
+} from "./chunk-5JX5EWR5.js";
 import {
   ModelsConfig
-} from "./chunk-GCY7QTCE.js";
+} from "./chunk-NO6XTCYT.js";
 import {
   APPROVAL_MODES
-} from "./chunk-UOA2IHRI.js";
+} from "./chunk-CPCVCKKF.js";
 import {
   tokenLimit
-} from "./chunk-V4PCIS25.js";
+} from "./chunk-FZVSFBNW.js";
 import {
   createDebugLogger
-} from "./chunk-UE5TZ55T.js";
+} from "./chunk-C27BYUX6.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-UZC5VPOJ.js → chunk-2GFRA3MN.js}

@@ -6,16 +6,16 @@ import {
 import {
   JsonFormatter,
   parseAndFormatApiError
-} from "./chunk-GCY7QTCE.js";
+} from "./chunk-NO6XTCYT.js";
 import {
   FatalBudgetExceededError,
   FatalCancellationError,
   FatalTurnLimitedError,
   createDebugLogger
-} from "./chunk-UE5TZ55T.js";
+} from "./chunk-C27BYUX6.js";
 import {
   runExitCleanup
-} from "./chunk-KMJOMWHE.js";
+} from "./chunk-WRRF6TEQ.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/chunk-2GOPPEHK.js

@@ -0,0 +1,442 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  sanitizeFilenameForDisplay
+} from "./chunk-RS7MT2QG.js";
+import {
+  t
+} from "./chunk-6DHWO5ZF.js";
+import {
+  fetchGitDiff,
+  findProviderByCredentials,
+  resolveMetadataKey
+} from "./chunk-NO6XTCYT.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/ui/utils/computeStats.ts
+init_esbuild_shims();
+function calculateErrorRate(metrics) {
+  if (metrics.api.totalRequests === 0) {
+    return 0;
+  }
+  return metrics.api.totalErrors / metrics.api.totalRequests * 100;
+}
+__name(calculateErrorRate, "calculateErrorRate");
+function calculateAverageLatency(metrics) {
+  if (metrics.api.totalRequests === 0) {
+    return 0;
+  }
+  return metrics.api.totalLatencyMs / metrics.api.totalRequests;
+}
+__name(calculateAverageLatency, "calculateAverageLatency");
+function calculateCacheHitRate(metrics) {
+  if (metrics.tokens.prompt === 0) {
+    return 0;
+  }
+  return metrics.tokens.cached / metrics.tokens.prompt * 100;
+}
+__name(calculateCacheHitRate, "calculateCacheHitRate");
+var computeSessionStats = /* @__PURE__ */ __name((metrics) => {
+  const { models, tools, files } = metrics;
+  const totalApiTime = Object.values(models).reduce(
+    (acc, model) => acc + model.api.totalLatencyMs,
+    0
+  );
+  const totalToolTime = tools.totalDurationMs;
+  const agentActiveTime = totalApiTime + totalToolTime;
+  const apiTimePercent = agentActiveTime > 0 ? totalApiTime / agentActiveTime * 100 : 0;
+  const toolTimePercent = agentActiveTime > 0 ? totalToolTime / agentActiveTime * 100 : 0;
+  const totalCachedTokens = Object.values(models).reduce(
+    (acc, model) => acc + model.tokens.cached,
+    0
+  );
+  const totalPromptTokens = Object.values(models).reduce(
+    (acc, model) => acc + model.tokens.prompt,
+    0
+  );
+  const cacheEfficiency = totalPromptTokens > 0 ? totalCachedTokens / totalPromptTokens * 100 : 0;
+  const totalDecisions = tools.totalDecisions.accept + tools.totalDecisions.reject + tools.totalDecisions.modify;
+  const successRate = tools.totalCalls > 0 ? tools.totalSuccess / tools.totalCalls * 100 : 0;
+  const agreementRate = totalDecisions > 0 ? tools.totalDecisions.accept / totalDecisions * 100 : 0;
+  return {
+    totalApiTime,
+    totalToolTime,
+    agentActiveTime,
+    apiTimePercent,
+    toolTimePercent,
+    cacheEfficiency,
+    totalDecisions,
+    successRate,
+    agreementRate,
+    totalCachedTokens,
+    totalPromptTokens,
+    totalLinesAdded: files.totalLinesAdded,
+    totalLinesRemoved: files.totalLinesRemoved
+  };
+}, "computeSessionStats");
+
+// packages/cli/src/services/commandUtils.ts
+init_esbuild_shims();
+function getEffectiveSupportedModes(cmd) {
+  if (cmd.supportedModes !== void 0) {
+    return cmd.supportedModes;
+  }
+  switch (cmd.kind) {
+    case "built-in" /* BUILT_IN */:
+      return ["interactive"];
+    case "file" /* FILE */:
+    case "skill" /* SKILL */:
+    case "mcp-prompt" /* MCP_PROMPT */:
+      return ["interactive", "non_interactive", "acp"];
+    default:
+      return ["interactive"];
+  }
+}
+__name(getEffectiveSupportedModes, "getEffectiveSupportedModes");
+function filterCommandsForMode(commands, mode) {
+  return commands.filter(
+    (cmd) => getEffectiveSupportedModes(cmd).includes(mode)
+  );
+}
+__name(filterCommandsForMode, "filterCommandsForMode");
+
+// packages/cli/src/ui/commands/diffCommand.ts
+init_esbuild_shims();
+async function diffAction(context) {
+  const { config } = context.services;
+  if (!config) {
+    return {
+      type: "message",
+      messageType: "error",
+      content: t("Configuration not available.")
+    };
+  }
+  if (context.executionMode === "interactive") {
+    return { type: "dialog", dialog: "diff" };
+  }
+  const cwd = config.getWorkingDir() || config.getProjectRoot();
+  if (!cwd) {
+    return {
+      type: "message",
+      messageType: "error",
+      content: t("Could not determine current working directory.")
+    };
+  }
+  let result;
+  try {
+    result = await fetchGitDiff(cwd);
+  } catch (error) {
+    return {
+      type: "message",
+      messageType: "error",
+      content: `${t("Failed to compute git diff stats")}: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+  if (!result) {
+    return {
+      type: "message",
+      messageType: "info",
+      content: t(
+        "No diff available. Either this is not a git repository, HEAD is missing, or a merge/rebase/cherry-pick/revert is in progress."
+      )
+    };
+  }
+  if (result.stats.filesCount === 0) {
+    return {
+      type: "message",
+      messageType: "info",
+      content: t("Clean working tree \u2014 no changes against HEAD.")
+    };
+  }
+  const model = buildDiffRenderModel(result);
+  return {
+    type: "message",
+    messageType: "info",
+    content: renderDiffModelText(model)
+  };
+}
+__name(diffAction, "diffAction");
+function buildDiffRenderModel(result) {
+  const rows = [];
+  for (const [filename, s] of result.perFileStats) {
+    rows.push(toRow(filename, s));
+  }
+  const hiddenCount = Math.max(0, result.stats.filesCount - rows.length);
+  return {
+    filesCount: result.stats.filesCount,
+    linesAdded: result.stats.linesAdded,
+    linesRemoved: result.stats.linesRemoved,
+    rows,
+    hiddenCount
+  };
+}
+__name(buildDiffRenderModel, "buildDiffRenderModel");
+function toRow(filename, s) {
+  if (s.isBinary) {
+    return {
+      filename,
+      oldPath: s.oldPath,
+      isBinary: true,
+      isUntracked: Boolean(s.isUntracked),
+      isDeleted: Boolean(s.isDeleted),
+      truncated: false
+    };
+  }
+  return {
+    filename,
+    oldPath: s.oldPath,
+    added: s.added,
+    removed: s.isUntracked ? 0 : s.removed,
+    isBinary: false,
+    isUntracked: Boolean(s.isUntracked),
+    isDeleted: Boolean(s.isDeleted),
+    truncated: Boolean(s.truncated)
+  };
+}
+__name(toRow, "toRow");
+function computeDiffColumnWidths(rows) {
+  let maxAdded = 0;
+  let maxRemoved = 0;
+  for (const r of rows) {
+    if (r.isBinary) continue;
+    if ((r.added ?? 0) > maxAdded) maxAdded = r.added ?? 0;
+    if ((r.removed ?? 0) > maxRemoved) maxRemoved = r.removed ?? 0;
+  }
+  const addWidth = String(maxAdded).length;
+  const remWidth = String(maxRemoved).length;
+  const statColumnWidth = 1 + addWidth + 1 + 1 + remWidth;
+  return { addWidth, remWidth, statColumnWidth };
+}
+__name(computeDiffColumnWidths, "computeDiffColumnWidths");
+function renderDiffModelText(model) {
+  const { filesCount, linesAdded, linesRemoved, rows, hiddenCount } = model;
+  const header = filesCount === 1 ? t("{{count}} file changed, +{{added}} / -{{removed}}", {
+    count: String(filesCount),
+    added: String(linesAdded),
+    removed: String(linesRemoved)
+  }) : t("{{count}} files changed, +{{added}} / -{{removed}}", {
+    count: String(filesCount),
+    added: String(linesAdded),
+    removed: String(linesRemoved)
+  });
+  const lines = formatRowsText(rows);
+  const capNote = hiddenCount > 0 && rows.length > 0 ? `
+  ${t("\u2026and {{hidden}} more (showing first {{shown}})", {
+    hidden: String(hiddenCount),
+    shown: String(rows.length)
+  })}` : "";
+  return lines.length > 0 ? `${header}
+${lines.join("\n")}${capNote}` : header;
+}
+__name(renderDiffModelText, "renderDiffModelText");
+function formatRowsText(rows) {
+  if (rows.length === 0) return [];
+  const { addWidth, remWidth, statColumnWidth } = computeDiffColumnWidths(rows);
+  const out = [];
+  for (const r of rows) {
+    const safeName = sanitizeFilenameForDisplay(r.filename);
+    const displayName = r.oldPath ? `${sanitizeFilenameForDisplay(r.oldPath)} \u2192 ${safeName}` : safeName;
+    if (r.isBinary) {
+      const suffix2 = r.isUntracked ? ` ${t("(binary, new)")}` : r.isDeleted ? ` ${t("(binary, deleted)")}` : ` ${t("(binary)")}`;
+      out.push(`  ${padMarker("~", statColumnWidth)}  ${displayName}${suffix2}`);
+      continue;
+    }
+    const added = `+${String(r.added ?? 0).padStart(addWidth)}`;
+    const removed = `-${String(r.removed ?? 0).padStart(remWidth)}`;
+    let suffix = "";
+    if (r.isUntracked) {
+      suffix = r.truncated ? ` ${t("(new, partial)")}` : ` ${t("(new)")}`;
+    } else if (r.isDeleted) {
+      suffix = ` ${t("(deleted)")}`;
+    }
+    out.push(`  ${added} ${removed}  ${displayName}${suffix}`);
+  }
+  return out;
+}
+__name(formatRowsText, "formatRowsText");
+function padMarker(marker, width) {
+  if (marker.length >= width) return marker;
+  return `${marker}${" ".repeat(width - marker.length)}`;
+}
+__name(padMarker, "padMarker");
+var diffCommand = {
+  name: "diff",
+  get description() {
+    return t("Show working-tree change stats versus HEAD");
+  },
+  kind: "built-in" /* BUILT_IN */,
+  supportedModes: ["interactive", "non_interactive", "acp"],
+  action: diffAction
+};
+
+// packages/cli/src/utils/systemInfoFields.ts
+init_esbuild_shims();
+function getSystemInfoFields(info) {
+  const fields = [];
+  addField(fields, t("Qwen Code"), formatCliVersion(info));
+  addField(fields, t("Runtime"), formatRuntime(info));
+  addField(fields, t("IDE Client"), info.ideClient);
+  addField(fields, "LSP", info.lspStatus ?? "");
+  addField(fields, t("OS"), formatOs(info));
+  addField(fields, t("Auth"), formatAuth(info));
+  addField(fields, t("Base URL"), formatBaseUrl(info));
+  addField(fields, t("Model"), info.modelVersion);
+  addField(fields, t("Fast Model"), info.fastModel || info.modelVersion);
+  addField(fields, t("Session ID"), info.sessionId);
+  addField(fields, t("Sandbox"), info.sandboxEnv);
+  addField(fields, t("Proxy"), formatProxy(info.proxy));
+  addField(fields, t("Memory Usage"), info.memoryUsage);
+  return fields;
+}
+__name(getSystemInfoFields, "getSystemInfoFields");
+function addField(fields, label, value) {
+  if (value) {
+    fields.push({ label, value });
+  }
+}
+__name(addField, "addField");
+function formatCliVersion(info) {
+  if (!info.cliVersion) {
+    return "";
+  }
+  if (!info.gitCommit) {
+    return info.cliVersion;
+  }
+  return `${info.cliVersion} (${info.gitCommit})`;
+}
+__name(formatCliVersion, "formatCliVersion");
+function formatRuntime(info) {
+  if (!info.nodeVersion && !info.npmVersion) {
+    return "";
+  }
+  const node = info.nodeVersion ? `Node.js ${info.nodeVersion}` : "";
+  const npm = info.npmVersion ? `npm ${info.npmVersion}` : "";
+  return joinParts([node, npm], " / ");
+}
+__name(formatRuntime, "formatRuntime");
+function formatOs(info) {
+  return joinParts(
+    [info.osPlatform, info.osArch, formatOsRelease(info.osRelease)],
+    " "
+  ).trim();
+}
+__name(formatOs, "formatOs");
+function formatOsRelease(release) {
+  if (!release) {
+    return "";
+  }
+  return `(${release})`;
+}
+__name(formatOsRelease, "formatOsRelease");
+function formatAuth(info) {
+  if (!info.selectedAuthType) {
+    return "";
+  }
+  const managedProvider = findProviderByCredentials(
+    info.baseUrl,
+    info.apiKeyEnvKey
+  );
+  if (managedProvider && resolveMetadataKey(managedProvider)) {
+    return t(managedProvider.label);
+  }
+  if (info.selectedAuthType.startsWith("oauth") || info.selectedAuthType === "qwen-oauth") {
+    return "Qwen OAuth";
+  }
+  return `API Key - ${info.selectedAuthType}`;
+}
+__name(formatAuth, "formatAuth");
+function formatBaseUrl(info) {
+  if (!info.selectedAuthType || !info.baseUrl) {
+    return "";
+  }
+  if (info.selectedAuthType.startsWith("oauth") || info.selectedAuthType === "qwen-oauth") {
+    return "";
+  }
+  return info.baseUrl;
+}
+__name(formatBaseUrl, "formatBaseUrl");
+function formatProxy(proxy) {
+  if (!proxy) {
+    return "no proxy";
+  }
+  return redactProxy(proxy);
+}
+__name(formatProxy, "formatProxy");
+function redactProxy(proxy) {
+  try {
+    const url = new URL(proxy);
+    if (url.username || url.password) {
+      url.username = url.username ? "***" : "";
+      url.password = url.password ? "***" : "";
+    }
+    return url.toString();
+  } catch {
+    return proxy.replace(/\/\/[^/]*@/, "//***@");
+  }
+}
+__name(redactProxy, "redactProxy");
+function joinParts(parts, separator) {
+  return parts.filter((part) => part).join(separator);
+}
+__name(joinParts, "joinParts");
+
+// packages/cli/src/utils/costCalculator.ts
+init_esbuild_shims();
+function calculateCost(args) {
+  const { inputTokens, outputTokens, pricing } = args;
+  if (!pricing) return null;
+  const inputCost = pricing.inputPerMillionTokens != null ? inputTokens / 1e6 * pricing.inputPerMillionTokens : 0;
+  const outputCost = pricing.outputPerMillionTokens != null ? outputTokens / 1e6 * pricing.outputPerMillionTokens : 0;
+  const total = inputCost + outputCost;
+  return total > 0 ? total : null;
+}
+__name(calculateCost, "calculateCost");
+
+// packages/cli/src/ui/utils/skill-level-label.ts
+init_esbuild_shims();
+function levelLabel(level) {
+  switch (level) {
+    case "project":
+      return t("Project");
+    case "user":
+      return t("User");
+    case "extension":
+      return t("Extension");
+    case "bundled":
+      return t("Bundled");
+    default: {
+      const _exhaustive = level;
+      return _exhaustive;
+    }
+  }
+}
+__name(levelLabel, "levelLabel");
+
+export {
+  getSystemInfoFields,
+  calculateErrorRate,
+  calculateAverageLatency,
+  calculateCacheHitRate,
+  computeSessionStats,
+  calculateCost,
+  getEffectiveSupportedModes,
+  filterCommandsForMode,
+  levelLabel,
+  computeDiffColumnWidths,
+  diffCommand
+};
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */