[Latty]

I tried zoxide for a while but I really disliked how it made things fuzzy, and most of the use cases for it I found were 90% solved by using ZSH's history search which I use routinely anyway.

It gives you this potentially constantly shifting set of shortcuts, essentially, and the problem is that means I have to constantly check I did get the result I wanted, and that I haven't accidentally gone to the wrong place. I found that more annoying to me than just using tab completions or history, which are much more predictable.

I can see how someone who has different workflows or environments might find it great though.

[robenkleene]

How are you using Zsh history to navigate to specific folders? E.g., does that mean you always start your `cd` from the home directory (e.g., `~`)? I'm asking because it's usually less key strokes to `cd` to a relative directory (assuming you're working in several related directories). But then the `cd` entry in your history would assume a specific starting path (and therefore wouldn't be universally helpful to recall from history)?

Also, re:

> the problem is that means I have to constantly check I did get the result I wanted, and that I haven't accidentally gone to the wrong place.

Is there a reason you don't add your current path to your prompt? I don't know how I'd work without that, never knowing which directory I'm in.

[nickjj]

I like using fzf combined with zsh's shell history filtering.

You can type `cd ~` and press CTRL+r to immediately fuzzy match commands you've run with `cd ~`. fzf naturally ranks paths to cd into on top. If you find that too noisy you can just hit CTRL+r with an empty prompt and then search for `^cd ~` to only find cd commands.

I've written about filtering related history with zsh here: https://nickjanetakis.com/blog/hooking-up-fzf-with-zsh-tab-c...

If you want to go into ultra lazy mode you can also type `cd ` and spam the up / down arrows to only show commands from your history where you cd'd into a directory. That use case is also covered in the above post. I normally don't use this for changing directories but it can be done.

[jvanderbot]

You don't even need history.

Just `find . -type d | fzf` to determine what dir to change to (or ~ for "anywhere else")

1. Make an alias fcd 2. Make a tab complete that does that for the command fcd

This is kind of 101 bash - just DIY.

Here's mine:

(2) is the hardest part - just write something that works with `complete` and fzf. Nowadays this is childs play for any AI to just spit out.

    fz_comp()
    {
      COMPREPLY=()
      local cur="${COMP_WORDS[COMP_CWORD]}"
      local prev="${COMP_WORDS[COMP_CWORD-1]}"
      local opts="none"
      if [ -z "$cur" ];then
        COMPREPLY=($(find $1 -type d | fzf --preview="ls {} -l"))
        return
      fi
      COMPREPLY=($(find $1 -type d | grep $cur | fzf --preview="ls {} -l"))
    }

(1) is just a) set the new command b) make the completion call c) map that call to <TAB> completion.

    alias fcd=cd
    _fcd(){ fz_comp $(pwd) }
    complete -F _fcd fcd

there you go.

[BeetleB]

If I'm reading this correctly, this will pass all subdirectories to fzf, which is very different from only directories you've visited.

[jvanderbot]

The premise is the same: Dump history into fzf and add a grep/awk.

My point was that requiring a new shell (or even history) is a limiting factor here, and either backwards search over commands (as suggested ITT), or just plan fzf directory changes are more functional and already integrated into bash.

[robenkleene]

`cd foo` is useless in history if you're not already in foo's parent directory. This is the problem Zoxide solves, `z foo` will still do something useful in that case. (Side note about fzf, recursively fuzzy finding subdirectories fine for some use cases, but it doesn't scale as well as Zoxide.)

[BeetleB]

It's (likely) simpler with zoxide + fzf.

I use autojump, which is a lot like zoxide (possible predates it). It stores all the directories you've visited in an SQLite DB (along with the rank for each). I wrote a shell keybinding that presents me with fzf, along with the directories I've visited, in rank order.

With just a few keystrokes, I can visit any directory I've ever visited, really fast. It doesn't need to be the top ranking directory for my query.

I can't live without it now.

[robenkleene]

Yeah the problem with this approach to me is populating the history with a bunch of cd to absolute paths to begin with, which is not something I'd do natural (I have many ways I'm navigating the file system), and definitely wouldn't do manually. Not having to populate that list is the advantage of zoxide.

[jvanderbot]

From 2024 when this was last posted: It appears to me that these could all be just tab complete, fzf, or similar. Some are just plain old bash.

The commands are written in rust, presumably because they're part of this warp shell advertised on readme?

I used to use this https://github.com/jodavaho/smartcd

'scd journal'

'scd logs personal'

Now I tab complete using fzf, but the above is what you want.

Bash is Turing complete. You "need" nothing else. You may want it for various reasons.

[robenkleene]

- Recursive directory tab completion isn't viable for many key use cases (it'll hang with both monorepos and networked volumes). The only thing that makes zoxide viable is that it only matches against visited directories. (Similarly fzf doesn't have much of a relation here besides encouraging recursive fuzzy matching, which I tend to avoid because it doesn't scale to complex directory structures.)

- Zoxide is probably sponsored by Warp, I doubt they have a relation beyond that, I'm not sure but they don't have much of a synergy beyond both being written in Rust. (The main point of relevance here is Warp is venture funded.)

- Zoxide having a database outside of the shell is actually a huge advantage to me, because it makes it easy to access your database outside of the shell (e.g., Zoxide integration in Vim).

[nickjj]

I think that's ok if you have absolute paths mixed in.

If I have some long path like ~/src/open-source/dotfiles or /home/nick/src/open-source/dotfiles it all works with fuzzy matching. You can hit CTRL+r and then search for "cd dotfiles" and it finds it. The ~ isn't necessary, you can also do "^cd dotfiles"` for a tighter list of matches for paths that are more ambigious with other non-cd commands.

[Latty]

It's not that I always use absolute/home-relative paths, but I'm almost always working from the same folders for the context: if I'm working on a project, I'll be in the project directory and work relative to that the vast majority of the time, for example. I also use the substring history search which makes it more useful for the equivalent to zoxide's case.

And I do have my path in my prompt, I'm not talking about something that actually takes time, but more interrupts flow (for me, as I say, I get how for other people it'd work better).

[robenkleene]

The issue for me with this approach is one: It assumes a clear root for a project (e.g., your base you're cd-ing off of), I think that's only good assumption for small-scale projects? E.g., sufficient complexity, for programming at least, necessitates modularity which dilutes the concept of a "root".

The other issue is that it creates a separate "hop" which adds key strokes and cognitive load (i.e., I can't just jump directly to a subdirectory or related directory I first have to jump to a "junction" directory then to my destination).

In any event, I could see how that would be a reasonable approach in the absence zoxide, but those are the reasons I personally still prefer zoxide. (For the record, zoxide has some nice techniques for making a match more specific, e.g., `z foo bar` will hop to a dir containing `bar` only if it's in a subdirectory containing `foo`.

[AyyEye]

Mcfly[1] takes your working directory into account when searching shell history.

From the readme:

> The key feature of McFly is smart command prioritization powered by a small neural network that runs in real time. The goal is for the command you want to run to always be one of the top suggestions.

> When suggesting a command, McFly takes into consideration:

- The directory where you ran the command. You're likely to run that command in the same directory in the future.

- What commands you typed before the command (e.g., the command's execution context).

- How often you run the command.

- When you last ran the command.

- If you've selected the command in McFly before.

- The command's historical exit status. You probably don't want to run old failed commands.

[1] https://github.com/cantino/mcfly

[fragmede]

> The directory where you ran the command.

I love that mode in Atuin. I can never remember which of the run commands to use between make/cmake/bazel/yarn/npm/uv and hitting ctrl-r twice and scrolling up is better than having to root around in a readme, which I may or may not have bothered to write for my future self.

http://atuin.sh/

McFly sounds interesting! Added it to my list of things to investigate. Does it do multi-machine syncing?

[skydhash]

You can settle on make (or just) and have consistent targets like run, test, build, deploy, etc….

I use emacs, so I have compilation buffers for those.

[fragmede]

> The command's historical exit status. You probably don't want to run old failed commands.

Yeah but the other commands I ran is so that one succeeds.

[alright2565]

There's no need to type "cd", just the folder name and hit up until you get to the right command.

[robenkleene]

That's not default behavior in most shells (e.g., `autocd` in Zsh, and, for the record, that's also not default up arrow behavior in Bash or Zsh [it is in Fish]).

But my question is specifically about relative vs. absolute paths when recalling directory traversal from history. I'm still struggling to follow how you'd use Zsh history as a zoxide replacement without always using absolute paths.

[yonatan8070]

I generally work in only a few folders (we'll call them project a, project b, project c), so once I taught it these are high priority, it just works when I type any part of their names

[Perz1val]

Same and I'm about to try the counter approach: just alias those few things

[cb321]

In Zsh with `setopt autocd cdablevars`, shell variables more or less work like cd-aliases. You could also just add `a=projectA; b=projectB; c=projectC` to your `~/.zprofile` and then at prompts type 1-letter commands `a`, `b`, `c`.

One added bonus of such file tree bookmarks via variables (over a similar `alias a='cd foo'`) is that if you get muscle-memory/active memory for those few abbreviations other use cases like `make -C $a` also work. I usually leave `$hb` & `$lb` set to `$HOME/bin` and `/usr/local/bin`, for example.

[cassepipe]

Interesting !

I have this alternative in my zsh config:

    # BOOKMARKS (mark b)
    declare -x -A bookmarks
    bookmarks=(
     d            "$HOME/Desktop"
     dd           "$HOME/Downloads"
     c            "$XDG_CONFIG_HOME"
    )
    for key value in ${(kv)marks}; do
     hash -d $key=$value
    done

Then I can just use ~c, ~d or ~dd or anything temporary I want to put there

[cb321]

`hash -d` (aka "named directories") is surely an alternative and if that suits you, by all means.

I see at least two downsides: 1) now you have to remember to say `make -C ~c` { not `make -C $c` which I think most would find more natural } 2) the hash cannot be exported to inheriting subprocesses like a regular scalar $var.

Of course, 1) is kind of weak since you can also use "~var" most places. It's just not as familiar to many as $var.

One notable equivalency is that Zsh prompt escapes for $PS1 and friends like %~ would treat both the same - converting them to a "~c" inside your prompt.

So, in terms of "looking like what you type", that maybe makes ~c better. Maybe there is some setopt to make Zsh expand %~ as $c or $dd? Not sure. There are a lot of setopts.

Anyway, I actually use the exporting feature to non-Zsh subprocesses myself. So, I'm pretty locked-in to vars not just hash entries.

[darkamaul]

The comment above is something I love about HN. I never knew this existed and would not have even thought to search for it but, but that’s something that I see me using everyday.

[cb321]

Glad to be appreciated. You might also enjoy this snippet from my zshrc:

    my-expand() BUFFER=${(e)BUFFER} CURSOR=$#BUFFER
    zle -N my-expand        # Make Alt-E expand environ vars w/o val escape
    bindkey '^[e' my-expand # Allows eVar "short cuts" for history !!:gs etc

It's vaguely related in that it lets you put a variable in the main Zsh Line Editor (ZLE) buffer (with the leading `$`) and then press Alt-E to expand it. ('e' for E)nvironment-E)xpand).

As per the comment I did this so that I could have "history substitution expressions" stored in variables, then Alt-E - look (& maybe edit) & ENTER.

The history syntax itself is very cryptic, derived from early 1980s BSD csh. As with most such crypticnesses, figuring it out once, storing it somewhere you can remember, and expanding it on demand is a not awful way to learn it.

But besides cryptic history directives you could also use it for the `$a<Alt-E>` above to "see before you do". You need an extra `$`, though, as written. It would be pretty easy to auto-add a `$` prefix in `my-expand`, though (with Alt-E just becoming a sort of different kind of TAB for expansion rather than completion).

[mrcarrot]

Yeah, I've been trying it recently and I'm not entirely convinced I want to keep using it.

My biggest annoyance at the moment (and this may be me missing something), is that I have two directories: "thing" and "thing-api". I'm doing work in "thing" much more often than in the "thing-api", but whenever I run "z thing", it takes me to "thing-api" first, and I have to "z thing" again to get to where I wanted to go. It ends up being more effort than if I'd just tab-completed or history searched a plain cd command.

[neobrain]

Perhaps helpful: There's also a `zi` command, which prompts you with a list of all matches before changing directories. Personally there's only few directories where I need it, and I just memorize using zi instead of z for those.

However I agree z should ideally have some syntax like `thing$` to denote a full directory name instead.

[dicytea]

Yeah I aliased zi to z for this reason. z feels too much like a lottery ticket.

[cycomanic]

> Yeah, I've been trying it recently and I'm not entirely convinced I want to keep using it.

> My biggest annoyance at the moment (and this may be me missing something), is that I have two directories: "thing" and "thing-api". I'm doing work in "thing" much more often than in the "thing-api", but whenever I run "z thing", it takes me to "thing-api" first, and I have to "z thing" again to get to where I wanted to go. It ends up being more effort than if I'd just tab-completed or history searched a plain cd command.

AFAIK the z command does take frequency into account (or was it most recent visit). However to avoid going into thing-api instead of thing I believe you just type thing/ i.e. At the slash and z will take you to thing (that obviously doesn't work with tab completion though).

I found that after some time I have gotten so used to z (which I aliases to cd) that I wouldn't want to live without it.

[keybits]

The aha moment for me was to type a space after the characters I'm searching for - then hit tab. You then get the list of options ranked (and a nice view showing the contents of each folder).

[paholg]

zoxide stores a rank for each directory based on how often you visit it, but you can manually adjust the scores.

Run `zoxide query -ls thing` to see the scores, and `zoxide add thing -s AMOUNT` to increase the score.

[yonatan8070]

That's good to know, when I needed to raise the score for a directory I just did a bunch of `cd .`

[cwel]

(⌐■_■)

[_kb]

If xkcd took comment form, this would be it.

[BeetleB]

I wrote a shell keybinding that presents me with the candidates using fzf (in rank order). This way I can see which one it will go to and pick the "correct" one if need be. It's blazing fast.

[eviks]

You're right, "z d" to always to always go to your downloads folder if way more powerful than whatever fuzzy match can achieve, and unfortunately the project didn't want to add a predictable input mechanism, though maybe that'll change in the future...

[sandreas]

I use fzf completitions

  source <(fzf --zsh) > /dev/null

and the ** shortcut followed by <TAB>, e.g.

  cd ~/** # <TAB>

along with cd - to change to the directory before

  cd -

[robenkleene]

This will hang if you have too many subdirectories (e.g., a good-sized company's monorepo). A networked volumes will also often cause it to hang.

(PS: In Zsh `cd -<tab>` will show a pop up menu of all directories in the history stack.)

[sandreas]

Seems to be some kind of oh-my-zsh thing... cd - <TAB> does not work on my zsh config.

[robenkleene]

Ah, good point, this isn’t `oh-my-zsh` but it does require a couple of options to work as described:

1. `setopt autopushd pushdsilent`: This is the key component, `autopushd` automatically adds directories to the directory stack (and `pushdsilent` option does it without echoing added directories). Without this option, there’s no directory stack to traverse (unless directories are first manually added to it with `pushd` [for completion, `popd` pops directories off the stack navigating back to those directories]). `autopushd` just calls `pushd` on the current directory after each `cd`.

2. To get a menu, Zsh completion also has to be loaded, e.g., `autoload -Uz compinit && compinit -C`

3. Finally `zstyle ':completion:*' menu select` is optional, but that highlights the selected match, which is a nicer UI in my opinion.

Those are the options I used to get this working with `zsh -f` (which starts Zsh with a default config).

[sandreas]

Works, is really nice, thank you.

May I (auto-)suggest:

https://github.com/zsh-users/zsh-autosuggestions

Have fun ;-)

[jalk]

in my homedir

  > fd -t d | wc -l 
  213842

takes 5 seconds.

Population doing `cd ~/**<tab>` takes way way longer than 5 seconds though.

But regardless of the speed up one could add to cd + fzf in this case, I will still be using zoxide:

  > zoxide query -l | wc -l
  1294

and `zi` starts instantaneous if I need the dynamic filtering

edit: layout