@empiricalrun/test-gen 0.73.0 → 0.74.0

package/dist/tools/str_replace_editor.js

@@ -1,429 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.textEditorTools = void 0;
-exports.strReplaceEditorExecutor = strReplaceEditorExecutor;
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-const web_1 = require("../bin/utils/platform/web");
-const str_replace_editor_1 = require("./definitions/str_replace_editor");
-const git_1 = require("./executor/utils/git");
-/**
- * Helper function to collect git patch artifacts for file modifications
- */
-async function collectGitPatchArtifact(filePath, repoDir, operation, collectArtifacts) {
-    if (!collectArtifacts)
-        return;
-    try {
-        const gitPatch = operation === "create"
-            ? (0, git_1.getGitDiffForNewFile)(filePath, repoDir)
-            : (0, git_1.getGitDiff)(filePath, repoDir);
-        if (gitPatch.trim()) {
-            const patchArtifact = {
-                name: `${path_1.default.basename(filePath, path_1.default.extname(filePath))}_${operation}.patch`,
-                contentType: "text/plain",
-                data: Buffer.from(gitPatch, "utf-8"),
-            };
-            collectArtifacts([patchArtifact]);
-        }
-    }
-    catch (error) {
-        // Ignore git diff errors, don't fail the operation
-        console.warn(`Failed to generate git patch for ${filePath}:`, error);
-    }
-}
-/**
- * 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
- * message to the LLM is more informative, enabling it to pick a unique old_str in the next attempt.
- */
-function getUniqueOccurences(contents, old_str) {
-    const lines = contents.split("\n");
-    const lineIndices = [];
-    lines.forEach((line, index) => {
-        if (line.includes(old_str)) {
-            lineIndices.push(index);
-        }
-    });
-    if (lineIndices.length === 0) {
-        return [];
-    }
-    if (lineIndices.length == 1) {
-        // line number should be 1-indexed, hence we add 1 to the line index
-        return [{ uniqueContext: old_str, lineNumber: lineIndices[0] + 1 }];
-    }
-    const uniqueContexts = [];
-    const maxContextSize = Math.min(10, lines.length);
-    for (const lineIndex of lineIndices) {
-        let contextSize = 0; // Start with just the line itself
-        let isUnique = false;
-        let context = "";
-        while (!isUnique && contextSize < maxContextSize) {
-            // Expand context to include more lines (both above and below)
-            const startLine = Math.max(0, lineIndex - contextSize);
-            const endLine = Math.min(lines.length - 1, lineIndex + contextSize);
-            // Extract the context as a group of lines
-            context = lines.slice(startLine, endLine + 1).join("\n");
-            // Check if this context is unique among all occurrences
-            isUnique = lineIndices.every((idx) => {
-                if (idx === lineIndex)
-                    return true; // Skip self
-                const otherStartLine = Math.max(0, idx - contextSize);
-                const otherEndLine = Math.min(lines.length - 1, idx + contextSize);
-                const otherContext = lines
-                    .slice(otherStartLine, otherEndLine + 1)
-                    .join("\n");
-                return context !== otherContext;
-            });
-            // If not unique, expand context by one more line in each direction
-            if (!isUnique) {
-                contextSize++;
-            }
-        }
-        // Only add context if we actually found a unique one
-        if (isUnique) {
-            uniqueContexts.push({
-                uniqueContext: context,
-                lineNumber: lineIndex + 1,
-            });
-        }
-    }
-    return uniqueContexts;
-}
-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,
-    };
-}
-async function fileCreateExecutor({ input, filePath, absoluteFilePath, repoDir, collectArtifacts, }) {
-    if (input.file_text === undefined || input.file_text === null) {
-        return {
-            result: "Error: file_text is required for create command",
-            isError: true,
-        };
-    }
-    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);
-    // Collect git patch artifact
-    await collectGitPatchArtifact(filePath, repoDir, "create", collectArtifacts);
-    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,
-        };
-    }
-}
-async function fileStrReplaceExecutor({ input, filePath, absoluteFilePath, repoDir, collectArtifacts, }) {
-    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);
-        // Collect git patch artifact
-        await collectGitPatchArtifact(filePath, repoDir, "replace", collectArtifacts);
-        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, collectArtifacts, }) {
-    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"));
-    // Collect git patch artifact
-    await collectGitPatchArtifact(filePath, repoDir, "insert", collectArtifacts);
-    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, collectArtifacts, }) {
-    const repoDir = repoPath;
-    const { path: filePath } = input;
-    const absoluteFilePath = path_1.default.join(repoDir, filePath);
-    try {
-        switch (input.command) {
-            case "view":
-                return fileViewExecutor({ input, filePath, absoluteFilePath });
-            case "create":
-                return fileCreateExecutor({
-                    input,
-                    filePath,
-                    absoluteFilePath,
-                    repoDir,
-                    collectArtifacts,
-                });
-            case "str_replace":
-                return fileStrReplaceExecutor({
-                    input,
-                    filePath,
-                    absoluteFilePath,
-                    repoDir,
-                    collectArtifacts,
-                });
-            case "insert":
-                return fileInsertExecutor({
-                    input,
-                    filePath,
-                    absoluteFilePath,
-                    repoDir,
-                    collectArtifacts,
-                });
-            case "undo_edit":
-                return {
-                    result: `undo_edit tool is not supported.`,
-                    isError: true,
-                };
-            default:
-                throw new Error(`Unknown command: ${input.command}`);
-        }
-    }
-    catch (error) {
-        return {
-            result: error instanceof Error ? error.message : "Unknown error occurred",
-            isError: true,
-        };
-    }
-}
-const fileViewTool = {
-    ...str_replace_editor_1.textEditorTools["fileViewTool"],
-    execute: async (params) => {
-        const { input } = params;
-        const { repoPath } = params;
-        return strReplaceEditorExecutor({
-            input: {
-                command: "view",
-                path: input.path,
-            },
-            repoPath,
-        });
-    },
-};
-const fileCreateTool = {
-    ...str_replace_editor_1.textEditorTools["fileCreateTool"],
-    execute: async (params) => {
-        const { input } = params;
-        const { repoPath, collectArtifacts } = params;
-        return strReplaceEditorExecutor({
-            input: {
-                command: "create",
-                path: input.path,
-                file_text: input.file_text,
-            },
-            repoPath,
-            collectArtifacts,
-        });
-    },
-};
-const stringReplaceTool = {
-    ...str_replace_editor_1.textEditorTools["stringReplaceTool"],
-    execute: async (params) => {
-        const { input } = params;
-        const { repoPath, collectArtifacts } = params;
-        return strReplaceEditorExecutor({
-            input: {
-                command: "str_replace",
-                path: input.path,
-                old_str: input.old_str,
-                new_str: input.new_str,
-            },
-            repoPath,
-            collectArtifacts,
-        });
-    },
-};
-const stringInsertTool = {
-    ...str_replace_editor_1.textEditorTools["stringInsertTool"],
-    execute: async (params) => {
-        const { input } = params;
-        const { repoPath, collectArtifacts } = params;
-        return strReplaceEditorExecutor({
-            input: {
-                command: "insert",
-                path: input.path,
-                insert_line: input.insert_line,
-                new_str: input.new_str,
-            },
-            repoPath,
-            collectArtifacts,
-        });
-    },
-};
-exports.textEditorTools = [
-    fileViewTool,
-    fileCreateTool,
-    stringReplaceTool,
-    stringInsertTool,
-];