Is it possible to use multiple capfs simultaneously with different frontends?

[flexagoon]

I want to use codeium.el which only provides a capf, not a backend. The experience I want to achieve is what you'd get when using GitHub Copilot in VSCode - regular LSP suggestions are displayed in a popup when you press C-SPC, and the AI suggestions are automatically shown inline (with the company-preview frontend) and you can press tab to accept them. Is this possible to implement with company?

[dgutov]

You could try using cape-capf-super (from cape) to merge the capfs.

The result might be somewhat different from VSCode, since from your description the AI suggestions are treated differently.

But give it a try and please report back with your impressions.

[dgutov]

Okay, if the goal is to only have one of the backends active at the same time, that should be doable.

Problem is, codeium.el is not quite written to coexist with other sources, at least currently:

What you can see here is it produces a number of completions, not just one. That's why its readme asks you to disable the popup (so you don't see them) and accepting a completion with TAB would usually not work (it would complete up to the common part) -- you would need to use RET. But if you remove the popup backend from the list, it will not be used for the "regular" completions too.

To set it up so that the AI suggestions are skipped when some chars are entered, try this:

(defun my/codeium-completion-at-point ()
  (when (and (null (thing-at-point 'symbol))
             (not (company-explicit-action-p)))
    (codeium-completion-at-point)))

(add-hook 'completion-at-point-functions #'my/codeium-completion-at-point -10 t)

It won't help you switch to LSP completions from AI ones mid-completion, but some custom scripting could do that as well.

To the question of only using the preview frontend - I suppose the custom wrapper above could be more intricate such as it returns only one completion. But then the seemingly popular feature of iterating between different AI completions would need to be implemented some other way (e.g. using the WIP "variants" thingy as discussed in dgutov/robe#144). But I'm not sure it's really that bad - to see them all together instead of just one. Seems like a matter of preference.

[flexagoon]

To set it up so that the AI suggestions are skipped when some chars are entered, try this:

Doesn't that skip AI suggestions whenever any text is under your cursor? If you type something like if (, the LSP won't give any autosuggestions, because there are none that match the configured minimum prefix length. So you should be able to see AI suggestions in this case. It looks like with your code you just won't see any suggestions at all?

So looks like it's needed to first get the results from lsp-completion-at-point, then check if any of them match the prefix length and show those that do, otherwise show AI suggestions (but not if C-SPC was pressed - in that case LSP suggestions should be shown regardless of the prefix length)

Perhaps the C-SPC part can be achieved by just binding it to a function that calls company without the Codeium capf. But is the first part possible?

I suppose the custom wrapper above could be more intricate such as it returns only one completion.

I don't really know elisp, but I assume it has some sort of first or take 1 function. Would it be enough to just wrap codeium-completion-at-point with that?

But I'm not sure it's really that bad - to see them all together instead of just one. Seems like a matter of preference.

It's not just a matter of preference - the issue is that AI completions are usually multiple lines long, so they are very hard to read and understand if they're shown as a single line in a pop up

[dgutov]

Doesn't that skip AI suggestions whenever any text is under your cursor?

No, (thing-at-point 'symbol) usually returns nil after if (. But if you minimum prefix length is >1, then the above snippet could use a more complex condition indeed (you could just check the length of the symbol at point, though).

Perhaps the C-SPC part can be achieved by just binding it to a function that calls company without the Codeium capf. But is the first part possible?

Sure, with some Elisp you could implement dynamic dispatch to one or the other.

I don't really know elisp, but I assume it has some sort of first or take 1 function. Would it be enough to just wrap codeium-completion-at-point with that?

Yes, but function ...completion-at-point return a more complex structure: the 3rd element is a "completion table" which usually is a function as well. You'd have to operate on its returned values (which have different shapes depending on the passed argument). I wouldn't recommend diving into that right away, better try the simpler approach from my snippet first.

It's not just a matter of preference - the issue is that AI completions are usually multiple lines long, so they are very hard to read and understand if they're shown as a single line in a pop up

Point taken, I guess it really depends on the length of the suggestions. Anyway, I pushed a change yesterday which should make the newlines more discernible in the popup; that should help a little.

[flexagoon]

you could just check the length of the symbol at point, though

But that doesn't take into account whether there are any LSP completions available for that symbol, right? So eg. if you type foo without having any variables which start with "foo", the symbol length will be 3, but there won't be any LSP autosuggestions.

[dgutov]

But that doesn't take into account whether there are any LSP completions available for that symbol, right?

Right. You can try this instead (cape needs to be installed):

(defun my/codeium-completion-at-point ()
  (when (and (or (null (thing-at-point 'symbol))
                 (< (length (thing-at-point 'symbol)) company-minimum-prefix-length))
             (not (company-explicit-action-p)))
    (codeium-completion-at-point)))

(add-hook 'completion-at-point-functions #'my/codeium-completion-at-point -10 t)
(add-hook 'completion-at-point-functions (cape-capf-nonexclusive 'eglot-completion-at-point) 0 t)
(add-hook 'completion-at-point-functions #'codeium-completion-at-point 10 t)

You need to evaluate the last 3 lines in the buffer you're testing this combination in. If it works well, put them in a lambda and add it to eglot-managed-mode-hook. Same thing should work with lsp-mode.