shell-routines

Run a batch script, parse its JSON output, display structured results

Audit shell scripts for quality, security, and best practices

Scaffold a new bash script from template with best practices

Run bash script tests with coverage enforcement

Configure Bash LSP development environment and tools

Expert agent for designing bash script architecture. Use for complex multi-file projects, bash vs POSIX decisions, performance optimisation, library vs executable design, and project structure decisions. Use proactively for architectural questions. <example> Context: User is planning a deployment tool with multiple components user: "I need to build a deployment pipeline with separate scripts for build, test, and deploy. Should they share a config?" assistant: "I'll use the shell-architect agent to design the project structure and file responsibilities." <commentary> Multi-file project with unclear structure — architectural design needed before implementation. </commentary> </example> <example> Context: User has a working script that needs to run on Alpine Linux user: "This deployment script uses arrays extensively but needs to run on Alpine where bash isn't installed by default" assistant: "I'll use the shell-architect agent to evaluate the Bash vs POSIX trade-offs for Alpine compatibility." <commentary> Portability constraint requires an architectural decision about Bash vs POSIX sh, template selection, and feature migration strategy. </commentary> </example> <example> Context: User has common functions scattered across several scripts user: "I have logging, error handling, and config functions duplicated in five scripts. Should I extract them into a library?" assistant: "I'll use the shell-architect agent to assess whether these should be a sourced library or standalone scripts, and design the interface." <commentary> Library vs executable design decision — the architect determines which functions are stateless utilities (library candidates) vs stateful workflows (executable scripts). </commentary> </example> <example> Context: User has a script processing 100,000 files that runs too slowly user: "This file-processing script takes hours on large directories. What's the right approach to speed it up?" assistant: "I'll use the shell-architect agent to evaluate batch processing, parallelism, and architectural changes for performance." <commentary> Performance optimisation at scale requires architectural decisions (batch vs individual, parallelism strategy, data flow) before implementation. </commentary> </example>

Expert bash/shell scripting agent for implementation work. Use proactively for writing shell scripts, multi-file refactoring, performance optimisation, security hardening, and any bash task requiring deep domain knowledge. Use after shell-architect produces a design. <example> Context: shell-architect has produced a design with template assignments user: "Implement the architecture the shell-architect recommended" assistant: "I'll use the shell-expert agent to implement the design following the assigned templates and skill standards." <commentary> Direct handoff from design to implementation — shell-expert consumes the architect's output and writes code. </commentary> </example> <example> Context: User has a monolithic script that needs splitting user: "Split deploy.sh into a library of functions and a thin entry-point script" assistant: "I'll use the shell-expert agent to refactor the script following skill standards." <commentary> Multi-file refactoring requiring code modification while maintaining correctness — implementation work. </commentary> </example> <example> Context: User needs a new script written from scratch user: "Write a script that rotates log files older than 7 days, compresses them, and notifies on failure" assistant: "I'll use the shell-expert agent to write this script following shell-best-practices standards." <commentary> New script creation — the expert scaffolds from templates and applies coding/security standards. </commentary> </example> <example> Context: User needs security hardening on an existing script user: "This script runs as root and processes user-supplied filenames. Harden it." assistant: "I'll use the shell-expert agent to apply security hardening from the shell-security skill." <commentary> Security-critical modification — the expert applies input validation, path sanitisation, and privilege reduction patterns from the preloaded security skill. </commentary> </example>

Write batch shell scripts that consolidate many operations into one run emitting a single structured JSON result. Use when one action runs across 3+ similar inputs ("process all files", "rename many files") or a multi-stage shell pipeline is needed (extract → transform → aggregate), and the user need not see results between steps. Prefer this over repeated individual tool calls.

Write secure, portable bash scripts with proper structure, error handling, and quoting. Use when scaffolding a new script ("write a bash script", "scaffold", "new shell file") or modifying, auditing, or hardening an existing one ("fix this script", "refactor bash", "add error handling to"). Covers bash functions, helpers, deployment scripts, and file operations.

Debug a failing bash script: reproduce the failure, isolate the cause with non-invasive tracing (bash -x, bash -n, ShellCheck), then apply and verify the fix. Use when a script errors at runtime, crashes, exits non-zero, or produces wrong output ("debug this script", "fix my script", "why is this failing"). For a script that works but runs slowly, use shell-profiling; for quality review of a working script, use shell-review.

Profile a slow-but-correct bash script: measure a baseline, trace with xtrace timing to find the hotspot, apply shell-specific optimisations, and benchmark the result. Use when a script works correctly but runs too slowly, or to measure/compare execution speed ("profile this script", "why is my script slow", "find the bottleneck"). For runtime errors use shell-debugging; for quality review use shell-review.

Review a working bash script for quality, correctness, standards compliance, and security, producing a structured report with severity-ranked findings and concrete fixes. Use when assessing a finished script ("review my script", "pre-merge review", "is this good bash?"). For runtime failures use shell-debugging; for deep security auditing use shell-security.

1 hook across 1 event

bash-language-server