What is the Bash/Linux Patterns skill?

It covers essential Bash patterns, commands, and scripting to work efficiently on macOS and Linux.

Which tools are typical in this skill?

Core tools include grep, sed, awk, cut, sort, and wc, plus Bash scripting for automation.

How does error handling work in these patterns?

It emphasizes set -euo pipefail, along with traps for cleanup and clear logging to make scripts reliable.

bash-linux

Scanned

npx machina-cli add skill vudovn/antigravity-kit/bash-linux --openclaw

Files (1)

SKILL.md

4.1 KB

Bash Linux Patterns

Essential patterns for Bash on Linux/macOS.

1. Operator Syntax

Chaining Commands

Operator	Meaning	Example
`;`	Run sequentially	`cmd1; cmd2`
`&&`	Run if previous succeeded	`npm install && npm run dev`
`\|\|`	Run if previous failed	`npm test \|\| echo "Tests failed"`
`\|`	Pipe output	`ls \| grep ".js"`

2. File Operations

Essential Commands

Task	Command
List all	`ls -la`
Find files	`find . -name "*.js" -type f`
File content	`cat file.txt`
First N lines	`head -n 20 file.txt`
Last N lines	`tail -n 20 file.txt`
Follow log	`tail -f log.txt`
Search in files	`grep -r "pattern" --include="*.js"`
File size	`du -sh *`
Disk usage	`df -h`

3. Process Management

Task	Command
List processes	`ps aux`
Find by name	`ps aux \| grep node`
Kill by PID	`kill -9 <PID>`
Find port user	`lsof -i :3000`
Kill port	`kill -9 $(lsof -t -i :3000)`
Background	`npm run dev &`
Jobs	`jobs -l`
Bring to front	`fg %1`

4. Text Processing

Core Tools

Tool	Purpose	Example
`grep`	Search	`grep -rn "TODO" src/`
`sed`	Replace	`sed -i 's/old/new/g' file.txt`
`awk`	Extract columns	`awk '{print $1}' file.txt`
`cut`	Cut fields	`cut -d',' -f1 data.csv`
`sort`	Sort lines	`sort -u file.txt`
`uniq`	Unique lines	`sort file.txt \| uniq -c`
`wc`	Count	`wc -l file.txt`

5. Environment Variables

Task	Command
View all	`env` or `printenv`
View one	`echo $PATH`
Set temporary	`export VAR="value"`
Set in script	`VAR="value" command`
Add to PATH	`export PATH="$PATH:/new/path"`

6. Network

Task	Command
Download	`curl -O https://example.com/file`
API request	`curl -X GET https://api.example.com`
POST JSON	`curl -X POST -H "Content-Type: application/json" -d '{"key":"value"}' URL`
Check port	`nc -zv localhost 3000`
Network info	`ifconfig` 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

Task	PowerShell	Bash
List files	`Get-ChildItem`	`ls -la`
Find files	`Get-ChildItem -Recurse`	`find . -type f`
Environment	`$env:VAR`	`$VAR`
String concat	`"$a$b"`	`"$a$b"` (same)
Null check	`if ($x)`	`if [ -n "$x" ]`
Pipeline	Object-based	Text-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!

Source

git clone https://github.com/vudovn/antigravity-kit/blob/main/.agent/skills/bash-linux/SKILL.mdView on GitHub

Overview

Bash/Linux Patterns covers essential terminal patterns, commands, piping, and scripting for macOS and Linux. It teaches operator syntax, file operations, process management, text processing, environment variables, network basics, and common script templates to streamline workflows.

How This Skill Works

The skill compiles practical shell patterns into reusable snippets and templates. Users apply these through one-liners or scripts, leveraging piping, redirection, and pipefail-based error handling to build reliable automation.

When to Use It

Automate command pipelines and conditional execution in deployment scripts
Search, filter, and transform logs or source files with grep/sed/awk
Manage long-running processes and identify/list ports during development
Configure environment variables and build startup scripts
Create robust scripts with error handling and cleanup traps

Quick Start

Step 1: Open terminal and run a simple command like ls -la to verify shell access
Step 2: Create a small script using the Script Template and functions shown in the skill
Step 3: Run the script with set -euo pipefail and observe robust error handling

Best Practices

Enable strict error handling: set -euo pipefail
Check for required commands before use (command -v)
Use quotes and safe IFS in loops to handle spaces
Prefer small, testable functions with logging helpers
Document scripts with a clear header and comments

Example Use Cases

List all files with details: ls -la
Find files: find . -name "*.js" -type f
Search in files: grep -r "pattern" --include="*.js"
Follow a log: tail -f log.txt
Kill a port: kill -9 $(lsof -t -i :3000)

Frequently Asked Questions

Add this skill to your agents