MCP Git Server

Instructions

Implementation Reference

• src/mcp_server_git/git/operations.py:819-856 (handler)

  Core handler function that executes `repo.git.show(revision)` with support for `--stat` mode, output truncation via max_lines, and large output warnings. This is the primary logic for the git_show tool.

  def git_show(
      repo: Repo, revision: str, stat_only: bool = False, max_lines: int | None = None
  ) -> str:
      """Show commit details with diff and size limiting options"""
      try:
          if stat_only:
              # Return only commit info and file statistics
              show_output = repo.git.show("--stat", revision)
              return f"Commit details for {revision}:\n{show_output}"
  
          # Get full commit details
          show_output = repo.git.show(revision)
  
          # Apply line limit if specified
          if max_lines and max_lines > 0:
              lines = show_output.split("\n")
              if len(lines) > max_lines:
                  truncated_output = "\n".join(lines[:max_lines])
                  truncated_output += (
                      f"\n\n... [Truncated: showing {max_lines} of {len(lines)} lines]"
                  )
                  truncated_output += "\nUse stat_only=true for summary or increase max_lines for more content"
                  return truncated_output
  
          # Check if output is extremely large and warn
          if len(show_output) > 50000:  # 50KB threshold
              lines_count = len(show_output.split("\n"))
              warning = f"⚠️  Large commit detected ({lines_count} lines, ~{len(show_output) // 1000}KB)\n"
              warning += "Consider using stat_only=true for summary or max_lines parameter to limit output\n\n"
              return warning + show_output
  
          return show_output
  
      except GitCommandError as e:
          return f"❌ Show failed: {str(e)}"
      except Exception as e:
          return f"❌ Show error: {str(e)}"

• src/mcp_server_git/git/models.py:77-82 (schema)

  Pydantic input schema for the git_show tool defining required repo_path and revision, optional stat_only and max_lines parameters.

  class GitShow(BaseModel):
      repo_path: str
      revision: str
      stat_only: bool | None = False
      max_lines: int | None = None

• src/mcp_server_git/core/tools.py:254-261 (registration)

  Tool registration in ToolRegistry for git_show, referencing GitShow schema and setting metadata.

  ToolDefinition(
      name=GitTools.SHOW,
      category=ToolCategory.GIT,
      description="Show the contents of a commit",
      schema=GitShow,
      handler=placeholder_handler,
      requires_repo=True,
  ),

• src/mcp_server_git/core/handlers.py:104-106 (registration)

  Handler mapping in CallToolHandler._get_git_handlers() dictionary, assigning _create_git_handler wrapper around git_show function from operations.py for the git_show tool.

  "git_show": self._create_git_handler(
      git_show, requires_repo=True, extra_args=["revision"]
  ),

• src/mcp_server_git/protected_git_operations.py:299-856 (helper)

  Protected wrapper async def protected_git_show that validates repository binding before calling core git_show. Used in secured contexts.

  async def protected_git_show(self, repo_path: str, revision: str) -> str:
      """Git show with repository binding protection."""
      validated_path = await self._validate_and_prepare_operation(repo_path)
      repo = Repo(validated_path)
      return git_show(repo, revision)
  
  async def protected_git_checkout(self, repo_path: str, branch_name: str) -> str:
      """Git checkout with repository binding protection."""
      validated_path = await self._validate_and_prepare_operation(repo_path)
      repo = Repo(validated_path)
      return git_checkout(repo, branch_name)
  
  async def protected_git_create_branch(
      self, repo_path: str, branch_name: str, base_branch: str | None = None
  ) -> str:
      """Git create branch with repository binding protection."""
      validated_path = await self._validate_and_prepare_operation(repo_path)
      repo = Repo(validated_path)
      return git_create_branch(repo, branch_name, base_branch)
  
  async def protected_git_reset(
      self, repo_path: str, mode: str = "mixed", target: str | None = None
  ) -> str:
      """Git reset with repository binding protection."""
      validated_path = await self._validate_and_prepare_operation(repo_path)
      repo = Repo(validated_path)
      return git_reset(repo, mode, target)
  
  async def protected_git_remote_get_url(self, repo_path: str, name: str) -> str:
      """Git remote get-url with repository binding protection."""
      validated_path = await self._validate_and_prepare_operation(repo_path)
      repo = Repo(validated_path)
      return git_remote_get_url(repo, name)
  
  async def protected_git_remote_list(self, repo_path: str) -> str:
      """Git remote list with repository binding protection."""
      validated_path = await self._validate_and_prepare_operation(repo_path)
      repo = Repo(validated_path)
      return git_remote_list(repo)
  
  async def _get_current_remote_url(self, repo_path: Path) -> str:
      """Get current remote URL from repository."""
      repo = Repo(repo_path)
      return git_remote_get_url(repo, "origin")