git_diff_unstaged

Identify uncommitted changes in your Git working directory with this tool. Review modifications before staging them to ensure accurate commit management.

Instructions

Shows changes in the working directory that are not yet staged

Input Schema

TableJSON Schema

Name	Required	Description	Default
`repo_path`	Yes

Implementation Reference

src/mcp_server_git/git/operations.py:192-242 (handler)

Core handler function that executes `repo.git.diff()` to show unstaged changes, with options for stat-only, name-only, paths, and size limiting.

def git_diff_unstaged(
    repo: Repo,
    stat_only: bool = False,
    max_lines: int | None = None,
    name_only: bool = False,
    paths: list[str] | None = None,
) -> str:
    """Get unstaged changes diff with file-specific and advanced options"""
    try:
        # Build git diff arguments
        diff_args = []

        # Add options based on parameters
        if name_only:
            diff_args.append("--name-only")
        elif stat_only:
            diff_args.append("--stat")

        # Add specific paths if provided
        if paths:
            diff_args.extend(["--"] + paths)

        # Execute git diff with arguments
        diff_output = repo.git.diff(*diff_args)

        # Handle name-only output
        if name_only:
            return (
                f"Files with unstaged changes:\n{diff_output}"
                if diff_output.strip()
                else "No unstaged changes"
            )

        # Handle stat-only output
        if stat_only:
            return (
                f"Unstaged changes summary:\n{diff_output}"
                if diff_output.strip()
                else "No unstaged changes"
            )

        # Apply size limiting for full diff output
        return _apply_diff_size_limiting(
            diff_output, "unstaged changes", stat_only, max_lines
        )

    except GitCommandError as e:
        return f"❌ Diff unstaged failed: {str(e)}"
    except Exception as e:
        return f"❌ Diff unstaged error: {str(e)}"

src/mcp_server_git/git/models.py:11-17 (schema)

Pydantic input schema/model defining parameters for the git_diff_unstaged tool.

class GitDiffUnstaged(BaseModel):
    repo_path: str
    stat_only: bool | None = False
    max_lines: int | None = None
    name_only: bool | None = False
    paths: list[str] | None = None

src/mcp_server_git/core/handlers.py:67-71 (registration)
Tool registration in the CallToolHandler._get_git_handlers() method, creating a wrapped handler for git_diff_unstaged.
```
"git_diff_unstaged": self._create_git_handler(
    git_diff_unstaged,
    requires_repo=True,
    extra_args=["stat_only", "max_lines", "name_only", "paths"],
),
```

src/mcp_server_git/core/tools.py:182-188 (registration)

ToolDefinition registration in ToolRegistry.initialize_default_tools(), defining name, description, schema, and metadata for git_diff_unstaged.

ToolDefinition(
    name=GitTools.DIFF_UNSTAGED,
    category=ToolCategory.GIT,
    description="Show changes in the working directory that are not yet staged",
    schema=GitDiffUnstaged,
    handler=placeholder_handler,
    requires_repo=True,

src/mcp_server_git/git/operations.py:141-174 (helper)

Helper function used by git_diff_unstaged (and other diff functions) to apply output truncation and size warnings.

def _apply_diff_size_limiting(
    diff_output: str,
    operation_name: str,
    stat_only: bool = False,
    max_lines: int | None = None,
) -> str:
    """Apply size limiting to diff outputs with consistent formatting"""
    if not diff_output.strip():
        return f"No changes detected in {operation_name}"

    if stat_only:
        # This should be handled by the caller using --stat flag
        return diff_output

    # Apply line limit if specified
    if max_lines and max_lines > 0:
        lines = diff_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(diff_output) > 50000:  # 50KB threshold
        lines_count = len(diff_output.split("\n"))
        warning = f"⚠️  Large diff detected ({lines_count} lines, ~{len(diff_output) // 1000}KB)\n"
        warning += "Consider using stat_only=true for summary or max_lines parameter to limit output\n\n"
        return warning + diff_output

    return diff_output

MCP Git Server