Heatseeker's latest is still listed as 1.6.1 on crates.io - it would be easier to obtain Heatseeker if this were updated.

This is for parity with Selecta's scoring_redesign_4 branch; it should fall naturally out of #2.

I'd like a way to express "Given this stdin and this --search argument, if after filtering there's only 1 remaining candidate, select it and write to stdout non-interactively, but if there's >1, go into interactive mode".

fzf has an argument -f, --filter=STR Filter mode. Do not start interactive finder., which I use to simulate this by filtering the input then checking the number of matches with wc and if there's 1 just proceeding to use the result, but piping to fzf if necessary to filter further. It's close, but what I really want is as described above.

For example, given this use case, I'd rather just get cat on stdout immediately and have hs exit 0.

printf 'cat\nrat\nbat' | hs -s cat
> cat (1/3 choices)

After cancelling hs using control-C, the terminal is left in a different state. The return key results in ^M instead of newlines, as described here.

This can be confirmed by comparing the output of stty -a | grep icrnl before and after running hs and pressing ^C. Pressing ^G instead of ^C behaves correctly.

Currently heatseeker.exe is dynamically linked with vcruntime140.dll, which is not bundled with Windows. This can be avoided compiling with

set RUSTFLAGS=-C target-feature=+crt-static
cargo build --release

When I compile 1.7.1 on NixOS unstable I get this when I run it:

 ls | hs
thread 'main' panicked at 'Spawn failed: No such file or directory (os error 2)', src/screen/unix.rs:250:23
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace.
thread 'main' panicked at 'Spawn failed: No such file or directory (os error 2)', src/screen/unix.rs:250:23
stack backtrace:
   0:     0x55d90cd17504 - <std::sys_common::backtrace::_print::DisplayBacktrace as core::fmt::Display>::fmt::hd5cf01a6458823ce
   1:     0x55d90cd361cd - core::fmt::write::h239984b34be80164
   2:     0x55d90cd15405 - std::io::Write::write_fmt::h71b3597bde52e201
   3:     0x55d90cd1a7e5 - std::panicking::default_hook::{{closure}}::h22b55119be64c15e
   4:     0x55d90cd1a520 - std::panicking::default_hook::hb52d14bb75b54309
   5:     0x55d90cd1aee5 - std::panicking::rust_panic_with_hook::hc671c362d83d7750
   6:     0x55d90cd1aa82 - std::panicking::continue_panic_fmt::h65e4009de34f6bc6
   7:     0x55d90cd1a9dc - std::panicking::begin_panic_fmt::h3ee1dd8002c2d90b
   8:     0x55d90ccf7e28 - hs::screen::unix::Terminal::stty::hd71a89a1bdf00198
   9:     0x55d90ccf8385 - <hs::screen::unix::Terminal as core::ops::drop::Drop>::drop::h345868f7de696340
  10:     0x55d90ccf454c - core::ptr::real_drop_in_place::h50fc56ce1563076b
  11:     0x55d90ccf777f - hs::screen::unix::UnixScreen::open_screen::ha34cf2a7491e9c91
  12:     0x55d90cce8d4a - hs::main::h591dcdb950c07157
  13:     0x55d90ccee6b3 - std::rt::lang_start::{{closure}}::hffae13e0b28b56eb
  14:     0x55d90cd1a913 - std::panicking::try::do_call::haa65fe754e1236a4
  15:     0x55d90cd268aa - __rust_maybe_catch_panic
  16:     0x55d90cd1b326 - std::rt::lang_start_internal::h182449fd1250c1b3
  17:     0x55d90cceb762 - main
  18:     0x7f21ef9aab8e - __libc_start_main
  19:     0x55d90cce519a - _start
  20:                0x0 - <unknown>
thread panicked while panicking. aborting.
[1]    26423 done                                        ls --color=tty |
       26424 illegal hardware instruction (core dumped)  hs

Sorry, this is kind of a brain dump. I hope you'll help me turning your tool into the core fuzzy matcher of my editor WIP. Otherwise I need to reinvent the wheel again :)

Background

Fuzzy matching is a common task and useful in many places. My use case is a better Vim like editor (https://github.com/swiboe/swiboe) which I feel driven to write after being fed up with Vim's (and other editors) shortcomings over the last 7 years writing and maintaining one of Vim's most popular plugins.

Suggested design changes

I outlined an implementation for a fuzzy matcher to test the basic design of Swiboe here. The lessons I learned so far are the following:

What you match is not what you want.

What I mean is that a potential match candidate has a text - displayed to the user and used for scoring. But when it is selected, it might return another value to the caller of the matcher - for example I might match for filenames under a certain directory, but want a fully sanitized absolute path back.

Related, a matching candidate should contain additional information - for example for a UI to display. Continuing with the file path example, you might want to attach if the file is new, added or edited inside a git repository - since the gui will draw it differently.

I think the easiest way of achieving this is to introduce a Candidate struct (as I did in my toy implementation), but make it generic over some user data T that can be queried and contain all this additional information.

Multi threaded matching and optimizations

I tested my toy matcher on ~300k of files and realized that in such cases parallel matching on many CPUs is needed. I think the library should take an optional thread pool on construction or query time and use it to match on many cores.

Related: A big optimization that i stole from YCM's matcher and I am not sure if heatseeker implements is to do a cheap filtering on the characters for each match, before doing the full subsequence match. This works like this: we use a bitset with 127 entries (ASCII only, but that does not mean it does not work for utf, it just means that all strings with utf have to be matched all the time) and set each bit for each character in the string. If a candidate has a zero where a query has a one, the candidate does not need to be matched. This comparison is super fast. If you are interested, this optimization is implemented in my toy matchers.

Sometimes you want to use heatseeker to simply pick things from a list without specifically searching for one or two of them. One use case I just tried is:

brew outdated | awk '{print $1}' | hs | xargs brew upgrade

This task kinda needs to be done by looking through all the outdated packages and wondering if you want each one upgraded or not. But you can't do that -- scrolling in heatseeker just wraps around to the top, and you can only ever see one screenful of content. I felt pretty silly just now typing a... ^T^T, backspace, b... ^T^T^T. You could also reduce your font size to like 5px and increase the line count... but this is not ideal either.

I can also imagine it being difficult to narrow down lots of very similar results, i.e. more than a screenful of /home/me/projects/bitte/neverending/path/segments/file_a.txt.

I understand selecta does not scroll either, but aim high, why not.

Multiple selections are absolutely brilliant. I use it to quickly copy boilerplate code into the current directory, selecting only the files I need.

cp "$(find ~/src/templates -type f | hs)" .

I know parsing the output of ls and friends is supposed to be evil, but for scripts for my own convenience I see no harm in it. However, it would be nice to be able to deal with output of multiple selections that have spaces in them. For example, this:

Yields:

boilerplate.tex this is a nasty file.txt assignment.tex 

So there is no way to differentiate between those files. I believe the output should be:

boilerplate.tex 'this is a nasty file.txt' assignment.tex 

or at least, there should be an option to enable enable single quotes around selections that contain spaces.

Thanks for considering 😄

so we can use like this:

rg --color ansi unwrap_or | hs | xargs vi 

skim (https://github.com/lotabout/skim) support this feature.

Heatseeker apparently doesn't work on Vim 7.4 on either Ubuntu or OS X, although Selecta works fine. Those terminals are up to their old tricks again.

Hi,

would you be interested in writing a wiki with examples that one could copy paste into it's profile? Something like Examples · junegunn/fzf Wiki

At the moment I slightly modified your example from readme and shamlessly took some bits from kelleyma49/PSFzf: A PowerShell wrapper around the fuzzy finder fzf

This way everyone could improve this snippets and benefit from other people's improvements.

$ps = $null
try {
    # On Windows 10, PSReadLine ships with PowerShell
    $ps = [Microsoft.PowerShell.PSConsoleReadline]
} catch [Exception] {
    # Otherwise, it can be installed from the PowerShell Gallery:
    # https://github.com/lzybkr/PSReadLine#installation
    Import-Module PSReadLine
    $ps = [PSConsoleUtilities.PSConsoleReadLine]
}

# cargo install fd heatseeker huniq
write-host "ctrl+t -> fuzzy select file respecting gitignore"
Set-PSReadlineKeyHandler `
  -Chord 'Ctrl+t' `
  -BriefDescription "InsertHeatseekerPathInCommandLine" `
  -LongDescription "Run Heatseeker in the PWD, appending any selected paths to the current command (respectig gitignore)" `
  -ScriptBlock {
      $choices = $(fd -H | hs)
      $ps::Insert($choices -join " ")
  }
write-host "ctrl+t -> fuzzy select any file"
Set-PSReadlineKeyHandler `
  -Chord 'Ctrl+shift+t' `
  -BriefDescription "InsertHeatseekerPathInCommandLine" `
  -LongDescription "Run Heatseeker in the PWD, appending any selected paths to the current command without respecting '.gitignore', '.ignore', '.fdignore'" `
  -ScriptBlock {
      $choices = $(fd -HI | hs)
      $ps::Insert($choices -join " ")
  }

write-host "ctrl+k -> fuzzy kill process"
Set-PSReadlineKeyHandler `
  -Chord 'Ctrl+k -> fuzzy kill process' `
  -BriefDescription "InsertHeatseekerPathInCommandLine" `
  -LongDescription "Fuzzy kill process" `
  -ScriptBlock {
      $result = Get-Process | Where-Object { ![string]::IsNullOrEmpty($_.ProcessName) } | ForEach-Object { "{0,-8} {1}" -f $_.Id,$_.ProcessName } | hs
      $id = $result -replace "([0-9]+)(.*)",'$1'
      Stop-Process $id -Verbose
  }


write-host "ctrl+r -> fuzzy reverse history"
Set-PSReadlineKeyHandler `
  -Chord 'Ctrl+shift+r' `
  -BriefDescription "InsertHeatseekerPathInCommandLine" `
  -LongDescription "Run Heatseeker on pwershell History" `
  -ScriptBlock {
      $choices = $(Get-Content (Get-PSReadLineOption).HistorySavePath | huniq | hs)
      $ps::Insert($choices -join " ")
  }

Heatseeker should detect when the terminal window has been resized and re-render the screen accordingly. It should be relatively easy to support this feature on both Windows and POSIX.

Reproduction steps:

• cd to a git repo with a dirty working copy. We'll use git to demonstrate a TTY change.
• Do git add -p. Hit return. Git sees the return and re-prints its instructions.
• echo a | hs and hit enter.
• Do git add -p again. Hit return. The return is printed to the terminal as a ^M and git doesn't see it at all.

Expected:

TTY state is unchanged after hs terminates, so git behaves in the same way.

Actual:

TTY state is permanently changed. But it only seems to affect other programs that mess with the TTY. It doesn't break shells or cat or vim. But it does break git and https://github.com/devlocker/tychus.

Details:

The TTY change is observable via stty:

$ stty
speed 38400 baud;
lflags: echoe echok echoke echoctl pendin
oflags: -oxtabs
cflags: cs8 -parenb

$ echo 'a' | hs
a

$ stty
speed 38400 baud;
lflags: echoke echoctl pendin
iflags: -icrnl ignbrk
oflags: -oxtabs
cflags: cs8 -parenb

Local configuration:

$ echo $SHELL
/usr/local/bin/zsh
$ zsh --version
zsh 5.2 (x86_64-apple-darwin15.4.0)
$ uname -a
Darwin failbowl.local 17.7.0 Darwin Kernel Version 17.7.0: Thu Jun 21 22:53:14 PDT 2018; root:xnu-4570.71.2~1/RELEASE_X86_64 x86_64
$ hs --version
heatseeker 1.5.2 multi-threaded (cb2de6c) (built 2018-07-28 05:51:19 -0000 for x86_64-apple-darwin)

It's still at 1.5.0 - cargo install seems like the most convenient way to install HeatSeeker to me, so I'd appreciate this.

Thanks.

I installed via Chocolatey. It works correctly in a Windows cmd shell, but running ls | hs.exe just hangs forever in an MSYS shell or Git Bash shell.

(Possibly also worth noting that ls | selecta in the same shell gives me an error:
selecta:829:in 'spawn': No such file or directory - /dev/tty (Errno::ENOENT))

As an example of where this is a problem, I can run a command like:

locate '.' | hs

which causes:

thread 'main' panicked at 'called Result::unwrap() on an Err value: Custom { kind: InvalidData, error: StringError("stream did not contain valid UTF-8") }', libcore/result.rs:945:5

This is the result of some directory or filename somewhere in my system not being encoded in UTF-8.
There's a number of places this error could possibly come from, the one that stands out first is src/main.rs:283, which is:

stdin.read_line(&mut s).unwrap();

But there looks like there's probably a lot of potential places where input to heatseeker is assumed to be UTF-8. If this were a shell script, I'd be using something like the following:

iconv -f 'UTF8' -t "ASCII//TRANSLIT" -c < input_file > output_file

I think in heatseeker's case, transliterating would be a better way to handle user input than panicking. When I have the chance, I'll look around in rust's APIs and see if I can find the rust equivalent for this.

Some distros don't necessarily have stty at /bin/stty, but /usr/bin/env is slightly more standardized.

(I'd offer a patch but I'm currently a total Rust illiterate .)

There should be a dedicated thread reading keystrokes into a queue, so that buffered keystrokes can be read all at once. The Unix implementation has always done this, it just needs to be coded up on the Windows side as well.

Currently I have the below setup. My folder heirachy is about 200k files and the suggested solution has a 10 to 15 second response time. To make hs respond immediately I have a cache of the directory contents which I can rebuild with ctrl-alt-s.

It's not the ideal solution. What would be nice is a companion tool that keeps the cache up to date by monitoring the file system. Not sure if this is possible in a general way. Just though I'd throw this out to you. Great tool by the way. Even with rebuilding the cache manually it's awesome.

# Trigger fuzzy search
Set-PSReadlineKeyHandler `
     -Chord 'Ctrl+s' `
     -BriefDescription "InsertHeatseekerPathInCommandLine" `
     -LongDescription "Run Heatseeker in the PWD, appending any selected paths to the current command" `
     -ScriptBlock {
         $choices = [IO.File]::ReadAllText($(Resolve-Path .hscache)) | hs
         $ps::Insert($choices -join " ")
    }


# Rebuild cache
Set-PSReadlineKeyHandler `
     -Chord 'Ctrl+Alt+s' `
     -BriefDescription "RebuildHeatseekerPathInCommandLineCache" `
     -LongDescription "Rebuilds the heatseaker cache" `
     -ScriptBlock {
         $job = start-job {
             param($path)
             Get-ChildItem -Name -Attributes !D -Recurse $path > $path/.hscache
         } -arg $(pwd) 
         while( $job.State -ne "Completed") {
                Write-Progress -Activity ".hscache-build " -Status $(get-childitem .hscache).length
                sleep -m 200
         }

        Write-Progress -Activity ".hscache-build" -Completed
    }

Heatseeker currently panics because system call interruption is apparently not being handled correctly.

Nowadays crossbeam is on version 0.7. 0.2 is really old and in order to package heatseeker for Fedora, we need this update.

Motivation

Use heatseeker for:

Quickly navigating log files

Entries in a log file can be matched using

^\d{2}\.\d{2}\.\d{4}

Each entry may span multiple lines.

Filtering the list of flags of a command, obtained from the man page or using cmd --help.

The following yields the list of flags of the cal command:

regex="^ *-.*\n.*"
man cal | col -b | rg -Uo "$regex"

Excerpt:

-1      Display only the current month. This is the default.                                                                                                                                                       
-A      number                                                                                                                                                                                                                  
    Months to add after. The specified number of months is added to the end of the display. This is in addition to any date range selected by the -y, -3, or -1 options. For example, “cal -y -B2         

An entry may span multiple lines. Searching for months in heatseeker should show the whole entry:

-A      number                                                                                                                                                                                                                  
    Months to add after. The specified number of months is added to the end of the display. This is in addition to any date range selected by the -y, -3, or -1 options. For example, “cal -y -B2         

Additional context

This feature request is inspired by rofi, a GUI fuzzy selector for X11 and compile-mode in Emacs.

This will obviously result in huge performance gains. Note that this will depend on upcoming language and library features (cf. Improve the Send trait). Alternately, the parallelization could be implemented in unsafe code.

This bug seems to occur randomly after hitting enter to make your selection:

stty: 'standard input': unable to perform all requested operations                    
thread 'main' panicked at 'called `Option::unwrap()` on a `None` value', src/libcore/option.rs:378:21                                                                       
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace.  

It's most easily explained with a quick video.

15s video of bug

I recorded until I got a success followed by a failure. Note the difference wasn't due to the names selected (dir a in the case of success; file create_public in the case a failure): the same command, in succession, has produced success and failures on both, as I was playing around.

Machine / Install Info:

• Mac 10.12.6
• HS installed 2 days ago using Homebrew
• GNU bash, version 5.0.2(1)-release (x86_64-apple-darwin16.7.0)

I use heatseeker to search through my shell history to find previously used commands lines.

MSG=$(history 1 | sort -n -r | sed -e 's/\s*[0-9]*\s*\(.*\)/\1/' | ~/bin/heatseeker -F)

The clue here is that when I startup heatseeker, the last used command is at the top and the oldest is at the bottom. If I now start typing, I get the results sorted by score - which is not what I want. I want to keep them chronologically, so that I can find the most recently used commands at the top.

Essentially, I want a 'filter only, do not sort' mode.

It would never have occurred to me in a million years to use CTRL+T as the selector, my first guess would always be spacebar, which is what other apps I've experienced in the past have used.

Is it possible to add support for spacebar?

Since the common case consists of appending characters to the query, it makes sense to annotate the matches with additional state information (essentially the index of the last matched character, as of the last query performed). This will enable incremental scoring, instead of computing scores from scratch for a given string.

I looked into that really quickly, but it seems a bit more involved. It would be very useful though since on some keyboard (kinesis advantage) and keymaps (Neo2) the cursor keys are much easier to reach than the ctrl-* cords.

Hi,

I'm using heatseeker and after I activate it, some console programs appear not to be able to receive keyboard input, particularly ones that take over the console and one might want to ^C out of. The shell itself is fine, and not all console programs seem affected.

Steps to reproduce.

1. Open PowerShell
2. Run echo a | hs and press enter
3. Run ping -t google.com

Expected outcome:

I should be able to press Control+C for ping to stop pinging.

Actual outcome:

Pressing Control+C does not stop pinging.

Remarks:

ping is not the only program affected by this. I first noticed this when running the hugo server, but I don't think everyone has that installed. The node-js repl is notably not affected, and in fact kind of "resets" the state of the shell. That is to say, I can run echo a | hs, press enter, run node, exit that repl normally, then ping -t google.com and I will be able to ^C out of that as I'd expect. I have no idea if that would be helpful to you for troubleshooting.

System information:

hs --version
heatseeker 1.6.0-3a43ab5 (built 2018-11-11 21:32:06 -0000 for x86_64-pc-windows-msvc)

$PSVersionTable.PSVersion

Major  Minor  Patch  PreReleaseLabel BuildLabel
-----  -----  -----  --------------- ----------
6      1      3

[Environment]::OSVersion

Platform ServicePack Version      VersionString
-------- ----------- -------      -------------
 Win32NT             10.0.17763.0 Microsoft Windows NT 10.0.17763.0

Thank you. If there's anything else you need from me that would be useful, please let me know.

It would be nice if shift-tab worked to go to the previous match, I'm used to that kind of setup.

Great tool by the way!

The compile completes just fine, however when I call the resulting binary later, it doesn't see to get the input string I pass it via STDIN:

projects/heatseeker [3d|master*] cargo build --release
   Compiling libc v0.1.10
   Compiling unicode-width v0.1.3
   Compiling winapi v0.2.2
   Compiling winapi-build v0.1.1
   Compiling num_cpus v0.2.6
   Compiling log v0.3.1
   Compiling kernel32-sys v0.1.4
   Compiling getopts v0.2.13
   Compiling time v0.1.32
   Compiling heatseeker v1.3.0 (file:///C:/Users/q284114/projects/heatseeker)
projects/heatseeker [3d|master*] cp target/release/hs.exe ~/bin
‘target/release/hs.exe’ -> ‘/cygdrive/c/Users/muellerj/bin/hs.exe’
projects/heatseeker [3d|master*] which hs
/cygdrive/c/Users/muellerj/bin/hs
projects/heatseeker [3d|master*] echo "foo\nbar\baz" | hs

  [ Here, nothing is displayed, I eventually kill it with ^C ]

projects/heatseeker [3d|master*] hs --help
Usage: C:\Users\muellerj\bin\hs.exe [options]

Options:
    -h, --help          Show this message
    -v, --version       Show version
    -s, --search [SEARCH]
                        Specify an initial search string
    -f, --first         Automatically select the first match
    -F, --full-screen   Use the entire screen in order to display as many
                        choices as possible

The 'heatseeker' project name causes Cargo to produce an executable named heatseeker (heatseeker.exe on Windows); I'd prefer this to just be hs, ideally without having to rename the entire project in Cargo.

Although matching itself is basically Unicode-aware (or at least code point aware), input is handled a byte at a time, under the antiquated assumption that a byte is a char. This strategy obviously breaks when you want to type "東欧を覆う" or "☃" or even just "Mötley Crüe" as part of a query.

I'm not sure if the Rust standard library has an online algorithm that converts a stream of bytes into a stream of chars; that is the only part that might be slightly tricky.

As far as I know, Ctrl+s is the keybind for the function to search history forward interactively, set as a pre-defined default by PSReadLine.

Is this something that should maybe be mentioned in the example in README.md?

And if I may ask, did you pick Ctrl-S intentionally here? I mean that interactive history search forward does not really seem useful to me. Can't remember that I've actually used it for myself.

It would probably be helpful to document some of the available keyboard commands in the README, especially Ctrl+T!

The following test case works as far as Unicode goes (outside of Windows), but the choices wrap around the screen several times and break the UI (tested on Linux, not yet reproduced on OS X):

python3 -c '[print("☃foo" * 20) for i in range(30)]' | hs

I am using heatseeker for my reverse-search implementation (the one coming up when pressing ctrl+R in bash/zsh), and noticed that it doesn't behave intuitively to me quite yet because some keybindings are missing.

Would you like me to contribute support for this?

These can be hosted as ordinary GitHub releases for now; standalone executables should work fine for almost everyone. In the long term, it would be nice to support package managers, particularly Homebrew and Choco.

Note that before any releases are performed, the initial version number should be nailed down.

Would crates.io make any sense for hosting hs? Because apparently there's a selecta crate.

If I'm looking for a file called

10_inch_nails_spiral_type.bin

very often I might type

.binspiralnail

but hs will only match if I wrote

nailspiral.bin

I suggest allowing out of order matching by splitting groups on spaces

.bin spiral nail

and then in-order matching occurs in groups with no spacing and out of order matching can occur between groups. You would probably want to make this an option.

choices | hs --out-of-order-delimter=' '