@rdmind/rdmind 0.0.22-alpha.0 → 0.0.23-alpha.0

package/cli.js

@@ -183770,7 +183770,7 @@ function createContentGeneratorConfig(config, authType, generationConfig) {
   };
 }
 async function createContentGenerator(config, gcConfig, sessionId2) {
-  const version2 = "0.0.22-alpha.0";
+  const version2 = "0.0.23-alpha.0";
   const userAgent2 = `QwenCode/${version2} (${process.platform}; ${process.arch})`;
   const baseHeaders = {
     "User-Agent": userAgent2
@@ -185708,6 +185708,7 @@ var init_gitUtils = __esm({
 });
 
 // packages/core/src/utils/paths.ts
+import fs19 from "node:fs";
 import path15 from "node:path";
 import os11 from "node:os";
 import * as crypto11 from "node:crypto";
@@ -185799,11 +185800,51 @@ function isSubpath(parentPath, childPath) {
   const relative10 = pathModule2.relative(parentPath, childPath);
   return !relative10.startsWith(`..${pathModule2.sep}`) && relative10 !== ".." && !pathModule2.isAbsolute(relative10);
 }
+function resolvePath(baseDir = process.cwd(), relativePath) {
+  const homeDir = os11.homedir();
+  if (relativePath === "~") {
+    return homeDir;
+  } else if (relativePath.startsWith("~/")) {
+    return path15.join(homeDir, relativePath.slice(2));
+  } else if (path15.isAbsolute(relativePath)) {
+    return relativePath;
+  } else {
+    return path15.resolve(baseDir, relativePath);
+  }
+}
+function validatePath(config, resolvedPath, options2 = {}) {
+  const { allowFiles = false } = options2;
+  const workspaceContext = config.getWorkspaceContext();
+  if (!workspaceContext.isPathWithinWorkspace(resolvedPath)) {
+    throw new Error("Path is not within workspace");
+  }
+  try {
+    const stats = fs19.statSync(resolvedPath);
+    if (!allowFiles && !stats.isDirectory()) {
+      throw new Error(`Path is not a directory: ${resolvedPath}`);
+    }
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") {
+      throw new Error(`Path does not exist: ${resolvedPath}`);
+    }
+    throw error;
+  }
+}
+function resolveAndValidatePath(config, relativePath, options2 = {}) {
+  const targetDir = config.getTargetDir();
+  if (!relativePath) {
+    return targetDir;
+  }
+  const resolvedPath = resolvePath(targetDir, relativePath);
+  validatePath(config, resolvedPath, options2);
+  return resolvedPath;
+}
 var QWEN_DIR5, SHELL_SPECIAL_CHARS;
 var init_paths = __esm({
   "packages/core/src/utils/paths.ts"() {
     "use strict";
     init_esbuild_shims();
+    init_errors();
     QWEN_DIR5 = ".rdmind";
     SHELL_SPECIAL_CHARS = /[ \t()[\]{};|*?$`'"#&<>!~]/;
     __name(tildeifyPath, "tildeifyPath");
@@ -185813,11 +185854,14 @@ var init_paths = __esm({
     __name(unescapePath, "unescapePath");
     __name(getProjectHash, "getProjectHash");
     __name(isSubpath, "isSubpath");
+    __name(resolvePath, "resolvePath");
+    __name(validatePath, "validatePath");
+    __name(resolveAndValidatePath, "resolveAndValidatePath");
   }
 });
 
 // packages/core/src/tools/memoryTool.ts
-import * as fs19 from "node:fs/promises";
+import * as fs20 from "node:fs/promises";
 import * as path16 from "node:path";
 function setGeminiMdFilename(newFilename) {
   if (Array.isArray(newFilename)) {
@@ -185859,7 +185903,7 @@ function ensureNewlineSeparation(currentContent) {
 }
 async function readMemoryFileContent(scope = "global") {
   try {
-    return await fs19.readFile(getMemoryFilePath(scope), "utf-8");
+    return await fs20.readFile(getMemoryFilePath(scope), "utf-8");
   } catch (err) {
     const error = err;
     if (!(error instanceof Error) || error.code !== "ENOENT") throw err;
@@ -186084,10 +186128,10 @@ Project: ${projectPath} (current project only)`;
         const memoryFilePath = getMemoryFilePath(scope);
         try {
           if (modified_by_user && modified_content !== void 0) {
-            await fs19.mkdir(path16.dirname(memoryFilePath), {
+            await fs20.mkdir(path16.dirname(memoryFilePath), {
               recursive: true
             });
-            await fs19.writeFile(memoryFilePath, modified_content, "utf-8");
+            await fs20.writeFile(memoryFilePath, modified_content, "utf-8");
             const successMessage = `Okay, I've updated the ${scope} memory file with your modifications.`;
             return {
               llmContent: successMessage,
@@ -186095,9 +186139,9 @@ Project: ${projectPath} (current project only)`;
             };
           } else {
             await MemoryTool.performAddMemoryEntry(fact, memoryFilePath, {
-              readFile: fs19.readFile,
-              writeFile: fs19.writeFile,
-              mkdir: fs19.mkdir
+              readFile: fs20.readFile,
+              writeFile: fs20.writeFile,
+              mkdir: fs20.mkdir
             });
             const successMessage = `Okay, I've remembered that in ${scope} memory: "${fact}"`;
             return {
@@ -186256,7 +186300,7 @@ ${newContent}`;
 
 // packages/core/src/core/prompts.ts
 import path17 from "node:path";
-import fs20 from "node:fs";
+import fs21 from "node:fs";
 import os12 from "node:os";
 import process18 from "node:process";
 function resolvePathFromEnv(envVar) {
@@ -186321,11 +186365,11 @@ function getCoreSystemPrompt(userMemory, model) {
     if (!systemMdResolution.isSwitch) {
       systemMdPath = systemMdResolution.value;
     }
-    if (!fs20.existsSync(systemMdPath)) {
+    if (!fs21.existsSync(systemMdPath)) {
       throw new Error(`missing system prompt file '${systemMdPath}'`);
     }
   }
-  const basePrompt = systemMdEnabled ? fs20.readFileSync(systemMdPath, "utf8") : `
+  const basePrompt = systemMdEnabled ? fs21.readFileSync(systemMdPath, "utf8") : `
 You are RDMind, an interactive CLI agent, specializing in software engineering tasks. Your primary goal is to help users safely and efficiently, adhering strictly to the following instructions and utilizing your available tools.
 
 # Core Mandates
@@ -186507,8 +186551,8 @@ Your core function is efficient and safe assistance. Balance extreme conciseness
   );
   if (writeSystemMdResolution.value && !writeSystemMdResolution.isDisabled) {
     const writePath = writeSystemMdResolution.isSwitch ? systemMdPath : writeSystemMdResolution.value;
-    fs20.mkdirSync(path17.dirname(writePath), { recursive: true });
-    fs20.writeFileSync(writePath, basePrompt);
+    fs21.mkdirSync(path17.dirname(writePath), { recursive: true });
+    fs21.writeFileSync(writePath, basePrompt);
   }
   const memorySuffix = userMemory && userMemory.trim().length > 0 ? `
 
@@ -198134,7 +198178,7 @@ ${stderr}`));
 });
 
 // packages/core/src/tools/shell.ts
-import fs21 from "node:fs";
+import fs22 from "node:fs";
 import path18 from "node:path";
 import os16, { EOL } from "node:os";
 import crypto12 from "node:crypto";
@@ -198321,8 +198365,8 @@ var init_shell = __esm({
           const result = await resultPromise;
           const backgroundPIDs = [];
           if (os16.platform() !== "win32") {
-            if (fs21.existsSync(tempFilePath)) {
-              const pgrepLines = fs21.readFileSync(tempFilePath, "utf8").split(EOL).filter(Boolean);
+            if (fs22.existsSync(tempFilePath)) {
+              const pgrepLines = fs22.readFileSync(tempFilePath, "utf8").split(EOL).filter(Boolean);
               for (const line of pgrepLines) {
                 if (!/^\d+$/.test(line)) {
                   console.error(`pgrep: ${line}`);
@@ -198407,8 +198451,8 @@ ${result.output}`;
             ...executionError
           };
         } finally {
-          if (fs21.existsSync(tempFilePath)) {
-            fs21.unlinkSync(tempFilePath);
+          if (fs22.existsSync(tempFilePath)) {
+            fs22.unlinkSync(tempFilePath);
           }
         }
       }
@@ -198517,7 +198561,7 @@ Co-authored-by: ${gitCoAuthorSettings.name} <${gitCoAuthorSettings.email}>`;
 });
 
 // packages/core/src/core/coreToolScheduler.ts
-import * as fs22 from "node:fs/promises";
+import * as fs23 from "node:fs/promises";
 import * as path19 from "node:path";
 function createFunctionResponsePart(callId, toolName, output) {
   return {
@@ -198607,7 +198651,7 @@ async function truncateAndSaveToFile(content, callId, projectTempDir, threshold,
   const safeFileName = `${path19.basename(callId)}.output`;
   const outputFile = path19.join(projectTempDir, safeFileName);
   try {
-    await fs22.writeFile(outputFile, fileContent);
+    await fs23.writeFile(outputFile, fileContent);
     return {
       content: `Tool output was too large and has been truncated.
 The full output has been saved to: ${outputFile}
@@ -199386,7 +199430,7 @@ var init_thoughtUtils = __esm({
 
 // packages/core/src/services/chatRecordingService.ts
 import path20 from "node:path";
-import fs23 from "node:fs";
+import fs24 from "node:fs";
 import { randomUUID as randomUUID4 } from "node:crypto";
 var ChatRecordingService;
 var init_chatRecordingService = __esm({
@@ -199431,7 +199475,7 @@ var init_chatRecordingService = __esm({
               this.config.storage.getProjectTempDir(),
               "chats"
             );
-            fs23.mkdirSync(chatsDir, { recursive: true });
+            fs24.mkdirSync(chatsDir, { recursive: true });
             const timestamp = (/* @__PURE__ */ new Date()).toISOString().slice(0, 16).replace(/:/g, "-");
             const filename = `session-${timestamp}-${this.sessionId.slice(
               0,
@@ -199607,7 +199651,7 @@ var init_chatRecordingService = __esm({
        */
       readConversation() {
         try {
-          this.cachedLastConvData = fs23.readFileSync(this.conversationFile, "utf8");
+          this.cachedLastConvData = fs24.readFileSync(this.conversationFile, "utf8");
           return JSON.parse(this.cachedLastConvData);
         } catch (error) {
           if (error.code !== "ENOENT") {
@@ -199634,7 +199678,7 @@ var init_chatRecordingService = __esm({
             conversation.lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
             const newContent = JSON.stringify(conversation, null, 2);
             this.cachedLastConvData = newContent;
-            fs23.writeFileSync(this.conversationFile, newContent);
+            fs24.writeFileSync(this.conversationFile, newContent);
           }
         } catch (error) {
           console.error("Error writing conversation file:", error);
@@ -199660,7 +199704,7 @@ var init_chatRecordingService = __esm({
             "chats"
           );
           const sessionPath = path20.join(chatsDir, `${sessionId2}.json`);
-          fs23.unlinkSync(sessionPath);
+          fs24.unlinkSync(sessionPath);
         } catch (error) {
           console.error("Error deleting session:", error);
           throw error;
@@ -200532,7 +200576,7 @@ var init_constants3 = __esm({
 });
 
 // packages/core/src/utils/getFolderStructure.ts
-import * as fs24 from "node:fs/promises";
+import * as fs25 from "node:fs/promises";
 import * as path21 from "node:path";
 async function readFullStructure(rootPath, options2) {
   const rootName = path21.basename(rootPath);
@@ -200560,7 +200604,7 @@ async function readFullStructure(rootPath, options2) {
     }
     let entries;
     try {
-      const rawEntries = await fs24.readdir(currentPath, { withFileTypes: true });
+      const rawEntries = await fs25.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")) {
@@ -208025,7 +208069,7 @@ var require_ignore = __commonJS({
 });
 
 // packages/core/src/utils/gitIgnoreParser.ts
-import * as fs25 from "node:fs";
+import * as fs26 from "node:fs";
 import * as path22 from "node:path";
 var import_ignore, GitIgnoreParser;
 var init_gitIgnoreParser = __esm({
@@ -208046,7 +208090,7 @@ var init_gitIgnoreParser = __esm({
       loadPatternsForFile(patternsFilePath) {
         let content;
         try {
-          content = fs25.readFileSync(patternsFilePath, "utf-8");
+          content = fs26.readFileSync(patternsFilePath, "utf-8");
         } catch (_error) {
           return [];
         }
@@ -208113,7 +208157,7 @@ var init_gitIgnoreParser = __esm({
               "info",
               "exclude"
             );
-            this.globalPatterns = fs25.existsSync(excludeFile) ? this.loadPatternsForFile(excludeFile) : [];
+            this.globalPatterns = fs26.existsSync(excludeFile) ? this.loadPatternsForFile(excludeFile) : [];
           }
           ig.add(this.globalPatterns);
           const pathParts = relativePath.split(path22.sep);
@@ -208138,7 +208182,7 @@ var init_gitIgnoreParser = __esm({
               }
             } else {
               const gitignorePath = path22.join(dir, ".gitignore");
-              if (fs25.existsSync(gitignorePath)) {
+              if (fs26.existsSync(gitignorePath)) {
                 const patterns = this.loadPatternsForFile(gitignorePath);
                 this.cache.set(dir, patterns);
                 ig.add(patterns);
@@ -208157,7 +208201,7 @@ var init_gitIgnoreParser = __esm({
 });
 
 // packages/core/src/utils/qwenIgnoreParser.ts
-import * as fs26 from "node:fs";
+import * as fs27 from "node:fs";
 import * as path23 from "node:path";
 var import_ignore2, QwenIgnoreParser;
 var init_qwenIgnoreParser = __esm({
@@ -208180,7 +208224,7 @@ var init_qwenIgnoreParser = __esm({
         const patternsFilePath = path23.join(this.projectRoot, ".rdmindignore");
         let content;
         try {
-          content = fs26.readFileSync(patternsFilePath, "utf-8");
+          content = fs27.readFileSync(patternsFilePath, "utf-8");
         } catch (_error) {
           return;
         }
@@ -215142,7 +215186,7 @@ var init_esm9 = __esm({
 });
 
 // packages/core/src/services/fileSystemService.ts
-import fs27 from "node:fs/promises";
+import fs28 from "node:fs/promises";
 import * as path26 from "node:path";
 var StandardFileSystemService;
 var init_fileSystemService = __esm({
@@ -215155,10 +215199,10 @@ var init_fileSystemService = __esm({
         __name(this, "StandardFileSystemService");
       }
       async readTextFile(filePath) {
-        return fs27.readFile(filePath, "utf-8");
+        return fs28.readFile(filePath, "utf-8");
       }
       async writeTextFile(filePath, content) {
-        await fs27.writeFile(filePath, content, "utf-8");
+        await fs28.writeFile(filePath, content, "utf-8");
       }
       findFiles(fileName, searchPaths) {
         return searchPaths.flatMap((searchPath) => {
@@ -219988,7 +220032,7 @@ var init_esm10 = __esm({
 });
 
 // packages/core/src/services/gitService.ts
-import * as fs28 from "node:fs/promises";
+import * as fs29 from "node:fs/promises";
 import * as path27 from "node:path";
 var GitService;
 var init_gitService = __esm({
@@ -220041,9 +220085,9 @@ var init_gitService = __esm({
       async setupShadowGitRepository() {
         const repoDir = this.getHistoryDir();
         const gitConfigPath = path27.join(repoDir, ".gitconfig");
-        await fs28.mkdir(repoDir, { recursive: true });
+        await fs29.mkdir(repoDir, { recursive: true });
         const gitConfigContent = "[user]\n  name = Qwen Code\n  email = qwen-code@qwen.ai\n[commit]\n  gpgsign = false\n";
-        await fs28.writeFile(gitConfigPath, gitConfigContent);
+        await fs29.writeFile(gitConfigPath, gitConfigContent);
         const repo = simpleGit(repoDir);
         const isRepoDefined = await repo.checkIsRepo(CheckRepoActions.IS_REPO_ROOT);
         if (!isRepoDefined) {
@@ -220056,13 +220100,13 @@ var init_gitService = __esm({
         const shadowGitIgnorePath = path27.join(repoDir, ".gitignore");
         let userGitIgnoreContent = "";
         try {
-          userGitIgnoreContent = await fs28.readFile(userGitIgnorePath, "utf-8");
+          userGitIgnoreContent = await fs29.readFile(userGitIgnorePath, "utf-8");
         } catch (error) {
           if (isNodeError(error) && error.code !== "ENOENT") {
             throw error;
           }
         }
-        await fs28.writeFile(shadowGitIgnorePath, userGitIgnoreContent);
+        await fs29.writeFile(shadowGitIgnorePath, userGitIgnoreContent);
       }
       get shadowGitRepository() {
         const repoDir = this.getHistoryDir();
@@ -220751,7 +220795,7 @@ var init_ignorePatterns = __esm({
 });
 
 // packages/core/src/utils/fileUtils.ts
-import fs29 from "node:fs";
+import fs30 from "node:fs";
 import fsPromises from "node:fs/promises";
 import path29 from "node:path";
 function detectBOM(buf) {
@@ -220799,7 +220843,7 @@ function decodeUTF32(buf, littleEndian) {
   return out;
 }
 async function readFileWithEncoding(filePath) {
-  const full = await fs29.promises.readFile(filePath);
+  const full = await fs30.promises.readFile(filePath);
   if (full.length === 0) return "";
   const bom = detectBOM(full);
   if (!bom) {
@@ -220834,7 +220878,7 @@ function isWithinRoot(pathToCheck, rootDirectory) {
 async function isBinaryFile(filePath) {
   let fh = null;
   try {
-    fh = await fs29.promises.open(filePath, "r");
+    fh = await fs30.promises.open(filePath, "r");
     const stats = await fh.stat();
     const fileSize = stats.size;
     if (fileSize === 0) return false;
@@ -220904,7 +220948,7 @@ async function detectFileType(filePath) {
 }
 async function processSingleFileContent(filePath, rootDirectory, fileSystemService, offset, limit2) {
   try {
-    if (!fs29.existsSync(filePath)) {
+    if (!fs30.existsSync(filePath)) {
       return {
         llmContent: "Could not read file because no file was found at the specified path.",
         returnDisplay: "File not found.",
@@ -220912,7 +220956,7 @@ async function processSingleFileContent(filePath, rootDirectory, fileSystemServi
         errorType: "file_not_found" /* FILE_NOT_FOUND */
       };
     }
-    const stats = await fs29.promises.stat(filePath);
+    const stats = await fs30.promises.stat(filePath);
     if (stats.isDirectory()) {
       return {
         llmContent: "Could not read file because the provided path is a directory, not a file.",
@@ -220994,7 +221038,7 @@ async function processSingleFileContent(filePath, rootDirectory, fileSystemServi
       case "pdf":
       case "audio":
       case "video": {
-        const contentBuffer = await fs29.promises.readFile(filePath);
+        const contentBuffer = await fs30.promises.readFile(filePath);
         const base64Data = contentBuffer.toString("base64");
         return {
           llmContent: {
@@ -221028,7 +221072,7 @@ async function processSingleFileContent(filePath, rootDirectory, fileSystemServi
 }
 async function fileExists(filePath) {
   try {
-    await fsPromises.access(filePath, fs29.constants.F_OK);
+    await fsPromises.access(filePath, fs30.constants.F_OK);
     return true;
   } catch (_) {
     return false;
@@ -231286,18 +231330,18 @@ var init_stdio2 = __esm({
 });
 
 // packages/core/src/ide/ide-client.ts
-import * as fs30 from "node:fs";
+import * as fs31 from "node:fs";
 import * as os18 from "node:os";
 import * as path33 from "node:path";
 function getRealPath(path110) {
   try {
-    return fs30.realpathSync(path110);
+    return fs31.realpathSync(path110);
   } catch (_e) {
     return path110;
   }
 }
 function getIdeServerHost() {
-  const isInContainer = fs30.existsSync("/.dockerenv") || fs30.existsSync("/run/.containerenv");
+  const isInContainer = fs31.existsSync("/.dockerenv") || fs31.existsSync("/run/.containerenv");
   return isInContainer ? "host.docker.internal" : "127.0.0.1";
 }
 var import_undici, logger, IdeClient;
@@ -231739,14 +231783,14 @@ var init_ide_client = __esm({
             os18.tmpdir(),
             `qwen-code-ide-server-${this.ideProcessInfo.pid}.json`
           );
-          const portFileContents = await fs30.promises.readFile(portFile, "utf8");
+          const portFileContents = await fs31.promises.readFile(portFile, "utf8");
           return JSON.parse(portFileContents);
         } catch (_) {
         }
         const portFileDir = path33.join(os18.tmpdir(), "gemini", "ide");
         let portFiles;
         try {
-          portFiles = await fs30.promises.readdir(portFileDir);
+          portFiles = await fs31.promises.readdir(portFileDir);
         } catch (e2) {
           logger.debug("Failed to read IDE connection directory:", e2);
           return void 0;
@@ -231765,7 +231809,7 @@ var init_ide_client = __esm({
         try {
           fileContents = await Promise.all(
             matchingFiles.map(
-              (file) => fs30.promises.readFile(path33.join(portFileDir, file), "utf8")
+              (file) => fs31.promises.readFile(path33.join(portFileDir, file), "utf8")
             )
           );
         } catch (e2) {
@@ -231977,7 +232021,7 @@ ${errorMessage}`,
 });
 
 // packages/core/src/tools/edit.ts
-import * as fs31 from "node:fs";
+import * as fs32 from "node:fs";
 import * as path34 from "node:path";
 function applyReplacement(currentContent, oldString, newString, isNewFile) {
   if (isNewFile) {
@@ -232307,8 +232351,8 @@ var init_edit = __esm({
        */
       ensureParentDirectoriesExist(filePath) {
         const dirName = path34.dirname(filePath);
-        if (!fs31.existsSync(dirName)) {
-          fs31.mkdirSync(dirName, { recursive: true });
+        if (!fs32.existsSync(dirName)) {
+          fs32.mkdirSync(dirName, { recursive: true });
         }
       }
     };
@@ -232562,7 +232606,7 @@ Eg.
 });
 
 // packages/core/src/tools/glob.ts
-import fs32 from "node:fs";
+import fs33 from "node:fs";
 import path35 from "node:path";
 function sortFileEntries(entries, nowTimestamp, recencyThresholdMs) {
   const sortedEntries = [...entries];
@@ -232583,7 +232627,7 @@ function sortFileEntries(entries, nowTimestamp, recencyThresholdMs) {
   });
   return sortedEntries;
 }
-var GlobToolInvocation, GlobTool;
+var MAX_FILE_COUNT, GlobToolInvocation, GlobTool;
 var init_glob2 = __esm({
   "packages/core/src/tools/glob.ts"() {
     "use strict";
@@ -232595,80 +232639,55 @@ var init_glob2 = __esm({
     init_config3();
     init_constants3();
     init_tool_error();
+    init_errors();
+    MAX_FILE_COUNT = 100;
     __name(sortFileEntries, "sortFileEntries");
     GlobToolInvocation = class extends BaseToolInvocation {
       constructor(config, params) {
         super(params);
         this.config = config;
+        this.fileService = config.getFileService();
       }
       static {
         __name(this, "GlobToolInvocation");
       }
+      fileService;
       getDescription() {
         let description = `'${this.params.pattern}'`;
         if (this.params.path) {
-          const searchDir = path35.resolve(
-            this.config.getTargetDir(),
-            this.params.path || "."
-          );
-          const relativePath = makeRelative(searchDir, this.config.getTargetDir());
-          description += ` within ${shortenPath(relativePath)}`;
+          description += ` in path '${this.params.path}'`;
         }
         return description;
       }
       async execute(signal) {
         try {
-          const workspaceContext = this.config.getWorkspaceContext();
-          const workspaceDirectories = workspaceContext.getDirectories();
-          let searchDirectories;
-          if (this.params.path) {
-            const searchDirAbsolute = path35.resolve(
-              this.config.getTargetDir(),
-              this.params.path
-            );
-            if (!workspaceContext.isPathWithinWorkspace(searchDirAbsolute)) {
-              const rawError = `Error: Path "${this.params.path}" is not within any workspace directory`;
-              return {
-                llmContent: rawError,
-                returnDisplay: `Path is not within workspace`,
-                error: {
-                  message: rawError,
-                  type: "path_not_in_workspace" /* PATH_NOT_IN_WORKSPACE */
-                }
-              };
-            }
-            searchDirectories = [searchDirAbsolute];
-          } else {
-            searchDirectories = workspaceDirectories;
-          }
-          const fileDiscovery = this.config.getFileService();
-          const allEntries = [];
-          for (const searchDir of searchDirectories) {
-            let pattern = this.params.pattern;
-            const fullPath = path35.join(searchDir, pattern);
-            if (fs32.existsSync(fullPath)) {
-              pattern = escape3(pattern);
-            }
-            const entries = await glob(pattern, {
-              cwd: searchDir,
-              withFileTypes: true,
-              nodir: true,
-              stat: true,
-              nocase: !this.params.case_sensitive,
-              dot: true,
-              ignore: this.config.getFileExclusions().getGlobExcludes(),
-              follow: false,
-              signal
-            });
-            allEntries.push(...entries);
-          }
+          const searchDirAbs = resolveAndValidatePath(
+            this.config,
+            this.params.path
+          );
+          const searchLocationDescription = this.params.path ? `within ${searchDirAbs}` : `in the workspace directory`;
+          let pattern = this.params.pattern;
+          const fullPath = path35.join(searchDirAbs, pattern);
+          if (fs33.existsSync(fullPath)) {
+            pattern = escape3(pattern);
+          }
+          const allEntries = await glob(pattern, {
+            cwd: searchDirAbs,
+            withFileTypes: true,
+            nodir: true,
+            stat: true,
+            nocase: true,
+            dot: true,
+            follow: false,
+            signal
+          });
           const relativePaths = allEntries.map(
             (p) => path35.relative(this.config.getTargetDir(), p.fullpath())
           );
-          const { filteredPaths, gitIgnoredCount, qwenIgnoredCount } = fileDiscovery.filterFilesWithReport(relativePaths, {
-            respectGitIgnore: this.params?.respect_git_ignore ?? this.config.getFileFilteringOptions().respectGitIgnore ?? DEFAULT_FILE_FILTERING_OPTIONS.respectGitIgnore,
-            respectQwenIgnore: this.params?.respect_qwen_ignore ?? this.config.getFileFilteringOptions().respectQwenIgnore ?? DEFAULT_FILE_FILTERING_OPTIONS.respectQwenIgnore
-          });
+          const { filteredPaths } = this.fileService.filterFilesWithReport(
+            relativePaths,
+            this.getFileFilteringOptions()
+          );
           const filteredAbsolutePaths = new Set(
             filteredPaths.map((p) => path35.resolve(this.config.getTargetDir(), p))
           );
@@ -232676,20 +232695,8 @@ var init_glob2 = __esm({
             (entry) => filteredAbsolutePaths.has(entry.fullpath())
           );
           if (!filteredEntries || filteredEntries.length === 0) {
-            let message = `No files found matching pattern "${this.params.pattern}"`;
-            if (searchDirectories.length === 1) {
-              message += ` within ${searchDirectories[0]}`;
-            } else {
-              message += ` within ${searchDirectories.length} workspace directories`;
-            }
-            if (gitIgnoredCount > 0) {
-              message += ` (${gitIgnoredCount} files were git-ignored)`;
-            }
-            if (qwenIgnoredCount > 0) {
-              message += ` (${qwenIgnoredCount} files were rdmind-ignored)`;
-            }
             return {
-              llmContent: message,
+              llmContent: `No files found matching pattern "${this.params.pattern}" ${searchLocationDescription}`,
               returnDisplay: `No files found`
             };
           }
@@ -232700,28 +232707,27 @@ var init_glob2 = __esm({
             nowTimestamp,
             oneDayInMs
           );
-          const sortedAbsolutePaths = sortedEntries.map(
+          const totalFileCount = sortedEntries.length;
+          const truncated = totalFileCount > MAX_FILE_COUNT;
+          const entriesToShow = truncated ? sortedEntries.slice(0, MAX_FILE_COUNT) : sortedEntries;
+          const sortedAbsolutePaths = entriesToShow.map(
             (entry) => entry.fullpath()
           );
           const fileListDescription = sortedAbsolutePaths.join("\n");
-          const fileCount = sortedAbsolutePaths.length;
-          let resultMessage = `Found ${fileCount} file(s) matching "${this.params.pattern}"`;
-          if (searchDirectories.length === 1) {
-            resultMessage += ` within ${searchDirectories[0]}`;
-          } else {
-            resultMessage += ` across ${searchDirectories.length} workspace directories`;
-          }
-          if (gitIgnoredCount > 0) {
-            resultMessage += ` (${gitIgnoredCount} additional files were git-ignored)`;
-          }
-          if (qwenIgnoredCount > 0) {
-            resultMessage += ` (${qwenIgnoredCount} additional files were rdmind-ignored)`;
-          }
+          let resultMessage = `Found ${totalFileCount} file(s) matching "${this.params.pattern}" ${searchLocationDescription}`;
           resultMessage += `, sorted by modification time (newest first):
+---
 ${fileListDescription}`;
+          if (truncated) {
+            const omittedFiles = totalFileCount - MAX_FILE_COUNT;
+            const fileTerm = omittedFiles === 1 ? "file" : "files";
+            resultMessage += `
+---
+[${omittedFiles} ${fileTerm} truncated] ...`;
+          }
           return {
             llmContent: resultMessage,
-            returnDisplay: `Found ${fileCount} matching file(s)`
+            returnDisplay: `Found ${totalFileCount} matching file(s)${truncated ? " (truncated)" : ""}`
           };
         } catch (error) {
           const errorMessage = error instanceof Error ? error.message : String(error);
@@ -232729,7 +232735,7 @@ ${fileListDescription}`;
           const rawError = `Error during glob search operation: ${errorMessage}`;
           return {
             llmContent: rawError,
-            returnDisplay: `Error: An unexpected error occurred.`,
+            returnDisplay: `Error: ${errorMessage || "An unexpected error occurred."}`,
             error: {
               message: rawError,
               type: "glob_execution_error" /* GLOB_EXECUTION_ERROR */
@@ -232737,35 +232743,30 @@ ${fileListDescription}`;
           };
         }
       }
+      getFileFilteringOptions() {
+        const options2 = this.config.getFileFilteringOptions?.();
+        return {
+          respectGitIgnore: options2?.respectGitIgnore ?? DEFAULT_FILE_FILTERING_OPTIONS.respectGitIgnore,
+          respectQwenIgnore: options2?.respectQwenIgnore ?? DEFAULT_FILE_FILTERING_OPTIONS.respectQwenIgnore
+        };
+      }
     };
     GlobTool = class _GlobTool extends BaseDeclarativeTool {
       constructor(config) {
         super(
           _GlobTool.Name,
           "FindFiles",
-          "Efficiently finds files matching specific glob patterns (e.g., `src/**/*.ts`, `**/*.md`), returning absolute paths sorted by modification time (newest first). Ideal for quickly locating files based on their name or path structure, especially in large codebases.",
+          'Fast file pattern matching tool that works with any codebase size\n- Supports glob patterns like "**/*.js" or "src/**/*.ts"\n- Returns matching file paths sorted by modification time\n- Use this tool when you need to find files by name patterns\n- When you are doing an open ended search that may require multiple rounds of globbing and grepping, use the Agent tool instead\n- You have the capability to call multiple tools in a single response. It is always better to speculatively perform multiple searches as a batch that are potentially useful.',
           "search" /* Search */,
           {
             properties: {
               pattern: {
-                description: "The glob pattern to match against (e.g., '**/*.py', 'docs/*.md').",
+                description: "The glob pattern to match files against",
                 type: "string"
               },
               path: {
-                description: "Optional: The absolute path to the directory to search within. If omitted, searches the root directory.",
+                description: 'The directory to search in. If not specified, the current working directory will be used. IMPORTANT: Omit this field to use the default directory. DO NOT enter "undefined" or "null" - simply omit it for the default behavior. Must be a valid directory path if provided.',
                 type: "string"
-              },
-              case_sensitive: {
-                description: "Optional: Whether the search should be case-sensitive. Defaults to false.",
-                type: "boolean"
-              },
-              respect_git_ignore: {
-                description: "Optional: Whether to respect .gitignore patterns when finding files. Only available in git repositories. Defaults to true.",
-                type: "boolean"
-              },
-              respect_qwen_ignore: {
-                description: "Optional: Whether to respect .rdmindignore patterns when finding files. Defaults to true.",
-                type: "boolean"
               }
             },
             required: ["pattern"],
@@ -232782,29 +232783,16 @@ ${fileListDescription}`;
        * Validates the parameters for the tool.
        */
       validateToolParamValues(params) {
-        const searchDirAbsolute = path35.resolve(
-          this.config.getTargetDir(),
-          params.path || "."
-        );
-        const workspaceContext = this.config.getWorkspaceContext();
-        if (!workspaceContext.isPathWithinWorkspace(searchDirAbsolute)) {
-          const directories = workspaceContext.getDirectories();
-          return `Search path ("${searchDirAbsolute}") resolves outside the allowed workspace directories: ${directories.join(", ")}`;
-        }
-        const targetDir = searchDirAbsolute || this.config.getTargetDir();
-        try {
-          if (!fs32.existsSync(targetDir)) {
-            return `Search path does not exist ${targetDir}`;
-          }
-          if (!fs32.statSync(targetDir).isDirectory()) {
-            return `Search path is not a directory: ${targetDir}`;
-          }
-        } catch (e2) {
-          return `Error accessing search path: ${e2}`;
-        }
         if (!params.pattern || typeof params.pattern !== "string" || params.pattern.trim() === "") {
           return "The 'pattern' parameter cannot be empty.";
         }
+        if (params.path) {
+          try {
+            resolveAndValidatePath(this.config, params.path);
+          } catch (error) {
+            return getErrorMessage(error);
+          }
+        }
         return null;
       }
       createInvocation(params) {
@@ -232815,12 +232803,11 @@ ${fileListDescription}`;
 });
 
 // packages/core/src/tools/grep.ts
-import fs33 from "node:fs";
 import fsPromises2 from "node:fs/promises";
 import path36 from "node:path";
 import { EOL as EOL2 } from "node:os";
 import { spawn as spawn5 } from "node:child_process";
-var GrepToolInvocation, GrepTool;
+var MAX_LLM_CONTENT_LENGTH, GrepToolInvocation, GrepTool;
 var init_grep2 = __esm({
   "packages/core/src/tools/grep.ts"() {
     "use strict";
@@ -232832,6 +232819,7 @@ var init_grep2 = __esm({
     init_errors();
     init_gitUtils();
     init_tool_error();
+    MAX_LLM_CONTENT_LENGTH = 2e4;
     GrepToolInvocation = class extends BaseToolInvocation {
       constructor(config, params) {
         super(params);
@@ -232842,93 +232830,37 @@ var init_grep2 = __esm({
         __name(this, "GrepToolInvocation");
       }
       fileExclusions;
-      /**
-       * 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).
-       * @throws {Error} If path is outside root, doesn't exist, or isn't a directory.
-       */
-      resolveAndValidatePath(relativePath) {
-        if (!relativePath) {
-          return null;
-        }
-        const targetPath = path36.resolve(this.config.getTargetDir(), relativePath);
-        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(", ")}`
-          );
-        }
-        try {
-          const stats = fs33.statSync(targetPath);
-          if (!stats.isDirectory()) {
-            throw new Error(`Path is not a directory: ${targetPath}`);
-          }
-        } catch (error) {
-          if (isNodeError(error) && error.code !== "ENOENT") {
-            throw new Error(`Path does not exist: ${targetPath}`);
-          }
-          throw new Error(
-            `Failed to access path stats for ${targetPath}: ${error}`
-          );
-        }
-        return targetPath;
-      }
       async execute(signal) {
         try {
-          const workspaceContext = this.config.getWorkspaceContext();
-          const searchDirAbs = this.resolveAndValidatePath(this.params.path);
+          const searchDirAbs = resolveAndValidatePath(
+            this.config,
+            this.params.path
+          );
           const searchDirDisplay = this.params.path || ".";
-          let searchDirectories;
-          if (searchDirAbs === null) {
-            searchDirectories = workspaceContext.getDirectories();
-          } else {
-            searchDirectories = [searchDirAbs];
-          }
-          let allMatches = [];
-          const maxResults = this.params.maxResults ?? 20;
-          let totalMatchesFound = 0;
-          let searchTruncated = false;
-          for (const searchDir of searchDirectories) {
-            const matches = await this.performGrepSearch({
-              pattern: this.params.pattern,
-              path: searchDir,
-              include: this.params.include,
-              signal
-            });
-            totalMatchesFound += matches.length;
-            if (searchDirectories.length > 1) {
-              const dirName = path36.basename(searchDir);
-              matches.forEach((match2) => {
-                match2.filePath = path36.join(dirName, match2.filePath);
-              });
-            }
-            const remainingSlots = maxResults - allMatches.length;
-            if (remainingSlots <= 0) {
-              searchTruncated = true;
-              break;
-            }
-            if (matches.length > remainingSlots) {
-              allMatches = allMatches.concat(matches.slice(0, remainingSlots));
-              searchTruncated = true;
-              break;
-            } else {
-              allMatches = allMatches.concat(matches);
-            }
-          }
-          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 rawMatches = await this.performGrepSearch({
+            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 (rawMatches.length === 0) {
+            const noMatchMsg = `No matches found for pattern "${this.params.pattern}" ${searchLocationDescription}${filterDescription}.`;
             return { llmContent: noMatchMsg, returnDisplay: `No matches found` };
           }
-          const matchesByFile = allMatches.reduce(
+          let truncatedByLineLimit = false;
+          let matchesToInclude = rawMatches;
+          if (this.params.limit !== void 0 && rawMatches.length > this.params.limit) {
+            matchesToInclude = rawMatches.slice(0, this.params.limit);
+            truncatedByLineLimit = true;
+          }
+          const totalMatches = rawMatches.length;
+          const matchTerm = totalMatches === 1 ? "match" : "matches";
+          const header = `Found ${totalMatches} ${matchTerm} for pattern "${this.params.pattern}" ${searchLocationDescription}${filterDescription}:
+---
+`;
+          const matchesByFile = matchesToInclude.reduce(
             (acc, match2) => {
               const fileKey = match2.filePath;
               if (!acc[fileKey]) {
@@ -232940,40 +232872,38 @@ var init_grep2 = __esm({
             },
             {}
           );
-          const matchCount = allMatches.length;
-          const matchTerm = matchCount === 1 ? "match" : "matches";
-          let headerText = `Found ${matchCount} ${matchTerm} for pattern "${this.params.pattern}" ${searchLocationDescription}${this.params.include ? ` (filter: "${this.params.include}")` : ""}`;
-          if (searchTruncated) {
-            headerText += ` (showing first ${matchCount} of ${totalMatchesFound}+ total matches)`;
-          }
-          let llmContent = `${headerText}:
----
-`;
+          let grepOutput = "";
           for (const filePath in matchesByFile) {
-            llmContent += `File: ${filePath}
+            grepOutput += `File: ${filePath}
 `;
             matchesByFile[filePath].forEach((match2) => {
               const trimmedLine = match2.line.trim();
-              llmContent += `L${match2.lineNumber}: ${trimmedLine}
+              grepOutput += `L${match2.lineNumber}: ${trimmedLine}
 `;
             });
-            llmContent += "---\n";
+            grepOutput += "---\n";
           }
-          if (searchTruncated) {
-            llmContent += `
-WARNING: Results truncated to prevent context overflow. To see more results:
-- Use a more specific pattern to reduce matches
-- Add file filters with the 'include' parameter (e.g., "*.js", "src/**")
-- Specify a narrower 'path' to search in a subdirectory
-- Increase 'maxResults' parameter if you need more matches (current: ${maxResults})`;
+          let truncatedByCharLimit = false;
+          if (grepOutput.length > MAX_LLM_CONTENT_LENGTH) {
+            grepOutput = grepOutput.slice(0, MAX_LLM_CONTENT_LENGTH) + "...";
+            truncatedByCharLimit = true;
+          }
+          const finalLines = grepOutput.split("\n").filter(
+            (line) => line.trim() && !line.startsWith("File:") && !line.startsWith("---")
+          );
+          const includedLines = finalLines.length;
+          let llmContent = header + grepOutput;
+          if (truncatedByLineLimit || truncatedByCharLimit) {
+            const omittedMatches = totalMatches - includedLines;
+            llmContent += ` [${omittedMatches} ${omittedMatches === 1 ? "line" : "lines"} truncated] ...`;
           }
-          let displayText = `Found ${matchCount} ${matchTerm}`;
-          if (searchTruncated) {
-            displayText += ` (truncated from ${totalMatchesFound}+)`;
+          let displayMessage = `Found ${totalMatches} ${matchTerm}`;
+          if (truncatedByLineLimit || truncatedByCharLimit) {
+            displayMessage += ` (truncated)`;
           }
           return {
             llmContent: llmContent.trim(),
-            returnDisplay: displayText
+            returnDisplay: displayMessage
           };
         } catch (error) {
           console.error(`Error during GrepLogic execution: ${error}`);
@@ -233051,40 +232981,19 @@ WARNING: Results truncated to prevent context overflow. To see more results:
        * @returns A string describing the grep
        */
       getDescription() {
-        let description = `'${this.params.pattern}'`;
-        if (this.params.include) {
-          description += ` in ${this.params.include}`;
-        }
-        if (this.params.path) {
-          const resolvedPath = path36.resolve(
-            this.config.getTargetDir(),
-            this.params.path
-          );
-          if (resolvedPath === this.config.getTargetDir() || this.params.path === ".") {
-            description += ` within ./`;
-          } else {
-            const relativePath = makeRelative(
-              resolvedPath,
-              this.config.getTargetDir()
-            );
-            description += ` within ${shortenPath(relativePath)}`;
-          }
-        } else {
-          const workspaceContext = this.config.getWorkspaceContext();
-          const directories = workspaceContext.getDirectories();
-          if (directories.length > 1) {
-            description += ` across all workspace directories`;
-          }
+        let description = `'${this.params.pattern}' in path '${this.params.path || "./"}'`;
+        if (this.params.glob) {
+          description += ` (filter: '${this.params.glob}')`;
         }
         return description;
       }
       /**
        * Performs the actual search using the prioritized strategies.
-       * @param options Search options including pattern, absolute path, and include glob.
+       * @param options Search options including pattern, absolute path, and glob filter.
        * @returns A promise resolving to an array of match objects.
        */
       async performGrepSearch(options2) {
-        const { pattern, path: absolutePath, include } = options2;
+        const { pattern, path: absolutePath, glob: glob2 } = options2;
         let strategyUsed = "none";
         try {
           const isGit = isGitRepository(absolutePath);
@@ -233099,8 +233008,8 @@ WARNING: Results truncated to prevent context overflow. To see more results:
               "--ignore-case",
               pattern
             ];
-            if (include) {
-              gitArgs.push("--", include);
+            if (glob2) {
+              gitArgs.push("--", glob2);
             }
             try {
               const output = await new Promise((resolve26, reject) => {
@@ -233158,8 +233067,8 @@ WARNING: Results truncated to prevent context overflow. To see more results:
               return null;
             }).filter((dir) => !!dir);
             commonExcludes.forEach((dir) => grepArgs.push(`--exclude-dir=${dir}`));
-            if (include) {
-              grepArgs.push(`--include=${include}`);
+            if (glob2) {
+              grepArgs.push(`--include=${glob2}`);
             }
             grepArgs.push(pattern);
             grepArgs.push(".");
@@ -233226,7 +233135,7 @@ WARNING: Results truncated to prevent context overflow. To see more results:
             "GrepLogic: Falling back to JavaScript grep implementation."
           );
           strategyUsed = "javascript fallback";
-          const globPattern = include ? include : "**/*";
+          const globPattern = glob2 ? glob2 : "**/*";
           const ignorePatterns = this.fileExclusions.getGlobExcludes();
           const filesIterator = globStream(globPattern, {
             cwd: absolutePath,
@@ -233277,28 +233186,26 @@ WARNING: Results truncated to prevent context overflow. To see more results:
       constructor(config) {
         super(
           _GrepTool.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.",
+          "Grep",
+          'A powerful search tool for finding patterns in files\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  - Case-insensitive by default\n  - Use Task tool for open-ended searches requiring multiple rounds\n',
           "search" /* 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"
               },
-              path: {
-                description: "Optional: The absolute path to the directory to search within. If omitted, searches the current working directory.",
-                type: "string"
+              glob: {
+                type: "string",
+                description: 'Glob pattern to filter files (e.g. "*.js", "*.{ts,tsx}")'
               },
-              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"
+              path: {
+                type: "string",
+                description: "File or directory to search in. Defaults to current working directory."
               },
-              maxResults: {
-                description: "Optional: Maximum number of matches to return to prevent context overflow (default: 20, max: 100). Use lower values for broad searches, higher for specific searches.",
+              limit: {
                 type: "number",
-                minimum: 1,
-                maximum: 100
+                description: "Limit output to first N matching lines. Optional - shows all matches if not specified."
               }
             },
             required: ["pattern"],
@@ -233311,39 +233218,6 @@ WARNING: Results truncated to prevent context overflow. To see more results:
         __name(this, "GrepTool");
       }
       static Name = ToolNames.GREP;
-      /**
-       * 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).
-       * @throws {Error} If path is outside root, doesn't exist, or isn't a directory.
-       */
-      resolveAndValidatePath(relativePath) {
-        if (!relativePath) {
-          return null;
-        }
-        const targetPath = path36.resolve(this.config.getTargetDir(), relativePath);
-        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(", ")}`
-          );
-        }
-        try {
-          const stats = fs33.statSync(targetPath);
-          if (!stats.isDirectory()) {
-            throw new Error(`Path is not a directory: ${targetPath}`);
-          }
-        } catch (error) {
-          if (isNodeError(error) && error.code !== "ENOENT") {
-            throw new Error(`Path does not exist: ${targetPath}`);
-          }
-          throw new Error(
-            `Failed to access path stats for ${targetPath}: ${error}`
-          );
-        }
-        return targetPath;
-      }
       /**
        * Validates the parameters for the tool
        * @param params Parameters to validate
@@ -233353,16 +233227,11 @@ WARNING: Results truncated to prevent context overflow. To see more results:
         try {
           new RegExp(params.pattern);
         } catch (error) {
-          return `Invalid regular expression pattern provided: ${params.pattern}. Error: ${getErrorMessage(error)}`;
-        }
-        if (params.maxResults !== void 0) {
-          if (!Number.isInteger(params.maxResults) || params.maxResults < 1 || params.maxResults > 100) {
-            return `maxResults must be an integer between 1 and 100, got: ${params.maxResults}`;
-          }
+          return `Invalid regular expression pattern: ${params.pattern}. Error: ${getErrorMessage(error)}`;
         }
         if (params.path) {
           try {
-            this.resolveAndValidatePath(params.path);
+            resolveAndValidatePath(this.config, params.path);
           } catch (error) {
             return getErrorMessage(error);
           }
@@ -234114,7 +233983,7 @@ 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 MAX_LLM_CONTENT_LENGTH, GrepToolInvocation2, RipGrepTool;
+var MAX_LLM_CONTENT_LENGTH2, GrepToolInvocation2, RipGrepTool;
 var init_ripGrep = __esm({
   "packages/core/src/tools/ripGrep.ts"() {
     "use strict";
@@ -234126,7 +233995,7 @@ var init_ripGrep = __esm({
     init_ripgrepUtils();
     init_schemaValidator();
     init_constants3();
-    MAX_LLM_CONTENT_LENGTH = 2e4;
+    MAX_LLM_CONTENT_LENGTH2 = 2e4;
     GrepToolInvocation2 = class extends BaseToolInvocation {
       constructor(config, params) {
         super(params);
@@ -234135,43 +234004,13 @@ var init_ripGrep = __esm({
       static {
         __name(this, "GrepToolInvocation");
       }
-      /**
-       * 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 to search within.
-       * @throws {Error} If path is outside root, doesn't exist, or isn't a directory.
-       */
-      resolveAndValidatePath(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()) {
-            throw new Error(`Path is not a directory: ${targetPath}`);
-          }
-        } catch (error) {
-          if (isNodeError(error) && error.code !== "ENOENT") {
-            throw new Error(`Path does not exist: ${targetPath}`);
-          }
-          throw new Error(
-            `Failed to access path stats for ${targetPath}: ${error}`
-          );
-        }
-        return targetPath;
-      }
       async execute(signal) {
         try {
-          const searchDirAbs = this.resolveAndValidatePath(this.params.path);
+          const searchDirAbs = resolveAndValidatePath(
+            this.config,
+            this.params.path,
+            { allowFiles: true }
+          );
           const searchDirDisplay = this.params.path || ".";
           const rawOutput = await this.performRipgrepSearch({
             pattern: this.params.pattern,
@@ -234191,26 +234030,39 @@ var init_ripGrep = __esm({
           const header = `Found ${totalMatches} ${matchTerm} for pattern "${this.params.pattern}" ${searchLocationDescription}${filterDescription}:
 ---
 `;
-          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);
+          const parts = [];
+          let includedLines = 0;
           let truncatedByCharLimit = false;
-          if (grepOutput.length > maxGrepOutputLength) {
-            grepOutput = grepOutput.slice(0, maxGrepOutputLength) + "...";
-            truncatedByCharLimit = true;
+          let currentLength = 0;
+          for (const line of linesToInclude) {
+            const sep7 = includedLines > 0 ? 1 : 0;
+            includedLines++;
+            if (currentLength + line.length <= MAX_LLM_CONTENT_LENGTH2) {
+              parts.push(line);
+              currentLength = currentLength + line.length + sep7;
+            } else {
+              const remaining = Math.max(
+                MAX_LLM_CONTENT_LENGTH2 - currentLength - sep7,
+                10
+              );
+              parts.push(line.slice(0, remaining) + "...");
+              truncatedByCharLimit = true;
+              break;
+            }
           }
-          const finalLines = grepOutput.split(EOL3).filter((line) => line.trim());
-          const includedLines = finalLines.length;
+          const grepOutput = parts.join("\n");
           let llmContent = header + grepOutput;
           if (truncatedByLineLimit || truncatedByCharLimit) {
             const omittedMatches = totalMatches - includedLines;
-            llmContent += ` [${omittedMatches} ${omittedMatches === 1 ? "line" : "lines"} truncated] ...`;
+            llmContent += `
+---
+[${omittedMatches} ${omittedMatches === 1 ? "line" : "lines"} truncated] ...`;
           }
           let displayMessage = `Found ${totalMatches} ${matchTerm}`;
           if (truncatedByLineLimit || truncatedByCharLimit) {
@@ -234311,29 +234163,11 @@ var init_ripGrep = __esm({
        */
       getDescription() {
         let description = `'${this.params.pattern}'`;
-        if (this.params.glob) {
-          description += ` in ${this.params.glob}`;
-        }
         if (this.params.path) {
-          const resolvedPath = path40.resolve(
-            this.config.getTargetDir(),
-            this.params.path
-          );
-          if (resolvedPath === this.config.getTargetDir() || this.params.path === ".") {
-            description += ` within ./`;
-          } else {
-            const relativePath = makeRelative(
-              resolvedPath,
-              this.config.getTargetDir()
-            );
-            description += ` within ${shortenPath(relativePath)}`;
-          }
-        } else {
-          const workspaceContext = this.config.getWorkspaceContext();
-          const directories = workspaceContext.getDirectories();
-          if (directories.length > 1) {
-            description += ` across all workspace directories`;
-          }
+          description += ` in path '${this.params.path}'`;
+        }
+        if (this.params.glob) {
+          description += ` (filter: '${this.params.glob}')`;
         }
         return description;
       }
@@ -234374,39 +234208,6 @@ var init_ripGrep = __esm({
         __name(this, "RipGrepTool");
       }
       static Name = ToolNames.GREP;
-      /**
-       * 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 to search within.
-       * @throws {Error} If path is outside root, doesn't exist, or isn't a directory.
-       */
-      resolveAndValidatePath(relativePath) {
-        if (!relativePath) {
-          return this.config.getTargetDir();
-        }
-        const targetPath = path40.resolve(this.config.getTargetDir(), relativePath);
-        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(", ")}`
-          );
-        }
-        try {
-          const stats = fs36.statSync(targetPath);
-          if (!stats.isDirectory()) {
-            throw new Error(`Path is not a directory: ${targetPath}`);
-          }
-        } catch (error) {
-          if (isNodeError(error) && error.code !== "ENOENT") {
-            throw new Error(`Path does not exist: ${targetPath}`);
-          }
-          throw new Error(
-            `Failed to access path stats for ${targetPath}: ${error}`
-          );
-        }
-        return targetPath;
-      }
       /**
        * Validates the parameters for the tool
        * @param params Parameters to validate
@@ -234427,7 +234228,7 @@ var init_ripGrep = __esm({
         }
         if (params.path) {
           try {
-            this.resolveAndValidatePath(params.path);
+            resolveAndValidatePath(this.config, params.path, { allowFiles: true });
           } catch (error) {
             return getErrorMessage(error);
           }
@@ -320370,7 +320171,7 @@ init_esbuild_shims();
 
 // packages/cli/src/generated/git-commit.ts
 init_esbuild_shims();
-var GIT_COMMIT_INFO2 = "db4821fe";
+var GIT_COMMIT_INFO2 = "b7098a68";
 
 // packages/cli/src/ui/components/AboutBox.tsx
 var import_jsx_runtime43 = __toESM(require_jsx_runtime(), 1);
@@ -342283,7 +342084,7 @@ import { homedir as homedir16 } from "node:os";
 init_esbuild_shims();
 import * as os26 from "node:os";
 import * as path77 from "node:path";
-function resolvePath(p) {
+function resolvePath2(p) {
   if (!p) {
     return "";
   }
@@ -342295,7 +342096,7 @@ function resolvePath(p) {
   }
   return path77.normalize(expandedPath);
 }
-__name(resolvePath, "resolvePath");
+__name(resolvePath2, "resolvePath");
 
 // packages/cli/src/utils/version.ts
 init_esbuild_shims();
@@ -342531,7 +342332,7 @@ __name(getPackageJson, "getPackageJson");
 // packages/cli/src/utils/version.ts
 async function getCliVersion() {
   const pkgJson = await getPackageJson();
-  return "0.0.22-alpha.0";
+  return "0.0.23-alpha.0";
 }
 __name(getCliVersion, "getCliVersion");
 
@@ -343333,7 +343134,7 @@ async function loadCliConfig(settings, extensions, extensionEnablementManager, s
     ...DEFAULT_MEMORY_FILE_FILTERING_OPTIONS,
     ...settings.context?.fileFiltering
   };
-  const includeDirectories = (settings.context?.includeDirectories || []).map(resolvePath).concat((argv.includeDirectories || []).map(resolvePath));
+  const includeDirectories = (settings.context?.includeDirectories || []).map(resolvePath2).concat((argv.includeDirectories || []).map(resolvePath2));
   const { memoryContent, fileCount } = await loadHierarchicalGeminiMemory(
     cwd7,
     settings.context?.loadMemoryFromIncludeDirectories ? includeDirectories : [],