Productividad en Shell

# Pipes — encadena comandos
cat package.json | jq '.dependencies | keys[]'
git log --oneline | head -20
npm outdated | grep -v "Package"
 
# Redirección
npm run build > build.log 2>&1        # stdout + stderr a archivo
npm test 2>/dev/null                   # suprime errores
 
# Sustitución de comandos
echo "Node $(node -v) on $(uname -s)"
 
# Historial
history | grep "docker"               # busca comandos anteriores
Ctrl+R                                 # búsqueda inversa (interactiva)
!!                                     # repite el último comando
sudo !!                                # repite el último comando con sudo

#!/bin/bash
# guardar como: scripts/health-check.sh
# ejecutar con: bash scripts/health-check.sh
 
echo "=== Project Health Check ==="
echo ""
 
echo "Node: $(node -v) | npm: $(npm -v)"
echo "Branch: $(git branch --show-current)"
echo "Uncommitted changes: $(git status --porcelain | wc -l | tr -d ' ')"
echo ""
 
echo "--- Dependencies ---"
echo "Total packages: $(ls node_modules | wc -l | tr -d ' ')"
echo "Outdated:" 
npm outdated 2>/dev/null || echo "  All up to date"
echo ""
 
echo "--- Code Stats ---"
echo "TypeScript files: $(find src -name '*.ts' -o -name '*.tsx' 2>/dev/null | wc -l | tr -d ' ')"
echo "Test files: $(find src -name '*.test.*' -o -name '*.spec.*' 2>/dev/null | wc -l | tr -d ' ')"
echo "TODO count: $(grep -r 'TODO\|FIXME' src/ --include='*.ts' --include='*.tsx' 2>/dev/null | wc -l | tr -d ' ')"
echo ""
 
echo "--- Type Check ---"
npx tsc --noEmit 2>&1 | tail -1

# Cuenta líneas de código por tipo de archivo
find src -name "*.tsx" | xargs wc -l | sort -n | tail -20
 
# Encuentra las 10 dependencias más grandes
du -sh node_modules/* | sort -rh | head -10
 
# Lista todas las fuentes de importación únicas
grep -rh "from ['\"]" src/ | sed "s/.*from ['\"]//;s/['\"].*//" | sort -u
 
# Encuentra componentes que usan useState pero no useEffect
grep -rl "useState" src/components/ | xargs grep -L "useEffect"
 
# Cuenta commits por autor
git shortlog -sn --all | head -10
 
# Encuentra archivos cambiados en el último commit que contengan TODO
git diff --name-only HEAD~1 | xargs grep -l "TODO" 2>/dev/null
 
# Procesamiento JSON con jq
cat package.json | jq '.scripts'
cat package.json | jq '.dependencies | keys | length'
curl -s https://api.example.com/data | jq '.items[] | {id, name}'

# Redirige stdout a archivo
npm run build > build.log
 
# Redirige stderr a archivo
npm run build 2> errors.log
 
# Redirige ambos al mismo archivo
npm run build > build.log 2>&1
# Sintaxis moderna (bash 4+):
npm run build &> build.log
 
# Añade en lugar de sobrescribir
echo "new entry" >> log.txt
 
# Descarta la salida
npm install > /dev/null 2>&1
 
# Redirige stdin desde archivo
node script.js < input.txt
 
# Documento aquí (entrada multilínea)
cat << 'EOF' > .env.local
DATABASE_URL=postgresql://localhost:5432/mydb
NEXT_PUBLIC_API_URL=http://localhost:3000/api
EOF

# Navegación
alias ..="cd .."
alias ...="cd ../.."
alias proj="cd ~/projects"
 
# Atajos de Git
alias gs="git status -sb"
alias gl="git log --oneline --graph -20"
alias gd="git diff"
alias gc="git commit -m"
alias gp="git push"
alias gpu="git pull"
alias gco="git checkout"
alias gcb="git checkout -b"
 
# Atajos de npm
alias ni="npm install"
alias nd="npm run dev"
alias nb="npm run build"
alias nt="npm test"
alias nrd="npm run dev"
 
# Servidores rápidos
alias serve="npx serve ."
alias py-serve="python3 -m http.server 8080"
 
# Utilidad
alias ll="ls -la"
alias cls="clear"
alias ports="lsof -i -P | grep LISTEN"
alias myip="curl -s ifconfig.me"
 
# Funciones
mkcd() { mkdir -p "$1" && cd "$1"; }
 
# Mata el proceso en un puerto
killport() { lsof -ti :"$1" | xargs kill -9 2>/dev/null && echo "Killed port $1" || echo "Nothing on port $1"; }
 
# Crea un nuevo archivo de componente
newcomp() {
  local name="$1"
  local dir="src/components"
  mkdir -p "$dir"
  cat > "$dir/$name.tsx" << EOF
interface ${name}Props {
  // props
}
 
export function ${name}({}: ${name}Props) {
  return (
    <div>
      <h2>${name}</h2>
    </div>
  );
}
EOF
  echo "Created $dir/$name.tsx"
}

# Recarga después de editar
source ~/.zshrc   # o ~/.bashrc

#!/bin/bash
 
# Variables
NAME="my-app"
PORT=${PORT:-3000}           # valor por defecto si no está establecido
TIMESTAMP=$(date +%Y%m%d)
 
# Condicionales
if [ -f "package.json" ]; then
  echo "Node project found"
elif [ -f "Cargo.toml" ]; then
  echo "Rust project found"
else
  echo "Unknown project type"
fi
 
# Verifica si existe el comando
if command -v pnpm &> /dev/null; then
  pnpm install
else
  npm install
fi
 
# Bucles
for file in src/components/*.tsx; do
  echo "Component: $(basename "$file" .tsx)"
done
 
# Bucle sobre líneas
git diff --name-only | while read -r file; do
  echo "Changed: $file"
done
 
# Sale si hay error (siempre úsalo en scripts)
set -euo pipefail
# -e: sale si algún comando falla
# -u: error en variables no definidas
# -o pipefail: detecta errores en pipes
 
# Trap para limpieza
cleanup() { rm -f /tmp/myapp-*.log; }
trap cleanup EXIT

# Verificación rápida de deploy: type-check, lint, test, build
#!/bin/bash
set -euo pipefail
 
echo "1/4 Type checking..."
npx tsc --noEmit
 
echo "2/4 Linting..."
npx next lint
 
echo "3/4 Testing..."
npx vitest run
 
echo "4/4 Building..."
npm run build
 
echo "All checks passed!"

# Monitorea un archivo y ejecuta automáticamente un comando
# Instala: brew install entr (macOS) o apt install entr (Linux)
find src -name "*.test.ts" | entr -c npx vitest run
 
# O monitorea con un bucle simple
while true; do
  inotifywait -r -e modify src/ 2>/dev/null || fswatch -1 src/
  npx tsc --noEmit
done

# Elimina todos los archivos .log encontrados
find . -name "*.log" | xargs rm
 
# Ejecuta prettier en todos los archivos TypeScript cambiados
git diff --name-only --diff-filter=M | grep '\.tsx\?$' | xargs npx prettier --write
 
# Abre todos los archivos que contienen un patrón en VS Code
rg -l "deprecated" src/ | xargs code
 
# Ejecución en paralelo
find tests -name "*.test.ts" | xargs -P 4 -I {} npx vitest run {}
# -P 4 = 4 procesos en paralelo
# -I {} = placeholder para la entrada