@empiricalrun/test-gen 0.74.1 → 0.75.0

package/dist/tools/fetch-video-analysis/index.js

@@ -4,20 +4,45 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fetchVideoAnalysis = void 0;
-const crypto_1 = __importDefault(require("crypto"));
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const node_path_1 = __importDefault(require("node:path"));
 const fetch_video_analysis_1 = require("../definitions/fetch-video-analysis");
 const local_ffmpeg_client_1 = require("./local-ffmpeg-client");
 const utils_1 = require("./utils");
 const video_analysis_1 = require("./video-analysis");
+function getVideoAnalysisParams(params) {
+    return {
+        model: params?.model || "gemini-2.5-pro",
+        fps: params?.fps ?? 30,
+        threshold: params?.threshold ?? 0.001,
+        featureFlag: params?.featureFlag ?? "send-all-frames",
+    };
+}
+function hashObject(obj) {
+    const sortedObj = Object.keys(obj)
+        .sort()
+        .reduce((acc, key) => {
+        acc[key] = obj[key];
+        return acc;
+    }, {});
+    const json = JSON.stringify(sortedObj);
+    return node_crypto_1.default
+        .createHash("sha256")
+        .update(json)
+        .digest("hex")
+        .substring(0, 16);
+}
 exports.fetchVideoAnalysis = {
     ...fetch_video_analysis_1.fetchVideoAnalysis,
     execute: async ({ input, trace, }) => {
         const { videoUrl } = input;
-        const videoUrlHash = crypto_1.default
-            .createHash("sha256")
-            .update(videoUrl)
-            .digest("hex")
-            .substring(0, 16);
+        const params = getVideoAnalysisParams(input.params);
+        const videoUrlHash = hashObject({
+            videoUrl,
+            ...params,
+        });
+        const { model: selectedModel, fps: effectiveFps, threshold: effectiveThreshold, featureFlag: effectiveFeatureFlag, } = params;
+        const WORKING_DIR = `./video-analysis-artifacts/${videoUrlHash}`;
         const R2_BASE_URL = `https://video-analysis.empirical.run/${videoUrlHash}/`;
         const videoAnalysisSpan = trace?.span({
             name: "video-analysis",
@@ -34,36 +59,60 @@ exports.fetchVideoAnalysis = {
             }
             const processingSpan = videoAnalysisSpan?.span({
                 name: "ffmpeg-processing",
-                input: { videoUrl },
+                input: {
+                    videoUrl,
+                    fps: effectiveFps,
+                    threshold: effectiveThreshold,
+                },
             });
             try {
-                const { totalFramesCount, uniqueFramesCount, uniqueFrames } = await ffmpegClient.extractVideoFrames(videoUrl, "./temp");
+                const extractionResult = await ffmpegClient.extractVideoFrames(videoUrl, WORKING_DIR, {
+                    fps: effectiveFps,
+                    threshold: effectiveThreshold,
+                });
+                const { totalFramesCount, uniqueFrames } = extractionResult;
                 processingSpan?.end({
                     output: {
                         totalFramesCount,
-                        uniqueFramesCount,
+                        uniqueFramesCount: uniqueFrames.length,
                     },
                 });
                 console.log(`[video-analysis] Analyzing ${uniqueFrames.length} frames with LLM`);
-                const videoInfoWithoutAnalysis = {
+                const outputZipPath = node_path_1.default.join(WORKING_DIR, "frames.zip");
+                const zipUploadPromise = (0, utils_1.zipAndUploadFramesToR2)(uniqueFrames, outputZipPath, videoUrlHash).catch((error) => {
+                    throw error; // Re-throw to maintain error in Promise.all
+                });
+                const { analysis: llmAnalysis, usage } = await (0, video_analysis_1.analyzeFramesWithLLM)(uniqueFrames.map((frame) => frame.image), videoAnalysisSpan, selectedModel);
+                console.log(`[video-analysis] Finished Analyzing ${uniqueFrames.length} frames with LLM`);
+                const videoInfo = {
                     total_frames_count: totalFramesCount,
-                    unique_frames_count: uniqueFramesCount,
+                    unique_frames_count: uniqueFrames.length,
                     video_url: videoUrl,
-                    video_url_hash: videoUrlHash,
+                    analysis_id: videoUrlHash,
                     created_at: new Date().toISOString(),
+                    params: {
+                        fps: effectiveFps,
+                        threshold: effectiveThreshold,
+                        model: selectedModel,
+                        featureFlag: effectiveFeatureFlag,
+                    },
+                    usage,
+                    langfuse_trace_id: trace?.id || undefined,
+                    frames_zip_url: `${R2_BASE_URL}frames.zip`,
+                    analysis: llmAnalysis,
                 };
-                const framesUploadPromise = (0, utils_1.uploadFramesToR2)(videoInfoWithoutAnalysis, uniqueFrames, R2_BASE_URL);
-                const { analysis: llmAnalysis, usage } = await (0, video_analysis_1.analyzeFramesWithLLM)(uniqueFrames.map((frame) => frame.image), videoAnalysisSpan, "gemini-2.5-pro");
-                console.log(`[video-analysis] Finished Analyzing ${uniqueFrames.length} frames with LLM`);
-                const videoInfo = {
-                    ...videoInfoWithoutAnalysis,
-                    llm_analysis: llmAnalysis,
-                    video_url_hash: videoUrlHash,
+                await Promise.all([
+                    zipUploadPromise,
+                    (0, utils_1.uploadSummaryToR2)(videoInfo, R2_BASE_URL),
+                ]);
+                await (0, utils_1.safeCleanupDirectory)(WORKING_DIR, "video-analysis-cleanup");
+                const toolResult = {
+                    video_url: videoUrl,
+                    analysis: llmAnalysis,
+                    analysis_id: videoUrlHash,
                 };
-                const uniqueFramesWithUrls = await framesUploadPromise;
-                await (0, utils_1.uploadAnalysisToR2)(videoInfo, uniqueFramesWithUrls, R2_BASE_URL);
                 return {
-                    result: JSON.stringify(videoInfo, null, 2),
+                    result: JSON.stringify(toolResult, null, 2),
                     isError: false,
                     usage,
                 };

package/dist/tools/fetch-video-analysis/local-ffmpeg-client.d.ts

@@ -1,3 +1,4 @@
+import { UniqueFrameWithMetadata } from "@empiricalrun/shared-types";
 export declare class LocalFFmpegClient {
     private static readonly MAX_VIDEO_DURATION_SECONDS;
     private static readonly CHUNK_DURATION_SECONDS;
@@ -6,19 +7,17 @@ export declare class LocalFFmpegClient {
     private getVideoDuration;
     private validateVideoChunk;
     private downloadVideo;
+    private ensureEmptyDir;
+    private runFFmpegCommand;
     private createVideoChunks;
     private extractFramesToFiles;
     private processVideoChunks;
-    extractVideoFrames(videoUrl: string, outputDir: string): Promise<{
+    extractVideoFrames(videoUrl: string, outputDir: string, options?: {
+        fps?: number;
+        threshold?: number;
+    }): Promise<{
         totalFramesCount: number;
-        uniqueFramesCount: number;
-        uniqueFrames: {
-            metadata: {
-                index: number;
-                path: string;
-            };
-            image: string;
-        }[];
+        uniqueFrames: UniqueFrameWithMetadata[];
     }>;
 }
 //# sourceMappingURL=local-ffmpeg-client.d.ts.map

package/dist/tools/fetch-video-analysis/local-ffmpeg-client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"local-ffmpeg-client.d.ts","sourceRoot":"","sources":["../../../src/tools/fetch-video-analysis/local-ffmpeg-client.ts"],"names":[],"mappings":"AASA,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,iBAAiB;YAoDjB,oBAAoB;YAiCpB,kBAAkB;IAyD1B,kBAAkB,CACtB,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC;QACT,gBAAgB,EAAE,MAAM,CAAC;QACzB,iBAAiB,EAAE,MAAM,CAAC;QAC1B,YAAY,EAAE;YACZ,QAAQ,EAAE;gBAAE,KAAK,EAAE,MAAM,CAAC;gBAAC,IAAI,EAAE,MAAM,CAAA;aAAE,CAAC;YAC1C,KAAK,EAAE,MAAM,CAAC;SACf,EAAE,CAAC;KACL,CAAC;CAgEH"}
+{"version":3,"file":"local-ffmpeg-client.d.ts","sourceRoot":"","sources":["../../../src/tools/fetch-video-analysis/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;YAoEjB,oBAAoB;YAyCpB,kBAAkB;IA2D1B,kBAAkB,CACtB,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE;QAAE,GAAG,CAAC,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,GAC7C,OAAO,CAAC;QACT,gBAAgB,EAAE,MAAM,CAAC;QACzB,YAAY,EAAE,uBAAuB,EAAE,CAAC;KACzC,CAAC;CAiEH"}

package/dist/tools/fetch-video-analysis/local-ffmpeg-client.js

@@ -75,6 +75,26 @@ class LocalFFmpegClient {
         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) {
         const chunkPaths = [];
         const chunkCount = Math.ceil(duration / LocalFFmpegClient.CHUNK_DURATION_SECONDS);
@@ -84,9 +104,26 @@ class LocalFFmpegClient {
             const chunkPath = path_1.default.join(outputDir, `chunk_${i.toString().padStart(3, "0")}.mp4`);
             const remainingDuration = duration - startTime;
             const chunkDuration = Math.min(LocalFFmpegClient.CHUNK_DURATION_SECONDS, remainingDuration);
-            const command = `ffmpeg -i "${videoPath}" -ss ${startTime} -t ${chunkDuration} -c:v libx264 -c:a aac -preset ultrafast -crf 28 "${chunkPath}"`;
             try {
-                await execAsync(command);
+                await fs_1.promises.rm(chunkPath, { force: true });
+                await this.runFFmpegCommand({
+                    inputPath: videoPath,
+                    args: [
+                        "-ss",
+                        String(startTime),
+                        "-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) {
@@ -108,14 +145,17 @@ class LocalFFmpegClient {
         }
         return chunkPaths;
     }
-    async extractFramesToFiles(videoPath, outputDir, chunkIndex) {
-        await fs_1.promises.mkdir(outputDir, { recursive: true });
+    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`);
-        const command = `ffmpeg -i "${videoPath}" -vf "fps=30" "${framePattern}"`;
-        console.log(`Extracting frames with command: ${command}`);
+        console.log(`Extracting frames with command: ffmpeg -i "${videoPath}" -vf "fps=${fps}" "${framePattern}"`);
         try {
-            await execAsync(command);
+            await this.runFFmpegCommand({
+                inputPath: videoPath,
+                args: ["-vf", `fps=${fps}`],
+                outputPath: framePattern,
+            });
         }
         catch (error) {
             throw new Error(`Frame extraction failed: ${error}`);
@@ -128,10 +168,10 @@ class LocalFFmpegClient {
         console.log(`Extracted ${frameFiles.length} frames from ${chunkIndex !== undefined ? `chunk ${chunkIndex}` : "video"}`);
         return frameFiles;
     }
-    async processVideoChunks(chunkPaths, workingDir) {
+    async processVideoChunks(chunkPaths, workingDir, fps) {
         const allFramePaths = [];
         const consolidatedFramesDir = path_1.default.join(workingDir, "consolidated_frames");
-        await fs_1.promises.mkdir(consolidatedFramesDir, { recursive: true });
+        await this.ensureEmptyDir(consolidatedFramesDir);
         let globalFrameIndex = 0;
         for (let i = 0; i < chunkPaths.length; i++) {
             const chunkPath = chunkPaths[i];
@@ -141,7 +181,7 @@ class LocalFFmpegClient {
                 throw new Error(`Chunk path is undefined for chunk ${i + 1}`);
             }
             try {
-                const chunkFramePaths = await this.extractFramesToFiles(chunkPath, chunkFramesDir, i);
+                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);
@@ -165,9 +205,11 @@ class LocalFFmpegClient {
         }
         return allFramePaths;
     }
-    async extractVideoFrames(videoUrl, outputDir) {
+    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;
         try {
             await fs_1.promises.mkdir(workingDir, { recursive: true });
             await this.downloadVideo(videoUrl, videoPath);
@@ -177,12 +219,12 @@ class LocalFFmpegClient {
                 throw new Error(`Video duration (${Math.round(duration)}s) exceeds maximum allowed duration (${LocalFFmpegClient.MAX_VIDEO_DURATION_SECONDS}s)`);
             }
             const chunkPaths = await this.createVideoChunks(videoPath, workingDir, duration);
-            const allFramePaths = await this.processVideoChunks(chunkPaths, workingDir);
+            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: 0.001,
+                threshold,
                 logPrefix: "ffmpeg-chunk-frame-dedup",
             });
             console.log(`Filtered to ${uniqueImages.length} unique frames from ${allFramesCount} total frames across ${chunkPaths.length} chunks`);
@@ -194,16 +236,12 @@ class LocalFFmpegClient {
             }
             return {
                 totalFramesCount: allFramesCount,
-                uniqueFramesCount: uniqueImages.length,
                 uniqueFrames: uniqueImages,
             };
         }
         catch (error) {
             throw new Error(`Frame extraction failed: ${error instanceof Error ? error.message : String(error)}`);
         }
-        finally {
-            await fs_1.promises.rm(workingDir, { recursive: true });
-        }
     }
 }
 exports.LocalFFmpegClient = LocalFFmpegClient;

package/dist/tools/fetch-video-analysis/open-ai.d.ts

@@ -0,0 +1,6 @@
+export declare function analyzeImages({ systemPrompt, imageBase64Array, userPrompt, }: {
+    systemPrompt: string;
+    imageBase64Array: string[];
+    userPrompt: string;
+}): Promise<string>;
+//# sourceMappingURL=open-ai.d.ts.map

package/dist/tools/fetch-video-analysis/open-ai.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"open-ai.d.ts","sourceRoot":"","sources":["../../../src/tools/fetch-video-analysis/open-ai.ts"],"names":[],"mappings":"AAOA,wBAAsB,aAAa,CAAC,EAClC,YAAY,EACZ,gBAAgB,EAChB,UAAU,GACX,EAAE;IACD,YAAY,EAAE,MAAM,CAAC;IACrB,gBAAgB,EAAE,MAAM,EAAE,CAAC;IAC3B,UAAU,EAAE,MAAM,CAAC;CACpB,mBA+BA"}

package/dist/tools/fetch-video-analysis/open-ai.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeImages = analyzeImages;
+const openai_1 = __importDefault(require("openai"));
+const openai = new openai_1.default({
+    apiKey: ``,
+});
+async function analyzeImages({ systemPrompt, imageBase64Array, userPrompt, }) {
+    const response = await openai.responses.create({
+        model: "gpt-4.1-2025-04-14",
+        input: [
+            {
+                role: "system",
+                content: systemPrompt,
+            },
+            {
+                role: "user",
+                content: [
+                    {
+                        type: "input_text",
+                        text: userPrompt,
+                    },
+                    ...imageBase64Array.map((base64) => ({
+                        detail: "auto",
+                        type: "input_image",
+                        image_url: `data:image/png;base64,${base64}`,
+                    })),
+                ],
+            },
+        ],
+    });
+    console.log(response.output_text);
+    return response.output_text;
+}

package/dist/tools/fetch-video-analysis/utils.d.ts

@@ -1,10 +1,13 @@
-import { UniqueFrameInfo, VideoAnalysisInfo } from "@empiricalrun/shared-types";
-export declare const uploadFramesToR2: (videoInfo: Omit<VideoAnalysisInfo, "llm_analysis">, frames: {
+import { type FileMap } from "@empiricalrun/r2-uploader";
+import { UniqueFrameInfo, UniqueFrameWithMetadata, VideoAnalysisSummary } from "@empiricalrun/shared-types";
+export declare const safeCleanupDirectory: (dirPath: string, label?: string) => Promise<void>;
+export declare const uploadFramesToR2: (videoInfo: Omit<VideoAnalysisSummary, "analysis">, frames: {
     metadata: {
         index: number;
         path: string;
     };
     image: string;
 }[], r2BaseUrl: string) => Promise<UniqueFrameInfo[]>;
-export declare const uploadAnalysisToR2: (videoInfo: VideoAnalysisInfo, uniqueFrames: UniqueFrameInfo[], r2BaseUrl: string) => Promise<string>;
+export declare const uploadSummaryToR2: (videoInfo: VideoAnalysisSummary, r2BaseUrl: string) => Promise<string>;
+export declare const zipAndUploadFramesToR2: (uniqueFrames: UniqueFrameWithMetadata[], outputZipPath: string, videoUrlHash: string) => Promise<FileMap>;
 //# sourceMappingURL=utils.d.ts.map

package/dist/tools/fetch-video-analysis/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/tools/fetch-video-analysis/utils.ts"],"names":[],"mappings":"AACA,OAAO,EACL,eAAe,EACf,iBAAiB,EAElB,MAAM,4BAA4B,CAAC;AAmCpC,eAAO,MAAM,gBAAgB,GAC3B,WAAW,IAAI,CAAC,iBAAiB,EAAE,cAAc,CAAC,EAClD,QAAQ;IACN,QAAQ,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IAC1C,KAAK,EAAE,MAAM,CAAC;CACf,EAAE,EACH,WAAW,MAAM,KAChB,OAAO,CAAC,eAAe,EAAE,CAqB3B,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAC7B,WAAW,iBAAiB,EAC5B,cAAc,eAAe,EAAE,EAC/B,WAAW,MAAM,KAChB,OAAO,CAAC,MAAM,CAwChB,CAAC"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/tools/fetch-video-analysis/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EAGb,MAAM,2BAA2B,CAAC;AACnC,OAAO,EACL,eAAe,EACf,uBAAuB,EACvB,oBAAoB,EACrB,MAAM,4BAA4B,CAAC;AAKpC,eAAO,MAAM,oBAAoB,GAC/B,SAAS,MAAM,EACf,cAAiB,KAChB,OAAO,CAAC,IAAI,CAUd,CAAC;AAoCF,eAAO,MAAM,gBAAgB,GAC3B,WAAW,IAAI,CAAC,oBAAoB,EAAE,UAAU,CAAC,EACjD,QAAQ;IACN,QAAQ,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IAC1C,KAAK,EAAE,MAAM,CAAC;CACf,EAAE,EACH,WAAW,MAAM,KAChB,OAAO,CAAC,eAAe,EAAE,CAqB3B,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAC5B,WAAW,oBAAoB,EAC/B,WAAW,MAAM,KAChB,OAAO,CAAC,MAAM,CAsBhB,CAAC;AAEF,eAAO,MAAM,sBAAsB,GACjC,cAAc,uBAAuB,EAAE,EACvC,eAAe,MAAM,EACrB,cAAc,MAAM,KACnB,OAAO,CAAC,OAAO,CAsBjB,CAAC"}

package/dist/tools/fetch-video-analysis/utils.js

@@ -1,7 +1,23 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.uploadAnalysisToR2 = exports.uploadFramesToR2 = void 0;
+exports.zipAndUploadFramesToR2 = exports.uploadSummaryToR2 = exports.uploadFramesToR2 = exports.safeCleanupDirectory = void 0;
 const r2_uploader_1 = require("@empiricalrun/r2-uploader");
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const safeCleanupDirectory = async (dirPath, label = "cleanup") => {
+    try {
+        console.log(`[${label}] Cleaning up directory: ${dirPath}`);
+        await fs_1.promises.rm(dirPath, { recursive: true });
+    }
+    catch (error) {
+        console.warn(`[${label}] Failed to cleanup directory ${dirPath}:`, error instanceof Error ? error.message : String(error));
+    }
+};
+exports.safeCleanupDirectory = safeCleanupDirectory;
 const uploadFilesToR2 = async (files, videoUrlHash) => {
     const label = `video-analysis-upload:${videoUrlHash}`;
     const start = Date.now();
@@ -25,7 +41,7 @@ const uploadFilesToR2 = async (files, videoUrlHash) => {
     }
 };
 const uploadFramesToR2 = async (videoInfo, frames, r2BaseUrl) => {
-    const { video_url_hash: videoUrlHash } = videoInfo;
+    const { analysis_id: videoUrlHash } = videoInfo;
     const frameFiles = frames.map((f) => {
         const fileName = `frame_${f.metadata.index}_${videoUrlHash}.png`;
         const buffer = Buffer.from(f.image, "base64");
@@ -41,21 +57,12 @@ const uploadFramesToR2 = async (videoInfo, frames, r2BaseUrl) => {
     }));
 };
 exports.uploadFramesToR2 = uploadFramesToR2;
-const uploadAnalysisToR2 = async (videoInfo, uniqueFrames, r2BaseUrl) => {
+const uploadSummaryToR2 = async (videoInfo, r2BaseUrl) => {
     try {
-        const { video_url_hash: videoUrlHash, total_frames_count, unique_frames_count, video_url, llm_analysis, created_at, } = videoInfo;
-        const summary = {
-            total_frames_count,
-            unique_frames_count,
-            video_url,
-            llm_analysis,
-            video_url_hash: videoUrlHash,
-            uniqueFrames,
-            created_at,
-        };
+        const { analysis_id: videoUrlHash } = videoInfo;
         const filesToUpload = [
             {
-                buffer: Buffer.from(JSON.stringify(summary, null, 2)),
+                buffer: Buffer.from(JSON.stringify(videoInfo, null, 2)),
                 fileName: "summary.json",
                 mimeType: "application/json",
             },
@@ -69,4 +76,23 @@ const uploadAnalysisToR2 = async (videoInfo, uniqueFrames, r2BaseUrl) => {
         throw error;
     }
 };
-exports.uploadAnalysisToR2 = uploadAnalysisToR2;
+exports.uploadSummaryToR2 = uploadSummaryToR2;
+const zipAndUploadFramesToR2 = async (uniqueFrames, outputZipPath, videoUrlHash) => {
+    const filePaths = uniqueFrames.map((u) => u.metadata.path);
+    await new Promise((resolve, reject) => {
+        (0, child_process_1.execFile)("zip", ["-0", "-j", outputZipPath, ...filePaths], (err) => {
+            if (err)
+                return reject(err);
+            resolve();
+        });
+    });
+    const tempUploadDir = path_1.default.dirname(outputZipPath);
+    console.log(`[zip-upload] Uploading zip file: ${outputZipPath} to video-analysis/${videoUrlHash}/`);
+    return await (0, r2_uploader_1.uploadDirectory)({
+        sourceDir: tempUploadDir,
+        fileList: [outputZipPath],
+        destinationDir: videoUrlHash,
+        uploadBucket: "video-analysis",
+    });
+};
+exports.zipAndUploadFramesToR2 = zipAndUploadFramesToR2;

package/dist/tools/fetch-video-analysis/video-analysis.js

@@ -14,7 +14,7 @@ async function analyzeFramesWithLLM(frameBase64Data, trace, selectedModel, apiKe
         let chatModel = new chat_1.GeminiChatModel(selectedChatModel, [], apiKey || process.env.GOOGLE_API_KEY);
         chatModel.validateEnvVarsForAuth();
         const frameAttachments = frameBase64Data.map((frameBase64, index) => ({
-            base64Data: frameBase64,
+            url: frameBase64,
             contentType: "image/png",
             name: `frame-${index}.png`,
         }));

package/dist/tools/file-operations/create.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create.d.ts","sourceRoot":"","sources":["../../../src/tools/file-operations/create.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAM1E,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AAE9D,iBAAe,kBAAkB,CAAC,EAChC,KAAK,EACL,QAAQ,EACR,gBAAgB,EAChB,OAAO,EACP,gBAAgB,GACjB,EAAE;IACD,KAAK,EAAE,qBAAqB,CAAC;IAC7B,QAAQ,EAAE,MAAM,CAAC;IACjB,gBAAgB,EAAE,MAAM,CAAC;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;CACrC,GAAG,OAAO,CAAC,UAAU,CAAC,CAuDtB;AAED,OAAO,EAAE,kBAAkB,EAAE,CAAC"}
+{"version":3,"file":"create.d.ts","sourceRoot":"","sources":["../../../src/tools/file-operations/create.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAO1E,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AAE9D,iBAAe,kBAAkB,CAAC,EAChC,KAAK,EACL,QAAQ,EACR,gBAAgB,EAChB,OAAO,EACP,gBAAgB,GACjB,EAAE;IACD,KAAK,EAAE,qBAAqB,CAAC;IAC7B,QAAQ,EAAE,MAAM,CAAC;IACjB,gBAAgB,EAAE,MAAM,CAAC;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;CACrC,GAAG,OAAO,CAAC,UAAU,CAAC,CA0DtB;AAED,OAAO,EAAE,kBAAkB,EAAE,CAAC"}

package/dist/tools/file-operations/create.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fileCreateExecutor = fileCreateExecutor;
+const child_process_1 = require("child_process");
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const web_1 = require("../../bin/utils/platform/web");
@@ -42,12 +43,14 @@ the required directories recursively for the new file.`,
         fs_1.default.mkdirSync(parentDir, { recursive: true });
     }
     fs_1.default.writeFileSync(absoluteFilePath, input.file_text);
+    // Stage the file
+    (0, child_process_1.execSync)(`git add "${filePath}"`, { cwd: repoDir });
     // Collect git patch artifact
     await (0, git_helper_1.collectGitPatchArtifact)(filePath, repoDir, "create", collectArtifacts);
-    let createTypescriptResult = await (0, web_1.runTypescriptCompiler)(repoDir);
-    if (!createTypescriptResult.success) {
+    let tscResult = await (0, web_1.runTypescriptCompiler)(repoDir);
+    if (!tscResult.success) {
         return {
-            result: `File ${filePath} has been created. However, type checks are failing with errors:\n\n${createTypescriptResult.errors.join("\n")}`,
+            result: `File ${filePath} has been created. However, type checks are failing with errors:\n\n${tscResult.errors.join("\n")}`,
             isError: true,
         };
     }

package/dist/tools/file-operations/insert.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"insert.d.ts","sourceRoot":"","sources":["../../../src/tools/file-operations/insert.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAK1E,OAAO,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AAEzD,iBAAe,kBAAkB,CAAC,EAChC,KAAK,EACL,QAAQ,EACR,gBAAgB,EAChB,OAAO,EACP,gBAAgB,GACjB,EAAE;IACD,KAAK,EAAE,qBAAqB,CAAC;IAC7B,QAAQ,EAAE,MAAM,CAAC;IACjB,gBAAgB,EAAE,MAAM,CAAC;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;CACrC,GAAG,OAAO,CAAC,UAAU,CAAC,CAqDtB;AAED,OAAO,EAAE,kBAAkB,EAAE,CAAC"}
+{"version":3,"file":"insert.d.ts","sourceRoot":"","sources":["../../../src/tools/file-operations/insert.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAM1E,OAAO,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AAEzD,iBAAe,kBAAkB,CAAC,EAChC,KAAK,EACL,QAAQ,EACR,gBAAgB,EAChB,OAAO,EACP,gBAAgB,GACjB,EAAE;IACD,KAAK,EAAE,qBAAqB,CAAC;IAC7B,QAAQ,EAAE,MAAM,CAAC;IACjB,gBAAgB,EAAE,MAAM,CAAC;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;CACrC,GAAG,OAAO,CAAC,UAAU,CAAC,CAwDtB;AAED,OAAO,EAAE,kBAAkB,EAAE,CAAC"}

package/dist/tools/file-operations/insert.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fileInsertExecutor = fileInsertExecutor;
+const child_process_1 = require("child_process");
 const fs_1 = __importDefault(require("fs"));
 const web_1 = require("../../bin/utils/platform/web");
 const git_helper_1 = require("./shared/git-helper");
@@ -43,12 +44,14 @@ async function fileInsertExecutor({ input, filePath, absoluteFilePath, repoDir,
     }
     lines.splice(input.insert_line, 0, textToInsert);
     fs_1.default.writeFileSync(absoluteFilePath, lines.join("\n"));
+    // Stage the file
+    (0, child_process_1.execSync)(`git add "${filePath}"`, { cwd: repoDir });
     // Collect git patch artifact
     await (0, git_helper_1.collectGitPatchArtifact)(filePath, repoDir, "insert", collectArtifacts);
-    let insertTypescriptResult = await (0, web_1.runTypescriptCompiler)(repoDir);
-    if (!insertTypescriptResult.success) {
+    let tscResult = await (0, web_1.runTypescriptCompiler)(repoDir);
+    if (!tscResult.success) {
         return {
-            result: `Insertion in file ${filePath} was applied. However, type checks are failing with errors:\n${insertTypescriptResult.errors.join("\n")}`,
+            result: `Insertion in file ${filePath} was applied. However, type checks are failing with errors:\n${tscResult.errors.join("\n")}`,
             isError: true,
         };
     }

package/dist/tools/file-operations/replace.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"replace.d.ts","sourceRoot":"","sources":["../../../src/tools/file-operations/replace.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAK1E,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AAG9D,iBAAe,sBAAsB,CAAC,EACpC,KAAK,EACL,QAAQ,EACR,gBAAgB,EAChB,OAAO,EACP,gBAAgB,GACjB,EAAE;IACD,KAAK,EAAE,qBAAqB,CAAC;IAC7B,QAAQ,EAAE,MAAM,CAAC;IACjB,gBAAgB,EAAE,MAAM,CAAC;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;CACrC,GAAG,OAAO,CAAC,UAAU,CAAC,CAiFtB;AAED,OAAO,EAAE,sBAAsB,EAAE,CAAC"}
+{"version":3,"file":"replace.d.ts","sourceRoot":"","sources":["../../../src/tools/file-operations/replace.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAM1E,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AAG9D,iBAAe,sBAAsB,CAAC,EACpC,KAAK,EACL,QAAQ,EACR,gBAAgB,EAChB,OAAO,EACP,gBAAgB,GACjB,EAAE;IACD,KAAK,EAAE,qBAAqB,CAAC;IAC7B,QAAQ,EAAE,MAAM,CAAC;IACjB,gBAAgB,EAAE,MAAM,CAAC;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;CACrC,GAAG,OAAO,CAAC,UAAU,CAAC,CAoFtB;AAED,OAAO,EAAE,sBAAsB,EAAE,CAAC"}

package/dist/tools/file-operations/replace.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fileStrReplaceExecutor = fileStrReplaceExecutor;
+const child_process_1 = require("child_process");
 const fs_1 = __importDefault(require("fs"));
 const web_1 = require("../../bin/utils/platform/web");
 const git_helper_1 = require("./shared/git-helper");
@@ -61,12 +62,14 @@ async function fileStrReplaceExecutor({ input, filePath, absoluteFilePath, repoD
         }
         const newContent = normalizedContent.replace(normalizedOldStr, input.new_str);
         fs_1.default.writeFileSync(absoluteFilePath, newContent);
+        // Stage the file
+        (0, child_process_1.execSync)(`git add "${filePath}"`, { cwd: repoDir });
         // Collect git patch artifact
         await (0, git_helper_1.collectGitPatchArtifact)(filePath, repoDir, "replace", collectArtifacts);
-        let strReplaceTypescriptResult = await (0, web_1.runTypescriptCompiler)(repoDir);
-        if (!strReplaceTypescriptResult.success) {
+        let tscResult = await (0, web_1.runTypescriptCompiler)(repoDir);
+        if (!tscResult.success) {
             return {
-                result: `Edits to file ${filePath} have been applied. However, type checks are failing with errors:\n\n${strReplaceTypescriptResult.errors.join("\n")}`,
+                result: `Edits to file ${filePath} have been applied. However, type checks are failing with errors:\n\n${tscResult.errors.join("\n")}`,
                 isError: true,
             };
         }

package/dist/tools/file-operations/shared/git-helper.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"git-helper.d.ts","sourceRoot":"","sources":["../../../../src/tools/file-operations/shared/git-helper.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,gBAAgB,EACjB,MAAM,4BAA4B,CAAC;AAKpC,iBAAe,uBAAuB,CACpC,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,QAAQ,GAAG,SAAS,GAAG,QAAQ,EAC1C,gBAAgB,CAAC,EAAE,gBAAgB,GAClC,OAAO,CAAC,IAAI,CAAC,CAoBf;AAED,OAAO,EAAE,uBAAuB,EAAE,CAAC"}
+{"version":3,"file":"git-helper.d.ts","sourceRoot":"","sources":["../../../../src/tools/file-operations/shared/git-helper.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,gBAAgB,EACjB,MAAM,4BAA4B,CAAC;AAQpC,iBAAe,uBAAuB,CACpC,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,QAAQ,GAAG,SAAS,GAAG,QAAQ,EAC1C,gBAAgB,CAAC,EAAE,gBAAgB,GAClC,OAAO,CAAC,IAAI,CAAC,CAoBf;AAED,OAAO,EAAE,uBAAuB,EAAE,CAAC"}

package/dist/tools/file-operations/shared/git-helper.js

@@ -12,7 +12,7 @@ async function collectGitPatchArtifact(filePath, repoDir, operation, collectArti
     try {
         const gitPatch = operation === "create"
             ? (0, git_1.getGitDiffForNewFile)(filePath, repoDir)
-            : (0, git_1.getGitDiff)(filePath, repoDir);
+            : (0, git_1.getGitDiffStaged)(filePath, repoDir);
         if (gitPatch.trim()) {
             const patchArtifact = {
                 name: `${path_1.default.basename(filePath, path_1.default.extname(filePath))}_${operation}.patch`,

package/dist/tools/file-operations/view/index.d.ts

@@ -1,14 +1,11 @@
 import { IDashboardAPIClient, ToolResult } from "@empiricalrun/shared-types";
 import type { StrReplaceInputParams } from "../shared/helpers";
-type FileViewExecutorOptions = {
-    use: "fs" | "github";
-};
 type FileViewExecutorParams = {
     input: StrReplaceInputParams;
     repoName?: string;
     apiClient?: IDashboardAPIClient;
     repoPath: string;
 };
-declare function fileViewExecutor(params: FileViewExecutorParams, options?: FileViewExecutorOptions): Promise<ToolResult>;
-export { fileViewExecutor };
+export declare function fileViewExecutor(params: FileViewExecutorParams): Promise<ToolResult>;
+export {};
 //# sourceMappingURL=index.d.ts.map

package/dist/tools/file-operations/view/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/tools/file-operations/view/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAQ7E,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAG/D,KAAK,uBAAuB,GAAG;IAC7B,GAAG,EAAE,IAAI,GAAG,QAAQ,CAAC;CACtB,CAAC;AAEF,KAAK,sBAAsB,GAAG;IAC5B,KAAK,EAAE,qBAAqB,CAAC;IAC7B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,mBAAmB,CAAC;IAChC,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,iBAAe,gBAAgB,CAC7B,MAAM,EAAE,sBAAsB,EAC9B,OAAO,CAAC,EAAE,uBAAuB,GAChC,OAAO,CAAC,UAAU,CAAC,CAkDrB;AAED,OAAO,EAAE,gBAAgB,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/tools/file-operations/view/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAI7E,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAG/D,KAAK,sBAAsB,GAAG;IAC5B,KAAK,EAAE,qBAAqB,CAAC;IAC7B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,mBAAmB,CAAC;IAChC,QAAQ,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,wBAAsB,gBAAgB,CACpC,MAAM,EAAE,sBAAsB,GAC7B,OAAO,CAAC,UAAU,CAAC,CA4BrB"}