@empiricalrun/test-gen 0.75.0 → 0.77.0

package/dist/video-core/index.d.ts

@@ -0,0 +1,44 @@
+import { VideoAnalysisParams } from "@empiricalrun/shared-types";
+export declare function parseVideoAnalysisParams(paramsString: string): VideoAnalysisParams;
+export declare function runVideoAnalysisForCli({ url, params, startServer, }: {
+    url: string;
+    params: string;
+    startServer?: boolean;
+}): Promise<import("./analysis-server").AnalysisServerHandle>;
+export declare function runVideoAnalysis({ videoUrl, videoUrlHash, params, featureFlags, workingDirectory, skipUpload, }: {
+    videoUrl: string;
+    videoUrlHash: string;
+    params: VideoAnalysisParams;
+    featureFlags: string[];
+    workingDirectory: string;
+    skipUpload?: boolean;
+}): Promise<{
+    result: {
+        total_extracted_frames: number;
+        video_duration: number;
+        unique_frames_count: number;
+        video_url: string;
+        analysis: string;
+        analysis_id: string;
+        params: VideoAnalysisParams;
+    };
+    unique_frames: import("@empiricalrun/shared-types").UniqueFrameInfos[];
+    interleaved_tool_result: import("@empiricalrun/shared-types").ToolResultPart[];
+    chat_messages: import("@empiricalrun/shared-types").CanonicalMessage[];
+    isError: boolean;
+} | {
+    result: {
+        total_extracted_frames: number;
+        video_duration: number;
+        unique_frames_count: number;
+        video_url: string;
+        analysis: string;
+        analysis_id: string;
+        params: VideoAnalysisParams;
+    };
+    interleaved_tool_result: never[];
+    chat_messages: never[];
+    isError: boolean;
+    unique_frames?: undefined;
+}>;
+//# sourceMappingURL=index.d.ts.map

package/dist/video-core/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/video-core/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAc,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAa7E,wBAAgB,wBAAwB,CACtC,YAAY,EAAE,MAAM,GACnB,mBAAmB,CAoCrB;AAED,wBAAsB,sBAAsB,CAAC,EAC3C,GAAG,EACH,MAAM,EACN,WAAkB,GACnB,EAAE;IACD,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB,6DAuFA;AAED,wBAAsB,gBAAgB,CAAC,EACrC,QAAQ,EACR,YAAY,EACZ,MAAM,EACN,YAAY,EACZ,gBAAgB,EAChB,UAAU,GACX,EAAE;IACD,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,MAAM,EAAE,mBAAmB,CAAC;IAC5B,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,gBAAgB,EAAE,MAAM,CAAC;IACzB,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyGA"}

package/dist/video-core/index.js

@@ -0,0 +1,204 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseVideoAnalysisParams = parseVideoAnalysisParams;
+exports.runVideoAnalysisForCli = runVideoAnalysisForCli;
+exports.runVideoAnalysis = runVideoAnalysis;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const constants_1 = require("../constants");
+const ffmpeg_1 = require("../utils/ffmpeg");
+const hash_1 = require("../utils/hash");
+const agent_orchestrator_1 = require("./agent-orchestrator");
+const model_limits_1 = require("./model-limits");
+const storage_manager_1 = require("./storage-manager");
+const utils_1 = require("./utils");
+function parseVideoAnalysisParams(paramsString) {
+    const defaults = {
+        model: constants_1.VIDEO_ANALYSIS.DEFAULT_MODEL,
+        fps: constants_1.VIDEO_ANALYSIS.DEFAULT_FPS,
+        threshold: constants_1.VIDEO_ANALYSIS.DEFAULT_THRESHOLD,
+    };
+    if (!paramsString?.trim())
+        return defaults;
+    const result = { ...defaults };
+    for (const chunk of paramsString.split(",")) {
+        const [key, value] = chunk.split("=").map((s) => s.trim());
+        if (!key || !value)
+            continue;
+        switch (key.toLowerCase()) {
+            case "fps":
+            case "threshold": {
+                const num = Number(value);
+                if (Number.isFinite(num))
+                    result[key] = num;
+                break;
+            }
+            case "model":
+                result.model = value;
+                break;
+            case "starttime":
+            case "start_time":
+                result.startTime = Number(value);
+                break;
+            case "duration":
+                result.duration = Number(value);
+                break;
+        }
+    }
+    return result;
+}
+async function runVideoAnalysisForCli({ url, params, startServer = true, }) {
+    console.log("🎬 Starting video analysis...");
+    console.log(`📹 Video URL: ${url}`);
+    console.log(`⚙️  Parameters: ${params || "default"}`);
+    const videoAnalysisParams = parseVideoAnalysisParams(params);
+    const videoUrlHash = (0, hash_1.createHashBasedOnParams)(url, videoAnalysisParams);
+    const WORKING_DIR = node_path_1.default.join("video-analysis", videoUrlHash);
+    let result;
+    const startTime = performance.now();
+    try {
+        const { result: analysisResult, unique_frames, interleaved_tool_result, chat_messages, } = await runVideoAnalysis({
+            videoUrl: url,
+            videoUrlHash,
+            params: videoAnalysisParams,
+            featureFlags: [],
+            workingDirectory: WORKING_DIR,
+            skipUpload: true,
+        });
+        result = {
+            ...analysisResult,
+            unique_frames: unique_frames,
+            interleaved_tool_result: interleaved_tool_result,
+            chat_messages: chat_messages,
+        };
+        const endTime = performance.now();
+        const durationMs = endTime - startTime;
+        console.log(`[Performance] Video analysis completed in ${durationMs.toFixed(2)}ms (${(durationMs / 1000).toFixed(2)}s)`);
+    }
+    catch (error) {
+        console.error("Error during video analysis:", error);
+        throw error;
+    }
+    console.log("✅ Video analysis completed!");
+    console.log(`📊 Found ${result.unique_frames_count} unique frames`);
+    if (startServer) {
+        const resultFileName = `analysis-result.json`;
+        await node_fs_1.default.promises.mkdir(WORKING_DIR, { recursive: true });
+        const resultFilePath = node_path_1.default.join(WORKING_DIR, resultFileName);
+        await node_fs_1.default.promises.writeFile(resultFilePath, JSON.stringify({ ...result, workingDir: WORKING_DIR }, null, 2));
+        console.log(`💾 Analysis result saved to: ${resultFilePath}`);
+        console.log("🚀 Starting analysis viewer server...");
+        // Dynamic import to avoid circular dependency
+        const { startAnalysisServer } = await import("./analysis-server.js");
+        const handle = await startAnalysisServer("video-analysis");
+        console.log(`🌐 Analysis viewer available at: ${handle.url}`);
+        console.log("📋 Press Ctrl+C to stop the server");
+        let isShuttingDown = false;
+        const gracefulShutdown = async (signal) => {
+            if (isShuttingDown)
+                return;
+            isShuttingDown = true;
+            console.log(`\n🛑 Received ${signal}, shutting down server...`);
+            try {
+                await handle.close();
+                process.exit(0);
+            }
+            catch (error) {
+                console.error("Error closing server:", error);
+                process.exit(1);
+            }
+        };
+        process.once("SIGINT", () => gracefulShutdown("SIGINT"));
+        process.once("SIGTERM", () => gracefulShutdown("SIGTERM"));
+        return handle;
+    }
+    else {
+        console.log("🚀 Analysis viewer server not started. Results available in the CLI.");
+        console.log(result);
+        process.exit(0);
+    }
+}
+async function runVideoAnalysis({ videoUrl, videoUrlHash, params, featureFlags, workingDirectory, skipUpload, }) {
+    try {
+        const ffmpegClient = new ffmpeg_1.LocalFFmpegClient();
+        const extractionResult = await ffmpegClient.extractVideoFrames(videoUrl, videoUrlHash, workingDirectory, {
+            fps: params.fps,
+            threshold: params.threshold,
+            startTime: params.startTime,
+            duration: params.duration,
+        });
+        const { totalFramesCount, uniqueFrameInfos, videoDurationSeconds } = extractionResult;
+        await (0, storage_manager_1.uploadFramesToR2)(videoUrlHash, uniqueFrameInfos);
+        const batchSize = await (0, model_limits_1.calculateOptimalBatchSize)(params.model, uniqueFrameInfos);
+        const frameBatch = uniqueFrameInfos
+            .map((f) => {
+            return {
+                name: f.fileName,
+                contentType: "image/png",
+                url: f.url,
+            };
+        })
+            .slice(0, batchSize);
+        const { analysis, allMessages, parsedXml } = await (0, agent_orchestrator_1.orchestrateVideoAnalysis)({
+            selectedModel: params.model,
+            featureFlags,
+            workingDirectory,
+            frameBatch,
+        });
+        const isTruncated = frameBatch.length !== batchSize;
+        const finalAnalysis = isTruncated
+            ? `NOTE: the unique frames to be processed were truncated to ${batchSize} due to limitations on the number of frames that can be processed in a single batch. ${analysis}`
+            : analysis;
+        const interleavedResults = (0, utils_1.createInterleavedResults)(parsedXml, uniqueFrameInfos);
+        const videoAnalysisSummary = {
+            total_extracted_frames: totalFramesCount,
+            video_duration: videoDurationSeconds,
+            unique_frames_count: uniqueFrameInfos.length,
+            video_url: videoUrl,
+            analysis: finalAnalysis,
+            analysis_id: videoUrlHash,
+            params,
+            interleaved_tool_result: interleavedResults,
+        };
+        if (!skipUpload) {
+            await (0, storage_manager_1.uploadSummaryToR2)(videoAnalysisSummary);
+            await (0, storage_manager_1.uploadChatStateToR2)(allMessages, videoUrlHash);
+        }
+        const toolResult = {
+            total_extracted_frames: totalFramesCount,
+            video_duration: videoDurationSeconds,
+            unique_frames_count: uniqueFrameInfos.length,
+            video_url: videoUrl,
+            analysis: finalAnalysis,
+            analysis_id: videoUrlHash,
+            params,
+        };
+        return {
+            result: toolResult,
+            unique_frames: uniqueFrameInfos,
+            interleaved_tool_result: interleavedResults,
+            chat_messages: allMessages,
+            isError: false,
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return {
+            result: {
+                total_extracted_frames: 0,
+                video_duration: 0,
+                unique_frames_count: 0,
+                video_url: videoUrl,
+                analysis: `Error during video analysis: ${errorMessage}`,
+                analysis_id: videoUrlHash,
+                params,
+            },
+            interleaved_tool_result: [],
+            chat_messages: [],
+            isError: true,
+        };
+    }
+}

package/dist/video-core/model-limits.d.ts

@@ -0,0 +1,4 @@
+import { SupportedChatModels, UniqueFrameInfos } from "@empiricalrun/shared-types";
+export declare function calculateActualBatchSize(uniqueFrameInfos: UniqueFrameInfos[]): Promise<number>;
+export declare function calculateOptimalBatchSize(model: SupportedChatModels, uniqueFrameInfos: UniqueFrameInfos[]): Promise<number>;
+//# sourceMappingURL=model-limits.d.ts.map

package/dist/video-core/model-limits.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-limits.d.ts","sourceRoot":"","sources":["../../src/video-core/model-limits.ts"],"names":[],"mappings":"AACA,OAAO,EACL,mBAAmB,EACnB,gBAAgB,EACjB,MAAM,4BAA4B,CAAC;AAgCpC,wBAAsB,wBAAwB,CAC5C,gBAAgB,EAAE,gBAAgB,EAAE,GACnC,OAAO,CAAC,MAAM,CAAC,CAwBjB;AAED,wBAAsB,yBAAyB,CAC7C,KAAK,EAAE,mBAAmB,EAC1B,gBAAgB,EAAE,gBAAgB,EAAE,GACnC,OAAO,CAAC,MAAM,CAAC,CAwBjB"}

package/dist/video-core/model-limits.js

@@ -0,0 +1,67 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateActualBatchSize = calculateActualBatchSize;
+exports.calculateOptimalBatchSize = calculateOptimalBatchSize;
+const node_fs_1 = __importDefault(require("node:fs"));
+const constants_1 = require("../constants");
+function isClaudeModel(model) {
+    return model.includes("claude") || model.includes("sonnet");
+}
+function isOpenAIModel(model) {
+    return model.includes("gpt") || model.includes("openai");
+}
+function getModelLimits(model) {
+    if (isClaudeModel(model)) {
+        return {
+            maxImages: constants_1.VIDEO_ANALYSIS.CLAUDE_MAX_IMAGES_PER_BATCH,
+            maxSizeMB: constants_1.VIDEO_ANALYSIS.CLAUDE_MAX_REQUEST_SIZE_MB,
+        };
+    }
+    if (isOpenAIModel(model)) {
+        return {
+            maxImages: constants_1.VIDEO_ANALYSIS.OPENAI_MAX_IMAGES_PER_BATCH,
+            maxSizeMB: constants_1.VIDEO_ANALYSIS.OPENAI_MAX_REQUEST_SIZE_MB,
+        };
+    }
+    return {
+        maxImages: 20,
+        maxSizeMB: 10,
+    };
+}
+async function calculateActualBatchSize(uniqueFrameInfos) {
+    try {
+        const sizes = await Promise.all(uniqueFrameInfos.map(async (frame, index) => {
+            const pathToUse = frame.path;
+            if (!pathToUse) {
+                throw new Error(`Frame ${index} has no path: ${JSON.stringify(frame)}`);
+            }
+            const stats = await node_fs_1.default.promises.stat(pathToUse);
+            return stats.size;
+        }));
+        const totalBytes = sizes.reduce((sum, size) => sum + size, 0);
+        const totalMB = totalBytes / (1024 * 1024);
+        return totalMB;
+    }
+    catch (error) {
+        return uniqueFrameInfos.length * constants_1.VIDEO_ANALYSIS.DEFAULT_FRAME_SIZE_MB;
+    }
+}
+async function calculateOptimalBatchSize(model, uniqueFrameInfos) {
+    if (!uniqueFrameInfos || uniqueFrameInfos.length === 0) {
+        throw new Error("framePaths are required to calculate the optimal batch size");
+    }
+    const limits = getModelLimits(model);
+    let batchSize = Math.min(limits.maxImages, uniqueFrameInfos.length);
+    while (batchSize > 0) {
+        const frameBatch = uniqueFrameInfos.slice(0, batchSize);
+        const actualBatchSizeMB = await calculateActualBatchSize(frameBatch);
+        if (actualBatchSizeMB <= limits.maxSizeMB) {
+            return batchSize;
+        }
+        batchSize = Math.floor(batchSize * constants_1.VIDEO_ANALYSIS.BATCH_SIZE_REDUCTION_FACTOR);
+    }
+    return 1;
+}

package/dist/video-core/storage-manager.d.ts

@@ -0,0 +1,5 @@
+import type { CanonicalMessage, UniqueFrameInfos, VideoAnalysisSummary } from "@empiricalrun/shared-types";
+export declare const uploadFramesToR2: (videoUrlHash: string, frames: UniqueFrameInfos[]) => Promise<void>;
+export declare const uploadSummaryToR2: (videoInfo: VideoAnalysisSummary) => Promise<void>;
+export declare function uploadChatStateToR2(allMessages: CanonicalMessage[], videoUrlHash: string): Promise<void>;
+//# sourceMappingURL=storage-manager.d.ts.map

package/dist/video-core/storage-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-manager.d.ts","sourceRoot":"","sources":["../../src/video-core/storage-manager.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,gBAAgB,EAChB,gBAAgB,EAChB,oBAAoB,EACrB,MAAM,4BAA4B,CAAC;AAoCpC,eAAO,MAAM,gBAAgB,GAC3B,cAAc,MAAM,EACpB,QAAQ,gBAAgB,EAAE,KACzB,OAAO,CAAC,IAAI,CAQd,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAC5B,WAAW,oBAAoB,KAC9B,OAAO,CAAC,IAAI,CAWd,CAAC;AAEF,wBAAsB,mBAAmB,CACvC,WAAW,EAAE,gBAAgB,EAAE,EAC/B,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC,IAAI,CAAC,CAWf"}

package/dist/video-core/storage-manager.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uploadSummaryToR2 = exports.uploadFramesToR2 = void 0;
+exports.uploadChatStateToR2 = uploadChatStateToR2;
+const r2_uploader_1 = require("@empiricalrun/r2-uploader");
+const uploadToR2 = 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 (videoUrlHash, frames) => {
+    const frameFiles = frames.map((f) => ({
+        buffer: Buffer.from(f.base64, "base64"),
+        fileName: f.fileName,
+        mimeType: "image/png",
+    }));
+    await uploadToR2(frameFiles, videoUrlHash);
+};
+exports.uploadFramesToR2 = uploadFramesToR2;
+const uploadSummaryToR2 = async (videoInfo) => {
+    await uploadToR2([
+        {
+            buffer: Buffer.from(JSON.stringify(videoInfo, null, 2)),
+            fileName: "summary.json",
+            mimeType: "application/json",
+        },
+    ], videoInfo.analysis_id);
+};
+exports.uploadSummaryToR2 = uploadSummaryToR2;
+async function uploadChatStateToR2(allMessages, videoUrlHash) {
+    await uploadToR2([
+        {
+            buffer: Buffer.from(JSON.stringify(allMessages)),
+            fileName: "chat-state.json",
+            mimeType: "application/json",
+        },
+    ], videoUrlHash);
+}

package/dist/video-core/types.d.ts

@@ -0,0 +1,13 @@
+import type { VideoAnalysisToolResponse } from "@empiricalrun/shared-types";
+export interface AnalysisProcessingContext {
+    rawAnalysis: string;
+    artifactsPath: string;
+}
+export interface ProcessedAnalysis {
+    parsedXml: VideoAnalysisToolResponse[];
+    keyFrameImagesMap: Map<string, {
+        type: "image/png";
+        base64Data: string;
+    }>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/video-core/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/video-core/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,4BAA4B,CAAC;AAE5E,MAAM,WAAW,yBAAyB;IACxC,WAAW,EAAE,MAAM,CAAC;IACpB,aAAa,EAAE,MAAM,CAAC;CACvB;AAED,MAAM,WAAW,iBAAiB;IAChC,SAAS,EAAE,yBAAyB,EAAE,CAAC;IACvC,iBAAiB,EAAE,GAAG,CAAC,MAAM,EAAE;QAAE,IAAI,EAAE,WAAW,CAAC;QAAC,UAAU,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAC3E"}

package/dist/video-core/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/video-core/utils.d.ts

@@ -0,0 +1,25 @@
+import { ToolResultPart, UniqueFrameInfos, VideoAnalysisToolResponse } from "@empiricalrun/shared-types";
+export declare const getR2BaseUrlByHash: (videoUrlHash: string) => string;
+export declare const parseXmlSummaryToJson: (xmlContent: string) => Array<VideoAnalysisToolResponse>;
+export declare function loadKeyFrameImages(keyFrames: string[], extractionArtifactsDir: string): Promise<Map<string, {
+    type: "image/png";
+    base64Data: string;
+}>>;
+export declare function createInterleavedResults(parsedAnalysis: VideoAnalysisToolResponse[], uniqueFrameInfos: UniqueFrameInfos[]): ToolResultPart[];
+export interface VideoValidationResult {
+    isValid: boolean;
+    error?: string;
+}
+export declare function validateVideoAccess(videoUrl: string): Promise<VideoValidationResult>;
+export declare function downloadVideo(videoUrl: string, outputPath: string): Promise<void>;
+export declare function convertFramesForUpload(keyFrameImagesMap: Map<string, {
+    type: "image/png";
+    base64Data: string;
+}>): {
+    metadata: {
+        index: number;
+        path: string;
+    };
+    image: string;
+}[];
+//# sourceMappingURL=utils.d.ts.map

package/dist/video-core/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../src/video-core/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EACd,gBAAgB,EAChB,yBAAyB,EAC1B,MAAM,4BAA4B,CAAC;AAIpC,eAAO,MAAM,kBAAkB,GAAI,cAAc,MAAM,WAEtD,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAChC,YAAY,MAAM,KACjB,KAAK,CAAC,yBAAyB,CAyCjC,CAAC;AA8DF,wBAAsB,kBAAkB,CACtC,SAAS,EAAE,MAAM,EAAE,EACnB,sBAAsB,EAAE,MAAM,GAC7B,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC,CAkBjE;AAED,wBAAgB,wBAAwB,CACtC,cAAc,EAAE,yBAAyB,EAAE,EAC3C,gBAAgB,EAAE,gBAAgB,EAAE,GACnC,cAAc,EAAE,CAwClB;AAED,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,OAAO,CAAC;IACjB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AAED,wBAAsB,mBAAmB,CACvC,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,qBAAqB,CAAC,CAgBhC;AAED,wBAAsB,aAAa,CACjC,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,IAAI,CAAC,CAoDf;AAED,wBAAgB,sBAAsB,CACpC,iBAAiB,EAAE,GAAG,CAAC,MAAM,EAAE;IAAE,IAAI,EAAE,WAAW,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,CAAC,GACxE;IACD,QAAQ,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IAC1C,KAAK,EAAE,MAAM,CAAC;CACf,EAAE,CAiBF"}

package/dist/video-core/utils.js

@@ -0,0 +1,211 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseXmlSummaryToJson = exports.getR2BaseUrlByHash = void 0;
+exports.loadKeyFrameImages = loadKeyFrameImages;
+exports.createInterleavedResults = createInterleavedResults;
+exports.validateVideoAccess = validateVideoAccess;
+exports.downloadVideo = downloadVideo;
+exports.convertFramesForUpload = convertFramesForUpload;
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const getR2BaseUrlByHash = (videoUrlHash) => {
+    return `https://video-analysis.empirical.run/${videoUrlHash}/`;
+};
+exports.getR2BaseUrlByHash = getR2BaseUrlByHash;
+const parseXmlSummaryToJson = (xmlContent) => {
+    const sections = [];
+    try {
+        // Find the summary block first to limit parsing scope
+        const summaryMatch = xmlContent.match(/<summary>([\s\S]*?)<\/summary>/);
+        if (!summaryMatch) {
+            return sections;
+        }
+        const summaryContent = summaryMatch[1];
+        if (!summaryContent) {
+            return sections;
+        }
+        // Extract all section blocks using matchAll to avoid infinite loop
+        const sectionMatches = Array.from(summaryContent.matchAll(/<section>([\s\S]*?)<\/section>/g) || []);
+        for (const sectionMatch of sectionMatches) {
+            const sectionContent = sectionMatch?.[1];
+            if (!sectionContent)
+                continue;
+            const keyFrameMatch = sectionContent.match(/<key_frame>(.*?)<\/key_frame>/);
+            const descriptionMatch = sectionContent.match(/<description>(.*?)<\/description>/);
+            if (keyFrameMatch?.[1] && descriptionMatch?.[1]) {
+                sections.push({
+                    key_frame: keyFrameMatch[1].trim(),
+                    description: descriptionMatch[1].trim(),
+                });
+            }
+        }
+    }
+    catch (error) { }
+    return sections;
+};
+exports.parseXmlSummaryToJson = parseXmlSummaryToJson;
+async function fileExists(filePath) {
+    return fs_1.promises
+        .access(filePath)
+        .then(() => true)
+        .catch(() => false);
+}
+// Try unique_frames directory first, then consolidated_frames as fallback
+async function findFramePath(frameId, baseDir) {
+    const uniqueFramePath = path_1.default.join(baseDir, "unique_frames", `${frameId}.png`);
+    const consolidatedFramePath = path_1.default.join(baseDir, "consolidated_frames", `${frameId}.png`);
+    if (await fileExists(uniqueFramePath)) {
+        return uniqueFramePath;
+    }
+    if (await fileExists(consolidatedFramePath)) {
+        return consolidatedFramePath;
+    }
+    return null;
+}
+async function loadFrameImage(framePath) {
+    const imageBuffer = await fs_1.promises.readFile(framePath);
+    const base64Data = imageBuffer.toString("base64");
+    return {
+        type: "image/png",
+        base64Data: base64Data,
+    };
+}
+async function loadSingleFrame(frameId, extractionArtifactsDir) {
+    try {
+        const framePath = await findFramePath(frameId, extractionArtifactsDir);
+        if (!framePath) {
+            return null;
+        }
+        const imageData = await loadFrameImage(framePath);
+        return {
+            frameId: frameId,
+            imageData,
+        };
+    }
+    catch (error) {
+        return null;
+    }
+}
+async function loadKeyFrameImages(keyFrames, extractionArtifactsDir) {
+    const frameImageParts = await Promise.all(keyFrames.map((frameId) => loadSingleFrame(frameId, extractionArtifactsDir)));
+    const frameImageMap = new Map();
+    frameImageParts
+        .filter((part) => part !== null)
+        .forEach(({ frameId, imageData }) => {
+        frameImageMap.set(frameId, imageData);
+    });
+    return frameImageMap;
+}
+function createInterleavedResults(parsedAnalysis, uniqueFrameInfos) {
+    const interleavedResults = [];
+    if (parsedAnalysis && Array.isArray(parsedAnalysis)) {
+        for (const section of parsedAnalysis) {
+            // Add section text
+            interleavedResults.push({
+                type: "text",
+                text: JSON.stringify(section),
+            });
+            // Add corresponding frame image if available
+            if (section.key_frame && uniqueFrameInfos.length > 0) {
+                const sectionFrameId = section.key_frame;
+                // Extract frame index from frameId (e.g., "frame_6" -> 6)
+                const frameNumberMatch = sectionFrameId.match(/frame_(\d+)/);
+                const frameIndex = frameNumberMatch && frameNumberMatch[1]
+                    ? parseInt(frameNumberMatch[1], 10)
+                    : null;
+                if (frameIndex !== null) {
+                    // Find the corresponding uploaded frame by index
+                    const uploadedFrame = uniqueFrameInfos.find((frame) => frame.index === frameIndex);
+                    if (uploadedFrame) {
+                        interleavedResults.push({
+                            type: "image/png",
+                            url: uploadedFrame.url,
+                        });
+                    }
+                }
+            }
+        }
+    }
+    return interleavedResults;
+}
+async function validateVideoAccess(videoUrl) {
+    try {
+        const response = await fetch(videoUrl, { method: "HEAD" });
+        if (!response.ok) {
+            return {
+                isValid: false,
+                error: `Failed to access video at ${videoUrl}: ${response.statusText}`,
+            };
+        }
+        return { isValid: true };
+    }
+    catch (error) {
+        return {
+            isValid: false,
+            error: `Network error accessing video: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+}
+async function downloadVideo(videoUrl, outputPath) {
+    if (await fileExists(outputPath)) {
+        return;
+    }
+    const response = await fetch(videoUrl);
+    if (!response.ok) {
+        throw new Error(`Failed to download video: ${response.statusText}`);
+    }
+    const contentLength = response.headers.get("content-length");
+    const totalSize = contentLength ? parseInt(contentLength, 10) : 0;
+    if (!response.body) {
+        throw new Error("Response body is null");
+    }
+    const reader = response.body.getReader();
+    const chunks = [];
+    let downloadedSize = 0;
+    const startTime = Date.now();
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        chunks.push(value);
+        downloadedSize += value.length;
+        const elapsedSeconds = (Date.now() - startTime) / 1000;
+        const speed = elapsedSeconds > 0 ? downloadedSize / elapsedSeconds : 0;
+        const speedMBps = (speed / 1024 / 1024).toFixed(1);
+        if (totalSize > 0) {
+            const percentage = Math.round((downloadedSize / totalSize) * 100);
+            const progressBar = "█".repeat(Math.floor(percentage / 5)) +
+                "░".repeat(20 - Math.floor(percentage / 5));
+            process.stdout.write(`\r[${progressBar}] ${percentage}% (${(downloadedSize / 1024 / 1024).toFixed(1)} MB) ${speedMBps} MB/s`);
+        }
+        else {
+            process.stdout.write(`\rDownloaded: ${(downloadedSize / 1024 / 1024).toFixed(1)} MB @ ${speedMBps} MB/s`);
+        }
+    }
+    const buffer = new Uint8Array(downloadedSize);
+    let offset = 0;
+    for (const chunk of chunks) {
+        buffer.set(chunk, offset);
+        offset += chunk.length;
+    }
+    await fs_1.promises.writeFile(outputPath, buffer);
+}
+function convertFramesForUpload(keyFrameImagesMap) {
+    return Array.from(keyFrameImagesMap.entries()).map(([frameId, imageData]) => {
+        // Extract frame index from frameId (e.g., "frame_000006" -> 6)
+        const frameNumberMatch = frameId.match(/frame_(\d+)/);
+        const frameIndex = frameNumberMatch && frameNumberMatch[1]
+            ? parseInt(frameNumberMatch[1], 10)
+            : 0;
+        return {
+            metadata: {
+                index: frameIndex,
+                path: `${frameId}.png`,
+            },
+            image: imageData.base64Data,
+        };
+    });
+}

package/dist/video-core/xml-parser.d.ts

@@ -0,0 +1,3 @@
+import { AnalysisProcessingContext, ProcessedAnalysis } from "./types";
+export declare function processAnalysisAndLoadFrames({ rawAnalysis, artifactsPath, }: AnalysisProcessingContext): Promise<ProcessedAnalysis>;
+//# sourceMappingURL=xml-parser.d.ts.map

package/dist/video-core/xml-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"xml-parser.d.ts","sourceRoot":"","sources":["../../src/video-core/xml-parser.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,yBAAyB,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAmBvE,wBAAsB,4BAA4B,CAAC,EACjD,WAAW,EACX,aAAa,GACd,EAAE,yBAAyB,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAiBxD"}