@empiricalrun/test-gen 0.74.2 → 0.76.0

package/dist/bin/index.js

@@ -7,8 +7,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const commander_1 = require("commander");
 const dotenv_1 = __importDefault(require("dotenv"));
 const fs_1 = __importDefault(require("fs"));
-const chat_1 = require("../agent/chat");
 const models_1 = require("../agent/chat/models");
+const cli_1 = require("../agent/cli");
 const auth_1 = require("../auth");
 const client_1 = require("../dashboard/client");
 const recorder_1 = require("../recorder");
@@ -20,13 +20,13 @@ const utils_1 = require("./utils");
 dotenv_1.default.config({
     path: [".env.local", ".env"],
 });
-async function runChatAgent({ modelInput, useDiskForChatState, prompt: initialPromptContent, useTriage, resetChat, useFSCache, }) {
+async function runChatAgent({ modelInput, useDiskForChatState, prompt: initialPromptContent, agentMode = "chat", resetChat, useFSCache, }) {
     const resolvedModel = (0, models_1.resolveChatModelBasedOnInput)(modelInput);
-    return await (0, chat_1.runChatAgentForCLI)({
+    return await (0, cli_1.runChatAgentForCLI)({
         selectedModel: resolvedModel,
         useDiskForChatState: useDiskForChatState || false,
         initialPromptContent,
-        useTriage: useTriage || false,
+        agentMode,
         resetChat: resetChat || false,
         useFSCache: useFSCache || false,
     });
@@ -178,7 +178,7 @@ async function main() {
         .option("--model <model>", "LLM to use (gpt-5, claude-4 or gemini-2.5)")
         .option("--use-disk", "Save and load chat state from disk")
         .option("--prompt <string>", "String to pass as user prompt")
-        .option("--use-triage", "run the model in triage mode, different set of tools")
+        .option("--agent-mode <mode>", "Mode of the agent: 'chat' or 'triage' or 'video' or 'code-review' (Defaults to 'chat')")
         .option("--use-cache", "Use filesystem cache for LLM responses (Claude-only, and will disable streaming)")
         .option("--reset-chat", "Clear any saved chat state (last-chat.json) before starting")
         .action(async (options) => {
@@ -186,7 +186,7 @@ async function main() {
             modelInput: options.model,
             useDiskForChatState: options.useDisk,
             prompt: options.prompt,
-            useTriage: options.useTriage,
+            agentMode: options.agentMode,
             resetChat: options.resetChat,
             useFSCache: options.useCache,
         });

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

@@ -1,11 +1,11 @@
 import { IDashboardAPIClient, ToolResult } from "@empiricalrun/shared-types";
 import { type StrReplaceInputParams } from "../../../tools/file-operations/shared/helpers";
 export { getFileInfoFromGitHub } from "./reader";
-export declare function viewFileUsingGitHub({ input, filePath, repoName, apiClient, branchName, }: {
+export declare function viewFileUsingGitHub({ input, repoName, apiClient, branchName, baseBranch, }: {
     input: StrReplaceInputParams;
-    filePath: string;
     repoName: string;
     apiClient: IDashboardAPIClient;
     branchName: string;
+    baseBranch: string;
 }): Promise<ToolResult>;
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/file-info/adapters/github/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAE7E,OAAO,EAEL,KAAK,qBAAqB,EAC3B,MAAM,+CAA+C,CAAC;AAEvD,OAAO,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAC;AAIjD,wBAAsB,mBAAmB,CAAC,EACxC,KAAK,EACL,QAAQ,EACR,QAAQ,EACR,SAAS,EACT,UAAU,GACX,EAAE;IACD,KAAK,EAAE,qBAAqB,CAAC;IAC7B,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,mBAAmB,CAAC;IAC/B,UAAU,EAAE,MAAM,CAAC;CACpB,GAAG,OAAO,CAAC,UAAU,CAAC,CAsBtB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/file-info/adapters/github/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,UAAU,EAAE,MAAM,4BAA4B,CAAC;AAE7E,OAAO,EAEL,KAAK,qBAAqB,EAC3B,MAAM,+CAA+C,CAAC;AAEvD,OAAO,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAC;AAEjD,wBAAsB,mBAAmB,CAAC,EACxC,KAAK,EACL,QAAQ,EACR,SAAS,EACT,UAAU,EACV,UAAU,GACX,EAAE;IACD,KAAK,EAAE,qBAAqB,CAAC;IAC7B,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,mBAAmB,CAAC;IAC/B,UAAU,EAAE,MAAM,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;CACpB,GAAG,OAAO,CAAC,UAAU,CAAC,CA2BtB"}

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

@@ -6,10 +6,10 @@ const helpers_1 = require("../../../tools/file-operations/shared/helpers");
 const reader_1 = require("./reader");
 var reader_2 = require("./reader");
 Object.defineProperty(exports, "getFileInfoFromGitHub", { enumerable: true, get: function () { return reader_2.getFileInfoFromGitHub; } });
-const REPO_OWNER = "empirical-run";
-async function viewFileUsingGitHub({ input, filePath, repoName, apiClient, branchName, }) {
-    const githubReader = new reader_1.GitHubFileReader(repoName, apiClient, REPO_OWNER);
-    const fileData = await githubReader.readFile(filePath, branchName);
+async function viewFileUsingGitHub({ input, repoName, apiClient, branchName, baseBranch, }) {
+    const filePath = input.path;
+    const githubReader = new reader_1.GitHubFileReader(repoName, apiClient);
+    const fileData = await githubReader.readFile(filePath, branchName, baseBranch);
     if (!fileData) {
         return {
             result: `Error: File or directory ${filePath} is not found.`,

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;
-    readFile(filePath: string, branchName: string): Promise<FileReadResult | null>;
-    private getFileContent;
-    private getContentsForDirectory;
-    getFileInfo(branchName: string): Promise<FileInfo>;
+    constructor(repoName: string, apiClient: IDashboardAPIClient);
+    resolveBranchName(branchName: string | undefined, baseBranch?: string): Promise<string>;
+    readFile(filePath: string, branchName: string, baseBranch: string): Promise<FileReadResult | null>;
+    private readDirectory;
 }
-export declare function getFileInfoFromGitHub(repoName: string, apiClient: IDashboardAPIClient, branchName: 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;IAkBzB,QAAQ,CACZ,QAAQ,EAAE,MAAM,EAChB,UAAU,EAAE,MAAM,GACjB,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC;YAmCnB,cAAc;YAiBd,uBAAuB;IAuB/B,WAAW,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,QAAQ,CAAC;CA+EzD;AAED,wBAAsB,qBAAqB,CACzC,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,mBAAmB,EAC9B,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,180 +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) {
-        if (!branchName || branchName === "main") {
-            return "main";
+    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 main
-            return "main";
+            // 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) {
-        const branch = await this.resolveBranchName(branchName);
-        const normalizedPath = filePath === "" ? "." : filePath;
+    async readFile(filePath, branchName, baseBranch) {
+        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) {
-        const branch = await this.resolveBranchName(branchName);
-        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) {
-        const branch = await this.resolveBranchName(branchName);
-        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) {
-        const files = await this.getContentsForDirectory("", branchName);
-        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),
-                }
-                : {
+        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) {
-    const fileReader = new GitHubFileReader(repoName, apiClient, REPO_OWNER);
-    return fileReader.getFileInfo(branchName);
+            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}`,
+    };
+}