Git Polite

View unstaged git changes with line-level selection numbers for partial staging.

PREFER THIS OVER git diff when you need to selectively stage changes. Unlike git diff, this tool includes untracked files (newly created files) in the output. This tool numbers each changed line (0001, 0002, etc.) so you can stage specific lines or ranges instead of entire files. Essential for creating multiple logical commits from intermixed changes.

Key features:

• Includes untracked files (status: "added") as well as modified files (status: "modified")

• Numbers every changed line for precise selection

• Supports byte-based pagination to protect LLM context

• Auto-truncates large diffs (>10KB) with clear indication

Handling truncated files: When a file shows truncated: true with empty lines: [], use the diff tool to view its complete content. The diff tool returns the same numbered line format needed for partial staging with apply_changes, whereas git diff output lacks line numbers and cannot be used for selective staging. For example, if a large refactored file is truncated, call diff(path="src/large_module.py") to see the full numbered diff and selectively stage related changes.

Use cases:

• Breaking up large changes into multiple focused commits

• Staging only specific changes while keeping others unstaged

• Creating atomic commits from work-in-progress code

• Separating refactoring from feature changes

• Selectively staging parts of newly created files

After viewing changes, use apply_changes with the line numbers to stage selected changes.

Args: paths: Optional list of file paths to filter (default: all files) page_token: Opaque pagination token from previous response page_size_files: Max files per page - safety limit (default: PAGE_SIZE_FILES_DEFAULT) page_size_bytes: Max bytes per page - primary limit (default: PAGE_SIZE_BYTES_DEFAULT) unified: Context lines around changes (default: UNIFIED_LIST_DEFAULT)

Returns: JSON string with format: {page_token_next, files: [{path, binary, lines}], stats}

View complete diff for a single file without truncation.

This tool is designed for viewing the full diff of a single file, regardless of size. Unlike list_changes, this tool will NEVER truncate the output, making it suitable for reviewing large files like lock files or generated code.

Use this when you need to:

• View the complete diff of a large file (e.g., uv.lock, package-lock.json)

• Review all changes in a specific file before staging

• Analyze files that would be truncated by list_changes

Args: path: File path to view diff for (required) unified: Context lines around changes (default: UNIFIED_LIST_DEFAULT)

Returns: JSON string with format: {path, binary, status, lines, size_bytes}

Stage selected lines to git index for partial commits (alternative to git add -p).

After using list_changes to view numbered changes, use this tool to selectively stage specific lines or ranges to the git index. This enables creating multiple logical commits from a single file with intermixed changes.

Unlike git add, this tool can stage parts of untracked files (newly created files). You can commit only the first 10 lines of a new file while keeping the rest unstaged.

Number format examples:

• Single lines: "0001,0002,0005"

• Ranges: "0001-0010"

• Combined: "0001-0005,0020-0025"

The tool updates the git index directly and reports remaining unstaged changes, allowing iterative staging for multiple commits from the same file.

Args: path: File path to apply changes to numbers: Change numbers in format: NNNN,MMMM,PPPP-QQQQ

Returns: JSON string with format: {applied: [{file, applied_count, after_applying: {diff, unstaged_lines}}], skipped, stats}

Start a guided session to organize and commit all unstaged changes with appropriate granularity.

This tool helps you organize your changes and create multiple focused commits by:

1. Showing recent commit messages as style reference

2. Displaying summary statistics of all unstaged changes (file counts, line counts)

3. Providing step-by-step instructions for the commit workflow

This tool uses progressive disclosure: it shows only statistics (additions/deletions per file) to avoid token limits. Use list_changes or diff tools to view detailed changes for specific files.

Use this when you have multiple logical changes mixed together and want to organize them into separate, well-structured commits.

Returns: JSON with recent commits, file statistics, and next steps for the agent

Unstack linear commits into parallel branches for separate PRs.

This tool transforms a linear commit history (A -> B -> C -> D) into parallel branches (A -> B, A -> C, A -> D) where each branch contains specific commits cherry-picked from the original history.

Use this when you've made multiple changes in sequence but want to create separate PRs for different logical changes. Each branch can be independently reviewed and merged.

Example scenario: You have commits: fix-bug -> add-feature -> update-docs You want separate PRs, so you create:

• feat/999: [fix-bug, update-docs]

• feat/1000: [add-feature]

This creates two branches from origin/main:

• feat/999 with fix-bug and update-docs cherry-picked in order

• feat/1000 with add-feature cherry-picked

Args: branches: Dictionary mapping branch names to lists of commit references. Commits can be specified as SHA, branch names, or symbolic refs (e.g., HEAD~2). Commits are cherry-picked in the order specified. parent: Base commit to branch from (default: "origin/main"). All branches will start from this commit.

Returns: JSON string with format: { created_branches: [{name, commits_applied, head_sha}], errors: [{branch, commit, error}], stats: {total_branches, successful_branches, failed_branches} }

Note: - Existing branches with the same name will cause an error - The current branch is not changed by this operation - Uses low-level git commands (commit-tree, update-ref) to avoid changing working directory