Fuzzy finder

Find

def find -params 1 -shell-candidates %{ find -type f } %{ edit %arg{1} }

More advanced :find command, that supports wildcard expansions and respects Kakoune's path option:

define-command -docstring "find file recursively searching for it under path" \
find -params 1 -shell-candidates %{ find -type f } %{ evaluate-commands %sh{
    for buffer in $kak_buflist; do # check if file exist in buffer list, as gf initially does
        buffer="${buffer%\'}";  buffer="${buffer#\'}"
        if [ -z "${buffer##*$1}" ]; then
            echo "buffer $buffer"
            exit
        fi
    done
    if [ -e "'$1'" ]; then # check if absolute path given
        echo "edit -existing '$1'"
        exit
    fi
    for path in $kak_opt_path; do
        path="${path%\'}"; path="${path#\'}"
        case $path in # in default path configuration current kak dir goes before current buffer dir
            "./") path=${kak_buffile%/*};; # swap './' and '%/' since '.%' has fewer scope to search
            "%/") path=$(pwd);;
        esac
        if [ -z "${1##*/*}" ]; then # if path contains '/' treat it as absolute path
            test=$(eval echo "'$path/$1'")
            [ -e "$test" ] && file=$test
        else # search for file recursively
            file=$(find -L $path -xdev -type f -name $(eval echo $1) | head -n 1)
        fi
        if [ ! -z "$file" ]; then
            echo "edit -existing '$file'"
            exit
        fi
    done
    echo "echo -markup '{Error}unable to find file ''$1'''"
}}

This find can also be mapped to gf keeping old behavior with gAlt+f:

map -docstring "file non-recursive" global goto '<a-f>' '<esc>gf'
map -docstring "file" global goto 'f' '<esc>:find %reg{dot}<ret>'

Git

def git-edit -params 1 -shell-candidates %{ git ls-files } %{ edit %arg{1} }

FZF

fzf is a basic fuzzy finder tool used to interactively filter large lists of data in a shell.

In the following snippets, a tmux pane is opened with fzf ready to filter a list of files and a list of current buffers.

Other kakoune lists could be filtered this way, taking fzf.vim as inspiration.

define-command -docstring 'Invoke fzf to open a file' -params 0 fzf-edit %{
    evaluate-commands %sh{
        if [ -z "${kak_client_env_TMUX}" ]; then
            printf 'fail "client was not started under tmux"\n'
        else
            file="$(find . -type f |TMUX="${kak_client_env_TMUX}" fzf-tmux -d 15)"
            if [ -n "$file" ]; then
                printf 'edit "%s"\n' "$file"
            fi
        fi
    }
}

# the original version no longer works since kak_buflist is no longer ":" separated.
# this one works if you don't have single quote in file names.

def -override -docstring 'invoke fzf to select a buffer' \
  fzf-buffer %{eval %sh{
      BUFFER=$(printf %s\\n ${kak_buflist} | sed "s/'//g" |fzf-tmux -d 15)
      if [ -n "$BUFFER" ]; then
        echo buffer ${BUFFER}
      fi
} }

fzf.kak

There's also a fzf.kak plugin, that includes such features:

• Supports both x11 and tmux
• Opening files with find, fd, rg, ag
• Previewing file contents with syntax highlighting, backed by bat, coderay, highlight, rogue`
• Switching buffers
• Automatic detection of your VCS to list files. Supports:
  • Git
  • GNU Bazaar
  • Subversion
  • Mercurial
• Searching tags with universal-ctags
• Filtering tags by kinds for all ctags supported languages
• Searching current buffer contents

Rofi

Select an open buffer using Rofi

define-command rofi-buffers \
-docstring 'Select an open buffer using Rofi' %{ %sh{
    BUFFER=$(printf %s\\n "${kak_buflist}" | tr : '\n' | rofi -dmenu)
    if [ -n "$BUFFER" ]; then
    	echo "eval -client '$kak_client' 'buffer ${BUFFER}'" | kak -p ${kak_session}
    fi
} }  

Using Ag + Rofi to select files in your project directory.

define-command rofi-files \
-docstring 'Select files in project using Ag and Rofi' %{ %sh{
    FILE=$(ag -g "" | rofi -dmenu)
    if [ -n "$FILE" ]; then
        printf 'eval -client %%{%s} edit %%{%s}\n' "${kak_client}" "${FILE}" | kak -p "${kak_session}"
    fi
} }

Fast file finder: fasd integration

Add function k () kak `fasd -f $1` to your .zshrc to open frecent files with k filename