Simplify workflow with fuzzy search

• Fuzzy search?
• Search through bash history
• Select one time passwords
• Open web pages from Firefox bookmarks
• Launch programs
• Open files and buffers in Neovim
• Auto suggest from LSP in Neovim

During my personal time near the PC when I have the desire to improve my workflow, be it writing code or mixing music, I aim for two goals: making things faster (real or perceived performance) or simpler (less in size, resource consumption, or cognitive complexity). Sometimes, fixing one improves the other. Here is a particular example for fuzzy search.

Fuzzy search?

A way to get substring matches when you enter non-consecutive characters. For instance, pefl matches

PErf script | ~/src/fg/stackcollapse-perf.pl | ~/src/fg/FLamegraph.pl > 4.svg
sudo apt install PErl ncurses-bin libdav1d7 iptables Fdisk fiLe
PinEntry-FLtk
sudo aPt purgE FLex

Many lines match in a modestly sized file (think .bash_history) so smart scoring based on metrics as frequency or recency is applied. Different programs choose different paths for optimizing user experience, so there won't be any general way.

For many people I've asked, fuzzy searching is harder than prefix searching as instead of typing the prefix you need to remember various sub-parts, and if you don't, matches will bury you. For me, though, it is easier, as I tend to remember middle command parts better.

Search through bash history

C-r or history are good but non-interactive. If I use a command twice or more, I usually make it a script, nevertheless, some commands are altered slightly, and as I'm too lazy to use snippets, I search them in history.

Initially, I used hstr (patch), which displays the fullscreen list of commands in order of execution. Core distinction with other fuzzy finders is that hstr's "fuzziness" is limited to words: vi s will match vim start.sh but vis will not, so you need to type extra spaces.

I used it with bind -x '"\C-f": "hstr"' in .bashrc¹. Blacklisting, favourite commands, priorities were unnecessary, and the keys were either Enter (execute), Tab (push to command line but don't execute, also right arrow key) or C-c.

Starting from Linux 6.2, you need to sudo sysctl -w dev.tty.legacy_tiocsti=1 or the command won't execute.

Then I started adopting fzy for different tasks, and I thought, "Why do I need a separate tool?" It is just 50kB, but maybe I can fit the command search into using fzy as well? Turns out, yes.

fzy doesn't take the whole screen but 10 lines (customizable) at the bottom. Unfortunately, it doesn't order or deduplicate commands, and that should be done manually. When no duplicates are present, order is irrelevant, and you may use a cron script for cleaning .bash_history:

awk '!seen[$0]++' ~/.bash_history > /tmp/h
mv /tmp/h ~/.bash_history

And voilà, one tool less, simpler.

fzy was bound to bind -x '"\C-f": " $(<$HISTFILE fzy)"', but it doesn't record commands in history, so you can leverage a shell script:

cmd=$(<$HISTFILE fzy)
echo "$cmd" >> $HISTFILE
eval "$cmd"

Select one time passwords

I use pass as a password manager and Aegis for TOTP on my smartphone. However, the possibility of losing access to important apps (I wouldn't configure a second factor for them otherwise) with phone breaking is bad, and also PC-based password generation can save a few minutes of my life.

I backed up Aegis's encrypted database as a json file and wrote a script to get the passwords, but then I thought "Do I need python3-cryptography? There must be a simpler way".

I installed pass-otp which, as a pass extension, included X keyboard integration. The last desired functionality was transferring the passwords. Mounting the phone's file system, I used a non-encrypted passwords database (fine as it is transient, deleted right after migration) and extracted the secrets:

f = Path(sys.argv[1])
for entry in json.loads(f.read_text())["db"]["entries"]:
    name = entry["name"].replace(" ", "-")
    os.system("echo \"otpauth://totp/totp-secret?secret={0}&issuer={1}\"\
        | pass add -e otp/{1}" .format(entry["info"]["secret"], name))
f.unlink()

The last step was to write a wrapper around pass-otp itself:

pass otp -c "otp/$(ls -1 ~/.password-store/otp | sed 's/....$//' | fzy)"\
    >/dev/null

Type otp and the code is in your clipboard.

Open web pages from Firefox bookmarks

Usually I don't have anything I need on the web, so having a browser open is wasteful. When the browser starts, you need a few seconds until the omnibar (search and URL bar combined) starts working. Until then, no suggestions work, and even if you type the URL by hand, it'd probably get partially accepted (http://go although http://google.com was typed). Can I do better?

First step is to get a text list of bookmarks. Omnibar suggests from history and open tabs as well, but target use case is a single opened tab, and I'd add every web page deemed useful to bookmarks anyway.

tmp=$(mktemp)
cp ~/.mozilla/firefox/*.default/places.sqlite $tmp
sqlite3 $tmp 'SELECT a.title, b.url FROM moz_bookmarks AS a \
    JOIN moz_places AS b ON a.fk = b.id;'\
    | sort > /tmp/ff-bookmarks
rm $tmp

²

Run this script as a cron job. Then you need to pipe the file to fzy and open a new tab:

</tmp/ff-bookmarks fzy | awk -F'|' '{print $NF}' | xargs firefox --new-tab

The delimiter is set to | as it is both sqlite's default for columns and rare in URL titles. One caveat is that Firefox process is tied to the command invoked so browser exits with the script.

Launch programs

A more ordinary thing compared to Firefox-tabs-from-the-terminal is a general command launcher. dmenu (patch) is small and fast. It is not fuzzy (prefix completion), but here is a trick that obsoletes smart search algorithms.

dmenu package has a script that searches all executables and outputs a long list, most items in which can't be opened outside a terminal. To filter graphical applications, you can either search in .desktop files or write explicitly what you want to open:

PATH=$PATH:~/.local/bin exec $(echo "\
offscreen
firefox-esr
homm
minecraft
oblivion
pidgin
reaper
telegram-desktop
witcher1
witcher2\
"|dmenu)&

Yes, I'm a hard-working person

Open files and buffers in Neovim

Neovim has different ways to open new files or switch to already opened ones:

• :e. Not fuzzy, prefix matching for file path.
• netrw, standard and well known. Roughly half a megabyte of Vimscript. Allows only searching in current directory (no recursive search), making it useless for nested projects
• ctrlp, 40kb. Way better! I guess I can even read all of its code in around an hour. Fuzzy matching, directory cache, it is nearly ideal. But is there a simpler solution?

Yes! Having fzy, you can leverage nvim-fzy and nvim-qwahl to have a fzy-backed window appearing whenever you open files or buffers³.

One may argue that opening another TTY in a terminal emulator in an editor is simpler than executing Vimscript. As for me, the overall code base is smaller, and the perceived speed is higher.

Auto suggest from LSP in Neovim

The last example is a tool that is simple to configure⁴. The standard autocomplete tool before 0.11⁵ for me was nvim-cmp (engine) and cmp-nvim-lsp (LSP integration). blink is gaining traction still seems complex to setup. Both include a lot of code. What if you want simple autocomplete for LSP? It should be a minor middleware between LSP and the editor itself.

There is a perfect plugin mini.completion for my needs It's small, reuses editor's popup menu and sets up in a single line:

"lazy.nvim config
{ "echasnovski/mini.completion", ft = { "c", "cpp", "py", "lua" }, event = "InsertEnter", opts = {} }