PluginBench
Skill
Pass
Audit score 90

bash-linux

sickn33/agentic-awesome-skills

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

What is bash-linux?

Reference guide for Bash shell operations on Linux/macOS, covering command chaining, file operations, process management, text processing, and scripting patterns. Use when working directly with terminal tasks on Unix-like systems.

  • Command chaining with operators (&&, ||, |, ;) for sequential and conditional execution
  • File operations including listing, finding, searching, and monitoring logs
  • Process management: listing, killing, finding by port, and background job control
  • Text processing with grep, sed, awk, cut, sort, and uniq for data extraction and transformation
  • Environment variable management and PATH configuration
  • Network operations with curl and netcat for downloads and API requests

How to install bash-linux

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

How to use bash-linux

  1. 1.Reference the appropriate section (File Operations, Process Management, Text Processing, etc.) for your task
  2. 2.Use the provided command syntax and examples as templates for your specific use case
  3. 3.For scripts, start with the provided template and add your logic in the main() function
  4. 4.Apply error handling patterns (set -e, set -u, set -o pipefail) at the top of scripts for safety
  5. 5.Test commands interactively before adding them to automated scripts

Use cases

Good for
  • Automating deployment or build workflows on Linux/macOS servers
  • Searching and processing log files or large datasets with grep and text tools
  • Managing running processes and debugging port conflicts
  • Writing robust shell scripts with proper error handling and cleanup
  • Chaining multiple commands in CI/CD pipelines or local development workflows
Who it's for
  • DevOps engineers and system administrators
  • Backend developers working on Linux/macOS systems
  • CI/CD pipeline builders and automation engineers
  • Anyone writing shell scripts or working in terminal environments

bash-linux FAQ

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

Use && when the next command depends on the previous succeeding (e.g., npm install && npm run dev). Use || to run a fallback if the previous fails (e.g., npm test || echo 'Tests failed'). Use ; to run commands sequentially regardless of success.

How do I make a script exit if any command fails?

Add set -e at the top of your script, or use set -euo pipefail for stricter error handling that also exits on undefined variables and pipe failures.

What's the difference between piping (|) and command substitution ($())?

Piping (|) sends the output of one command as input to another. Command substitution $() captures the output of a command and uses it as a value in another command.

How do I kill a process using a specific port?

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

Should I use this skill on Windows systems?

No, this skill is for Bash on Linux/macOS. For Windows, use PowerShell patterns or Windows Command Prompt. Windows Subsystem for Linux (WSL) can run Bash.

Full instructions (SKILL.md)

Source of truth, from sickn33/agentic-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: critical 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.