So you've installed `fzf` – now what? (andrew-quinn.me)

dont forget ` -m` for multiselect ;)

Quick question. How do you set up the key bindings for the command prompt window on Windows? The control-r, alt-c, etc.

  Remove-PSReadlineKeyHandler 'Ctrl+r'
  Remove-PSReadlineKeyHandler 'Ctrl+t'
  Import-Module PSFzf

So, just like what fish shell gives out of the box :)

fzf actually has a huge list of functions for the shell to use on their wiki

https://github.com/junegunn/fzf/wiki/examples

I've been seeing mentions of fzf for some time but this article might make it try it.

Zsh's H-S-MW plugin [1], which provides multi word CTRL+R to search the history + a couple of half-assed tools I wrote [2] seem to cover most of the think I would need fzf for, but maybe fzf would work better or be a useful addition to my toolset. Maybe it could replace those half-assed tools.

Of course I intensively use ripgrep.

[1] https://github.com/z-shell/H-S-MW

[2] https://news.ycombinator.com/item?id=34495070

That blew my mind, thanks so much for sharing

So I might aswell ask here: I want to search for a string using ripgrep, select one of the files from the result list using FZF and then open the selected file with VS code.

> rg . | fzf

How do I do this on windows (NOT Linux)??

*Note:* Assume I already have ripgrep, FZF & VS Code installed.

Two things I use fuzzy finder for:

1. flog: go to git branches I had checked out in the past quickly

2. pr: preview and check out PRs I've been assigned to review

    flog () {
     branch="$(
        git branch --sort=-committerdate --format="%(committerdate:relative)%09%(refname:short)%09%(subject)" \
        | column -ts $'\t' \
        | fzf \
        | sed 's/.*ago \+\([^ ]*\) .*/\1/'
      )" 
     git co $branch || (
      echo -n "git co $branch" | pbcopy
     )
    }

    errcho() {
      echo "$@" 1>&2
    }
    
    jq_query=$(cat <<- EOF
      map(
          { key: "\(.number)"
          , value:
            { line: "\(.number):\(if .isDraft then "" else " " end):\(.author.login):\(.title):\(.headRefName)"
            , body: "# \(.number): \(.title)
    ## \(.headRefName)
    
    \(.body)"
            }
          }
        )
      | from_entries
    EOF
    )
    
    pr () {
      local gh_user=${1:-}
    
      if [ -z "$gh_user" ]; then
        gh_user="@me"
      fi
    
      tmpFile=$(mktemp /tmp/prs-XXXXXX.json)
    
      cleanup () {
        rm "$tmpFile"
      }
    
      trap cleanup EXIT
      gh pr list -S "review-requested:${gh_user}" \
      --json number,title,headRefName,body,author,isDraft \
      | jq -r "$jq_query" > "$tmpFile"
    
      preview_command="\
        jq -r '.[\"{1}\"].body' $tmpFile \
        | pandoc -f gfm -t markdown      \
        | glow -s light -
      "
      pr_number=$(
        jq -r \
          'to_entries | map(.value.line) | join("
    ")' \
          "$tmpFile" \
        | column -t -s: \
        | fzf                            \
            --ansi                       \
            --delimiter=' '              \
            --preview="$preview_command" \
            --preview-window=up:80%      \
        | grep -o '^[0-9]\+'
      )
    
      if [ -n "$pr_number" ]; then
        errcho "checking out #$pr_number"
        gh pr checkout "$pr_number" && gh pr view --web "$pr_number" && git pull || echo -e "gh pr checkout $pr_number && gh pr view --web $pr_number && git pull"
      else
        errcho "canceled"
      fi
    }

Fantastic article.

I was exactly in the situation the article describes, I installed it, then, didn't find a use case.

But that's because Ubuntu doesn't come with completion enabled by default.

You have to add in your bashrc:

    if [ -e /usr/share/doc/fzf/examples/key-bindings.bash ]; then
      source /usr/share/doc/fzf/examples/key-bindings.bash
    fi

The fzf and ubuntu docs don't mention you have to.

Couldn't find easily how to do it with google, but chatgpt saved the day once again.

   source /usr/share/fzf/keybindings.bash

  source /usr/share/doc/fzf/examples/completion.bash
  source /usr/share/doc/fzf/examples/key-bindings.bash

    if [ -e /usr/share/doc/fzf/examples/completion.bash ]; then
      source /usr/share/doc/fzf/examples/completion.bash
    fi

   git log --oneline | fzf

    git log --oneline | fzf | cowsay

I had no idea about alt+c, that's a game changer for me. great intro.

You can also go to the specific line you pick from fzf search

nvim $(rg . --vimgrep | fzf | awk -F: '{print $1, "+" $2+0}')

fzf is super useful for navigating and switching git branches I realised today [1]

    function gbll(){
    local tags branches target
    branches=$(
      git --no-pager branch --sort=-committerdate \
        --format="%(if)%(HEAD)%(then)%(else)%(if:equals=HEAD)%(refname:strip=3)%(then)%(else)%1B[0;34;1mbranch%09%1B[m%(refname:short)%(end)%(end)" \
      | sed '/^$/d') || return
    tags=$(
      git --no-pager tag | awk '{print "\x1b[35;1mtag\x1b[m\t" $1}') || return
    target=$(
      (echo "$branches"; echo "$tags") |
      fzf --no-hscroll --no-multi -n 2 \
          --ansi --preview="git --no-pager log -150 --pretty=format:%s '..{2}'") || return
    git checkout $(awk '{print $2}' <<<"$target" )
    }

[1]https://github.com/junegunn/fzf/wiki/Examples#git

    cp = !git pick-branch | xargs git pick-commits | tac | xargs -t git cherry-pick

I love how people share their fzf scripts whenever a new post comes along. I'll share some of my own.

First, some env variables for setting defaults:

    export FZF_DEFAULT_COMMAND='fd --type f --hidden --exclude .git'
    export FZF_DEFAULT_OPTS='--layout=reverse --inline-info'
    export FZF_CTRL_T_COMMAND="$FZF_DEFAULT_COMMAND"

And some neat commands:

1. A command for fuzzy jumping between workspaces with tree previews (depends on `tree`):

    export WORKSPACE_ROOT="$HOME/whatever-your-root-is"
    ws() {
      cd "$WORKSPACE_ROOT/`ls -a $WORKSPACE_ROOT | fgrep -v .DS_Store | fzf --preview '(cd $WORKSPACE_ROOT/{1}; pwd; tree -C -L 1 -I node_modules -I .DS_Store)'`"
    }

2. A command to be able to fuzzy search files with previews and syntax highlighting. Depends on bat being installed.

    alias fzp="fzf --preview 'bat --style=numbers --color=always --line-range :500 {}' --border --height='80%'"

3. A command to fuzzily run npm scripts with previews and syntax highlighting. Depends on bat and gojq, but you can sub gojq with jq. It does have a bug where it doesn't handle ":" characters in script keys well, but I'll fix that at some point.

    npz() {
      local script
      script=$(cat package.json | gojq -r '.scripts | keys[] ' | fzf --preview 'cat package.json | gojq -r ".scripts | .$(echo {1})" | bat -l sh --color always --file-name "npm run $(echo {1})" | sed "s/File: /Command: /"') && npm run $(echo "$script")
    }

4. A command for rapidly selecting an AWS profile. As a user of AWS SSO with many accounts/roles, this is a life-saver. I combine this with having my prompt show the currently selected role for added value.

    alias aws-profile='export AWS_PROFILE=$(sed -n "s/\[profile \(.*\)\]/\1/gp" ~/.aws/config | fzf)'
    alias ap="aws-profile"

5. A command for fuzzily finding and tailing an AWS cloudwatch log group. I didn't come up with this one, and I can't remember where I read about it, or I'd attribute it properly.

    awslogs() {
      export AWS_PROFILE=$(cat ~/.aws/config | awk '/^\[profile /{print $2}' | tr -d ']' | fzf)
      local log_group=$(aws logs describe-log-groups | gojq -r '.logGroups[].logGroupName' | fzf)
      aws logs tail "$log_group" --since 3h --follow --format=short
    }

I also have a few other commands related using fzf, but they're more bespoke and probably not useful to others.

jump (https://github.com/gsamokovarov/jump) is something I use as I didn’t know about Alt-C. Highly recommended

       $ jump shell

   If you have run the integration, enter a few directories in a new shell to
   populate the database.

   Are you coming from autojump or z? You can import their existing scoring
   databases into jump with:

       $ jump import

Thanks for this. I didn't know about the built-in-cd. For anyone on macOS trying to get Alt-C to work see https://github.com/junegunn/fzf/issues/164.

We have an IoT command server and connecting to one of the devices (for maintenance, logs or whatever) involved two manual lookups in the output of two commands and then finding your match in both. I was sick of this one day and with some grep, sed, awk and finally fzf, you could just sort of type the device's name and press "enter" to connect.

People's reaction when I showed them was basically WHAT IS THIS MAGIC?!?

I love fuzzy shell history. Game changer in terms of shell productivity.

I use atuin[0] instead of fzf as I find the experience a bit nicer and it has history backups built in (disclaimer, I am a maintainer)

Some of our users still prefer fzf because they are used to how it fuzzy finds, but we're running an experiment with skim[1] which allows us to embed the fuzzy engine without much overhead - hopefully giving them back that fzf-like experience

[0]: https://github.com/ellie/atuin [1]: https://github.com/lotabout/skim

    atuin-setup() {
        if ! which atuin &> /dev/null; then return 1; fi
        bindkey '^E' _atuin_search_widget

        export ATUIN_NOBIND="true"
        eval "$(atuin init "$CUR_SHELL")"
        fzf-atuin-history-widget() {
            local selected num
            setopt localoptions noglobsubst noposixbuiltins pipefail no_aliases 2>/dev/null

            # local atuin_opts="--cmd-only --limit ${ATUIN_LIMIT:-5000}"
            local atuin_opts="--cmd-only"
            local fzf_opts=(
                --height=${FZF_TMUX_HEIGHT:-80%}
                --tac
                "-n2..,.."
                --tiebreak=index
                "--query=${LBUFFER}"
                "+m"
                "--bind=ctrl-d:reload(atuin search $atuin_opts -c $PWD),ctrl-r:reload(atuin search $atuin_opts)"
            )

            selected=$(
                eval "atuin search ${atuin_opts}" |
                    fzf "${fzf_opts[@]}"
            )
            local ret=$?
            if [ -n "$selected" ]; then
                # the += lets it insert at current pos instead of replacing
                LBUFFER+="${selected}"
            fi
            zle reset-prompt
            return $ret
        }
        zle -N fzf-atuin-history-widget
        bindkey '^R' fzf-atuin-history-widget
    }
    atuin-setup

    $ history -r

    shopt -s histappend
    PROMPT_COMMAND="history -a;$PROMPT_COMMAND"

    setopt inc_append_history

  export CDPATH="$HOME:$HOME/code/:$(ls -d $HOME/work/*/| tr \\n :)"

  ~/project% find -type d | wc -l
  13946

If anyone who uses i3 needs an fzf application launcher in their lives, adding the following two lines to your config will make $mod+d open it as a floating window in the middle (uses rxvt-unicode):

    bindsym $mod+d exec --no-startup-id urxvt -title "fzf-menu-random123" -e bash -c 'i3-dmenu-desktop --dmenu=fzf'
    for_window [title="fzf-menu-random123"] floating enable

fzf lua is a cool plugin for neovim: https://github.com/ibhagwan/fzf-lua

So you don't need to do stuff like

    vi $(find . '/' | fzf)

And instead can use fzf from inside the editor.

It also supports integrating it with fdfind and ripgrep.

Am I the only one that tried fzf as a replacement to the default Ctrl+R behavior, then switched back?

I'm perfectly satisfied with the default Ctrl+R functionality, to the point that fzf seemed to add visual clutter without any value.

I guess I was never let down by inverse search.

Context: I'm using Linux and doing SWE and SRE work, and constantly live in the terminal.

   source /usr/share/doc/fzf/examples/key-bindings.bash

    docker compose -p devenv exec myservice /bin/sh

    # use up and down arrow to match search history based on typed starting text
    "\e[A": history-search-backward
    "\e[B": history-search-forward
    
    # if you prefer to search anywhere in the command
    "\e[A":history-substring-search-backward
    "\e[B":history-substring-search-forward

Alright, you convinced me. Damn great article!

For me the killer feature is fuzzy tab completion.

https://github.com/Aloxaf/fzf-tab

Install this, get an instant improvement to anything you do on the terminal. It works with any existing program with tab completion.

Most useful fzf thing for me is this: history | fzf

Here's a little function that I use pretty often when I want to install a package but I'm not sure what the exact package name is. Give it a keyword and it searches apt-cache and dumps the results into fzf.

  function finstall {
      PACKAGE_NAME=$(apt-cache search $1 | fzf | cut --delimiter=" " --fields=1)
      if [ "$PACKAGE_NAME" ]; then
          echo "Installing $PACKAGE_NAME"
          sudo apt install $PACKAGE_NAME
      fi
  }

    # ~/.config/fish/functions/fbi.fish
    function fbi -a query -d 'Install Brew package via FZF'
        set -f PREVIEW 'HOMEBREW_COLOR=1 brew info {}'
        set -f PKGS (brew formulae) (brew casks |sed 's|^|homebrew/cask/|')
    
        set -f INSTALL_PKGS (echo $PKGS \
            |sed 's/ /\n/g' \
            |fzf --multi --preview=$PREVIEW --query=$query --nth=-1 --with-nth=-2.. --delimiter=/)
    
        if test ! -z "$INSTALL_PKGS"
            brew install $INSTALL_PKGS
        else
            echo "Nothing to install…"
        end
    end

I have ctrl-r and alt-c assigned to macro keys on my keyboard, they're so danged useful.

Something else you can try in your `~/.gitconfig`

    [alias]
      fza = "!git ls-files -m -o --exclude-standard | fzf -m --print0 | xargs -0 git add"

    git fza will quickly let you add files if you've changed a lot.

I alias `git fza` to `ga` and it gets used a lot

Oh, and another useful shortcut is this:

    export FZF_CTRL_T_COMMAND="mdfind -onlyin . -name ."

Obviously only useful for MacOS, but fzf plus spotlight is pretty useful. You can use it to find that lost file that you only remember part of the name!