mcp-server-git 2025.1.14__py3-none-any.whl

mcp_server_git/__init__.py

@@ -0,0 +1,24 @@
+import click
+from pathlib import Path
+import logging
+import sys
+from .server import serve
+
+@click.command()
+@click.option("--repository", "-r", type=Path, help="Git repository path")
+@click.option("-v", "--verbose", count=True)
+def main(repository: Path | None, verbose: bool) -> None:
+    """MCP Git Server - Git functionality for MCP"""
+    import asyncio
+
+    logging_level = logging.WARN
+    if verbose == 1:
+        logging_level = logging.INFO
+    elif verbose >= 2:
+        logging_level = logging.DEBUG
+
+    logging.basicConfig(level=logging_level, stream=sys.stderr)
+    asyncio.run(serve(repository))
+
+if __name__ == "__main__":
+    main()

mcp_server_git/__main__.py

@@ -0,0 +1,5 @@
+# __main__.py
+
+from mcp_server_git import main
+
+main()

mcp_server_git/server.py

@@ -0,0 +1,333 @@
+import logging
+from pathlib import Path
+from typing import Sequence
+from mcp.server import Server
+from mcp.server.session import ServerSession
+from mcp.server.stdio import stdio_server
+from mcp.types import (
+    ClientCapabilities,
+    TextContent,
+    Tool,
+    ListRootsResult,
+    RootsCapability,
+)
+from enum import Enum
+import git
+from pydantic import BaseModel
+
+class GitStatus(BaseModel):
+    repo_path: str
+
+class GitDiffUnstaged(BaseModel):
+    repo_path: str
+
+class GitDiffStaged(BaseModel):
+    repo_path: str
+
+class GitDiff(BaseModel):
+    repo_path: str
+    target: str
+
+class GitCommit(BaseModel):
+    repo_path: str
+    message: str
+
+class GitAdd(BaseModel):
+    repo_path: str
+    files: list[str]
+
+class GitReset(BaseModel):
+    repo_path: str
+
+class GitLog(BaseModel):
+    repo_path: str
+    max_count: int = 10
+
+class GitCreateBranch(BaseModel):
+    repo_path: str
+    branch_name: str
+    base_branch: str | None = None
+
+class GitCheckout(BaseModel):
+    repo_path: str
+    branch_name: str
+
+class GitShow(BaseModel):
+    repo_path: str
+    revision: str
+
+class GitTools(str, Enum):
+    STATUS = "git_status"
+    DIFF_UNSTAGED = "git_diff_unstaged"
+    DIFF_STAGED = "git_diff_staged"
+    DIFF = "git_diff"
+    COMMIT = "git_commit"
+    ADD = "git_add"
+    RESET = "git_reset"
+    LOG = "git_log"
+    CREATE_BRANCH = "git_create_branch"
+    CHECKOUT = "git_checkout"
+    SHOW = "git_show"
+
+def git_status(repo: git.Repo) -> str:
+    return repo.git.status()
+
+def git_diff_unstaged(repo: git.Repo) -> str:
+    return repo.git.diff()
+
+def git_diff_staged(repo: git.Repo) -> str:
+    return repo.git.diff("--cached")
+
+def git_diff(repo: git.Repo, target: str) -> str:
+    return repo.git.diff(target)
+
+def git_commit(repo: git.Repo, message: str) -> str:
+    commit = repo.index.commit(message)
+    return f"Changes committed successfully with hash {commit.hexsha}"
+
+def git_add(repo: git.Repo, files: list[str]) -> str:
+    repo.index.add(files)
+    return "Files staged successfully"
+
+def git_reset(repo: git.Repo) -> str:
+    repo.index.reset()
+    return "All staged changes reset"
+
+def git_log(repo: git.Repo, max_count: int = 10) -> list[str]:
+    commits = list(repo.iter_commits(max_count=max_count))
+    log = []
+    for commit in commits:
+        log.append(
+            f"Commit: {commit.hexsha}\n"
+            f"Author: {commit.author}\n"
+            f"Date: {commit.authored_datetime}\n"
+            f"Message: {commit.message}\n"
+        )
+    return log
+
+def git_create_branch(repo: git.Repo, branch_name: str, base_branch: str | None = None) -> str:
+    if base_branch:
+        base = repo.refs[base_branch]
+    else:
+        base = repo.active_branch
+
+    repo.create_head(branch_name, base)
+    return f"Created branch '{branch_name}' from '{base.name}'"
+
+def git_checkout(repo: git.Repo, branch_name: str) -> str:
+    repo.git.checkout(branch_name)
+    return f"Switched to branch '{branch_name}'"
+
+def git_show(repo: git.Repo, revision: str) -> str:
+    commit = repo.commit(revision)
+    output = [
+        f"Commit: {commit.hexsha}\n"
+        f"Author: {commit.author}\n"
+        f"Date: {commit.authored_datetime}\n"
+        f"Message: {commit.message}\n"
+    ]
+    if commit.parents:
+        parent = commit.parents[0]
+        diff = parent.diff(commit, create_patch=True)
+    else:
+        diff = commit.diff(git.NULL_TREE, create_patch=True)
+    for d in diff:
+        output.append(f"\n--- {d.a_path}\n+++ {d.b_path}\n")
+        output.append(d.diff.decode('utf-8'))
+    return "".join(output)
+
+async def serve(repository: Path | None) -> None:
+    logger = logging.getLogger(__name__)
+
+    if repository is not None:
+        try:
+            git.Repo(repository)
+            logger.info(f"Using repository at {repository}")
+        except git.InvalidGitRepositoryError:
+            logger.error(f"{repository} is not a valid Git repository")
+            return
+
+    server = Server("mcp-git")
+
+    @server.list_tools()
+    async def list_tools() -> list[Tool]:
+        return [
+            Tool(
+                name=GitTools.STATUS,
+                description="Shows the working tree status",
+                inputSchema=GitStatus.schema(),
+            ),
+            Tool(
+                name=GitTools.DIFF_UNSTAGED,
+                description="Shows changes in the working directory that are not yet staged",
+                inputSchema=GitDiffUnstaged.schema(),
+            ),
+            Tool(
+                name=GitTools.DIFF_STAGED,
+                description="Shows changes that are staged for commit",
+                inputSchema=GitDiffStaged.schema(),
+            ),
+            Tool(
+                name=GitTools.DIFF,
+                description="Shows differences between branches or commits",
+                inputSchema=GitDiff.schema(),
+            ),
+            Tool(
+                name=GitTools.COMMIT,
+                description="Records changes to the repository",
+                inputSchema=GitCommit.schema(),
+            ),
+            Tool(
+                name=GitTools.ADD,
+                description="Adds file contents to the staging area",
+                inputSchema=GitAdd.schema(),
+            ),
+            Tool(
+                name=GitTools.RESET,
+                description="Unstages all staged changes",
+                inputSchema=GitReset.schema(),
+            ),
+            Tool(
+                name=GitTools.LOG,
+                description="Shows the commit logs",
+                inputSchema=GitLog.schema(),
+            ),
+            Tool(
+                name=GitTools.CREATE_BRANCH,
+                description="Creates a new branch from an optional base branch",
+                inputSchema=GitCreateBranch.schema(),
+            ),
+            Tool(
+                name=GitTools.CHECKOUT,
+                description="Switches branches",
+                inputSchema=GitCheckout.schema(),
+            ),
+            Tool(
+                name=GitTools.SHOW,
+                description="Shows the contents of a commit",
+                inputSchema=GitShow.schema(),
+            )
+        ]
+
+    async def list_repos() -> Sequence[str]:
+        async def by_roots() -> Sequence[str]:
+            if not isinstance(server.request_context.session, ServerSession):
+                raise TypeError("server.request_context.session must be a ServerSession")
+
+            if not server.request_context.session.check_client_capability(
+                ClientCapabilities(roots=RootsCapability())
+            ):
+                return []
+
+            roots_result: ListRootsResult = await server.request_context.session.list_roots()
+            logger.debug(f"Roots result: {roots_result}")
+            repo_paths = []
+            for root in roots_result.roots:
+                path = root.uri.path
+                try:
+                    git.Repo(path)
+                    repo_paths.append(str(path))
+                except git.InvalidGitRepositoryError:
+                    pass
+            return repo_paths
+
+        def by_commandline() -> Sequence[str]:
+            return [str(repository)] if repository is not None else []
+
+        cmd_repos = by_commandline()
+        root_repos = await by_roots()
+        return [*root_repos, *cmd_repos]
+
+    @server.call_tool()
+    async def call_tool(name: str, arguments: dict) -> list[TextContent]:
+        repo_path = Path(arguments["repo_path"])
+        repo = git.Repo(repo_path)
+
+        match name:
+            case GitTools.STATUS:
+                status = git_status(repo)
+                return [TextContent(
+                    type="text",
+                    text=f"Repository status:\n{status}"
+                )]
+
+            case GitTools.DIFF_UNSTAGED:
+                diff = git_diff_unstaged(repo)
+                return [TextContent(
+                    type="text",
+                    text=f"Unstaged changes:\n{diff}"
+                )]
+
+            case GitTools.DIFF_STAGED:
+                diff = git_diff_staged(repo)
+                return [TextContent(
+                    type="text",
+                    text=f"Staged changes:\n{diff}"
+                )]
+
+            case GitTools.DIFF:
+                diff = git_diff(repo, arguments["target"])
+                return [TextContent(
+                    type="text",
+                    text=f"Diff with {arguments['target']}:\n{diff}"
+                )]
+
+            case GitTools.COMMIT:
+                result = git_commit(repo, arguments["message"])
+                return [TextContent(
+                    type="text",
+                    text=result
+                )]
+
+            case GitTools.ADD:
+                result = git_add(repo, arguments["files"])
+                return [TextContent(
+                    type="text",
+                    text=result
+                )]
+
+            case GitTools.RESET:
+                result = git_reset(repo)
+                return [TextContent(
+                    type="text",
+                    text=result
+                )]
+
+            case GitTools.LOG:
+                log = git_log(repo, arguments.get("max_count", 10))
+                return [TextContent(
+                    type="text",
+                    text="Commit history:\n" + "\n".join(log)
+                )]
+
+            case GitTools.CREATE_BRANCH:
+                result = git_create_branch(
+                    repo,
+                    arguments["branch_name"],
+                    arguments.get("base_branch")
+                )
+                return [TextContent(
+                    type="text",
+                    text=result
+                )]
+
+            case GitTools.CHECKOUT:
+                result = git_checkout(repo, arguments["branch_name"])
+                return [TextContent(
+                    type="text",
+                    text=result
+                )]
+
+            case GitTools.SHOW:
+                result = git_show(repo, arguments["revision"])
+                return [TextContent(
+                    type="text",
+                    text=result
+                )]
+
+            case _:
+                raise ValueError(f"Unknown tool: {name}")
+
+    options = server.create_initialization_options()
+    async with stdio_server() as (read_stream, write_stream):
+        await server.run(read_stream, write_stream, options, raise_exceptions=True)

mcp_server_git-2025.1.14.dist-info/METADATA

@@ -0,0 +1,280 @@
+Metadata-Version: 2.4
+Name: mcp-server-git
+Version: 2025.1.14
+Summary: A Model Context Protocol server providing tools to read, search, and manipulate Git repositories programmatically via LLMs
+Author: Anthropic, PBC.
+Maintainer-email: David Soria Parra <davidsp@anthropic.com>
+License: MIT
+License-File: LICENSE
+Keywords: automation,git,llm,mcp
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Requires-Python: >=3.10
+Requires-Dist: click>=8.1.7
+Requires-Dist: gitpython>=3.1.43
+Requires-Dist: mcp>=1.0.0
+Requires-Dist: pydantic>=2.0.0
+Description-Content-Type: text/markdown
+
+# mcp-server-git: A git MCP server
+
+## Overview
+
+A Model Context Protocol server for Git repository interaction and automation. This server provides tools to read, search, and manipulate Git repositories via Large Language Models.
+
+Please note that mcp-server-git is currently in early development. The functionality and available tools are subject to change and expansion as we continue to develop and improve the server.
+
+### Tools
+
+1. `git_status`
+   - Shows the working tree status
+   - Input:
+     - `repo_path` (string): Path to Git repository
+   - Returns: Current status of working directory as text output
+
+2. `git_diff_unstaged`
+   - Shows changes in working directory not yet staged
+   - Input:
+     - `repo_path` (string): Path to Git repository
+   - Returns: Diff output of unstaged changes
+
+3. `git_diff_staged`
+   - Shows changes that are staged for commit
+   - Input:
+     - `repo_path` (string): Path to Git repository
+   - Returns: Diff output of staged changes
+
+4. `git_diff`
+   - Shows differences between branches or commits
+   - Inputs:
+     - `repo_path` (string): Path to Git repository
+     - `target` (string): Target branch or commit to compare with
+   - Returns: Diff output comparing current state with target
+
+5. `git_commit`
+   - Records changes to the repository
+   - Inputs:
+     - `repo_path` (string): Path to Git repository
+     - `message` (string): Commit message
+   - Returns: Confirmation with new commit hash
+
+6. `git_add`
+   - Adds file contents to the staging area
+   - Inputs:
+     - `repo_path` (string): Path to Git repository
+     - `files` (string[]): Array of file paths to stage
+   - Returns: Confirmation of staged files
+
+7. `git_reset`
+   - Unstages all staged changes
+   - Input:
+     - `repo_path` (string): Path to Git repository
+   - Returns: Confirmation of reset operation
+
+8. `git_log`
+   - Shows the commit logs
+   - Inputs:
+     - `repo_path` (string): Path to Git repository
+     - `max_count` (number, optional): Maximum number of commits to show (default: 10)
+   - Returns: Array of commit entries with hash, author, date, and message
+
+9. `git_create_branch`
+   - Creates a new branch
+   - Inputs:
+     - `repo_path` (string): Path to Git repository
+     - `branch_name` (string): Name of the new branch
+     - `start_point` (string, optional): Starting point for the new branch
+   - Returns: Confirmation of branch creation
+8. `git_checkout`
+   - Switches branches
+   - Inputs:
+     - `repo_path` (string): Path to Git repository
+     - `branch_name` (string): Name of branch to checkout
+   - Returns: Confirmation of branch switch
+9. `git_show`
+   - Shows the contents of a commit
+   - Inputs:
+     - `repo_path` (string): Path to Git repository
+     - `revision` (string): The revision (commit hash, branch name, tag) to show
+   - Returns: Contents of the specified commit
+
+## Installation
+
+### Using uv (recommended)
+
+When using [`uv`](https://docs.astral.sh/uv/) no specific installation is needed. We will
+use [`uvx`](https://docs.astral.sh/uv/guides/tools/) to directly run *mcp-server-git*.
+
+### Using PIP
+
+Alternatively you can install `mcp-server-git` via pip:
+
+```
+pip install mcp-server-git
+```
+
+After installation, you can run it as a script using:
+
+```
+python -m mcp_server_git
+```
+
+## Configuration
+
+### Usage with Claude Desktop
+
+Add this to your `claude_desktop_config.json`:
+
+<details>
+<summary>Using uvx</summary>
+
+```json
+"mcpServers": {
+  "git": {
+    "command": "uvx",
+    "args": ["mcp-server-git", "--repository", "path/to/git/repo"]
+  }
+}
+```
+</details>
+
+<details>
+<summary>Using docker</summary>
+
+* Note: replace '/Users/username' with the a path that you want to be accessible by this tool
+
+```json
+"mcpServers": {
+  "git": {
+    "command": "docker",
+    "args": ["run", "--rm", "-i", "--mount", "type=bind,src=/Users/username,dst=/Users/username", "mcp/git"]
+  }
+}
+```
+</details>
+
+<details>
+<summary>Using pip installation</summary>
+
+```json
+"mcpServers": {
+  "git": {
+    "command": "python",
+    "args": ["-m", "mcp_server_git", "--repository", "path/to/git/repo"]
+  }
+}
+```
+</details>
+
+### Usage with [Zed](https://github.com/zed-industries/zed)
+
+Add to your Zed settings.json:
+
+<details>
+<summary>Using uvx</summary>
+
+```json
+"context_servers": [
+  "mcp-server-git": {
+    "command": {
+      "path": "uvx",
+      "args": ["mcp-server-git"]
+    }
+  }
+],
+```
+</details>
+
+<details>
+<summary>Using pip installation</summary>
+
+```json
+"context_servers": {
+  "mcp-server-git": {
+    "command": {
+      "path": "python",
+      "args": ["-m", "mcp_server_git"]
+    }
+  }
+},
+```
+</details>
+
+## Debugging
+
+You can use the MCP inspector to debug the server. For uvx installations:
+
+```
+npx @modelcontextprotocol/inspector uvx mcp-server-git
+```
+
+Or if you've installed the package in a specific directory or are developing on it:
+
+```
+cd path/to/servers/src/git
+npx @modelcontextprotocol/inspector uv run mcp-server-git
+```
+
+Running `tail -n 20 -f ~/Library/Logs/Claude/mcp*.log` will show the logs from the server and may
+help you debug any issues.
+
+## Development
+
+If you are doing local development, there are two ways to test your changes:
+
+1. Run the MCP inspector to test your changes. See [Debugging](#debugging) for run instructions.
+
+2. Test using the Claude desktop app. Add the following to your `claude_desktop_config.json`:
+
+### Docker
+
+```json
+{
+  "mcpServers": {
+    "git": {
+      "command": "docker",
+      "args": [
+        "run",
+        "--rm",
+        "-i",
+        "--mount", "type=bind,src=/Users/username/Desktop,dst=/projects/Desktop",
+        "--mount", "type=bind,src=/path/to/other/allowed/dir,dst=/projects/other/allowed/dir,ro",
+        "--mount", "type=bind,src=/path/to/file.txt,dst=/projects/path/to/file.txt",
+        "mcp/git"
+      ]
+    }
+  }
+}
+```
+
+### UVX
+```json
+{
+"mcpServers": {
+  "git": {
+    "command": "uv",
+    "args": [ 
+      "--directory",
+      "/<path to mcp-servers>/mcp-servers/src/git",
+      "run",
+      "mcp-server-git"
+    ]
+  }
+}
+```
+
+## Build
+
+Docker build:
+
+```bash
+cd src/git
+docker build -t mcp/git .
+```
+
+## License
+
+This MCP server is licensed under the MIT License. This means you are free to use, modify, and distribute the software, subject to the terms and conditions of the MIT License. For more details, please see the LICENSE file in the project repository.

mcp_server_git-2025.1.14.dist-info/RECORD

@@ -0,0 +1,8 @@
+mcp_server_git/__init__.py,sha256=u1kAH2ucvcRXgB_DMrxPFIppcBWzC6x2XKRc-COuCSs,650
+mcp_server_git/__main__.py,sha256=hsKGEXubWAgg4lB38E1tKJ3ZZp8FOFK8W1CT0-i8SR8,55
+mcp_server_git/server.py,sha256=aadPvauUkRge-KwT-GliOXzxuUz0ibeMQjU5DJVlzZM,10335
+mcp_server_git-2025.1.14.dist-info/METADATA,sha256=M6BIbq00bvUF_fBJk_rWktrgqrREhGH4lP2I2Qg0FDI,7081
+mcp_server_git-2025.1.14.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+mcp_server_git-2025.1.14.dist-info/entry_points.txt,sha256=lNDfXZzZdY33F_H2B1kgXXeORLmy5YYmrFfbDAoy4DY,55
+mcp_server_git-2025.1.14.dist-info/licenses/LICENSE,sha256=jMfG4zsk7U7o_MzDPszxAlSdBPpMuXN87Ml3Da0QgP8,1059
+mcp_server_git-2025.1.14.dist-info/RECORD,,

mcp_server_git-2025.1.14.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

mcp_server_git-2025.1.14.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+mcp-server-git = mcp_server_git:main

mcp_server_git-2025.1.14.dist-info/licenses/LICENSE

@@ -0,0 +1,7 @@
+Copyright (c) 2024 Anthropic, PBC.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.