import openai
import random

class LegacyCodeOuijaBoard:
    """
    A tool that uses AI to generate 'spirit channeled' explanations
    for confusing legacy code patterns.
    """
    
    def __init__(self, api_key):
        self.client = openai.OpenAI(api_key=api_key)
        self.developer_spirits = [
            "Brian from DevOps (2015)",
            "The Intern Who Over-Engineered Everything",
            "The Consultant Who Left After 3 Weeks",
            "The Lead Dev Who Hated Comments"
        ]
    
    def channel_explanation(self, code_snippet, filename):
        """
        Generate a plausible (and often hilarious) explanation
        for why legacy code was written a certain way.
        """
        spirit = random.choice(self.developer_spirits)
        
        prompt = f"""You are {spirit}, the original developer of this code.
        Explain why you wrote this code in {filename}:
        
        {code_snippet}
        
        Be specific, technical, and add one personal anecdote about
        why this seemed like a good idea at the time."""
        
        response = self.client.chat.completions.create(
            model="gpt-4",
            messages=[{"role": "user", "content": prompt}],
            max_tokens=150
        )
        
        return {
            "spirit": spirit,
            "explanation": response.choices[0].message.content,
            "confidence": f"{random.randint(30, 95)}% accurate (probably)"
        }

# Example usage:
# ouija = LegacyCodeOuijaBoard("your-api-key-here")
# result = ouija.channel_explanation(
#     "def validateUser():
#         # ...validation logic...
#         response = requests.get('https://weather.api/current')
#         return response.json()['temperature'] > 20",
#     "auth_helpers.py"
# )
# print(f"Channeled: {result['spirit']}")
# print(f"Explanation: {result['explanation']}")
# print(f"Confidence: {result['confidence']}")

The Problem: When Codebases Become Cryptic Haunted Houses

Every developer reaches that fateful moment. You're assigned a 'small tweak' to a payment processing system last touched in 2015. You open the file. The air grows cold. A variable named tmp_final_v2_actual stares back at you. You check git blame. The author's email is ghost@deleted.local. Their profile picture is a grey silhouette. This isn't coding; it's an exorcism.

The real tragedy isn't the missing documentation—it's the lost context. Why does validateUser() also make a call to an external weather API? Was this a brilliant workaround for a now-defunct service, or did 'Brian from DevOps' just really like knowing if it was raining? The original architects have moved on to greener pastures, higher-paying jobs, or, in one legendary case at my old startup, a remote monastery in Nepal. You're left with the digital equivalent of hieroglyphics in a tomb no one remembers building.

We waste weeks—collectively, probably years—of developer time playing psychic detective. We trace execution flows like paranormal investigators, looking for 'cold spots' (null pointer exceptions) and 'orbs' (magic numbers that glow with ominous significance). We hold meetings where the most senior person says, 'I think this was for the old Salesforce integration... or was it the GDPR panic? Let's not touch it.' The code isn't just legacy; it's cursed.

The Solution: Channeling the Spirits of Stack Overflow Past

If we're going to treat legacy code like a haunted house, we might as well use the proper tools. Enter the Legacy Code Ouija Board. I built this not because I believe in the supernatural, but because sometimes a little theatricality makes reading through 8 layers of nested conditionals slightly less soul-crushing.

At its core, the tool is a pragmatic code analysis CLI wrapped in a delightfully spooky persona. It scans your git history to identify 'ghost developers'—contributors who no longer have access to the repo. It parses variable names, function patterns, and comment fragments (the rare ones that exist) to generate 'psychic readings' about the code's original intent. Is it accurate? About as accurate as a real ouija board—which is to say, surprisingly often, because it's mostly making educated guesses based on observable patterns, but the presentation is 100% more entertaining.

Why does this work? Because humor disarms frustration. When the tool analyzes a function called doTheMagic() and outputs, 'The spirits sense this was a Friday afternoon fix. The developer was thinking about pizza. The code works but they were not proud.'—you laugh, but you also internalize the likely truth. It reframes a painful task as a collaborative game with the ghosts in the machine.

How to Use It: Conducting Your First Code Séance

Getting started is straightforward, assuming you have Node.js installed and a repository that makes you question your career choices.

First, install the package globally, as all tools of great mystical power should be:

npm install -g legacy-code-ouija

Navigate to your haunted codebase and invoke the board:

cd path/to/your/cursed/project
ouija analyze --file ./src/eldritchHorror.js

The tool will then commune with the git logs and present its findings. Here's a snippet from the core analysis engine that shows how it identifies a 'ghost':

// From the ouija.js main file
getGhostDevelopers(gitHistory) {
  return gitHistory.filter(commit => {
    // If the author's email is generic or domain is dead
    return isGhostEmail(commit.authorEmail) || 
           !hasRepoAccess(commit.author);
  }).map(ghost => ghost.author);
}

function isGhostEmail(email) {
  const ghostPatterns = [
    /deleted@/,
    /noreply/,
    /former.*@company-that-no-longer-exists\.com/
  ];
  return ghostPatterns.some(pattern => pattern.test(email));
}

Check out the full source code on GitHub to see the complete incantations, including the ritualistic console animations that play when you encounter a file with a cyclomatic complexity over 50 (the truly cursed sections).

Key Features: Your Toolkit for Digital Paranormal Investigation

• Ghost Developer Identification: Analyzes git blame to list contributors who've left the company, their accounts are deleted, or their emails bounce. It presents them with epitaphs like 'Last Seen: Pushing to prod at 3 AM, 2016.'
• Psychic Intent Readings: Uses NLP (Natural Language... Pseudoscience) on variable and function names. Finds temp, hack, fixme, and asdf to gauge original developer sentiment and urgency.
• Ritualistic Console Animations: When navigating deeply nested logic or files with 10+ consecutive lines of regex, the terminal might display a swirling vortex of ASCII art or 'candles flickering.' It's a mood.
• Spiritual Cleansing Refactors: Suggests concrete refactors (extract method, rename variable, add comment) but labels them with warnings like 'The spirit of the old code may resist this change. Proceed with caution and a unit test offering.'
• Fortune Cookie Explanations: Outputs findings in the style of a mystic reading: 'I see a man in a faded company hoodie. He is writing a SQL query in a string buffer. He is afraid of his team lead. The function returns null on Tuesdays.'

Conclusion: Embrace the Haunting, But Bring a Flashlight

The Legacy Code Ouija Board won't magically document your entire monolith. What it will do is make the process of understanding it less lonely, less frustrating, and significantly funnier. It acknowledges the absurd reality of maintaining software that outlives its creators—a reality where we are all, at some point, digital mediums trying to interpret the intentions of the departed.

So the next time you're faced with a method named performDarkRitual() that somehow calculates tax, don't scream into your keyboard. Ask the board. The answer might be insightful, it might be nonsense, but at least you'll have a story for stand-up.

Try it out and commune with your codebase's past: https://github.com/BoopyCode/legacy-code-ouija

Remember: In the world of legacy code, sometimes the best debugger is a sense of humor—and a pretend ouija board. The spirits are restless, but your pull request doesn't have to be.