skillZs
★ LIVE SKILL TAGS ★
>>> LIVE SKILLS INDEX <<<
* OPEN SOURCE *
NO LOGIN, NO TRACKING
※ REAL INSTALL DATA ※
← back to all skills
wyattowalsh/agents51 installs

shell-scripter

Shell script generation, review, and dialect conversion. Makefile and justfile generation. ShellCheck rules. Use for shell work. NOT for Python (python-conventions) or CI/CD (devops-engineer).

How do I install this agent skill?

npx skills add https://github.com/wyattowalsh/agents --skill shell-scripter
view source ↗

Is this agent skill safe to install?

  • Gen Agent Trust Hubpass

    The shell-scripter skill is a secure utility for generating, reviewing, and converting shell scripts, Makefiles, and justfiles. It uses local Python scripts for static analysis and conversion while strictly adhering to shell security best practices and ShellCheck rule explanations.

  • Socketpass

    No alerts

  • Snykpass

    Risk: LOW · No issues

  • Runlayerpass

    1/13 files flagged

What does this agent skill do?

Shell Scripter

Generate, review, convert, and lint shell scripts. Makefile and justfile generation. References ShellCheck rule IDs with explanations but does NOT run ShellCheck.

Scope: Shell scripts (bash, zsh, fish, sh/POSIX), Makefiles, justfiles. NOT for Python scripts (use python-conventions), CI/CD pipelines (use devops-engineer), or running/testing scripts.

Dispatch

$ARGUMENTSMode
create <description>Generate a shell script from natural language
review <script or path>Audit for pitfalls, reference ShellCheck rules
convert <script or path> <target>Dialect conversion (bash/zsh/fish)
posix <script or path>POSIX compliance check at pattern level
makefile <tasks>Generate a Makefile from task descriptions
justfile <tasks>Generate a justfile from task descriptions
Natural language about shell scriptingAuto-detect mode from intent
EmptyShow mode menu with examples

Auto-Detection Heuristic

  1. Path to .sh/.bash/.zsh/.fish file + modification verb (review, check, fix, audit, lint) -> review
  2. Path to .sh file + "to zsh/fish/bash" -> convert
  3. Path to .sh file + "posix" or "portable" -> posix
  4. "makefile" or "make targets" in input -> makefile
  5. "justfile" or "just recipes" in input -> justfile
  6. Describes desired script behavior -> create
  7. Ambiguous -> ask which mode

Mode: Create

Generate a shell script from a natural language description.

Generation Process

  1. Determine target dialect (default: bash)
  2. Run uv run python scripts/dialect-converter.py --list-features <dialect> to confirm available features
  3. Write the script with:
    • Proper shebang (env-based like env bash, not hardcoded interpreter paths)
    • set -euo pipefail for bash (equivalent for other dialects)
    • Meaningful variable names, quoted expansions
    • Error handling for external commands
    • Usage function if script accepts arguments

Validation

  1. Run uv run python scripts/script-analyzer.py --stdin <<< "$SCRIPT" on the generated script
  2. Fix any issues found, present final script

Mode: Review

Audit a shell script for common pitfalls. Reference ShellCheck rule IDs.

Analysis

  1. Read the target script
  2. Run uv run python scripts/script-analyzer.py <path>
  3. Parse the JSON output: {shebang, dialect, issues, posix_compatible, complexity_estimate}
  4. For each issue, load references/shellcheck-rules.md to explain the rule ID

Findings Report

  1. Group findings by severity: error > warning > info > style
  2. Present findings with:
    • ShellCheck rule ID (e.g., SC2086)
    • Line number and code snippet
    • Explanation of WHY it is a problem
    • Concrete fix
  3. If no issues found, state this explicitly

Severity mapping:

SeverityExamples
errorUnquoted variables in conditionals, syntax errors, command injection
warningMissing error handling, unquoted glob expansions, deprecated syntax
infoSuboptimal patterns, unnecessary subshells, redundant commands
styleInconsistent quoting, missing shellcheck directives, naming

Mode: Convert

Convert shell syntax between bash, zsh, and fish.

  1. Read the source script
  2. Identify source dialect (from shebang or --from flag)
  3. Run uv run python scripts/dialect-converter.py <path> --from <source> --to <target>
  4. Parse the JSON output: {converted_script, changes, warnings}
  5. Present the converted script with a change summary table
  6. Flag any constructs that have no direct equivalent in the target dialect

Mode: POSIX

Check a script for POSIX compliance at the pattern level.

  1. Read the target script
  2. Run uv run python scripts/script-analyzer.py <path> --posix
  3. Identify bash-isms: [[ ]], (( )), arrays, local, source, process substitution, {a..z}, $'...'
  4. For each bash-ism, suggest the POSIX equivalent from references/posix-compatibility.md
  5. Report whether the script is POSIX-compatible or list required changes

Mode: Makefile

Generate a Makefile from task descriptions.

  1. Parse task descriptions from $ARGUMENTS
  2. Determine dependencies between tasks
  3. Generate Makefile with:
    • .PHONY declarations for non-file targets
    • .DEFAULT_GOAL
    • help target using self-documenting pattern (## comments)
    • Consistent variable naming (UPPER_SNAKE_CASE)
    • .ONESHELL when multi-line recipes need shared state
  4. Follow conventions from references/makefile-justfile.md

Mode: Justfile

Generate a justfile from task descriptions.

  1. Parse task descriptions from $ARGUMENTS
  2. Generate justfile with:
    • Recipe documentation comments
    • Default recipe (first position or default alias)
    • Parameter declarations with defaults where sensible
    • set shell directive if non-default shell needed
    • set dotenv-load if environment variables are referenced
  3. Follow conventions from references/makefile-justfile.md

Canonical Vocabulary

Use these terms exactly throughout:

TermDefinition
dialectShell language variant: bash, zsh, fish, sh (POSIX)
bash-ismSyntax or feature not in POSIX sh (e.g., arrays, [[ ]])
shebang#! line specifying the interpreter
SC ruleA ShellCheck rule ID (e.g., SC2086 = unquoted variable)
recipeA justfile target (not "task" or "rule")
targetA Makefile target (not "task" or "recipe")
portableWorks across bash/zsh/sh without modification

Reference Files

Load ONE reference at a time. Do not preload all references into context.

FileContentRead When
references/shellcheck-rules.mdTop 50 ShellCheck rules with severity, explanation, examples, fixesReview mode, explaining SC rule IDs
references/posix-compatibility.mdPOSIX builtins, bash-isms with POSIX equivalents, portability patternsPOSIX mode, create mode with --posix
references/dialect-differences.mdSyntax differences between bash/zsh/fish with conversion recipesConvert mode, cross-dialect questions
references/common-pitfalls.mdUnquoted vars, missing error handling, injection, race conditions, trapsReview mode, create mode best practices
references/makefile-justfile.mdMakefile best practices, justfile syntax and patterns, migration guideMakefile mode, justfile mode
ScriptWhen to Run
scripts/script-analyzer.pyReview and POSIX modes -- static analysis of shell scripts
scripts/dialect-converter.pyConvert mode -- syntax conversion between dialects

Critical Rules

  1. Never claim to run ShellCheck -- reference SC rule IDs and explain them, but analysis is pattern-based
  2. Always use env-based shebangs (e.g., env bash), never hardcoded interpreter paths
  3. Default to set -euo pipefail in generated bash scripts -- omit only with explicit justification
  4. Always quote variable expansions unless splitting is intentionally required (SC2086)
  5. Never generate scripts that use eval unless no alternative exists -- explain the risk
  6. Every generated script must include error handling for external commands
  7. Generated Makefiles must include a .PHONY declaration and a help target
  8. Generated justfiles must have a default recipe and documentation comments
  9. Review findings must include the SC rule ID, line number, and a concrete fix
  10. Never modify the script being reviewed -- review is read-only
  11. Convert mode must warn about constructs with no direct equivalent in the target dialect
  12. POSIX mode must identify every bash-ism and provide a POSIX alternative

Add the canonical catalog link to the repository README so users can inspect current installs and available audits. The publishing guide covers the complete discovery path.

<a href="https://skillzs.dev/skills/wyattowalsh/agents/shell-scripter">View shell-scripter on skillZs</a>