Provided by: fasd_1.0.1-1_all bug


       fasd - quick access to files and directories


       fasd [options] [query ...]

       [f|a|s|d|z] [options] [query ...]

       fasd [-A|-D] [paths ...]


              -s         list paths with ranks
              -l         list paths without ranks
              -i         interactive mode
              -e <cmd>   set command to execute on the result file
              -b <name>  only use <name> backend
              -B <name>  add additional backend <name>
              -a         match files and directories
              -d         match directories only
              -f         match files only
              -r         match by rank only
              -t         match by recent access only
              -R         reverse listing order
              -h         show a brief help message
              -[0-9]     select the nth entry


       Fasd  keeps  track  of  files and directories you access in your shell and gives you quick
       access to them.  You can use fasd to reference files or directories  by  just  a  few  key
       identifying  characters.   You  can  use  fasd  to boost your command line productivity by
       defining your own aliases to launch programs on files or directories.  Fasd,  by  default,
       provides   some  basic  aliases,  including  a  shell  function  "z"  that  resembles  the
       functionality of "z" and "autojump."

       The name "fasd" comes from the default suggested aliases  f(files),  a(files/directories),
       s(show/search/select), d(directories).

       Fasd  ranks  files  and  directories  by  "frecency,"  that  is,  by  both "frequency" and
       "recency." The term "frecency" was first coined by Mozilla and used in Firefox.


              z bundle
              f -e vim nginx conf
              f -i rc$
              vi `f nginx conf`
              cp update.html `d www`
              open `sf pdf`


       To get fasd working in a shell, some initialization code must be run.  Put lines below  in
       your POSIX compatible shell rc.

              eval "$(fasd --init auto)"

       This  will setup a command hook that executes on every command and advanced tab completion
       for zsh and bash.

       If you want more control over  what  gets  into  your  shell  environment,  you  can  pass
       customized set of arguments to fasd --init.

              zsh-hook             # define _fasd_preexec and add it to zsh preexec array
              zsh-ccomp            # zsh command mode completion definitions
              zsh-ccomp-install    # setup command mode completion for zsh
              zsh-wcomp            # zsh word mode completion definitions
              zsh-wcomp-install    # setup word mode completion for zsh
              bash-hook            # add hook code to bash $PROMPT_COMMAND
              bash-ccomp           # bash command mode completion definitions
              bash-ccomp-install   # setup command mode completion for bash
              posix-alias          # define aliases that applies to all posix shells
              posix-hook           # setup $PS1 hook for shells that's posix compatible
              tcsh-alias           # define aliases for tcsh
              tcsh-hook            # setup tcsh precmd alias

       Example for a minimal zsh setup (no tab completion):

              eval "$(fasd --init posix-alias zsh-hook)"

       Note  that  this  method  will  slightly  increase your shell start-up time, since calling
       binaries has overhead.  You can cache  fasd  init  code  if  you  want  minimal  overhead.
       Example code for bash (to be put into .bashrc):

              if [ "$(command -v fasd)" -nt "$fasd_cache" -o ! -s "$fasd_cache" ]; then
                fasd --init posix-alias bash-hook bash-ccomp bash-ccomp-install >| "$fasd_cache"
              source "$fasd_cache"
              unset fasd_cache

       Optionally, if you can also source fasd if you want fasd to be a shell function instead of
       an executable.

       You can tweak initialization code.  For instance, if you want to use "c" instead of "z" to
       do directory jumping, you can use the alias below:

              alias c='fasd_cd -d'
              # `-d' option present for bash completion
              # function fasd_cd is defined in posix-alias


       Fasd has three matching modes: default, case-insensitive, and fuzzy.

       For a given set of queries (the set of command-line arguments passed to fasd), a path is a
       match if and only if:

       1. Queries match the path in order.

       2. The last query matches the last segment of the path.

       If no match is found, fasd will try the same process ignoring case.  If still no match  is
       found,  fasd  will  allow extra characters to be placed between query characters for fuzzy


       • If you want your last query not to match the last segment of the path, append `/' as the
         last query.

       • If  you  want  your  last query to match the end of the filename, append `$' to the last


       Fasd's basic functionalities are POSIX compliant, meaning that you should be able  to  use
       fasd  in  all  POSIX compliant shells.  Your shell need to support command substitution in
       $PS1 in order for fasd to automatically track your commands and files.   This  feature  is
       not  specified by the POSIX standard, but it's nonetheless present in many POSIX compliant
       shells.  In shells without  prompt  command  or  prompt  command  substitution  (tcsh  for
       instance),  you  can  add  entries  manually  with  "fasd  -A".   You are very welcomed to
       contribute shell initialization code for not yet supported shells.


       Fasd offers two completion modes,  command  mode  completion  and  word  mode  completion.
       Command mode completion works in bash and zsh.  Word mode completion only works in zsh.

       Command  mode  completion is just like completion for any other commands.  It is triggered
       when you hit tab on a fasd command or its aliases.  Under this mode your  queries  can  be
       separated  by  a  space.   Tip:  if  you  find  that the completion result overwrites your
       queries, type an extra space before you hit tab.

       Word mode completion can be triggered on any command.  Word completion is triggered by any
       command  line argument that starts with "," (all), "f," (files), or "d," (directories), or
       that ends with ",," (all), ",,f" (files), or ",,d" (directories).  Examples:

              $ vim ,rc,lo<Tab>
              $ vim /etc/rc.local

              $ mv index.html d,www<Tab>
              $ mv index.html /var/www/

       There are also three zle widgets: "fasd-complete",  "fasd-complete-f",  "fasd-complete-d".
       You can bind them to keybindings you like:

              bindkey '^X^A' fasd-complete    # C-x C-a to do fasd-complete (fils and directories)
              bindkey '^X^F' fasd-complete-f  # C-x C-f to do fasd-complete-f (only files)
              bindkey '^X^D' fasd-complete-d  # C-x C-d to do fasd-complete-d (only directories)


       Fasd  can  take  advantage  of different sources of recent / frequent files.  Most desktop
       environments (like Gtk) and some editors (like Vim) keep a list of accessed  files.   Fasd
       can  use  them  as  additional  backends  if  the data can be converted into fasd's native
       format.  As of now, fasd supports Gtk's recently-used.xbel  and  Vim's  viminfo  backends.
       You can define your own backend by declaring a function by that name in your .fasdrc.  You
       set default backend with _FASD_BACKENDS variable in our .fasdrc.


       Upon every execution, fasd will source  "/etc/fasdrc"  and  "$HOME/.fasdrc"  if  they  are
       present.  Below are some variables you can set:

              Path to the fasd data file, default "$HOME/.fasd".

              List of blacklisted strings. Commands matching them will not be processed.
              Default is "--help".

              List of all commands that needs to be shifted, defaults to "sudo busybox".

              List of all commands that will be ignored, defaults to "fasd ls echo".

              Fasd defaults to track your "$PWD". Set this to 0 to disable this behavior.

              Which awk to use. fasd can detect and use a compatible awk.

              File to log all STDERR to, defaults to "/dev/null".

              Max total score / weight, defaults to 2000.

              Which shell to execute. Some shells will run faster than others. fasd
              runs faster with dash and ksh variants.

              Default backends.

              If set to any non-empty string, fasd will not add or delete entries from
              database. You can set and export this variable from command line.

              Level of "fuzziness" when doing fuzzy matching. More precisely, the number of
              characters that can be skipped to generate a match. Set to empty or 0 to
              disable fuzzy matching. Default value is 2.

              Path to .viminfo file for viminfo backend, defaults to "$HOME/.viminfo"

              Path to XDG recently-used.xbel file for recently-used backend, defaults to


       Fasd is hosted on GitHub:

       If  fasd  does  not  work  as  expected, please file a bug report on GitHub describing the
       unexpected behavior along with your OS version, shell version, awk version,  sed  version,
       and a log file.

       You can set _FASD_SINK in your .fasdrc to obtain a log.



       Fasd  is  originally  written  based  on  code  from z ( by rupa
       deadwyler under the WTFPL license.  Most if not all of the code has been rewritten.   Fasd
       is licensed under the "MIT/X11" license.


       Wei Dai <>.