How to robustly use D- mappings in terminal nvim?

Question

I'm using kitty to run terminal nvim on macOS. I want to use D- (command-key) mappings inside nvim. Because terminals, for reasons I don't understand, don't simply pass command-key chords through to the underlying nvim, this requires a workaround. This is what I currently use in kitty.conf:

map cmd+left  send_text all :call feedkeys("\<D-LEFT>")\r
map cmd+right send_text all :call feedkeys("\<D-RIGHT>")\r
map cmd+up    send_text all :call feedkeys("\<D-UP>")\r
map cmd+down  send_text all :call feedkeys("\<D-DOWN>")\r
...

This works in normal mode, but not in insert mode due to the colon. Nvim provides the <Cmd> pseudokey (:help <Cmd>) to replace the : for writing mode-agnostic command mappings within Vim. But kitty doesn't know anything about <Cmd>. However, if <Cmd> is just a stand-in for some bytes, I could just specify these bytes directly in kitty.conf.

How can I get the bytes represented by <Cmd>? Or is there another solution?

Answer 1

You can find out which key code is used by Vim (or NeoVim) to represent the <Cmd> sequence with:

:echo "\<Cmd>"

From my own experimentation, it seems that this produces <80><fd>g in Vim and <80><fd>h in NeoVim, where the <80> and <fd> are hexadecimal codes representing keys in the upper half of the first 256 key range.

It seems it's possible to use \x sequences to represent keys by their hex code in the Kitty config file, so it's possible that something like the below might work for the NeoVim sequence:

map cmd+left  send_text all \x80\xfdhcall feedkeys("\<D-LEFT>")\r

(Use \x80\fdgcall ... instead for the Vim sequence.)

It's possible, though, that Vim (and NeoVim) will only use that sequence internally and won't really recognize it even if it's produced by the terminal emulator... So while that's your best shot to send <Cmd> to Vim, it's totally possible that it doesn't really work, perhaps even by design...

---

Since you're trying to use <Cmd> to actually send a few other different key sequences to Vim, why not try to send those sequences directly?

In both Vim on a Mac, or NeoVim on Linux, I see the following:

:echo "\<D-Left>"
<80><fc><80><80>kl

So perhaps mapping it directly with the below would work?

map cmd+left  send_text all \x80\xfc\x80\x80kl
map cmd+right send_text all \x80\xfc\x80\x80kr
map cmd+up    send_text all \x80\xfc\x80\x80ku
map cmd+down  send_text all \x80\xfc\x80\x80kd
...

(You can confirm these key codes and find additional ones for further mappings you have with the :echo "\<...>" trick in Vim.)

Answer 2

I was able to solve this problem through an imperfect, laborious, but functional solution.

The basic idea is to map command key chords into specially-prefixed byte sequences that the terminal (and neovim) understand. This requires finding a suitable prefixing scheme using some "safe" byte sequence as a prefix/escape indicator.

I chose "vertical tab" (0x0b), which is normally generated by C-k, because I never use vertical tabs or otherwise press C-k. I'm not 100% sure this won't subtly break something else, but if there is an issue, it is simple to switch to a different sequence.

For each command chord to pass through, set up a kitty mapping and a corresponding vim mapping:

# kitty.conf
...
map cmd+a send_text all \x0ba
...

# init.vim
...
imap <CHAR-0x0b>a <D-a>
...

Because the vim mapping is recursive, this should seamlessly work with the existing D- mappings in your init.vim.

You can generate as many of these mappings as you need-- if you want to be comprehensive (and include other modifier combinations with command, for D-M- mappings etc), you can quickly pile up a very long list.