For these commands I want to rerun, but not often enough, I add a comment to the command like `yay - Sc # clear pacman and yay caches` so it's easier to search in the future
I use this a lot too, often with cherry-picks and reverts that can't be merged into this or that branch yet, too. It's very convenient and works everywhere without installing anything.
I just add " ###" to the end of commands run frequently. It makes easier to identify important commands with atuin, fzf or plain bash/fish history search.
I made a shell script "hg" which stands for "history | grep." So "hg .wine" brings up all commands in the bash command history buffer with the string .wine in them, say "1601 ls .wine" To run one of course you just enter ! and the number of the command. So like... !1601. Whole process is extremely ergonomic.
Although - if anyone wants to write a shell extension that always runs the command output in a separate panel and keeps the parent panel (or tab) to just the commands entered that would be cool too.
I switched to atuin and it's a huge step up from native Ctrl + R and fzf because you can press Ctrl + R again and again and it switches between searching through directory, session, host, or global history.
I listened to an interview with the creator of atuin on the changelog podcast. It seems like a compelling idea. The only thing that makes me consider switching from the fzf/ctr-r combo is syncing my history between tmux sessions. But I don't spend enough time in the terminal to really justify the time to set it up.
Seconding `fzf`, it's such an improvement from the stock Ctrl-R behavior I think it's worth installing even if you never actually run `fzf` at the command line itself. Hence why I led with the new shortcuts at https://andrew-quinn.me/fzf (fuzzy `cd` with Alt-C being the other one of note).
Interestingly, the default fish shell also comes with something similar these days, although I still prefer the look of `fzf`.
Came here to say this. Fzf is almost too good, it's so convenient to find past commands that I've gotten two years into a career as a software developer without committing any of my most common command line tools to memory.
Yes, this. For example, `Ctrl+R makedo` would go back in history to the first command that matches this, to use the ` ./scripts/makedocs.sh` example from the article.
And Ctrl+s goes forward in history, but if you don’t have flow control disabled you might think your terminal became frozen in time. Ctrl+q will resume the flow in that case.
Also got to watch out for Ctrl+d on qwerty kb layouts where s and d keys live side by side.
Yup. Then if you want to run the commands that you ran after it last time, hit `Ctrl+O` instead of `Enter` and the next command you ran will be pre-filled on the prompt.
I’ll give it a try, might see if could integrate it into telescope for vim too because I find myself a bit slow when there using harpoon at the moment.
For me, C-r is sufficient (and/or M-r in Emacs, where C-r by default does reverse interactive search on the text in buffer; it's nice to have both at the same time, actually). However, I must have skipped some education about shell history and/or its default settings, because half the time I need it, the command I want isn't there to be found. I also observed the following kinds of behaviors:
- Sometimes, shell history seems to be scoped (or reacting to) current working directory;
- Sometimes, commands executed on remote machines end up being saved in local history;
- When the shell gets killed (e.g. when Emacs crashes and takes down the shells open inside with it), or the system crashes, sometimes the history gets saved, and sometimes nothing remains from a session that spanned multiple days;
- When I have multiple terminals open, it's a coin toss whether only one will have history saved or all of them, and then another toss as to whether histories will be CWD-sensitive or not.
Is there a good primer/community consensus on how to configure shell so all history gets saved in sensible manner (including continuously, so it survives a crash)?
> Is there a good primer/community consensus on how to configure shell so all history gets saved in sensible manner (including continuously, so it survives a crash)?
I find that zsh is quite good at addressing some of the issues you mention.
.. have added a gist in comments below, i got used to saving separate history files for each project and launch gnome-terminal with that .. and Ctrl-R within that scope
There are shell options you need to set to, for example, make shell history saving work when multiple terminals are used (the defaults are bad). Read the manual
# Ensure history is written after every command, allowing it to persist across sessions
shopt -s histappend # Append to history instead of overwriting
PROMPT_COMMAND="history -a; history -c; history -r; $PROMPT_COMMAND"
# Set the history size (adjust as needed)
HISTSIZE=50000 # Number of commands kept in memory
HISTFILESIZE=1000000 # Number of commands kept in the history file
# Add timestamps to history (format: YYYY-MM-DD HH:MM:SS)
HISTTIMEFORMAT="%Y-%m-%d %H:%M:%S "
# Ignore duplicate and space-prefixed commands
HISTCONTROL=ignoredups:ignorespace
# Save multi-line commands as a single entry
shopt -s cmdhist
# Allow history expansion with Ctrl + R
bind '"\e[A":history-search-backward'
bind '"\e[B":history-search-forward'
Also, if you are on shells you worry about, use gnu screen (or tmux if you prefer) imho. It will give you a second layer of history to be able to dig through.
This will do what you want:
Append this to your .bashrc.
```export PROMPT_COMMAND="history -a; history -c; history -r; $PROMPT_COMMAND"```
-a = append to history file
-c = 'clear' aka write the history file
-r = reload
Every time you hit 'enter' this will add the command to the history file, and will reload your bash prompt history.
That means that every terminal window will share a common history file and you don't need to close the TERM to 'save' the session to history.
This is ESPECIALLY helpful on remote (SSH) connections.
Downside:
You 'Up Arrow' history gets altered by every term window you have running. So you can't just blindly `up` to repeat a command.
POSIX outlines vi mode, but emacs is not mentioned.
"vi - Allow shell command line editing using the built-in vi editor. Enabling vi mode shall disable any other command line editing mode provided as an implementation extension."
.. another cheap trick .. when juggling different projects i keep a separate history file for each under ~/.histories/ .. shameless plug to my gist .. bash script that launches gnome-terminal with a named history file ..
especially for many, like me, who cannot change shell... since we are not working with our pc, but we are SSH connecting to plenty of different servers
I always found it most useful to have up and down arrows search through history for what I've already typed. So to run my tests via Gradle, I usually just type ’.g‘ followed by up arrow.
I think I set it up with
‘‘‘
"\e[A": history-search-backward
"\e[B": history-search-forward
’’’
(Not near a computer right now to confirm)
82 comments
[ 5.5 ms ] story [ 152 ms ] threadAn obvious improvement! And if you're using text you don't even need to be watching out to recognise it, you can search with Ctrl-R.
I made a shell script "hg" which stands for "history | grep." So "hg .wine" brings up all commands in the bash command history buffer with the string .wine in them, say "1601 ls .wine" To run one of course you just enter ! and the number of the command. So like... !1601. Whole process is extremely ergonomic.
Although - if anyone wants to write a shell extension that always runs the command output in a separate panel and keeps the parent panel (or tab) to just the commands entered that would be cool too.
Not a Mercurial user, I take it? (hg is the standard command for Mercurial.)
For example I have 'glast' to list the 5 previous git branches.
Or I have 'phelp' that basically lists the available commands in a package file.
I guess that more advance tool would be "atuin" [1], but it is too much for my use case.
[0] https://github.com/junegunn/fzf [1] https://github.com/atuinsh/atuin
"Sync your shell history to all of your machines, wherever they are"
That sounds like a potential security issue though.
Regardless, I just run it local only on each of my machines, separately. It’s still really helpful!
Interestingly, the default fish shell also comes with something similar these days, although I still prefer the look of `fzf`.
Also got to watch out for Ctrl+d on qwerty kb layouts where s and d keys live side by side.
https://github.com/atuinsh/atuin
You're welcome.
No matter my config it would always glitch. Atuin is backed by a global sqlite db: problem solved. And unlimited history.
I don't use sync though, commands sent to 3rd party servers are a no-go.
Like vi in reverse, n goes further back, but N goes forward.
The "set -o vi" option is a POSIX optional feature, and should work in any compliant shell.
CTRL+r
vs
CTRL+R (so Ctrl shift R)
I've tried, and see no difference: what should it be?
So ctrl shift R goes from the latest command backwards that fit your search term.
Oh I see, ctrl R does the same thing interesting.
For me, C-r is sufficient (and/or M-r in Emacs, where C-r by default does reverse interactive search on the text in buffer; it's nice to have both at the same time, actually). However, I must have skipped some education about shell history and/or its default settings, because half the time I need it, the command I want isn't there to be found. I also observed the following kinds of behaviors:
- Sometimes, shell history seems to be scoped (or reacting to) current working directory;
- Sometimes, commands executed on remote machines end up being saved in local history;
- When the shell gets killed (e.g. when Emacs crashes and takes down the shells open inside with it), or the system crashes, sometimes the history gets saved, and sometimes nothing remains from a session that spanned multiple days;
- When I have multiple terminals open, it's a coin toss whether only one will have history saved or all of them, and then another toss as to whether histories will be CWD-sensitive or not.
Is there a good primer/community consensus on how to configure shell so all history gets saved in sensible manner (including continuously, so it survives a crash)?
I find that zsh is quite good at addressing some of the issues you mention.
```export PROMPT_COMMAND="history -a; history -c; history -r; $PROMPT_COMMAND"```
-a = append to history file -c = 'clear' aka write the history file -r = reload
Every time you hit 'enter' this will add the command to the history file, and will reload your bash prompt history. That means that every terminal window will share a common history file and you don't need to close the TERM to 'save' the session to history.
This is ESPECIALLY helpful on remote (SSH) connections. Downside: You 'Up Arrow' history gets altered by every term window you have running. So you can't just blindly `up` to repeat a command.
It takes a little to get used to, but VERY handy.
This allows EV
Then I can use the vi/vim search keys
- escape
- '/'
- <type words>
- hit n or N to move back and forth
Way way easier than using the up or down arrow.
"vi - Allow shell command line editing using the built-in vi editor. Enabling vi mode shall disable any other command line editing mode provided as an implementation extension."
https://pubs.opengroup.org/onlinepubs/9699919799/utilities/V...
https://gist.github.com/appsmatics/ff27e885460bd345eabe1c5f7...
[1] https://terminaltrove.com/atuin/
[2] https://terminaltrove.com/hoard/
so basically I end up doing ctrl-r, then fuzzy find the command and run it
bravo! you can also search with grep, I did not know!
``` history | grep ICON ```
I think I set it up with ‘‘‘ "\e[A": history-search-backward "\e[B": history-search-forward ’’’ (Not near a computer right now to confirm)
I find this somehow much faster than C-r