@empiricalrun/test-gen 0.76.0 → 0.77.0

package/dist/utils/dedup-image.js

@@ -1,75 +1,20 @@
 "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 find_threshold_1 = require("./find-threshold");
+async function deduplicateImages({ base64Images, threshold, 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;
+    let previousImageBuffer = 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 });
+            const currentBuffer = Buffer.from(imgData.image, "base64");
             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 (previousImageBuffer) {
+                isDuplicate = await (0, find_threshold_1.areImagesDuplicate)(currentBuffer, previousImageBuffer, threshold);
             }
-            // 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;
+                previousImageBuffer = currentBuffer;
             }
         }
         catch (error) {

package/dist/utils/{local-ffmpeg-client.d.ts → ffmpeg/index.d.ts}

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

package/dist/utils/ffmpeg/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/utils/ffmpeg/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAa9D,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,cAAc;YASd,gBAAgB;YAoBhB,iBAAiB;YAsEjB,oBAAoB;YAkEpB,kBAAkB;IA8G1B,iBAAiB,CACrB,gBAAgB,EAAE,gBAAgB,EAAE,EACpC,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,MAAM,CAAC;IAgFZ,kBAAkB,CACtB,QAAQ,EAAE,MAAM,EAChB,YAAY,EAAE,MAAM,EACpB,kBAAkB,EAAE,MAAM,EAC1B,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,gBAAgB,EAAE,gBAAgB,EAAE,CAAC;QACrC,oBAAoB,EAAE,MAAM,CAAC;KAC9B,CAAC;CA0IH"}

package/dist/utils/{local-ffmpeg-client.js → ffmpeg/index.js}

@@ -4,12 +4,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LocalFFmpegClient = void 0;
+const node_crypto_1 = __importDefault(require("node:crypto"));
 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 constants_1 = require("../../constants");
+const utils_1 = require("../../video-core/utils");
+const dedup_image_fs_1 = require("../dedup-image-fs");
 const execAsync = (0, util_1.promisify)(child_process_1.exec);
+const FRAME_DIMENSION = "1280:720";
 class LocalFFmpegClient {
     static MAX_VIDEO_DURATION_SECONDS = 15 * 60; // 15 minutes
     static CHUNK_DURATION_SECONDS = 2 * 60; // 2 minutes
@@ -66,15 +70,6 @@ class LocalFFmpegClient {
             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 });
@@ -146,96 +141,198 @@ class LocalFFmpegClient {
         }
         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}"`);
+    async extractFramesWithFPS({ videoPath, outputDir, fps, globalStartTime, duration, }) {
+        // Create directory but don't clear it - multiple calls may be appending
+        await fs_1.promises.mkdir(outputDir, { recursive: true });
+        console.log(`Extracting frames at ${fps} fps using single ffmpeg command (${duration ? duration + "s duration" : "full length"}) starting at global time ${globalStartTime}s`);
+        const outputPattern = path_1.default.join(outputDir, "frame_%06d.png");
+        const args = [];
+        if (duration) {
+            args.push("-t", duration.toString());
+        }
+        const vf = `fps=${fps},scale=${FRAME_DIMENSION}:force_original_aspect_ratio=decrease,pad=${FRAME_DIMENSION}:(ow-iw)/2:(oh-ih)/2`;
+        args.push("-vf", `"${vf}"`, "-q:v", "2", "-y");
         try {
             await this.runFFmpegCommand({
                 inputPath: videoPath,
-                args: ["-vf", `fps=${fps}`],
-                outputPath: framePattern,
+                args: args,
+                outputPath: outputPattern,
             });
+            const files = await fs_1.promises.readdir(outputDir);
+            const frameFiles = files
+                .filter((f) => f.startsWith("frame_") && f.endsWith(".png"))
+                .sort();
+            const renamedFiles = [];
+            for (let i = 0; i < frameFiles.length; i++) {
+                const originalPath = path_1.default.join(outputDir, frameFiles[i]);
+                const globalFrameNumber = Math.floor(globalStartTime * fps) + i;
+                const newFileName = `chunk0_frame_${globalFrameNumber.toString().padStart(6, "0")}.png`;
+                const newPath = path_1.default.join(outputDir, newFileName);
+                await fs_1.promises.rename(originalPath, newPath);
+                renamedFiles.push(newPath);
+            }
+            console.log(`Successfully extracted ${renamedFiles.length} frames using single ffmpeg command with global frame numbering starting from ${Math.floor(globalStartTime * fps)}`);
+            return renamedFiles;
         }
         catch (error) {
-            throw new Error(`Frame extraction failed: ${error}`);
+            console.warn(`Failed to extract frames with fps filter:`, error);
+            return [];
         }
-        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) {
+    async processVideoChunks(chunkPaths, workingDir, fps, effectiveDuration, globalStartTime = 0) {
         const allFramePaths = [];
         const consolidatedFramesDir = path_1.default.join(workingDir, "consolidated_frames");
-        await this.ensureEmptyDir(consolidatedFramesDir);
-        let globalFrameIndex = 0;
+        // Check if consolidated_frames directory exists and has frames - if so, append mode
+        const dirExists = await fs_1.promises
+            .access(consolidatedFramesDir)
+            .then(() => true)
+            .catch(() => false);
+        let hasExistingFrames = false;
+        if (dirExists) {
+            try {
+                const existingFiles = await fs_1.promises.readdir(consolidatedFramesDir);
+                hasExistingFrames = existingFiles.some((file) => file.endsWith(".png"));
+            }
+            catch {
+                hasExistingFrames = false;
+            }
+        }
+        if (hasExistingFrames) {
+            // Append mode: directory has frames, don't clear it
+            console.log(`Appending to existing consolidated_frames directory`);
+        }
+        else {
+            // Fresh mode: clear and recreate directory
+            await this.ensureEmptyDir(consolidatedFramesDir);
+            console.log(`Creating fresh consolidated_frames directory`);
+        }
         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}`);
+            console.log(`Processing chunk ${i + 1}/${chunkPaths.length} with precise frame extraction`);
             if (chunkPath === undefined) {
                 throw new Error(`Chunk path is undefined for chunk ${i + 1}`);
             }
             try {
-                const chunkFramePaths = await this.extractFramesToFiles(chunkPath, chunkFramesDir, i, fps);
+                const chunkStartTime = i * LocalFFmpegClient.CHUNK_DURATION_SECONDS;
+                const chunkDuration = Math.min(LocalFFmpegClient.CHUNK_DURATION_SECONDS, effectiveDuration - chunkStartTime);
+                const actualGlobalStartTime = globalStartTime + chunkStartTime;
+                const chunkFramePaths = await this.extractFramesWithFPS({
+                    videoPath: chunkPath,
+                    outputDir: chunkFramesDir,
+                    fps,
+                    globalStartTime: actualGlobalStartTime,
+                    duration: chunkDuration,
+                });
                 for (const framePath of chunkFramePaths) {
-                    const newFramePath = path_1.default.join(consolidatedFramesDir, `frame_${globalFrameIndex.toString().padStart(6, "0")}.png`);
+                    const basename = path_1.default.basename(framePath);
+                    const frameNumberMatch = basename.match(/frame_(\d+)\.png$/);
+                    const localFrameNumber = frameNumberMatch && frameNumberMatch[1]
+                        ? parseInt(frameNumberMatch[1], 10)
+                        : 0;
+                    const globalFrameNumber = Math.floor(chunkStartTime * fps) + localFrameNumber;
+                    const newFramePath = path_1.default.join(consolidatedFramesDir, `frame_${globalFrameNumber.toString().padStart(6, "0")}.png`);
+                    // In append mode, check if frame already exists
+                    if (hasExistingFrames) {
+                        const frameExists = await fs_1.promises
+                            .access(newFramePath)
+                            .then(() => true)
+                            .catch(() => false);
+                        if (frameExists) {
+                            console.log(`Frame ${newFramePath} already exists, skipping`);
+                            allFramePaths.push(newFramePath);
+                            continue;
+                        }
+                    }
                     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) {
+    async storeUniqueFrames(uniqueFrameInfos, 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];
+        // Check if directory exists and has frames - if so, append mode
+        const dirExists = await fs_1.promises
+            .access(uniqueFramesDir)
+            .then(() => true)
+            .catch(() => false);
+        let hasExistingFrames = false;
+        if (dirExists) {
+            try {
+                const existingFiles = await fs_1.promises.readdir(uniqueFramesDir);
+                hasExistingFrames = existingFiles.some((file) => file.endsWith(".png"));
+            }
+            catch {
+                hasExistingFrames = false;
+            }
+        }
+        if (hasExistingFrames) {
+            // Append mode: directory has frames, don't clear it
+            console.log(`Appending ${uniqueFrameInfos.length} frames to existing ${uniqueFramesDir}`);
+        }
+        else {
+            // Fresh mode: clear and recreate directory
+            await this.ensureEmptyDir(uniqueFramesDir);
+            console.log(`Creating fresh ${uniqueFramesDir} with ${uniqueFrameInfos.length} frames`);
+        }
+        console.log(`Storing ${uniqueFrameInfos.length} unique frames in ${uniqueFramesDir}`);
+        for (let i = 0; i < uniqueFrameInfos.length; i++) {
+            const frame = uniqueFrameInfos[i];
             if (!frame)
                 continue;
-            const originalPath = frame.metadata.path;
-            const uniqueFramePath = path_1.default.join(uniqueFramesDir, `unique_frame_${i.toString().padStart(4, "0")}.png`);
+            const originalPath = frame.path;
+            const originalBasename = path_1.default.basename(originalPath);
+            const frameNumberMatch = originalBasename.match(/frame_(\d+)\.png$/);
+            const frameNumber = frameNumberMatch
+                ? frameNumberMatch[1]
+                : i.toString().padStart(6, "0");
+            const uniqueFramePath = path_1.default.join(uniqueFramesDir, `frame_${frameNumber}.png`);
             try {
+                // In append mode, check if frame already exists to avoid overwriting
+                if (hasExistingFrames) {
+                    const frameExists = await fs_1.promises
+                        .access(uniqueFramePath)
+                        .then(() => true)
+                        .catch(() => false);
+                    if (frameExists) {
+                        console.log(`Frame ${uniqueFramePath} already exists, skipping`);
+                        continue;
+                    }
+                }
                 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}`);
+        console.log(`Stored ${uniqueFrameInfos.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`);
+    async extractVideoFrames(videoUrl, videoUrlHash, absoluteWorkingDir, options) {
+        console.log("🚀 ~ LocalFFmpegClient ~ using absolute workingDir:", absoluteWorkingDir);
+        const workingDir = absoluteWorkingDir;
+        const urlHash = node_crypto_1.default
+            .createHash("sha256")
+            .update(videoUrl)
+            .digest("hex")
+            .substring(0, 16);
+        const videoPath = path_1.default.join(workingDir, `video_${urlHash}.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);
+            await (0, utils_1.downloadVideo)(videoUrl, videoPath);
             const videoDuration = await this.getVideoDuration(videoPath);
             console.log(`Video duration: ${Math.round(videoDuration)} seconds`);
             if (videoDuration > LocalFFmpegClient.MAX_VIDEO_DURATION_SECONDS) {
@@ -269,7 +366,8 @@ class LocalFFmpegClient {
             }
             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 allFramePaths = await this.processVideoChunks(chunkPaths, workingDir, fps, effectiveDuration, // Pass duration for precise calculations
+            effectiveStartTime);
             const allFramesCount = allFramePaths.length;
             const uniqueImages = await (0, dedup_image_fs_1.deduplicateImageFiles)({
                 imagePaths: allFramePaths,
@@ -284,10 +382,28 @@ class LocalFFmpegClient {
                 }
                 throw new Error("No frames were extracted from the video");
             }
-            await this.storeUniqueFrames(uniqueImages, workingDir);
+            const uniqueFrameInfos = uniqueImages.map((f) => {
+                const normalizedIndex = f.metadata.index
+                    .toString()
+                    .padStart(constants_1.VIDEO_ANALYSIS.FRAME_INDEX_PADDING, "0");
+                const timeInSeconds = f.metadata.index / fps;
+                const minutes = Math.floor(timeInSeconds / 60);
+                const seconds = Math.floor(timeInSeconds % 60);
+                const timestamp = `${minutes}m${seconds.toString().padStart(2, "0")}s`;
+                const fileName = `frame_${normalizedIndex}.png`;
+                return {
+                    index: f.metadata.index,
+                    path: f.metadata.path,
+                    fileName: fileName,
+                    base64: f.image,
+                    url: `${(0, utils_1.getR2BaseUrlByHash)(videoUrlHash)}${fileName}`,
+                    timestamp: timestamp,
+                };
+            });
+            await this.storeUniqueFrames(uniqueFrameInfos, workingDir);
             return {
                 totalFramesCount: allFramesCount,
-                uniqueFrames: uniqueImages,
+                uniqueFrameInfos,
                 videoDurationSeconds: videoDuration,
             };
         }

package/dist/utils/find-threshold.d.ts

@@ -0,0 +1,8 @@
+export declare function compareImageBuffers(buffer1: Buffer, buffer2: Buffer, pixelmatchThreshold: number): Promise<{
+    diffPixels: number;
+    totalPixels: number;
+    diffFraction: number;
+}>;
+export declare function findSimilarityPercentage(base64Image1: string, base64Image2: string): Promise<number>;
+export declare function areImagesDuplicate(buffer1: Buffer, buffer2: Buffer, threshold: number): Promise<boolean>;
+//# sourceMappingURL=find-threshold.d.ts.map

package/dist/utils/find-threshold.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"find-threshold.d.ts","sourceRoot":"","sources":["../../src/utils/find-threshold.ts"],"names":[],"mappings":"AAKA,wBAAsB,mBAAmB,CACvC,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,mBAAmB,EAAE,MAAM,GAC1B,OAAO,CAAC;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,CAAA;CAAE,CAAC,CA6B5E;AAED,wBAAsB,wBAAwB,CAC5C,YAAY,EAAE,MAAM,EACpB,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC,MAAM,CAAC,CASjB;AAED,wBAAsB,kBAAkB,CACtC,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,OAAO,CAAC,CAYlB"}

package/dist/utils/find-threshold.js

@@ -0,0 +1,55 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compareImageBuffers = compareImageBuffers;
+exports.findSimilarityPercentage = findSimilarityPercentage;
+exports.areImagesDuplicate = areImagesDuplicate;
+const pixelmatch_1 = __importDefault(require("pixelmatch"));
+const sharp_1 = __importDefault(require("sharp"));
+const PIXELMATCH_THRESHOLD = 0.1;
+async function compareImageBuffers(buffer1, buffer2, pixelmatchThreshold) {
+    const metadata1 = await (0, sharp_1.default)(buffer1).metadata();
+    const metadata2 = await (0, sharp_1.default)(buffer2).metadata();
+    const width = metadata1.width || 0;
+    const height = metadata1.height || 0;
+    if (width !== (metadata2.width || 0) || height !== (metadata2.height || 0)) {
+        throw new Error("Images must have the same dimensions for comparison");
+    }
+    const { data: data1 } = await (0, sharp_1.default)(buffer1)
+        .ensureAlpha()
+        .raw()
+        .toBuffer({ resolveWithObject: true });
+    const { data: data2 } = await (0, sharp_1.default)(buffer2)
+        .ensureAlpha()
+        .raw()
+        .toBuffer({ resolveWithObject: true });
+    const diffPixels = (0, pixelmatch_1.default)(data1, data2, null, width, height, {
+        threshold: pixelmatchThreshold,
+    });
+    const totalPixels = width * height;
+    const diffFraction = diffPixels / totalPixels;
+    return { diffPixels, totalPixels, diffFraction };
+}
+async function findSimilarityPercentage(base64Image1, base64Image2) {
+    try {
+        const buffer1 = Buffer.from(base64Image1, "base64");
+        const buffer2 = Buffer.from(base64Image2, "base64");
+        const { diffFraction } = await compareImageBuffers(buffer1, buffer2, 0.1);
+        return diffFraction;
+    }
+    catch (error) {
+        throw new Error(`Error calculating similarity: ${error}`);
+    }
+}
+async function areImagesDuplicate(buffer1, buffer2, threshold) {
+    try {
+        const { diffFraction } = await compareImageBuffers(buffer1, buffer2, PIXELMATCH_THRESHOLD);
+        return diffFraction <= threshold;
+    }
+    catch (error) {
+        console.error("Error comparing images for duplication:", error);
+        return false;
+    }
+}

package/dist/utils/hash.d.ts

@@ -0,0 +1,2 @@
+export declare function createHashBasedOnParams(mainStringToHash: string, additionalParams: Record<string, any>): string;
+//# sourceMappingURL=hash.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hash.d.ts","sourceRoot":"","sources":["../../src/utils/hash.ts"],"names":[],"mappings":"AAEA,wBAAgB,uBAAuB,CACrC,gBAAgB,EAAE,MAAM,EACxB,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GACpC,MAAM,CAmBR"}

package/dist/utils/hash.js

@@ -0,0 +1,24 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHashBasedOnParams = createHashBasedOnParams;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+function createHashBasedOnParams(mainStringToHash, additionalParams) {
+    const sortedParams = Object.keys(additionalParams)
+        .sort()
+        .reduce((acc, key) => {
+        acc[key] = additionalParams[key];
+        return acc;
+    }, {});
+    const json = JSON.stringify({
+        mainStringTohash: mainStringToHash,
+        ...sortedParams,
+    });
+    return node_crypto_1.default
+        .createHash("sha256")
+        .update(json)
+        .digest("hex")
+        .substring(0, 16);
+}

package/dist/utils/model.d.ts

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

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

@@ -1 +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"}
+{"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,qBAAqB,EAAE,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAoBrE,CAAC"}

package/dist/utils/model.js

@@ -1,12 +1,14 @@
 "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",
+exports.CLI_ARGS_TO_MODEL_MAP = void 0;
+exports.CLI_ARGS_TO_MODEL_MAP = {
     "claude-4": "claude-sonnet-4-20250514",
-    "claude-sonnet-4": "claude-sonnet-4-20250514",
+    "claude-4-5": "claude-sonnet-4-5-20250929",
     "claude-opus-4": "claude-opus-4-20250514",
+    "claude-sonnet-4": "claude-sonnet-4-20250514",
+    "claude-sonnet-4-5": "claude-sonnet-4-5-20250929",
+    "claude-haiku": "claude-3-5-haiku-20241022",
+    "claude-haiku-3-5": "claude-3-5-haiku-20241022",
     gemini: "gemini-2.5-pro",
     "gemini-2.5": "gemini-2.5-pro",
     "gemini-2.5-pro": "gemini-2.5-pro",

package/dist/utils/repo-tree.d.ts

@@ -1,4 +1,3 @@
 import { FileInfo } from "@empiricalrun/shared-types";
-export declare const DEFAULT_EXCLUDE: (string | RegExp)[];
 export declare function generateAsciiTree(root: FileInfo, options?: {}): string;
 //# sourceMappingURL=repo-tree.d.ts.map

package/dist/utils/repo-tree.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"repo-tree.d.ts","sourceRoot":"","sources":["../../src/utils/repo-tree.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,4BAA4B,CAAC;AAEtD,eAAO,MAAM,eAAe,qBAW3B,CAAC;AAEF,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,KAAK,UAqF7D"}
+{"version":3,"file":"repo-tree.d.ts","sourceRoot":"","sources":["../../src/utils/repo-tree.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,4BAA4B,CAAC;AAGtD,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,KAAK,UAqF7D"}

package/dist/utils/repo-tree.js

@@ -1,23 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_EXCLUDE = void 0;
 exports.generateAsciiTree = generateAsciiTree;
-exports.DEFAULT_EXCLUDE = [
-    "node_modules",
-    "dist",
-    "build",
-    /\.git/,
-    ".DS_Store",
-    "playwright-report",
-    "test-results",
-    ".empiricalrun",
-    "auth",
-    "package-lock.json",
-];
+const constants_1 = require("../constants");
 function generateAsciiTree(root, options = {}) {
     const defaultOptions = {
         showHidden: false,
-        exclude: exports.DEFAULT_EXCLUDE,
+        exclude: constants_1.DEFAULT_EXCLUDE,
         maxDepth: 10,
     };
     const opts = { ...defaultOptions, ...options };

package/dist/utils/slug.js

@@ -44,7 +44,7 @@ const slugify = (str) => {
 exports.slugify = slugify;
 const extractSlugFromDiagnosisUrl = (diagnosisUrl) => {
     const slug = diagnosisUrl.split("--").pop();
-    if (!slug) {
+    if (!diagnosisUrl.includes("--") || !slug) {
         throw new Error("Invalid diagnosis URL - could not extract slug");
     }
     return slug;

package/dist/video-core/agent-orchestrator.d.ts

@@ -0,0 +1,14 @@
+import type { Attachment, CanonicalMessage, ChatState, SupportedChatModels } from "@empiricalrun/shared-types";
+import { ProcessedAnalysis } from "./types";
+export declare function extractTextPartFromLastMessage(messages: CanonicalMessage[]): string | null;
+export declare function getChatStateWithFrameIdAttachmentParts(attachments: Attachment[], selectedModel: SupportedChatModels): ChatState;
+export declare function orchestrateVideoAnalysis({ selectedModel, featureFlags, workingDirectory, frameBatch, }: {
+    selectedModel: SupportedChatModels;
+    featureFlags: string[];
+    workingDirectory: string;
+    frameBatch: Attachment[];
+}): Promise<{
+    analysis: string;
+    allMessages: CanonicalMessage[];
+} & ProcessedAnalysis>;
+//# sourceMappingURL=agent-orchestrator.d.ts.map

package/dist/video-core/agent-orchestrator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-orchestrator.d.ts","sourceRoot":"","sources":["../../src/video-core/agent-orchestrator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,UAAU,EACV,gBAAgB,EAChB,SAAS,EACT,mBAAmB,EAEpB,MAAM,4BAA4B,CAAC;AAIpC,OAAO,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAG5C,wBAAgB,8BAA8B,CAC5C,QAAQ,EAAE,gBAAgB,EAAE,GAC3B,MAAM,GAAG,IAAI,CAgBf;AAED,wBAAgB,sCAAsC,CACpD,WAAW,EAAE,UAAU,EAAE,EACzB,aAAa,EAAE,mBAAmB,GACjC,SAAS,CAqBX;AAED,wBAAsB,wBAAwB,CAAC,EAC7C,aAAa,EACb,YAAY,EACZ,gBAAgB,EAChB,UAAU,GACX,EAAE;IACD,aAAa,EAAE,mBAAmB,CAAC;IACnC,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,gBAAgB,EAAE,MAAM,CAAC;IACzB,UAAU,EAAE,UAAU,EAAE,CAAC;CAC1B,GAAG,OAAO,CACT;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,gBAAgB,EAAE,CAAA;CAAE,GAAG,iBAAiB,CAC1E,CAoDA"}