Ytdyklly

It's not uncommon that I make a typo when entering commands in my bash interactive shell. I'd like to be able to correct the typo in my bash history so that the incorrect command does not pollute it and lead me to accidentally re-execute it later. In particular, I'd like to edit the last command.

There are quite a number of questions asking about how to prevent accidentally editing bash history. I want the opposite: I want to explicitly edit history.

Based on some of the explanations from the referenced questions, I tried doing:

$ echo foo

pressing Up, changing it to:

$ echo foobar

pressing Down, but that does nothing, and if I then press Enter, it will execute the modified command and leave both

echo foo

echo foobar

in my history.

I am aware that I can manually delete history entries with history -d, but I haven't devised a good way to use that conveniently. I don't want to make a shell function to unconditionally delete the last history entry because I still want to be able to use Up to load the last entry so that I can correct it. I could make the correction and then delete the second-to-last history entry, but that feels clumsy and it's particularly annoying for a long-running command since I'd either need to remember to perform extra steps later or would need to temporarily suspend it, do those steps, and resume.

What I want:

• Ideally what I'd like to be able to do is to press Up, make a correction to my previous command, and press some special keybinding or add some magic token to the command-line to cause it to replace the history entry when executed.




• Also acceptable would be to press some other key sequence to retrieve and edit a command from history (similar to Ctrl+R) that overwrites the history entry when executed.




• A robust shell function that removes the second-to-last history entry would be tolerable but non-ideal.

I imagine that surely other people make typos too and are similarly annoyed when such commands pollute their history. What do other people do?

Option #1 - Manually

I'd simply open the ~/.bash_history file in an editor such as vim and make whatever changes you need to that file and save.

$ vim ~/.bash_history

Before editing it make sure your current terminals history is committed to this file as well:

$ history -a

Keep in mind that your history file is located where ever this environment variable is pointing to:

$ echo $HISTFILE

/Users/user1/.bash_history

Option #2 - HSTR

There's a CLI tool called HSTR that you can use to manage your ~/.bash_history file in a more systematic way. The main website for HSTR was videos and good details on using it.

It also mentions this blurb:

HSTR can also manage your command history (for instance you can remove commands that are obsolete or contain a sensitive information) or bookmark your favorite commands.

Refer to the full docs for more on this: HSTR DOCUMENTATION.

References

• Remove a certain line from Bash history file

HSTR seemed appealing but turned out to be a bit too heavyweight for my taste.

I instead wrote my own bash function:

# Removes the last command from the history that matches the given search

# string and re-executes it using the given replacement string.

#

# Usage:

#   historysub SEARCH [REPLACEMENT]

#   historysub -d SEARCH

#

#   REPLACEMENT may be omitted to remove SEARCH from the executed command.

#

#   -d removes the last command matching SEARCH from the history without

#   executing a new command.

historysub()

{

  local delete=0

  local usage=0

  local OPTIND=1

  while getopts ":hd" option; do

    case "${option}" in

      d) delete=1 ;;

      h) usage=1 ;;

      ?) usage=2 ;;

    esac

  done

  shift $((OPTIND - 1))



  local search="${1}"

  local replacement="${2}"



  usage_text=

  usage_text+="Usage: ${FUNCNAME[0]} SEARCH [REPLACEMENT]n"

  usage_text+="       ${FUNCNAME[0]} -d SEARCHn"



  if (( usage )); then

    echo -e "${usage_text}"

    return $(( usage - 1 ))

  fi



  if [[ -z "${search}" ]]; then

    echo -e "${usage_text}" >&2

    return 1

  fi



  # Find the last matching history entry (excluding ourself).

  local hist_info

  hist_info=$(HISTTIMEFORMAT="" history | grep -F -- "${search}" | grep -vF -- "${FUNCNAME[0]}" | tail -n 1)

  if [[ -z "${hist_info}" ]]; then

    echo "${FUNCNAME[0]}: "${search}" not found." >&2

    return 1

  fi



  local re='^[ t]*([0-9]+)[ t]+(.+)$'

  local hist_num hist_cmd

  hist_num=$(sed -E "s/${re}/1/" <<< "${hist_info}")

  hist_cmd=$(sed -E "s/${re}/2/" <<< "${hist_info}")



  history -d "${hist_num}"

  if (( delete )); then

    echo "Removed: ${hist_cmd}"

    return 0

  fi



  local cmd="${hist_cmd/${search}/${replacement}}"

  echo "${cmd}"



  # Add the new command to the history.

  history -s ${cmd}

  eval ${cmd}

}

So now I can run historysub TYPO CORRECTION to re-execute a command with a correction. It's not as good as being able to interactively edit the old command, but I think it should be good enough for my needs.