import re
import sys

class SyntaxShaman:
    """
    A mystical debugger that treats syntax errors as spirits needing banishment.
    Detects common typos and optionally auto-fixes them with ceremonial flair.
    """
    
    def __init__(self, filepath):
        self.filepath = filepath
        self.ghosts = [
            (r'\bif\(([^)]+)\)\s*{', r'if(\1) {'),  # Missing space before {
            (r'\bfor\s*\([^;]+;[^;]+;[^)]+\)\s*{', r'for(\1) {'),  # Same for loops
            (r'\bconsole\.log\(([^)]+)\)', r'console.log(\1)'),  # Fix log spacing
            (r'\bfunction\s+(\w+)\s*\(', r'function \1('),  # Function name spacing
            (r'\bvar\s+(\w+)\s*=', r'var \1 ='),  # Variable assignment spacing
        ]
    
    def detect_ghosts(self):
        """Scan the file for common syntax spirits."""
        with open(self.filepath, 'r') as f:
            content = f.read()
        
        findings = []
        for pattern, _ in self.ghosts:
            matches = re.finditer(pattern, content)
            for match in matches:
                findings.append({
                    'line': content[:match.start()].count('\n') + 1,
                    'match': match.group(),
                    'type': 'Syntax Spirit'
                })
        return findings
    
    def cleanse_file(self, dramatic=True):
        """Auto-fix detected issues with optional dramatic flair."""
        with open(self.filepath, 'r') as f:
            content = f.read()
        
        new_content = content
        for pattern, replacement in self.ghosts:
            new_content = re.sub(pattern, replacement, new_content)
        
        with open(self.filepath, 'w') as f:
            f.write(new_content)
        
        if dramatic:
            print("\n🔮 The spirits have been banished! 🔮\n")
            print("Your code is now cleansed of syntactic impurities.")
        
        return new_content != content

# Usage:
# shaman = SyntaxShaman('your_file.js')
# print("Detected:", shaman.detect_ghosts())
# shaman.cleanse_file()

The Haunting Reality of Modern Development

Picture this: you've just written what might be the most elegant algorithm since Dijkstra first drew a graph. The logic is sound, the architecture is beautiful, and you're about to change lives with this code. You hit run. And... nothing. Or worse: 'SyntaxError: Unexpected token'. Your masterpiece has been reduced to digital gibberish because somewhere between lines 127 and 128, a curly brace decided to go on vacation without telling you.

This isn't just a minor inconvenience—it's a full-blown spiritual crisis. You're not debugging code anymore; you're performing an exorcism on what appears to be possessed text. The modern IDE, that supposed bastion of developer assistance, occasionally decides to take a coffee break right when you need it most. Lightweight editors? Don't get me started. They're basically ghost-hunting grounds where syntax errors roam free, terrorizing innocent developers.

Consider the sheer absurdity: you spent three years studying data structures, algorithms, and system design, only to be defeated by a missing quotation mark. You've implemented distributed systems that handle millions of requests per second, but can't spot the extra parenthesis that's been hiding in plain sight for two hours. It's like being a master chef who burns water because you forgot to turn on the stove.

Enter the Syntax Shaman

I built Syntax Shaman because I got tired of performing digital seances every time my code refused to run. This tool approaches syntax errors with the appropriate level of drama they deserve: as mystical spirits that need ceremonial banishment. It doesn't just find your missing semicolons—it tells you that "The spirits of mismatched parentheses haunt line 42" or warns that "A lonely bracket wanders the astral plane near line 87."

Underneath the theatrical presentation lies genuinely useful functionality. Syntax Shaman scans your files for common syntax ghosts: missing brackets, unclosed quotes, absent semicolons, and other trivial errors that somehow manage to derail entire development sessions. It works as a CLI tool that you can run against your codebase, either as a one-time cleansing ritual or integrated into your development workflow.

The magic happens in two modes: diagnostic and cleansing. Diagnostic mode identifies the spiritual disturbances in your code with dramatic, fortune-cookie-style messages that at least make the debugging process entertaining. Cleansing mode actually fixes the trivial errors, but does so with ceremonial flair—because if you're going to auto-fix syntax, you might as well make it feel like a proper exorcism.

How to Summon the Shaman

Getting started is simpler than debugging that regex you wrote six months ago. Install via npm:

npm install -g syntax-shaman

Then invoke the spirits (I mean, run the tool) on your code:

syntax-shaman diagnose ./src

For the full ceremonial experience with auto-fixing:

syntax-shaman cleanse ./src --ritual=full

Here's a snippet from the main diagnostic logic that shows how it identifies those pesky syntax spirits:

function detectSyntaxSpirits(content, filename) {
  const spirits = [];
  
  // Check for lonely parentheses
  const parenMatches = content.match(/(\([^\)]*|\{[^\}]*|\[[^\]]*)/g);
  if (parenMatches) {
    parenMatches.forEach((match, index) => {
      spirits.push({
        type: 'unclosed_paren',
        line: getLineNumber(content, match),
        message: `A lonely ${match[0]} wanders without its counterpart`
      });
    });
  }
  
  // Check for missing semicolons in JavaScript/TypeScript
  if (filename.endsWith('.js') || filename.endsWith('.ts')) {
    const lines = content.split('\n');
    lines.forEach((line, index) => {
      if (line.trim() && !line.trim().endsWith(';') && 
          !line.trim().endsWith('{') && !line.trim().endsWith('}')) {
        spirits.push({
          type: 'missing_semicolon',
          line: index + 1,
          message: 'The spirit of omission lingers here—a semicolon has departed'
        });
      }
    });
  }
  
  return spirits;
}

Check out the full source code on GitHub to see all the spiritual detection algorithms in their full glory.

Key Features That Actually Help

• Detects Common Syntax Ghosts: Missing brackets, unclosed quotes, absent semicolons, and other trivial errors that somehow manage to ruin your day
• Dramatic Diagnostics: Outputs fortune-cookie-style messages like "The spirits of mismatched parentheses haunt line 42" or "A quotation mark has abandoned its partner on line 18"
• Ceremonial Cleansing: Optionally auto-fixes trivial errors with appropriate ritualistic flair, because mundane fixes deserve dramatic presentation
• Multi-language Support: Works with JavaScript, TypeScript, Python, JSON, and other languages where syntax errors like to party
• CI/CD Integration: Can be added to your pipeline to prevent syntax spirits from reaching production

From Spiritual Crisis to Productive Coding

Syntax Shaman won't write your business logic for you, and it certainly won't help you understand why your microservices are communicating via carrier pigeon instead of HTTP. But what it will do is eliminate those soul-crushing moments when you realize you've been debugging for an hour because of a missing comma. It turns frustration into amusement, and wasted time into productive development.

The real value isn't just in catching errors—it's in changing your relationship with those errors. Instead of feeling like you've been defeated by a typo, you get to feel like a digital exorcist banishing spirits from your codebase. It's the same result, but with dramatically better vibes.

Try it out: https://github.com/BoopyCode/syntax-shaman. Your codebase has spirits, and they're not the fun, polymorphic kind. They're the missing-semicolon, unclosed-bracket, syntax-error kind. And they need banishing.

Remember: in the battle against syntax errors, sometimes you need more than a linter. Sometimes you need a shaman.