@ai-setting/roy-agent-core 1.5.29 → 1.5.31

package/dist/env/tool/built-in/index.js

@@ -8,7 +8,7 @@ import {
   grepTool,
   readFileTool,
   writeFileTool
-} from "../../../shared/@ai-setting/roy-agent-core-satmq6sh.js";
+} from "../../../shared/@ai-setting/roy-agent-core-p46v1kr2.js";
 import"../../../shared/@ai-setting/roy-agent-core-xs5rsgat.js";
 import"../../../shared/@ai-setting/roy-agent-core-psv4v63c.js";
 import"../../../shared/@ai-setting/roy-agent-core-fs0mn2jk.js";

package/dist/env/tool/index.js

@@ -2,7 +2,7 @@ import {
   ToolComponent,
   ToolRegistry,
   ToolValidator
-} from "../../shared/@ai-setting/roy-agent-core-qqceba6k.js";
+} from "../../shared/@ai-setting/roy-agent-core-q27e6dhw.js";
 import {
   bashTool,
   echoTool,
@@ -13,7 +13,7 @@ import {
   grepTool,
   readFileTool,
   writeFileTool
-} from "../../shared/@ai-setting/roy-agent-core-satmq6sh.js";
+} from "../../shared/@ai-setting/roy-agent-core-p46v1kr2.js";
 import"../../shared/@ai-setting/roy-agent-core-e25xkv53.js";
 import"../../shared/@ai-setting/roy-agent-core-qxhq8ven.js";
 import"../../shared/@ai-setting/roy-agent-core-kkbwepqb.js";

package/dist/index.js

@@ -9,7 +9,7 @@ import {
   ToolComponent,
   ToolRegistry,
   ToolValidator
-} from "./shared/@ai-setting/roy-agent-core-qqceba6k.js";
+} from "./shared/@ai-setting/roy-agent-core-q27e6dhw.js";
 import {
   bashTool,
   editFileTool,
@@ -19,7 +19,7 @@ import {
   grepTool,
   readFileTool,
   writeFileTool
-} from "./shared/@ai-setting/roy-agent-core-satmq6sh.js";
+} from "./shared/@ai-setting/roy-agent-core-p46v1kr2.js";
 import {
   PromptComponent,
   getBuiltInPrompt,

package/dist/shared/@ai-setting/{roy-agent-core-satmq6sh.js → roy-agent-core-p46v1kr2.js}

@@ -11,9 +11,100 @@ import {
 // src/env/tool/built-in/bash.ts
 init_propagation();
 import { z } from "zod";
-import { exec } from "child_process";
-import { promisify } from "util";
-var execAsync = promisify(exec);
+import { spawn } from "child_process";
+import path from "path";
+function getPlatform() {
+  return process.platform;
+}
+function isWindows() {
+  return getPlatform() === "win32";
+}
+function getShellCommand(command) {
+  if (isWindows()) {
+    return {
+      shell: "cmd.exe",
+      args: ["/c", command]
+    };
+  }
+  return {
+    shell: "/bin/sh",
+    args: ["-c", command]
+  };
+}
+function normalizeCwd(cwd) {
+  if (!cwd)
+    return;
+  return path.normalize(cwd);
+}
+function executeCommand(command, options) {
+  return new Promise((resolve) => {
+    const { shell, args } = getShellCommand(command);
+    let stdout = "";
+    let stderr = "";
+    let timedOut = false;
+    let resolved = false;
+    let timer = null;
+    let forceKillTimer = null;
+    const child = spawn(shell, args, {
+      cwd: normalizeCwd(options.cwd),
+      env: options.env,
+      stdio: ["ignore", "pipe", "pipe"],
+      windowsHide: true
+    });
+    const cleanup = () => {
+      if (timer)
+        clearTimeout(timer);
+      if (forceKillTimer)
+        clearTimeout(forceKillTimer);
+    };
+    const doResolve = (result) => {
+      if (!resolved) {
+        resolved = true;
+        cleanup();
+        resolve(result);
+      }
+    };
+    if (options.timeout) {
+      timer = setTimeout(() => {
+        timedOut = true;
+        if (isWindows()) {
+          child.kill("SIGTERM");
+          forceKillTimer = setTimeout(() => {
+            if (!child.killed) {
+              try {
+                process.kill(child.pid, "SIGKILL");
+              } catch {}
+            }
+          }, 500);
+        } else {
+          child.kill("SIGKILL");
+        }
+      }, options.timeout);
+    }
+    child.stdout?.on("data", (data) => {
+      stdout += data.toString();
+    });
+    child.stderr?.on("data", (data) => {
+      stderr += data.toString();
+    });
+    child.on("close", (code) => {
+      doResolve({
+        stdout: stdout.trim(),
+        stderr: stderr.trim(),
+        exitCode: timedOut ? -1 : code ?? 0,
+        timedOut
+      });
+    });
+    child.on("error", (err) => {
+      doResolve({
+        stdout: stdout.trim(),
+        stderr: err.message,
+        exitCode: 1,
+        timedOut: false
+      });
+    });
+  });
+}
 function getCurrentSpanContext() {
   try {
     const { getTracerProvider } = (init_tracer_provider(), __toCommonJS(exports_tracer_provider));
@@ -61,19 +152,14 @@ var bashTool = {
   metadata: {
     category: "system",
     tags: ["shell", "command", "terminal", "exec"],
-    version: "1.2.0"
+    version: "1.3.0"
   },
   execute: async (args, ctx) => {
     const startTime = Date.now();
     const { command, workdir, timeout = 60000, env } = args;
     const currentSpanCtx = getCurrentSpanContext();
     const traceId = currentSpanCtx?.traceId || getCurrentTraceId();
-    const options = {
-      timeout
-    };
-    if (workdir || ctx.workdir) {
-      options.cwd = workdir || ctx.workdir;
-    }
+    const cwd = workdir || ctx.workdir;
     const childEnv = {};
     for (const [key, value] of Object.entries(process.env)) {
       if (value !== undefined) {
@@ -96,7 +182,6 @@ var bashTool = {
     if (env) {
       Object.assign(childEnv, env);
     }
-    options.env = childEnv;
     let otelSpan = undefined;
     try {
       const { getTracerProvider } = (init_tracer_provider(), __toCommonJS(exports_tracer_provider));
@@ -105,51 +190,67 @@ var bashTool = {
       otelSpan = tracer.startSpan(`bash: ${command.slice(0, 50)}${command.length > 50 ? "..." : ""}`, {
         attributes: {
           "bash.command": command.slice(0, 200),
-          "bash.workdir": workdir || ctx.workdir || "",
-          "bash.timeout": timeout
+          "bash.workdir": cwd || "",
+          "bash.timeout": timeout,
+          "bash.platform": process.platform
         }
       });
     } catch {}
     const spanId = otelSpan?.spanContext?.spanId;
     try {
-      const { stdout, stderr } = await execAsync(command, options);
+      const result = await executeCommand(command, {
+        cwd,
+        timeout,
+        env: childEnv
+      });
       if (otelSpan) {
-        otelSpan.end({ stdout, stderr });
+        if (result.timedOut) {
+          const execError = new Error(`Command timed out after ${timeout}ms`);
+          execError.name = "BashExecutionError";
+          otelSpan.end(undefined, execError);
+        } else if (result.exitCode !== 0) {
+          const execError = new Error(result.stderr || "Command failed");
+          execError.name = "BashExecutionError";
+          otelSpan.end(undefined, execError);
+        } else {
+          otelSpan.end({ stdout: result.stdout, stderr: result.stderr });
+        }
       }
       return {
-        success: true,
-        output: stdout || "(no output)",
+        success: !result.timedOut && result.exitCode === 0,
+        output: result.stdout || "(no output)",
+        error: result.timedOut ? `Command timed out after ${timeout}ms` : result.exitCode !== 0 ? result.stderr : undefined,
         metadata: {
           execution_time_ms: Date.now() - startTime,
-          stdout,
-          stderr,
-          exit_code: 0,
+          stdout: result.stdout,
+          stderr: result.stderr,
+          exit_code: result.exitCode,
+          timed_out: result.timedOut,
           trace_id: traceId,
           parent_span_id: currentSpanCtx?.spanId,
-          span_id: spanId
+          span_id: spanId,
+          platform: process.platform
         }
       };
     } catch (error) {
-      const exitCode = error.code || 1;
-      const stdout = error.stdout || "";
-      const stderr = error.stderr || error.message;
-      const execError = new Error(stderr);
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      const execError = new Error(errorMessage);
       execError.name = "BashExecutionError";
       if (otelSpan) {
         otelSpan.end(undefined, execError);
       }
       return {
-        success: exitCode === 0,
-        output: stdout || "(no output)",
-        error: stderr,
+        success: false,
+        output: "",
+        error: errorMessage,
         metadata: {
           execution_time_ms: Date.now() - startTime,
-          stdout,
-          stderr,
-          exit_code: exitCode,
+          exit_code: 1,
+          timed_out: false,
           trace_id: traceId,
           parent_span_id: currentSpanCtx?.spanId,
-          span_id: spanId
+          span_id: spanId,
+          platform: process.platform
         }
       };
     }
@@ -182,13 +283,15 @@ var echoTool = {
 // src/env/tool/built-in/glob.ts
 import { z as z2 } from "zod";
 import { glob as globAsync } from "glob";
+import { stat } from "fs/promises";
+import path2 from "path";
 var globTool = {
   name: "glob",
   description: "Search for files matching a glob pattern. Use this to find files by name patterns like **/*.ts or **/*.md.",
   parameters: z2.object({
-    pattern: z2.string().describe("Glob pattern to match (e.g., **/*.ts, **/*.md)"),
+    pattern: z2.string().min(1).describe("Glob pattern to match (e.g., **/*.ts, **/*.md)"),
     cwd: z2.string().optional().describe("Working directory to search in"),
-    maxResults: z2.number().int().positive().optional().describe("Maximum number of results to return"),
+    maxResults: z2.number().int().positive().default(100).optional().describe("Maximum number of results to return"),
     ignore: z2.array(z2.string()).optional().describe("Patterns to ignore")
   }),
   sandbox: {
@@ -197,20 +300,66 @@ var globTool = {
   metadata: {
     category: "file",
     tags: ["search", "file", "glob", "pattern"],
-    version: "1.0.0"
+    version: "1.1.0"
   },
   execute: async (args, ctx) => {
     const startTime = Date.now();
     const { pattern, cwd, maxResults = 100, ignore } = args;
     const searchDir = cwd || ctx.workdir || process.cwd();
     try {
-      const files = await globAsync(pattern, {
+      const dirStats = await stat(searchDir);
+      if (!dirStats.isDirectory()) {
+        return {
+          success: false,
+          output: "",
+          error: `Path is not a directory: ${searchDir}`,
+          metadata: { execution_time_ms: Date.now() - startTime }
+        };
+      }
+    } catch (error) {
+      return {
+        success: false,
+        output: "",
+        error: error instanceof Error ? error.message : String(error),
+        metadata: { execution_time_ms: Date.now() - startTime }
+      };
+    }
+    try {
+      const absolutePattern = path2.isAbsolute(pattern) ? pattern : pattern;
+      const files = await globAsync(absolutePattern, {
         cwd: searchDir,
         ignore: ignore || ["**/node_modules/**", "**/.git/**"],
-        maxDepth: 20
+        maxDepth: 20,
+        absolute: false,
+        nodir: true
       });
-      const limitedFiles = files.slice(0, maxResults);
-      const output = limitedFiles.join(`
+      const filesWithMtime = [];
+      for (const file of files) {
+        try {
+          const fullPath = path2.join(searchDir, file);
+          const stats = await stat(fullPath);
+          if (stats.isFile()) {
+            filesWithMtime.push({
+              path: file,
+              mtime: stats.mtimeMs
+            });
+          }
+        } catch {}
+      }
+      filesWithMtime.sort((a, b) => b.mtime - a.mtime);
+      const truncated = filesWithMtime.length > maxResults;
+      const limitedFiles = filesWithMtime.slice(0, maxResults);
+      const outputLines = [];
+      if (limitedFiles.length === 0) {
+        outputLines.push("No files found");
+      } else {
+        outputLines.push(...limitedFiles.map((f) => f.path));
+        if (truncated) {
+          outputLines.push("");
+          outputLines.push(`(Results are truncated: showing first ${maxResults} results. Consider using a more specific path or pattern.)`);
+        }
+      }
+      const output = outputLines.join(`
 `);
       return {
         success: true,
@@ -218,8 +367,9 @@ var globTool = {
         metadata: {
           execution_time_ms: Date.now() - startTime,
           output_size: output.length,
-          total_matches: files.length,
-          returned_matches: limitedFiles.length
+          total_matches: filesWithMtime.length,
+          returned_matches: limitedFiles.length,
+          truncated
         }
       };
     } catch (error) {
@@ -237,7 +387,8 @@ var globTool = {
 
 // src/env/tool/built-in/read-file.ts
 import { z as z3 } from "zod";
-import { readFile } from "fs/promises";
+import { readFile, stat as stat2 } from "fs/promises";
+import path3 from "path";
 var readFileTool = {
   name: "read_file",
   description: "Read the contents of a file. Use this to read source code, configuration files, or any text files.",
@@ -261,21 +412,67 @@ var readFileTool = {
   metadata: {
     category: "file",
     tags: ["read", "file", "io"],
-    version: "1.0.0"
+    version: "1.1.0"
   },
   execute: async (args, ctx) => {
     const startTime = Date.now();
     const { path: filePath, offset, limit, encoding = "utf-8" } = args;
+    if (!filePath || typeof filePath !== "string") {
+      return {
+        success: false,
+        output: "",
+        error: "Invalid file path provided",
+        metadata: { execution_time_ms: Date.now() - startTime }
+      };
+    }
+    const normalizedPath = path3.normalize(filePath);
+    try {
+      const stats = await stat2(normalizedPath);
+      if (stats.isDirectory()) {
+        return {
+          success: false,
+          output: "",
+          error: `Path is a directory, not a file: ${normalizedPath}`,
+          metadata: { execution_time_ms: Date.now() - startTime }
+        };
+      }
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return {
+          success: false,
+          output: "",
+          error: `File not found: ${normalizedPath}`,
+          metadata: { execution_time_ms: Date.now() - startTime }
+        };
+      }
+      return {
+        success: false,
+        output: "",
+        error: error instanceof Error ? error.message : String(error),
+        metadata: { execution_time_ms: Date.now() - startTime }
+      };
+    }
     try {
-      const content = await readFile(filePath, encoding);
+      const contentBuffer = await readFile(normalizedPath);
+      let contentStr;
+      if (encoding === "base64") {
+        contentStr = contentBuffer.toString("base64");
+      } else {
+        contentStr = contentBuffer.toString("utf-8");
+      }
       let output;
-      const contentBuffer = content;
-      const contentStr = typeof contentBuffer === "string" ? contentBuffer : contentBuffer.toString(encoding);
       if (offset !== undefined || limit !== undefined) {
-        const lines = contentStr.split(`
-`);
+        const lines = contentStr.split(/\r?\n/);
         const startLine = offset || 0;
-        const endLine = limit ? startLine + limit : lines.length;
+        const endLine = limit !== undefined ? Math.min(startLine + limit, lines.length) : lines.length;
+        if (startLine >= lines.length) {
+          return {
+            success: false,
+            output: "",
+            error: `Offset ${offset} is beyond file length (${lines.length} lines)`,
+            metadata: { execution_time_ms: Date.now() - startTime }
+          };
+        }
         output = lines.slice(startLine, endLine).join(`
 `);
       } else {
@@ -287,7 +484,7 @@ var readFileTool = {
         metadata: {
           execution_time_ms: Date.now() - startTime,
           output_size: output.length,
-          file_path: filePath
+          file_path: normalizedPath
         }
       };
     } catch (error) {
@@ -305,8 +502,8 @@ var readFileTool = {
 
 // src/env/tool/built-in/write-file.ts
 import { z as z4 } from "zod";
-import { writeFile, mkdir } from "fs/promises";
-import { dirname } from "path";
+import { writeFile, mkdir, stat as stat3 } from "fs/promises";
+import path4 from "path";
 var writeFileTool = {
   name: "write_file",
   description: "Write content to a file. Use this to create new files or overwrite existing ones.",
@@ -331,24 +528,53 @@ var writeFileTool = {
   metadata: {
     category: "file",
     tags: ["write", "file", "io", "create"],
-    version: "1.0.0"
+    version: "1.1.0"
   },
   execute: async (args, ctx) => {
     const startTime = Date.now();
     const { path: filePath, content, createDirs = false, append = false } = args;
+    if (!filePath || typeof filePath !== "string") {
+      return {
+        success: false,
+        output: "",
+        error: "Invalid file path provided",
+        metadata: { execution_time_ms: Date.now() - startTime }
+      };
+    }
+    const normalizedPath = path4.normalize(filePath);
+    try {
+      const stats = await stat3(normalizedPath);
+      if (stats.isDirectory()) {
+        return {
+          success: false,
+          output: "",
+          error: `Path is a directory, not a file: ${normalizedPath}`,
+          metadata: { execution_time_ms: Date.now() - startTime }
+        };
+      }
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        return {
+          success: false,
+          output: "",
+          error: error instanceof Error ? error.message : String(error),
+          metadata: { execution_time_ms: Date.now() - startTime }
+        };
+      }
+    }
     try {
       if (createDirs) {
-        await mkdir(dirname(filePath), { recursive: true });
+        await mkdir(path4.dirname(normalizedPath), { recursive: true });
       }
       const flags = append ? "a" : "w";
-      await writeFile(filePath, content, { flag: flags });
+      await writeFile(normalizedPath, content, { flag: flags });
       return {
         success: true,
-        output: append ? `Content appended to: ${filePath}` : `File written: ${filePath}`,
+        output: append ? `Content appended to: ${normalizedPath}` : `File written: ${normalizedPath}`,
         metadata: {
           execution_time_ms: Date.now() - startTime,
           output_size: content.length,
-          file_path: filePath
+          file_path: normalizedPath
         }
       };
     } catch (error) {
@@ -366,7 +592,9 @@ var writeFileTool = {
 
 // src/env/tool/built-in/edit-file.ts
 import { z as z5 } from "zod";
-import { readFile as readFile2, writeFile as writeFile2 } from "fs/promises";
+import { readFile as readFile2, writeFile as writeFile2, stat as stat4, unlink } from "fs/promises";
+import path5 from "path";
+import { randomUUID } from "crypto";
 var editFileTool = {
   name: "edit_file",
   description: "Edit a file by replacing specific text. Use this to make targeted changes to files by specifying what to find and what to replace.",
@@ -391,32 +619,75 @@ var editFileTool = {
   metadata: {
     category: "file",
     tags: ["edit", "file", "replace", "modify"],
-    version: "1.0.0"
+    version: "1.1.0"
   },
   execute: async (args, ctx) => {
     const startTime = Date.now();
     const { path: filePath, oldString, newString, replaceAll = false } = args;
+    if (!filePath || typeof filePath !== "string") {
+      return {
+        success: false,
+        output: "",
+        error: "Invalid file path provided",
+        metadata: { execution_time_ms: Date.now() - startTime }
+      };
+    }
+    const normalizedPath = path5.normalize(filePath);
+    try {
+      const stats = await stat4(normalizedPath);
+      if (stats.isDirectory()) {
+        return {
+          success: false,
+          output: "",
+          error: `Path is a directory, not a file: ${normalizedPath}`,
+          metadata: { execution_time_ms: Date.now() - startTime }
+        };
+      }
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return {
+          success: false,
+          output: "",
+          error: `File not found: ${normalizedPath}`,
+          metadata: { execution_time_ms: Date.now() - startTime }
+        };
+      }
+      return {
+        success: false,
+        output: "",
+        error: error instanceof Error ? error.message : String(error),
+        metadata: { execution_time_ms: Date.now() - startTime }
+      };
+    }
     try {
-      const content = await readFile2(filePath, "utf-8");
-      const searchPattern = replaceAll ? new RegExp(escapeRegExp(oldString), "g") : new RegExp(escapeRegExp(oldString));
+      const content = await readFile2(normalizedPath, "utf-8");
+      const escapedPattern = escapeRegExp(oldString);
+      const searchPattern = replaceAll ? new RegExp(escapedPattern, "g") : new RegExp(escapedPattern);
       if (!searchPattern.test(content)) {
         return {
           success: false,
           output: "",
-          error: `Could not find "${oldString}" in file ${filePath}`,
+          error: `Could not find "${oldString}" in file ${normalizedPath}`,
           metadata: {
             execution_time_ms: Date.now() - startTime
           }
         };
       }
-      const newContent = replaceAll ? content.replace(new RegExp(escapeRegExp(oldString), "g"), newString) : content.replace(oldString, newString);
-      await writeFile2(filePath, newContent, "utf-8");
+      const newContent = replaceAll ? content.replace(new RegExp(escapedPattern, "g"), newString) : content.replace(oldString, newString);
+      const tempPath = `${normalizedPath}.${randomUUID()}.tmp`;
+      await writeFile2(tempPath, newContent, "utf-8");
+      await Bun.write(normalizedPath, newContent);
+      try {
+        await unlink(tempPath);
+      } catch {}
+      const count = replaceAll ? (content.match(new RegExp(escapedPattern, "g")) || []).length : content.includes(oldString) ? 1 : 0;
       return {
         success: true,
-        output: replaceAll ? `Replaced all occurrences in: ${filePath}` : `Replaced text in: ${filePath}`,
+        output: replaceAll ? `Replaced ${count} occurrences in: ${normalizedPath}` : `Replaced text in: ${normalizedPath}`,
         metadata: {
           execution_time_ms: Date.now() - startTime,
-          file_path: filePath
+          file_path: normalizedPath,
+          replacements: count
         }
       };
     } catch (error) {
@@ -437,13 +708,22 @@ function escapeRegExp(string) {
 
 // src/env/tool/built-in/grep.ts
 import { z as z6 } from "zod";
-import { readFile as readFile3 } from "fs/promises";
+import { readFile as readFile3, stat as stat5 } from "fs/promises";
 import { glob as globAsync2 } from "glob";
+import path6 from "path";
+function isBinaryContent(content) {
+  for (let i = 0;i < Math.min(content.length, 8192); i++) {
+    if (content[i] === 0) {
+      return true;
+    }
+  }
+  return false;
+}
 var grepTool = {
   name: "grep",
   description: "Search for text patterns in files. Use this to find specific strings, code patterns, or content across multiple files.",
   parameters: z6.object({
-    pattern: z6.string().describe("The pattern to search for"),
+    pattern: z6.string().min(1).describe("The pattern to search for"),
     path: z6.string().optional().describe("File or directory path to search in"),
     include: z6.string().optional().describe("Glob pattern for files to include (e.g., *.ts, *.js)"),
     caseSensitive: z6.boolean().default(true).optional().describe("Whether the search should be case sensitive"),
@@ -456,7 +736,7 @@ var grepTool = {
   metadata: {
     category: "file",
     tags: ["search", "grep", "find", "pattern"],
-    version: "1.0.0"
+    version: "1.1.0"
   },
   execute: async (args, ctx) => {
     const startTime = Date.now();
@@ -470,34 +750,69 @@ var grepTool = {
     } = args;
     const basePath = searchPath || ctx.workdir || process.cwd();
     try {
+      const stats = await stat5(basePath);
+      if (!stats.isDirectory() && !stats.isFile()) {
+        return {
+          success: false,
+          output: "",
+          error: `Path is neither a file nor a directory: ${basePath}`,
+          metadata: { execution_time_ms: Date.now() - startTime }
+        };
+      }
+    } catch (error) {
+      return {
+        success: false,
+        output: "",
+        error: error instanceof Error ? error.message : String(error),
+        metadata: { execution_time_ms: Date.now() - startTime }
+      };
+    }
+    try {
+      const isFile = (await stat5(basePath)).isFile();
       let files = [];
-      if (include) {
-        files = await globAsync2(include, {
-          cwd: basePath,
-          ignore: ["**/node_modules/**", "**/.git/**"],
-          maxDepth: 10
-        });
+      if (isFile) {
+        files = [basePath];
       } else {
-        files = await globAsync2("**/*", {
+        const globPattern = include || "**/*";
+        files = await globAsync2(globPattern, {
           cwd: basePath,
-          ignore: ["**/node_modules/**", "**/.git/**"],
-          maxDepth: 10
+          ignore: ["**/node_modules/**", "**/.git/**", "**/*.min.js", "**/*.map"],
+          maxDepth: 10,
+          nodir: true
         });
+        files = files.map((f) => path6.join(basePath, f));
       }
       const results = [];
       const regexFlags = caseSensitive ? "" : "i";
-      const regex = new RegExp(pattern, regexFlags);
+      let regex;
+      try {
+        regex = new RegExp(pattern, regexFlags);
+      } catch {
+        return {
+          success: false,
+          output: "",
+          error: `Invalid regex pattern: ${pattern}`,
+          metadata: { execution_time_ms: Date.now() - startTime }
+        };
+      }
       for (const file of files) {
         if (results.length >= maxResults)
           break;
         try {
-          const content = await readFile3(`${basePath}/${file}`, "utf-8");
-          const lines = content.split(`
-`);
+          const fileStats = await stat5(file);
+          if (fileStats.isDirectory())
+            continue;
+          const content = await readFile3(file);
+          if (isBinaryContent(content))
+            continue;
+          const textContent = content.toString("utf-8");
+          const lines = textContent.split(/\r?\n/);
           for (let i = 0;i < lines.length; i++) {
+            regex.lastIndex = 0;
             if (regex.test(lines[i])) {
               const lineNum = showLineNumbers ? `${i + 1}:` : "";
-              results.push(`${file}:${lineNum}${lines[i]}`);
+              const relativePath = path6.relative(basePath, file);
+              results.push(`${relativePath}:${lineNum}${lines[i]}`);
               if (results.length >= maxResults)
                 break;
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-setting/roy-agent-core",
-  "version": "1.5.29",
+  "version": "1.5.31",
   "type": "module",
   "description": "Core SDK for roy-agent - Environment, Components, Tools, Sessions, Tasks",
   "main": "./dist/index.js",