jazz-ai 0.2.2 → 0.4.3

package/dist/core/agent/tools/git-tools.js

@@ -1,19 +1,107 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createGitStatusTool = createGitStatusTool;
 exports.createGitLogTool = createGitLogTool;
 exports.createGitDiffTool = createGitDiffTool;
 exports.createGitBranchTool = createGitBranchTool;
 exports.createGitAddTool = createGitAddTool;
+exports.createExecuteGitAddTool = createExecuteGitAddTool;
 exports.createGitCommitTool = createGitCommitTool;
+exports.createExecuteGitCommitTool = createExecuteGitCommitTool;
 exports.createGitPushTool = createGitPushTool;
 exports.createGitPullTool = createGitPullTool;
 exports.createGitCheckoutTool = createGitCheckoutTool;
+exports.createExecuteGitPushTool = createExecuteGitPushTool;
+exports.createExecuteGitPullTool = createExecuteGitPullTool;
+exports.createExecuteGitCheckoutTool = createExecuteGitCheckoutTool;
 const effect_1 = require("effect");
 const zod_1 = require("zod");
 const shell_1 = require("../../../services/shell");
 const base_tool_1 = require("./base-tool");
-// Safe Git operations (no approval needed)
+const context_utils_1 = require("./context-utils");
+const env_utils_1 = require("./env-utils");
+const DEFAULT_GIT_TIMEOUT = 15000;
+function runGitCommand(options) {
+    return effect_1.Effect.gen(function* () {
+        const { spawn } = yield* effect_1.Effect.promise(() => Promise.resolve().then(() => __importStar(require("child_process"))));
+        return yield* effect_1.Effect.async((resume) => {
+            const sanitizedEnv = (0, env_utils_1.createSanitizedEnv)();
+            const gitArgs = ["--no-pager", ...options.args];
+            const child = spawn("git", gitArgs, {
+                cwd: options.workingDirectory,
+                stdio: ["ignore", "pipe", "pipe"],
+                env: sanitizedEnv,
+                detached: false,
+            });
+            let stdout = "";
+            let stderr = "";
+            const timeoutMs = options.timeoutMs ?? DEFAULT_GIT_TIMEOUT;
+            const timeoutId = setTimeout(() => {
+                child.kill("SIGTERM");
+                resume(effect_1.Effect.fail(new Error(`Git command timed out after ${timeoutMs}ms`)));
+            }, timeoutMs);
+            child.stdout.on("data", (data) => {
+                stdout += data.toString();
+            });
+            child.stderr.on("data", (data) => {
+                stderr += data.toString();
+            });
+            child.on("error", (error) => {
+                clearTimeout(timeoutId);
+                resume(effect_1.Effect.fail(error));
+            });
+            child.on("close", (code) => {
+                clearTimeout(timeoutId);
+                resume(effect_1.Effect.succeed({
+                    stdout: stdout.trimEnd(),
+                    stderr: stderr.trimEnd(),
+                    exitCode: code ?? 0,
+                }));
+            });
+        });
+    });
+}
+function resolveWorkingDirectory(shell, context, path) {
+    const key = (0, context_utils_1.buildKeyFromContext)(context);
+    if (path && path.trim().length > 0) {
+        return shell.resolvePath(key, path);
+    }
+    return shell.getCwd(key);
+}
+// Safe Git operations (no approval needed) \\
 function createGitStatusTool() {
     const parameters = zod_1.z
         .object({
@@ -24,8 +112,8 @@ function createGitStatusTool() {
     })
         .strict();
     return (0, base_tool_1.defineTool)({
-        name: "gitStatus",
-        description: "Show the working tree status of a Git repository",
+        name: "git_status",
+        description: "Display the current status of a Git repository's working tree. Shows modified files, untracked files, staged changes, and current branch information. Use this to understand what changes exist before committing or to check repository state.",
         tags: ["git", "status"],
         parameters,
         validate: (args) => {
@@ -37,29 +125,53 @@ function createGitStatusTool() {
         handler: (args, context) => effect_1.Effect.gen(function* () {
             const shell = yield* shell_1.FileSystemContextServiceTag;
             const typedArgs = args;
-            const workingDir = typedArgs.path
-                ? yield* shell.resolvePath({
-                    agentId: context.agentId,
-                    ...(context.conversationId && { conversationId: context.conversationId }),
-                }, typedArgs.path)
-                : yield* shell.getCwd({
-                    agentId: context.agentId,
-                    ...(context.conversationId && { conversationId: context.conversationId }),
-                });
-            // For now, return a simple status message
+            // Catch errors from path resolution and return them as ToolExecutionResult
+            const workingDirResult = yield* resolveWorkingDirectory(shell, context, typedArgs.path).pipe(effect_1.Effect.catchAll((error) => effect_1.Effect.succeed({
+                success: false,
+                result: null,
+                error: error instanceof Error ? error.message : String(error),
+            })));
+            // If path resolution failed, return the error
+            if (typeof workingDirResult === "object" &&
+                "success" in workingDirResult &&
+                !workingDirResult.success) {
+                return workingDirResult;
+            }
+            const workingDir = workingDirResult;
+            const commandResult = yield* runGitCommand({
+                args: ["status", "--short", "--branch"],
+                workingDirectory: workingDir,
+            });
+            if (commandResult.exitCode !== 0) {
+                return {
+                    success: false,
+                    result: null,
+                    error: commandResult.stderr ||
+                        `git status failed with exit code ${commandResult.exitCode}`,
+                };
+            }
+            const lines = commandResult.stdout.split("\n").filter((line) => line.trim().length > 0);
+            const branchLine = lines.find((line) => line.startsWith("##")) ?? "";
+            const changes = lines.filter((line) => !line.startsWith("##"));
+            const hasChanges = changes.length > 0;
             return {
                 success: true,
                 result: {
                     workingDirectory: workingDir,
-                    status: "Git status would be executed here",
-                    hasChanges: false,
+                    branch: branchLine.replace(/^##\s*/, "") || "unknown",
+                    hasChanges,
+                    summary: hasChanges ? changes : ["Working tree clean"],
+                    rawStatus: commandResult.stdout,
                 },
             };
         }),
         createSummary: (result) => {
             if (result.success && typeof result.result === "object" && result.result !== null) {
                 const gitResult = result.result;
-                return gitResult.hasChanges ? "Repository has changes" : "Repository is clean (no changes)";
+                const suffix = gitResult.branch ? ` on ${gitResult.branch}` : "";
+                return gitResult.hasChanges
+                    ? `Repository has changes${suffix}`
+                    : `Repository is clean${suffix}`;
             }
             return result.success ? "Git status retrieved" : "Git status failed";
         },
@@ -83,8 +195,8 @@ function createGitLogTool() {
     })
         .strict();
     return (0, base_tool_1.defineTool)({
-        name: "gitLog",
-        description: "Show commit history of a Git repository",
+        name: "git_log",
+        description: "Display commit history of a Git repository. Shows commit hashes, authors, dates, and messages. Supports limiting results and one-line format for quick overview. Use to review recent changes, find specific commits, or understand repository evolution.",
         tags: ["git", "history"],
         parameters,
         validate: (args) => {
@@ -96,22 +208,59 @@ function createGitLogTool() {
         handler: (args, context) => effect_1.Effect.gen(function* () {
             const shell = yield* shell_1.FileSystemContextServiceTag;
             const typedArgs = args;
-            const workingDir = typedArgs.path
-                ? yield* shell.resolvePath({
-                    agentId: context.agentId,
-                    ...(context.conversationId && { conversationId: context.conversationId }),
-                }, typedArgs.path)
-                : yield* shell.getCwd({
-                    agentId: context.agentId,
-                    ...(context.conversationId && { conversationId: context.conversationId }),
-                });
-            // For now, return a simple log message
+            // Catch errors from path resolution and return them as ToolExecutionResult
+            const workingDirResult = yield* resolveWorkingDirectory(shell, context, typedArgs.path).pipe(effect_1.Effect.catchAll((error) => effect_1.Effect.succeed({
+                success: false,
+                result: null,
+                error: error instanceof Error ? error.message : String(error),
+            })));
+            // If path resolution failed, return the error
+            if (typeof workingDirResult === "object" &&
+                "success" in workingDirResult &&
+                !workingDirResult.success) {
+                return workingDirResult;
+            }
+            const workingDir = workingDirResult;
+            const limit = typedArgs.limit ?? 10;
+            const prettyFormat = "%H%x1f%h%x1f%an%x1f%ar%x1f%s%x1e";
+            const commandResult = yield* runGitCommand({
+                args: [
+                    "log",
+                    `--max-count=${limit}`,
+                    `--pretty=format:${prettyFormat}`,
+                    "--date=relative",
+                ],
+                workingDirectory: workingDir,
+            });
+            if (commandResult.exitCode !== 0) {
+                return {
+                    success: false,
+                    result: null,
+                    error: commandResult.stderr || `git log failed with exit code ${commandResult.exitCode}`,
+                };
+            }
+            const commits = commandResult.stdout
+                .split("\x1e")
+                .filter((entry) => entry.trim().length > 0)
+                .map((entry) => {
+                const [hash, shortHash, author, relativeDate, subject] = entry
+                    .split("\x1f")
+                    .map((value) => value.trim());
+                return {
+                    hash,
+                    shortHash,
+                    author,
+                    relativeDate,
+                    subject,
+                    oneline: typedArgs.oneline ? `${shortHash} ${subject}` : undefined,
+                };
+            });
             return {
                 success: true,
                 result: {
                     workingDirectory: workingDir,
-                    commits: "Git log would be executed here",
-                    commitCount: 0,
+                    commitCount: commits.length,
+                    commits,
                 },
             };
         }),
@@ -137,8 +286,8 @@ function createGitDiffTool() {
     })
         .strict();
     return (0, base_tool_1.defineTool)({
-        name: "gitDiff",
-        description: "Show changes between commits, commit and working tree, etc.",
+        name: "git_diff",
+        description: "Display differences between commits, branches, or working tree. Shows what has changed in files (additions, deletions, modifications). Use to review changes before committing, compare branches, or see what differs from a specific commit. Supports staged changes and branch comparisons.",
         tags: ["git", "diff"],
         parameters,
         validate: (args) => {
@@ -150,24 +299,51 @@ function createGitDiffTool() {
         handler: (args, context) => effect_1.Effect.gen(function* () {
             const shell = yield* shell_1.FileSystemContextServiceTag;
             const typedArgs = args;
-            const workingDir = typedArgs.path
-                ? yield* shell.resolvePath({
-                    agentId: context.agentId,
-                    ...(context.conversationId && { conversationId: context.conversationId }),
-                }, typedArgs.path)
-                : yield* shell.getCwd({
-                    agentId: context.agentId,
-                    ...(context.conversationId && { conversationId: context.conversationId }),
-                });
-            // For now, return a simple diff message
+            // Catch errors from path resolution and return them as ToolExecutionResult
+            const workingDirResult = yield* resolveWorkingDirectory(shell, context, typedArgs.path).pipe(effect_1.Effect.catchAll((error) => effect_1.Effect.succeed({
+                success: false,
+                result: null,
+                error: error instanceof Error ? error.message : String(error),
+            })));
+            // If path resolution failed, return the error
+            if (typeof workingDirResult === "object" &&
+                "success" in workingDirResult &&
+                !workingDirResult.success) {
+                return workingDirResult;
+            }
+            const workingDir = workingDirResult;
+            const diffArgs = ["diff", "--no-color"];
+            if (typedArgs.staged) {
+                diffArgs.push("--staged");
+            }
+            if (typedArgs.branch) {
+                diffArgs.push(typedArgs.branch);
+            }
+            else if (typedArgs.commit) {
+                diffArgs.push(typedArgs.commit);
+            }
+            const commandResult = yield* runGitCommand({
+                args: diffArgs,
+                workingDirectory: workingDir,
+                timeoutMs: 20000,
+            });
+            if (commandResult.exitCode !== 0) {
+                return {
+                    success: false,
+                    result: null,
+                    error: commandResult.stderr || `git diff failed with exit code ${commandResult.exitCode}`,
+                };
+            }
+            const trimmedDiff = commandResult.stdout.trimEnd();
+            const hasChanges = trimmedDiff.length > 0;
             return {
                 success: true,
                 result: {
                     workingDirectory: workingDir,
-                    diff: "Git diff would be executed here",
-                    hasChanges: false,
+                    diff: trimmedDiff || "No differences",
+                    hasChanges,
                     options: {
-                        staged: typedArgs.staged || false,
+                        staged: typedArgs.staged ?? false,
                         branch: typedArgs.branch,
                         commit: typedArgs.commit,
                     },
@@ -196,8 +372,8 @@ function createGitBranchTool() {
     })
         .strict();
     return (0, base_tool_1.defineTool)({
-        name: "gitBranch",
-        description: "List, create, or delete branches",
+        name: "git_branch",
+        description: "List Git branches (local, remote, or both). Shows all available branches and identifies the current branch. Use to see what branches exist, check which branch you're on, or discover remote branches. Note: This tool only lists branches; use git_checkout to switch branches.",
         tags: ["git", "branch"],
         parameters,
         validate: (args) => {
@@ -209,26 +385,56 @@ function createGitBranchTool() {
         handler: (args, context) => effect_1.Effect.gen(function* () {
             const shell = yield* shell_1.FileSystemContextServiceTag;
             const typedArgs = args;
-            const workingDir = typedArgs.path
-                ? yield* shell.resolvePath({
-                    agentId: context.agentId,
-                    ...(context.conversationId && { conversationId: context.conversationId }),
-                }, typedArgs.path)
-                : yield* shell.getCwd({
-                    agentId: context.agentId,
-                    ...(context.conversationId && { conversationId: context.conversationId }),
-                });
-            // For now, return a simple branch message
+            // Catch errors from path resolution and return them as ToolExecutionResult
+            const workingDirResult = yield* resolveWorkingDirectory(shell, context, typedArgs.path).pipe(effect_1.Effect.catchAll((error) => effect_1.Effect.succeed({
+                success: false,
+                result: null,
+                error: error instanceof Error ? error.message : String(error),
+            })));
+            // If path resolution failed, return the error
+            if (typeof workingDirResult === "object" &&
+                "success" in workingDirResult &&
+                !workingDirResult.success) {
+                return workingDirResult;
+            }
+            const workingDir = workingDirResult;
+            const branchArgs = ["branch", "--list"];
+            if (typedArgs.remote) {
+                branchArgs.push("--remotes");
+            }
+            else if (typedArgs.all) {
+                branchArgs.push("--all");
+            }
+            const commandResult = yield* runGitCommand({
+                args: branchArgs,
+                workingDirectory: workingDir,
+            });
+            if (commandResult.exitCode !== 0) {
+                return {
+                    success: false,
+                    result: null,
+                    error: commandResult.stderr || `git branch failed with exit code ${commandResult.exitCode}`,
+                };
+            }
+            const lines = commandResult.stdout.split("\n").filter((line) => line.trim().length > 0);
+            let currentBranch;
+            const branches = lines.map((line) => {
+                const trimmed = line.replace(/^\*\s*/, "").trim();
+                if (line.trim().startsWith("*")) {
+                    currentBranch = trimmed;
+                }
+                return trimmed;
+            });
             return {
                 success: true,
                 result: {
                     workingDirectory: workingDir,
-                    branches: ["main", "develop", "feature/new-feature"],
-                    currentBranch: "main",
+                    branches,
+                    currentBranch,
                     options: {
                         list: typedArgs.list !== false,
-                        all: typedArgs.all || false,
-                        remote: typedArgs.remote || false,
+                        all: typedArgs.all ?? false,
+                        remote: typedArgs.remote ?? false,
                     },
                 },
             };
@@ -255,8 +461,8 @@ function createGitAddTool() {
     })
         .strict();
     return (0, base_tool_1.defineTool)({
-        name: "gitAdd",
-        description: "Add file contents to the staging area (requires user approval)",
+        name: "git_add",
+        description: "Stage files for commit by adding them to Git's index. Prepares changes to be included in the next commit. Can stage specific files or all changes. Requires user approval before execution.",
         tags: ["git", "index"],
         parameters,
         validate: (args) => {
@@ -279,28 +485,95 @@ function createGitAddTool() {
                         ...(context.conversationId && { conversationId: context.conversationId }),
                     });
                 const filesToAdd = typedArgs.all ? "all files" : typedArgs.files.join(", ");
-                return `Add ${filesToAdd} to Git staging area in ${workingDir}?`;
+                return `Add ${filesToAdd} to Git staging area in ${workingDir}?\n\nIMPORTANT: After getting user confirmation, you MUST call the execute_git_add tool with these exact arguments: {"path": ${typedArgs.path ? `"${typedArgs.path}"` : "undefined"}, "files": ${JSON.stringify(typedArgs.files)}, "all": ${typedArgs.all === true}}`;
             }),
+            errorMessage: "Approval required: Git add requires user confirmation.",
+            execute: {
+                toolName: "execute_git_add",
+                buildArgs: (args) => {
+                    const typedArgs = args;
+                    return {
+                        path: typedArgs.path,
+                        files: typedArgs.files,
+                        all: typedArgs.all,
+                    };
+                },
+            },
+        },
+        handler: (_args, _context) => effect_1.Effect.succeed({
+            success: false,
+            result: null,
+            error: "Approval required",
+        }),
+        createSummary: (result) => {
+            if (result.success && typeof result.result === "object" && result.result !== null) {
+                const gitResult = result.result;
+                return `Added ${Array.isArray(gitResult.addedFiles) ? gitResult.addedFiles.join(", ") : gitResult.addedFiles} to staging area`;
+            }
+            return result.success ? "Files added to Git" : "Git add failed";
+        },
+    });
+}
+function createExecuteGitAddTool() {
+    const parameters = zod_1.z
+        .object({
+        path: zod_1.z
+            .string()
+            .optional()
+            .describe("Path to the Git repository (defaults to current working directory)"),
+        files: zod_1.z.array(zod_1.z.string()).min(1).describe("Files to add to the staging area"),
+        all: zod_1.z.boolean().optional().describe("Add all changes in the working directory"),
+    })
+        .strict();
+    return (0, base_tool_1.defineTool)({
+        name: "execute_git_add",
+        description: "Internal tool that performs the actual git add operation after user has approved the git_add request. Stages files for commit by adding them to Git's index.",
+        hidden: true,
+        parameters,
+        validate: (args) => {
+            const result = parameters.safeParse(args);
+            return result.success
+                ? { valid: true, value: result.data }
+                : { valid: false, errors: result.error.issues.map((i) => i.message) };
         },
         handler: (args, context) => effect_1.Effect.gen(function* () {
             const shell = yield* shell_1.FileSystemContextServiceTag;
             const typedArgs = args;
-            const workingDir = typedArgs.path
-                ? yield* shell.resolvePath({
-                    agentId: context.agentId,
-                    ...(context.conversationId && { conversationId: context.conversationId }),
-                }, typedArgs.path)
-                : yield* shell.getCwd({
-                    agentId: context.agentId,
-                    ...(context.conversationId && { conversationId: context.conversationId }),
-                });
-            // For now, return a simple add message
+            const workingDirResult = yield* resolveWorkingDirectory(shell, context, typedArgs.path).pipe(effect_1.Effect.catchAll((error) => effect_1.Effect.succeed({
+                success: false,
+                result: null,
+                error: error instanceof Error ? error.message : String(error),
+            })));
+            if (typeof workingDirResult === "object" &&
+                "success" in workingDirResult &&
+                !workingDirResult.success) {
+                return workingDirResult;
+            }
+            const workingDir = workingDirResult;
+            const addArgs = ["add"];
+            if (typedArgs.all) {
+                addArgs.push("--all");
+            }
+            else {
+                addArgs.push(...typedArgs.files);
+            }
+            const commandResult = yield* runGitCommand({
+                args: addArgs,
+                workingDirectory: workingDir,
+            });
+            if (commandResult.exitCode !== 0) {
+                return {
+                    success: false,
+                    result: null,
+                    error: commandResult.stderr || `git add failed with exit code ${commandResult.exitCode}`,
+                };
+            }
             return {
                 success: true,
                 result: {
                     workingDirectory: workingDir,
                     addedFiles: typedArgs.all ? "all files" : typedArgs.files,
-                    message: "Files would be added to staging area",
+                    message: "Files added to staging area",
                 },
             };
         }),
@@ -325,8 +598,8 @@ function createGitCommitTool() {
     })
         .strict();
     return (0, base_tool_1.defineTool)({
-        name: "gitCommit",
-        description: "Record changes to the repository (requires user approval)",
+        name: "git_commit",
+        description: "Create a commit to permanently record staged changes in the repository history. Requires a commit message describing the changes. Can commit all staged changes or all working directory changes. Requires user approval before execution.",
         tags: ["git", "commit"],
         parameters,
         validate: (args) => {
@@ -348,28 +621,98 @@ function createGitCommitTool() {
                         agentId: context.agentId,
                         ...(context.conversationId && { conversationId: context.conversationId }),
                     });
-                return `Commit changes in ${workingDir} with message: "${typedArgs.message}"?`;
+                return `Commit changes in ${workingDir} with message: "${typedArgs.message}"?\n\nIMPORTANT: After getting user confirmation, you MUST call the execute_git_commit tool with these exact arguments: {"path": ${typedArgs.path ? `"${typedArgs.path}"` : "undefined"}, "message": ${JSON.stringify(typedArgs.message)}, "all": ${typedArgs.all === true}}`;
             }),
+            errorMessage: "Approval required: Git commit requires user confirmation.",
+            execute: {
+                toolName: "execute_git_commit",
+                buildArgs: (args) => {
+                    const typedArgs = args;
+                    return {
+                        path: typedArgs.path,
+                        message: typedArgs.message,
+                        all: typedArgs.all,
+                    };
+                },
+            },
+        },
+        handler: (_args, _context) => effect_1.Effect.succeed({
+            success: false,
+            result: null,
+            error: "Approval required",
+        }),
+        createSummary: (result) => {
+            if (result.success && typeof result.result === "object" && result.result !== null) {
+                const gitResult = result.result;
+                return `Committed: "${gitResult.message}" (${gitResult.commitHash})`;
+            }
+            return result.success ? "Git commit created" : "Git commit failed";
+        },
+    });
+}
+function createExecuteGitCommitTool() {
+    const parameters = zod_1.z
+        .object({
+        path: zod_1.z
+            .string()
+            .optional()
+            .describe("Path to the Git repository (defaults to current working directory)"),
+        message: zod_1.z.string().min(1).describe("Commit message"),
+        all: zod_1.z.boolean().optional().describe("Commit all changes in the working directory"),
+    })
+        .strict();
+    return (0, base_tool_1.defineTool)({
+        name: "execute_git_commit",
+        description: "Internal tool that performs the actual git commit operation after user has approved the git_commit request. Creates a commit with the specified message.",
+        hidden: true,
+        parameters,
+        validate: (args) => {
+            const result = parameters.safeParse(args);
+            return result.success
+                ? { valid: true, value: result.data }
+                : { valid: false, errors: result.error.issues.map((i) => i.message) };
         },
         handler: (args, context) => effect_1.Effect.gen(function* () {
             const shell = yield* shell_1.FileSystemContextServiceTag;
             const typedArgs = args;
-            const workingDir = typedArgs.path
-                ? yield* shell.resolvePath({
-                    agentId: context.agentId,
-                    ...(context.conversationId && { conversationId: context.conversationId }),
-                }, typedArgs.path)
-                : yield* shell.getCwd({
-                    agentId: context.agentId,
-                    ...(context.conversationId && { conversationId: context.conversationId }),
-                });
-            // For now, return a simple commit message
+            const workingDirResult = yield* resolveWorkingDirectory(shell, context, typedArgs.path).pipe(effect_1.Effect.catchAll((error) => effect_1.Effect.succeed({
+                success: false,
+                result: null,
+                error: error instanceof Error ? error.message : String(error),
+            })));
+            if (typeof workingDirResult === "object" &&
+                "success" in workingDirResult &&
+                !workingDirResult.success) {
+                return workingDirResult;
+            }
+            const workingDir = workingDirResult;
+            const commitArgs = ["commit", "-m", typedArgs.message];
+            if (typedArgs.all) {
+                commitArgs.push("--all");
+            }
+            const commandResult = yield* runGitCommand({
+                args: commitArgs,
+                workingDirectory: workingDir,
+            });
+            if (commandResult.exitCode !== 0) {
+                return {
+                    success: false,
+                    result: null,
+                    error: commandResult.stderr || `git commit failed with exit code ${commandResult.exitCode}`,
+                };
+            }
+            // Get the commit hash from the last commit
+            const hashResult = yield* runGitCommand({
+                args: ["rev-parse", "HEAD"],
+                workingDirectory: workingDir,
+            });
+            const commitHash = hashResult.exitCode === 0 ? hashResult.stdout.trim() : "unknown";
             return {
                 success: true,
                 result: {
                     workingDirectory: workingDir,
                     message: typedArgs.message,
-                    commitHash: "abc123",
+                    commitHash,
                 },
             };
         }),
@@ -395,8 +738,8 @@ function createGitPushTool() {
     })
         .strict();
     return (0, base_tool_1.defineTool)({
-        name: "gitPush",
-        description: "Update remote refs along with associated objects (requires user approval)",
+        name: "git_push",
+        description: "Upload local commits to a remote repository. Pushes the current branch (or specified branch) to the remote (default: origin). Supports force push to overwrite remote history (use with caution). Requires user approval before execution.",
         tags: ["git", "push"],
         parameters,
         validate: (args) => {
@@ -421,32 +764,26 @@ function createGitPushTool() {
                 const remote = typedArgs.remote || "origin";
                 const branch = typedArgs.branch || "current branch";
                 const force = typedArgs.force ? " (force push)" : "";
-                return `Push${force} to ${remote}/${branch} in ${workingDir}?`;
+                return `Push${force} to ${remote}/${branch} in ${workingDir}?\n\nIMPORTANT: After getting user confirmation, you MUST call the execute_git_push tool with these exact arguments: {"path": ${typedArgs.path ? `"${typedArgs.path}"` : "undefined"}, "remote": ${typedArgs.remote ? `"${typedArgs.remote}"` : "undefined"}, "branch": ${typedArgs.branch ? `"${typedArgs.branch}"` : "undefined"}, "force": ${typedArgs.force === true}}`;
             }),
-        },
-        handler: (args, context) => effect_1.Effect.gen(function* () {
-            const shell = yield* shell_1.FileSystemContextServiceTag;
-            const typedArgs = args;
-            const workingDir = typedArgs.path
-                ? yield* shell.resolvePath({
-                    agentId: context.agentId,
-                    ...(context.conversationId && { conversationId: context.conversationId }),
-                }, typedArgs.path)
-                : yield* shell.getCwd({
-                    agentId: context.agentId,
-                    ...(context.conversationId && { conversationId: context.conversationId }),
-                });
-            // For now, return a simple push message
-            return {
-                success: true,
-                result: {
-                    workingDirectory: workingDir,
-                    remote: typedArgs.remote || "origin",
-                    branch: typedArgs.branch || "current",
-                    force: typedArgs.force || false,
-                    message: "Changes would be pushed successfully",
+            errorMessage: "Approval required: Git push requires user confirmation.",
+            execute: {
+                toolName: "execute_git_push",
+                buildArgs: (args) => {
+                    const typedArgs = args;
+                    return {
+                        path: typedArgs.path,
+                        remote: typedArgs.remote,
+                        branch: typedArgs.branch,
+                        force: typedArgs.force,
+                    };
                 },
-            };
+            },
+        },
+        handler: (_args, _context) => effect_1.Effect.succeed({
+            success: false,
+            result: null,
+            error: "Approval required",
         }),
         createSummary: (result) => {
             if (result.success && typeof result.result === "object" && result.result !== null) {
@@ -470,8 +807,8 @@ function createGitPullTool() {
     })
         .strict();
     return (0, base_tool_1.defineTool)({
-        name: "gitPull",
-        description: "Fetch from and integrate with another repository or a local branch (requires user approval)",
+        name: "git_pull",
+        description: "Download and merge changes from a remote repository into the current branch. Combines git fetch and git merge. Supports rebase mode to maintain linear history. Use to update your local branch with remote changes. Requires user approval before execution.",
         tags: ["git", "pull"],
         parameters,
         validate: (args) => {
@@ -496,32 +833,26 @@ function createGitPullTool() {
                 const remote = typedArgs.remote || "origin";
                 const branch = typedArgs.branch || "current branch";
                 const rebase = typedArgs.rebase ? " (with rebase)" : "";
-                return `Pull${rebase} from ${remote}/${branch} in ${workingDir}?`;
+                return `Pull${rebase} from ${remote}/${branch} in ${workingDir}?\n\nIMPORTANT: After getting user confirmation, you MUST call the execute_git_pull tool with these exact arguments: {"path": ${typedArgs.path ? `"${typedArgs.path}"` : "undefined"}, "remote": ${typedArgs.remote ? `"${typedArgs.remote}"` : "undefined"}, "branch": ${typedArgs.branch ? `"${typedArgs.branch}"` : "undefined"}, "rebase": ${typedArgs.rebase === true}}`;
             }),
-        },
-        handler: (args, context) => effect_1.Effect.gen(function* () {
-            const shell = yield* shell_1.FileSystemContextServiceTag;
-            const typedArgs = args;
-            const workingDir = typedArgs.path
-                ? yield* shell.resolvePath({
-                    agentId: context.agentId,
-                    ...(context.conversationId && { conversationId: context.conversationId }),
-                }, typedArgs.path)
-                : yield* shell.getCwd({
-                    agentId: context.agentId,
-                    ...(context.conversationId && { conversationId: context.conversationId }),
-                });
-            // For now, return a simple pull message
-            return {
-                success: true,
-                result: {
-                    workingDirectory: workingDir,
-                    remote: typedArgs.remote || "origin",
-                    branch: typedArgs.branch || "current",
-                    rebase: typedArgs.rebase || false,
-                    message: "Changes would be pulled successfully",
+            errorMessage: "Approval required: Git pull requires user confirmation.",
+            execute: {
+                toolName: "execute_git_pull",
+                buildArgs: (args) => {
+                    const typedArgs = args;
+                    return {
+                        path: typedArgs.path,
+                        remote: typedArgs.remote,
+                        branch: typedArgs.branch,
+                        rebase: typedArgs.rebase,
+                    };
                 },
-            };
+            },
+        },
+        handler: (_args, _context) => effect_1.Effect.succeed({
+            success: false,
+            result: null,
+            error: "Approval required",
         }),
         createSummary: (result) => {
             if (result.success && typeof result.result === "object" && result.result !== null) {
@@ -545,8 +876,8 @@ function createGitCheckoutTool() {
     })
         .strict();
     return (0, base_tool_1.defineTool)({
-        name: "gitCheckout",
-        description: "Switch branches or restore working tree files (requires user approval)",
+        name: "git_checkout",
+        description: "Switch to a different branch or create a new branch. Changes the working directory to match the specified branch. Can create new branches or force checkout (discarding local changes). Use to navigate between branches or start work on a new feature branch. Requires user approval before execution.",
         tags: ["git", "checkout"],
         parameters,
         validate: (args) => {
@@ -570,22 +901,253 @@ function createGitCheckoutTool() {
                     });
                 const create = typedArgs.create ? " (create new branch)" : "";
                 const force = typedArgs.force ? " (force - discards changes)" : "";
-                return `Checkout branch "${typedArgs.branch}"${create}${force} in ${workingDir}?`;
+                return `Checkout branch "${typedArgs.branch}"${create}${force} in ${workingDir}?\n\nIMPORTANT: After getting user confirmation, you MUST call the execute_git_checkout tool with these exact arguments: {"path": ${typedArgs.path ? `"${typedArgs.path}"` : "undefined"}, "branch": "${typedArgs.branch}", "create": ${typedArgs.create === true}, "force": ${typedArgs.force === true}}`;
             }),
+            errorMessage: "Approval required: Git checkout requires user confirmation.",
+            execute: {
+                toolName: "execute_git_checkout",
+                buildArgs: (args) => {
+                    const typedArgs = args;
+                    return {
+                        path: typedArgs.path,
+                        branch: typedArgs.branch,
+                        create: typedArgs.create,
+                        force: typedArgs.force,
+                    };
+                },
+            },
+        },
+        handler: (_args, _context) => effect_1.Effect.succeed({
+            success: false,
+            result: null,
+            error: "Approval required",
+        }),
+        createSummary: (result) => {
+            if (result.success && typeof result.result === "object" && result.result !== null) {
+                const gitResult = result.result;
+                return `Switched to ${gitResult.branch}${gitResult.created ? " (newly created)" : ""}`;
+            }
+            return result.success ? "Git checkout successful" : "Git checkout failed";
+        },
+    });
+}
+function createExecuteGitPushTool() {
+    const parameters = zod_1.z
+        .object({
+        path: zod_1.z
+            .string()
+            .optional()
+            .describe("Path to the Git repository (defaults to current working directory)"),
+        remote: zod_1.z.string().optional().describe("Remote repository name (defaults to 'origin')"),
+        branch: zod_1.z.string().optional().describe("Branch to push (defaults to current branch)"),
+        force: zod_1.z.boolean().optional().describe("Force push (overwrites remote history)"),
+    })
+        .strict();
+    return (0, base_tool_1.defineTool)({
+        name: "execute_git_push",
+        description: "Internal tool that performs the actual git push operation after user has approved the git_push request. Uploads local commits to the remote repository.",
+        hidden: true,
+        parameters,
+        validate: (args) => {
+            const result = parameters.safeParse(args);
+            return result.success
+                ? { valid: true, value: result.data }
+                : { valid: false, errors: result.error.issues.map((i) => i.message) };
+        },
+        handler: (args, context) => effect_1.Effect.gen(function* () {
+            const shell = yield* shell_1.FileSystemContextServiceTag;
+            const typedArgs = args;
+            const workingDirResult = yield* resolveWorkingDirectory(shell, context, typedArgs.path).pipe(effect_1.Effect.catchAll((error) => effect_1.Effect.succeed({
+                success: false,
+                result: null,
+                error: error instanceof Error ? error.message : String(error),
+            })));
+            if (typeof workingDirResult === "object" &&
+                "success" in workingDirResult &&
+                !workingDirResult.success) {
+                return workingDirResult;
+            }
+            const workingDir = workingDirResult;
+            const remote = typedArgs.remote || "origin";
+            const branch = typedArgs.branch || "";
+            const pushArgs = ["push"];
+            if (typedArgs.force) {
+                pushArgs.push("--force");
+            }
+            if (branch) {
+                pushArgs.push(remote, branch);
+            }
+            else {
+                pushArgs.push(remote);
+            }
+            const commandResult = yield* runGitCommand({
+                args: pushArgs,
+                workingDirectory: workingDir,
+            });
+            if (commandResult.exitCode !== 0) {
+                return {
+                    success: false,
+                    result: null,
+                    error: commandResult.stderr || `git push failed with exit code ${commandResult.exitCode}`,
+                };
+            }
+            return {
+                success: true,
+                result: {
+                    workingDirectory: workingDir,
+                    remote,
+                    branch: branch || "current",
+                    force: typedArgs.force || false,
+                    message: "Changes pushed successfully",
+                },
+            };
+        }),
+        createSummary: (result) => {
+            if (result.success && typeof result.result === "object" && result.result !== null) {
+                const gitResult = result.result;
+                return `Pushed to ${gitResult.remote}/${gitResult.branch}${gitResult.force ? " (force)" : ""}`;
+            }
+            return result.success ? "Git push successful" : "Git push failed";
+        },
+    });
+}
+function createExecuteGitPullTool() {
+    const parameters = zod_1.z
+        .object({
+        path: zod_1.z
+            .string()
+            .optional()
+            .describe("Path to the Git repository (defaults to current working directory)"),
+        remote: zod_1.z.string().optional().describe("Remote repository name (defaults to 'origin')"),
+        branch: zod_1.z.string().optional().describe("Branch to pull (defaults to current branch)"),
+        rebase: zod_1.z.boolean().optional().describe("Use rebase instead of merge"),
+    })
+        .strict();
+    return (0, base_tool_1.defineTool)({
+        name: "execute_git_pull",
+        description: "Internal tool that performs the actual git pull operation after user has approved the git_pull request. Downloads and merges changes from the remote repository.",
+        hidden: true,
+        parameters,
+        validate: (args) => {
+            const result = parameters.safeParse(args);
+            return result.success
+                ? { valid: true, value: result.data }
+                : { valid: false, errors: result.error.issues.map((i) => i.message) };
         },
         handler: (args, context) => effect_1.Effect.gen(function* () {
             const shell = yield* shell_1.FileSystemContextServiceTag;
             const typedArgs = args;
-            const workingDir = typedArgs.path
-                ? yield* shell.resolvePath({
-                    agentId: context.agentId,
-                    ...(context.conversationId && { conversationId: context.conversationId }),
-                }, typedArgs.path)
-                : yield* shell.getCwd({
-                    agentId: context.agentId,
-                    ...(context.conversationId && { conversationId: context.conversationId }),
-                });
-            // For now, return a simple checkout message
+            const workingDirResult = yield* resolveWorkingDirectory(shell, context, typedArgs.path).pipe(effect_1.Effect.catchAll((error) => effect_1.Effect.succeed({
+                success: false,
+                result: null,
+                error: error instanceof Error ? error.message : String(error),
+            })));
+            if (typeof workingDirResult === "object" &&
+                "success" in workingDirResult &&
+                !workingDirResult.success) {
+                return workingDirResult;
+            }
+            const workingDir = workingDirResult;
+            const remote = typedArgs.remote || "origin";
+            const branch = typedArgs.branch || "";
+            const pullArgs = ["pull"];
+            if (typedArgs.rebase) {
+                pullArgs.push("--rebase");
+            }
+            if (branch) {
+                pullArgs.push(remote, branch);
+            }
+            else {
+                pullArgs.push(remote);
+            }
+            const commandResult = yield* runGitCommand({
+                args: pullArgs,
+                workingDirectory: workingDir,
+            });
+            if (commandResult.exitCode !== 0) {
+                return {
+                    success: false,
+                    result: null,
+                    error: commandResult.stderr || `git pull failed with exit code ${commandResult.exitCode}`,
+                };
+            }
+            return {
+                success: true,
+                result: {
+                    workingDirectory: workingDir,
+                    remote,
+                    branch: branch || "current",
+                    rebase: typedArgs.rebase || false,
+                    message: "Changes pulled successfully",
+                },
+            };
+        }),
+        createSummary: (result) => {
+            if (result.success && typeof result.result === "object" && result.result !== null) {
+                const gitResult = result.result;
+                return `Pulled from ${gitResult.remote}/${gitResult.branch}${gitResult.rebase ? " (rebase)" : ""}`;
+            }
+            return result.success ? "Git pull successful" : "Git pull failed";
+        },
+    });
+}
+function createExecuteGitCheckoutTool() {
+    const parameters = zod_1.z
+        .object({
+        path: zod_1.z
+            .string()
+            .optional()
+            .describe("Path to the Git repository (defaults to current working directory)"),
+        branch: zod_1.z.string().min(1).describe("Branch name to checkout"),
+        create: zod_1.z.boolean().optional().describe("Create the branch if it doesn't exist"),
+        force: zod_1.z.boolean().optional().describe("Force checkout (discards local changes)"),
+    })
+        .strict();
+    return (0, base_tool_1.defineTool)({
+        name: "execute_git_checkout",
+        description: "Internal tool that performs the actual git checkout operation after user has approved the git_checkout request. Switches to the specified branch or creates a new branch.",
+        hidden: true,
+        parameters,
+        validate: (args) => {
+            const result = parameters.safeParse(args);
+            return result.success
+                ? { valid: true, value: result.data }
+                : { valid: false, errors: result.error.issues.map((i) => i.message) };
+        },
+        handler: (args, context) => effect_1.Effect.gen(function* () {
+            const shell = yield* shell_1.FileSystemContextServiceTag;
+            const typedArgs = args;
+            const workingDirResult = yield* resolveWorkingDirectory(shell, context, typedArgs.path).pipe(effect_1.Effect.catchAll((error) => effect_1.Effect.succeed({
+                success: false,
+                result: null,
+                error: error instanceof Error ? error.message : String(error),
+            })));
+            if (typeof workingDirResult === "object" &&
+                "success" in workingDirResult &&
+                !workingDirResult.success) {
+                return workingDirResult;
+            }
+            const workingDir = workingDirResult;
+            const checkoutArgs = ["checkout"];
+            if (typedArgs.create) {
+                checkoutArgs.push("-b");
+            }
+            if (typedArgs.force) {
+                checkoutArgs.push("--force");
+            }
+            checkoutArgs.push(typedArgs.branch);
+            const commandResult = yield* runGitCommand({
+                args: checkoutArgs,
+                workingDirectory: workingDir,
+            });
+            if (commandResult.exitCode !== 0) {
+                return {
+                    success: false,
+                    result: null,
+                    error: commandResult.stderr ||
+                        `git checkout failed with exit code ${commandResult.exitCode}`,
+                };
+            }
             return {
                 success: true,
                 result: {