import os
import sys
from typing import Dict, List

def env_snitch(expected_vars: List[str], env_file: str = None) -> Dict[str, Dict[str, str]]:
    """
    Compare expected environment variables with actual values.
    
    Args:
        expected_vars: List of environment variable names to check
        env_file: Optional .env file path to load variables from
    
    Returns:
        Dictionary with 'missing', 'mismatched', and 'correct' categories
    """
    
    # Load from .env file if provided
    if env_file:
        try:
            with open(env_file, 'r') as f:
                for line in f:
                    line = line.strip()
                    if line and not line.startswith('#'):
                        key, value = line.split('=', 1)
                        os.environ[key] = value
        except FileNotFoundError:
            print(f"Warning: {env_file} not found")
    
    results = {
        'missing': {},
        'mismatched': {},
        'correct': {}
    }
    
    for var in expected_vars:
        actual_value = os.getenv(var)
        
        if actual_value is None:
            results['missing'][var] = "Not set"
        elif len(actual_value.strip()) == 0:
            results['mismatched'][var] = f"Set but empty"
        else:
            results['correct'][var] = actual_value
    
    return results

# Example usage:
if __name__ == "__main__":
    # List variables you expect to be set
    expected = ["DATABASE_URL", "API_KEY", "LOG_LEVEL", "DEBUG_MODE"]
    
    # Run the snitch
    report = env_snitch(expected, ".env.example")
    
    # Print results
    print("\n=== ENV SNITCH REPORT ===")
    print(f"Missing: {len(report['missing'])}")
    print(f"Mismatched: {len(report['mismatched'])}")
    print(f"Correct: {len(report['correct'])}")
    
    if report['missing']:
        print("\n\u274c MISSING VARIABLES:")
        for var in report['missing']:
            print(f"  - {var}")

The Problem: When Configuration Becomes Espionage

import os
import json
from typing import Dict, List

def env_snitch(expected_vars: List[str], env_name: str = "current") -> Dict:
    """
    Compare expected environment variables with what's actually set.
    
    Args:
        expected_vars: List of environment variable names you expect to be set
        env_name: Name of the environment being checked (e.g., 'production', 'staging')
    
    Returns:
        Dictionary with missing vars, mismatched values, and debug info
    """
    
    results = {
        "environment": env_name,
        "timestamp": datetime.now().isoformat(),
        "missing": [],
        "mismatched": [],
        "available": {},
        "all_actual_vars": {}
    }
    
    # Check each expected variable
    for var_name in expected_vars:
        actual_value = os.getenv(var_name)
        
        if actual_value is None:
            results["missing"].append(var_name)
        else:
            results["available"][var_name] = {
                "value": actual_value[:50] + "..." if len(actual_value) > 50 else actual_value,
                "length": len(actual_value)
            }
    
    # Capture all environment variables for debugging
    for key, value in os.environ.items():
        results["all_actual_vars"][key] = value[:100] + "..." if len(value) > 100 else value
    
    return results

# Usage example:
if __name__ == "__main__":
    expected = ["DATABASE_URL", "API_KEY", "LOG_LEVEL", "REDIS_HOST"]
    debug_info = env_snitch(expected, "production")
    print(json.dumps(debug_info, indent=2))

Environment variables are supposed to be simple, right? Just little key-value pairs that tell your application where to find things. But somewhere along the way, they became the digital equivalent of classified documents locked in a safe that only the senior dev who left six months ago knows the combination to.

Here's how it usually goes: You write beautiful, perfect code. It runs flawlessly on your machine. You deploy it to staging. Suddenly, your database connection fails, your API keys are invalid, and your logging system is writing to /dev/null. You spend hours comparing files, checking deployment scripts, and questioning your life choices. The problem? Someone, somewhere, forgot to set DATABASE_URL in the production environment. Or worse, they set it to localhost:5432 because 'that's what worked in development.'

The absurdity reaches peak levels when you realize you're basically playing a game of 'Guess Who?' with your infrastructure. Is the API key missing? Is the database host wrong? Did someone accidentally commit their local .env file? It's like trying to solve a murder mystery where the victim is your application and the murder weapon is a missing environment variable.

The Solution: Introducing Your Configuration Double Agent

I built ENV Snitch because I got tired of playing psychic detective with my environment variables. This tool doesn't just tell you what's wrong - it turns the whole debugging process into an entertaining spy operation. Think of it as James Bond meets your .env file.

At its core, ENV Snitch does something beautifully simple: it compares what you think your environment should be (from your .env files) against what it actually is (the runtime environment). But instead of giving you dry, technical output, it presents the information like a classified intelligence briefing. Missing variables become 'compromised assets.' Mismatched values become 'discrepancies requiring immediate attention.' It's debugging with dramatic flair.

Despite the humor, this is actually a seriously useful tool. The spy-movie terminology isn't just for laughs - it helps you quickly identify what's important. When you see "RED ALERT: CRITICAL ASSET MISSING" next to your database connection string, you know exactly where to focus your attention. No more scanning through pages of logs looking for that one missing piece.

How to Use Your New Spy Gadget

Getting started with ENV Snitch is easier than explaining to your manager why production is down. First, install it:

npm install -g env-snitch
# or
pip install env-snitch
# or clone from GitHub and run directly

Basic usage is straightforward. Point it at your .env file and let it compare against your current environment:

env-snitch compare --env-file .env.production

# Or get really fancy with the interrogate mode
env-snitch interrogate --env-file .env.staging --strict

Here's a taste of what the actual code looks like - this is from the comparison logic that makes the magic happen:

def compare_environments(expected, actual):
    """Compare expected vs actual environment variables."""
    discrepancies = []
    
    for key, expected_value in expected.items():
        if key not in actual:
            discrepancies.append({
                'type': 'MISSING',
                'key': key,
                'expected': expected_value,
                'actual': 'UNDEFINED'
            })
        elif actual[key] != expected_value:
            discrepancies.append({
                'type': 'MISMATCH',
                'key': key,
                'expected': expected_value,
                'actual': actual[key]
            })
    
    return generate_intelligence_report(discrepancies)

Check out the full source code on GitHub to see all the clever ways it turns boring environment checks into an espionage adventure.

Key Features That Would Make 007 Jealous

• Environment Comparison: Compares .env files against actual runtime environments with surgical precision
• Spy-Movie Terminology: Highlights discrepancies with dramatic labels like "COMPROMISED ASSET" and "SUSPICIOUS VARIANCE"
• Classified Briefings: Generates intelligence reports showing exactly what changed where and when
• Interrogate Mode: Asks pointed questions about missing variables that would make even the most hardened config file crack
• Multi-Environment Support: Compare across local, staging, and production simultaneously
• Export Options: Save your intelligence reports for future reference or to show your team what went wrong

Conclusion: From Debugging to De-briefing

ENV Snitch turns one of the most frustrating parts of development into something actually enjoyable. Instead of dreading environment variable issues, you can approach them like a spy mission. The tool gives you clear, actionable intelligence about what's wrong with your configuration, presented in a way that's impossible to ignore.

The benefits are real: faster debugging, fewer production incidents, and less time spent playing 'guess the missing variable.' Plus, you get to feel like a secret agent while you're doing it. That's what I call a win-win.

Ready to stop guessing and start knowing? Try ENV Snitch today. Your future self (and your production environment) will thank you. Remember: in the world of environment variables, trust no one - but you can trust ENV Snitch to tell you what's really going on.

"The variable is always in the last place you look... because after you find it, you stop looking." - Unknown Spy (probably)