### Full Vimscript Configuration for copilot.vim

Source: https://context7.com/github/copilot.vim/llms.txt

A complete `~/.vimrc` or `init.vim` setup for copilot.vim. This example covers plugin management, various Copilot options (version, proxy, filetypes, workspace roots, idle delay), and key bindings for suggestion acceptance, cycling, and panel access.

```vim
" ~/.vimrc or ~/.config/nvim/init.vim

" --- Plugin manager (vim-plug example) ---
call plug#begin()
  Plug 'github/copilot.vim'
call plug#end()

" --- Copilot options ---

" Use latest language server (or pin: '1.408.0')
let g:copilot_version = 'latest'

" Custom Node.js if system node is too old
" let g:copilot_node_command = "~/.nvm/versions/node/v20.11.0/bin/node"

" GitHub Enterprise (omit for github.com)
" let g:copilot_enterprise_uri = 'https://github.corp.example.com'

" Proxy (omit if not needed)
" let g:copilot_proxy = 'http://proxy.corp.example.com:3128'
" let g:copilot_proxy_strict_ssl = v:false

" Disable for specific filetypes
let g:copilot_filetypes = {
      \ 'xml':      v:false,
      \ 'markdown': v:false,
      \ }

" Workspace roots for better context
let g:copilot_workspace_folders = ["~/Projects/myapp"]

" Custom idle delay (ms)
let g:copilot_idle_delay = 75

" --- Key bindings ---

" Use CTRL-J to accept instead of Tab
imap <silent><script><expr> <C-J> copilot#Accept("\<CR>")
let g:copilot_no_tab_map = v:true

" Word / line partial acceptance
imap <C-L> <Plug>(copilot-accept-word)
imap <C-K> <Plug>(copilot-accept-line)

" Cycle suggestions
imap <C-N> <Plug>(copilot-next)
imap <C-P> <Plug>(copilot-previous)

" Open panel
nnoremap <Leader>cp <Cmd>Copilot panel<CR>

" --- Highlighting ---
autocmd ColorScheme * \
      \ highlight CopilotSuggestion guifg=#6e6e6e ctermfg=244

```

--------------------------------

### Installation

Source: https://context7.com/github/copilot.vim/llms.txt

Instructions for installing the copilot.vim plugin for both Vim and Neovim on Linux, macOS, and Windows, followed by the authentication process.

```APIDOC
## Installation

Install the plugin and authenticate with GitHub Copilot.

```bash
# Vim (Linux/macOS)
git clone --depth=1 https://github.com/github/copilot.vim.git \
  ~/.vim/pack/github/start/copilot.vim

# Neovim (Linux/macOS)
git clone --depth=1 https://github.com/github/copilot.vim.git \
  ~/.config/nvim/pack/github/start/copilot.vim

# Vim (Windows, PowerShell)
git clone --depth=1 https://github.com/github/copilot.vim.git `
  $HOME/vimfiles/pack/github/start/copilot.vim

# Neovim (Windows, PowerShell)
git clone --depth=1 https://github.com/github/copilot.vim.git `
  $HOME/AppData/Local/nvim/pack/github/start/copilot.vim
```

```vim
" After installation, authenticate inside Vim/Neovim:
:Copilot setup
" Follow the prompt: copy the one-time code, press ENTER to open GitHub
" in your browser, paste the code, then return to Vim.
" Expected output: Copilot: Authenticated as GitHub user <username>
```
```

--------------------------------

### pip Build Verification Commands

Source: https://github.com/github/copilot.vim/blob/release/copilot-language-server/dist/assets/agents/CVE_Remediator.agent.md

Examples of pip commands to install requirements or run tests. Use these to verify the project builds and passes tests.

```bash
pip install -r requirements.txt
```

```bash
python -m pytest
```

--------------------------------

### Install and Verify GitHub Copilot Profile via Command Line

Source: https://github.com/github/copilot.vim/blob/release/copilot-language-server/dist/policy-templates/darwin/README.md

Use the `profiles` command to install, verify, and remove the GitHub Copilot configuration profile. Ensure you have administrator privileges for installation and removal.

```bash
# Install the profile
sudo profiles -I -F IDEGitHubCopilot.mobileconfig

# Verify installation
profiles -P

# Remove the profile (if needed)
sudo profiles -R -p IDEGitHubCopilot
```

--------------------------------

### Install copilot.vim Plugin

Source: https://context7.com/github/copilot.vim/llms.txt

Clone the repository to the appropriate plugin directory for Vim or Neovim on Linux, macOS, or Windows.

```bash
git clone --depth=1 https://github.com/github/copilot.vim.git \
  ~/.vim/pack/github/start/copilot.vim
```

```bash
git clone --depth=1 https://github.com/github/copilot.vim.git \
  ~/.config/nvim/pack/github/start/copilot.vim
```

```bash
git clone --depth=1 https://github.com/github/copilot.vim.git `
  $HOME/vimfiles/pack/github/start/copilot.vim
```

```bash
git clone --depth=1 https://github.com/github/copilot.vim.git `
  $HOME/AppData/Local/nvim/pack/github/start/copilot.vim
```

--------------------------------

### Clone copilot.vim for Neovim (Linux/macOS)

Source: https://github.com/github/copilot.vim/blob/release/README.md

Manually install the copilot.vim plugin for Neovim on Linux or macOS systems.

```bash
git clone --depth=1 https://github.com/github/copilot.vim.git \
  ~/.config/nvim/pack/github/start/copilot.vim
```

--------------------------------

### npm Build Command

Source: https://github.com/github/copilot.vim/blob/release/copilot-language-server/dist/assets/agents/CVE_Remediator.agent.md

Example npm command to build or test the project. Adapt based on your project's `package.json` scripts.

```bash
npm run build
```

```bash
npm test
```

--------------------------------

### npm List Direct Dependencies

Source: https://github.com/github/copilot.vim/blob/release/copilot-language-server/dist/assets/agents/CVE_Remediator.agent.md

Use this npm command to list all direct dependencies installed in the project.

```bash
npm ls --depth=0
```

--------------------------------

### Execute Policy Templates Installation Script (PowerShell)

Source: https://github.com/github/copilot.vim/blob/release/copilot-language-server/dist/policy-templates/win32/README.md

Run this PowerShell script after navigating to the policy templates directory to automate their installation. Requires Administrator privileges.

```powershell
.\Install-PolicyTemplates.ps1
```

--------------------------------

### Maven Build Commands

Source: https://github.com/github/copilot.vim/blob/release/copilot-language-server/dist/assets/agents/CVE_Remediator.agent.md

Examples of Maven commands to clean, compile, test, or verify the project. Choose the command appropriate for your build stage.

```bash
mvn clean compile
```

```bash
mvn clean test
```

```bash
mvn clean verify
```

--------------------------------

### Clone copilot.vim for Vim (Linux/macOS)

Source: https://github.com/github/copilot.vim/blob/release/README.md

Manually install the copilot.vim plugin for Vim on Linux or macOS systems.

```bash
git clone --depth=1 https://github.com/github/copilot.vim.git \
  ~/.vim/pack/github/start/copilot.vim
```

--------------------------------

### Full Lua Configuration for copilot.vim (Neovim)

Source: https://context7.com/github/copilot.vim/llms.txt

A complete `init.lua` configuration for copilot.vim using lazy.nvim. This example sets up the language server version, custom key mappings for suggestion acceptance and cycling, filetype control, workspace folders, idle delay, and highlight overrides.

```lua
-- ~/.config/nvim/lua/plugins/copilot.lua  (lazy.nvim spec)
return {
  'github/copilot.vim',
  event = 'InsertEnter',
  config = function()
    -- Language server version
    vim.g.copilot_version = 'latest'

    -- Disable Tab mapping; use CTRL-J instead
    vim.g.copilot_no_tab_map = true
    vim.keymap.set('i', '<C-J>', 'copilot#Accept("\<CR>")', {
      expr = true,
      replace_keycodes = false,
      silent = true,
      desc = 'Copilot: accept suggestion',
    })

    -- Partial acceptance
    vim.keymap.set('i', '<C-L>', '<Plug>(copilot-accept-word)',
      { desc = 'Copilot: accept next word' })
    vim.keymap.set('i', '<C-K>', '<Plug>(copilot-accept-line)',
      { desc = 'Copilot: accept next line' })

    -- Cycle
    vim.keymap.set('i', '<C-N>', '<Plug>(copilot-next)',
      { desc = 'Copilot: next suggestion' })
    vim.keymap.set('i', '<C-P>', '<Plug>(copilot-previous)',
      { desc = 'Copilot: previous suggestion' })

    -- Panel
    vim.keymap.set('n', '<Leader>cp', '<Cmd>Copilot panel<CR>',
      { desc = 'Copilot: open panel' })

    -- Filetype control
    vim.g.copilot_filetypes = {
      xml      = false,
      markdown = false,
    }

    -- Workspace folders
    vim.g.copilot_workspace_folders = {
      vim.fn.expand('~/Projects/myapp'),
    }

    -- Idle delay
    vim.g.copilot_idle_delay = 75

    -- Highlight override
    vim.api.nvim_create_autocmd('ColorScheme', {
      pattern = '*', 
      callback = function()
        vim.api.nvim_set_hl(0, 'CopilotSuggestion', {
          fg = '#6e6e6e', ctermfg = 244, force = true,
        })
      end,
    })
  end,
}

```

--------------------------------

### Authenticate Copilot in Vim/Neovim

Source: https://context7.com/github/copilot.vim/llms.txt

Run the :Copilot setup command within your Vim or Neovim instance and follow the on-screen prompts to authenticate with your GitHub account.

```vim
" After installation, authenticate inside Vim/Neovim:
:Copilot setup
" Follow the prompt: copy the one-time code, press ENTER to open GitHub
" in your browser, paste the code, then return to Vim.
" Expected output: Copilot: Authenticated as GitHub user <username>
```

--------------------------------

### Navigate to Policy Templates Directory (PowerShell)

Source: https://github.com/github/copilot.vim/blob/release/copilot-language-server/dist/policy-templates/win32/README.md

Use this command in PowerShell to navigate to the directory where the policy templates are installed. Ensure you replace '[Language Server Installation Directory]' with the actual path.

```powershell
cd "[Language Server Installation Directory]\policy-templates\win32"
```

--------------------------------

### Clone copilot.vim for Neovim (Windows PowerShell)

Source: https://github.com/github/copilot.vim/blob/release/README.md

Manually install the copilot.vim plugin for Neovim on Windows systems using PowerShell.

```powershell
git clone --depth=1 https://github.com/github/copilot.vim.git `
  $HOME/AppData/Local/nvim/pack/github/start/copilot.vim
```

--------------------------------

### Cycle Copilot Suggestions (Vimscript/Lua)

Source: https://context7.com/github/copilot.vim/llms.txt

Use `copilot#Next()` and `copilot#Previous()` to cycle through multiple suggestions. Default bindings are provided, along with custom Vimscript and Lua examples for Neovim.

```vim
" Default bindings (set automatically if the meta keys are free):
"   imap <M-]> <Plug>(copilot-next)
"   imap <M-[> <Plug>(copilot-previous)

" Custom bindings — Vimscript:
imap <C-N> <Plug>(copilot-next)
imap <C-P> <Plug>(copilot-previous)

" Custom bindings — Lua (Neovim):
vim.keymap.set('i', '<C-N>', '<Plug>(copilot-next)')
vim.keymap.set('i', '<C-P>', '<Plug>(copilot-previous)')

" Programmatic use:
call copilot#Next()      " advances to next suggestion
call copilot#Previous()  " returns to previous suggestion
```

--------------------------------

### Clone copilot.vim for Vim (Windows PowerShell)

Source: https://github.com/github/copilot.vim/blob/release/README.md

Manually install the copilot.vim plugin for Vim on Windows systems using PowerShell.

```powershell
git clone --depth=1 https://github.com/github/copilot.vim.git `
  $HOME/vimfiles/pack/github/start/copilot.vim
```

--------------------------------

### Copy ADMX File for Manual Installation

Source: https://github.com/github/copilot.vim/blob/release/copilot-language-server/dist/policy-templates/win32/README.md

Manually copy the ADMX file to the central policy definitions directory. This is part of the manual installation process for Group Policy templates.

```cmd
Copy IDEGitHubCopilot.admx to C:\Windows\PolicyDefinitions\
```

--------------------------------

### Open Copilot Multi-Completion Panel (Vimscript/Lua)

Source: https://context7.com/github/copilot.vim/llms.txt

The `:Copilot panel` command opens a split window displaying up to 10 alternative completions. Examples show how to open it in different splits, use it programmatically, and configure keybindings in Vimscript and Lua.

```vim
" Open the panel (uses the current line/cursor position):
:Copilot panel

" Open in a vertical split:
:vertical Copilot panel

" Open in a new tab:
:tab Copilot panel

" Inside the panel buffer:
"   <CR>  — accept the completion under the cursor
"   [[    — jump to the previous completion
"   ]]    — jump to the next completion
"   :q    — close the panel

" Programmatic open (from a keybind):
nnoremap <Leader>cp <Cmd>Copilot panel<CR>

" Lua (Neovim):
vim.keymap.set('n', '<Leader>cp', '<Cmd>Copilot panel<CR>')
```

--------------------------------

### pip Show Specific Package

Source: https://github.com/github/copilot.vim/blob/release/copilot-language-server/dist/assets/agents/CVE_Remediator.agent.md

Use this pip command to display detailed information about a specific installed package.

```bash
pip show <package-name>
```

--------------------------------

### Copy ADML File for Manual Installation

Source: https://github.com/github/copilot.vim/blob/release/copilot-language-server/dist/policy-templates/win32/README.md

Manually copy the ADML language resource file to the appropriate language subfolder within the policy definitions directory. This is part of the manual installation process.

```cmd
Copy en-US\IDEGitHubCopilot.adml to C:\Windows\PolicyDefinitions\en-US\
```

--------------------------------

### Manually Trigger or Dismiss Copilot Suggestions (Vimscript/Lua)

Source: https://context7.com/github/copilot.vim/llms.txt

Use `copilot#Suggest()` to explicitly request a suggestion and `copilot#Dismiss()` to clear it. Examples show default bindings, custom Vimscript, and Lua configurations for Neovim.

```vim
" Default bindings:
"   imap <M-\\> <Plug>(copilot-suggest)   " explicit request
"   imap <C-]>> <Plug>(copilot-dismiss)   " dismiss

" Custom bindings — Vimscript:
imap <C-\\> <Plug>(copilot-suggest)
imap <C-X> <Plug>(copilot-dismiss)

" Custom bindings — Lua (Neovim):
vim.keymap.set('i', '<C-\\>', '<Plug>(copilot-suggest)')
vim.keymap.set('i', '<C-X>',  '<Plug>(copilot-dismiss)')

" Programmatic use:
call copilot#Suggest()   " trigger immediately
call copilot#Dismiss()   " clear ghost text + cancel pending requests
```

--------------------------------

### Specify Custom Node.js Binary (Vimscript/Lua)

Source: https://context7.com/github/copilot.vim/llms.txt

Use `g:copilot_node_command` to specify the Node.js binary path when the system's Node.js is too old (minimum Node.js 18). Examples show setting paths for nodenv and nvm.

```vim
" Use a specific nodenv-managed version:
let g:copilot_node_command = "~/.nodenv/versions/20.11.0/bin/node"

" Use nvm-managed Node.js (expand the path explicitly):
let g:copilot_node_command = expand("~/.nvm/versions/node/v20.11.0/bin/node")

" Lua (Neovim):
vim.g.copilot_node_command = vim.fn.expand("~/.nvm/versions/node/v20.11.0/bin/node")
```

--------------------------------

### Configure Per-Filetype Enable/Disable (Vimscript/Lua)

Source: https://context7.com/github/copilot.vim/llms.txt

The `g:copilot_filetypes` dictionary controls which filetypes receive inline suggestions. Most are enabled by default, but Git-related filetypes are disabled. Examples show disabling specific filetypes or enabling only a subset.

```vim
" Disable suggestions for XML and Markdown only:
let g:copilot_filetypes = {
      \ 'xml':      v:false,
      \ 'markdown': v:false,
      \ }

" Disable ALL filetypes, then selectively re-enable Python and Go:
let g:copilot_filetypes = {
      \ '*':      v:false,
      \ 'python': v:true,
      \ 'go':     v:true,
      \ }

" Lua (Neovim) equivalent:
vim.g.copilot_filetypes = {
  xml      = false,
  markdown = false,
}

" Per-buffer override (overrides g:copilot_filetypes):
let b:copilot_enabled = v:false   " disable for this buffer
let b:copilot_enabled = v:true    " force-enable even if filetype is disabled
```

--------------------------------

### pipdeptree JSON Output

Source: https://github.com/github/copilot.vim/blob/release/copilot-language-server/dist/assets/agents/CVE_Remediator.agent.md

Use this command to get a JSON representation of the project's dependency tree, useful for parsing.

```bash
pipdeptree --json
```

--------------------------------

### Highlight Copilot Suggestions (Lua)

Source: https://github.com/github/copilot.vim/blob/release/doc/copilot.txt

Override the default highlighting for Copilot suggestions using Lua. This example sets the foreground color for the 'solarized' ColorScheme.

```lua
vim.api.nvim_create_autocmd('ColorScheme', {
  pattern = 'solarized',
  -- group = ...,
  callback = function()
    vim.api.nvim_set_hl(0, 'CopilotSuggestion', {
      fg = '#555555',
      ctermfg = 8,
      force = true
    })
  end
})
```

--------------------------------

### Highlight Copilot Suggestions (Vimscript)

Source: https://github.com/github/copilot.vim/blob/release/doc/copilot.txt

Override the default highlighting for Copilot suggestions using an autocommand. This example sets the foreground color for the 'solarized' ColorScheme.

```vimscript
autocmd ColorScheme solarized
      \ highlight CopilotSuggestion guifg=#555555 ctermfg=8
```

--------------------------------

### Inspect Current Copilot Suggestion (Vimscript/Lua)

Source: https://context7.com/github/copilot.vim/llms.txt

The `copilot#GetDisplayedSuggestion()` function returns details about the current inline suggestion. This is useful for custom statusline integrations or conditional mappings. Examples show Vimscript and Lua usage.

```vim
" Returns: { 'item': {}, 'text': '', 'outdentSize': 0, 'deleteSize': 0, 'deleteChars': '' }
" 'text' is empty when no suggestion is shown.

function! MyStatusline() abort
  let s = copilot#GetDisplayedSuggestion()
  if !empty(s.text)
    return '🤖 ' . substitute(s.text, "\n.*", '…', '')
  endif
  return ''
endfunction

" Lua equivalent (Neovim):
vim.api.nvim_create_autocmd('CursorMovedI', {
  callback = function()
    local s = vim.fn['copilot#GetDisplayedSuggestion']()
    if s.text ~= '' then
      vim.notify('Copilot: ' .. s.text:gsub('\n.*', '…'), vim.log.levels.INFO)
    end
  end
})
```

--------------------------------

### Specify Node.js Binary for Copilot

Source: https://github.com/github/copilot.vim/blob/release/doc/copilot.txt

Define the path to the Node.js binary if the default one in your PATH is an unsupported version.

```vimscript
let g:copilot_node_command =
      \ "~/.nodenv/versions/18.18.0/bin/node"
```

--------------------------------

### Configure Copilot Workspace Folders

Source: https://github.com/github/copilot.vim/blob/release/doc/copilot.txt

Provide a list of workspace folders or project roots to improve suggestion quality. New folders can be added automatically by setting b:workspace_folder for a buffer.

```vimscript
let g:copilot_workspace_folders =
       \ ["~/Projects/myproject"]
```

--------------------------------

### Custom Key Mapping to Accept Copilot Suggestion (Vimscript)

Source: https://github.com/github/copilot.vim/blob/release/doc/copilot.txt

Map a custom key (e.g., CTRL-J) to accept the current suggestion using copilot#Accept(). The argument to copilot#Accept() is the fallback when no suggestion is displayed.

```vimscript
imap <silent><script><expr> <C-J> copilot#Accept("\<CR>")
let g:copilot_no_tab_map = v:true
```

--------------------------------

### Enable Extension-Contributed MCP Servers (Registry Test - Machine)

Source: https://github.com/github/copilot.vim/blob/release/copilot-language-server/dist/policy-templates/win32/README.md

Use this command in the command prompt to directly add or update a registry value, enabling extension-contributed MCP servers system-wide. '/f' forces the update.

```cmd
reg add "HKLM\SOFTWARE\Policies\Microsoft\IDEGitHubCopilot" /v "mcp.contributionPoint.enabled" /t REG_DWORD /d 1 /f
```

--------------------------------

### Configure Copilot Proxy Settings

Source: https://context7.com/github/copilot.vim/llms.txt

Configures an HTTP/HTTPS proxy for the language server. Falls back to $HTTPS_PROXY / $HTTP_PROXY if unset. Disabling strict SSL accommodates corporate MITM SSL certificates.

```vim
" Set an explicit proxy:
let g:copilot_proxy = 'http://proxy.corp.example.com:3128'

" Shorthand (scheme is prepended automatically):
let g:copilot_proxy = 'proxy.corp.example.com:3128'

" Disable strict SSL for corporate MITM proxies:
let g:copilot_proxy_strict_ssl = v:false

" Alternative: use the Node.js environment variable approach:
" export NODE_TLS_REJECT_UNAUTHORIZED=0

" Lua (Neovim):
vim.g.copilot_proxy            = 'http://proxy.corp.example.com:3128'
vim.g.copilot_proxy_strict_ssl = false
```

--------------------------------

### Accept One Line with copilot#AcceptLine()

Source: https://context7.com/github/copilot.vim/llms.txt

Employ copilot#AcceptLine() to accept the next line of an inline suggestion. It can be mapped to custom keys and supports a fallback value.

```vim
" Default binding (set automatically if <M-C-Right> is free):
"   imap <M-C-Right> <Plug>(copilot-accept-line)

" Custom binding — Vimscript:
imap <C-K> <Plug>(copilot-accept-line)

" Custom binding — Lua (Neovim):
vim.keymap.set('i', '<C-K>', '<Plug>(copilot-accept-line)')

" Direct function call (fallback = empty string = do nothing):
imap <silent><script><expr> <C-K> copilot#AcceptLine("")
```

--------------------------------

### Configure GitHub Enterprise URI for Copilot

Source: https://context7.com/github/copilot.vim/llms.txt

Routes authentication and API calls to a self-hosted GitHub Enterprise Server instance instead of github.com.

```vim
" Point to your GHE instance:
let g:copilot_enterprise_uri = 'https://github.corp.example.com'

" Lua (Neovim):
vim.g.copilot_enterprise_uri = 'https://github.corp.example.com'

" Then run the normal setup flow:
" :Copilot setup
```

--------------------------------

### Accept One Word with copilot#AcceptWord()

Source: https://context7.com/github/copilot.vim/llms.txt

Utilize copilot#AcceptWord() for partial acceptance of inline suggestions, accepting only the next word. This can be mapped to a custom key.

```vim
" Default binding (set automatically if <M-Right> is free):
"   imap <M-Right> <Plug>(copilot-accept-word)

" Custom binding — Vimscript:
imap <C-L> <Plug>(copilot-accept-word)

" Custom binding — Lua (Neovim):
vim.keymap.set('i', '<C-L>', '<Plug>(copilot-accept-word)')

" Direct function call (e.g. with a custom fallback):
imap <silent><script><expr> <C-L> copilot#AcceptWord("\t")
```

--------------------------------

### Accept Inline Suggestion with copilot#Accept()

Source: https://context7.com/github/copilot.vim/llms.txt

Use copilot#Accept() in an insert-mode map to accept the current inline suggestion. It defaults to Tab or a specified fallback when no suggestion is present.

```vim
" Default: Tab accepts the suggestion (set up automatically by the plugin)
" The plugin installs this mapping unless g:copilot_no_tab_map is set:
"   imap <silent><script><nowait><expr> <Tab> copilot#Accept()

" Custom key (CTRL-J) instead of Tab — Vimscript:
imap <silent><script><expr> <C-J> copilot#Accept("\<CR>")
let g:copilot_no_tab_map = v:true

" Custom key — Lua (Neovim):
vim.keymap.set('i', '<C-J>', 'copilot#Accept("\\<CR>")', {
  expr = true,
  replace_keycodes = false
})
vim.g.copilot_no_tab_map = true

" Use empty string fallback to do nothing when no suggestion is shown:
imap <silent><script><expr> <C-J> copilot#Accept("")
```

--------------------------------

### Configure Copilot Proxy Server

Source: https://github.com/github/copilot.vim/blob/release/doc/copilot.txt

Specify the proxy server for Copilot to use. If not set, environment variables like $HTTPS_PROXY will be used.

```vimscript
let g:copilot_proxy = 'http://localhost:3128'
```

--------------------------------

### Set Copilot Workspace Folders

Source: https://context7.com/github/copilot.vim/llms.txt

Provides Copilot with project root paths to improve suggestion quality by giving the model more context about the codebase structure. Globs are resolved.

```vim
" Single project:
let g:copilot_workspace_folders = ["~/Projects/myapp"]

" Multiple projects (globs are resolved):
let g:copilot_workspace_folders = [
      \ "~/Projects/frontend",
      \ "~/Projects/backend",
      \ ]

" Per-buffer workspace folder (auto-registered when newly seen):
let b:workspace_folder = getcwd()

" Lua (Neovim):
vim.g.copilot_workspace_folders = {
  vim.fn.expand("~/Projects/myapp"),
}
```

--------------------------------

### Multi-Completion Panel

Source: https://context7.com/github/copilot.vim/llms.txt

Open a panel displaying multiple alternative completions for the current cursor position. Allows accepting, navigating, and dismissing suggestions.

```APIDOC
## `:Copilot panel` — Multi-Completion Panel

Opens a split window showing up to 10 alternative completions for the current cursor position. Use `<CR>` to accept a completion, `[[` / `]]` to jump between them.

### Usage:
```vim
:Copilot panel
:vertical Copilot panel
:tab Copilot panel
```

### Inside the panel buffer:
*   `<CR>` — accept the completion under the cursor
*   `[[` — jump to the previous completion
*   `]]` — jump to the next completion
*   `:q` — close the panel
```

--------------------------------

### Custom Key Mapping to Accept Copilot Suggestion (Lua)

Source: https://github.com/github/copilot.vim/blob/release/doc/copilot.txt

Map a custom key (e.g., CTRL-J) to accept the current suggestion using copilot#Accept(). The argument to copilot#Accept() is the fallback when no suggestion is displayed. Set copilot_no_tab_map to true to disable the default Tab mapping.

```lua
vim.keymap.set('i', '<C-J>', 'copilot#Accept("\<CR>")', {
  expr = true,
  replace_keycodes = false
})
vim.g.copilot_no_tab_map = true
```

--------------------------------

### copilot#Accept([fallback])

Source: https://context7.com/github/copilot.vim/llms.txt

Function to accept the currently displayed inline suggestion. It can be mapped to a key and accepts an optional fallback.

```APIDOC
## `copilot#Accept([fallback])` — Accept Inline Suggestion

Inserts the currently displayed inline suggestion. Designed for use in an `<expr>` insert-mode map. When no suggestion is shown, `fallback` is returned instead (defaults to `<Tab>` or the original tab map).

```vim
" Default: Tab accepts the suggestion (set up automatically by the plugin)
" The plugin installs this mapping unless g:copilot_no_tab_map is set:
"   imap <silent><script><nowait><expr> <Tab> copilot#Accept()

" Custom key (CTRL-J) instead of Tab — Vimscript:
imap <silent><script><expr> <C-J> copilot#Accept("\<CR>")
let g:copilot_no_tab_map = v:true

" Custom key — Lua (Neovim):
vim.keymap.set('i', '<C-J>', 'copilot#Accept("\\<CR>")', {
  expr = true,
  replace_keycodes = false
})
vim.g.copilot_no_tab_map = true

" Use empty string fallback to do nothing when no suggestion is shown:
imap <silent><script><expr> <C-J> copilot#Accept("")
```
```

--------------------------------

### Per-Filetype Enable/Disable

Source: https://context7.com/github/copilot.vim/llms.txt

Configure which filetypes receive inline suggestions. Allows enabling or disabling Copilot for specific file types.

```APIDOC
## `g:copilot_filetypes` — Per-Filetype Enable/Disable

A dictionary controlling which filetypes receive inline suggestions. Most filetypes are enabled by default. Git commit messages, `gitrebase`, `hgcommit`, `svn`, and `cvs` are disabled by default.

### Configuration examples:
```vim
" Disable suggestions for XML and Markdown only:
let g:copilot_filetypes = {
      \ 'xml':      v:false,
      \ 'markdown': v:false,
      \ }

" Disable ALL filetypes, then selectively re-enable Python and Go:
let g:copilot_filetypes = {
      \ '*':      v:false,
      \ 'python': v:true,
      \ 'go':     v:true,
      \ }
```

### Per-buffer override:
```vim
let b:copilot_enabled = v:false   " disable for this buffer
let b:copilot_enabled = v:true    " force-enable even if filetype is disabled
```
```

--------------------------------

### Set Copilot Language Server Version

Source: https://context7.com/github/copilot.vim/llms.txt

Controls which version of the language server is fetched. Accepts semver constraints, 'latest', or false to use the bundled static copy.

```vim
" Always use the latest available language server (fetched at startup):
let g:copilot_version = 'latest'

" Pin to an exact version:
let g:copilot_version = '1.408.0'

" Use a semver range (default behaviour is a minor-pinned range like '^1.400.0'):
let g:copilot_version = '^1.400.0'

" Disable npx entirely; use only the static server bundled inside the plugin:
let g:copilot_version = v:false

" Lua (Neovim):
vim.g.copilot_version = 'latest'
-- or:
vim.g.copilot_version = false
```

--------------------------------

### Configure Additional Copilot LSP Settings

Source: https://context7.com/github/copilot.vim/llms.txt

A dictionary merged into the workspace/didChangeConfiguration payload sent to the language server. Used to select completion models or pass other server-side settings.

```vim
" Select a specific completion model by ID (use :Copilot model for interactive selection):
let g:copilot_settings = {'selectedCompletionModel': 'gpt-4o-copilot'}

" Extend with arbitrary server settings:
let g:copilot_settings = {
      \ 'selectedCompletionModel': 'gpt-4o-copilot',
      \ }

" Lua (Neovim):
vim.g.copilot_settings = {
  selectedCompletionModel = 'gpt-4o-copilot',
}
```

--------------------------------

### npm List Specific Dependency

Source: https://github.com/github/copilot.vim/blob/release/copilot-language-server/dist/assets/agents/CVE_Remediator.agent.md

Use this npm command to check the version and status of a specific package.

```bash
npm ls <package-name>
```

--------------------------------

### Configure GitHub Copilot Enterprise URI

Source: https://github.com/github/copilot.vim/blob/release/doc/copilot.txt

Set the URI for your GitHub Enterprise instance if you are using GitHub Copilot Enterprise.

```vimscript
let g:copilot_enterprise_uri = 'https://DOMAIN.ghe.com'
```

--------------------------------

### Check Managed Preferences for GitHub Copilot

Source: https://github.com/github/copilot.vim/blob/release/copilot-language-server/dist/policy-templates/darwin/README.md

Verify the current GitHub Copilot policy settings by checking the managed preferences file. This command is useful for confirming that policies have been applied correctly.

```bash
# Check managed preferences
defaults read /Library/Managed\ Preferences/IDEGitHubCopilot 2>/dev/null || echo "No managed settings found"
```

--------------------------------

### Maven Dependency Tree Command

Source: https://github.com/github/copilot.vim/blob/release/copilot-language-server/dist/assets/agents/CVE_Remediator.agent.md

Use this Maven command to list all direct dependencies of a project. Adapt the filtering for specific names.

```bash
mvn dependency:tree
```

--------------------------------

### Custom Node.js Binary

Source: https://context7.com/github/copilot.vim/llms.txt

Specify a custom Node.js binary to be used by the Copilot language server. Necessary when the system's Node.js version is below the minimum requirement.

```APIDOC
## `g:copilot_node_command` — Custom Node.js Binary

Tells the plugin which `node` binary to use when spawning the language server. Required when the system Node.js is too old (minimum: Node.js 18).

### Configuration examples:
```vim
" Use a specific nodenv-managed version:
let g:copilot_node_command = "~/.nodenv/versions/20.11.0/bin/node"

" Use nvm-managed Node.js (expand the path explicitly):
let g:copilot_node_command = expand("~/.nvm/versions/node/v20.11.0/bin/node")
```
```

--------------------------------

### Copilot Command Reference

Source: https://context7.com/github/copilot.vim/llms.txt

Execute various Copilot commands directly from the Vim/Neovim command line for status checks, configuration, and debugging.

```vim
" Check operational status for the current buffer
:Copilot status
" → Copilot: Ready
```

```vim
" Globally disable / re-enable inline suggestions
:Copilot disable
:Copilot enable
```

```vim
" Sign out of GitHub Copilot
:Copilot signout
```

```vim
" Show plugin, editor, language server, and Node.js version info
:Copilot version
" → copilot.vim 1.59.0
" → Neovim 0.10.1
" → GitHub Copilot Language Server 1.408.0
" → Node.js 20.11.0
```

```vim
" Restart the language server process
:Copilot restart
```

```vim
" Upgrade the bundled language server to the latest via npx
:Copilot upgrade
```

```vim
" Open the Copilot log buffer for debugging
:Copilot log
```

```vim
" Select an alternate completion model (if available on your subscription)
:Copilot model
```

```vim
" Open inline help
:Copilot help
:Copilot help panel   " jump to a specific section
```

--------------------------------

### Override Copilot Syntax Highlighting

Source: https://context7.com/github/copilot.vim/llms.txt

Customize the highlight groups for ghost-text suggestions and cycling annotations to integrate with your color theme.

```vim
" Vimscript — override for the 'solarized' colorscheme:
autocmd ColorScheme solarized
      \ highlight CopilotSuggestion guifg=#555555 ctermfg=8

" Vimscript — override for all colorschemes:
autocmd ColorScheme *
      \ highlight CopilotSuggestion guifg=#6e6e6e ctermfg=244
      \ | highlight CopilotAnnotation guifg=#4e9a06 ctermfg=2

" Lua (Neovim) — override for a specific colorscheme:
vim.api.nvim_create_autocmd('ColorScheme', {
  pattern = 'catppuccin',
  callback = function()
    vim.api.nvim_set_hl(0, 'CopilotSuggestion', {
      fg = '#585b70',
      ctermfg = 8,
      force = true,
    })
    vim.api.nvim_set_hl(0, 'CopilotAnnotation', {
      fg = '#a6e3a1',
      force = true,
    })
  end,
})
```

--------------------------------

### Map CTRL-L to Accept One Word of Suggestion (Vimscript)

Source: https://github.com/github/copilot.vim/blob/release/doc/copilot.txt

Map CTRL-L to accept one word of the current suggestion using the <Plug>(copilot-accept-word) map.

```vimscript
imap <C-L> <Plug>(copilot-accept-word)
```

--------------------------------

### Configure Copilot Filetype Enablement

Source: https://github.com/github/copilot.vim/blob/release/doc/copilot.txt

Manage which file types Copilot is enabled for. By default, most are enabled. Use this to opt-out of specific file types or to enable only specific ones.

```vimscript
let g:copilot_filetypes = {
      \ 'xml': v:false,
      \ }
```

```vimscript
let g:copilot_filetypes = {
      \ '*': v:false,
      \ 'python': v:true,
      \ }
```

--------------------------------

### Map CTRL-L to Accept One Word of Suggestion (Lua)

Source: https://github.com/github/copilot.vim/blob/release/doc/copilot.txt

Map CTRL-L to accept one word of the current suggestion using the <Plug>(copilot-accept-word) map.

```lua
vim.keymap.set('i', '<C-L>', '<Plug>(copilot-accept-word)')
```

--------------------------------

### copilot#AcceptLine([fallback])

Source: https://context7.com/github/copilot.vim/llms.txt

Function to accept only the next line of the current inline suggestion.

```APIDOC
## `copilot#AcceptLine([fallback])` — Accept One Line

Accepts only the next line of the current inline suggestion.

```vim
" Default binding (set automatically if <M-C-Right> is free):
"   imap <M-C-Right> <Plug>(copilot-accept-line)

" Custom binding — Vimscript:
imap <C-K> <Plug>(copilot-accept-line)

" Custom binding — Lua (Neovim):
vim.keymap.set('i', '<C-K>', '<Plug>(copilot-accept-line)')

" Direct function call (fallback = empty string = do nothing):
imap <silent><script><expr> <C-K> copilot#AcceptLine("")
```
```

--------------------------------

### Maven Dependency List Command

Source: https://github.com/github/copilot.vim/blob/release/copilot-language-server/dist/assets/agents/CVE_Remediator.agent.md

Use this Maven command to list direct dependencies, excluding transitive ones. This is an alternative to `dependency:tree`.

```bash
mvn dependency:list -DexcludeTransitive=true
```

--------------------------------

### Disable Extension-Contributed MCP Servers (Registry Test - User)

Source: https://github.com/github/copilot.vim/blob/release/copilot-language-server/dist/policy-templates/win32/README.md

Use this command in the command prompt to directly add or update a registry value, disabling extension-contributed MCP servers for the current user. '/f' forces the update.

```cmd
reg add "HKCU\SOFTWARE\Policies\Microsoft\IDEGitHubCopilot" /v "mcp.contributionPoint.enabled" /t REG_DWORD /d 0 /f
```

--------------------------------

### copilot#AcceptWord([fallback])

Source: https://context7.com/github/copilot.vim/llms.txt

Function to accept only the next word of the current inline suggestion, allowing for partial acceptance.

```APIDOC
## `copilot#AcceptWord([fallback])` — Accept One Word

Accepts only the next word of the current inline suggestion, leaving the rest of the suggestion visible for further partial acceptance.

```vim
" Default binding (set automatically if <M-Right> is free):
"   imap <M-Right> <Plug>(copilot-accept-word)

" Custom binding — Vimscript:
imap <C-L> <Plug>(copilot-accept-word)

" Custom binding — Lua (Neovim):
vim.keymap.set('i', '<C-L>', '<Plug>(copilot-accept-word)')

" Direct function call (e.g. with a custom fallback):
imap <silent><script><expr> <C-L> copilot#AcceptWord("\t")
```
```

--------------------------------

### :Copilot Command

Source: https://context7.com/github/copilot.vim/llms.txt

Overview of the `:Copilot` command, which serves as the primary interface for managing GitHub Copilot functionality within Vim/Neovim.

```APIDOC
## `:Copilot` Command

The single entry point for all Copilot sub-commands. Tab-completion is supported.

```vim
" Check operational status for the current buffer
:Copilot status
" → Copilot: Ready

" Globally disable / re-enable inline suggestions
:Copilot disable
:Copilot enable

" Sign out of GitHub Copilot
:Copilot signout

" Show plugin, editor, language server, and Node.js version info
:Copilot version
" → copilot.vim 1.59.0
" → Neovim 0.10.1
" → GitHub Copilot Language Server 1.408.0
" → Node.js 20.11.0

" Restart the language server process
:Copilot restart

" Upgrade the bundled language server to the latest via npx
:Copilot upgrade

" Open the Copilot log buffer for debugging
:Copilot log

" Select an alternate completion model (if available on your subscription)
:Copilot model

" Open inline help
:Copilot help
:Copilot help panel   " jump to a specific section
```
```

--------------------------------

### Cycle Suggestions

Source: https://context7.com/github/copilot.vim/llms.txt

Cycle through multiple suggestions provided by Copilot. This function requests additional completions and allows navigation between them.

```APIDOC
## `copilot#Next()` / `copilot#Previous()` — Cycle Suggestions

Requests additional completions from the server and cycles through them. The annotation `(2/5)` in ghost text reflects position in the list.

### Programmatic use:
```vim
call copilot#Next()
call copilot#Previous()
```
```

--------------------------------

### Set Copilot Version Constraint

Source: https://github.com/github/copilot.vim/blob/release/doc/copilot.txt

Specify a version constraint for the Copilot Language Server. Use 'latest' to always fetch the newest version or v:false to use a static embedded version.

```vimscript
let g:copilot_version = 'latest'
```

```vimscript
let g:copilot_version = v:false
```

--------------------------------

### Manual Trigger / Dismiss

Source: https://context7.com/github/copilot.vim/llms.txt

Manually trigger a Copilot suggestion or dismiss the current suggestion and cancel pending requests.

```APIDOC
## `copilot#Suggest()` / `copilot#Dismiss()` — Manual Trigger / Dismiss

`copilot#Suggest()` explicitly requests a suggestion even when the plugin is disabled for the current buffer. `copilot#Dismiss()` clears any visible suggestion and cancels pending requests.

### Programmatic use:
```vim
call copilot#Suggest()
call copilot#Dismiss()
```
```

--------------------------------

### Set Copilot Suggestion Trigger Delay

Source: https://context7.com/github/copilot.vim/llms.txt

Controls the delay in milliseconds after the last cursor movement before firing a textDocument/inlineCompletion request. Default is 45 ms.

```vim
" Increase delay to reduce request frequency on slow connections:
let g:copilot_idle_delay = 200

" Decrease for faster response (higher server load):
let g:copilot_idle_delay = 0

" Lua (Neovim):
vim.g.copilot_idle_delay = 150
```

--------------------------------

### Intune OMA-URI Setting for MCP Servers

Source: https://github.com/github/copilot.vim/blob/release/copilot-language-server/dist/policy-templates/win32/README.md

This configuration is used within a Microsoft Intune Custom Configuration Profile to manage the 'Enable Extension-Contributed MCP Servers' policy. Set the Value to '1' to enable or '0' to disable.

```text
Name: Enable Extension-Contributed MCP Servers
OMA-URI: ./Device/Vendor/MSFT/Policy/Config/ADMX_IDEGitHubCopilot/McpContributionPointEnabled
Data type: Integer
Value: 1 (enabled) or 0 (disabled)
```

--------------------------------

### Inspect Current Suggestion

Source: https://context7.com/github/copilot.vim/llms.txt

Retrieve information about the currently displayed Copilot suggestion. Useful for custom statusline integrations or conditional mappings.

```APIDOC
## `copilot#GetDisplayedSuggestion()` — Inspect Current Suggestion

Returns a dictionary describing the currently rendered inline suggestion. Useful for building custom statusline integrations or conditional mappings.

### Returns:
`{ 'item': {}, 'text': '', 'outdentSize': 0, 'deleteSize': 0, 'deleteChars': '' }`
`'text'` is empty when no suggestion is shown.

### Programmatic use:
```vim
let s = copilot#GetDisplayedSuggestion()
```
```

--------------------------------

### Check Copilot Status with copilot#Enabled()

Source: https://context7.com/github/copilot.vim/llms.txt

Use `copilot#Enabled()` to check if Copilot is active for the current buffer. This is useful for conditional logic in statuslines or key mappings. It returns 1 if enabled, 0 otherwise.

```vim
" Statusline indicator (Vimscript):
function! CopilotStatus() abort
  return copilot#Enabled() ? ' Copilot' : ''
endfunction
set statusline+=%{CopilotStatus()}

" Conditional map: only trigger if Copilot is enabled:
imap <expr> <Tab> copilot#Enabled()
      \ ? copilot#Accept()
      \ : "\<Tab>"

" Lua (Neovim) statusline with lualine:
-- In your lualine config:
sections = {
  lualine_x = {
    {
      function()
        return vim.fn['copilot#Enabled']() == 1 and '  Copilot' or ''
      end,
    },
  },
}

```

--------------------------------

### Validate CVEs for Pip Dependencies

Source: https://github.com/github/copilot.vim/blob/release/copilot-language-server/dist/assets/agents/CVE_Remediator.agent.md

Submit a JSON payload containing a list of pip dependencies and their versions to the `validate_cves` tool.

```json
{
    "dependencies": ["django@3.2.0", "requests@2.25.1"],
    "ecosystem": "pip"
}
```

--------------------------------

### Validate CVEs for Maven Dependencies

Source: https://github.com/github/copilot.vim/blob/release/copilot-language-server/dist/assets/agents/CVE_Remediator.agent.md

Submit a JSON payload containing a list of Maven dependencies and their versions to the `validate_cves` tool.

```json
{
    "dependencies": ["org.springframework:spring-core@5.3.20", "org.apache.logging.log4j:log4j-core@2.14.1"],
    "ecosystem": "maven"
}
```

--------------------------------

### Disable Strict SSL Verification for Proxy

Source: https://github.com/github/copilot.vim/blob/release/doc/copilot.txt

Disable SSL certificate verification if your corporate proxy uses a man-in-the-middle certificate. Alternatively, set the $NODE_TLS_REJECT_UNAUTHORIZED environment variable to "0".

```vimscript
let g:copilot_proxy_strict_ssl = v:false
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.