@ai-setting/roy-agent-core 1.3.10 → 1.3.14

package/src/env/tool/built-in/edit-file.ts

@@ -1,92 +0,0 @@
-import { z } from "zod";
-import { readFile, writeFile } from "fs/promises";
-import type { Tool, ToolContext, ToolResult } from "../types";
-
-/**
- * 编辑文件工具
- * 通过 oldString/newString 替换来编辑文件
- */
-export const editFileTool: Tool = {
-  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.",
-  parameters: z.object({
-    path: z.string().describe("The file path to edit"),
-    oldString: z.string().describe("The text to find and replace"),
-    newString: z.string().describe("The replacement text"),
-    replaceAll: z.boolean().default(false).optional().describe("Replace all occurrences instead of just the first"),
-  }),
-  sandbox: {
-    enabled: true,
-    config: {
-      filesystem: {
-        denyWrite: ["/etc", "/usr/bin", "/usr/sbin", "/bin", "/sbin"],
-      },
-    },
-  },
-  permission: {
-    requireConfirmation: true,
-    level: "dangerous",
-  },
-  metadata: {
-    category: "file",
-    tags: ["edit", "file", "replace", "modify"],
-    version: "1.0.0",
-  },
-  execute: async (args, ctx: ToolContext): Promise<ToolResult> => {
-    const startTime = Date.now();
-    const { path: filePath, oldString, newString, replaceAll = false } = args;
-
-    try {
-      // 读取文件内容
-      const content = await readFile(filePath, "utf-8");
-
-      // 检查是否找到要替换的内容
-      const searchPattern = replaceAll ? new RegExp(escapeRegExp(oldString), "g") : new RegExp(escapeRegExp(oldString));
-      if (!searchPattern.test(content)) {
-        return {
-          success: false,
-          output: "",
-          error: `Could not find "${oldString}" in file ${filePath}`,
-          metadata: {
-            execution_time_ms: Date.now() - startTime,
-          },
-        };
-      }
-
-      // 执行替换
-      const newContent = replaceAll
-        ? content.replace(new RegExp(escapeRegExp(oldString), "g"), newString)
-        : content.replace(oldString, newString);
-
-      // 写回文件
-      await writeFile(filePath, newContent, "utf-8");
-
-      return {
-        success: true,
-        output: replaceAll
-          ? `Replaced all occurrences in: ${filePath}`
-          : `Replaced text in: ${filePath}`,
-        metadata: {
-          execution_time_ms: Date.now() - startTime,
-          file_path: filePath,
-        },
-      };
-    } catch (error) {
-      return {
-        success: false,
-        output: "",
-        error: error instanceof Error ? error.message : String(error),
-        metadata: {
-          execution_time_ms: Date.now() - startTime,
-        },
-      };
-    }
-  },
-};
-
-/**
- * 转义正则表达式特殊字符
- */
-function escapeRegExp(string: string): string {
-  return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}

package/src/env/tool/built-in/glob.test.ts

@@ -1,94 +0,0 @@
-import { describe, test, expect, beforeEach } from "bun:test";
-import { globTool } from "./glob";
-import { mkdir, rm } from "fs/promises";
-import { join } from "path";
-
-describe("globTool", () => {
-  const testDir = join("/tmp", `glob-test-${Date.now()}`);
-
-  beforeEach(async () => {
-    // 创建测试目录结构
-    await mkdir(join(testDir, "src"), { recursive: true });
-    await mkdir(join(testDir, "docs"), { recursive: true });
-    await mkdir(join(testDir, "node_modules", "pkg"), { recursive: true });
-    
-    // 创建测试文件
-    await Bun.write(join(testDir, "src", "index.ts"), "");
-    await Bun.write(join(testDir, "src", "util.ts"), "");
-    await Bun.write(join(testDir, "docs", "readme.md"), "");
-    await Bun.write(join(testDir, "package.json"), "");
-  });
-
-  describe("parameters", () => {
-    test("should validate pattern parameter", async () => {
-      const result = await globTool.execute(
-        { pattern: "**/*.ts", cwd: testDir },
-        {}
-      );
-      
-      expect(result.success).toBe(true);
-    });
-  });
-
-  describe("execution", () => {
-    test("should find files by pattern", async () => {
-      const result = await globTool.execute(
-        { pattern: "**/*.ts", cwd: testDir },
-        {}
-      );
-      
-      expect(result.success).toBe(true);
-      expect(result.output).toContain("index.ts");
-      expect(result.output).toContain("util.ts");
-    });
-
-    test("should exclude node_modules by default", async () => {
-      const result = await globTool.execute(
-        { pattern: "**/*.js", cwd: testDir },
-        {}
-      );
-      
-      expect(result.success).toBe(true);
-      expect(result.output).not.toContain("node_modules");
-    });
-
-    test("should respect maxResults limit", async () => {
-      const result = await globTool.execute(
-        { pattern: "**/*", cwd: testDir, maxResults: 2 },
-        {}
-      );
-      
-      expect(result.success).toBe(true);
-      const files = result.output.split("\n").filter(f => f.length > 0);
-      expect(files.length).toBeLessThanOrEqual(2);
-    });
-
-    test("should use context workdir", async () => {
-      const result = await globTool.execute(
-        { pattern: "**/*.ts" },
-        { workdir: testDir }
-      );
-      
-      expect(result.success).toBe(true);
-      expect(result.output).toContain("index.ts");
-    });
-
-    test("should return metadata with counts", async () => {
-      const result = await globTool.execute(
-        { pattern: "**/*", cwd: testDir },
-        {}
-      );
-      
-      expect(result.metadata?.total_matches).toBeDefined();
-      expect(result.metadata?.returned_matches).toBeDefined();
-    });
-  });
-
-  describe("metadata", () => {
-    test("should have correct metadata", () => {
-      expect(globTool.name).toBe("glob");
-      expect(globTool.metadata?.category).toBe("file");
-      expect(globTool.metadata?.tags).toContain("search");
-    });
-  });
-});

package/src/env/tool/built-in/glob.ts

@@ -1,65 +0,0 @@
-import { z } from "zod";
-import { glob as globAsync } from "glob";
-import path from "path";
-import type { Tool, ToolContext, ToolResult } from "../types";
-
-/**
- * Glob 工具
- * 文件模式匹配搜索
- */
-export const globTool: Tool = {
-  name: "glob",
-  description: "Search for files matching a glob pattern. Use this to find files by name patterns like **/*.ts or **/*.md.",
-  parameters: z.object({
-    pattern: z.string().describe("Glob pattern to match (e.g., **/*.ts, **/*.md)"),
-    cwd: z.string().optional().describe("Working directory to search in"),
-    maxResults: z.number().int().positive().optional().describe("Maximum number of results to return"),
-    ignore: z.array(z.string()).optional().describe("Patterns to ignore"),
-  }),
-  sandbox: {
-    enabled: true,
-  },
-  metadata: {
-    category: "file",
-    tags: ["search", "file", "glob", "pattern"],
-    version: "1.0.0",
-  },
-  execute: async (args, ctx: ToolContext): Promise<ToolResult> => {
-    const startTime = Date.now();
-    const { pattern, cwd, maxResults = 100, ignore } = args;
-
-    const searchDir = cwd || ctx.workdir || process.cwd();
-
-    try {
-      const files = await globAsync(pattern, {
-        cwd: searchDir,
-        ignore: ignore || ["**/node_modules/**", "**/.git/**"],
-        maxDepth: 20,
-      });
-
-      // 限制结果数量
-      const limitedFiles = files.slice(0, maxResults);
-      const output = limitedFiles.join("\n");
-
-      return {
-        success: true,
-        output,
-        metadata: {
-          execution_time_ms: Date.now() - startTime,
-          output_size: output.length,
-          total_matches: files.length,
-          returned_matches: limitedFiles.length,
-        },
-      };
-    } catch (error) {
-      return {
-        success: false,
-        output: "",
-        error: error instanceof Error ? error.message : String(error),
-        metadata: {
-          execution_time_ms: Date.now() - startTime,
-        },
-      };
-    }
-  },
-};

package/src/env/tool/built-in/grep.test.ts

@@ -1,122 +0,0 @@
-import { describe, test, expect, beforeEach } from "bun:test";
-import { grepTool } from "./grep";
-import { writeFile, mkdir } from "fs/promises";
-import { join } from "path";
-
-describe("grepTool", () => {
-  const testDir = join("/tmp", `grep-test-${Date.now()}`);
-  const testFile1 = join(testDir, "file1.ts");
-  const testFile2 = join(testDir, "file2.ts");
-
-  beforeEach(async () => {
-    await mkdir(testDir, { recursive: true });
-    await writeFile(testFile1, "function hello() {\n  return 'Hello';\n}\nconsole.log(hello());");
-    await writeFile(testFile2, "class Greeter {\n  greet() {\n    return 'Hi';\n  }\n}");
-  });
-
-  describe("parameters", () => {
-    test("should validate pattern parameter", async () => {
-      const result = await grepTool.execute(
-        { pattern: "hello", path: testDir, include: "*.ts" },
-        {}
-      );
-      
-      expect(result.success).toBe(true);
-    });
-  });
-
-  describe("execution", () => {
-    test("should find pattern in files", async () => {
-      const result = await grepTool.execute(
-        { pattern: "hello", path: testDir, include: "*.ts" },
-        {}
-      );
-      
-      expect(result.success).toBe(true);
-      expect(result.output).toContain("file1.ts");
-      expect(result.output).toContain("hello");
-    });
-
-    test("should show line numbers by default", async () => {
-      const result = await grepTool.execute(
-        { pattern: "function", path: testDir, include: "*.ts" },
-        {}
-      );
-      
-      expect(result.success).toBe(true);
-      expect(result.output).toContain(":1:");
-    });
-
-    test("should hide line numbers when disabled", async () => {
-      const result = await grepTool.execute(
-        { pattern: "function", path: testDir, include: "*.ts", showLineNumbers: false },
-        {}
-      );
-      
-      expect(result.success).toBe(true);
-      expect(result.output).not.toContain(":1:");
-    });
-
-    test("should be case sensitive by default", async () => {
-      const result = await grepTool.execute(
-        { pattern: "Hello", path: testDir, include: "*.ts" },
-        {}
-      );
-      
-      expect(result.success).toBe(true);
-      expect(result.output).toContain("Hello");
-    });
-
-    test("should be case insensitive when specified", async () => {
-      const result = await grepTool.execute(
-        { pattern: "hello", path: testDir, include: "*.ts", caseSensitive: false },
-        {}
-      );
-      
-      expect(result.success).toBe(true);
-      expect(result.output).toContain("Hello");
-    });
-
-    test("should respect maxResults limit", async () => {
-      await writeFile(join(testDir, "file3.ts"), "hello\nhello\nhello\nhello\nhello");
-      
-      const result = await grepTool.execute(
-        { pattern: "hello", path: testDir, include: "*.ts", maxResults: 2 },
-        {}
-      );
-      
-      expect(result.success).toBe(true);
-      const matches = result.output.split("\n").filter(m => m.includes("hello"));
-      expect(matches.length).toBeLessThanOrEqual(2);
-    });
-
-    test("should return no matches message", async () => {
-      const result = await grepTool.execute(
-        { pattern: "nonexistent", path: testDir, include: "*.ts" },
-        {}
-      );
-      
-      expect(result.success).toBe(true);
-      expect(result.output).toContain("(no matches found)");
-    });
-
-    test("should include metadata", async () => {
-      const result = await grepTool.execute(
-        { pattern: "hello", path: testDir, include: "*.ts" },
-        {}
-      );
-      
-      expect(result.metadata?.execution_time_ms).toBeDefined();
-      expect(result.metadata?.matches_count).toBeDefined();
-      expect(result.metadata?.files_searched).toBeDefined();
-    });
-  });
-
-  describe("metadata", () => {
-    test("should have correct metadata", () => {
-      expect(grepTool.name).toBe("grep");
-      expect(grepTool.metadata?.category).toBe("file");
-      expect(grepTool.metadata?.tags).toContain("search");
-    });
-  });
-});

package/src/env/tool/built-in/grep.ts

@@ -1,108 +0,0 @@
-import { z } from "zod";
-import { readFile } from "fs/promises";
-import { glob as globAsync } from "glob";
-import type { Tool, ToolContext, ToolResult } from "../types";
-
-/**
- * Grep 工具
- * 在文件中搜索内容
- */
-export const grepTool: Tool = {
-  name: "grep",
-  description: "Search for text patterns in files. Use this to find specific strings, code patterns, or content across multiple files.",
-  parameters: z.object({
-    pattern: z.string().describe("The pattern to search for"),
-    path: z.string().optional().describe("File or directory path to search in"),
-    include: z.string().optional().describe("Glob pattern for files to include (e.g., *.ts, *.js)"),
-    caseSensitive: z.boolean().default(true).optional().describe("Whether the search should be case sensitive"),
-    maxResults: z.number().int().positive().default(50).optional().describe("Maximum number of results"),
-    showLineNumbers: z.boolean().default(true).optional().describe("Show line numbers in results"),
-  }),
-  sandbox: {
-    enabled: true,
-  },
-  metadata: {
-    category: "file",
-    tags: ["search", "grep", "find", "pattern"],
-    version: "1.0.0",
-  },
-  execute: async (args, ctx: ToolContext): Promise<ToolResult> => {
-    const startTime = Date.now();
-    const {
-      pattern,
-      path: searchPath,
-      include,
-      caseSensitive = true,
-      maxResults = 50,
-      showLineNumbers = true,
-    } = args;
-
-    const basePath = searchPath || ctx.workdir || process.cwd();
-
-    try {
-      // 如果指定了 include，先找到匹配的文件
-      let files: string[] = [];
-      if (include) {
-        files = await globAsync(include, {
-          cwd: basePath,
-          ignore: ["**/node_modules/**", "**/.git/**"],
-          maxDepth: 10,
-        });
-      } else {
-        // 否则搜索目录
-        files = await globAsync("**/*", {
-          cwd: basePath,
-          ignore: ["**/node_modules/**", "**/.git/**"],
-          maxDepth: 10,
-        });
-      }
-
-      const results: string[] = [];
-      // 不使用全局标志，避免 lastIndex 问题
-      const regexFlags = caseSensitive ? "" : "i";
-      const regex = new RegExp(pattern, regexFlags);
-
-      for (const file of files) {
-        if (results.length >= maxResults) break;
-
-        try {
-          const content = await readFile(`${basePath}/${file}`, "utf-8");
-          const lines = content.split("\n");
-
-          for (let i = 0; i < lines.length; i++) {
-            if (regex.test(lines[i])) {
-              const lineNum = showLineNumbers ? `${i + 1}:` : "";
-              results.push(`${file}:${lineNum}${lines[i]}`);
-
-              if (results.length >= maxResults) break;
-            }
-          }
-        } catch {
-          // 跳过无法读取的文件（如二进制）
-        }
-      }
-
-      const output = results.join("\n") || "(no matches found)";
-
-      return {
-        success: true,
-        output,
-        metadata: {
-          execution_time_ms: Date.now() - startTime,
-          output_size: output.length,
-          matches_count: results.length,
-          files_searched: files.length,
-        },
-      };
-    } catch (error) {
-      return {
-        success: false,
-        output: "",
-        error: error instanceof Error ? error.message : String(error),
-        metadata: {
-          execution_time_ms: Date.now() - startTime,
-        },
-      };
-    }
-  },
-};

package/src/env/tool/built-in/index.ts

@@ -1,44 +0,0 @@
-import type { Tool } from "../types";
-import { bashTool } from "./bash";
-import { echoTool } from "./echo";
-import { globTool } from "./glob";
-import { readFileTool } from "./read-file";
-import { writeFileTool } from "./write-file";
-import { editFileTool } from "./edit-file";
-import { grepTool } from "./grep";
-
-// 重新导出所有内置工具
-export { bashTool };
-export { echoTool };
-export { globTool };
-export { readFileTool };
-export { writeFileTool };
-export { editFileTool };
-export { grepTool };
-
-/**
- * 获取所有内置工具
- * 
- * Note: run-workflow tool is not included here because it requires
- * a WorkflowService instance which needs to be initialized at runtime.
- * Use initRunWorkflowTool(workflowService) to initialize it.
- */
-export function getAllBuiltInTools(): Tool[] {
-  return [
-    bashTool,
-    echoTool,
-    globTool,
-    readFileTool,
-    writeFileTool,
-    editFileTool,
-    grepTool,
-  ];
-}
-
-/**
- * 获取指定内置工具
- */
-export function getBuiltInTool(name: string): Tool | undefined {
-  const tools = getAllBuiltInTools();
-  return tools.find((t) => t.name === name);
-}

package/src/env/tool/built-in/read-file.test.ts

@@ -1,84 +0,0 @@
-import { describe, test, expect, beforeEach } from "bun:test";
-import { readFileTool } from "./read-file";
-import { writeFile, mkdir } from "fs/promises";
-import { join } from "path";
-
-describe("readFileTool", () => {
-  const testDir = join("/tmp", `read-test-${Date.now()}`);
-  const testFile = join(testDir, "test.txt");
-  const multiLineFile = join(testDir, "multi.txt");
-
-  beforeEach(async () => {
-    await mkdir(testDir, { recursive: true });
-    await writeFile(testFile, "Hello, World!");
-    await writeFile(multiLineFile, "Line 1\nLine 2\nLine 3\nLine 4\nLine 5");
-  });
-
-  describe("parameters", () => {
-    test("should validate path parameter", async () => {
-      const result = await readFileTool.execute({ path: testFile }, {});
-      
-      expect(result.success).toBe(true);
-      expect(result.output).toBe("Hello, World!");
-    });
-
-    test("should handle missing path gracefully", async () => {
-      // Zod 会使用 undefined 值执行，可能导致文件系统错误而不是验证错误
-      const result = await readFileTool.execute({} as any, {});
-      expect(result).toBeDefined();
-    });
-  });
-
-  describe("execution", () => {
-    test("should read file content", async () => {
-      const result = await readFileTool.execute({ path: testFile }, {});
-      
-      expect(result.success).toBe(true);
-      expect(result.output).toBe("Hello, World!");
-    });
-
-    test("should read with offset and limit", async () => {
-      const result = await readFileTool.execute(
-        { path: multiLineFile, offset: 1, limit: 2 },
-        {}
-      );
-      
-      expect(result.success).toBe(true);
-      expect(result.output).toBe("Line 2\nLine 3");
-    });
-
-    test("should return error for non-existent file", async () => {
-      const result = await readFileTool.execute(
-        { path: join(testDir, "non-existent.txt") },
-        {}
-      );
-      
-      expect(result.success).toBe(false);
-      expect(result.error).toBeDefined();
-    });
-
-    test("should include metadata", async () => {
-      const result = await readFileTool.execute({ path: testFile }, {});
-      
-      expect(result.metadata?.execution_time_ms).toBeDefined();
-      expect(result.metadata?.output_size).toBeDefined();
-      expect(result.metadata?.file_path).toBe(testFile);
-    });
-  });
-
-  describe("metadata", () => {
-    test("should have correct metadata", () => {
-      expect(readFileTool.name).toBe("read_file");
-      expect(readFileTool.metadata?.category).toBe("file");
-      expect(readFileTool.metadata?.tags).toContain("read");
-    });
-
-    test("should have sandbox config", () => {
-      expect(readFileTool.sandbox?.enabled).toBe(true);
-    });
-
-    test("should be safe permission", () => {
-      expect(readFileTool.permission?.level).toBe("safe");
-    });
-  });
-});

package/src/env/tool/built-in/read-file.ts

@@ -1,75 +0,0 @@
-import { z } from "zod";
-import { readFile } from "fs/promises";
-import type { Tool, ToolContext, ToolResult } from "../types";
-
-/**
- * 读取文件工具
- */
-export const readFileTool: Tool = {
-  name: "read_file",
-  description: "Read the contents of a file. Use this to read source code, configuration files, or any text files.",
-  parameters: z.object({
-    path: z.string().describe("The file path to read"),
-    offset: z.number().int().nonnegative().optional().describe("Line offset to start reading from"),
-    limit: z.number().int().positive().optional().describe("Number of lines to read"),
-    encoding: z.enum(["utf-8", "base64"]).default("utf-8").optional().describe("File encoding"),
-  }),
-  sandbox: {
-    enabled: true,
-    config: {
-      filesystem: {
-        denyRead: ["/etc/shadow", "/etc/sudoers", "/root/.ssh"],
-      },
-    },
-  },
-  permission: {
-    level: "safe",
-  },
-  metadata: {
-    category: "file",
-    tags: ["read", "file", "io"],
-    version: "1.0.0",
-  },
-  execute: async (args, ctx: ToolContext): Promise<ToolResult> => {
-    const startTime = Date.now();
-    const { path: filePath, offset, limit, encoding = "utf-8" } = args;
-
-    try {
-      const content = await readFile(filePath, encoding as BufferEncoding);
-
-      // 如果是二进制或指定了 offset/limit，需要特殊处理
-      let output: string;
-      const contentBuffer = content as Buffer | string;
-      const contentStr = typeof contentBuffer === "string" 
-        ? contentBuffer 
-        : (contentBuffer as Buffer).toString(encoding as BufferEncoding);
-      if (offset !== undefined || limit !== undefined) {
-        const lines = contentStr.split("\n");
-        const startLine = offset || 0;
-        const endLine = limit ? startLine + limit : lines.length;
-        output = lines.slice(startLine, endLine).join("\n");
-      } else {
-        output = contentStr;
-      }
-
-      return {
-        success: true,
-        output,
-        metadata: {
-          execution_time_ms: Date.now() - startTime,
-          output_size: output.length,
-          file_path: filePath,
-        },
-      };
-    } catch (error) {
-      return {
-        success: false,
-        output: "",
-        error: error instanceof Error ? error.message : String(error),
-        metadata: {
-          execution_time_ms: Date.now() - startTime,
-        },
-      };
-    }
-  },
-};