Merge branch 'main' into patch-1

Author: andrew-lastmile

README.md

@@ -117,6 +117,7 @@ Official integrations are maintained by companies building production ready MCP
 - <img height="12" width="12" src="https://codelogic.com/wp-content/themes/codelogic/assets/img/favicon.png" alt="CodeLogic Logo" /> **[CodeLogic](https://github.com/CodeLogicIncEngineering/codelogic-mcp-server)** - Interact with [CodeLogic](https://codelogic.com), a Software Intelligence platform that graphs complex code and data architecture dependencies, to boost AI accuracy and insight.
 - <img height="12" width="12" src="https://static.coingecko.com/s/coingecko-logo-white-750bdea438e850281f784dffc8f4fd498415754f088d655a1140849745cb66ac.svg" alt="CoinGecko Logo" /> **[CoinGecko](https://github.com/coingecko/coingecko-typescript/tree/main/packages/mcp-server)** - Official [CoinGecko API](https://www.coingecko.com/en/api) MCP Server for Crypto Price & Market Data, across 200+ Blockchain Networks and 8M+ Tokens.
 - <img height="12" width="12" src="https://www.comet.com/favicon.ico" alt="Comet Logo" /> **[Comet Opik](https://github.com/comet-ml/opik-mcp)** - Query and analyze your [Opik](https://github.com/comet-ml/opik) logs, traces, prompts and all other telemtry data from your LLMs in natural language.
+- <img height="12" width="12" src="https://cdn.prod.website-files.com/6572bd8c27ee5db3eb91f4b3/6572bd8d27ee5db3eb91f55e_favicon-dashflow-webflow-template.svg" alt="OSS Conductor Logo" /> <img height="12" width="12" src="https://orkes.io/icons/icon-48x48.png" alt="Orkes Conductor Logo" />**[Conductor](https://github.com/conductor-oss/conductor-mcp)** - Interact with Conductor (OSS and Orkes) REST APIs.
 - <img height="12" width="12" src="https://www.confluent.io/favicon.ico" alt="Confluent Logo" /> **[Confluent](https://github.com/confluentinc/mcp-confluent)** - Interact with Confluent Kafka and Confluent Cloud REST APIs.
 - <img src="https://contrastsecurity.com/favicon.ico" alt="Contrast Security" width="12" height="12"> **[Contrast Security](https://github.com/Contrast-Security-OSS/mcp-contrast)** - Brings Contrast's vulnerability and SCA data into your coding agent to quickly remediate vulnerabilities.
 - <img height="12" width="12" src="https://www.convex.dev/favicon.ico" alt="Convex Logo" /> **[Convex](https://stack.convex.dev/convex-mcp-server)** - Introspect and query your apps deployed to Convex.

src/git/README.md

@@ -16,21 +16,24 @@ Please note that mcp-server-git is currently in early development. The functiona
 
 2. `git_diff_unstaged`
    - Shows changes in working directory not yet staged
-   - Input:
+   - Inputs:
      - `repo_path` (string): Path to Git repository
+     - `context_lines` (number, optional): Number of context lines to show (default: 3)
    - Returns: Diff output of unstaged changes
 
 3. `git_diff_staged`
    - Shows changes that are staged for commit
-   - Input:
+   - Inputs:
      - `repo_path` (string): Path to Git repository
+     - `context_lines` (number, optional): Number of context lines to show (default: 3)
    - 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
+     - `context_lines` (number, optional): Number of context lines to show (default: 3)
    - Returns: Diff output comparing current state with target
 
 5. `git_commit`
@@ -85,6 +88,15 @@ Please note that mcp-server-git is currently in early development. The functiona
      - `repo_path` (string): Path to directory to initialize git repo
    - Returns: Confirmation of repository initialization
 
+13. `git_branch`
+   - List Git branches
+   - Inputs:
+     - `repo_path` (string): Path to the Git repository.
+     - `branch_type` (string): Whether to list local branches ('local'), remote branches ('remote') or all branches('all').
+     - `contains` (string, optional): The commit sha that branch should contain. Do not pass anything to this param if no commit sha is specified
+     - `not_contains` (string, optional): The commit sha that branch should NOT contain. Do not pass anything to this param if no commit sha is specified
+   - Returns: List of branches
+
 ## Installation
 
 ### Using uv (recommended)

src/git/pyproject.toml

@@ -36,4 +36,4 @@ dev-dependencies = ["pyright>=1.1.389", "ruff>=0.7.3", "pytest>=8.0.0"]
 testpaths = ["tests"]
 python_files = "test_*.py"
 python_classes = "Test*"
-python_functions = "test_*"
+python_functions = "test_*"

src/git/src/mcp_server_git/py.typed

@@ -1,6 +1,6 @@
 import logging
 from pathlib import Path
-from typing import Sequence
+from typing import Sequence, Optional
 from mcp.server import Server
 from mcp.server.session import ServerSession
 from mcp.server.stdio import stdio_server
@@ -13,20 +13,26 @@
 )
 from enum import Enum
 import git
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
+
+# Default number of context lines to show in diff output
+DEFAULT_CONTEXT_LINES = 3
 
 class GitStatus(BaseModel):
     repo_path: str
 
 class GitDiffUnstaged(BaseModel):
     repo_path: str
+    context_lines: int = DEFAULT_CONTEXT_LINES
 
 class GitDiffStaged(BaseModel):
     repo_path: str
+    context_lines: int = DEFAULT_CONTEXT_LINES
 
 class GitDiff(BaseModel):
     repo_path: str
     target: str
+    context_lines: int = DEFAULT_CONTEXT_LINES
 
 class GitCommit(BaseModel):
     repo_path: str
@@ -59,6 +65,24 @@ class GitShow(BaseModel):
 class GitInit(BaseModel):
     repo_path: str
 
+class GitBranch(BaseModel):
+    repo_path: str = Field(
+        ...,
+        description="The path to the Git repository.",
+    )
+    branch_type: str = Field(
+        ...,
+        description="Whether to list local branches ('local'), remote branches ('remote') or all branches('all').",
+    )
+    contains: Optional[str] = Field(
+        None,
+        description="The commit sha that branch should contain. Do not pass anything to this param if no commit sha is specified",
+    )
+    not_contains: Optional[str] = Field(
+        None,
+        description="The commit sha that branch should NOT contain. Do not pass anything to this param if no commit sha is specified",
+    )
+
 class GitTools(str, Enum):
     STATUS = "git_status"
     DIFF_UNSTAGED = "git_diff_unstaged"
@@ -72,18 +96,19 @@ class GitTools(str, Enum):
     CHECKOUT = "git_checkout"
     SHOW = "git_show"
     INIT = "git_init"
+    BRANCH = "git_branch"
 
 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_unstaged(repo: git.Repo, context_lines: int = DEFAULT_CONTEXT_LINES) -> str:
+    return repo.git.diff(f"--unified={context_lines}")
 
-def git_diff_staged(repo: git.Repo) -> str:
-    return repo.git.diff("--cached")
+def git_diff_staged(repo: git.Repo, context_lines: int = DEFAULT_CONTEXT_LINES) -> str:
+    return repo.git.diff(f"--unified={context_lines}", "--cached")
 
-def git_diff(repo: git.Repo, target: str) -> str:
-    return repo.git.diff(target)
+def git_diff(repo: git.Repo, target: str, context_lines: int = DEFAULT_CONTEXT_LINES) -> str:
+    return repo.git.diff(f"--unified={context_lines}", target)
 
 def git_commit(repo: git.Repo, message: str) -> str:
     commit = repo.index.commit(message)
@@ -102,16 +127,16 @@ def git_log(repo: git.Repo, max_count: int = 10) -> list[str]:
     log = []
     for commit in commits:
         log.append(
-            f"Commit: {commit.hexsha}\n"
-            f"Author: {commit.author}\n"
+            f"Commit: {commit.hexsha!r}\n"
+            f"Author: {commit.author!r}\n"
             f"Date: {commit.authored_datetime}\n"
-            f"Message: {commit.message}\n"
+            f"Message: {commit.message!r}\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]
+        base = repo.references[base_branch]
     else:
         base = repo.active_branch
 
@@ -132,10 +157,10 @@ def git_init(repo_path: str) -> str:
 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"
+        f"Commit: {commit.hexsha!r}\n"
+        f"Author: {commit.author!r}\n"
+        f"Date: {commit.authored_datetime!r}\n"
+        f"Message: {commit.message!r}\n"
     ]
     if commit.parents:
         parent = commit.parents[0]
@@ -147,6 +172,34 @@ def git_show(repo: git.Repo, revision: str) -> str:
         output.append(d.diff.decode('utf-8'))
     return "".join(output)
 
+def git_branch(repo: git.Repo, branch_type: str, contains: str | None = None, not_contains: str | None = None) -> str:
+    match contains:
+        case None:
+            contains_sha = (None,)
+        case _:
+            contains_sha = ("--contains", contains)
+
+    match not_contains:
+        case None:
+            not_contains_sha = (None,)
+        case _:
+            not_contains_sha = ("--no-contains", not_contains)
+
+    match branch_type:
+        case 'local':
+            b_type = None
+        case 'remote':
+            b_type = "-r"
+        case 'all':
+            b_type = "-a"
+        case _:
+            return f"Invalid branch type: {branch_type}"
+
+    # None value will be auto deleted by GitPython
+    branch_info = repo.git.branch(b_type, *contains_sha, *not_contains_sha)
+
+    return branch_info
+
 async def serve(repository: Path | None) -> None:
     logger = logging.getLogger(__name__)
 
@@ -166,62 +219,67 @@ async def list_tools() -> list[Tool]:
             Tool(
                 name=GitTools.STATUS,
                 description="Shows the working tree status",
-                inputSchema=GitStatus.schema(),
+                inputSchema=GitStatus.model_json_schema(),
             ),
             Tool(
                 name=GitTools.DIFF_UNSTAGED,
                 description="Shows changes in the working directory that are not yet staged",
-                inputSchema=GitDiffUnstaged.schema(),
+                inputSchema=GitDiffUnstaged.model_json_schema(),
             ),
             Tool(
                 name=GitTools.DIFF_STAGED,
                 description="Shows changes that are staged for commit",
-                inputSchema=GitDiffStaged.schema(),
+                inputSchema=GitDiffStaged.model_json_schema(),
             ),
             Tool(
                 name=GitTools.DIFF,
                 description="Shows differences between branches or commits",
-                inputSchema=GitDiff.schema(),
+                inputSchema=GitDiff.model_json_schema(),
             ),
             Tool(
                 name=GitTools.COMMIT,
                 description="Records changes to the repository",
-                inputSchema=GitCommit.schema(),
+                inputSchema=GitCommit.model_json_schema(),
             ),
             Tool(
                 name=GitTools.ADD,
                 description="Adds file contents to the staging area",
-                inputSchema=GitAdd.schema(),
+                inputSchema=GitAdd.model_json_schema(),
             ),
             Tool(
                 name=GitTools.RESET,
                 description="Unstages all staged changes",
-                inputSchema=GitReset.schema(),
+                inputSchema=GitReset.model_json_schema(),
             ),
             Tool(
                 name=GitTools.LOG,
                 description="Shows the commit logs",
-                inputSchema=GitLog.schema(),
+                inputSchema=GitLog.model_json_schema(),
             ),
             Tool(
                 name=GitTools.CREATE_BRANCH,
                 description="Creates a new branch from an optional base branch",
-                inputSchema=GitCreateBranch.schema(),
+                inputSchema=GitCreateBranch.model_json_schema(),
             ),
             Tool(
                 name=GitTools.CHECKOUT,
                 description="Switches branches",
-                inputSchema=GitCheckout.schema(),
+                inputSchema=GitCheckout.model_json_schema(),
             ),
             Tool(
                 name=GitTools.SHOW,
                 description="Shows the contents of a commit",
-                inputSchema=GitShow.schema(),
+                inputSchema=GitShow.model_json_schema(),
             ),
             Tool(
                 name=GitTools.INIT,
                 description="Initialize a new Git repository",
-                inputSchema=GitInit.schema(),
+                inputSchema=GitInit.model_json_schema(),
+            ),
+            Tool(
+                name=GitTools.BRANCH,
+                description="List Git branches",
+                inputSchema=GitBranch.model_json_schema(),
             )
         ]
 
@@ -278,21 +336,21 @@ async def call_tool(name: str, arguments: dict) -> list[TextContent]:
                 )]
 
             case GitTools.DIFF_UNSTAGED:
-                diff = git_diff_unstaged(repo)
+                diff = git_diff_unstaged(repo, arguments.get("context_lines", DEFAULT_CONTEXT_LINES))
                 return [TextContent(
                     type="text",
                     text=f"Unstaged changes:\n{diff}"
                 )]
 
             case GitTools.DIFF_STAGED:
-                diff = git_diff_staged(repo)
+                diff = git_diff_staged(repo, arguments.get("context_lines", DEFAULT_CONTEXT_LINES))
                 return [TextContent(
                     type="text",
                     text=f"Staged changes:\n{diff}"
                 )]
 
             case GitTools.DIFF:
-                diff = git_diff(repo, arguments["target"])
+                diff = git_diff(repo, arguments["target"], arguments.get("context_lines", DEFAULT_CONTEXT_LINES))
                 return [TextContent(
                     type="text",
                     text=f"Diff with {arguments['target']}:\n{diff}"
@@ -351,6 +409,18 @@ async def call_tool(name: str, arguments: dict) -> list[TextContent]:
                     text=result
                 )]
 
+            case GitTools.BRANCH:
+                result = git_branch(
+                    repo,
+                    arguments.get("branch_type", 'local'),
+                    arguments.get("contains", None),
+                    arguments.get("not_contains", None),
+                )
+                return [TextContent(
+                    type="text",
+                    text=result
+                )]
+
             case _:
                 raise ValueError(f"Unknown tool: {name}")
 

src/git/src/mcp_server_git/server.py

@@ -1,7 +1,7 @@
 import pytest
 from pathlib import Path
 import git
-from mcp_server_git.server import git_checkout
+from mcp_server_git.server import git_checkout, git_branch
 import shutil
 
 @pytest.fixture
@@ -27,4 +27,44 @@ def test_git_checkout_existing_branch(test_repository):
 def test_git_checkout_nonexistent_branch(test_repository):
 
     with pytest.raises(git.GitCommandError):
-        git_checkout(test_repository, "nonexistent-branch")
+        git_checkout(test_repository, "nonexistent-branch")
+
+def test_git_branch_local(test_repository):
+    test_repository.git.branch("new-branch-local")
+    result = git_branch(test_repository, "local")
+    assert "new-branch-local" in result
+
+def test_git_branch_remote(test_repository):
+    # GitPython does not easily support creating remote branches without a remote.
+    # This test will check the behavior when 'remote' is specified without actual remotes.
+    result = git_branch(test_repository, "remote")
+    assert "" == result.strip()  # Should be empty if no remote branches
+
+def test_git_branch_all(test_repository):
+    test_repository.git.branch("new-branch-all")
+    result = git_branch(test_repository, "all")
+    assert "new-branch-all" in result
+
+def test_git_branch_contains(test_repository):
+    # Create a new branch and commit to it
+    test_repository.git.checkout("-b", "feature-branch")
+    Path(test_repository.working_dir / Path("feature.txt")).write_text("feature content")
+    test_repository.index.add(["feature.txt"])
+    commit = test_repository.index.commit("feature commit")
+    test_repository.git.checkout("master")
+
+    result = git_branch(test_repository, "local", contains=commit.hexsha)
+    assert "feature-branch" in result
+    assert "master" not in result
+
+def test_git_branch_not_contains(test_repository):
+    # Create a new branch and commit to it
+    test_repository.git.checkout("-b", "another-feature-branch")
+    Path(test_repository.working_dir / Path("another_feature.txt")).write_text("another feature content")
+    test_repository.index.add(["another_feature.txt"])
+    commit = test_repository.index.commit("another feature commit")
+    test_repository.git.checkout("master")
+
+    result = git_branch(test_repository, "local", not_contains=commit.hexsha)
+    assert "another-feature-branch" not in result
+    assert "master" in result