Bash Script Generator

Bash Script Generator

Overview

Generate production-ready Bash scripts with clear requirements capture, deterministic generation flow, and validation-first iteration.

Trigger Phrases

Use this skill when the user asks to:

• Create, generate, write, or build a Bash/shell script
• Convert manual CLI steps into an automation script
• Build a text-processing script using grep, awk, or sed
• Create an operations helper script, cron script, or CI utility script

Do not use this skill for validating an existing script only. Use devops-skills:bash-script-validator for validation-only requests.

Execution Model

Follow stages in order. Do not skip a stage; use the documented fallback when blocked.

Stage 0: Preflight

1. Confirm scope and target output path.
2. Confirm shell target:

• Default: bash
• If portability is requested: POSIX sh

3. Check capabilities and pick fallback path:

If a fallback path is used, state it explicitly in the final summary.

Stage 1: Capture Requirements

Collect only what is needed to generate the script correctly:

• Input source and format
• Output destination and format
• Error handling behavior (fail-fast/retry/continue)
• Security constraints (sensitive data, privilege level)
• Performance constraints (large files, parallelism)
• Portability requirement (Bash-only vs POSIX)

Then create a Captured Requirements table with stable IDs.

## Captured Requirements

| Requirement ID | Description | Source | Implementation Plan |
|---|---|---|---|
| REQ-001 | Parse nginx logs from file input | User | `parse_args()` + `validate_file()` + `awk` parser |
| REQ-002 | Output top 10 errors | User | `analyze_errors()` + `sort | uniq -c | head -10` |
| REQ-003 | Handle large files efficiently | Assumption | Single-pass `awk`; avoid multi-pass loops |

Rules:

• Every major design decision maps to at least one REQ-*.
• Keep assumptions explicit and minimal.

Stage 2: Choose Generation Path

Use this deterministic decision tree:

Need multi-command architecture, unusual control flow, or strict non-template conventions?
├─ Yes -> Custom generation
└─ No
   Need standard CLI skeleton (usage/logging/arg parsing/cleanup)?
   ├─ Yes -> Template-first generation
   └─ No -> Custom generation

Template-first is the default for single-purpose CLI utilities.

Stage 3: Load Only Relevant References

Use progressive disclosure. Read only docs needed for the current request.

Citation format (required):

• [Ref: docs/<file>.md -> <section>]

Stage 4: Generate Script

Path A: Template-first (default)

1. Generate scaffold:

bash scripts/generate_script_template.sh standard output-script.sh

2. Replace placeholders and add business logic.
3. Keep logging to stderr and data output to stdout unless requirements say otherwise.
4. Add comments only where logic is non-obvious.

Path B: Custom generation

Build a script with at least:

• Shebang and strict mode
• usage()
• parse_args()
• Input validation and dependency checks
• Main workflow function(s)
• Predictable exit codes

Stage 5: Validate and Iterate

Default validation path:

1. Invoke devops-skills:bash-script-validator
2. Apply fixes
3. Re-run validation
4. Repeat until checks pass or blocker is identified

Fallback validation path (when validator skill is unavailable):

# Deterministic local gate for this skill:
bash scripts/run_ci_checks.sh --skip-shellcheck

# CI gate (shellcheck required):
bash scripts/run_ci_checks.sh --require-shellcheck

If any check is skipped, include Skipped check, Reason, and Risk in the output.

Stage 6: Final Response Contract

Always return:

1. Generated script path
2. Requirements traceability (REQ-* -> implementation)
3. Validation results with rerun status
4. Citations in standard format
5. Any assumptions/fallbacks used

Canonical Example Flows

Example A: Full Flow (Template-first)

1. Clarify missing data format and output expectations.
2. Capture REQ-* table.
3. Choose template-first path.
4. Generate scaffold with scripts/generate_script_template.sh.
5. Implement logic and map functions to REQ-*.
6. Validate with devops-skills:bash-script-validator and rerun until clean.
7. Return final summary with citations.

Example B: Constrained Environment Flow

Use this when AskUserQuestion, validator skill, or shellcheck is unavailable:

1. Ask clarifying questions in chat.
2. Mark unresolved items as assumptions in Captured Requirements.
3. Generate from template script or template file copy fallback.
4. Run bash -n (and sh -n if relevant).
5. If shellcheck is missing, report skip with risk and mitigation.

Done Criteria

The task is complete only when all items are true:

• Trigger matched and scope confirmed
• Captured Requirements table exists with REQ-* IDs
• Template-first vs custom decision is documented
• Script is generated with deterministic structure
• Validation executed and rerun policy applied
• Any skipped checks include explicit reason and risk
• Final response includes traceability, citations, and assumptions

Helper Scripts and Assets

• Script generator: scripts/generate_script_template.sh
• Deterministic CI gate: scripts/run_ci_checks.sh
• Regression test suite: scripts/test_generator.sh
• Standard scaffold: assets/templates/standard-template.sh
• Example output style: examples/log-analyzer.sh

Reference Docs

• docs/bash-scripting-guide.md
• docs/script-patterns.md
• docs/generation-best-practices.md
• docs/text-processing-guide.md

External References

• GNU Bash Manual
• POSIX Shell Specification
• ShellCheck

Converted and distributed by TomeVault — claim your Tome and manage your conversions.