I Got Tired of Typing Long Paths, So I Built JustJump

Source: Dev.to

The problem with long paths

You open a terminal, and before you can do any actual work, you type something like:

cd ~/projects/foo/

Or if you work with WordPress:

cd ~/projects/client-site/wp-content/themes/my-custom-theme/
cd ../../plugins/my-custom-plugin/

Or Drupal:

cd ~/projects/drupal-site/web/modules/custom/my_feature_module/
cd ../../../themes/custom/my_theme/

Every. Single. Time.
It doesn’t get easier with practice; it just gets annoying. Your brain already knows where everything is, but the shell refuses to use that knowledge.

Introducing JustJump

JustJump is a small Go CLI that lets you register the directories that matter and jump to them interactively with two keystrokes.

• Works across monorepos, micro‑services, client projects, and DDEV containers.
• Avoids stale shell aliases—renaming a folder won’t break your jumps.
• Complements tools like zoxide and fzf but focuses on a simple two‑level model:

Running jj inside a registered project opens an interactive picker for that project’s jump points. Running jj -G lets you switch between projects.

Because .justjump.yaml lives in the project root, you can commit it to Git. Every teammate who clones the repo gets the same jump points out of the box—no individual setup required.

Installation

Binary (no sudo)

curl -sSf https://rtech91.github.io/justjump/install.sh | bash

The binary is placed in ~/.local/bin.

Build from source

make build-release
make install

Shell integration

Copy the appropriate .justjumprc from misc/rc/bash/ or misc/rc/zsh/ into your home directory and source it:

[ -f ~/.justjumprc ] && source ~/.justjumprc

Basic usage

Register a project root

cd ~/projects/myproject
jj add -G
# -> Global jump root added: myproject -> ~/projects/myproject

Define local jump points

Create a .justjump.yaml in the project root:

jumppoints:
  - backend/
  - frontend/
  - infra/terraform/

You can also cd into any subdirectory and run jj add (without -G) to register that path directly.

Jump within a project

jj
# -> interactive picker with local jump points

Switch projects from anywhere

jj -G
# -> interactive picker with global roots

Remove entries

jj remove        # removes the current directory's local jump point
jj remove -G     # removes the current project root registration

DDEV container integration

Container paths (e.g., /var/www/html/web/modules/custom/mymodule) are painful to type repeatedly. Since container paths differ from host paths, registration must happen inside the container.

DDEV configuration (.ddev/config.yaml)

webimage_extra_packages: [golang]
hooks:
  post-start:
    - exec: curl -sSf https://rtech91.github.io/justjump/install.sh | bash
    - exec: echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.bashrc

After ddev start or ddev restart:

ddev ssh
cd /var/www/html
jj add -G

Add a .justjump.yaml at the container project root:

jumppoints:
  - web/modules/custom/
  - web/themes/custom/
  - config/sync/

Now jj inside the container provides instant navigation. If you use Zsh inside DDEV, also append to .zshrc:

hooks:
  post-start:
    - exec: echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.zshrc

Internals & design notes

• No database, no daemon—everything lives in plain files under ~/.config/justjump/.
• No silent stale paths: JustJump skips missing entries and warns you. Use jj verify for an explicit health check.
• Consistent mnemonic flags: --global / -G works the same across add, remove, verify, and jumping.

Conclusion

JustJump removes the friction between knowing where you want to go and actually getting there:

1. Register a project root once.
2. Define meaningful local jump points.
3. Run jj, pick, press Enter.

It works the same way on your laptop and inside a DDEV container.

The source code is available on GitHub: . Feel free to try it, explore the code, or share how you use it.