Hey there are a lot of great client tools out there and everybody has it set up differently to suit their own workflow.

And sometimes these things can be quite tricky to set up, but I personally have been enjoying the way my terminal functions. So hey, let me show you how I have mine set up so that you can take some of these tools and ideas and put them together and forever change the way you use your terminal.

I also want to mention that I'm going to be using Homebrew to manage and install all the tools I'm going to be using today.

I always have auto-completions and highlightings on my system, so I need to quickly install that on my terminal first.

Once you've done that, you can now take these lines and copy them and then paste them in your RC file. You could also use the same exact lines that I'm using right here, or you could just paste the ones that you just copied from your terminal.

Once you've done that, you can now go ahead and save your RC file and don't forget to source it. Now we can see that the auto-completions are working and the syntax are working correctly.

So with that out of the way, we can now move on to the next one.

Mas CLI is a terminal app store manager that lets you easily control and manage your apps downloaded from the App Store because we all know how bad App Store can get.

I personally don't want to have to ever open App Store to update anything. To install Mas, we're going to do `brew install mas`.

I've already had that installed, so I'm not going to do that. Mas has many commands, for example, if we check for `mas list`.

It shows a list of apps and their versions downloaded from the App Store. We can also go in and grab some of these app IDs so that we can use it for other commands.

So, for example, I grabbed one of Neovim's and now I'm going to check for the `mas info`.

So I'm going to paste that ID in and you'll see that it gives us the version of the app, free or paid, and other information like the OS or the size of the app.

`mas outdated` will check for any outdated apps. `mas upgrade` will install any updates you have downloaded from the App Store.

This is great because sometimes the App Store doesn't show the updates and auto-updates don't function properly. This helps a lot with Xcode command line tools, if you know what I mean.

We could also use `mas search` followed by the name of the app to search for specific apps.

You can download things from the App Store using `mas purchase`. If you want to know more about these, there are more commands you can read on their GitHub page.

I just like the fact that I don't have to open the Mac App Store because it's just not that great.

Fuzzy find your directories with `fzf`. Search your files effectively in the terminal. This is a must-have for me. The less I have to `cd` the better.

To install `fzf`, we can run `brew install fzf`. I also use `fd` instead of `find` and `bat` is another must-have tool.

`bat` is like `cat` replacement with colors for your code views. So `brew install bat` as well. This is what `bat` does, it gives you a highlight when you `cat` out a file, and this is really nice, especially if you combine this with `fzf`.

Once you have `bat` installed, we can go back into our RC file and add this line to initialize fzf for use with your shell.

Most importantly, don't forget to save, quit, and source it.

Then you can check if FCF is properly installed by running `fzf`, and if it does prompt you something, that means you're good to go.

Or you could run `fzf --version` to check. Going back into our RC file, and if we go down and check our first fzf default command setup, we basically have this first command as the default fzf command using FD to search with the hidden flag to show the dot directories.

And this flag will make things a little bit cleaner. And we are also going to be excluding the `.git` files. The Control-T command will be set equals to the first command.

The third one is the option C or Alt-C command, which will only search for directories. This line is going to be the default options set for fzf: borders and height and colors.

And the next one is going to set FCF especially for tmux because fzf and tmux work a little bit differently.

Let's take a look at how Control-T works. So when I do Control-T, it gives me this filter of every single file in my current directory.

And then I can start fuzzy searching through that. So I'm just going to jump to the block animation projects that I have and then press Enter.

And then there you go. Now for Option-C, when I press Option-C, I can just jump straight to the directory that I'm searching for instantly.

For my use case, sometimes I just do `nvim` and then type Control-T, and then that will fuzzy find me through every single thing.

So let's go to block animation and then Enter to get into Neovim or your editor. You can also do the same thing if you are using VS Code.

So, 'cd' control, select the directory you want to go to and press enter, and it will jump you there.

I also have an alias set up for this, so I basically use the alias with the script to allow me to fuzzily search through the history files that I opened with Neovim and open me in the editor.

Taking a quick look at the script, you can see that we have this function.

The first line is going to check for Neovim files and grab them, and then the second block will basically just filter the old files we got from Neovim.

And then the third one is just the FCF selection and just some preview that we specifically made for this to work.

Next one checks if the files are selected. If they are, they're going to be opened in Neovim. And then lastly, we are just going to invoke the function so that it works in Zsh.

Also, if this was the first time you are writing and saving a script, don't forget to execute the script with this `chmod` command.

So, let me just go ahead and copy that, and then you can just save, quit, go back to your shell and run that command.

Going back to the Zshrc file, you can see that I have an alias set as NLF, and the path is set to the scripts.

So, it depends on where your script is located. But if you prefer to just write the script in your RC file, you can do that.

Taking a quick look at this again, I can NLF go into the file with Neovim and then quit.

It is so useful and really handy when you want to quickly edit something and just get out.

of it. I also have an alias setup for using fuzzy find with man pages. What this alias allows me to do is quickly search through any man pages and open them up.

So for example, I can do `fman` and search for the Git man pages and then I can just quickly look through that.

I find this really useful when I want to quickly look for some man pages, but of course you can just run the command `man` `git` or something like that.

Talking about man pages, we also have another tool called `tldr`. This one is very similar to `man git` except that it only brings up the key commands that are most commonly used.

I use this when I actually want to just quickly get the command and not get into the details of the tools. To install, we can do `brew install tldr` then we can start running `tldr` followed by the tool that you want to run.

You can go ahead and read through that if you want to. This one is really nice to have. It is basically `fzf` integrated with Git. Let me just show you real quick.

So I have that sourced in here into my file, basically from the path of my scripts folder. So this is his GitHub right here, `fzf-g`.

You can go and check out the repo. To use it, I'm basically just going to clone it, but I already have it installed on my system, so I'm not going to clone it again.

But you can go ahead and run `git clone` and paste that link in and then clone it to whichever folder or scripts you want to clone into.

The only commands I use from this is to check for Git branches or remotes or worktrees.

So going back to our terminal really quickly, now jumping to a project, that has a Git remote in it.

I can press Ctrl+G B for all the branches, Ctrl+G R for all the remotes, and then Ctrl+G W for work trees.

Zoxide is similar to `cd`. It remembers the path you typed in without having to type it out fully. You need to type out the full directory the first time you use Zoxide for it to remember.

Now to install Zoxide, we're going to use Brew.

So, `brew install zoxide`. Then you need to go to your `.zshrc` file and then add this line to initialize Zoxide.

Save it and source the file. Now we can run Zoxide followed by the directory you want to go to. Press enter and it should jump you there.

Pressing `z` again will just jump you back to home. Now it remembers `desktop`, so I can just type `z es`. And if you want to go to, for example, `projects`, I can do `z projects`.

Now we remember the `projects`, so all we have to type is `z pro` and it jumps me to `projects`.

You can basically jump anywhere you want using that, even with a directory that is about six to seven levels deep. So like this one, you can see that it's actually seven levels deep.

Zoxide is based on recency, meaning that it will prioritize the directory you jumped to most recently, so it will not clash.

I have another script for Zoxide which allows me to search through every file and open it into Neovim and not just history files.

If we go and check our RC file, I have an alias set to `nz` which will call the script in my scripts folder. Going back to the script, we can see that our first block here is going to be responsible for checking if there is an argument provided with the `nz` command.

If there is no argument, it will call FZF using FD with the following options from FZF.

The second block checks if an argument is provided.

So if there's only one match, it will open it directly into Neovim, but if there are multiple matches, then it will use FZF to filter it out again, and then you can select the one you want to open into Neovim.

So for example, if we run NZ right now and search for the files we want to go to, for example, this one, it will jump straight into that file.

Let's go to `main.jsx`, and there we go. You could even take it up to a next level and go set an alias from `cd` to Zoxide instead, but I personally would like to keep `cd` and Z separate.

Next up is Eza. Eza is like `ls` on steroids.

I use Eza for the sanity of my eyes. This here is just the basic Eza, but we can configure Eza to another level, so you can go check their repo if you want to customize it a little bit more.

You'll see that I have icons, time, and date on the left side of it. So in my RC file, I basically have an alias of `ls` set to Eza.

So if we go to that alias, you can see that we have options in there. So for example, if we take no file size and save and source it, the file size is gone.

Let's go back and remove the icons so you can see it more clearly. If we go back into our RC file, we already have Eza piped into FZF option `c` as piped into it.

I currently have my Eza set to long, which means that my LS is going to be in the list, but if you change that to a grid, source the file, and you can see that it is now in a grid with those icons.

If we quickly take a look at our option C, you'll notice on the right side that our eza previews are also working in fzf, and of course, we can add the icons to this too.

Next, we have the duck. Yazi is a terminal file manager built on Rust.

I've been trying this out a lot, and I do kind of like it. I feel like it's a good thing to have in your terminal.

So to install Yazi, we are going to still use Homebrew to install it. Running `yazi` will give us this window.

Using the up and down arrows to navigate in the current directory, left and right to the next and previous directories. Now I'm going to set up some more configurations for Yazi by creating a `yazi` directory in my `.

config`. Now we are going to add the `yazi.toml` file, the `keymaps.

toml` file, and the `themes.toml` file. Then we are going to create a `flavors` directory and download the themes from GitHub into this directory.

If you head to the Yazi GitHub repo, you can find some of the configurations already preset for you. So I am just going to copy this `keymaps`.

I can see some of the Vim keymaps that I kind of need, and we're just going to paste it in our `keymaps.

toml` file. We can now run `yazi` to check if the keymaps are actually working. So we can use JK to move up and down, L to go into the next directory, and then H to go to the previous directories.

Next, we are going to go set the themes, so I'm going to head to the repo, and the theme I'm going to be using is Catpuccin.

So we're going to copy that and paste it here. So now we can go to our `themes.

toml` file, and now we can add the flares configuration in here. So copy that, paste it, and then save it.

Now we can run `yazi` to check if the themes are being applied, and yes, they are.

And finally, we are going to be configuring the `yazi` configuration file. For me, I don't really have anything much to configure for `yazi`.

I'm okay with the default options, so we're going to go ahead and copy it from the GitHub. The only thing I'm going to be changing is to be able to use `yazi` to open Neovim from the `yazi` window itself.

So by default, it comes with the Vim editor, but I am going to change it to Neovim.

For some reason, there is a bug that doesn't allow the create title to be an array, which is what it comes with by default.

I'm guessing the first one is for creating a file, and the second one is for creating a directory, but it doesn't work right now, so we can just pick one.

8 Command Line Tools that will Change Your Terminal Experience

8 Command Line Tools that will Change Your Terminal Experience

Scripts