Zoxide: A Better CD Command

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"))
    }

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

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.

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.

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`.

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.

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.

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

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

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

Fish was weird at first, with it's insistence on `or` instead of `||`, and `and` instead of `&&`. Since they relented on this, there's not much non-POSIX weirdness for me. From time to time I'll try to `export` something, but fish just reminds you what to do instead. 3rd party integration is excellent now, too.

When I write scripts I'll just target /bin/sh, or /bin/bash if necessary. Never saw a reason to write zsh or fish scripts.

100% this! I tried fish, loved it, then didn't use it for about a year becayse I'd convinced myself posix compliance was important. The truth is day to day I use 5 or less shell language primitives, mostly I run other programs from the shell, and pipe them into each other, so the shell language compliance doesn't matter.

I don't understand this reticence about POSIX compliance. When would you need your shell to be POSIX compliant? I've been using fish for ten years and I've never had an issue, even with scripting. If I need to run a script, it always has bash in the shebang line, so it runs normally.

Am I missing something useful?

If you work with a lot of longer commands, you can press Alt+e to edit the current prompt in $EDITOR, so you can use your favorite editor to do whatever you'd like to the command.

Oh-my-zsh adds most of that while still being POSIX compliant

This whole time I didn't know you're supposed to use alt+s. I just got mad sudo !! didn't work. Thanks!

eza was the first one I tried - that's about it for me. see https://github.com/orgs/eza-community/discussions/679 also

Can you tell me an example where this has a difference in behaviour?

Basically somewhere that source would not behave as you wanted?

I'm also uncertain what you mean wrt a binary. A binary will only have the environment variables available to the shell it's executed in - or do you mean that you'd also want it to inherit variables the binary itself might read from disk via .env files or similar?

  #!ruby
  
  if ARGV.size < 1
    puts "Usage: wz path"
    exit
  end
  
  # Get current working directory
  current_dir = "#{Dir.pwd}/"
  # puts "Current directory: #{current_dir}"
  
  # Run git worktree list and capture the output
  worktree_output = `git worktree list`
  
  # Split output into lines and process
  worktrees = worktree_output.split("\n")
  
  # Extract all worktree paths
  worktree_paths = worktrees.map { |wt| "#{wt.split.first}/" }
  # puts "Worktree paths: #{worktree_paths}"
  
  # First path is always the root worktree
  root_wt_path = worktree_paths[0]
  
  # Find current worktree by comparing with pwd
  current_wt_path = worktree_paths.find do |path|
    # puts "Path: #{path}"
    current_dir.start_with?(path) 
  end
  
  if current_wt_path == root_wt_path
    zoxide_destination = `zoxide query --exclude "#{Dir.pwd}" "#{ARGV[0]}"`.strip
    puts zoxide_destination
    exit 0
  end
  
  current_dir_in_root_wt = current_dir.sub(current_wt_path, root_wt_path)
  Dir.chdir(current_dir_in_root_wt)
  current_dir = "#{Dir.pwd}/"
  # puts "Current directory: #{current_dir}"
  
  # puts "Querying zoxide for #{ARGV[0]}"
  zoxide_destination = `zoxide query --exclude "#{Dir.pwd}" "#{ARGV[0]}"`.strip
  # puts "zoxide destination: #{zoxide_destination}"
  Dir.chdir(zoxide_destination)
  current_dir = "#{Dir.pwd}/"
  
  if current_dir.start_with?(root_wt_path)
    target_dir = current_dir.sub(root_wt_path, current_wt_path)
    puts target_dir
    exit 0
  end
  
  puts Dir.pwd
  exit 0
  
  

  # Worktree aware form of zoxide's z command.
  function w() {
   cd $(wz $@)
  }

I used to agree, but nowadays my thinking is "I use my own machines 99.99% of the time, why optimize for the 0.01%?".