@empiricalrun/playwright-utils 0.22.6 → 0.23.0

package/bundled/test-gen/agent/browsing/run.js

@@ -0,0 +1,88 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateTestsUsingMasterAgent = void 0;
+const detect_port_1 = __importDefault(require("detect-port"));
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const web_1 = require("../../bin/utils/platform/web");
+const server_1 = require("../../file/server");
+const exec_1 = require("../../utils/exec");
+const utils_1 = require("./utils");
+/**
+ *
+ * Function to generate tests using master agent
+ * @export
+ * @param {GenerateTestsType} {
+ *   testFilePath,
+ *   filePathToUpdate,
+ * }
+ */
+async function generateTestsUsingMasterAgent({ testFilePath, filePathToUpdate, pwProjectsFilter, testGenToken, repoDir, }) {
+    // valiate if the file path and file to update are valid
+    // also warn users if they are on older version of test-gen
+    (0, utils_1.canRunMasterAgent)(testFilePath);
+    // detect available http port on the machine
+    const port = await (0, detect_port_1.default)(3030);
+    // start a file service to handle file updates from agent
+    // - also update the file path with updates when agent is done spitting out code
+    const fileService = new server_1.FileService({ port, repoDir });
+    await fileService.startFileService();
+    fileService.setFilePath(filePathToUpdate);
+    // read playwright config from ./playwright.config.ts of source repo
+    const playwrightConfig = await (0, utils_1.readPlaywrightConfig)(repoDir);
+    // detect the playwright project name for the given test file and playwright config
+    const project = await (0, utils_1.detectProjectName)(testFilePath, playwrightConfig, pwProjectsFilter);
+    const pageVar = await (0, web_1.getPageVariableNameFromCreateTest)(filePathToUpdate);
+    console.log(`Detected playwright project name: ${project}`);
+    // run playwright test which will internally run the master agent
+    const teardownFileRegex = /.*\.teardown\.ts/;
+    const testsDirectory = `${repoDir}/tests`;
+    const isTestRunTriggeredForTeardown = teardownFileRegex.test(testFilePath);
+    const teardowns = new utils_1.TeardownManager(testsDirectory);
+    if (!isTestRunTriggeredForTeardown) {
+        await teardowns.skipAll();
+    }
+    const command = `npx playwright test ${testFilePath} --retries 0 --project ${project} --timeout 0 --headed`;
+    let isError = false, error = "";
+    try {
+        await (0, exec_1.cmd)(command.split(" "), {
+            env: {
+                APP_PORT: port.toString(),
+                PW_TEST_HTML_REPORT_OPEN: "never",
+                // pass the test gen token so that the agent has the same configuration as cli
+                TEST_GEN_TOKEN: testGenToken,
+                PAGE_VAR_NAME: pageVar || "page",
+                DISPLAY: ":99",
+            },
+        });
+    }
+    catch (e) {
+        error = `Failed to generate test using master agent ${e}`;
+        console.error(error);
+        isError = true;
+    }
+    if (!isTestRunTriggeredForTeardown) {
+        teardowns.unskipAll();
+    }
+    // clean up the file if there is any error
+    if (isError) {
+        try {
+            const fileContent = await fs_extra_1.default.readFile(filePathToUpdate, "utf-8");
+            const updatedContent = (0, web_1.replaceCreateTestWithNewCode)(filePathToUpdate, fileContent, "");
+            await fs_extra_1.default.writeFile(filePathToUpdate, updatedContent, "utf-8");
+            await (0, web_1.lintErrors)(filePathToUpdate);
+        }
+        catch (e) {
+            console.error("Failed to remove extra scripts from files post test gen error", e);
+        }
+    }
+    // remove the test only from the file
+    await (0, web_1.removeTestOnly)(testFilePath);
+    if (isError) {
+        // throw the error because of which test gen failed
+        throw Error(error);
+    }
+}
+exports.generateTestsUsingMasterAgent = generateTestsUsingMasterAgent;

package/bundled/test-gen/agent/browsing/utils.d.ts

@@ -0,0 +1,41 @@
+import { TraceClient } from "@empiricalrun/llm";
+import type { TestGenConfig } from "@empiricalrun/shared-types";
+import { Page } from "playwright";
+import { PlaywrightTestConfig } from "playwright/test";
+export declare function isRegExp(obj: any): obj is RegExp;
+export declare function prepareBrowsingAgentTask(steps: string[]): string;
+/**
+ * Function to prepare test file for master agent to run
+ * @param {TestGenConfig} genConfig
+ * @return {*}  {Promise<string>}
+ */
+export declare function prepareFileForMasterAgent(genConfig: TestGenConfig, trace?: TraceClient): Promise<string>;
+export declare function injectPwLocatorGenerator(page: Page): Promise<void>;
+/**
+ * Function to validate if the test file path are valid.
+ * @throws if there are any missing dependencies for master agent to run.
+ * @param {string} filePath
+ */
+export declare function canRunMasterAgent(filePath: string): void;
+/**
+ * function to read playwright config from the source repo
+ * @return {*}  {Promise<PlaywrightTestConfig>}
+ */
+export declare function readPlaywrightConfig(repoDir: string): Promise<PlaywrightTestConfig>;
+/**
+ * detect the project name for the given file in playwright test repo
+ * if project and test file path for running test don't match, then playwright throws error
+ * @param testFilePath
+ * @returns
+ */
+export declare function detectProjectName(testFilePath: string, playwrightConfig: PlaywrightTestConfig, pwProjectsFilter?: string[]): Promise<string>;
+export declare class TeardownManager {
+    private directory;
+    constructor(directory: string);
+    private teardownFiles;
+    private getAllTeardownFiles;
+    private skipTeardownFile;
+    skipAll(): Promise<void>;
+    unskipAll(): void;
+}
+//# sourceMappingURL=utils.d.ts.map

package/bundled/test-gen/agent/browsing/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/agent/browsing/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,KAAK,EAAe,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAI7E,OAAO,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAClC,OAAO,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAsBvD,wBAAgB,QAAQ,CAAC,GAAG,EAAE,GAAG,GAAG,GAAG,IAAI,MAAM,CAKhD;AAED,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,MAAM,EAAE,UAIvD;AA8FD;;;;GAIG;AACH,wBAAsB,yBAAyB,CAC7C,SAAS,EAAE,aAAa,EACxB,KAAK,CAAC,EAAE,WAAW,GAClB,OAAO,CAAC,MAAM,CAAC,CA0DjB;AAyBD,wBAAsB,wBAAwB,CAAC,IAAI,EAAE,IAAI,iBA2HxD;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,QAIjD;AAED;;;GAGG;AACH,wBAAsB,oBAAoB,CACxC,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,oBAAoB,CAAC,CAM/B;AAWD;;;;;GAKG;AACH,wBAAsB,iBAAiB,CACrC,YAAY,EAAE,MAAM,EACpB,gBAAgB,EAAE,oBAAoB,EACtC,gBAAgB,GAAE,MAAM,EAAU,GACjC,OAAO,CAAC,MAAM,CAAC,CA+CjB;AAED,qBAAa,eAAe;IACd,OAAO,CAAC,SAAS;gBAAT,SAAS,EAAE,MAAM;IACrC,OAAO,CAAC,aAAa,CAAqB;YAE5B,mBAAmB;YAUnB,gBAAgB;IAsBjB,OAAO;IAuBb,SAAS;CAKjB"}

package/bundled/test-gen/agent/browsing/utils.js

@@ -0,0 +1,406 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TeardownManager = exports.detectProjectName = exports.readPlaywrightConfig = exports.canRunMasterAgent = exports.injectPwLocatorGenerator = exports.prepareFileForMasterAgent = exports.prepareBrowsingAgentTask = exports.isRegExp = void 0;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const minimatch_1 = require("minimatch");
+const path_1 = __importDefault(require("path"));
+const ts_morph_1 = require("ts-morph");
+const api_1 = __importDefault(require("tsx/cjs/api"));
+const logger_1 = require("../../bin/logger");
+const context_1 = require("../../bin/utils/context");
+const fs_1 = require("../../bin/utils/fs");
+const web_1 = require("../../bin/utils/platform/web");
+const create_test_block_1 = require("../codegen/create-test-block");
+const fix_ts_errors_1 = require("../codegen/fix-ts-errors");
+const lexical_scoped_vars_1 = require("../codegen/lexical-scoped-vars");
+const update_flow_1 = require("../codegen/update-flow");
+function isRegExp(obj) {
+    return (obj instanceof RegExp ||
+        Object.prototype.toString.call(obj) === "[object RegExp]");
+}
+exports.isRegExp = isRegExp;
+function prepareBrowsingAgentTask(steps) {
+    const sanitizedSteps = steps.map((step) => step.replace(/`/g, "\\`"));
+    const task = `${sanitizedSteps.join("\n")}\n`;
+    return task;
+}
+exports.prepareBrowsingAgentTask = prepareBrowsingAgentTask;
+/**
+ * Function to prepare test file for update scenarios for master agent to run
+ * @param {TestGenConfig} genConfig
+ */
+async function prepareFileForUpdateScenario(genConfig, trace) {
+    const { specPath, testCase } = genConfig;
+    const { name, suites } = testCase;
+    await (0, web_1.addUserContextFixture)({
+        scenarioName: name,
+        filePath: specPath,
+        suites,
+    });
+    // update the test case with appropriate location for createTest
+    const [suggestion] = await (0, update_flow_1.appendCreateTestBlock)({
+        trace,
+        testCase,
+        file: specPath,
+        validateTypes: false,
+        options: genConfig.options,
+    });
+    const createTestFilePath = suggestion?.updatedFiles[0] || "";
+    console.log("appending to existing test block");
+    console.log("updated test file path", createTestFilePath);
+    const fetchScopeVariablesSpan = trace?.span({
+        name: "fetch-scope-variables",
+        input: {
+            createTestFilePath,
+        },
+    });
+    const scopeVariables = await (0, lexical_scoped_vars_1.getLexicalScopedVars)({
+        file: await fs_extra_1.default.readFile(createTestFilePath, "utf-8"),
+        referencePoint: "await createTest",
+        trace: fetchScopeVariablesSpan,
+    });
+    fetchScopeVariablesSpan?.end({
+        name: "fetch-scope-variables",
+        output: {
+            variables: scopeVariables,
+        },
+    });
+    await (0, web_1.appendScopeToCreateTest)(createTestFilePath, scopeVariables);
+    // extract the createTest function and pass the scoped vars
+    const updateFileSpan = trace?.span({
+        name: "update-file-span",
+        input: {
+            createTestFilePath,
+        },
+    });
+    await fs_extra_1.default.writeFile(createTestFilePath, (0, web_1.addNewImport)(await fs_extra_1.default.readFile(createTestFilePath, "utf-8"), ["createTest"], "@empiricalrun/test-gen"));
+    updateFileSpan?.end();
+    const { pomPrompt, nonSpecFilePrompt } = await (0, context_1.contextForGeneration)(createTestFilePath);
+    await (0, fix_ts_errors_1.validateAndFixTypescriptErrors)({
+        trace,
+        file: createTestFilePath,
+        pomCode: pomPrompt,
+        nonSpecFileCode: nonSpecFilePrompt,
+        testCase: testCase,
+        options: genConfig.options,
+    });
+    const testFileContent = await fs_extra_1.default.readFile(specPath, "utf-8");
+    const { testBlock, testNode } = (0, web_1.getTypescriptTestBlock)({
+        scenarioName: name,
+        content: testFileContent,
+        suites,
+    });
+    const parentDescribe = (0, web_1.findFirstSerialDescribeBlock)(testNode);
+    const isFileMarkedSerial = await (0, web_1.hasTopLevelDescribeConfigureWithSerialMode)(specPath);
+    // add test.only / describe.only to the spec file so that only that block is executed
+    if (!isFileMarkedSerial) {
+        const updatedTestFileContent = newContentsWithTestOnly(testFileContent, testBlock, testBlock, parentDescribe?.getText() || "");
+        await fs_extra_1.default.writeFile(specPath, updatedTestFileContent);
+    }
+    return createTestFilePath;
+}
+/**
+ * Function to prepare test file for master agent to run
+ * @param {TestGenConfig} genConfig
+ * @return {*}  {Promise<string>}
+ */
+async function prepareFileForMasterAgent(genConfig, trace) {
+    const prepareFileSpan = trace?.span({
+        name: "prepare-file-for-master-agent",
+    });
+    new logger_1.CustomLogger({ useReporter: true }).log(`Preparing file for master agent. [view trace](${trace?.getTraceUrl()})`);
+    const { specPath, testCase } = genConfig;
+    const { name, suites } = testCase;
+    // check if the spec file exists
+    // if no then create a new file with test and expect imports
+    if (!fs_extra_1.default.existsSync(specPath)) {
+        const fileCreateSpan = prepareFileSpan?.span({
+            name: "create-file",
+            input: { specPath },
+        });
+        await fs_extra_1.default.createFile(specPath);
+        const fileContentWithImports = (0, web_1.addNewImport)("", ["test", "expect"], (0, web_1.getFixtureImportPath)(specPath));
+        await fs_extra_1.default.writeFile(specPath, fileContentWithImports, "utf-8");
+        fileCreateSpan?.end({ output: { specPath, fileContentWithImports } });
+    }
+    const existingContents = await fs_extra_1.default.readFile(specPath, "utf-8");
+    const { testBlock } = (0, web_1.getTypescriptTestBlock)({
+        scenarioName: name,
+        suites,
+        content: existingContents,
+    });
+    if (!testBlock) {
+        const newTestBlock = await (0, create_test_block_1.createEmptyTestCaseBlock)({
+            trace: prepareFileSpan,
+            testCase: genConfig.testCase,
+            file: specPath,
+            options: genConfig.options,
+        });
+        await fs_extra_1.default.writeFile(specPath, `${existingContents} \n\n ${newTestBlock}`, "utf-8");
+        const updatedContent = (0, web_1.injectCodeSnippetBySuiteChain)({
+            testFileContent: existingContents,
+            suites: testCase.suites,
+            codeSnippet: `\n\n${newTestBlock}`,
+        });
+        await fs_extra_1.default.writeFile(specPath, updatedContent, "utf-8");
+    }
+    const updatePath = await prepareFileForUpdateScenario(genConfig, prepareFileSpan);
+    return updatePath;
+}
+exports.prepareFileForMasterAgent = prepareFileForMasterAgent;
+function newContentsWithTestOnly(existingContents, originalTestBlock, updatedTestBlock, parentDescribeBlock) {
+    if (!parentDescribeBlock) {
+        const testMarkedAsOnly = updatedTestBlock.replace("test(", "test.only(");
+        return existingContents.replace(originalTestBlock, testMarkedAsOnly);
+    }
+    else {
+        const updatedDescribeBlock = parentDescribeBlock.replace(originalTestBlock, updatedTestBlock);
+        // TODO: this should only happen when the describe block has "serial" execution
+        const describeMarkedAsOnly = updatedDescribeBlock.replace("test.describe(", "test.describe.only(");
+        return existingContents.replace(parentDescribeBlock, describeMarkedAsOnly);
+    }
+}
+async function injectPwLocatorGenerator(page) {
+    let pathToInstalledTestGen = require.resolve(".").split("dist")[0];
+    // eslint-disable-next-line turbo/no-undeclared-env-vars
+    if (process.env.RUNNING_BROWSER_TESTS_FOR_TEST_GEN) {
+        pathToInstalledTestGen = process.cwd();
+    }
+    const annotateElementPath = path_1.default.join(pathToInstalledTestGen, "dist", "browser-injected-scripts", "annotate-elements.js");
+    if (!fs_extra_1.default.existsSync(annotateElementPath)) {
+        throw new Error(`annotate-elements.js not found at path: ${annotateElementPath}`);
+    }
+    const remoteScriptResponses = await Promise.all([
+        "https://assets-test.empirical.run/pw-selector.js",
+        "https://code.jquery.com/jquery-3.7.1.min.js",
+    ].map((url) => fetch(url)));
+    const scripts = await Promise.all([
+        ...remoteScriptResponses.map((r) => r.text()),
+        fs_extra_1.default.readFile(annotateElementPath, "utf-8"),
+    ]);
+    page.on("load", async () => {
+        try {
+            await Promise.all(scripts.map((s) => page.addScriptTag({ content: s })));
+            await page.evaluate(async () => {
+                //@ts-ignore
+                //https://developer.mozilla.org/en-US/docs/Web/API/TrustedScriptURL
+                const trustedPolicy = window.trustedTypes?.createPolicy(crypto.randomUUID(), {
+                    createScriptURL: (url) => url,
+                });
+                //@ts-ignore
+                const injectScriptInIframe = (iframeDoc) => {
+                    try {
+                        [
+                            "https://assets-test.empirical.run/pw-selector.js",
+                            "https://code.jquery.com/jquery-3.7.1.min.js",
+                        ].forEach((url) => {
+                            const script = iframeDoc.createElement("script");
+                            script.src = trustedPolicy.createScriptURL(url);
+                            iframeDoc.head.appendChild(script);
+                        });
+                    }
+                    catch (e) {
+                        console.warn("Error injecting script in iframe.");
+                    }
+                };
+                const iframes = document.getElementsByTagName("iframe");
+                for (const iframe of iframes) {
+                    iframe.getBoundingClientRect();
+                    const rect = iframe.getBoundingClientRect();
+                    const isVisible = rect.width > 0 && rect.height > 0;
+                    if (isVisible) {
+                        //@ts-ignore
+                        const iframeContent = iframe.contentDocument || iframe.contentWindow?.document;
+                        const isScriptInjected = !!iframe.contentWindow?.playwright;
+                        if (iframeContent && !isScriptInjected) {
+                            injectScriptInIframe(iframeContent);
+                        }
+                    }
+                }
+            });
+        }
+        catch (e) {
+            console.warn("Error during script injection on page load:", e);
+        }
+    });
+    try {
+        await Promise.all(scripts.map((s) => page.addScriptTag({ content: s })));
+        await page.evaluate(async () => {
+            //@ts-ignore
+            const injectScriptInIframe = (iframeDoc) => {
+                try {
+                    //@ts-ignore
+                    //https://developer.mozilla.org/en-US/docs/Web/API/TrustedScriptURL
+                    const trustedPolicy = window.trustedTypes.createPolicy(crypto.randomUUID(), {
+                        createScriptURL: (url) => url,
+                    });
+                    [
+                        "https://assets-test.empirical.run/pw-selector.js",
+                        "https://code.jquery.com/jquery-3.7.1.min.js",
+                    ].forEach((url) => {
+                        const scr = iframeDoc.createElement("script");
+                        scr.src = trustedPolicy.createScriptURL(url);
+                        iframeDoc.head.appendChild(scr);
+                    });
+                }
+                catch (e) {
+                    console.warn("Error injecting script in iframe.");
+                }
+            };
+            const iframes = document.getElementsByTagName("iframe");
+            for (const iframe of iframes) {
+                iframe.getBoundingClientRect();
+                const rect = iframe.getBoundingClientRect();
+                const isVisible = rect.width > 0 && rect.height > 0;
+                if (isVisible) {
+                    //@ts-ignore
+                    const iframeContent = iframe.contentDocument || iframe.contentWindow?.document;
+                    const isScriptInjected = !!iframe.contentWindow?.playwright;
+                    if (iframeContent && !isScriptInjected) {
+                        injectScriptInIframe(iframeContent);
+                    }
+                }
+            }
+        });
+    }
+    catch (e) {
+        console.warn("Error injecting script in iframe.");
+    }
+}
+exports.injectPwLocatorGenerator = injectPwLocatorGenerator;
+/**
+ * Function to validate if the test file path are valid.
+ * @throws if there are any missing dependencies for master agent to run.
+ * @param {string} filePath
+ */
+function canRunMasterAgent(filePath) {
+    if (!fs_extra_1.default.existsSync(filePath)) {
+        throw new Error(`File for master agent to run not found: ${filePath}`);
+    }
+}
+exports.canRunMasterAgent = canRunMasterAgent;
+/**
+ * function to read playwright config from the source repo
+ * @return {*}  {Promise<PlaywrightTestConfig>}
+ */
+async function readPlaywrightConfig(repoDir) {
+    const [lastDir] = repoDir.split("/").reverse();
+    const playwrightConfig = (await api_1.default.require("./playwright.config.ts", `${repoDir}/${lastDir}`)).default;
+    return playwrightConfig;
+}
+exports.readPlaywrightConfig = readPlaywrightConfig;
+function matchAgainstPattern(pattern, filePathToTest) {
+    if (isRegExp(pattern)) {
+        const regExp = pattern;
+        return regExp.test(filePathToTest);
+    }
+    else {
+        return (0, minimatch_1.minimatch)(filePathToTest, pattern);
+    }
+}
+/**
+ * detect the project name for the given file in playwright test repo
+ * if project and test file path for running test don't match, then playwright throws error
+ * @param testFilePath
+ * @returns
+ */
+async function detectProjectName(testFilePath, playwrightConfig, pwProjectsFilter = ["*"]) {
+    const filePath = testFilePath.replace("./tests/", "");
+    if (!playwrightConfig.projects || playwrightConfig.projects.length === 0) {
+        throw new Error(`No projects found in playwright config.`);
+    }
+    const filteredProjectNames = playwrightConfig.projects
+        .map((p) => {
+        const testIgnore = p.testIgnore;
+        const testMatch = p.testMatch || "**";
+        let ignoreFile = false;
+        if (testIgnore) {
+            if (typeof testIgnore === "string" || isRegExp(testIgnore)) {
+                ignoreFile = matchAgainstPattern(testIgnore, filePath);
+            }
+            else if (typeof testIgnore === "object") {
+                ignoreFile = testIgnore.some((ignore) => matchAgainstPattern(ignore, filePath));
+            }
+        }
+        // if test file path is in ignore list then skip it
+        if (ignoreFile) {
+            return "";
+        }
+        let isMatch = false;
+        if (typeof testMatch === "string" || isRegExp(testMatch)) {
+            isMatch = matchAgainstPattern(testMatch, filePath);
+        }
+        else if (typeof testMatch === "object") {
+            isMatch = testMatch.some((match) => matchAgainstPattern(match, filePath));
+        }
+        if (isMatch && p.use?.defaultBrowserType === "chromium") {
+            return p.name || "";
+        }
+        else {
+            return "";
+        }
+    })
+        .filter((p) => !!p)
+        .filter((p) => pwProjectsFilter.some((f) => matchAgainstPattern(f, p)));
+    if (filteredProjectNames.length === 0) {
+        throw new Error(`No project found for the test file: ${testFilePath} in playwright config.`);
+    }
+    return filteredProjectNames[0];
+}
+exports.detectProjectName = detectProjectName;
+class TeardownManager {
+    directory;
+    constructor(directory) {
+        this.directory = directory;
+    }
+    teardownFiles = [];
+    async getAllTeardownFiles() {
+        const teardownFileRegex = /.*\.teardown\.ts/;
+        const teardownFiles = await (0, fs_1.readFilesInDirectory)(this.directory, (fileName) => teardownFileRegex.test(fileName));
+        return teardownFiles;
+    }
+    async skipTeardownFile(filePath) {
+        const project = new ts_morph_1.Project();
+        const sourceFile = project.addSourceFileAtPath(filePath);
+        sourceFile
+            .getDescendantsOfKind(ts_morph_1.SyntaxKind.CallExpression)
+            .forEach((callExpression) => {
+            const expression = callExpression.getExpression();
+            if (expression.getText() === "teardown") {
+                expression.replaceWithText("teardown.skip");
+            }
+            else if (expression.getText() === "test") {
+                expression.replaceWithText("test.skip");
+            }
+        });
+        // Save the modified file
+        sourceFile.save().catch((error) => {
+            console.error(`Error updating the file: ${filePath}`, error);
+        });
+    }
+    async skipAll() {
+        this.teardownFiles = await this.getAllTeardownFiles();
+        await Promise.all(this.teardownFiles.map(async ({ filePath }) => await this.skipTeardownFile(filePath)));
+        process.on("beforeExit", () => {
+            this.unskipAll();
+        });
+        process.on("exit", () => {
+            this.unskipAll();
+        });
+        process.on("SIGINT", () => {
+            this.unskipAll();
+        });
+        process.on("SIGTERM", () => {
+            this.unskipAll();
+        });
+    }
+    unskipAll() {
+        this.teardownFiles.forEach(({ filePath, content }) => {
+            fs_extra_1.default.writeFileSync(filePath, content, "utf-8");
+        });
+    }
+}
+exports.TeardownManager = TeardownManager;

package/bundled/test-gen/agent/codegen/create-test-block.d.ts

@@ -0,0 +1,9 @@
+import { TraceClient } from "@empiricalrun/llm";
+import type { TestCase, TestGenConfigOptions } from "@empiricalrun/shared-types";
+export declare function createEmptyTestCaseBlock({ testCase, file, options, trace, }: {
+    testCase: TestCase;
+    file: string;
+    options?: TestGenConfigOptions;
+    trace?: TraceClient;
+}): Promise<string | undefined>;
+//# sourceMappingURL=create-test-block.d.ts.map

package/bundled/test-gen/agent/codegen/create-test-block.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-test-block.d.ts","sourceRoot":"","sources":["../../../src/agent/codegen/create-test-block.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,WAAW,EACZ,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EACV,QAAQ,EACR,oBAAoB,EACrB,MAAM,4BAA4B,CAAC;AAcpC,wBAAsB,wBAAwB,CAAC,EAC7C,QAAQ,EACR,IAAI,EACJ,OAAO,EACP,KAAK,GACN,EAAE;IACD,QAAQ,EAAE,QAAQ,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,oBAAoB,CAAC;IAC/B,KAAK,CAAC,EAAE,WAAW,CAAC;CACrB,+BAqDA"}

package/bundled/test-gen/agent/codegen/create-test-block.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEmptyTestCaseBlock = void 0;
+const llm_1 = require("@empiricalrun/llm");
+const logger_1 = require("../../bin/logger");
+const context_1 = require("../../bin/utils/context");
+const web_1 = require("../../bin/utils/platform/web");
+const constants_1 = require("../../constants");
+const promptTemplate_0 = "{{#section \"system\"}}\nYou are a software test engineer who is given a task to write an empty test block.\nBased on the inputs you need to create an empty playwright test block with correctly imported fixture.\n\nThe test will contain a test name which you will need to use to build the empty test case block.\n\nYou will be provided with current tests, fixtures and page object models for you to use and create test case block as\nper the task provided to you.\n\nBefore responding you need to ensure that the code change is minimal and the change is reusable across tests. You need\nto ensure the code follows DRY principle.\n\nHere is the list of current tests and fixtures:\n\n{{testFiles}}\n\nHere is the list of current page object models:\n\n{{pageFiles}}\n{{/section}}\n\n{{#section \"user\"}}\nFollowing is the test scenario for which you need to write the empty test case block:\ntest name:\n{{scenarioName}}\n\ntask:\ncreate an empty test case block for the following test steps:\n{{scenario}}\n\ntest file path: {{scenarioFile}}\n\n------\n\nYou also need to ensure that the empty test case block has a starting page to begin test.\n\nIn order to identify the right page with which the test should start, follow the steps:\n- based on the similarities with other test cases mentioned in the file, identify the right page fixture to be imported\n- Read the page fixture methods step by step. Identify whether the fixture handles navigating to a page.\n- Identify whether other tests using the page fixture had to add separate steps for navigation or not\n- Based on the above analysis there will be following cases and choose either for the given test scenario:\n-- Case 1: if the test case scenario provided inside the task mentions about page navigation, then use that page\nnavigation. skip other cases if this case is satisfied.\n-- Case 2: refer other test cases which import similar fixtures and infer the first page navigation of this test case.\nYou should prefer tests which are in the same file. Tests within same file have higher overlaps in first page\nnavigation.\n- Once the page fixture is decided, look for userContext fixture in files. If its available then add \"userContext\" to\nthe test case block\n\n\n\nFollow these instructions before responding with output:\n- Read the code line by line and achieve the task provided to you\n- Read the dependencies of the code block by scanning through file paths and file provided to you. refer the same file\npath while responding with update\n- Focus only on the test case provided and associated JS methods called from the test case.\n- Respond only with the new empty test case block to be created and nothing else.\n- DO NOT respond with any backticks or markdown syntax\n- If \"userContext\" fixture is available in fixtures file, ensure importing that fixture in the test case block.\n- Provide a reason based on the test steps provided to you on why you chose the fixture or page.goto statement. The\nreason should be one of the list steps provided to you and mention why the case was chosen\n{{/section}}";
+const session_1 = require("../../session");
+async function createEmptyTestCaseBlock({ testCase, file, options, trace, }) {
+    const logger = new logger_1.CustomLogger({ useReporter: false });
+    logger.log("Creating new test block");
+    const context = await (0, context_1.contextForGeneration)(file);
+    // TODO: move this to a common place
+    const session = (0, session_1.getSessionDetails)();
+    trace =
+        trace ||
+            llm_1.langfuseInstance?.trace({
+                name: "create-empty-test-block",
+                id: crypto.randomUUID(),
+                release: session.version,
+                tags: [
+                    options?.metadata.projectName || "",
+                    options?.metadata.environment || "",
+                ].filter((s) => !!s),
+            });
+    const promptSpan = trace?.span({
+        name: "build-create-empty-test-case-prompt",
+    });
+    const prompt = (0, llm_1.compilePrompt)(promptTemplate_0, {
+        testFiles: context.codePrompt,
+        pageFiles: context.pomPrompt,
+        scenarioName: testCase.name,
+        scenario: testCase.steps.join("\n"),
+        scenarioFile: file,
+    });
+    promptSpan?.end({ output: { prompt } });
+    const llm = new llm_1.LLM({
+        trace,
+        provider: options?.modelProvider || constants_1.DEFAULT_MODEL_PROVIDER,
+        defaultModel: options?.model || constants_1.DEFAULT_MODEL,
+        providerApiKey: constants_1.MODEL_API_KEYS[options?.modelProvider || constants_1.DEFAULT_MODEL_PROVIDER],
+    });
+    const firstShotMessage = await llm.createChatCompletion({
+        messages: prompt,
+        modelParameters: {
+            ...constants_1.DEFAULT_MODEL_PARAMETERS,
+            ...options?.modelParameters,
+        },
+    });
+    const markdownRemoverSpan = trace?.span({
+        name: "remove-markdown-span",
+    });
+    let response = firstShotMessage?.content || "";
+    markdownRemoverSpan?.end({ output: { response } });
+    const { testBlock } = (0, web_1.getTypescriptTestBlock)({
+        scenarioName: testCase.name,
+        content: response,
+    });
+    return testBlock;
+}
+exports.createEmptyTestCaseBlock = createEmptyTestCaseBlock;

package/bundled/test-gen/agent/codegen/fix-ts-errors.d.ts

@@ -0,0 +1,13 @@
+import { TraceClient } from "@empiricalrun/llm";
+import type { TestCase, TestGenConfigOptions } from "@empiricalrun/shared-types";
+import { CustomLogger } from "../../bin/logger";
+export declare function validateAndFixTypescriptErrors({ trace, logger, file, pomCode, nonSpecFileCode, testCase, options, }: {
+    trace?: TraceClient;
+    logger?: CustomLogger;
+    file: string;
+    pomCode: string;
+    nonSpecFileCode: string;
+    testCase: TestCase;
+    options?: TestGenConfigOptions;
+}): Promise<void>;
+//# sourceMappingURL=fix-ts-errors.d.ts.map

package/bundled/test-gen/agent/codegen/fix-ts-errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fix-ts-errors.d.ts","sourceRoot":"","sources":["../../../src/agent/codegen/fix-ts-errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACpE,OAAO,KAAK,EACV,QAAQ,EACR,oBAAoB,EACrB,MAAM,4BAA4B,CAAC;AAGpC,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAUhD,wBAAsB,8BAA8B,CAAC,EACnD,KAAK,EACL,MAA2B,EAC3B,IAAI,EACJ,OAAO,EACP,eAAe,EACf,QAAQ,EACR,OAAO,GACR,EAAE;IACD,KAAK,CAAC,EAAE,WAAW,CAAC;IACpB,MAAM,CAAC,EAAE,YAAY,CAAC;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,eAAe,EAAE,MAAM,CAAC;IACxB,QAAQ,EAAE,QAAQ,CAAC;IACnB,OAAO,CAAC,EAAE,oBAAoB,CAAC;CAChC,iBAwEA"}