#!/usr/bin/env node
// Dependency Drama Llama - Conflict Resolver
// Run: node dependency-resolver.js

const fs = require('fs');
const path = require('path');

class DependencyResolver {
    constructor() {
        this.conflicts = [];
        this.solutions = [];
    }
    
    analyzePackageJson(packagePath) {
        try {
            const packageData = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
            const dependencies = {
                ...packageData.dependencies,
                ...packageData.devDependencies
            };
            
            // Find conflicting versions
            const versionMap = new Map();
            
            for (const [pkg, version] of Object.entries(dependencies)) {
                const cleanVersion = version.replace(/[^\d.]/g, '');
                if (!versionMap.has(pkg)) {
                    versionMap.set(pkg, new Set());
                }
                versionMap.get(pkg).add(cleanVersion);
            }
            
            // Report conflicts
            for (const [pkg, versions] of versionMap) {
                if (versions.size > 1) {
                    this.conflicts.push({
                        package: pkg,
                        versions: Array.from(versions),
                        severity: 'HIGH'
                    });
                }
            }
            
            return this.conflicts;
        } catch (error) {
            console.error('Error reading package.json:', error.message);
            return [];
        }
    }
    
    suggestSolutions() {
        this.conflicts.forEach(conflict => {
            const latestVersion = Math.max(...conflict.versions.map(v => parseFloat(v)));
            this.solutions.push({
                package: conflict.package,
                action: `Update all references to version ${latestVersion}`,
                command: `npm install ${conflict.package}@${latestVersion}`
            });
        });
        return this.solutions;
    }
}

// Usage
const resolver = new DependencyResolver();
const conflicts = resolver.analyzePackageJson('./package.json');

if (conflicts.length > 0) {
    console.log('🚨 DEPENDENCY CONFLICTS FOUND:');
    conflicts.forEach(c => {
        console.log(`• ${c.package}: ${c.versions.join(' vs ')}`);
    });
    
    const solutions = resolver.suggestSolutions();
    console.log('\n💡 SUGGESTED SOLUTIONS:');
    solutions.forEach(s => {
        console.log(`• ${s.package}: ${s.action}`);
        console.log(`  Run: ${s.command}`);
    });
} else {
    console.log('✅ No dependency conflicts found!');
}

The Problem: Your Dependencies Are Having More Drama Than a High School Cafeteria

Modern development has become less about writing code and more about managing the intricate social lives of thousands of packages that apparently can't get along. You're not a developer anymore—you're a relationship counselor for code that has commitment issues.

Why does this problem exist? Because somewhere along the line, we decided that every package should have its own opinion about which version of lodash, react, or webpack is "the one." It's like if every person at a dinner party brought their own fork, but each fork only works with specific plates, and the plates are fighting with the tablecloth about linen standards.

You know the pain: you add one innocent-looking package for parsing dates, and suddenly your entire build process collapses because date-fns wants lodash@4.17.20 but moment.js is still hung up on lodash@4.17.15 from their college days, and they refuse to be in the same virtual room together. The error message? "Something went wrong." Thanks, npm. Very helpful. I'll just stare at my screen for two hours until I remember that one time in 2019 when I installed something globally that I shouldn't have.

The Solution: Turning Package Conflicts into Must-See TV

I built Dependency Drama Llama because I realized that if I'm going to suffer through dependency hell, I might as well be entertained while doing it. Instead of cryptic error messages, you get dramatic confessionals. Instead of boring dependency trees, you get relationship maps worthy of a reality TV show.

How does it work? The tool scans your package-lock.json or yarn.lock file and identifies all the version conflicts. But instead of just listing them, it creates a dramatic narrative where packages are characters with personalities, grudges, and relationship issues. React isn't just a library—it's the popular kid who thinks they're too good for everyone else. Lodash is that friend who keeps changing their personality (version) every few months.

Despite the humor, this is actually useful. By anthropomorphizing the conflicts, you remember them better. "Oh right, axios and fetch are fighting again because axios thinks fetch is too basic" sticks in your brain better than "TypeError: Cannot read property 'then' of undefined." Plus, the tool actually suggests real solutions—it just presents them in the most dramatic way possible.

How to Use It: Your Backstage Pass to Dependency Drama

Installation is as simple as the relationships are complicated:

npm install -g dependency-drama-llama
# or
npx dependency-drama-llama

Basic usage is even simpler. Navigate to your project and run:

drama-llama analyze

Here's a snippet from the main analysis function that shows how the magic happens:

function createDramaReport(conflicts) {
  return conflicts.map(conflict => {
    const dramaLevel = calculateDramaLevel(conflict);
    const characters = assignPersonalities(conflict.packages);
    
    return {
      title: `${characters[0].name} vs ${characters[1].name}: ${dramaLevel} Drama`,
      confession: generateConfessional(characters, conflict),
      solution: suggestDramaticSolution(conflict)
    };
  });
}

Check out the full source code on GitHub to see all the dramatic goodness, including the personality matrix that decides whether a package is a "diva," a "mediator," or a "troublemaker."

Key Features: More Entertainment Than Your Package Manager

• Scans package-lock.json or yarn.lock to detect version conflicts: It reads your lock files like a therapist reads relationship texts—looking for all the subtle signs of impending disaster.
• Generates a dramatic 'relationship map' showing which packages are feuding: Visualizes dependencies as characters with relationship statuses. "It's complicated" has never been more accurate.
• Suggests the most dramatic solution: Like kicking out the troublemaker package or forcing two packages to couples counseling (version mediation).
• Outputs conflict explanations in reality TV confession-style quotes: "I just feel like axios doesn't respect my boundaries. He's always trying to handle my errors for me, and I need space to throw my own exceptions, you know?"

Conclusion: Finally, Dependency Management You'll Actually Enjoy

Dependency Drama Llama won't magically solve all your version conflicts (though it tries), but it will make the process of debugging them significantly less painful. Instead of staring at incomprehensible error stacks, you'll be reading dramatic interpersonal conflicts between packages that have more character development than most Netflix originals.

The real benefit is psychological: when you start thinking of your dependencies as dramatic characters instead of abstract packages, you remember their quirks and conflicts better. You'll start anticipating that moment when TypeScript and JavaScript have their annual "are we even in the same relationship?" fight.

Try it out: https://github.com/BoopyCode/dependency-drama-llama

Your dependencies are already dramatic—you might as well get a good show out of it. After all, if you're going to spend hours debugging why left-pad version 1.2.3 won't talk to left-pad version 1.2.4, you deserve better entertainment than "npm ERR! code ELIFECYCLE."