@qwen-code/qwen-code 0.19.2 → 0.19.3

package/chunks/{chunk-UAARVVBI.js → chunk-QWFNTRH4.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   runExitCleanup
-} from "./chunk-GYZQA2FO.js";
+} from "./chunk-I2LYBGNI.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";

package/chunks/chunk-QYUE6W3T.js

@@ -0,0 +1,123 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  init_esbuild_shims
+} from "./chunk-A4BMJM77.js";
+import {
+  __commonJS,
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// node_modules/strip-json-comments/index.js
+var require_strip_json_comments = __commonJS({
+  "node_modules/strip-json-comments/index.js"(exports, module) {
+    "use strict";
+    init_esbuild_shims();
+    var singleComment = Symbol("singleComment");
+    var multiComment = Symbol("multiComment");
+    var stripWithoutWhitespace = /* @__PURE__ */ __name(() => "", "stripWithoutWhitespace");
+    var stripWithWhitespace = /* @__PURE__ */ __name((string, start, end) => string.slice(start, end).replace(/\S/g, " "), "stripWithWhitespace");
+    var isEscaped = /* @__PURE__ */ __name((jsonString, quotePosition) => {
+      let index = quotePosition - 1;
+      let backslashCount = 0;
+      while (jsonString[index] === "\\") {
+        index -= 1;
+        backslashCount += 1;
+      }
+      return Boolean(backslashCount % 2);
+    }, "isEscaped");
+    module.exports = (jsonString, options = {}) => {
+      if (typeof jsonString !== "string") {
+        throw new TypeError(`Expected argument \`jsonString\` to be a \`string\`, got \`${typeof jsonString}\``);
+      }
+      const strip = options.whitespace === false ? stripWithoutWhitespace : stripWithWhitespace;
+      let insideString = false;
+      let insideComment = false;
+      let offset = 0;
+      let result = "";
+      for (let i = 0; i < jsonString.length; i++) {
+        const currentCharacter = jsonString[i];
+        const nextCharacter = jsonString[i + 1];
+        if (!insideComment && currentCharacter === '"') {
+          const escaped = isEscaped(jsonString, i);
+          if (!escaped) {
+            insideString = !insideString;
+          }
+        }
+        if (insideString) {
+          continue;
+        }
+        if (!insideComment && currentCharacter + nextCharacter === "//") {
+          result += jsonString.slice(offset, i);
+          offset = i;
+          insideComment = singleComment;
+          i++;
+        } else if (insideComment === singleComment && currentCharacter + nextCharacter === "\r\n") {
+          i++;
+          insideComment = false;
+          result += strip(jsonString, offset, i);
+          offset = i;
+          continue;
+        } else if (insideComment === singleComment && currentCharacter === "\n") {
+          insideComment = false;
+          result += strip(jsonString, offset, i);
+          offset = i;
+        } else if (!insideComment && currentCharacter + nextCharacter === "/*") {
+          result += jsonString.slice(offset, i);
+          offset = i;
+          insideComment = multiComment;
+          i++;
+          continue;
+        } else if (insideComment === multiComment && currentCharacter + nextCharacter === "*/") {
+          i++;
+          insideComment = false;
+          result += strip(jsonString, offset, i + 1);
+          offset = i + 1;
+          continue;
+        }
+      }
+      return result + (insideComment ? strip(jsonString.slice(offset)) : jsonString.slice(offset));
+    };
+  }
+});
+
+// packages/cli/src/config/path-comparison.ts
+init_esbuild_shims();
+import * as fs from "node:fs";
+import * as path from "node:path";
+function isWithinRoot(childPath, parentPath) {
+  const relativePath = path.relative(parentPath, childPath);
+  return relativePath === "" || !relativePath.startsWith(`..${path.sep}`) && relativePath !== ".." && !path.isAbsolute(relativePath);
+}
+__name(isWithinRoot, "isWithinRoot");
+function getPathComparisonVariants(rawPath) {
+  const variants = /* @__PURE__ */ new Set([path.normalize(path.resolve(rawPath))]);
+  try {
+    variants.add(path.normalize(fs.realpathSync(rawPath)));
+  } catch {
+  }
+  return variants;
+}
+__name(getPathComparisonVariants, "getPathComparisonVariants");
+function arePathsEquivalent(left, right) {
+  const rightVariants = getPathComparisonVariants(right);
+  for (const leftVariant of getPathComparisonVariants(left)) {
+    if (rightVariants.has(leftVariant)) {
+      return true;
+    }
+  }
+  return false;
+}
+__name(arePathsEquivalent, "arePathsEquivalent");
+
+export {
+  require_strip_json_comments,
+  isWithinRoot,
+  getPathComparisonVariants,
+  arePathsEquivalent
+};
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-5JZLXFPD.js → chunk-R5OP2ATH.js}

@@ -5,10 +5,10 @@ import {
 } from "./chunk-Y6Z2O3WR.js";
 import {
   resolveBundleDir
-} from "./chunk-PXFFKNCO.js";
+} from "./chunk-YAINVQ3Q.js";
 import {
   Storage
-} from "./chunk-C4K3FEQ2.js";
+} from "./chunk-UX4SGCGN.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";
@@ -158,15 +158,15 @@ init_esbuild_shims();
 
 // import("./locales/**/*.js") in packages/cli/src/i18n/index.ts
 var globImport_locales_js = __glob({
-  "./locales/ca.js": () => import("./ca-7WC7ELX6.js"),
-  "./locales/de.js": () => import("./de-ACHALDED.js"),
-  "./locales/en.js": () => import("./en-NCUBOJOY.js"),
-  "./locales/fr.js": () => import("./fr-GVKZ27MF.js"),
-  "./locales/ja.js": () => import("./ja-FKZ2WZ4D.js"),
-  "./locales/pt.js": () => import("./pt-SY5NCFGR.js"),
-  "./locales/ru.js": () => import("./ru-FWNXJG4F.js"),
-  "./locales/zh-TW.js": () => import("./zh-TW-QGAVRXT3.js"),
-  "./locales/zh.js": () => import("./zh-RBEGQVQT.js")
+  "./locales/ca.js": () => import("./ca-IUFWESZL.js"),
+  "./locales/de.js": () => import("./de-EOW5PVHF.js"),
+  "./locales/en.js": () => import("./en-HPWEJBTR.js"),
+  "./locales/fr.js": () => import("./fr-BN5NKSAC.js"),
+  "./locales/ja.js": () => import("./ja-7DEUB2TS.js"),
+  "./locales/pt.js": () => import("./pt-TNZRNLQB.js"),
+  "./locales/ru.js": () => import("./ru-NIAUBKCN.js"),
+  "./locales/zh-TW.js": () => import("./zh-TW-TR3XYGE5.js"),
+  "./locales/zh.js": () => import("./zh-5EUYXASN.js")
 });
 
 // packages/cli/src/i18n/index.ts

package/chunks/{chunk-BNXANYLH.js → chunk-RD6YJJJ6.js}

@@ -5,7 +5,7 @@ import {
   Storage,
   resolvePath,
   sanitizeCwd
-} from "./chunk-C4K3FEQ2.js";
+} from "./chunk-UX4SGCGN.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";
@@ -23,6 +23,7 @@ var AUTO_MEMORY_METADATA_FILENAME = "meta.json";
 var AUTO_MEMORY_EXTRACT_CURSOR_FILENAME = "extract-cursor.json";
 var AUTO_MEMORY_CONSOLIDATION_LOCK_FILENAME = "consolidation.lock";
 var USER_AUTO_MEMORY_DIRNAME = "memories";
+var TEAM_AUTO_MEMORY_DIRNAME = "team-memory";
 function findGitRoot(startPath) {
   let current = path.resolve(startPath);
   while (true) {
@@ -82,6 +83,7 @@ function getMemoryBaseDir() {
 }
 __name(getMemoryBaseDir, "getMemoryBaseDir");
 var _autoMemoryRootCache = /* @__PURE__ */ new Map();
+var _teamAutoMemoryRootCache = /* @__PURE__ */ new Map();
 function getAutoMemoryRoot(projectRoot) {
   const useLocalMemory = process.env["QWEN_CODE_MEMORY_LOCAL"] === "1";
   const memoryBaseDir = useLocalMemory ? "" : getMemoryBaseDir();
@@ -106,6 +108,7 @@ function getAutoMemoryRoot(projectRoot) {
 __name(getAutoMemoryRoot, "getAutoMemoryRoot");
 function clearAutoMemoryRootCache() {
   _autoMemoryRootCache.clear();
+  _teamAutoMemoryRootCache.clear();
 }
 __name(clearAutoMemoryRootCache, "clearAutoMemoryRootCache");
 function getAutoMemoryProjectStateDir(projectRoot) {
@@ -178,6 +181,79 @@ function isUserAutoMemPath(absolutePath) {
   return rel === "" || !rel.startsWith("..") && !path.isAbsolute(rel);
 }
 __name(isUserAutoMemPath, "isUserAutoMemPath");
+function getTeamAutoMemoryRoot(projectRoot) {
+  const cached = _teamAutoMemoryRootCache.get(projectRoot);
+  if (cached !== void 0) return cached;
+  const root = findGitRoot(projectRoot) ?? path.resolve(projectRoot);
+  const result = path.join(root, QWEN_DIR, TEAM_AUTO_MEMORY_DIRNAME);
+  _teamAutoMemoryRootCache.set(projectRoot, result);
+  return result;
+}
+__name(getTeamAutoMemoryRoot, "getTeamAutoMemoryRoot");
+function getTeamAutoMemoryIndexPath(projectRoot) {
+  return path.join(
+    getTeamAutoMemoryRoot(projectRoot),
+    AUTO_MEMORY_INDEX_FILENAME
+  );
+}
+__name(getTeamAutoMemoryIndexPath, "getTeamAutoMemoryIndexPath");
+function isTeamAutoMemPath(absolutePath, projectRoot) {
+  const normalizedPath = path.normalize(realpathNearestExisting(absolutePath));
+  const memRoot = path.normalize(
+    realpathNearestExisting(getTeamAutoMemoryRoot(projectRoot))
+  );
+  const rel = path.relative(memRoot, normalizedPath);
+  return rel === "" || !rel.startsWith("..") && !path.isAbsolute(rel);
+}
+__name(isTeamAutoMemPath, "isTeamAutoMemPath");
+function resolveLeafSymlink(inputPath) {
+  const maxHops = 40;
+  let current = path.resolve(inputPath);
+  for (let i = 0; i < maxHops; i++) {
+    let stat;
+    try {
+      stat = fs.lstatSync(current);
+    } catch {
+      return current;
+    }
+    if (!stat.isSymbolicLink()) {
+      return current;
+    }
+    const target = fs.readlinkSync(current);
+    if (path.isAbsolute(target)) {
+      current = target;
+    } else {
+      let parent;
+      try {
+        parent = fs.realpathSync(path.dirname(current));
+      } catch {
+        parent = path.dirname(current);
+      }
+      current = path.resolve(parent, target);
+    }
+  }
+  return current;
+}
+__name(resolveLeafSymlink, "resolveLeafSymlink");
+function realpathNearestExisting(inputPath) {
+  const resolved = resolveLeafSymlink(inputPath);
+  const missingSegments = [];
+  let current = resolved;
+  while (!fs.existsSync(current)) {
+    const parent = path.dirname(current);
+    if (parent === current) {
+      return resolved;
+    }
+    missingSegments.unshift(path.basename(current));
+    current = parent;
+  }
+  try {
+    return path.join(fs.realpathSync(current), ...missingSegments);
+  } catch {
+    return resolved;
+  }
+}
+__name(realpathNearestExisting, "realpathNearestExisting");
 function isAnyAutoMemPath(absolutePath, projectRoot) {
   return isAutoMemPath(absolutePath, projectRoot) || isUserAutoMemPath(absolutePath);
 }
@@ -190,6 +266,7 @@ export {
   AUTO_MEMORY_EXTRACT_CURSOR_FILENAME,
   AUTO_MEMORY_CONSOLIDATION_LOCK_FILENAME,
   USER_AUTO_MEMORY_DIRNAME,
+  TEAM_AUTO_MEMORY_DIRNAME,
   getMemoryBaseDir,
   getAutoMemoryRoot,
   clearAutoMemoryRootCache,
@@ -206,6 +283,9 @@ export {
   getUserAutoMemoryIndexPath,
   getUserAutoMemoryTopicPath,
   isUserAutoMemPath,
+  getTeamAutoMemoryRoot,
+  getTeamAutoMemoryIndexPath,
+  isTeamAutoMemPath,
   isAnyAutoMemPath
 };
 /**