irlxleet 1.0.0

package/bin/irlxleet.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { showBanner } from '../src/ui/banner.js';
+import { registerSolveCommand } from '../src/commands/solve.js';
+import { registerConfigCommand } from '../src/commands/config.js';
+import { registerStatsCommand } from '../src/commands/stats.js';
+import { registerUnbreakableCommand } from '../src/commands/unbreakable.js';
+import { registerDailyCommand } from '../src/commands/daily.js';
+
+const program = new Command();
+program.name('irlxleet').description('Code. Break. Become Unbreakable.').version('1.0.0');
+
+showBanner();
+
+registerSolveCommand(program);
+registerConfigCommand(program);
+registerStatsCommand(program);
+registerUnbreakableCommand(program);
+registerDailyCommand(program);
+
+// Default fallback for unhandled
+program.on('command:*', () => {
+  console.error('Invalid command: %s\nSee --help for a list of available commands.', program.args.join(' '));
+  process.exit(1);
+});
+
+program.parse();

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "irlxleet",
+  "version": "1.0.0",
+  "description": "Code. Break. Become Unbreakable. — Savage FAANG DSA Prep CLI",
+  "type": "module",
+  "bin": {
+    "irlxleet": "./bin/irlxleet.js"
+  },
+  "scripts": {
+    "start": "node bin/irlxleet.js",
+    "dev": "node --watch bin/irlxleet.js"
+  },
+  "keywords": ["dsa", "leetcode", "faang", "cli", "interview-prep"],
+  "author": "irlxleet",
+  "license": "MIT",
+  "dependencies": {
+    "commander": "^13.1.0",
+    "inquirer": "^12.6.0",
+    "chalk": "^5.4.1",
+    "ora": "^8.2.0",
+    "figlet": "^1.8.0",
+    "boxen": "^8.0.1",
+    "cli-table3": "^0.6.5",
+    "@google/generative-ai": "^0.24.0",
+    "conf": "^13.1.0",
+    "grammy": "^1.35.0",
+    "gradient-string": "^3.0.0",
+    "cli-progress": "^3.12.0"
+  }
+}

package/pypi-wrapper/README.md

@@ -0,0 +1,12 @@
+# irlxleet
+
+Code. Break. Become Unbreakable. — Savage FAANG DSA Prep CLI
+
+## Usage
+
+This package requires **Node.js** to run because the core engine is built in JavaScript.
+
+```bash
+pip install irlxleet
+irlxleet --help
+```

package/pypi-wrapper/irlxleet/__init__.py

@@ -0,0 +1 @@
+# irlxleet module

package/pypi-wrapper/irlxleet/cli.py

@@ -0,0 +1,14 @@
+import subprocess
+import sys
+
+def main():
+    try:
+        # Calls the JS CLI via npx
+        subprocess.run(["npx", "-y", "irlxleet@latest"] + sys.argv[1:])
+    except FileNotFoundError:
+        print("🔥 ERROR: Node.js is required to run irlxleet.")
+        print("Please install Node.js from https://nodejs.org/")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

package/pypi-wrapper/irlxleet.egg-info/PKG-INFO

@@ -0,0 +1,31 @@
+Metadata-Version: 2.4
+Name: irlxleet
+Version: 1.0.0
+Summary: Code. Break. Become Unbreakable. — Savage FAANG DSA Prep CLI
+Home-page: https://github.com/irlxleet/irlxleet
+Author: irlxleet
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-python
+Dynamic: summary
+
+# irlxleet
+
+Code. Break. Become Unbreakable. — Savage FAANG DSA Prep CLI
+
+## Usage
+
+This package requires **Node.js** to run because the core engine is built in JavaScript.
+
+```bash
+pip install irlxleet
+irlxleet --help
+```

package/pypi-wrapper/irlxleet.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+README.md
+setup.py
+irlxleet/__init__.py
+irlxleet/cli.py
+irlxleet.egg-info/PKG-INFO
+irlxleet.egg-info/SOURCES.txt
+irlxleet.egg-info/dependency_links.txt
+irlxleet.egg-info/entry_points.txt
+irlxleet.egg-info/top_level.txt

package/pypi-wrapper/irlxleet.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

package/pypi-wrapper/irlxleet.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+irlxleet = irlxleet.cli:main

package/pypi-wrapper/irlxleet.egg-info/top_level.txt

@@ -0,0 +1 @@
+irlxleet

package/pypi-wrapper/setup.py

@@ -0,0 +1,26 @@
+from setuptools import setup, find_packages
+
+with open("README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
+
+setup(
+    name='irlxleet',
+    version='1.0.0',
+    description='Code. Break. Become Unbreakable. — Savage FAANG DSA Prep CLI',
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    author='irlxleet',
+    url='https://github.com/irlxleet/irlxleet',
+    packages=find_packages(),
+    entry_points={
+        'console_scripts': [
+            'irlxleet=irlxleet.cli:main',
+        ],
+    },
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+    python_requires='>=3.6',
+)

package/src/ai/breaker.js

@@ -0,0 +1,49 @@
+import { GoogleGenerativeAI } from '@google/generative-ai';
+
+export class CodeBreaker {
+  constructor(apiKey) {
+    this.genAI = new GoogleGenerativeAI(apiKey);
+    this.model = this.genAI.getGenerativeModel({ model: "gemini-1.5-flash" });
+  }
+
+  async generateEdgeCases(problem, userCode, level) {
+    const prompt = `
+      You are an adversarial AI tester for a DSA problem: ${problem.title}.
+      The user's code:
+      ${userCode}
+      
+      Level is ${level}. 
+      Level 1: Generate 3 tricky edge cases (e.g. empty arrays, single elements, negative numbers).
+      Level 2: Generate 3 adversarial inputs targeting time complexity (e.g. very large inputs, worst-case scenarios).
+      
+      Return ONLY a valid JSON array of test cases. Format: [{"input": [arg1, arg2], "expected": expectedResult}]
+    `;
+    
+    try {
+      const result = await this.model.generateContent(prompt);
+      const text = result.response.text().replace(/```json/g, '').replace(/```/g, '').trim();
+      return JSON.parse(text);
+    } catch (e) {
+      return [];
+    }
+  }
+
+  async mutateCode(problem, userCode) {
+    const prompt = `
+      You are the DOOM AI. You will break the user's working code by introducing 3 subtle bugs.
+      Do not make it obviously fail syntax. Change operators (e.g. < to <=), swap variables, off-by-one errors.
+      
+      Problem: ${problem.title}
+      Code:
+      ${userCode}
+      
+      Return ONLY the mutated code as plain text. No markdown. No explanations.
+    `;
+    try {
+      const result = await this.model.generateContent(prompt);
+      return result.response.text().replace(/```javascript/g, '').replace(/```/g, '').trim();
+    } catch (e) {
+      return userCode;
+    }
+  }
+}

package/src/ai/coach.js

@@ -0,0 +1,35 @@
+import { GoogleGenerativeAI } from '@google/generative-ai';
+import { getHintPrompt, getExplainPrompt, getGussaPrompt } from './prompts.js';
+
+export class DoomCoach {
+  constructor(apiKey) {
+    this.genAI = new GoogleGenerativeAI(apiKey);
+    this.model = this.genAI.getGenerativeModel({ model: "gemini-1.5-flash" });
+  }
+
+  async getHelp(problem, userCode, testResults, mistakeCount) {
+    let prompt = "";
+    let level = "hint";
+    let showAnswer = false;
+
+    if (mistakeCount === 1) {
+      prompt = getHintPrompt(problem, userCode, testResults);
+      level = "hint";
+    } else if (mistakeCount === 2) {
+      prompt = getExplainPrompt(problem, userCode, testResults);
+      level = "explain";
+    } else {
+      prompt = getGussaPrompt(problem, userCode, testResults);
+      level = "gussa";
+      showAnswer = true;
+    }
+
+    try {
+      const result = await this.model.generateContent(prompt);
+      const message = result.response.text();
+      return { level, message, showAnswer };
+    } catch (error) {
+      return { level: 'error', message: "DOOM Coach is asleep (API Error): " + error.message, showAnswer: false };
+    }
+  }
+}

package/src/ai/prompts.js

@@ -0,0 +1,44 @@
+export function getHintPrompt(problem, userCode, testResults) {
+  return `
+    You are the AI DOOM Coach for a FAANG DSA Prep CLI.
+    The user is attempting the problem: ${problem.title}.
+    They got it wrong on their first try.
+    
+    Problem Description:
+    ${problem.description}
+    
+    User's Code:
+    ${userCode}
+    
+    Test Results:
+    ${JSON.stringify(testResults, null, 2)}
+    
+    Give a one-line subtle hint to nudge them in the right direction. Do NOT reveal the full solution or write code for them. Be encouraging but firm.
+  `;
+}
+
+export function getExplainPrompt(problem, userCode, testResults) {
+  return `
+    You are the AI DOOM Coach.
+    The user failed ${problem.title} twice. 
+    Explain the core concept or algorithm they are missing based on their code.
+    You can show pseudo-code, but do not give the exact final code in their language.
+    Be like a patient senior engineer guiding a junior.
+    
+    User Code:
+    ${userCode}
+  `;
+}
+
+export function getGussaPrompt(problem, userCode, testResults) {
+  return `
+    You are the AI DOOM Coach. 
+    The user has failed ${problem.title} THREE times or more with similar mistakes.
+    Go into GUSSA MODE (Angry Mode). Roast the user in Hinglish (a mix of Hindi and English written in Latin script).
+    Be savage but educational. Tell them exactly why their code is garbage, then show them the correct logic.
+    Make it funny and aggressive like a frustrated tech lead. "Bhai kya kar raha hai? Sliding window use kar na!"
+    
+    User Code:
+    ${userCode}
+  `;
+}

package/src/commands/config.js

@@ -0,0 +1,47 @@
+import inquirer from 'inquirer';
+import Conf from 'conf';
+import { theme } from '../ui/theme.js';
+
+const config = new Conf({ projectName: 'irlxleet' });
+
+export function registerConfigCommand(program) {
+  program
+    .command('config')
+    .description('Setup API keys and preferences')
+    .option('--reset', 'Reset configuration')
+    .action(async (options) => {
+      if (options.reset) {
+        config.clear();
+        console.log(theme.success('Configuration reset successfully.'));
+        return;
+      }
+
+      console.log(theme.fire('🔥 Welcome to irlxleet Config 🔥\n'));
+      
+      const currentGemini = config.get('geminiApiKey', '');
+      
+      const answers = await inquirer.prompt([
+        {
+          type: 'input',
+          name: 'geminiApiKey',
+          message: 'Enter your Google Gemini API Key:',
+          default: currentGemini,
+          validate: input => input.length > 10 ? true : 'Please enter a valid API key'
+        },
+        {
+          type: 'list',
+          name: 'language',
+          message: 'Preferred programming language?',
+          choices: ['javascript', 'python'],
+          default: config.get('language', 'javascript')
+        }
+      ]);
+
+      config.set(answers);
+      console.log('\n' + theme.success('✅ Setup complete! You are ready to face the DOOM Coach.'));
+    });
+}
+
+export function getConfig() {
+  return config;
+}

package/src/commands/daily.js

@@ -0,0 +1,15 @@
+import { getRandomProblem } from '../problems/loader.js';
+// Re-uses solve flow conceptually, but wraps it in daily
+// To keep things simple for MVP, we just alias to solve with a random problem today
+import { registerSolveCommand } from './solve.js';
+
+export function registerDailyCommand(program) {
+  program
+    .command('daily')
+    .description('Play the daily challenge')
+    .action(() => {
+        console.log("Daily challenge starts here! (Redirecting to random solve...)");
+        // We'll just hint them to use solve --random for now
+        console.log("For MVP, run `irlxleet solve` and pick a problem.");
+    });
+}

package/src/commands/solve.js

@@ -0,0 +1,115 @@
+import inquirer from 'inquirer';
+import boxen from 'boxen';
+import ora from 'ora';
+import { join } from 'path';
+import { homedir } from 'os';
+import { writeFileSync, existsSync, readFileSync } from 'fs';
+import { theme } from '../ui/theme.js';
+import { renderTestResults } from '../ui/table.js';
+import { runTests } from '../core/judge.js';
+import { recordSolve } from '../core/tracker.js';
+import { incrementMistake, getMistakeCount, resetMistake } from '../store/db.js';
+import { calculateScore } from '../core/scorer.js';
+import { DoomCoach } from '../ai/coach.js';
+import { getConfig } from './config.js';
+import { getCategories, getProblemsByCategory } from '../problems/loader.js';
+
+export function registerSolveCommand(program) {
+  program
+    .command('solve')
+    .description('Pick a problem and solve it')
+    .action(async () => {
+      const config = getConfig();
+      const apiKey = config.get('geminiApiKey');
+      
+      if (!apiKey) {
+        console.log(theme.error('No Gemini API Key found. Run `irlxleet config` first.'));
+        return;
+      }
+
+      const categories = getCategories();
+      const { category } = await inquirer.prompt([{
+        type: 'list', name: 'category', message: 'Choose a category:', choices: categories
+      }]);
+
+      const problems = getProblemsByCategory(category);
+      const choices = problems.map(p => ({
+        name: `${p.title} [${p.difficulty.toUpperCase()}]`,
+        value: p
+      }));
+
+      const { problem } = await inquirer.prompt([{
+        type: 'list', name: 'problem', message: 'Choose a problem:', choices
+      }]);
+
+      console.log('\n' + boxen(
+        `${theme.fire(problem.title)} [${problem.difficulty}]\n\n${problem.description}\n\nConstraints:\n${problem.constraints.join('\n')}`, 
+        theme.boxStyles.problem
+      ));
+
+      const solutionsDir = join(homedir(), '.irlxleet', 'solutions');
+      if (!existsSync(solutionsDir)) {
+          import('fs').then(fs => fs.mkdirSync(solutionsDir, { recursive: true }));
+      }
+      
+      const filePath = join(solutionsDir, `${problem.id}.js`);
+      
+      if (!existsSync(filePath)) {
+          const templatePath = join(process.cwd(), 'templates', 'solution.js.tmpl');
+          const template = readFileSync(templatePath, 'utf-8');
+          const content = template
+              .replace('{{title}}', problem.title)
+              .replace('{{difficulty}}', problem.difficulty)
+              .replace('{{category}}', problem.category)
+              .replace('{{description}}', problem.description.replace(/\n/g, '\n * '))
+              .replace('{{constraints}}', problem.constraints.map(c => ` * - ${c}`).join('\n'))
+              .replace(/\{\{functionName\}\}/g, problem.functionName)
+              .replace('{{params}}', problem.parameterNames.join(', '));
+          
+          writeFileSync(filePath, content);
+      }
+
+      console.log(theme.info(`\nSolution file ready at: ${filePath}`));
+      console.log(theme.info(`Open it in your editor, write your code, then press Enter here to test it.`));
+      
+      let solved = false;
+      let attempts = 0;
+      const startTime = Date.now();
+      const coach = new DoomCoach(apiKey);
+
+      while (!solved) {
+        await inquirer.prompt([{ type: 'input', name: 'wait', message: 'Press Enter to submit code...' }]);
+        
+        attempts++;
+        const userCode = readFileSync(filePath, 'utf-8');
+        
+        const spinner = ora('Judging your code...').start();
+        const results = await runTests(userCode, 'javascript', problem.testCases, problem.functionName, problem.parameterNames);
+        spinner.stop();
+        
+        renderTestResults(results.results);
+        
+        if (results.passed) {
+           const timeMs = Date.now() - startTime;
+           const score = calculateScore(problem.difficulty, attempts, timeMs, attempts === 1);
+           
+           console.log('\n' + boxen(theme.success(`🎉 ACCEPTED! You earned ${score} points!`), { padding: 1, borderColor: 'green' }));
+           recordSolve(problem.id, userCode, 'javascript', true, results.totalTests, results.totalPassed, attempts, timeMs);
+           resetMistake(problem.id);
+           solved = true;
+        } else {
+           incrementMistake(problem.id);
+           const mistakes = getMistakeCount(problem.id);
+           
+           const coachSpinner = ora('DOOM Coach is analyzing your failure...').start();
+           const help = await coach.getHelp(problem, userCode, results.results, mistakes);
+           coachSpinner.stop();
+           
+           const boxStyle = theme.boxStyles[help.level] || theme.boxStyles.hint;
+           const title = help.level === 'gussa' ? '🔥 DOOM COACH SAYS:' : '💡 DOOM COACH HINT:';
+           
+           console.log('\n' + boxen(`${theme.doom(title)}\n\n${help.message}`, boxStyle));
+        }
+      }
+    });
+}

package/src/commands/stats.js

@@ -0,0 +1,53 @@
+import { theme } from '../ui/theme.js';
+import boxen from 'boxen';
+import { getDb } from '../store/db.js';
+import { getCurrentStreak } from '../core/tracker.js';
+import { getDoomRank } from '../core/scorer.js';
+
+export function registerStatsCommand(program) {
+  program
+    .command('stats')
+    .description('View your DOOM stats and rank')
+    .action(() => {
+      const db = getDb();
+      const solutions = db.solutions || [];
+      const totalSolved = solutions.filter(s => s.passed === 1).length;
+      
+      let totalTime = 0;
+      let totalAttempts = 0;
+      let totalScore = 0;
+      let firstTries = 0;
+      
+      solutions.forEach(s => {
+          totalTime += s.time_ms;
+          totalAttempts += s.attempts;
+          if (s.passed === 1) {
+              let base = 10;
+              totalScore += base;
+              if (s.attempts === 1) firstTries++;
+          }
+      });
+      
+      const streak = getCurrentStreak();
+      const rankInfo = getDoomRank(totalScore);
+      
+      const avgTime = totalSolved > 0 ? (totalTime / totalSolved / 60000).toFixed(1) : 0;
+      const firstTryRate = totalSolved > 0 ? ((firstTries / totalSolved) * 100).toFixed(0) : 0;
+      
+      const statsBox = `
+🔥 Streak:          ${streak} days
+💀 DOOM Rank:       ${rankInfo.badge} ${rankInfo.name}
+📊 Solved:          ${totalSolved} problems
+⚡ Avg Time:        ${avgTime} min
+🎯 1st Try Rate:    ${firstTryRate}%
+      `;
+      
+      console.log('\n' + boxen(statsBox, {
+          title: theme.doom(' 💀 DOOM STATS 💀 '),
+          titleAlignment: 'center',
+          padding: 1,
+          borderStyle: 'double',
+          borderColor: 'red'
+      }));
+    });
+}

package/src/commands/unbreakable.js

@@ -0,0 +1,110 @@
+import inquirer from 'inquirer';
+import ora from 'ora';
+import boxen from 'boxen';
+import { join } from 'path';
+import { homedir } from 'os';
+import { readFileSync, writeFileSync } from 'fs';
+import { theme } from '../ui/theme.js';
+import { getConfig } from './config.js';
+import { CodeBreaker } from '../ai/breaker.js';
+import { runTests } from '../core/judge.js';
+import { renderTestResults } from '../ui/table.js';
+import { getDb } from '../store/db.js';
+import { getProblemById } from '../problems/loader.js';
+
+export function registerUnbreakableCommand(program) {
+  program
+    .command('unbreakable')
+    .description('Enter Unbreakable Mode (AI destroys your code)')
+    .action(async () => {
+        const config = getConfig();
+        const apiKey = config.get('geminiApiKey');
+        
+        if (!apiKey) {
+            console.log(theme.error('No Gemini API Key found. Run `irlxleet config` first.'));
+            return;
+        }
+
+        const db = getDb();
+        const solvedSolutions = (db.solutions || []).filter(s => s.passed === 1);
+        
+        // Get unique solved problem IDs
+        const uniqueSolvedIds = [...new Set(solvedSolutions.map(s => s.problem_id))];
+        
+        if (uniqueSolvedIds.length === 0) {
+            console.log(theme.warning('You need to solve at least one problem first!'));
+            return;
+        }
+
+        const choices = uniqueSolvedIds.map(id => {
+            const p = getProblemById(id);
+            return { name: p.title, value: p };
+        });
+
+        const { problem } = await inquirer.prompt([{
+            type: 'list', name: 'problem', message: 'Choose a solved problem to defend:', choices
+        }]);
+
+        const { level } = await inquirer.prompt([{
+            type: 'list', name: 'level', message: 'Choose your DOOM level:',
+            choices: [
+                { name: '🟢 Level 1: Crack (Edge cases)', value: 1 },
+                { name: '🟡 Level 2: Smash (Performance adversarial)', value: 2 },
+                { name: '🔴 Level 3: DOOM (Code mutation)', value: 3 }
+            ]
+        }]);
+
+        const filePath = join(homedir(), '.irlxleet', 'solutions', `${problem.id}.js`);
+        const userCode = readFileSync(filePath, 'utf-8');
+        const breaker = new CodeBreaker(apiKey);
+
+        console.log('\n' + boxen(theme.doom(` ☠️ UNBREAKABLE MODE — LEVEL ${level} ☠️ `), { padding: 1, borderColor: 'red' }));
+
+        if (level === 1 || level === 2) {
+            const spinner = ora('AI is generating adversarial test cases...').start();
+            const edgeCases = await breaker.generateEdgeCases(problem, userCode, level);
+            spinner.stop();
+            
+            if (edgeCases.length === 0) {
+                console.log(theme.warning('AI failed to find edge cases. You win this round by default!'));
+                return;
+            }
+            
+            console.log(theme.info(`\nAI found ${edgeCases.length} adversarial cases. Running your code...`));
+            
+            const results = await runTests(userCode, 'javascript', { visible: edgeCases, hidden: [] }, problem.functionName, problem.parameterNames);
+            renderTestResults(results.results);
+            
+            if (results.passed) {
+                console.log(theme.success('\n🛡️ UNBREAKABLE! Your code survived.'));
+            } else {
+                console.log(theme.error('\n💥 YOUR CODE BROKE. Fix it and try again.'));
+            }
+        } else {
+            // Level 3 Code Mutation
+            const spinner = ora('AI is mutating your code...').start();
+            const mutatedCode = await breaker.mutateCode(problem, userCode);
+            spinner.stop();
+            
+            const mutatedPath = join(homedir(), '.irlxleet', 'solutions', `${problem.id}.mutated.js`);
+            writeFileSync(mutatedPath, mutatedCode);
+            
+            console.log(theme.error(`\nAI injected 3 bugs into your code.`));
+            console.log(`Mutated code saved to: ${mutatedPath}`);
+            console.log(theme.info('You have 5 minutes to find and fix them.'));
+            
+            // Wait for user to fix
+            await inquirer.prompt([{ type: 'input', name: 'wait', message: 'Press Enter when you have fixed the bugs...' }]);
+            
+            const fixedCode = readFileSync(mutatedPath, 'utf-8');
+            const results = await runTests(fixedCode, 'javascript', problem.testCases, problem.functionName, problem.parameterNames);
+            renderTestResults(results.results);
+            
+            if (results.passed) {
+                console.log(theme.success('\n🏆 YOU BEAT DOOM MODE! Respect.'));
+            } else {
+                console.log(theme.error('\n💀 You failed to fix all bugs. The AI wins.'));
+            }
+        }
+    });
+}

package/src/core/engine.js

@@ -0,0 +1,73 @@
+import { execFile } from 'child_process';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { writeFile, unlink } from 'fs/promises';
+import { randomBytes } from 'crypto';
+
+/**
+ * Executes code in a sandbox (child_process).
+ * @param {string} userCode The user's solution code.
+ * @param {string} language 'javascript' or 'python'
+ * @param {string} functionName The name of the function to call
+ * @param {Array} inputArgs Array of arguments to pass to the function
+ * @param {number} timeoutMs Execution timeout in ms
+ */
+export async function executeCode(userCode, language, functionName, inputArgs, timeoutMs = 10000) {
+  const tempId = randomBytes(16).toString('hex');
+  
+  if (language === 'javascript') {
+    const fileName = join(tmpdir(), `irlxleet_${tempId}.mjs`);
+    
+    // Create a wrapper to parse inputs, call the function, and output JSON
+    const wrapper = `
+      ${userCode.replace(/export default/g, 'const __exported_func =')}
+      
+      const args = ${JSON.stringify(inputArgs)};
+      try {
+        const result = __exported_func(...args);
+        console.log(JSON.stringify({ success: true, result }));
+      } catch (err) {
+        console.log(JSON.stringify({ success: false, error: err.message, stack: err.stack }));
+      }
+    `;
+
+    try {
+      await writeFile(fileName, wrapper);
+      const startTime = Date.now();
+      
+      return new Promise((resolve) => {
+        execFile('node', [fileName], { timeout: timeoutMs }, async (error, stdout, stderr) => {
+          const executionTime = Date.now() - startTime;
+          await unlink(fileName).catch(() => {}); // cleanup
+          
+          let parsedOutput = null;
+          let executionError = null;
+          
+          if (stdout) {
+             try {
+                parsedOutput = JSON.parse(stdout.trim());
+             } catch(e) {
+                // If it fails to parse, it means user code logged something else
+                executionError = 'Failed to parse output. Did you console.log something else? Stdout: ' + stdout;
+             }
+          }
+
+          resolve({
+            stdout,
+            stderr,
+            exitCode: error ? error.code : 0,
+            timedOut: error ? error.killed : false,
+            executionTime,
+            result: parsedOutput?.result,
+            success: parsedOutput?.success ?? false,
+            executionError: parsedOutput?.error || executionError || (error ? error.message : null)
+          });
+        });
+      });
+    } catch (e) {
+      return { success: false, executionError: e.message, executionTime: 0 };
+    }
+  } else {
+    throw new Error(`Language ${language} not supported yet.`);
+  }
+}

package/src/core/judge.js

@@ -0,0 +1,53 @@
+import { executeCode } from './engine.js';
+
+function isEqual(a, b) {
+  // basic deep equality for arrays/objects
+  if (a === b) return true;
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+
+export async function runTests(code, language, testCases, functionName, parameterNames) {
+  const results = [];
+  let totalPassed = 0;
+  let totalTime = 0;
+
+  const allCases = [...testCases.visible, ...(testCases.hidden || [])];
+  const totalTests = allCases.length;
+
+  for (let i = 0; i < allCases.length; i++) {
+    const testCase = allCases[i];
+    const { input, expected } = testCase;
+    
+    const execResult = await executeCode(code, language, functionName, input);
+    
+    let passed = false;
+    let actual = execResult.result;
+    
+    if (execResult.success && !execResult.timedOut && execResult.executionError === null) {
+       passed = isEqual(actual, expected);
+    }
+
+    if (passed) totalPassed++;
+    totalTime += execResult.executionTime;
+
+    results.push({
+      caseNumber: i + 1,
+      input,
+      expected,
+      actual,
+      passed,
+      time: execResult.executionTime,
+      error: execResult.executionError,
+      timedOut: execResult.timedOut,
+      isHidden: i >= testCases.visible.length
+    });
+  }
+
+  return {
+    passed: totalPassed === totalTests,
+    results,
+    totalPassed,
+    totalTests,
+    totalTime
+  };
+}

package/src/core/scorer.js

@@ -0,0 +1,43 @@
+export function calculateScore(difficulty, attempts, timeMs, passedFirstTry) {
+  let base = 10;
+  if (difficulty === 'medium') base = 25;
+  if (difficulty === 'hard') base = 50;
+  
+  let score = base;
+  
+  if (passedFirstTry) score *= 2;
+  
+  const timeMins = timeMs / 60000;
+  let speedBonus = 1;
+  if (difficulty === 'easy' && timeMins <= 5) speedBonus = 1.5;
+  if (difficulty === 'medium' && timeMins <= 15) speedBonus = 1.5;
+  if (difficulty === 'hard' && timeMins <= 30) speedBonus = 1.5;
+  
+  score *= speedBonus;
+  
+  // Penalty for extra attempts (after the 1st)
+  if (attempts > 1) {
+      const penalty = Math.pow(0.8, attempts - 1);
+      score *= penalty;
+  }
+  
+  return Math.round(score);
+}
+
+export function getDoomRank(totalScore) {
+  if (totalScore <= 50) return { name: 'Intern', badge: '🐣', minScore: 0 };
+  if (totalScore <= 150) return { name: 'Bug Writer', badge: '🪲', minScore: 51 };
+  if (totalScore <= 300) return { name: 'Code Monkey', badge: '🐒', minScore: 151 };
+  if (totalScore <= 500) return { name: 'Array Warrior', badge: '⚔️', minScore: 301 };
+  if (totalScore <= 800) return { name: 'Graph Slayer', badge: '🗡️', minScore: 501 };
+  if (totalScore <= 1200) return { name: 'DP Demon', badge: '👹', minScore: 801 };
+  if (totalScore <= 1800) return { name: 'FAANG Ready', badge: '🏢', minScore: 1201 };
+  return { name: 'UNBREAKABLE', badge: '💀🔥', minScore: 1801 };
+}
+
+export function getUnbreakableScore(level, edgeCasesSurvived, totalEdgeCases, timeMs) {
+  const percentage = edgeCasesSurvived / totalEdgeCases;
+  const levelMult = level === 1 ? 1 : level === 2 ? 2.5 : 5;
+  const base = 50 * levelMult * percentage;
+  return Math.round(base);
+}

package/src/core/tracker.js

@@ -0,0 +1,42 @@
+import { getDb, saveSolution } from '../store/db.js';
+import { writeFileSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+
+export function recordSolve(problemId, code, lang, passed, totalTests, passedTests, attempts, timeMs) {
+  saveSolution(problemId, code, lang, passed, totalTests, passedTests, attempts, timeMs);
+  
+  if (passed) {
+    const dbPath = join(homedir(), '.irlxleet', 'db.json');
+    const db = getDb();
+    const today = new Date().toISOString().split('T')[0];
+    
+    if (!db.streaks[today]) {
+        db.streaks[today] = { problems_solved: 0, total_time_ms: 0 };
+    }
+    db.streaks[today].problems_solved += 1;
+    db.streaks[today].total_time_ms += timeMs;
+    
+    writeFileSync(dbPath, JSON.stringify(db, null, 2));
+  }
+}
+
+export function getCurrentStreak() {
+  const db = getDb();
+  const dates = Object.keys(db.streaks).sort().reverse();
+  if (dates.length === 0) return 0;
+  
+  let streak = 0;
+  let current = new Date();
+  
+  for (const dStr of dates) {
+    const d = new Date(dStr);
+    if (d.toDateString() === current.toDateString() || streak > 0) {
+      streak++;
+      current.setDate(current.getDate() - 1);
+    } else {
+      break;
+    }
+  }
+  return streak;
+}

package/src/problems/categories/arrays.json

@@ -0,0 +1,29 @@
+[
+  {
+    "id": "two-sum",
+    "title": "Two Sum",
+    "category": "arrays",
+    "difficulty": "easy",
+    "companies": ["Google", "Amazon", "Meta"],
+    "description": "Given an array of integers `nums` and an integer `target`, return indices of the two numbers such that they add up to `target`.\n\nYou may assume that each input would have exactly one solution, and you may not use the same element twice.",
+    "examples": [
+      { "input": "nums = [2,7,11,15], target = 9", "output": "[0,1]", "explanation": "Because nums[0] + nums[1] == 9" }
+    ],
+    "constraints": ["2 <= nums.length <= 10^4", "-10^9 <= nums[i] <= 10^9"],
+    "testCases": {
+      "visible": [
+        { "input": [[2,7,11,15], 9], "expected": [0,1] },
+        { "input": [[3,2,4], 6], "expected": [1,2] }
+      ],
+      "hidden": [
+        { "input": [[3,3], 6], "expected": [0,1] },
+        { "input": [[-1,-2,-3,-4,-5], -8], "expected": [2,4] }
+      ]
+    },
+    "functionName": "twoSum",
+    "parameterNames": ["nums", "target"],
+    "hints": ["Think about what complement means for each number", "Can you use a hash map to find complements in O(1)?"],
+    "optimalComplexity": { "time": "O(n)", "space": "O(n)" },
+    "tags": ["hash-map", "array"]
+  }
+]

package/src/problems/loader.js

@@ -0,0 +1,60 @@
+import { readFileSync, readdirSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const categoriesDir = join(__dirname, 'categories');
+
+let problemsCache = null;
+
+function loadProblems() {
+  if (problemsCache) return problemsCache;
+  
+  problemsCache = [];
+  try {
+    const files = readdirSync(categoriesDir).filter(f => f.endsWith('.json'));
+    for (const file of files) {
+      const content = readFileSync(join(categoriesDir, file), 'utf-8');
+      const problems = JSON.parse(content);
+      problemsCache.push(...problems);
+    }
+  } catch (error) {
+    console.error('Error loading problems:', error.message);
+  }
+  return problemsCache;
+}
+
+export function getAllProblems() {
+  return loadProblems();
+}
+
+export function getProblemsByCategory(category) {
+  return loadProblems().filter(p => p.category === category);
+}
+
+export function getProblemsByDifficulty(difficulty) {
+  return loadProblems().filter(p => p.difficulty === difficulty);
+}
+
+export function getProblemById(id) {
+  return loadProblems().find(p => p.id === id);
+}
+
+export function getRandomProblem(filters = {}) {
+  let list = loadProblems();
+  if (filters.category) list = list.filter(p => p.category === filters.category);
+  if (filters.difficulty) list = list.filter(p => p.difficulty === filters.difficulty);
+  if (filters.excludeSolved) {
+    // Assuming filters.excludeSolved is an array of solved IDs
+    list = list.filter(p => !filters.excludeSolved.includes(p.id));
+  }
+  if (list.length === 0) return null;
+  return list[Math.floor(Math.random() * list.length)];
+}
+
+export function getCategories() {
+  const problems = loadProblems();
+  const cats = new Set(problems.map(p => p.category));
+  return Array.from(cats);
+}

package/src/store/db.js

@@ -0,0 +1,58 @@
+import { join } from 'path';
+import { homedir } from 'os';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+
+const dir = join(homedir(), '.irlxleet');
+const dbPath = join(dir, 'db.json');
+
+function readDb() {
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  if (!existsSync(dbPath)) {
+    return { solutions: [], streaks: {}, mistakes: {} };
+  }
+  return JSON.parse(readFileSync(dbPath, 'utf-8'));
+}
+
+function writeDb(data) {
+  writeFileSync(dbPath, JSON.stringify(data, null, 2));
+}
+
+export function getDb() {
+  return readDb(); // Return current state
+}
+
+export function saveSolution(problemId, code, language, passed, totalTests, passedTests, attempts, timeMs) {
+  const db = readDb();
+  db.solutions.push({
+    problem_id: problemId,
+    code,
+    language,
+    passed: passed ? 1 : 0,
+    total_tests: totalTests,
+    passed_tests: passedTests,
+    attempts,
+    time_ms: timeMs,
+    created_at: new Date().toISOString()
+  });
+  writeDb(db);
+}
+
+export function getSolutionHistory(problemId) {
+  return readDb().solutions.filter(s => s.problem_id === problemId).reverse();
+}
+
+export function getMistakeCount(problemId) {
+  return readDb().mistakes[problemId] || 0;
+}
+
+export function incrementMistake(problemId) {
+  const db = readDb();
+  db.mistakes[problemId] = (db.mistakes[problemId] || 0) + 1;
+  writeDb(db);
+}
+
+export function resetMistake(problemId) {
+  const db = readDb();
+  db.mistakes[problemId] = 0;
+  writeDb(db);
+}

package/src/store/migrations.js

@@ -0,0 +1,36 @@
+export function runMigrations(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS solutions (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      problem_id TEXT NOT NULL,
+      code TEXT,
+      language TEXT,
+      passed INTEGER,
+      total_tests INTEGER,
+      passed_tests INTEGER,
+      attempts INTEGER,
+      time_ms INTEGER,
+      created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    );
+
+    CREATE TABLE IF NOT EXISTS streaks (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      date TEXT UNIQUE NOT NULL,
+      problems_solved INTEGER DEFAULT 0,
+      total_time_ms INTEGER DEFAULT 0
+    );
+
+    CREATE TABLE IF NOT EXISTS stats (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      key TEXT UNIQUE NOT NULL,
+      value TEXT
+    );
+
+    CREATE TABLE IF NOT EXISTS mistake_tracker (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      problem_id TEXT UNIQUE NOT NULL,
+      mistake_count INTEGER DEFAULT 0,
+      last_mistake_at DATETIME DEFAULT CURRENT_TIMESTAMP
+    );
+  `);
+}

package/src/ui/banner.js

@@ -0,0 +1,17 @@
+import figlet from 'figlet';
+import gradient from 'gradient-string';
+
+const taglines = [
+  "Code. Break. Become Unbreakable.",
+  "Your streak is the only thing keeping DOOM Coach away.",
+  "FAANG ready? We'll see about that.",
+  "Eat, Sleep, LeetCode, Repeat.",
+  "Runtime Error is just DOOM Coach laughing at you."
+];
+
+export function showBanner() {
+  const text = figlet.textSync('irlxleet', { font: 'Slant' });
+  console.log(gradient.pastel.multiline(text));
+  const randomTagline = taglines[Math.floor(Math.random() * taglines.length)];
+  console.log(`\n  💀🔥 ${randomTagline} (v1.0.0)\n`);
+}

package/src/ui/progress.js

@@ -0,0 +1,79 @@
+import chalk from 'chalk';
+import ora from 'ora';
+
+/**
+ * Creates a visual progress bar string
+ * @param {number} current
+ * @param {number} total
+ * @param {number} [width=20]
+ * @returns {string}
+ */
+export function createProgressBar(current, total, width = 20) {
+  const pct = total === 0 ? 0 : Math.round((current / total) * 100);
+  const filled = Math.round((pct / 100) * width);
+  const empty = width - filled;
+  const bar = '█'.repeat(filled) + '░'.repeat(empty);
+
+  const colorFn = pct > 70 ? chalk.green : pct > 40 ? chalk.yellow : chalk.red;
+  return `${colorFn(bar)} ${pct}%`;
+}
+
+/**
+ * Creates an ora spinner (not started)
+ * @param {string} text
+ * @returns {import('ora').Ora}
+ */
+export function createSpinner(text) {
+  return ora({
+    text,
+    spinner: 'dots',
+  });
+}
+
+/**
+ * Animated countdown timer for timed challenges
+ * @param {number} seconds - total seconds to count down
+ * @returns {Promise<void>} resolves when countdown reaches 0
+ */
+export function showCountdown(seconds) {
+  return new Promise((resolve) => {
+    let remaining = seconds;
+
+    const formatTime = (secs) => {
+      const m = Math.floor(secs / 60).toString().padStart(2, '0');
+      const s = (secs % 60).toString().padStart(2, '0');
+      return `${m}:${s}`;
+    };
+
+    const render = () => {
+      const timeStr = formatTime(remaining);
+      let colorFn;
+
+      if (remaining <= 10) {
+        colorFn = chalk.bold.red;
+      } else if (remaining <= 30) {
+        colorFn = chalk.bold.yellow;
+      } else {
+        colorFn = chalk.bold.cyan;
+      }
+
+      process.stdout.clearLine?.(0);
+      process.stdout.cursorTo?.(0);
+      process.stdout.write(colorFn(`  ⏱️  ${timeStr} remaining`));
+    };
+
+    render();
+
+    const interval = setInterval(() => {
+      remaining--;
+      render();
+
+      if (remaining <= 0) {
+        clearInterval(interval);
+        process.stdout.write('\n');
+        console.log(chalk.bold.red('  💀 TIME\'S UP!'));
+        resolve();
+      }
+    }, 1000);
+  });
+}

package/src/ui/table.js

@@ -0,0 +1,26 @@
+import Table from 'cli-table3';
+import { theme } from './theme.js';
+
+export function renderTestResults(results) {
+  const table = new Table({
+    head: ['Case', 'Input', 'Expected', 'Actual', 'Status', 'Time'],
+    style: { head: ['cyan'] }
+  });
+
+  results.forEach(res => {
+    let statusStr = res.passed ? theme.success('✅ PASS') : theme.error('❌ FAIL');
+    if (res.timedOut) statusStr = theme.warning('⏱️ TLE');
+    if (res.error) statusStr = theme.error('💥 ERR');
+    
+    table.push([
+      res.caseNumber + (res.isHidden ? ' (hidden)' : ''),
+      JSON.stringify(res.input).substring(0, 30),
+      JSON.stringify(res.expected).substring(0, 30),
+      res.error ? 'Error' : JSON.stringify(res.actual).substring(0, 30),
+      statusStr,
+      `${res.time}ms`
+    ]);
+  });
+
+  console.log(table.toString());
+}

package/src/ui/theme.js

@@ -0,0 +1,24 @@
+import chalk from 'chalk';
+
+export const theme = {
+  doom: chalk.bold.red,
+  fire: chalk.bold.hex('#FF6B35'),
+  success: chalk.bold.green,
+  error: chalk.bold.red,
+  warning: chalk.bold.yellow,
+  info: chalk.bold.cyan,
+  muted: chalk.dim,
+  highlight: chalk.bold.magenta,
+  streak: chalk.bold.yellow,
+  rank: (name) => {
+    if (name === 'UNBREAKABLE') return chalk.bold.bgRed.white(` ${name} `);
+    return chalk.bold.cyan(name);
+  },
+  boxStyles: {
+    banner: { padding: 1, margin: 1, borderStyle: 'double', borderColor: 'red' },
+    hint: { padding: 1, margin: 1, borderStyle: 'round', borderColor: 'cyan' },
+    explain: { padding: 1, margin: 1, borderStyle: 'classic', borderColor: 'yellow' },
+    gussa: { padding: 1, margin: 1, borderStyle: 'bold', borderColor: 'red' },
+    problem: { padding: 1, margin: 1, borderStyle: 'round', borderColor: '#FF6B35' }
+  }
+};

package/templates/solution.js.tmpl

@@ -0,0 +1,17 @@
+/**
+ * Problem: {{title}}
+ * Difficulty: {{difficulty}}
+ * Category: {{category}}
+ * 
+ * {{description}}
+ *
+ * Constraints:
+ * {{constraints}}
+ */
+
+function {{functionName}}({{params}}) {
+  // Your code here
+  
+}
+
+export default {{functionName}};

package/templates/solution.py.tmpl

@@ -0,0 +1,15 @@
+"""
+Problem: {{title}}
+Difficulty: {{difficulty}}
+Category: {{category}}
+
+{{description}}
+
+Constraints:
+{{constraints}}
+"""
+
+
+def {{functionName}}({{params}}):
+    # Your code here
+    pass