@empiricalrun/test-gen 0.73.1 → 0.74.1

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

@@ -0,0 +1,89 @@
+"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 crypto_1 = __importDefault(require("crypto"));
+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");
+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 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 },
+            });
+            try {
+                const { totalFramesCount, uniqueFramesCount, uniqueFrames } = await ffmpegClient.extractVideoFrames(videoUrl, "./temp");
+                processingSpan?.end({
+                    output: {
+                        totalFramesCount,
+                        uniqueFramesCount,
+                    },
+                });
+                console.log(`[video-analysis] Analyzing ${uniqueFrames.length} frames with LLM`);
+                const videoInfoWithoutAnalysis = {
+                    total_frames_count: totalFramesCount,
+                    unique_frames_count: uniqueFramesCount,
+                    video_url: videoUrl,
+                    video_url_hash: videoUrlHash,
+                    created_at: new Date().toISOString(),
+                };
+                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,
+                };
+                const uniqueFramesWithUrls = await framesUploadPromise;
+                await (0, utils_1.uploadAnalysisToR2)(videoInfo, uniqueFramesWithUrls, R2_BASE_URL);
+                return {
+                    result: JSON.stringify(videoInfo, 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

@@ -0,0 +1,24 @@
+export declare class LocalFFmpegClient {
+    private static readonly MAX_VIDEO_DURATION_SECONDS;
+    private static readonly CHUNK_DURATION_SECONDS;
+    constructor();
+    private checkFFmpegAvailability;
+    private getVideoDuration;
+    private validateVideoChunk;
+    private downloadVideo;
+    private createVideoChunks;
+    private extractFramesToFiles;
+    private processVideoChunks;
+    extractVideoFrames(videoUrl: string, outputDir: string): Promise<{
+        totalFramesCount: number;
+        uniqueFramesCount: number;
+        uniqueFrames: {
+            metadata: {
+                index: number;
+                path: string;
+            };
+            image: string;
+        }[];
+    }>;
+}
+//# sourceMappingURL=local-ffmpeg-client.d.ts.map

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

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

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

@@ -0,0 +1,209 @@
+"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 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);
+            const command = `ffmpeg -i "${videoPath}" -ss ${startTime} -t ${chunkDuration} -c:v libx264 -c:a aac -preset ultrafast -crf 28 "${chunkPath}"`;
+            try {
+                await execAsync(command);
+                // 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) {
+        await fs_1.promises.mkdir(outputDir, { recursive: true });
+        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}`);
+        try {
+            await execAsync(command);
+        }
+        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) {
+        const allFramePaths = [];
+        const consolidatedFramesDir = path_1.default.join(workingDir, "consolidated_frames");
+        await fs_1.promises.mkdir(consolidatedFramesDir, { recursive: true });
+        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);
+                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) {
+        const workingDir = path_1.default.join(process.cwd(), outputDir);
+        const videoPath = path_1.default.join(workingDir, `video-${Date.now()}.webm`);
+        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);
+            const allFramesCount = allFramePaths.length;
+            const uniqueImages = await (0, dedup_image_fs_1.deduplicateImageFiles)({
+                imagePaths: allFramePaths,
+                batchSize: 50,
+                threshold: 0.001,
+                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,
+                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/utils.d.ts

@@ -0,0 +1,10 @@
+import { UniqueFrameInfo, VideoAnalysisInfo } from "@empiricalrun/shared-types";
+export declare const uploadFramesToR2: (videoInfo: Omit<VideoAnalysisInfo, "llm_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>;
+//# sourceMappingURL=utils.d.ts.map

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

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

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

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadAnalysisToR2 = exports.uploadFramesToR2 = void 0;
+const r2_uploader_1 = require("@empiricalrun/r2-uploader");
+const uploadFilesToR2 = async (files, videoUrlHash) => {
+    const label = `video-analysis-upload:${videoUrlHash}`;
+    const start = Date.now();
+    console.log(`[${label}] preparing ${files.length} files for upload...`);
+    console.log(`[${label}] starting upload of ${files.length} files to video-analysis/${videoUrlHash}/...`);
+    const interval = setInterval(() => {
+        const secs = Math.round((Date.now() - start) / 1000);
+        console.log(`[${label}] uploading... ${secs}s elapsed`);
+    }, 1000);
+    try {
+        await (0, r2_uploader_1.uploadInMemoryFiles)({
+            files,
+            destinationDir: videoUrlHash,
+            uploadBucket: "video-analysis",
+        });
+    }
+    finally {
+        clearInterval(interval);
+        const secs = Math.round((Date.now() - start) / 1000);
+        console.log(`[${label}] upload complete in ${secs}s`);
+    }
+};
+const uploadFramesToR2 = async (videoInfo, frames, r2BaseUrl) => {
+    const { video_url_hash: videoUrlHash } = videoInfo;
+    const frameFiles = frames.map((f) => {
+        const fileName = `frame_${f.metadata.index}_${videoUrlHash}.png`;
+        const buffer = Buffer.from(f.image, "base64");
+        return { buffer, fileName, mimeType: "image/png" };
+    });
+    console.log(`[video-analysis-upload] uploading ${frameFiles.length} frames to video-analysis/${videoUrlHash}/...`);
+    await uploadFilesToR2(frameFiles, videoUrlHash);
+    return frames.map((f) => ({
+        index: f.metadata.index,
+        path: f.metadata.path,
+        fileName: `frame_${f.metadata.index}_${videoUrlHash}.png`,
+        url: `${r2BaseUrl}frame_${f.metadata.index}_${videoUrlHash}.png`,
+    }));
+};
+exports.uploadFramesToR2 = uploadFramesToR2;
+const uploadAnalysisToR2 = async (videoInfo, uniqueFrames, 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 filesToUpload = [
+            {
+                buffer: Buffer.from(JSON.stringify(summary, null, 2)),
+                fileName: "summary.json",
+                mimeType: "application/json",
+            },
+        ];
+        console.log(`[video-analysis-upload] uploading ${filesToUpload.length} files to video-analysis/${videoUrlHash}/...`);
+        await uploadFilesToR2(filesToUpload, videoUrlHash);
+        return r2BaseUrl;
+    }
+    catch (error) {
+        console.error("Error uploading video analysis to R2:", error);
+        throw error;
+    }
+};
+exports.uploadAnalysisToR2 = uploadAnalysisToR2;

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

@@ -0,0 +1,7 @@
+import { TraceClient } from "@empiricalrun/llm";
+import { SupportedChatModels, Usage } from "@empiricalrun/shared-types";
+export declare function analyzeFramesWithLLM(frameBase64Data: string[], trace?: TraceClient, selectedModel?: SupportedChatModels, apiKey?: string): Promise<{
+    analysis: string;
+    usage: Usage;
+}>;
+//# sourceMappingURL=video-analysis.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"video-analysis.d.ts","sourceRoot":"","sources":["../../../src/tools/fetch-video-analysis/video-analysis.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAEhD,OAAO,EAEL,mBAAmB,EACnB,KAAK,EACN,MAAM,4BAA4B,CAAC;AAIpC,wBAAsB,oBAAoB,CACxC,eAAe,EAAE,MAAM,EAAE,EACzB,KAAK,CAAC,EAAE,WAAW,EACnB,aAAa,CAAC,EAAE,mBAAmB,EACnC,MAAM,CAAC,EAAE,MAAM,GACd,OAAO,CAAC;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,KAAK,CAAA;CAAE,CAAC,CAgE7C"}

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

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeFramesWithLLM = analyzeFramesWithLLM;
+const chat_1 = require("@empiricalrun/llm/chat");
+const models_1 = require("../../agent/chat/models");
+async function analyzeFramesWithLLM(frameBase64Data, trace, selectedModel, apiKey) {
+    const llmSpan = trace?.span({
+        name: "llm-frame-analysis",
+        input: { frameCount: frameBase64Data.length },
+    });
+    const selectedChatModel = selectedModel || (0, models_1.getDefaultChatModelId)();
+    try {
+        // TODO: Move to canonical chat model
+        let chatModel = new chat_1.GeminiChatModel(selectedChatModel, [], apiKey || process.env.GOOGLE_API_KEY);
+        chatModel.validateEnvVarsForAuth();
+        const frameAttachments = frameBase64Data.map((frameBase64, index) => ({
+            base64Data: frameBase64,
+            contentType: "image/png",
+            name: `frame-${index}.png`,
+        }));
+        const userMessage = `
+Analyze the ${frameBase64Data.length} frames that are extracted from a screen recording.`;
+        chatModel.pushUserMessage(userMessage, frameAttachments);
+        const systemPrompt = `
+You are given a set of unique frames from a screen recording. Your job is to return a verbose bullet list of what is going on in the video. Don't miss out on anything.
+`;
+        // Get LLM response
+        const response = await chatModel.getLLMResponse({
+            systemPrompt,
+            tools: [], // No tools needed for this analysis
+            selectedModel: selectedChatModel,
+            trace: llmSpan,
+            hasThinkingEnabled: false,
+            hasInterleavedThinkingEnabled: false,
+        });
+        if (!response) {
+            throw new Error("No response from LLM");
+        }
+        chatModel.pushMessage(response);
+        const usage = chatModel.getUsage();
+        const analysisResult = chatModel.getHumanReadableLatestMessage();
+        llmSpan?.end({ output: { analysis: analysisResult?.textMessage } });
+        return {
+            analysis: analysisResult?.textMessage || "No analysis generated",
+            usage,
+        };
+    }
+    catch (error) {
+        console.error("Error in LLM frame analysis", error);
+        llmSpan?.end();
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Error analyzing frames with AI: ${message}`);
+    }
+}

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

@@ -0,0 +1,11 @@
+import { CollectArtifacts, ToolResult } from "@empiricalrun/shared-types";
+import type { StrReplaceInputParams } from "./shared/helpers";
+declare function fileCreateExecutor({ input, filePath, absoluteFilePath, repoDir, collectArtifacts, }: {
+    input: StrReplaceInputParams;
+    filePath: string;
+    absoluteFilePath: string;
+    repoDir: string;
+    collectArtifacts?: CollectArtifacts;
+}): Promise<ToolResult>;
+export { fileCreateExecutor };
+//# sourceMappingURL=create.d.ts.map

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

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

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

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fileCreateExecutor = fileCreateExecutor;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const web_1 = require("../../bin/utils/platform/web");
+const git_helper_1 = require("./shared/git-helper");
+async function fileCreateExecutor({ input, filePath, absoluteFilePath, repoDir, collectArtifacts, }) {
+    if (input.file_text === undefined || input.file_text === null) {
+        return {
+            result: "Error: file_text is required for create command",
+            isError: true,
+        };
+    }
+    if (filePath.endsWith("test.ts")) {
+        return {
+            result: "Error: Creating test.ts files is not allowed. Did you mean spec.ts?",
+            isError: true,
+        };
+    }
+    if (filePath.endsWith("spec.ts") && !filePath.startsWith("tests/")) {
+        return {
+            result: "Error: Creating spec.ts files is not allowed outside tests/ directory",
+            isError: true,
+        };
+    }
+    const fileName = path_1.default.basename(filePath);
+    if (!fileName.includes(".")) {
+        return {
+            result: `Error: File name must include a file extension. This tool cannot create empty directories.
+If you need to create a file which is inside a directory that does not exist, you can expect this tool to create
+the required directories recursively for the new file.`,
+            isError: true,
+        };
+    }
+    const parentDir = path_1.default.dirname(absoluteFilePath);
+    if (parentDir !== "." && !fs_1.default.existsSync(parentDir)) {
+        // Ensure parent directory exists
+        fs_1.default.mkdirSync(parentDir, { recursive: true });
+    }
+    fs_1.default.writeFileSync(absoluteFilePath, input.file_text);
+    // 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) {
+        return {
+            result: `File ${filePath} has been created. However, type checks are failing with errors:\n\n${createTypescriptResult.errors.join("\n")}`,
+            isError: true,
+        };
+    }
+    else {
+        return {
+            result: `Successfully created file ${filePath}`,
+            isError: false,
+        };
+    }
+}

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

@@ -0,0 +1,15 @@
+import { CollectArtifacts, IDashboardAPIClient, Tool, ToolResult } from "@empiricalrun/shared-types";
+import { StrReplaceInputParams } from "./shared/helpers";
+/**
+ * Our implementation of Claude's built-in text editor tool
+ * https://docs.anthropic.com/en/docs/build-with-claude/tool-use/text-editor-tool
+ */
+declare function strReplaceEditorExecutor({ input, repoPath, collectArtifacts, apiClient, }: {
+    input: StrReplaceInputParams;
+    repoPath: string;
+    collectArtifacts?: CollectArtifacts;
+    apiClient?: IDashboardAPIClient;
+}): Promise<ToolResult>;
+declare const textEditorTools: Tool[];
+export { strReplaceEditorExecutor, textEditorTools };
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/tools/file-operations/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAChB,mBAAmB,EACnB,IAAI,EAEJ,UAAU,EACX,MAAM,4BAA4B,CAAC;AAQpC,OAAO,EAAE,qBAAqB,EAAE,MAAM,kBAAkB,CAAC;AAGzD;;;GAGG;AACH,iBAAe,wBAAwB,CAAC,EACtC,KAAK,EACL,QAAQ,EACR,gBAAgB,EAChB,SAAS,GACV,EAAE;IACD,KAAK,EAAE,qBAAqB,CAAC;IAC7B,QAAQ,EAAE,MAAM,CAAC;IACjB,gBAAgB,CAAC,EAAE,gBAAgB,CAAC;IACpC,SAAS,CAAC,EAAE,mBAAmB,CAAC;CACjC,GAAG,OAAO,CAAC,UAAU,CAAC,CAoDtB;AA+ED,QAAA,MAAM,eAAe,EAAE,IAAI,EAK1B,CAAC;AAEF,OAAO,EAAE,wBAAwB,EAAE,eAAe,EAAE,CAAC"}