DEV Community: aldama

Vterm completion for files, directories, command history and programs in Emacs

aldama — Sat, 07 Aug 2021 04:24:07 +0000

This is a naive solution. Feel free to suggest alternative solutions or
improvements.

https://gist.github.com/ram535/a2153fb86f33ecec587d593c1c5e1623

The Goal

When pressing TAB in vterm terminal, we should get a list of
suggestion. The suggestion list should either be a file, a directory, a
history command or a program name.

What we need

This is the list of what we need for the solution.

emacs
vterm
bash

Step 1 - Get the list of program

If you go to the terminal and run:

compgen -c

You will get a list of all the programs under the PATH environment
variable.

Let's get that list using elisp.

(shell-command-to-string "compgen -c")
;; "emacs\nnano\nneovim\nvim......."

This gives us a long string.

Let's split that long string into a list of string.

(split-string (shell-command-to-string "compgen -c") "\n" t )
;; ("emacs" "nano" "neovim" "vim".......)

Now we have a list of the programs of the system.

Step 2 - Choose a program from the list of programs

Now we can choose an item from that list of programs using the
completing-read build-in emacs function.

(completing-read "Command " (split-string (shell-command-to-string "compgen -c") "\n" t ))

Step 3 - Send the chosen program to vterm

(vterm-send-string
 (completing-read "Command "
                  (split-string (shell-command-to-string "compgen -c") "\n" t )))

Step 4 - Get the list of files and directories in the CWD

If you go to the terminal and run:

compgen -f

You will get the list of files and directories in the current working
directory (CWD).

Let's get that list using elisp.

(shell-command-to-string "compgen -f")
;; "Documents\nDownload\nMusic\nProjects......."

This gives us a long string.

Let's split that long string into a list of string.

(split-string (shell-command-to-string "compgen -f") "\n" t )
;; ("Documents" "Download" "Music" "Projects".......)

Now we have a list of files and directories of the CWD.

Step 5 - Choose a file or directory from the list of files and directories

(completing-read "Choose " (split-string (shell-command-to-string "compgen -f") "\n" t ))

Step 6 - Send the chosen file or directory to vterm

(vterm-send-string
 (completing-read "Choose "
                  (split-string (shell-command-to-string "compgen -f") "\n" t )))

Step 6.5 - There is a gotcha with getting the list of files and directories

The default-directory emacs variable is never update when we move to
different directories in a vterm terminal.

That can be solve calling this function.

(defun vterm-directory-sync ()
  "Synchronize current working directory."
  (interactive)
  (when vterm--process
    (let* ((pid (process-id vterm--process))
           (dir (file-truename (format "/proc/%d/cwd/" pid))))
      (setq default-directory dir))))

The Step 14 has been update with this solution and everything should work as intended.

Step 7 - Get the list of bash history commands

Bash history commands are save in the .bash_history file.

Let's create a temporary buffer and insert the content of
.bash_history file into it.

(with-temp-buffer
  (insert-file-contents "~/.bash_history")
  (split-string (buffer-string) "\n" t))

Let's split the content of the temporary buffer into a list of strings.

(with-temp-buffer
  (insert-file-contents "~/.bash_history")
  (split-string (buffer-string) "\n" t))

Now we have a list of bash command history.

Step 8 - Choose a command from the list of bash command history

(completing-read "History" (with-temp-buffer
                                (insert-file-contents "~/.bash_history")
                                (split-string (buffer-string) "\n" t)))

Step 9 - Send the chosen history command to vterm

(vterm-send-string
   (completing-read "History" (with-temp-buffer
                                (insert-file-contents "~/.bash_history")
                                (split-string (buffer-string) "\n" t))))

Step 10 - Combine the list of files, directories, history commands and programs into one list

Let's combine the lists we got from step 1, 4 and 7 into one list.

(let ((program-list (split-string (shell-command-to-string "compgen -c") "\n" t ))
      (file-directory-list (split-string (shell-command-to-string "compgen -f") "\n" t ))
      (history-list (with-temp-buffer
                      (insert-file-contents "~/.bash_history")
                      (split-string (buffer-string) "\n" t))))

  (append program-list file-directory-list history-list))

Let's make it a function.

(defun get-full-list ()
  (let ((program-list (split-string (shell-command-to-string "compgen -c") "\n" t ))
        (file-directory-list (split-string (shell-command-to-string "compgen -f") "\n" t ))
        (history-list (with-temp-buffer
                        (insert-file-contents "~/.bash_history")
                        (split-string (buffer-string) "\n" t))))

    (append program-list file-directory-list history-list)))

Step 11 - Delete duplicates (optional)

We are going to use -distinct function from the dash.el package.

(defun get-full-list ()
  (let ((program-list (split-string (shell-command-to-string "compgen -c") "\n" t ))
        (file-directory-list (split-string (shell-command-to-string "compgen -f") "\n" t ))
        (history-list (with-temp-buffer
                        (insert-file-contents "~/.bash_history")
                        (split-string (buffer-string) "\n" t))))

    (-distinct (append program-list file-directory-list history-list))))

Step 12 - Give suggestion for a partial word

Imagine we type:

em
  ^

^ is the position of the cursor. In this scenario we would like to
have a suggestion of items that contain the letters "em".

If we read the documentation of the function completing-read.

(completing-read PROMPT COLLECTION &optional PREDICATE REQUIRE-MATCH INITIAL-INPUT HIST DEF INHERIT-INPUT-METHOD)

We can see that we can give an INITIAL-INPUT.

But how do we get an INITIAL-INPUT. That is where thing-at-point
build-in emacs function comes in handy.

Let's see some examples:

world
  ^

world
     ^

If we call (thing-at-point 'word 'no-properties), in either example,
it returns "world". Now can use (thing-at-point 'word 'no-properties)
as out INITIAL-INPUT.

Let's go back to our scenario. We type "em" and evaluate the code below,
it will give us suggestion of words that contain "em" from the the list
we got in the step 10.

(completing-read "Choose: " (get-full-list) nil nil (thing-at-point 'word 'no-properties))

Let's make it a function.

(defun vterm-completion-choose-item ()
(completing-read "Choose: " (get-full-list) nil nil (thing-at-point 'word 'no-properties)))

Step 13 - Replace partial word with the chosen word

First we check if there is a word at point.

(when (thing-at-point 'word))

If it is a word, let's delete it.

(when (thing-at-point 'word)
(backward-kill-word 1))

WARNING (backward-kill-word) will not work in vterm. You have to use
(vterm-send-meta-backspace) instead.

Let's insert the chosen item in a vterm terminal.

(defvar vterm-chosen-item (vterm-completion-choose-item))

(when (thing-at-point 'word)
(vterm-send-meta-backspace))

(vterm-send-string vterm-chosen-item)

Let's make it a function.

(defvar vterm-chosen-item)

(defun vterm-completion ()
  (interactive)
  (setq vterm-chosen-item (vterm-completion-choose-item))
  (when (thing-at-point 'word)
    (vterm-send-meta-backspace))
  (vterm-send-string vterm-chosen-item))

Step 14 - Solution

I use general.el for the keybindings and evil-mode.

(use-package vterm
  :config        
  (defun get-full-list ()
    (let ((program-list (split-string (shell-command-to-string "compgen -c") "\n" t ))
          (file-directory-list (split-string (shell-command-to-string "compgen -f") "\n" t ))
          (history-list (with-temp-buffer
                          (insert-file-contents "~/.bash_history")
                          (split-string (buffer-string) "\n" t))))

      (delete-dups (append program-list file-directory-list history-list))))

  (defun vterm-completion-choose-item ()
    (completing-read "Choose: " (get-full-list) nil nil (thing-at-point 'word 'no-properties)))

  (defun vterm-completion ()
    (interactive)
    (vterm-directory-sync)
   (let ((vterm-chosen-item (vterm-completion-choose-item)))
      (when (thing-at-point 'word)
         (vterm-send-meta-backspace))
      (vterm-send-string vterm-chosen-item)))

  (defun vterm-directory-sync ()
    "Synchronize current working directory."
    (interactive)
    (when vterm--process
      (let* ((pid (process-id vterm--process))
             (dir (file-truename (format "/proc/%d/cwd/" pid))))
        (setq default-directory dir))))

  :general
  (:states 'insert
           :keymaps 'vterm-mode-map
           "<tab>" 'vterm-completion))

Extra

Increase the bash history command and do not store duplicate items.

Add this in the .bashrc file.

export HISTSIZE=10000
export HISTFILESIZE=10000
export HISTCONTROL=ignoreboth:erasedups

KMonad and the power of infinite leader keys

aldama — Fri, 06 Aug 2021 20:32:32 +0000

First of all that was a title clickbait.
Title clickbaits are still legal in Mexico (I think).

Jokes aside, I will show you how every key in your keyboard can be a leader key.

Since most of the Emacs community are keyboard driven freaks, I hope you will see the potential in your workflow.

What is KMonad?

It is a program that lets you remap the keys of your keyboard.

Install KMonad

Download the executable from https://github.com/kmonad/kmonad/releases.

Put it somewhere your PATH enviroment variable points.

In my case I like to put executables in $HOME/bin.
So I add this line export PATH="$HOME/bin:$PATH" in the .profile file.

Then run the following commands.

# Add self to the input and uinput groups
sudo usermod -aG input $USER
sudo groupadd uinput
sudo usermod -aG uinput $USER

echo 'KERNEL=="uinput", MODE="0660", GROUP="uinput", OPTIONS+="static_node=uinput"' | sudo tee /etc/udev/rules.d/90-uinput.rules

# This seems to be needed because uinput isn't compiled as a loadable module these days.
# See https://github.com/chrippa/ds4drv/issues/93#issuecomment-265300511
echo uinput | sudo tee /etc/modules-load.d/uinput.conf

For more info check https://github.com/kmonad/kmonad/issues/160#issuecomment-766121884.

Create a KMonad configuration file

mkdir -p ~/.config/kmonad
touch ~/.config/kmonad/config.kbd

Add system information

On the top of config.kbd add the next.

(defcfg
  input  (device-file "<path to your keyboard input>")
  output (uinput-sink "KMonad kbd"))

Go to /dev/input/by-path/ or /dev/input/by-id/ and look for any file ending in kbd.

I think if your keyboard is plugable, it should appear in /dev/input/by-id/
and your build-in laptop keyboard should appear in /dev/input/by-path/.

In my case I am using my build-in laptop keyboard. This is what I added in the configuration file. Yours should be different, modify it with your information.

(defcfg
  input  (device-file "/dev/input/by-path/platform-i8042-serio-0-event-kbd")
  output (uinput-sink "KMonad kbd"))

uinput-sink will be the name given to the virtual keyboard that KMonad creates.
You can write anything in there.

Keyboard blueprint

Now we need to create the blueprint of our keyboard. The layouts that will create later will base of this blueprint.

This is the blueprint of my keyboard. Modify it as you need.

(defsrc
  esc   f1   f2   f3   f4   f5   f6   f7   f8   f9   f10  f11   f12    pause  prnt  ins  del
  `     1    2    3    4    5    6    7    8    9    0    -     =      bspc              home
  tab   q    w    e    r    t    y    u    i    o    p    [     ]      ret               pgup
  caps  a    s    d    f    g    h    j    k    l    ;    '     \                        pgdn
  lsft  z    x    c    v    b    n    m    ,    .    /    rsft         up                end
  lctl  lmet lalt      spc       ralt cmps rctl                 left   down   rght
  )

Base layout (default)

KMonad takes the first layout as the default layout.
Let's create our first layout and named it base.
And let's also swap capslock and escape.

(deflayer base
  caps    f1    f2   f3   f4   f5   f6   f7   f8   f9   f10  f11   f12    pause  prnt  ins  del
  `       1     2    3    4    5    6    7    8    9    0    -     =      bspc              home
  tab     q     w    e    r    t    y    u    i    o    p    [     ]      ret               pgup
  esc     a     s    d    f    g    h    j    k    l    ;    '     \                        pgdn
  lsft    z     x    c    v    b    n    m    ,    .    /    rsft         up                end
  lctl    lmet  lalt      spc       ralt cmps rctl                 left   down   rght
  )

Now if we run:

kmonad ~/.config/kmonad/config.kbd

You will notice that capslock and escape have been swaped.

Create a second layout

Let's call the second layout syms, short for symbols.
First lets modify our base layout so when we hold a, it calls the syms layout.

(deflayer base
  caps    f1    f2   f3   f4   f5   f6   f7   f8   f9   f10  f11   f12    pause  prnt  ins  del
  `       1     2    3    4    5    6    7    8    9    0    -     =      bspc              home
  tab     q     w    e    r    t    y    u    i    o    p    [     ]      ret               pgup
  esc     (layer-toggle syms)  s    d    f    g    h    j    k    l    ;    '     \         pgdn
  lsft    z     x    c    v    b    n    m    ,    .    /    rsft         up                end
  lctl    lmet  lalt      spc       ralt cmps rctl                 left   down   rght
  )

But that is too messy. Let's create an alias for that command.

(defalias
  sym (layer-toggle syms))

And now we can modify out base layout like this:

(deflayer base
  caps    f1    f2   f3   f4   f5   f6   f7   f8   f9   f10  f11   f12    pause  prnt  ins  del
  `       1     2    3    4    5    6    7    8    9    0    -     =      bspc              home
  tab     q     w    e    r    t    y    u    i    o    p    [     ]      ret               pgup
  esc     @sym  s    d    f    g    h    j    k    l    ;    '     \                        pgdn
  lsft    z     x    c    v    b    n    m    ,    .    /    rsft         up                end
  lctl    lmet  lalt      spc       ralt cmps rctl                 left   down   rght
  )

Let's create our syms layout.
We will start simple and just add two symbols to make everything more clear.

(deflayer syms
  _     _    _    _    _    _    _    _    _    _    _   _   _   _   _     _    _
  _     _    _    _    _    _    _    _    _    _    _   _   _   _              _
  _     _    _    _    _    _    _    _    _    _    _   _   _   _              _
  _     _    _    _    _    _    _    [    ]    _    _   _   _                  _
  _     _    _    _    _    _    _    _    _    _    _   _       _              _
  _     _    _         _         _    _    _                 _   _   _
  )

Now if we if we run our configuration.

kmonad ~/.config/kmonad/config.kbd

When we hold a and press j, we get [.
And when we hold a and press k, we get ].

The bad news is that we lost the ability to type the letter a.

Let's use `a` key a leader key

From our last example let's modify the alias we made for calling the syms layout.

(defalias
  sym (tap-next a (layer-toggle syms)))

With this modification, if we just tap a, we get a.
But if we hold a and press j, we get [.
And also if we hold a and press k, we get ].

Let's create another leader key

(defcfg
  input  (device-file "<path to your keyboard input>")
  output (uinput-sink "KMonad kbd"))

(defalias
  sym (tap-next bspc (layer-toggle syms)))

(defsrc
  esc   f1   f2   f3   f4   f5   f6   f7   f8   f9   f10  f11   f12    pause  prnt  ins  del
  `     1    2    3    4    5    6    7    8    9    0    -     =      bspc              home
  tab   q    w    e    r    t    y    u    i    o    p    [     ]      ret               pgup
  caps  a    s    d    f    g    h    j    k    l    ;    '     \                        pgdn
  lsft  z    x    c    v    b    n    m    ,    .    /    rsft         up                end
  lctl  lmet lalt      spc       ralt cmps rctl                 left   down   rght
  )

(deflayer base
  esc   f1   f2   f3   f4   f5   f6   f7   f8   f9   f10  f11   f12    pause  prnt  ins  del
  `     1    2    3    4    5    6    7    8    9    0    -     =      bspc              home
  tab   q    w    e    r    t    y    u    i    o    p    [     ]      ret               pgup
  @sym  a    s    d    f    g    h    j    k    l    ;    '     \                        pgdn
  lsft  z    x    c    v    b    n    m    ,    .    /    rsft         up                end
  lctl  lmet lalt      spc       ralt cmps rctl                 left   down   rght
  )

(deflayer syms
  _     _    _    _    _    _    _    _    _    _    _   _   _   _   _     _    _
  _     _    _    _    _    _    _    _    _    _    _   _   _   _              _
  _     _    _    _    _    _    _    _    _    _    _   _   _   _              _
  _     _    _    _    _    _    _    [    ]    _    _   _   _                  _
  _     _    _    _    _    _    _    _    _    _    _   _       _              _
  _     _    _         _         _    _    _                 _   _   _
  )

That is a full configuration.
In this configuration when we tap caplocks, get a backspace.
If we hold caplocks and press j, we get [.
If we hold caplocks and press k, we get ].
And the good news is that we got rid of caplocks previous life functionality.

Conclusion

There is much more you can do with KMonad.
I suggest you to read the official tutorial to learn more about KMonad.

Now you know how covert every key in a leader key.

One last thing. Since I use Linux Mint and Stumpwm.
I added this line kmonad $HOME/.config/kmonad/config.kbd & to my .profile file, so kmonad starts when I log in.

Extra

(defcfg
  input  (device-file "<path to your keyboard input>")
  output (uinput-sink "KMonad kbd"))

(defalias
  d  (tap-hold-next 150 d [)
  f  (tap-hold-next 150 f ]))

(defsrc
  esc   f1   f2   f3   f4   f5   f6   f7   f8   f9   f10  f11   f12    pause  prnt  ins  del
  `     1    2    3    4    5    6    7    8    9    0    -     =      bspc              home
  tab   q    w    e    r    t    y    u    i    o    p    [     ]      ret               pgup
  caps  a    s    d    f    g    h    j    k    l    ;    '     \                        pgdn
  lsft  z    x    c    v    b    n    m    ,    .    /    rsft         up                end
  lctl  lmet lalt      spc       ralt cmps rctl                 left   down   rght
  )

(deflayer base
  esc   f1   f2   f3   f4   f5   f6   f7   f8   f9   f10  f11   f12    pause  prnt  ins  del
  `     1    2    3    4    5    6    7    8    9    0    -     =      bspc              home
  tab   q    w    e    r    t    y    u    i    o    p    [     ]      ret               pgup
  caps  a    s    @d   @f   g    h    j    k    l    ;    '     \                        pgdn
  lsft  z    x    c    v    b    n    m    ,    .    /    rsft         up                end
  lctl  lmet lalt      spc       ralt cmps rctl                 left   down   rght
  )

If you hold d more than 150 milliseconds, you will get [.
If you quickly tap d, you will get d.
If you hold f more than 150 milliseconds, you will get ].
If you quickly tap f, you will get f.

DEV Community: aldama

Vterm completion for files, directories, command history and programs in Emacs

The Goal

What we need

Step 1 - Get the list of program

Step 2 - Choose a program from the list of programs

Step 3 - Send the chosen program to vterm

Step 4 - Get the list of files and directories in the CWD

Step 5 - Choose a file or directory from the list of files and directories

Step 6 - Send the chosen file or directory to vterm

Step 6.5 - There is a gotcha with getting the list of files and directories

Step 7 - Get the list of bash history commands

Step 8 - Choose a command from the list of bash command history

Step 9 - Send the chosen history command to vterm

Step 10 - Combine the list of files, directories, history commands and programs into one list

Step 11 - Delete duplicates (optional)

Step 12 - Give suggestion for a partial word

Step 13 - Replace partial word with the chosen word

Step 14 - Solution

Extra

KMonad and the power of infinite leader keys

What is KMonad?

Install KMonad

Create a KMonad configuration file

Add system information

Keyboard blueprint

Base layout (default)

Create a second layout

Let's use a key a leader key

Let's create another leader key

Conclusion

Extra

Let's use `a` key a leader key