PluginBench
Skill
Pass
Audit score 90

bash-linux

sickn33/antigravity-awesome-skills

Essential Bash/Linux terminal patterns, commands, and scripting for macOS and Linux systems.

What is bash-linux?

Reference guide for critical Bash commands, piping, process management, and error handling patterns. Use when working on macOS or Linux systems to execute terminal workflows, manage processes, and write safe shell scripts.

  • Command chaining with operators (&&, ||, |, ;)
  • File operations: listing, finding, searching, and monitoring logs
  • Process management: listing, killing, and port management
  • Text processing with grep, sed, awk, cut, sort, and uniq
  • Environment variable configuration and PATH management
  • Network operations: curl requests and port checking

How to install bash-linux

npx skills add https://github.com/sickn33/antigravity-awesome-skills --skill bash-linux
Claude Code
Cursor
Windsurf
Cline

How to use bash-linux

  1. 1.Reference the operator syntax table when chaining multiple commands
  2. 2.Use file operations commands (ls, find, grep) to locate and inspect files
  3. 3.Apply process management commands (ps, kill, lsof) to monitor and control running processes
  4. 4.Use text processing tools (grep, sed, awk) to extract and transform data
  5. 5.Set environment variables with export or inline before running commands
  6. 6.Follow the script template for new shell scripts, including set -euo pipefail for safety
  7. 7.Use trap cleanup EXIT for resource cleanup in scripts
  8. 8.Check the error handling section and apply set -e, set -u, set -o pipefail as needed

Use cases

Good for
  • Automating deployment or build workflows on Linux/macOS servers
  • Debugging running processes and killing hung applications on specific ports
  • Searching and processing log files or large datasets with grep and text tools
  • Writing safe shell scripts with error handling and cleanup routines
  • Managing environment variables and PATH configuration across systems
Who it's for
  • Backend developers working on Linux/macOS systems
  • DevOps engineers managing servers and deployments
  • System administrators automating tasks and troubleshooting
  • Full-stack developers needing terminal proficiency
  • Anyone writing or maintaining shell scripts

bash-linux FAQ

When should I use && vs || vs ; for chaining commands?

Use && to run the next command only if the previous succeeded (e.g., npm install && npm run dev). Use || to run the next command only if the previous failed (e.g., npm test || echo "Tests failed"). Use ; to run commands sequentially regardless of success.

How do I safely write a Bash script that exits on errors?

Start your script with set -euo pipefail. This makes it exit on errors (set -e), undefined variables (set -u), and pipe failures (set -o pipefail). Optionally add set -x for debugging output.

How do I kill a process running on a specific port?

Use lsof -i :PORT to find the process ID, then kill -9 PID to terminate it. Or combine them: kill -9 $(lsof -t -i :3000) to kill the process on port 3000.

What's the difference between piping in Bash vs PowerShell?

Bash pipes are text-based (output is strings), while PowerShell pipes are object-based. In Bash, use grep, sed, and awk to filter and transform text. In PowerShell, you work with objects directly.

How do I read a file line by line in a Bash script?

Use: while IFS= read -r line; do echo "$line"; done < file.txt. The IFS= prevents leading/trailing whitespace from being trimmed, and -r prevents backslash interpretation.

Full instructions (SKILL.md)

Source of truth, from sickn33/antigravity-awesome-skills.


name: bash-linux description: "Bash/Linux terminal patterns. Critical commands, piping, error handling, scripting. Use when working on macOS or Linux systems." risk: unknown source: community date_added: "2026-02-27"

Bash Linux Patterns

Essential patterns for Bash on Linux/macOS.


1. Operator Syntax

Chaining Commands

OperatorMeaningExample
;Run sequentiallycmd1; cmd2
&&Run if previous succeedednpm install && npm run dev
||Run if previous failednpm test || echo "Tests failed"
|Pipe outputls | grep ".js"

2. File Operations

Essential Commands

TaskCommand
List allls -la
Find filesfind . -name "*.js" -type f
File contentcat file.txt
First N lineshead -n 20 file.txt
Last N linestail -n 20 file.txt
Follow logtail -f log.txt
Search in filesgrep -r "pattern" --include="*.js"
File sizedu -sh *
Disk usagedf -h

3. Process Management

TaskCommand
List processesps aux
Find by nameps aux | grep node
Kill by PIDkill -9 <PID>
Find port userlsof -i :3000
Kill portkill -9 $(lsof -t -i :3000)
Backgroundnpm run dev &
Jobsjobs -l
Bring to frontfg %1

4. Text Processing

Core Tools

ToolPurposeExample
grepSearchgrep -rn "TODO" src/
sedReplacesed -i 's/old/new/g' file.txt
awkExtract columnsawk '{print $1}' file.txt
cutCut fieldscut -d',' -f1 data.csv
sortSort linessort -u file.txt
uniqUnique linessort file.txt | uniq -c
wcCountwc -l file.txt

5. Environment Variables

TaskCommand
View allenv or printenv
View oneecho $PATH
Set temporaryexport VAR="value"
Set in scriptVAR="value" command
Add to PATHexport PATH="$PATH:/new/path"

6. Network

TaskCommand
Downloadcurl -O https://example.com/file
API requestcurl -X GET https://api.example.com
POST JSONcurl -X POST -H "Content-Type: application/json" -d '{"key":"value"}' URL
Check portnc -zv localhost 3000
Network infoifconfig or ip addr

7. Script Template

#!/bin/bash
set -euo pipefail  # Exit on error, undefined var, pipe fail

# Colors (optional)
RED='\033[0;31m'
GREEN='\033[0;32m'
NC='\033[0m'

# Script directory
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"

# Functions
log_info() { echo -e "${GREEN}[INFO]${NC} $1"; }
log_error() { echo -e "${RED}[ERROR]${NC} $1" >&2; }

# Main
main() {
    log_info "Starting..."
    # Your logic here
    log_info "Done!"
}

main "$@"

8. Common Patterns

Check if command exists

if command -v node &> /dev/null; then
    echo "Node is installed"
fi

Default variable value

NAME=${1:-"default_value"}

Read file line by line

while IFS= read -r line; do
    echo "$line"
done < file.txt

Loop over files

for file in *.js; do
    echo "Processing $file"
done

9. Differences from PowerShell

TaskPowerShellBash
List filesGet-ChildItemls -la
Find filesGet-ChildItem -Recursefind . -type f
Environment$env:VAR$VAR
String concat"$a$b""$a$b" (same)
Null checkif ($x)if [ -n "$x" ]
PipelineObject-basedText-based

10. Error Handling

Set options

set -e          # Exit on error
set -u          # Exit on undefined variable
set -o pipefail # Exit on pipe failure
set -x          # Debug: print commands

Trap for cleanup

cleanup() {
    echo "Cleaning up..."
    rm -f /tmp/tempfile
}
trap cleanup EXIT

Remember: Bash is text-based. Use && for success chains, set -e for safety, and quote your variables!

When to Use

This skill is applicable to execute the workflow or actions described in the overview.

Limitations

  • Use this skill only when the task clearly matches the scope described above.
  • Do not treat the output as a substitute for environment-specific validation, testing, or expert review.
  • Stop and ask for clarification if required inputs, permissions, safety boundaries, or success criteria are missing.