git-branchless

git-branchless is a suite of tools designed to enhance Git workflows, specifically focusing on patch-stacking, prototyping, and high-performance operations in large repositories.

Key Capabilities:

• Ease of Use: Includes git undo for general-purpose undoing of commits, merges, rebases, and branch operations; git smartlog for advanced history visualization; and git restack for repairing broken commit graphs.
• Power User Flexibility: Supports patch-stack workflows, divergent development for prototyping, git sync for rebasing all local stacks without checking them out, and git move for subtree manipulation.
• High Performance: Optimized for monorepos and large repositories (e.g., Linux kernel) using in-memory operations, custom sparse indexes, and multithreading to avoid slow working-copy updates.

You can install git-branchless using your system's package manager or via Cargo. After installation, you must initialize the tool within your Git repository.

1. Install the package (e.g., via Cargo).
2. Run git branchless init inside your repository to complete the setup.

git undo provides a high-level abstraction for reversing repository states. Unlike git reflog, which tracks individual reference movements, git undo can handle complex operations like rebases and branch deletions.

Supported operations:

• Commits and amended commits.
• Merges and rebases (including fixing wrongly resolved conflicts).
• Checkouts.
• Branch creations, updates, and deletions.

Limitations:

• Cannot currently 'uncommit' a commit to restore changes to the working copy (use git reset HEAD^ for this).
• Cannot undo staging/unstaging of files.
• Cannot undo into the middle of a conflict state.
• Does not handle untracked files.

The fix subcommand allows you to run a command and automatically amend the commits with any changes produced by that command. This is useful for automated bug fixing or linting.

Key behaviors:

• It uses the apply_fixes logic to rewrite commits.
• It requires move_options to determine how commits are rewritten (e.g., whether to force rewrite public commits).
• It is not compatible with the --on-disk option; use --in-memory instead.

The split command allows you to extract changes from a single commit into separate commits. This is useful for breaking down large, monolithic commits into smaller, more manageable ones. The command can take a list of files to extract and supports different modes for how the extracted changes are integrated into the history.

When splitting, the command also handles restacking the descendants of the target commit to maintain a clean history.

The restack command automates the process of fixing a broken commit graph caused by rewrites (like git commit --amend). When a commit is amended or rewritten, its descendants become 'abandoned' because they are still based on the old, now-obsolete commit. restack finds these abandoned commits and rebases them onto the new, rewritten versions of their parents, restoring a continuous history.

This command can be applied to specific commits using revsets or to all obsolete commits in the repository.

When calling undo() with interactive: true, a TUI is launched. The interface provides a visual commit graph and a numbered list of events.

TUI Commands:

• h / ?: Show help
• q / Q: Quit
• n / N / Right: View next state
• p / P / Left: View previous state
• g / G: Go to a specific event ID (opens a dialog to enter an ID)
• Enter: Revert the repository to the currently selected state (requires confirmation in the terminal)

If you accidentally hide or unhide commits, you can revert the operation using the git undo command. The hide and unhide commands will explicitly print the command to run if the operation can be undone.

Example output from hide: To unhide these X commits, run: git undo