codeium.txt

*codeium.txt*  Codeium

GETTING STARTED                                 *codeium*

Run the `:Codeium Auth` command to login to Codeium. This is required to
enable the plugin.

Once logged in, suggested completions will be displayed inline as virtual
text. You can insert a completion by pressing <Tab>.

COMMANDS                                        *:Codeium*

                                                *:Codeium_Auth*
:Codeium Auth           Authenticate to Codeium.

                                                *:Codeium_Chat*
:Codeium Chat           Open Codeium Chat in a browser window

                                                *:Codeium_Disable*
:Codeium Disable        Disable Codeium completions

                                                *:Codeium_Enable*
:Codeium Enable         Re-enable Codeium completions after running :Codeium Disable

                                                *:Codeium_DisableBuffer*
:Codeium DisableBuffer  Disable Codeium completions in the current buffer only.

                                                *:Codeium_EnableBuffer*
:Codeium EnableBuffer   Re-enable Codeium completions in the current
                        buffer after running :Codeium DisableBuffer

                                                *:Codeium_Toggle*
:Codeium Toggle         Enable Codeium completions if they are disabled.
                        Disable Codeium completions if they are enabled. Does
                        NOT enable completions for current buffer, if they are
                        disabled with :Codeium DisableBuffer. However, still
                        affects other buffers.

OPTIONS                                         *codeium-options*

                                                *g:codeium_filetypes*
g:codeium_filetypes     A dictionary mapping whether codeium should be
                        enabled or disabled in certain filetypes. This can
                        be used to opt out of completions for certain filetypes.
>
                        let g:codeium_filetypes = {
                              \ 'bash': v:false,
                              \ 'typescript': v:true,
                              \ }
<

                                                *g:codeium_enabled*
g:codeium_enabled       A global boolean flag that controls whether codeium
                        completions are enabled or disabled by default.
>
                        let g:codeium_enabled = v:true
<

                                                *g:codeium_manual*
g:codeium_manual        If true, codeium completions will never automatically
                        trigger.
>
                        let g:codeium_manual = v:true
<

                                                *g:codeium_no_map_tab*
g:codeium_no_map_tab    A global boolean flag that controls whether codeium
                        uses <TAB> for the mapping codeium#Accept
>
                        let g:codeium_no_map_tab = v:true
<

                                                *g:codeium_idle_delay*
g:codeium_idle_delay    Delay in milliseconds before autocompletions are
                        shown (limited by language server to a minimum of 75).
>
                        let g:codeium_idle_delay = 500
<
                                                *g:codeium_render*
g:codeium_render        A global boolean flag that controls whether codeium
                        renders are enabled or disabled.
>
                        let g:codeium_render = v:false
<

                                                *g:codeium_tab_fallback*
g:codeium_tab_fallback  The fallback key when there is no suggestion display
                        in `codeium#Accept()`.
>
                        let g:codeium_tab_fallback = "\t"
<
                                                *g:codeium_bin*
g:codeium_bin           Manually set the path to the `codeium` language server
                        binary on your system.
                        If unset, `codeium.vim` will fetch and download the
                        binary from the internet.
>
                        let g:codeium_bin = "~/.local/bin/codeium_language_server"
<
                                                *g:codeium_os*
g:codeium_os            Manually set the host OS, accepted values are
                        "Linux", "Darwin", "Windows". if unset, the value will
                        be obtained using `uname`.
>
                        let g:codeium_os = "Linux"
<
                                                *g:codeium_arch*
g:codeium_arch          Manually set the host architecture, accepted values
                        are "x86_64", "aarch64", "arm". If unset, the value
                        will be obtained using `uname -m`.
>
                        let g:codeium_arch = "x86_64"
<
                                                *g:codeium_port_config*
g:codeium_port_config
                        Set the ports the chat client and web server use.
			Pass in web_server and chat_client fields to the mapping to set.
                        Please note that if this option is set, only one
			window will work with codeium.
			It is recommended to set both the web_server and chat_client options
			if using this. 
			If you are setting this because you are using vim remotely and want chat to work
			you will need to forward the two ports you set here, along with port 42100.
			That window can have as many buffers within it, but any other
			opened windows will not be able to use Codeium's features.
>
                        let g:codeium_port_config = {
				'web_server': <Your web server port>,
				'chat_client': <Your chat client port>
				}
<
                                                *g:codeium_virtual_text_priority*
g:codeium_virtual_text_priority
                        The priority used for Codeium's virtual text completions
                        in Neovim. This can control how completions appear when
                        multiple virtual text items are on the same line, such
                        as when using LSP inlay hints.

                        The priority can be set on a per-buffer basis by setting
                        the b:codeium_virtual_text_priority variable. If
                        neither of these are set, the default priority is 65535,
                        which will usually place it above any other virtual text.
>
                        let g:codeium_virtual_text_priority = 1000
<

                                                *b:codeium_virtual_text_priority*
b:codeium_virtual_text_priority
                        The priority given to Codeium's virtual text completions
                        for the current buffer in Neovim. If not set,
                        g:codeium_virtual_text_priority is used.
>
                        let b:codeium_virtual_text_priority = 1000
<

MAPS                                            *codeium-maps*

                                                *codeium-i_<Tab>*
Codeium.vim defaults to using the <Tab> key to insert the current
suggestion. If there is no suggestion display, the <Tab> key will fallback
to any existing <Tab> mapping you have. This is bound to `codeium#Accept()`

Other Maps ~

                                                *codeium-i_CTRL-]*
<C-]>                   Dismiss the current suggestion.
<Plug>(codeium-dismiss)
<Cmd>call codeium#Clear()<CR>

                                                *codeium-i_ALT-]*
<M-]>                   Cycle to the next suggestion.
<Plug>(codeium-next)
<Cmd>call codeium#CycleCompletions(1)<CR>

                                                *codeium-i_ALT-[*
<M-[>                   Cycle to the previous suggestion.
<Plug>(codeium-previous)
<Cmd>call codeium#CycleCompletions(-1)<CR>

SYNTAX HIGHLIGHTING                             *codeium-highlighting*

Inline suggestions are highlighted using the CodeiumSuggestion group,
which defaults to a gray color. You can configure this highlight group for
your colorscheme in after/colors/<colorschemename>.vim in your
'runtimepath' (e.g., ~/.config/nvim/after/colors/solarized.vim).  Example
declaration:
>
        highlight CodeiumSuggestion guifg=#555555 ctermfg=8
<
 vim:tw=78:et:ft=help:norl: