@ai-setting/roy-agent-cli 1.3.15 → 1.3.16

package/dist/core/src/env/tool/built-in/echo.js

@@ -0,0 +1,27 @@
+/**
+ * Echo tool - simple echo command
+ *
+ * This is a convenience tool for logging messages in workflows.
+ */
+export const echoTool = {
+    name: "echo",
+    description: "Echo a message to the console. Useful for logging in workflows.",
+    parameters: {
+        name: "message",
+        schema: {
+            type: "string",
+            description: "The message to echo",
+        },
+    },
+    execute: async (args, _ctx) => {
+        const message = args?.message || "(no message)";
+        return {
+            success: true,
+            output: message,
+            metadata: {
+                execution_time_ms: 0,
+            },
+        };
+    },
+};
+//# sourceMappingURL=echo.js.map

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

@@ -0,0 +1,7 @@
+import type { Tool } from "../types";
+/**
+ * 编辑文件工具
+ * 通过 oldString/newString 替换来编辑文件
+ */
+export declare const editFileTool: Tool;
+//# sourceMappingURL=edit-file.d.ts.map

package/dist/core/src/env/tool/built-in/edit-file.js

@@ -0,0 +1,86 @@
+import { z } from "zod";
+import { readFile, writeFile } from "fs/promises";
+/**
+ * 编辑文件工具
+ * 通过 oldString/newString 替换来编辑文件
+ */
+export const 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.",
+    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) => {
+        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) {
+    return string.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+//# sourceMappingURL=edit-file.js.map

package/dist/core/src/env/tool/built-in/edit-file.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=edit-file.test.d.ts.map

package/dist/core/src/env/tool/built-in/edit-file.test.js

@@ -0,0 +1,84 @@
+import { describe, test, expect, beforeEach } from "bun:test";
+import { editFileTool } from "./edit-file.js";
+import { writeFile, mkdir } from "fs/promises";
+import { join } from "path";
+describe("editFileTool", () => {
+    const testDir = join("/tmp", `edit-test-${Date.now()}`);
+    const testFile = join(testDir, "test.txt");
+    beforeEach(async () => {
+        await mkdir(testDir, { recursive: true });
+        await writeFile(testFile, "Hello, World!\nThis is a test.\nEnd of file.");
+    });
+    describe("parameters", () => {
+        test("should validate required parameters", async () => {
+            const result = await editFileTool.execute({ path: testFile, oldString: "Hello", newString: "Hi" }, {});
+            expect(result.success).toBe(true);
+        });
+        test("should handle missing oldString gracefully", async () => {
+            const result = await editFileTool.execute({ path: testFile, newString: "Hi" }, {});
+            // 会因为找不到空字符串而失败
+            expect(result).toBeDefined();
+        });
+        test("should handle missing newString gracefully", async () => {
+            const result = await editFileTool.execute({ path: testFile, oldString: "Hello" }, {});
+            // 会成功替换为空字符串
+            expect(result.success).toBe(true);
+        });
+    });
+    describe("execution", () => {
+        test("should replace text in file", async () => {
+            const result = await editFileTool.execute({ path: testFile, oldString: "Hello", newString: "Hi" }, {});
+            expect(result.success).toBe(true);
+            const content = await Bun.file(testFile).text();
+            expect(content).toContain("Hi, World!");
+            expect(content).not.toContain("Hello, World!");
+        });
+        test("should replace all occurrences with replaceAll", async () => {
+            await writeFile(testFile, "foo bar foo baz foo");
+            const result = await editFileTool.execute({ path: testFile, oldString: "foo", newString: "qux", replaceAll: true }, {});
+            expect(result.success).toBe(true);
+            const content = await Bun.file(testFile).text();
+            expect(content).toBe("qux bar qux baz qux");
+        });
+        test("should replace only first occurrence without replaceAll", async () => {
+            await writeFile(testFile, "foo bar foo baz foo");
+            const result = await editFileTool.execute({ path: testFile, oldString: "foo", newString: "qux" }, {});
+            expect(result.success).toBe(true);
+            const content = await Bun.file(testFile).text();
+            expect(content).toBe("qux bar foo baz foo");
+        });
+        test("should return error when text not found", async () => {
+            const result = await editFileTool.execute({ path: testFile, oldString: "NonExistent", newString: "Something" }, {});
+            expect(result.success).toBe(false);
+            expect(result.error).toContain("Could not find");
+        });
+        test("should handle multiline replacement", async () => {
+            const result = await editFileTool.execute({
+                path: testFile,
+                oldString: "Hello, World!\nThis is a test.",
+                newString: "Greetings!\nThis has been updated."
+            }, {});
+            expect(result.success).toBe(true);
+            const content = await Bun.file(testFile).text();
+            expect(content).toContain("Greetings!");
+            expect(content).toContain("This has been updated.");
+        });
+        test("should include metadata", async () => {
+            const result = await editFileTool.execute({ path: testFile, oldString: "Hello", newString: "Hi" }, {});
+            expect(result.metadata?.execution_time_ms).toBeDefined();
+            expect(result.metadata?.file_path).toBe(testFile);
+        });
+    });
+    describe("metadata", () => {
+        test("should have correct metadata", () => {
+            expect(editFileTool.name).toBe("edit_file");
+            expect(editFileTool.metadata?.category).toBe("file");
+            expect(editFileTool.metadata?.tags).toContain("edit");
+        });
+        test("should require confirmation", () => {
+            expect(editFileTool.permission?.requireConfirmation).toBe(true);
+            expect(editFileTool.permission?.level).toBe("dangerous");
+        });
+    });
+});
+//# sourceMappingURL=edit-file.test.js.map

package/dist/core/src/env/tool/built-in/glob.d.ts

@@ -0,0 +1,7 @@
+import type { Tool } from "../types";
+/**
+ * Glob 工具
+ * 文件模式匹配搜索
+ */
+export declare const globTool: Tool;
+//# sourceMappingURL=glob.d.ts.map

package/dist/core/src/env/tool/built-in/glob.js

@@ -0,0 +1,60 @@
+import { z } from "zod";
+import { glob as globAsync } from "glob";
+/**
+ * Glob 工具
+ * 文件模式匹配搜索
+ */
+export const globTool = {
+    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) => {
+        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,
+                },
+            };
+        }
+    },
+};
+//# sourceMappingURL=glob.js.map

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=glob.test.d.ts.map

package/dist/core/src/env/tool/built-in/glob.test.js

@@ -0,0 +1,61 @@
+import { describe, test, expect, beforeEach } from "bun:test";
+import { globTool } from "./glob.js";
+import { mkdir } 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");
+        });
+    });
+});
+//# sourceMappingURL=glob.test.js.map

package/dist/core/src/env/tool/built-in/grep.d.ts

@@ -0,0 +1,7 @@
+import type { Tool } from "../types";
+/**
+ * Grep 工具
+ * 在文件中搜索内容
+ */
+export declare const grepTool: Tool;
+//# sourceMappingURL=grep.d.ts.map

package/dist/core/src/env/tool/built-in/grep.js

@@ -0,0 +1,96 @@
+import { z } from "zod";
+import { readFile } from "fs/promises";
+import { glob as globAsync } from "glob";
+/**
+ * Grep 工具
+ * 在文件中搜索内容
+ */
+export const grepTool = {
+    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) => {
+        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 = [];
+            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 = [];
+            // 不使用全局标志，避免 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,
+                },
+            };
+        }
+    },
+};
+//# sourceMappingURL=grep.js.map

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=grep.test.d.ts.map

package/dist/core/src/env/tool/built-in/grep.test.js

@@ -0,0 +1,74 @@
+import { describe, test, expect, beforeEach } from "bun:test";
+import { grepTool } from "./grep.js";
+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");
+        });
+    });
+});
+//# sourceMappingURL=grep.test.js.map

package/dist/core/src/env/tool/built-in/index.d.ts

@@ -0,0 +1,28 @@
+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 declare function getAllBuiltInTools(): Tool[];
+/**
+ * 获取指定内置工具
+ */
+export declare function getBuiltInTool(name: string): Tool | undefined;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,41 @@
+import { bashTool } from "./bash.js";
+import { echoTool } from "./echo.js";
+import { globTool } from "./glob.js";
+import { readFileTool } from "./read-file.js";
+import { writeFileTool } from "./write-file.js";
+import { editFileTool } from "./edit-file.js";
+import { grepTool } from "./grep.js";
+// 重新导出所有内置工具
+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() {
+    return [
+        bashTool,
+        echoTool,
+        globTool,
+        readFileTool,
+        writeFileTool,
+        editFileTool,
+        grepTool,
+    ];
+}
+/**
+ * 获取指定内置工具
+ */
+export function getBuiltInTool(name) {
+    const tools = getAllBuiltInTools();
+    return tools.find((t) => t.name === name);
+}
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,6 @@
+import type { Tool } from "../types";
+/**
+ * 读取文件工具
+ */
+export declare const readFileTool: Tool;
+//# sourceMappingURL=read-file.d.ts.map