import os
import sys

class EnvConfessionalBooth:
    """
    A satirical yet brutally effective tool that forces you to confess
    your environment variable sins before they haunt you in production.
    """
    
    def __init__(self, required_vars):
        """
        Initialize with list of required environment variables.
        Example: ['API_KEY', 'DATABASE_URL', 'SECRET_SALT']
        """
        self.required_vars = required_vars
        self.missing_vars = []
    
    def confess(self):
        """
        Check for missing environment variables and expose sins.
        Returns True if all variables are present, False otherwise.
        """
        print("\n🔔 *Ding Ding Ding* 🔔")
        print("Welcome to the .env Confessional Booth!")
        print("Let's expose your environment variable sins...\n")
        
        for var in self.required_vars:
            if not os.getenv(var):
                self.missing_vars.append(var)
                print(f"❌ SIN DETECTED: '{var}' is missing from your environment")
                print(f"   You'll get a cryptic 'Internal Server Error' for this!")
            else:
                print(f"✅ Virtue found: '{var}' is properly set")
        
        if self.missing_vars:
            print(f"\n⚠️  CONFESSION TIME: You have {len(self.missing_vars)} unconfessed sins!")
            print(f"Missing: {', '.join(self.missing_vars)}")
            print("\nGo forth and set these variables before deployment!")
            return False
        else:
            print("\n🎉 ABSOLUTION GRANTED: All environment variables are present!")
            print("Your app won't fail silently (at least not for this reason).")
            return True

# Usage example:
if __name__ == "__main__":
    # Define your required environment variables
    required = ['API_KEY', 'DATABASE_URL', 'SECRET_SALT', 'STRIPE_KEY']
    
    # Create confessional booth
    confessor = EnvConfessionalBooth(required)
    
    # Check for sins
    if not confessor.confess():
        sys.exit(1)  # Exit with error if sins found

The Problem: Our Dirty Little Secrets

Environment variables are the digital equivalent of that junk drawer in your kitchen. You throw everything in there—API keys, database URLs, secret salts—and then promptly forget about them until something breaks. And when it breaks, oh boy, does it break spectacularly. No error messages, just a cryptic 'Internal Server Error' that sends you down a rabbit hole of checking your code, your dependencies, your life choices.

Why does this problem exist? Because we treat environment variables like they're classified government documents. We whisper them to new team members in hushed tones ('psst, the staging DB password is 'password123', but don't tell anyone'). We store them in Slack DMs, sticky notes, and sometimes—god help us—in plain text files named 'secrets.txt' on the desktop. It's absurd. We're building billion-dollar applications on foundations of chaos and hope.

Consider this classic scenario: you deploy to production. The app starts. Everything seems fine. Then, at 2 AM, your phone blows up because the payment service is down. Why? Because the environment variable was named STRIPE_API_KEY in development but STRIPE_SECRET in production. Or maybe it was set to an empty string. Or maybe it never existed at all. The application, being the polite software it is, decides to fail silently rather than inconvenience anyone with a helpful error message. It's like your code is gaslighting you.

The Solution: A Booth for Your Sins

Enter the .env Confessional Booth. I built this tool because I was tired of playing detective every time my app decided to have an existential crisis. The concept is simple: instead of letting your environment variables hide in shame, force them to confess their sins before they cause damage.

How does it work? The tool scans your codebase for required environment variables (looking for patterns like process.env.SOMETHING or os.getenv('WHATEVER')). Then it checks if those variables are actually set in your environment or .env files. But here's the twist: instead of dry technical output, it generates dramatic 'confession' messages that make you feel the weight of your mistakes.

Why is this actually useful despite the humor? Because it turns a tedious, error-prone task into something memorable. You're not just checking variables—you're conducting an intervention for your code. The color-coded output (red for missing, yellow for empty, orange for suspicious) gives you instant visual feedback. And the pièce de résistance: it generates an 'absolution' script with all the correct exports, so you can fix your sins with a single command.

How to Use It: Your Path to Redemption

Installation is straightforward. Since it's a Python tool, you can install it via pip:

pip install env-confessional-booth

Or clone it directly from GitHub and run it as a script. Basic usage is even simpler:

# Scan your current directory
confess --scan .

# Specify a different directory
confess --scan /path/to/your/project

# Generate absolution script
confess --scan . --absolve

Here's a taste of the actual code—the part that generates those deliciously dramatic confession messages:

def generate_confession(var_name, status, value=None):
    if status == 'missing':
        return f"🫣 I confess: {var_name} is MISSING. I don't exist at all."
    elif status == 'empty':
        return f"😶 I confess: {var_name} is EMPTY. I'm here, but I'm nothing."
    elif status == 'suspicious':
        return f"🤨 I confess: {var_name} looks SUSPICIOUS. Value: {value}"
    else:
        return f"🙏 {var_name} is ABSOLVED. All is well."

Check out the full source code on GitHub to see all the glorious details.

Key Features: Your Digital Priest

• Scans code for required environment variables and checks if they're set: No more guessing which variables your code actually needs.
• Generates dramatic 'confession' messages for missing/incorrect values: Turns debugging into theater. "I confess: DATABASE_URL is EMPTY. I'm here, but I'm nothing."
• Creates a mock 'absolution' script with correct variable exports: One command to fix all your sins: source absolve.sh.
• Color-coded output showing severity of each 'sin': Red for mortal sins (missing), yellow for venial sins (empty), orange for suspicious activity.

Conclusion: Go Forth and Sin No More

The .env Confessional Booth won't solve all your problems, but it will solve the most annoying ones. It takes a task that's typically done poorly (or not at all) and makes it both fun and effective. You'll catch issues before they reach production, onboard new developers faster, and finally understand why your app was failing at 2 AM.

So try it out: https://github.com/BoopyCode/env-var-confessional-1767935878. Your future self—the one who isn't debugging at 2 AM—will thank you. And remember: in the kingdom of code, the only true sin is ignoring your environment variables until they rise up against you.