@empiricalrun/test-gen 0.77.0 → 0.78.1

package/dist/video-core/agent-orchestrator.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"agent-orchestrator.d.ts","sourceRoot":"","sources":["../../src/video-core/agent-orchestrator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,UAAU,EACV,gBAAgB,EAChB,SAAS,EACT,mBAAmB,EAEpB,MAAM,4BAA4B,CAAC;AAIpC,OAAO,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAG5C,wBAAgB,8BAA8B,CAC5C,QAAQ,EAAE,gBAAgB,EAAE,GAC3B,MAAM,GAAG,IAAI,CAgBf;AAED,wBAAgB,sCAAsC,CACpD,WAAW,EAAE,UAAU,EAAE,EACzB,aAAa,EAAE,mBAAmB,GACjC,SAAS,CAqBX;AAED,wBAAsB,wBAAwB,CAAC,EAC7C,aAAa,EACb,YAAY,EACZ,gBAAgB,EAChB,UAAU,GACX,EAAE;IACD,aAAa,EAAE,mBAAmB,CAAC;IACnC,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,gBAAgB,EAAE,MAAM,CAAC;IACzB,UAAU,EAAE,UAAU,EAAE,CAAC;CAC1B,GAAG,OAAO,CACT;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,gBAAgB,EAAE,CAAA;CAAE,GAAG,iBAAiB,CAC1E,CAoDA"}

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

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

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

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

@@ -1,398 +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.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;
-}