@cyanheads/git-mcp-server 1.2.4

package/build/tools/branch.js

@@ -0,0 +1,296 @@
+/**
+ * Branch Tools
+ * ===========
+ *
+ * MCP tools for Git branch operations.
+ */
+import { z } from 'zod';
+import { GitService } from '../services/git-service.js';
+import { PathValidation } from '../utils/validation.js';
+/**
+ * Registers branch tools with the MCP server
+ *
+ * @param server - MCP server instance
+ */
+export function setupBranchTools(server) {
+    // List branches
+    server.tool("git_branch_list", "List branches in a repository. Displays both local and optionally remote branches, clearly marking the current branch.", {
+        path: z.string().min(1, "Repository path is required").describe("Path to the Git repository"),
+        all: z.boolean().optional().default(false).describe("Whether to include remote branches in the list")
+    }, async ({ path, all }) => {
+        try {
+            const normalizedPath = PathValidation.normalizePath(path);
+            const gitService = new GitService(normalizedPath);
+            // Check if this is a git repository
+            const isRepo = await gitService.isGitRepository();
+            if (!isRepo) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Error: Not a Git repository: ${normalizedPath}`
+                        }],
+                    isError: true
+                };
+            }
+            const result = await gitService.listBranches(all);
+            if (!result.resultSuccessful) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Error: ${result.resultError.errorMessage}`
+                        }],
+                    isError: true
+                };
+            }
+            // The listBranches result now contains the current branch
+            const branchSummary = result.resultData;
+            const currentBranch = branchSummary.current;
+            const allBranches = branchSummary.all; // Get all branch names from the summary
+            if (allBranches.length === 0) { // Check the length of the derived array
+                return {
+                    content: [{
+                            type: "text",
+                            text: `No branches found in repository at: ${normalizedPath}`
+                        }]
+                };
+            }
+            // Format output
+            let output = `Branches in repository at: ${normalizedPath}\n\n`;
+            allBranches.forEach(branch => {
+                // Clean up potential remote prefixes like 'remotes/origin/' for display if needed
+                const displayBranch = branch.replace(/^remotes\/[^\/]+\//, '');
+                if (displayBranch === currentBranch) {
+                    output += `* ${displayBranch} (current)\n`;
+                }
+                else {
+                    output += `  ${displayBranch}\n`;
+                }
+            });
+            return {
+                content: [{
+                        type: "text",
+                        text: output
+                    }]
+            };
+        }
+        catch (error) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `Error: ${error instanceof Error ? error.message : String(error)}`
+                    }],
+                isError: true
+            };
+        }
+    });
+    // Create branch
+    server.tool("git_branch_create", "Create a new branch. Creates a new branch at the specified reference point (commit or branch) and optionally checks it out.", {
+        path: z.string().min(1, "Repository path is required").describe("Path to the Git repository"),
+        name: z.string().min(1, "Branch name is required").describe("Name of the new branch to create"),
+        startPoint: z.string().optional().describe("Reference (commit, branch) to create the branch from"),
+        checkout: z.boolean().optional().default(false).describe("Whether to checkout the newly created branch")
+    }, async ({ path, name, startPoint, checkout }) => {
+        try {
+            const normalizedPath = PathValidation.normalizePath(path);
+            const gitService = new GitService(normalizedPath);
+            // Check if this is a git repository
+            const isRepo = await gitService.isGitRepository();
+            if (!isRepo) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Error: Not a Git repository: ${normalizedPath}`
+                        }],
+                    isError: true
+                };
+            }
+            const result = await gitService.createBranch({
+                name,
+                startPoint,
+                checkout
+            });
+            if (!result.resultSuccessful) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Error: ${result.resultError.errorMessage}`
+                        }],
+                    isError: true
+                };
+            }
+            return {
+                content: [{
+                        type: "text",
+                        text: `Successfully created branch '${name}'${checkout ? ' and checked it out' : ''}`
+                    }]
+            };
+        }
+        catch (error) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `Error: ${error instanceof Error ? error.message : String(error)}`
+                    }],
+                isError: true
+            };
+        }
+    });
+    // Checkout branch
+    server.tool("git_checkout", "Checkout a branch, tag, or commit. Switches the working directory to the specified target and updates HEAD to point to it. Can optionally create a new branch.", {
+        path: z.string().min(1, "Repository path is required").describe("Path to the Git repository"),
+        target: z.string().min(1, "Branch or commit to checkout is required").describe("Branch name, tag, or commit hash to checkout"),
+        createBranch: z.boolean().optional().default(false).describe("Whether to create a new branch with the specified name")
+    }, async ({ path, target, createBranch }) => {
+        try {
+            const normalizedPath = PathValidation.normalizePath(path);
+            const gitService = new GitService(normalizedPath);
+            // Check if this is a git repository
+            const isRepo = await gitService.isGitRepository();
+            if (!isRepo) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Error: Not a Git repository: ${normalizedPath}`
+                        }],
+                    isError: true
+                };
+            }
+            const result = await gitService.checkout(target, createBranch);
+            if (!result.resultSuccessful) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Error: ${result.resultError.errorMessage}`
+                        }],
+                    isError: true
+                };
+            }
+            return {
+                content: [{
+                        type: "text",
+                        text: `Successfully checked out '${target}'${createBranch ? ' (new branch)' : ''}`
+                    }]
+            };
+        }
+        catch (error) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `Error: ${error instanceof Error ? error.message : String(error)}`
+                    }],
+                isError: true
+            };
+        }
+    });
+    // Delete branch
+    server.tool("git_branch_delete", "Delete a branch. Removes the specified branch from the repository. By default, only fully merged branches can be deleted unless force is set to true.", {
+        path: z.string().min(1, "Repository path is required").describe("Path to the Git repository"),
+        branch: z.string().min(1, "Branch name is required").describe("Name of the branch to delete"),
+        force: z.boolean().optional().default(false).describe("Force deletion even if branch is not fully merged")
+    }, async ({ path, branch, force }) => {
+        try {
+            const normalizedPath = PathValidation.normalizePath(path);
+            const gitService = new GitService(normalizedPath);
+            // Check if this is a git repository
+            const isRepo = await gitService.isGitRepository();
+            if (!isRepo) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Error: Not a Git repository: ${normalizedPath}`
+                        }],
+                    isError: true
+                };
+            }
+            const result = await gitService.deleteBranch(branch, force);
+            if (!result.resultSuccessful) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Error: ${result.resultError.errorMessage}`
+                        }],
+                    isError: true
+                };
+            }
+            return {
+                content: [{
+                        type: "text",
+                        text: `Successfully deleted branch '${branch}'`
+                    }]
+            };
+        }
+        catch (error) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `Error: ${error instanceof Error ? error.message : String(error)}`
+                    }],
+                isError: true
+            };
+        }
+    });
+    // Merge branch
+    server.tool("git_merge", "Merge a branch into the current branch. Combines changes from the specified branch into the current branch with configurable merge strategies.", {
+        path: z.string().min(1, "Repository path is required").describe("Path to the Git repository"),
+        branch: z.string().min(1, "Branch to merge is required").describe("Name of the branch to merge into the current branch"),
+        message: z.string().optional().describe("Custom commit message for the merge commit"),
+        fastForwardOnly: z.boolean().optional().default(false).describe("Only allow fast-forward merges (fail if not possible)"),
+        noFastForward: z.boolean().optional().default(false).describe("Create a merge commit even when fast-forward is possible")
+    }, async ({ path, branch, message, fastForwardOnly, noFastForward }) => {
+        try {
+            const normalizedPath = PathValidation.normalizePath(path);
+            const gitService = new GitService(normalizedPath);
+            // Check if this is a git repository
+            const isRepo = await gitService.isGitRepository();
+            if (!isRepo) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Error: Not a Git repository: ${normalizedPath}`
+                        }],
+                    isError: true
+                };
+            }
+            // Can't have both fastForwardOnly and noFastForward
+            if (fastForwardOnly && noFastForward) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Error: Cannot specify both fastForwardOnly and noFastForward`
+                        }],
+                    isError: true
+                };
+            }
+            const result = await gitService.merge({
+                branch,
+                message,
+                fastForwardOnly,
+                noFastForward
+            });
+            if (!result.resultSuccessful) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Error: ${result.resultError.errorMessage}`
+                        }],
+                    isError: true
+                };
+            }
+            return {
+                content: [{
+                        type: "text",
+                        text: `Successfully merged branch '${branch}' into current branch`
+                    }]
+            };
+        }
+        catch (error) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `Error: ${error instanceof Error ? error.message : String(error)}`
+                    }],
+                isError: true
+            };
+        }
+    });
+}

package/build/tools/index.js

@@ -0,0 +1,29 @@
+/**
+ * MCP Tool Handlers
+ * ================
+ *
+ * Entry point for all MCP tool implementations.
+ * This module registers all tool handlers with the MCP server.
+ */
+import { setupRepositoryTools } from './repository.js';
+import { setupBranchTools } from './branch.js';
+import { setupWorkdirTools } from './workdir.js';
+import { setupRemoteTools } from './remote.js';
+import { setupAdvancedTools } from './advanced.js';
+/**
+ * Registers all Git MCP tools with the server
+ *
+ * @param server - MCP server instance
+ */
+export function registerAllTools(server) {
+    // Repository operations (init, clone, status)
+    setupRepositoryTools(server);
+    // Branch operations (create, checkout, merge, etc.)
+    setupBranchTools(server);
+    // Working directory operations (stage, unstage, commit, etc.)
+    setupWorkdirTools(server);
+    // Remote operations (add, fetch, pull, push, etc.)
+    setupRemoteTools(server);
+    // Advanced operations (stash, cherry-pick, rebase, etc.)
+    setupAdvancedTools(server);
+}

package/build/tools/remote.js

@@ -0,0 +1,279 @@
+/**
+ * Remote Tools
+ * ===========
+ *
+ * MCP tools for Git remote operations.
+ */
+import { z } from 'zod';
+import { GitService } from '../services/git-service.js';
+import { PathValidation } from '../utils/validation.js';
+/**
+ * Registers remote operation tools with the MCP server
+ *
+ * @param server - MCP server instance
+ */
+export function setupRemoteTools(server) {
+    // Add a remote
+    server.tool("git_remote_add", "Add a new remote repository reference. Creates a connection to a remote repository with a name and URL, allowing fetching and pushing changes to and from that repository.", {
+        path: z.string().min(1, "Repository path is required").describe("Path to the Git repository"),
+        name: z.string().min(1, "Remote name is required").describe("Name for the remote repository (e.g., 'origin')"),
+        url: z.string().url("Invalid URL format").describe("URL of the remote repository")
+    }, async ({ path, name, url }) => {
+        try {
+            const normalizedPath = PathValidation.normalizePath(path);
+            const gitService = new GitService(normalizedPath);
+            // Check if this is a git repository
+            const isRepo = await gitService.isGitRepository();
+            if (!isRepo) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Error: Not a Git repository: ${normalizedPath}`
+                        }],
+                    isError: true
+                };
+            }
+            const result = await gitService.addRemote({
+                name,
+                url
+            });
+            if (!result.resultSuccessful) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Error: ${result.resultError.errorMessage}`
+                        }],
+                    isError: true
+                };
+            }
+            return {
+                content: [{
+                        type: "text",
+                        text: `Successfully added remote '${name}' with URL '${url}'`
+                    }]
+            };
+        }
+        catch (error) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `Error: ${error instanceof Error ? error.message : String(error)}`
+                    }],
+                isError: true
+            };
+        }
+    });
+    // List remotes
+    server.tool("git_remote_list", "List all configured remote repositories. Displays the names and URLs of all remotes associated with the repository, showing both fetch and push URLs.", {
+        path: z.string().min(1, "Repository path is required").describe("Path to the Git repository")
+    }, async ({ path }) => {
+        try {
+            const normalizedPath = PathValidation.normalizePath(path);
+            const gitService = new GitService(normalizedPath);
+            // Check if this is a git repository
+            const isRepo = await gitService.isGitRepository();
+            if (!isRepo) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Error: Not a Git repository: ${normalizedPath}`
+                        }],
+                    isError: true
+                };
+            }
+            const result = await gitService.listRemotes();
+            if (!result.resultSuccessful) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Error: ${result.resultError.errorMessage}`
+                        }],
+                    isError: true
+                };
+            }
+            if (result.resultData.length === 0) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `No remotes found in repository at: ${normalizedPath}`
+                        }]
+                };
+            }
+            // Format output
+            let output = `Remotes in repository at: ${normalizedPath}\n\n`;
+            result.resultData.forEach(remote => {
+                output += `${remote.name}\n`;
+                output += `  fetch: ${remote.refs.fetch}\n`;
+                output += `  push: ${remote.refs.push}\n\n`;
+            });
+            return {
+                content: [{
+                        type: "text",
+                        text: output
+                    }]
+            };
+        }
+        catch (error) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `Error: ${error instanceof Error ? error.message : String(error)}`
+                    }],
+                isError: true
+            };
+        }
+    });
+    // Fetch from remote
+    server.tool("git_fetch", "Fetch changes from a remote repository. Downloads objects and refs from a remote repository without merging them into local branches.", {
+        path: z.string().min(1, "Repository path is required").describe("Path to the Git repository"),
+        remote: z.string().optional().default("origin").describe("Name of the remote to fetch from (defaults to 'origin')"),
+        branch: z.string().optional().describe("Specific branch to fetch (fetches all branches if omitted)")
+    }, async ({ path, remote, branch }) => {
+        try {
+            const normalizedPath = PathValidation.normalizePath(path);
+            const gitService = new GitService(normalizedPath);
+            // Check if this is a git repository
+            const isRepo = await gitService.isGitRepository();
+            if (!isRepo) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Error: Not a Git repository: ${normalizedPath}`
+                        }],
+                    isError: true
+                };
+            }
+            const result = await gitService.fetch(remote, branch);
+            if (!result.resultSuccessful) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Error: ${result.resultError.errorMessage}`
+                        }],
+                    isError: true
+                };
+            }
+            return {
+                content: [{
+                        type: "text",
+                        text: `Successfully fetched from remote '${remote}'${branch ? ` branch '${branch}'` : ''}`
+                    }]
+            };
+        }
+        catch (error) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `Error: ${error instanceof Error ? error.message : String(error)}`
+                    }],
+                isError: true
+            };
+        }
+    });
+    // Pull from remote
+    server.tool("git_pull", "Pull changes from a remote repository. Fetches from a remote repository and integrates changes into the current branch, either by merging or rebasing.", {
+        path: z.string().min(1, "Repository path is required").describe("Path to the Git repository"),
+        remote: z.string().optional().describe("Name of the remote to pull from (defaults to origin)"),
+        branch: z.string().optional().describe("Branch to pull from (defaults to current tracking branch)"),
+        rebase: z.boolean().optional().default(false).describe("Whether to use rebase instead of merge when pulling")
+    }, async ({ path, remote, branch, rebase }) => {
+        try {
+            const normalizedPath = PathValidation.normalizePath(path);
+            const gitService = new GitService(normalizedPath);
+            // Check if this is a git repository
+            const isRepo = await gitService.isGitRepository();
+            if (!isRepo) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Error: Not a Git repository: ${normalizedPath}`
+                        }],
+                    isError: true
+                };
+            }
+            const result = await gitService.pull({
+                remote,
+                branch,
+                rebase
+            });
+            if (!result.resultSuccessful) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Error: ${result.resultError.errorMessage}`
+                        }],
+                    isError: true
+                };
+            }
+            return {
+                content: [{
+                        type: "text",
+                        text: `Successfully pulled changes${remote ? ` from remote '${remote}'` : ''}${branch ? ` branch '${branch}'` : ''}${rebase ? ' with rebase' : ''}`
+                    }]
+            };
+        }
+        catch (error) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `Error: ${error instanceof Error ? error.message : String(error)}`
+                    }],
+                isError: true
+            };
+        }
+    });
+    // Push to remote
+    server.tool("git_push", "Push local changes to a remote repository. Uploads local branch commits to the remote repository, updating remote references.", {
+        path: z.string().min(1, "Repository path is required").describe("Path to the Git repository"),
+        remote: z.string().optional().default("origin").describe("Name of the remote to push to (defaults to 'origin')"),
+        branch: z.string().optional().describe("Branch to push (defaults to current branch)"),
+        force: z.boolean().optional().default(false).describe("Force push changes, overwriting remote history"),
+        setUpstream: z.boolean().optional().default(false).describe("Set upstream tracking for the branch being pushed")
+    }, async ({ path, remote, branch, force, setUpstream }) => {
+        try {
+            const normalizedPath = PathValidation.normalizePath(path);
+            const gitService = new GitService(normalizedPath);
+            // Check if this is a git repository
+            const isRepo = await gitService.isGitRepository();
+            if (!isRepo) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Error: Not a Git repository: ${normalizedPath}`
+                        }],
+                    isError: true
+                };
+            }
+            const result = await gitService.push({
+                remote,
+                branch,
+                force,
+                setUpstream
+            });
+            if (!result.resultSuccessful) {
+                return {
+                    content: [{
+                            type: "text",
+                            text: `Error: ${result.resultError.errorMessage}`
+                        }],
+                    isError: true
+                };
+            }
+            return {
+                content: [{
+                        type: "text",
+                        text: `Successfully pushed changes to remote '${remote}'${branch ? ` branch '${branch}'` : ''}${force ? ' (force push)' : ''}${setUpstream ? ' (set upstream)' : ''}`
+                    }]
+            };
+        }
+        catch (error) {
+            return {
+                content: [{
+                        type: "text",
+                        text: `Error: ${error instanceof Error ? error.message : String(error)}`
+                    }],
+                isError: true
+            };
+        }
+    });
+}