In .gud-options

There should be a command to view the history file

Don't track unless a remote is selected and the local branch for it doesn't already exist

Currently selecting a local branch with gud cr will create a new branch that tracks the local. Selecting a remote when the local already exists will give an error that the local already exists.

Select a branch, then select a commit from that branch to cherrypick

If using a custom .gud-options it should allow configuring shortcuts for each

This would require refactoring shortcuts to pull from the .gud-options list instead of an internally defined hash array.

Choose a remote

Duplicating stash-message

Using read raw doesn't let the user use backspace. For bash, read -e will fix this. This does not fix the issue for zsh.

Conditionally using vared for zsh may be an option

vared -p "test" -c tmp

Currently there are a host of different commands in the form of gg-* which allows calling them directly and sharing between scripts.

However, this both clutters things by creating a lot of commands, and means aliases need to be defined in .bashrc and upgrading means both updating that config, and re-running installation.

If commands were run via

gg [command or alias here]

Upgrading could be done simply by pulling the latest version.

This would also likely simplify the codebase, as currently there is the need to determine the source directory in every command file. If converted to functions imported into a single file that would not be necessary.

In that format, there would be some desire for autocomplete and you could no longer tab complete the commands. However if the expectation is to either use the menu or aliases, that shouldn't be necessary.

Commands for doing diffs based on selected commits

Given there'd often be a need to track multiple files, this wouldn't be a good option to fuzzy find a single file, so it may need to prompt after each selection to add more or another way of simply specifying multiple.

Creates branch from current branch

Keeping a history of commands run would be very useful for backtracking when someone makes a mess of their repository.

If would be best if the current repo could be determined somehow and have the history organized in that way, but at the least having just a file with every command run in sequence and when would be very useful.

Shouldn't specify which remote, determine automatically

gud add lists both untracked files and tracked files that have been modified but not staged. There should be an indication of one vs the other

column may get a line too long error. Also, certain columns may be more appropriate to truncate, like the author column.

Shows at the top of the preview window with the diff

Stashing, popping, applying etc could use helpers

Include the diff in the preview window

git branch [current branch] -u [remote]/[branch]

Finding the longest option in a column before outputting will allow formatting to adjust to the content even using awk and printf

if tags have semantic versioning, incrementing major, minor, or patch can be done programmatically. Something along the lines of gg-tag-patch-increment would get the most recent tag (or high value sorted numerically?) and increment the last piece.

When bat is not installed, it's still trying to use it

Add the --track option to the checkout.

BASH is hardly the nicest language to work with, and reusing code is a pain as is, leading to some duplication in areas, and just not clear separation of concerns.

But it works. Converting to python creates additional dependencies and potentially impacts performance. There's a cost-benefit analysis here that I'm not decided on so it deserves some more consideration as to what it would take and if it would be worth it.

The biggest potential advantage would be tests. If this could translate to unit tests, then it'd be a big win, because it's not possible as is.

Having them listed in the menu would help memorization and reference of shortcuts

It needs to list all tags

Currently missing a command to simply create a new branch from an existing branch in the same way as gg-branch-tag

If sudo ./install.sh the folder is created in /root/.config/git-gud instead of the local user

This would also apply to git cherry-pick, git reset --hard, and git diff when between two commits

error: tag 'tag' not found.

Colors could be used to improve clarity in some commands, but time has to be spent playing with formatting to make that happen.

The command should be highlighted in a color

Empty string is used in place

Need to select which branch first, then show the history of that branch, not the current branch

Currently it lists each subdirectory of any file that can be added. For example,

./foo/bar/foobar/file

will result in listing

• foo
• foo/bar
• foo/foobar
• foo/bar/foobar

Which is intentional. Except that if there are no files directly under any of those directories, then they're redundant. if the file list is

• ./foo/bar/foobar/file
• ./foo/bar/anotherfile

The it should only list

• ./foo/bar/foobar/file
• ./foo/bar/anotherfile
• ./foo/bar

Because ./foo would be redundant to ./foo/bar

This could be challenging for branching paths, but the current expansion quickly becomes unwieldy.

In checkout it parses when the command itself should parse

--bind alt-j:preview-down,alt-k:preview-up

Other highlighters listed in the fzf readme

• Bat: https://github.com/sharkdp/bat
• Highlight: http://www.andre-simon.de/doku/highlight/en/highlight.php
• CodeRay: http://coderay.rubychan.de/
• Rouge: https://github.com/jneen/rouge

# Try bat, highlight, coderay, rougify in turn, then fall back to cat
fzf --preview '[[ $(file --mime {}) =~ binary ]] &&
                 echo {} is a binary file ||
                 (bat --style=numbers --color=always {} ||
                  highlight -O ansi -l {} ||
                  coderay {} ||
                  rougify {} ||
                  cat {}) 2> /dev/null | head -500'

Allow passing in a directory to install to instead of /usr/local/bin

This should save the directory to a .install-directory file so uninstall.sh can reference it.