@empiricalrun/test-gen 0.76.0 → 0.77.0

package/dist/video-core/agent-orchestrator.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractTextPartFromLastMessage = extractTextPartFromLastMessage;
+exports.getChatStateWithFrameIdAttachmentParts = getChatStateWithFrameIdAttachmentParts;
+exports.orchestrateVideoAnalysis = orchestrateVideoAnalysis;
+const agent_1 = require("../agent");
+const state_1 = require("../agent/chat/state");
+const executor_1 = require("../agent/video-analysis/executor");
+const xml_parser_1 = require("./xml-parser");
+function extractTextPartFromLastMessage(messages) {
+    const lastMessage = messages.length
+        ? messages[messages.length - 1]
+        : undefined;
+    if (!lastMessage) {
+        return null;
+    }
+    return lastMessage.parts
+        .filter((p) => "text" in p && !("thinking" in p && p.thinking))
+        .map((p) => p.text)
+        .join("\\n");
+}
+function getChatStateWithFrameIdAttachmentParts(attachments, selectedModel) {
+    const chatState = (0, state_1.createChatState)({
+        userPrompt: `Analyse the frames and give me a summary at the end.`,
+        attachments: [],
+        existingState: undefined,
+        selectedModel,
+        error: null,
+    });
+    const userMessageWithAttachment = attachments.map((attachment) => ({
+        text: `Frame ID: ${attachment.name.split(".")[0]}`,
+        attachments: [attachment],
+    }));
+    chatState.messages[0].parts = [
+        ...chatState.messages[0].parts,
+        ...userMessageWithAttachment,
+    ];
+    return chatState;
+}
+async function orchestrateVideoAnalysis({ selectedModel, featureFlags, workingDirectory, frameBatch, }) {
+    const frameIds = frameBatch
+        .map((attachment) => {
+        const filename = attachment.name || "";
+        // Remove .png extension if present
+        return filename.replace(/\.png$/, "");
+    })
+        .filter(Boolean)
+        .join(", ");
+    const allMessages = [];
+    const toolExecutor = new executor_1.VideoAnalysisToolExecutor({
+        chatSession: null,
+        repoPath: workingDirectory,
+        featureFlags,
+        environmentOverrides: {},
+    });
+    const chatState = getChatStateWithFrameIdAttachmentParts(frameBatch, selectedModel);
+    const agent = new agent_1.VideoAnalysisAgent({
+        featureFlags: featureFlags,
+        selectedModel,
+        chatState,
+        toolExecutor,
+    });
+    while (!agent.askUserForInput) {
+        await agent.runLoop({
+            reporter: async () => { },
+        });
+    }
+    allMessages.push(...agent.messages);
+    const rawAnalysis = extractTextPartFromLastMessage(allMessages);
+    if (!rawAnalysis) {
+        throw new Error("Could not extract text response from accumulated messages");
+    }
+    const { parsedXml, keyFrameImagesMap } = await (0, xml_parser_1.processAnalysisAndLoadFrames)({
+        rawAnalysis,
+        artifactsPath: workingDirectory,
+    });
+    return { analysis: rawAnalysis, allMessages, parsedXml, keyFrameImagesMap };
+}

package/dist/video-core/analysis-server.d.ts

@@ -0,0 +1,24 @@
+import http from "http";
+export type AnalysisServerOptions = {
+    htmlFilePath?: string;
+    port?: number;
+    host?: string;
+};
+export type AnalysisData = {
+    unique_frames_count: number;
+    video_url: string;
+    analysis: string;
+    analysis_id: string;
+    params: any;
+    unique_frames: any[];
+    interleaved_tool_result: any;
+};
+export type AnalysisServerHandle = {
+    url: string;
+    port: number;
+    host: string;
+    server: http.Server;
+    close: () => Promise<void>;
+};
+export declare function startAnalysisServer(rootPath?: string): Promise<AnalysisServerHandle>;
+//# sourceMappingURL=analysis-server.d.ts.map

package/dist/video-core/analysis-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analysis-server.d.ts","sourceRoot":"","sources":["../../src/video-core/analysis-server.ts"],"names":[],"mappings":"AACA,OAAO,IAAI,MAAM,MAAM,CAAC;AA+DxB,MAAM,MAAM,qBAAqB,GAAG;IAClC,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IACzB,mBAAmB,EAAE,MAAM,CAAC;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,MAAM,EAAE,GAAG,CAAC;IACZ,aAAa,EAAE,GAAG,EAAE,CAAC;IACrB,uBAAuB,EAAE,GAAG,CAAC;CAC9B,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG;IACjC,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,IAAI,CAAC,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC5B,CAAC;AAEF,wBAAsB,mBAAmB,CACvC,QAAQ,GAAE,MAAyB,GAClC,OAAO,CAAC,oBAAoB,CAAC,CAqa/B"}

package/dist/video-core/analysis-server.js

@@ -0,0 +1,398 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startAnalysisServer = startAnalysisServer;
+const fs_1 = __importDefault(require("fs"));
+const http_1 = __importDefault(require("http"));
+const open_1 = __importDefault(require("open"));
+const path_1 = __importDefault(require("path"));
+const url_1 = require("url");
+const find_threshold_1 = require("../utils/find-threshold");
+async function discoverAnalysisDirectories(rootPath) {
+    const analyses = [];
+    try {
+        await fs_1.default.promises.access(rootPath);
+        const entries = await fs_1.default.promises.readdir(rootPath, {
+            withFileTypes: true,
+        });
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                const dirPath = path_1.default.join(rootPath, entry.name);
+                const analysisFilePath = path_1.default.join(dirPath, "analysis-result.json");
+                try {
+                    await fs_1.default.promises.access(analysisFilePath);
+                    const fileData = await fs_1.default.promises.readFile(analysisFilePath, "utf8");
+                    const analysisData = JSON.parse(fileData);
+                    const stat = await fs_1.default.promises.stat(analysisFilePath);
+                    analyses.push({
+                        id: entry.name,
+                        name: entry.name,
+                        path: dirPath,
+                        data: analysisData,
+                        modifiedTime: stat.mtime,
+                    });
+                }
+                catch (error) {
+                    // Skip directories without analysis-result.json
+                    continue;
+                }
+            }
+        }
+        // Sort by modification time, newest first
+        analyses.sort((a, b) => b.modifiedTime.getTime() - a.modifiedTime.getTime());
+    }
+    catch (error) {
+        // Root path doesn't exist or is inaccessible
+        console.log(`Warning: Could not access root path ${rootPath}`);
+    }
+    return analyses;
+}
+async function startAnalysisServer(rootPath = "video-analysis") {
+    const host = "0.0.0.0";
+    const port = 63745;
+    const htmlFilePath = path_1.default.join(__dirname, "analysis-viewer.html");
+    let workingDir;
+    let currentAnalysisId;
+    await fs_1.default.promises.access(htmlFilePath, fs_1.default.constants.R_OK);
+    const server = http_1.default.createServer(async (req, res) => {
+        res.setHeader("Access-Control-Allow-Origin", "*");
+        res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+        res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+        if (req.method === "OPTIONS") {
+            res.statusCode = 200;
+            res.end();
+            return;
+        }
+        const url = new url_1.URL(req.url || "/", `http://${req.headers.host}`);
+        // API endpoint to list all available analyses
+        if (url.pathname === "/api/analyses" && req.method === "GET") {
+            const analyses = await discoverAnalysisDirectories(rootPath);
+            const analysesInfo = analyses.map((analysis) => ({
+                id: analysis.id,
+                name: analysis.name,
+                modifiedTime: analysis.modifiedTime.toISOString(),
+                video_url: analysis.data.video_url,
+                analysis_id: analysis.data.analysis_id,
+                unique_frames_count: analysis.data.unique_frames_count,
+            }));
+            res.statusCode = 200;
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify(analysesInfo));
+            return;
+        }
+        // API endpoint to get specific analysis data
+        if (url.pathname === "/api/data" && req.method === "GET") {
+            const analysisId = url.searchParams.get("id");
+            if (analysisId) {
+                const analyses = await discoverAnalysisDirectories(rootPath);
+                const analysis = analyses.find((a) => a.id === analysisId);
+                if (analysis) {
+                    workingDir = analysis.path;
+                    currentAnalysisId = analysisId;
+                    res.statusCode = 200;
+                    res.setHeader("Content-Type", "application/json");
+                    res.end(JSON.stringify(analysis.data));
+                    return;
+                }
+                else {
+                    res.statusCode = 404;
+                    res.end("Analysis not found");
+                    return;
+                }
+            }
+            else if (currentAnalysisId) {
+                // Return current analysis data if no ID specified but one is already loaded
+                const analyses = await discoverAnalysisDirectories(rootPath);
+                const analysis = analyses.find((a) => a.id === currentAnalysisId);
+                if (analysis) {
+                    res.statusCode = 200;
+                    res.setHeader("Content-Type", "application/json");
+                    res.end(JSON.stringify(analysis.data));
+                    return;
+                }
+            }
+            res.statusCode = 404;
+            res.end("No analysis specified or found");
+            return;
+        }
+        if (url.pathname === "/api/unique-frames" && req.method === "GET") {
+            res.statusCode = 200;
+            res.setHeader("Content-Type", "application/json");
+            if (!workingDir || !currentAnalysisId) {
+                res.statusCode = 404;
+                res.end("No analysis loaded or working directory not found");
+                return;
+            }
+            // Get current analysis data
+            const analyses = await discoverAnalysisDirectories(rootPath);
+            const analysis = analyses.find((a) => a.id === currentAnalysisId);
+            if (!analysis) {
+                res.statusCode = 404;
+                res.end("Current analysis not found");
+                return;
+            }
+            const uniqueFramesDir = path_1.default.join(workingDir, "unique_frames");
+            console.log("  Looking for frames in:", uniqueFramesDir);
+            // Get FPS from analysis data, default to 30 if not available
+            const fps = analysis.data?.params?.fps || 30;
+            console.log("  Using FPS:", fps);
+            try {
+                const frameFiles = fs_1.default
+                    .readdirSync(uniqueFramesDir)
+                    .filter((f) => f.endsWith(".png"))
+                    .sort();
+                console.log(`  Found ${frameFiles.length} PNG files`);
+                if (frameFiles.length > 0) {
+                    console.log("  Sample files:", frameFiles.slice(0, 3));
+                }
+                // Use async file operations for better performance
+                const frameDataPromises = frameFiles.map(async (filename, index) => {
+                    if (!filename)
+                        return null;
+                    const frameNumber = filename.match(/frame_(\d+)/)?.[1] || String(index);
+                    const framePath = path_1.default.join(uniqueFramesDir, filename);
+                    try {
+                        const stat = await fs_1.default.promises.stat(framePath);
+                        return {
+                            index: parseInt(frameNumber),
+                            path: filename,
+                            fileName: filename,
+                            url: `/api/frame/${encodeURIComponent(filename)}`,
+                            timestamp: `${Math.floor(parseInt(frameNumber) / fps / 60)}m${Math.floor((parseInt(frameNumber) / fps) % 60)
+                                .toString()
+                                .padStart(2, "0")}s`,
+                            size: stat.size,
+                            similarityPercentage: null, // Will be calculated on-demand
+                        };
+                    }
+                    catch (error) {
+                        console.log(`  Error reading stats for ${filename}:`, error instanceof Error ? error.message : "Unknown error");
+                        return null;
+                    }
+                });
+                const frameDataResults = await Promise.all(frameDataPromises);
+                const frameData = frameDataResults.filter((frame) => frame !== null);
+                res.end(JSON.stringify(frameData));
+                return;
+            }
+            catch (error) {
+                console.log("  Error reading directory:", error instanceof Error ? error.message : "Unknown error");
+                res.statusCode = 404;
+                res.end(`Error reading frames directory: ${error instanceof Error ? error.message : "Unknown error"}`);
+                return;
+            }
+        }
+        if (url.pathname === "/api/similarity" && req.method === "GET") {
+            if (!workingDir) {
+                res.statusCode = 404;
+                res.end("Working directory not found");
+                return;
+            }
+            const frame1 = url.searchParams.get("frame1");
+            const frame2 = url.searchParams.get("frame2");
+            if (!frame1 || !frame2) {
+                res.statusCode = 400;
+                res.end("Missing frame1 or frame2 parameter");
+                return;
+            }
+            const uniqueFramesDir = path_1.default.join(workingDir, "unique_frames");
+            const frame1Path = path_1.default.join(uniqueFramesDir, frame1);
+            const frame2Path = path_1.default.join(uniqueFramesDir, frame2);
+            try {
+                // Security checks
+                if (frame1.includes("..") ||
+                    frame1.includes("/") ||
+                    frame1.includes("\\") ||
+                    frame2.includes("..") ||
+                    frame2.includes("/") ||
+                    frame2.includes("\\")) {
+                    res.statusCode = 400;
+                    res.end("Invalid filename");
+                    return;
+                }
+                if (!frame1.endsWith(".png") || !frame2.endsWith(".png")) {
+                    res.statusCode = 400;
+                    res.end("Only PNG files are supported");
+                    return;
+                }
+                const [base64Image1, base64Image2] = await Promise.all([
+                    fs_1.default.promises
+                        .readFile(frame1Path)
+                        .then((buf) => buf.toString("base64")),
+                    fs_1.default.promises
+                        .readFile(frame2Path)
+                        .then((buf) => buf.toString("base64")),
+                ]);
+                const similarityPercentage = await (0, find_threshold_1.findSimilarityPercentage)(base64Image1, base64Image2);
+                res.statusCode = 200;
+                res.setHeader("Content-Type", "application/json");
+                res.end(JSON.stringify({ similarity: similarityPercentage }));
+                return;
+            }
+            catch (error) {
+                console.log(`  Error calculating similarity for ${frame1} vs ${frame2}:`, error instanceof Error ? error.message : "Unknown error");
+                res.statusCode = 500;
+                res.end("Error calculating similarity");
+                return;
+            }
+        }
+        if (url.pathname.startsWith("/api/frame/") && req.method === "GET") {
+            if (!workingDir) {
+                res.statusCode = 404;
+                res.end("Working directory not found");
+                return;
+            }
+            const filename = decodeURIComponent(url.pathname.substring("/api/frame/".length));
+            const uniqueFramesDir = path_1.default.join(workingDir, "unique_frames");
+            const framePath = path_1.default.join(uniqueFramesDir, filename);
+            try {
+                // Security check: ensure the filename doesn't contain path traversal
+                if (filename.includes("..") ||
+                    filename.includes("/") ||
+                    filename.includes("\\")) {
+                    res.statusCode = 400;
+                    res.end("Invalid filename");
+                    return;
+                }
+                // Check if file exists and is a PNG
+                if (!filename.endsWith(".png")) {
+                    res.statusCode = 400;
+                    res.end("Only PNG files are supported");
+                    return;
+                }
+                await fs_1.default.promises.access(framePath, fs_1.default.constants.R_OK);
+                const imageBuffer = await fs_1.default.promises.readFile(framePath);
+                res.statusCode = 200;
+                res.setHeader("Content-Type", "image/png");
+                res.setHeader("Cache-Control", "public, max-age=3600"); // Cache for 1 hour
+                res.end(imageBuffer);
+                return;
+            }
+            catch (error) {
+                console.log(`  Error serving frame ${filename}:`, error instanceof Error ? error.message : "Unknown error");
+                res.statusCode = 404;
+                res.end("Frame not found");
+                return;
+            }
+        }
+        if (req.method !== "GET" && req.method !== "HEAD") {
+            res.statusCode = 405;
+            res.setHeader("Content-Type", "text/plain; charset=utf-8");
+            res.end("Method Not Allowed");
+            return;
+        }
+        res.statusCode = 200;
+        res.setHeader("Content-Type", "text/html; charset=utf-8");
+        res.setHeader("Cache-Control", "no-store");
+        try {
+            let htmlContent = await fs_1.default.promises.readFile(htmlFilePath, "utf8");
+            // Inject script to load analyses list and handle navigation
+            const injectionScript = `
+      <script>
+      // Load analyses list and set up navigation
+      window.addEventListener('DOMContentLoaded', async function() {
+        try {
+          const response = await fetch('/api/analyses');
+          const analyses = await response.json();
+          
+          // Store analyses globally
+          window.currentAnalyses = analyses;
+          
+          // Call the HTML implementation directly
+          if (typeof window.displayAnalysesList === 'function') {
+            window.displayAnalysesList(analyses);
+          }
+          
+          // Auto-load first analysis if available
+          if (analyses.length > 0) {
+            loadAnalysis(analyses[0].id);
+          }
+        } catch (error) {
+          showError('Error loading analyses list: ' + error.message);
+        }
+      });
+      
+      function loadAnalysis(id) {
+        fetch('/api/data?id=' + encodeURIComponent(id))
+          .then(response => response.json())
+          .then(data => {
+            if (typeof displayData === 'function') {
+              displayData(data);
+            }
+            if (typeof setActiveAnalysis === 'function') {
+              setActiveAnalysis(id);
+            }
+          })
+          .catch(error => {
+            showError('Error loading analysis: ' + error.message);
+          });
+      }
+      
+      // Make loadAnalysis available globally
+      window.loadAnalysis = loadAnalysis;
+      </script>
+    `;
+            htmlContent = htmlContent.replace("</body>", injectionScript + "</body>");
+            if (req.method === "HEAD") {
+                res.end();
+                return;
+            }
+            res.end(htmlContent);
+        }
+        catch (err) {
+            res.statusCode = 500;
+            res.setHeader("Content-Type", "text/plain; charset=utf-8");
+            res.end(`Error reading HTML file: ${err instanceof Error ? err.message : "Unknown error"}`);
+        }
+    });
+    // Try to bind to the preferred port first, and if it's in use, fall back to any free port
+    await new Promise((resolve, reject) => {
+        const tryEphemeral = () => {
+            // Remove any existing error listeners to avoid multiple handlers
+            server.removeAllListeners("error");
+            server.once("error", reject);
+            server.listen(0, host, () => resolve());
+        };
+        server.once("error", (err) => {
+            const e = err;
+            if (e && e.code === "EADDRINUSE") {
+                // Port is taken; retry on an ephemeral port assigned by the OS
+                tryEphemeral();
+            }
+            else {
+                reject(err);
+            }
+        });
+        server.listen(port, host, () => resolve());
+    });
+    const address = server.address();
+    if (!address || typeof address === "string") {
+        await new Promise((resolve) => server.close(() => resolve()));
+        throw new Error("Server failed to bind to an address");
+    }
+    const resolvedUrl = `http://${address.address}:${address.port}`;
+    // Open the URL in the default browser
+    try {
+        await (0, open_1.default)(resolvedUrl);
+    }
+    catch (error) { }
+    const handle = {
+        url: resolvedUrl,
+        port: address.port,
+        host: address.address,
+        server,
+        close: () => new Promise((resolve, reject) => {
+            server.close((err) => {
+                if (err) {
+                    reject(err);
+                }
+                else {
+                    resolve();
+                }
+            });
+        }),
+    };
+    return handle;
+}