████████████████████████████████████████████████████████████████████████████████
████                                                                        ████
████   ┌──────────────────────────────────────────────────────────────┐     ████
████   │  prayson@_42 ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ │     ████
████   │  $ nvim Tools.md                                             │     ████
████   │   ▶ tools                                                    │     ████
████   │     • uv run                                                 │     ████
████   │     • gh issue list                                          │     ████
████   │                                                              │     ████
████   │   $ ▋                                                        │     ████
████   └──────────────────────────────────────────────────────────────┘     ████
████                                                                        ████
████               /\_/\                                                    ████
████              ( o.o )      fox@cli                                      ████
████               > ^ <                                                    ████
████              /  _  \                                                   ████
████             /__/ \__\                                                  ████
████                                                                        ████
████████████████████████████████████████████████████████████████████████████████

Tools Reference

A comprehensive guide to all tools, utilities, and applications included in this dotfiles setup. Each tool is documented with its purpose, common usage patterns, and practical examples.

Development Tools
Command Line Utilities
Terminal & Editors
Neovim
Programming Languages
- Python
- Node.js & JavaScript
- Go
- Rust
AI & LLM Tools
Productivity Applications
Window Management
System Utilities
Dotfiles Management

Development Tools

Version Control

git

The distributed version control system. Foundation for all source code management.

git status                    # Check working tree status
git add -p                    # Interactive staging
git commit -am "message"      # Stage and commit
git log --oneline -10         # Recent commits

gh (GitHub CLI)

Official GitHub CLI for managing repositories, issues, PRs, and more directly from the terminal.

gh repo clone owner/repo      # Clone a repository
gh pr create                  # Create a pull request
gh pr list                    # List open PRs
gh issue list                 # List issues
gh run list                   # View workflow runs
gh api repos/:owner/:repo     # Direct API access

Use cases: PR workflows, issue management, GitHub Actions monitoring, API scripting

gh-dash

Interactive GitHub dashboard TUI. View PRs, issues, and repository activity. Installed as gh extension.

gh dash                       # Open dashboard

Key	Action
`j/k`	Navigate
`Enter`	View details
`/`	Search
`?`	Help
`q`	Quit

Use cases: PR review, issue tracking, repository monitoring, GitHub activity overview

lazygit

A simple terminal UI for git commands. Makes complex git operations visual and intuitive.

lazygit                       # Open in current repo

Key	Action
`space`	Stage/unstage file
`c`	Commit
`p`	Pull
`P`	Push
`b`	Branch operations
`s`	Stash
`?`	Help

Use cases: Visual staging, interactive rebasing, conflict resolution, branch management

serie

Rich git commit graph visualization in the terminal with image rendering support.

serie                         # Open commit graph
serie --order topo            # Topological order
serie --order chrono          # Chronological order
serie --preload               # Preload images for smooth scrolling

Key	Action
`j/k`	Navigate
`Enter`	Show commit details
`/`	Search
`?`	Help

Use cases: Visualizing commit history, understanding branch structure, exploring complex git workflows

gitlogue

Cinematic git commit replay tool that turns your git history into an animated story with realistic typing animations and syntax highlighting.

gitlogue                      # Start screensaver mode
gitlogue --commit HEAD~5..HEAD # Replay commit range
gitlogue --commit abc123 --loop # Loop specific commit
gitlogue --author "john"      # Filter by author
gitlogue --theme dracula      # Use specific theme
gitlogue --speed 20           # Typing speed (ms/char)
gitlogue theme list           # List themes

Use cases: Screensaver, presentations, content creation, education, visualizing code evolution

git-lfs

Git Large File Storage. Handles large files (binaries, datasets, media) efficiently.

git lfs install               # Initialize in repo
git lfs track "*.psd"         # Track file pattern
git lfs ls-files              # List tracked files

git-filter-repo

Powerful tool for rewriting git history. Faster and safer than git-filter-branch.

git filter-repo --path src/   # Keep only src/ directory
git filter-repo --invert-paths --path secret.txt  # Remove file from history

Use cases: Removing sensitive data, splitting repositories, cleaning history

difftastic

Structural diff tool that understands syntax. Shows meaningful diffs, not just line changes.

difft file1.py file2.py       # Compare files
git diff --external-diff=difft # Use with git

Use cases: Code review, understanding changes in context, syntax-aware diffs

Infrastructure & Cloud

terraform

Infrastructure as Code tool for provisioning cloud resources declaratively.

terraform init                # Initialize working directory
terraform plan                # Preview changes
terraform apply               # Apply changes
terraform destroy             # Tear down infrastructure

azure-cli

Microsoft Azure command-line interface for managing Azure resources.

az login                      # Authenticate
az account list               # List subscriptions
az vm list                    # List virtual machines
az group create -n mygroup -l eastus  # Create resource group

act

Run GitHub Actions locally. Test workflows without pushing to GitHub.

act                           # Run default event
act -l                        # List available jobs
act -j build                  # Run specific job
act pull_request              # Simulate PR event

Use cases: Testing workflows locally, debugging Actions, faster iteration

resterm

Terminal-based API client for HTTP, GraphQL, gRPC, WebSocket, and SSE. Keyboard-driven with no cloud sync - everything stays local in .http/.rest files.

resterm                       # Open TUI in current directory
resterm init                  # Bootstrap new project with templates
resterm --workspace ./api     # Open specific workspace
resterm --from-curl cmd.txt   # Import curl commands
resterm --from-openapi spec.yaml  # Import OpenAPI spec

Key	Action
`Ctrl+Enter`	Send request
`Tab`	Cycle panes (sidebar/editor/response)
`g+p`	Jump to response pane
`g+i`	Jump to editor pane
`Ctrl+E`	Switch environments
`Ctrl+G`	View captured globals
`g+c`	Compare responses (with `@compare`)

Features:

OAuth 2.0 with auto token refresh (client credentials, password, auth code + PKCE)
SSH tunnels for HTTP/gRPC/WebSocket/SSE
Workflows with @workflow/@step directives
Request tracing and timeline visualization
RestermScript (RTS) for templates and logic

Use cases: API testing, debugging webhooks, gRPC development, WebSocket testing

lima

Linux virtual machines on macOS. Uses Apple's Virtualization.framework for native performance.

limactl start                 # Start default Ubuntu VM
limactl start --name=dev debian  # Start named Debian VM
lima                          # Open shell in default VM
lima uname -a                 # Run command in VM
lima nerdctl run -d nginx     # Run containers (Docker-compatible)
lima nerdctl compose up       # Docker Compose equivalent
limactl list                  # List all VMs
limactl stop default          # Stop VM
limactl delete default        # Delete VM

Command	Description
`limactl start`	Start/create VM
`lima`	Shell into VM
`lima nerdctl`	containerd CLI (Docker-like)
`limactl stop`	Stop VM
`limactl delete`	Remove VM

Available templates:

default - Ubuntu with containerd
debian, archlinux, fedora, alpine
docker - Docker CE instead of containerd

Why lima over Docker Desktop:

Native Apple virtualization (fast, low memory)
No licensing restrictions
Automatic file sharing (~ mounted in VM)
Automatic port forwarding

Use cases: Container development, Linux testing, Docker alternative, running Linux tools

slim (docker-slim)

Container image optimizer. Minify container images by up to 30x while making them more secure by removing unnecessary files and auto-generating security profiles (Seccomp, AppArmor).

slim build my-image           # Analyze & minify image
slim build --target my-image --tag my-image.slim  # Custom output tag
slim xray my-image            # Inspect image layers & reverse-engineer Dockerfile
slim lint Dockerfile          # Lint Dockerfile for best practices
slim debug my-container       # Debug running container with sidecar
slim profile my-image         # Profile without building slim image
slim images                   # List container images

Command	Description
`slim build`	Analyze and create optimized image
`slim xray`	Inspect image, show layers, reverse-engineer Dockerfile
`slim lint`	Lint Dockerfiles
`slim debug`	Attach debug sidecar to running container
`slim profile`	Profile image without building

Build flags:

--http-probe=false - Disable HTTP probing (for CLI tools)
--include-path /path - Include additional paths
--include-shell - Keep basic shell in minified image
--copy-meta-artifacts /path - Copy Seccomp/AppArmor profiles

Example workflow:

# 1. Build and minify
slim build --target python:3.12 --tag python:3.12.slim

# 2. Compare sizes
docker images | grep python

# 3. Use generated security profile
docker run --security-opt seccomp:my-image-seccomp.json my-image.slim

Use cases: Reduce image size, improve security, optimize CI/CD pipelines, remove attack surface

temporal

Durable execution platform for building reliable workflows. The CLI includes a local development server, workflow management, and debugging tools.

temporal server start-dev     # Start local dev server (Web UI at :8233)
temporal server start-dev --db-filename temporal.db  # Persist data
temporal server start-dev --ui-port 8080  # Custom Web UI port
temporal workflow list        # List workflows
temporal workflow show -w <id> # Show workflow details
temporal workflow start --task-queue myqueue --type MyWorkflow  # Start workflow
temporal workflow signal -w <id> --name mySignal --input '{"key":"value"}'
temporal workflow cancel -w <id>  # Cancel running workflow
temporal workflow terminate -w <id>  # Force terminate workflow

Command	Description
`temporal server start-dev`	Start local Temporal Service + Web UI
`temporal workflow list`	List all workflows
`temporal workflow show`	Show workflow execution history
`temporal workflow start`	Start a new workflow
`temporal workflow signal`	Send signal to running workflow
`temporal workflow cancel`	Request graceful cancellation
`temporal workflow terminate`	Force terminate workflow

Server flags:

--db-filename <file> - Persist workflows between restarts
--ui-port <port> - Change Web UI port (default: 8233)
--port <port> - Change gRPC port (default: 7233)
--log-level <level> - Set log verbosity

SDK setup (TypeScript):

npx @temporalio/create@latest ./my-app  # Create new project
npm install @temporalio/client @temporalio/worker @temporalio/workflow @temporalio/activity

Use cases: Durable workflows, long-running processes, saga patterns, distributed transactions, reliable task queues

Database Tools

dbt

Data build tool for analytics engineering. Transform raw data into analytics-ready tables using SQL and Jinja templating.

dbt init myproject            # Initialize new project
dbt run                       # Run all models
dbt run --select model_name   # Run specific model
dbt test                      # Run tests
dbt build                     # Run models + tests
dbt docs generate             # Generate documentation
dbt docs serve                # Serve docs locally
dbt debug                     # Test connection

Command	Description
`dbt run`	Execute models
`dbt test`	Run data tests
`dbt build`	Run + test
`dbt compile`	Compile SQL without running
`dbt seed`	Load CSV files
`dbt snapshot`	Run snapshots
`dbt source freshness`	Check source data freshness

Project structure:

myproject/
├── dbt_project.yml           # Project config
├── models/                   # SQL models
│   ├── staging/              # Raw data transforms
│   └── marts/                # Business logic
├── tests/                    # Custom tests
├── macros/                   # Reusable Jinja macros
└── seeds/                    # CSV files to load

Use cases: Data transformation, ELT pipelines, analytics engineering, data modeling

mongosh

MongoDB Shell. Interactive JavaScript interface for MongoDB.

mongosh                       # Connect to local MongoDB
mongosh "mongodb://host:port" # Connect to remote

// Inside mongosh
show dbs                      // List databases
use mydb                      // Switch database
db.collection.find()          // Query documents
db.collection.insertOne({})   // Insert document

harlequin

Terminal-based SQL IDE with connection management and results formatting.

harlequin                     # Open SQL IDE
harlequin "duckdb://./data.db" # Connect to DuckDB
harlequin "sqlite:///path.db" # Connect to SQLite
harlequin "postgres://..."    # Connect to PostgreSQL

Key	Action
`Ctrl+j`	Run query
`Ctrl+n`	New buffer (editor tab)
`Ctrl+w`	Close buffer (editor tab)
`Ctrl+k`	Next buffer (editor tab)
`Ctrl+e`	Export results to CSV/Parquet/JSON
`Ctrl+s`	Save query to file
`Ctrl+o`	Open file in editor
`F2`	Focus Query Editor
`F5`	Focus Results Viewer
`F6`	Focus Data Catalog
`F9`	Toggle sidebar
`F10`	Toggle fullscreen
`j/k`	Switch tabs (in Results Viewer)

See harlequin.sh/docs/bindings for full keybindings reference. Might need Shift+Ctrl

Use cases: SQL development, database exploration, query testing, data analysis

snowsql (SnowSQL)

Snowflake's official command-line client for executing SQL queries, DDL/DML operations, and data loading against Snowflake data warehouses.

snowsql -a <account> -u <user>   # Connect to Snowflake
snowsql -c <connection_name>     # Use named connection from config
snowsql -q "SELECT 1"            # Execute query directly
snowsql -f script.sql            # Run SQL file
snowsql -f script.sql -o output_format=csv  # Output as CSV
snowsql -v                       # Check version

Key/Command	Action
`!help`	Show help in interactive mode
`!set`	Show/set session variables
`!source file.sql`	Execute SQL file
`!spool on/off`	Enable/disable output logging
`!exit`	Exit SnowSQL

Configuration: ~/.snowsql/config

Named connections:

[connections.prod]
accountname = xy12345.us-east-1
username = my_user
dbname = analytics
warehousename = compute_wh

Data loading:

# PUT local file to stage
snowsql -q "PUT file://data.csv @mystage"

# COPY into table
snowsql -q "COPY INTO mytable FROM @mystage FILE_FORMAT=(TYPE=CSV)"

Use cases: SQL development, data loading/unloading, Snowflake administration, scripting ETL pipelines

sqlit

The lazygit of SQL databases - connect and query any database from your terminal in seconds. Supports SQL Server, PostgreSQL, MySQL, SQLite, DuckDB, and more.

sqlit                         # Launch TUI, pick a connection
sqlit --mock=sqlite-demo      # Try without a real database
sqlit query -c "MyDB" -q "SELECT * FROM users"  # CLI mode
sqlit connections add sqlite --name "Local" --file-path "./db.sqlite"

Key	Action
`i`	Enter INSERT mode (typing)
`Esc`	Back to NORMAL mode
`e/q/r`	Focus Explorer/Query/Results
`s`	SELECT TOP 100 from table
`h`	Query history
`d`	Clear query
`y`	Copy query
`<space>c`	Connect to database
`<space>t`	Change theme
`Ctrl+Q`	Quit

Use cases: Quick database queries, connection management, SQL development without heavy IDE

tabiew

Lightweight TUI for viewing and querying tabular data files (CSV, Parquet, JSON, Arrow, Excel) with SQL support and vim-style keybindings.

tw data.csv                   # Open CSV file
tw data.parquet               # Open Parquet file
tw *.csv                      # Open multiple files as tabs
tw data.csv --separator '|'   # Custom delimiter
tw data.csv --no-header       # No header row
curl -s "url/data.csv" | tw   # Pipe from curl

Key	Action
`h/j/k/l`	Navigate
`b/w`	Previous/next column
`g/G`	First/last row
`Ctrl+u/d`	Half page up/down
`e`	Toggle auto-fit
`/`	Fuzzy search
`:`	Command palette
`q`	Close tab
`Q`	Quit

Commands:

:Q SELECT * FROM df WHERE price > 100    # SQL query
:S column1, column2                       # Select columns
:F price < 1000 AND qty > 5              # Filter rows
:O column DESC                            # Order by column
:schema                                   # Show loaded tables
:reset                                    # Reset to original data

Use cases: Data exploration, quick CSV/Parquet viewing, SQL queries on files, data analysis

Command Line Utilities

File Navigation & Search

fzf

Command-line fuzzy finder. Enables interactive filtering for any list.

# Basic usage
fzf                           # Interactive file finder
cat file | fzf                # Filter any input

# Integration with other commands
nvim $(fzf)                   # Open selected file in nvim
cd $(find . -type d | fzf)    # cd to selected directory

# Shortcuts (with shell integration)
Ctrl+r                        # Search command history
Ctrl+t                        # Paste selected file path
Alt+c                         # cd to selected directory

Use cases: File selection, history search, process killing, git operations

fd

A simple, fast alternative to find. User-friendly syntax and smart defaults.

fd                            # List all files
fd pattern                    # Find files matching pattern
fd -e py                      # Find by extension
fd -t d                       # Find directories only
fd -H                         # Include hidden files
fd pattern -x rm              # Execute command on results

Use cases: File searching, scripting, finding files by pattern

ripgrep (rg)

Extremely fast grep alternative. Respects .gitignore by default.

rg pattern                    # Search in current directory
rg pattern -t py              # Search only Python files
rg -i pattern                 # Case insensitive
rg -l pattern                 # List files only
rg -C 3 pattern               # Show 3 lines context
rg --json pattern             # JSON output

Use cases: Code search, log analysis, finding usages across codebase

eza

Modern replacement for ls with icons, git integration, and tree view.

eza                           # List files
eza -l                        # Long format
eza -la                       # Include hidden
eza --tree                    # Tree view
eza --icons                   # With icons
eza --git                     # Show git status

Aliases configured:

ls    # eza
ll    # eza -l
la    # eza -la
tree  # eza --tree

zoxide

Smarter cd command that learns your habits. Jump to frequently used directories.

z foo                         # Jump to best match for "foo"
z foo bar                     # Jump to best match for "foo bar"
zi                            # Interactive selection with fzf
zoxide query foo              # Show match without jumping

Use cases: Quick directory navigation, reducing cd path typing

yazi

Blazing fast terminal file manager with image preview support.

yazi                          # Open file manager
yazi /path/to/dir             # Open specific directory

Key	Action
`j/k`	Navigate up/down
`h/l`	Parent/enter directory
`Enter`	Open file
`y`	Yank (copy)
`p`	Paste
`d`	Delete
`a`	Create file
`r`	Rename
`space`	Select
`/`	Search
`q`	Quit

Use cases: File browsing, bulk operations, preview files without opening

broot

Interactive tree view with search. Navigate and operate on directory structures.

broot                         # Open in current directory
br                            # Shortcut (if configured)

Key	Action
Type	Filter/search
`Enter`	cd to directory
`alt+Enter`	Open in $EDITOR
`ctrl+q`	Quit

File Viewing & Processing

bat

A cat clone with syntax highlighting, line numbers, and git integration.

bat file.py                   # View with highlighting
bat -l json data              # Force language
bat -p file                   # Plain output (no decorations)
bat -A file                   # Show non-printable characters
bat --diff file               # Show git diff

Alias configured: cat -> bat

jq

Lightweight command-line JSON processor.

jq '.' file.json              # Pretty print
jq '.key' file.json           # Extract key
jq '.items[]' file.json       # Iterate array
jq -r '.name' file.json       # Raw output (no quotes)
jq 'keys' file.json           # List keys
curl api | jq '.data'         # Process API response

Use cases: API responses, JSON configuration, data transformation

ncdu

NCurses disk usage analyzer. Interactive exploration of disk space.

ncdu                          # Analyze current directory
ncdu /path                    # Analyze specific path
ncdu -x /                     # Exclude other filesystems

Key	Action
`j/k`	Navigate
`Enter`	Enter directory
`d`	Delete
`g`	Show percentage/graph
`q`	Quit

Alias configured: du -> ncdu

lnav

Log file navigator. View and analyze log files with filtering and highlighting.

lnav /var/log/system.log      # View specific log
lnav                          # Interactive picker
lnav -r                       # Recursive directory

Key	Action
`j/k`	Navigate
`/`	Search
`:`	Command mode
`i`	Toggle histogram
`q`	Quit

Use cases: Debug application errors, monitor system logs, analyze multiple logs

System Monitoring

btop

Resource monitor with CPU, memory, disks, network, and processes.

btop                          # Open monitor

Key	Action
`h`	Help
`m`	Toggle memory display
`n`	Toggle network display
`d`	Toggle disk display
`e`	Tree view
`f`	Filter processes
`k`	Kill process
`q`	Quit

Alias configured: top -> btop

jolt

Terminal-based battery and energy monitor for macOS and Linux. Tracks power consumption, process energy usage, and battery health in a themeable TUI.

jolt                          # Start TUI
jolt pipe                     # Output metrics as JSON for scripting
jolt debug                    # Print system and battery debug info
jolt daemon start             # Start background daemon for history
jolt daemon status            # Check daemon status
jolt history                  # View historical data
jolt theme                    # Manage themes

Key	Action
`j/k`	Navigate up/down
`Enter`	Expand/collapse process group
`K`	Kill selected process
`g`	Toggle graph (battery/power)
`t`	Open theme picker
`s`	Open settings
`h`	View history
`?`	Show help
`q`	Quit

Features:

Battery status (charge, time remaining, health, cycle count)
Power monitoring (system power draw with CPU/GPU breakdown)
Process tracking sorted by energy impact
Historical graphs for battery and power trends
10+ built-in themes with dark/light auto-detection
Background daemon for data collection

Use cases: Battery diagnostics, identifying power-hungry processes, monitoring battery health

hyperfine

Command-line benchmarking tool with statistical analysis.

hyperfine 'command'           # Benchmark single command
hyperfine 'cmd1' 'cmd2'       # Compare commands
hyperfine --runs 10 'cmd'     # Specify run count
hyperfine --warmup 3 'cmd'    # Warmup runs
hyperfine --export-json r.json 'cmd'  # Export results

Use cases: Performance comparison, optimization validation, CI benchmarking

watchexec

File watcher that executes commands on changes. Respects .gitignore, supports debouncing, handles process restarts.

watchexec -e py -- pytest             # Run tests on .py changes
watchexec -e rs -- cargo build        # Rebuild on Rust changes
watchexec --restart -- python app.py  # Restart long-running process
watchexec -w src -w tests -- make     # Watch multiple directories
watchexec -c -e js,ts -- npm test     # Clear screen between runs
watchexec -f '*.md' -- glow README.md # Watch specific pattern
watchexec --ignore dist -- npm build  # Ignore directory

Flag	Description
`-e ext`	Filter by extension
`-w path`	Watch specific path
`-f pattern`	Filter by glob pattern
`--ignore`	Ignore paths
`-c`	Clear screen before each run
`--restart`	Restart process on change
`--debounce ms`	Debounce time (default 50ms)
`-n`	No default ignores

Use cases: Auto-testing, live reload, build automation, development workflow

Text Processing

GNU coreutils

GNU versions of standard Unix utilities. More features than macOS defaults.

Configured aliases include:

cp      # gcp -v
mv      # gmv -v
rm      # grm -v
mkdir   # gmkdir -v
chmod   # gchmod -v
chown   # gchown -v

vhs

Record terminal sessions as GIFs. Write a simple script to automate your recording.

vhs record                    # Interactive recording
vhs demo.tape                 # Run tape file and generate GIF
vhs new demo.tape             # Create new tape file template
vhs validate demo.tape        # Validate tape syntax
vhs publish demo.gif          # Share recording via vhs.charm.sh

Tape file example:

Output demo.gif
Set FontSize 14
Set Width 1200
Set Height 600

Type "echo 'Hello, World!'"
Enter
Sleep 2s

Use cases: Documentation, tutorials, bug reports, showcasing CLI tools, README demos

scooter

Interactive find-and-replace in the terminal with preview.

scooter                       # Open in current directory
scooter /path/to/dir          # Search specific directory
scooter --search-text "old" --replace-text "new"  # Pre-populate

Key	Action
Type	Filter matches
`space`	Toggle instance
`Enter`	Execute replacements
`e`	Open in editor

Use cases: Refactoring, bulk renaming, batch text replacements

rename

Perl-based rename with regex support.

rename 's/\.txt$/.md/' *.txt  # Change extensions
rename 'y/A-Z/a-z/' *         # Lowercase filenames
rename 's/ /_/g' *            # Replace spaces with underscores

aliases CLI

Built-in CLI tool to view and manage shell aliases. Supports quick lookups and interactive TUI browsing with Nerd Font icons.

aliases                       # Show help and categories
aliases -s git                # Show git aliases (󰊢)
aliases -s files              # Show file operation aliases (󰉋)
aliases -d ga                 # Describe specific alias
aliases --tui                 # Launch interactive TUI browser
aliases -t                    # Short form for TUI

Key (TUI)	Action
`/`	Search aliases
`j/k` or `↓/↑`	Navigate
`Enter`	Select
`Escape`	Clear search
`q`	Quit

Categories: git files nav term pkg sys gnu fn

Use cases: Learning aliases, quick reference, discovering available shortcuts

Terminal & Editors

dawn

Distraction-free writing environment with live markdown rendering. Renders markdown as you type: headers scale up, math becomes Unicode art, images appear inline. Pairs with glow for reading.

dawn                          # Start new writing session
dawn document.md              # Open existing file
dawn -p document.md           # Preview mode (read-only)
dawn -P document.md           # Print rendered output to stdout

Key	Action
`Ctrl+F`	Toggle focus mode
`Ctrl+R`	Toggle raw markdown
`Ctrl+L`	Table of contents
`Ctrl+S`	Search
`Ctrl+N`	Jump to/create footnote
`Ctrl+Z`	Undo
`Ctrl+Y`	Redo
`Ctrl+H`	Show all shortcuts
`Esc`	Close panel/modal

Features:

Live markdown rendering (headers, bold, italic, code, blockquotes, lists)
LaTeX math expressions as Unicode art
Syntax highlighting for 35+ languages
Tables with Unicode box-drawing
Writing timer for flow sessions
Light and dark themes

Use cases: Distraction-free writing, drafting documents, markdown editing, focused writing sessions

glow

Terminal markdown viewer. Renders markdown beautifully in the terminal - the reader complement to dawn's writer.

glow README.md                # Render markdown with styling
glow -p README.md             # Pager mode (scrollable like less)
glow -w 80 README.md          # Set max width
glow .                        # Browse and select markdown files
glow -s dark README.md        # Use dark style
glow -s light README.md       # Use light style

Key	Action
`j/k` or `↓/↑`	Scroll down/up
`d/u`	Half page down/up
`g/G`	Go to top/bottom
`/`	Search
`q`	Quit

glow vs dawn:

glow = Read markdown (viewer, like less for markdown)
dawn = Write markdown (editor with live preview)

Use cases: Reading READMEs in terminal, browsing documentation, quick markdown preview

ghostty

GPU-accelerated terminal emulator. Fast, feature-rich, and highly configurable.

Configuration: ~/.config/ghostty/config

Use cases: Primary terminal emulator, tmux integration

tmux

Terminal multiplexer. Manage multiple terminal sessions in one window.

tmux                          # Start new session
tmux new -s name              # Named session
tmux ls                       # List sessions
tmux attach -t name           # Attach to session
tmux kill-session -t name     # Kill session

Leader key: Ctrl+b

Binding	Action
`leader + c`	New window
`leader + n`	Next window
`leader + p`	Previous window
`leader + "`	Horizontal split
`leader + %`	Vertical split
`leader + hjkl`	Navigate panes
`leader + z`	Zoom pane
`leader + d`	Detach
`leader + I`	Install plugins

Aliases:

iexit   # Kill current session
ikill   # Kill all sessions
iswitch # Interactive session switcher

sesh

Smart session manager for tmux. Quick switching between projects.

sesh connect project          # Connect to or create session
sesh list                     # List sessions

Configuration: ~/.config/sesh/sesh.toml

starship

Minimal, fast, customizable prompt for any shell.

Configuration: ~/.config/starship/starship.toml

Neovim

Hyperextensible text editor built on Vim. Configured with LazyVim as the base distribution.

nvim file                     # Open file
nvim +42 file                 # Open at line 42
nvim -d file1 file2           # Diff mode

Configuration: ~/.config/nvim/

Alias: n -> nvim

Vim Grammar: Speaking the Language

The key to mastering Vim is understanding its grammar. Vim commands follow a simple rule:

verb + noun

Or more specifically:

[count] + operator + [count] + motion/text-object

Once you learn this pattern, you stop memorizing commands and start composing them.

Verbs (Operators) - What you want to do:

Operator	Action
`d`	Delete
`c`	Change (delete + insert mode)
`y`	Yank (copy)
`v`	Visual select
`gu`	Lowercase
`gU`	Uppercase
`>`	Indent right
`<`	Indent left
`=`	Auto-indent

Nouns (Motions) - Where to apply the action:

Motion	Meaning
`w`	Word forward
`b`	Word backward
`e`	End of word
`0`	Start of line
`$`	End of line
`^`	First non-blank
`gg`	Start of file
`G`	End of file
`}`	Next paragraph
`{`	Previous paragraph
`f{char}`	Find character forward
`t{char}`	Till character forward
`/pattern`	Search forward

Text Objects - Structured nouns:

Object	Meaning
`iw`	Inner word
`aw`	Around word
`i"`	Inner quotes
`a"`	Around quotess
`i(`	Inner parentheses
`a(`	Around parentheses
`i{`	Inner braces
`it`	Inner tag (HTML/XML)
`ip`	Inner paragraph
`is`	Inner sentence

also i" == iq

Examples - Composing Commands:

dw      = delete word
d$      = delete to end of line
d3w     = delete 3 words
diw     = delete inner word (word under cursor)
di"     = delete inside quotes
da(     = delete around parentheses (including parens)
ci{     = change inside braces
yap     = yank a paragraph
gUiw    = uppercase inner word
>ip     = indent paragraph

The Power of Composition:

If you know 5 operators and 10 motions, you have 50 commands. Learn one new motion, gain 5 more commands. This is why Vim scales - knowledge multiplies.

Operators (5) x Motions (10) = Commands (50)

Double Operator = Line Operation:

Command	Action
`dd`	Delete line
`yy`	Yank line
`cc`	Change line
`>>`	Indent line
`gUU`	Uppercase line

The Dot Command (.):

Repeats your last change. This is why Vim users prefer ciw over bcw - it creates a repeatable atomic action.

ciw     + new text + Esc    -> .  repeats "change word to new text"

Motions & Navigation

Key	Action
`h/j/k/l`	Left/Down/Up/Right
`w/W`	Next word/WORD
`b/B`	Previous word/WORD
`e/E`	End of word/WORD
`0/$`	Start/End of line
`^`	First non-blank character
`gg/G`	Start/End of file
`{number}G`	Go to line number
`Ctrl+d/u`	Half page down/up
`Ctrl+f/b`	Full page down/up
`%`	Jump to matching bracket
`f{char}`	Find character (inclusive)
`t{char}`	Till character (exclusive)
`F{char}`	Find backward
`T{char}`	Till backward
`;/,`	Repeat f/t forward/backward
`/{pattern}`	Search forward
`?{pattern}`	Search backward
`n/N`	Next/Previous search result
`*/#`	Search word under cursor

File & Buffer Management

Key	Action
`<leader><leader>`	Find files
`<leader>ff`	Find files (Telescope)
`<leader>fg`	Live grep search
`<leader>fb`	Buffer list
`<leader>fh`	Help tags
`<leader>e`	File explorer (neo-tree)
`<leader>-`	Yazi file manager
`<leader>bd`	Delete buffer
`<leader>.`	Scratch buffer

Harpoon (Quick File Access)

Key	Action
`<leader>a`	Add file to harpoon
`<leader>1-5`	Jump to harpoon file 1-5

Git Integration

Key	Action
`<leader>gg`	Open Lazygit
`<leader>gf`	File history (Lazygit)
`<leader>Gh`	File history (Telescope)
`<leader>gl`	Git log
`<leader>gb`	Blame line
`<leader>gB`	Browse on GitHub

Code Navigation (LSP)

Key	Action
`gd`	Go to definition
`gr`	Go to references
`K`	Hover documentation
`<leader>ca`	Code actions
`<leader>cr`	Rename symbol
`<leader>cf`	Format code
`<leader>cd`	Line diagnostics
`<leader>nv`	Navbuddy symbol tree
`]d/[d`	Next/Previous diagnostic

Testing

Key	Action
`<leader>tt`	Run nearest test
`<leader>tT`	Run file tests
`<leader>tr`	Run last test
`<leader>ts`	Toggle test summary
`<leader>to`	Show test output
`<leader>tS`	Stop tests

Debugging (DAP)

Key	Action
`<leader>dm`	Debug test method
`<leader>dc`	Debug test class
`<leader>df`	Debug file
`<leader>du`	Debug function
`<leader>dk`	Debug class

AI Integration (OpenCode)

Key	Action
`<leader>oa`	Ask about code
`<leader>os`	Select prompt
`<leader>o+`	Add context
`<leader>ot`	Toggle panel
`<leader>oc`	Select command
`<leader>on`	New session
`<leader>oi`	Interrupt
`<leader>oA`	Cycle agent

UI Toggles

Key	Action
`<leader>us`	Toggle spelling
`<leader>uw`	Toggle word wrap
`<leader>uL`	Toggle relative numbers
`<leader>ud`	Toggle diagnostics
`<leader>ul`	Toggle line numbers
`<leader>uT`	Toggle treesitter
`<leader>ub`	Toggle dark/light mode
`<leader>uh`	Toggle inlay hints
`<leader>n`	Notification history
`<leader>N`	Neovim news

Text Manipulation

Key	Action
`ys{motion}{char}`	Add surround
`cs{old}{new}`	Change surround
`ds{char}`	Delete surround
`gc{motion}`	Toggle comment
`gcc`	Comment line
`>>/<<`	Indent/Unindent
`J`	Join lines
`.`	Repeat last action

Multi-cursor

Key	Action
`Ctrl+n`	Select word, add cursor
`Ctrl+Up/Down`	Add cursor above/below
`<leader>x`	Delete cursor

Splits & Windows

Key	Action
`<leader>\|`	Vertical split
`<leader>-`	Horizontal split
`Ctrl+h/j/k/l`	Navigate splits
`<leader>wd`	Delete window

Installed Plugins

Key plugins in this configuration:

Plugin	Purpose
LazyVim	Base distribution
Telescope	Fuzzy finder
neo-tree	File explorer
Harpoon	Quick file marks
Yazi	Terminal file manager
Lazygit	Git UI
nvim-dap	Debugger
nvim-cmp	Autocompletion
Treesitter	Syntax highlighting
Mason	LSP installer
Snacks	UI utilities
Catppuccin	Color scheme

Programming Languages

Python

uv

Extremely fast Python package manager, project manager, and resolver written in Rust. Replaces pip, pip-tools, pipx, poetry, pyenv, and virtualenv.

Creating Projects

uv init                       # Initialize project in current directory
uv init myproj                # Initialize project in myproj/
uv init --app --package       # Initialize packageable app (CLI, web app)
uv init --lib --package       # Initialize packageable library
uv init --python 3.12         # Use specific Python version

Managing Dependencies

uv add requests               # Add dependency
uv add pytest --dev           # Add dev dependency
uv add -r requirements.txt    # Add from requirements file
uv remove requests            # Remove dependency
uv tree                       # Show dependency tree
uv lock --upgrade             # Upgrade all dependencies

Running Code

uv run python                 # Run Python in project environment
uv run pytest                 # Run pytest
uv run --with rich python     # Run with additional package
uv run --with bpython bpython # Run bpython REPL
uv run --python 3.11 python   # Run with specific Python version

Tools (like pipx)

uvx ruff check .              # Run tool without installing (alias for uv tool run)
uvx --from textual textual-demo  # Run command from specific package
uv tool install ruff          # Install tool globally
uv tool install --with plugins pkg  # Install with extra dependencies
uv tool list                  # List installed tools
uv tool upgrade ruff          # Upgrade specific tool
uv tool upgrade --all         # Upgrade all tools
uv tool uninstall ruff        # Uninstall tool

Scripts with Inline Dependencies

uv init --script myscript.py  # Initialize script with metadata
uv add click --script myscript.py  # Add dependency to script
uv run myscript.py            # Run script (installs deps automatically)

Add shebang to make scripts executable: #!/usr/bin/env -S uv run

Python Version Management

uv python list                # List installed and available versions
uv python install 3.12        # Install Python version
uv python uninstall 3.11      # Uninstall Python version
uv python pin 3.12            # Pin project to Python version

Project Lifecycle

uv build                      # Build packageable project
uv publish                    # Publish to PyPI
uv version                    # Check project version
uv version --bump minor       # Bump version

Use cases: Project management, dependency resolution, running scripts, tool management, Python version management

pixi

Fast package manager for conda environments. Like Poetry for the conda world.

pixi init                     # Initialize project
pixi add numpy                # Add dependency
pixi run python script.py     # Run in environment
pixi shell                    # Activate environment

Use cases: Data science projects, conda ecosystem, reproducible environments

Node.js & JavaScript

node

JavaScript runtime built on Chrome's V8 engine.

node script.js                # Run JavaScript
node -e "console.log('hi')"   # Evaluate expression
node --inspect script.js      # Debug mode

bun

Fast all-in-one JavaScript runtime, bundler, and package manager.

bun run script.ts             # Run TypeScript directly
bun install                   # Install dependencies
bun add package               # Add dependency
bun build ./src/index.ts      # Bundle
bun test                      # Run tests

Use cases: Fast package installs, TypeScript execution, bundling

yarn

Fast, reliable dependency management.

yarn                          # Install dependencies
yarn add package              # Add dependency
yarn run script               # Run script

Aliases:

y     # yarn
ya    # yarn add
yad   # yarn add --dev
yr    # yarn run
ys    # yarn start
yt    # yarn test

Go

go

The Go programming language. Compiled, statically typed.

go run main.go                # Run program
go build                      # Compile
go test                       # Run tests
go mod init                   # Initialize module
go get package                # Add dependency

Rust

rust (rustc, cargo)

Systems programming language focused on safety and performance.

cargo new project             # Create project
cargo build                   # Compile
cargo run                     # Build and run
cargo test                    # Run tests
cargo add package             # Add dependency
rustc --version               # Check version

AI & LLM Tools

opencode

Open source AI coding agent with terminal UI, desktop app, and IDE extensions. Neovim-inspired interface for AI pair programming.

opencode                      # Start TUI in current project
opencode -c                   # Continue last session
opencode -s <id>              # Continue specific session
opencode -m anthropic/claude  # Use specific model
opencode run "prompt"         # Non-interactive mode
opencode run -f file.py "explain this"  # Attach files
opencode serve                # Start headless server
opencode models               # List available models
opencode auth login           # Configure API keys
opencode upgrade              # Update to latest version

Key	Action
`Ctrl+x`	Leader key
`<leader>n`	New session
`<leader>l`	List sessions
`<leader>m`	List models
`<leader>a`	List agents
`<leader>t`	List themes
`<leader>b`	Toggle sidebar
`<leader>u`	Undo changes
`<leader>r`	Redo changes
`<leader>y`	Copy messages
`<leader>c`	Compact context
`Tab`	Cycle agent (Plan/Build mode)
`Escape`	Interrupt
`@`	Fuzzy find files
`Ctrl+p`	Command list

Commands:

/init - Initialize project (creates AGENTS.md)
/undo - Undo last changes
/redo - Redo changes
/share - Share conversation link
/connect - Configure provider API keys

Modes:

Build mode - AI makes changes to code
Plan mode (Tab) - AI suggests implementation without editing

Configuration: ~/.config/opencode/opencode.json

Use cases: AI pair programming, code generation, refactoring, learning codebases

ollama

Run large language models locally.

ollama run llama2             # Run model
ollama list                   # List installed models
ollama pull mistral           # Download model
ollama serve                  # Start server

Use cases: Local AI, privacy-focused LLM usage, offline development

llama.cpp

LLM inference in C/C++. Run models efficiently on CPU.

llama-cli -m model.gguf -p "prompt"  # Run inference

LlamaBarn

macOS menu bar app for running local LLMs. Built by ggml-org (llama.cpp maintainers).

# Server runs at http://localhost:2276/v1
curl http://localhost:2276/v1/models              # List installed models
curl http://localhost:2276/v1/chat/completions \  # Chat completion
  -H "Content-Type: application/json" \
  -d '{"model": "gemma-3-4b", "messages": [{"role": "user", "content": "Hello"}]}'

Features:

100% local, 12MB native app, zero config
Smart model catalog with auto-configuration
OpenAI-compatible API
Works with any client: editors, CLIs, chat UIs

Use cases: Local LLM server, AI coding assistants, model experimentation

Productivity Applications

1Password

Password manager with CLI integration.

op signin                     # Authenticate
op item get "item name"       # Retrieve item
op read "op://vault/item/field"  # Read secret

Raycast

Spotlight replacement with extensibility. Launcher, snippets, clipboard history.

Default shortcut: Cmd + Space

Use cases: App launching, snippets, window management, calculations

espanso

Cross-platform text expander. Type abbreviations, get expansions.

# Example config
matches:
  - trigger: ":email"
    replace: "user@example.com"

Use cases: Email templates, code snippets, common phrases

Shortcat

Keyboard-driven UI navigation. Click any button with your keyboard.

Shortcut: Cmd + Shift + Space (configurable)

Use cases: Mouseless workflow, accessibility, RSI prevention

hiddenbar

Hide menu bar items. Keep your menu bar clean.

Notion

Note-taking and knowledge management.

CleanShot

Screenshot and screen recording tool with annotation.

Alt-Tab

Windows-style alt-tab window switcher for macOS.

Zen Browser

Privacy-focused Firefox-based browser with a clean, minimal UI. Emphasizes distraction-free browsing with vertical tabs and workspace organization.

Use cases: Privacy-conscious browsing, distraction-free web, Firefox extension compatibility

Window Management

AeroSpace

Tiling window manager for macOS. i3-like experience.

Configuration: ~/.config/aerospace/aerospace.toml

Key	Action
`alt + h/j/k/l`	Focus window
`alt + shift + h/j/k/l`	Move window
`alt + 1-9`	Switch workspace
`alt + shift + 1-9`	Move to workspace

Use cases: Tiling window management, keyboard-driven workflow

skhd

Simple hotkey daemon for macOS. Define custom keyboard shortcuts.

Configuration: ~/.config/skhd/skhdrc

System Utilities

stow

Symlink farm manager. Manages dotfiles by creating symlinks.

stow -d ~/dotfiles -t ~ zsh   # Stow zsh config
stow -D zsh                   # Unstow
stow --adopt zsh              # Adopt existing files

Use cases: Dotfiles management, keeping configs in git

direnv

Load/unload environment variables based on directory.

# Create .envrc in project directory
echo 'export API_KEY=xxx' > .envrc
direnv allow                  # Allow the envrc

Use cases: Per-project environment, secrets management, auto-activation

thefuck

Corrects your previous console command.

fuck                          # Correct last command

Alias configured: f -> fuck

tldr (tlrc)

Official tldr client written in Rust. Simplified man pages with practical examples.

tldr tar                      # Show tar examples
tldr git commit               # Show git commit examples
tldr --update                 # Update page cache

Installed via: brew install tlrc (installs as tldr)

wireguard-tools

Tools for WireGuard VPN.

wg                            # Show interface status
wg-quick up wg0               # Bring up interface
wg-quick down wg0             # Bring down interface

AlDente

Battery charge limiter for MacBooks. Extends battery lifespan.

Lulu

macOS firewall. Block unknown outgoing connections.

Flux

Adjusts display color based on time of day. Reduces eye strain.

Fonts

Installed fonts:

Hack - Monospace font designed for source code
Hack Nerd Font - Hack with additional glyphs/icons
Symbols Only Nerd Font - Just the icons (for yazi)

Additional Tools from install.sh

Bun

Installed via: curl -fsSL https://bun.sh/install | bash

repgrep (rgr)

Interactive ripgrep. Browse search results in a TUI.

rgr pattern                   # Interactive search

Installed via: cargo install repgrep

Dotfiles Management

update (install.sh CLI)

The primary CLI for managing this dotfiles setup. Installs, updates, and queries tools.

update                        # Full dotfiles install (idempotent)
update <tool>                 # Update single tool (auto-detects package manager)
update --versions             # Show all installed tool versions
update --versions brew        # Show versions for specific group
update --info <tool>          # Show tool info, examples, and category
update --outdated             # Show packages with available updates
update --all                  # Update everything (brew, uv, cargo, git repos)
update --only <function>      # Run specific install function
update --list                 # List available install functions
update --help                 # Show help

Version groups: brew, cask, uv, cargo, node, go

Examples:

update bat                    # Update bat (detects: brew)
update ruff                   # Update ruff (detects: uv tool)
update --info fzf             # Show fzf description and examples
update --outdated             # Check what needs updating
update --all                  # Update all package managers
update --only install_nvim    # Re-run just nvim setup

Use cases: Dotfiles installation, tool updates, version management, system maintenance

Quick Reference

File Operations

Task	Command
Find files	`fd pattern`
Search content	`rg pattern`
Fuzzy find	`fzf`
List files	`eza -la`
Disk usage	`ncdu`
File manager	`yazi`
Delete by pattern	`purge '.csv'` or `pg '.log'`

Git Operations

Task	Command
Status	`gs` (git status)
Stage all	`gaa` (git add .)
Commit	`gc "message"`
Push	`gp`
Visual git	`lazygit`
Commit graph	`serie`

Development

Task	Command
New Python project	`uv init`
Add dependency	`uv add package`
Run Python	`uv run python`
Run tool once	`uvx ruff check .`
Run TypeScript	`bun run file.ts`

System

Task	Command
Process monitor	`btop`
Benchmark	`hyperfine 'cmd'`
Correct command	`fuck`
Quick docs	`tldr command`

FilesExpand file tree

Tools.md

Latest commit

History

Tools.md

File metadata and controls

Tools Reference

Table of Contents

Development Tools

Version Control

git

gh (GitHub CLI)

gh-dash

lazygit

serie

gitlogue

git-lfs

git-filter-repo

difftastic

Infrastructure & Cloud

terraform

azure-cli

act

resterm

lima

slim (docker-slim)

temporal

Database Tools

dbt

mongosh

harlequin

snowsql (SnowSQL)

sqlit

tabiew

Command Line Utilities

File Navigation & Search

fzf

fd

ripgrep (rg)

eza

zoxide

yazi

broot

File Viewing & Processing

bat

jq

ncdu

lnav

System Monitoring

btop

jolt

hyperfine

watchexec

Text Processing

GNU coreutils

vhs

scooter

rename

aliases CLI

Terminal & Editors

dawn

glow

ghostty

tmux

sesh

starship

Neovim

Vim Grammar: Speaking the Language

Motions & Navigation

File & Buffer Management

Harpoon (Quick File Access)

Git Integration

Code Navigation (LSP)

Testing

Debugging (DAP)

AI Integration (OpenCode)

UI Toggles

Text Manipulation

Multi-cursor

Splits & Windows