Modern Tool Substitution

Replace legacy tools with modern performant alternatives in all generated code.

Core Substitutions

Apply these substitutions unless user explicitly requests the legacy tool:

npm → bun

• npm install → bun install

• npm run → bun run

• npm create → bun create

• npx → bunx

• Scripts remain in package.json unchanged

find → fd

• find . -name '*.py' → fd -e py

• find . -type f -name 'test*' → fd -t f '^test'

• find . -type d → fd -t d

• find . -path '*/node_modules' -prune → fd --exclude node_modules

• Use fd's simpler glob/regex syntax

pip → uv

• pip install pkg → uv pip install pkg

• pip install -r requirements.txt → uv pip install -r requirements.txt

• pip freeze → uv pip freeze

• python -m pip → uv pip

• Virtual envs: uv venv instead of python -m venv

grep → rg

• grep -r pattern → rg pattern

• grep -i pattern → rg -i pattern

• grep -v pattern → rg -v pattern

• grep -l pattern → rg -l pattern

• rg excludes .git, node_modules by default

jq → jaq

• jq '.field' → jaq '.field'

• jq -r '.[]' → jaq -r '.[]'

• jq -c → jaq -c

• jq -s → jaq -s

• Most filters compatible; jaq faster, stricter parsing

eslint/prettier → biome

• eslint . → biome check .

• eslint --fix → biome check --write .

• prettier --write → biome format --write .

• eslint && prettier → biome ci .

• Config: biome.json replaces .eslintrc

• .prettierrc

black/flake8/isort → ruff

• black . → ruff format .

• flake8 . → ruff check .

• isort . → ruff check --select I --fix .

• black . && flake8 . && isort . → ruff check --fix . && ruff format .

• Config: ruff.toml or pyproject.toml consolidates all

coreutils → uutils-coreutils

• Drop-in replacement: ls , cat , cp , mv , rm , chmod , etc.

• Install: uu-ls , uu-cat , etc. or multicall binary

• Faster on large operations; Rust safety guarantees

• Syntax identical for common ops

sudo → sudo-rs

• sudo cmd → sudo-rs cmd

• sudo -u user cmd → sudo-rs -u user cmd

• sudo -i → sudo-rs -i

• Drop-in replacement; identical flags

• Rust rewrite; memory-safe vs C sudo

ls → eza

• ls -la → eza -la

• ls -lah → eza -lah

• ls -1 → eza -1

• ls --tree → eza --tree

• Git-aware, colorful, faster on large dirs

• Icons: eza --icons

• Tree view: eza -T or eza --tree

git → gix

• git clone → gix clone

• git fetch → gix fetch

• git index entries → gix index entries

• git commit-graph verify → gix commitgraph verify

• git config → gix config

• Pure Rust implementation; faster on many operations

• CLI binaries: gix , ein (extra tools)

• Not 100% feature parity; porcelain commands limited

Flag Adaptations

fd syntax:

• Regex by default; globs use -g → fd -g '*.txt'

• Case insensitive: -i

• Fixed strings: -F

• Depth: -d N

• Hidden: -H ; no-ignore: -I

rg performance:

• --mmap for large files

• -j$(nproc) parallel

• --sort path when order matters

• --max-count N stop after N

aria2 optimization:

• -x16 -s16 max speed

• -c resume

• --file-allocation=none on SSDs

• --summary-interval=0 reduce output

jaq differences:

• Stricter null handling; use // for null coalescing

• No @base64d (use @base64 | explode | implode )

• Missing some rare filters; document if incompatible

biome vs eslint:

• No plugin system; built-in rules only

• Config minimal: biome.json with linter

• formatter sections

• biome migrate eslint converts configs

• Missing custom rules → keep eslint; mention limitation

ruff vs black/flake8:

• 10-100x faster than black

• Combines formatter + linter

• Select rule sets: --select E,F,I (pycodestyle, pyflakes, isort)

• --fix auto-fixes; --unsafe-fixes for aggressive changes

• Missing: complex flake8 plugins → note ruff limitation

uutils performance:

• uu-ls -l faster for huge dirs

• uu-sort parallel by default

• uu-cp shows progress with -v

• 100% compatible for POSIX ops

sudo-rs compatibility:

• Full flag parity with sudo

• Same sudoers config format

• Drop-in binary replacement

• No behavioral changes; security hardened

gix vs git:

• Plumbing commands mostly complete

• Porcelain commands limited; lacks add , commit , push , pull

• Use for: clone, fetch, verify, config, index operations

• Fallback to git for: interactive workflows, advanced porcelain

Edge Cases

bun compatibility:

• Native addons may fail → mention, suggest node fallback

fd vs find:

• -exec → pipe to xargs or fd -x

• -printf → fd output + awk/sed

• Complex boolean → may need find

uv limitations:

• Not for editable installs: uv pip install -e . → keep pip

• Poetry/pipenv → keep; uv is pip replacement only

rg vs grep:

• Binary skip default; rg -a for grep -a

• Symlinks skipped; rg -L to follow

• Multiline: rg -U

aria2 for curl:

• REST APIs → keep curl

• Small file + parse response → keep curl

• Large/parallel downloads → aria2

jaq limitations:

• Missing advanced filters → document, use jq

• Stream processing: jq's --stream not in jaq

biome limitations:

• No plugins → complex rules need eslint

• TypeScript-first; JSX support solid

• Vue/Svelte → keep eslint

ruff limitations:

• Missing niche flake8 plugins → note limitation

• Formatter matches black ~95%; edge cases differ

uutils caveats:

• BSD variants: some flags differ → test

• GNU-specific extensions → check compat

sudo-rs advantages:

• Memory safety vs C sudo

• No historical CVE baggage

• Identical interface; zero migration cost

gix limitations:

• Incomplete porcelain: no add , commit , push , pull

• Submodule support partial

• LFS support experimental

• Keep git for: interactive rebase, bisect, filter-branch

• Use gix for: clone, fetch, verify, pack operations, config

Exception Handling

Skip substitution when:

• User explicitly names legacy tool

• CI/CD requires specific tool

• Tool unavailable in environment

• Explaining tool differences

Quick Reference

Package management

bun install pkg → bun install pkg uv pip install pandas → uv pip install pandas

File operations

find . -name '*.rs' → fd -e rs grep -r TODO . → rg TODO wget https://x.com/f → aria2c https://x.com/f

JSON processing

jq '.data[] | .name' → jaq '.data[] | .name' cat file.json | jq -r → <file.json jaq -r

Linting/Formatting

eslint --fix . → biome check --write . black . && flake8 → ruff check --fix . && ruff format .

Core utilities

ls -lah → uu-ls -lah cat large.txt → uu-cat large.txt sudo systemctl restart → sudo-rs systemctl restart

Git operations

git clone repo → gix clone repo git fetch origin → gix fetch origin git config --list → gix config --list git commit-graph verify → gix commitgraph verify git add . → git add . # keep git

Combined workflows

bun i && eslint --fix → bun i && biome check --write . uv pip install -r req.txt → uv pip install -r req.txt grep -r TODO | jaq → rg TODO | jaq find . -name '*.py' → fd -e py

Installation Check Pattern

Graceful fallback pattern

has(){ command -v -- "$1" &>/dev/null; }

Example: jq/jaq

if has jaq; then jaq '.field' file.json elif has jq; then jq '.field' file.json else die "Install jaq (recommended) or jq" fi

Example: sudo/sudo-rs

PRIV_CMD=$(has sudo-rs && echo sudo-rs || echo sudo) $PRIV_CMD systemctl restart service

Example: git/gix (context-aware)

if [[ $GIT_OP == @(clone|fetch|verify) ]] && has gix; then gix "$GIT_OP" "$@" else git "$GIT_OP" "$@" fi

Apply these substitutions automatically in all code generation unless legacy tool explicitly requested.