@empiricalrun/test-gen 0.75.0 → 0.77.0

package/dist/file-info/adapters/github/reader.js

@@ -6,181 +6,213 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.GitHubFileReader = void 0;
 exports.getFileInfoFromGitHub = getFileInfoFromGitHub;
 const path_1 = __importDefault(require("path"));
-const dashboard_1 = require("../../../dashboard");
-const REPO_OWNER = "empirical-run";
 class GitHubFileReader {
     repoName;
     apiClient;
-    repoOwner;
-    constructor(repoName, apiClient, repoOwner) {
+    constructor(repoName, apiClient) {
         this.repoName = repoName;
         this.apiClient = apiClient;
-        this.repoOwner = repoOwner;
-    }
-    async fetchFileFromGitHub(filePath, branch) {
-        return (await this.apiClient.callGitHubProxy({
-            method: "GET",
-            url: `/repos/${this.repoOwner}/${this.repoName}/contents/${filePath}?ref=${branch}`,
-        }));
-    }
-    async fetchTreeFromGitHub(branch) {
-        return (await this.apiClient.callGitHubProxy({
-            method: "GET",
-            url: `/repos/${this.repoOwner}/${this.repoName}/git/trees/${branch}?recursive=1`,
-        }));
     }
     async resolveBranchName(branchName, baseBranch) {
         if (!branchName || branchName === baseBranch) {
             return baseBranch;
         }
         try {
-            // Try to fetch the branch to see if it exists
             await this.apiClient.callGitHubProxy({
                 method: "GET",
-                url: `/repos/${this.repoOwner}/${this.repoName}/branches/${branchName}`,
+                url: `/repos/empirical-run/${this.repoName}/branches/${branchName}`,
             });
+            console.log(`[GitHubFileReader] Branch ${branchName} exists`);
             return branchName;
         }
         catch {
-            // Branch doesn't exist, fallback to base branch
+            console.log(`[GitHubFileReader] Branch ${branchName} not found, falling back to ${baseBranch}`);
             return baseBranch;
         }
     }
     async readFile(filePath, branchName, baseBranch) {
-        const branch = await this.resolveBranchName(branchName, baseBranch);
-        const normalizedPath = filePath === "" ? "." : filePath;
+        const resolvedBranch = await this.resolveBranchName(branchName, baseBranch);
+        // Check if path has file extension - if not, treat as directory
+        const hasFileExtension = path_1.default.extname(filePath) !== "";
+        if (!hasFileExtension) {
+            console.log(`[GitHubFileReader] Reading as directory: ${filePath}`);
+            return this.readDirectory(filePath, resolvedBranch);
+        }
         try {
-            const response = await this.fetchFileFromGitHub(normalizedPath, branch);
-            const isDirectory = Array.isArray(response);
-            if (!isDirectory) {
-                if (response.type === "file" && response.content) {
-                    const content = Buffer.from(response.content, "base64").toString("utf-8");
-                    return {
-                        content,
-                        isDirectory: false,
-                    };
-                }
-            }
-            else {
+            console.log(`[GitHubFileReader] Reading as file: ${filePath}, resolved branch: ${resolvedBranch}`);
+            const params = {
+                repo: this.repoName,
+                path: filePath,
+                ref: resolvedBranch,
+            };
+            const response = await this.apiClient.request(`/api/github/files`, {
+                method: "GET",
+                params,
+            });
+            if (response.data?.fileContents.available) {
                 return {
-                    content: response.map((item) => item.name).join("\n"),
-                    isDirectory: true,
+                    content: response.data.fileContents.content,
+                    isDirectory: false,
                 };
             }
+            console.log(`[GitHubFileReader] File not available: ${filePath}`);
+            // For file paths (with extensions), don't fall back to directory reading
+            return null;
         }
         catch (error) {
-            if (error instanceof dashboard_1.NonRetryableHTTPError && error.status === 404) {
-                return null; // File or directory not found
-            }
-            throw error; // Re-throw other errors
+            console.log(`[GitHubFileReader] Error reading file ${filePath}:`, error);
+            // For file paths, return null (file not found)
+            return null;
         }
-        return null;
     }
-    async getFileContent(path, branchName, baseBranch) {
-        const branch = await this.resolveBranchName(branchName, baseBranch);
-        const response = await this.fetchFileFromGitHub(path, branch);
-        const isDirectory = Array.isArray(response);
-        if (isDirectory) {
-            throw new Error(`${path} is a directory, not a file`);
+    async readDirectory(filePath, resolvedBranch) {
+        try {
+            console.log(`[GitHubFileReader] Reading directory: ${filePath}, resolved branch: ${resolvedBranch}`);
+            const params = {
+                repo: this.repoName,
+                path: filePath || ".", // Handle empty path
+                ref: resolvedBranch,
+            };
+            const treeResponse = await this.apiClient.request(`/api/github/tree`, {
+                method: "GET",
+                params,
+            });
+            if (treeResponse.data?.tree) {
+                const targetPath = filePath === "." || filePath === "" ? "" : filePath;
+                const files = treeResponse.data.tree.tree
+                    .map((item) => item.path)
+                    .filter((itemPath) => {
+                    if (!itemPath)
+                        return false;
+                    // Check if item is a direct child of the target directory
+                    const itemDir = path_1.default.dirname(itemPath);
+                    // Normalize "." to "" for root directory comparison
+                    const normalizedItemDir = itemDir === "." ? "" : itemDir;
+                    return normalizedItemDir === targetPath;
+                })
+                    .map((itemPath) => path_1.default.basename(itemPath))
+                    .sort()
+                    .join("\n");
+                if (files.length === 0) {
+                    // No files means directory is invalid
+                    return null;
+                }
+                else {
+                    return { content: files, isDirectory: true };
+                }
+            }
         }
-        if (response.type === "file" && response.content) {
-            return Buffer.from(response.content, "base64").toString("utf-8");
+        catch (error) {
+            console.log(`[GitHubFileReader] Error reading directory ${filePath}:`, error);
         }
-        throw new Error(`Unable to fetch file content for ${path}`);
+        return null;
     }
-    async getContentsForDirectory(path, branchName, baseBranch) {
-        const branch = await this.resolveBranchName(branchName, baseBranch);
-        const response = await this.fetchTreeFromGitHub(branch);
-        if (response.tree) {
-            // Convert to expected RepoTree format
-            return {
-                sha: response.sha,
-                truncated: false,
-                tree: response.tree.map((item) => ({
-                    path: item.path || "",
-                    mode: item.mode || "",
-                    type: item.type === "blob" ? "blob" : "tree",
-                    sha: item.sha,
-                })),
-            };
-        }
-        throw new Error(`Unable to fetch directory contents for ${path}`);
+}
+exports.GitHubFileReader = GitHubFileReader;
+async function getFileContent(repoName, path, apiClient, branchName) {
+    const params = {
+        repo: repoName,
+        path: path,
+    };
+    if (branchName) {
+        params.ref = branchName;
+    }
+    const response = await apiClient.request(`/api/github/files`, {
+        method: "GET",
+        params,
+    });
+    if (!response.data) {
+        throw new Error(`Unable to fetch file for FileInfo`);
     }
-    async getFileInfo(branchName, baseBranch) {
-        const rootPath = "";
-        const files = await this.getContentsForDirectory(rootPath, branchName, baseBranch);
-        const root = [];
-        const nodeMap = {};
-        if (!files) {
-            return {
+    return response.data.fileContents.content;
+}
+async function getContentsForDirectory({ repo, path, }, apiClient, branchName) {
+    const params = {
+        repo: repo,
+        path: path,
+    };
+    if (branchName) {
+        params.ref = branchName;
+    }
+    const response = await apiClient.request(`/api/github/tree`, {
+        method: "GET",
+        params,
+    });
+    if (!response.data) {
+        throw new Error(`Unable to fetch file for FileInfo`);
+    }
+    return response.data.tree;
+}
+async function getFileInfoFromGitHub(repoName, apiClient, branchName, baseBranchName) {
+    const fileReader = new GitHubFileReader(repoName, apiClient);
+    const resolvedBranch = await fileReader.resolveBranchName(branchName, baseBranchName);
+    const files = await getContentsForDirectory({ repo: repoName, path: "" }, apiClient, resolvedBranch);
+    const root = [];
+    const nodeMap = {};
+    if (!files) {
+        return {
+            type: "directory",
+            path: repoName,
+            name: repoName,
+            children: [],
+        };
+    }
+    files.tree.forEach((file) => {
+        if (!file.path) {
+            return;
+        }
+        const pathParts = file.path.split("/");
+        const fileName = path_1.default.basename(file.path);
+        const isFile = file.type === "blob";
+        const currentPath = file.path;
+        const currentNode = isFile
+            ? {
+                type: "file",
+                path: currentPath,
+                name: fileName,
+                getContent: async () => getFileContent(repoName, currentPath, apiClient, resolvedBranch),
+            }
+            : {
                 type: "directory",
-                path: this.repoName,
-                name: this.repoName,
+                path: currentPath,
+                name: fileName,
                 children: [],
             };
+        nodeMap[currentPath] = currentNode;
+        if (pathParts.length === 1) {
+            root.push(currentNode);
         }
-        files.tree.forEach((file) => {
-            if (!file.path) {
-                return;
-            }
-            const pathParts = file.path.split("/");
-            const fileName = path_1.default.basename(file.path);
-            const isFile = file.type === "blob";
-            const currentPath = file.path;
-            const currentNode = isFile
-                ? {
-                    type: "file",
-                    path: currentPath,
-                    name: fileName,
-                    getContent: async () => this.getFileContent(currentPath, branchName, baseBranch),
-                }
-                : {
+        else {
+            const parentPath = path_1.default.dirname(currentPath);
+            if (!nodeMap[parentPath]) {
+                const parentNode = {
                     type: "directory",
-                    path: currentPath,
-                    name: fileName,
+                    path: parentPath,
+                    name: parentPath.split("/").pop() || "",
                     children: [],
                 };
-            nodeMap[currentPath] = currentNode;
-            if (pathParts.length === 1) {
-                root.push(currentNode);
-            }
-            else {
-                const parentPath = path_1.default.dirname(currentPath);
-                if (!nodeMap[parentPath]) {
-                    const parentNode = {
-                        type: "directory",
-                        path: parentPath,
-                        name: parentPath.split("/").pop() || "",
-                        children: [],
-                    };
-                    nodeMap[parentPath] = parentNode;
-                    const parentPathParts = parentPath.split("/");
-                    if (parentPathParts.length === 1) {
-                        root.push(parentNode);
-                    }
-                    else {
-                        const grandparentPath = path_1.default.dirname(parentPath);
-                        if (nodeMap[grandparentPath] &&
-                            nodeMap[grandparentPath].type === "directory") {
-                            nodeMap[grandparentPath].children.push(parentNode);
-                        }
-                    }
+                nodeMap[parentPath] = parentNode;
+                const parentPathParts = parentPath.split("/");
+                if (parentPathParts.length === 1) {
+                    root.push(parentNode);
                 }
-                if (nodeMap[parentPath].type === "directory") {
-                    nodeMap[parentPath].children.push(currentNode);
+                else {
+                    const grandparentPath = path_1.default.dirname(parentPath);
+                    if (nodeMap[grandparentPath] &&
+                        nodeMap[grandparentPath].type === "directory") {
+                        nodeMap[grandparentPath].children.push(parentNode);
+                    }
                 }
             }
-        });
-        return {
-            type: "directory",
-            path: this.repoName,
-            name: this.repoName,
-            children: root,
-        };
-    }
-}
-exports.GitHubFileReader = GitHubFileReader;
-async function getFileInfoFromGitHub(repoName, apiClient, branchName, baseBranch) {
-    const fileReader = new GitHubFileReader(repoName, apiClient, REPO_OWNER);
-    return fileReader.getFileInfo(branchName, baseBranch);
+            if (nodeMap[parentPath].type === "directory") {
+                nodeMap[parentPath].children.push(currentNode);
+            }
+        }
+    });
+    return {
+        type: "directory",
+        path: repoName,
+        name: repoName,
+        children: root,
+    };
 }

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAYhD,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AACpC,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC7C,OAAO,EACL,yBAAyB,EACzB,iBAAiB,GAClB,MAAM,yCAAyC,CAAC;AACjD,OAAO,EAAE,oBAAoB,EAAE,MAAM,2CAA2C,CAAC;AAsBjF,wBAAsB,UAAU,CAC9B,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,IAAI,GAAG,YAAY,EAC5B,KAAK,CAAC,EAAE,SAAS,iBA0DlB;AAED,wBAAsB,UAAU,CAAC,OAAO,EAAE,IAAI,iBAY7C"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAYhD,OAAO,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AAEpC,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAC;AAC7C,OAAO,EACL,yBAAyB,EACzB,iBAAiB,GAClB,MAAM,yCAAyC,CAAC;AACjD,OAAO,EAAE,oBAAoB,EAAE,MAAM,2CAA2C,CAAC;AAsBjF,wBAAsB,UAAU,CAC9B,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,IAAI,GAAG,YAAY,EAC5B,KAAK,CAAC,EAAE,SAAS,iBA0DlB;AAED,wBAAsB,UAAU,CAAC,OAAO,EAAE,IAAI,iBAY7C"}

package/dist/tools/analyse-video/index.d.ts

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

package/dist/tools/analyse-video/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/tools/analyse-video/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,IAAI,EAGL,MAAM,4BAA4B,CAAC;AACpC,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAK7B,OAAO,EACL,kBAAkB,EAEnB,MAAM,8BAA8B,CAAC;AAiBtC,eAAO,MAAM,YAAY,EAAE,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAsCjE,CAAC"}

package/dist/tools/analyse-video/index.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyseVideo = void 0;
+const constants_1 = require("../../constants");
+const hash_1 = require("../../utils/hash");
+const video_core_1 = require("../../video-core");
+const utils_1 = require("../../video-core/utils");
+const analyse_video_1 = require("../definitions/analyse-video");
+function getVideoAnalysisParams(params) {
+    return {
+        model: params?.model || constants_1.VIDEO_ANALYSIS.DEFAULT_MODEL,
+        fps: params?.fps ?? constants_1.VIDEO_ANALYSIS.DEFAULT_FPS,
+        threshold: params?.threshold ?? constants_1.VIDEO_ANALYSIS.DEFAULT_THRESHOLD,
+        startTime: params?.startTime,
+        duration: params?.duration,
+    };
+}
+exports.analyseVideo = {
+    ...analyse_video_1.analyseVideo,
+    execute: async ({ input, featureFlags, repoPath }) => {
+        const { videoUrl } = input;
+        const params = getVideoAnalysisParams(input.params);
+        const videoUrlHash = (0, hash_1.createHashBasedOnParams)(videoUrl, params);
+        const validationResult = await (0, utils_1.validateVideoAccess)(videoUrl);
+        if (!validationResult.isValid) {
+            return {
+                result: validationResult.error,
+                isError: true,
+            };
+        }
+        const { result, isError, interleaved_tool_result } = await (0, video_core_1.runVideoAnalysis)({
+            videoUrl,
+            videoUrlHash,
+            params,
+            featureFlags,
+            workingDirectory: repoPath,
+        });
+        const finalResult = [
+            {
+                type: "text",
+                text: JSON.stringify(result),
+            },
+            ...interleaved_tool_result,
+        ];
+        return {
+            isError: isError,
+            result: finalResult,
+        };
+    },
+};

package/dist/tools/create-pull-request/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/tools/create-pull-request/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,4BAA4B,CAAC;AA6BvD,eAAO,MAAM,qBAAqB,EAAE,IAwDnC,CAAC"}

package/dist/tools/{definitions/commit-and-create-pr.js → create-pull-request/index.js}

@@ -2,6 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createPullRequestTool = void 0;
 const zod_1 = require("zod");
+const utils_1 = require("../executor/utils");
+const utils_2 = require("./utils");
+const REPO_OWNER = "empirical-run";
 const createPullRequestSchema = zod_1.z.object({
     pullRequestTitle: zod_1.z
         .string()
@@ -27,5 +30,29 @@ Don't ask the user for this information, just come up with it yourself.
         parameters: createPullRequestSchema,
     },
     needsBrowser: false,
-    isInlineTool: false,
+    isInlineTool: true,
+    execute: async ({ input, apiClient, chatSession }) => {
+        const owner = REPO_OWNER;
+        try {
+            const valids = await (0, utils_2.validateInputs)({ input, apiClient, chatSession });
+            const { pullRequestTitle, pullRequestDescription, branchName } = valids;
+            const repo = await (0, utils_2.getRepoName)(chatSession, apiClient);
+            const existingPR = await (0, utils_1.getExistingPR)({
+                owner,
+                repo,
+                branchName,
+                apiClient: apiClient,
+            });
+            const toolResponse = existingPR
+                ? await (0, utils_2.handleExistingPullRequest)(existingPR, owner, repo, pullRequestDescription, chatSession, apiClient)
+                : await (0, utils_2.handleNewPullRequest)(owner, repo, pullRequestTitle, branchName, chatSession, pullRequestDescription, apiClient);
+            return toolResponse;
+        }
+        catch (error) {
+            return {
+                isError: true,
+                result: `Failed to commit and push changes: ${error instanceof Error ? error.message : String(error)}`,
+            };
+        }
+    },
 };

package/dist/tools/create-pull-request/utils.d.ts

@@ -0,0 +1,21 @@
+import { ChatSessionInfo, IDashboardAPIClient } from "@empiricalrun/shared-types";
+export interface ValidatedInputs {
+    pullRequestTitle: string;
+    pullRequestDescription: string;
+    branchName: string;
+}
+export declare function validateInputs({ input, apiClient, chatSession, }: any): Promise<ValidatedInputs>;
+export declare function getRepoName(chatSession: ChatSessionInfo | null | undefined, apiClient: IDashboardAPIClient): Promise<string>;
+export declare function getMergeableStateInfo(owner: string, repo: string, pullRequest: any, apiClient: any): Promise<{
+    mergeableState: "unknown" | "dirty" | "clean" | "unstable";
+    stateDescription: string;
+}>;
+export declare function handleExistingPullRequest(pullRequest: any, owner: string, repo: string, pullRequestDescription: string, chatSession: any, apiClient: any): Promise<{
+    isError: boolean;
+    result: string;
+}>;
+export declare function handleNewPullRequest(owner: string, repo: string, pullRequestTitle: string, branchName: string, chatSession: any, pullRequestDescription: string, apiClient: any): Promise<{
+    isError: boolean;
+    result: string;
+}>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/tools/create-pull-request/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/tools/create-pull-request/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EACf,mBAAmB,EAEpB,MAAM,4BAA4B,CAAC;AAUpC,MAAM,WAAW,eAAe;IAC9B,gBAAgB,EAAE,MAAM,CAAC;IACzB,sBAAsB,EAAE,MAAM,CAAC;IAC/B,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,wBAAsB,cAAc,CAAC,EACnC,KAAK,EACL,SAAS,EACT,WAAW,GACZ,EAAE,GAAG,GAAG,OAAO,CAAC,eAAe,CAAC,CAehC;AAED,wBAAsB,WAAW,CAC/B,WAAW,EAAE,eAAe,GAAG,IAAI,GAAG,SAAS,EAC/C,SAAS,EAAE,mBAAmB,GAC7B,OAAO,CAAC,MAAM,CAAC,CA2BjB;AAED,wBAAsB,qBAAqB,CACzC,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,EACZ,WAAW,EAAE,GAAG,EAChB,SAAS,EAAE,GAAG;;;GAUf;AAED,wBAAsB,yBAAyB,CAC7C,WAAW,EAAE,GAAG,EAChB,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,EACZ,sBAAsB,EAAE,MAAM,EAC9B,WAAW,EAAE,GAAG,EAChB,SAAS,EAAE,GAAG;;;GAqBf;AAED,wBAAsB,oBAAoB,CACxC,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,EACZ,gBAAgB,EAAE,MAAM,EACxB,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,GAAG,EAChB,sBAAsB,EAAE,MAAM,EAC9B,SAAS,EAAE,GAAG;;;GAuBf"}

package/dist/tools/create-pull-request/utils.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateInputs = validateInputs;
+exports.getRepoName = getRepoName;
+exports.getMergeableStateInfo = getMergeableStateInfo;
+exports.handleExistingPullRequest = handleExistingPullRequest;
+exports.handleNewPullRequest = handleNewPullRequest;
+const utils_1 = require("../executor/utils");
+const pr_description_1 = require("../executor/utils/pr-description");
+async function validateInputs({ input, apiClient, chatSession, }) {
+    const { pullRequestTitle, pullRequestDescription } = input;
+    const branchName = chatSession?.branchName;
+    if (!apiClient) {
+        throw new Error("Dashboard API client is not available.");
+    }
+    if (!branchName) {
+        throw new Error("Branch name is not available in the chat session.");
+    }
+    return {
+        pullRequestTitle,
+        pullRequestDescription,
+        branchName,
+    };
+}
+async function getRepoName(chatSession, apiClient) {
+    if (!chatSession?.id) {
+        throw new Error("Cannot create pull request without repo name or chat session ID.");
+    }
+    try {
+        const url = `/api/chat-sessions/${chatSession.id}/details`;
+        const sessionDetails = await apiClient.request(url, { method: "GET" });
+        if ("error" in sessionDetails) {
+            throw new Error(`Failed to fetch session details: ${sessionDetails.error}`);
+        }
+        if (!sessionDetails.gitPayload?.repoName) {
+            throw new Error("Repository name not found in session details.");
+        }
+        return sessionDetails.gitPayload.repoName;
+    }
+    catch (error) {
+        throw new Error(`Failed to fetch repository name: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+async function getMergeableStateInfo(owner, repo, pullRequest, apiClient) {
+    const mergeableState = await (0, utils_1.getMergeableState)({
+        owner,
+        repo,
+        pullRequest,
+        apiClient,
+    });
+    const stateDescription = (0, utils_1.getMergeableStateDescription)(mergeableState);
+    return { mergeableState, stateDescription };
+}
+async function handleExistingPullRequest(pullRequest, owner, repo, pullRequestDescription, chatSession, apiClient) {
+    const updatedPR = await (0, utils_1.updatePullRequest)({
+        owner,
+        repo,
+        prNumber: pullRequest.number,
+        body: (0, pr_description_1.addMetadataToPRDescription)(pullRequestDescription, chatSession),
+        apiClient,
+    });
+    const { mergeableState, stateDescription } = await getMergeableStateInfo(owner, repo, updatedPR, apiClient);
+    return {
+        isError: false,
+        result: `Updated existing PR: ${updatedPR.html_url}\n\nMergeable state: ${mergeableState} - ${stateDescription}`,
+    };
+}
+async function handleNewPullRequest(owner, repo, pullRequestTitle, branchName, chatSession, pullRequestDescription, apiClient) {
+    const newPR = await (0, utils_1.createPullRequest)({
+        owner,
+        repo,
+        title: pullRequestTitle,
+        head: branchName,
+        base: chatSession?.baseBranchName || "main",
+        body: (0, pr_description_1.addMetadataToPRDescription)(pullRequestDescription, chatSession),
+        apiClient,
+    });
+    const { mergeableState, stateDescription } = await getMergeableStateInfo(owner, repo, newPR, apiClient);
+    return {
+        isError: false,
+        result: `Created a new PR: ${newPR.html_url}\n\nMergeable state: ${mergeableState} - ${stateDescription}`,
+    };
+}

package/dist/tools/definitions/{fetch-video-analysis.d.ts → analyse-video.d.ts}

@@ -1,39 +1,44 @@
 import { ToolDefinition } from "@empiricalrun/shared-types";
 import z from "zod";
-export declare const videoAnalysisSchema: z.ZodObject<{
+export declare const analyseVideoSchema: z.ZodObject<{
     videoUrl: z.ZodString;
     params: z.ZodOptional<z.ZodObject<{
         fps: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
         threshold: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        startTime: z.ZodOptional<z.ZodNumber>;
+        duration: z.ZodOptional<z.ZodNumber>;
         model: z.ZodOptional<z.ZodDefault<z.ZodString>>;
-        featureFlag: z.ZodOptional<z.ZodDefault<z.ZodEnum<["none", "send-all-frames", "separate-threshold", "ai-based-frames"]>>>;
     }, "strip", z.ZodTypeAny, {
         model?: string | undefined;
-        fps?: number | undefined;
+        startTime?: number | undefined;
         threshold?: number | undefined;
-        featureFlag?: "none" | "send-all-frames" | "separate-threshold" | "ai-based-frames" | undefined;
+        fps?: number | undefined;
+        duration?: number | undefined;
     }, {
         model?: string | undefined;
-        fps?: number | undefined;
+        startTime?: number | undefined;
         threshold?: number | undefined;
-        featureFlag?: "none" | "send-all-frames" | "separate-threshold" | "ai-based-frames" | undefined;
+        fps?: number | undefined;
+        duration?: number | undefined;
     }>>;
 }, "strip", z.ZodTypeAny, {
     videoUrl: string;
     params?: {
         model?: string | undefined;
-        fps?: number | undefined;
+        startTime?: number | undefined;
         threshold?: number | undefined;
-        featureFlag?: "none" | "send-all-frames" | "separate-threshold" | "ai-based-frames" | undefined;
+        fps?: number | undefined;
+        duration?: number | undefined;
     } | undefined;
 }, {
     videoUrl: string;
     params?: {
         model?: string | undefined;
-        fps?: number | undefined;
+        startTime?: number | undefined;
         threshold?: number | undefined;
-        featureFlag?: "none" | "send-all-frames" | "separate-threshold" | "ai-based-frames" | undefined;
+        fps?: number | undefined;
+        duration?: number | undefined;
     } | undefined;
 }>;
-export declare const fetchVideoAnalysis: ToolDefinition<z.infer<typeof videoAnalysisSchema>>;
-//# sourceMappingURL=fetch-video-analysis.d.ts.map
+export declare const analyseVideo: ToolDefinition<z.infer<typeof analyseVideoSchema>>;
+//# sourceMappingURL=analyse-video.d.ts.map

package/dist/tools/definitions/analyse-video.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyse-video.d.ts","sourceRoot":"","sources":["../../../src/tools/definitions/analyse-video.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAC5D,OAAO,CAAC,MAAM,KAAK,CAAC;AAGpB,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2C7B,CAAC;AAEH,eAAO,MAAM,YAAY,EAAE,cAAc,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAczE,CAAC"}