@empiricalrun/test-gen 0.76.0 → 0.78.0

package/dist/utils/dedup-image.js

@@ -1,80 +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.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/local-ffmpeg-client.d.ts

@@ -1,27 +0,0 @@
-import { UniqueFrameWithMetadata } from "@empiricalrun/shared-types";
-export declare class LocalFFmpegClient {
-    private static readonly MAX_VIDEO_DURATION_SECONDS;
-    private static readonly CHUNK_DURATION_SECONDS;
-    constructor();
-    private checkFFmpegAvailability;
-    private getVideoDuration;
-    private validateVideoChunk;
-    private downloadVideo;
-    private ensureEmptyDir;
-    private runFFmpegCommand;
-    private createVideoChunks;
-    private extractFramesToFiles;
-    private processVideoChunks;
-    storeUniqueFrames(uniqueFrames: UniqueFrameWithMetadata[], workingDir: string): Promise<string>;
-    extractVideoFrames(videoUrl: string, outputDir: string, options?: {
-        fps?: number;
-        threshold?: number;
-        startTime?: number;
-        duration?: number;
-    }): Promise<{
-        totalFramesCount: number;
-        uniqueFrames: UniqueFrameWithMetadata[];
-        videoDurationSeconds: number;
-    }>;
-}
-//# sourceMappingURL=local-ffmpeg-client.d.ts.map

package/dist/utils/local-ffmpeg-client.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"local-ffmpeg-client.d.ts","sourceRoot":"","sources":["../../src/utils/local-ffmpeg-client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,4BAA4B,CAAC;AAUrE,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,0BAA0B,CAAW;IAC7D,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,sBAAsB,CAAU;;IAMxD,OAAO,CAAC,uBAAuB;YAWjB,gBAAgB;YAiBhB,kBAAkB;YAgClB,aAAa;YAeb,cAAc;YASd,gBAAgB;YAoBhB,iBAAiB;YAsEjB,oBAAoB;YAyCpB,kBAAkB;IA2D1B,iBAAiB,CACrB,YAAY,EAAE,uBAAuB,EAAE,EACvC,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,MAAM,CAAC;IAiCZ,kBAAkB,CACtB,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE;QACR,GAAG,CAAC,EAAE,MAAM,CAAC;QACb,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB,GACA,OAAO,CAAC;QACT,gBAAgB,EAAE,MAAM,CAAC;QACzB,YAAY,EAAE,uBAAuB,EAAE,CAAC;QACxC,oBAAoB,EAAE,MAAM,CAAC;KAC9B,CAAC;CA2GH"}

package/dist/utils/local-ffmpeg-client.js

@@ -1,299 +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.LocalFFmpegClient = void 0;
-const child_process_1 = require("child_process");
-const fs_1 = require("fs");
-const path_1 = __importDefault(require("path"));
-const util_1 = require("util");
-const dedup_image_fs_1 = require("./dedup-image-fs");
-const execAsync = (0, util_1.promisify)(child_process_1.exec);
-class LocalFFmpegClient {
-    static MAX_VIDEO_DURATION_SECONDS = 15 * 60; // 15 minutes
-    static CHUNK_DURATION_SECONDS = 2 * 60; // 2 minutes
-    constructor() {
-        this.checkFFmpegAvailability();
-    }
-    checkFFmpegAvailability() {
-        try {
-            (0, child_process_1.execSync)("ffmpeg -version", { stdio: "ignore" });
-            (0, child_process_1.execSync)("ffprobe -version", { stdio: "ignore" });
-        }
-        catch (error) {
-            throw new Error(`ffmpeg and ffprobe are required for video processing: ${error}`);
-        }
-    }
-    async getVideoDuration(videoPath) {
-        const command = `ffprobe -v quiet -show_entries format=duration -of csv=p=0 "${videoPath}"`;
-        try {
-            const { stdout } = await execAsync(command);
-            const duration = parseFloat(stdout.trim());
-            if (isNaN(duration)) {
-                throw new Error("Could not determine video duration");
-            }
-            return duration;
-        }
-        catch (error) {
-            throw new Error(`Failed to get video duration: ${error}`);
-        }
-    }
-    async validateVideoChunk(chunkPath) {
-        const command = `ffprobe -v error -show_entries format=duration -of csv=p=0 "${chunkPath}"`;
-        try {
-            const { stdout, stderr } = await execAsync(command);
-            if (stderr && stderr.toLowerCase().includes("error")) {
-                console.warn(`Chunk validation found errors: ${stderr}`);
-                return false;
-            }
-            const duration = parseFloat(stdout.trim());
-            if (isNaN(duration) || duration <= 0) {
-                console.warn(`Chunk has invalid duration: ${duration}`);
-                return false;
-            }
-            // Check file size as additional validation
-            const stats = await fs_1.promises.stat(chunkPath);
-            if (stats.size < 1024) {
-                // Less than 1KB is suspicious for a video chunk
-                console.warn(`Chunk file size too small: ${stats.size} bytes`);
-                return false;
-            }
-            return true;
-        }
-        catch (error) {
-            console.warn(`Chunk validation failed: ${error}`);
-            return false;
-        }
-    }
-    async downloadVideo(videoUrl, outputPath) {
-        console.log(`Downloading video from: ${videoUrl}`);
-        const response = await fetch(videoUrl);
-        if (!response.ok) {
-            throw new Error(`Failed to download video: ${response.statusText}`);
-        }
-        const buffer = await response.arrayBuffer();
-        await fs_1.promises.writeFile(outputPath, Buffer.from(buffer));
-    }
-    async ensureEmptyDir(dir) {
-        try {
-            await fs_1.promises.rm(dir, { recursive: true, force: true });
-        }
-        catch {
-            // ignore
-        }
-        await fs_1.promises.mkdir(dir, { recursive: true });
-    }
-    async runFFmpegCommand({ inputPath, args, outputPath, }) {
-        const quotedInput = `"${inputPath}"`;
-        const output = outputPath ? ` "${outputPath}"` : "";
-        const cmd = `ffmpeg -y -nostdin -i ${quotedInput} ${args.join(" ")}${output}`;
-        try {
-            await execAsync(cmd);
-        }
-        catch (error) {
-            throw new Error(`ffmpeg command failed: ${cmd} => ${String(error)}`);
-        }
-    }
-    async createVideoChunks(videoPath, outputDir, duration, startTime = 0) {
-        const chunkPaths = [];
-        const chunkCount = Math.ceil(duration / LocalFFmpegClient.CHUNK_DURATION_SECONDS);
-        console.log(`Creating ${chunkCount} chunks of ${LocalFFmpegClient.CHUNK_DURATION_SECONDS} seconds each`);
-        for (let i = 0; i < chunkCount; i++) {
-            const chunkOffsetTime = i * LocalFFmpegClient.CHUNK_DURATION_SECONDS;
-            const absoluteStartTime = startTime + chunkOffsetTime;
-            const chunkPath = path_1.default.join(outputDir, `chunk_${i.toString().padStart(3, "0")}.mp4`);
-            const remainingDuration = duration - chunkOffsetTime;
-            const chunkDuration = Math.min(LocalFFmpegClient.CHUNK_DURATION_SECONDS, remainingDuration);
-            try {
-                await fs_1.promises.rm(chunkPath, { force: true });
-                await this.runFFmpegCommand({
-                    inputPath: videoPath,
-                    args: [
-                        "-ss",
-                        String(absoluteStartTime),
-                        "-t",
-                        String(chunkDuration),
-                        "-c:v",
-                        "libx264",
-                        "-c:a",
-                        "aac",
-                        "-preset",
-                        "ultrafast",
-                        "-crf",
-                        "28",
-                    ],
-                    outputPath: chunkPath,
-                });
-                // Validate the created chunk
-                const isValid = await this.validateVideoChunk(chunkPath);
-                if (isValid) {
-                    chunkPaths.push(chunkPath);
-                }
-                else {
-                    console.warn(`Chunk ${i} appears corrupted, skipping...`);
-                    try {
-                        await fs_1.promises.unlink(chunkPath);
-                    }
-                    catch (unlinkError) {
-                        console.warn(`Failed to remove corrupted chunk: ${unlinkError}`);
-                    }
-                }
-            }
-            catch (error) {
-                throw new Error(`Failed to create chunk ${i}: ${error}`);
-            }
-        }
-        return chunkPaths;
-    }
-    async extractFramesToFiles(videoPath, outputDir, chunkIndex, fps) {
-        await this.ensureEmptyDir(outputDir);
-        const framePrefix = chunkIndex !== undefined ? `chunk${chunkIndex}_frame` : "frame";
-        const framePattern = path_1.default.join(outputDir, `${framePrefix}_%04d.png`);
-        console.log(`Extracting frames with command: ffmpeg -i "${videoPath}" -vf "fps=${fps}" "${framePattern}"`);
-        try {
-            await this.runFFmpegCommand({
-                inputPath: videoPath,
-                args: ["-vf", `fps=${fps}`],
-                outputPath: framePattern,
-            });
-        }
-        catch (error) {
-            throw new Error(`Frame extraction failed: ${error}`);
-        }
-        const files = await fs_1.promises.readdir(outputDir);
-        const frameFiles = files
-            .filter((file) => file.startsWith(framePrefix) && file.endsWith(".png"))
-            .sort()
-            .map((file) => path_1.default.join(outputDir, file));
-        console.log(`Extracted ${frameFiles.length} frames from ${chunkIndex !== undefined ? `chunk ${chunkIndex}` : "video"}`);
-        return frameFiles;
-    }
-    async processVideoChunks(chunkPaths, workingDir, fps) {
-        const allFramePaths = [];
-        const consolidatedFramesDir = path_1.default.join(workingDir, "consolidated_frames");
-        await this.ensureEmptyDir(consolidatedFramesDir);
-        let globalFrameIndex = 0;
-        for (let i = 0; i < chunkPaths.length; i++) {
-            const chunkPath = chunkPaths[i];
-            const chunkFramesDir = path_1.default.join(workingDir, `chunk_${i}_frames`);
-            console.log(`Processing chunk ${i + 1}/${chunkPaths.length}`);
-            if (chunkPath === undefined) {
-                throw new Error(`Chunk path is undefined for chunk ${i + 1}`);
-            }
-            try {
-                const chunkFramePaths = await this.extractFramesToFiles(chunkPath, chunkFramesDir, i, fps);
-                for (const framePath of chunkFramePaths) {
-                    const newFramePath = path_1.default.join(consolidatedFramesDir, `frame_${globalFrameIndex.toString().padStart(6, "0")}.png`);
-                    await fs_1.promises.rename(framePath, newFramePath);
-                    allFramePaths.push(newFramePath);
-                    globalFrameIndex++;
-                }
-            }
-            catch (error) {
-                console.warn(`Failed to process chunk ${i + 1}: ${error}. Skipping this chunk.`);
-                // Continue with other chunks instead of failing completely
-            }
-            try {
-                await fs_1.promises.rm(chunkFramesDir, { recursive: true });
-            }
-            catch (error) {
-                console.warn(`Failed to clean up chunk frames directory: ${error}`);
-            }
-            if (global.gc) {
-                global.gc();
-            }
-        }
-        return allFramePaths;
-    }
-    async storeUniqueFrames(uniqueFrames, workingDir) {
-        const uniqueFramesDir = path_1.default.join(workingDir, "unique_frames");
-        await this.ensureEmptyDir(uniqueFramesDir);
-        console.log(`Storing ${uniqueFrames.length} unique frames in ${uniqueFramesDir}`);
-        for (let i = 0; i < uniqueFrames.length; i++) {
-            const frame = uniqueFrames[i];
-            if (!frame)
-                continue;
-            const originalPath = frame.metadata.path;
-            const uniqueFramePath = path_1.default.join(uniqueFramesDir, `unique_frame_${i.toString().padStart(4, "0")}.png`);
-            try {
-                await fs_1.promises.copyFile(originalPath, uniqueFramePath);
-            }
-            catch (error) {
-                console.warn(`Failed to copy frame ${originalPath} to ${uniqueFramePath}:`, error);
-            }
-        }
-        console.log(`Stored ${uniqueFrames.length} unique frames in: ${uniqueFramesDir}`);
-        return uniqueFramesDir;
-    }
-    async extractVideoFrames(videoUrl, outputDir, options) {
-        const workingDir = path_1.default.join(process.cwd(), outputDir);
-        const videoPath = path_1.default.join(workingDir, `video_${Date.now()}.webm`);
-        const fps = options?.fps ?? 30;
-        const threshold = options?.threshold ?? 0.001;
-        const startTime = options?.startTime;
-        const duration = options?.duration;
-        try {
-            await fs_1.promises.mkdir(workingDir, { recursive: true });
-            await this.downloadVideo(videoUrl, videoPath);
-            const videoDuration = await this.getVideoDuration(videoPath);
-            console.log(`Video duration: ${Math.round(videoDuration)} seconds`);
-            if (videoDuration > LocalFFmpegClient.MAX_VIDEO_DURATION_SECONDS) {
-                throw new Error(`Video duration (${Math.round(videoDuration)}s) exceeds maximum allowed duration (${LocalFFmpegClient.MAX_VIDEO_DURATION_SECONDS}s)`);
-            }
-            // Validate and adjust time parameters
-            let effectiveStartTime = 0;
-            let effectiveDuration = videoDuration;
-            if (startTime !== undefined) {
-                if (startTime < 0) {
-                    throw new Error(`Start time cannot be negative: ${startTime}`);
-                }
-                if (startTime >= videoDuration) {
-                    throw new Error(`Start time (${startTime}s) exceeds video duration (${Math.round(videoDuration)}s)`);
-                }
-                effectiveStartTime = startTime;
-                effectiveDuration = videoDuration - startTime;
-            }
-            if (duration !== undefined) {
-                if (duration <= 0) {
-                    throw new Error(`Duration must be positive: ${duration}`);
-                }
-                const maxAllowedDuration = videoDuration - effectiveStartTime;
-                if (duration > maxAllowedDuration) {
-                    console.warn(`Requested duration (${duration}s) exceeds available time (${maxAllowedDuration}s), truncating to fit`);
-                    effectiveDuration = maxAllowedDuration;
-                }
-                else {
-                    effectiveDuration = duration;
-                }
-            }
-            console.log(`Effective extraction range: ${effectiveStartTime}s to ${effectiveStartTime + effectiveDuration}s`);
-            const chunkPaths = await this.createVideoChunks(videoPath, workingDir, effectiveDuration, effectiveStartTime);
-            const allFramePaths = await this.processVideoChunks(chunkPaths, workingDir, fps);
-            const allFramesCount = allFramePaths.length;
-            const uniqueImages = await (0, dedup_image_fs_1.deduplicateImageFiles)({
-                imagePaths: allFramePaths,
-                batchSize: 50,
-                threshold,
-                logPrefix: "ffmpeg-chunk-frame-dedup",
-            });
-            console.log(`Filtered to ${uniqueImages.length} unique frames from ${allFramesCount} total frames across ${chunkPaths.length} chunks`);
-            if (uniqueImages.length === 0) {
-                if (chunkPaths.length === 0) {
-                    throw new Error("No valid video chunks were created. The video may be corrupted or in an unsupported format.");
-                }
-                throw new Error("No frames were extracted from the video");
-            }
-            await this.storeUniqueFrames(uniqueImages, workingDir);
-            return {
-                totalFramesCount: allFramesCount,
-                uniqueFrames: uniqueImages,
-                videoDurationSeconds: videoDuration,
-            };
-        }
-        catch (error) {
-            throw new Error(`Frame extraction failed: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-}
-exports.LocalFFmpegClient = LocalFFmpegClient;

package/eslint.config.mjs

@@ -1,43 +0,0 @@
-import libraryConfig from "../eslint-config/library.mjs";
-import tsParser from "@typescript-eslint/parser";
-import js from "@eslint/js";
-
-export default [
-  ...libraryConfig,
-  {
-    files: ["src/**/*.ts", "src/**/*.tsx"],
-    languageOptions: {
-      parser: tsParser,
-      globals: {
-        window: true,
-        document: true,
-      },
-      parserOptions: {
-        project: "./tsconfig.lint.json",
-        tsconfigRootDir: import.meta.dirname,
-      },
-    },
-  },
-  {
-    files: ["**/*.js"],
-    ...js.configs.recommended,
-    languageOptions: {
-      globals: {
-        browser: true,
-      },
-      parserOptions: {
-        ecmaVersion: 2022,
-        sourceType: "module",
-      },
-    },
-    rules: {
-      "@typescript-eslint/no-floating-promises": "off",
-      "@typescript-eslint/no-misused-promises": "off",
-      "@typescript-eslint/no-unsafe-assignment": "off",
-      "@typescript-eslint/no-unsafe-call": "off",
-      "@typescript-eslint/no-unsafe-member-access": "off",
-      "@typescript-eslint/no-unsafe-return": "off",
-      "no-unused-vars": "warn",
-    },
-  },
-];