@empiricalrun/test-gen 0.75.0 → 0.77.0

package/dist/tools/commit-and-create-pr/index.js

@@ -1,83 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createPullRequestTool = void 0;
-const child_process_1 = require("child_process");
-const commit_and_create_pr_1 = require("../definitions/commit-and-create-pr");
-const utils_1 = require("../executor/utils");
-const git_1 = require("../executor/utils/git");
-const pr_description_1 = require("../executor/utils/pr-description");
-exports.createPullRequestTool = {
-    ...commit_and_create_pr_1.createPullRequestTool,
-    execute: async ({ input, repoPath, apiClient, chatSession }) => {
-        try {
-            const { pullRequestTitle, pullRequestDescription } = input;
-            const remoteUrl = (0, child_process_1.execSync)("git config --get remote.origin.url", {
-                cwd: repoPath,
-            })
-                .toString()
-                .trim();
-            const { owner, repo } = (0, utils_1.parseGitHubUrl)(remoteUrl);
-            const branchName = await (0, git_1.getCurrentBranchName)(repoPath);
-            (0, child_process_1.execSync)(`git push origin ${branchName} --set-upstream`, {
-                cwd: repoPath,
-            });
-            if (!apiClient) {
-                throw new Error("Dashboard API client is not available.");
-            }
-            let pullRequest = await (0, utils_1.getExistingPR)({
-                owner,
-                repo,
-                branchName,
-                apiClient,
-            });
-            if (pullRequest) {
-                pullRequest = await (0, utils_1.updatePullRequest)({
-                    owner,
-                    repo,
-                    prNumber: pullRequest.number,
-                    body: (0, pr_description_1.addMetadataToPRDescription)(pullRequestDescription, chatSession),
-                    apiClient,
-                });
-                const mergeableState = await (0, utils_1.getMergeableState)({
-                    owner,
-                    repo,
-                    pullRequest,
-                    apiClient,
-                });
-                const stateDescription = (0, utils_1.getMergeableStateDescription)(mergeableState);
-                return {
-                    isError: false,
-                    result: `Updated existing PR: ${pullRequest.html_url}\n\nMergeable state: ${mergeableState} - ${stateDescription}`,
-                };
-            }
-            else {
-                pullRequest = await (0, utils_1.createPullRequest)({
-                    owner,
-                    repo,
-                    title: pullRequestTitle,
-                    head: branchName,
-                    base: chatSession?.baseBranchName || "main",
-                    body: (0, pr_description_1.addMetadataToPRDescription)(pullRequestDescription, chatSession),
-                    apiClient,
-                });
-                const mergeableState = await (0, utils_1.getMergeableState)({
-                    owner,
-                    repo,
-                    pullRequest,
-                    apiClient,
-                });
-                const stateDescription = (0, utils_1.getMergeableStateDescription)(mergeableState);
-                return {
-                    isError: false,
-                    result: `Created a new PR: ${pullRequest.html_url}\n\nMergeable state: ${mergeableState} - ${stateDescription}`,
-                };
-            }
-        }
-        catch (error) {
-            return {
-                isError: true,
-                result: `Failed to commit and push changes: ${error instanceof Error ? error.message : String(error)}`,
-            };
-        }
-    },
-};

package/dist/tools/definitions/commit-and-create-pr.d.ts

@@ -1,3 +0,0 @@
-import type { ToolDefinition } from "@empiricalrun/shared-types";
-export declare const createPullRequestTool: ToolDefinition;
-//# sourceMappingURL=commit-and-create-pr.d.ts.map

package/dist/tools/definitions/commit-and-create-pr.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"commit-and-create-pr.d.ts","sourceRoot":"","sources":["../../../src/tools/definitions/commit-and-create-pr.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAmBjE,eAAO,MAAM,qBAAqB,EAAE,cAenC,CAAC"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"fetch-video-analysis.d.ts","sourceRoot":"","sources":["../../../src/tools/definitions/fetch-video-analysis.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAC5D,OAAO,CAAC,MAAM,KAAK,CAAC;AAEpB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2C9B,CAAC;AAEH,eAAO,MAAM,kBAAkB,EAAE,cAAc,CAC7C,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAcpC,CAAC"}

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

@@ -1,61 +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.fetchVideoAnalysis = exports.videoAnalysisSchema = void 0;
-const zod_1 = __importDefault(require("zod"));
-exports.videoAnalysisSchema = zod_1.default.object({
-    videoUrl: zod_1.default
-        .string()
-        .url("Must be a valid URL")
-        .describe("The URL of the video to analyze."),
-    params: zod_1.default
-        .object({
-        fps: zod_1.default
-            .number()
-            .int()
-            .min(1)
-            .max(120)
-            .default(30)
-            .optional()
-            .describe("Frames per second to extract from the video (default: 30)"),
-        threshold: zod_1.default
-            .number()
-            .min(0)
-            .max(0.5)
-            .default(0.001)
-            .optional()
-            .describe("Deduplication threshold (fraction of pixels that may differ to consider frames identical). Lower = stricter. Default: 0.001"),
-        model: zod_1.default
-            .string()
-            .default("gemini-2.5-pro")
-            .optional()
-            .describe("Gemini LLM model identifier to use for analysis defaults to gemini-2.5-pro"),
-        featureFlag: zod_1.default
-            .enum([
-            "none",
-            "send-all-frames",
-            "separate-threshold",
-            "ai-based-frames",
-        ])
-            .default("none")
-            .optional()
-            .describe("Feature flag to use for analysis defaults to none"),
-    })
-        .optional(),
-});
-exports.fetchVideoAnalysis = {
-    schema: {
-        name: "fetchVideoAnalysis",
-        description: `
-Analyzes Playwright test execution videos to identify test failures and UI issues.
-  
-**Input:** The video URL is mandatory (supports webm, mp4). DO NOT specify params UNLESS the user has explicitly asked for a specific param value to be tested.
-**Output:** analysis summary of what happened during the test execution.
-**Use when:** You have a failing test with a video recording and need to understand what went wrong`,
-        parameters: exports.videoAnalysisSchema,
-    },
-    needsBrowser: false,
-    isInlineTool: false,
-};

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

@@ -1,5 +0,0 @@
-import type { Tool } from "@empiricalrun/shared-types";
-import type { z } from "zod";
-import { type videoAnalysisSchema } from "../definitions/fetch-video-analysis";
-export declare const fetchVideoAnalysis: Tool<z.infer<typeof videoAnalysisSchema>>;
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/tools/fetch-video-analysis/index.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAEV,IAAI,EAIL,MAAM,4BAA4B,CAAC;AACpC,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAE7B,OAAO,EAEL,KAAK,mBAAmB,EACzB,MAAM,qCAAqC,CAAC;AAwC7C,eAAO,MAAM,kBAAkB,EAAE,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAoJxE,CAAC"}

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

@@ -1,138 +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.fetchVideoAnalysis = void 0;
-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 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",
-            input: { videoUrl },
-        });
-        try {
-            const ffmpegClient = new local_ffmpeg_client_1.LocalFFmpegClient();
-            const response = await fetch(videoUrl, { method: "HEAD" });
-            if (!response.ok) {
-                return {
-                    result: `Failed to access video at ${videoUrl}: ${response.statusText}`,
-                    isError: true,
-                };
-            }
-            const processingSpan = videoAnalysisSpan?.span({
-                name: "ffmpeg-processing",
-                input: {
-                    videoUrl,
-                    fps: effectiveFps,
-                    threshold: effectiveThreshold,
-                },
-            });
-            try {
-                const extractionResult = await ffmpegClient.extractVideoFrames(videoUrl, WORKING_DIR, {
-                    fps: effectiveFps,
-                    threshold: effectiveThreshold,
-                });
-                const { totalFramesCount, uniqueFrames } = extractionResult;
-                processingSpan?.end({
-                    output: {
-                        totalFramesCount,
-                        uniqueFramesCount: uniqueFrames.length,
-                    },
-                });
-                console.log(`[video-analysis] Analyzing ${uniqueFrames.length} frames with LLM`);
-                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: uniqueFrames.length,
-                    video_url: videoUrl,
-                    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,
-                };
-                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,
-                };
-                return {
-                    result: JSON.stringify(toolResult, null, 2),
-                    isError: false,
-                    usage,
-                };
-            }
-            catch (ffmpegError) {
-                processingSpan?.end();
-                throw ffmpegError;
-            }
-        }
-        catch (error) {
-            console.error("Error in video analysis", error);
-            videoAnalysisSpan?.end();
-            const message = error instanceof Error ? error.message : String(error);
-            return {
-                result: `Error analyzing video: ${message}`,
-                isError: true,
-            };
-        }
-        finally {
-            videoAnalysisSpan?.end();
-        }
-    },
-};

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

@@ -1 +0,0 @@
-{"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

@@ -1,247 +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("../../utils/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) {
-        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 startTime = i * LocalFFmpegClient.CHUNK_DURATION_SECONDS;
-            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);
-            try {
-                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) {
-                    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 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);
-            const duration = await this.getVideoDuration(videoPath);
-            console.log(`Video duration: ${Math.round(duration)} seconds`);
-            if (duration > LocalFFmpegClient.MAX_VIDEO_DURATION_SECONDS) {
-                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, 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");
-            }
-            return {
-                totalFramesCount: allFramesCount,
-                uniqueFrames: uniqueImages,
-            };
-        }
-        catch (error) {
-            throw new Error(`Frame extraction failed: ${error instanceof Error ? error.message : String(error)}`);
-        }
-    }
-}
-exports.LocalFFmpegClient = LocalFFmpegClient;

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

@@ -1,6 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,37 +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.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,13 +0,0 @@
-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 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 +0,0 @@
-{"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"}