@empiricalrun/test-gen 0.73.0 → 0.74.0

package/dist/tools/upgrade-packages/index.js

@@ -7,26 +7,13 @@ exports.upgradePackagesTool = void 0;
 const child_process_1 = require("child_process");
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
-const zod_1 = require("zod");
+const upgrade_packages_1 = require("../definitions/upgrade-packages");
 const utils_1 = require("../executor/utils");
 const git_1 = require("../executor/utils/git");
 const pr_description_1 = require("../executor/utils/pr-description");
 const utils_2 = require("./utils");
-const packageSpecSchema = zod_1.z.object({
-    name: zod_1.z.string(),
-    version: zod_1.z.string(),
-});
-const upgradePackagesSchema = zod_1.z.object({
-    packages: zod_1.z.array(packageSpecSchema).min(1),
-});
 exports.upgradePackagesTool = {
-    schema: {
-        name: "upgradePackages",
-        description: `This tool can be used to upgrade NPM packages in this repository. To run this tool, specify a list of packages with their names and version strings. At least one package must be specified.
-This tool handles the entire workflow: editing the package.json file, running "npm install", generating lockfile, committing the changes and creating a pull request. For patch updates (e.g., 1.0.1 → 1.0.2), the tool will automatically merge the PR for minor updates. For major updates, the user needs to review the PR and merge it manually.`,
-        parameters: upgradePackagesSchema,
-    },
-    needsBrowser: false,
+    ...upgrade_packages_1.upgradePackagesTool,
     execute: async ({ input, repoPath, apiClient, chatSession }) => {
         const { packages: packagesToUpdate } = input;
         try {
@@ -75,6 +62,9 @@ This tool handles the entire workflow: editing the package.json file, running "n
             let shouldMerge = false;
             let prNumber = null;
             let merged = false;
+            if (!apiClient) {
+                throw new Error("Dashboard API client is not available.");
+            }
             try {
                 const { pr } = await (0, utils_1.findOrCreatePullRequest)({
                     owner: "empirical-run",

package/dist/tools/view-failed-test-run-report/index.d.ts

@@ -0,0 +1,12 @@
+import { Tool } from "@empiricalrun/shared-types";
+import { z } from "zod";
+export declare const ViewFailedTestRunReportSchema: z.ZodObject<{
+    testRunUrl: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    testRunUrl: string;
+}, {
+    testRunUrl: string;
+}>;
+export type ViewFailedTestRunReportInput = z.infer<typeof ViewFailedTestRunReportSchema>;
+export declare const viewFailedTestRunReportTool: Tool;
+//# sourceMappingURL=index.d.ts.map

package/dist/tools/view-failed-test-run-report/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/tools/view-failed-test-run-report/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAc,MAAM,4BAA4B,CAAC;AAE9D,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,eAAO,MAAM,6BAA6B;;;;;;EAExC,CAAC;AAEH,MAAM,MAAM,4BAA4B,GAAG,CAAC,CAAC,KAAK,CAChD,OAAO,6BAA6B,CACrC,CAAC;AAEF,eAAO,MAAM,2BAA2B,EAAE,IAoLzC,CAAC"}

package/dist/tools/view-failed-test-run-report/index.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.viewFailedTestRunReportTool = exports.ViewFailedTestRunReportSchema = void 0;
+// import fs from "fs";
+const zod_1 = require("zod");
+const playwright_report_parser_1 = require("../../utils/playwright-report-parser");
+exports.ViewFailedTestRunReportSchema = zod_1.z.object({
+    testRunUrl: zod_1.z.string().describe("The URL of the test run to process."),
+});
+exports.viewFailedTestRunReportTool = {
+    schema: {
+        name: "viewFailedTestRunReport",
+        description: "View the test run report using its URL. the report only contains information about failed tests.",
+        parameters: exports.ViewFailedTestRunReportSchema,
+    },
+    needsBrowser: false,
+    isInlineTool: true,
+    execute: async ({ input, apiClient }) => {
+        const { testRunUrl } = input;
+        // Remove query parameters if they exist
+        const urlWithoutParams = testRunUrl.split("?")[0] || testRunUrl;
+        // Extract the run ID and repo name from the URL
+        const urlParts = urlWithoutParams.split("/");
+        const runId = urlParts.pop(); // Last part is the run ID
+        const repoName = urlParts[urlParts.length - 2]; // Second to last part is the repo name
+        if (!runId || !repoName) {
+            return {
+                isError: true,
+                result: "Invalid test run URL - could not extract run ID or repo name",
+            };
+        }
+        let result = {
+            testRun: null,
+            summary: null,
+            environment: null,
+            currentBuild: null,
+        };
+        let data = null;
+        if (!apiClient) {
+            throw new Error("Dashboard API client is not available.");
+        }
+        try {
+            data = await apiClient.request(`/api/test-runs/${runId}?repo_name=${repoName}`, { method: "GET" });
+        }
+        catch (error) {
+            return {
+                isError: true,
+                result: `Failed to fetch test run details: ${error instanceof Error ? error.message : String(error)}`,
+            };
+        }
+        const testRun = data?.data?.test_run?.testRun;
+        const project = data?.data?.test_run?.project;
+        const environmentSlug = testRun?.environment_slug;
+        const summaryUrl = testRun?.summary_url;
+        // TODO: Remove html from this tool
+        const indexHtmlUrl = summaryUrl?.replace("summary.json", "index.html");
+        if (testRun) {
+            result = {
+                testRun: testRun,
+                currentBuild: {
+                    id: testRun?.build_id,
+                    build_url: testRun?.build_url,
+                    project_id: testRun?.project_id,
+                    build_id: testRun?.build_id,
+                    branch: testRun?.test_run_branch,
+                    commit: testRun?.commit,
+                    commit_url: testRun?.commit_url,
+                    version: "",
+                },
+            };
+        }
+        if (summaryUrl && indexHtmlUrl) {
+            try {
+                const summaryJson = await fetch(summaryUrl);
+                const summaryData = await summaryJson.json();
+                // fs.writeFileSync(
+                //   "download-summary.json",
+                //   summaryJson ? JSON.stringify(summaryData, null, 2) : "",
+                //   "utf-8",
+                // );
+                const htmlDetailed = await apiClient.request(`/api/reports/html-detailed`, {
+                    method: "GET",
+                    params: {
+                        url: indexHtmlUrl,
+                    },
+                });
+                const parsedReport = (0, playwright_report_parser_1.parsePlaywrightTestReport)(summaryData);
+                // fs.writeFileSync(
+                //   "parsed-report.json",
+                //   parsedReport ? JSON.stringify(parsedReport, null, 2) : "",
+                //   "utf-8",
+                // );
+                const failedTests = parsedReport.tests.filter((test) => test.status === "failed");
+                const reportJson = htmlDetailed.files["report.json"];
+                const testsWithResults = failedTests.map((test) => {
+                    let matchingTest = (0, playwright_report_parser_1.findTestInReport)(reportJson, test, htmlDetailed.files);
+                    // to reduce the token size of the final response, we remove the steps from the results
+                    if (matchingTest && Array.isArray(matchingTest.results)) {
+                        matchingTest.results = matchingTest.results.map((result) => ({
+                            ...result,
+                            steps: [],
+                            errors: result.errors.map((error) => {
+                                return {
+                                    message: error.message.slice(0, 100),
+                                };
+                            }),
+                        }));
+                    }
+                    if (matchingTest) {
+                        return {
+                            ...test,
+                            results: matchingTest.results,
+                            steps: [],
+                            error: { ...test.error, snippet: "" },
+                        };
+                    }
+                });
+                const updatedReport = {
+                    ...parsedReport,
+                    tests: testsWithResults,
+                };
+                result = {
+                    ...result,
+                    summary: updatedReport,
+                };
+            }
+            catch (err) {
+                console.error("Failed to save summary: ", err);
+                const errMsg = `Failed to save summary: ${err instanceof Error ? err.message : String(err)}`;
+                return {
+                    isError: true,
+                    result: errMsg,
+                };
+            }
+        }
+        if (environmentSlug && project?.repo_name) {
+            const environment = await apiClient.request(`/api/environments`, {
+                method: "GET",
+                params: {
+                    project_repo_name: repoName,
+                    environment_slug: environmentSlug,
+                },
+            });
+            if (environment?.data?.environment && environment?.data?.build) {
+                result = {
+                    ...result,
+                    environment: environment?.data?.environment,
+                    currentBuild: {
+                        ...result.currentBuild,
+                        environment_id: environment?.data?.build?.environment_id,
+                    },
+                };
+            }
+        }
+        return {
+            isError: false,
+            result: `
+Note: the paths in the test run report are relative to the tests directory and not the repo directory.
+
+Test run report: ${JSON.stringify(result, null, 2)}`,
+        };
+    },
+};

package/dist/trace-utils/index.d.ts

@@ -0,0 +1,4 @@
+export { extractFileFromZipFromUrl, getFilenamesInZip, } from "../tools/trace-dot-zip/utils/extract-zip";
+export { generateNetworkTrace } from "../tools/trace-dot-zip/utils/network-trace";
+export { deduplicateImages } from "../utils/dedup-image";
+//# sourceMappingURL=index.d.ts.map

package/dist/trace-utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/trace-utils/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,yBAAyB,EACzB,iBAAiB,GAClB,MAAM,0CAA0C,CAAC;AAClD,OAAO,EAAE,oBAAoB,EAAE,MAAM,4CAA4C,CAAC;AAClF,OAAO,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC"}

package/dist/trace-utils/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deduplicateImages = exports.generateNetworkTrace = exports.getFilenamesInZip = exports.extractFileFromZipFromUrl = void 0;
+var extract_zip_1 = require("../tools/trace-dot-zip/utils/extract-zip");
+Object.defineProperty(exports, "extractFileFromZipFromUrl", { enumerable: true, get: function () { return extract_zip_1.extractFileFromZipFromUrl; } });
+Object.defineProperty(exports, "getFilenamesInZip", { enumerable: true, get: function () { return extract_zip_1.getFilenamesInZip; } });
+var network_trace_1 = require("../tools/trace-dot-zip/utils/network-trace");
+Object.defineProperty(exports, "generateNetworkTrace", { enumerable: true, get: function () { return network_trace_1.generateNetworkTrace; } });
+var dedup_image_1 = require("../utils/dedup-image");
+Object.defineProperty(exports, "deduplicateImages", { enumerable: true, get: function () { return dedup_image_1.deduplicateImages; } });

package/dist/utils/dedup-image-fs.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Processes an array of image file paths and returns only unique images as base64 strings.
+ * This is a file system wrapper around the deduplicateImages function that processes
+ * images in batches to avoid memory overflow.
+ *
+ * @param options - Configuration options
+ * @param options.imagePaths - An array of file paths to image files.
+ * @param options.batchSize - Number of images to process at a time (default: 50)
+ * @param options.threshold - The maximum fraction of pixels allowed to differ to consider two images similar.
+ *                    For example, 0.01 means that if less than 1% of the pixels differ, the images are considered duplicates.
+ *                    Default is 0.001 (0.1%).
+ * @param options.logPrefix - The ID of the test run, used for logging purposes.
+ * @returns A promise that resolves to an array of unique image objects with base64 data.
+ */
+export declare function deduplicateImageFiles({ imagePaths, batchSize, threshold, logPrefix, }: {
+    imagePaths: string[];
+    batchSize?: number;
+    threshold?: number;
+    logPrefix?: string;
+}): Promise<{
+    metadata: {
+        index: number;
+        path: string;
+    };
+    image: string;
+}[]>;
+//# sourceMappingURL=dedup-image-fs.d.ts.map

package/dist/utils/dedup-image-fs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dedup-image-fs.d.ts","sourceRoot":"","sources":["../../src/utils/dedup-image-fs.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;GAaG;AACH,wBAAsB,qBAAqB,CAAC,EAC1C,UAAU,EACV,SAAc,EACd,SAAiB,EACjB,SAA4B,GAC7B,EAAE;IACD,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,GAAG,OAAO,CAAC;IAAE,QAAQ,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,EAAE,CAAC,CAmG1E"}

package/dist/utils/dedup-image-fs.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deduplicateImageFiles = deduplicateImageFiles;
+const fs_1 = require("fs");
+const dedup_image_1 = require("./dedup-image");
+/**
+ * Processes an array of image file paths and returns only unique images as base64 strings.
+ * This is a file system wrapper around the deduplicateImages function that processes
+ * images in batches to avoid memory overflow.
+ *
+ * @param options - Configuration options
+ * @param options.imagePaths - An array of file paths to image files.
+ * @param options.batchSize - Number of images to process at a time (default: 50)
+ * @param options.threshold - The maximum fraction of pixels allowed to differ to consider two images similar.
+ *                    For example, 0.01 means that if less than 1% of the pixels differ, the images are considered duplicates.
+ *                    Default is 0.001 (0.1%).
+ * @param options.logPrefix - The ID of the test run, used for logging purposes.
+ * @returns A promise that resolves to an array of unique image objects with base64 data.
+ */
+async function deduplicateImageFiles({ imagePaths, batchSize = 50, threshold = 0.001, logPrefix = "dedup-image-fs", }) {
+    const uniqueImages = [];
+    console.log(`[${logPrefix}] Processing ${imagePaths.length} images in batches of ${batchSize}`);
+    for (let i = 0; i < imagePaths.length; i += batchSize) {
+        const batch = imagePaths.slice(i, i + batchSize);
+        console.log(`[${logPrefix}] Processing batch ${Math.floor(i / batchSize) + 1}/${Math.ceil(imagePaths.length / batchSize)}`);
+        const batchBase64Images = [];
+        for (let j = 0; j < batch.length; j++) {
+            const imagePath = batch[j];
+            if (!imagePath) {
+                console.error(`[${logPrefix}] Error: imagePath is undefined for batch ${Math.floor(i / batchSize) + 1}/${Math.ceil(imagePaths.length / batchSize)}`);
+                continue;
+            }
+            try {
+                const buffer = await fs_1.promises.readFile(imagePath);
+                const base64 = buffer.toString("base64");
+                batchBase64Images.push({
+                    metadata: {
+                        index: i + j,
+                        path: imagePath,
+                    },
+                    image: base64,
+                });
+            }
+            catch (error) {
+                console.error(`[${logPrefix}] Error reading image ${imagePath}:`, error);
+                continue;
+            }
+        }
+        // If this is the first batch, just deduplicate within the batch
+        if (uniqueImages.length === 0) {
+            const batchUniqueImages = await (0, dedup_image_1.deduplicateImages)({
+                base64Images: batchBase64Images,
+                threshold,
+                logPrefix: `${logPrefix}-batch-${Math.floor(i / batchSize) + 1}`,
+            });
+            uniqueImages.push(...batchUniqueImages);
+        }
+        else {
+            // For subsequent batches, compare against the last unique image and then deduplicate within batch
+            const lastUniqueImage = uniqueImages[uniqueImages.length - 1];
+            if (!lastUniqueImage) {
+                console.error(`[${logPrefix}] Error: lastUniqueImage is undefined for batch ${Math.floor(i / batchSize) + 1}/${Math.ceil(imagePaths.length / batchSize)}`);
+                continue;
+            }
+            const batchWithPrevious = [lastUniqueImage, ...batchBase64Images];
+            const batchUniqueImages = await (0, dedup_image_1.deduplicateImages)({
+                base64Images: batchWithPrevious,
+                threshold,
+                logPrefix: `${logPrefix}-batch-${Math.floor(i / batchSize) + 1}`,
+            });
+            // Remove the first image if it's the same as the last unique image (it was a duplicate)
+            // and add the rest to unique images
+            if (batchUniqueImages.length > 0) {
+                // Skip the first image if it has the same path as the last unique image
+                const startIndex = batchUniqueImages[0]?.metadata.path === lastUniqueImage.metadata.path
+                    ? 1
+                    : 0;
+                uniqueImages.push(...batchUniqueImages.slice(startIndex));
+            }
+        }
+        // Force garbage collection after each batch
+        if (global.gc) {
+            global.gc();
+        }
+    }
+    console.log(`[${logPrefix}] Filtered to ${uniqueImages.length} unique images from ${imagePaths.length} total images`);
+    return uniqueImages;
+}

package/dist/utils/dedup-image.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Processes an array of base64 image objects and returns only unique images.
+ * Two images are considered "similar" if the fraction of differing pixels (when resized)
+ * is below the provided threshold.
+ *
+ * @param options - Configuration options
+ * @param options.base64Images - An array of objects, each with a metadata field and a base64-encoded image string.
+ * @param options.threshold - The maximum fraction of pixels allowed to differ to consider two images similar.
+ *                    For example, 0.01 means that if less than 1% of the pixels differ, the images are considered duplicates.
+ *                    Default is 0.001 (0.1%).
+ * @param options.logPrefix - The ID of the test run, used for logging purposes.
+ * @returns A promise that resolves to an array of unique image objects.
+ */
+export declare function deduplicateImages({ base64Images, threshold, logPrefix, }: {
+    base64Images: {
+        metadata: any;
+        image: string;
+    }[];
+    threshold?: number;
+    logPrefix?: string;
+}): Promise<{
+    metadata: any;
+    image: string;
+}[]>;
+//# sourceMappingURL=dedup-image.d.ts.map

package/dist/utils/dedup-image.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dedup-image.d.ts","sourceRoot":"","sources":["../../src/utils/dedup-image.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;GAYG;AACH,wBAAsB,iBAAiB,CAAC,EACtC,YAAY,EACZ,SAAiB,EACjB,SAAyB,GAC1B,EAAE;IACD,YAAY,EAAE;QAAE,QAAQ,EAAE,GAAG,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IACjD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,GAAG,OAAO,CAAC;IAAE,QAAQ,EAAE,GAAG,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,EAAE,CAAC,CAsE9C"}

package/dist/utils/dedup-image.js

@@ -0,0 +1,80 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deduplicateImages = deduplicateImages;
+const pixelmatch_1 = __importDefault(require("pixelmatch"));
+const sharp_1 = __importDefault(require("sharp"));
+/**
+ * Processes an array of base64 image objects and returns only unique images.
+ * Two images are considered "similar" if the fraction of differing pixels (when resized)
+ * is below the provided threshold.
+ *
+ * @param options - Configuration options
+ * @param options.base64Images - An array of objects, each with a metadata field and a base64-encoded image string.
+ * @param options.threshold - The maximum fraction of pixels allowed to differ to consider two images similar.
+ *                    For example, 0.01 means that if less than 1% of the pixels differ, the images are considered duplicates.
+ *                    Default is 0.001 (0.1%).
+ * @param options.logPrefix - The ID of the test run, used for logging purposes.
+ * @returns A promise that resolves to an array of unique image objects.
+ */
+async function deduplicateImages({ base64Images, threshold = 0.001, logPrefix = "dedup-image", }) {
+    const uniqueImages = [];
+    // We'll store the raw pixel data (RGBA) and dimensions for the previous unique image.
+    let previousImageData = null;
+    let previousWidth = null;
+    let previousHeight = null;
+    for (const imgData of base64Images) {
+        try {
+            // Convert the base64 string to a Buffer.
+            const buffer = Buffer.from(imgData.image, "base64");
+            const imgMetadata = await (0, sharp_1.default)(buffer).metadata();
+            const height = imgMetadata.height || 0;
+            const width = imgMetadata.width || 0;
+            // Resize the image to fixed dimensions and extract its raw RGBA pixel data.
+            const { data } = await (0, sharp_1.default)(buffer)
+                .ensureAlpha()
+                .raw()
+                .toBuffer({ resolveWithObject: true });
+            let isDuplicate = false;
+            // If there's a previously processed unique image, compare the current image with it.
+            if (previousImageData &&
+                previousWidth === width &&
+                previousHeight === height) {
+                // Only compare images if they have the same dimensions
+                try {
+                    const diffPixels = (0, pixelmatch_1.default)(data, // current image pixel data
+                    previousImageData, // previous image pixel data
+                    null, // no diff image output is needed
+                    width, height, { threshold: 0.1 });
+                    // console.log("diffPixels", diffPixels);
+                    const totalPixels = height * width;
+                    const diffFraction = diffPixels / totalPixels;
+                    // console.log("diffFraction", diffFraction);
+                    // If the fraction of differing pixels is below (or equal to) the threshold,
+                    // consider the current image a duplicate.
+                    if (diffFraction <= threshold) {
+                        isDuplicate = true;
+                    }
+                }
+                catch (error) {
+                    console.error(`[${logPrefix}] Error comparing images:`, error);
+                    // If comparison fails, treat as non-duplicate
+                    isDuplicate = false;
+                }
+            }
+            // If the image is not a duplicate, add it to the list and update the previous image data.
+            if (!isDuplicate) {
+                uniqueImages.push(imgData);
+                previousImageData = data;
+                previousWidth = width;
+                previousHeight = height;
+            }
+        }
+        catch (error) {
+            console.error(`[${logPrefix}] Error processing image:`, error);
+        }
+    }
+    return uniqueImages;
+}

package/dist/utils/env.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"env.d.ts","sourceRoot":"","sources":["../../src/utils/env.ts"],"names":[],"mappings":"AAAA,wBAAgB,gBAAgB,YAM/B"}
+{"version":3,"file":"env.d.ts","sourceRoot":"","sources":["../../src/utils/env.ts"],"names":[],"mappings":"AAAA,wBAAgB,gBAAgB,YAK/B"}

package/dist/utils/env.js

@@ -3,6 +3,5 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.isRunningOnCloud = isRunningOnCloud;
 function isRunningOnCloud() {
     return (process.env.CI === "true" ||
-        // eslint-disable-next-line turbo/no-undeclared-env-vars
         !!process.env.RUNNING_BROWSER_TESTS_FOR_TEST_GEN);
 }

package/dist/utils/json.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.truncateJsonValues = truncateJsonValues;
-function truncateJsonValues(obj, maxLength = 1000) {
+function truncateJsonValues(obj, maxLength = 3000) {
     if (typeof obj === "string") {
         if (obj.length > maxLength) {
             const suffix = "...[truncated]";

package/dist/utils/model.d.ts

@@ -0,0 +1,3 @@
+import { SupportedChatModels } from "@empiricalrun/shared-types";
+export declare const ARGS_TO_MODEL_MAP: Record<string, SupportedChatModels>;
+//# sourceMappingURL=model.d.ts.map

package/dist/utils/model.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model.d.ts","sourceRoot":"","sources":["../../src/utils/model.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAEjE,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAkBjE,CAAC"}

package/dist/utils/model.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ARGS_TO_MODEL_MAP = void 0;
+exports.ARGS_TO_MODEL_MAP = {
+    "claude-3-5": "claude-3-5-sonnet-20241022",
+    "claude-3-7": "claude-3-7-sonnet-20250219",
+    "claude-4": "claude-sonnet-4-20250514",
+    "claude-sonnet-4": "claude-sonnet-4-20250514",
+    "claude-opus-4": "claude-opus-4-20250514",
+    gemini: "gemini-2.5-pro",
+    "gemini-2.5": "gemini-2.5-pro",
+    "gemini-2.5-pro": "gemini-2.5-pro",
+    o3: "o3-2025-04-16",
+    "o3-2025-04-16": "o3-2025-04-16",
+    "gpt-5": "gpt-5-2025-08-07",
+    "o4-mini": "o4-mini-2025-04-16",
+    "o4-mini-2025-04-16": "o4-mini-2025-04-16",
+};

package/dist/utils/playwright-report-parser.d.ts

@@ -0,0 +1,13 @@
+import { HtmlReportData, HtmlReportFile, HtmlReportTest, PlaywrightMatchingTest, PlaywrightTestReport } from "@empiricalrun/shared-types";
+import type { JSONReport } from "playwright/types/testReporter";
+export declare function parsePlaywrightTestReport(jsonReport: JSONReport): PlaywrightTestReport;
+export declare const findTestInReport: (reportJson: HtmlReportFile, targetTest: PlaywrightMatchingTest, allFiles: HtmlReportData["files"]) => HtmlReportTest | null;
+export interface TestCriteria {
+    name: string;
+    file_path: string;
+    suites: string[];
+}
+export declare function findMatchingTest(tests: PlaywrightMatchingTest[], testCriteria: TestCriteria): PlaywrightMatchingTest | null;
+export declare function fetchAndFindTestCase(summaryJsonUrl: string, testCriteria: TestCriteria): Promise<PlaywrightMatchingTest>;
+export declare function findTestInPlaywrightSummary(summaryJson: JSONReport, testCriteria: TestCriteria): Promise<PlaywrightMatchingTest | null>;
+//# sourceMappingURL=playwright-report-parser.d.ts.map

package/dist/utils/playwright-report-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"playwright-report-parser.d.ts","sourceRoot":"","sources":["../../src/utils/playwright-report-parser.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,cAAc,EACd,cAAc,EACd,cAAc,EACd,sBAAsB,EACtB,oBAAoB,EACrB,MAAM,4BAA4B,CAAC;AACpC,OAAO,KAAK,EACV,UAAU,EAGX,MAAM,+BAA+B,CAAC;AAqEvC,wBAAgB,yBAAyB,CACvC,UAAU,EAAE,UAAU,GACrB,oBAAoB,CAuBtB;AAED,eAAO,MAAM,gBAAgB,GAC3B,YAAY,cAAc,EAC1B,YAAY,sBAAsB,EAClC,UAAU,cAAc,CAAC,OAAO,CAAC,0BAwBlC,CAAC;AAEF,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAED,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,sBAAsB,EAAE,EAC/B,YAAY,EAAE,YAAY,GACzB,sBAAsB,GAAG,IAAI,CAgB/B;AAED,wBAAsB,oBAAoB,CACxC,cAAc,EAAE,MAAM,EACtB,YAAY,EAAE,YAAY,GACzB,OAAO,CAAC,sBAAsB,CAAC,CAqBjC;AAED,wBAAsB,2BAA2B,CAC/C,WAAW,EAAE,UAAU,EACvB,YAAY,EAAE,YAAY,GACzB,OAAO,CAAC,sBAAsB,GAAG,IAAI,CAAC,CASxC"}