@empiricalrun/test-gen 0.75.0 → 0.76.0

package/dist/file-info/adapters/github/reader.d.ts

@@ -2,15 +2,10 @@ import { FileInfo, FileReadResult, IDashboardAPIClient } from "@empiricalrun/sha
 export declare class GitHubFileReader {
     private repoName;
     private apiClient;
-    private repoOwner;
-    constructor(repoName: string, apiClient: IDashboardAPIClient, repoOwner: string);
-    private fetchFileFromGitHub;
-    private fetchTreeFromGitHub;
-    private resolveBranchName;
+    constructor(repoName: string, apiClient: IDashboardAPIClient);
+    resolveBranchName(branchName: string | undefined, baseBranch?: string): Promise<string>;
     readFile(filePath: string, branchName: string, baseBranch: string): Promise<FileReadResult | null>;
-    private getFileContent;
-    private getContentsForDirectory;
-    getFileInfo(branchName: string, baseBranch: string): Promise<FileInfo>;
+    private readDirectory;
 }
-export declare function getFileInfoFromGitHub(repoName: string, apiClient: IDashboardAPIClient, branchName: string, baseBranch: string): Promise<FileInfo>;
+export declare function getFileInfoFromGitHub(repoName: string, apiClient: IDashboardAPIClient, branchName: string, baseBranchName: string): Promise<FileInfo>;
 //# sourceMappingURL=reader.d.ts.map

package/dist/file-info/adapters/github/reader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"reader.d.ts","sourceRoot":"","sources":["../../../../src/file-info/adapters/github/reader.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EACR,cAAc,EACd,mBAAmB,EACpB,MAAM,4BAA4B,CAAC;AA4CpC,qBAAa,gBAAgB;IAEzB,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,SAAS;IACjB,OAAO,CAAC,SAAS;gBAFT,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,mBAAmB,EAC9B,SAAS,EAAE,MAAM;YAGb,mBAAmB;YAUnB,mBAAmB;YASnB,iBAAiB;IAqBzB,QAAQ,CACZ,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC;YAmCnB,cAAc;YAkBd,uBAAuB;IAwB/B,WAAW,CAAC,UAAU,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC;CAoF7E;AAED,wBAAsB,qBAAqB,CACzC,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,mBAAmB,EAC9B,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,QAAQ,CAAC,CAGnB"}
+{"version":3,"file":"reader.d.ts","sourceRoot":"","sources":["../../../../src/file-info/adapters/github/reader.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EACR,cAAc,EACd,mBAAmB,EACpB,MAAM,4BAA4B,CAAC;AAcpC,qBAAa,gBAAgB;IAEzB,OAAO,CAAC,QAAQ;IAChB,OAAO,CAAC,SAAS;gBADT,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,mBAAmB;IAGlC,iBAAiB,CACrB,UAAU,EAAE,MAAM,GAAG,SAAS,EAC9B,UAAU,GAAE,MAAe,GAC1B,OAAO,CAAC,MAAM,CAAC;IAsBZ,QAAQ,CACZ,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC;YA4CnB,aAAa;CA8C5B;AAyED,wBAAsB,qBAAqB,CACzC,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,mBAAmB,EAC9B,UAAU,EAAE,MAAM,EAClB,cAAc,EAAE,MAAM,GACrB,OAAO,CAAC,QAAQ,CAAC,CAyFnB"}

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

@@ -6,181 +6,210 @@ 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) {
+    async resolveBranchName(branchName, baseBranch = "main") {
         if (!branchName || branchName === baseBranch) {
             return baseBranch;
         }
         try {
-            // Try to fetch the branch to see if it exists
+            // Try to fetch the branch to see if it exists via GitHub proxy
             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");
+                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`);
+    }
+    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) {
+    // Use GitHubFileReader to resolve the branch
+    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: [],
+        };
     }
-    async getFileInfo(branchName, baseBranch) {
-        const rootPath = "";
-        const files = await this.getContentsForDirectory(rootPath, branchName, baseBranch);
-        const root = [];
-        const nodeMap = {};
-        if (!files) {
-            return {
+    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/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,31 @@ 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,
+            });
+            if (existingPR) {
+                return await (0, utils_2.handleExistingPullRequest)(existingPR, owner, repo, pullRequestDescription, chatSession, apiClient);
+            }
+            else {
+                return await (0, utils_2.handleNewPullRequest)(owner, repo, pullRequestTitle, branchName, chatSession, pullRequestDescription, apiClient);
+            }
+        }
+        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" | "clean" | "dirty" | "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/extract-frames-from-video.d.ts

@@ -0,0 +1,39 @@
+import { ToolDefinition } from "@empiricalrun/shared-types";
+import z from "zod";
+export declare const extractFramesFromVideoSchema: 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.ZodString>;
+        duration: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        startTime?: string | undefined;
+        threshold?: number | undefined;
+        fps?: number | undefined;
+        duration?: string | undefined;
+    }, {
+        startTime?: string | undefined;
+        threshold?: number | undefined;
+        fps?: number | undefined;
+        duration?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    videoUrl: string;
+    params?: {
+        startTime?: string | undefined;
+        threshold?: number | undefined;
+        fps?: number | undefined;
+        duration?: string | undefined;
+    } | undefined;
+}, {
+    videoUrl: string;
+    params?: {
+        startTime?: string | undefined;
+        threshold?: number | undefined;
+        fps?: number | undefined;
+        duration?: string | undefined;
+    } | undefined;
+}>;
+export declare const extractFramesFromVideo: ToolDefinition<z.infer<typeof extractFramesFromVideoSchema>>;
+//# sourceMappingURL=extract-frames-from-video.d.ts.map

package/dist/tools/definitions/extract-frames-from-video.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extract-frames-from-video.d.ts","sourceRoot":"","sources":["../../../src/tools/definitions/extract-frames-from-video.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAC5D,OAAO,CAAC,MAAM,KAAK,CAAC;AAEpB,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoCvC,CAAC;AAEH,eAAO,MAAM,sBAAsB,EAAE,cAAc,CACjD,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAoB7C,CAAC"}

package/dist/tools/definitions/extract-frames-from-video.js

@@ -0,0 +1,60 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractFramesFromVideo = exports.extractFramesFromVideoSchema = void 0;
+const zod_1 = __importDefault(require("zod"));
+exports.extractFramesFromVideoSchema = zod_1.default.object({
+    videoUrl: zod_1.default
+        .string()
+        .url("Must be a valid URL")
+        .describe("The URL of the video to extract frames from."),
+    params: zod_1.default
+        .object({
+        fps: zod_1.default
+            .number()
+            .int()
+            .min(1)
+            .max(120)
+            .default(30)
+            .optional()
+            .describe("Frames per second to extract from the video (default: 30)"),
+        threshold: zod_1.default
+            .number()
+            .min(0)
+            .max(0.5)
+            .default(0.001)
+            .optional()
+            .describe("Deduplication threshold (fraction of pixels that may differ to consider frames identical). Lower = stricter. Default: 0.001"),
+        startTime: zod_1.default
+            .string()
+            .optional()
+            .describe("Start time in format MM:SS, example 1 min 32 sec -> 01:32"),
+        duration: zod_1.default
+            .string()
+            .optional()
+            .describe("Duration time in format MM:SS, example 1 min 32 sec -> 01:32"),
+    })
+        .optional(),
+});
+exports.extractFramesFromVideo = {
+    schema: {
+        name: "extractFramesFromVideo",
+        description: `
+Extracts frames from a video with precise timing control.
+
+**Input:** Video URL (required), optional parameters for timing, frame rate, and output format
+**Output:** PNG formate Frame URLs with metadata.
+**Use when:** You need specific frames from a video segment, want to analyze particular time ranges, or need distinct frames fromthe video, or just need all frames from the video for further processing
+
+**Key Features:**
+- Time-based frame extraction (start time + duration)
+- Configurable frame rate and deduplication threshold
+- Frame metadata including timestamps and indices
+- Memory-efficient processing for large videos`,
+        parameters: exports.extractFramesFromVideoSchema,
+    },
+    needsBrowser: false,
+    isInlineTool: false,
+};