@qwen-code/qwen-code 0.1.2-nightly.20251031.ced79cf4 → 0.1.3-nightly.20251101.ff8a8ac6

package/cli.js

@@ -182628,7 +182628,7 @@ function createContentGeneratorConfig(config, authType, generationConfig) {
   };
 }
 async function createContentGenerator(config, gcConfig, sessionId2) {
-  const version2 = "0.1.2-nightly.20251031.ced79cf4";
+  const version2 = "0.1.3-nightly.20251101.ff8a8ac6";
   const userAgent2 = `QwenCode/${version2} (${process.platform}; ${process.arch})`;
   const baseHeaders = {
     "User-Agent": userAgent2
@@ -184427,7 +184427,7 @@ var init_tool_names = __esm({
       WRITE_FILE: "write_file",
       READ_FILE: "read_file",
       READ_MANY_FILES: "read_many_files",
-      GREP: "search_file_content",
+      GREP: "grep_search",
       GLOB: "glob",
       SHELL: "run_shell_command",
       TODO_WRITE: "todo_write",
@@ -198829,7 +198829,8 @@ var init_turn = __esm({
       CompressionStatus2[CompressionStatus2["COMPRESSED"] = 1] = "COMPRESSED";
       CompressionStatus2[CompressionStatus2["COMPRESSION_FAILED_INFLATED_TOKEN_COUNT"] = 2] = "COMPRESSION_FAILED_INFLATED_TOKEN_COUNT";
       CompressionStatus2[CompressionStatus2["COMPRESSION_FAILED_TOKEN_COUNT_ERROR"] = 3] = "COMPRESSION_FAILED_TOKEN_COUNT_ERROR";
-      CompressionStatus2[CompressionStatus2["NOOP"] = 4] = "NOOP";
+      CompressionStatus2[CompressionStatus2["COMPRESSION_FAILED_EMPTY_SUMMARY"] = 4] = "COMPRESSION_FAILED_EMPTY_SUMMARY";
+      CompressionStatus2[CompressionStatus2["NOOP"] = 5] = "NOOP";
     })(CompressionStatus || (CompressionStatus = {}));
     Turn = class {
       static {
@@ -198961,6 +198962,474 @@ ${[...this.pendingCitations].sort().join("\n")}`
   }
 });
 
+// packages/core/dist/src/config/constants.js
+var DEFAULT_MEMORY_FILE_FILTERING_OPTIONS, DEFAULT_FILE_FILTERING_OPTIONS;
+var init_constants3 = __esm({
+  "packages/core/dist/src/config/constants.js"() {
+    "use strict";
+    init_esbuild_shims();
+    DEFAULT_MEMORY_FILE_FILTERING_OPTIONS = {
+      respectGitIgnore: false,
+      respectQwenIgnore: true
+    };
+    DEFAULT_FILE_FILTERING_OPTIONS = {
+      respectGitIgnore: true,
+      respectQwenIgnore: true
+    };
+  }
+});
+
+// packages/core/dist/src/utils/getFolderStructure.js
+import * as fs24 from "node:fs/promises";
+import * as path21 from "node:path";
+async function readFullStructure(rootPath, options2) {
+  const rootName = path21.basename(rootPath);
+  const rootNode = {
+    name: rootName,
+    path: rootPath,
+    files: [],
+    subFolders: [],
+    totalChildren: 0,
+    totalFiles: 0
+  };
+  const queue = [
+    { folderInfo: rootNode, currentPath: rootPath }
+  ];
+  let currentItemCount = 0;
+  const processedPaths = /* @__PURE__ */ new Set();
+  while (queue.length > 0) {
+    const { folderInfo, currentPath } = queue.shift();
+    if (processedPaths.has(currentPath)) {
+      continue;
+    }
+    processedPaths.add(currentPath);
+    if (currentItemCount >= options2.maxItems) {
+      continue;
+    }
+    let entries;
+    try {
+      const rawEntries = await fs24.readdir(currentPath, { withFileTypes: true });
+      entries = rawEntries.sort((a, b) => a.name.localeCompare(b.name));
+    } catch (error) {
+      if (isNodeError(error) && (error.code === "EACCES" || error.code === "ENOENT")) {
+        console.warn(`Warning: Could not read directory ${currentPath}: ${error.message}`);
+        if (currentPath === rootPath && error.code === "ENOENT") {
+          return null;
+        }
+        continue;
+      }
+      throw error;
+    }
+    const filesInCurrentDir = [];
+    const subFoldersInCurrentDir = [];
+    for (const entry of entries) {
+      if (entry.isFile()) {
+        if (currentItemCount >= options2.maxItems) {
+          folderInfo.hasMoreFiles = true;
+          break;
+        }
+        const fileName = entry.name;
+        const filePath = path21.join(currentPath, fileName);
+        if (options2.fileService) {
+          const shouldIgnore = options2.fileFilteringOptions.respectGitIgnore && options2.fileService.shouldGitIgnoreFile(filePath) || options2.fileFilteringOptions.respectQwenIgnore && options2.fileService.shouldQwenIgnoreFile(filePath);
+          if (shouldIgnore) {
+            continue;
+          }
+        }
+        if (!options2.fileIncludePattern || options2.fileIncludePattern.test(fileName)) {
+          filesInCurrentDir.push(fileName);
+          currentItemCount++;
+          folderInfo.totalFiles++;
+          folderInfo.totalChildren++;
+        }
+      }
+    }
+    folderInfo.files = filesInCurrentDir;
+    for (const entry of entries) {
+      if (entry.isDirectory()) {
+        if (currentItemCount >= options2.maxItems) {
+          folderInfo.hasMoreSubfolders = true;
+          break;
+        }
+        const subFolderName = entry.name;
+        const subFolderPath = path21.join(currentPath, subFolderName);
+        let isIgnored = false;
+        if (options2.fileService) {
+          isIgnored = options2.fileFilteringOptions.respectGitIgnore && options2.fileService.shouldGitIgnoreFile(subFolderPath) || options2.fileFilteringOptions.respectQwenIgnore && options2.fileService.shouldQwenIgnoreFile(subFolderPath);
+        }
+        if (options2.ignoredFolders.has(subFolderName) || isIgnored) {
+          const ignoredSubFolder = {
+            name: subFolderName,
+            path: subFolderPath,
+            files: [],
+            subFolders: [],
+            totalChildren: 0,
+            totalFiles: 0,
+            isIgnored: true
+          };
+          subFoldersInCurrentDir.push(ignoredSubFolder);
+          currentItemCount++;
+          folderInfo.totalChildren++;
+          continue;
+        }
+        const subFolderNode = {
+          name: subFolderName,
+          path: subFolderPath,
+          files: [],
+          subFolders: [],
+          totalChildren: 0,
+          totalFiles: 0
+        };
+        subFoldersInCurrentDir.push(subFolderNode);
+        currentItemCount++;
+        folderInfo.totalChildren++;
+        queue.push({ folderInfo: subFolderNode, currentPath: subFolderPath });
+      }
+    }
+    folderInfo.subFolders = subFoldersInCurrentDir;
+  }
+  return rootNode;
+}
+function formatStructure(node, currentIndent, isLastChildOfParent, isProcessingRootNode, builder) {
+  const connector = isLastChildOfParent ? "\u2514\u2500\u2500\u2500" : "\u251C\u2500\u2500\u2500";
+  if (!isProcessingRootNode || node.isIgnored) {
+    builder.push(`${currentIndent}${connector}${node.name}${path21.sep}${node.isIgnored ? TRUNCATION_INDICATOR : ""}`);
+  }
+  const indentForChildren = isProcessingRootNode ? "" : currentIndent + (isLastChildOfParent ? "    " : "\u2502   ");
+  const fileCount = node.files.length;
+  for (let i = 0; i < fileCount; i++) {
+    const isLastFileAmongSiblings = i === fileCount - 1 && node.subFolders.length === 0 && !node.hasMoreSubfolders;
+    const fileConnector = isLastFileAmongSiblings ? "\u2514\u2500\u2500\u2500" : "\u251C\u2500\u2500\u2500";
+    builder.push(`${indentForChildren}${fileConnector}${node.files[i]}`);
+  }
+  if (node.hasMoreFiles) {
+    const isLastIndicatorAmongSiblings = node.subFolders.length === 0 && !node.hasMoreSubfolders;
+    const fileConnector = isLastIndicatorAmongSiblings ? "\u2514\u2500\u2500\u2500" : "\u251C\u2500\u2500\u2500";
+    builder.push(`${indentForChildren}${fileConnector}${TRUNCATION_INDICATOR}`);
+  }
+  const subFolderCount = node.subFolders.length;
+  for (let i = 0; i < subFolderCount; i++) {
+    const isLastSubfolderAmongSiblings = i === subFolderCount - 1 && !node.hasMoreSubfolders;
+    formatStructure(node.subFolders[i], indentForChildren, isLastSubfolderAmongSiblings, false, builder);
+  }
+  if (node.hasMoreSubfolders) {
+    builder.push(`${indentForChildren}\u2514\u2500\u2500\u2500${TRUNCATION_INDICATOR}`);
+  }
+}
+async function getFolderStructure(directory, options2) {
+  const resolvedPath = path21.resolve(directory);
+  const mergedOptions = {
+    maxItems: options2?.maxItems ?? MAX_ITEMS,
+    ignoredFolders: options2?.ignoredFolders ?? DEFAULT_IGNORED_FOLDERS,
+    fileIncludePattern: options2?.fileIncludePattern,
+    fileService: options2?.fileService,
+    fileFilteringOptions: options2?.fileFilteringOptions ?? DEFAULT_FILE_FILTERING_OPTIONS
+  };
+  try {
+    let isTruncated2 = function(node) {
+      if (node.hasMoreFiles || node.hasMoreSubfolders || node.isIgnored) {
+        return true;
+      }
+      for (const sub of node.subFolders) {
+        if (isTruncated2(sub)) {
+          return true;
+        }
+      }
+      return false;
+    };
+    var isTruncated = isTruncated2;
+    __name(isTruncated2, "isTruncated");
+    const structureRoot = await readFullStructure(resolvedPath, mergedOptions);
+    if (!structureRoot) {
+      return `Error: Could not read directory "${resolvedPath}". Check path and permissions.`;
+    }
+    const structureLines = [];
+    formatStructure(structureRoot, "", true, true, structureLines);
+    let summary = `Showing up to ${mergedOptions.maxItems} items (files + folders).`;
+    if (isTruncated2(structureRoot)) {
+      summary += ` Folders or files indicated with ${TRUNCATION_INDICATOR} contain more items not shown, were ignored, or the display limit (${mergedOptions.maxItems} items) was reached.`;
+    }
+    return `${summary}
+
+${resolvedPath}${path21.sep}
+${structureLines.join("\n")}`;
+  } catch (error) {
+    console.error(`Error getting folder structure for ${resolvedPath}:`, error);
+    return `Error processing directory "${resolvedPath}": ${getErrorMessage(error)}`;
+  }
+}
+var MAX_ITEMS, TRUNCATION_INDICATOR, DEFAULT_IGNORED_FOLDERS;
+var init_getFolderStructure = __esm({
+  "packages/core/dist/src/utils/getFolderStructure.js"() {
+    "use strict";
+    init_esbuild_shims();
+    init_errors();
+    init_constants3();
+    MAX_ITEMS = 20;
+    TRUNCATION_INDICATOR = "...";
+    DEFAULT_IGNORED_FOLDERS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist"]);
+    __name(readFullStructure, "readFullStructure");
+    __name(formatStructure, "formatStructure");
+    __name(getFolderStructure, "getFolderStructure");
+  }
+});
+
+// packages/core/dist/src/utils/environmentContext.js
+async function getDirectoryContextString(config) {
+  const workspaceContext = config.getWorkspaceContext();
+  const workspaceDirectories = workspaceContext.getDirectories();
+  const folderStructures = await Promise.all(workspaceDirectories.map((dir) => getFolderStructure(dir, {
+    fileService: config.getFileService()
+  })));
+  const folderStructure = folderStructures.join("\n");
+  let workingDirPreamble;
+  if (workspaceDirectories.length === 1) {
+    workingDirPreamble = `I'm currently working in the directory: ${workspaceDirectories[0]}`;
+  } else {
+    const dirList = workspaceDirectories.map((dir) => `  - ${dir}`).join("\n");
+    workingDirPreamble = `I'm currently working in the following directories:
+${dirList}`;
+  }
+  return `${workingDirPreamble}
+Here is the folder structure of the current working directories:
+
+${folderStructure}`;
+}
+async function getEnvironmentContext(config) {
+  const today = (/* @__PURE__ */ new Date()).toLocaleDateString(void 0, {
+    weekday: "long",
+    year: "numeric",
+    month: "long",
+    day: "numeric"
+  });
+  const platform14 = process.platform;
+  const directoryContext = await getDirectoryContextString(config);
+  const context2 = `
+This is the Qwen Code. We are setting up the context for our chat.
+Today's date is ${today} (formatted according to the user's locale).
+My operating system is: ${platform14}
+${directoryContext}
+        `.trim();
+  const initialParts = [{ text: context2 }];
+  const toolRegistry = config.getToolRegistry();
+  if (config.getFullContext()) {
+    try {
+      const readManyFilesTool = toolRegistry.getTool("read_many_files");
+      if (readManyFilesTool) {
+        const invocation = readManyFilesTool.build({
+          paths: ["**/*"],
+          // Read everything recursively
+          useDefaultExcludes: true
+          // Use default excludes
+        });
+        const result = await invocation.execute(AbortSignal.timeout(3e4));
+        if (result.llmContent) {
+          initialParts.push({
+            text: `
+--- Full File Context ---
+${result.llmContent}`
+          });
+        } else {
+          console.warn("Full context requested, but read_many_files returned no content.");
+        }
+      } else {
+        console.warn("Full context requested, but read_many_files tool not found.");
+      }
+    } catch (error) {
+      console.error("Error reading full file context:", error);
+      initialParts.push({
+        text: "\n--- Error reading full file context ---"
+      });
+    }
+  }
+  return initialParts;
+}
+async function getInitialChatHistory(config, extraHistory) {
+  const envParts = await getEnvironmentContext(config);
+  const envContextString = envParts.map((part) => part.text || "").join("\n\n");
+  return [
+    {
+      role: "user",
+      parts: [{ text: envContextString }]
+    },
+    {
+      role: "model",
+      parts: [{ text: "Got it. Thanks for the context!" }]
+    },
+    ...extraHistory ?? []
+  ];
+}
+var init_environmentContext = __esm({
+  "packages/core/dist/src/utils/environmentContext.js"() {
+    "use strict";
+    init_esbuild_shims();
+    init_getFolderStructure();
+    __name(getDirectoryContextString, "getDirectoryContextString");
+    __name(getEnvironmentContext, "getEnvironmentContext");
+    __name(getInitialChatHistory, "getInitialChatHistory");
+  }
+});
+
+// packages/core/dist/src/services/chatCompressionService.js
+function findCompressSplitPoint(contents, fraction) {
+  if (fraction <= 0 || fraction >= 1) {
+    throw new Error("Fraction must be between 0 and 1");
+  }
+  const charCounts = contents.map((content) => JSON.stringify(content).length);
+  const totalCharCount = charCounts.reduce((a, b) => a + b, 0);
+  const targetCharCount = totalCharCount * fraction;
+  let lastSplitPoint = 0;
+  let cumulativeCharCount = 0;
+  for (let i = 0; i < contents.length; i++) {
+    const content = contents[i];
+    if (content.role === "user" && !content.parts?.some((part) => !!part.functionResponse)) {
+      if (cumulativeCharCount >= targetCharCount) {
+        return i;
+      }
+      lastSplitPoint = i;
+    }
+    cumulativeCharCount += charCounts[i];
+  }
+  const lastContent = contents[contents.length - 1];
+  if (lastContent?.role === "model" && !lastContent?.parts?.some((part) => part.functionCall)) {
+    return contents.length;
+  }
+  return lastSplitPoint;
+}
+var COMPRESSION_TOKEN_THRESHOLD, COMPRESSION_PRESERVE_THRESHOLD, ChatCompressionService;
+var init_chatCompressionService = __esm({
+  "packages/core/dist/src/services/chatCompressionService.js"() {
+    "use strict";
+    init_esbuild_shims();
+    init_turn();
+    init_uiTelemetry();
+    init_tokenLimits();
+    init_prompts();
+    init_partUtils();
+    init_loggers();
+    init_types3();
+    init_environmentContext();
+    COMPRESSION_TOKEN_THRESHOLD = 0.7;
+    COMPRESSION_PRESERVE_THRESHOLD = 0.3;
+    __name(findCompressSplitPoint, "findCompressSplitPoint");
+    ChatCompressionService = class {
+      static {
+        __name(this, "ChatCompressionService");
+      }
+      async compress(chat, promptId, force, model, config, hasFailedCompressionAttempt) {
+        const curatedHistory = chat.getHistory(true);
+        if (curatedHistory.length === 0 || hasFailedCompressionAttempt && !force) {
+          return {
+            newHistory: null,
+            info: {
+              originalTokenCount: 0,
+              newTokenCount: 0,
+              compressionStatus: CompressionStatus.NOOP
+            }
+          };
+        }
+        const originalTokenCount = uiTelemetryService.getLastPromptTokenCount();
+        const contextPercentageThreshold = config.getChatCompression()?.contextPercentageThreshold;
+        if (!force) {
+          const threshold = contextPercentageThreshold ?? COMPRESSION_TOKEN_THRESHOLD;
+          if (originalTokenCount < threshold * tokenLimit(model)) {
+            return {
+              newHistory: null,
+              info: {
+                originalTokenCount,
+                newTokenCount: originalTokenCount,
+                compressionStatus: CompressionStatus.NOOP
+              }
+            };
+          }
+        }
+        const splitPoint = findCompressSplitPoint(curatedHistory, 1 - COMPRESSION_PRESERVE_THRESHOLD);
+        const historyToCompress = curatedHistory.slice(0, splitPoint);
+        const historyToKeep = curatedHistory.slice(splitPoint);
+        if (historyToCompress.length === 0) {
+          return {
+            newHistory: null,
+            info: {
+              originalTokenCount,
+              newTokenCount: originalTokenCount,
+              compressionStatus: CompressionStatus.NOOP
+            }
+          };
+        }
+        const summaryResponse = await config.getContentGenerator().generateContent({
+          model,
+          contents: [
+            ...historyToCompress,
+            {
+              role: "user",
+              parts: [
+                {
+                  text: "First, reason in your scratchpad. Then, generate the <state_snapshot>."
+                }
+              ]
+            }
+          ],
+          config: {
+            systemInstruction: getCompressionPrompt()
+          }
+        }, promptId);
+        const summary = getResponseText(summaryResponse) ?? "";
+        const isSummaryEmpty = !summary || summary.trim().length === 0;
+        let newTokenCount = originalTokenCount;
+        let extraHistory = [];
+        if (!isSummaryEmpty) {
+          extraHistory = [
+            {
+              role: "user",
+              parts: [{ text: summary }]
+            },
+            {
+              role: "model",
+              parts: [{ text: "Got it. Thanks for the additional context!" }]
+            },
+            ...historyToKeep
+          ];
+          const fullNewHistory = await getInitialChatHistory(config, extraHistory);
+          newTokenCount = Math.floor(fullNewHistory.reduce((total, content) => total + JSON.stringify(content).length, 0) / 4);
+        }
+        logChatCompression(config, makeChatCompressionEvent({
+          tokens_before: originalTokenCount,
+          tokens_after: newTokenCount
+        }));
+        if (isSummaryEmpty) {
+          return {
+            newHistory: null,
+            info: {
+              originalTokenCount,
+              newTokenCount: originalTokenCount,
+              compressionStatus: CompressionStatus.COMPRESSION_FAILED_EMPTY_SUMMARY
+            }
+          };
+        } else if (newTokenCount > originalTokenCount) {
+          return {
+            newHistory: null,
+            info: {
+              originalTokenCount,
+              newTokenCount,
+              compressionStatus: CompressionStatus.COMPRESSION_FAILED_INFLATED_TOKEN_COUNT
+            }
+          };
+        } else {
+          uiTelemetryService.setLastPromptTokenCount(newTokenCount);
+          return {
+            newHistory: extraHistory,
+            info: {
+              originalTokenCount,
+              newTokenCount,
+              compressionStatus: CompressionStatus.COMPRESSED
+            }
+          };
+        }
+      }
+    };
+  }
+});
+
 // packages/core/dist/src/services/loopDetectionService.js
 import { createHash as createHash3 } from "node:crypto";
 var TOOL_CALL_LOOP_THRESHOLD, CONTENT_LOOP_THRESHOLD, CONTENT_CHUNK_SIZE, MAX_HISTORY_LENGTH, LLM_LOOP_CHECK_HISTORY_COUNT, LLM_CHECK_AFTER_TURNS, DEFAULT_LLM_CHECK_INTERVAL, MIN_LLM_CHECK_INTERVAL, MAX_LLM_CHECK_INTERVAL, LOOP_DETECTION_SYSTEM_PROMPT, LoopDetectionService;
@@ -199322,298 +199791,6 @@ var init_types6 = __esm({
   }
 });
 
-// packages/core/dist/src/config/constants.js
-var DEFAULT_MEMORY_FILE_FILTERING_OPTIONS, DEFAULT_FILE_FILTERING_OPTIONS;
-var init_constants3 = __esm({
-  "packages/core/dist/src/config/constants.js"() {
-    "use strict";
-    init_esbuild_shims();
-    DEFAULT_MEMORY_FILE_FILTERING_OPTIONS = {
-      respectGitIgnore: false,
-      respectQwenIgnore: true
-    };
-    DEFAULT_FILE_FILTERING_OPTIONS = {
-      respectGitIgnore: true,
-      respectQwenIgnore: true
-    };
-  }
-});
-
-// packages/core/dist/src/utils/getFolderStructure.js
-import * as fs24 from "node:fs/promises";
-import * as path21 from "node:path";
-async function readFullStructure(rootPath, options2) {
-  const rootName = path21.basename(rootPath);
-  const rootNode = {
-    name: rootName,
-    path: rootPath,
-    files: [],
-    subFolders: [],
-    totalChildren: 0,
-    totalFiles: 0
-  };
-  const queue = [
-    { folderInfo: rootNode, currentPath: rootPath }
-  ];
-  let currentItemCount = 0;
-  const processedPaths = /* @__PURE__ */ new Set();
-  while (queue.length > 0) {
-    const { folderInfo, currentPath } = queue.shift();
-    if (processedPaths.has(currentPath)) {
-      continue;
-    }
-    processedPaths.add(currentPath);
-    if (currentItemCount >= options2.maxItems) {
-      continue;
-    }
-    let entries;
-    try {
-      const rawEntries = await fs24.readdir(currentPath, { withFileTypes: true });
-      entries = rawEntries.sort((a, b) => a.name.localeCompare(b.name));
-    } catch (error) {
-      if (isNodeError(error) && (error.code === "EACCES" || error.code === "ENOENT")) {
-        console.warn(`Warning: Could not read directory ${currentPath}: ${error.message}`);
-        if (currentPath === rootPath && error.code === "ENOENT") {
-          return null;
-        }
-        continue;
-      }
-      throw error;
-    }
-    const filesInCurrentDir = [];
-    const subFoldersInCurrentDir = [];
-    for (const entry of entries) {
-      if (entry.isFile()) {
-        if (currentItemCount >= options2.maxItems) {
-          folderInfo.hasMoreFiles = true;
-          break;
-        }
-        const fileName = entry.name;
-        const filePath = path21.join(currentPath, fileName);
-        if (options2.fileService) {
-          const shouldIgnore = options2.fileFilteringOptions.respectGitIgnore && options2.fileService.shouldGitIgnoreFile(filePath) || options2.fileFilteringOptions.respectQwenIgnore && options2.fileService.shouldQwenIgnoreFile(filePath);
-          if (shouldIgnore) {
-            continue;
-          }
-        }
-        if (!options2.fileIncludePattern || options2.fileIncludePattern.test(fileName)) {
-          filesInCurrentDir.push(fileName);
-          currentItemCount++;
-          folderInfo.totalFiles++;
-          folderInfo.totalChildren++;
-        }
-      }
-    }
-    folderInfo.files = filesInCurrentDir;
-    for (const entry of entries) {
-      if (entry.isDirectory()) {
-        if (currentItemCount >= options2.maxItems) {
-          folderInfo.hasMoreSubfolders = true;
-          break;
-        }
-        const subFolderName = entry.name;
-        const subFolderPath = path21.join(currentPath, subFolderName);
-        let isIgnored = false;
-        if (options2.fileService) {
-          isIgnored = options2.fileFilteringOptions.respectGitIgnore && options2.fileService.shouldGitIgnoreFile(subFolderPath) || options2.fileFilteringOptions.respectQwenIgnore && options2.fileService.shouldQwenIgnoreFile(subFolderPath);
-        }
-        if (options2.ignoredFolders.has(subFolderName) || isIgnored) {
-          const ignoredSubFolder = {
-            name: subFolderName,
-            path: subFolderPath,
-            files: [],
-            subFolders: [],
-            totalChildren: 0,
-            totalFiles: 0,
-            isIgnored: true
-          };
-          subFoldersInCurrentDir.push(ignoredSubFolder);
-          currentItemCount++;
-          folderInfo.totalChildren++;
-          continue;
-        }
-        const subFolderNode = {
-          name: subFolderName,
-          path: subFolderPath,
-          files: [],
-          subFolders: [],
-          totalChildren: 0,
-          totalFiles: 0
-        };
-        subFoldersInCurrentDir.push(subFolderNode);
-        currentItemCount++;
-        folderInfo.totalChildren++;
-        queue.push({ folderInfo: subFolderNode, currentPath: subFolderPath });
-      }
-    }
-    folderInfo.subFolders = subFoldersInCurrentDir;
-  }
-  return rootNode;
-}
-function formatStructure(node, currentIndent, isLastChildOfParent, isProcessingRootNode, builder) {
-  const connector = isLastChildOfParent ? "\u2514\u2500\u2500\u2500" : "\u251C\u2500\u2500\u2500";
-  if (!isProcessingRootNode || node.isIgnored) {
-    builder.push(`${currentIndent}${connector}${node.name}${path21.sep}${node.isIgnored ? TRUNCATION_INDICATOR : ""}`);
-  }
-  const indentForChildren = isProcessingRootNode ? "" : currentIndent + (isLastChildOfParent ? "    " : "\u2502   ");
-  const fileCount = node.files.length;
-  for (let i = 0; i < fileCount; i++) {
-    const isLastFileAmongSiblings = i === fileCount - 1 && node.subFolders.length === 0 && !node.hasMoreSubfolders;
-    const fileConnector = isLastFileAmongSiblings ? "\u2514\u2500\u2500\u2500" : "\u251C\u2500\u2500\u2500";
-    builder.push(`${indentForChildren}${fileConnector}${node.files[i]}`);
-  }
-  if (node.hasMoreFiles) {
-    const isLastIndicatorAmongSiblings = node.subFolders.length === 0 && !node.hasMoreSubfolders;
-    const fileConnector = isLastIndicatorAmongSiblings ? "\u2514\u2500\u2500\u2500" : "\u251C\u2500\u2500\u2500";
-    builder.push(`${indentForChildren}${fileConnector}${TRUNCATION_INDICATOR}`);
-  }
-  const subFolderCount = node.subFolders.length;
-  for (let i = 0; i < subFolderCount; i++) {
-    const isLastSubfolderAmongSiblings = i === subFolderCount - 1 && !node.hasMoreSubfolders;
-    formatStructure(node.subFolders[i], indentForChildren, isLastSubfolderAmongSiblings, false, builder);
-  }
-  if (node.hasMoreSubfolders) {
-    builder.push(`${indentForChildren}\u2514\u2500\u2500\u2500${TRUNCATION_INDICATOR}`);
-  }
-}
-async function getFolderStructure(directory, options2) {
-  const resolvedPath = path21.resolve(directory);
-  const mergedOptions = {
-    maxItems: options2?.maxItems ?? MAX_ITEMS,
-    ignoredFolders: options2?.ignoredFolders ?? DEFAULT_IGNORED_FOLDERS,
-    fileIncludePattern: options2?.fileIncludePattern,
-    fileService: options2?.fileService,
-    fileFilteringOptions: options2?.fileFilteringOptions ?? DEFAULT_FILE_FILTERING_OPTIONS
-  };
-  try {
-    let isTruncated2 = function(node) {
-      if (node.hasMoreFiles || node.hasMoreSubfolders || node.isIgnored) {
-        return true;
-      }
-      for (const sub of node.subFolders) {
-        if (isTruncated2(sub)) {
-          return true;
-        }
-      }
-      return false;
-    };
-    var isTruncated = isTruncated2;
-    __name(isTruncated2, "isTruncated");
-    const structureRoot = await readFullStructure(resolvedPath, mergedOptions);
-    if (!structureRoot) {
-      return `Error: Could not read directory "${resolvedPath}". Check path and permissions.`;
-    }
-    const structureLines = [];
-    formatStructure(structureRoot, "", true, true, structureLines);
-    let summary = `Showing up to ${mergedOptions.maxItems} items (files + folders).`;
-    if (isTruncated2(structureRoot)) {
-      summary += ` Folders or files indicated with ${TRUNCATION_INDICATOR} contain more items not shown, were ignored, or the display limit (${mergedOptions.maxItems} items) was reached.`;
-    }
-    return `${summary}
-
-${resolvedPath}${path21.sep}
-${structureLines.join("\n")}`;
-  } catch (error) {
-    console.error(`Error getting folder structure for ${resolvedPath}:`, error);
-    return `Error processing directory "${resolvedPath}": ${getErrorMessage(error)}`;
-  }
-}
-var MAX_ITEMS, TRUNCATION_INDICATOR, DEFAULT_IGNORED_FOLDERS;
-var init_getFolderStructure = __esm({
-  "packages/core/dist/src/utils/getFolderStructure.js"() {
-    "use strict";
-    init_esbuild_shims();
-    init_errors();
-    init_constants3();
-    MAX_ITEMS = 20;
-    TRUNCATION_INDICATOR = "...";
-    DEFAULT_IGNORED_FOLDERS = /* @__PURE__ */ new Set(["node_modules", ".git", "dist"]);
-    __name(readFullStructure, "readFullStructure");
-    __name(formatStructure, "formatStructure");
-    __name(getFolderStructure, "getFolderStructure");
-  }
-});
-
-// packages/core/dist/src/utils/environmentContext.js
-async function getDirectoryContextString(config) {
-  const workspaceContext = config.getWorkspaceContext();
-  const workspaceDirectories = workspaceContext.getDirectories();
-  const folderStructures = await Promise.all(workspaceDirectories.map((dir) => getFolderStructure(dir, {
-    fileService: config.getFileService()
-  })));
-  const folderStructure = folderStructures.join("\n");
-  let workingDirPreamble;
-  if (workspaceDirectories.length === 1) {
-    workingDirPreamble = `I'm currently working in the directory: ${workspaceDirectories[0]}`;
-  } else {
-    const dirList = workspaceDirectories.map((dir) => `  - ${dir}`).join("\n");
-    workingDirPreamble = `I'm currently working in the following directories:
-${dirList}`;
-  }
-  return `${workingDirPreamble}
-Here is the folder structure of the current working directories:
-
-${folderStructure}`;
-}
-async function getEnvironmentContext(config) {
-  const today = (/* @__PURE__ */ new Date()).toLocaleDateString(void 0, {
-    weekday: "long",
-    year: "numeric",
-    month: "long",
-    day: "numeric"
-  });
-  const platform14 = process.platform;
-  const directoryContext = await getDirectoryContextString(config);
-  const context2 = `
-This is the Qwen Code. We are setting up the context for our chat.
-Today's date is ${today} (formatted according to the user's locale).
-My operating system is: ${platform14}
-${directoryContext}
-        `.trim();
-  const initialParts = [{ text: context2 }];
-  const toolRegistry = config.getToolRegistry();
-  if (config.getFullContext()) {
-    try {
-      const readManyFilesTool = toolRegistry.getTool("read_many_files");
-      if (readManyFilesTool) {
-        const invocation = readManyFilesTool.build({
-          paths: ["**/*"],
-          // Read everything recursively
-          useDefaultExcludes: true
-          // Use default excludes
-        });
-        const result = await invocation.execute(AbortSignal.timeout(3e4));
-        if (result.llmContent) {
-          initialParts.push({
-            text: `
---- Full File Context ---
-${result.llmContent}`
-          });
-        } else {
-          console.warn("Full context requested, but read_many_files returned no content.");
-        }
-      } else {
-        console.warn("Full context requested, but read_many_files tool not found.");
-      }
-    } catch (error) {
-      console.error("Error reading full file context:", error);
-      initialParts.push({
-        text: "\n--- Error reading full file context ---"
-      });
-    }
-  }
-  return initialParts;
-}
-var init_environmentContext = __esm({
-  "packages/core/dist/src/utils/environmentContext.js"() {
-    "use strict";
-    init_esbuild_shims();
-    init_getFolderStructure();
-    __name(getDirectoryContextString, "getDirectoryContextString");
-    __name(getEnvironmentContext, "getEnvironmentContext");
-  }
-});
-
 // packages/core/dist/src/subagents/subagent-events.js
 import { EventEmitter as EventEmitter5 } from "events";
 var SubAgentEventType, SubAgentEventEmitter;
@@ -200175,11 +200352,7 @@ var init_subagent = __esm({
         if (this.promptConfig.systemPrompt && this.promptConfig.initialMessages) {
           throw new Error("PromptConfig cannot have both `systemPrompt` and `initialMessages` defined.");
         }
-        const envParts = await getEnvironmentContext(this.runtimeContext);
-        const envHistory = [
-          { role: "user", parts: envParts },
-          { role: "model", parts: [{ text: "Got it. Thanks for the context!" }] }
-        ];
+        const envHistory = await getInitialChatHistory(this.runtimeContext);
         const start_history = [
           ...envHistory,
           ...this.promptConfig.initialMessages ?? []
@@ -205187,32 +205360,7 @@ var init_types8 = __esm({
 function isThinkingSupported(model) {
   return model.startsWith("gemini-2.5") || model === DEFAULT_GEMINI_MODEL_AUTO;
 }
-function findCompressSplitPoint(contents, fraction) {
-  if (fraction <= 0 || fraction >= 1) {
-    throw new Error("Fraction must be between 0 and 1");
-  }
-  const charCounts = contents.map((content) => JSON.stringify(content).length);
-  const totalCharCount = charCounts.reduce((a, b) => a + b, 0);
-  const targetCharCount = totalCharCount * fraction;
-  let lastSplitPoint = 0;
-  let cumulativeCharCount = 0;
-  for (let i = 0; i < contents.length; i++) {
-    const content = contents[i];
-    if (content.role === "user" && !content.parts?.some((part) => !!part.functionResponse)) {
-      if (cumulativeCharCount >= targetCharCount) {
-        return i;
-      }
-      lastSplitPoint = i;
-    }
-    cumulativeCharCount += charCounts[i];
-  }
-  const lastContent = contents[contents.length - 1];
-  if (lastContent?.role === "model" && !lastContent?.parts?.some((part) => part.functionCall)) {
-    return contents.length;
-  }
-  return lastSplitPoint;
-}
-var MAX_TURNS, COMPRESSION_TOKEN_THRESHOLD, COMPRESSION_PRESERVE_THRESHOLD, GeminiClient;
+var MAX_TURNS, GeminiClient;
 var init_client2 = __esm({
   "packages/core/dist/src/core/client.js"() {
     "use strict";
@@ -205221,9 +205369,9 @@ var init_client2 = __esm({
     init_models();
     init_geminiChat();
     init_prompts();
-    init_tokenLimits();
     init_turn();
     init_chatRecordingService();
+    init_chatCompressionService();
     init_loopDetectionService();
     init_task();
     init_telemetry();
@@ -205237,10 +205385,7 @@ var init_client2 = __esm({
     init_types8();
     init_handler();
     __name(isThinkingSupported, "isThinkingSupported");
-    __name(findCompressSplitPoint, "findCompressSplitPoint");
     MAX_TURNS = 100;
-    COMPRESSION_TOKEN_THRESHOLD = 0.7;
-    COMPRESSION_PRESERVE_THRESHOLD = 0.3;
     GeminiClient = class {
       static {
         __name(this, "GeminiClient");
@@ -205324,21 +205469,10 @@ var init_client2 = __esm({
       async startChat(extraHistory) {
         this.forceFullIdeContext = true;
         this.hasFailedCompressionAttempt = false;
-        const envParts = await getEnvironmentContext(this.config);
         const toolRegistry = this.config.getToolRegistry();
         const toolDeclarations = toolRegistry.getFunctionDeclarations();
         const tools = [{ functionDeclarations: toolDeclarations }];
-        const history = [
-          {
-            role: "user",
-            parts: envParts
-          },
-          {
-            role: "model",
-            parts: [{ text: "Got it. Thanks for the context!" }]
-          },
-          ...extraHistory ?? []
-        ];
+        const history = await getInitialChatHistory(this.config, extraHistory);
         try {
           const userMemory = this.config.getUserMemory();
           const model = this.config.getModel();
@@ -205509,12 +205643,13 @@ var init_client2 = __esm({
           const currentHistory = this.getChat().getHistory(true);
           const userMemory = this.config.getUserMemory();
           const systemPrompt = getCoreSystemPrompt(userMemory, this.config.getModel());
-          const environment = await getEnvironmentContext(this.config);
+          const initialHistory = await getInitialChatHistory(this.config);
           const mockRequestContent = [
             {
               role: "system",
-              parts: [{ text: systemPrompt }, ...environment]
+              parts: [{ text: systemPrompt }]
             },
+            ...initialHistory,
             ...currentHistory
           ];
           const { totalTokens: totalRequestTokens } = await this.config.getContentGenerator().countTokens({
@@ -205641,85 +205776,19 @@ var init_client2 = __esm({
         }
       }
       async tryCompressChat(prompt_id, force = false) {
-        const model = this.config.getModel();
-        const curatedHistory = this.getChat().getHistory(true);
-        if (curatedHistory.length === 0 || this.hasFailedCompressionAttempt && !force) {
-          return {
-            originalTokenCount: 0,
-            newTokenCount: 0,
-            compressionStatus: CompressionStatus.NOOP
-          };
-        }
-        const originalTokenCount = uiTelemetryService.getLastPromptTokenCount();
-        const contextPercentageThreshold = this.config.getChatCompression()?.contextPercentageThreshold;
-        if (!force) {
-          const threshold = contextPercentageThreshold ?? COMPRESSION_TOKEN_THRESHOLD;
-          if (originalTokenCount < threshold * tokenLimit(model)) {
-            return {
-              originalTokenCount,
-              newTokenCount: originalTokenCount,
-              compressionStatus: CompressionStatus.NOOP
-            };
+        const compressionService = new ChatCompressionService();
+        const { newHistory, info } = await compressionService.compress(this.getChat(), prompt_id, force, this.config.getModel(), this.config, this.hasFailedCompressionAttempt);
+        if (info.compressionStatus === CompressionStatus.COMPRESSED) {
+          if (newHistory) {
+            this.chat = await this.startChat(newHistory);
+            this.forceFullIdeContext = true;
           }
-        }
-        const splitPoint = findCompressSplitPoint(curatedHistory, 1 - COMPRESSION_PRESERVE_THRESHOLD);
-        const historyToCompress = curatedHistory.slice(0, splitPoint);
-        const historyToKeep = curatedHistory.slice(splitPoint);
-        const summaryResponse = await this.config.getContentGenerator().generateContent({
-          model,
-          contents: [
-            ...historyToCompress,
-            {
-              role: "user",
-              parts: [
-                {
-                  text: "First, reason in your scratchpad. Then, generate the <state_snapshot>."
-                }
-              ]
-            }
-          ],
-          config: {
-            systemInstruction: { text: getCompressionPrompt() }
+        } else if (info.compressionStatus === CompressionStatus.COMPRESSION_FAILED_INFLATED_TOKEN_COUNT || info.compressionStatus === CompressionStatus.COMPRESSION_FAILED_EMPTY_SUMMARY) {
+          if (!force) {
+            this.hasFailedCompressionAttempt = true;
           }
-        }, prompt_id);
-        const summary = getResponseText(summaryResponse) ?? "";
-        const chat = await this.startChat([
-          {
-            role: "user",
-            parts: [{ text: summary }]
-          },
-          {
-            role: "model",
-            parts: [{ text: "Got it. Thanks for the additional context!" }]
-          },
-          ...historyToKeep
-        ]);
-        this.forceFullIdeContext = true;
-        const newTokenCount = Math.floor(chat.getHistory().reduce((total, content) => total + JSON.stringify(content).length, 0) / 4);
-        logChatCompression(this.config, makeChatCompressionEvent({
-          tokens_before: originalTokenCount,
-          tokens_after: newTokenCount
-        }));
-        if (newTokenCount > originalTokenCount) {
-          this.hasFailedCompressionAttempt = !force && true;
-          return {
-            originalTokenCount,
-            newTokenCount,
-            compressionStatus: CompressionStatus.COMPRESSION_FAILED_INFLATED_TOKEN_COUNT
-          };
-        } else {
-          this.chat = chat;
-          uiTelemetryService.setLastPromptTokenCount(newTokenCount);
         }
-        logChatCompression(this.config, makeChatCompressionEvent({
-          tokens_before: originalTokenCount,
-          tokens_after: newTokenCount
-        }));
-        return {
-          originalTokenCount,
-          newTokenCount,
-          compressionStatus: CompressionStatus.COMPRESSED
-        };
+        return info;
       }
     };
   }
@@ -231807,10 +231876,20 @@ function getRipgrepPath() {
   const vendorPath = isBundled ? path39.join(__dirname3, "vendor", "ripgrep", `${arch3}-${platform14}`, binaryName) : path39.join(__dirname3, "..", "..", "..", "vendor", "ripgrep", `${arch3}-${platform14}`, binaryName);
   return vendorPath;
 }
-async function canUseRipgrep() {
+async function canUseRipgrep(useBuiltin = true) {
   try {
-    const rgPath = getRipgrepPath();
-    return await fileExists(rgPath);
+    if (useBuiltin) {
+      const rgPath = getRipgrepPath();
+      if (await fileExists(rgPath)) {
+        return true;
+      }
+    }
+    const { spawn: spawn13 } = await import("node:child_process");
+    return await new Promise((resolve23) => {
+      const proc2 = spawn13("rg", ["--version"]);
+      proc2.on("error", () => resolve23(false));
+      proc2.on("exit", (code2) => resolve23(code2 === 0));
+    });
   } catch (_error) {
     return false;
   }
@@ -231843,17 +231922,19 @@ import fs36 from "node:fs";
 import path40 from "node:path";
 import { EOL as EOL3 } from "node:os";
 import { spawn as spawn6 } from "node:child_process";
-var DEFAULT_TOTAL_MAX_MATCHES, GrepToolInvocation2, RipGrepTool;
+var MAX_LLM_CONTENT_LENGTH, GrepToolInvocation2, RipGrepTool;
 var init_ripGrep = __esm({
   "packages/core/dist/src/tools/ripGrep.js"() {
     "use strict";
     init_esbuild_shims();
     init_tools();
-    init_schemaValidator();
+    init_tool_names();
     init_paths();
     init_errors();
     init_ripgrepUtils();
-    DEFAULT_TOTAL_MAX_MATCHES = 2e4;
+    init_schemaValidator();
+    init_constants3();
+    MAX_LLM_CONTENT_LENGTH = 2e4;
     GrepToolInvocation2 = class extends BaseToolInvocation {
       static {
         __name(this, "GrepToolInvocation");
@@ -231866,19 +231947,20 @@ var init_ripGrep = __esm({
       /**
        * Checks if a path is within the root directory and resolves it.
        * @param relativePath Path relative to the root directory (or undefined for root).
-       * @returns The absolute path if valid and exists, or null if no path specified (to search all directories).
+       * @returns The absolute path to search within.
        * @throws {Error} If path is outside root, doesn't exist, or isn't a directory.
        */
       resolveAndValidatePath(relativePath) {
-        if (!relativePath) {
-          return null;
-        }
-        const targetPath = path40.resolve(this.config.getTargetDir(), relativePath);
+        const targetDir = this.config.getTargetDir();
+        const targetPath = relativePath ? path40.resolve(targetDir, relativePath) : targetDir;
         const workspaceContext = this.config.getWorkspaceContext();
         if (!workspaceContext.isPathWithinWorkspace(targetPath)) {
           const directories = workspaceContext.getDirectories();
           throw new Error(`Path validation failed: Attempted path "${relativePath}" resolves outside the allowed workspace directories: ${directories.join(", ")}`);
         }
+        return this.ensureDirectory(targetPath);
+      }
+      ensureDirectory(targetPath) {
         try {
           const stats = fs36.statSync(targetPath);
           if (!stats.isDirectory()) {
@@ -231894,82 +231976,50 @@ var init_ripGrep = __esm({
       }
       async execute(signal) {
         try {
-          const workspaceContext = this.config.getWorkspaceContext();
           const searchDirAbs = this.resolveAndValidatePath(this.params.path);
           const searchDirDisplay = this.params.path || ".";
-          let searchDirectories;
-          if (searchDirAbs === null) {
-            searchDirectories = workspaceContext.getDirectories();
-          } else {
-            searchDirectories = [searchDirAbs];
-          }
-          let allMatches = [];
-          const totalMaxMatches = DEFAULT_TOTAL_MAX_MATCHES;
-          if (this.config.getDebugMode()) {
-            console.log(`[GrepTool] Total result limit: ${totalMaxMatches}`);
-          }
-          for (const searchDir of searchDirectories) {
-            const searchResult = await this.performRipgrepSearch({
-              pattern: this.params.pattern,
-              path: searchDir,
-              include: this.params.include,
-              signal
-            });
-            if (searchDirectories.length > 1) {
-              const dirName = path40.basename(searchDir);
-              searchResult.forEach((match2) => {
-                match2.filePath = path40.join(dirName, match2.filePath);
-              });
-            }
-            allMatches = allMatches.concat(searchResult);
-            if (allMatches.length >= totalMaxMatches) {
-              allMatches = allMatches.slice(0, totalMaxMatches);
-              break;
-            }
-          }
-          let searchLocationDescription;
-          if (searchDirAbs === null) {
-            const numDirs = workspaceContext.getDirectories().length;
-            searchLocationDescription = numDirs > 1 ? `across ${numDirs} workspace directories` : `in the workspace directory`;
-          } else {
-            searchLocationDescription = `in path "${searchDirDisplay}"`;
-          }
-          if (allMatches.length === 0) {
-            const noMatchMsg = `No matches found for pattern "${this.params.pattern}" ${searchLocationDescription}${this.params.include ? ` (filter: "${this.params.include}")` : ""}.`;
+          const rawOutput = await this.performRipgrepSearch({
+            pattern: this.params.pattern,
+            path: searchDirAbs,
+            glob: this.params.glob,
+            signal
+          });
+          const searchLocationDescription = this.params.path ? `in path "${searchDirDisplay}"` : `in the workspace directory`;
+          const filterDescription = this.params.glob ? ` (filter: "${this.params.glob}")` : "";
+          if (!rawOutput.trim()) {
+            const noMatchMsg = `No matches found for pattern "${this.params.pattern}" ${searchLocationDescription}${filterDescription}.`;
             return { llmContent: noMatchMsg, returnDisplay: `No matches found` };
           }
-          const wasTruncated = allMatches.length >= totalMaxMatches;
-          const matchesByFile = allMatches.reduce((acc, match2) => {
-            const fileKey = match2.filePath;
-            if (!acc[fileKey]) {
-              acc[fileKey] = [];
-            }
-            acc[fileKey].push(match2);
-            acc[fileKey].sort((a, b) => a.lineNumber - b.lineNumber);
-            return acc;
-          }, {});
-          const matchCount = allMatches.length;
-          const matchTerm = matchCount === 1 ? "match" : "matches";
-          let llmContent = `Found ${matchCount} ${matchTerm} for pattern "${this.params.pattern}" ${searchLocationDescription}${this.params.include ? ` (filter: "${this.params.include}")` : ""}`;
-          if (wasTruncated) {
-            llmContent += ` (results limited to ${totalMaxMatches} matches for performance)`;
-          }
-          llmContent += `:
+          const allLines = rawOutput.split(EOL3).filter((line) => line.trim());
+          const totalMatches = allLines.length;
+          const matchTerm = totalMatches === 1 ? "match" : "matches";
+          const header = `Found ${totalMatches} ${matchTerm} for pattern "${this.params.pattern}" ${searchLocationDescription}${filterDescription}:
 ---
 `;
-          for (const filePath in matchesByFile) {
-            llmContent += `File: ${filePath}
-`;
-            matchesByFile[filePath].forEach((match2) => {
-              const trimmedLine = match2.line.trim();
-              llmContent += `L${match2.lineNumber}: ${trimmedLine}
-`;
-            });
-            llmContent += "---\n";
-          }
-          let displayMessage = `Found ${matchCount} ${matchTerm}`;
-          if (wasTruncated) {
-            displayMessage += ` (limited)`;
+          const maxTruncationNoticeLength = 100;
+          const maxGrepOutputLength = MAX_LLM_CONTENT_LENGTH - header.length - maxTruncationNoticeLength;
+          let truncatedByLineLimit = false;
+          let linesToInclude = allLines;
+          if (this.params.limit !== void 0 && allLines.length > this.params.limit) {
+            linesToInclude = allLines.slice(0, this.params.limit);
+            truncatedByLineLimit = true;
+          }
+          let grepOutput = linesToInclude.join(EOL3);
+          let truncatedByCharLimit = false;
+          if (grepOutput.length > maxGrepOutputLength) {
+            grepOutput = grepOutput.slice(0, maxGrepOutputLength) + "...";
+            truncatedByCharLimit = true;
+          }
+          const finalLines = grepOutput.split(EOL3).filter((line) => line.trim());
+          const includedLines = finalLines.length;
+          let llmContent = header + grepOutput;
+          if (truncatedByLineLimit || truncatedByCharLimit) {
+            const omittedMatches = totalMatches - includedLines;
+            llmContent += ` [${omittedMatches} ${omittedMatches === 1 ? "line" : "lines"} truncated] ...`;
+          }
+          let displayMessage = `Found ${totalMatches} ${matchTerm}`;
+          if (truncatedByLineLimit || truncatedByCharLimit) {
+            displayMessage += ` (truncated)`;
           }
           return {
             llmContent: llmContent.trim(),
@@ -231984,38 +232034,8 @@ var init_ripGrep = __esm({
           };
         }
       }
-      parseRipgrepOutput(output, basePath) {
-        const results = [];
-        if (!output)
-          return results;
-        const lines = output.split(EOL3);
-        for (const line of lines) {
-          if (!line.trim())
-            continue;
-          const firstColonIndex = line.indexOf(":");
-          if (firstColonIndex === -1)
-            continue;
-          const secondColonIndex = line.indexOf(":", firstColonIndex + 1);
-          if (secondColonIndex === -1)
-            continue;
-          const filePathRaw = line.substring(0, firstColonIndex);
-          const lineNumberStr = line.substring(firstColonIndex + 1, secondColonIndex);
-          const lineContent = line.substring(secondColonIndex + 1);
-          const lineNumber = parseInt(lineNumberStr, 10);
-          if (!isNaN(lineNumber)) {
-            const absoluteFilePath = path40.resolve(basePath, filePathRaw);
-            const relativeFilePath = path40.relative(basePath, absoluteFilePath);
-            results.push({
-              filePath: relativeFilePath || path40.basename(absoluteFilePath),
-              lineNumber,
-              line: lineContent
-            });
-          }
-        }
-        return results;
-      }
       async performRipgrepSearch(options2) {
-        const { pattern, path: absolutePath, include } = options2;
+        const { pattern, path: absolutePath, glob: glob2 } = options2;
         const rgArgs = [
           "--line-number",
           "--no-heading",
@@ -232024,26 +232044,23 @@ var init_ripGrep = __esm({
           "--regexp",
           pattern
         ];
-        if (include) {
-          rgArgs.push("--glob", include);
-        }
-        const excludes = [
-          ".git",
-          "node_modules",
-          "bower_components",
-          "*.log",
-          "*.tmp",
-          "build",
-          "dist",
-          "coverage"
-        ];
-        excludes.forEach((exclude) => {
-          rgArgs.push("--glob", `!${exclude}`);
-        });
+        const filteringOptions = this.getFileFilteringOptions();
+        if (!filteringOptions.respectGitIgnore) {
+          rgArgs.push("--no-ignore-vcs");
+        }
+        if (filteringOptions.respectQwenIgnore) {
+          const qwenIgnorePath = path40.join(this.config.getTargetDir(), ".qwenignore");
+          if (fs36.existsSync(qwenIgnorePath)) {
+            rgArgs.push("--ignore-file", qwenIgnorePath);
+          }
+        }
+        if (glob2) {
+          rgArgs.push("--glob", glob2);
+        }
         rgArgs.push("--threads", "4");
         rgArgs.push(absolutePath);
         try {
-          const rgPath = await ensureRipgrepPath();
+          const rgPath = this.config.getUseBuiltinRipgrep() ? await ensureRipgrepPath() : "rg";
           const output = await new Promise((resolve23, reject) => {
             const child = spawn6(rgPath, rgArgs, {
               windowsHide: true
@@ -232075,21 +232092,27 @@ var init_ripGrep = __esm({
               }
             });
           });
-          return this.parseRipgrepOutput(output, absolutePath);
+          return output;
         } catch (error) {
           console.error(`GrepLogic: ripgrep failed: ${getErrorMessage(error)}`);
           throw error;
         }
       }
+      getFileFilteringOptions() {
+        const options2 = this.config.getFileFilteringOptions?.();
+        return {
+          respectGitIgnore: options2?.respectGitIgnore ?? DEFAULT_FILE_FILTERING_OPTIONS.respectGitIgnore,
+          respectQwenIgnore: options2?.respectQwenIgnore ?? DEFAULT_FILE_FILTERING_OPTIONS.respectQwenIgnore
+        };
+      }
       /**
        * Gets a description of the grep operation
-       * @param params Parameters for the grep operation
        * @returns A string describing the grep
        */
       getDescription() {
         let description = `'${this.params.pattern}'`;
-        if (this.params.include) {
-          description += ` in ${this.params.include}`;
+        if (this.params.glob) {
+          description += ` in ${this.params.glob}`;
         }
         if (this.params.path) {
           const resolvedPath = path40.resolve(this.config.getTargetDir(), this.params.path);
@@ -232114,21 +232137,25 @@ var init_ripGrep = __esm({
         __name(this, "RipGrepTool");
       }
       config;
-      static Name = "search_file_content";
+      static Name = ToolNames.GREP;
       constructor(config) {
-        super(_RipGrepTool.Name, "SearchText", "Searches for a regular expression pattern within the content of files in a specified directory (or current working directory). Can filter files by a glob pattern. Returns the lines containing matches, along with their file paths and line numbers. Total results limited to 20,000 matches like VSCode.", Kind.Search, {
+        super(_RipGrepTool.Name, "Grep", 'A powerful search tool built on ripgrep\n\n  Usage:\n  - ALWAYS use Grep for search tasks. NEVER invoke `grep` or `rg` as a Bash command. The Grep tool has been optimized for correct permissions and access.\n  - Supports full regex syntax (e.g., "log.*Error", "function\\s+\\w+")\n  - Filter files with glob parameter (e.g., "*.js", "**/*.tsx")\n  - Use Task tool for open-ended searches requiring multiple rounds\n  - Pattern syntax: Uses ripgrep (not grep) - special regex characters need escaping (use `interface\\{\\}` to find `interface{}` in Go code)\n', Kind.Search, {
           properties: {
             pattern: {
-              description: "The regular expression (regex) pattern to search for within file contents (e.g., 'function\\s+myFunction', 'import\\s+\\{.*\\}\\s+from\\s+.*').",
-              type: "string"
+              type: "string",
+              description: "The regular expression pattern to search for in file contents"
+            },
+            glob: {
+              type: "string",
+              description: 'Glob pattern to filter files (e.g. "*.js", "*.{ts,tsx}") - maps to rg --glob'
             },
             path: {
-              description: "Optional: The absolute path to the directory to search within. If omitted, searches the current working directory.",
-              type: "string"
+              type: "string",
+              description: "File or directory to search in (rg PATH). Defaults to current working directory."
             },
-            include: {
-              description: "Optional: A glob pattern to filter which files are searched (e.g., '*.js', '*.{ts,tsx}', 'src/**'). If omitted, searches all files (respecting potential global ignores).",
-              type: "string"
+            limit: {
+              type: "number",
+              description: "Limit output to first N lines/entries. Optional - shows all matches if not specified."
             }
           },
           required: ["pattern"],
@@ -232139,12 +232166,12 @@ var init_ripGrep = __esm({
       /**
        * Checks if a path is within the root directory and resolves it.
        * @param relativePath Path relative to the root directory (or undefined for root).
-       * @returns The absolute path if valid and exists, or null if no path specified (to search all directories).
+       * @returns The absolute path to search within.
        * @throws {Error} If path is outside root, doesn't exist, or isn't a directory.
        */
       resolveAndValidatePath(relativePath) {
         if (!relativePath) {
-          return null;
+          return this.config.getTargetDir();
         }
         const targetPath = path40.resolve(this.config.getTargetDir(), relativePath);
         const workspaceContext = this.config.getWorkspaceContext();
@@ -232170,11 +232197,16 @@ var init_ripGrep = __esm({
        * @param params Parameters to validate
        * @returns An error message string if invalid, null otherwise
        */
-      validateToolParams(params) {
+      validateToolParamValues(params) {
         const errors = SchemaValidator.validate(this.schema.parametersJsonSchema, params);
         if (errors) {
           return errors;
         }
+        try {
+          new RegExp(params.pattern);
+        } catch (error) {
+          return `Invalid regular expression pattern: ${params.pattern}. Error: ${getErrorMessage(error)}`;
+        }
         if (params.path) {
           try {
             this.resolveAndValidatePath(params.path);
@@ -243855,6 +243887,7 @@ var init_config3 = __esm({
       interactive;
       trustedFolder;
       useRipgrep;
+      useBuiltinRipgrep;
       shouldUseNodePtyShell;
       skipNextSpeakerCheck;
       shellExecutionConfig;
@@ -243942,11 +243975,10 @@ var init_config3 = __esm({
         this.chatCompression = params.chatCompression;
         this.interactive = params.interactive ?? false;
         this.trustedFolder = params.trustedFolder;
-        this.shouldUseNodePtyShell = params.shouldUseNodePtyShell ?? false;
-        this.skipNextSpeakerCheck = params.skipNextSpeakerCheck ?? false;
         this.skipLoopDetection = params.skipLoopDetection ?? false;
         this.tavilyApiKey = params.tavilyApiKey;
         this.useRipgrep = params.useRipgrep ?? true;
+        this.useBuiltinRipgrep = params.useBuiltinRipgrep ?? true;
         this.shouldUseNodePtyShell = params.shouldUseNodePtyShell ?? false;
         this.skipNextSpeakerCheck = params.skipNextSpeakerCheck ?? true;
         this.shellExecutionConfig = {
@@ -244314,6 +244346,9 @@ var init_config3 = __esm({
       getUseRipgrep() {
         return this.useRipgrep;
       }
+      getUseBuiltinRipgrep() {
+        return this.useBuiltinRipgrep;
+      }
       getShouldUseNodePtyShell() {
         return this.shouldUseNodePtyShell;
       }
@@ -244402,13 +244437,14 @@ var init_config3 = __esm({
           let useRipgrep = false;
           let errorString = void 0;
           try {
-            useRipgrep = await canUseRipgrep();
+            useRipgrep = await canUseRipgrep(this.getUseBuiltinRipgrep());
           } catch (error) {
             errorString = String(error);
           }
           if (useRipgrep) {
             registerCoreTool(RipGrepTool, this);
           } else {
+            errorString = errorString || "Ripgrep is not available. Please install ripgrep globally.";
             logRipgrepFallback(this, new RipgrepFallbackEvent(errorString));
             registerCoreTool(GrepTool, this);
           }
@@ -251803,6 +251839,7 @@ var init_src = __esm({
     init_textUtils();
     init_formatters();
     init_generateContentResponseUtilities();
+    init_ripgrepUtils();
     init_fileSearch();
     init_errorParsing();
     init_workspaceContext();
@@ -316229,7 +316266,7 @@ init_esbuild_shims();
 
 // packages/cli/src/generated/git-commit.ts
 init_esbuild_shims();
-var GIT_COMMIT_INFO2 = "2d7b6ccf";
+var GIT_COMMIT_INFO2 = "388dee5a";
 
 // packages/cli/src/ui/components/AboutBox.tsx
 var import_jsx_runtime43 = __toESM(require_jsx_runtime(), 1);
@@ -317345,7 +317382,7 @@ var ToolsList = /* @__PURE__ */ __name(({
   showDescriptions,
   terminalWidth
 }) => /* @__PURE__ */ (0, import_jsx_runtime51.jsxs)(Box_default, { flexDirection: "column", marginBottom: 1, children: [
-  /* @__PURE__ */ (0, import_jsx_runtime51.jsx)(Text, { bold: true, color: theme.text.primary, children: "Available Gemini CLI tools:" }),
+  /* @__PURE__ */ (0, import_jsx_runtime51.jsx)(Text, { bold: true, color: theme.text.primary, children: "Available Qwen Code CLI tools:" }),
   /* @__PURE__ */ (0, import_jsx_runtime51.jsx)(Box_default, { height: 1 }),
   tools.length > 0 ? tools.map((tool) => /* @__PURE__ */ (0, import_jsx_runtime51.jsxs)(Box_default, { flexDirection: "row", children: [
     /* @__PURE__ */ (0, import_jsx_runtime51.jsxs)(Text, { color: theme.text.primary, children: [
@@ -319044,6 +319081,15 @@ var SETTINGS_SCHEMA = {
         description: "Use ripgrep for file content search instead of the fallback implementation. Provides faster search performance.",
         showInDialog: true
       },
+      useBuiltinRipgrep: {
+        type: "boolean",
+        label: "Use Builtin Ripgrep",
+        category: "Tools",
+        requiresRestart: false,
+        default: true,
+        description: 'Use the bundled ripgrep binary. When set to false, the system-level "rg" command will be used instead. This setting is only effective when useRipgrep is true.',
+        showInDialog: true
+      },
       enableToolOutputTruncation: {
         type: "boolean",
         label: "Enable Tool Output Truncation",
@@ -325786,6 +325832,8 @@ var USER_SETTINGS_PATH = Storage.getGlobalSettingsPath();
 var USER_SETTINGS_DIR2 = path71.dirname(USER_SETTINGS_PATH);
 var DEFAULT_EXCLUDED_ENV_VARS = ["DEBUG", "DEBUG_MODE"];
 var MIGRATE_V2_OVERWRITE = true;
+var SETTINGS_VERSION = 2;
+var SETTINGS_VERSION_KEY = "$version";
 var MIGRATION_MAP = {
   accessibility: "ui.accessibility",
   allowedTools: "tools.allowed",
@@ -325911,6 +325959,12 @@ function setNestedProperty(obj, path107, value) {
 }
 __name(setNestedProperty, "setNestedProperty");
 function needsMigration(settings) {
+  if (SETTINGS_VERSION_KEY in settings) {
+    const version2 = settings[SETTINGS_VERSION_KEY];
+    if (typeof version2 === "number" && version2 >= SETTINGS_VERSION) {
+      return false;
+    }
+  }
   const hasV1Keys = Object.entries(MIGRATION_MAP).some(([v1Key, v2Path]) => {
     if (v1Key === v2Path || !(v1Key in settings)) {
       return false;
@@ -325931,6 +325985,11 @@ function migrateSettingsToV2(flatSettings) {
   const flatKeys = new Set(Object.keys(flatSettings));
   for (const [oldKey, newPath] of Object.entries(MIGRATION_MAP)) {
     if (flatKeys.has(oldKey)) {
+      if (KNOWN_V2_CONTAINERS.has(oldKey) && typeof flatSettings[oldKey] === "object" && flatSettings[oldKey] !== null && !Array.isArray(flatSettings[oldKey])) {
+        v2Settings[oldKey] = flatSettings[oldKey];
+        flatKeys.delete(oldKey);
+        continue;
+      }
       setNestedProperty(v2Settings, newPath, flatSettings[oldKey]);
       flatKeys.delete(oldKey);
     }
@@ -325954,6 +326013,7 @@ function migrateSettingsToV2(flatSettings) {
       v2Settings[remainingKey] = newValue;
     }
   }
+  v2Settings[SETTINGS_VERSION_KEY] = SETTINGS_VERSION;
   return v2Settings;
 }
 __name(migrateSettingsToV2, "migrateSettingsToV2");
@@ -325990,6 +326050,9 @@ function migrateSettingsToV1(v2Settings) {
     v2Keys.delete("mcpServers");
   }
   for (const remainingKey of v2Keys) {
+    if (remainingKey === SETTINGS_VERSION_KEY) {
+      continue;
+    }
     const value = v2Settings[remainingKey];
     if (value === void 0) {
       continue;
@@ -326195,6 +326258,21 @@ function loadSettings(workspaceDir = process27.cwd()) {
             }
             settingsObject = migratedSettings;
           }
+        } else if (!(SETTINGS_VERSION_KEY in settingsObject)) {
+          settingsObject[SETTINGS_VERSION_KEY] = SETTINGS_VERSION;
+          if (MIGRATE_V2_OVERWRITE) {
+            try {
+              fs69.writeFileSync(
+                filePath,
+                JSON.stringify(settingsObject, null, 2),
+                "utf-8"
+              );
+            } catch (e2) {
+              console.error(
+                `Error adding version to settings file: ${getErrorMessage(e2)}`
+              );
+            }
+          }
         }
         return { settings: settingsObject, rawJson: content };
       }
@@ -338265,7 +338343,7 @@ __name(getPackageJson, "getPackageJson");
 // packages/cli/src/utils/version.ts
 async function getCliVersion() {
   const pkgJson = await getPackageJson();
-  return "0.1.2-nightly.20251031.ced79cf4";
+  return "0.1.3-nightly.20251101.ff8a8ac6";
 }
 __name(getCliVersion, "getCliVersion");
 
@@ -338763,7 +338841,7 @@ async function parseArguments(settings) {
     'Use the "proxy" setting in settings.json instead. This flag will be removed in a future version.'
   ).command(
     "$0 [query..]",
-    "Launch Gemini CLI",
+    "Launch Qwen Code CLI",
     (yargsInstance2) => yargsInstance2.positional("query", {
       description: "Positional prompt. Defaults to one-shot; use -i/--prompt-interactive for interactive."
     }).option("model", {
@@ -339146,6 +339224,7 @@ async function loadCliConfig(settings, extensions, extensionEnablementManager, s
     interactive,
     trustedFolder,
     useRipgrep: settings.tools?.useRipgrep,
+    useBuiltinRipgrep: settings.tools?.useBuiltinRipgrep,
     shouldUseNodePtyShell: settings.tools?.shell?.enableInteractiveShell,
     skipNextSpeakerCheck: settings.model?.skipNextSpeakerCheck,
     enablePromptCompletion: settings.general?.enablePromptCompletion ?? false,
@@ -340228,7 +340307,7 @@ var bugCommand = {
     let info = `
 * **CLI Version:** ${cliVersion}
 * **Git Commit:** ${GIT_COMMIT_INFO2}
-* **Session ID:** ${sessionId}
+* **Session ID:** ${config?.getSessionId() || "unknown"}
 * **Operating System:** ${osVersion}
 * **Sandbox Environment:** ${sandboxEnv}
 * **Auth Type:** ${selectedAuthType}`;
@@ -352954,10 +353033,10 @@ import * as os38 from "node:os";
 import path105 from "node:path";
 var homeDirectoryCheck = {
   id: "home-directory",
-  check: /* @__PURE__ */ __name(async (workspaceRoot) => {
+  check: /* @__PURE__ */ __name(async (options2) => {
     try {
       const [workspaceRealPath, homeRealPath] = await Promise.all([
-        fs92.realpath(workspaceRoot),
+        fs92.realpath(options2.workspaceRoot),
         fs92.realpath(os38.homedir())
       ]);
       if (workspaceRealPath === homeRealPath) {
@@ -352971,9 +353050,9 @@ var homeDirectoryCheck = {
 };
 var rootDirectoryCheck = {
   id: "root-directory",
-  check: /* @__PURE__ */ __name(async (workspaceRoot) => {
+  check: /* @__PURE__ */ __name(async (options2) => {
     try {
-      const workspaceRealPath = await fs92.realpath(workspaceRoot);
+      const workspaceRealPath = await fs92.realpath(options2.workspaceRoot);
       const errorMessage = "Warning: You are running Qwen Code in the root directory. Your entire folder structure will be used for context. It is strongly recommended to run in a project-specific directory.";
       if (path105.dirname(workspaceRealPath) === workspaceRealPath) {
         return errorMessage;
@@ -352984,13 +353063,27 @@ var rootDirectoryCheck = {
     }
   }, "check")
 };
+var ripgrepAvailabilityCheck = {
+  id: "ripgrep-availability",
+  check: /* @__PURE__ */ __name(async (options2) => {
+    if (!options2.useRipgrep) {
+      return null;
+    }
+    const isAvailable = await canUseRipgrep(options2.useBuiltinRipgrep);
+    if (!isAvailable) {
+      return "Ripgrep not available: Please install ripgrep globally to enable faster file content search. Falling back to built-in grep.";
+    }
+    return null;
+  }, "check")
+};
 var WARNING_CHECKS = [
   homeDirectoryCheck,
-  rootDirectoryCheck
+  rootDirectoryCheck,
+  ripgrepAvailabilityCheck
 ];
-async function getUserStartupWarnings(workspaceRoot = process.cwd()) {
+async function getUserStartupWarnings(options2) {
   const results = await Promise.all(
-    WARNING_CHECKS.map((check) => check.check(workspaceRoot))
+    WARNING_CHECKS.map((check) => check.check(options2))
   );
   return results.filter((msg) => msg !== null);
 }
@@ -354917,7 +355010,11 @@ ${finalArgs[promptIndex + 1]}`;
     let input = config.getQuestion();
     const startupWarnings = [
       ...await getStartupWarnings(),
-      ...await getUserStartupWarnings()
+      ...await getUserStartupWarnings({
+        workspaceRoot: process.cwd(),
+        useRipgrep: settings.merged.tools?.useRipgrep ?? true,
+        useBuiltinRipgrep: settings.merged.tools?.useBuiltinRipgrep ?? true
+      })
     ];
     if (config.isInteractive()) {
       await kittyProtocolDetectionComplete;