Cli Power Tools

Utility Pro

Overview

Masters the command-line environment by turning raw text and unstructured data into actionable insights. Combines Rust-powered search tools (ripgrep, fd, bat), structured data shells (Nushell), JSON manipulation (jq/yq), and modern HTTP clients (xh) for high-performance CLI workflows.

Core philosophy: Replace legacy text-parsing pipelines (grep/awk/sed chains) with purpose-built tools that understand structure. ripgrep understands gitignore rules, fd understands file types, jq understands JSON, and Nushell understands tables.

When to use: Codebase-wide search and analysis, multi-file refactoring, JSON/YAML transformation pipelines, API debugging, directory navigation, log parsing, disk usage auditing, dependency tracing.

When NOT to use: GUI-based tasks, complex application logic (write a script instead), tasks requiring interactive prompts.

Quick Reference

Tool Overview

Common Mistakes

Installation

All tools are available via common package managers. Most are single statically linked binaries.

Shell integration (add to shell config after installing):

Delegation

• Large-scale codebase search and analysis: Use Explore agent to run ripgrep queries, trace dependencies, and map code patterns
• Multi-file refactoring workflows: Use Task agent to coordinate fd, sed, and verification steps across an entire project
• Pipeline architecture for data transformation: Use Plan agent to design structured pipelines combining jq, Nushell, and API tools

References

• Modern Unix Toolbox -- ripgrep, fd, bat, zoxide, fzf, eza, terminal setup
• Advanced Regex and jq -- named captures, lookahead/lookbehind, jq filters, integrated pipelines
• Nushell Structured Data -- table paradigm, API interaction, scripting, Unix interop

Advanced Regex and jq

Regular Expressions

Key Features for CLI Usage

Log Parsing Pattern

Parse structured log lines into named fields:

# Pattern for: "2026-01-30 14:30:45 ERROR [auth] Login failed for user@example.com"
rg -P '^(?P<timestamp>[\d-]{10} [\d:]{8}) (?P<level>INFO|WARN|ERROR) \[(?P<module>[^\]]+)\] (?P<message>.*)$' app.log

Practical Regex Examples

# Find all import statements for a specific module
rg "import .+ from ['\"]@/lib/auth"

# Match function declarations (TypeScript)
rg -P "(?:export\s+)?(?:async\s+)?function\s+\w+"

# Find all TODO comments with ticket references
rg -P "TODO\((?P<ticket>[A-Z]+-\d+)\)"

# Extract all URLs from a file
rg -oP "https?://[^\s\"'<>]+"

# Find duplicate consecutive words
rg -P "\b(\w+)\s+\1\b"

Performance Tips

• Prefer non-capturing groups (?:...) over capturing (...) when you do not need the match
• Use rg -P for PCRE2 when you need lookahead/lookbehind
• Use --only-matching to reduce output noise in pipelines
• Avoid .* at the start of patterns; anchor with ^ when possible

jq: JSON Manipulation

jq is a full functional programming language for JSON data.

Essential Filters

# Create array of IDs from nested objects
jq '[.items[].id]' data.json

# Filter objects by field value
jq '.[] | select(.status == "active")' data.json

# Update a specific field in-place
jq '(.user.role) |= "admin"' data.json

# Sum an array of numbers
jq '[.[].amount] | add' data.json

# Group by field and count
jq 'group_by(.module) | map({module: .[0].module, count: length})' logs.json

# Flatten nested arrays
jq '[.categories[].items[]]' data.json

# Conditional transformation
jq '.[] | if .price > 100 then .category = "premium" else . end' data.json

Common Patterns

# Extract IDs from nested array where status is active
jq '.projects[] | select(.status == "active") | .id' data.json

# Get error count per module from JSON logs
jq -r 'group_by(.module) | .[] | {module: .[0].module, count: length}' logs.json

# Merge two JSON files
jq -s '.[0] * .[1]' base.json overrides.json

# Convert JSON to CSV
jq -r '.[] | [.name, .email, .role] | @csv' users.json

# Pretty-print with sorted keys
jq -S '.' messy.json

yq for YAML

yq uses jq-like syntax for YAML files:

# Read a nested value
yq '.config.database.host' config.yml

# Update a value
yq -i '.config.port = 8080' config.yml

# Convert YAML to JSON
yq -o json config.yml

Integrated Pipelines

The real power comes from combining tools in pipelines.

# Find all API endpoints in the codebase and list unique URLs
rg -oP "fetch\(['\"]([^'\"]+)['\"]" --no-filename | \
  sed "s/fetch(['\"//" | sed "s/['\"])//" | \
  sort | uniq -c | sort -rn

# Find all exported functions and count by file
rg -c "^export " -g "*.ts" | sort -t: -k2 -rn

# Extract all environment variable references
rg -oP "process\.env\.(\w+)" --no-filename | sort -u

# Audit disk usage of source directories as JSON
du -sk src/*/ | jq -Rs 'split("\n") | map(select(. != "") | split("\t") | {size: .[0] | tonumber, path: .[1]}) | sort_by(.size) | reverse'

Modern Unix Toolbox

Modern Unix utilities, primarily written in Rust, prioritize speed, safety, and human-friendly defaults over their legacy counterparts.

ripgrep (rg)

The gold standard for text search. Faster than grep, ag, and git grep. Respects .gitignore and skips binary/hidden files by default.

# Basic search with context
rg "auth-error" -C 3

# Search only in TypeScript JSX files, excluding tests
rg "auth-error" -g "*.tsx" -g "!*.test.*" --stats

# List only files with matches (no content)
rg -l "TODO"

# Match whole words only
rg -w "user"

# Define custom file type and search it
rg --type-add 'web:*.{html,css,js}' --type web "pattern"

# Output matches as JSON (pipe to jq for structured analysis)
rg "TODO" --json | jq 'select(.type == "match") | .data.lines.text'

# Search with PCRE2 for advanced regex features
rg -P "(?<=function\s)\w+" --only-matching

fd

A simple, fast alternative to find. Colorized output and smart case-sensitivity by default.

# Find all PDF files
fd -e pdf

# Find files matching a pattern in a specific path
fd "config" /path/to/search

# Execute a command for every result
fd -e tsx -x prettier --write {}

# Find and delete all .DS_Store files
fd -H .DS_Store -x rm -f {}

# Find directories only
fd -t d "test"

# Find files modified in the last hour
fd --changed-within 1h

bat

A cat replacement with syntax highlighting for 100+ languages and Git integration.

# View file with full decorations
bat --style=header,grid,numbers file.ts

# View specific line range
bat -r 10:20 file.py

# Show non-printable characters (debug encoding issues)
bat -A file.txt

# Use as a pager for other tools
rg "pattern" | bat -l ts

# Plain output (no decorations, useful in pipes)
bat --plain file.ts

zoxide (z)

Intelligent directory jumping that remembers where you have been.

# Jump to best match for "project"
z project

# Go back to previous directory
z -

# Interactive selection using fzf
zi

# Add a directory to the database manually
zoxide add /path/to/project

# List all tracked directories ranked by frequency
zoxide query --list

fzf (Fuzzy Finder)

The glue of the modern CLI. Provides interactive fuzzy search for files, history, and any list.

# Interactive file selection
fzf

# Search through command history (keybinding)
# CTRL-R

# File search with preview
fzf --preview 'bat --color=always {}'

# Pipe any list into fzf for selection
git branch | fzf | xargs git checkout

# Multi-select mode
fd -e ts | fzf -m | xargs bat

Keybindings (when configured):

eza

A metadata-rich ls replacement with tree views and Git status integration.

# Tree view with depth limit
eza --tree --level=2

# Show all files with git status and icons
eza -la --git --icons

# Sort by modification time
eza -l --sort=modified

# Show only directories
eza -D

Terminal Setup

For the best experience, use these tools inside a modern terminal emulator with a Nerd Font for proper icon support:

Nushell Structured Data

Nushell (Nu) is a modern shell that works with structured data (tables) rather than raw strings. Every command output is a table, making data manipulation intuitive and type-safe.

The Table Paradigm

In Nushell, all command output is structured. No more parsing text with awk and sed.

# List files over 1MB, sorted by size
ls | where size > 1mb | sort-by size

# Get top 5 processes by memory usage
ps | sort-by mem | last 5

# Count files by extension
ls **/* | group-by {|f| $f.name | path parse | get extension} | transpose ext count | sort-by count -r

# Filter and transform in a single pipeline
ls | where type == "file" | select name size | sort-by size -r | first 10

Working with APIs

Nushell handles HTTP requests and JSON natively.

# Fetch a JSON API and extract a field
http get https://api.github.com/repos/nushell/nushell | get stargazers_count

# POST with JSON body
http post https://api.example.com/data {name: "test", active: true}

# Fetch and filter API results
http get https://api.github.com/users/octocat/repos | where stargazers_count > 100 | select name stargazers_count

# Convert between formats
open data.csv | save data.json
open config.yaml | to json

Scripting with Nushell

Nushell scripts are typed, eliminating common shell scripting bugs like word splitting and globbing.

# Typed function with error handling
def deploy-check [env: string] {
  let status = (http get $"https://($env).example.com/health")
  if $status.ok {
    print $"($env) is healthy"
  } else {
    error make {msg: $"Deploy check failed for ($env)"}
  }
}

# Function with default parameters
def search-logs [pattern: string, --lines(-n): int = 100] {
  open app.log | lines | where {|line| $line | str contains $pattern} | last $lines
}

# Pipeline as a variable
let large_files = (ls **/* | where size > 10mb | sort-by size -r)
$large_files | each {|f| print $"Large file: ($f.name) - ($f.size)"}

Data Format Conversion

# CSV to JSON
open data.csv | to json | save data.json

# JSON to YAML
open config.json | to yaml | save config.yaml

# TSV to table display
open data.tsv | table

# Space-separated values to structured table
"10240 src/app" | from ssv | rename size path

Unix Interoperability

Move between Nushell tables and standard Unix text with to text and from ssv.

# Convert Unix command output to a Nushell table
du -sk * | from ssv | rename size path | upsert size {|r| $r.size | into int} | sort-by size -r | first 10

# Pipe Nushell output to Unix tools
ls | get name | to text | xargs wc -l

# Use external commands and capture output
let result = (^git log --oneline -10 | lines)
$result | length

Audit Pipelines

# Audit disk usage as formatted JSON
du -sk * | from ssv | rename size path | upsert size {|r| $r.size | into int} | sort-by size -r | first 10 | to json

# Find duplicate files by size
ls **/* | where type == "file" | group-by size | where {|g| ($g.items | length) > 1} | each {|g| $g.items | get name}

# Summarize git log by author
^git log --format="%an" | lines | uniq -c | sort-by count -r | first 10

Advantages Over Traditional Shell