This plugin is obsolete and will no longer be maintained. I’ve implemented its core features, including autocompletion, in Vim. See :h cmdline-autocompletion, :h fuzzy-file-picker, and :h live-grep for details.

The ultimate auto-completion plugin for Vim command-line.

• Command Completion: Never struggle to remember complex commands again.
• Search Suggestions: Access relevant search terms with fewer keystrokes, enhancing your navigation.

VimSuggest goes beyond basic auto-completion, offering a suite of advanced features by leveraging Vim's native custom completion mechanism (:h :command-completion-custom). These features feel like a natural extension of the editor, but they can be easily disabled if desired.

• Asynchronous Fuzzy File Search (:VSFind): Effortlessly locate files across your entire project with minimal keystrokes.
• Real-Time Live Grep (:VSGrep): Instantly find text across your entire codebase using glob or regex patterns.
• Fuzzy Search: Quickly locate buffers (:VSBuffer) and search various Vim artifacts.
• In-Buffer Search (:VSGlobal): Leverage Vim's powerful :global command for lightning-fast buffer searches.
• Include File Search (:VSInclSearch): Seamlessly search across included files using Vim's :ilist command.
• Live File Search (:VSFindL): Asynchronously search for files using glob or regex patterns.
• Custom Shell Command Execution (:VSExec): Run and interact with shell commands directly within Vim.

Auto-completion can also be disabled by default and only triggered when the <Tab> key is pressed, which more closely aligns with Vim's default behavior.

• Vim version 9.1 or higher

Install VimSuggest via vim-plug or Vim's built-in package manager.

call plug#begin() Plug 'girishji/vimsuggest' call plug#end()

git clone https://github.com/girishji/vimsuggest.git $HOME/.vim/pack/downloads/opt/vimsuggest

packadd vimsuggest

git clone https://github.com/girishji/vimsuggest.git %USERPROFILE%\vimfiles\pack\downloads\opt\vimsuggest

packadd vimsuggest

VimSuggest offers extensive customization options for both command completion and search completion.

let s:vim_suggest = {} let s:vim_suggest.cmd = { \ 'enable': v:true, \ 'pum': v:true, \ 'exclude': [], \ 'onspace': ['b\%[uffer]','colo\%[rscheme]'], \ 'alwayson': v:true, \ 'popupattrs': {}, \ 'wildignore': v:true, \ 'addons': v:true, \ 'trigger': 't', \ 'reverse': v:false, \ 'prefixlen': 1, \ }

let s:vim_suggest.search = { \ 'enable': v:true, \ 'pum': v:true, \ 'fuzzy': v:false, \ 'alwayson': v:true, \ 'popupattrs': { \  'maxheight': 12 \ }, \ 'range': 100, \ 'timeout': 200, \ 'async': v:true, \ 'async_timeout': 3000, \ 'async_minlines': 1000, \ 'highlight': v:true, \ 'trigger': 't', \ 'prefixlen': 1, \ }

To apply your configuration:

call g:VimSuggestSetOptions(s:vim_suggest)

If you are using vim-plug you may have to do:

autocmd VimEnter * call g:VimSuggestSetOptions(s:vim_suggest)

Enable or disable VimSuggest globally:

:VimSuggestEnable " Enable VimSuggest :VimSuggestDisable " Disable VimSuggest

VimSuggest uses custom highlight groups:

• VimSuggestMatch: Highlights matched portion of the text. Linked to PmenuMatch by default.
• VimSuggestMatchSel: Highlights matched text in the selected item of the menu. Linked to PmenuMatchSel by default.
• VimSuggestMute: Highlights passive text, like line numbers in grep output. Linked to LineNr by default.

" Customize popup window appearance let s:vim_suggest.cmd.popupattrs = { \ 'borderchars': ['─', '│', '─', '│', '┌', '┐', '┘', '└'], \ 'borderhighlight': ['Normal'], \ 'highlight': 'Normal', \ 'border': [1, 1, 1, 1], \ 'maxheight': 20, \ } " Exclude specific patterns from completion " To exclude :[N]b[uffer][!] and :[N]sb[uffer][!] do: let s:vim_suggest.cmd.exclude = [ \ '^\s*\d*\s*b\%[uffer]!\?\s\+', \ '^\s*\d*\s*sb\%[uffer]!\?\s\+' \ ] " Apply the configuration call g:VimSuggestSetOptions(s:vim_suggest) " Customize highlight groups highlight VimSuggestMatch ctermfg=Green guifg=#00FF00 highlight VimSuggestMatchSel cterm=bold gui=bold ctermfg=Green guifg=#00FF00 highlight VimSuggestMute ctermfg=Gray guifg=#808080

When the popup window is open, you can use the following key mappings:

Note: Keys used in command-line editing (:h cmdline-editing) remain unmodified.

You can remap the following keys by configuring the option as shown below:

let s:vim_suggest.keymap = { \ 'page_up': ["\<PageUp>", "\<S-Up>"], \ 'page_down': ["\<PageDown>", "\<S-Down>"], \ 'hide': "\<C-e>", \ 'dismiss': "\<C-s>", \ 'send_to_qflist': "\<C-q>", \ 'send_to_arglist': "\<C-l>", \ 'send_to_clipboard': "\<C-g>", \ 'split_open': "\<C-j>", \ 'vsplit_open': "\<C-v>", \ 'tab_open': "\<C-t>", \ }

Apply the configuration as follows:

call g:VimSuggestSetOptions(s:vim_suggest)

If you are using vim-plug you may have to do:

autocmd VimEnter * call g:VimSuggestSetOptions(s:vim_suggest)

When the addons option is set to v:true, the following commands are made available. You can use these commands directly or map them to your preferred keys.

1. Fuzzy Find Files

   :VSFind [dirpath] [fuzzy_pattern]

   This runs the system's find program (or alternatives) asynchronously to gather files for fuzzy searching. The optional first argument is the directory to search within.

   Example key mappings:

   nnoremap <key> :VSFind<space> nnoremap <key> :VSFind ~/.vim<space> nnoremap <key> :VSFind $VIMRUNTIME<space>

   The 'find' program can be specified through the g:vimsuggest_fzfindprg variable. If this variable is not defined, a default command is used (that ignores hidden files and directories). The placeholder "$*" is allowed to specify where the optional directory argument will be included. If placeholder is not specifed, directory name is included at the end. Environment variables and tilde are expanded for directory names.

   let g:vimsuggest_fzfindprg = 'find $* \! \( -path "*/.*" -prune \) -type f -follow' let g:vimsuggest_fzfindprg = 'fd --type f .'

   (Optional) To execute the program through a shell:

   let g:vimsuggest_shell = true set shell=/bin/sh set shellcmdflag=-c

   Performance:

   Using the system's find program significantly outperforms Vim's :find command. On the Vim source repository, it takes ~1 second to list all files using :find **/* command, while :VSFind takes ~30 milliseconds (30x faster). Shell's recursive glob wildcard can be slow.

2. Fuzzy Search Buffers and Other Vim Artifacts

   :VSBuffer [fuzzy_pattern] :VSGitFind [dir] [fuzzy_pattern] :VSMru [fuzzy_pattern] :VSKeymap [fuzzy_pattern] :VSMark [fuzzy_pattern] :VSRegister [fuzzy_pattern] :VSChangelist [fuzzy_pattern] 

   • VSBuffer: Search and switch between currently open buffers
     • Displays matching buffers as you type
   • VSGitFind: Smart file search with Git awareness
     • In Git repositories: Searches tracked files
     • Outside Git (or if 'dir' is given): Falls back to regular file search (like VSFind)
   • VSMru: Access recently used files
     • Lists files from Vim's v:oldfiles history
     • Example: Quickly return to files you edited yesterday
   • VSKeymap: Navigate to keymap definitions
     • Opens the source file containing the definition of keymap
   • VSMark: Quick mark navigation
     • Jump to any mark location in your files
   • VSRegister: Register content access
     • Paste the content of register
   • VSChangelist: Navigate through changes
     • Jump to any point in the file's change history
     • See :help changelist for details

   Example key mapping:

   nnoremap <key> :VSBuffer<space>

3. Live Grep Search

   :VSGrep {pattern} [directory]

   Executes a grep command live, showing results as you type. {pattern} is given directly to grep command, and it's best to enclose it in quotes to handle special characters. You can also specify an optional directory.

   Example key mappings:

   nnoremap <key> :VSGrep ""<left> nnoremap <key> :VSGrep "<c-r>=expand('<cword>')<cr>"<left>

   The grep program is taken from g:vimsuggest_grepprg variable or the :h 'grepprg' option. If it contains $*, it gets replaced by the command-line arguments. Otherwise, arguments are appended to the end of the command.

   let g:vimsuggest_grepprg = 'grep -REIHins $* --exclude-dir=.git --exclude=".*"' let g:vimsuggest_grepprg = 'rg --vimgrep --smart-case $* .' let g:vimsuggest_grepprg = 'ag --vimgrep'

4. Live File Search

   :VSFindL {pattern} [directory]

   This command runs system's find program live, showing results as you type. {pattern} is a glob (or regex) pattern that should be enclosed in quotes if it contains wildcards. The find command is customized via g:vimsuggest_findprg (similar to g:vimsuggest_fzfindprg).

   Example key mapping and configuring 'find' program:

   nnoremap <key> :VSFindL "*"<left><left> let g:vimsuggest_findprg = 'find -EL $* \! \( -regex ".*\.(swp\|git)" -prune \) -type f -name $*' " Using fd: nnoremap <key> :VSFindL<space> let g:vimsuggest_findprg = 'fd --type f' let g:vimsuggest_findprg = 'fd --type f --glob'

5. In-Buffer Search (:h :global)

   :VSGlobal {regex_pattern}

   Use this for a powerful in-buffer search with Vim's regex. For example, to list all functions and classes in a Python file and jump quickly:

   nnoremap <buffer> <key> :VSGlobal \v(^\|\s)(def\|class).{-}

6. Search in Included Files (:h include-search)

   :VSInclSearch {regex_pattern}

   Similar to VSGlobal, but searches for symbols (ignoring comments) in both the current buffer and included files. The results are gathered using the :ilist command.

   Example key mapping:

   nnoremap <key> :VSInclSearch<space>

7. Execute Shell Command

   :VSExec {shell_command}

   This command runs any shell command using your $SHELL environment, allowing features like brace expansion and globbing. Errors are ignored. However, :VSGrep and VSFindL commands are less clunky.

   Example key mappings:

   nnoremap <key> :VSExec fd --type f<space> nnoremap <key> :VSExec grep -RIHins "" . --exclude-dir={.git,"node_*"} --exclude=".*"<c-left><c-left><c-left><left><left> " Easier to type but low performance: nnoremap <key> :VSExec grep -IHins "" **/*<c-left><left><left>

let g:vimsuggest_shell = v:true set shell=/bin/zsh set shellcmdflag=-c

For insert-mode auto-completion, try Vimcomplete.

Open an issue if you encounter problems. Pull requests are welcomed.