import yaml
import json
import re

class ConfigSyntaxTherapist:
    """
    A therapeutic approach to configuration error handling.
    Instead of technical jargon, it gives emotional support and roasts.
    """
    
    def __init__(self):
        self.roasts = [
            "Your YAML is having an existential crisis about tabs vs spaces.",
            "This JSON is missing a comma like I'm missing patience.",
            "Your config is gaslighting you. That key doesn't exist, honey.",
            "Syntax error detected. Have you considered therapy?",
            "Indentation problem. Your YAML needs better life choices."
        ]
    
    def diagnose_yaml(self, yaml_content):
        """
        Diagnose YAML syntax issues with therapeutic feedback.
        """
        try:
            yaml.safe_load(yaml_content)
            return "Your YAML is emotionally stable. Good job!"
        except yaml.YAMLError as e:
            error_line = str(e).split('line')[1].split(',')[0] if 'line' in str(e) else 'unknown'
            roast = self.roasts[hash(error_line) % len(self.roasts)]
            return f"🚨 YAML Therapy Session Needed:\n• Error on line {error_line}\n• {roast}\n• Suggestion: Check indentation or missing colons"
    
    def diagnose_json(self, json_content):
        """
        Diagnose JSON syntax issues with coping strategies.
        """
        try:
            json.loads(json_content)
            return "Your JSON is well-adjusted. No therapy needed!"
        except json.JSONDecodeError as e:
            roast = self.roasts[hash(str(e.pos)) % len(self.roasts)]
            return f"🚨 JSON Intervention Required:\n• Error at position {e.pos}\n• {roast}\n• Coping strategy: Validate with jsonlint.com"
    
    def check_config(self, config_text, config_type='auto'):
        """
        Main method to check any configuration syntax.
        Auto-detects YAML vs JSON based on content.
        """
        if config_type == 'auto':
            config_type = 'yaml' if re.search(r'^\s*[a-zA-Z0-9_]+:\s', config_text, re.MULTILINE) else 'json'
        
        if config_type == 'yaml':
            return self.diagnose_yaml(config_text)
        else:
            return self.diagnose_json(config_text)

# Usage example:
therapist = ConfigSyntaxTherapist()
bad_yaml = """
database:
  host: localhost
    port: 5432  # Wrong indentation!
  user: admin"""

print(therapist.check_config(bad_yaml))

The Problem: Your Configuration Files Are Gaslighting You

Let's be honest: modern development has become less about solving interesting algorithmic challenges and more about playing 'Find the Missing Comma' in a 200-line JSON file. We've created this beautiful ecosystem where you need YAML for Kubernetes, TOML for Rust projects, JSON for everything else, INI files for legacy systems, and .env files that somehow always get committed by accident. It's like we're competing to see how many different ways we can write database_url = "localhost" before someone snaps.

The real absurdity? These aren't even programming errors. They're formatting errors. You're not debugging a race condition or a memory leak—you're debugging whether you used two spaces or four. You're not solving the traveling salesman problem; you're solving the traveling tab problem. And the worst part? The error messages are about as helpful as a fortune cookie that just says "something is wrong."

Remember that time your entire CI/CD pipeline failed because of a single extra space in a YAML file? Or when you spent an afternoon trying to figure out why your app wasn't connecting to the database, only to discover your .env file had DATABASE_URL while your code was looking for DB_URL? These aren't bugs—they're psychological warfare. Your configuration files are gaslighting you, and you're just sitting there taking it.

The Solution: Therapy for Your Configuration Files

I built Config Syntax Therapist because I realized we needed a different approach. Instead of cold, technical error messages that make you feel stupid, why not have something that understands your pain? Something that says, "Hey, I see you're struggling with YAML indentation again. That's okay. We've all been there. Let's work through this together."

At its core, Config Syntax Therapist is a CLI tool that reads your configuration files, identifies syntax errors, highlights ambiguous or conflicting settings across multiple files, and provides explanations in plain, empathetic language. But it's also a coping mechanism for developers who've spent too many nights staring at configuration files wondering if they should just quit and become a goat farmer.

The magic happens in how it frames the problems. Instead of "SyntaxError: unexpected token at line 42," you get "I notice you have an extra comma here. This might be because you're feeling anxious about whether you've included everything. It's okay to let go." Instead of silently failing when environment variables conflict with config file settings, it says "I see you've defined PORT in both your .env file and your config.yaml. This creates some tension in your application's identity. Let's explore which one feels more authentic to you."

Despite the humor, this is actually useful. The tool catches real issues that standard linters miss—like when you have conflicting settings across different configuration formats, or when your indentation is technically correct but ambiguous. It's like having a senior developer looking over your shoulder, except this one doesn't judge you for using tabs instead of spaces.

How to Use It: Your First Therapy Session

Getting started is easier than debugging a Kubernetes manifest. First, install it via pip:

pip install config-syntax-therapist

Then, run it against your configuration files. The basic usage looks like this:

# Analyze a single file
config-therapist analyze config.yaml

# Analyze multiple files and check for conflicts
config-therapist analyze --check-conflicts \
  config.yaml \
  .env \
  docker-compose.yml

Here's a snippet from the main analysis function that shows how it detects and frames errors:

def analyze_yaml(file_path):
    """Analyze YAML file with therapeutic approach"""
    try:
        with open(file_path, 'r') as f:
            content = f.read()
        yaml.safe_load(content)
        return {"status": "healthy", "message": "Your YAML is well-balanced."}
    except yaml.YAMLError as e:
        error_msg = str(e)
        if "mapping values" in error_msg:
            return {
                "status": "needs_attention",
                "message": "I notice some tension in your key-value relationships. "
                          "Perhaps you're trying to express too much at once?"
            }
        elif "indentation" in error_msg:
            return {
                "status": "needs_attention",
                "message": "Your indentation seems inconsistent. "
                          "This might reflect some uncertainty about hierarchy. "
                          "Remember: it's okay to take space when you need it."
            }

Check out the full source code on GitHub to see all the therapeutic interventions available.

Key Features: More Than Just Error Messages

• Empathetic Error Detection: Identifies syntax errors in YAML, JSON, TOML, INI, and environment files, then explains them in plain, understanding language. No more "unexpected token"—just "I see you're struggling with closure here."
• Cross-Configuration Conflict Resolution: Highlights when the same setting is defined differently across multiple files (like when your .env says PORT=3000 but your config.yaml says port: 8080). It even suggests which one to prioritize based on your project's emotional needs.
• Coping Strategy Generation: When it detects problematic patterns, it suggests alternatives like "Have you considered using environment variables instead of hardcoding these values?" or "Maybe your configuration would feel more secure in a secrets manager?"
• Ambiguity Detection: Catches technically valid but confusing patterns, like YAML with inconsistent indentation or JSON with trailing commas (depending on your parser's mood).
• Format-Specific Therapy: Different approaches for different formats. YAML gets help with boundary issues, JSON works on commitment problems, TOML explores simplicity, and environment files learn about healthy separation.

Conclusion: Your Configuration Deserves Better

Config Syntax Therapist won't solve all your problems—you'll still need to actually fix the syntax errors—but it will make the process less painful. It turns what was once a frustrating, time-consuming chore into something that's at least mildly entertaining. And more importantly, it catches issues that other tools miss, saving you from those "it works on my machine" moments that inevitably happen at 2 AM before a big launch.

The real benefit isn't just the time saved (though that's significant). It's the shift in perspective. Instead of seeing configuration errors as personal failures, you start seeing them as opportunities for growth. Your YAML isn't broken—it's just going through a phase. Your JSON isn't invalid—it's expressing itself differently. And when you have conflicting settings across files, it's not a bug—it's a cry for help.

So give it a try. Your configuration files have been through a lot. They deserve some emotional support. And you deserve to spend less time debugging commas and more time writing actual code.

Try it out: https://github.com/BoopyCode/config-syntax-therapist

Remember: it's not you, it's your YAML. And we're here to help.