I used to hate leaving Vim for Git’s interactive staging mode or some separate GUI to pick apart a hairy set of changes. As a result I usually tried to avoid these messy situations.

Then I discovered Vim fugitive. It allows to go through the diff and stage chunks so intuitively, it changed the way I work. Just j/k to move around, = to expand file, s to stage selection, c to commit. The process of reviewing changes became very natural and actually enjoyable. I like the feeling of control it gives and how it makes focused commits painless while not disrupting the flow.

Congratulations on publishing this. I use `git add -p` quite a lot, and this project looks interesting!

I knew that you could place a `git-xyz` executable and you can call it as `git xyz`. I didn't know you could do it with flags !?!

A small video or some screenshots would help a lot. If you can record interactivity with ascii-cinema, that will be even better.

This is my favorite alias:

    i = !git add -N . && git add -p

`git i` lets you interactively add new files as well as existing ones

It would be nice if this had the same interface for `git add -i` allowing you to type in numbers or letters.

** Commands **

  1: status   2: update   3: revert   4: add untracked

  5: patch   6: diff   7: quit   8: help

What now>

This allows you to either type in (p) or (5) to go into patch mode.

This looks neat!

I think it’ll fit nicely alongside scmpuff which I’ve been using for years (and at this point refuse to ever give it up): https://github.com/mroth/scmpuff

the thing i really wish existed was git add -p mode that automatically segmented unstaged changes into a series of fixups based on the blame of the surrounding area that changed. this wouldn't work in all cases, but in many cases, i've made a series of 3-4 clearly-separable changes, i then go and make fixes on top of all of them, and now i want to fixup each change.

I like the idea of 'G' to filter hunks. The perl script does not exist since git v2.40.0 so I don't think the installation instructions work for recent versions of git as there is no way to stop 'git add -p' from running the builtin version. I see this is MIT licenced but the code is very closely based on the perl script which is licensed under the GPLv2.

The one feature I would love to see and would be an instant-install, is a command that lets me revert a hunk back. It would be nice to be able to wipe out some dangling console.log() statements as I go through the changes.

Question: why not send this to the Git mailing list, and hopefully get this in upstream?

My 2c: I'd like to see git add interactive go through the hunks in order of most recent first!

I'm a serial "git add -p" user. (Micro-review before every commit is super healthy imo).

I made an alias a while ago I use frequently:

    af       => !f() { git add -p $(git diff --name-only | fzf); }; f

When you have a large diff, it's get unruly quickly to "add -p".

This just prompts you with a fuzzy find of the files that have changed and you can just pick one to go through the "add -p" process for that file.

For the terminal averse, IDEs usually have "jump to next change" and a tab for the changed files that can achieve the same.

I always love to see these little git extensions. For anyone else interested in this stuff, here are some others I like:

lazygit (of course): https://github.com/jesseduffield/lazygit

git-machete: https://github.com/VirtusLab/git-machete

rebase-editor: https://github.com/sjurba/rebase-editor

[dead]

I've used `tig` for this sort of thing for well over a decade. `tig status` lets you see all files, interactively add things, whatever.

[flagged]