[Help] Prevent cycling completions from actually inputting text

[Ajaymamtora]

When tabbing through the completions in insert mode, I dont want the suggestion text to be placed after my cursor until I explicitly confirm it - I've tried:

....
      opts.completion.list.selection = {
        preselect = false,
        auto_insert = false,
      },

But it still does this, am I configuring it wrong or is this not supported? I can't figure it out

[soifou]

Do you mean the ghost text feature? If not, please provide your full blink.cmp configuration.

[Ajaymamtora]

The reason I want this, is because when recording a macro I sometimes accidentally rely on this when using multicursors, which breaks the macro unless I remember to submit, I also just think it makes more sense that the completion is there only when I accept it

[soifou]

Ok then auto_insert = false is indeed the right setting.

See https://cmp.saghen.dev/configuration/completion.html#list for the different combinations, yours is what's called "Manual" in the doc tab. If you don't observe this behavior, there's probably something wrong with your config.

[Ajaymamtora]

Okay thanks, sorry I forgot to provide the config, it's here:

local Icons = require("core.ui.icons")

local EXCLUDED_FILETYPES = require("utils.general").exclude_filetypes

local MAX_WINDOW_HEIGHT = 15
local MAX_WINDOW_WIDTH = 60
local MIN_WINDOW_WIDTH = 10

local M = {}

local sources = {
  default = {
    -- "i18n",
    "lsp",
    "path",
    "go_deep",
    "snippets",
    "buffer",
    "lazydev",
    -- "ripgrep",
    -- "ecolog",
    "datword",
  },
  -- Modified in func below
  per_filetype = {},

  providers = {
    -- i18n = {
    --   name = "i18n",
    --   module = "i18n.integration.blink_source",
    --   opts = {},
    -- },
    lsp = {
      name = "LSP",
      module = "blink.cmp.sources.lsp",
      enabled = true,
      async = true,
      timeout_ms = 4000,
      transform_items = nil,
      should_show_items = true,
      max_items = nil,
      min_keyword_length = 0,
      fallbacks = {},
      score_offset = 2,
    },
    lazydev = {
      name = "LazyDev",
      module = "lazydev.integrations.blink",
      -- make lazydev completions top priority (see `:h blink.cmp`)
      score_offset = 100,
    },
    path = {
      name = "Path",
      module = "blink.cmp.sources.path",
      score_offset = 3,
      opts = {
        trailing_slash = false,
        label_trailing_slash = true,
        get_cwd = function(context)
          return vim.fn.expand(("#%d:p:h"):format(context.bufnr))
        end,
        show_hidden_files_by_default = false,
      },
    },
    datword = {
      name = "DatWord",
      module = "blink-cmp-dat-word",
      opts = {
        paths = {
          _G._Settings.home .. "/.google-10000-english-words/google-10000-english-no-swears.txt",
        },
      },
      max_items = 20,
      score_offset = -10,
      min_keyword_length = 2,
    },
    go_deep = {
      name = "go_deep",
      module = "blink.compat.source",
      min_keyword_length = 3,
      max_items = 5,
      opts = {
        workspace_symbol_timeout_ms = 2000,
        documentation_wait_timeout_ms = 500,
        get_documentation_implementation = "hover",
        add_import_statement_implementation = "treesitter",
        get_package_name_implementation = "regex",
        exclude_vendored_packages = false,
      },
    },
    snippets = {
      name = "Snippets",
      module = "blink.cmp.sources.snippets",
      score_offset = 0,
      opts = {
        friendly_snippets = true,
        global_snippets = { "all" },
        extended_filetypes = {},
        ignored_filetypes = {},
        get_filetype = function(context)
          return vim.bo.filetype
        end,
        -- Set to '+' to use the system clipboard, or '"' to use the unnamed register
        clipboard_register = nil,
        search_paths = { vim.fn.stdpath("config") .. "/snippets" },
      },
    },

    ripgrep = {
      module = "blink-ripgrep",
      name = "Ripgrep",
      -- the options below are optional, some default values are shown
      ---@module "blink-ripgrep"
      ---@type blink-ripgrep.Options
      opts = {
        -- the minimum length of the current word to start searching
        -- (if the word is shorter than this, the search will not start)
        prefix_min_len = 3,

        -- Specifies how to find the root of the project where the ripgrep
        -- search will start from. Accepts the same options as the marker
        -- given to `:h vim.fs.root()` which offers many possibilities for
        -- configuration. If none can be found, defaults to Neovim's cwd.
        --
        -- Examples:
        -- - ".git" (default)
        -- - { ".git", "package.json", ".root" }
        project_root_marker = ".git",

        -- When a result is found for a file whose filetype does not have a
        -- treesitter parser installed, fall back to regex based highlighting
        -- that is bundled in Neovim.
        fallback_to_regex_highlighting = true,

        -- Keymaps to toggle features on/off. This can be used to alter
        -- the behavior of the plugin without restarting Neovim. Nothing
        -- is enabled by default. Requires folke/snacks.nvim.
        toggles = {
          -- The keymap to toggle the plugin on and off from blink
          -- completion results. Example: "<leader>tg" ("toggle grep")
          on_off = nil,

          -- The keymap to toggle debug mode on/off. Example: "<leader>td" ("toggle debug")
          debug = nil,
        },

        backend = {
          -- The backend to use for searching. Defaults to "ripgrep".
          -- Available options:
          -- - "ripgrep", always use ripgrep
          -- - "gitgrep", always use git grep
          -- - "gitgrep-or-ripgrep", use git grep if possible, otherwise
          --   use ripgrep. Uses the same options as the gitgrep backend
          use = "ripgrep",

          -- Whether to set up custom highlight-groups for the icons used
          -- in the completion items. Defaults to `true`, which means this
          -- is enabled.
          customize_icon_highlight = true,

          ripgrep = {
            -- For many options, see `rg --help` for an exact description of
            -- the values that ripgrep expects.

            -- The number of lines to show around each match in the preview
            -- (documentation) window. For example, 5 means to show 5 lines
            -- before, then the match, and another 5 lines after the match.
            context_size = 5,

            -- The maximum file size of a file that ripgrep should include
            -- in its search. Useful when your project contains large files
            -- that might cause performance issues.
            -- Examples:
            -- "1024" (bytes by default), "200K", "1M", "1G", which will
            -- exclude files larger than that size.
            max_filesize = "1M",

            -- Enable fallback to neovim cwd if project_root_marker is not
            -- found. Default: `true`, which means to use the cwd.
            project_root_fallback = true,

            -- The casing to use for the search in a format that ripgrep
            -- accepts. Defaults to "--ignore-case". See `rg --help` for
            -- all the available options ripgrep supports, but you can try
            -- "--case-sensitive" or "--smart-case".
            search_casing = "--ignore-case",

            -- (advanced) Any additional options you want to give to
            -- ripgrep. See `rg -h` for a list of all available options.
            -- Might be helpful in adjusting performance in specific
            -- situations. If you have an idea for a default, please open
            -- an issue!
            --
            -- Not everything will work (obviously).
            additional_rg_options = {},

            -- Absolute root paths where the rg command will not be
            -- executed. Usually you want to exclude paths using gitignore
            -- files or ripgrep specific ignore files, but this can be used
            -- to only ignore the paths in blink-ripgrep.nvim, maintaining
            -- the ability to use ripgrep for those paths on the command
            -- line. If you need to find out where the searches are
            -- executed, enable `debug` and look at `:messages`.
            ignore_paths = {},

            -- Any additional paths to search in, in addition to the
            -- project root. This can be useful if you want to include
            -- dictionary files (/usr/share/dict/words), framework
            -- documentation, or any other reference material that is not
            -- available within the project root.
            additional_paths = {},
          },
        },

        gitgrep = {
          -- no options are currently available
        },

        -- Show debug information in `:messages` that can help in
        -- diagnosing issues with the plugin.
        debug = false,
      },
      -- (optional) customize how the results are displayed. Many options
      -- are available - make sure your lua LSP is set up so you get
      -- autocompletion help
      transform_items = function(_, items)
        for _, item in ipairs(items) do
          -- example: append a description to easily distinguish rg results
          item.labelDetails = {
            description = "(rg)",
          }
        end
        return items
      end,
    },

    buffer = {
      name = "Buffer",
      module = "blink.cmp.sources.buffer",
      score_offset = 0,
      opts = {
        get_bufnrs = function()
          return vim.tbl_filter(function(bufnr)
            return vim.bo[bufnr].buftype == ""
          end, vim.api.nvim_list_bufs())
        end,
      },
    },

    -- ecolog = {
    --   name = "ecolog", -- IMPORTANT: use the same name as you would for nvim-cmp
    --   module = "blink.compat.source",
    --
    --   -- all blink.cmp source config options work as normal:
    --   score_offset = -1,
    --
    --   -- this table is passed directly to the proxied completion source
    --   -- as the `option` field in nvim-cmp's source config
    --   --
    --   -- this is NOT the same as the opts in a plugin's lazy.nvim spec
    --   opts = {},
    -- },
  },
}

M.opts = {
  keymap = {
    preset = "none",
    ["<CR>"] = { "accept", "fallback" },
    ["<C-c>"] = { "show", "show_documentation", "hide_documentation", "fallback" },
    ["<C-x>"] = { "hide", "fallback_to_mappings" },
    ["<C-CR>"] = {
      function(cmp)
        if _G._Settings.is_work then
          if _G._Settings.use_ai then
            local c_ok, minuet = pcall(require, "minuet.virtualtext")
            if c_ok then
              if minuet.action.is_visible() then
                return minuet.action.accept()
              else
                return cmp.select_accept_and_enter()
              end
            end
          else
            return cmp.select_accept_and_enter()
          end
        else
          if _G._Settings.use_ai then
            local c_ok, neocodeium = pcall(require, "neocodeium")
            if c_ok then
              if neocodeium.visible() then
                return neocodeium.accept()
              else
                return cmp.select_accept_and_enter()
              end
            end
          else
            return cmp.select_accept_and_enter()
          end
        end
      end,
    },
    ["<C-Tab>"] = { "snippet_forward", "fallback" },
    ["<C-S-Tab>"] = { "snippet_backward", "fallback" },
    ["<Tab>"] = { "select_next", "fallback" },
    ["<S-Tab>"] = { "select_prev", "fallback" },
    ["<C-y>"] = { "scroll_documentation_up", "fallback" },
    ["<C-e>"] = { "scroll_documentation_down", "fallback" },
    ["<C-u>"] = {
      function(cmp)
        if cmp.is_menu_visible() then
          cmp.select_prev()
          cmp.select_prev()
          cmp.select_prev()
          cmp.select_prev()
          return cmp.select_prev()
        end
      end,
      "fallback",
    },
    ["<C-d>"] = {
      function(cmp)
        if cmp.is_menu_visible() then
          cmp.select_next()
          cmp.select_next()
          cmp.select_next()
          cmp.select_next()
          return cmp.select_next()
        end
      end,
      "fallback",
    },
    ["<C-f>"] = {
      function()
        require("blink-cmp").show({ providers = { "ripgrep" } })
      end,
    },
  },

  enabled = function()
    local filetype = vim.bo.filetype

    -- Assumes EXCLUDED_FILETYPES is a table (list) of filetypes to disable.
    -- For example: local EXCLUDED_FILETYPES = { "lua", "log", "gitcommit" }
    local disabled_filetypes = EXCLUDED_FILETYPES

    -- Filetypes in this list will always be enabled, even if they are in disabled_filetypes.
    -- For example, if "lua" is in both lists, it will be enabled.
    local included_filetypes = { "AvanteInput", "AvanteSelectedFiles", "Avante", "codecompanion" }

    -- 1. Check if the filetype is explicitly included.
    --    This gives it priority and re-enables it.
    for _, included_ft in ipairs(included_filetypes) do
      if filetype == included_ft then
        return true
      end
    end

    -- 2. If not explicitly included, check if it is disabled.
    for _, disabled_ft in ipairs(disabled_filetypes) do
      if filetype == disabled_ft then
        return false
      end
    end

    -- 3. If the filetype is not in the disabled list, it's enabled by default.
    return true
  end,

  snippets = {
    expand = function(snippet)
      require("luasnip").lsp_expand(snippet)
    end,
    active = function(filter)
      if filter and filter.direction then
        return require("luasnip").jumpable(filter.direction)
      end
      return require("luasnip").in_snippet()
    end,
    jump = function(direction)
      require("luasnip").jump(direction)
    end,
  },

  cmdline = {
    keymap = {
      preset = "none",
      ["<C-CR>"] = {
        function(cmp)
          local search_mode = vim.fn.getcmdtype()
          if cmp.is_menu_visible() and search_mode ~= "/" and search_mode ~= "?" then
            cmp.accept_and_enter()
            -- prevent going to fallback

            return true
          else
            -- Menu not open, do fallback
            -- cmp.accept_and_enter()

            return false
          end
        end,
        "fallback",
      },
      ["<CR>"] = {
        function(cmp)
          local search_mode = vim.fn.getcmdtype()
          if cmp.is_menu_visible() and search_mode ~= "/" and search_mode ~= "?" then
            cmp.accept()
            -- prevent going to fallback

            return true
          else
            -- Menu not open, do fallback
            -- cmp.accept_and_enter()

            return false
          end
        end,
        "fallback",
      },
      ["<Esc>"] = {
        function(cmp)
          local search_mode = vim.fn.getcmdtype()
          if cmp.is_menu_visible() and search_mode ~= "/" and search_mode ~= "?" then
            cmp.hide()
            -- prevent going to fallback

            return true
          else
            -- Menu not open, do fallback
            cmp.cancel()
            vim.api.nvim_feedkeys(
              vim.api.nvim_replace_termcodes("<Esc>", true, false, true),
              "n", -- 'n' flag means don't remap
              false
            )

            return true
          end
        end,
        "fallback",
      },
      ["<C-c>"] = { "show" },
      ["<C-x>"] = { "hide" },
      ["<Tab>"] = { "select_next" },
      ["<Down>"] = { "select_next" },
      ["<S-Tab>"] = { "select_prev" },
      ["<Up>"] = { "select_prev" },
      ["<Right>"] = { "accept", "fallback" },
    },
    completion = { menu = { auto_show = true } },
  },

  completion = {
    keyword = {
      range = "full",
    },
    trigger = {
      show_in_snippet = true,
      show_on_keyword = true,
      show_on_trigger_character = true,
      show_on_accept_on_trigger_character = true,
      show_on_insert_on_trigger_character = true,
    },

    list = {
      max_items = 200,
      selection = {
        preselect = false,
        auto_insert = false,
      },
      cycle = {
        from_bottom = true,
        from_top = true,
      },
    },

    accept = {
      create_undo_point = true,
      auto_brackets = {
        enabled = true,
        override_brackets_for_filetypes = {},
        kind_resolution = {
          enabled = true,
          blocked_filetypes = {},
        },
        semantic_token_resolution = {
          enabled = true,
          blocked_filetypes = {},
          timeout_ms = 400,
        },
      },
    },

    menu = {
      enabled = true,
      min_width = MIN_WINDOW_WIDTH,
      max_height = MAX_WINDOW_HEIGHT,
      border = vim.o.winborder,
      winblend = vim.g.has_transparent_bg and vim.g.base_winblend or 10,
      scrolloff = 2,
      scrollbar = true,
      cmdline_position = function()
        if vim.g.ui_cmdline_pos ~= nil then
          local pos = vim.g.ui_cmdline_pos -- (1, 0)-indexed
          return { pos[1] - 2, pos[2] }
        end
        local height = (vim.o.cmdheight == 0) and 1 or vim.o.cmdheight
        return { vim.o.lines - height, 0 }
      end,
      auto_show = function(ctx)
        return ctx.mode ~= "cmdline" or not vim.tbl_contains({ "/", "?" }, vim.fn.getcmdtype())
      end,
      draw = {
        -- We don't need label_description now because label and label_description are already
        -- combined together in label by colorful-menu.nvim.
        columns = { { "kind_icon" }, { "label", gap = 1 } },
        components = {
          label = {
            text = function(ctx)
              return require("colorful-menu").blink_components_text(ctx)
            end,
            highlight = function(ctx)
              return require("colorful-menu").blink_components_highlight(ctx)
            end,
          },
        },
      },
    },

    documentation = {
      auto_show = true,
      auto_show_delay_ms = 250,
      update_delay_ms = 200,
      treesitter_highlighting = true,
      window = {
        min_width = MIN_WINDOW_WIDTH,
        max_width = MAX_WINDOW_WIDTH,
        max_height = MAX_WINDOW_HEIGHT,
        border = vim.o.winborder,
        winblend = vim.g.has_transparent_bg and vim.g.base_winblend or 10,
        scrollbar = true,
      },
    },
    ghost_text = {
      enabled = false,
    },
  },

  signature = {
    enabled = true,
    window = {
      min_width = MIN_WINDOW_WIDTH,
      max_width = MAX_WINDOW_WIDTH,
      max_height = MAX_WINDOW_HEIGHT,
      border = vim.o.winborder,
      winblend = vim.g.has_transparent_bg and vim.g.base_winblend or 10,
      scrollbar = false,
      treesitter_highlighting = true,
    },
  },

  fuzzy = {
    max_typos = function(keyword)
      return math.floor(#keyword / 4)
    end,
    frecency = {
      enabled = true,
    },
    use_proximity = true,
    -- max_items = 200,
    sorts = {
      -- (optionally) always prioritize exact matches
      "exact",

      -- pass a function for custom behavior
      -- function(item_a, item_b)
      --   return item_a.score > item_b.score
      -- end,

      "score",
      "sort_text",
    },
    prebuilt_binaries = {
      download = _G._Settings.is_termux,
      force_version = nil,
      force_system_triple = nil,
    },
    implementation = "prefer_rust_with_warning",
  },

  appearance = {
    highlight_ns = vim.api.nvim_create_namespace("blink_cmp"),
    nerd_font_variant = "mono",
    kind_icons = Icons.blink,
  },
  sources = sources,
}

M.config = function()
  local opts = M.opts

  local cmp = require("blink.cmp")
  -- if _G._Settings.is_work and Settings.use_ai then
  -- table.insert(opts.sources.completion.default, 3, "cmp_ai")
  -- opts.sources.completion.providers["cmp_ai"] = {
  --   name = "cmp_ai",
  --   module = "blink.compat.source",
  --   score_offset = 3,
  -- }
  -- end

  local codecmpok, _ = pcall(require, "codecompanion")
  if codecmpok then
    table.insert(opts.sources.default, 5, "codecompanion")

    opts.sources.providers["codecompanion"] = {
      name = "CodeCompanion",
      module = "codecompanion.providers.completion.blink",
      score_offset = 0,
      opts = {},
    }

    opts.sources.per_filetype["codecompanion"] = {
      "codecompanion",
      "buffer",
    }
  end

  local cmp_list = require("blink.cmp.completion.list")

  -- Handler for show event
  cmp_list.show_emitter:on(function()
    -- vim.g.matchup_matchparen_pumvisible = true
    vim.g.matchup_enabled = false
  end)

  -- Handler for hide event
  cmp_list.hide_emitter:on(function()
    -- vim.g.matchup_matchparen_pumvisible = false
    vim.g.matchup_enabled = true
  end)

  opts.fuzzy.prebuilt_binaries.ignore_version_mismatch = true

  cmp.setup(opts)

  local neo_ok, _ = pcall(require, "neocodeium")
  if neo_ok then
    -- local neocodeium = require("neocodeium.commands")
    -- local commands = require("neocodeium.commands")
    -- if cmp.windows and cmp.windows.autocomplete then
    --   cmp.on_open(function()
    --     neocodeium.clear() -- Call neocodeium.clear when autocomplete opens
    --   end)
    --
    --   cmp.on_close(function()
    --     commands.enable() -- Enable commands when autocomplete closes
    --     neocodeium.cycle_or_complete() -- Trigger neocodeium's cycle or complete logic
    --   end)
    -- end

    vim.api.nvim_create_autocmd("User", {
      pattern = "BlinkCmpMenuOpen",
      callback = function()
        require("neocodeium").clear()
      end,
    })
  end
end

return M

Just before I call setup, I've tried doing ` opts.completion.list.selection = { preselect = false, auto_insert = false }

` just to make sure as well, but it still doesn't work.

By the sounds of it then this should be converted back to a bug?

I've tried myself and can't spot anything wrong with the config, and I'm on the latest commit. Have you got any ideas what I could do? Thanks

[soifou]

Thanks, spotted! You need to remove this hack and this will work again:

				local cmp_list = require("blink.cmp.completion.list")

				-- Handler for show event
				cmp_list.show_emitter:on(function()
					-- vim.g.matchup_matchparen_pumvisible = true
					vim.g.matchup_enabled = false
				end)

				-- Handler for hide event
				cmp_list.hide_emitter:on(function()
					-- vim.g.matchup_matchparen_pumvisible = false
					vim.g.matchup_enabled = true
				end)

Also just a note when you do:

					["<C-u>"] = {
						function(cmp)
							if cmp.is_menu_visible() then
								cmp.select_prev()
								cmp.select_prev()
								cmp.select_prev()
								cmp.select_prev()
								return cmp.select_prev()
							end
						end,
						"fallback",
					},
					["<C-d>"] = {
						function(cmp)
							if cmp.is_menu_visible() then
								cmp.select_next()
								cmp.select_next()
								cmp.select_next()
								cmp.select_next()
								return cmp.select_next()
							end
						end,
						"fallback",
					},

You can simplify with this (on latest):

            ['<C-d>'] = { function(cmp) return cmp.select_next({ count = 5 }) end, 'fallback' },
            ['<C-u>'] = { function(cmp) return cmp.select_prev({ count = 5 }) end, 'fallback' },

[Ajaymamtora]

Nice one thank you, that worked!