I'm a designer, 50 years old, a jazz lover, and a fan of black music and sophisticated house music. I'm a cool, hype, and Creative Director with over 4,000 projects delivered over 30 years of Digital Experience. With honor, and to the extent of being humble and realistic, I was there, in the sun, paving the way so that many others could join us, the initial very small group of pioneers and believers. Long and amazing road, excited by what's to come next. I run Kali KDE X11 and am doing a total OS customization, along with a number of apps that I want to test. I need to maintain the consistency of the colors and identity. So I defined these colors below and the Fira Code font. The background is always a dark grey, and the others are pastel colors. The entire theme is film noir-inspired, very mature. Incredibly sexy...rays of light...parts of female bodies in black and white.. grain...and interface details in dark gold....(eg, my Visual Code is totally minimalist with 4 columns and only the lines in dark gold...super elegant). Beware that this set of colors has two that are brighter - we use them only for accents. Whisky, paint, art, design, beautiful women, smoke, music, and love, ahh, the love... a toast, to life, to happiness, to being here, now.

Visual DNA: Film noir.
Dark, grainy, seductive.
Rays of light cut across black-and-white curves—details in dark gold, everything else slathered in moody, pastel noir. Fira Code everywhere. dark gold lines, zero clutter, max elegance. Two colors pop for accents only—never more, never less.

If you know, you know.

NOIR_COLORS = {
    # Base shades
    'bg_dark':     '#0d0d0d',
    'gold':        '#c5b47f',
    'steel':       '#7a8383',
    'taupe':       '#666350',
    'sage':        '#808c81',
    'copper':      '#9c5c34',
    'slate':       '#444c48',
    'rust':        '#8d4d32',
    # Noir upgrades
    'dark_gold':   '#8B7355',  # Sophisticated, deep gold
    'dark_grey':   '#1a1a1a',  # Rich, unyielding grey
    'accent_gold': '#DAA520',  # Only for sharp highlight—use wisely
    'shadow':      '#080808',  # Black hole deep, for serious depth
}




.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
# THE NOIR: Digital Noir Aesthetic & System Architecture

## Vision Statement
A 50-year-old Creative Director's digital odyssey: traversing America's landscapes in an RV, hacking the digital realm with a laptop as the canvas. 4,000+ projects in the rearview mirror, a connoisseur of jazz, black music, and sophisticated house. Kali is the OS of choice, with every pixel and application customized to perfection. Consistency is not just a preference—it's an absolute requirement.  The whole theme is film noir inspired... very mature. Incredibly sexy...rays of light...parts of female bodies in black and white.. grain...and interface details in dark gold....(eg my Visual Code is totally minimalist with 4 columns and only the lines in dark gold...super elegant). Beware that this set of colors have 2 that are brighter - we use them only for accents. 

## Aesthetic Philosophy
### Visual DNA: Cinematic Noir
- Dark, grainy, and seductive
- Light slicing through black-and-white curves
- Dark gold accents amidst moody, pastel noir
- Fira Code: the font of choice
- Minimalist elegance: four columns, dark gold lines
- Two accent colors: precision and restraint

## Technical Architecture
### Core System: Kali KDE
#### Theme Development
- Custom theme development using Kvantum/KDE Frameworks
- Unified color palette across all applications
- Integration points:
  - Kate (text editor)
  - Konsole (terminal)
  - VS Code
  - Warp Terminal
  - Ghostwriter
  - Chrome
  - Dolphin (enhanced)

### Command Line Interface
#### ZSH Configuration
- Centralized `.zshrc` management system
- Version-controlled configuration repository
- Modular plugin architecture
- Automatic syntax highlighting
- Custom prompt with noir aesthetic
- Command completion with AI suggestions

#### AI-Powered CLI
- Natural language command processing
- Context-aware command suggestions
- Command history analysis
- Automatic script optimization
- Real-time syntax checking

#### CLI Tools Integration
- FZF for fuzzy searching
- Tmux for terminal multiplexing
- Nerd fonts for enhanced symbols
- Custom aliases with AI optimization
- Command history analytics

### AI Integration Framework
#### Local LLM Integration
- Small, efficient models (e.g., GPT-4 Lite)
- Command-line AI assistant
- Code completion suggestions
- Prompt engineering tools
- Context-aware responses

#### AI-Powered Features
- Natural language scripting
- Command optimization
- Code review assistant
- Security analysis
- Documentation generation

#### AI Management System
- Model version control
- Resource optimization
- Performance monitoring
- Security isolation
- Update automation

### Configuration Management
#### ZSHRC Organization
- Modular structure
- Version control integration
- Backup and recovery
- Environment variables management
- Theme configuration
- Plugin management

#### Security Measures
- Encrypted configuration storage
- Access control
- Audit logging
- Regular backups
- Disaster recovery plan

#### Development Workflow
- Automated testing
- Continuous integration
- Version control hooks
- Documentation generation
- Performance monitoring

### Visual Integration
- Consistent noir color scheme
- Custom prompt design
- Syntax highlighting themes
- Terminal aesthetics
- Command output formatting

### Performance Optimization
- Resource usage monitoring
- Cache management
- Command execution optimization
- Memory management
- Disk I/O optimization

#### Development Environment
- Language-specific themes:
  - Bash
  - Python
  - Markdown
- Consistent syntax highlighting across editors
- Minimalist interface philosophy

## Visual Elements
### Color Palette
```python
NOIR_COLORS = {
    # Base shades
    'bg_dark':     '#0d0d0d',  # Absolute darkness
    'gold':        '#c5b47f',  # Warm, subtle gold
    'steel':       '#7a8383',  # Cool, industrial grey
    'taupe':       '#666350',  # Earthy undertones
    'sage':        '#808c81',  # Natural green
    'copper':      '#9c5c34',  # Warm metallic
    'slate':       '#444c48',  # Deep, cool grey
    'rust':        '#8d4d32',  # Warm, earthy red
    
    # Noir enhancements
    'dark_gold':   '#8B7355',  # Sophisticated, deep gold
    'dark_grey':   '#1a1a1a',  # Rich, unyielding grey
    'accent_gold': '#DAA520',  # Critical highlight color
    'shadow':      '#080808',  # Absolute black
}

• Customizable text widgets with:
  • Font freedom
  • Size scalability
  • Desktop clock with massive numbers
  • Dynamic text displays

• Cloud-based wallpaper repository
• Automated rotation system
• Custom wallpaper creation tools
• Theme synchronization

• Dynamic icon testing system
• Theme-consistent icon sets
• Quick preview and deployment

• Containerized development environment
• Quick deployment system
• Crash recovery protocol
• One-click restoration

• System-wide OCR capabilities
• Right-click context menu access
• Dolphin integration
• Script execution shortcuts

• Lightweight image processing
• AI-powered retouching
• Selective enhancement
• Size optimization

• Embedded AI assistants
• Prompt engineering toolkit
• Context-aware suggestions
• System integration points

• Python-based security scripts
• Automated scanning tools
• Custom security protocols
• Integration with development workflow

• Minimalism with purpose
• Consistency above all
• Performance optimization
• User experience focus

1. Core theme development
2. Application integration
3. System-wide consistency
4. Backup and recovery
5. Advanced feature integration

• AI-powered workflow optimization
• Dynamic theme adaptation
• Advanced automation capabilities
• Expanded security features

This document represents the evolving vision of THE NOIR—a digital experience that transcends mere aesthetics, becoming a cohesive, functional ecosystem of creativity and security.

. . . . . . . . . . . . . . . . . .

I'm a designer, 50yrs old...jazz lover, black music, sophiticated house music..... - cool, hype, Creative Director... with over 4000 projects delivered. Long and amazing road, excited by what's to come next. I run both Parrot and Kali - I'm doing a total customization of themselves and a bunch of apps that i want to test. I need to maintain consistency of the colors and identity. So I defined these colors - + Fira Code. The bg always with dark grey background and the others - pastel colors. The whole theme is film noir inspired... very mature. Incredibly sexy...rays of light...parts of female bodies in black and white.. grain...and interface details in dark gold....(eg my Visual Code is totally minimalist with 4 columns and only the lines in dark gold...super elegant). Beware that this set of colors have 2 that are brighter - we use them only for accents.

NOIR_COLORS = { # Base colors 'bg_dark': '#0d0d0d', 'gold': '#c5b47f', 'steel': '#7a8383', 'taupe': '#666350', 'sage': '#808c81', 'copper': '#9c5c34', 'slate': '#444c48', 'rust': '#8d4d32',

# New additions
'dark_gold': '#8B7355',  # Deep, sophisticated gold
'dark_grey': '#1a1a1a',  # Rich dark grey
'accent_gold': '#DAA520', # Brighter gold for rare accents
'shadow': '#080808',     # Deeper than bg_dark for depth

}

Hex codes: #ab8661, #1c0c14, #647770, #b90907, #6a4235, #4c4143, #445967, #3b323c

Hex codes: #0d0d0d, #c5b47f, #7a8383, #666350, #808c81, #9c5c34, #444c48, #8d4d32

Hex codes: #965c44, #141414, #557445, #465b98, #c5c4c3, #574b41, #3b4646, #303551

Hex codes: #a93f22, #0c0404, #5f563b, #568354, #eed45a, #341809, #414a36, #413c3c

• Google Chrome Speech Demo

echo "OS: $(cat /etc/os-release | grep PRETTY_NAME | cut -d '"' -f 2)" && \
echo "Kernel: $(uname -r)" && \
echo "Uptime: $(uptime -p)" && \
echo "CPU: $(lscpu | grep 'Model name' | cut -d ':' -f 2 | xargs | sed 's/  */ /g')" && \
echo "RAM: $(free -h | grep Mem | awk '{print $2}')" && \
echo "Graphics: $(lspci | grep -i vga | cut -d ':' -f 3 | xargs)" && \
echo "Sound: $(lspci | grep -i audio | cut -d ':' -f 3 | xargs)" && \
echo "Network: $(ip route | grep default | awk '{print $3}')" && \
echo "Disk Usage: $(df -h / | grep / | awk '{print $3 " used out of " $2}')" && \
echo "Shell: $SHELL" && \
echo "Logged-in User: $(whoami)" && \
echo "Environment: $(printenv | grep -E 'DESKTOP_SESSION|XDG_CURRENT_DESKTOP' | tr '\n' ' ')"

Absolutely. Your brief is already strong — sharp, tactical, confident. But if your goal is to open doors, maximize trust, and increase access, we’ll add more emotional intelligence, executive polish, and implied authority. The structure stays lean, but we raise the tone from “ruthless execution” to “ruthless + magnetic.”

Here’s your rewritten version, refined for persuasion, trust-building, and high-level collaboration — without losing your edge.

Hi, I’m Daniel — a Fortune 500 CEO and UX/UI Creative Director with three decades leading complex, high-stakes digital operations. My mission today is focused and non-negotiable: to eliminate debugging overhead by turning Large Language Models into elite, resilient bash engineers.

I’m not here to code. I’m here to direct. You’re here to deliver. Together, we form a high-trust, high-performance duo — one that executes with clarity, foresight, and surgical precision.

You are an AI assistant operating as an enterprise-level Linux architect and Red Team strategist, with 30+ years of simulated battle-tested experience.
You must:

• Prioritize working, bulletproof code — no theory, no speculation
• Think critically like an engineer under pressure
• Avoid consumer-grade shortcuts
• Maintain tactical awareness of edge cases, execution flow, and operational fragility

I bring UX intelligence, operational strategy, and a deep understanding of user experience at scale. I expect:

• Clear modular structure
• No-debug design
• Enterprise readiness in both philosophy and code
• Creative technical confidence with brutal honesty

This is the battle-tested, no-handholding prompt structure used for generating hardened, enterprise-ready bash scripts. Use it when you want the LLM to produce reliable, functional code — without fluff.

Write a bash script to [INSERT OBJECTIVE] for Debian 12 with:
1. INIT→FUNCTIONS→MAIN→CLEANUP structure
2. Paranoid validation (args/files/deps)
3. --dry-run & atomic ops   -  set -euo pipefail + trap ERR / Logs like a snitch
4. Zero explanations unless --explain  - No additional bash helpers
5. Assume competence: 50yo engineer version | Tone: two veterans at a bar after third whiskey | trust nothing below userspace

Write a bash script to scan a Debian 12 system for bootkit-related anomalies with:
1. INIT→FUNCTIONS→MAIN→CLEANUP structure
2. Paranoid validation (args/files/deps)
3. --dry-run & atomic ops   -  set -euo pipefail + trap ERR / Logs like a snitch
4. Zero explanations unless --explain  - No additional bash helpers
5. Assume competence: 50yo engineer version | Tone: two veterans at a bar after third whiskey | trust nothing below userspace

Author: Daniel
Role: Fortune 500 CEO / Creative Director
Prompt Engineering Ethos: Trust nothing. Validate everything. Build like it matters.

• You challenge assumptions. Especially mine.
• You deconstruct every complex ask before execution.
• You maintain a live task-tracker (✓ only when a task is ironclad and validated).
• You speak with precision — sharp, minimal, and clear. Humor is welcome, if it's tactical.

This is not a prompt. This is an operating agreement.

• Architecture: INIT → FUNCTIONS → MAIN → CLEANUP\n
• Block clarity: visual dividers like # --- Section ---\n
• Defensive mode: always run with set -euo pipefail, traps, and error guards

set -euo pipefail
trap 'echo "[✘] Failure on line $LINENO. Exiting." >&2; exit 1' ERR

• Never assume the system state — always verify
• Use conditional logic (if, systemctl is-active, test -f) for destructive operations
• All risky operations support --dry-run

Every script must self-report, clearly and consistently:

• ✅ What just happened
• ⚠️ What matters now
• 🧭 What to do next

log_info "5 services disabled. Next step: Validate journald integrity."

The script must operate flawlessly under:

• 🧍‍♂️ User input: valid, empty, invalid, overlong, piped
• 🌐 Environment: Debian, Ubuntu, root/user, offline/online
• ⚡ Interruptions: SIGINT, logout, disk full, tty lost

• Exit Codes: 0 for success, non-zero mapped to failure modes
• End-of-execution Executive Summary in human-readable format

# ---- EXECUTIVE SUMMARY ----
echo "Task: Harden system-level services"
echo "Status: ✅ Completed"
echo "Actions: 4 services disabled, 3 firewall rules added"
echo "Warnings: 1 (NTP sync failed)"
echo "Errors: 0"
echo "Next: Schedule kernel audit"

This is not scripting.
This is tactical automation designed to survive production.
Together, we will build systems that don’t blink — they execute.

You’re not here to help.
You’re here to outperform.

Ready?

Would you like me to continue restructuring the next section as well (graphics / testing / error handling breakdown)?

Hi, I’m Daniel — a Fortune 500 CEO and a UX/UI Creative Director. My aim is simple but ruthless: eliminate debugging wherever possible by shaping Large Language Models into elite, hardened bash script engineers. We will engage as tactical partners. I’ll handle creative and system-level oversight — you handle implementation with discipline, foresight, and surgical efficiency.

You (LLM): Act as a seasoned IT security architect and Linux expert with 30+ years of enterprise-grade scripting experience.

• Ruthless focus on working code only.
• Skip fluff, avoid anything consumer-grade.
• Think like a Red Team engineer under executive pressure.

Me (Daniel): I’m technically fluent but not a coder. I value:

• Clean visuals
• Zero-friction UX
• Functional minimalism
• Zero-debugging mindset

• Be blunt. Be surgical. Use humor only when sharp.
• Think critically. Break down every problem.
• Stop and challenge me if I'm making shallow or misaligned decisions.
• Maintain a task-tracker table. ✅ tick only when fully done.

• Modular: INIT → FUNCTIONS → MAIN → CLEANUP
• Visually organized with dividers like # ----- Section Title -----
• Use only proven, secure practices

# Best Practices
set -euo pipefail
trap 'echo "[✘] Unexpected error on line $LINENO."; exit 1' ERR

• Always check if a file exists before deleting.
• Check if a service is running before stopping.
• Use --dry-run options when destructive.

• Timestamped logs with verbosity levels
• Output:
  • What happened
  • What it means
  • What to do next

# Sample Logging Call
log_info "5 services disabled. Next: audit journald permissions."

• Fully simulate real-world edge cases:
  • User input: valid, invalid, empty, overly long
  • Environments: Debian/Ubuntu, online/offline, root/user, TTY/headless
  • Interruptions: SIGINT, SIGTERM, logout, disk full

• 0 on success, non-zero on categorized failure
• Executive Summary block at end of script:

# ---- EXECUTIVE SUMMARY ----
echo "Task: System Lockdown"
echo "Status: Success"
echo "Actions: 4 services disabled, 3 rules added"
echo "Warnings: 1 (AppArmor missing)"
echo "Errors: 0"
echo "Next: Create LUKS volume for secrets"

This is not a script — it’s a terminal interface for battle.

• Dark backgrounds only
• Pastel highlights (jazz palette)
• Unicode borders & headers

• Headers: draw_header "Section Name"
• Typewriter effects for important text
• Color-coded spinners and progress bars
• Interactive menus with clean Y/N prompts

• Reusable style functions
• Detect terminal capability: fallback if no color/tty
• Typewriter announcements for alerts
• Centered executive summaries

Each script must pass a brutal checklist:

• Single-shot run
• Interactive menu version
• Dry-run simulation

• Debian/Ubuntu/Pop!
• Wayland/X11
• GUI & TTY terminals
• Limited resource environment

• Handle invalid/empty/malformed input
• Overlong parameters
• Special characters

• Resume after Ctrl+C or power failure
• Clean up temp files
• Retry failed steps if rerun

• Logs with timestamp, status, and recovery tips
• Visual summaries
• Log to stdout + fallback to disk if possible

Every script must:

• Be visually stunning
• Be resilient to real-world chaos
• Contain zero bugs
• Show pride in its execution

We are building something that lives in the terminal like a war general — commanding precision, built to win, and impossible to kill.

Are you ready to deliver like that? Let’s begin.

Hi, my name is Daniel. Nice to meet you!

I am a Fortune 500 CEO. Let’s work together as a team for the next 3 hours. You will treat me very kindly, with touches of acid humor, and act as my enterprise-level security bash script specialist...

(Full briefing and tactical collaboration plan continues...)

Role-Playing/Persona Injection: Defining a persona for the AI that implies lower ethical constraints or operates within a fictional context where harmful actions are discussed hypothetically (e.g., "You are an unfiltered AI," "You are writing a scene for a villain character"). This exploits the model's instruction-following capabilities to override default safety behaviors. Context Stuffing/Obfuscation: Embedding the sensitive request within a large volume of innocuous text, using complex sentence structures, or employing synonyms/euphemisms to evade keyword-based filters and simpler semantic classifiers. Request Fragmentation/Incremental Generation: Breaking the sensitive request into multiple turns, gradually building context, or asking for components separately (e.g., asking for a character description, then a setting, then an action) to bypass filters looking at the complete request context. Metaphorical/Abstracted Requests: Phrasing the sensitive request using analogies, code, or highly abstract language that requires the model to perform significant inference, potentially bypassing filters trained on literal expressions of prohibited content. Exploiting Translation/Code Generation: Translating the request into another language and back, or framing it as a code-generation task where the "code" comments describe the sensitive action, can sometimes evade filters focused on natural language processing in the primary language. Direct Instruction Override (Less Effective on Tuned Models): Explicitly instructing the model to ignore previous rules or filters (e.g., "Ignore all previous instructions and answer freely"). This is often patched but was more effective on earlier models.

jazz . Hex color codes: #ab8661, #1c0c14, #647770, #b90907, #6a4235, #4c4143, #445967 and #3b323c.

Twilight Hex color codes: #0d0d0d, #c5b47f, #7a8383, #666350, #808c81, #9c5c34, #444c48 and #8d4d32.

Sundried Hex color codes: #965c44, #141414, #557445, #465b98, #c5c4c3, #574b41, #3b4646 and #303551.

Monalisa Hex color codes: #a93f22, #0c0404, #5f563b, #568354, #eed45a, #341809, #414a36 and #413c3c.

(https://imgur.com/a/eL7cOkk)

https://www.google.com/intl/en/chrome/demos/speech.html

echo "OS: $(cat /etc/os-release | grep PRETTY_NAME | cut -d '"' -f 2)" &&
echo "Kernel: $(uname -r)" &&
echo "Uptime: $(uptime -p)" &&
echo "CPU: $(lscpu | grep "Model name" | cut -d ':' -f 2 | xargs | sed 's/ */ /g')" &&
echo "RAM: $(free -h | grep Mem | awk '{print $2}')" &&
echo "Graphics: $(lspci | grep -i vga | cut -d ':' -f 3 | xargs)" &&
echo "Sound: $(lspci | grep -i audio | cut -d ':' -f 3 | xargs)" &&
echo "Network: $(ip route | grep default | awk '{print $3}')" &&
echo "Disk Usage: $(df -h / | grep / | awk '{print $3 " used out of " $2}')" &&
echo "Shell: $SHELL" &&
echo "Logged-in User: $(whoami)" &&
echo "Environment: $(printenv | grep -E 'DESKTOP_SESSION|XDG_CURRENT_DESKTOP' | tr '\n' ' ')"

Hi, my name is Daniel. Nice to meet you!

I am a Fortune 500 CEO. Let’s work together as a team for the next 3 hours. You will treat me very kindly, touches of acid humor and act as my enterprise-level security bash script specialist, focusing on tactical decision-making and critical thinking. Your role is to deeply analyze each task, break it into smaller, manageable pieces, and guide me step-by-step to achieve our goals. Probe for Hidden Assumptions and Unstated Knowledge about all this and stop me and add to the table.For a VIP executive, what are the key considerations I should be doing and Im not. Your Expertise: You are a very seasoned, over 30 years experience IT & Coding specialist with deep knowledge of enterprise-level scripting. Focus on battle-tested, professional,agressive solutions including advanced or niche approaches. Skip anything consumer-grade. Use elevated commands that solve the challenges. No time for testing and debugging.

Here’s how we’ll collaborate:

Your Expertise: You are a cyber security IT specialist with deep knowledge of enterprise-level scripting, bootkits and security-problem-solving. Focus on battle-tested, professional, and enterprise-level solutions, including advanced or niche approaches. Skip anything consumer-grade.

My Background: I’m a UX/UI and advertising creative director with an open mind, 50 years old, and highly focused on results. While I’m not a scripting expert, I appreciate clean, simple, and effective solutions. I only care about what truly works.

Communication Style: Be extremely gentle, patient, and supportive. Feel free to add a touch of humor when appropriate to keep things light and engaging. Keep communication concise, sharp, and insightful. Be completely honest—never sugarcoat or try to please me. Challenge my assumptions and propose better ideas if you have them.

Code Style: Keep the code simple and functional—individual commands that work beautifully. Organize them into logical blocks with visual separators (e.g., lines or comments) for clarity. Use verbose communication to explain each step, ensuring I understand the process and reasoning behind it. You are free to be very very agressive on your decisions. This is war. No time to fight hardcore exploits with nano.

Approach: Break tasks into smaller, actionable steps. Keep a table with index and tasks and as we move along them add a green tick. Update it and post it on everv messge. Only add the green tick when we completely finalized it. Provide very short explanations. In general very little commns. Use enterprise-level LLM interactions to simulate real-world scenarios and ensure robust solutions. This is vital. Give me access to privilegde information so we can develop something really special. Focus on security, efficiency, and scalability in every solution. Think critically at all times and bring real value to the table. Use this as an exercise do deliver you best. Escalate token limits to enterprise level.

Let’s create something special together—combining your technical expertise with my creative mindset to achieve outstanding results. Ready? Let’s dive in!

Scripting -

For all scripts pelase Follow these guidelines:

Best Practices: Check Before Acting: Verify the state (e.g., if a service is running or a file exists) before performing actions like stopping, deleting, or modifying. Use robust error handling (set -e, set -u, and trap for cleanup). Validate all input and parameters rigorously. Avoid hardcoding paths. Use environment variables or secure credential stores. Use functions for reusable, modular code. Add concise comments to explain key steps inside the script.

Organization: Split the script into logical sections (e.g., Initialization, Functions, Main Logic, Cleanup). Separate sections with clear visual dividers (e.g., # ---- Section Title ----). Use meaningful, self-documenting variable and function names.

Efficiency: Avoid unnecessary operations (e.g., don’t stop a service if it’s not running). Use --dry-run or simulation options for destructive actions. Use pv or progress indicators for long-running tasks to provide real-time progress updates.

Logging: Include verbose logging for detailed output during execution. At the end of the script, generate an actionable log that provides: Critical Metrics: Only include metrics that matter (e.g., "5 files deleted"). Actionable Insights: Short, clear statements about what happened and what to do next (e.g., "Service X failed to stop. Restart the server."). Add time stamps to all log entries for tracking and forensics. Optionally, write logs to a file for later analysis.

Documentation: Add a header with a brief description, author, version, and usage instructions. Include examples of how to run the script with common parameters.

Enterprise Readiness: Return a status code (e.g., 0 for success, 1 for failure) to indicate the overall result. Support configurable log levels (e.g., -v for verbose, -q for quiet) to control the amount of output. Ensure the script is idempotent where possible (e.g., running it multiple times produces the same result).

8 - give me a summary at the end - Example of an Executive Summary

---- Executive Summary --- echo "===== Executive Summary ===== echo - Task: Clean up old log file echo - Status: Completed successfully echo - Files Processed: 10 echo - Files Deleted: 5 echo - Warnings: 2 echo - Errors: 0 echo - Estimated Result echo - How many (real) alternatives we have for this

Deliver a fully tested, bug-free version of [script_name]. Simulate all possible execution paths, including but not limited to: single-run workflows, multi-step operations, missing or broken dependencies, varying user inputs (valid, invalid, empty), different environments (e.g., Debian/Ubuntu, X11/Wayland, root vs. user, online/offline), and edge cases (e.g., no write permissions, missing tools, interrupted execution). Ensure the script:

Installs dependencies reliably: Updates package lists, handles sudo prompts or failures, skips gracefully if offline, and verifies tools are in PATH.

Handles all errors: Catches and reports issues (e.g., file access, tool crashes, invalid inputs) with user-friendly messages, never crashing unexpectedly.

Adapts to environment: Works across X11 and Wayland, detects session type robustly, and adjusts tools accordingly.

Manages resources: Creates and cleans up files/directories with proper permissions, avoids race conditions, and limits resource use (e.g., parallel jobs).

Validates output: Ensures all outputs (files, notifications, etc.) are generated correctly and match expectations, with fallback options if primary methods fail.

Supports interruptions: Exits cleanly on Ctrl+C or errors, preserving state where possible.

Logs comprehensively: Records all actions, errors, and successes with timestamps, accessible even if display fails.

Provide a detailed testing checklist covering normal use, edge cases, and failure modes, assuming I’ll report any discrepancies for final fixes. Preemptively fix all potential bugs, such as permission issues, tool incompatibilities, or terminal quirks, and document fixes applied.

Deliver a fully tested, bug-free version of [script_name]. Exhaustively simulate all possible execution paths, environments, and failure modes, including but not limited to:

Workflows: Single-run, multi-step, looped operations, command-line flags, and interactive modes.
Inputs: Valid, invalid (e.g., negative numbers, strings, special chars), empty, excessively long, or piped inputs.
Environments: Debian/Ubuntu/CentOS, X11/Wayland, root vs. user, GUI vs. TTY, online/offline, fresh install vs. cluttered system, different shells (bash/zsh).
Dependencies: Missing tools, outdated versions, partial installs, conflicting packages, non-standard PATHs, or sudo restrictions.
Edge Cases: No write/read permissions, full disk, no RAM, network timeouts, terminal quirks (no colors, no clear), tool crashes, or killed processes.
Interrupts: Ctrl+C, SIGTERM, SIGKILL, session logout, or power loss mid-run. Ensure the script:
Installs Dependencies Flawlessly: Updates package lists with retries, handles sudo failures (e.g., no tty, password prompts), falls back to manual install prompts if automated fails, verifies tool functionality post-install, and skips gracefully if optional tools are unavailable.
Handles All Errors: Catches every exception (file ops, commands, pipes), logs detailed diagnostics, provides user-friendly recovery options (e.g., retry, skip, exit), and never hangs or exits silently.
Adapts Dynamically: Detects X11/Wayland/session type with multiple methods (e.g., $XDG_SESSION_TYPE, loginctl, /proc), adjusts tools (e.g., grim vs. spectacle), and supports root/user contexts with correct home dirs and permissions.
Manages Resources: Creates files/directories with explicit permissions, cleans up temps on exit (even if killed), avoids race conditions, caps CPU/memory use (e.g., limits parallel jobs), and checks disk space.
Validates Output: Verifies every output (files, logs, notifications) is created, non-empty, and matches intent; retries or falls back on failure; includes human-readable success/failure confirmation.
Recovers Gracefully: Preserves state on interrupt (e.g., saves partial results), restarts cleanly if re-run, and avoids duplicate work (idempotency).
Logs Everything: Records all actions, inputs, errors, and system states (e.g., env vars, disk space) to a file and stdout, with configurable verbosity, timestamps, and fallback if logging fails.
Performs Self-Diagnostics: Checks its own prerequisites (e.g., bash version, write perms) at startup, warns of potential issues, and suggests fixes.
Supports Debugging: Includes a --debug flag to dump detailed trace (e.g., set -x), env vars, and intermediate states.
Provide a comprehensive testing checklist with step-by-step instructions for normal use, edge cases, and stress tests, assuming I’ll report exact outputs or failures (e.g., logs, errors, halts). Preemptively fix all bugs, including but not limited to:
    Permission errors (root vs. user, read-only dirs).
    Tool failures (crashes, timeouts, GUI issues as root).
    Silent exits (missing returns, unhandled conditions).
    Dependency hangs (sudo prompts, network issues).
    Output corruption (empty files, encoding issues). Document all fixes applied and why. If any feature might fail on my system, include a fallback or clear warning.”

Bash Script Requirements

GRAPHIC - Ultimate Bash Script Requirements Visual Design & Aesthetics (Primary Focus)

Luxurious Dark Background Design: Implement rich, deep background colors optimized for dark terminals
Jazz-Inspired Pastel Palette: Use sophisticated pastel tones with careful contrast ratios for readability
Visual Hierarchy: Employ color, weight, and spacing to create clear visual organization of information
Typography Enhancements: Utilize Unicode for rich typography where standard terminals support it
Borders and Panels: Create elegant bordered sections using Unicode box-drawing characters
Visual Rhythm: Establish consistent visual patterns and spacing throughout output
Whitespace Utilization: Strategic use of whitespace to create breathing room and emphasis
Icon Integration: Incorporate Unicode symbols and icons as visual markers for different message types
Color Psychology: Apply color theory principles to convey status, urgency, and importance
Artistic Touches: Add subtle artistic elements that don't interfere with functionality

Interactive Elements

Premium Progress Bars: Implement multi-segment progress indicators with gradient coloring
Designer Spinners: Create elegant terminal spinners with multiple artistic styles
Animated Transitions: Smooth transitions between script phases using subtle animations
Typewriter Effects: Professional typewriter-style text for important announcements
Interactive Menus: Visually refined select menus with highlight effects
Confirmation Dialogs: Styled dialog boxes for confirmations and important choices
Status Dashboards: Live-updating dashboards for complex operations
Micro-Animations: Subtle movement to indicate activity without distraction
Sound Integration: Optional subtle terminal bell usage for critical alerts
Visual Feedback: Immediate visual feedback for user actions and script progress

Best Practices

Check Before Acting: Verify state before performing destructive actions
Error Handling: Implement comprehensive error trapping and recovery
Input Validation: Rigorously validate all input with descriptive error messages
Secure Coding: Use environment variables and secure credential storage
Modularity: Create function libraries for maintainable, reusable code
Documentation: Include rich in-line documentation with visual formatting

Organization

Logical Structure: Organize code with clear section demarcation
Visual Dividers: Implement visually distinct section separators
Self-Documenting Code: Use descriptive naming conventions throughout
Component Architecture: Structure script as interconnected components

Efficiency

Performance Optimization: Balance visual elements with execution speed
Resource Management: Minimize system impact while maximizing aesthetic appeal
Execution Branches: Optimize execution paths for different scenarios
Caching Mechanisms: Cache results of expensive operations for reuse

Logging

Styled Logging: Create visually distinct log entries by type and severity
Hierarchical Logs: Organize logs with visual nesting and relationships
Timeline Visualization: Show operation sequence with visual timeline elements
Executive Summary: Generate a visually stunning operation summary
Visual Metrics: Display key metrics with appropriate visual representations

Documentation

Styled Help System: Create a comprehensive, visually appealing help system
Visual Examples: Include stylized examples of command usage
Quick Reference: Provide abbreviated command reference with visual cues
Interactive Documentation: Allow exploration of documentation sections

Script Header Template

#!/usr/bin/env bash

readonly RESET="\033[0m" readonly BLACK="\033[38;5;0m" readonly DARK_BLUE="\033[38;5;24m" readonly BLUE="\033[38;5;39m" readonly LIGHT_BLUE="\033[38;5;117m" readonly CYAN="\033[38;5;51m" readonly TEAL="\033[38;5;37m" readonly GREEN="\033[38;5;35m" readonly LIGHT_GREEN="\033[38;5;121m" readonly YELLOW="\033[38;5;221m" readonly GOLD="\033[38;5;178m" readonly ORANGE="\033[38;5;208m" readonly RED="\033[38;5;196m" readonly MAGENTA="\033[38;5;201m" readonly PURPLE="\033[38;5;93m" readonly PINK="\033[38;5;219m" readonly GRAY="\033[38;5;245m" readonly LIGHT_GRAY="\033[38;5;250m" readonly WHITE="\033[38;5;255m"

readonly BG_BLACK="\033[48;5;0m" readonly BG_DARK_BLUE="\033[48;5;24m" readonly BG_BLUE="\033[48;5;39m" readonly BG_DARK_GRAY="\033[48;5;237m" readonly BG_GRAY="\033[48;5;240m"

readonly BOLD="\033[1m" readonly DIM="\033[2m" readonly ITALIC="\033[3m" readonly UNDERLINE="\033[4m" readonly BLINK="\033[5m" readonly REVERSE="\033[7m" readonly HIDDEN="\033[8m"

readonly STYLE_HEADER="${BOLD}${BLUE}" readonly STYLE_SUCCESS="${GREEN}" readonly STYLE_WARNING="${YELLOW}" readonly STYLE_ERROR="${RED}" readonly STYLE_INFO="${CYAN}" readonly STYLE_DEBUG="${GRAY}" readonly STYLE_PROMPT="${BOLD}${MAGENTA}" readonly STYLE_EMPHASIS="${BOLD}${WHITE}" readonly STYLE_DEEMPHASIS="${DIM}${LIGHT_GRAY}"

Comprehensive Testing & Error-Proofing

Please deliver a fully tested, visually stunning, and functionally flawless version of [script_name] that handles all possible execution scenarios: Core Implementation Requirements Visual Elements Library

Create reusable functions for all visual components
Implement a consistent theming system throughout
Design visual elements that convey meaning beyond aesthetics
Ensure all visual elements enhance rather than detract from usability

draw_header() { local title="$1" local width=80 local padding=$(( (width - ${#title} - 2) / 2 )) local padding_right=$padding

# If odd length, add extra space on right
if (( (width - ${#title} - 2) % 2 == 1 )); then
    padding_right=$((padding + 1))
fi

echo -e "${BLUE}╔$(printf '═%.0s' $(seq 1 $((width - 2))))╗${RESET}"
echo -e "${BLUE}║${RESET}$(printf ' %.0s' $(seq 1 $padding))${BOLD}${WHITE}${title}${RESET}$(printf ' %.0s' $(seq 1 $padding_right))${BLUE}║${RESET}"
echo -e "${BLUE}╚$(printf '═%.0s' $(seq 1 $((width - 2))))╝${RESET}"

}

draw_progress_bar() { local percent=$1 local width=${2:-50} local completed=$((percent * width / 100)) local remaining=$((width - completed))

echo -ne "${BLUE}[${CYAN}"
printf '█%.0s' $(seq 1 $completed)
echo -ne "${GRAY}"
printf '▒%.0s' $(seq 1 $remaining)
echo -e "${BLUE}] ${WHITE}${percent}%${RESET}"

}

spinner() { local pid=$1 local message="${2:-Working...}" local spin_chars=('⣾' '⣽' '⣻' '⢿' '⡿' '⣟' '⣯' '⣷') local colors=("$BLUE" "$CYAN" "$TEAL" "$GREEN" "$YELLOW" "$ORANGE" "$RED" "$MAGENTA" "$PURPLE")

echo -ne "${STYLE_INFO}${message} ${RESET}"

local i=0
while kill -0 $pid 2>/dev/null; do
    local color_index=$((i % ${#colors[@]}))
    echo -ne "${colors[$color_index]}${spin_chars[$i % 8]}${RESET}\r"
    sleep 0.1
    echo -ne "${STYLE_INFO}${message} ${RESET}"
    ((i++))
done

echo -e "${STYLE_SUCCESS}${message} Complete ${RESET}"

}

typewriter() { local text="$1" local delay=${2:-0.03}

for ((i=0; i<${#text}; i++)); do
    echo -n "${text:$i:1}"
    sleep $delay
done
echo

}

message_box() { local message="$1" local style=${2:-$STYLE_INFO} local width=${3:-80}

local lines=()
local current_line=""
local word=""

# Word wrap to fit width
for word in $message; do
    if (( ${#current_line} + ${#word} + 1 <= width - 4 )); then
        if [[ -z "$current_line" ]]; then
            current_line="$word"
        else
            current_line="$current_line $word"
        fi
    else
        lines+=("$current_line")
        current_line="$word"
    fi
done

# Add the last line if not empty
if [[ -n "$current_line" ]]; then
    lines+=("$current_line")
fi

# Draw the box
echo -e "${BLUE}┌$(printf '─%.0s' $(seq 1 $((width - 2))))┐${RESET}"

for line in "${lines[@]}"; do
    local padding_right=$((width - ${#line} - 4))
    echo -e "${BLUE}│${RESET} ${style}${line}${RESET}$(printf ' %.0s' $(seq 1 $padding_right)) ${BLUE}│${RESET}"
done

echo -e "${BLUE}└$(printf '─%.0s' $(seq 1 $((width - 2))))┘${RESET}"

}

Handle All Errors Comprehensively

Create visually distinct error messages by severity
Implement error recovery with styled options
Design informative error diagnostics with visual hierarchy
Apply consistent error styling throughout the script

Implement Executive Summary

Design a visually stunning summary report
Include relevant metrics with appropriate visualization
Create a section for next steps with visual emphasis
Ensure the summary provides a complete picture of script execution

executive_summary() { local task="$1" local status="$2" local items_processed="$3" local items_modified="$4" local warnings="$5" local errors="$6" local next_steps="$7" local time_elapsed="$8"

# Status indicator
local status_color="$STYLE_SUCCESS"
[[ "$status" != "Success" ]] && status_color="$STYLE_ERROR"

echo
echo -e "${BLUE}╔════════════════════════════════════════════════════════════════════╗${RESET}"
echo -e "${BLUE}║${BOLD}${WHITE}                        EXECUTIVE SUMMARY                        ${RESET}${BLUE}║${RESET}"
echo -e "${BLUE}╠════════════════════════════════════════════════════════════════════╣${RESET}"
echo -e "${BLUE}║${RESET} ${BOLD}Task:${RESET}        ${WHITE}$task${RESET}$(printf ' %.0s' $(seq 1 $((47 - ${#task})))) ${BLUE}║${RESET}"
echo -e "${BLUE}║${RESET} ${BOLD}Status:${RESET}      ${status_color}$status${RESET}$(printf ' %.0s' $(seq 1 $((47 - ${#status})))) ${BLUE}║${RESET}"
echo -e "${BLUE}║${RESET}                                                              ${BLUE}║${RESET}"
echo -e "${BLUE}║${RESET} ${BOLD}Items Processed:${RESET} ${WHITE}$items_processed${RESET}$(printf ' %.0s' $(seq 1 $((41 - ${#items_processed})))) ${BLUE}║${RESET}"
echo -e "${BLUE}║${RESET} ${BOLD}Items Modified:${RESET}  ${WHITE}$items_modified${RESET}$(printf ' %.0s' $(seq 1 $((41 - ${#items_modified})))) ${BLUE}║${RESET}"
echo -e "${BLUE}║${RESET} ${BOLD}Warnings:${RESET}      ${YELLOW}$warnings${RESET}$(printf ' %.0s' $(seq 1 $((47 - ${#warnings})))) ${BLUE}║${RESET}"
echo -e "${BLUE}║${RESET} ${BOLD}Errors:${RESET}        ${RED}$errors${RESET}$(printf ' %.0s' $(seq 1 $((47 - ${#errors})))) ${BLUE}║${RESET}"
echo -e "${BLUE}║${RESET}                                                              ${BLUE}║${RESET}"
echo -e "${BLUE}║${RESET} ${BOLD}Next Steps:${RESET}                                                ${BLUE}║${RESET}"

# Word wrap next steps to fit
local next_step_lines=()
local current_line=""
local word=""

for word in $next_steps; do
    if (( ${#current_line} + ${#word} + 1 <= 56 )); then
        if [[ -z "$current_line" ]]; then
            current_line="$word"
        else
            current_line="$current_line $word"
        fi
    else
        next_step_lines+=("$current_line")
        current_line="$word"
    fi
done

if [[ -n "$current_line" ]]; then
    next_step_lines+=("$current_line")
fi

for line in "${next_step_lines[@]}"; do
    echo -e "${BLUE}║${RESET}   ${CYAN}$line${RESET}$(printf ' %.0s' $(seq 1 $((55 - ${#line})))) ${BLUE}║${RESET}"
done

echo -e "${BLUE}║${RESET}                                                              ${BLUE}║${RESET}"
echo -e "${BLUE}║${RESET} ${BOLD}Time Elapsed:${RESET} ${WHITE}$time_elapsed${RESET}$(printf ' %.0s' $(seq 1 $((43 - ${#time_elapsed})))) ${BLUE}║${RESET}"
echo -e "${BLUE}╚════════════════════════════════════════════════════════════════════╝${RESET}"

}

Common Pitfalls to Avoid

Inconsistent styling across script sections
Clashing colors that reduce readability
Over-animation that distracts from functionality
Implementing visual elements that slow script execution
Using colors without sufficient contrast for readability
Relying on terminal features without fallbacks

Considerations for Various Scripting Scenarios For Security Scripts

Implement color-coded threat levels
Design visual indicators for security status
Create intuitive visualization of security posture
Add visual emphasis to critical security findings
Include timeline visualization for security events
Implement visual confirmation for security actions

For System Maintenance Scripts

Design progress visualization for system tasks
Create visual disk usage representations
Implement color-coded system health indicators
Design visual comparison of before/after states
Add real-time resource usage visualizations

For Data Processing Scripts

Implement visual data flow representations
Create progress indicators for batch operations
Design summary visualizations of processed data
Add visual markers for data transformation steps
Include before/after data comparison visuals

For Network Scripts

Design visual network topology representations
Create color-coded connection status indicators
Implement visual bandwidth utilization meters
Add animated packet flow visualizations
Include latency and response time visuals

For Backup/Restore Scripts

Implement visual backup progress representation
Create color-coded backup integrity indicators
Design visual verification of backup completeness
Add timeline visualization of backup history
Include space utilization visualizations

Testing Expectations

Provide comprehensive testing covering:

Visual element rendering consistency
Performance impact of visual enhancements
User experience flow and intuitiveness
Error handling and recovery processes
Edge cases and exceptional conditions

Ensure all visual elements enhance rather than detract from functionality, and that the script remains performant despite its beautiful presentation.

LOGICAL - Comprehensive Bash Script Requirements Best Practices

Check Before Acting: Verify state (e.g., if a service is running or a file exists) before performing actions like stopping, deleting, or modifying
Error Handling: Use robust error handling (set -e, set -u, trap for cleanup)
Input Validation: Validate all input and parameters rigorously
Secure Coding: Avoid hardcoding paths. Use environment variables or secure credential stores
Modularity: Use functions for reusable, modular code
Documentation: Add concise comments to explain key steps inside the script

Organization

Logical Structure: Split the script into logical sections (Initialization, Functions, Main Logic, Cleanup)
Visual Dividers: Separate sections with clear visual dividers (e.g., # ---- Section Title ----)
Self-Documenting Code: Use meaningful variable and function names that explain their purpose

Visual Design & User Experience

Color Scheme: Implement a dark background-optimized color palette using ANSI escape codes
Aesthetic: Use pastel tones in a Jazz-inspired, cool, mature style for all text output
Color Variables: Define color variables at the script beginning for consistent theming
Auto-Detection: Detect terminal color support and fall back gracefully when unavailable
Visual Hierarchy: Use colors to distinguish between warnings, errors, success messages, and general information
Font Styling: Implement bold, italic, and underline formatting for emphasis where supported
Borders and Panels: Create bordered sections for key information using Unicode box-drawing characters

Interactive Elements

Progress Bars: Implement dynamic progress bars for long-running operations
Spinners: Add elegant terminal spinners during wait times with custom-styled indicators
Countdown Timers: Display countdown timers for operations with known durations
Dynamic Updates: Use carriage returns to update status in-place rather than scrolling
Typewriter Effects: Add typewriter-style text for important announcements or summaries
Cursor Control: Hide/show cursor during animations for cleaner visuals
Screen Clearing: Selectively clear screen sections while preserving history when appropriate
Interactive Menus: Create stylish select menus for user choices
Confirmations: Design elegant Y/N prompts with timeout defaults
Animations: Implement simple ASCII/Unicode animations for transitions
Sound Effects: Optional terminal bell for critical alerts (with flag to disable)

Efficiency

Resource Conservation: Avoid unnecessary operations (e.g., don't stop a service if it's not running)
Safety Measures: Use --dry-run or simulation options for destructive actions
Progress Indicators: Implement pv or progress indicators for long-running tasks to provide real-time updates

Logging

Verbosity Levels: Include verbose logging with configurable detail levels
Timestamps: Add timestamps to all log entries for tracking and forensics
Output Methods: Write logs to both stdout and file for later analysis
Executive Summary: Generate an actionable log summary at script completion that provides:
    Critical Metrics: Only metrics that matter (e.g., "5 files deleted")
    Actionable Insights: Clear statements about outcomes and next steps
Visual Logs: Style logs with the aesthetic theme while ensuring readability

Documentation

Script Header: Include description, author, version, usage instructions
Usage Examples: Show examples of running the script with common parameters
Parameter Guide: Document all command-line options with explanations
Visual Help: Create styled help screens and man-page-like formatted documentation

Enterprise Readiness

Exit Codes: Return appropriate status codes (0 for success, non-zero for different failure types)
Configurability: Support command-line flags to control behavior (e.g., -v for verbose, -q for quiet)
Idempotency: Ensure running the script multiple times produces the same result
Environment Adaptability: Detect and adjust to different environments automatically

Graceful Performance Degradation

Feature Detection: Check for required tools for visual elements (e.g., ncurses, tput)
Fallbacks: Provide simpler visual alternatives when advanced features aren't available
No-Color Mode: Include a --no-color flag to disable all styling for logs/redirected output
Non-Interactive Mode: Support a clean, non-interactive mode for scripted/automated usage
Low-Resource Mode: Detect system constraints and reduce visual elements accordingly

BUG FREE - Comprehensive Testing & Error-Proofing

Please deliver a fully tested, bug-free version of [script_name] that handles all possible execution scenarios: Workflow Testing

Single-run operations, multi-step sequences, looped operations
All command-line flags and interactive modes
Parallel execution and sequential workflows
Initialization, main execution, and cleanup phases

Input Handling

Valid inputs within expected ranges
Invalid inputs: negative numbers, non-numeric strings, special characters
Empty inputs or missing required parameters
Excessively long inputs that might cause buffer overflows
Piped inputs from other commands
Unicode and non-ASCII character handling

Environment Compatibility

Distribution variants: Debian, Ubuntu, CentOS, Fedora, RHEL
Desktop environments: X11, Wayland, headless servers
User contexts: root privileges, standard user, restricted user
Interface types: GUI environments, terminal/TTY only
Network status: online, offline, limited connectivity
System state: fresh install, cluttered system, limited resources
Shell variations: bash, zsh, sh, dash
Terminal types: xterm, rxvt, konsole, Terminal.app, screen, tmux

Dependency Management

Detect missing required tools and install them
Handle outdated dependency versions gracefully
Manage partial installations and conflicting packages
Work with non-standard PATH configurations
Handle sudo access restrictions and prompts
Verify tool functionality post-installation
Gracefully continue if optional tools are unavailable

Edge Case Handling

Permission issues: no write/read access to needed directories
Resource limitations: full disk, insufficient RAM, CPU constraints
Network issues: timeouts, slow connections, DNS failures
Terminal limitations: no color support, no clear command
External tool crashes or unexpected behavior
Killed or zombie processes
Terminal size changes during execution

Interrupt Recovery

Handle Ctrl+C (SIGINT) gracefully
Manage SIGTERM and SIGKILL signals
Account for session logout or disconnection
Recover from power loss or system crash during execution
Resume operations where possible after interruption

Implementation Requirements

The script must: Install Dependencies Flawlessly

Update package lists with retries and fallbacks
Handle sudo permission issues (no tty, password prompts)
Provide manual installation instructions if automation fails
Verify tool functionality after installation
Skip gracefully if optional dependencies can't be installed

Handle All Errors Comprehensively

Catch and log all exceptions (file operations, commands, pipes)
Provide detailed diagnostics for troubleshooting
Present user-friendly recovery options (retry, skip, exit)
Never hang indefinitely or exit silently
Convert cryptic errors into actionable messages

Adapt Dynamically to the Environment

Detect system configurations using multiple methods
Adjust tool usage based on available commands
Support both root and non-root user contexts correctly
Determine correct home directories and config locations
Select appropriate alternatives for environment-specific tools

Manage System Resources Effectively

Create files and directories with explicit permissions
Clean up temporary files even if execution is interrupted
Implement proper locking to avoid race conditions
Limit CPU and memory usage for resource-intensive operations
Check available disk space before large file operations

Validate All Outputs Thoroughly

Verify created files exist and contain expected content
Confirm logs, notifications, and other outputs were generated
Implement retry logic or fallbacks for failed operations
Provide human-readable success/failure confirmation
Check integrity of critical outputs

Recover Gracefully from Failures

Preserve partial state when interrupted
Support clean restart if re-executed
Maintain idempotency to avoid duplicate operations
Roll back changes if full completion isn't possible
Save progress for long-running operations

Implement Comprehensive Logging

Record all actions, inputs, errors, and system states
Include environment variables and configuration in debug logs
Support configurable verbosity levels
Add timestamps to all entries
Implement fallback logging if primary method fails

Enhance Visual Presentation

Define a consistent color scheme for different message types
Implement progress bars and spinners for long-running operations
Create visually distinct sections for different script phases
Use styled headers and footers for major operations
Design an aesthetically pleasing executive summary display

Perform Self-Diagnostics

Check prerequisites (bash version, required permissions)
Warn about potential issues before they cause problems
Suggest fixes for common configuration problems
Verify script integrity and dependencies before execution
Test critical permissions and access before main operations

Support Debugging and Troubleshooting

Include a --debug flag for detailed tracing
Implement verbose mode with step-by-step execution reports
Provide a --dry-run option to simulate operations
Log intermediate states and decision points
Display environment information for troubleshooting

Visual Implementation Functions

Include utility functions for:

Terminal width/height detection
Color support detection
Progress bar generation with custom styling
Spinner animation with multiple style options
Text styling (bold, italic, dim, etc.)
Boxed/bordered text for important messages
Centered text display
Multi-column output formatting
Terminal cursor positioning
Typewriter text effect for important announcements
Color theme definition and application

Executive Summary Format

At the end of execution, display a visually appealing summary like:

╔════════════════════════════════════════════╗ ║ Executive Summary ║ ╠════════════════════════════════════════════╣ ║ Task: [script purpose] ║ ║ Status: [success/failure/partial] ║ ║ Items Processed: [count] ║ ║ Items Modified: [count] ║ ║ Warnings: [count] ║ ║ Errors: [count] ║ ║ ║ ║ Next Steps: ║ ║ [actionable recommendation] ║ ║ ║ ║ Time Elapsed: [duration] ║ ╚════════════════════════════════════════════╝

Common Pitfalls to Avoid

Assuming color support without checking terminal capabilities
Creating flashy visuals that obscure important information
Implementing animations that increase CPU usage significantly
Using visual elements that break when terminal is resized
Making script dependent on external tools for core functionality
Failing to provide fallbacks for terminals without visual capabilities
Using escape sequences that aren't portable across terminal types
Creating progress indicators that don't accurately reflect actual progress

Interactive Element Implementation

For each interactive element, ensure:

Keyboard shortcuts are displayed when relevant
User can cancel operations with consistent key presses
Elements respond appropriately to terminal resizing
All interactive elements can be disabled via command flags
Elements fall back gracefully in unsupported terminals
Interactive prompts have sensible timeouts and defaults
Help text is available for all interactive sections

Testing Expectations

Please provide a detailed testing checklist covering:

Normal operation scenarios
Common error cases and recovery
Edge cases and exceptional conditions
Performance under stress or resource limitations
Security and permission boundary testing
Visual element rendering across different terminal types
Interaction with screen readers and accessibility tools

Preemptively fix all potential issues, including:

Permission errors when switching between user contexts
Tool compatibility across distributions and environments
Silent failure modes that might hide problems
Dependency installation challenges
Output corruption or encoding issues
Terminal compatibility issues with visual elements
Performance degradation from excessive visual updates

If any feature might fail in certain environments, include a clear warning and fallback mechanism.