Produtividade do Shell

# Pipes - encadeia comandos
cat package.json | jq '.dependencies | keys[]'
git log --oneline | head -20
npm outdated | grep -v "Package"
 
# Redirecionamento
npm run build > build.log 2>&1        # stdout + stderr para arquivo
npm test 2>/dev/null                   # suprime erros
 
# Substituição de comando
echo "Node $(node -v) on $(uname -s)"
 
# Histórico
history | grep "docker"               # busca comandos passados
Ctrl+R                                 # busca reversa (interativa)
!!                                     # repete o último comando
sudo !!                                # repete o último comando com sudo

#!/bin/bash
# salve como: scripts/health-check.sh
# execute com: bash scripts/health-check.sh
 
echo "=== Verificação de Saúde do Projeto ==="
echo ""
 
echo "Node: $(node -v) | npm: $(npm -v)"
echo "Branch: $(git branch --show-current)"
echo "Alterações não commitadas: $(git status --porcelain | wc -l | tr -d ' ')"
echo ""
 
echo "--- Dependências ---"
echo "Total de pacotes: $(ls node_modules | wc -l | tr -d ' ')"
echo "Desatualizados:"
npm outdated 2>/dev/null || echo "  Todos atualizados"
echo ""
 
echo "--- Estatísticas de Código ---"
echo "Arquivos TypeScript: $(find src -name '*.ts' -o -name '*.tsx' 2>/dev/null | wc -l | tr -d ' ')"
echo "Arquivos de Teste: $(find src -name '*.test.*' -o -name '*.spec.*' 2>/dev/null | wc -l | tr -d ' ')"
echo "Contagem de TODO: $(grep -r 'TODO\|FIXME' src/ --include='*.ts' --include='*.tsx' 2>/dev/null | wc -l | tr -d ' ')"
echo ""
 
echo "--- Verificação de Tipo ---"
npx tsc --noEmit 2>&1 | tail -1

# Conta linhas de código por tipo de arquivo
find src -name "*.tsx" | xargs wc -l | sort -n | tail -20
 
# Encontra as 10 maiores dependências
du -sh node_modules/* | sort -rh | head -10
 
# Lista todas as fontes de importação únicas
grep -rh "from ['\"]" src/ | sed "s/.*from ['\"]//;s/['\"].*//" | sort -u
 
# Encontra componentes que usam useState mas não useEffect
grep -rl "useState" src/components/ | xargs grep -L "useEffect"
 
# Conta commits por autor
git shortlog -sn --all | head -10
 
# Encontra arquivos alterados no último commit que contêm TODO
git diff --name-only HEAD~1 | xargs grep -l "TODO" 2>/dev/null
 
# Processamento de JSON com jq
cat package.json | jq '.scripts'
cat package.json | jq '.dependencies | keys | length'
curl -s https://api.example.com/data | jq '.items[] | {id, name}'

# Redireciona stdout para arquivo
npm run build > build.log
 
# Redireciona stderr para arquivo
npm run build 2> errors.log
 
# Redireciona ambos para o mesmo arquivo
npm run build > build.log 2>&1
# Sintaxe moderna (bash 4+):
npm run build &> build.log
 
# Anexa em vez de sobrescrever
echo "nova entrada" >> log.txt
 
# Descarta a saída
npm install > /dev/null 2>&1
 
# Redireciona stdin de um arquivo
node script.js < input.txt
 
# Here document (entrada multilinha)
cat << 'EOF' > .env.local
DATABASE_URL=postgresql://localhost:5432/mydb
NEXT_PUBLIC_API_URL=http://localhost:3000/api
EOF

# Navegação
alias ..="cd .."
alias ...="cd ../.."
alias proj="cd ~/projects"
 
# Atalhos 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"
 
# Atalhos 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"
 
# Utilitário
alias ll="ls -la"
alias cls="clear"
alias ports="lsof -i -P | grep LISTEN"
alias myip="curl -s ifconfig.me"
 
# Funções
mkcd() { mkdir -p "$1" && cd "$1"; }
 
# Mata o processo em uma porta
killport() { lsof -ti :"$1" | xargs kill -9 2>/dev/null && echo "Porta $1 morta" || echo "Nada na porta $1"; }
 
# Cria um novo arquivo 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 "Criado $dir/$name.tsx"
}

# Recarrega após editar
source ~/.zshrc   # ou ~/.bashrc

#!/bin/bash
 
# Variáveis
NAME="my-app"
PORT=${PORT:-3000}           # valor padrão se não definido
TIMESTAMP=$(date +%Y%m%d)
 
# Condicionais
if [ -f "package.json" ]; then
  echo "Projeto Node encontrado"
elif [ -f "Cargo.toml" ]; then
  echo "Projeto Rust encontrado"
else
  echo "Tipo de projeto desconhecido"
fi
 
# Verifica se o comando existe
if command -v pnpm &> /dev/null; then
  pnpm install
else
  npm install
fi
 
# Loops
for file in src/components/*.tsx; do
  echo "Componente: $(basename "$file" .tsx)"
done
 
# Loop sobre linhas
git diff --name-only | while read -r file; do
  echo "Alterado: $file"
done
 
# Sai em caso de erro (sempre use em scripts)
set -euo pipefail
# -e: sai em caso de erro
# -u: erro em variáveis indefinidas
# -o pipefail: captura erros em pipes
 
# Trap para limpeza
cleanup() { rm -f /tmp/myapp-*.log; }
trap cleanup EXIT

# Verificação rápida de deploy: type-check, lint, test, build
#!/bin/bash
set -euo pipefail
 
echo "1/4 Verificação de tipo..."
npx tsc --noEmit
 
echo "2/4 Linting..."
npx next lint
 
echo "3/4 Testando..."
npx vitest run
 
echo "4/4 Construindo..."
npm run build
 
echo "Todas as verificações passaram!"

# Assiste a um arquivo e executa um comando automaticamente
# Instale: brew install entr (macOS) ou apt install entr (Linux)
find src -name "*.test.ts" | entr -c npx vitest run
 
# Ou assista com um loop simples
while true; do
  inotifywait -r -e modify src/ 2>/dev/null || fswatch -1 src/
  npx tsc --noEmit
done

# Exclui todos os arquivos .log encontrados
find . -name "*.log" | xargs rm
 
# Executa prettier em todos os arquivos TypeScript alterados
git diff --name-only --diff-filter=M | grep '\.tsx\?$' | xargs npx prettier --write
 
# Abre todos os arquivos que contêm um padrão no VS Code
rg -l "deprecated" src/ | xargs code
 
# Execução paralela
find tests -name "*.test.ts" | xargs -P 4 -I {} npx vitest run {}
# -P 4 = 4 processos paralelos
# -I {} = placeholder para a entrada