@empiricalrun/test-gen 0.63.0 → 0.64.1

package/dist/tools/str_replace_editor.js

@@ -4,29 +4,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.textEditorTools = void 0;
-exports.cleanupBackupFiles = cleanupBackupFiles;
 exports.strReplaceEditorExecutor = strReplaceEditorExecutor;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const zod_1 = require("zod");
 const web_1 = require("../bin/utils/platform/web");
-function createBackup(filePath) {
-    const backupPath = `${filePath}.bak`;
-    if (fs_1.default.existsSync(filePath)) {
-        fs_1.default.copyFileSync(filePath, backupPath);
-    }
-}
-function hasBackup(filePath) {
-    const backupPath = `${filePath}.bak`;
-    return fs_1.default.existsSync(backupPath);
-}
-function restoreBackup(filePath) {
-    const backupPath = `${filePath}.bak`;
-    if (fs_1.default.existsSync(backupPath)) {
-        fs_1.default.copyFileSync(backupPath, filePath);
-        fs_1.default.unlinkSync(backupPath);
-    }
-}
 /**
  * While running str_replace command, we've seen LLM can struggle to send unique old_str.
  * This function tries to find unique contexts for each occurrence of old_str, so that the error
@@ -85,234 +67,249 @@ function getUniqueOccurences(contents, old_str) {
     }
     return uniqueContexts;
 }
-/**
- * Cleans up any backup files that were created during the editing process
- * @returns The number of backup files that were cleaned up
- */
-function cleanupBackupFiles(repoDir) {
-    let cleanedCount = 0;
-    const walkDir = (dir) => {
-        let files = [];
-        try {
-            files = fs_1.default.readdirSync(dir);
-        }
-        catch (readDirError) {
-            return;
-        }
-        for (const file of files) {
-            const fullPath = path_1.default.join(dir, file);
-            let stat;
-            try {
-                stat = fs_1.default.statSync(fullPath);
-            }
-            catch (statError) {
-                continue;
-            }
-            if (stat.isDirectory()) {
-                if (file !== "node_modules") {
-                    walkDir(fullPath);
-                }
-            }
-            else if (file.endsWith(".bak")) {
-                try {
-                    fs_1.default.unlinkSync(fullPath);
-                    cleanedCount++;
-                }
-                catch (unlinkError) {
-                    // Intentionally ignore errors during cleanup
-                }
-            }
+function escapeRegExp(text) {
+    return text.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+}
+async function fileViewExecutor({ input, filePath, absoluteFilePath, }) {
+    if (!fs_1.default.existsSync(absoluteFilePath)) {
+        return {
+            result: `Error: File ${filePath} not found. Please provide relative file path to the Repository.`,
+            isError: true,
+        };
+    }
+    // Handle directory view
+    if (fs_1.default.statSync(absoluteFilePath).isDirectory()) {
+        const files = fs_1.default.readdirSync(absoluteFilePath);
+        return {
+            result: files.join("\n"),
+            isError: false,
+        };
+    }
+    else {
+        // Check if file is binary, which is not supported
+        const { isBinary } = await import("istextorbinary");
+        const binary = isBinary(absoluteFilePath);
+        if (binary) {
+            return {
+                result: "Error: File is binary, which is not supported",
+                isError: true,
+            };
         }
+    }
+    // Handle file view
+    const content = fs_1.default.readFileSync(absoluteFilePath, "utf8");
+    const lines = content.split("\n");
+    if (input.view_range) {
+        const [start, end] = input.view_range;
+        const endLine = end === -1 ? lines.length : end;
+        return {
+            result: lines
+                .slice(start - 1, endLine)
+                .map((line, idx) => `${start + idx}: ${line}`)
+                .join("\n"),
+            isError: false,
+        };
+    }
+    return {
+        result: lines.map((line, idx) => `${idx + 1}: ${line}`).join("\n"),
+        isError: false,
     };
-    try {
-        walkDir(repoDir);
+}
+async function fileCreateExecutor({ input, filePath, absoluteFilePath, repoDir, }) {
+    if (input.file_text === undefined || input.file_text === null) {
+        return {
+            result: "Error: file_text is required for create command",
+            isError: true,
+        };
     }
-    catch (error) {
-        // Intentionally ignore errors during cleanup
+    if (filePath.endsWith("test.ts")) {
+        return {
+            result: "Error: Creating test.ts files is not allowed. Did you mean spec.ts?",
+            isError: true,
+        };
+    }
+    if (filePath.endsWith("spec.ts") && !filePath.startsWith("tests/")) {
+        return {
+            result: "Error: Creating spec.ts files is not allowed outside tests/ directory",
+            isError: true,
+        };
+    }
+    const fileName = path_1.default.basename(filePath);
+    if (!fileName.includes(".")) {
+        return {
+            result: `Error: File name must include a file extension. This tool cannot create empty directories.
+If you need to create a file which is inside a directory that does not exist, you can expect this tool to create
+the required directories recursively for the new file.`,
+            isError: true,
+        };
+    }
+    const parentDir = path_1.default.dirname(absoluteFilePath);
+    if (parentDir !== "." && !fs_1.default.existsSync(parentDir)) {
+        // Ensure parent directory exists
+        fs_1.default.mkdirSync(parentDir, { recursive: true });
+    }
+    fs_1.default.writeFileSync(absoluteFilePath, input.file_text);
+    let createTypescriptResult = await (0, web_1.runTypescriptCompiler)(repoDir);
+    if (!createTypescriptResult.success) {
+        return {
+            result: `File ${filePath} has been created. However, type checks are failing with errors:\n\n${createTypescriptResult.errors.join("\n")}`,
+            isError: true,
+        };
+    }
+    else {
+        return {
+            result: `Successfully created file ${filePath}`,
+            isError: false,
+        };
     }
-    return cleanedCount;
 }
-function escapeRegExp(text) {
-    return text.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
+async function fileStrReplaceExecutor({ input, filePath, absoluteFilePath, repoDir, }) {
+    if (!fs_1.default.existsSync(absoluteFilePath)) {
+        return {
+            result: `Error: File ${filePath} not found. Please provide relative file path to the Repository.`,
+            isError: true,
+        };
+    }
+    if (!input.old_str) {
+        return {
+            result: "Error: old_str is required for str_replace command",
+            isError: true,
+        };
+    }
+    if (input.new_str === undefined || input.new_str === null) {
+        // "" is valid as new_str, so we check for nullish -- not falsy
+        return {
+            result: "Error: new_str is required for str_replace command",
+            isError: true,
+        };
+    }
+    const content = fs_1.default.readFileSync(absoluteFilePath, "utf8");
+    // Normalize newlines in both the content and search string
+    const normalizedContent = content.replace(/\r\n/g, "\n");
+    const normalizedOldStr = input.old_str
+        .replace(/\\n/g, "\n")
+        .replace(/\r\n/g, "\n");
+    if (!normalizedContent.includes(normalizedOldStr)) {
+        return {
+            result: `old_str not found in file: ${filePath}`,
+            isError: true,
+        };
+    }
+    else {
+        const escapedOldStr = escapeRegExp(normalizedOldStr);
+        const occurences = normalizedContent.match(new RegExp(escapedOldStr, "g"));
+        if (occurences && occurences.length > 1) {
+            const uniqueContexts = getUniqueOccurences(content, input.old_str);
+            if (uniqueContexts.length === 0) {
+                return {
+                    result: `Error: old_str found ${occurences.length} times in file: ${filePath}, but no unique contexts could be identified. Try using a more specific string.`,
+                    isError: true,
+                };
+            }
+            const uniqueContextsString = uniqueContexts
+                .map(({ uniqueContext, lineNumber }, idx) => `${idx + 1}. For occurence at line number ${lineNumber}, unique context is:\n\`\`\`\n${uniqueContext}\n\`\`\`\n`)
+                .join("\n");
+            return {
+                result: `Error: old_str found ${occurences.length} times in file: ${filePath}. Please use one of these unique contexts instead:\n\n${uniqueContextsString}`,
+                isError: true,
+            };
+        }
+        const newContent = normalizedContent.replace(normalizedOldStr, input.new_str);
+        fs_1.default.writeFileSync(absoluteFilePath, newContent);
+        let strReplaceTypescriptResult = await (0, web_1.runTypescriptCompiler)(repoDir);
+        if (!strReplaceTypescriptResult.success) {
+            return {
+                result: `Edits to file ${filePath} have been applied. However, type checks are failing with errors:\n\n${strReplaceTypescriptResult.errors.join("\n")}`,
+                isError: true,
+            };
+        }
+        else {
+            return {
+                result: `Edits to file ${filePath} have been applied. Type checks have also passed.`,
+                isError: false,
+            };
+        }
+    }
+}
+async function fileInsertExecutor({ input, filePath, absoluteFilePath, repoDir, }) {
+    if (!fs_1.default.existsSync(absoluteFilePath)) {
+        return {
+            result: `Error: File ${filePath} not found. Please provide relative file path to the Repository.`,
+            isError: true,
+        };
+    }
+    if (input.insert_line === undefined || !input.new_str) {
+        return {
+            result: "Error: insert_line and new_str are required for insert command",
+            isError: true,
+        };
+    }
+    const content = fs_1.default.readFileSync(absoluteFilePath, "utf8");
+    const lines = content.split("\n");
+    if (input.insert_line < 1) {
+        return {
+            result: "Error: insert_line must be greater than or equal to 1 (line numbers are 1-indexed).",
+            isError: true,
+        };
+    }
+    if (input.insert_line > lines.length + 1) {
+        return {
+            result: `Error: The file at ${filePath} has only ${lines.length} lines, so insert_line must be less than or equal to ${lines.length + 1}. At the maximum value of ${lines.length + 1}, you can insert at the end of the file.`,
+            isError: true,
+        };
+    }
+    lines.splice(input.insert_line - 1, 0, input.new_str);
+    fs_1.default.writeFileSync(absoluteFilePath, lines.join("\n"));
+    let insertTypescriptResult = await (0, web_1.runTypescriptCompiler)(repoDir);
+    if (!insertTypescriptResult.success) {
+        return {
+            result: `Insertion in file ${filePath} was applied. However, type checks are failing with errors:\n${insertTypescriptResult.errors.join("\n")}`,
+            isError: true,
+        };
+    }
+    else {
+        return {
+            result: `Insertion in file ${filePath} was applied. Type checks have also passed.`,
+            isError: false,
+        };
+    }
 }
 /**
  * Our implementation of Claude's built-in text editor tool
  * https://docs.anthropic.com/en/docs/build-with-claude/tool-use/text-editor-tool
  */
-async function strReplaceEditorExecutor(input, repoPath) {
+async function strReplaceEditorExecutor({ input, repoPath, }) {
     const repoDir = repoPath;
     const { path: filePath } = input;
     const absoluteFilePath = path_1.default.join(repoDir, filePath);
     try {
-        let content;
-        let lines;
-        let newContent;
         switch (input.command) {
             case "view":
-                if (!fs_1.default.existsSync(absoluteFilePath)) {
-                    return {
-                        result: "Error: File not found",
-                        isError: true,
-                    };
-                }
-                // Handle directory view
-                if (fs_1.default.statSync(absoluteFilePath).isDirectory()) {
-                    const files = fs_1.default.readdirSync(absoluteFilePath);
-                    return {
-                        result: files.join("\n"),
-                        isError: false,
-                    };
-                }
-                else {
-                    // Check if file is binary, which is not supported
-                    const { isBinary } = await import("istextorbinary");
-                    const binary = isBinary(absoluteFilePath);
-                    if (binary) {
-                        return {
-                            result: "Error: File is binary, which is not supported",
-                            isError: true,
-                        };
-                    }
-                }
-                // Handle file view
-                content = fs_1.default.readFileSync(absoluteFilePath, "utf8");
-                lines = content.split("\n");
-                if (input.view_range) {
-                    const [start, end] = input.view_range;
-                    const endLine = end === -1 ? lines.length : end;
-                    return {
-                        result: lines
-                            .slice(start - 1, endLine)
-                            .map((line, idx) => `${start + idx}: ${line}`)
-                            .join("\n"),
-                        isError: false,
-                    };
-                }
-                return {
-                    result: lines.map((line, idx) => `${idx + 1}: ${line}`).join("\n"),
-                    isError: false,
-                };
+                return fileViewExecutor({ input, filePath, absoluteFilePath });
             case "create":
-                if (input.file_text === undefined || input.file_text === null) {
-                    throw new Error("file_text is required for create command");
-                }
-                if (filePath.endsWith("test.ts")) {
-                    throw new Error("Creating test.ts files is not allowed. Did you mean spec.ts?");
-                }
-                if (filePath.endsWith("spec.ts") && !filePath.startsWith("tests/")) {
-                    throw new Error("Creating spec.ts files is not allowed outside tests/ directory");
-                }
-                const parentDir = path_1.default.dirname(absoluteFilePath);
-                if (parentDir !== "." && !fs_1.default.existsSync(parentDir)) {
-                    // Ensure parent directory exists
-                    fs_1.default.mkdirSync(parentDir, { recursive: true });
-                }
-                fs_1.default.writeFileSync(absoluteFilePath, input.file_text);
-                let createTypescriptResult = await (0, web_1.runTypescriptCompiler)(repoDir);
-                if (!createTypescriptResult.success) {
-                    return {
-                        result: `File ${filePath} has been created. However, type checks are failing with errors:\n${createTypescriptResult.errors.join("\n")}`,
-                        isError: true,
-                    };
-                }
-                return {
-                    result: `Successfully created file ${filePath}`,
-                    isError: false,
-                };
+                return fileCreateExecutor({
+                    input,
+                    filePath,
+                    absoluteFilePath,
+                    repoDir,
+                });
             case "str_replace":
-                if (!input.old_str) {
-                    throw new Error("old_str is required for str_replace command");
-                }
-                if (input.new_str === undefined || input.new_str === null) {
-                    // "" is valid as new_str, so we check for nullish -- not falsy
-                    throw new Error("new_str is required for str_replace command");
-                }
-                createBackup(absoluteFilePath);
-                content = fs_1.default.readFileSync(absoluteFilePath, "utf8");
-                // Normalize newlines in both the content and search string
-                const normalizedContent = content.replace(/\r\n/g, "\n");
-                const normalizedOldStr = input.old_str
-                    .replace(/\\n/g, "\n")
-                    .replace(/\r\n/g, "\n");
-                if (!normalizedContent.includes(normalizedOldStr)) {
-                    return {
-                        result: `old_str not found in file: ${filePath}`,
-                        isError: true,
-                    };
-                }
-                else {
-                    const escapedOldStr = escapeRegExp(normalizedOldStr);
-                    const occurences = normalizedContent.match(new RegExp(escapedOldStr, "g"));
-                    if (occurences && occurences.length > 1) {
-                        const uniqueContexts = getUniqueOccurences(content, input.old_str);
-                        if (uniqueContexts.length === 0) {
-                            return {
-                                result: `Error: old_str found ${occurences.length} times in file: ${filePath}, but no unique contexts could be identified. Try using a more specific string.`,
-                                isError: true,
-                            };
-                        }
-                        const uniqueContextsString = uniqueContexts
-                            .map(({ uniqueContext, lineNumber }, idx) => `${idx + 1}. For occurence at line number ${lineNumber}, unique context is:\n\`\`\`\n${uniqueContext}\n\`\`\`\n`)
-                            .join("\n");
-                        return {
-                            result: `Error: old_str found ${occurences.length} times in file: ${filePath}. Please use one of these unique contexts instead:\n\n${uniqueContextsString}`,
-                            isError: true,
-                        };
-                    }
-                    newContent = normalizedContent.replace(normalizedOldStr, input.new_str);
-                    fs_1.default.writeFileSync(absoluteFilePath, newContent);
-                    let strReplaceTypescriptResult = await (0, web_1.runTypescriptCompiler)(repoDir);
-                    if (!strReplaceTypescriptResult.success) {
-                        return {
-                            result: `Edits to file ${filePath} have been applied. However, type checks are failing with errors:\n${strReplaceTypescriptResult.errors.join("\n")}`,
-                            isError: true,
-                        };
-                    }
-                    else {
-                        return {
-                            result: `Edits to file ${filePath} have been applied. Type checks have also passed.`,
-                            isError: false,
-                        };
-                    }
-                }
+                return fileStrReplaceExecutor({
+                    input,
+                    filePath,
+                    absoluteFilePath,
+                    repoDir,
+                });
             case "insert":
-                if (input.insert_line === undefined || !input.new_str) {
-                    throw new Error("insert_line and new_str are required for insert command");
-                }
-                createBackup(absoluteFilePath);
-                content = fs_1.default.readFileSync(absoluteFilePath, "utf8");
-                lines = content.split("\n");
-                if (input.insert_line < 1) {
-                    throw new Error("insert_line must be greater than or equal to 1 (line numbers are 1-indexed).");
-                }
-                if (input.insert_line > lines.length + 1) {
-                    throw new Error(`The file at ${filePath} has only ${lines.length} lines, so insert_line must be less than or equal to ${lines.length + 1}. At the maximum value of ${lines.length + 1}, you can insert at the end of the file.`);
-                }
-                lines.splice(input.insert_line - 1, 0, input.new_str);
-                fs_1.default.writeFileSync(absoluteFilePath, lines.join("\n"));
-                let insertTypescriptResult = await (0, web_1.runTypescriptCompiler)(repoDir);
-                if (!insertTypescriptResult.success) {
-                    return {
-                        result: `Insertion in file ${filePath} was applied. However, type checks are failing with errors:\n${insertTypescriptResult.errors.join("\n")}`,
-                        isError: true,
-                    };
-                }
-                else {
-                    return {
-                        result: `Insertion in file ${filePath} was applied. Type checks have also passed.`,
-                        isError: false,
-                    };
-                }
+                return fileInsertExecutor({
+                    input,
+                    filePath,
+                    absoluteFilePath,
+                    repoDir,
+                });
             case "undo_edit":
-                if (hasBackup(absoluteFilePath)) {
-                    restoreBackup(absoluteFilePath);
-                    return {
-                        result: `Successfully restored ${filePath} from backup`,
-                        isError: false,
-                    };
-                }
                 return {
-                    result: `No backup file found for ${filePath}`,
+                    result: `undo_edit tool is not supported.`,
                     isError: true,
                 };
             default:
@@ -343,28 +340,37 @@ File contents are returned with line numbers, starting from 1.
             path: zod_1.z.string().describe("The path to the file or directory to view."),
         }),
     },
-    execute: async (input, repoPath) => {
+    execute: async ({ input, repoPath, }) => {
         return strReplaceEditorExecutor({
-            command: "view",
-            path: input.path,
-        }, repoPath);
+            input: {
+                command: "view",
+                path: input.path,
+            },
+            repoPath,
+        });
     },
 };
 const fileCreateTool = {
     schema: {
         name: "fileCreateTool",
-        description: "A tool to create a new file with given contents.",
+        description: `A tool to create a new file with given contents.
+This tool will also create parent directories that do not exist.
+For example, for path "tests/example/foo.spec.ts", the tool will create
+directories "tests", "tests/example", and "tests/example/foo.spec.ts".`,
         parameters: zod_1.z.object({
             path: zod_1.z.string().describe("The path to the new file."),
             file_text: zod_1.z.string().describe("The contents of the new file."),
         }),
     },
-    execute: async (input, repoPath) => {
+    execute: async ({ input, repoPath, }) => {
         return strReplaceEditorExecutor({
-            command: "create",
-            path: input.path,
-            file_text: input.file_text,
-        }, repoPath);
+            input: {
+                command: "create",
+                path: input.path,
+                file_text: input.file_text,
+            },
+            repoPath,
+        });
     },
 };
 const stringReplaceTool = {
@@ -378,13 +384,16 @@ in the file. If old_str is not unique, the tool will return an error.`,
             new_str: zod_1.z.string().describe("The string to replace old_str with."),
         }),
     },
-    execute: async (input, repoPath) => {
+    execute: async ({ input, repoPath, }) => {
         return strReplaceEditorExecutor({
-            command: "str_replace",
-            path: input.path,
-            old_str: input.old_str,
-            new_str: input.new_str,
-        }, repoPath);
+            input: {
+                command: "str_replace",
+                path: input.path,
+                old_str: input.old_str,
+                new_str: input.new_str,
+            },
+            repoPath,
+        });
     },
 };
 const stringInsertTool = {
@@ -403,13 +412,16 @@ To insert a string at the end of the file, you should use insert_line = (total l
             new_str: zod_1.z.string().describe("The string to insert."),
         }),
     },
-    execute: async (input, repoPath) => {
+    execute: async ({ input, repoPath, }) => {
         return strReplaceEditorExecutor({
-            command: "insert",
-            path: input.path,
-            insert_line: input.insert_line,
-            new_str: input.new_str,
-        }, repoPath);
+            input: {
+                command: "insert",
+                path: input.path,
+                insert_line: input.insert_line,
+                new_str: input.new_str,
+            },
+            repoPath,
+        });
     },
 };
 exports.textEditorTools = [

package/dist/tools/test-gen-browser.d.ts

@@ -1,3 +1,3 @@
-import type { Tool } from "@empiricalrun/llm/chat";
+import { Tool } from "@empiricalrun/shared-types";
 export declare const generateTestWithBrowserAgent: Tool;
 //# sourceMappingURL=test-gen-browser.d.ts.map

package/dist/tools/test-gen-browser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"test-gen-browser.d.ts","sourceRoot":"","sources":["../../src/tools/test-gen-browser.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,wBAAwB,CAAC;AA2FnD,eAAO,MAAM,4BAA4B,EAAE,IA8G1C,CAAC"}
+{"version":3,"file":"test-gen-browser.d.ts","sourceRoot":"","sources":["../../src/tools/test-gen-browser.ts"],"names":[],"mappings":"AACA,OAAO,EAAoB,IAAI,EAAE,MAAM,4BAA4B,CAAC;AAmGpE,eAAO,MAAM,4BAA4B,EAAE,IAwI1C,CAAC"}