Structured Bash Script Generator

What You'll Do

• 📥 Gather the script's goal, required positional/flag arguments, environment variables, and external program dependencies
• 🧱 Produce a Bash 3.2-compatible script skeleton with a check_requirements function that validates inputs and dependencies kindly
• 🛡️ Ensure the script sets safe defaults (set -euo pipefail), quotes expansions, and keeps logic portable to macOS/Linux Bash 3.2
• ✨ Format the script with shfmt when available and return a polished result ready for immediate use

When to Use This Skill

Use this skill whenever the user asks for a new bash script or a major refactor of an existing script and they expect:

• Guardrails around required arguments, environment variables, or external tools
• Friendly, actionable error messages when prerequisites are missing
• Compatibility with older Bash versions (macOS default 3.2)

Do not use this skill for:

• POSIX sh-only scripts (no Bash-specific features allowed)
• Small one-liners or trivial command snippets (respond inline instead)
• Advanced Bash (>3.2) needs such as associative arrays or coproc

Phase 1 · Clarify the Script Brief

1. Confirm the script's purpose, expected inputs, outputs, and typical usage examples.
2. Identify all positional arguments and flags that must be provided. Capture human-friendly labels for each so the usage text and errors are clear.
3. List required environment variables (names + meaning) and external commands (e.g., curl, jq). Note install hints when useful.
4. Ask about optional inputs or defaults that should be applied when values are omitted.
5. Determine whether the script writes files, consumes stdin/stdout, or needs cleanup logic.

Deliverable: A short table (in notes or your head) of arguments, env vars, and commands you will feed into check_requirements and usage messaging.

Phase 2 · Plan the Script Structure

Lay out the sections before writing code:

1. Header & Safety

   • #!/usr/bin/env bash
   • set -euo pipefail
   • IFS=$'\n\t' only if tighter word splitting is needed.

2. Metadata Comments (optional)

   • Summarize script purpose and prerequisites in commented lines for discoverability.

3. Usage Helper

   • A usage() function that prints how to run the script, expected args, environment variables, and examples.

4. Requirement Configuration

   • Define REQUIRED_ARGS, REQUIRED_ENV_VARS, and REQUIRED_PROGRAMS as indexed arrays (compatible with Bash 3.2). When nothing is required, keep the arrays empty but present.
   • Optionally define associative-looking notes via comments or simple case statements; do not use declare -A (requires Bash ≥4).

5. check_requirements Function (see Phase 3 for exact pattern)

   • Accepts parsed arguments (or a struct) and validates all prerequisites.
   • Emits kind, actionable errors to STDERR and returns non-zero on failure.

6. Argument Parsing

   • Prefer getopts for short flags. For long options, parse manually with a while loop; avoid getopt if portability is uncertain.
   • Populate variables for downstream logic (use ${VAR:-} to coexist with set -u).

7. Main Logic

   • Encapsulate primary workflow in main() and finish with main "$@".

Phase 3 · Compose the Script

Follow this recipe while writing the actual script content.

Required Guardrail: check_requirements

check_requirements() {
  local -r provided_arg_count=$1
  local missing=0

  if [ ${#REQUIRED_ARGS[@]} -gt 0 ] && [ "$provided_arg_count" -lt ${#REQUIRED_ARGS[@]} ]; then
    printf 'Error: Expected %s arguments (%s) but received %s.\n' \
      ${#REQUIRED_ARGS[@]} "${REQUIRED_ARGS[*]}" "$provided_arg_count" >&2
    missing=1
  fi

  local env_var
  for env_var in "${REQUIRED_ENV_VARS[@]}"; do
    if [ -z "${!env_var:-}" ]; then
      printf 'Error: Missing required environment variable %s. Please set it before rerunning.\n' "$env_var" >&2
      missing=1
    fi
  done

  local program
  for program in "${REQUIRED_PROGRAMS[@]}"; do
    if ! command -v "$program" >/dev/null 2>&1; then
      printf 'Error: Required program %s is not installed or not on PATH. Please install it first.\n' "$program" >&2
      missing=1
    fi
  done

  if [ "$missing" -ne 0 ]; then
    printf '\n' >&2
    usage >&2
    return 1
  fi
}

Implementation notes:

• Always invoke check_requirements right after argument parsing, e.g. check_requirements "$#".
• If the script allows optional trailing arguments, keep REQUIRED_ARGS limited to the mandatory ones and validate optional parameters separately after check_requirements "$#" succeeds.
• Keep error language supportive (“Please install…”) rather than punitive.
• Route any diagnostics to STDERR (>&2) and exit gracefully with return 1 so the caller can exit 1 or handle it.
• Only call usage from error paths (like failed requirement checks) so successful runs stay quiet unless the user explicitly asks for help.

Bash 3.2 Compatibility Guardrails

• Use indexed arrays only; no associative arrays or namerefs (local -n).
• Avoid [[ string =~ regex ]] with capture groups that rely on Bash ≥3.2. Basic regex is fine, but keep patterns simple.
• Do not rely on mapfile, readarray, coproc, printf -v, or process substitution that requires /dev/fd (often missing on macOS).
• Prefer $( command ) subshells over backticks and quote every expansion.
• Use printf instead of echo -e for reliable escape handling.

Usage Function Pattern

usage() {
  cat <<'EOF'
Usage: my_script.sh <source> <destination> [--dry-run]

Required arguments:
  source        Path to the input file (must exist)
  destination   Output directory (will be created if missing)

Environment variables:
  API_TOKEN     Token used to authenticate API requests

External tools:
  curl, jq

Examples:
  my_script.sh ./input.csv ./out --dry-run
EOF
}

Tailor the body to the specific script; keep instructions kind and explicit.

Script Assembly Checklist

1. Write header, safety settings, and optional metadata comments.
2. Define requirement arrays (even if empty) and defaults for optional values.
3. Implement usage() and check_requirements() exactly once.
4. Parse arguments safely (getopts or manual loop) and convert into named variables.
5. Call check_requirements immediately after parsing. If it fails, exit with exit 1.
6. Implement main() with clear, modular helpers; rely on functions instead of sprawling inline code.
7. End with main "$@" and ensure the script returns appropriate exit codes.

Phase 4 · Validate, Format, and Hand Off

1. Self-check

   • Does the script run without arguments and show usage?
   • Do missing env vars and programs produce the friendly errors described earlier?
   • Do all branches respect set -euo pipefail (guard nullable variables with ${VAR:-})?

2. Formatting via shfmt

   • Detect availability: if command -v shfmt >/dev/null 2>&1; then ... fi
   • Run shfmt -i 2 -bn -ci -sr -w <path-to-script> after writing the file.
   • Mention in your response whether formatting ran or was skipped (and why).

3. Final Response Checklist

   • Provide the complete script in a fenced code block (label it bash).
   • Summarize how requirements are enforced.
   • If manual formatting was necessary (no shfmt), note it explicitly.
   • Suggest any quick validation commands (dry runs, linting) if relevant.

Reference Template

Use this skeleton as a starting point and adapt each section based on the user's requirements:

#!/usr/bin/env bash
set -euo pipefail

# Script: <name>
# Purpose: <one-line description>
# Requirements: <short summary of args/env/programs>

REQUIRED_ARGS=("arg1" "arg2")
REQUIRED_ENV_VARS=("ENV_VAR")
REQUIRED_PROGRAMS=("curl" "jq")

usage() {
  cat <<'EOF'
Usage: <script-name> <arg1> <arg2>

Required arguments:
  arg1   <describe>
  arg2   <describe>

Environment variables:
  ENV_VAR   <describe>

External tools:
  curl, jq
EOF
}

check_requirements() {
  local -r provided_arg_count=$1
  local missing=0

  if [ ${#REQUIRED_ARGS[@]} -gt 0 ] && [ "$provided_arg_count" -lt ${#REQUIRED_ARGS[@]} ]; then
    printf 'Error: Expected %s arguments (%s) but received %s.\n' \
      ${#REQUIRED_ARGS[@]} "${REQUIRED_ARGS[*]}" "$provided_arg_count" >&2
    missing=1
  fi

  local env_var
  for env_var in "${REQUIRED_ENV_VARS[@]}"; do
    if [ -z "${!env_var:-}" ]; then
      printf 'Error: Missing required environment variable %s. Please set it before rerunning.\n' "$env_var" >&2
      missing=1
    fi
  done

  local program
  for program in "${REQUIRED_PROGRAMS[@]}"; do
    if ! command -v "$program" >/dev/null 2>&1; then
      printf 'Error: Required program %s is not installed or not on PATH. Please install it first.\n' "$program" >&2
      missing=1
    fi
  done

  if [ "$missing" -ne 0 ]; then
    printf '\n' >&2
    usage >&2
    return 1
  fi
}

parse_args() {
  # TODO: replace with real parsing
  SOURCE=${1:-}
  DEST=${2:-}
}

main() {
  parse_args "$@"
  check_requirements "$#" || exit 1

  # TODO: script logic goes here
  printf 'Running with source=%s dest=%s\n' "$SOURCE" "$DEST"
}

main "$@"

Update placeholders, replace TODO sections, and adjust arrays when a requirement does not apply (leave the array empty—do not delete it).

Quality Checklist Before Finishing

• Script declares all requirement arrays and the check_requirements function
• Error messages are friendly, specific, and routed to STDERR
• Script avoids Bash ≥4 features and has been reviewed for 3.2 compatibility
• usage() accurately reflects arguments, env vars, and dependencies
• Formatting completed with shfmt (or explicitly noted why it was skipped)
• Final response contains both summary guidance and the full script for copy/paste